Match now builds asks, choices, decision rows and rule requests from the inbox items, beside commits and commands, so its card count follows the Tasks badge. A decision card shows its options with the recommended one marked; a pick is released with the same single passkey, and the hub posts the answer of a decision row to the row's agent itself and keeps the row off the stack until its question changes. A choice cannot be rejected; a rule card's accept opens its row, its reject carries the feedback. Every card shows the scores its text carries as labels, value included; outside a commit's score line only an emoji-led score counts. Answered decision rows leave the badge and show as answered in the inbox. Requirement 012 records the operator's amendment of 2026-11-19 and decision 11. 🎯 Fix: 92 % 💥 Break: 4 % 💸 Tokens: – ⏱️ Velocity: – 🛡️ Security: 100 % 🏆 Score: 88 🚦 Gate: ✅ 90/5, tokens and velocity <= 100, security 100 % Created-with: https://s.veen.world/skills Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
147 lines
6.7 KiB
Python
147 lines
6.7 KiB
Python
from __future__ import annotations
|
|
|
|
from .council import agent
|
|
from .errors import ToolError
|
|
from .fields import decode, expect, field
|
|
from .messaging import DIRECT, EVERYONE, TO_ALL
|
|
from .records import digest
|
|
from .register import REGISTER, adder, operator_rows, read_register
|
|
from .signed import signing
|
|
|
|
CHOICE_REQUEST = "send me your open decisions as choices"
|
|
CHANNELS = {**DIRECT, **TO_ALL}
|
|
CHOICE_KEYS = ("class", "to")
|
|
RECIPIENT_LIMIT = 40
|
|
ANSWER_CLASS = "post"
|
|
QUESTION_SHOWN = 200
|
|
|
|
|
|
def answer_text(decision: dict, label: str) -> str:
|
|
question = " ".join(decision["question"].split())[:QUESTION_SHOWN]
|
|
return f"Choice for decision {decision['id']} ({question}): {label}"
|
|
|
|
|
|
def answer_signed(decision: dict, label: str) -> dict:
|
|
"""Returns:
|
|
The post to the asking agent that a click on the option label
|
|
signs: the operator's answer operator_message proves.
|
|
"""
|
|
if EVERYONE in decision["agent"]:
|
|
raise ToolError(f"a choice answer goes to the asking agent, never to a name with {EVERYONE}")
|
|
return signing.message_item(agent(decision["agent"]), ANSWER_CLASS, answer_text(decision, label), "", "", "")
|
|
|
|
|
|
def row_answer_signed(row: dict, to: str, label: str) -> dict:
|
|
"""Args:
|
|
row: an open decision row of the register.
|
|
to: the row's adding agent.
|
|
label: one of the row's option labels.
|
|
|
|
Returns:
|
|
The post to that agent that a Match pick signs, in the words the
|
|
inbox's own answer sends.
|
|
"""
|
|
if not to or EVERYONE in to:
|
|
raise ToolError(f"a decision row is answered only when an agent other than {EVERYONE} holds role A on it")
|
|
return signing.message_item(agent(to), ANSWER_CLASS, f"Decision {row['task']}\nAnswer: {label}", "", "", "")
|
|
|
|
|
|
def answered(record: dict | None, row: dict) -> bool:
|
|
return record is not None and record["sha256"] == digest(row["command"])
|
|
|
|
|
|
def recipients(payload: dict) -> list[str]:
|
|
"""Args:
|
|
payload: the page's class and to: 1 to RECIPIENT_LIMIT distinct
|
|
agent names for post and call, [EVERYONE] for a class to all.
|
|
"""
|
|
cls, names = payload["class"], payload["to"]
|
|
if not isinstance(cls, str) or cls not in CHANNELS:
|
|
raise ToolError(f"class must be one of {', '.join(CHANNELS)}")
|
|
if not isinstance(names, list) or not all(isinstance(name, str) for name in names):
|
|
raise ToolError("to must be a list of agent names")
|
|
if cls in TO_ALL:
|
|
if names != [EVERYONE]:
|
|
raise ToolError(f"a choice request to all names to [{EVERYONE}]")
|
|
return names
|
|
targets = [field({"to": name}, "to").strip() for name in names]
|
|
if not 1 <= len(targets) <= RECIPIENT_LIMIT or any(EVERYONE in target for target in targets):
|
|
raise ToolError(f"a post or a call names 1 to {RECIPIENT_LIMIT} agents, never a name with {EVERYONE}")
|
|
if len({agent(target) for target in targets}) != len(targets):
|
|
raise ToolError("to must name distinct agents")
|
|
return targets
|
|
|
|
|
|
class Choosing:
|
|
def choice_items(self, payload: dict) -> list[dict]:
|
|
return [signing.message_item(target, payload["class"], CHOICE_REQUEST, "", "", "") for target in recipients(payload)]
|
|
|
|
def sign_choices(self, body: bytes) -> dict:
|
|
payload = decode(body)
|
|
expect(payload, CHOICE_KEYS)
|
|
return self.challenge_for(self.choice_items(payload))
|
|
|
|
def request_choices(self, body: bytes) -> dict:
|
|
"""Returns:
|
|
The ids of the stored requests, one per recipient, once one
|
|
passkey assertion signed each of them; nothing is stored or sent
|
|
before every item verified.
|
|
"""
|
|
payload = decode(body)
|
|
expect(payload, (*CHOICE_KEYS, "proof"))
|
|
items = self.choice_items(payload)
|
|
for item in items:
|
|
self.operator_proven(payload["proof"], item)
|
|
records = [self.stored_message(item, payload["proof"], None) for item in items]
|
|
runs = [self.radioed(record, CHANNELS[payload["class"]]) for record in records]
|
|
return {"ids": [record["id"] for record in records], "ok": all(run["code"] == 0 for run in runs), "runs": runs}
|
|
|
|
def answer_choice(self, item: dict, proof: dict) -> str:
|
|
"""Args:
|
|
item: a checked decision item whose signed is answer_signed().
|
|
proof: the relayed signature; the hub sends the answer itself,
|
|
so it verifies the signature here, once.
|
|
|
|
Returns:
|
|
The outcome words for the stream.
|
|
"""
|
|
record = self.decisions.get(item["id"])
|
|
if record is None:
|
|
return "unknown"
|
|
if record["status"] != "pending":
|
|
return f"already {record['status']}"
|
|
self.operator_proven(proof, item["signed"])
|
|
message = self.stored_message(item["signed"], proof, None)
|
|
decided, changed = self.decisions.decide(item["id"], {"status": "decided", "choice": item["label"], "message": message["id"]})
|
|
if not changed:
|
|
self.messages.remove(message["id"])
|
|
return f"already {decided['status']}"
|
|
run = self.radioed(message, CHANNELS[ANSWER_CLASS])
|
|
where = f"{ANSWER_CLASS} to {message['address']}"
|
|
return f"decided · {where}" if run["code"] == 0 else f"decided · {where} failed ({run['code']})"
|
|
|
|
def answer_row(self, item: dict, proof: dict) -> str:
|
|
"""Args:
|
|
item: a checked operator item of a decision row whose label is
|
|
the picked option and whose signed is row_answer_signed().
|
|
proof: the relayed signature, verified here once, as the hub
|
|
sends the answer itself.
|
|
|
|
Returns:
|
|
The outcome words for the stream; the row stays open until its
|
|
agent closes it, while answers keeps it off the Match stack.
|
|
"""
|
|
tasks = read_register(self.council / REGISTER)
|
|
row = next((row for row in operator_rows(tasks) if row["task"] == item["id"]), None)
|
|
if row is None or item["label"] not in [option["label"] for option in row["options"]] or row_answer_signed(row, adder(tasks[item["id"]]), item["label"]) != item["signed"]:
|
|
return "refused: the row changed since the release"
|
|
self.operator_proven(proof, item["signed"])
|
|
with self.answers.changed:
|
|
if answered(self.answers.get(item["id"]), row):
|
|
return "already answered"
|
|
message = self.stored_message(item["signed"], proof, None)
|
|
self.answers.insert(item["id"], {"sha256": digest(row["command"]), "label": item["label"], "message": message["id"]})
|
|
run = self.radioed(message, CHANNELS[ANSWER_CLASS])
|
|
where = f"{ANSWER_CLASS} to {message['address']}"
|
|
return f"answered · {where}" if run["code"] == 0 else f"answered · {where} failed ({run['code']})"
|