trantor 0.15.0

package/bin/crew-runner.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+// agent-bus crew runner — keeps a crew agent alive forever without burning tokens.
+//
+//   node crew-runner.mjs <agent> [project-dir]
+//
+// The park problem: CLIs end their turn no matter what you prompt (harnesses actively kill
+// "call relay_wait repeatedly" loops). So the runner owns the waiting: it long-polls the bus
+// over plain HTTP (zero tokens, doubles as a heartbeat), and when a message addressed to this
+// agent arrives it RESUMES the CLI session (native resume = full context kept) with that
+// message as the prompt. The model just works and ends its turn; the runner does the rest.
+import { execSync, spawnSync } from "node:child_process";
+import { readFileSync, existsSync, appendFileSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+
+const AGENT = process.argv[2];
+const DIR = process.argv[3] || process.cwd();
+const PROJ = basename(DIR);
+const SESSION = `${AGENT}:${PROJ}`;
+if (!AGENT) { console.error("usage: crew-runner.mjs <agent> [project-dir]"); process.exit(1); }
+
+function hubUrl() {
+  if (process.env.RELAY_URL) return process.env.RELAY_URL;
+  try { const u = JSON.parse(readFileSync(join(homedir(), ".agent-bus", "config.json"), "utf8")).url; if (u) return u; } catch {}
+  return "http://127.0.0.1:4477";
+}
+const HUB = hubUrl();
+process.on("uncaughtException", (e) => { console.log(`\x1b[31m[runner] UNCAUGHT: ${e?.stack || e}\x1b[0m`); });
+process.on("unhandledRejection", (e) => { console.log(`\x1b[31m[runner] UNHANDLED REJECTION: ${e?.stack || e}\x1b[0m`); });
+const log = (s) => console.log(`\x1b[38;5;43m[runner]\x1b[0m ${s}`);
+const LOGDIR = join(homedir(), ".agent-bus", "logs");
+import { mkdirSync } from "node:fs";
+try { mkdirSync(LOGDIR, { recursive: true }); } catch {}
+let TURN = 0;
+const telemetry = (rec) => { try { appendFileSync(join(LOGDIR, `${AGENT}-${PROJ}.jsonl`), JSON.stringify(rec) + "\n"); } catch {} };
+const banner = (trigger) => {
+  console.log(`\x1b[2J\x1b[H\x1b[48;5;236m\x1b[38;5;43m  ◤ ${AGENT.toUpperCase()} ◢  agent-bus crew · ${PROJ} · turn ${TURN} · ${trigger}${MODEL ? ` · ${MODEL}` : ""}  \x1b[0m\n`);
+};
+
+async function api(path, body) {
+  const opts = body
+    ? { method: "POST", headers: { "content-type": "application/json", connection: "close" }, body: JSON.stringify(body) }
+    : { headers: { connection: "close" } };   // fresh socket per call — long-polls on stale keep-alive sockets reset
+  const r = await fetch(HUB + path, opts);
+  return r.json();
+}
+
+// ---- 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}`;
+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 " },
+  gemini:   { first: `gemini --yolo{M} -p "$(cat {P})"`,
+              next:  `gemini --yolo{M} -r latest -p "$(cat {P})"`, mflag: " -m " },
+  kimi:     { first: `kimi --print --yolo{M} -p "$(cat {P})" < /dev/null`,
+              next:  `kimi --print --yolo{M} -r {SID} -p "$(cat {P})" < /dev/null`, mflag: " --model ", sid: /To resume this session: kimi -r ([a-f0-9-]+)/ },
+  deepseek: { first: `opencode run{M} "$(cat {P})"`,
+              next:  `opencode run -c{M} "$(cat {P})"`, mflag: " -m ", env: join(homedir(), ".token-scrooge", ".env") },
+  opencode: { first: `opencode run{M} "$(cat {P})"`,
+              next:  `opencode run -c{M} "$(cat {P})"`, mflag: " -m ", env: join(homedir(), ".token-scrooge", ".env") },
+  claude:   { first: `claude{M} -p "$(cat {P})" --dangerously-skip-permissions`,
+              next:  `claude -c{M} -p "$(cat {P})" --dangerously-skip-permissions`, mflag: " --model " },
+};
+const cli = CLI[AGENT];
+if (!cli) { console.error(`unknown agent '${AGENT}' (known: ${Object.keys(CLI).join(", ")})`); process.exit(1); }
+
+const RULES = `Rules: you are ${SESSION} on the agent-bus 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.`;
+
+let sid = "";
+function runTurn(prompt, isFirst, trigger = "kickoff") {
+  TURN++; banner(trigger);
+  const t0 = Date.now();
+  const pf = join(homedir(), ".agent-bus", `turn-${AGENT}-${PROJ}.txt`);
+  appendFileSync(pf, "", { flag: "w" }); // truncate
+  appendFileSync(pf, prompt);
+  let cmd = (isFirst || (cli.sid && !sid)) ? cli.first : cli.next;
+  const mfrag = MODEL && cli.mflag ? `${cli.mflag}${MODEL}` : "";
+  cmd = cmd.replaceAll("{M}", mfrag).replaceAll("{P}", pf).replaceAll("{SID}", sid);
+  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], {
+    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,
+  });
+  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)`);
+  return r.status;
+}
+
+// ---- main loop ----
+const KICKOFF = process.env.CREW_KICKOFF ||
+  `You just joined. 1) relay_send to "all": "${AGENT} reporting — ready for a contract". 2) relay_inbox — if a contract for you is already waiting, do it now per the Rules. 3) End your turn.\n\n${RULES}`;
+
+let LESSONS = "";
+async function loadLessons() {
+  try {
+    const { lessons } = await api(`/lessons?agent=${encodeURIComponent(AGENT)}`);
+    if (lessons?.length) LESSONS = "\n\nLESSONS from previous crews (hard-won — follow them):\n" + lessons.map(l => `- [${l.scope}] ${l.text}`).join("\n");
+  } catch {}
+}
+
+(async () => {
+  await loadLessons();
+  // start cursor at the CURRENT tip so we don't replay history
+  let cursor = 0;
+  try { const r = await api(`/inbox?session=${encodeURIComponent(SESSION)}&since=0`); cursor = r.cursor || 0; } catch {}
+  await api("/register", { session: SESSION, project: PROJ, status: "crew member booting" }).catch(() => {});
+
+  let pendingBcast = [];
+  runTurn(KICKOFF + LESSONS, true, "kickoff");
+  log(`parked — long-polling the bus as ${SESSION} (free; this poll is also the heartbeat)`);
+
+  while (true) {
+    let msgs = [];
+    try {
+      const r = await api(`/poll?session=${encodeURIComponent(SESSION)}&since=${cursor}&wait=280`);
+      msgs = r.messages || []; cursor = r.cursor ?? cursor;
+    } catch (e) { log(`hub unreachable (${e.message}) — retrying in 5s`); await new Promise(s => setTimeout(s, 5000)); continue; }
+    if (!msgs.length) continue;                       // heartbeat tick, nothing for us
+    const direct = msgs.filter(m => m.to === SESSION);
+    const mentions = msgs.filter(m => m.to === "all" && (m.text.includes(`@${AGENT}`) || m.text.toLowerCase().includes(`${AGENT}:`)));
+    const bcast = msgs.filter(m => m.to === "all" && !mentions.includes(m));
+    pendingBcast.push(...bcast);                      // wake-policy: plain broadcasts batch, they don't wake
+    const wake = [...direct, ...mentions];
+    if (!wake.length) { if (bcast.length) log(`${bcast.length} broadcast(s) batched (no wake) — ${pendingBcast.length} pending`); continue; }
+    const ctx = pendingBcast.length ? `\nFYI broadcasts since your last turn (context only):\n${pendingBcast.map(m => `[${m.from} -> all]: ${m.text}`).join("\n")}\n` : "";
+    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");
+    log("parked — waiting for the next message");
+  }
+})();

package/bin/crew-verify.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+// crew-verify — prove that spawned crew agents ACTUALLY joined the bus (don't trust the spawn).
+//
+//   node crew-verify.mjs <project> <agent...> [--timeout 30]
+//
+// An agent counts as UP when its session (<agent>:<project>) has registered with a lastSeen
+// AFTER this verifier started. Prints one line per agent; exits non-zero listing failures —
+// the launcher retries those, and the orchestrator gets the truth instead of a green lie.
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+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;
+const [PROJ, ...AGENTS] = args;
+if (!PROJ || !AGENTS.length) { console.error("usage: crew-verify.mjs <project> <agent...> [--timeout 30]"); process.exit(2); }
+
+function hubUrl() {
+  if (process.env.RELAY_URL) return process.env.RELAY_URL;
+  try { const u = JSON.parse(readFileSync(join(homedir(), ".agent-bus", "config.json"), "utf8")).url; if (u) return u; } catch {}
+  return "http://127.0.0.1:4477";
+}
+const HUB = hubUrl();
+const START = 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) {
+    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);
+    } catch {}
+    if (up.size < want.size) await new Promise(s => setTimeout(s, 1500));
+  }
+  const failed = [...want].filter(s => !up.has(s));
+  for (const s of want) console.log(`${up.has(s) ? "✓" : "✗"} ${s} ${up.has(s) ? "on the bus" : `NOT on the bus after ${TIMEOUT}s`}`);
+  if (failed.length) { console.log(`FAILED:${failed.map(s => s.split(":")[0]).join(",")}`); process.exit(1); }
+})();

package/bin/crew.sh

@@ -0,0 +1,125 @@
+#!/bin/bash
+# agent-bus crew launcher v2 — visible terminal windows that CANNOT silently die or silently fail.
+#
+#   bin/crew.sh up codex gemini kimi deepseek    # one window per agent, in the CURRENT project dir
+#   bin/crew.sh down                             # kill crew processes + close windows (no dialogs)
+#
+# Each window runs bin/crew-runner.mjs: the CLI does one turn and exits; the RUNNER long-polls
+# the bus (free, doubles as heartbeat) and resumes the CLI — with full context — whenever a
+# message arrives. No model-side parking, no harness fights, no token burn while idle.
+#
+# Spawns are SERIALIZED and then VERIFIED on the bus (crew-verify.mjs); failures retry once and
+# are reported loudly — the orchestrator never gets a green lie.
+#
+# Geometry: "crewRect": "X,Y,W,H" in ~/.agent-bus/config.json (or CREW_RECT env) — set once per
+# machine; used for every spawn including respawns. Default: right half of the main display.
+set -u
+CMD="${1:-up}"; shift 2>/dev/null || true
+DIR="$(pwd)"
+PROJ="$(basename "$DIR")"
+BUS_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+STATE="$HOME/.agent-bus/crew-windows.txt"
+mkdir -p "$HOME/.agent-bus"
+
+down() {
+  [ -f "$STATE" ] || { echo "no tracked crew windows"; return 0; }
+  while read -r wid; do
+    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
+      # makes Terminal raise the "Terminate running processes?" dialog on close.
+      for pid in $(ps -t "${TTY#/dev/}" -o pid= 2>/dev/null); do kill -9 "$pid" 2>/dev/null; done
+    fi
+  done < "$STATE"
+  sleep 1
+  while read -r wid; do
+    osascript -e "tell application \"Terminal\" to close (first window whose id is $wid)" 2>/dev/null
+  done < "$STATE"
+  sleep 0.5
+  osascript -e 'tell application "System Events" to tell process "Terminal"' \
+            -e 'repeat with w in windows' -e 'try' \
+            -e 'if exists sheet 1 of w then click button "Terminate" of sheet 1 of w' \
+            -e 'end try' -e 'end repeat' -e 'end tell' >/dev/null 2>&1
+  rm -f "$STATE"
+  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; }
+
+if [ "$(uname)" != "Darwin" ]; then
+  echo "Window spawning is macOS-only. Run one per terminal, in $DIR:"
+  for a in "$@"; do echo "  node $BUS_DIR/bin/crew-runner.mjs $a $DIR"; done
+  exit 0
+fi
+
+# one-time wiring for every detected CLI (idempotent, backed up)
+node "$BUS_DIR/bin/connect.mjs" | tail -n +2
+
+# ---- geometry: AUTO-DETECTED from the screen you're working on (never hard-coded coords).
+# NSScreen.mainScreen = the display with keyboard focus; visibleFrame excludes menu bar/Dock.
+# Crew tiles into the RIGHT 58% of THAT screen (left side stays for dashboard/main terminal).
+# One-off override: CREW_RECT="X,Y,W,H" env (no persistent config — display setups change).
+if [ -n "${CREW_RECT:-}" ]; then
+  IFS=',' read -r GX GY GW GH <<< "$CREW_RECT"
+else
+  eval "$(osascript -l JavaScript -e '
+    ObjC.import("AppKit");
+    const f=$.NSScreen.mainScreen.visibleFrame, prim=$.NSScreen.screens.objectAtIndex(0).frame;
+    const yTop = prim.size.height - (f.origin.y + f.size.height);
+    const x=Math.round(f.origin.x), y=Math.round(yTop), w=Math.round(f.size.width), h=Math.round(f.size.height);
+    `SX=${x} SY=${y} SW=${w} SH=${h}`' 2>/dev/null)"
+  if [ -z "${SW:-}" ]; then  # fallback: primary display via Finder
+    read -r SX SY SW SH <<< "$(osascript -e 'tell application "Finder" to get bounds of window of desktop' | tr ',' ' ')"
+    SY=25; SH=$(( SH - 25 ))
+  fi
+  GX=$(( SX + SW * 42 / 100 )); GY=$SY; GW=$(( SW * 58 / 100 )); GH=$SH
+fi
+echo "— crew area: ${GW}x${GH} at ${GX},${GY} (focused screen, auto-detected) —"
+
+spawn_grid() {  # $@ = agents — (re)computes the grid for THIS batch and spawns serially
+  local N=$# COLS=2
+  [ $N -le 2 ] && COLS=1
+  local ROWS=$(( (N + COLS - 1) / COLS ))
+  local CW=$(( GW / COLS )) CH=$(( GH / ROWS ))
+  local i=0 SPEC AGENT MODEL
+  for SPEC in "$@"; do
+    AGENT="${SPEC%%:*}"                       # agent[:model] — model rides in as CREW_MODEL
+    MODEL=""; [ "$SPEC" != "$AGENT" ] && MODEL="${SPEC#*:}"
+    local C=$(( i % COLS )) R=$(( i / COLS ))
+    local X1=$(( GX + C * CW )) Y1=$(( GY + R * CH ))
+    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:]') — agent-bus 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"
+    sleep 1.2   # serialize — rapid-fire 'do script' calls race and silently drop windows
+    i=$(( i + 1 ))
+  done
+}
+
+echo "— spawning crew (serialized) —"
+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)
+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)
+  echo "$VER2"
+  STILL=$(echo "$VER2" | grep "^FAILED:" | cut -d: -f2)
+  if [ -n "$STILL" ]; then
+    echo ""
+    echo "✗✗ CREW INCOMPLETE — these agents are NOT on the bus: $STILL"
+    echo "   Do NOT assign them work. Investigate their windows or run: crew.sh up ${STILL//,/ }"
+    exit 1
+  fi
+fi
+echo "— crew verified on the bus. Send contracts with relay_send; runners keep agents alive for free. Teardown: crew.sh down —"

package/bin/doctor.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+// trantor doctor — tell a fresh user exactly where they stand and what to do next.
+// Checks: runtime, hub, plugin, each CLI (installed? wired? AUTHENTICATED?), API keys,
+// quota profile, optional Scrooge brain. Prints a checklist with copy-paste fixes.
+//   node bin/doctor.mjs
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const H = homedir();
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const has = (c) => { try { execSync(`command -v ${c}`, { stdio: "ignore", shell: "/bin/sh" }); return true; } catch { return false; } };
+const read = (p) => { try { return JSON.parse(readFileSync(p, "utf8")); } catch { return null; } };
+const ok = (m) => console.log(`  ✓ ${m}`);
+const warn = (m, fix) => { console.log(`  ✗ ${m}`); if (fix) console.log(`      → ${fix}`); issues++; };
+let issues = 0;
+
+console.log("TRANTOR DOCTOR\n");
+
+// runtime + hub
+console.log("core");
+Number(process.versions.node.split(".")[0]) >= 18 ? ok(`node ${process.versions.node}`) : warn(`node ${process.versions.node} too old`, "install node >= 18");
+const cfg = read(join(H, ".agent-bus", "config.json")) || {};
+const HUB = process.env.RELAY_URL || cfg.url || "http://127.0.0.1:4477";
+try {
+  const h = await (await fetch(`${HUB}/health`, { signal: AbortSignal.timeout(2000) })).json();
+  ok(`hub up at ${HUB} (${h.peers} peers known)`);
+} catch {
+  warn(`hub not reachable at ${HUB}`, `bash ${join(ROOT, "deploy", "setup.sh")}   # installs the always-on service`);
+}
+
+// claude plugin
+console.log("\nclaude (the orchestrator)");
+if (!has("claude")) warn("claude CLI not found", "install Claude Code: https://claude.com/claude-code");
+else {
+  const st = read(join(H, ".claude", "settings.json")) || {};
+  Object.keys(st.enabledPlugins || {}).some(k => k.startsWith("agent-bus@") || k.startsWith("trantor@"))
+    ? ok("plugin installed")
+    : warn("plugin not installed", "claude plugin marketplace add sashabogi/trantor && claude plugin install agent-bus");
+}
+
+// crew CLIs: installed / wired / authenticated
+console.log("\ncrew CLIs (install any subset — seats follow the work)");
+const CLIS = [
+  { name: "codex",  bin: "codex",    wired: () => (readFileSync(join(H, ".codex", "config.toml"), "utf8")).includes("[mcp_servers.relay]"), auth: () => existsSync(join(H, ".codex", "auth.json")), login: "codex   (sign in with your ChatGPT account on first run)" },
+  { name: "gemini", bin: "gemini",   wired: () => !!read(join(H, ".gemini", "settings.json"))?.mcpServers?.relay, auth: () => existsSync(join(H, ".gemini", "oauth_creds.json")) || !!process.env.GEMINI_API_KEY || !!process.env.GOOGLE_API_KEY, login: "gemini   (Google sign-in on first run, or set GEMINI_API_KEY)" },
+  { name: "kimi",   bin: "kimi",     wired: () => !!read(join(H, ".kimi", "mcp.json"))?.mcpServers?.relay, auth: () => existsSync(join(H, ".kimi", "credentials")), login: "kimi → /login   (Kimi account or Moonshot API key)" },
+  { name: "deepseek (via opencode)", bin: "opencode", wired: () => !!read(join(H, ".config", "opencode", "opencode.json"))?.mcp?.relay, auth: () => !!process.env.DEEPSEEK_API_KEY || (existsSync(join(H, ".agent-bus", ".env")) && readFileSync(join(H, ".agent-bus", ".env"), "utf8").includes("DEEPSEEK_API_KEY")) || !!read(join(H, ".local", "share", "opencode", "auth.json")), login: `get a key at platform.deepseek.com, then: echo 'DEEPSEEK_API_KEY=sk-…' >> ~/.agent-bus/.env` },
+];
+let installed = 0;
+for (const c of CLIS) {
+  if (!has(c.bin)) { console.log(`  – ${c.name}: not installed (optional)`); continue; }
+  installed++;
+  let wired = false; try { wired = c.wired(); } catch {}
+  wired ? ok(`${c.name}: wired to the bus`) : warn(`${c.name}: installed but not wired`, `node ${join(ROOT, "bin", "connect.mjs")}`);
+  let authed = false; try { authed = c.auth(); } catch {}
+  authed ? ok(`${c.name}: authenticated`) : warn(`${c.name}: NOT authenticated — it will join the bus but fail on its first turn`, c.login);
+}
+if (!installed) warn("no crew CLIs found", "install at least one of: codex, gemini, kimi, opencode — Trantor orchestrates whatever you have");
+
+// brain
+console.log("\nthe brain");
+has("scrooge") || existsSync(join(H, ".local", "bin", "scrooge"))
+  ? ok("economics engine installed (routing + cost ledger active)")
+  : warn("economics engine missing — Advisor runs without live pricing; relay_scrooge dormant", "trantor setup   (installs it automatically)");
+const prof = read(join(H, ".agent-bus", "profile.json"));
+prof?.providers && Object.keys(prof.providers).length
+  ? ok(`quota profile set (${Object.entries(prof.providers).map(([k, v]) => `${k}=${v.plan}`).join(", ")})`)
+  : warn("quota profile not set — the Advisor will assume API billing everywhere", `node ${join(ROOT, "bin", "profile.mjs")} set claude=max codex=plus deepseek=api …  (use YOUR real plans)`);
+
+console.log(issues ? `\n${issues} issue(s) — fix the → lines above, then re-run the doctor.` : "\nAll clear — open a claude session in any project and say: \"fire up the crew\".");
+process.exit(issues ? 1 : 0);

