feat(orchestrator): review staged work as match cards (requirement 012, phases A and B)

Requirement 012 plus its first two phases: the kvb-match skill (match.py add, list, show) feeds the existing review queue, /api/match serves the cards and local-only stale and snapshot posts, and payload files are read only as regular files under /tmp within the sandbox view and 64 KiB. The card at #tasks/match shows face, name, age in days, repository, branch, worktree and files that open while scrolling; right-click or long press marks a line, stale cards cannot be accepted. Accept, reject and the passkey release follow in phase C after the screenshot feedback. Tests run once on unify/skills-20261114 after the merge (operator order 2026-11-14).

🎯 Fix: 75 %
💥 Break: 8 %
💸 Tokens: 100 %
⏱️ Velocity: 100 %
🛡️ Security: 95 %
🏆 Score: 66
🚦 Gate: ⛔ fix 75 % < 90, break 8 % > 5; security 95 % < 100: ask the operator before the commit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Kevin Veen-BirkenbachandClaude Opus 5.5 committed 2026-11-14 21:36:40 +00:00
1 parent a2a03995cb
commit 8bc7209ed1
23 files changed
+1407 -15

No files matched your search

+3 -1
View File
@@ -9,7 +9,7 @@ Compatible with Claude Code, Codex, Gemini CLI, Cursor, Copilot, Windsurf, Cline
## Naming 🏷️ ## Naming 🏷️
Every first-party skill is named `kvb-<category>-<name>` with one of these categories: `think`, `create`, `code`, `ci`, `git`, `release`, `check`, `org`, `agent`, `skill`, `coach`: `think` thinks without producing a file, `create` produces an artifact, `code` works on code, `ci` on pipelines, `git` on history and forges, `release` announces a release (changelog, article, posts), `check` analyses and reports findings, `org` coordinates agents, `agent` acts on one agent itself: its repository setup (code index, agent instructions) and its state (drain, suspend, resume), `skill` works on skills themselves, `coach` serves the operator's wellbeing. Only `kvb-cleanup`, `kvb-coach`, `kvb-help` and the collectors `kvb-dream`, `kvb-optimize`, `kvb-release` and `kvb-transcend` stand without a category. Names use `a-z`, `0-9` and single hyphens, at most 64 characters, and equal their directory name. `tests/test_naming.py` enforces all of it, including that the organigram below lists every skill under its category. Every first-party skill is named `kvb-<category>-<name>` with one of these categories: `think`, `create`, `code`, `ci`, `git`, `release`, `check`, `org`, `agent`, `skill`, `coach`: `think` thinks without producing a file, `create` produces an artifact, `code` works on code, `ci` on pipelines, `git` on history and forges, `release` announces a release (changelog, article, posts), `check` analyses and reports findings, `org` coordinates agents, `agent` acts on one agent itself: its repository setup (code index, agent instructions) and its state (drain, suspend, resume), `skill` works on skills themselves, `coach` serves the operator's wellbeing. Only `kvb-cleanup`, `kvb-coach`, `kvb-help`, `kvb-match` and the collectors `kvb-dream`, `kvb-optimize`, `kvb-release` and `kvb-transcend` stand without a category. Names use `a-z`, `0-9` and single hyphens, at most 64 characters, and equal their directory name. `tests/test_naming.py` enforces all of it, including that the organigram below lists every skill under its category.
## Organigram 🏛️ ## Organigram 🏛️
@@ -115,6 +115,7 @@ flowchart LR
none --> optimize_all[kvb-optimize] none --> optimize_all[kvb-optimize]
none --> release_all[kvb-release] none --> release_all[kvb-release]
none --> coach_all[kvb-coach] none --> coach_all[kvb-coach]
none --> match_all[kvb-match]
coach --> coach_meditation[kvb-coach-meditation] coach --> coach_meditation[kvb-coach-meditation]
``` ```
@@ -240,6 +241,7 @@ flowchart LR
optimize[kvb-optimize] optimize[kvb-optimize]
release_all[kvb-release] release_all[kvb-release]
coach[kvb-coach] coach[kvb-coach]
match[kvb-match]
end end
subgraph cat_coach [coach] subgraph cat_coach [coach]
meditation[kvb-coach-meditation] meditation[kvb-coach-meditation]
+149
View File
@@ -0,0 +1,149 @@
# 012 - Match Review
## User Story
As the operator, I want every waiting commit and operator command as a card
in one stack under Tasks, decide each with a swipe and release all decisions
with one passkey at the end, so that I review agent work fast without
terminal prompts.
## Decisions (operator-confirmed 2026-11-14; do not re-litigate)
1. **Cards**: staged commits (diff, score, gate) and operator commands with
their payload: the command, its directory, its reason and the content of
every file the command reads (an issue body, a script, a list file).
Rejected: staged commits only; decision rows as cards (they keep their own
pick view).
2. **Place**: a Match view under the Tasks tab; the Tasks tab carries a badge
with the number of waiting cards.
3. **Card layout**: on top the agent's face, below it the agent's name and
its age in days (since its first session), then repository, branch and
worktree; below them the affected files, each collapsed, opening one
after another while the card scrolls down and showing the diff (commits)
or the file content (command payloads) with line numbers.
4. **Marks**: a right-click on a code line (a long press on touch) opens a
short comment field; the mark stays on the card.
5. **Decide**: the green check at the bottom right, a swipe right or the
right arrow key accepts; the red cross at the bottom left, a swipe left or
the left arrow key rejects and opens a feedback popup prefilled with the
card's marks (file, line, comment), editable; a swipe up or the up arrow
key moves the card to the back of the stack. Nothing runs while the
operator swipes.
6. **Release**: after the last card, a list overview shows every decision
with a way to change it; one passkey signature over the list of card id,
tree or payload hash and decision releases them all. Accepted commits:
the agent checks the signature with `approval.py verify` against the
signed hash and commits. Accepted commands: the hub runs them as it runs
operator rows today. Rejections: a radio call with the feedback text goes
to the card's agent. Rejected: a passkey per card; a release button
without a passkey.
7. **Source**: the existing hub review queue (`approval.py`) and the operator
rows stay the source of truth. A thin `kvb-match` skill (`match.py add`,
`list`, `show`) lets an agent add a finished stage as a patch snapshot
(staged diff, tree hash, score) and shows the cards in a terminal.
Rejected: a second queue next to the reviews; a UI over the reviews only.
8. **Snapshot binding**: a card shows the patch or payload as it was when it
was added; when the agent's staged tree or a payload file changes
afterwards, the card shows `stale` and cannot be accepted until it is
added again.
9. **Gone rows**: a card whose review or operator row the server no longer
has leaves the stack on the next refresh; it never shows a 404.
10. **Responsive**: the view works at 390 px and on desktop, with touch
swipe and mouse drag. Reaching the hub from a phone is a separate
requirement.
## Approach
```mermaid
flowchart TD
subgraph P["🧭 0 · Preparation"]
P1["📋 Write requirement"] --> P2{"✅ Operator approves?"}
P2 -- "✏️ corrections" --> P1
end
P2 -- "🤖 yes" --> Q1
subgraph Q["🗂️ A · Queue and skill"]
Q1["🧩 match.py add, list, show over the review queue"] --> Q2["📦 Operator rows as cards with payload files"]
Q2 --> Q3["🔒 Snapshot hash, stale and gone detection"]
Q3 --> QT{"🧪 Unit tests green?"}
QT -- "🔴 no: fix" --> Q1
end
QT -- "🟢 yes" --> C1
subgraph C["🃏 B · Card"]
C1["🙂 Face, name, age, repository, branch, worktree"] --> C2["📜 Files open on scroll, diff with line numbers"]
C2 --> C3["🖱️ Right-click and long-press marks"]
C3 --> CT{"🧪 E2E at 1920, 1366, 390 green?"}
CT -- "🔴 no: fix" --> C1
CT -- "🟢 yes" --> CF{"💬 Operator feedback on screenshots?"}
CF -- "✏️ changes" --> C1
end
CF -- "👍 fits" --> D1
subgraph D["👉 C · Decide and release"]
D1["↔️ Swipe, buttons, arrow keys, later"] --> D2["📝 Feedback popup prefilled from marks"]
D2 --> D3["📋 List overview of all decisions"]
D3 --> D4["🔑 One passkey signature over ids, hashes, decisions"]
D4 --> D5["🚀 Commits verified and committed, commands run, calls sent"]
D5 --> DT{"🧪 Release and negative control green?"}
DT -- "🔴 no: fix" --> D1
DT -- "🟢 yes" --> DF{"💬 Operator feedback?"}
DF -- "✏️ changes" --> D1
end
DF -- "👍 fits" --> E1["🏁 Review, commit with operator OK, hand-over"]
```
## Acceptance Criteria
### Queue and skill
- [ ] `match.py add --repo <worktree>` in a worktree with staged changes adds
one card whose patch equals `git diff --cached` and whose hash equals
`git write-tree`; `match.py list` shows it and `match.py show <id>`
prints its patch.
- [ ] Every open operator row appears as a card with its command, directory,
reason and the content of each regular file its command names; a
symlink or a file over the size limit is shown as refused, not read.
- [ ] A card whose staged tree or payload file changed after it was added
shows `stale` and its accept is disabled.
- [ ] A card whose review or operator row the server no longer returns is
gone from the stack after the next refresh, without a page reload.
### Card
- [ ] A card shows the agent's face, name, age in days, repository, branch
and worktree, and the file list.
- [ ] Scrolling down a card opens its files one after another; each shows
its diff or content with line numbers.
- [ ] A right-click or a long press on a code line adds a mark with a
comment; the mark is shown at its line.
### Decide and release
- [ ] Swipe right, the check button and the right arrow record accept; swipe
left, the cross button and the left arrow open the feedback popup
prefilled with every mark of the card; swipe up and the up arrow move
the card to the back; no commit and no command runs before the
release.
- [ ] The list overview shows every decision and lets each be changed
before the release.
- [ ] The server refuses a release whose passkey signature does not cover
exactly the listed card ids, hashes and decisions, and refuses a
replayed signature.
- [ ] After a release, `approval.py verify` accepts an accepted commit only
at its signed tree hash; a changed index is refused.
- [ ] After a release, each accepted command runs once and its result is
shown; each rejected card's agent receives a radio call whose text
contains the feedback.
- [ ] The Tasks tab badge equals the number of waiting cards.
### Tests
- [ ] Unit: `match.py add`, `list`, `show`; the snapshot hash; stale and gone
detection; release signature verification for a valid, a tampered and
a replayed list; the feedback prefill from marks.
- [ ] Integration: `approval.py verify` against a released list; payload
extraction from operator rows, including a symlink and an oversized
file that are refused.
- [ ] E2E: Chromium and Firefox at 1920, 1366 and 390 px swipe through three
cards (a commit, a command, a stale card), mark a line, reject with
feedback, open the list overview and release through a virtual WebAuthn
authenticator; negative control: a decision changed after signing is
refused.
+1
View File
@@ -12,3 +12,4 @@ skill defines the format.
- [006 - Score Metric Overlays](006-score-metric-overlays.md) - [006 - Score Metric Overlays](006-score-metric-overlays.md)
- [007 - Resources View](007-resources-view.md) - [007 - Resources View](007-resources-view.md)
- [008 - Home Dashboard](008-home-dashboard.md) - [008 - Home Dashboard](008-home-dashboard.md)
- [012 - Match Review](012-match-review.md)
+9 -3
View File
@@ -25,7 +25,9 @@ ITEM = re.compile(r"/api/(asks|decisions)/([0-9a-f]{16})(?:/(allow|deny))?")
ENTRY = re.compile(r"/api/stream/([0-9]{1,12})") ENTRY = re.compile(r"/api/stream/([0-9]{1,12})")
BOARD = re.compile(r"/api/board/([a-z-]{1,32})") BOARD = re.compile(r"/api/board/([a-z-]{1,32})")
UPLOADS = "/api/uploads" UPLOADS = "/api/uploads"
POSTS = ("/api/asks", UPLOADS, "/api/messages") MATCH_ROUTE = "/api/match"
MATCH_POSTS = {"/api/match/stale": "match_stale", "/api/match/snapshot": "match_snapshot"}
POSTS = ("/api/asks", UPLOADS, "/api/messages", *MATCH_POSTS)
STORED = { STORED = {
"page": (".html", "text/html; charset=utf-8", PAGE_CSP), "page": (".html", "text/html; charset=utf-8", PAGE_CSP),
"files": (".json", "application/json", PLAIN_CSP), "files": (".json", "application/json", PLAIN_CSP),
@@ -127,6 +129,8 @@ class Handler(Exchange):
self.answer(lambda: hub.events(self.query()), HTTPStatus.OK) self.answer(lambda: hub.events(self.query()), HTTPStatus.OK)
elif path == "/api/tree": elif path == "/api/tree":
self.answer(hub.repositories, HTTPStatus.OK) self.answer(hub.repositories, HTTPStatus.OK)
elif path == MATCH_ROUTE:
self.answer(hub.match_cards, HTTPStatus.OK)
elif path == "/api/resources": elif path == "/api/resources":
self.answer(lambda: sampled(hub.kept / RESOURCES, hub.span(self.query(), time.time())), HTTPStatus.OK) self.answer(lambda: sampled(hub.kept / RESOURCES, hub.span(self.query(), time.time())), HTTPStatus.OK)
elif path == "/api/scores": elif path == "/api/scores":
@@ -262,9 +266,11 @@ class Handler(Exchange):
""" """
if path == "/mcp": if path == "/mcp":
return self.mcp_receiver(host) return self.mcp_receiver(host)
if path == "/api/asks": if path == "/api/asks" or path in MATCH_POSTS:
if self.local(host): if self.local(host):
return lambda body: self.answer(lambda: self.server.hub.ask(body), HTTPStatus.CREATED) hub = self.server.hub
receive = getattr(hub, MATCH_POSTS[path]) if path in MATCH_POSTS else hub.ask
return lambda body: self.answer(lambda: receive(body), HTTPStatus.OK if path in MATCH_POSTS else HTTPStatus.CREATED)
self.send_text(HTTPStatus.FORBIDDEN, "forbidden: local POST with the X-Kvb-Orchestrator header and no foreign origin only") self.send_text(HTTPStatus.FORBIDDEN, "forbidden: local POST with the X-Kvb-Orchestrator header and no foreign origin only")
return None return None
if RUNNER_ROUTE.fullmatch(path): if RUNNER_ROUTE.fullmatch(path):
+4 -1
View File
@@ -26,6 +26,7 @@ from .inbox import Inbox
from .jobs import Jobs from .jobs import Jobs
from .language import Language, Model from .language import Language, Model
from .ledger import Ledger, Marks, Reviews from .ledger import Ledger, Marks, Reviews
from .matching import Matching
from .mcp import Mcp from .mcp import Mcp
from .messaging import Messaging from .messaging import Messaging
from .names import Names from .names import Names
@@ -82,7 +83,7 @@ def environment(templates: Path) -> jinja2.Environment:
@dataclass(frozen=True) @dataclass(frozen=True)
class Hub(Mcp, Reviewing, Asking, Messaging, Choosing, Approving, Denying, Requesting, Cleaning, Offices, Tasking, Gating, Firewall, Inbox, Rules, Jobs, Sources, Timeline, View, Language): class Hub(Mcp, Reviewing, Asking, Messaging, Choosing, Approving, Denying, Requesting, Cleaning, Offices, Tasking, Gating, Firewall, Inbox, Matching, Rules, Jobs, Sources, Timeline, View, Language):
council: Path council: Path
pages: Path pages: Path
public_port: int public_port: int
@@ -128,6 +129,7 @@ class Hub(Mcp, Reviewing, Asking, Messaging, Choosing, Approving, Denying, Reque
replay: Path replay: Path
history: History history: History
view_store: ViewStore view_store: ViewStore
match_snapshots: Ledger
def hosts(self) -> tuple[str, str]: def hosts(self) -> tuple[str, str]:
return f"127.0.0.1:{self.public_port}", f"localhost:{self.public_port}" return f"127.0.0.1:{self.public_port}", f"localhost:{self.public_port}"
@@ -174,6 +176,7 @@ def open_hub(council: Path, pages: Path, public_port: int, state: Path, host_sta
voice_notes=VoiceNotes(state / "voice", host_state / "voice", speech, lambda: {message["voice"] for message in messages.listed() if message.get("voice")}), voice_notes=VoiceNotes(state / "voice", host_state / "voice", speech, lambda: {message["voice"] for message in messages.listed() if message.get("voice")}),
replay=state / "replay" / "messages.json", replay=state / "replay" / "messages.json",
view_store=ViewStore(state / "view.json"), view_store=ViewStore(state / "view.json"),
match_snapshots=Ledger(state / "match.json"),
rules=Ledger(state / "rules.json"), rules=Ledger(state / "rules.json"),
offers=Offers(), offers=Offers(),
jobs=Ledger(state / "jobs.json"), jobs=Ledger(state / "jobs.json"),
+124
View File
@@ -0,0 +1,124 @@
from __future__ import annotations
import time
from .council import read_claims
from .diffs import stored_diff
from .errors import Missing, ToolError
from .fields import decode, expect, field
from .payloads import denied_roots, payload_files, payload_hash
from .records import digest, iso_epoch
from .register import REGISTER, adder, operator_rows, read_register
from .signed import signing
from .tree import inside
OPERATOR = "operator/"
def repository_of(common_dir: str) -> str:
return common_dir.removesuffix("/.git") if common_dir.endswith("/.git") else common_dir
def born_of(agent: str, names: list[dict], claims: list[dict]) -> float | None:
"""Returns:
When the agent was first seen: its earliest name sighting, else its
earliest claim; None when neither knows it.
"""
seen = [entry["first_seen"] for entry in names if entry["name"] == agent and isinstance(entry.get("first_seen"), int | float)]
claimed = [iso_epoch(claim["since"]) for claim in claims if agent and agent in (claim["agent"], claim["session"])]
found = seen or [moment for moment in claimed if moment is not None]
return min(found) if found else None
def place_of(directory: str, scan: dict) -> tuple[str, str, str]:
"""Returns:
The repository, branch and worktree of the deepest worktree of the
branch tree that holds directory; empty texts outside every one.
"""
found = [(repo["path"], branch["name"], tree["path"]) for repo in scan.get("repos", []) for branch in repo["branches"] for tree in branch["worktrees"] if tree["path"] and inside(directory, tree["path"])]
return max(found, key=lambda place: len(place[2])) if found else ("", "", directory)
class Matching:
def match_cards(self) -> dict:
now = time.time()
claims = read_claims(self.council)
names = self.names.listed()
reviews = self.reviews.pending()
cards = [self.commit_card(review, reviews, born_of(review.get("agent", ""), names, claims)) for review in reviews]
tasks = read_register(self.council / REGISTER)
held = self.open_jobs()
rows = [row for row in operator_rows(tasks) if row["check"] != "decision" and row["task"] not in held]
roots = denied_roots(self.settings_files()[0])
scan = self.tree.get()
for row in rows:
agent = adder(tasks[row["task"]])
cards.append(self.command_card(row, agent, born_of(agent, names, claims), roots, scan))
listed = {card["id"] for card in cards}
for snapshot in self.match_snapshots.listed():
if snapshot["id"] not in listed:
self.match_snapshots.remove(snapshot["id"])
return {"now": now, "cards": cards}
def commit_card(self, review: dict, reviews: list[dict], born: float | None) -> dict:
newer = [other["id"] for other in reviews if other["created"] > review["created"] and (other["worktree"], other["branch"]) == (review["worktree"], review["branch"])]
live = review.get("live_tree")
reason = f"added again as review:{newer[-1]}" if newer else "the staged tree changed since it was added" if live not in (None, review["tree"]) else ""
try:
files = stored_diff(self.reviews.pages, "review", review["id"])["diff"]
except Missing:
files = None
place = {"repo": repository_of(review.get("repo", "")), "branch": review["branch"], "worktree": review["worktree"]}
return {
"id": f"review:{review['id']}", "kind": "commit", "ref": review["id"], "agent": review.get("agent", ""), "born": born, "created_ts": iso_epoch(review["created"]),
**place, "title": review["title"], "score": review.get("score", ""), "gate": review.get("gate", ""), "hash": review["tree"], "live_hash": live or review["tree"],
"stale": bool(reason), "stale_reason": reason, "files": files, "command": "", "directory": review["worktree"], "reason": "",
}
def command_card(self, row: dict, agent: str, born: float | None, roots: list[str] | None, scan: dict) -> dict:
card_id = f"operator:{row['task']}"
files = payload_files(row["command"], row["directory"], roots)
live = payload_hash(row["command"], row["directory"], files)
snapshot = self.match_snapshots.get(card_id)
if snapshot is None or snapshot["command_sha256"] != digest(row["command"]):
self.match_snapshots.remove(card_id)
snapshot = self.match_snapshots.insert(card_id, {"command_sha256": digest(row["command"]), "hash": live, "files": files, "taken": time.time()})
stale = snapshot["hash"] != live
repo, branch, worktree = place_of(row["directory"], scan)
return {
"id": card_id, "kind": "command", "ref": row["task"], "agent": agent, "born": born, "created_ts": snapshot["taken"], "repo": repo, "branch": branch, "worktree": worktree,
"title": row["command"], "score": "", "gate": "", "hash": snapshot["hash"], "live_hash": live, "stale": stale,
"stale_reason": "a payload file changed since it was added" if stale else "", "files": snapshot["files"], "command": row["command"], "directory": row["directory"],
"reason": row["why"], "sha256": digest(row["command"]),
}
def match_stale(self, body: bytes) -> dict:
"""Args:
body: {"id", "tree"}: a pending review and the tree git
write-tree prints in its worktree now; a tree other than the
review's marks its card stale.
"""
payload = decode(body)
expect(payload, ("id", "tree"))
review_id, tree = field(payload, "id"), field(payload, "tree")
review = self.reviews.get(review_id)
if review is None or review["status"] != "pending":
raise Missing(review_id)
self.reviews.change(review_id, {"live_tree": tree})
return {"id": review_id, "stale": tree != review["tree"]}
def match_snapshot(self, body: bytes) -> dict:
"""Args:
body: {"task"}: an open operator row whose card takes its payload
files as they are now.
"""
payload = decode(body)
expect(payload, ("task",))
task = payload["task"]
if not isinstance(task, str) or not task.startswith(OPERATOR) or not signing.TASK.fullmatch(task):
raise ToolError("task must be an operator row")
self.match_snapshots.remove(f"operator:{task}")
card = next((card for card in self.match_cards()["cards"] if card["id"] == f"operator:{task}"), None)
if card is None:
raise Missing(task)
return {"id": card["id"], "hash": card["hash"], "stale": card["stale"]}
+121
View File
@@ -0,0 +1,121 @@
from __future__ import annotations
import hashlib
import os
import re
import shlex
import stat
from .signed import client_module, signing
sandbox_paths = client_module("sandbox_paths", {})
PAYLOAD_LIMIT = 64 << 10
PAYLOAD_FILES = 8
PAYLOAD_ROOT = "/tmp"
BINARY_PROBE = 8000
EXTENSION = re.compile(r"[^/]+\.[A-Za-z0-9]{1,8}")
URL = re.compile(r"[A-Za-z][A-Za-z0-9+.-]*://")
def words_of(command: str) -> list[str]:
try:
return shlex.split(command)
except ValueError:
return command.split()
def named_paths(command: str, directory: str) -> list[str]:
"""Returns:
Every word of the command, or value of a --name=value option, that
names a path: one holding a / or ending in a file extension, no
URL; relative ones joined to directory, each once, in order.
"""
found: list[str] = []
for word in words_of(command):
value = word.split("=", 1)[1] if word.startswith("-") and "=" in word else word
if not value or value.startswith("-") or URL.match(value) or not ("/" in value or EXTENSION.fullmatch(value)):
continue
path = os.path.normpath(os.path.join(directory, os.path.expanduser(value)))
if path not in found:
found.append(path)
return found
def refused(path: str, reason: str, size: int) -> dict:
return {"path": path, "state": "refused", "reason": reason, "sha256": "", "size": size, "content": ""}
def read_payload(path: str, roots: list[str] | None) -> dict | None:
"""Args:
path: an absolute, normalized path a command names.
roots: the sandbox denyRead roots, None when the hub knows none yet.
Returns:
The file as shown on a card: read with its content and sha256, or
refused with the reason and no content; None when nothing lies at
the path or it is no file.
"""
try:
info = os.lstat(path)
except OSError:
return None
if stat.S_ISLNK(info.st_mode):
return refused(path, "a symlink, never followed", 0)
if not stat.S_ISREG(info.st_mode):
return None
if not path.startswith(f"{PAYLOAD_ROOT}/") or os.path.realpath(path) != path:
return refused(path, f"outside {PAYLOAD_ROOT} or behind a symlinked folder", info.st_size)
if roots is None:
return refused(path, "no sandbox view yet, so no file is read", info.st_size)
if sandbox_paths.denied(path, roots):
return refused(path, "the sandbox denies reading it", info.st_size)
if info.st_size > PAYLOAD_LIMIT:
return refused(path, f"{info.st_size} bytes, over the {PAYLOAD_LIMIT} bytes a card shows", info.st_size)
try:
descriptor = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
except OSError as error:
return refused(path, f"unreadable: {error.strerror}", info.st_size)
with os.fdopen(descriptor, "rb") as handle:
if not stat.S_ISREG(os.fstat(handle.fileno()).st_mode):
return refused(path, "no regular file", info.st_size)
data = handle.read(PAYLOAD_LIMIT + 1)
if len(data) > PAYLOAD_LIMIT:
return refused(path, f"over the {PAYLOAD_LIMIT} bytes a card shows", len(data))
if b"\0" in data[:BINARY_PROBE]:
return refused(path, "a binary file", len(data))
return {"path": path, "state": "read", "reason": "", "sha256": hashlib.sha256(data).hexdigest(), "size": len(data), "content": data.decode("utf-8", "replace")}
def payload_files(command: str, directory: str, roots: list[str] | None) -> list[dict]:
found = (read_payload(path, roots) for path in named_paths(command, directory) if directory.startswith("/"))
return [entry for entry in found if entry is not None][:PAYLOAD_FILES]
def payload_hash(command: str, directory: str, files: list[dict]) -> str:
"""Returns:
The sha256 a command card is bound to: its command, directory and
each named file's path, state, reason and content digest.
"""
listed = [[entry["path"], entry["state"], entry["reason"], entry["sha256"]] for entry in files]
return signing.item_hash({"kind": "payload", "command": command, "directory": directory, "files": listed})
def denied_roots(settings_files: list[dict]) -> list[str] | None:
"""Args:
settings_files: the settings files of the hub's sandbox view, each
with its permissions and sandbox sections.
Returns:
Every absolute sandbox.filesystem.denyRead entry of them, None when
the view lists no file.
"""
if not settings_files:
return None
roots: list[str] = []
for entry in settings_files:
sandbox = entry["settings"].get("sandbox")
filesystem = sandbox.get("filesystem") if isinstance(sandbox, dict) else None
listed = filesystem.get("denyRead") if isinstance(filesystem, dict) else None
roots += [path.rstrip("/") or "/" for path in listed or [] if isinstance(path, str) and path.startswith("/")]
return roots
+4
View File
@@ -434,6 +434,8 @@ pre.notes { margin: 0; padding: 8px 10px; background: var(--sunken); border-radi
{% include "style-home.css" %} {% include "style-home.css" %}
{% include "style-firewall.css" %} {% include "style-firewall.css" %}
{% include "style-match.css" %}
</style> </style>
</head> </head>
<body> <body>
@@ -585,6 +587,8 @@ pre.notes { margin: 0; padding: 8px 10px; background: var(--sunken); border-radi
{% include "page-kanban.js" %} {% include "page-kanban.js" %}
{% include "page-match.js" %}
{% include "page-choices.js" %} {% include "page-choices.js" %}
{% include "page-time.js" %} {% include "page-time.js" %}
+1 -1
View File
@@ -2,7 +2,7 @@ const Nav = (() => {
"use strict"; "use strict";
const TABS = [["home", "Home"], ["stream", "Stream"], ["agents", "Agents"], ["artifacts", "Artifacts"], ["tasks", "Tasks"], ["resources", "Resources"]]; const TABS = [["home", "Home"], ["stream", "Stream"], ["agents", "Agents"], ["artifacts", "Artifacts"], ["tasks", "Tasks"], ["resources", "Resources"]];
const SUBS = {stream: [["rules", "Firewall"]]}; const SUBS = {stream: [["rules", "Firewall"]]};
const PANES = {inbox: ["tasks", "operator"]}; const PANES = {inbox: ["tasks", "operator"], match: ["tasks", "match"]};
const VIEWS = [["orbit", "Orbit"], ["chord", "Chord"], ["swimlane", "Swimlane"], ["tree", "Tree"], ["3d", "3D"]]; const VIEWS = [["orbit", "Orbit"], ["chord", "Chord"], ["swimlane", "Swimlane"], ["tree", "Tree"], ["3d", "3D"]];
const TASK_VIEWS = [["list", "List"], ["board", "Board"], ["rasci", "RASCI"], ["gantt", "Gantt"], ["burn", "Burndown and burnup"], ["3d", "3D"]]; const TASK_VIEWS = [["list", "List"], ["board", "Board"], ["rasci", "RASCI"], ["gantt", "Gantt"], ["burn", "Burndown and burnup"], ["3d", "3D"]];
const OWN = {agents: [["hierarchy", "Hierarchy"]]}; const OWN = {agents: [["hierarchy", "Hierarchy"]]};
+286
View File
@@ -0,0 +1,286 @@
const MATCH_REFRESH = 2000;
const MATCH_PEEKS = 2;
const LONG_PRESS = 550;
const PRESS_SLOP = 10;
const MATCH_KINDS = {commit: ["Commit", "info", "bi-git"], command: ["Command", "warn", "bi-terminal"]};
const matchView = {cards: null, order: [], marks: new Map(), opened: new Map(), dom: null, sig: "", fetched: 0, loading: false, press: null};
async function fetchMatch() {
if (matchView.loading) {
return;
}
matchView.loading = true;
matchView.fetched = Date.now();
try {
const response = await fetch("/api/match", {cache: "no-store"});
if (response.ok) {
const data = await response.json();
matchView.cards = Array.isArray(data.cards) ? data.cards : [];
}
} catch {
matchView.cards = matchView.cards || [];
} finally {
matchView.loading = false;
}
drawMatch();
}
function matchOrder(cards) {
const ids = new Set(cards.map((card) => card.id));
const kept = matchView.order.filter((id) => ids.has(id));
const fresh = cards.filter((card) => !kept.includes(card.id)).sort((a, b) => Number(a.stale) - Number(b.stale) || (a.created_ts || 0) - (b.created_ts || 0));
matchView.order = [...kept, ...fresh.map((card) => card.id)];
const byId = new Map(cards.map((card) => [card.id, card]));
return matchView.order.map((id) => byId.get(id));
}
function ageWords(born) {
if (typeof born !== "number") {
return "age unknown";
}
const days = Math.max(0, Math.floor((state.now - born) / DAY));
return days === 1 ? "1 day" : `${days} days`;
}
function marksOf(card) {
const key = `${card.id}@${card.hash}`;
if (!matchView.marks.has(key)) {
matchView.marks.set(key, []);
}
return matchView.marks.get(key);
}
function contentRows(text) {
const lines = String(text).split("\n");
if (lines.length && lines[lines.length - 1] === "") {
lines.pop();
}
return lines.map((line, index) => h("tr", {class: "ctx", "data-line": index + 1}, h("td", {class: "num"}, index + 1), h("td", {class: "code"}, revealed(line))));
}
function markRow(mark, columns) {
return h("tr", {class: "match-mark", "data-line": mark.line}, h("td", {colspan: columns}, icon("bi-chat-square-text"), h("span", {class: "match-mark-text"}, revealed(mark.comment))));
}
function fileRows(card, file) {
const commit = card.kind === "commit";
const rows = commit ? (file.patch ? Diffs.rows(file.patch).map(patchRow) : []) : file.state === "read" ? contentRows(file.content) : [];
const columns = commit ? 4 : 2;
const marks = marksOf(card).filter((mark) => mark.path === file.path);
return rows.flatMap((row) => {
const line = row.dataset.line;
const here = marks.filter((mark) => String(mark.line) === line);
if (here.length) {
row.classList.add("marked");
}
return [row, ...here.map((mark) => markRow(mark, columns))];
});
}
function fileHead(card, file) {
const count = marksOf(card).filter((mark) => mark.path === file.path).length;
const marks = count ? h("span", {class: "match-marks", title: `${count} marks`}, String(count)) : null;
if (card.kind === "commit") {
const tone = DIFF_TONES[file.status] || "neutral";
const stat = file.status === "B" ? icon("bi-file-earmark-binary") : h("span", {class: "stat"}, h("span", {class: "add"}, `+${file.additions}`), h("span", {class: "del"}, `-${file.deletions}`));
return h("summary", {class: "diff-head"}, h("span", {class: "letter", "data-tone": tone}, file.status), h("code", {class: "path"}, revealed(file.path)), h("span", {class: "spacer"}),
file.note ? h("span", {class: "note", title: file.note}, icon("bi-eye-slash"), file.note) : null, marks, stat);
}
const tone = file.state === "read" ? "ok" : "bad";
return h("summary", {class: "diff-head"}, h("span", {class: "letter", "data-tone": tone}, icon("bi-file-earmark-text")), h("code", {class: "path"}, revealed(file.path)), h("span", {class: "spacer"}),
file.state === "read" ? null : h("span", {class: "note", title: file.reason}, icon("bi-exclamation-triangle"), `refused: ${file.reason}`), marks, h("span", {class: "muted"}, `${file.size} B`));
}
function fileBlock(card, file, index) {
const opened = matchView.opened.has(card.id) ? matchView.opened.get(card.id).has(file.path) : index === 0;
const rows = fileRows(card, file);
const table = rows.length ? h("div", {class: "diff-scroll"}, h("table", {class: "diff"}, h("tbody", {}, rows))) : h("p", {class: "muted"}, card.kind === "commit" ? "No patch shipped for this file." : "Not read.");
const block = h("details", {class: "match-file", "data-path": file.path, "data-state": card.kind === "command" ? file.state : null, open: opened}, fileHead(card, file), table);
block.addEventListener("toggle", () => remember(card, block));
return h("li", {}, block);
}
function remember(card, block) {
if (!matchView.opened.has(card.id)) {
matchView.opened.set(card.id, new Set());
}
const open = matchView.opened.get(card.id);
if (block.open) {
open.add(block.dataset.path);
} else {
open.delete(block.dataset.path);
}
}
function openOnScroll(body) {
const files = [...body.querySelectorAll(".match-file")];
const view = body.getBoundingClientRect();
for (let index = 0; index < files.length - 1; index += 1) {
const file = files[index];
if (!file.open) {
return;
}
const next = files[index + 1];
if (!next.open && file.getBoundingClientRect().bottom <= view.bottom + 8) {
next.open = true;
return;
}
}
}
function closeComment(card) {
const open = card.querySelector(".match-comment");
if (open) {
open.remove();
}
}
function commentField(card, data, row) {
const article = row.closest(".match-card");
closeComment(article);
const file = row.closest(".match-file");
const words = h("textarea", {class: "field", rows: 2, "aria-label": "Comment", placeholder: "Comment on this line"});
const save = h("button", {type: "button", class: "btn small primary match-save", ...named("Save mark"), on: {click: () => {
if (!words.value.trim()) {
words.focus();
return;
}
marksOf(data).push({path: file.dataset.path, line: Number(row.dataset.line), comment: words.value.trim()});
drawMatch(true);
}}}, icon("bi-bookmark-fill"), "Save");
const cancel = h("button", {type: "button", class: "btn small ghost", ...named("Cancel"), on: {click: () => closeComment(article)}}, "Cancel");
const columns = row.children.length;
const field = h("tr", {class: "match-comment"}, h("td", {colspan: columns}, h("div", {class: "match-comment-box"}, h("code", {}, `${file.dataset.path}:${row.dataset.line}`), words, h("div", {class: "actions"}, cancel, save))));
row.after(field);
words.focus();
}
function codeRow(event) {
const row = event.target instanceof Element ? event.target.closest(".match-file tr[data-line]") : null;
return row && !row.classList.contains("match-mark") ? row : null;
}
function markable(article, data) {
article.addEventListener("contextmenu", (event) => {
const row = codeRow(event);
if (row) {
event.preventDefault();
commentField(article, data, row);
}
});
article.addEventListener("pointerdown", (event) => {
const row = codeRow(event);
if (!row || event.pointerType !== "touch") {
return;
}
const press = {x: event.clientX, y: event.clientY, timer: window.setTimeout(() => {
matchView.press = null;
commentField(article, data, row);
}, LONG_PRESS)};
matchView.press = press;
});
const drop = () => {
if (matchView.press) {
window.clearTimeout(matchView.press.timer);
matchView.press = null;
}
};
article.addEventListener("pointermove", (event) => {
if (matchView.press && Math.hypot(event.clientX - matchView.press.x, event.clientY - matchView.press.y) > PRESS_SLOP) {
drop();
}
});
article.addEventListener("pointerup", drop);
article.addEventListener("pointercancel", drop);
}
function matchHead(card) {
const [kindName, kindTone, kindIcon] = MATCH_KINDS[card.kind] || [card.kind, "neutral", "bi-collection"];
return h("header", {class: "match-head"},
h("div", {class: "match-who"}, face(card.agent || "-", true), h("strong", {class: "match-name"}, revealed(card.agent || "unknown agent")), h("span", {class: "match-age"}, ageWords(card.born))),
h("div", {class: "states"}, h("span", {class: "pill", "data-tone": kindTone}, icon(kindIcon), kindName), card.gate ? pill(`gate ${card.gate}`, card.gate === "pass" ? "ok" : "bad") : null,
card.score ? h("span", {class: "pill", "data-tone": "neutral"}, revealed(card.score)) : null, card.stale ? h("span", {class: "pill match-stale-pill", "data-tone": "bad"}, icon("bi-hourglass-split"), "stale") : null),
h("dl", {class: "meta match-place"}, [["Repository", card.repo], ["Branch", card.branch], ["Worktree", card.worktree]].map(([label, value]) => h("div", {}, h("dt", {}, label), h("dd", {}, h("code", {title: value ? revealed(value) : null}, revealed(dash(value))))))),
h("h2", {class: "match-title"}, revealed(card.title)),
card.stale ? h("p", {class: "match-stale"}, icon("bi-exclamation-triangle"), revealed(card.stale_reason)) : null);
}
function matchCommand(card) {
if (card.kind !== "command") {
return null;
}
return h("section", {class: "match-payload"},
h("pre", {class: "match-command"}, h("code", {}, revealed(card.command))),
h("p", {class: "match-directory"}, revealed(card.directory)),
card.reason && card.reason !== "-" ? h("p", {class: "match-reason"}, revealed(card.reason)) : null);
}
function matchCard(card) {
const files = card.files || [];
const list = files.length ? h("ol", {class: "match-files", "aria-label": `Files: ${files.length}`}, files.map((file, index) => fileBlock(card, file, index))) : h("p", {class: "muted"}, card.kind === "commit" ? "No diff shipped with this stage." : "Its command names no file.");
const body = h("div", {class: "match-body"}, matchCommand(card), list);
body.addEventListener("scroll", () => openOnScroll(body), {passive: true});
const article = h("article", {class: "card match-card front", "data-card": card.id, "data-kind": card.kind, "data-stale": String(Boolean(card.stale)), "aria-label": `${card.kind} card of ${card.agent || "an agent"}`},
matchHead(card), body);
markable(article, card);
window.setTimeout(() => openOnScroll(body), 0);
return article;
}
function peekTab(card) {
const [kindName, kindTone] = MATCH_KINDS[card.kind] || [card.kind, "neutral"];
return h("button", {type: "button", class: "match-peek", "data-card": card.id, "data-stale": String(Boolean(card.stale)), ...named(`Show ${kindName.toLowerCase()} card: ${card.title}`), on: {click: () => {
matchView.order = [card.id, ...matchView.order.filter((id) => id !== card.id)];
drawMatch(true);
}}}, face(card.agent || "-", false), h("span", {class: "pill", "data-tone": kindTone}, kindName), card.stale ? h("span", {class: "pill", "data-tone": "bad"}, "stale") : null, h("span", {class: "match-peek-title"}, revealed(card.title)));
}
function matchScreen() {
const stack = h("div", {class: "match-stack"});
const count = h("span", {class: "muted"});
matchView.dom = {stack, count};
matchView.sig = "";
const bar = h("div", {class: "card controls task-toolbar", role: "toolbar", "aria-label": "Match"}, h("strong", {}, icon("bi-stack"), "Match"), count, h("span", {class: "spacer"}),
iconBtn("bi-list-check", "Tasks", "btn small soft", () => go("tasks", null), "Tasks: back to the task list"));
fetchMatch();
return h("div", {class: "graph tasks match"}, bar, stack);
}
function drawMatch(force) {
const dom = matchView.dom;
if (!dom || !dom.stack.isConnected) {
return;
}
if (!matchView.loading && Date.now() - matchView.fetched > MATCH_REFRESH) {
fetchMatch();
}
if (matchView.cards === null) {
dom.stack.replaceChildren(h("p", {class: "muted"}, "Loading cards …"));
return;
}
const cards = matchOrder(matchView.cards);
const sig = JSON.stringify([cards.map((card) => [card.id, card.hash, card.live_hash, card.stale, card.born, card.files ? card.files.length : null]), Math.floor(state.now / DAY)]);
if (!force && sig === matchView.sig) {
return;
}
matchView.sig = sig;
dom.count.textContent = cards.length === 1 ? "1 card waits" : `${cards.length} cards wait`;
if (!cards.length) {
dom.stack.replaceChildren(emptyState("No card waits", "No staged commit and no operator command waits for a decision."));
return;
}
const [front, ...rest] = cards;
const accept = h("button", {type: "button", class: "btn match-accept", disabled: Boolean(front.stale), ...named("Accept", front.stale ? `Accept: refused while the card is stale (${front.stale_reason})` : "Accept")}, icon("bi-check-lg"));
const reject = h("button", {type: "button", class: "btn match-reject", ...named("Reject")}, icon("bi-x-lg"));
const peeks = rest.length ? h("div", {class: "match-peeks", role: "group", "aria-label": `${rest.length} more cards`}, rest.map(peekTab)) : null;
const behind = rest.slice(0, MATCH_PEEKS).map((card, index) => {
const sheet = h("div", {class: "match-behind", "aria-hidden": "true"});
sheet.style.setProperty("--depth", String(index + 1));
return sheet;
});
const before = dom.stack.querySelector(".match-card.front");
const scrolled = before && before.dataset.card === front.id ? before.querySelector(".match-body").scrollTop : 0;
const shown = matchCard(front);
dom.stack.replaceChildren(peeks, h("div", {class: "match-deck"}, behind, shown), h("div", {class: "match-actions"}, reject, accept));
shown.querySelector(".match-body").scrollTop = scrolled;
}
+4 -2
View File
@@ -55,7 +55,7 @@
} }
function screenOf() { function screenOf() {
return {home: homeScreen, stream: streamScreen, inbox: tasksScreen, rules: rulesScreen, agents: agentsScreen, artifacts: artifactsScreen, tasks: tasksScreen, resources: resourcesScreen}[ui.screen](); return {home: homeScreen, stream: streamScreen, inbox: tasksScreen, match: matchScreen, rules: rulesScreen, agents: agentsScreen, artifacts: artifactsScreen, tasks: tasksScreen, resources: resourcesScreen}[ui.screen]();
} }
function render(force) { function render(force) {
@@ -70,10 +70,11 @@
inboxDom = null; inboxDom = null;
inboxSig = ""; inboxSig = "";
taskView.dom = null; taskView.dom = null;
matchView.dom = null;
const main = document.getElementById("main"); const main = document.getElementById("main");
main.setAttribute("aria-labelledby", `tab-${ui.screen}`); main.setAttribute("aria-labelledby", `tab-${ui.screen}`);
main.replaceChildren(screenOf()); main.replaceChildren(screenOf());
const fit = ["tasks", "inbox", "resources"].includes(ui.screen) || (["agents", "artifacts"].includes(ui.screen) && !["tree", "hierarchy"].includes(ui.views[ui.screen])); const fit = ["tasks", "inbox", "match", "resources"].includes(ui.screen) || (["agents", "artifacts"].includes(ui.screen) && !["tree", "hierarchy"].includes(ui.views[ui.screen]));
document.body.classList.toggle("fit", fit); document.body.classList.toggle("fit", fit);
document.body.classList.toggle("pane", !fit); document.body.classList.toggle("pane", !fit);
drawn.screen = ui.screen; drawn.screen = ui.screen;
@@ -90,6 +91,7 @@
drawInbox(); drawInbox();
drawRadio(); drawRadio();
drawTasks(); drawTasks();
drawMatch(false);
drawChoices(); drawChoices();
drawStatus(); drawStatus();
tick(); tick();
+47
View File
@@ -0,0 +1,47 @@
.graph.tasks.match > .match-stack { flex: 1; }
.match-stack { display: grid; grid-template-rows: auto minmax(0, 1fr) auto; gap: var(--sp-2); min-height: 0; width: min(100%, 960px); margin: 0 auto; }
.match-peeks { display: flex; flex-wrap: wrap; gap: var(--sp-1); min-width: 0; }
.match-peek { display: inline-flex; align-items: center; gap: 6px; max-width: 100%; min-width: 0; padding: 4px 10px 4px 4px; border: 1px solid var(--line); border-radius: 999px; background: var(--panel); color: inherit; font: inherit; font-size: var(--fs-sm); cursor: pointer; }
.match-peek[data-stale="true"] { border-color: var(--bad); }
.match-peek .match-peek-title { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; min-width: 0; }
.match-deck { position: relative; display: grid; grid-template-rows: minmax(0, 1fr); min-height: 0; padding-top: 14px; }
.match-behind { position: absolute; inset: calc(14px - var(--depth) * 7px) calc(var(--depth) * 12px) auto; height: 40px; border: 1px solid var(--line); border-radius: var(--radius-lg); background: var(--panel); opacity: calc(1 - var(--depth) * 0.3); }
.match-card.front { position: relative; display: grid; grid-template-rows: auto minmax(0, 1fr); min-height: 0; padding: 0; overflow: hidden; }
.match-card[data-stale="true"] { box-shadow: inset 0 3px 0 var(--bad); }
.match-head { display: grid; justify-items: center; gap: 6px; padding: var(--sp-3); border-bottom: 1px solid var(--line); text-align: center; }
.match-who { display: grid; justify-items: center; gap: 2px; }
.match-who .avatar.big { width: 72px; height: 72px; }
.match-name { font-size: var(--fs-lg); }
.match-age { color: var(--muted); font-size: var(--fs-sm); }
.match-place { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: var(--sp-2); width: 100%; margin: 0; text-align: left; }
.match-place code { display: block; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.match-title { margin: 0; font-size: var(--fs-md); overflow-wrap: anywhere; }
.match-stale { display: flex; align-items: center; gap: 6px; margin: 0; color: var(--bad); font-size: var(--fs-sm); }
.match-body { min-height: 0; overflow: auto; padding: var(--sp-2) var(--sp-3) var(--sp-3); overscroll-behavior: contain; }
.match-payload { display: grid; gap: 4px; margin-bottom: var(--sp-2); }
.match-command { margin: 0; padding: 8px 10px; border-radius: 10px; background: var(--sunken); font-family: var(--mono); white-space: pre-wrap; overflow-wrap: anywhere; }
.match-directory, .match-reason { margin: 0; color: var(--muted); font-size: var(--fs-sm); overflow-wrap: anywhere; }
.match-directory::before { content: "in "; }
.match-files { display: grid; gap: var(--sp-2); margin: 0; padding: 0; list-style: none; }
.match-file { min-width: 0; overflow: hidden; border: 1px solid var(--line); border-radius: 10px; background: var(--panel); }
.match-file > summary.diff-head { padding: 6px 10px; cursor: pointer; list-style: none; }
.match-file > summary.diff-head::-webkit-details-marker { display: none; }
.match-file .diff-scroll { max-height: none; overflow: auto hidden; }
.match-file .diff-head .note { display: inline-flex; align-items: center; gap: 4px; color: var(--warn); font-size: var(--fs-xs); }
.match-marks { min-width: 20px; padding: 0 6px; border-radius: 999px; background: var(--accent); color: var(--on-accent); font-size: var(--fs-xs); text-align: center; }
.match-file tr.marked td.code { box-shadow: inset 3px 0 0 var(--accent); }
.match-file tr.match-mark td, .match-file tr.match-comment td { padding: 4px 10px; background: var(--info-soft); font-family: var(--sans); white-space: normal; }
.match-mark-text { margin-left: 6px; }
.match-comment-box { display: grid; gap: 6px; }
.match-comment-box .actions { display: flex; justify-content: flex-end; gap: 6px; }
.match-actions { display: flex; justify-content: space-between; padding-bottom: var(--sp-1); }
.match-actions .btn { width: 56px; height: 56px; border-radius: 50%; }
.match-reject { color: var(--bad); }
.match-accept { color: var(--ok); }
.match-accept:disabled { opacity: 0.4; cursor: not-allowed; }
@media (max-width: 640px) {
.match-place { grid-template-columns: minmax(0, 1fr); }
.match-head { padding: var(--sp-2); }
.match-who .avatar.big { width: 56px; height: 56px; }
.match-body { padding: var(--sp-1) var(--sp-2) var(--sp-2); }
}
+1 -1
View File
@@ -2,7 +2,7 @@
name: kvb-code-test name: kvb-code-test
description: > description: >
Run the Makefile test targets the operator picks and report; fix mode loops Run the Makefile test targets the operator picks and report; fix mode loops
until green. Trigger when asked to run or fix the tests. until green. Trigger when asked to run or fix tests.
--- ---
The Makefile is the source of truth for how this project runs tests. Never The Makefile is the source of truth for how this project runs tests. Never
+1 -1
View File
@@ -2,7 +2,7 @@
name: kvb-code-tune name: kvb-code-tune
description: > description: >
Speed up CI, deploys, builds and hot paths without losing logic or Speed up CI, deploys, builds and hot paths without losing logic or
coverage. Trigger on a job over its time budget or where time goes. coverage. Trigger on a job over budget or where time goes.
--- ---
One rule outranks every optimization: **nothing that reduces logic, coverage or One rule outranks every optimization: **nothing that reduces logic, coverage or
+1 -1
View File
@@ -1,7 +1,7 @@
--- ---
name: kvb-git-diff name: kvb-git-diff
description: > description: >
Approve staged commits in the Agent Orchestrator; the commit skills run it. Approve staged commits in the Agent Orchestrator; commit skills run it.
--- ---
The commit skills run this where they ask for the commit approval. A hub The commit skills run this where they ask for the commit approval. A hub
+28
View File
@@ -0,0 +1,28 @@
---
name: kvb-match
description: >
Add finished stages as hub Match cards.
---
The operator decides every waiting commit and operator command as a card in
the hub's Match view under Tasks. The cards come from the hub's review queue
and the operator rows; this skill only adds to them and shows them.
`${CLAUDE_SKILL_DIR}/scripts/match.py` holds the steps.
1. Once a stage is finished, add it in the worktree. `<gate>` is `pass`
when every gate the calling skill ran is green, else `fail`:
```bash
python3 ${CLAUDE_SKILL_DIR}/scripts/match.py add --repo "$PWD" --title "<subject>" --score "<score line>" --gate <gate> --agent "<agent>"
```
It prints the review `id`. The card shows the patch and tree of that
moment; change the stage afterwards and the card turns `stale`, so add it
again.
2. An operator row's card shows the files its command names as they were
when it appeared. After changing one, take it again:
`match.py add --task <operator/slug>`.
3. `match.py list` prints every card and marks a commit card whose staged
tree changed as stale in the hub; `match.py show <card>` prints its patch
or its command with the payload files.
4. Wait for the decision as `kvb-git-diff` does, from its step 3 on.
+195
View File
@@ -0,0 +1,195 @@
#!/usr/bin/env python3
"""Args:
add --repo <worktree> --title <subject> --score <line> --gate <pass|fail>
--agent <name> [--pages <dir>] [--rules <dir>]: adds the staged
change of the worktree as a commit card: a review of the hub queue
whose page holds the patch git diff --cached prints and whose tree is
the one git write-tree prints; <dir> is the hub's pages folder,
/tmp/kvb-git-diff by default, and --rules the MEDUSA rules the
masked card diff is built with, as approval.py request takes them.
add --task <operator/slug>: takes the payload files of an open operator
row again, so its stale card turns fresh.
list: prints one line per card; a commit card whose worktree's staged
tree changed is reported to the hub, which marks it stale.
show <card>: prints a commit card's patch, or a command card's command,
directory, reason and payload files.
--port <port>: the hub's port, 8737 by default.
--client <dir>: the hub's client folder, by default
~/.local/share/kvb-orchestrator/client.
Returns:
Exit code 0 with the result on stdout; 1 with the reason on stderr.
"""
from __future__ import annotations
import argparse
import html
import importlib
import json
import os
import re
import sys
import tempfile
import urllib.request
from pathlib import Path
PORT = 8737
CLIENT = Path.home() / ".local" / "share" / "kvb-orchestrator" / "client"
PAGES = Path("/tmp/kvb-git-diff")
PATCH = re.compile(r'<pre id="patch">(.*)</pre>', re.DOTALL)
REVIEW = re.compile(r"[0-9a-f]{16}")
UNSAFE = re.compile(r"[^A-Za-z0-9._-]+")
class Refused(Exception):
pass
def client_modules(folder: Path) -> dict:
sys.path.insert(0, str(folder))
return {name: importlib.import_module(name) for name in ("hub_api", "staged_diff", "approval")}
def git_text(client: dict, cwd: Path, args: list[str]) -> str:
try:
return client["staged_diff"].git(cwd, args, None).decode("utf-8", "surrogateescape")
except client["staged_diff"].DiffError as error:
raise Refused(str(error)) from error
def hub(client: dict, port: int, path: str, body: dict | None) -> object:
api = client["hub_api"]
data = None if body is None else json.dumps(body).encode("utf-8")
headers = {**api.GUARD, **({} if body is None else {"Content-Type": "application/json"})}
try:
return api.load(urllib.request.Request(f"{api.base_url(port)}{path}", data=data, headers=headers, method="GET" if body is None else "POST"), api.SLACK)
except (OSError, ValueError) as error:
raise Refused(f"the Agent Orchestrator did not answer {path}: {error}") from error
def page_text(client: dict, port: int, review_id: str) -> str:
api = client["hub_api"]
request = urllib.request.Request(f"{api.base_url(port)}/reviews/{review_id}/page", headers=api.GUARD)
try:
with api.OPENER.open(request, timeout=api.SLACK) as response:
return response.read().decode("utf-8", "replace")
except OSError as error:
raise Refused(f"the review page did not load: {error}") from error
def cards(client: dict, port: int) -> list[dict]:
data = hub(client, port, "/api/match", None)
if not isinstance(data, dict) or not isinstance(data.get("cards"), list):
raise Refused("the Agent Orchestrator answered no cards")
return data["cards"]
def add_commit(args: argparse.Namespace, client: dict) -> str:
repo = args.repo.resolve()
tree = git_text(client, repo, ["write-tree"]).strip()
branch = git_text(client, repo, ["symbolic-ref", "--short", "HEAD"]).strip()
patch = git_text(client, repo, ["diff", "--cached", "--no-ext-diff", "--no-textconv", "--no-color"])
if not patch.strip():
raise Refused(f"nothing staged in {repo}")
shown = patch.encode("utf-8", "surrogateescape").decode("utf-8", "replace")
page = args.pages / f"match-{UNSAFE.sub('-', branch)}-{tree[:12]}.html"
page.write_text(f'<!doctype html><meta charset="utf-8"><title>{html.escape(args.title)}</title><pre id="patch">{html.escape(shown)}</pre>\n', encoding="utf-8")
with tempfile.NamedTemporaryFile("w", encoding="utf-8", suffix=".txt", delete=False) as notes:
notes.write(f"{args.score}\n")
try:
os.chdir(repo)
request = argparse.Namespace(port=args.port, title=args.title, page=page, notes=Path(notes.name), gate=args.gate, score=args.score, agent=args.agent, rules=args.rules)
return client["approval"].request_review(request)
except client["approval"].Refused as error:
raise Refused(str(error)) from error
finally:
os.unlink(notes.name)
def add_task(args: argparse.Namespace, client: dict) -> str:
return json.dumps(hub(client, args.port, "/api/match/snapshot", {"task": args.task}))
def checked(client: dict, port: int, card: dict) -> dict:
worktree = Path(card["worktree"])
if card["kind"] != "commit" or card["stale"] or not worktree.is_dir():
return card
try:
live = git_text(client, worktree, ["write-tree"]).strip()
except Refused:
return card
if live == card["hash"]:
return card
hub(client, port, "/api/match/stale", {"id": card["ref"], "tree": live})
return {**card, "stale": True, "stale_reason": "the staged tree changed since it was added"}
def list_cards(args: argparse.Namespace, client: dict) -> str:
lines = []
for card in (checked(client, args.port, card) for card in cards(client, args.port)):
where = card["branch"] or card["directory"]
lines.append("\t".join([card["id"], card["kind"], "stale" if card["stale"] else "fresh", card["agent"] or "-", where or "-", card["title"]]))
return "\n".join(lines) if lines else "no cards"
def card_id(text: str) -> str:
return f"review:{text}" if REVIEW.fullmatch(text) else text
def show_card(args: argparse.Namespace, client: dict) -> str:
wanted = card_id(args.card)
card = next((card for card in cards(client, args.port) if card["id"] == wanted), None)
if card is None:
raise Refused(f"no card {wanted}")
if card["kind"] == "commit":
found = PATCH.search(page_text(client, args.port, card["ref"]))
if found:
return html.unescape(found.group(1))
return "".join(f"--- {entry['path']}\n{entry['patch']}\n" for entry in card["files"] or [])
lines = [f"$ {card['command']}", f" in {card['directory']}", f" reason: {card['reason']}"]
for entry in card["files"]:
lines.append(f"--- {entry['path']} ({entry['state']}{': ' + entry['reason'] if entry['reason'] else ''})")
lines.append(entry["content"].rstrip("\n"))
return "\n".join(lines) + "\n"
def parser() -> argparse.ArgumentParser:
found = argparse.ArgumentParser(prog="match")
commands = found.add_subparsers(dest="command", required=True)
adding = commands.add_parser("add")
target = adding.add_mutually_exclusive_group(required=True)
target.add_argument("--repo", type=Path)
target.add_argument("--task")
for name in ("--title", "--score", "--agent"):
adding.add_argument(name)
adding.add_argument("--gate", choices=("pass", "fail"))
adding.add_argument("--pages", type=Path, default=PAGES)
adding.add_argument("--rules", type=Path)
commands.add_parser("list")
showing = commands.add_parser("show")
showing.add_argument("card")
for sub in (adding, commands.choices["list"], showing):
sub.add_argument("--port", type=int, default=PORT)
sub.add_argument("--client", type=Path, default=CLIENT)
return found
def main() -> int:
args = parser().parse_args()
if args.command == "add" and args.repo and not all((args.title, args.score, args.agent, args.gate)):
print("refused: add --repo needs --title, --score, --gate and --agent", file=sys.stderr)
return 1
try:
client = client_modules(args.client)
run = {"list": list_cards, "show": show_card}.get(args.command) or (add_commit if args.repo else add_task)
output = run(args, client)
except (Refused, OSError) as error:
print(f"refused: {error}", file=sys.stderr)
return 1
sys.stdout.write(output if output.endswith("\n") or args.command == "show" else f"{output}\n")
return 0
if __name__ == "__main__":
raise SystemExit(main())
+1 -1
View File
@@ -2,7 +2,7 @@
name: kvb-org-perform name: kvb-org-perform
description: > description: >
Pick `model` and `effort` per subagent from a fixed table, cheaper only at Pick `model` and `effort` per subagent from a fixed table, cheaper only at
90 % confidence of equal results. Apply AUTOMATICALLY before every Agent 90% confidence of equal results. Apply AUTOMATICALLY before every Agent
call. call.
--- ---
+2 -2
View File
@@ -3,8 +3,8 @@ name: kvb-think-criticize
description: > description: >
Constructive criticism of a plan, design, decision, text or code, Constructive criticism of a plan, design, decision, text or code,
hardened by dialectic. Trigger on "kritisiere", hardened by dialectic. Trigger on "kritisiere",
"konstruktive Kritik", "was haeltst du davon", or requests for honest "konstruktive Kritik", "was haeltst du davon", or honest feedback
feedback. requests.
--- ---
Critical but constructive: the goal is a better result, not a verdict on its Critical but constructive: the goal is a better result, not a verdict on its
+1 -1
View File
@@ -1,7 +1,7 @@
--- ---
name: kvb-think-listen name: kvb-think-listen
description: > description: >
Pin down every requirement by focused questions, then reflect the task Pin down requirements by focused questions, then reflect the task
back. Trigger on unclear scope, constraints or success criteria, or a skill back. Trigger on unclear scope, constraints or success criteria, or a skill
needing an operator-only fact. needing an operator-only fact.
--- ---
+215
View File
@@ -0,0 +1,215 @@
from __future__ import annotations
import json
import os
import shutil
import sys
import tempfile
import time
import unittest
from pathlib import Path
HERE = Path(__file__).resolve().parent
sys.path[:0] = [str(HERE.parent), str(HERE)]
import test_orchestrator_e2e as base
from hub_case import HubCase
from hub_support import iso
OUT = Path(os.environ.get("E2E_OUT", "/tmp/hub-012-shots"))
FILES = (("src/app.py", 60), ("src/view.js", 30), ("docs/notes.md", 12))
CARD = """
const card = () => document.querySelector("#main .match-card.front");
const body = () => card() && card().querySelector(".match-body");
const opened = () => all(".match-file", card()).filter((file) => file.open).map((file) => file.dataset.path);
const pick = async (id) => {
const tab = await until(() => document.querySelector(`#main .match-peek[data-card="${id}"]`), 8000);
if (tab) {
tab.click();
}
return until(() => card() && card().dataset.card === id && card(), 8000);
};
const head = () => ({
card: card().dataset.card, kind: card().dataset.kind, stale: card().dataset.stale, face: Boolean(card().querySelector(".match-who .avatar svg")),
name: text(card().querySelector(".match-name")), age: text(card().querySelector(".match-age")),
place: all(".match-place dt", card()).map(text).map((label, index) => [label, text(all(".match-place dd", card())[index])]),
files: all(".match-file", card()).map((file) => file.dataset.path), accept: card().closest(".match-stack").querySelector(".match-accept").disabled,
reason: text(card().querySelector(".match-stale")), peeks: all("#main .match-peek").map((tab) => tab.dataset.card),
wide: document.documentElement.scrollWidth > window.innerWidth + 1,
});
"""
STACK = """(async () => {@HELPERS@@CARD@
await screenShown(8000);
await until(card, 8000);
await sleep(400);
return head();
})()"""
SCROLL = """(async () => {@HELPERS@@CARD@
await until(card, 8000);
const steps = [opened()];
for (let step = 0; step < 6; step += 1) {
body().scrollTop = body().scrollHeight;
body().dispatchEvent(new Event("scroll"));
await sleep(350);
steps.push(opened());
}
const numbered = all(".match-file[open]", card()).map((file) => [file.dataset.path, all("tr[data-line] td.num", file).filter((cell) => text(cell)).length > 0]);
body().scrollTop = 0;
return {steps, numbered};
})()"""
MARK = """(async () => {@HELPERS@@CARD@
await until(card, 8000);
const row = (path, line) => card().querySelector(`.match-file[data-path="${path}"] tr[data-line="${line}"]`);
const save = async (words) => {
const field = await until(() => card().querySelector(".match-comment textarea"), 3000);
if (!field) {
return false;
}
field.value = words;
card().querySelector(".match-comment .match-save").click();
await sleep(200);
return true;
};
const first = row("@FIRST@", 3);
first.scrollIntoView({block: "center"});
const box = first.getBoundingClientRect();
first.dispatchEvent(new MouseEvent("contextmenu", {bubbles: true, cancelable: true, clientX: box.left + 40, clientY: box.top + 4, button: 2}));
const clicked = await save("use the helper here");
const second = row("@FIRST@", 6);
second.dispatchEvent(new PointerEvent("pointerdown", {bubbles: true, cancelable: true, pointerId: 7, pointerType: "touch", isPrimary: true, clientX: box.left + 40, clientY: box.top + 4}));
await sleep(800);
second.dispatchEvent(new PointerEvent("pointerup", {bubbles: true, cancelable: true, pointerId: 7, pointerType: "touch", isPrimary: true}));
const pressed = await save("long press note");
const marks = all("tr.match-mark", card()).map((mark) => [mark.dataset.line, text(mark.querySelector(".match-mark-text"))]);
const marked = all("tr.marked", card()).map((mark) => mark.dataset.line);
return {clicked, pressed, marks, marked, count: text(card().querySelector('.match-file[data-path="@FIRST@"] .match-marks'))};
})()"""
PICK = """(async () => {@HELPERS@@CARD@
const found = await pick("@ID@");
if (!found) {
return {missing: "@ID@"};
}
await sleep(400);
const command = card().querySelector(".match-command");
const payload = all(".match-file", card()).map((file) => [file.dataset.path.split("/").pop(), file.dataset.state || "", all("tr[data-line]", file).length]);
return {...head(), command: command ? text(command.querySelector("code")) : null, where: text(card().querySelector(".match-directory")), why: text(card().querySelector(".match-reason")), payload};
})()"""
def probe(template: str, **values: str) -> str:
found = template.replace("@HELPERS@", base.HELPERS).replace("@CARD@", CARD)
for name, value in values.items():
found = found.replace(f"@{name}@", value)
return found
def patch(lines: int) -> str:
rows = [f"@@ -1,{lines} +1,{lines + 1} @@"] + [f" line {number}" for number in range(1, lines + 1)]
rows.insert(4, "+added line")
return "\n".join(rows)
@unittest.skipUnless(shutil.which(os.environ.get("CHROMIUM", "chromium")), "no Chromium")
class TestMatchReview(HubCase):
drive = base.TestOrchestratorE2E.drive
def setUp(self):
super().setUp()
work = tempfile.TemporaryDirectory()
self.addCleanup(work.cleanup)
self.work = Path(work.name)
now = time.time()
self.write_council({
"work/s1/claim.json": {"office": "work/s1", "session": "s1", "runtime": "claude", "name": "Skills", "since": iso(now - 3 * 86400 - 60), "beat": now, "work": "match"},
"work/s2/claim.json": {"office": "work/s2", "session": "s2", "runtime": "claude", "name": "Stage", "since": iso(now - 9 * 86400 - 60), "beat": now, "work": "i18n"},
})
diff = [{"path": path, "status": "M", "mode": "100644", "additions": 1, "deletions": 0, "patch": patch(lines), "note": ""} for path, lines in FILES]
self.commit = self.review("feat: match review", "/repo/.worktrees/feature/match", "feature/match", "Skills", diff)
stale_diff = [{"path": "README.md", "status": "M", "mode": "100644", "additions": 1, "deletions": 0, "patch": patch(8), "note": ""}]
self.stale = self.review("docs: stale stage", "/repo/.worktrees/feature/old", "feature/old", "Stage", stale_diff)
status, _, body = self.post_json("/api/match/stale", {"id": self.stale, "tree": "f" * 40}, self.local())
self.assertEqual(status, 200, body)
self.payload()
self.base = f"http://{self.host}/"
def review(self, title: str, worktree: str, branch: str, agent: str, diff: list[dict]) -> str:
arguments = {**self.arguments(title, "", self.page(f"{branch.replace('/', '-')}.html", "<!doctype html><title>p</title>")), "worktree": worktree, "branch": branch, "agent": agent, "diff": diff}
result = self.tool("review_request", arguments)
self.assertFalse(result["isError"], result)
return result["structuredContent"]["id"]
def payload(self) -> None:
body = self.work / "body.md"
body.write_text("".join(f"Release note line {number}\n" for number in range(1, 15)), encoding="utf-8")
(self.work / "link.md").symlink_to(body)
folder = self.state / "firewall"
folder.mkdir(parents=True, exist_ok=True)
files = [{"path": "/home/op/.claude/settings.json", "exists": True, "sha256": "", "settings": {"sandbox": {"filesystem": {"denyRead": []}}}}]
(folder / "view.json").write_text(json.dumps({"written": "2026-11-14T12:00:00+00:00", "files": files}), encoding="utf-8")
self.command = f"gh issue create --body-file {body} --list link.md"
self.write_council({"rasci.json": {"operator/issue": {"title": self.command, "workdir": str(self.work), "description": "file the release issue", "check": "done", "roles": {"Skills": "A", "Operator": "R"}}}})
def steps(self, browser: str, widths: tuple[tuple[int, int], ...]) -> list[dict]:
OUT.mkdir(parents=True, exist_ok=True)
steps = []
for width, height in widths:
shot = str(OUT / f"{browser}-{width}")
steps += [
{"width": width, "height": height, "url": f"{self.base}?{width}#tasks/match", "wait": 1500, "probe": probe(STACK), "shot": f"{shot}-stack.png"},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(SCROLL), "shot": None},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(MARK, FIRST=FILES[0][0]), "shot": f"{shot}-marked.png"},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(PICK, ID="operator:operator/issue"), "shot": f"{shot}-command.png"},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(PICK, ID=f"review:{self.stale}"), "shot": f"{shot}-stale.png"},
]
return steps
def check(self, data: dict, widths: tuple[tuple[int, int], ...]) -> None:
results = iter(data["results"])
order = [path for path, _ in FILES]
for width, _ in widths:
with self.subTest(width=width):
stack = next(results)
self.assertEqual((stack["card"], stack["kind"], stack["stale"], stack["face"]), (f"review:{self.commit}", "commit", "false", True), stack)
self.assertEqual((stack["name"], stack["age"]), ("Skills", "3 days"), stack)
self.assertEqual(stack["place"], [["Repository", "/repo"], ["Branch", "feature/match"], ["Worktree", "/repo/.worktrees/feature/match"]], stack)
self.assertEqual(stack["files"], order)
self.assertEqual(stack["peeks"], ["operator:operator/issue", f"review:{self.stale}"], stack)
self.assertFalse(stack["accept"], stack)
self.assertFalse(stack["wide"], stack)
scroll = next(results)
self.assertEqual(scroll["steps"][0], order[:1], scroll)
self.assertEqual(scroll["steps"][-1], order, scroll)
for step in scroll["steps"]:
self.assertEqual(step, order[: len(step)], scroll)
self.assertGreater(len({len(step) for step in scroll["steps"]}), 2, scroll)
self.assertEqual(scroll["numbered"], [[path, True] for path in order], scroll)
mark = next(results)
self.assertEqual((mark["clicked"], mark["pressed"]), (True, True), mark)
self.assertEqual(mark["marks"], [["3", "use the helper here"], ["6", "long press note"]], mark)
self.assertEqual(mark["marked"], ["3", "6"], mark)
self.assertEqual(mark["count"], "2", mark)
command = next(results)
self.assertEqual((command["kind"], command["stale"], command["command"], command["why"]), ("command", "false", self.command, "file the release issue"), command)
self.assertEqual(command["where"], str(self.work), command)
self.assertEqual(command["payload"], [["body.md", "read", 14], ["link.md", "refused", 0]], command)
self.assertEqual((command["name"], command["age"]), ("Skills", "3 days"), command)
stale = next(results)
self.assertEqual((stale["kind"], stale["stale"], stale["accept"], stale["name"], stale["age"]), ("commit", "true", True, "Stage", "9 days"), stale)
self.assertIn("changed", stale["reason"])
def test_chromium_shows_face_place_files_on_scroll_and_marks_at_three_widths(self):
data = self.drive(self.steps("chromium", base.WIDTHS), None)
(OUT / "chromium-match.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
self.assertEqual(data["errors"], [])
self.check(data, base.WIDTHS)
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
def test_firefox_shows_face_place_files_on_scroll_and_marks_at_three_widths(self):
data = self.drive(self.steps("firefox", base.WIDTHS), None, "bidi.mjs", os.environ.get("FIREFOX", "firefox"))
(OUT / "firefox-match.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
self.assertEqual([error for error in data["errors"] if "/favicon.ico" not in error], [])
self.check(data, base.WIDTHS)
if __name__ == "__main__":
unittest.main()
+208
View File
@@ -0,0 +1,208 @@
from __future__ import annotations
import json
import os
import subprocess
import sys
import tempfile
import unittest
from pathlib import Path
from hub_case import HubCase
from hub_support import GIT_ENV, HUB, REPO_ROOT
from kvb_orchestrator import payloads
MATCH = REPO_ROOT / "skills" / "kvb-match" / "scripts" / "match.py"
CLIENT = HUB / "client"
def git(cwd: Path, *args: str) -> str:
done = subprocess.run(["git", *args], cwd=cwd, env={**os.environ, **GIT_ENV}, check=True, capture_output=True, text=True)
return done.stdout
def staged_repo(root: Path) -> Path:
repo = root / "demo"
repo.mkdir()
git(repo, "init", "-q", "-b", "feature/match")
(repo / "app.py").write_text("keep = 1\nold = 2\n", encoding="utf-8")
git(repo, "add", "-A")
git(repo, "commit", "-q", "-m", "base")
(repo / "app.py").write_text("keep = 1\nnew = 3\nmore = 4\n", encoding="utf-8")
(repo / "notes.md").write_text("# Notes\n\nfresh\n", encoding="utf-8")
git(repo, "add", "-A")
return repo
class MatchCase(HubCase):
def setUp(self):
super().setUp()
work = tempfile.TemporaryDirectory()
self.addCleanup(work.cleanup)
self.work = Path(work.name)
self.sandbox_view([])
def sandbox_view(self, denied: list[str]) -> None:
folder = self.state / "firewall"
folder.mkdir(parents=True, exist_ok=True)
settings = {"sandbox": {"filesystem": {"denyRead": denied}}}
files = [{"path": "/home/op/.claude/settings.json", "exists": True, "sha256": "", "settings": settings}]
(folder / "view.json").write_text(json.dumps({"written": "2026-11-14T12:00:00+00:00", "files": files}), encoding="utf-8")
def match(self, cwd: Path, *args: str) -> subprocess.CompletedProcess:
command = [sys.executable, str(MATCH), *args, "--port", str(self.port), "--client", str(CLIENT)]
return subprocess.run(command, cwd=cwd, env={**os.environ, **GIT_ENV}, capture_output=True, text=True, timeout=60, check=False)
def add(self, repo: Path) -> str:
done = self.match(repo, "add", "--repo", str(repo), "--title", "feat: match", "--score", "🎯 95 💥 3", "--gate", "pass", "--agent", "Skills", "--pages", str(self.pages))
self.assertEqual(done.returncode, 0, done.stderr)
return json.loads(done.stdout)["id"]
def cards(self) -> list[dict]:
status, _, body = self.get("/api/match")
self.assertEqual(status, 200, body)
return json.loads(body)["cards"]
def card(self, card_id: str) -> dict:
return next(card for card in self.cards() if card["id"] == card_id)
def operator_row(self, task: str, command: str, directory: str) -> None:
register = {task: {"title": command, "workdir": directory, "description": "ship the release notes", "check": "done", "roles": {"Skills": "A", "Operator": "R"}}}
self.write_council({"rasci.json": register})
class TestMatchSkill(MatchCase):
def test_add_takes_the_staged_patch_and_tree_and_list_and_show_print_them(self):
repo = staged_repo(self.work)
review = self.add(repo)
card = self.card(f"review:{review}")
self.assertEqual((card["kind"], card["hash"], card["stale"]), ("commit", git(repo, "write-tree").strip(), False))
self.assertEqual((card["branch"], card["worktree"], card["agent"], card["title"]), ("feature/match", str(repo), "Skills", "feat: match"))
self.assertEqual([entry["path"] for entry in card["files"]], ["app.py", "notes.md"])
shown = self.match(repo, "show", f"review:{review}")
self.assertEqual(shown.returncode, 0, shown.stderr)
self.assertEqual(shown.stdout, git(repo, "diff", "--cached"))
listed = self.match(repo, "list")
self.assertEqual(listed.returncode, 0, listed.stderr)
self.assertIn(f"review:{review}", listed.stdout)
self.assertIn("feat: match", listed.stdout)
def test_add_refuses_an_empty_stage(self):
repo = staged_repo(self.work)
git(repo, "commit", "-q", "-m", "all")
done = self.match(repo, "add", "--repo", str(repo), "--title", "feat: none", "--score", "🎯 1", "--gate", "pass", "--agent", "Skills", "--pages", str(self.pages))
self.assertEqual(done.returncode, 1)
self.assertIn("nothing staged", done.stderr)
self.assertEqual(self.cards(), [])
def test_a_changed_stage_turns_the_card_stale_and_adding_it_again_gives_a_fresh_card(self):
repo = staged_repo(self.work)
first = self.add(repo)
(repo / "notes.md").write_text("# Notes\n\nchanged\n", encoding="utf-8")
git(repo, "add", "-A")
listed = self.match(repo, "list")
self.assertEqual(listed.returncode, 0, listed.stderr)
self.assertIn("stale", listed.stdout)
old = self.card(f"review:{first}")
self.assertTrue(old["stale"], old)
self.assertIn("changed", old["stale_reason"])
second = self.add(repo)
fresh = self.card(f"review:{second}")
self.assertEqual((fresh["stale"], fresh["hash"]), (False, git(repo, "write-tree").strip()))
self.assertTrue(self.card(f"review:{first}")["stale"])
def test_a_stale_report_needs_the_local_guard_and_a_tree(self):
repo = staged_repo(self.work)
review = self.add(repo)
status, _, _ = self.post_json("/api/match/stale", {"id": review, "tree": "f" * 40}, {"Host": self.host})
self.assertEqual(status, 403)
status, _, _ = self.post_json("/api/match/stale", {"id": review, "tree": "nope"}, self.local())
self.assertEqual(status, 400)
self.assertFalse(self.card(f"review:{review}")["stale"])
def test_a_gone_review_or_operator_row_leaves_the_cards(self):
repo = staged_repo(self.work)
review = self.add(repo)
self.operator_row("operator/ship", "make ship", str(self.work))
self.assertEqual(sorted(card["id"] for card in self.cards()), sorted([f"review:{review}", "operator:operator/ship"]))
status, _, body = self.post_json(f"/reviews/{review}/reject", {}, self.guard(self.host))
self.assertEqual(status, 200, body)
self.write_council({"rasci.json": {}})
self.assertEqual(self.cards(), [])
class TestCommandCards(MatchCase):
def payload_command(self) -> str:
body = self.work / "body.md"
body.write_text("# Release\n\nline two\n", encoding="utf-8")
(self.work / "link.md").symlink_to(body)
(self.work / "big.txt").write_text("x" * (payloads.PAYLOAD_LIMIT + 1), encoding="utf-8")
(self.work / "secret.txt").write_text("hidden\n", encoding="utf-8")
return f"gh issue create --body-file {body} --list link.md --big=big.txt --key {self.work / 'secret.txt'} --base origin/main"
def test_an_operator_row_is_a_card_with_command_directory_reason_and_payload_files(self):
self.sandbox_view([str(self.work / "secret.txt")])
command = self.payload_command()
self.operator_row("operator/ship", command, str(self.work))
card = self.card("operator:operator/ship")
self.assertEqual((card["kind"], card["command"], card["directory"], card["reason"], card["agent"], card["stale"]), ("command", command, str(self.work), "ship the release notes", "Skills", False))
files = {Path(entry["path"]).name: entry for entry in card["files"]}
self.assertEqual(sorted(files), ["big.txt", "body.md", "link.md", "secret.txt"])
self.assertEqual((files["body.md"]["state"], files["body.md"]["content"]), ("read", "# Release\n\nline two\n"))
for name, words in (("link.md", "symlink"), ("big.txt", "bytes"), ("secret.txt", "sandbox")):
with self.subTest(name=name):
self.assertEqual((files[name]["state"], files[name]["content"]), ("refused", ""))
self.assertIn(words, files[name]["reason"])
def test_without_a_sandbox_view_every_payload_file_is_refused(self):
(self.state / "firewall" / "view.json").unlink()
command = self.payload_command()
self.operator_row("operator/ship", command, str(self.work))
states = {entry["state"] for entry in self.card("operator:operator/ship")["files"]}
self.assertEqual(states, {"refused"})
def test_a_changed_payload_file_turns_the_card_stale_until_it_is_added_again(self):
command = self.payload_command()
self.operator_row("operator/ship", command, str(self.work))
before = self.card("operator:operator/ship")
(self.work / "body.md").write_text("# Release\n\nswapped\n", encoding="utf-8")
after = self.card("operator:operator/ship")
self.assertTrue(after["stale"], after)
self.assertEqual(after["files"], before["files"])
self.assertNotEqual(after["live_hash"], after["hash"])
done = self.match(self.work, "add", "--task", "operator/ship")
self.assertEqual(done.returncode, 0, done.stderr)
fresh = self.card("operator:operator/ship")
self.assertFalse(fresh["stale"], fresh)
self.assertIn("swapped", next(entry["content"] for entry in fresh["files"] if entry["path"].endswith("body.md")))
def test_decision_rows_and_rows_at_the_runner_are_no_cards(self):
self.write_council({"rasci.json": {"operator/pick": {"title": "-", "workdir": str(self.work), "check": "decision", "roles": {"Operator": "R"}}}})
self.assertEqual(self.cards(), [])
def test_show_prints_the_command_and_its_payload(self):
command = self.payload_command()
self.operator_row("operator/ship", command, str(self.work))
shown = self.match(self.work, "show", "operator:operator/ship")
self.assertEqual(shown.returncode, 0, shown.stderr)
for words in (command, f"in {self.work}", "line two", "refused"):
with self.subTest(words=words):
self.assertIn(words, shown.stdout)
class TestPayloadHash(unittest.TestCase):
def test_the_hash_binds_command_directory_and_every_file_state(self):
files = [{"path": "/tmp/a", "state": "read", "reason": "", "sha256": "1" * 64, "size": 3, "content": "abc"}]
base = payloads.payload_hash("make ship", "/repo", files)
self.assertEqual(base, payloads.payload_hash("make ship", "/repo", [dict(files[0])]))
self.assertRegex(base, "^[0-9a-f]{64}$")
for changed in (payloads.payload_hash("make ship ", "/repo", files), payloads.payload_hash("make ship", "/other", files), payloads.payload_hash("make ship", "/repo", [{**files[0], "sha256": "2" * 64}]), payloads.payload_hash("make ship", "/repo", [{**files[0], "state": "refused"}])):
self.assertNotEqual(changed, base)
def test_named_paths_come_from_words_and_option_values_resolved_in_the_directory(self):
named = payloads.named_paths("gh issue create --body-file /tmp/x/body.md --list=list.txt scripts/run.sh 'quoted file.md' https://example.org/a.md", "/repo")
self.assertEqual(named, ["/tmp/x/body.md", "/repo/list.txt", "/repo/scripts/run.sh", "/repo/quoted file.md"])
if __name__ == "__main__":
unittest.main()
+1
View File
@@ -16,6 +16,7 @@ UNCATEGORIZED = frozenset(
"kvb-coach", "kvb-coach",
"kvb-dream", "kvb-dream",
"kvb-help", "kvb-help",
"kvb-match",
"kvb-optimize", "kvb-optimize",
"kvb-release", "kvb-release",
"kvb-transcend", "kvb-transcend",