feat(orchestrator): release Match decisions with one passkey, bound to what each card showed

Phase C of 012: the Match overview lists every decided card with flip,
edit and back, and one passkey signature releases them all through the
inbox. An approved operator command is bound to the payload hash its card
showed (match_item in the signed set): the hub refuses a stale snapshot or
a changed payload file at release and again before it queues the job. A
rejected commit review carries its feedback as a radio call to the card's
agent, which the hub verifies and records as the review's rejection. Reject
feedback shows line by line, an empty one as such; the arrow keys are in
the help; 012 counts every waiting inbox entry in the Tasks badge.

Accepted MEDUSA false positives (kvb-think-criticize 2026-11-17):
MEDUSA-MM-SCAN-058 signing.py:335 and :337 (pla of plan), EXA010
page-match.js:409 (passkey in a title), EXA006 matching.py:49 (agent then
requester_of), STG002 page-constants.js:79 (U+2212 minus as a label).

🎯 Fix: 92 %
💥 Break: 4 %
💸 Tokens: 100 %
⏱️ Velocity: 100 %
🛡️ Security: 100 % (style-match.css not covered by MEDUSA, reviewed by hand)
🏆 Score: 88
🚦 Gate: ✅ 90/5, tokens and velocity <= 100, security 100 %

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Kevin Veen-BirkenbachandClaude Opus 5.5 committed 2026-11-17 10:00:02 +00:00
1 parent e9cd1aeda5
commit 5e00a79fdc
11 files changed
+673 -28

No files matched your search