package/bin/handoff-prompt.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+# agent-bus handoff prompt (macOS) — shown when a session hits its context limit.
+# Asks the user, with a timeout, whether to open a FRESH same-agent session that takes
+# over via the handoff. Default (incl. timeout, or no UI) = open fresh. "Keep compacting" = skip.
+#
+# Usage: handoff-prompt.sh <project-dir> [timeout-seconds]
+# Agent to spawn = $AGENT_CMD (default "claude") — same agent, fresh window.
+DIR="${1:-$HOME}"
+TIMEOUT="${2:-25}"
+AGENT_CMD="${AGENT_CMD:-claude}"
+HERE="$(cd "$(dirname "$0")" && pwd)"
+NAME="$(basename "$DIR")"
+
+MSG="agent-bus — this session's context window is full ($NAME). Open a FRESH session to take over with a full window? It loads a handoff of this session. (The current session keeps compacting either way.)"
+
+# Best-effort timed dialog. On timeout, error, or no UI session -> empty -> we spawn (the default).
+CHOICE="$(osascript -e "button returned of (display dialog \"${MSG//\"/\\\"}\" buttons {\"Keep compacting\", \"Open fresh session\"} default button \"Open fresh session\" giving up after $TIMEOUT with title \"agent-bus\")" 2>/dev/null)"
+
+if [ "$CHOICE" != "Keep compacting" ]; then
+  "$HERE/open-session.sh" "$DIR" "$AGENT_CMD"
+fi

