trantor 0.18.49 → 0.18.51

package/bin/drill-surface.mjs

@@ -7,25 +7,69 @@
 // handoff machine — and asserts on evidence (transcript rows, herdr state, ledger files),
 // never on exit codes alone.
 //
-// It is the ship gate for desktop/chat/handoff/crew changes: run it before every such release;
-// a red drill does not ship. (There is no scripted release path to wire it into — the release
-// dance is manual — so the gate is this command plus the contract that mandates it.)
+// This gate covers automated seams, including the installed app's dead-pane guard. Live
+// key/ask/Accounts checks belong to in-app Drill Mode; duty needs a live probe. Those checks
+// report SKIP with recipes and never auto-close. A failed seam or signed close exits nonzero.
 //
-// Flags: --keep  leave the scratch world in place for inspection (prints paths).
+// Flags: --keep leaves the scratch world AND workspace for inspection.
+// Failed runs retain disk evidence after closing their workspace. No app build/install.
+// TRANTOR_DRILL_RESULT overrides ~/.agent-bus/drill-result.json (crew seats use .agent-bus-out).
+// TRANTOR_DRILL_APP selects an existing app executable; TRANTOR_DRILL_WORLD selects scratch cwd.
 
-import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync, readdirSync, statSync } from "node:fs";
-import { join, basename } from "node:path";
-import { homedir, tmpdir } from "node:os";
+import { mkdirSync, mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync, readdirSync, statSync, symlinkSync } from "node:fs";
+import { join, basename, resolve } from "node:path";
+import { homedir } from "node:os";
 import { execFileSync, execSync, spawn } from "node:child_process";
 import { createConnection } from "node:net";
 