+143 -2
View File
@@ -2,18 +2,23 @@ from __future__ import annotations
import json
import os
import secrets
import subprocess
import sys
import tempfile
import time
import unittest
from pathlib import Path
from unittest import mock
from hub_case import HubCase
from hub_support import GIT_ENV, HUB, REPO_ROOT
from kvb_orchestrator import payloads
from hub_support import APPROVAL, GIT_ENV, HUB, REPO_ROOT, key, signing
from kvb_orchestrator import batches, payloads, skill_scripts
MATCH = REPO_ROOT / "skills" / "kvb-match" / "scripts" / "match.py"
CLIENT = HUB / "client"
FEEDBACK = "app.py:2: name it after what it holds\nnotes.md:3: say why"
TOLD = "app.py:2: name it after what it holds notes.md:3: say why"
def git(cwd: Path, *args: str) -> str:
@@ -131,6 +136,142 @@ class TestMatchSkill(MatchCase):
self.assertEqual(self.cards(), [])
class TestMatchRelease(MatchCase):
def radio(self) -> list[list[str]]:
return [args for script, args in self.scripts.calls if script == skill_scripts.RADIO]
def stack(self) -> tuple[Path, str]:
self.claim("s1", "Skills session")
repo = staged_repo(self.work)
review = self.add(repo)
self.operator_row("operator/ship", "make ship", str(self.work))
return repo, review
def decisions(self, review: str, verdict: str) -> list[dict]:
"""Args:
review: the review id of the commit card.
verdict: accept or reject for the commit card; the command card
is always rejected with FEEDBACK.
Returns:
The entries the Match page releases, built as matchEntry builds
them from the cards.
"""
commit, command = self.card(f"review:{review}"), self.card("operator:operator/ship")
rejected = {"verb": "reject", "channel": "call", "reason": FEEDBACK}
first = {"kind": "review", "id": commit["ref"], "verb": "approve", "label": "", "sha256": ""}
second = {"kind": "operator", "id": command["ref"], "label": "", "sha256": command["sha256"], **rejected, "to": command["to"]}
return [first if verdict == "accept" else {**first, **rejected, "to": commit["to"]}, second]
def verify(self, repo: Path, review: str) -> subprocess.CompletedProcess:
argv = ["verify", "--port", str(self.port), "--approvers", str(self.approvers), "--replay", str(self.replay / "commit.json"), "--review", review, "--gate", "pass"]
return subprocess.run([sys.executable, str(APPROVAL), *argv], cwd=repo, env={**os.environ, **GIT_ENV}, capture_output=True, text=True, timeout=60, check=False)
def test_every_card_names_the_addressee_its_inbox_entry_shows(self):
_, review = self.stack()
shown = {item["id"]: item["to"] for item in self.snapshot()["inbox"]}
self.assertEqual({card["ref"]: card["to"] for card in self.cards()}, {review: "Skills", "operator/ship": "Skills"})
self.assertEqual((shown[review], shown["operator/ship"]), ("Skills", "Skills"))
def test_one_signature_releases_an_accepted_commit_the_commit_check_verifies_and_a_rejection_told_by_call(self):
repo, review = self.stack()
entries = self.decisions(review, "accept")
signer = self.pin()
proof = self.signed(entries, signer)
status, _, body = self.approve([entries[0], {**entries[1], "reason": "push it anyway"}], proof)
self.assertEqual(status, 400, body)
self.assertIn("list every approved item", body.decode())
status, _, body = self.approve(entries, key(-8, "stranger").proof(proof["payload"], self.origin))
self.assertEqual(status, 400, body)
self.assertIn("not signed", body.decode())
with mock.patch.object(batches, "UNDO", 0.4):
status, _, body = self.approve(entries, proof)
self.assertEqual(status, 202, body)
self.assertEqual(self.call("POST", f"/api/inbox/undo/{json.loads(body)['id']}", b"", self.guard(self.host))[0], 200)
self.assertIn("already used", self.approve(entries, proof)[2].decode())
self.assertEqual(self.approve(entries, self.signed(entries, signer))[0], 202)
self.settle(lambda: self.status(review) == "approved")
self.settle(lambda: (skill_scripts.RASCI, ["set", "operator/ship", "--status", "stopped"]) in self.scripts.calls)
self.settle(lambda: self.radio() != [])
self.assertEqual(len(self.radio()), 1, self.radio())
sent = self.radio()[0]
self.assertEqual(sent[:6], ["send", "call", "--to", "Skills session", "--session", "Operator"])
self.assertTrue(sent[6].endswith(f"Denied by the operator: operator command make ship in {self.work} (from Skills). Reason: {TOLD}"), sent)
done = self.verify(repo, review)
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn(f"tree {git(repo, 'write-tree').strip()} on feature/match", done.stdout)
self.assertNotIn(f"review:{review}", [card["id"] for card in self.cards()])
def test_a_rejected_commit_carries_its_feedback_by_call_and_the_commit_check_refuses_it(self):
repo, review = self.stack()
entries = self.decisions(review, "reject")
with mock.patch.object(batches, "UNDO", 0.05):
self.assertEqual(self.approve(entries, self.signed(entries, self.pin()))[0], 202)
self.settle(lambda: self.status(review) == "rejected")
self.settle(lambda: len(self.radio()) == 2)
told = sorted(sent[6].split("] ", 1)[1] for sent in self.radio())
self.assertEqual(told[0], f"Denied by the operator: commit feat: match on feature/match (from Skills). Reason: {TOLD}")
self.assertEqual({tuple(sent[:4]) for sent in self.radio()}, {("send", "call", "--to", "Skills session")})
stored = self.httpd.hub.reviews.get(review)
self.assertEqual((stored["channel"], stored["reason"], stored["to"]), ("call", TOLD, "Skills"))
done = self.verify(repo, review)
self.assertEqual(done.returncode, 1, done.stdout)
self.assertIn("rejected", done.stderr)
def test_a_command_release_binds_the_payload_hash_its_card_showed(self):
body = self.work / "body.md"
body.write_text("# Release\n", encoding="utf-8")
command = f"gh issue create --body-file {body}"
self.operator_row("operator/ship", command, str(self.work))
card = self.card("operator:operator/ship")
inbox = {"kind": "operator", "id": "operator/ship", "verb": "approve", "label": "", "sha256": card["sha256"]}
entry = {**inbox, "payload": card["hash"]}
row = signing.item_hash(signing.operator_item("operator/ship", command, str(self.work)))
bound = signing.match_item("operator:operator/ship", card["hash"])
self.assertEqual(self.prepare([inbox])["payload"]["items"], [row])
self.assertEqual(sorted(self.prepare([entry])["payload"]["items"]), sorted([row, signing.item_hash(bound)]))
signer = self.pin()
bare = signer.proof(signing.approval_payload([row], secrets.token_hex(16), int(time.time()) + 60), self.origin)
status, _, answer = self.approve([entry], bare)
self.assertEqual(status, 400, answer)
self.assertIn("list every approved item", answer.decode())
for bad, code in (({**entry, "payload": "x"}, 400), ({**entry, "payload": "0" * 64}, 409), ({**entry, "verb": "reject", "channel": "call", "reason": "", "to": "Skills"}, 400)):
with self.subTest(bad=bad):
self.assertEqual(self.post_json("/api/sign", {"items": [bad]}, self.guard(self.host))[0], code)
body.write_text("# Release, changed\n", encoding="utf-8")
status, _, answer = self.post_json("/api/sign", {"items": [entry]}, self.guard(self.host))
self.assertEqual(status, 409, answer)
self.assertIn("stale", answer.decode())
status, _, answer = self.post_json("/api/match/snapshot", {"task": "operator/ship"}, self.local())
self.assertEqual(status, 200, answer)
self.assertNotEqual(json.loads(answer)["hash"], card["hash"])
self.assertEqual(self.post_json("/api/sign", {"items": [entry]}, self.guard(self.host))[0], 409)
body.write_text("# Release\n", encoding="utf-8")
status, _, answer = self.post_json("/api/match/snapshot", {"task": "operator/ship"}, self.local())
self.assertEqual(json.loads(answer)["hash"], card["hash"], answer)
with mock.patch.object(batches, "UNDO", 0.4):
self.assertEqual(self.approve([entry], self.signed([entry], signer))[0], 202)
body.write_text("# Release, changed after the release\n", encoding="utf-8")
self.settle(lambda: any("payload file changed" in row["text"] for row in self.events("kinds=approval")["events"]))
self.assertEqual(self.httpd.hub.jobs.listed(), [])
body.write_text("# Release\n", encoding="utf-8")
with mock.patch.object(batches, "UNDO", 0.05):
self.assertEqual(self.approve([entry], self.signed([entry], signer))[0], 202)
self.settle(lambda: self.httpd.hub.jobs.listed() != [])
self.assertEqual([(job["task"], job["status"]) for job in self.httpd.hub.jobs.listed()], [("operator/ship", "queued")])
def test_a_commit_rejected_without_feedback_stays_a_plain_rejection(self):
_, review = self.stack()
entry = {"kind": "review", "id": review, "verb": "reject", "label": "", "sha256": ""}
for bad in ({**entry, "channel": "call", "reason": "x"}, {**entry, "channel": "mayday", "reason": "x", "to": "Skills"}, {**entry, "reason": "x", "to": "Skills"}):
with self.subTest(bad=bad):
self.assertEqual(self.post_json("/api/sign", {"items": [bad]}, self.guard(self.host))[0], 400)
with mock.patch.object(batches, "UNDO", 0.05):
self.assertEqual(self.approve([entry], None)[0], 202)
self.settle(lambda: self.status(review) == "rejected")
self.assertEqual(self.radio(), [])
class TestCommandCards(MatchCase):
def payload_command(self) -> str:
body = self.work / "body.md"