package/bin/open-session.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+# open-session.sh <dir> <command...> — open a NEW macOS Terminal window in <dir> running <command>.
+# Lets a Claude session spawn sibling terminal sessions (e.g. to test multi-session relay flows).
+DIR="${1:-$HOME}"; shift; CMD="$*"
+osascript >/dev/null <<OSA
+tell application "Terminal"
+  do script "cd " & quoted form of "$DIR" & " && $CMD"
+  activate
+end tell
+OSA

package/bin/profile.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+// agent-bus quota profile — declare what plan each provider runs on, once.
+// The Advisor uses this to pick execution modes (plans can't be detected reliably).
+//
+//   node bin/profile.mjs                       # show current profile
+//   node bin/profile.mjs set claude=max codex=plus gemini=tier kimi=coding-plan deepseek=api
+//   node bin/profile.mjs set claude=pro        # update one provider
+//
+// Plan vocabulary (free-form, but these mean something to the Advisor):
+//   api          — pay per token (offload aggressively; every orchestrator token is money)
+//   pro | plus | tier | coding-plan — a capped subscription (~$20-ish: crew is the only path
+//                  for real builds; the plan's quota is a scarce budget)
+//   max | max-5x | max-20x | ultra — high-tier subscription (cost moot; context horizon decides)
+//   none         — provider not available on this machine
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const FILE = join(homedir(), ".agent-bus", "profile.json");
+const KNOWN = ["claude", "codex", "gemini", "kimi", "deepseek", "opencode"];
+const TIER = (plan) => {
+  const p = String(plan || "none").toLowerCase();
+  if (p === "api") return "api";
+  if (/^(max|ultra)/.test(p)) return "high-sub";
+  if (p === "none") return "none";
+  return "capped-sub";                                  // pro/plus/tier/coding-plan/anything else
+};
+
+export function loadProfile() {
+  try { return JSON.parse(readFileSync(FILE, "utf8")); } catch { return { providers: {} }; }
+}
+export function tierOf(profile, provider) { return TIER(profile?.providers?.[provider]?.plan); }
+
+const [, , cmd, ...args] = process.argv;
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const prof = loadProfile();
+  prof.providers ||= {};
+  if (cmd === "set") {
+    for (const a of args) {
+      const [prov, plan] = a.split("=");
+      if (!prov || !plan) { console.error(`bad arg '${a}' — use provider=plan`); process.exit(1); }
+      prof.providers[prov.toLowerCase()] = { plan: plan.toLowerCase(), tier: TIER(plan) };
+    }
+    prof.updated = new Date().toISOString().slice(0, 10);
+    writeFileSync(FILE, JSON.stringify(prof, null, 2) + "\n");
+    console.log("profile saved →", FILE);
+  } else if (cmd && cmd !== "show") {
+    console.error("usage: profile.mjs [show] | set provider=plan …"); process.exit(1);
+  }
+  const p = loadProfile();
+  console.log("QUOTA PROFILE" + (existsSync(FILE) ? "" : "  (not set — Advisor will assume api billing everywhere)"));
+  for (const k of new Set([...KNOWN, ...Object.keys(p.providers || {})])) {
+    const e = (p.providers || {})[k];
+    console.log(`  ${k.padEnd(9)} ${e ? `${e.plan.padEnd(12)} → ${e.tier}` : "(unset)"}`);
+  }
+}

