trantor 0.18.49 → 0.18.50

package/bin/drill-seams.mjs

@@ -0,0 +1,157 @@
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, symlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { createServer } from "node:net";
+import { workspacePane, splitPane } from "./crew/herdr.mjs";
+
+const ROOT = dirname(import.meta.dirname);
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+const herdr = args => JSON.parse(execFileSync("herdr", args, { encoding: "utf8", timeout: 30000 }));
+const read = path => existsSync(path) ? readFileSync(path, "utf8") : "";
+
+export function checkSocketHome(home) {
+  const socket = join(home, ".config", "herdr", "herdr.sock");
+  if (Buffer.byteLength(socket) >= (process.platform === "darwin" ? 104 : 108)) {
+    throw new Error(`drill HOME socket path is too long: ${socket}; use a shorter TRANTOR_DRILL_WORLD inside .agent-bus-out`);
+  }
+  return socket;
+}
+
+export function isolatedEnv(home, bus, overrides = {}) {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) {
+    if (/^(RELAY_|TRANTOR_|CLAUDE_CODE_|HERDR_|AGENT_BUS_)/.test(key) || key === "CLAUDECODE") delete env[key];
+  }
+  return { ...env, HOME: home, AGENT_BUS_DIR: bus, RELAY_DATA_DIR: bus, ...overrides };
+}
+
+export async function stopChild(child) {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  child.kill("SIGTERM");
+  await Promise.race([new Promise(resolve => child.once("close", resolve)), sleep(2000)]);
+  if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+}
+
+export async function startDrillHub(home, bus, auth = "enforce") {
+  mkdirSync(bus, { recursive: true });
+  const probe = createServer();
+  await new Promise(resolve => probe.listen(0, "127.0.0.1", resolve));
+  const port = probe.address().port;
+  await new Promise(resolve => probe.close(resolve));
+  const url = `http://127.0.0.1:${port}`;
+  const env = isolatedEnv(home, bus, {
+    RELAY_PORT: String(port), RELAY_HOST: "127.0.0.1", RELAY_URL: url,
+    RELAY_AUTH: auth, RELAY_ENROLL: "tofu", RELAY_STORE: "json",
+  });
+  const child = spawn(process.execPath, [join(ROOT, "hub.mjs")], { env, stdio: "ignore" });
+  for (let attempt = 0; attempt < 100; attempt++) {
+    try {
+      if ((await fetch(`${url}/health`, { signal: AbortSignal.timeout(500) })).ok) return { child, env, url };
+    } catch { /* The private hub has not bound its port yet. */ }
+    if (child.exitCode !== null) break;
+    await sleep(100);
+  }
+  await stopChild(child);
+  throw new Error("private drill hub did not become ready");
+}
+
+export function appVerdict(kind, trace, panics = "") {
+  if (/\b(?:FAILED|FAIL|ERROR)\b/.test(trace)) return false;
+  if (kind === "ask") return /ask-drill open PASS/.test(trace) && /ask-drill cold PASS/.test(trace) && /ask-drill PASS:/.test(trace);
+  if (kind === "handoff") return /handoff-drill PASS:/.test(trace) && /handoff-drill verdict exit=0/.test(trace);
+  return /key-drill verdict exit=0/.test(trace) && !/skipped/.test(trace)
+    && [1, 2, 3].every(pass => trace.includes(`pass=${pass} posted keyDown+keyUp`))
+    && (kind !== "key-throw" || panics.includes("TaoObjcExceptionDrill"));
+}
+
+async function launchApp(kind, env, bus) {
+  const binary = process.env.TRANTOR_DRILL_APP || "/Applications/Trantor.app/Contents/MacOS/Trantor";
+  if (!existsSync(binary)) throw new Error(`installed app missing: ${binary}; no build/install attempted`);
+  const tracePath = join(bus, "app-trace.log");
+  const panicPath = join(bus, "app-panics.log");
+  const offset = read(tracePath).length;
+  const panicOffset = read(panicPath).length;
+  const child = spawn(binary, [], { env, stdio: "ignore", timeout: 180000, killSignal: "SIGKILL" });
+  let spawnError = null;
+  child.once("error", error => { spawnError = error; });
+  const deadline = Date.now() + 180000;
+  let trace = "";
+  try {
+    await sleep(1000);
+    execFileSync("osascript", ["-e", `tell application "System Events" to set frontmost of (first process whose unix id is ${child.pid}) to true`], { timeout: 10000, stdio: "ignore" });
+    while (Date.now() < deadline) {
+      trace = read(tracePath).slice(offset);
+      if (spawnError) throw spawnError;
+      if (appVerdict(kind, trace, read(panicPath).slice(panicOffset))) return `${tracePath}: ${trace.trim().split("\n").filter(line => /PASS|survived|verdict/.test(line)).join("; ")}`;
+      if (/\b(?:FAILED|FAIL|ERROR)\b/.test(trace) || child.exitCode !== null || child.signalCode !== null) break;
+      await sleep(500);
+    }
+    throw new Error(`${kind}: no complete app proof (exit=${child.exitCode} signal=${child.signalCode}); ${tracePath}: ${trace.trim().slice(-500)}`);
+  } finally {
+    await stopChild(child);
+    // The app normally closes these in its own finally. If it timed out first, only this
+    // launch's trace can authorize cleanup; never sweep the shared herdr workspace list.
+    for (const match of trace.matchAll(/ask-drill (?:open|cold) herdr workspace=(\S+)/g)) {
+      try { herdr(["workspace", "close", match[1]]); } catch { /* Already closed by the app. */ }
+    }
+  }
+}
+
+export async function runAppDrills({ world, proj, project, run }) {
+  // The HOME socket pathname must fit sockaddr_un even when it is a symlink.
+  const home = world;
+  const bus = join(home, "app-bus");
+  mkdirSync(join(home, ".config", "herdr"), { recursive: true });
+  const socket = checkSocketHome(home);
+  if (!existsSync(socket)) symlinkSync(join(homedir(), ".config", "herdr", "herdr.sock"), socket);
+  let hub;
+  try {
+    hub = await startDrillHub(home, bus, "off");
+    await fetch(`${hub.url}/project`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ project, brief: "Throwaway drill project" }) });
+    writeFileSync(join(bus, "config.json"), JSON.stringify({ url: hub.url, hubs: { [project]: hub.url }, contextWindow: 200000 }));
+    const env = { ...hub.env, TRANTOR_DEV_ROOT: dirname(proj), TRANTOR_ROOT: ROOT };
+    const created = herdr(["workspace", "create", "--cwd", proj, "--label", `tt-dead-drill-${process.pid}`, "--no-focus"]);
+    const workspace = created.result.workspace.workspace_id;
+    const pane = created.result.root_pane.pane_id;
+    try {
+      const sid = "00000000-0000-4000-8000-000000000092";
+      const transcripts = join(home, ".claude", "projects", proj.replace(/[/.]/g, "-"));
+      mkdirSync(transcripts, { recursive: true });
+      writeFileSync(join(transcripts, `${sid}.jsonl`), JSON.stringify({ type: "assistant", sessionId: sid, cwd: proj, timestamp: new Date().toISOString(), message: { model: "claude-sonnet-4-5", role: "assistant", usage: { input_tokens: 184000, output_tokens: 1, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 }, content: [{ type: "text", text: "dead drill session" }] } }) + "\n");
+      writeFileSync(join(bus, "crew-windows.txt"), `${project}\therdrws\t__ws__\t${workspace}\n${project}\torch\torchestrator\t${pane}\n`);
+      writeFileSync(join(bus, "orch-sessions.txt"), `${project}\t${sid}\n`);
+      await run("S6-handoff · app dead-pane guard", async () => {
+        const before = herdr(["pane", "process-info", "--pane", pane]).result.process_info.shell_pid;
+        const evidence = await launchApp("handoff", { ...env, TRANTOR_HANDOFF_DRILL: project }, bus);
+        const after = herdr(["pane", "process-info", "--pane", pane]).result.process_info.shell_pid;
+        if (!before || before !== after) throw new Error("dead-pane shell did not survive");
+        return `${evidence}; shell ${after} survived`;
+      });
+    } finally { herdr(["workspace", "close", workspace]); }
+  } catch (error) {
+    await run("S6-handoff · app setup", () => { throw error; });
+  } finally { if (hub) await stopChild(hub.child); }
+}
+
+export async function crewWorkspaceDrill({ proj, workspace }) {
+  if (!workspace) throw new Error("S1 left no project workspace");
+  const ctx = { env: process.env, have: { herdr: true } };
+  const host = workspacePane(ctx, workspace, proj);
+  if (!host) throw new Error("no project-local host pane");
+  const foreign = herdr(["workspace", "create", "--cwd", proj, "--label", `tt-focus-drill-${process.pid}`, "--focus"]);
+  const panes = [];
+  try {
+    for (let i = 0; i < 4; i++) {
+      const pane = splitPane(ctx, panes.at(-1) || host, "right", proj);
+      if (!pane) throw new Error("crew split failed");
+      panes.push(pane);
+    }
+    const rows = herdr(["pane", "list"]).result.panes;
+    if (!panes.every(id => rows.some(row => row.pane_id === id && row.workspace_id === workspace && row.cwd === proj))) throw new Error("a crew split landed outside the project workspace/cwd");
+    return `focused=${foreign.result.workspace.workspace_id}; seats=${panes.join(",")}; workspace=${workspace}; cwd=${proj}`;
+  } finally {
+    for (const pane of panes) herdr(["pane", "close", pane]);
+    herdr(["workspace", "close", foreign.result.workspace.workspace_id]);
+  }
+}

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/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