+import { pathToFileURL } from "node:url";
+import { DrillReport } from "./drill-report.mjs";
+import { sessionContext } from "../hooks/lib/api.mjs";
+import { runAppDrills, crewWorkspaceDrill, checkSocketHome } from "./drill-seams.mjs";
+import { shellQuote } from "./crew/core.mjs";
+
+// One ownership map. Shared steps must finish before ANY card they cover can close.
+export const CARD_STEPS = {
+  6799: { steps: ["S0", "S1", "S2", "S3", "S4", "S5"], autoClose: false },
+  6533: { steps: ["S6-ask"], autoClose: false, recipe: "covered by in-app Drill Mode: open a live orchestrator mid-ask, answer from Chat, and confirm the terminal advances and the card closes" },
+  6668: { steps: ["S6-handoff"], autoClose: true },
+  6317: { steps: ["S6-key-post", "S6-key-throw"], autoClose: false, recipe: "covered by in-app Drill Mode: open a real Workspace with a live terminal pane and exercise key dispatch in the terminal and composer" },
+  6667: { steps: ["S4b", "S7"], autoClose: true },
+  6587: { steps: ["S8"], autoClose: false, recipe: "needs live duty probe: operator removes the trantor/trantor-duty link, DMs the idle orchestrator, and checks for a socket nudge within 3 minutes" },
+  6481: { steps: ["S9"], autoClose: true },
+  6483: { steps: ["S10"], autoClose: false, recipe: "covered by in-app Drill Mode (#6800): operator checks Accounts with the CLI below the app minimum, then restores the CLI" },
+};
+
+export function findHandoff(dir, project) {
+  if (!existsSync(dir)) return null;
+  for (const name of readdirSync(dir)) {
+    if (!name.startsWith(`${project}-`) || !name.endsWith(".json")) continue;
+    const file = join(dir, name);
+    try {
+      const record = JSON.parse(readFileSync(file, "utf8"));
+      // relay_handoff can arrive before the hook ledger. Keep polling until states exist.
+      if (Array.isArray(record?.states) && record.states.length) return file;
+    } catch { /* A hook may still be writing this record; try it on the next poll. */ }
+  }
+  return null;
+}
+
+export async function main() {
 const KEEP = process.argv.includes("--keep");
 const G = "\x1b[32m", Rd = "\x1b[31m", Y = "\x1b[33m", D = "\x1b[2m", R = "\x1b[0m";
 let pass = 0, fail = 0, skip = 0;
-const PASS = (s, ev = "") => { pass++; console.log(`  ${G}PASS${R}  ${s}${ev ? `  ${D}${ev}${R}` : ""}`); };
-const FAIL = (s, ev = "") => { fail++; console.log(`  ${Rd}FAIL${R}  ${s}${ev ? `  ${D}${ev}${R}` : ""}`); };
-const SKIP = (s, why) => { skip++; console.log(`  ${Y}SKIP${R}  ${s}  ${D}${why}${R}`); };
-const step = (n) => console.log(`\n${n}`);
+const context = sessionContext();
+const output = resolve(process.env.TRANTOR_DRILL_RESULT || join(process.env.AGENT_BUS_DIR || join(homedir(), ".agent-bus"), "drill-result.json"));
+const report = new DrillReport(CARD_STEPS, output, context);
+let currentStep = null;
+const PASS = (s, ev = "") => { pass++; report.record(currentStep, "pass", s, ev); console.log(`  ${G}PASS${R}  ${s} [${report.cardsFor(currentStep).map(id => `#${id}`).join(", ")}]${ev ? `  ${D}${ev}${R}` : ""}`); };
+const FAIL = (s, ev = "") => { fail++; report.record(currentStep, "fail", s, ev); console.log(`  ${Rd}FAIL${R}  ${s} [${report.cardsFor(currentStep).map(id => `#${id}`).join(", ")}]${ev ? `  ${D}${ev}${R}` : ""}`); };
+const SKIP = (s, why) => { skip++; report.record(currentStep, "skip", s, why); console.log(`  ${Y}SKIP${R}  ${s}  ${D}${why}${R}`); };
+const step = (n) => {
+  if (currentStep) report.complete(currentStep);
+  currentStep = n.split(" ")[0];
+  console.log(`\n${n}`);
+};
 const sleep = (ms) => new Promise(r => setTimeout(r, ms));
 
 function herdr(args, { json = true } = {}) {
@@ -77,7 +121,9 @@ function userTurnsContaining(file, needle) {
     let r; try { r = JSON.parse(line); } catch { continue; }
     if (r?.type !== "user") continue;
     const c = r.message?.content;
+    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- SAFETY: JSONL content is a wire union of text or content blocks; this is its decode boundary.
     const t = typeof c === "string" ? c
+      // oxlint-disable-next-line anti-slop/no-runtime-typeof -- SAFETY: Untrusted JSONL blocks must be objects with type=text before reading their text field.
       : Array.isArray(c) ? c.map(b => (b && typeof b === "object" && b.type === "text") ? b.text : "").join(" ") : "";
     if (t.includes(needle)) hits.push(t);
   }
@@ -99,25 +145,23 @@ function assistantSaid(file, needle) {
 /** Start a Claude agent in a pane, answering the folder-trust dialog if it blocks startup
  *  (the P0b recovery: agent_not_ready keeps the name live; one enter accepts the fresh dir). */
 async function startClaude(name, paneId) {
-  let blocked = false;
-  try {
-    const r = herdr(["agent", "start", name, "--kind", "claude", "--pane", paneId]);
-    if (r.result?.agent?.agent_status === "idle") return "idle";
-    blocked = true;
-  } catch { blocked = true; }
-  if (blocked) {
-    await sleep(1500);
-    try { herdr(["agent", "send-keys", name, "enter"]); } catch {}
-    const settled = await waitFor("startup dialog answered", () => {
-      try {
-        const g = herdr(["agent", "get", name]);
-        const st = g.result?.agent?.agent_status;
-        return st === "idle" ? st : null;
-      } catch { return null; }
-    }, { timeoutMs: 45_000, everyMs: 2_000 });
-    return settled || "not-ready";
-  }
-  return "not-ready";
+  // Run in the pane shell: herdr agent start restores the server's child-session flag.
+  herdr(["pane", "run", paneId, "env -u CLAUDECODE -u CLAUDE_CODE_CHILD_SESSION claude"], { json: false });
+  let trusted = false;
+  const settled = await waitFor("startup", () => {
+    const screen = herdr(["pane", "read", paneId], { json: false });
+    if (!trusted && screen.includes("Yes, I trust this")) {
+      // New Claude versions default to No. Answer ONLY this drill-owned folder dialog.
+      const keys = /❯\s*No, exit/.test(screen) ? ["down", "enter"] : ["enter"];
+      herdr(["pane", "send-keys", paneId, ...keys], { json: false });
+      trusted = true;
+    }
+    try {
+      const status = herdr(["agent", "get", paneId]).result?.agent?.agent_status;
+      return status === "idle" ? status : null;
+    } catch { return null; }
+  }, { timeoutMs: 45000, everyMs: 1500 });
+  return settled || "not-ready";
 }
 
 // ---------- S0 · version skew ----------
@@ -136,9 +180,9 @@ step("S0 · version skew (hooks vs CLI vs app)");
   try { app = execSync('plutil -extract CFBundleShortVersionString raw "/Applications/Trantor.app/Contents/Info.plist"', { encoding: "utf8" }).trim(); } catch {}
   console.log(`  ${D}cli ${cli} · plugin ${plugin} · app ${app}${R}`);
   if (plugin === "?") {
-    console.log(`  ${Y}WARN${R}  plugin hook version unreadable — cannot rule out skew`);
+    SKIP("hook/CLI version skew", "plugin hook version unreadable");
   } else if (plugin !== cli) {
-    console.log(`  ${Y}WARN${R}  installed plugin hooks (${plugin}) differ from this tree (${cli}) — running sessions use the PLUGIN's hooks`);
+    FAIL("hook/CLI version skew", `plugin ${plugin} vs CLI ${cli}`);
   } else {
     PASS("no hook/CLI version skew", `${cli}`);
   }
@@ -148,11 +192,17 @@ step("S0 · version skew (hooks vs CLI vs app)");
 // ---------- world ----------
 // NOT tmpdir(): macOS tmp is a /var symlink and Claude records the /private/var realpath,
 // so the transcript-slug lookup would miss. A dot-dir under $HOME has no such alias.
-const world = join(homedir(), `.tt-drill-${process.pid}`);
-const proj = join(world, "drill-proj");
-const bus = join(world, "bus");
+const scratch = join(process.cwd(), ".agent-bus-out");
+mkdirSync(scratch, { recursive: true });
+const world = process.env.TRANTOR_DRILL_WORLD
+  ? resolve(process.env.TRANTOR_DRILL_WORLD) : mkdtempSync(`${scratch}/`);
+checkSocketHome(world);
+const proj = join(world, context.project);
+const bus = join(world, ".agent-bus");
 mkdirSync(proj, { recursive: true });
 mkdirSync(join(bus, "handoffs"), { recursive: true });
+mkdirSync(join(world, ".config", "herdr"), { recursive: true });
+symlinkSync(join(homedir(), ".config", "herdr", "herdr.sock"), join(world, ".config", "herdr", "herdr.sock"));
 execFileSync("git", ["init", "-q"], { cwd: proj });
 // The drill's handoff phase exercises the AUTO chain deliberately; the shipped default is ask.
 writeFileSync(join(bus, "autonomy.json"), JSON.stringify({ version: 1, defaults: { baton: "auto" }, projects: {} }));
@@ -160,25 +210,37 @@ const projectName = basename(proj);
 const tDir = transcriptDirFor(proj);
 
 let ws = null, pane = null;
+let cleaned = false;
 const cleanup = () => {
+  if (cleaned) return;
+  cleaned = true;
   if (KEEP) { console.log(`\n${D}--keep: world at ${world} · workspace ${ws?.workspace_id || "?"} left open${R}`); return; }
   try { if (pane) herdr(["agent", "prompt", pane, "/exit"], { json: true }); } catch {}
   try { if (ws) herdr(["workspace", "close", ws.workspace_id], { json: true }); } catch {}
+  if (fail > 0) { console.log(`failed-run evidence retained at ${world}`); return; }
   try { rmSync(world, { recursive: true, force: true }); } catch {}
 };
 process.on("exit", cleanup);
+for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => {
+  if (currentStep) FAIL("drill interrupted", signal);
+  cleanup();
+  process.exit(signal === "SIGINT" ? 130 : 143);
+});
 
+try {
 // ---------- S1 · cold start ----------
 step("S1 · cold start: workspace, clean env, agent, transcript EXISTS");
 try {
   const created = herdr(["workspace", "create", "--cwd", proj, "--label", "tt-drill"]);
   ws = { workspace_id: created.result.workspace.workspace_id };
   pane = created.result.root_pane.pane_id;
+  writeFileSync(join(bus, "crew-windows.txt"), `${projectName}\therdrws\t__ws__\t${ws.workspace_id}\n${projectName}\torch\torchestrator\t${pane}\n`);
   PASS("throwaway herdr workspace", `${ws.workspace_id} pane ${pane}`);
   // The P0b trap, prevented at the source: a pane inheriting CLAUDE_CODE_CHILD_SESSION runs
   // Claude with transcript saving OFF — an invisible session. Every spawn path must clear it.
   herdr(["pane", "run", pane,
-    `unset CLAUDE_CODE_CHILD_SESSION; export AGENT_BUS_DIR=${bus} RELAY_URL=http://127.0.0.1:1 ` +
+    // Heartbeat throttling is keyed by relay identity; never share the live orchestrator's stamp.
+    `unset CLAUDECODE CLAUDE_CODE_CHILD_SESSION RELAY_AGENT TRANTOR_ORCH TRANTOR_SEAT; export RELAY_SESSION=drill-${process.pid}:${projectName} RELAY_PROJECT=${projectName} AGENT_BUS_DIR=${bus} RELAY_URL=http://127.0.0.1:1 ` +
     `TRANTOR_NO_SCROOGE=1 TRANTOR_NO_HANDOFF_SPAWN=1 TRANTOR_NO_BALANCE_CHECK=1 ` +
     `RELAY_CONTEXT_WARN_FRAC=0.000001 RELAY_STOP_TIMEOUT_MS=300 RELAY_CONTEXT_WINDOW=1000000; echo ENV-READY`], { json: false });
   await sleep(1500);
@@ -188,7 +250,7 @@ try {
 } catch (e) {
   FAIL("S1 world setup", String(e.message || e).slice(0, 160));
   console.log(`\n${Rd}cannot continue without S1${R}`);
-  process.exit(1);
+  throw e;
 }
 
 // ---------- S2 · transport ----------
@@ -220,7 +282,7 @@ const MARK = `drill-${Date.now() % 100000}`;
 step("S3 · identity: the pane itself names the session (Phase 2)");
 let predecessorSid = null;
 {
-  const got = herdr(["agent", "get", "drill"]);
+  const got = herdr(["agent", "get", pane]);
   const as = got.result?.agent?.agent_session;
   const tfile = newestJsonl(tDir);
   predecessorSid = as?.kind === "id" ? as.value : null;
@@ -237,18 +299,12 @@ step("S4 · handoff machine: warn → arm → fire → WRITTEN → successor cla
   // The heartbeat is PostToolUse: only a REAL tool call can arm the baton. Models sometimes
   // answer without the tool (observed: run 2 of 3 on 2026-08-30 — 1-in-3 prompt fragility,
   // not a seam), so ask, verify tool use in the transcript, and re-ask up to twice.
-  const findHandoff = () => {
-    try {
-      const f = readdirSync(join(bus, "handoffs")).find(x => x.startsWith(`${projectName}-`) && x.endsWith(".json"));
-      return f ? join(bus, "handoffs", f) : null;
-    } catch { return null; }
-  };
   let handoffFile = null;
   for (let attempt = 1; attempt <= 3 && !handoffFile; attempt++) {
     const raw = await socketRequest({ id: "trantor:agent.prompt", method: "agent.prompt", params: {
       target: pane, text: `You MUST call the Bash tool now and run exactly: pwd — do not answer without calling it. Then reply with just DONE-S4-${attempt}.` } });
     if (JSON.parse(raw).result?.type !== "agent_prompted") { FAIL("S4 prompt accepted", raw.slice(0, 100)); break; }
-    handoffFile = await waitFor("handoff written", findHandoff, { timeoutMs: 120_000, everyMs: 2_000 });
+    handoffFile = await waitFor("handoff written", () => findHandoff(join(bus, "handoffs"), projectName), { timeoutMs: 120_000, everyMs: 2_000 });
     if (!handoffFile) console.log(`  ${D}attempt ${attempt}: no handoff yet — re-asking with the tool requirement${R}`);
   }
   if (!handoffFile) {
@@ -260,7 +316,7 @@ step("S4 · handoff machine: warn → arm → fire → WRITTEN → successor cla
     else FAIL("§5 ledger opens with WRITTEN", states.join(","));
 
     // Successor: end the predecessor, start fresh in the SAME pane — the claim is sessionstart's.
-    try { herdr(["agent", "prompt", "drill", "/exit"]); } catch {}
+    try { herdr(["agent", "prompt", pane, "/exit"]); } catch {}
     await sleep(4000);
     const st2 = await startClaude("drill2", pane);
     if (st2 !== "idle") FAIL("successor claude starts", String(st2));
@@ -315,7 +371,7 @@ step("S4b · --baton pane leg: the driver replaces the session in place, kickoff
     try {
       const wh = execFileSync(process.execPath, [join(import.meta.dirname, "write-handoff.mjs")], {
         input: "# handoff\nS4b: the pane leg drill — recap me.", encoding: "utf8", timeout: 30_000,
-        env: { ...process.env, CLAUDE_PROJECT_DIR: proj, AGENT_BUS_DIR: bus, TRANTOR_NO_HANDOFF_SPAWN: "1", TRANTOR_NO_BATON_SPAWN: "1" },
+        env: { ...process.env, RELAY_PROJECT: projectName, RELAY_SESSION: "", RELAY_AGENT: "", TRANTOR_ORCH: "", RELAY_URL: "http://127.0.0.1:1", CLAUDE_PROJECT_DIR: proj, AGENT_BUS_DIR: bus, TRANTOR_NO_HANDOFF_SPAWN: "1", TRANTOR_NO_BATON_SPAWN: "1" },
       });
       hf = /handoff saved: (\S+\.json)/.exec(wh)?.[1] || null;
     } catch (e) { FAIL("S4b manual handoff written", String(e.message || e).slice(0, 120)); }
@@ -323,8 +379,8 @@ step("S4b · --baton pane leg: the driver replaces the session in place, kickoff
       PASS("manual handoff written for the pane to carry", basename(hf));
       const child = spawn(process.execPath, [join(import.meta.dirname, "baton-pane.mjs"),
         "--project", proj, "--handoff", hf, "--pane", pane], {
-        env: { ...process.env, AGENT_BUS_DIR: bus, TRANTOR_BATON_IDLE_DEADLINE_S: "90",
-          TRANTOR_BATON_REOPEN: `herdr agent start drill3 --kind claude --pane ${pane}` },
+        env: { ...process.env, HOME: world, TRANTOR_DEV_ROOT: world, RELAY_PROJECT: projectName, RELAY_SESSION: "", RELAY_AGENT: "", TRANTOR_ORCH: "", RELAY_URL: "http://127.0.0.1:1", AGENT_BUS_DIR: bus, TRANTOR_BATON_IDLE_DEADLINE_S: "90",
+          TRANTOR_BATON_REOPEN: `${shellQuote(process.execPath)} ${shellQuote(join(import.meta.dirname, "cli.mjs"))} open ${shellQuote(projectName)}` },
         stdio: "ignore",
       });
       const exited = new Promise(res => child.on("exit", c => res(c)));
@@ -334,14 +390,17 @@ step("S4b · --baton pane leg: the driver replaces the session in place, kickoff
         for (let i = 0; i < 40; i++) {
           await sleep(3000);
           try {
-            const g = herdr(["agent", "get", "drill3"]);
+            const g = herdr(["agent", "get", pane]);
             const st = g.result?.agent?.agent_status;
-            if (st === "blocked") herdr(["agent", "send-keys", "drill3", "enter"]);
+            if (st === "blocked") herdr(["agent", "send-keys", pane, "enter"]);
             if (st === "idle") break;
           } catch {}
         }
       })();
-      const code = await Promise.race([exited, sleep(180_000).then(() => "timeout")]);
+      let timer;
+      const code = await Promise.race([exited, new Promise(resolve => { timer = setTimeout(() => resolve("timeout"), 180_000); })]);
+      clearTimeout(timer);
+      if (code === "timeout") child.kill("SIGTERM");
       await watcher;
       if (code === 0) PASS("driver ran the whole chain (idle gate → graceful end → reopen → kickoff)");
       else FAIL("driver ran the whole chain", `exit ${code} — see ${join(bus, "logs")}/baton-pane-*.log`);
@@ -367,6 +426,50 @@ step("S4b · --baton pane leg: the driver replaces the session in place, kickoff
 step("S5 · takeover from a Terminal session");
 SKIP("takeover chain", "needs an interactive Terminal-window session; proven live 2026-08-28 (0.18.13 drill) — automate in drill v2");
 
+} catch (error) {
+  FAIL("seam interrupted", error.message);
+}
+
+const run = async (name, fn) => {
+  step(name);
+  try { PASS(name, await fn()); } catch (error) { FAIL(name, error.message); }
+};
+step("S6-ask · app AskUserQuestion");
+SKIP("app AskUserQuestion", CARD_STEPS[6533].recipe);
+await runAppDrills({ world, proj, project: projectName, run });
+for (const mode of ["post", "throw"]) {
+  step(`S6-key-${mode} · app key dispatch`);
+  SKIP("app key dispatch", CARD_STEPS[6317].recipe);
+}
+await run("S7 · reopen-race", async () => {
+  // S4b records the production driver log plus successor claim. A rerun cannot reuse an old log.
+  const logs = readdirSync(join(bus, "logs")).filter(name => name.startsWith("baton-pane-"));
+  const trace = logs.map(name => readFileSync(join(bus, "logs", name), "utf8")).join("\n");
+  const handoff = /armed: .*handoff=(\S+)/.exec(trace)?.[1];
+  const record = handoff && JSON.parse(readFileSync(join(bus, "handoffs", handoff), "utf8"));
+  const ended = /^(\S+) ended pid /m.exec(trace)?.[1];
+  const reopened = /^(\S+) reopen starting via:/m.exec(trace)?.[1];
+  const elapsed = Date.parse(reopened) - Date.parse(ended);
+  if (!record?.states?.some(row => row.state === "claimed") || !trace.includes("reopen result: status=0")
+      || !trace.includes("agent drop dropped") || !Number.isFinite(elapsed) || elapsed < 0 || elapsed > 1000)
+    throw new Error(`no complete sub-second end/drop/reopen/claim proof; elapsed=${elapsed}; ${trace.trim().slice(-700)}`);
+  return `${handoff} claimed; reopen after ${elapsed}ms; ${trace.trim().split("\n").join("; ")}`;
+});
+step("S8 · duty wake-chain");
+SKIP("duty wake-chain", CARD_STEPS[6587].recipe);
+await run("S9 · crew workspace ownership", () => crewWorkspaceDrill({ proj, workspace: ws?.workspace_id }));
+step("S10 · provider CLI source");
+SKIP("provider CLI source", CARD_STEPS[6483].recipe);
+if (currentStep) report.complete(currentStep);
+if (!await report.closePassed()) fail++;
+console.log(`\nresult: ${output}`);
+console.log(JSON.stringify(report.results(), null, 2));
+cleanup();
 // ---------- verdict ----------
-console.log(`\n${fail === 0 ? G + "DRILL GREEN" : Rd + "DRILL RED"}${R} — ${pass} passed, ${fail} failed, ${skip} skipped`);
-process.exit(fail === 0 ? 0 : 1);
+process.exitCode = fail === 0 ? report.exitCode() : 1;
+console.log(`\n${process.exitCode === 0 ? G + "DRILL GREEN" : Rd + "DRILL RED"}${R} — ${pass} passed, ${fail} failed, ${skip} skipped`);
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  await main();
+}

package/bin/duty.mjs

@@ -245,6 +245,14 @@ if (cmd === "up") {
   const env = (() => {
     const e = { RELAY_URL: hub, RUNNER_RULES: RULES, CREW_KICKOFF: KICKOFF,
                 RUNNER_DUTY_NUDGES: "1",
+                // A parked seat waits for `trantor up`. That is right for a CODE seat — burning a
+                // plan re-sending the same contract helps nobody (#6270). It is wrong for DUTY,
+                // which is the seat every other seat's liveness runs through: on 2026-09-09 it
+                // parked on a quota read and sat holding 48 messages for 21.9 hours while the
+                // crew finished a night's work nobody gated. Duty is the one seat under a launchd
+                // keepalive, so it does not need to sit there — it can exit and let the supervisor
+                // bring it back clean, which also re-reads auth. 15 minutes, then hand over.
+                RUNNER_PARK_MAX_MS: "900000",
                 RUNNER_TITLE: "Trantor Duty Agent", RUNNER_ABOUT: ABOUT,
                 // launchd starts jobs with a MINIMAL Path — the resurrected seat could not find
                 // `claude` and every turn died exit 127 "missing-cli" (found live 2026-08-31,
@@ -360,6 +368,31 @@ if (cmd === "down") {
   process.exit(0);
 }
 
+/**
+ * Is duty actually moving mail? Read from the runner's own on-disk queue rather than trusting the
+ * process table. `pending-<agent>-<project>.json` is written on every failed delivery and deleted
+ * when the queue drains, so its existence means messages are held and its oldest entry says for how
+ * long. STALL_HOURS is deliberately well past the runner's own 15-minute retry ceiling: anything
+ * older than that is not a retry in progress, it is a parked seat nobody restarted.
+ */
+const STALL_HOURS = 1;
+function dutyHealth() {
+  const f = join(BUS, `pending-${AGENT}-trantor-duty.json`);
+  try {
+    const j = JSON.parse(readFileSync(f, "utf8"));
+    const wake = Array.isArray(j.wake) ? j.wake : [];
+    const bcast = Array.isArray(j.bcast) ? j.bcast : [];
+    const held = wake.length + bcast.length;
+    if (!held) return { held: 0, stalled: false, oldestHours: "0.0" };
+    const stamps = [...wake, ...bcast].map(m => m?.ts).filter(Number.isFinite);
+    const oldest = stamps.length ? Math.min(...stamps) : j.ts;
+    const hours = (Date.now() - oldest) / 3.6e6;
+    return { held, stalled: hours >= STALL_HOURS, oldestHours: hours.toFixed(1) };
+  } catch {
+    return { held: 0, stalled: false, oldestHours: "0.0" };   // no queue file = nothing held
+  }
+}
+
 // status
 {
   const pid = alivePid();
@@ -370,7 +403,41 @@ if (cmd === "down") {
   console.log("  whether a seat is still alive, and clears away dead runners. It never writes code");
   console.log("  and never edits your project files.  Stop it with: trantor duty down");
   console.log("");
-  console.log(pid ? `RUNNING (pid ${pid}) as ${SESSION}` : "NOT running");
+  // A pid is not health. This line used to read `pid ? "RUNNING" : "NOT running"`, and on 2026-09-09
+  // it said RUNNING for a seat whose last successful turn was 21.8 hours earlier and which was
+  // holding 48 undelivered messages, the oldest 21.9 hours old — the runner had parked itself
+  // waiting on a quota reset and only `trantor up` un-parks it. Nothing noticed, because the one
+  // command whose job is to answer "is duty working" was answering "does a process exist".
+  //
+  // The irony worth keeping: ten lines below, this same function already refuses to assume the hub
+  // feed is wired, on the grounds that "a running seat the hub isn't feeding looks identical to a
+  // working one from the outside". That rigour was applied to the hub and not to the seat itself.
+  //
+  // The queue is the honest signal because it survives the process: the runner persists it to
+  // pending-<agent>-<project>.json on every failed delivery, so a backlog with an old head means
+  // messages are not moving no matter what the process table says.
+  const health = dutyHealth();
+  if (!pid) {
+    console.log("NOT running");
+    // A backlog matters MORE when the seat is down, not less: those messages have nobody to deliver
+    // them and no retry ladder running. Reporting it only in the pid branch was the first version
+    // of this fix, and it hid exactly the case that needs saying out loud.
+    if (health.held) {
+      console.log(`  \x1b[31mand ${health.held} undelivered message(s) are held on disk, oldest ${health.oldestHours}h old\x1b[0m`);
+      console.log(`  → nothing will deliver them until the seat is back: trantor duty up`);
+    } else {
+      console.log("  queue empty — nothing is waiting");
+    }
+  }
+  else if (health.stalled) {
+    console.log(`\x1b[31mSTALLED\x1b[0m (pid ${pid}) as ${SESSION} — the process is up but mail is not moving`);
+    console.log(`  holding ${health.held} undelivered message(s), oldest ${health.oldestHours}h old`);
+    console.log(`  → the runner parks on quota/api failure and only a restart un-parks it: trantor duty up`);
+  } else if (health.held) {
+    console.log(`RUNNING (pid ${pid}) as ${SESSION} — draining ${health.held} queued message(s), oldest ${health.oldestHours}h old`);
+  } else {
+    console.log(`RUNNING (pid ${pid}) as ${SESSION} — queue empty`);
+  }
   console.log(existsSync(DUTY_PLIST)
     ? `keepalive: installed (${DUTY_LABEL}${process.platform === "darwin" ? (dutyLoaded() ? ", loaded" : ", not loaded in this session") : ""}) — launchd relaunches the seat after a crash or reboot`
     : "keepalive: NOT installed — a crash or reboot leaves the seat down (trantor duty up installs it)");

package/bin/write-handoff.mjs

@@ -6,7 +6,7 @@ import { writeFileSync, readFileSync, existsSync, mkdirSync, readdirSync } from
 import { join, basename } from "node:path";
 import { homedir, hostname } from "node:os";
 import { execSync } from "node:child_process";
-import { spawnBaton, handoffMode, resolveHandoffSurface } from "../hooks/lib/handoff.mjs";
+import { spawnBaton, handoffMode, resolveHandoffSurface, attachState, resolveSeat, resolveHandoffCard } from "../hooks/lib/handoff.mjs";
 import { handoffDir } from "../lib/project.mjs";
 
 const baton = process.argv.includes("--baton");
@@ -63,6 +63,12 @@ if (latest) {
 // carries the same interface the hooks-side records have: transcript_path ("" — the summary IS
 // the model's own words), mode (attended|unattended, #5648).
 const rec = { id: `${name}-${stamp}`, project, projectName: name, machine: hostname(), trigger: baton ? "manual-baton" : "manual-skill", stamp: Number(stamp) || 0, summary: summary.trim() || "(empty)", transcript_path: "", mode: handoffMode(name), gitStatus: git, consumed: false, states: [{ state: "written", ts: Number(stamp) || 0, by: baton ? "manual-baton" : "manual-skill" }] };
+// The structured working state rides beside the prose (TDD §4.5), dark behind
+// TRANTOR_STATE_HANDOFF. The manual path gets it for the same reason the hook path does: this
+// record is what the successor loads, and `summary` here IS the model's own handoff — the richest
+// STATE block there is.
+const seat = resolveSeat(name);
+attachState(rec, { project: name, seat, card: resolveHandoffCard({ projectName: name, seat }), worktree: project });
 const file = join(dir, `${rec.id}.json`);
 writeFileSync(file, JSON.stringify(rec, null, 2));
 console.log(`handoff saved: ${file}`);

package/deploy/setup.sh

@@ -24,6 +24,44 @@ if [ -f "$REPO/engine/install.sh" ]; then
     || echo "  (engine install failed — Trantor still works; the Advisor runs without live pricing. Retry: trantor setup)"
   case ":$PATH:" in *":$HOME/.local/bin:"*) ;; *) echo "  note: add ~/.local/bin to your PATH";; esac
 fi
+# Graft — local code-graph MCP tools every seat can call (token-saving retrieval; NanoNets, MIT).
+# Installed here so connect (next) wires it into each CLI; the graph self-refreshes per query and is
+# a no-op where a project has no index (built per project at crew launch). Non-fatal if it fails.
+#
+# We probe by BUILDING, not by `command -v graft`. A bin link proves nothing about whether graft can
+# parse: it depends on ten tree-sitter native bindings, all wired as `"install": "node-gyp-build"`.
+# npm v12 turns lifecycle scripts and implicit node-gyp builds OFF by default, and the prebuilds that
+# save us do not cover every platform — tree-sitter core and tree-sitter-python ship no linux-arm64.
+# There, the gyp fallback that used to compile them no longer runs, `graft` is still on PATH, and a
+# presence check prints a green tick over a tool that throws on first use. So the probe indexes a
+# one-file fixture (~0.2s) and requires the symbol back: exit 0 alone can mean "parsed nothing".
+# Every failure path is explicitly `|| rc=1` rather than leaning on set -e being suspended inside an
+# `if` condition: this must return a verdict, never abort setup.
+graft_works() {
+  rc=0
+  command -v graft >/dev/null 2>&1 || return 1
+  d="$(mktemp -d 2>/dev/null)" || return 1
+  printf 'export function graftProbe(n) {\n  return n;\n}\n' > "$d/probe.mjs" || rc=1
+  if [ "$rc" -eq 0 ]; then
+    ( cd "$d" && graft build . >/dev/null 2>&1 && graft skeleton probe.mjs . 2>/dev/null | grep -q graftProbe ) || rc=1
+  fi
+  rm -rf "$d"
+  return "$rc"
+}
+if ! graft_works; then
+  echo "▸ installing Graft (code-graph MCP tools for the seats)…"
+  npm install -g @nanonets/graft >/dev/null 2>&1 || true
+fi
+if graft_works; then
+  echo "✓ Graft installed"
+elif command -v graft >/dev/null 2>&1; then
+  echo "  (Graft is on PATH but cannot parse — almost certainly its native parsers were never built."
+  echo "   npm v12 skips them by default. Fix: npm install -g @nanonets/graft --allow-scripts"
+  echo "   Seats keep working without graft_* tools until then.)"
+else
+  echo "  (Graft install failed — seats keep working without graft_* tools; retry: npm install -g @nanonets/graft)"
+fi
+
 node "$REPO/bin/connect.mjs"
 echo
 node "$REPO/bin/doctor.mjs" || true