The Grant bar becomes one split control: Select, or Grant N with a menu for Deny, Grant all green, the picked list, Clear and Direct mode; picked items turn pale green. The radio drops its filter flyout and gains three-state bells per row, a test per row including Speak, Auto or Morse on a second click, mute on the sender avatar and the agent profile, Cancel MAYDAY beside Send only while one is active, a Send menu with a test message and hold-to-record push-to-talk. Decision rows read as questions with their options; the signed answer is Decision <id> plus Answer: <answer>, and the card names its recipient. Security: the passkey-signed answer carries no agent-written text, the inbox lists answerable rows only when their id fullmatches the TASK rule of the installed rasci.py (skill_scripts.task_pattern), and rasci.py, operator.py and hotfix.py check task slugs with fullmatch, so a trailing newline no longer passes. Accepted MEDUSA findings after kvb-think-criticize: page-inbox.js:116 EXA006 (by design after the fix), page-inbox.js:125 EXA010, operator.py:173, 618 and 633 RP001, FT-TRIGGER-005 and RLHF-POISON-002, operator.py:639 MEX-SCAN-346, operator.py:968 MM-SCAN-058, operator.py:974 ACP-SCAN-028 (false positives). 🎯 Fix: 85 % 💥 Break: 10 % 💸 Tokens: – ⏱️ Velocity: – 🛡️ Security: 100 % 🏆 Score: 77 🚦 Gate: ⛔ fix 85 % < 90, break 10 % > 5 Created-with: https://s.veen.world/skills Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
153 lines
7.0 KiB
Python
153 lines
7.0 KiB
Python
from __future__ import annotations
|
|
|
|
import time
|
|
|
|
from .choosing import EVERYONE, answer_text
|
|
from .diffs import sealed_file, store_diff, store_sealed, valid_diff, valid_sealed
|
|
from .errors import Conflict, Missing, ToolError
|
|
from .fields import (
|
|
COMMAND_LIMIT,
|
|
DESCRIPTION_LIMIT,
|
|
OPTION_LIMIT,
|
|
PATH_LIMIT,
|
|
WAIT_CAP,
|
|
bounded,
|
|
decode,
|
|
expect,
|
|
field,
|
|
instant,
|
|
message_text,
|
|
seconds,
|
|
visible,
|
|
)
|
|
from .signed import ask_signed
|
|
|
|
ASK_LIFETIME = 3600
|
|
PREVIEW_LIMIT = 4000
|
|
ASK_TEXTS = {"command": COMMAND_LIMIT, "cwd": PATH_LIMIT, "session": 200, "agent": 200}
|
|
ANSWERS = {"allow": "allowed", "deny": "denied"}
|
|
|
|
|
|
def ask_state(ask: dict, now: float) -> dict:
|
|
status = "expired" if ask["status"] == "pending" and ask["expires"] <= now else ask["status"]
|
|
return {"id": ask["id"], "status": status, "decided": ask["decided"], "proof": ask.get("proof"), "channel": ask.get("channel", ""), "reason": ask.get("reason", ""), "to": ask.get("to", "")}
|
|
|
|
|
|
def ask_row(ask: dict, names: dict[str, str]) -> dict:
|
|
keys = ("id", "tool", "command", "cwd", "session", "created_ts", "expires")
|
|
return {**{key: ask[key] for key in keys}, "agent": names.get(ask["session"], ""), "subagent": ask["agent"]}
|
|
|
|
|
|
def decision_state(decision: dict) -> dict:
|
|
"""Returns:
|
|
The status and choice, with the id and text of the operator's
|
|
passkey-signed answer when a click chose it, else None for both.
|
|
"""
|
|
message = decision.get("message")
|
|
answer = None if message is None else answer_text(decision, decision["choice"])
|
|
return {**{key: decision[key] for key in ("id", "status", "choice", "decided")}, "message": message, "answer": answer}
|
|
|
|
|
|
def decision_row(decision: dict) -> dict:
|
|
return {key: decision[key] for key in ("id", "question", "options", "agent", "created_ts")}
|
|
|
|
|
|
def option_of(option: object) -> dict:
|
|
"""Args:
|
|
option: {"label", "description"} and an optional "preview", a
|
|
multi-line mockup, snippet or table shown beside the options.
|
|
|
|
Returns:
|
|
The option with its texts stripped; "preview" only when it was given
|
|
and is not empty.
|
|
"""
|
|
if not isinstance(option, dict):
|
|
raise ToolError("every option must be an object with label and description")
|
|
expect(option, ("label", "description", *(("preview",) if "preview" in option else ())))
|
|
label = field(option, "label").strip()
|
|
description = bounded(option, "description", DESCRIPTION_LIMIT).strip()
|
|
preview = bounded(option, "preview", PREVIEW_LIMIT).rstrip() if "preview" in option else ""
|
|
visible({"description": description, "preview": preview})
|
|
return {"label": label, "description": description, **({"preview": preview} if preview.strip() else {})}
|
|
|
|
|
|
class Asking:
|
|
def ask(self, body: bytes) -> dict:
|
|
payload = decode(body)
|
|
diff = valid_diff(payload.pop("diff")) if "diff" in payload else None
|
|
sealed = valid_sealed(payload.pop("sealed"), diff) if "sealed" in payload else {}
|
|
expect(payload, ("tool", *ASK_TEXTS, "timeout"))
|
|
values = {name: bounded(payload, name, limit) for name, limit in ASK_TEXTS.items()}
|
|
visible(values)
|
|
lifetime = seconds(payload, "timeout", ASK_LIFETIME)
|
|
created = time.time()
|
|
fields = {**values, "tool": field(payload, "tool").strip(), "status": "pending", "decided": None, "proof": None, "diff_files": None if diff is None else len(diff)}
|
|
with self.asks.changed:
|
|
ask_id = self.asks.fresh()
|
|
if diff is not None:
|
|
store_diff(self.reviews.pages, "ask", ask_id, diff)
|
|
if sealed:
|
|
store_sealed(self.reviews.pages, "ask", ask_id, sealed)
|
|
record = self.asks.insert(ask_id, {**fields, "created_ts": created, "expires": created + lifetime})
|
|
self.automate("ask", record)
|
|
return {"id": record["id"], "status": record["status"]}
|
|
|
|
def ask_wait(self, ask_id: str, query: dict[str, list[str]]) -> dict:
|
|
wait = instant(query, "wait")
|
|
record = self.asks.get(ask_id)
|
|
if record is None:
|
|
raise Missing(ask_id)
|
|
left = max(record["expires"] - time.time(), 0.0)
|
|
record = self.asks.wait(ask_id, min(wait or 0.0, WAIT_CAP, left))
|
|
state = ask_state(record, time.time())
|
|
if state["status"] == "expired":
|
|
sealed_file(self.reviews.pages, "ask", ask_id).unlink(missing_ok=True)
|
|
return state
|
|
|
|
def settle(self, kind_name: str, item_id: str, verb: str, body: bytes) -> dict:
|
|
if kind_name == "asks" and verb in ANSWERS:
|
|
record = self.asks.get(item_id)
|
|
if record is None:
|
|
raise Missing(item_id)
|
|
if ask_state(record, time.time())["status"] == "expired":
|
|
raise Conflict(ask_state(record, time.time()))
|
|
proof = None
|
|
if verb == "allow":
|
|
payload = decode(body)
|
|
expect(payload, ("proof",))
|
|
proof = self.covered(payload["proof"], [ask_signed(record)], time.time())
|
|
decided, changed = self.asks.decide(item_id, {"status": ANSWERS[verb], "proof": proof})
|
|
if not changed:
|
|
raise Conflict(ask_state(decided, time.time()))
|
|
return ask_state(decided, time.time())
|
|
raise Missing(verb)
|
|
|
|
def decision_request(self, arguments: dict) -> dict:
|
|
expect(arguments, ("question", "options", "agent", "recommended"))
|
|
question = message_text(arguments, "question")
|
|
visible({"question": question})
|
|
options = arguments["options"]
|
|
if not isinstance(options, list) or not 1 <= len(options) <= OPTION_LIMIT:
|
|
raise ToolError(f"options must be a list of 1 to {OPTION_LIMIT} objects")
|
|
parsed = [option_of(option) for option in options]
|
|
if len({option["label"] for option in parsed}) != len(parsed):
|
|
raise ToolError("option labels must be distinct")
|
|
recommended = arguments["recommended"]
|
|
if not isinstance(recommended, str) or recommended.strip() not in ["", *(option["label"] for option in parsed)]:
|
|
raise ToolError("recommended must be one of the option labels or an empty string")
|
|
asker = field(arguments, "agent").strip()
|
|
if EVERYONE in asker:
|
|
raise ToolError(f"agent names the asking agent, never a name with {EVERYONE}")
|
|
fields = {"question": question, "options": parsed, "agent": asker, "recommended": recommended.strip()}
|
|
record = self.decisions.add({**fields, "status": "pending", "choice": None, "decided": None, "created_ts": time.time()})
|
|
self.automate("decision", record)
|
|
return {"id": record["id"], "status": record["status"], "url": self.url()}
|
|
|
|
def decision_wait(self, arguments: dict) -> dict:
|
|
expect(arguments, ("id", "timeout_seconds"))
|
|
decision_id = field(arguments, "id")
|
|
record = self.decisions.wait(decision_id, seconds(arguments, "timeout_seconds", WAIT_CAP))
|
|
if record is None:
|
|
raise ToolError(f"no decision {decision_id}")
|
|
return decision_state(record)
|