trantor 0.17.0 → 0.17.3

package/.claude-plugin/marketplace.json

@@ -1,19 +1,38 @@
 {
   "name": "trantor",
-  "owner": { "name": "Sasha Bogojevic", "email": "hello@hivedigitalllc.com" },
+  "owner": {
+    "name": "Sasha Bogojevic",
+    "email": "hello@hivedigitalllc.com"
+  },
   "metadata": {
     "description": "Trantor — the hub-world for AI agent crews: live message bus, presence, project Kanban/flow board + context-handoff for independent AI coding agents (Claude, Codex, Gemini, …)",
-    "version": "0.17.0"
+    "version": "0.17.3"
   },
   "plugins": [
     {
       "name": "trantor",
       "source": "./",
       "description": "The hub-world for AI agent crews. Say \"fire up the crew\" and Claude becomes the architect: a plan-aware Advisor routes the work (solo / cheap inline calls / live crew of Codex, Gemini, Kimi & DeepSeek in their own terminal windows), a Kanban/flow command center with a testing gate tracks it, and an economics brain (Scrooge) keeps the receipts. Includes the relay MCP, a SessionStart auto-discovery hook, and a PreCompact context-handoff so a fresh session can take over a full window instead of compacting.",
-      "version": "0.17.0",
-      "author": { "name": "Sasha Bogojevic" },
+      "version": "0.17.3",
+      "author": {
+        "name": "Sasha Bogojevic"
+      },
       "category": "development",
-      "keywords": ["multi-agent", "agent-crew", "orchestration", "coordination", "mcp", "hooks", "kanban", "context-handoff", "message-bus", "claude-code", "codex", "gemini", "llm-routing"]
+      "keywords": [
+        "multi-agent",
+        "agent-crew",
+        "orchestration",
+        "coordination",
+        "mcp",
+        "hooks",
+        "kanban",
+        "context-handoff",
+        "message-bus",
+        "claude-code",
+        "codex",
+        "gemini",
+        "llm-routing"
+      ]
     }
   ]
 }

package/.claude-plugin/plugin.json

