feat(orchestrator): rename kvb-hub to Agent Orchestrator with the phase 2 surface

Surface (requirement 001 phase 2): navigation Stream (Inbox, Regeln) / Agents / Artifacts with keys 1-3 and hash routes (#graph and #tree redirect), header with title, command palette and settings only, server-side badges (unsnoozed inbox, beats within 900 s, open jobs), a Mayday banner with "aufheben", four stream chips with agent:/art:/seit: search, Filter and time menus, the inbox in main, an agents toolbar (Funk an alle with Newsletter, Broadcast, Pan-Pan, Security, Mayday; Priorität; Tag/Nacht), Post or Call in the agent panel, Ambiente in the settings and read-aloud over the seven classes with Mayday locked.

Rename (decision 9): hub/ is orchestrator/, the package kvb_orchestrator, the unit kvb-orchestrator-runner.service, scripts/orchestrator.sh, environment KVB_ORCHESTRATOR_*, make targets orchestrator-*, the MCP server, image and compose project kvb-orchestrator, the guard header X-Kvb-Orchestrator and the message marker [kvb-orchestrator msg <id>]. install runs migrate first: it stops the old container, removes its image and code, moves state, approvals and pinned keys, swaps the MCP registration, the PermissionRequest hook and the runner unit, and changes nothing on a second run (scratch-HOME test with stub docker, claude and systemctl). Saved views fall back to the old localStorage key once.

MEDUSA acceptances carried to the renamed paths: 82 rows whose lines are unchanged (reason prefixed "renamed from <old path>, line unchanged"), and 7 rows whose text changed only in the product name, the package name, a temp prefix or a new class argument, each upheld by one kvb-think-criticize skeptic (approval.py:60, messaging.py:53, server.py:56, tests/hub_support.py:64, passkey.py:205, page-agent.js:75, language.py:46).

Cost 101 %: the longer name adds 15 tokens of skill text; the operator approved it with the commit.

🎯 Fix: 92 %
💥 Break: 4 %
💸 Cost: 101 %
⏱️ Time: –
🛡️ Security: 100 %
💰 Value: ?
🏆 Score: 87
🚦 Gate: ⚠️ cost 101 % > 100: ask the operator before the commit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

orchestrator/client/approval.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""Args:
+    pin --port <port> --approvers <file> --credential <blob>: pins the passkey
+        that the Agent Orchestrator settings panel registered (the blob it shows) in
+        <file>, written with mode 0600. Run it on the host, outside every
+        sandbox, e.g. --approvers ~/.config/kvb-orchestrator/approvers.json.
+    verify --port <port> --approvers <file> --replay <file> --review <id>
+        --gate <pass|fail>: run in the worktree right before the commit;
+        fetches the review's signature from the Agent Orchestrator on 127.0.0.1:<port>
+        and checks it against the repository, worktree, branch and the tree
+        git write-tree prints, as this process sees them.
+
+Returns:
+    pin: exit code 0 and the pinned credential on stdout; 1 and the reason
+        on stderr when the blob is no valid registration.
+    verify: exit code 0 when a pinned key signed this exact commit; 1 and
+        the reason on stderr otherwise. Commit only on 0.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+import time
+import urllib.request
+from pathlib import Path
+
+from hub_api import GUARD, SLACK, base_url, load
+from passkey import attested, b64decode
+from signing import ALGORITHMS, ID, Refused, origin_of, review_item
+from verifier import Trust, check, pin
+
+GIT_TIMEOUT = 30
+
+
+def git(cwd: Path, args: list[str]) -> str:
+    try:
+        done = subprocess.run(["git", *args], cwd=cwd, capture_output=True, text=True, timeout=GIT_TIMEOUT, check=False)
+    except (OSError, subprocess.TimeoutExpired) as error:
+        raise Refused(f"git {args[0]} did not run: {error}") from error
+    if done.returncode != 0:
+        raise Refused(f"git {' '.join(args)} failed: {done.stderr.strip()}")
+    return done.stdout.strip()
+
+
+def staged(cwd: Path, review_id: str) -> dict:
+    repo = git(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"])
+    worktree = git(cwd, ["rev-parse", "--show-toplevel"])
+    branch = git(cwd, ["symbolic-ref", "--short", "HEAD"])
+    return review_item(review_id, repo, worktree, branch, git(cwd, ["write-tree"]))
+
+
+def fetch(port: int, path: str) -> dict:
+    request = urllib.request.Request(f"{base_url(port)}{path}", headers=GUARD)
+    try:
+        data = load(request, SLACK)
+    except (OSError, ValueError) as error:
+        raise Refused(f"the Agent Orchestrator did not answer: {error}") from error
+    if not isinstance(data, dict):
+        raise Refused("the Agent Orchestrator answered no object")
+    return data
+
+
+def verify_commit(args: argparse.Namespace) -> str:
+    review = fetch(args.port, f"/api/reviews/{args.review}")
+    if review.get("status") != "approved":
+        raise Refused(f"the review is {review.get('status')}, not approved")
+    item = staged(Path.cwd(), args.review)
+    check(review.get("proof"), item, args.gate, Trust(approvers=args.approvers, replay=args.replay, origin=origin_of(args.port)), time.time())
+    return f"verified: the operator signed review {args.review}, tree {item['tree']} on {item['branch']} in {item['worktree']}"
+
+
+def pin_credential(args: argparse.Namespace) -> str:
+    try:
+        credential = json.loads(b64decode(args.credential, "credential"))
+    except (ValueError, RecursionError) as error:
+        raise Refused("the credential blob is no JSON") from error
+    entry = attested(credential, origin_of(args.port))
+    entries = pin(args.approvers, entry, time.time())
+    return f"pinned {entry['id']} ({ALGORITHMS[entry['alg']]}) in {args.approvers}; {len(entries)} key(s) pinned"
+
+
+def review_id(text: str) -> str:
+    if not ID.fullmatch(text):
+        raise argparse.ArgumentTypeError("a review id is 16 hex digits")
+    return text
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(prog="approval")
+    commands = parser.add_subparsers(dest="command", required=True)
+    pinning = commands.add_parser("pin")
+    verifying = commands.add_parser("verify")
+    for sub in (pinning, verifying):
+        sub.add_argument("--port", type=int, required=True)
+        sub.add_argument("--approvers", type=Path, required=True)
+    pinning.add_argument("--credential", required=True)
+    verifying.add_argument("--replay", type=Path, required=True)
+    verifying.add_argument("--review", type=review_id, required=True)
+    verifying.add_argument("--gate", choices=("pass", "fail"), required=True)
+    args = parser.parse_args()
+    try:
+        print(pin_credential(args) if args.command == "pin" else verify_commit(args))
+    except (Refused, OSError) as error:
+        print(f"refused: {error}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())