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/orbits.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import bisect
+import functools
+import itertools
+import math
+from collections.abc import Callable
+
+from .council import agent
+from .names import Directory
+from .register import ENDED, parties, status_of
+
+HALF_LIFE = 1800.0
+INNER = 150.0
+OUTER = 300.0
+TRACK_STEPS = 12
+
+
+def pair_weight(weights: dict[tuple[str, str], float], first: str, second: str) -> float:
+    return weights.get((min(first, second), max(first, second)), 0.0)
+
+
+def chain(names: list[str], weights: dict[tuple[str, str], float], activity: dict[str, float]) -> list[str]:
+    left = sorted(names, key=lambda name: (name.lower(), name))
+    if not left:
+        return []
+    current = max(left, key=lambda name: activity[name])
+    order = [current]
+    left.remove(current)
+    while left:
+        last = current
+        current = max(left, key=lambda name: (pair_weight(weights, last, name), activity[name]))
+        order.append(current)
+        left.remove(current)
+    return order
+
+
+def affinity(nodes: list[dict], radio: list[dict], tasks: dict[str, dict], claims: list[dict], end: float, key_of: Callable[[str], str]) -> dict:
+    """Args:
+        nodes: graph nodes keyed by session; chair and session nodes take part.
+        radio: rows with ts, source and targets as node keys.
+        tasks: register rows; workers and role holders are names.
+        claims: claims; their session is a node key.
+        end: the moment the decay counts back from.
+        key_of: maps a name to its node key.
+
+    Returns:
+        orbit: {key: {angle, radius}}, closer and inner for agents that talk
+            or work together recently; order: the keys around the circle.
+    """
+    names = [node["id"] for node in nodes if node["kind"] in ("chair", "session")]
+    activity = dict.fromkeys(names, 0.0)
+    weights: dict[tuple[str, str], float] = {}
+
+    def link(first: str, second: str, amount: float) -> None:
+        if first != second and first in activity and second in activity:
+            pair = (min(first, second), max(first, second))
+            weights[pair] = weights.get(pair, 0.0) + amount
+            activity[first] += amount
+            activity[second] += amount
+
+    for row in radio:
+        fade = 0.5 ** (max(end - row["ts"], 0.0) / HALF_LIFE)
+        if row["source"] in activity and not row["targets"]:
+            activity[row["source"]] += fade
+        for target in row["targets"]:
+            link(row["source"], target, fade)
+    places: dict[str, set[str]] = {}
+    for task, row in sorted(tasks.items()):
+        if status_of(row) in ENDED:
+            continue
+        members = {key_of(agent(row.get("worker"))), *map(key_of, parties(row))} | {claim["session"] for claim in claims if claim["office"] == task}
+        members.discard("")
+        for first, second in itertools.combinations(sorted(members), 2):
+            link(first, second, 1.0)
+        for place in (row.get("workdir"), row.get("branch")):
+            if isinstance(place, str) and place.strip():
+                places.setdefault(place.strip(), set()).update(members)
+    for members in places.values():
+        for first, second in itertools.combinations(sorted(members), 2):
+            link(first, second, 1.0)
+    for node in nodes:
+        if node["kind"] == "subagent" and node["parent"] in activity:
+            activity[node["parent"]] += 1.0
+    order = chain(names, weights, activity)
+    gaps = [1.0 / (1.0 + pair_weight(weights, first, second)) for first, second in zip(order, order[1:] + order[:1], strict=True)]
+    total = sum(gaps) or 1.0
+    top = max(activity.values(), default=0.0)
+    angle = -math.pi / 2
+    orbit = {}
+    for name, gap in zip(order, gaps, strict=True):
+        share = activity[name] / top if top > 0 else 0.0
+        orbit[name] = {"angle": round(angle, 4), "radius": round(OUTER - (OUTER - INNER) * share, 2)}
+        angle += 2 * math.pi * gap / total
+    return {"orbit": orbit, "order": order}
+
+
+def track(nodes: list[dict], radio: list[dict], tasks: dict[str, dict], claims: list[dict], span: tuple[float, float], directory: Directory, steps: int) -> list[dict]:
+    """Args:
+        nodes: graph nodes as affinity takes them.
+        radio: rows with ts, source and targets as node keys, sorted by ts.
+        tasks: register rows.
+        claims: claims.
+        span: the first and the last moment to sample.
+        directory: resolves a name to its node key at a moment.
+        steps: the intervals between the samples; 0 samples nothing.
+
+    Returns:
+        steps + 1 samples {ts, orbit}, evenly spaced over span, each orbit the
+        affinity layout of the radio heard up to its moment.
+    """
+    if steps <= 0:
+        return []
+    start, end = span
+    stamps = [row["ts"] for row in radio]
+    samples = []
+    for moment in [start + (end - start) * index / steps for index in range(steps)] + [end]:
+        heard = radio[: bisect.bisect_right(stamps, moment)]
+        layout = affinity(nodes, heard, tasks, claims, moment, functools.partial(directory.key, ts=moment))
+        samples.append({"ts": moment, "orbit": layout["orbit"]})
+    return samples