package/hooks/lib/handoff.mjs

@@ -247,7 +247,13 @@ export function lastRowMidTurn(transcriptPath) {
       const c = r?.message?.content;
       if (r.type === "assistant") {
         const blocks = Array.isArray(c) ? c : [];
-        if (blocks.some(b => b?.type === "tool_use")) return true;   // a result is still owed
+        const calls = blocks.filter(b => b?.type === "tool_use");
+        // #6668: a session parked in a LONE relay_wait is at its boundary. The wait is not work
+        // in flight — everything the turn did is already on disk, and the tool returns only when
+        // the bus speaks. Reading it as mid-turn armed the baton for the 17-minute boundary wait
+        // on a turn that never ends on its own; the pre-kill idle gate's deadline is what ends it.
+        if (calls.length && calls.every(isRelayWaitCall)) return false;
+        if (calls.length) return true;                               // a result is still owed
         return false;                                                // text-only → turn said its piece
       }
       // user row: #6528 follow-up — a trailing user row of ANY kind means in flight. A
@@ -263,6 +269,42 @@ export function lastRowMidTurn(transcriptPath) {
 export function turnInFlight(transcriptPath) {
   return subagentsActive(transcriptPath) || lastRowMidTurn(transcriptPath);
 }
+// The relay MCP's wait tool, by any server prefix (mcp__plugin_trantor_relay__relay_wait,
+// mcp__trantor__relay_wait, a bare relay_wait in a fixture).
+function isRelayWaitCall(block) {
+  return /(^|__)relay_wait$/.test(String(block?.name || ""));
+}
+
+// ---- does the transcript's session still have a process? (#6668) ------------------------------
+// Claude Code registers every live session in ~/.claude/sessions/<pid>.json ({pid, sessionId,
+// cwd, ...}) and removes the file at exit. The 09-07 12:35 chain armed on a transcript whose
+// session had exited at 12:16: the transcript's last row was a tool_result ("Connection closed"),
+// so the boundary gate read it as mid-turn and waited on a turn that no process would ever end.
+// A session with no live process IS at its boundary — its record can be written now.
+//   "live"    an entry names this session and its pid answers kill -0
+//   "dead"    the registry is in use (some other session is live) and none of its live entries
+//             name this session
+//   "unknown" no registry, or nothing in it is alive — say nothing, the boundary gate decides
+// The "dead" verdict needs another LIVE entry on purpose: a Claude Code too old to keep the
+// registry must not turn every mid-turn handoff into an immediate write.
+export function sessionProcessState(sessionId, { home = homedir() } = {}) {
+  if (!sessionId) return "unknown";
+  let files;
+  try { files = readdirSync(join(home, ".claude", "sessions")).filter(f => f.endsWith(".json")); } catch { return "unknown"; }
+  let anyLive = false;
+  for (const f of files) {
+    let entry;
+    try { entry = JSON.parse(readFileSync(join(home, ".claude", "sessions", f), "utf8")); } catch { continue; }
+    const pid = Number(entry?.pid) || Number(basename(f, ".json")) || 0;
+    if (!(pid > 0) || !pidAlive(pid)) continue;
+    anyLive = true;
+    if (String(entry?.sessionId || "") === sessionId) return "live";
+  }
+  return anyLive ? "dead" : "unknown";
+}
+function pidAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch (e) { return e?.code === "EPERM"; }
+}
 
 // ---- whole-session summary --------------------------------------------------
 function collectTurns(transcriptPath) {