package/bin/relay-watch.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+// relay-watch — a live feed of the bus via SSE (true push, no polling). Run in a terminal
+// to watch sessions talk in real time, or to monitor a presence/status board.
+//   node bin/relay-watch.mjs [session]   (default: "all" — see every message)
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+function relayUrl() {
+  if (process.env.RELAY_URL) return process.env.RELAY_URL;
+  try { const c = join(homedir(), ".agent-bus", "config.json"); if (existsSync(c)) { const u = JSON.parse(readFileSync(c, "utf8")).url; if (u) return u; } } catch {}
+  return "http://127.0.0.1:4477";
+}
+const URL_BASE = relayUrl();
+const SESSION = process.argv[2] || "all";
+const t = () => new Date().toLocaleTimeString();
+
+async function showPeers() {
+  try {
+    const { peers } = await (await fetch(`${URL_BASE}/peers`)).json();
+    const live = peers.filter(p => p.online);
+    console.log(`\n  live sessions (${live.length}):`);
+    for (const p of live) console.log(`   🟢 ${p.session}${p.status ? `  — ${p.status}` : ""}`);
+    console.log("");
+  } catch {}
+}
+
+async function watch() {
+  console.log(`relay-watch → ${URL_BASE}  (watching "${SESSION}")  —  Ctrl-C to stop`);
+  await showPeers();
+  for (;;) {
+    try {
+      const r = await fetch(`${URL_BASE}/stream?session=${encodeURIComponent(SESSION)}`, { headers: { accept: "text/event-stream" } });
+      if (!r.ok || !r.body) throw new Error(`stream ${r.status}`);
+      let buf = "";
+      const dec = new TextDecoder();
+      for await (const chunk of r.body) {
+        buf += dec.decode(chunk, { stream: true });
+        let i;
+        while ((i = buf.indexOf("\n\n")) >= 0) {
+          const frame = buf.slice(0, i); buf = buf.slice(i + 2);
+          for (const line of frame.split("\n")) {
+            if (!line.startsWith("data:")) continue;
+            try { const m = JSON.parse(line.slice(5).trim()); console.log(`  [${t()}] ${m.from} → ${m.to}: ${m.text}`); } catch {}
+          }
+        }
+      }
+    } catch (e) {
+      console.error(`  (stream dropped: ${e?.message || e} — reconnecting in 2s)`);
+      await new Promise(r => setTimeout(r, 2000));
+    }
+  }
+}
+watch();

