trantor 0.18.49 → 0.18.50

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.49",
+  "version": "0.18.50",
   "description": "Trantor — the hub-world for AI agent crews: live message bus, presence, project Kanban/flow board + crew orchestration for independent AI coding agents (Claude, Codex, Gemini, Kimi, DeepSeek)",
   "mcpServers": {
     "relay": {

package/bin/baton-pane.mjs

@@ -10,13 +10,14 @@
 //
 // Env seams (the drill's off switches, same doctrine as TRANTOR_NO_HANDOFF_SPAWN):
 //   TRANTOR_BATON_IDLE_DEADLINE_S  give up waiting for idle after this many seconds (default 600)
+//   TRANTOR_BATON_AGENT_DROP_MS    give herdr this long to retire the ended agent (default 10000)
 //   TRANTOR_BATON_REOPEN           command to reopen the pane, instead of `trantor open`
 //                                  (the drill points this at its own herdr world)
 // Detached means nobody reads stdout: everything lands in <bus>/logs/baton-pane-<project>.log.
 import { readFileSync, existsSync, mkdirSync, appendFileSync } from "node:fs";
 import { join, basename } from "node:path";
 import { homedir } from "node:os";
-import { execFileSync, execSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import { createConnection } from "node:net";
 
 const arg = (name) => { const i = process.argv.indexOf(name); return i > 0 ? process.argv[i + 1] : ""; };
@@ -67,8 +68,50 @@ function socketRequest(req, timeoutMs = 30_000) {
 
 const sleep = (ms) => new Promise(r => setTimeout(r, ms));
 const agentStatus = (pane) => herdrJson(["agent", "get", pane])?.result?.agent?.agent_status || null;
+const hasAgent = (pane) => Boolean(herdrJson(["agent", "get", pane])?.result?.agent);
 const alive = (pid) => { try { process.kill(pid, 0); return true; } catch { return false; } };
 
+// The shells a pane idles in once its agent is gone. Their pid is never the process to end.
+const SHELL_NAMES = new Set(["zsh", "bash", "sh", "fish", "dash", "ksh", "tcsh", "csh", "nu", "login"]);
+function isShellProcess(p) {
+  const raw = String(p?.name || p?.argv0 || "").trim();
+  const name = basename(raw.replace(/^-/, ""));   // login shells spell themselves "-zsh"
+  return SHELL_NAMES.has(name);
+}
+
+/** The pid the graceful end targets, from herdr's `pane process-info` result.process_info —
+ *  parity with lib.rs foreground_pid_from_process_info. #6668: the 09-07 12:35 chain would have
+ *  TERMed 80368, the pane's bare zsh, because foreground_process_group_id was taken as-is. The
+ *  shell (process_info.shell_pid, or any entry named like one) is never a candidate: with only
+ *  the shell in the foreground there is nothing to end, and the answer is null. */
+export function foregroundPid(info) {
+  if (!info) return null;
+  const procs = Array.isArray(info.foreground_processes) ? info.foreground_processes : [];
+  const shellPid = Number(info.shell_pid) || 0;
+  const byPid = (pid) => procs.find(p => Number(p?.pid) === pid);
+  const usable = (pid) => pid > 0 && pid !== shellPid && !isShellProcess(byPid(pid));
+  const group = Number(info.foreground_process_group_id) || 0;
+  if (usable(group)) return group;
+  const claude = procs.find(p => /claude/i.test([p?.name, p?.argv0, p?.cmdline].map(s => String(s || "")).join(" ")) && !isShellProcess(p));
+  if (claude && Number(claude.pid) > 0 && Number(claude.pid) !== shellPid) return Number(claude.pid);
+  for (let i = procs.length - 1; i >= 0; i--) {
+    const pid = Number(procs[i]?.pid) || 0;
+    if (usable(pid)) return pid;
+  }
+  return null;
+}
+
+export function agentDropStep(present, elapsedMs, deadlineMs) {
+  if (!present) return "dropped";
+  return elapsedMs >= deadlineMs ? "deadline" : "wait";
+}
+
+function summary(value, limit = 240) {
+  const oneLine = String(value || "").trim().replace(/\s+/g, " ");
+  if (!oneLine) return "<empty>";
+  return oneLine.length > limit ? `${oneLine.slice(0, limit - 1)}…` : oneLine;
+}
+
 async function main() {
   if (!handoffFile || !existsSync(handoffFile)) { log(`no handoff file (${handoffFile}) — abort`); process.exit(1); }
   const pane = arg("--pane") || orchPane((() => { try { return readFileSync(join(busDir, "crew-windows.txt"), "utf8"); } catch { return ""; } })(), projectName);
@@ -88,7 +131,7 @@ async function main() {
 
   // 2. Graceful end, mirroring end_process_gracefully: TERM, short wait, KILL.
   const info = herdrJson(["pane", "process-info", "--pane", pane])?.result?.process_info;
-  const pid = Number(info?.foreground_process_group_id) || Number(info?.foreground_processes?.[0]?.pid) || 0;
+  const pid = foregroundPid(info) || 0;
   if (pid > 0 && alive(pid)) {
     try { process.kill(pid, "SIGTERM"); } catch {}
     const killAt = Date.now() + 10_000;
@@ -96,18 +139,26 @@ async function main() {
     if (alive(pid)) { try { process.kill(pid, "SIGKILL"); } catch {} }
     log(`ended pid ${pid}`);
   } else {
-    log("no foreground process to end (already gone)");
+    log("no foreground process to end (already gone, or only the pane's shell is in the foreground)");
+  }
+
+  const dropStarted = Date.now();
+  const dropDeadline = Number(process.env.TRANTOR_BATON_AGENT_DROP_MS) || 10_000;
+  let dropOutcome;
+  while ((dropOutcome = agentDropStep(hasAgent(pane), Date.now() - dropStarted, dropDeadline)) === "wait") {
+    await sleep(200);
   }
+  log(`agent drop ${dropOutcome} after ${Date.now() - dropStarted}ms`);
 
   // 3. Reopen. `trantor open` rebinds orch-sessions.txt and restarts the pane's session — the
   //    bookkeeping the classic seam regression comes from skipping. The drill overrides this to
   //    stay inside its own herdr world.
   const reopen = process.env.TRANTOR_BATON_REOPEN || "trantor open";
-  try {
-    execSync(reopen, { cwd: projectDir, encoding: "utf8", timeout: 120_000, stdio: "pipe" });
-    log(`reopened via: ${reopen}`);
-  } catch (e) {
-    log(`reopen FAILED (${String(e?.message).slice(0, 200)}) — handoff waits on disk`);
+  log(`reopen starting via: ${reopen}`);
+  const reopened = spawnSync(reopen, { cwd: projectDir, encoding: "utf8", timeout: 120_000, stdio: "pipe", shell: true });
+  log(`reopen result: status=${reopened.status ?? "none"} stdout=${summary(reopened.stdout)} stderr=${summary(reopened.stderr)}`);
+  if (reopened.error || reopened.status !== 0) {
+    log(`reopen FAILED (${summary(reopened.error?.message || reopened.signal || `exit ${reopened.status}`)}) — handoff waits on disk`);
     process.exit(1);
   }
 
@@ -118,7 +169,9 @@ async function main() {
   }
   try {
     const raw = await socketRequest({ id: "trantor:agent.prompt", method: "agent.prompt", params: { target: pane, text: KICKOFF_PROMPT } });
-    log(`kickoff: ${String(JSON.parse(raw).result?.type)}`);
+    const response = JSON.parse(raw);
+    const result = response.result?.type || response.error?.code || "unexpected_response";
+    log(`kickoff result: ${result}${response.error?.message ? ` (${summary(response.error.message)})` : ""}`);
   } catch (e) {
     log(`kickoff FAILED (${String(e?.message).slice(0, 120)}) — successor may sit idle until spoken to`);
   }

package/bin/baton.mjs

@@ -8,7 +8,7 @@ import { join, basename, dirname } from "node:path";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { writeHandoff, spawnBaton, resolveHandoffSurface, armBaton, contextUsage, controllingTty, turnInFlight, armMaxMs } from "../hooks/lib/handoff.mjs";
+import { writeHandoff, spawnBaton, resolveHandoffSurface, armBaton, contextUsage, controllingTty, turnInFlight, armMaxMs, sessionProcessState } from "../hooks/lib/handoff.mjs";
 
 // #6074: the skill path (write-handoff.mjs) and this CLI path must share ONE resolution of which
 // project this is and where the session lives. Both call resolveHandoffSurface; the name comes
@@ -82,7 +82,13 @@ function autoBaton() {
   // a turn still in flight ARMS instead of writing: no record, no spawn, and the session's own
   // Stop hook fires the baton at the boundary, where the summary describes finished work.
   const force = process.argv.includes("--force");
-  if (!force && turnInFlight(transcript)) {
+  // #6668: a transcript whose session has NO live process is at its boundary, whatever its last
+  // row says. The 09-07 12:35 chain armed on a session that had exited at 12:16 (its tail was a
+  // tool_result "Connection closed"), then sat in the 17-minute boundary wait for a Stop hook no
+  // process would ever run. Write now; the record describes a session that is over.
+  const processState = sessionProcessState(sessionId);
+  if (processState === "dead") console.log(`session ${sessionId} has no live process — at its boundary, writing now`);
+  if (!force && processState !== "dead" && turnInFlight(transcript)) {
     armBaton(sessionId, {
       projectDir: cwd,
       transcript, reason: trigger, windowId: "", tty: controllingTty(),

package/bin/connect.mjs

@@ -16,6 +16,14 @@ import { fileURLToPath } from "node:url";
 const DRY = process.argv.includes("--dry-run");
 const MCP = join(dirname(dirname(fileURLToPath(import.meta.url))), "mcp.mjs");
 const URL_ = process.env.RELAY_URL || "http://127.0.0.1:4477";
+// Graft (github.com/NanoNets/context-graph-engine): a local Tree-sitter dependency graph served
+// over MCP (graft_find_code / _find_all / _trace_calls / _file_api / _repo_map). Wired next to
+// `relay` so a seat can locate code with one call instead of grep+read-many — the graph refreshes
+// itself before each query (no freshness hook) and serves the nearest ancestor with a graft/ index,
+// so it keys off the seat's cwd project. A project with no graft/ index simply returns empty tools,
+// never an error. `graft build` (or `graft init`) seeds a project's index; graft/ is gitignored.
+const GRAFT = (() => { try { return execSync("command -v graft", { encoding: "utf8", shell: "/bin/sh" }).trim(); } catch { return "graft"; } })();
+const HAS_GRAFT = GRAFT !== "graft" || (() => { try { execSync("command -v graft", { stdio: "ignore", shell: "/bin/sh" }); return true; } catch { return false; } })();
 const has = (cmd) => { try { execSync(`command -v ${cmd}`, { stdio: "ignore", shell: "/bin/sh" }); return true; } catch { return false; } };
 const stamp = new Date().toISOString().slice(0, 10);
 const backup = (p) => { const b = `${p}.bak-${stamp}`; if (!existsSync(b)) copyFileSync(p, b); return b; };
@@ -65,6 +73,16 @@ if (has("codex")) {
     if (!DRY) { if (existsSync(p)) backup(p); else mkdirSync(dirname(p), { recursive: true }); writeFileSync(p, cur + block); }
     report("codex", cur ? "wired" : "wired (new config)", p);
   }
+  // graft alongside relay
+  if (HAS_GRAFT) {
+    const g = existsSync(p) ? readFileSync(p, "utf8") : "";
+    if (g.includes("[mcp_servers.graft]")) report("codex", "graft already wired");
+    else {
+      const gblock = `\n# trantor — Graft code-graph tools (graft_find_code/_find_all/_trace_calls/_file_api/_repo_map)\n[mcp_servers.graft]\ncommand = "${GRAFT}"\nargs = ["mcp"]\n`;
+      if (!DRY) { if (existsSync(p)) backup(p); writeFileSync(p, g + gblock); }
+      report("codex", "graft wired", p);
+    }
+  }
 }
 
 // ---- Gemini CLI ----  (existing relay entries are never overwritten — user customization wins)
@@ -73,6 +91,7 @@ if (has("gemini")) {
   report("gemini", patchJson(p, d => {
     d.mcpServers ||= {};
     d.mcpServers.relay ||= { command: "node", args: [MCP], env: relayEnv("gemini") };
+    if (HAS_GRAFT) d.mcpServers.graft ||= { command: GRAFT, args: ["mcp"] };
   }), p);
 }
 
@@ -82,6 +101,7 @@ if (has("kimi")) {
   report("kimi", patchJson(p, d => {
     d.mcpServers ||= {};
     d.mcpServers.relay ||= { command: "node", args: [MCP], env: relayEnv("kimi") };
+    if (HAS_GRAFT) d.mcpServers.graft ||= { command: GRAFT, args: ["mcp"] };
   }), p);
 }
 
@@ -92,6 +112,7 @@ if (has("opencode")) {
     d.$schema ||= "https://opencode.ai/config.json";
     d.mcp ||= {};
     d.mcp.relay ||= { type: "local", command: ["node", MCP], enabled: true };
+    if (HAS_GRAFT) d.mcp.graft ||= { type: "local", command: [GRAFT, "mcp"], enabled: true };
     d.mcp.relay.environment ||= {};
     // Migrate the old generated pin too: `||=` alone left RELAY_AGENT=opencode in every existing
     // config forever, where OpenCode overlaid it on the qwen/glm/deepseek runner environment.
@@ -135,7 +156,7 @@ if (has("dsh")) {
     },
     dsh: { profile: { bundles: ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-headless"] } },
   };
-  const patch = `# trantor — generated by \`trantor connect\` (edits survive: regenerate by deleting this file)
+  const patch = `# trantor — generated by \`trantor connect\` (connect rewrites this file only when it is missing a row; delete it to force a full regen)
 - insert:
     - id: trantor-cc-hooks
       name: '@deepseek-ai/dsh-hooks-claude-code'
@@ -154,10 +175,29 @@ if (has("dsh")) {
           RELAY_AGENT: !!js process.env.RELAY_AGENT ?? 'dsh'
           RELAY_PROJECT: !!js process.env.RELAY_PROJECT ?? ''
           RELAY_SESSION: !!js process.env.RELAY_SESSION ?? ''
-`;
+${HAS_GRAFT ? `    - id: trantor-graft
+      name: '@deepseek-ai/dsh-mcp-client'
+      config:
+        serverName: graft
+        transport: stdio
+        command: ${GRAFT}
+        args: ['mcp']
+` : ""}`;
+  // "a profile exists" is not "a profile is current": connect grows rows over time (relay, then
+  // graft, then whatever comes next), and an existence check short-circuits on a profile written
+  // by an older connect forever — the seat silently never gets the new row. So the gate is
+  // CONTENT-based: every row id this connect would write must already be in the patch; a missing
+  // one regenerates the patch (backed up). Presence, not diff — user edits to rows that ARE there
+  // still win, the same rule as the gemini/kimi/opencode `||=` patches above.
+  const expectedIds = [...patch.matchAll(/- id: (\S+)/g)].map(m => m[1]);
+  const cur = existsSync(patchPath) ? readFileSync(patchPath, "utf8") : "";
+  const missing = expectedIds.filter(id => !cur.split("\n").some(l => l.trim() === `- id: ${id}`));
   const fresh = !existsSync(patchPath);
-  if (!fresh) report("dsh", "already wired", prof);
-  else {
+  if (!fresh && !missing.length) report("dsh", "already wired", prof);
+  else if (!fresh) {
+    if (!DRY) { backup(patchPath); writeFileSync(patchPath, patch); }
+    report("dsh", `regenerated — was missing: ${missing.join(", ")}`, prof);
+  } else {
     if (!DRY) {
       mkdirSync(prof, { recursive: true });
       // The seat runs the plugin's hooks MINUS SessionStart: the crew runner already owns

package/bin/crew/open.mjs

@@ -1,8 +1,10 @@
 import { randomUUID } from "node:crypto";
-import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { call } from "./core.mjs";
-import { createWorkspace, herdrCall, paneHasAgent, reportAgent, splitPane, workspaceList, workspacePane } from "./herdr.mjs";
+import { existsSync, openSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { spawn, execSync } from "node:child_process";
+import { call, parseJsonOutput } from "./core.mjs";
+import { createWorkspace, herdrCall, reportAgent, splitPane, workspaceList, workspacePane } from "./herdr.mjs";
 import { dropState, readRows, recordState } from "./state.mjs";
 import { resolveOrchestratorDir } from "./worktrees.mjs";
 
@@ -72,6 +74,19 @@ function orchestratorCommand(ctx, id) {
   return `${env} claude${harnessFlag(ctx)} ${action}`;
 }
 
+export function paneHasAgent(ctx, pane) {
+  const result = herdrCall(ctx, ["pane", "process-info", "--pane", pane]);
+  const info = parseJsonOutput(result.stdout)?.result?.process_info;
+  if (!result.ok || !info) return false;
+  const processes = Array.isArray(info.foreground_processes) ? info.foreground_processes : [];
+  return processes.some(process => {
+    const command = [process.name, process.argv0, process.cmdline, ...(Array.isArray(process.argv) ? process.argv : [])]
+      .filter(Boolean)
+      .join(" ");
+    return /(^|[/\s])claude(?:\.exe)?(?:$|\s)/i.test(command);
+  });
+}
+
 function tracked(ctx, live) {
   let workspace = "";
   let pane = "";
@@ -91,7 +106,8 @@ function reattach(ctx, workspace, pane, id) {
   const renamed = herdrCall(ctx, ["pane", "rename", pane, `orchestrator · ${ctx.project}`]);
   if (!renamed.ok) { dropState(ctx, ctx.project, "orch"); return false; }
   if (!paneHasAgent(ctx, pane)) {
-    herdrCall(ctx, ["pane", "run", pane, orchestratorCommand(ctx, id)]);
+    const started = herdrCall(ctx, ["pane", "run", pane, orchestratorCommand(ctx, id)]);
+    if (!started.ok) throw new Error(`trantor open: could not start the orchestrator in pane ${pane}`);
     reportAgent(ctx, pane, "claude");
     console.error(`— orchestrator pane was empty: resumed session ${id} in herdr:${workspace || "?"}/${pane} —`);
   } else console.error(`— orchestrator already hosted: reattached to herdr:${workspace || "?"}/${pane} —`);
@@ -136,6 +152,38 @@ function hostPane(ctx, chosen, id) {
   return pane;
 }
 
+// #6888: index the project once so its seats' Graft tools (graft_find_code, _trace_calls, …) have a
+// graph to serve. Non-blocking — the pane opens now, the ~7s build lands in the background; a no-op
+// if graft isn't installed or the index already exists (the graph self-refreshes per query after the
+// first build). Keeps the 20MB index out of the project's git.
+export function maybeBuildGraft(dir) {
+  if (!dir) return;
+  try { execSync("command -v graft", { stdio: "ignore", shell: "/bin/sh" }); } catch { return; }
+  try {
+    if (existsSync(join(dir, "graft", ".graph"))) return;
+    const gi = join(dir, ".gitignore");
+    try {
+      const cur = existsSync(gi) ? readFileSync(gi, "utf8") : "";
+      if (!/^graft\/?$/m.test(cur)) writeFileSync(gi, cur + (cur && !cur.endsWith("\n") ? "\n" : "") + "graft/\n");
+    } catch {}
+    // The build is backgrounded, so we cannot gate the pane on its exit code — but a failure has to
+    // land SOMEWHERE. It used to go to stdio:"ignore", which meant a graft whose native parsers were
+    // never built (npm v12 skips node-gyp by default; see deploy/setup.sh) failed in total silence
+    // while the line below still claimed an index was being built.
+    //
+    // The log goes to the OS temp dir rather than the project: nothing to gitignore, nothing to clean
+    // up, and no exit handler — after unref() the parent usually dies first, so an on-exit cleanup
+    // would be a promise we cannot keep. It is simply overwritten by the next open of this project.
+    const log = join(tmpdir(), `trantor-graft-build-${basename(dir)}.log`);
+    let fd = "ignore";
+    try { fd = openSync(log, "w"); } catch {}
+    const child = spawn("graft", ["build", dir], { cwd: dir, stdio: ["ignore", fd, fd], detached: true });
+    child.on("error", () => {});   // ENOENT/EACCES: the log and the absent index are the evidence
+    child.unref();
+    console.error(`— indexing this project for the seats' Graft tools in the background (failures land in ${log}) —`);
+  } catch {}
+}
+
 export function openOrchestrator(ctx, args) {
   let parsed;
   try { parsed = parseArgs(args); }
@@ -143,6 +191,7 @@ export function openOrchestrator(ctx, args) {
   if (parsed.help) { usage(); return 0; }
   try {
     Object.assign(ctx, resolveOrchestratorDir(ctx, parsed.project));
+    if (!ctx.dry) maybeBuildGraft(ctx.dir);
     if (!ctx.have.herdr) throw new Error("trantor open needs herdr (the pane host) — install: curl -fsSL https://herdr.dev/install.sh | sh");
     let id = sessionId(ctx);
     if (hasPendingHandoff(ctx)) {

package/bin/crew-runner.mjs

@@ -28,7 +28,8 @@ import {
   senderProjectOf, isLinkedProject,
 } from "../lib/turn-policy.mjs";
 import {
-  auditDutyNudges, claudeTranscriptDir, dutyNudgeDirective, observedDutyNudgeIds, planDutyNudges,
+  auditDutyNudges, claimDutyNudges, claudeTranscriptDir, dutyEscalations, dutyNudgeDirective,
+  observedDutyNudgeIds,
 } from "../lib/duty-nudges.mjs";
 
 const AGENT = process.argv[2];
@@ -1067,10 +1068,30 @@ function askedExcerpt(message) {
   // queued, on disk, with a backoff — which is the whole point of the change.
   async function deliverWake() {
     const wake = pendingWake;
-    const wakeCapped = capWake(wake);
+    const dutyPlan = DUTY_NUDGES
+      ? await claimDutyNudges({
+        messages: wake,
+        statePath: DUTY_NUDGE_STATE,
+        owner: `${RUNNER_ID}:${TURN + 1}`,
+      })
+      : { items: [], targets: [], owner: "" };
+    const claimedIds = new Set(dutyPlan.items.map(item => item.id));
+    const wakeForTurn = DUTY_NUDGES
+      ? wake.filter(message => {
+        const escalation = dutyEscalations([message])[0];
+        return !escalation || claimedIds.has(escalation.id);
+      })
+      : wake;
+    if (!wakeForTurn.length) {
+      pendingWake = [];
+      savePending([], pendingBcast);
+      log("duty escalation already nudged or reserved by another turn — consumed without a duplicate model wake");
+      return;
+    }
+    const wakeCapped = capWake(wakeForTurn);
     const bcastCapped = capBcast(pendingBcast);
     const wakeText = wakeCapped.text
-      ? `NEW BUS MESSAGE${wake.length > 1 ? "S" : ""} for you:\n${wakeCapped.text}\n`
+      ? `NEW BUS MESSAGE${wakeForTurn.length > 1 ? "S" : ""} for you:\n${wakeCapped.text}\n`
       : "";
     const ctxText = bcastCapped.text
       ? `\nFYI broadcasts since your last turn (context only):\n${bcastCapped.text}\n`
@@ -1078,29 +1099,26 @@ function askedExcerpt(message) {
     // Say plainly that this is a second look. Without it the model re-reads an old escalation as
     // brand new and can redo work it already half-did before the turn died.
     const againText = deliveryFails
-      ? `\n(REDELIVERY, attempt ${deliveryFails + 1} — an earlier turn failed before acting on ${wake.length > 1 ? "these" : "this"}. Check what you already did before repeating it.)\n`
+      ? `\n(REDELIVERY, attempt ${deliveryFails + 1} — an earlier turn failed before acting on ${wakeForTurn.length > 1 ? "these" : "this"}. Check what you already did before repeating it.)\n`
       : "";
     await loadLessons();
     const lessons = pickLessons(LESSONS_RAW, wakeCapped.text + " " + bcastCapped.text);
-    const trigger = wake.some(m => m.to === SESSION) ? "direct message" : "@mention";
+    const trigger = wakeForTurn.some(m => m.to === SESSION) ? "direct message" : "@mention";
     // Who is owed an answer, captured BEFORE the turn: pendingWake is cleared on success.
     const assigners = [];
-    for (const m of wake) if (m.from && !assigners.some(a => a.from === m.from)) assigners.push({ from: m.from, id: m.id });
-    const asked = askedExcerpt(wake[0]);
+    for (const m of wakeForTurn) if (m.from && !assigners.some(a => a.from === m.from)) assigners.push({ from: m.from, id: m.id });
+    const asked = askedExcerpt(wakeForTurn[0]);
     const tStart = Date.now();
     // #6134: ONE SESSION PER CARD. A seat that resumes forever carries every card it ever worked
     // into every later turn — qwen's 85.7M tokens were 96.7% cached, i.e. replayed history. The
     // card that moved this wake decides: a different one starts a fresh CLI session, and the seat
     // is told so, because a fresh session remembers nothing and must be sent to its card.
-    const card = wake.map(m => cardRef(m.text)).find(Boolean) || 0;
+    const card = wakeForTurn.map(m => cardRef(m.text)).find(Boolean) || 0;
     const fresh = card > 0 && card !== sessionCard;
     if (card) sessionCard = card;
     const freshText = fresh
       ? `\n(FRESH SESSION for card #${card} — you are not the session that worked earlier cards and you remember none of them. Read your card first: relay_board with card:${card}.)\n`
       : "";
-    const dutyPlan = DUTY_NUDGES
-      ? planDutyNudges(wake, DUTY_NUDGE_STATE)
-      : { items: [], targets: [] };
     const prompt = composedTurn({
       wakeText, ctxText, againText: againText + freshText + dutyNudgeDirective(dutyPlan),
       tailText: "\nAct on what's addressed to you, then end your turn.\n\n",

package/bin/drill-report.mjs

@@ -0,0 +1,80 @@
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { signedPost } from "../hooks/lib/api.mjs";
+
+// A PASS assertion is evidence, not a verdict: every mapped step must finish cleanly.
+export class DrillReport {
+  constructor(map, path, { project, session }) {
+    this.map = map;
+    this.path = path;
+    this.project = project;
+    this.session = session;
+    this.steps = {};
+    this.closures = {};
+    for (const { steps, autoClose, recipe } of Object.values(map)) {
+      if (autoClose || !recipe) continue;
+      for (const step of steps) this.steps[step] = {
+        complete: true, checks: [{ status: "skip", assertion: recipe, evidence: "" }],
+      };
+    }
+    this.write();
+  }
+
+  record(step, status, assertion, evidence = "") {
+    (this.steps[step] ||= { complete: false, checks: [] }).checks.push({ status, assertion, evidence });
+    this.write();
+  }
+
+  complete(step) {
+    (this.steps[step] ||= { complete: false, checks: [] }).complete = true;
+    this.write();
+  }
+
+  cardsFor(step) {
+    return Object.keys(this.map).filter(id => this.map[id].steps.includes(step));
+  }
+
+  results() {
+    return Object.fromEntries(Object.entries(this.map).map(([id, { steps }]) => {
+      const evidence = steps.flatMap(step => {
+        const row = this.steps[step];
+        return row?.checks.length
+          ? row.checks.map(check => `${step} ${check.status}: ${check.assertion}${check.evidence ? ` — ${check.evidence}` : ""}`)
+          : [`${step} fail: not run`];
+      });
+      const complete = steps.every(step => {
+        const row = this.steps[step];
+        return row?.complete && row.checks.length > 0 && row.checks.every(check => check.status !== "fail");
+      });
+      const skipped = steps.some(step => this.steps[step]?.checks.some(check => check.status === "skip"));
+      return [id, { status: complete ? skipped ? "skip" : "pass" : "fail", evidence, closure: this.closures[id] || "not attempted" }];
+    }));
+  }
+
+  write() {
+    mkdirSync(dirname(this.path), { recursive: true });
+    const temp = `${this.path}.${process.pid}.tmp`;
+    writeFileSync(temp, JSON.stringify(this.results(), null, 2) + "\n", { mode: 0o600 });
+    renameSync(temp, this.path);
+  }
+
+  exitCode() {
+    // Manual recipes stay visible as SKIP; only missing/failed proof or a refused close is red.
+    return Object.values(this.results()).some(result => result.status === "fail" || result.closure.startsWith("failed:")) ? 1 : 0;
+  }
+
+  async closePassed() {
+    for (const [id, result] of Object.entries(this.results())) {
+      if (!this.map[id].autoClose || result.status !== "pass" || this.closures[id]) continue;
+      const response = await signedPost("/task/update", {
+        id: Number(id), project: this.project, by: this.session, status: "done",
+        note: `trantor drill PASS\n${result.evidence.join("\n")}`.slice(0, 2000),
+      }, { project: this.project, session: this.session, timeoutMs: 15000 });
+      this.closures[id] = response.ok && response.json?.task?.status === "done"
+        && response.json.task.id === Number(id) && response.json.task.project === this.project
+        ? "done" : `failed: hub ${response.status} ${response.json?.error || "did not confirm done"}`;
+      this.write();
+    }
+    return Object.values(this.closures).every(value => value === "done");
+  }
+}

package/bin/drill-report.test.mjs

@@ -0,0 +1,146 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createServer, createConnection } from "node:net";
+import { DrillReport } from "./drill-report.mjs";
+import { CARD_STEPS, findHandoff } from "./drill-surface.mjs";
+import { appVerdict, startDrillHub, stopChild, checkSocketHome } from "./drill-seams.mjs";
+import { signedGet, signedPost } from "../hooks/lib/api.mjs";
+
+test("S4 waits for the hook ledger when relay_handoff arrives first", () => {
+  const world = mkdtempSync(join(import.meta.dirname, "..", ".agent-bus-out", "ledger-"));
+  try {
+    assert.equal(findHandoff(join(world, "missing"), "trantor"), null);
+    writeFileSync(join(world, "trantor-100.json"), JSON.stringify({ summary: "tool handoff" }));
+    writeFileSync(join(world, "trantor-101.json"), "{");
+    writeFileSync(join(world, "trantor-102.json"), JSON.stringify({ states: [] }));
+    writeFileSync(join(world, "other-100.json"), JSON.stringify({ states: [{ state: "written" }] }));
+    assert.equal(findHandoff(world, "trantor"), null);
+    const ledger = join(world, "trantor-103.json");
+    writeFileSync(ledger, JSON.stringify({ states: [{ state: "written" }] }));
+    assert.equal(findHandoff(world, "trantor"), ledger);
+    writeFileSync(ledger, JSON.stringify({ states: [{ state: "written" }, { state: "claimed" }, { state: "recapped" }] }));
+    assert.equal(findHandoff(world, "trantor"), ledger);
+  } finally { rmSync(world, { recursive: true, force: true }); }
+});
+
+test("signed closer on an enforce hub: complete evidence closes, partial/failure/skip never does", async () => {
+  const out = join(import.meta.dirname, "..", ".agent-bus-out");
+  mkdirSync(out, { recursive: true });
+  const world = mkdtempSync(join(out, "closer-test-"));
+  const bus = join(world, "bus");
+  const hub = await startDrillHub(world, bus);
+  const saved = { ...process.env };
+  Object.assign(process.env, { RELAY_URL: hub.url, AGENT_BUS_DIR: bus, RELAY_SESSION: "drill:trantor", RELAY_PROJECT: "trantor" });
+  const project = "trantor", session = "drill:trantor";
+  const path = join(world, "drill-result.json");
+  try {
+    const create = await signedPost("/task", { project, by: session, title: "closer test", status: "testing" });
+    assert.equal(create.ok, true, JSON.stringify(create));
+    const id = create.json.task.id;
+    const report = new DrillReport({ [id]: { steps: ["one", "two"], autoClose: true } }, path, { project, session });
+    report.record("one", "pass", "first assertion", "real evidence A");
+    await report.closePassed();
+    assert.equal(report.results()[id].status, "fail");
+    assert.equal((await signedGet("/tasks?project=trantor")).json.tasks[0].status, "testing");
+    report.complete("one");
+    report.record("two", "pass", "second assertion", "real evidence B");
+    report.complete("two");
+    assert.equal(await report.closePassed(), true);
+    const card = (await signedGet("/tasks?project=trantor")).json.tasks[0];
+    assert.equal(card.status, "done");
+    assert.equal(card.workedBy, session);
+    assert.match(card.log.at(-1).text, /real evidence A/);
+    assert.match(card.log.at(-1).text, /real evidence B/);
+    assert.equal(JSON.parse(readFileSync(path, "utf8"))[id].closure, "done");
+    const notes = card.log.length;
+    await report.closePassed();
+    assert.equal((await signedGet("/tasks?project=trantor")).json.tasks[0].log.length, notes);
+    const unsigned = await fetch(`${hub.url}/task/update`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id, status: "testing", by: session }) });
+    assert.equal(unsigned.status, 401);
+
+    for (const status of ["fail", "skip"]) {
+      const created = await signedPost("/task", { project, by: session, title: status, status: "testing" });
+      const blockedId = created.json.task.id;
+      const blocked = new DrillReport({ [blockedId]: { steps: ["step"], autoClose: true } }, path, { project, session });
+      blocked.record("step", "pass", "partial success");
+      blocked.record("step", status, "missing proof");
+      blocked.complete("step");
+      await blocked.closePassed();
+      assert.equal(blocked.results()[blockedId].status, status);
+      assert.equal((await signedGet("/tasks?project=trantor")).json.tasks.find(row => row.id === blockedId).status, "testing");
+    }
+    const missing = new DrillReport({ 999999: { steps: ["step"], autoClose: true } }, path, { project, session });
+    missing.record("step", "pass", "proof");
+    missing.complete("step");
+    assert.equal(await missing.closePassed(), false);
+    assert.match(missing.results()[999999].closure, /failed: hub 404/);
+    assert.equal(missing.exitCode(), 1);
+    const fresh = new DrillReport({ [id]: { steps: ["one"], autoClose: true } }, path, { project, session });
+    assert.equal(fresh.results()[id].status, "fail", "a rerun cannot inherit old PASS evidence");
+  } finally {
+    for (const key of Object.keys(process.env)) if (!(key in saved)) delete process.env[key];
+    Object.assign(process.env, saved);
+    await stopChild(hub.child);
+    rmSync(world, { recursive: true, force: true });
+  }
+});
+
+test("app proof requires every leg and rejects skipped key targets", () => {
+  assert.deepEqual(CARD_STEPS[6317].steps, ["S6-key-post", "S6-key-throw"]);
+  assert.equal(appVerdict("ask", "ask-drill PASS:"), false);
+  assert.equal(appVerdict("ask", "ask-drill open PASS\nask-drill cold PASS\nask-drill PASS:"), true);
+  const key = [1, 2, 3].map(pass => `key-drill pass=${pass} posted keyDown+keyUp`).join("\n") + "\nkey-drill verdict exit=0";
+  assert.equal(appVerdict("key-post", key), true);
+  assert.equal(appVerdict("key-post", key + "\npass=2 skipped"), false);
+  assert.equal(appVerdict("key-throw", key), false);
+  assert.equal(appVerdict("key-throw", key, "TaoObjcExceptionDrill"), true);
+  assert.equal(appVerdict("handoff", "handoff-drill PASS:\nhandoff-drill verdict exit=3"), false);
+});
+
+test("manual probes remain SKIP even when the runner stops before reaching them", () => {
+  const world = mkdtempSync(join(import.meta.dirname, "..", ".agent-bus-out", "skip-"));
+  try {
+    const report = new DrillReport(CARD_STEPS, join(world, "result.json"), { project: "trantor", session: "drill:trantor" });
+    assert.deepEqual(Object.keys(CARD_STEPS).filter(id => CARD_STEPS[id].autoClose), ["6481", "6667", "6668"]);
+    for (const id of [6317, 6533, 6587, 6483]) {
+      assert.equal(report.results()[id].status, "skip");
+      assert.equal(report.results()[id].closure, "not attempted");
+      assert.match(report.results()[id].evidence.join(" "), id === 6587 ? /live duty probe/ : /covered by in-app Drill Mode/);
+    }
+    assert.equal(report.exitCode(), 1, "unrun seams still fail");
+    for (const { steps, recipe } of Object.values(CARD_STEPS)) {
+      if (recipe) continue;
+      for (const step of steps) {
+        report.record(step, step === "S5" ? "skip" : "pass", step === "S5" ? "interactive Terminal takeover probe" : "seam proof");
+        report.complete(step);
+      }
+    }
+    assert.equal(report.exitCode(), 0, "passing seams plus manual SKIPs exit zero");
+    report.record("S4", "fail", "ledger missing");
+    assert.equal(report.exitCode(), 1, "a real seam failure remains fatal");
+  } finally { rmSync(world, { recursive: true, force: true }); }
+});
+
+test("short drill HOME connects through the native socket symlink; old staging is rejected", async () => {
+  const world = mkdtempSync(`${join(import.meta.dirname, "..", ".agent-bus-out")}/`);
+  const server = createServer(socket => socket.end("connected"));
+  try {
+    const path = checkSocketHome(world);
+    assert.throws(() => checkSocketHome(join(world, "x".repeat(108))), /too long/);
+    mkdirSync(join(world, ".config", "herdr"), { recursive: true });
+    const target = join(world, "s");
+    await new Promise((resolve, reject) => { server.once("error", reject); server.listen(target, resolve); });
+    symlinkSync(target, path);
+    const proof = await new Promise((resolve, reject) => {
+      const socket = createConnection(path);
+      socket.once("error", reject);
+      socket.once("data", data => resolve(data.toString()));
+    });
+    assert.equal(proof, "connected");
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+    rmSync(world, { recursive: true, force: true });
+  }
+});