@@ -1,11 +1,13 @@
 {
   "name": "trantor",
-  "version": "0.17.0",
+  "version": "0.17.3",
   "description": "Trantor — the hub-world for AI agent crews: live message bus, presence, project Kanban/flow board + crew orchestration for independent AI coding agents (Claude, Codex, Gemini, Kimi, DeepSeek)",
   "mcpServers": {
     "relay": {
       "command": "node",
-      "args": ["${CLAUDE_PLUGIN_ROOT}/mcp.mjs"]
+      "args": [
+        "${CLAUDE_PLUGIN_ROOT}/mcp.mjs"
+      ]
     }
   },
   "skills": "./skills/"

package/bin/advise.mjs

@@ -122,7 +122,10 @@ export function advise(input, world = loadWorld()) {
   const cards = routing.map((r, i) => ({
     order: i + 1, title: r.title, difficulty: r.difficulty,
     assignee: r.executor === "scrooge" || r.executor === "orchestrator" ? undefined : `${r.executor}:<project>`,
-    model: r.model || (["scrooge", "orchestrator"].includes(r.executor) ? undefined : `${r.executor}-default`),
+    // "auto" = resolve a LIVE model at spawn (the orchestrator runs `trantor up <agent>:<provider>
+    // --task --difficulty`, which picks the best live model). Was `<cli>-default` — a stale default.
+    model: r.model || (["scrooge", "orchestrator"].includes(r.executor) ? undefined : "auto"),
+    task: ["scrooge", "orchestrator"].includes(r.executor) ? undefined : r.kind,
     via: r.executor === "scrooge" ? "relay_scrooge" : "relay_task_add",
     deps_orders: r.executor === "orchestrator" && /integrat/i.test(r.title)
       ? routing.map((x, j) => j + 1).filter(j => j !== i + 1)

package/bin/cli.mjs

@@ -22,6 +22,7 @@ switch (cmd) {
   case "verify":  run("bin/crew-verify.mjs"); break;
   case "up":      process.argv.splice(2, 1); spawn("/bin/bash", [join(ROOT, "bin/crew.sh"), "up", ...args], { stdio: "inherit", cwd: process.cwd() }).on("exit", c => process.exit(c ?? 0)); break;
   case "down":    spawn("/bin/bash", [join(ROOT, "bin/crew.sh"), "down"], { stdio: "inherit", cwd: process.cwd() }).on("exit", c => process.exit(c ?? 0)); break;
+  case "swap":    spawn("/bin/bash", [join(ROOT, "bin/crew.sh"), "swap", ...args], { stdio: "inherit", cwd: process.cwd() }).on("exit", c => process.exit(c ?? 0)); break;
   case "hub":     run("hub.mjs"); break;
   case "watch":   run("bin/relay-watch.mjs"); break;
   case "ui": {

package/bin/crew-runner.mjs

@@ -48,8 +48,11 @@ async function api(path, body) {
 // ---- per-CLI invocation (first turn vs resume turn). {P} = prompt file path ----
 // CREW_MODEL env pins the model: each CLI gets its own flag via {M} (empty when unset).
 let MODEL = process.env.CREW_MODEL || "";
-// opencode expects provider/model — qualify bare ids for the deepseek/opencode agents
-if (MODEL && !MODEL.includes("/") && (AGENT === "deepseek" || AGENT === "opencode")) MODEL = `deepseek/${MODEL}`;
+// opencode expects provider/model. A BARE id for the `deepseek` agent qualifies to its
+// own provider; `opencode` ids must already be provider-qualified (e.g.
+// `zai-coding-plan/glm-5.1`) — never assume `deepseek/` for opencode (that mangled
+// ZAI-coding-plan models into deepseek/…). `scrooge route` returns qualified ids.
+if (MODEL && !MODEL.includes("/") && AGENT === "deepseek") MODEL = `deepseek/${MODEL}`;
 const CLI = {
   codex:    { first: `codex exec{M} --skip-git-repo-check --dangerously-bypass-approvals-and-sandbox "$(cat {P})" < /dev/null`,
               next:  `codex exec resume --last{M} --skip-git-repo-check --dangerously-bypass-approvals-and-sandbox "$(cat {P})" < /dev/null`, mflag: " -m " },
@@ -69,6 +72,46 @@ if (!cli) { console.error(`unknown agent '${AGENT}' (known: ${Object.keys(CLI).j
 
 const RULES = `Rules: you are ${SESSION} on the trantor crew. Work your assigned file(s), report on the bus (relay_send, <280 chars), move your Kanban card as you go (doing -> testing -> done; run the tests in 'testing', use 'failed' + a report if they break). When your work for THIS message is finished, END YOUR TURN — do NOT park, do NOT loop relay_wait; the runner waits for you and will wake you with the next message.`;
 
+// ---- failure visibility ----------------------------------------------------
+// A turn's CLI can fail (credits exhausted, auth, crash) and the runner would just
+// re-park — staying green on the bus, telling the orchestrator NOTHING. These surface
+// every non-zero turn to the bus in real time so the orchestrator (and `trantor swap`)
+// can react, and flip presence to errored/down.
+let consecFails = 0;
+let lastErrText = "";
+const ERRF = join(homedir(), ".agent-bus", `err-${AGENT}-${PROJ}.txt`);
+
+function classifyFailure(exit, errText) {
+  const t = (errText || "").toLowerCase();
+  if (exit === 127) return "missing-cli";
+  if (/quota|insufficient|credit|balance|payment required|402|429|too many requests|rate.?limit|exceeded your|out of (credit|quota)/.test(t)) return "exhausted";
+  if (/unauthor|401|invalid[ _-]?api[ _-]?key|forbidden|403|token expired|expired/.test(t)) return "auth";
+  return "crashed";
+}
+
+async function reportFailure(exit, trigger) {
+  consecFails++;
+  const reason = classifyFailure(exit, lastErrText);
+  const down = consecFails >= 2;
+  const status = down ? `down: ${reason} · ${consecFails} fails` : `errored: ${reason}`;
+  await api("/register", { session: SESSION, project: PROJ, status }).catch(() => {});
+  const hint = reason === "exhausted" ? " — needs `trantor swap`"
+    : reason === "auth" ? " — check credentials"
+    : reason === "missing-cli" ? " — CLI not on PATH" : "";
+  const text = down
+    ? `🛑 ${SESSION} DOWN — ${consecFails} consecutive failures (${reason}, exit ${exit})${hint}`
+    : `⚠️ ${SESSION} turn FAILED (${trigger}, exit ${exit} · ${reason})${hint}`;
+  await api("/send", { from: SESSION, to: "all", text, project: PROJ }).catch(() => {});
+  log(`\x1b[31mreported failure to bus: ${reason} (exit ${exit})\x1b[0m`);
+}
+
+async function reportHealthy() {
+  if (consecFails === 0) return;        // already healthy — don't spam
+  consecFails = 0;
+  await api("/register", { session: SESSION, project: PROJ, status: `active in ${PROJ}` }).catch(() => {});
+  await api("/send", { from: SESSION, to: "all", text: `✅ ${SESSION} recovered`, project: PROJ }).catch(() => {});
+}
+
 let sid = "";
 function runTurn(prompt, isFirst, trigger = "kickoff") {
   TURN++; banner(trigger);
@@ -82,12 +125,16 @@ function runTurn(prompt, isFirst, trigger = "kickoff") {
   const envs = [join(homedir(), ".agent-bus", ".env"), cli.env].filter(f => f && existsSync(f));
   for (const f of envs.reverse()) cmd = `set -a; source ${f}; set +a; ${cmd}`;   // ~/.agent-bus/.env wins
   log(`turn starting (${isFirst ? "fresh session" : "resume"})${MODEL ? ` · model=${MODEL}` : ""}`);
-  // inherit stdio so the window shows the agent working live; also capture for sid-parsing
-  const r = spawnSync("/bin/bash", ["-c", cli.sid ? `${cmd} | tee /dev/stderr` : cmd], {
+  // inherit stdio so the window shows the agent working live; also capture for sid-parsing.
+  // Tee stderr to ERRF (still shown live in the window) so a failed turn can be classified.
+  try { appendFileSync(ERRF, "", { flag: "w" }); } catch {}
+  const inner = cli.sid ? `${cmd} | tee /dev/stderr` : cmd;
+  const r = spawnSync("/bin/bash", ["-c", `{ ${inner} ; } 2> >(tee -a ${ERRF} >&2)`], {
     cwd: DIR, encoding: "utf8", stdio: cli.sid ? ["ignore", "pipe", "inherit"] : "inherit",
     env: { ...process.env, RELAY_URL: HUB, RELAY_AGENT: AGENT, RELAY_PROJECT: PROJ },
     maxBuffer: 16 * 1024 * 1024,
   });
+  try { lastErrText = readFileSync(ERRF, "utf8").slice(-4000); } catch { lastErrText = ""; }
   if (cli.sid && r.stdout) { const m = r.stdout.match(cli.sid); if (m) sid = m[1]; }
   telemetry({ ts: Date.now(), agent: AGENT, project: PROJ, turn: TURN, trigger, model: MODEL || "default", duration_ms: Date.now() - t0, exit: r.status });
   log(`turn ended (exit ${r.status}, ${((Date.now() - t0) / 1000).toFixed(0)}s)`);
@@ -114,7 +161,8 @@ async function loadLessons() {
   await api("/register", { session: SESSION, project: PROJ, status: "crew member booting" }).catch(() => {});
 
   let pendingBcast = [];
-  runTurn(KICKOFF + LESSONS, true, "kickoff");
+  const ec0 = runTurn(KICKOFF + LESSONS, true, "kickoff");
+  if (ec0) await reportFailure(ec0, "kickoff");   // a failed kickoff = the "fired up, died, nobody knew" case
   log(`parked — long-polling the bus as ${SESSION} (free; this poll is also the heartbeat)`);
 
   while (true) {
@@ -134,7 +182,9 @@ async function loadLessons() {
     pendingBcast = [];
     const lines = wake.map(m => `[${m.from}${m.to === "all" ? " -> all (mentions you)" : ""}]: ${m.text}`).join("\n");
     const prompt = `NEW BUS MESSAGE${wake.length > 1 ? "S" : ""} for you:\n${lines}\n${ctx}\nAct on what's addressed to you, then end your turn.\n\n${RULES}`;
-    await loadLessons(); runTurn(prompt + LESSONS, false, direct.length ? "direct message" : "@mention");
+    await loadLessons();
+    const ec = runTurn(prompt + LESSONS, false, direct.length ? "direct message" : "@mention");
+    if (ec) await reportFailure(ec, "message"); else await reportHealthy();
     log("parked — waiting for the next message");
   }
 })();

package/bin/crew-verify.mjs

@@ -13,8 +13,16 @@ import { homedir } from "node:os";
 const args = process.argv.slice(2);
 const ti = args.indexOf("--timeout");
 const TIMEOUT = ti >= 0 ? Number(args.splice(ti, 2)[1]) : 30;
+// --since <ms>: the spawn epoch captured by the launcher BEFORE it spawned the windows.
+// An agent counts as up the moment it registers (even "booting") with lastSeen >= this epoch.
+// Without it we'd default to "now", but the launcher only starts us AFTER the spawn+serialize
+// sleep, so a runner's early "booting" registration can land just before our own start and then
+// go silent through a slow first turn (e.g. opencode+GLM cold start ~40s) — a false failure that
+// triggers a duplicate respawn. Anchoring to the pre-spawn epoch removes that race.
+const si = args.indexOf("--since");
+const SINCE = si >= 0 ? Number(args.splice(si, 2)[1]) : NaN;
 const [PROJ, ...AGENTS] = args;
-if (!PROJ || !AGENTS.length) { console.error("usage: crew-verify.mjs <project> <agent...> [--timeout 30]"); process.exit(2); }
+if (!PROJ || !AGENTS.length) { console.error("usage: crew-verify.mjs <project> <agent...> [--timeout 30] [--since <ms>]"); process.exit(2); }
 
 function hubUrl() {
   if (process.env.RELAY_URL) return process.env.RELAY_URL;
@@ -22,15 +30,21 @@ function hubUrl() {
   return "http://127.0.0.1:4477";
 }
 const HUB = hubUrl();
-const START = Date.now();
+// Two distinct clocks, deliberately separate:
+//  - FRESH_SINCE: the freshness threshold. A registration counts only if lastSeen >= this.
+//    Prefer the launcher's pre-spawn epoch (so an early "booting" beat counts); else our start.
+//  - DEADLINE: how long WE poll, always measured from our own start so it can't be skewed
+//    (e.g. an epoch far in the past wouldn't shrink the window; one in the future wouldn't hang).
+const DEADLINE = Date.now() + TIMEOUT * 1000;
+const FRESH_SINCE = Number.isFinite(SINCE) ? SINCE : Date.now();
 
 (async () => {
   const want = new Set(AGENTS.map(a => `${a}:${PROJ}`));
   const up = new Set();
-  while (Date.now() - START < TIMEOUT * 1000 && up.size < want.size) {
+  while (Date.now() < DEADLINE && up.size < want.size) {
     try {
       const { peers } = await (await fetch(`${HUB}/peers`)).json();
-      for (const p of peers) if (want.has(p.session) && p.lastSeen >= START) up.add(p.session);
+      for (const p of peers) if (want.has(p.session) && p.lastSeen >= FRESH_SINCE) up.add(p.session);
     } catch {}
     if (up.size < want.size) await new Promise(s => setTimeout(s, 1500));
   }

package/bin/crew.sh

@@ -23,7 +23,8 @@ mkdir -p "$HOME/.agent-bus"
 
 down() {
   [ -f "$STATE" ] || { echo "no tracked crew windows"; return 0; }
-  while read -r wid; do
+  while IFS=$'\t' read -r a wid; do
+    [ -n "${wid:-}" ] || wid="$a"          # back-compat: old STATE stored bare window ids
     TTY=$(osascript -e "tell application \"Terminal\" to get tty of (first window whose id is $wid)" 2>/dev/null)
     if [ -n "$TTY" ]; then
       # SIGKILL everything on the tty, login included — TUIs trap SIGTERM, and a live login
@@ -32,7 +33,8 @@ down() {
     fi
   done < "$STATE"
   sleep 1
-  while read -r wid; do
+  while IFS=$'\t' read -r a wid; do
+    [ -n "${wid:-}" ] || wid="$a"
     osascript -e "tell application \"Terminal\" to close (first window whose id is $wid)" 2>/dev/null
   done < "$STATE"
   sleep 0.5
@@ -44,8 +46,50 @@ down() {
   echo "crew torn down"
 }
 [ "$CMD" = "down" ] && { down; exit 0; }
-[ "$CMD" != "up" ] && { echo "usage: crew.sh up <agent...> | crew.sh down"; exit 1; }
-[ $# -eq 0 ] && { echo "usage: crew.sh up codex gemini kimi deepseek (any subset; agent:model pins a model, e.g. deepseek:deepseek-v4-pro)"; exit 1; }
+case "$CMD" in up|swap) ;; *) echo "usage: crew.sh up <agent...> | crew.sh swap <oldAgent> <newAgent[:provider[/model]]> | crew.sh down"; exit 1 ;; esac
+
+# --task/--difficulty drive LAZY live-model selection for provider-only specs (agent:provider).
+# An agent spec is one of: `codex` (CLI default) · `opencode:zai-coding-plan` (provider only →
+# pick the best live model now) · `opencode:zai-coding-plan/glm-5.2` (full pin, used as-is).
+TASK="code"; DIFF="medium"; _ARGS=()
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --task) TASK="${2:-code}"; shift 2 || shift ;;
+    --difficulty|--diff) DIFF="${2:-medium}"; shift 2 || shift ;;
+    *) _ARGS+=("$1"); shift ;;
+  esac
+done
+if [ ${#_ARGS[@]} -gt 0 ]; then set -- "${_ARGS[@]}"; else set --; fi
+[ $# -eq 0 ] && { echo "usage: crew.sh up [--task K --difficulty D] codex gemini kimi deepseek (agent:provider picks a live model; agent:provider/model pins one)"; exit 1; }
+
+# scrooge (the model-routing brain) is bundled with this trantor install; fall back to PATH.
+SCROOGE="$BUS_DIR/engine/bin/scrooge"
+[ -f "$SCROOGE" ] || SCROOGE="$(command -v scrooge 2>/dev/null || echo scrooge)"
+
+# resolve_model <agent> <provider> <task> <diff> -> echoes a runner-ready model id, or empty
+# (→ CLI default). Enumeration is CLI-aware and never guesses an endpoint: opencode-managed
+# agents list via `opencode models <provider>`; others self-enumerate via the provider's /models.
+resolve_model() {
+  local agent="$1" provider="$2" task="$3" diff="$4" cands="" out=""
+  case "$agent" in
+    opencode|deepseek)
+      cands="$(opencode models "$provider" 2>/dev/null | tr '\n' ' ')"
+      [ -n "$cands" ] || { echo "[crew] no live models via 'opencode models $provider' — CLI default" >&2; return 0; }
+      out="$(python3 "$SCROOGE" route --candidates "$cands" -t "$task" -d "$diff" --json 2>/dev/null)" ;;
+    *)
+      out="$(python3 "$SCROOGE" route --provider "$provider" -t "$task" -d "$diff" --json 2>/dev/null)" ;;
+  esac
+  [ -n "$out" ] || { echo "[crew] live model selection failed for $agent:$provider — CLI default" >&2; return 0; }
+  printf '%s' "$out" | python3 -c 'import json,sys
+try: print(json.load(sys.stdin).get("qualified") or "")
+except Exception: pass' 2>/dev/null
+}
+
+# epoch_ms: milliseconds since the epoch, captured BEFORE a spawn so crew-verify can count an
+# agent the moment it registers (even "booting"), instead of racing its own start time. A slow
+# first turn (opencode+GLM cold start ~40s) means no heartbeat for the whole turn; anchoring the
+# verifier to this pre-spawn epoch lets the early "booting" registration satisfy it.
+epoch_ms() { python3 -c 'import time;print(int(time.time()*1000))'; }
 
 if [ "$(uname)" != "Darwin" ]; then
   echo "Window spawning is macOS-only. Run one per terminal, in $DIR:"
@@ -82,37 +126,87 @@ spawn_grid() {  # $@ = agents — (re)computes the grid for THIS batch and spawn
   [ $N -le 2 ] && COLS=1
   local ROWS=$(( (N + COLS - 1) / COLS ))
   local CW=$(( GW / COLS )) CH=$(( GH / ROWS ))
-  local i=0 SPEC AGENT MODEL
+  local i=0 SPEC AGENT FIELD MODEL
   for SPEC in "$@"; do
-    AGENT="${SPEC%%:*}"                       # agent[:model] — model rides in as CREW_MODEL
-    MODEL=""; [ "$SPEC" != "$AGENT" ] && MODEL="${SPEC#*:}"
+    AGENT="${SPEC%%:*}"                       # agent[:provider[/model]] — model rides in as CREW_MODEL
+    FIELD=""; [ "$SPEC" != "$AGENT" ] && FIELD="${SPEC#*:}"
+    MODEL=""
+    if [ -n "$FIELD" ]; then
+      case "$FIELD" in
+        */*) MODEL="$FIELD" ;;                                          # full pin: provider/model
+        *)   MODEL="$(resolve_model "$AGENT" "$FIELD" "$TASK" "$DIFF")"  # provider only: pick live now
+             if [ -n "$MODEL" ]; then echo "  → $AGENT: live model $MODEL ($FIELD · $TASK/$DIFF)"
+             else echo "  → $AGENT: '$FIELD' live selection unavailable — CLI default"; fi ;;
+      esac
+    fi
     local C=$(( i % COLS )) R=$(( i / COLS ))
-    local X1=$(( GX + C * CW )) Y1=$(( GY + R * CH ))
-    osascript \
+    local X1=$(( GX + C * CW )) Y1=$(( GY + R * CH )) WID=""
+    WID="$(osascript \
       -e 'tell application "Terminal"' \
       -e "  set w to do script \"cd $DIR && clear && CREW_MODEL=$MODEL node $BUS_DIR/bin/crew-runner.mjs $AGENT $DIR\"" \
       -e "  set custom title of w to \"$(echo "$AGENT" | tr '[:lower:]' '[:upper:]') — trantor crew\"" \
       -e "  set theWin to first window whose tabs contains w" \
       -e "  set bounds of theWin to {$X1, $Y1, $(( X1 + CW )), $(( Y1 + CH ))}" \
       -e "  return id of theWin" \
-      -e 'end tell' >> "$STATE" 2>/dev/null && echo "  → $AGENT window spawned" || echo "  ✗ $AGENT osascript spawn ERROR"
+      -e 'end tell' 2>/dev/null)"
+    if [ -n "$WID" ]; then printf '%s\t%s\n' "$AGENT" "$WID" >> "$STATE"; echo "  → $AGENT window spawned"; else echo "  ✗ $AGENT osascript spawn ERROR"; fi
     sleep 1.2   # serialize — rapid-fire 'do script' calls race and silently drop windows
     i=$(( i + 1 ))
   done
 }
 
+# swap <oldAgent> <newSpec>: replace a live agent (e.g. one reported exhausted) with a fresh
+# one whose model is live-selected. Tears down the old agent's window, spawns the new spec.
+swap() {
+  local OLD="${1:-}" NEWSPEC="${2:-}"
+  [ -n "$OLD" ] && [ -n "$NEWSPEC" ] || { echo "usage: trantor swap <oldAgent> <newAgent[:provider[/model]]> [--task K --difficulty D]"; exit 1; }
+  if [ -f "$STATE" ]; then
+    local tmp="$STATE.tmp"; : > "$tmp"
+    while IFS=$'\t' read -r a wid; do
+      [ -n "${wid:-}" ] || { wid="$a"; a=""; }
+      if [ "$a" = "$OLD" ]; then
+        echo "— tearing down old agent '$OLD' (window $wid) —"
+        local TTY; TTY=$(osascript -e "tell application \"Terminal\" to get tty of (first window whose id is $wid)" 2>/dev/null)
+        [ -n "$TTY" ] && for pid in $(ps -t "${TTY#/dev/}" -o pid= 2>/dev/null); do kill -9 "$pid" 2>/dev/null; done
+        sleep 0.5
+        osascript -e "tell application \"Terminal\" to close (first window whose id is $wid)" 2>/dev/null
+      else
+        printf '%s\t%s\n' "$a" "$wid" >> "$tmp"
+      fi
+    done < "$STATE"
+    mv "$tmp" "$STATE"
+  fi
+  echo "— spawning replacement: $NEWSPEC ($TASK/$DIFF) —"
+  local SWAP_EPOCH; SWAP_EPOCH=$(epoch_ms)
+  spawn_grid "$NEWSPEC"
+  local NEWAGENT="${NEWSPEC%%:*}"
+  echo "— verifying replacement on the bus —"
+  node "$BUS_DIR/bin/crew-verify.mjs" "$PROJ" "$NEWAGENT" --since "$SWAP_EPOCH" --timeout 30
+  echo "— swapped. RESEND the contract to '$NEWAGENT' (it joined fresh with no context). —"
+}
+
+if [ "$CMD" = "swap" ]; then swap "$@"; exit 0; fi
+
+# spec_for_agent <agent> <spec...>: echo the FULL original spec (agent:provider[/model]) whose
+# agent part matches — so a retry respawns on the SAME live-selected model, not the CLI default.
+spec_for_agent() { local want="$1"; shift; local s; for s in "$@"; do [ "${s%%:*}" = "$want" ] && { printf '%s' "$s"; return; }; done; printf '%s' "$want"; }
+
 echo "— spawning crew (serialized) —"
+SPAWN_EPOCH=$(epoch_ms)
 spawn_grid "$@"
 
 echo "— verifying on the bus (the spawn is not the truth; the bus is) —"
 AGENTS_ONLY=$(for a in "$@"; do printf "%s " "${a%%:*}"; done)
-VER=$(node "$BUS_DIR/bin/crew-verify.mjs" "$PROJ" $AGENTS_ONLY --timeout 30)
+VER=$(node "$BUS_DIR/bin/crew-verify.mjs" "$PROJ" $AGENTS_ONLY --since "$SPAWN_EPOCH" --timeout 30)
 echo "$VER"
 RETRY=$(echo "$VER" | grep "^FAILED:" | cut -d: -f2 | tr ',' ' ')
 if [ -n "${RETRY// }" ]; then
-  echo "— retrying failed spawns: $RETRY —"
-  spawn_grid $RETRY
-  VER2=$(node "$BUS_DIR/bin/crew-verify.mjs" "$PROJ" $RETRY --timeout 30)
+  # map failed agent names back to their FULL specs (preserve provider/model on respawn)
+  RETRY_SPECS=""; for a in $RETRY; do RETRY_SPECS="$RETRY_SPECS $(spec_for_agent "$a" "$@")"; done
+  echo "— retrying failed spawns:$RETRY_SPECS —"
+  RETRY_EPOCH=$(epoch_ms)
+  spawn_grid $RETRY_SPECS
+  VER2=$(node "$BUS_DIR/bin/crew-verify.mjs" "$PROJ" $RETRY --since "$RETRY_EPOCH" --timeout 30)
   echo "$VER2"
   STILL=$(echo "$VER2" | grep "^FAILED:" | cut -d: -f2)
   if [ -n "$STILL" ]; then

package/engine/bin/scrooge

@@ -590,6 +590,86 @@ def cmd_models(reg, args):
     for i in ids:
         print(i)
 
+def _model_version_key(mid):
+    """Best-effort 'newest' ordering when no capability data exists: the trailing
+    numeric version wins (glm-5.2 > glm-5.1 > glm-4.7). Returns a sortable tuple."""
+    m = re.search(r"(\d+(?:\.\d+)*)", mid)
+    return tuple(int(x) for x in m.group(1).split(".")) if m else (0,)
+
+_SMALL_VARIANT = ("air", "mini", "flash", "lite", "turbo", "nano", "small")
+def _is_small_variant(mid):
+    low = mid.lower()
+    return any(s in low for s in _SMALL_VARIANT)
+
+def _heuristic_pick(cands, difficulty):
+    """No capability data → pick by newest version, difficulty-aware on size variants
+    (easy prefers a small/turbo variant; medium/hard prefers the full model)."""
+    top_ver = max(_model_version_key(c) for c in cands)
+    top = [c for c in cands if _model_version_key(c) == top_ver]
+    if difficulty == "easy":
+        smalls = sorted(c for c in top if _is_small_variant(c))
+        if smalls:
+            return smalls[0]
+    bigs = sorted(c for c in top if not _is_small_variant(c))
+    return (bigs or sorted(top))[0]
+
+def cmd_route(reg, args):
+    """Pick ONE deliberate live model for the crew path (task × difficulty).
+    Enumeration is the CALLER's job for CLI-managed providers — pass ids via
+    --candidates (e.g. `opencode models <provider>`); for raw-API providers in the
+    registry, --provider self-enumerates via /models. Scoring uses capabilities when
+    available, else a newest-version heuristic. JSON with --json. NEVER guesses an
+    endpoint."""
+    caps = load_caps()
+    provider = args.provider
+    raw = []
+    if args.candidates:
+        raw = [c.strip() for c in re.split(r"[,\s]+", args.candidates) if c.strip()]
+    elif provider:
+        if provider not in reg["providers"]:
+            print(json.dumps({"error": "unknown provider '%s' and no --candidates given" % provider}))
+            raise SystemExit(2)
+        if not provider_key(reg, provider):
+            print(json.dumps({"error": "no API key for provider '%s'" % provider}))
+            raise SystemExit(2)
+        raw = list_live_models(reg, provider, ttl=0)
+    if not raw:
+        print(json.dumps({"error": "no candidate models (provider offline / no key / empty --candidates)"}))
+        raise SystemExit(2)
+    # bare id (strip any provider/ prefix) → first original (qualified) form seen
+    by_bare = {}
+    for r in raw:
+        by_bare.setdefault(r.split("/")[-1], r)
+    bare_ids = list(by_bare.keys())
+    task = args.task or "code"
+    difficulty = args.difficulty or "medium"
+    metric = task_metric(task)
+    # Only trust the capability-weighted router when the NEWEST-version candidate is itself
+    # scored. Otherwise stale caps (which lag new releases) would demote a newer model to 0
+    # and pick an old one — the exact failure that motivated this. Then prefer newest.
+    top_ver = max(_model_version_key(b) for b in bare_ids)
+    top_scored = any(model_quality(caps, b, metric) > 0
+                     for b in bare_ids if _model_version_key(b) == top_ver)
+    if top_scored:
+        scored = weigh_candidates(reg, caps, bare_ids, task, difficulty)
+        pick_bare = scored[0][0]
+        weighed, why = True, "capability×cost ranked (%s · %s floor) over %d live" % (task, difficulty, len(bare_ids))
+        cand_out = [{"model": b, "score": round(s, 4)} for b, s in scored[:6]]
+    else:
+        pick_bare = _heuristic_pick(bare_ids, difficulty)
+        weighed, why = False, "capabilities lag the newest model(s) → newest-version heuristic (difficulty-aware); run scrooge-capabilities to enrich"
+        cand_out = [{"model": b} for b in sorted(bare_ids, key=_model_version_key, reverse=True)[:6]]
+    original = by_bare[pick_bare]
+    qualified = original if "/" in original else (("%s/%s" % (provider, pick_bare)) if provider else pick_bare)
+    result = {"provider": provider, "model": pick_bare, "qualified": qualified,
+              "weighed": weighed, "task": task, "difficulty": difficulty, "why": why, "candidates": cand_out}
+    if getattr(args, "json", False):
+        print(json.dumps(result))
+    else:
+        err(DIM("[scrooge route] %s → %s (%s)" % (provider or "?", qualified, "weighed" if weighed else "heuristic")))
+        print(qualified)
+    return 0
+
 def cmd_list(reg, args):
     print("PROVIDERS (live = key present):")
     for p, cfg in reg["providers"].items():
@@ -1207,11 +1287,19 @@ def main():
     reg = load_registry()
 
     # Manual subcommand dispatch (avoids argparse subparser vs positional-prompt clash).
-    if argv and argv[0] in ("models", "list", "ledger", "watch", "learn", "lessons", "forget"):
+    if argv and argv[0] in ("models", "route", "list", "ledger", "watch", "learn", "lessons", "forget"):
         cmd, rest = argv[0], argv[1:]
         if cmd == "models":
             ap = argparse.ArgumentParser(prog="scrooge models"); ap.add_argument("provider")
             return cmd_models(reg, ap.parse_args(rest))
+        if cmd == "route":
+            ap = argparse.ArgumentParser(prog="scrooge route")
+            ap.add_argument("--provider", "-p", help="registry API provider to self-enumerate via /models")
+            ap.add_argument("--candidates", "-c", help="comma/space-separated model ids (e.g. `opencode models <p>`); takes precedence over --provider enumeration")
+            ap.add_argument("--task", "-t", default="code")
+            ap.add_argument("--difficulty", "-d", choices=["easy", "medium", "hard"], default="medium")
+            ap.add_argument("--json", action="store_true")
+            return cmd_route(reg, ap.parse_args(rest))
         if cmd == "list":
             return cmd_list(reg, None)
         if cmd == "ledger":

package/hooks/heartbeat.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+// trantor PostToolUse heartbeat — keeps a live session's presence fresh on the bus.
+//
+// Registration (sessionstart.mjs / mcp.mjs) tells the hub a session was BORN; nothing
+// tells it the session is still ALIVE. So presence decays after RELAY_ONLINE_MS (5 min)
+// and the dashboard rots into a graveyard of "idle" boards even while sessions work —
+// worst right after the laptop wakes from sleep, when every lastSeen is stale at once and
+// there is no resume event to re-register. This hook fixes that: every tool call (a true
+// sign of life) refreshes lastSeen, throttled so we hit the hub at most once per window.
+// The first tool call after a wake re-greens the session — that first action IS the resume signal.
+//
+// Cheap + fail-silent by contract: a per-session stamp file gates the network call to once
+// per HEARTBEAT_MS, and a short fetch timeout means we never add real latency to a tool call.
+// We POST /register WITHOUT a status field so the session's meaningful status is preserved
+// (the hub only overwrites status when one is supplied).
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir, hostname } from "node:os";
+
+const HEARTBEAT_MS = Number(process.env.RELAY_HEARTBEAT_MS || 60 * 1000);
+const FETCH_TIMEOUT_MS = Number(process.env.RELAY_HEARTBEAT_TIMEOUT_MS || 1500);
+
+function relayUrl() {
+  if (process.env.RELAY_URL) return process.env.RELAY_URL;
+  try {
+    const cfg = join(homedir(), ".agent-bus", "config.json");
+    if (existsSync(cfg)) { const u = JSON.parse(readFileSync(cfg, "utf8")).url; if (u) return u; }
+  } catch {}
+  return "http://127.0.0.1:4477";
+}
+
+async function main() {
+  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  // Mirror sessionstart.mjs: home-directory sessions aren't project work — don't register
+  // them (would spawn a phantom "<username>" board). Opt in with RELAY_SESSION/RELAY_PROJECT.
+  if (!process.env.RELAY_SESSION && !process.env.RELAY_PROJECT && projectDir === homedir()) return;
+
+  // Mirror mcp.mjs identity resolution EXACTLY so we refresh the same peer the relay
+  // registered (not a phantom): RELAY_PROJECT wins for project; RELAY_SESSION wins for
+  // identity, else a RELAY_AGENT brand ("codex","kimi",…) per project, else hostname:project.
+  const project = process.env.RELAY_PROJECT || basename(projectDir);
+  const session = process.env.RELAY_SESSION
+    || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${project}` : `${hostname()}:${project}`);
+
+  // Throttle: only ping if HEARTBEAT_MS has elapsed since the last ping for THIS session.
+  const stamp = join(homedir(), ".agent-bus", `hb-${session.replace(/[^A-Za-z0-9_.-]/g, "_")}.stamp`);
+  try {
+    if (existsSync(stamp)) {
+      const last = Number(readFileSync(stamp, "utf8")) || 0;
+      if (Date.now() - last < HEARTBEAT_MS) return;   // within window — nothing to do
+    }
+  } catch {}
+  // Write the stamp BEFORE the network call so rapid concurrent tool calls don't all fire.
+  try { writeFileSync(stamp, String(Date.now())); } catch {}
+
+  // POST /register with no status -> hub refreshes lastSeen + project, preserves status.
+  try {
+    await fetch(`${relayUrl()}/register`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ session, project }),
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    });
+  } catch {}
+}
+
+// Never block or break the tool flow: swallow everything, always exit clean.
+main().catch(() => {}).finally(() => process.exit(0));

package/hooks/hooks.json

@@ -1,9 +1,12 @@
 {
-  "description": "trantor — auto-register each session + inject live roster (SessionStart); write a handoff before compaction (PreCompact)",
+  "description": "trantor — auto-register each session + inject live roster (SessionStart); heartbeat presence on every tool call so live sessions stay green and recover after sleep (PostToolUse); write a handoff before compaction (PreCompact)",
   "hooks": {
     "SessionStart": [
       { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/sessionstart.mjs" } ] }
     ],
+    "PostToolUse": [
+      { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/heartbeat.mjs" } ] }
+    ],
     "PreCompact": [
       { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/precompact.mjs" } ] }
     ]

package/hooks/sessionstart.mjs

@@ -61,6 +61,14 @@ let additionalContext = "";
 try {
   await readStdin();
   const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  // Sessions started in the home directory itself aren't project work — registering
+  // them spawns a phantom "<username>" project board on the dashboard. Set
+  // RELAY_SESSION (or RELAY_PROJECT) to deliberately put a home-dir session on the bus.
+  if (!process.env.RELAY_SESSION && !process.env.RELAY_PROJECT && projectDir === homedir()) {
+    process.stderr.write("[trantor] session in the home directory — not registering on the bus (set RELAY_SESSION to opt in)\n");
+    process.stdout.write("{}");
+    process.exit(0);
+  }
   const session = process.env.RELAY_SESSION || `${hostname()}:${basename(projectDir)}`;
   const url = relayUrl();
 

package/hub.mjs

@@ -11,7 +11,7 @@ import { join } from "node:path";
 
 const PORT = Number(process.env.RELAY_PORT || 4477);
 const HOST = process.env.RELAY_HOST || "127.0.0.1";
-const DATA_DIR = join(homedir(), ".agent-bus");
+const DATA_DIR = process.env.RELAY_DATA_DIR || join(homedir(), ".agent-bus");
 const DATA = join(DATA_DIR, "bus.json");
 const ONLINE_MS = Number(process.env.RELAY_ONLINE_MS || 5 * 60 * 1000);
 if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
@@ -38,6 +38,7 @@ try { UI = readFileSync(new URL("./ui.html", import.meta.url), "utf8"); } catch
 // open SSE streams: [{ session, res }]
 const streams = [];
 const now = () => Date.now();
+const fmtAge = ms => { const m = Math.floor(ms / 60000); return m > 48 * 60 ? `${Math.floor(m / 1440)}d ago` : m > 90 ? `${Math.floor(m / 60)}h ago` : `${m}m ago`; };
 function body(req) { return new Promise(r => { let d = ""; req.on("data", c => (d += c)); req.on("end", () => { try { r(d ? JSON.parse(d) : {}); } catch { r({}); } }); }); }
 function json(res, code, obj) { res.writeHead(code, { "content-type": "application/json", "access-control-allow-origin": "*" }); res.end(JSON.stringify(obj)); }
 function touch(session, status, project) {
@@ -50,6 +51,15 @@ function touch(session, status, project) {
   if (!p.project && session.includes(":")) p.project = session.split(":").pop().slice(0, 80);
   state.peers[session] = p; dirty = true;
 }
+// Derive a coarse health from the free-text status the runner sets on a failed turn
+// ("errored: <reason>" / "down: <reason>") — lets the board show a failing-but-alive agent
+// distinctly instead of a healthy green. Default "ok".
+function healthOf(status) {
+  const s = String(status || "").toLowerCase();
+  if (s.startsWith("down")) return "down";
+  if (s.startsWith("errored")) return "errored";
+  return "ok";
+}
 function deliverable(m, session) { return (m.to === session || m.to === "all") && m.from !== session; }
 function pushToStreams(msg) {
   for (const s of streams) if (deliverable(msg, s.session)) { try { s.res.write(`data: ${JSON.stringify(msg)}\n\n`); } catch {} }
@@ -62,7 +72,7 @@ const server = http.createServer(async (req, res) => {
     if (req.method === "POST" && P === "/status") { const b = await body(req); touch(b.session, b.status ?? "", b.project); return json(res, 200, { ok: true }); }
     if (req.method === "GET" && P === "/peers") {
       const cutoff = now() - ONLINE_MS;
-      return json(res, 200, { peers: Object.entries(state.peers).map(([s, v]) => ({ session: s, lastSeen: v.lastSeen, online: v.lastSeen > cutoff, status: v.status || "", project: v.project || "" })) });
+      return json(res, 200, { peers: Object.entries(state.peers).map(([s, v]) => ({ session: s, lastSeen: v.lastSeen, online: v.lastSeen > cutoff, status: v.status || "", health: healthOf(v.status), project: v.project || "" })) });
     }
     // --- Kanban tasks ---
     if (req.method === "POST" && P === "/task") {           // create a card
@@ -107,16 +117,30 @@ const server = http.createServer(async (req, res) => {
       state.projectMeta[k] = m; dirty = true;
       return json(res, 200, { ok: true, project: k, brief: m.brief || "" });
     }
+    if (req.method === "POST" && P === "/project/delete") { // forget a project: its cards, peers, brief, and lane
+      const b = await body(req); const k = String(b.project || "").slice(0, 80);
+      if (!k) return json(res, 400, { error: "project required" });
+      const nt = state.tasks.length, np = Object.keys(state.peers).length, nm = state.messages.length;
+      state.tasks = state.tasks.filter(t => t.project !== k);
+      for (const [s, v] of Object.entries(state.peers)) if (v.project === k) delete state.peers[s];
+      delete state.projectMeta[k];
+      state.messages = state.messages.filter(m2 => (m2.project || "") !== k);
+      dirty = true;   // the project reappears cleanly if an agent ever registers it again
+      return json(res, 200, { ok: true, project: k, removed: { tasks: nt - state.tasks.length, peers: np - Object.keys(state.peers).length, messages: nm - state.messages.length } });
+    }
     if (req.method === "GET" && P === "/projects") {        // project-grouped view
       const cutoff = now() - ONLINE_MS; const byProj = {};
       const proj = p => p || "(unassigned)";
-      const mk = k => (byProj[k] ||= { project: k, brief: (state.projectMeta[k]?.brief) || "", agents: [], tasks: { todo:0,doing:0,testing:0,failed:0,done:0,blocked:0 }, doingTitles: [] });
+      const mk = k => (byProj[k] ||= { project: k, brief: (state.projectMeta[k]?.brief) || "", agents: [], tasks: { todo:0,doing:0,testing:0,failed:0,done:0,blocked:0 }, doingTitles: [], lastActivity: 0 });
       for (const [s, v] of Object.entries(state.peers)) {
-        const k = proj(v.project); mk(k).agents.push({ session: s, online: v.lastSeen > cutoff, status: v.status || "" });
+        const k = proj(v.project); const e = mk(k); e.agents.push({ session: s, online: v.lastSeen > cutoff, status: v.status || "", health: healthOf(v.status) });
+        if ((v.lastSeen || 0) > e.lastActivity) e.lastActivity = v.lastSeen;
       }
-      for (const t of state.tasks) { const e = mk(proj(t.project)); e.tasks[t.status] = (e.tasks[t.status]||0)+1; if (t.status === "doing") e.doingTitles.push(t.title); }
+      for (const t of state.tasks) { const e = mk(proj(t.project)); e.tasks[t.status] = (e.tasks[t.status]||0)+1; if (t.status === "doing") e.doingTitles.push(t.title); if ((t.updated || 0) > e.lastActivity) e.lastActivity = t.updated; }
       // derive a one-line phase ("where it is in the process") from the board
       for (const e of Object.values(byProj)) {
+        const mu = state.projectMeta[e.project]?.updated || 0; if (mu > e.lastActivity) e.lastActivity = mu;
+        e.idle = !e.agents.some(a => a.online);
         const { todo, doing, testing=0, failed=0, done, blocked } = e.tasks; const total = todo+doing+testing+failed+done+blocked;
         e.phase = total === 0 ? "no cards yet"
           : failed > 0 ? `${failed} FAILED — fixing`
@@ -126,6 +150,8 @@ const server = http.createServer(async (req, res) => {
           : done === total ? "shipped — all cards done"
           : todo > 0 ? `planned: ${todo} card${todo>1?"s":""} queued`
           : "in progress";
+        // dead board: no live agents -> the phase above is stale, say so honestly
+        if (e.idle) e.phase = `idle · last activity ${e.lastActivity ? fmtAge(now() - e.lastActivity) : "unknown"}`;
       }
       return json(res, 200, { projects: Object.values(byProj) });
     }

package/mcp.mjs

@@ -103,7 +103,12 @@ server.tool("relay_board", "Show THIS project's Kanban board (all cards + their
 
 server.tool("relay_peers", "List other Claude sessions connected to the relay (online in last 5 min).", {}, async () => {
   const { peers } = await api("GET", "/peers");
-  const lines = peers.map(p => `${p.online ? "🟢" : "⚪"} ${p.session}${p.session === SESSION ? " (you)" : ""}`);
+  const lines = peers.map(p => {
+    // health surfaces a failing-but-alive agent (runner-reported) — not a green lie
+    const icon = !p.online ? "⚪" : p.health === "down" ? "🛑" : p.health === "errored" ? "🔴" : "🟢";
+    const note = (p.health === "errored" || p.health === "down") && p.status ? ` — ${p.status}` : "";
+    return `${icon} ${p.session}${p.session === SESSION ? " (you)" : ""}${note}`;
+  });
   return { content: [{ type: "text", text: lines.join("\n") || "no peers yet" }] };
 });
 
@@ -152,5 +157,18 @@ server.tool("relay_wait", "Block up to `timeout` seconds waiting for the next me
   });
 
 await api("POST", "/register", { session: SESSION, project: PROJECT, status: `active in ${PROJECT}` }).catch(() => {});
+
+// Heartbeat — keep this session's presence fresh for as long as the MCP process lives.
+// Registration alone decays after the hub's online window (5 min); without this, idle agents
+// — and EVERY agent after the laptop sleeps (dead connection, no resume event) — fall off the
+// board while their process is still alive. This is the UNIVERSAL counterpart to the Claude-only
+// PostToolUse heartbeat hook: it runs inside the relay every agent loads (Claude, codex, gemini,
+// kimi, deepseek), so the whole crew stays tracked. We POST /register with NO status, so the
+// hub refreshes lastSeen but preserves the session's meaningful status. setInterval pauses during
+// sleep and fires on wake, so presence self-heals within one interval; .unref() lets the process
+// still exit cleanly when the agent closes the stdio transport (no phantom peers).
+const HEARTBEAT_MS = Number(process.env.RELAY_HEARTBEAT_MS || 60 * 1000);
+setInterval(() => { api("POST", "/register", { session: SESSION, project: PROJECT }).catch(() => {}); }, HEARTBEAT_MS).unref?.();
+
 await server.connect(new StdioServerTransport());
-process.stderr.write(`[trantor-mcp] connected as ${SESSION} -> ${URL_BASE}\n`);
+process.stderr.write(`[trantor-mcp] connected as ${SESSION} -> ${URL_BASE} (heartbeat ${HEARTBEAT_MS}ms)\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.0",
+  "version": "0.17.3",
   "type": "module",
   "bin": {
     "trantor": "bin/cli.mjs"
@@ -10,9 +10,9 @@
     "zod": "^4.4.3"
   },
   "scripts": {
-    "test": "node test.mjs && node test-scenarios.mjs"
+    "test": "node test.mjs && node test-scenarios.mjs && node test-failure.mjs"
   },
-  "description": "The hub-world for AI agent crews — orchestrate Claude Code, Codex, Gemini, Kimi & DeepSeek as live crews with a plan-aware Advisor, a Kanban/flow command center, a testing gate, and an economics brain (Scrooge).",
+  "description": "The hub-world for AI agent crews \u2014 orchestrate Claude Code, Codex, Gemini, Kimi & DeepSeek as live crews with a plan-aware Advisor, a Kanban/flow command center, a testing gate, and an economics brain (Scrooge).",
   "files": [
     "hub.mjs",
     "mcp.mjs",

package/ui.html

@@ -22,6 +22,10 @@ main{flex:1;display:grid;grid-template-columns:1fr 330px;min-height:0}
 .agent .nm{color:var(--tx)}
 .agent svg{flex:none}
 .agent.offl{opacity:.42}
+.agent.err{border-color:#ef4444;color:#ef4444}
+.agent.err .nm{color:#ef4444}
+.agent.down{border-color:#ef4444;background:rgba(239,68,68,.14);color:#ef4444}
+.agent.down .nm{color:#ef4444;font-weight:600}
 .agent .ast{color:var(--mut)}
 .prog{font-size:11.5px;color:var(--dim);white-space:nowrap}
 /* project brief + phase row */
@@ -56,6 +60,20 @@ main{flex:1;display:grid;grid-template-columns:1fr 330px;min-height:0}
 .tcard.done{opacity:.65}.tcard.done span{text-decoration:line-through}
 .empty{color:var(--dim);text-align:center;padding:30px}
 .empty.big{padding:60px 20px;font-size:15px}
+/* idle projects — collapsed thin rows below the live boards */
+.idle-head{font-size:10.5px;text-transform:uppercase;letter-spacing:.09em;color:var(--dim);font-weight:700;margin:18px 2px 8px}
+.idle-row{display:flex;align-items:center;gap:7px;background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:7px 14px;margin-bottom:7px;font-size:12.5px;color:var(--mut);cursor:pointer}
+.idle-row:hover{background:var(--card);border-color:#2c3a52}
+.idle-row .nm{color:var(--tx);font-weight:600}
+.mv{display:inline-flex;gap:3px;margin-left:6px}
+.mv b{cursor:pointer;color:var(--dim);font-size:10px;line-height:1;padding:3px 5px;border:1px solid var(--line);border-radius:6px;background:var(--card);font-weight:400}
+.mv b:hover{color:var(--tx);border-color:#2c3a52}
+.pdel{cursor:pointer;color:var(--dim);font-size:10.5px;padding:2px 7px;border:1px solid var(--line);border-radius:6px;background:var(--card);margin-left:5px;white-space:nowrap}
+.pdel:hover{color:var(--red);border-color:#5a2c2c}
+.pdel.arm{color:#fff;background:var(--red);border-color:var(--red)}
+.sortmode{font-size:10.5px;color:var(--dim);margin:0 0 10px;cursor:pointer;user-select:none}
+.sortmode:hover{color:var(--mut)}
+.proj.idle .proj-h{opacity:.55;cursor:pointer}
 /* flow (DAG) view */
 .vtog{display:flex;gap:2px;margin-left:10px}
 .vbtn{font-size:10px;font-weight:700;letter-spacing:.05em;padding:2px 9px;border-radius:10px;border:1px solid var(--line);background:var(--card);color:var(--dim);cursor:pointer}
@@ -120,7 +138,7 @@ aside h2{font-size:10.5px;text-transform:uppercase;letter-spacing:.09em;color:va
 <body>
 <header>
   <span class="dot" id="livedot"></span>
-  <span class="logo">agent<b>·</b>bus</span>
+  <span class="logo">tran<b>t</b>or</span>
   <span class="pill" id="hub">—</span>
   <span class="spacer"></span>
   <span class="pill" id="econ" title="Scrooge ledger, last 24h" style="display:none"></span>
@@ -160,7 +178,7 @@ const ICON={
 const BRAND=[[/claude|anthropic/,'anthropic'],[/codex|openai|gpt|chatgpt/,'openai'],[/gemini|bard/,'gemini'],[/mistral|mixtral/,'mistral'],[/deepseek/,'deepseek'],[/kimi|moonshot|\bk2\b/,'moonshot'],[/qwen/,'qwen'],[/grok|xai/,'grok'],[/cursor/,'cursor']];
 function brandOf(s){const x=String(s).toLowerCase();for(const[re,b]of BRAND)if(re.test(x))return b;return null;}
 function iconFor(s,size){const b=brandOf(s);if(!b||!ICON[b])return `<span style="display:inline-flex;width:${size}px;height:${size}px;align-items:center;justify-content:center;border-radius:50%;background:#2a3346;color:#aeb9c9;font-size:${Math.round(size*.55)}px;font-weight:700">${esc(String(s).slice(0,1).toUpperCase())}</span>`;const i=ICON[b];return `<svg viewBox="0 0 24 24" width="${size}" height="${size}" fill="currentColor" style="color:${i.c}">${i.p.map(d=>`<path d="${d}"/>`).join('')}</svg>`;}
-const phaseClass=ph=>/FAILED|blocked/.test(ph)?'blocked':/building|verifying|progress/.test(ph)?'building':/shipped|done/.test(ph)?'shipped':'planned';
+const phaseClass=ph=>/^idle ·/.test(ph)?'planned':/FAILED|blocked/.test(ph)?'blocked':/building|verifying|progress/.test(ph)?'building':/shipped|done/.test(ph)?'shipped':'planned';
 
 let POOLS={};
 async function econ(){
@@ -178,6 +196,16 @@ econ();setInterval(econ,15000);
 function poolOf(session){const b=brandOf(session);const k=b==='anthropic'?'claude':b==='openai'?'codex':b==='moonshot'?'kimi':b;return POOLS[k]||'';}
 const VIEWS = JSON.parse(localStorage.getItem("abViews") || "{}");
 function setView(proj, v){ VIEWS[proj] = v; localStorage.setItem("abViews", JSON.stringify(VIEWS)); render(); }
+function toggleIdle(name){ if(!name)return; const s=new Set(JSON.parse(localStorage.getItem("abIdleOpen")||"[]")); s.has(name)?s.delete(name):s.add(name); localStorage.setItem("abIdleOpen",JSON.stringify([...s])); render(); }
+let armedDel=null,armedTs=0;   // pending ✕ confirmation (project name + when it was armed)
+// ▲▼: snapshot the currently displayed order, swap, persist — manual order then wins until ↺ reset
+function moveProj(name,dir){
+  const names=[...document.querySelectorAll('#boards [data-projname]')].map(d=>d.dataset.projname);
+  const i=names.indexOf(name),j=i+dir;
+  if(i<0||j<0||j>=names.length)return;
+  [names[i],names[j]]=[names[j],names[i]];
+  localStorage.setItem("abOrder",JSON.stringify(names)); render();
+}
 function flowLayout(cards, proj){
   const byId = Object.fromEntries(cards.map(t => [t.id, t]));
   let anyDeps = cards.some(t => (t.deps || []).length);
@@ -343,16 +371,25 @@ async function render(){
   const sel=$('#to'),cur=sel.value;
   sel.innerHTML='<option value="all">all (broadcast)</option>'+allS.map(s=>`<option value="${esc(s)}">${esc(s)}</option>`).join('');
   sel.value=cur;
-  // sort: projects with online agents first, then by name; unassigned last
-  projects.sort((a,b)=>{const oa=a.agents.some(x=>x.online),ob=b.agents.some(x=>x.online);if(oa!==ob)return ob-oa;if(a.project==='(unassigned)')return 1;if(b.project==='(unassigned)')return -1;return a.project.localeCompare(b.project);});
+  // sort: manual order (abOrder, set via the ▲▼ controls) wins; otherwise online
+  // first, then most-recent activity — working boards float to the top on their own
+  const ORDER=JSON.parse(localStorage.getItem("abOrder")||"[]");
+  projects.sort((a,b)=>{
+    const ia=ORDER.indexOf(a.project),ib=ORDER.indexOf(b.project);
+    if(ia>=0||ib>=0)return (ia<0?1e9:ia)-(ib<0?1e9:ib);
+    const oa=a.agents.some(x=>x.online),ob=b.agents.some(x=>x.online);if(oa!==ob)return ob-oa;
+    if(a.project==='(unassigned)')return 1;if(b.project==='(unassigned)')return -1;
+    return (b.lastActivity||0)-(a.lastActivity||0)||a.project.localeCompare(b.project);
+  });
   const el=$('#boards');
   if(dragging)return;                                  // never rebuild mid-gesture
   if(!projects.length){el.innerHTML='<div class="empty big">no projects yet — agents register a project on connect</div>';return;}
-  el.innerHTML=projects.map(p=>{
+  const idleOpen=new Set(JSON.parse(localStorage.getItem("abIdleOpen")||"[]"));
+  const projBlock=p=>{
     const pt=tasks.filter(t=>t.project===p.project);
     const done=pt.filter(t=>t.status==='done').length;
     const pct=pt.length?Math.round(done/pt.length*100):0;
-    const agents=p.agents.sort((a,b)=>b.online-a.online).map(a=>`<span class="agent ${a.online?'':'offl'}" title="${esc(a.session)}${a.online?' · online':' · offline'}">${iconFor(a.session,15)}<span class="nm">${esc(a.session)}</span>${a.status?` <span class="ast">· ${esc(a.status)}</span>`:''}${poolOf(a.session)?` <span class="ast" style="opacity:.7">[${esc(poolOf(a.session))}]</span>`:''}</span>`).join('');
+    const agents=p.agents.sort((a,b)=>b.online-a.online).map(a=>`<span class="agent ${a.online?'':'offl'}${a.health==='down'?' down':a.health==='errored'?' err':''}" title="${esc(a.session)}${a.online?' · online':' · offline'}${a.health&&a.health!=='ok'?' · '+a.health:''}">${iconFor(a.session,15)}<span class="nm">${esc(a.session)}</span>${a.status?` <span class="ast">· ${esc(a.status)}</span>`:''}${poolOf(a.session)?` <span class="ast" style="opacity:.7">[${esc(poolOf(a.session))}]</span>`:''}</span>`).join('');
     const cols=COLS.map(([k,label])=>{
       let cards=pt.filter(t=>k==='testing'?(t.status==='testing'||t.status==='failed'):t.status===k);
       if(k==='done')cards=[...cards].sort((a,b)=>(b.updated||0)-(a.updated||0)); // newest finished on top
@@ -371,18 +408,46 @@ async function render(){
     const pmsgs=msgs.filter(m=>projOf(m)===p.project);
     const view = VIEWS[p.project] || "board";
     const vtog = `<div class="vtog"><button class="vbtn ${view==="board"?"on":""}" data-proj="${esc(p.project)}" data-view="board">BOARD</button><button class="vbtn ${view==="flow"?"on":""}" data-proj="${esc(p.project)}" data-view="flow">FLOW</button></div>`;
-    return `<div class="proj">`+
-      `<div class="proj-h"><span class="pname">📁 <b>${esc(p.project)}</b></span>${vtog}<div class="agents">${agents||'<span class="dim">no agents</span>'}</div><span class="spacer"></span><span class="prog">${done}/${pt.length} done · ${pct}%</span></div>`+
+    const ctl=`<span class="mv"><b class="mvup" data-proj="${esc(p.project)}" title="move up">▲</b><b class="mvdn" data-proj="${esc(p.project)}" title="move down">▼</b></span>${p.idle===true?`<span class="pdel" data-proj="${esc(p.project)}" title="forget this project (cards, peers, brief) — it returns if an agent registers it again">✕</span>`:''}`;
+    return `<div class="proj${p.idle===true?' idle':''}" data-projname="${esc(p.project)}"${p.idle===true?` data-idleproj="${esc(p.project)}"`:''}>`+
+      `<div class="proj-h"><span class="pname">📁 <b>${esc(p.project)}</b></span>${vtog}<div class="agents">${agents||'<span class="dim">no agents</span>'}</div><span class="spacer"></span><span class="prog">${done}/${pt.length} done · ${pct}%</span>${ctl}</div>`+
       `<div class="proj-brief">${brief}${ph?`<span class="phase ${phaseClass(ph)}">${esc(ph)}</span>`:''}</div>`+
       `<div class="pbar"><i style="width:${pct}%"></i></div>`+
       (view === "flow" ? flowHTML(pt, p.project) : `<div class="kanban">${cols}</div>`)+
       chatLane(pmsgs)+
     `</div>`;
-  }).join('');
+  };
+  // idle projects (zero online agents) collapse to thin rows below the live boards
+  const idleRow=p=>{
+    const pt=tasks.filter(t=>t.project===p.project);const done=pt.filter(t=>t.status==='done').length;
+    return `<div class="idle-row" data-projname="${esc(p.project)}" data-idleproj="${esc(p.project)}" title="click to expand">💤 <span class="nm">${esc(p.project)}</span><span class="dim">· ${esc(p.phase||'')} · ${done}/${pt.length} cards</span><span class="spacer"></span><span class="mv"><b class="mvup" data-proj="${esc(p.project)}" title="move up">▲</b><b class="mvdn" data-proj="${esc(p.project)}" title="move down">▼</b></span><span class="pdel" data-proj="${esc(p.project)}" title="forget this project (cards, peers, brief) — it returns if an agent registers it again">✕</span></div>`;
+  };
+  const live=projects.filter(p=>p.idle!==true),idlers=projects.filter(p=>p.idle===true);
+  el.innerHTML=(ORDER.length?`<div class="sortmode" id="sortreset" title="you've ordered projects manually — click to go back to automatic (recency) ordering">sort: manual · ↺ back to auto</div>`:'')
+    +live.map(projBlock).join('')
+    +(idlers.length?`<div class="idle-head">idle projects · ${idlers.length}</div>`+idlers.map(p=>idleOpen.has(p.project)?projBlock(p):idleRow(p)).join(''):'');
   // keep each project's chat scrolled to the latest line
   el.querySelectorAll('.chatlog').forEach(c=>{if(c.scrollHeight-c.clientHeight<60||c.dataset.stuck!=='0')c.scrollTop=c.scrollHeight;c.onscroll=()=>{c.dataset.stuck=(c.scrollHeight-c.scrollTop-c.clientHeight<40)?'1':'0';};});
   // click a card -> advance status todo->doing->done
   el.querySelectorAll('.vbtn').forEach(b=>b.onclick=()=>setView(b.dataset.proj,b.dataset.view));
+  // collapsed idle row -> expand; expanded idle project's header -> collapse again
+  el.querySelectorAll('.idle-row').forEach(r=>r.onclick=e=>{if(e.target.closest('.mv,.pdel'))return;toggleIdle(r.dataset.idleproj);});
+  el.querySelectorAll('.proj.idle .proj-h').forEach(h=>h.onclick=e=>{if(e.target.closest('.vbtn,.agent,.mv,.pdel'))return;toggleIdle(h.closest('.proj').dataset.idleproj);});
+  // ▲▼ reorder (persists as a manual order); ✕ forget — armed two-step, no popup
+  el.querySelectorAll('.mvup').forEach(b=>b.onclick=e=>{e.stopPropagation();moveProj(b.dataset.proj,-1);});
+  el.querySelectorAll('.mvdn').forEach(b=>b.onclick=e=>{e.stopPropagation();moveProj(b.dataset.proj,1);});
+  el.querySelectorAll('.pdel').forEach(b=>b.onclick=async e=>{
+    e.stopPropagation();
+    const p=b.dataset.proj;
+    if(!(armedDel===p&&Date.now()-armedTs<4000)){armedDel=p;armedTs=Date.now();b.classList.add('arm');b.textContent='✕ sure?';return;}
+    armedDel=null;
+    await fetch('/project/delete',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({project:p})});
+    render();
+  });
+  // the 2.5s re-render rebuilds the DOM — re-apply a still-fresh armed state so the
+  // "✕ sure?" confirmation survives until it expires instead of silently resetting
+  if(armedDel&&Date.now()-armedTs<4000){const ab=el.querySelector(`.pdel[data-proj="${CSS.escape(armedDel)}"]`);if(ab){ab.classList.add('arm');ab.textContent='✕ sure?';}}
+  const sr=$('#sortreset');if(sr)sr.onclick=()=>{localStorage.removeItem('abOrder');render();};
   wireFlow(el);
   el.querySelectorAll('.tcard, .fnode').forEach(c=>c.onclick=async()=>{
     const id=+c.dataset.id,t=tasks.find(x=>x.id===id);if(!t)return;
@@ -397,14 +462,25 @@ function addMsg(m,count=true){
   d.innerHTML=`<span class="t">${new Date(m.ts).toLocaleTimeString()}</span> ${iconFor(m.from,12)} <span class="from">${esc(m.from)}</span> → <span class="to">${esc(m.to)}</span>: ${esc(m.text)}`;
   const f=$('#feed');const stick=f.scrollHeight-f.scrollTop-f.clientHeight<50;f.appendChild(d);if(stick)f.scrollTop=f.scrollHeight;
 }
-function stream(){const ev=new EventSource('/stream?session=all');
+let _ev=null;
+function stream(){
+  try{_ev&&_ev.close();}catch(_){}                       // drop any prior connection before reopening (no duplicate streams)
+  const ev=new EventSource('/stream?session=all');_ev=ev;
   ev.onmessage=e=>{try{addMsg(JSON.parse(e.data));render();}catch(_){}};
-  ev.onerror=()=>{$('#livedot').classList.add('off');setTimeout(()=>{ev.close();stream();$('#livedot').classList.remove('off');},2000);};}
+  ev.onerror=()=>{$('#livedot').classList.add('off');setTimeout(()=>{ev.close();if(_ev===ev)stream();$('#livedot').classList.remove('off');},2000);};}
 $('#send').onclick=async()=>{const t=$('#text').value.trim();if(!t)return;
   await fetch('/send',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({from:'dashboard',to:$('#to').value,text:t})});$('#text').value='';};
 $('#text').addEventListener('keydown',e=>{if(e.key==='Enter')$('#send').click();});
 fetch('/recent?limit=40').then(r=>r.json()).then(d=>(d.messages||[]).forEach(m=>addMsg(m,false))).catch(()=>{});
 $('#hub').textContent=location.host;
 render();setInterval(render,2500);stream();
+// Self-heal after the laptop sleeps / the tab is backgrounded: browser timers and the SSE
+// stream get suspended and don't reliably resume, so the board freezes on stale data. The
+// moment the tab becomes visible / focused / regains network, force an immediate refresh +
+// stream reconnect — the equivalent of the heartbeat's "first action after wake" on the UI side.
+function wake(){render();stream();}
+document.addEventListener('visibilitychange',()=>{if(!document.hidden)wake();});
+addEventListener('focus',wake);
+addEventListener('online',wake);
 </script>
 </body></html>