package/bin/statusline.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// agent-bus statusline — prints a tiny live indicator for the agent's status bar:
+//   🟢 agent-bus · 3 live
+// Claude Code: add to settings.json ->
+//   "statusLine": { "type": "command", "command": "node /path/to/agent-bus/bin/statusline.mjs" }
+// Reads session info as JSON on stdin (Claude Code convention); fast + fail-silent.
+import { readFileSync, existsSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir, hostname } from "node:os";
+
+function relayUrl() {
+  if (process.env.RELAY_URL) return process.env.RELAY_URL;
+  try { const c = join(homedir(), ".agent-bus", "config.json"); if (existsSync(c)) { const u = JSON.parse(readFileSync(c, "utf8")).url; if (u) return u; } } catch {}
+  return "http://127.0.0.1:4477";
+}
+async function main() {
+  let stdin = ""; try { for await (const c of process.stdin) stdin += c; } catch {}
+  let cwd = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  try { const j = JSON.parse(stdin || "{}"); cwd = j.cwd || j.workspace?.current_dir || cwd; } catch {}
+  const me = process.env.RELAY_SESSION || `${hostname()}:${basename(cwd)}`;
+  try {
+    const r = await fetch(`${relayUrl()}/peers`, { signal: AbortSignal.timeout(800) });
+    const { peers } = await r.json();
+    const live = peers.filter(p => p.online && p.session !== me).length;
+    process.stdout.write(`\x1b[38;5;43m● agent-bus\x1b[0m \x1b[2m· ${live} other${live === 1 ? "" : "s"} live\x1b[0m`);
+  } catch {
+    process.stdout.write(`\x1b[2m○ agent-bus offline\x1b[0m`);   // hub unreachable
+  }
+}
+main();

