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/kvb_orchestrator/graph.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from collections import Counter
+
+from .council import HUMAN, agent, ordered, subagent
+from .names import Directory
+from .orbits import affinity
+from .records import shown
+from .register import ENDED, parties, status_of
+
+CHAIR = "Maintainer"
+
+
+def parent_of(roles: dict[str, str], known: set[str], fallback: str) -> str:
+    for letter in "AR":
+        names = sorted(name for name, letters in roles.items() if letter in letters and name in known)
+        if names:
+            return names[0]
+    return fallback
+
+
+def duties(name: str, task: str, row: dict, holders: dict[str, dict[str, dict]]) -> dict:
+    entry = {"task": task, "title": shown(row.get("title")), "status": status_of(row), "worker": False, "letters": ""}
+    return holders.setdefault(name, {}).setdefault(task, entry)
+
+
+def edges(radio: list[dict], grant_rows: list[dict], chair: str) -> list[dict]:
+    counts: Counter[tuple[str, str, str]] = Counter()
+    for row in (row for row in radio if row["source"]):
+        for target in row["targets"] or ["*"]:
+            counts[(row["source"], target, row["class"])] += 1
+    for grant in grant_rows:
+        counts[(chair, grant["target"], "grant")] += 1
+    return [{"source": s, "target": t, "class": c, "count": n} for (s, t, c), n in sorted(counts.items())]
+
+
+def graph(radio: list[dict], grant_rows: list[dict], tasks: dict[str, dict], claims: list[dict], end: float, directory: Directory) -> dict:
+    current = {task: row for task, row in sorted(tasks.items()) if status_of(row) not in ENDED}
+    chair = directory.key(CHAIR, end)
+    workers = {task: agent(row.get("worker")) for task, row in current.items()}
+    keys = {row["source"] for row in radio} | {key for row in radio for key in row["targets"]}
+    keys |= {claim["session"] for claim in claims if claim["agent"] and claim["session"] != "-"}
+    keys |= {directory.key(name, end) for name in workers.values() if not subagent(name)}
+    found = sorted(keys - {"", HUMAN, chair}, key=lambda key: (directory.label(key, end).lower(), key))
+    known = {chair, *found}
+    moons: dict[str, tuple[str, str]] = {}
+    holders: dict[str, dict[str, dict]] = {}
+    for task, row in current.items():
+        roles: dict[str, str] = {}
+        for name, letters in parties(row).items():
+            key = directory.key(name, end)
+            roles[key] = roles.get(key, "") + letters
+        worker = workers[task]
+        holder = directory.key(worker, end)
+        if subagent(worker):
+            parent = parent_of(roles, known, chair)
+            holder = f"{worker} @ {parent}"
+            moons[holder] = (parent, worker)
+        if holder:
+            duties(holder, task, row, holders)["worker"] = True
+        for key, letters in roles.items():
+            duties(key, task, row, holders)["letters"] += letters
+    plan = [(HUMAN, "operator", None, HUMAN), (chair, "chair", None, directory.label(chair, end))]
+    plan += [(key, "session", None, directory.label(key, end)) for key in found]
+    plan += [(moon, "subagent", *moons[moon]) for moon in ordered(set(moons))]
+    nodes = [
+        {
+            "id": key,
+            "kind": node_kind,
+            "parent": parent,
+            "label": label,
+            "names": directory.names(key) or [label],
+            "timeline": directory.timeline(key) or [{"name": label, "since": end}],
+            "tasks": list(holders.get(key, {}).values()),
+            "claims": [claim for claim in claims if claim["session"] == key],
+        }
+        for key, node_kind, parent, label in plan
+    ]
+    layout = affinity(nodes, radio, tasks, claims, end, lambda name: directory.key(name, end))
+    return {"nodes": nodes, "edges": edges(radio, grant_rows, chair), "layout": layout}