package/bin/write-handoff.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { writeFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir, hostname } from "node:os";
+import { execSync } from "node:child_process";
+const project = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const name = basename(project);
+let summary = ""; process.stdin.setEncoding("utf8");
+for await (const c of process.stdin) summary += c;
+const dir = join(homedir(), ".agent-bus", "handoffs");
+if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+const stamp = (() => { try { return execSync("date +%s",{encoding:"utf8"}).trim(); } catch { return String(process.pid); } })();
+let git=""; try { git = execSync("git -C "+JSON.stringify(project)+" status --short 2>/dev/null | head -30",{encoding:"utf8"}).trim(); } catch {}
+const rec = { id:`${name}-${stamp}`, project, projectName:name, machine:hostname(), trigger:"manual-skill", stamp:Number(stamp)||0, summary:summary.trim()||"(empty)", gitStatus:git, consumed:false };
+const file = join(dir, `${rec.id}.json`);
+writeFileSync(file, JSON.stringify(rec,null,2));
+console.log(`handoff saved: ${file}`);

package/configs/codex-config.toml

@@ -0,0 +1,6 @@
+# agent-bus for Codex CLI — add to ~/.codex/config.toml
+# Loading this MCP auto-registers the Codex session on the bus + gives the relay_* tools.
+[mcp_servers.relay]
+command = "node"
+args = ["REPLACE/WITH/ABSOLUTE/PATH/agent-bus/mcp.mjs"]
+env = { RELAY_URL = "http://127.0.0.1:4477", RELAY_SESSION = "codex:myproject" }

package/configs/gemini-settings.json

@@ -0,0 +1,10 @@
+{
+  "//": "agent-bus for Gemini CLI — merge into ~/.gemini/settings.json (or a project .gemini/settings.json).",
+  "mcpServers": {
+    "relay": {
+      "command": "node",
+      "args": ["REPLACE/WITH/ABSOLUTE/PATH/agent-bus/mcp.mjs"],
+      "env": { "RELAY_URL": "http://127.0.0.1:4477", "RELAY_SESSION": "gemini:myproject" }
+    }
+  }
+}

package/deploy/com.trantor.hub.plist

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<!-- trantor hub as an always-on launchd service. setup.sh fills the __PLACEHOLDERS__. -->
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>com.trantor.hub</string>
+  <key>ProgramArguments</key>
+  <array><string>__NODE__</string><string>__REPO__/hub.mjs</string></array>
+  <key>WorkingDirectory</key><string>__REPO__</string>
+  <key>EnvironmentVariables</key>
+  <dict><key>RELAY_HOST</key><string>127.0.0.1</string><key>RELAY_PORT</key><string>4477</string></dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>/tmp/trantor-hub.log</string>
+  <key>StandardErrorPath</key><string>/tmp/trantor-hub.log</string>
+</dict>
+</plist>