trantor 0.17.30 → 0.17.32

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.30",
+  "version": "0.17.32",
   "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/agents.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// trantor agents [sessionId] [--json] — the LIVE sub-agent manifest for a session.
+//
+// What were this session's sub-agents (Agent/Task tool, Workflow swarms, agent-teams) doing —
+// what was each tasked with, did it return, what did it write, and do those files still survive
+// on disk? Derived fresh from the on-disk transcripts every run (so it reflects CURRENT disk,
+// catching files an agent finished that were later clobbered — the 2026-06-21 kill corrupted a
+// completed 30KB lib down to a 17-byte stub).
+//
+//   trantor agents                 → the session of the newest handoff for THIS project (the
+//                                     predecessor a fresh session is taking over from)
+//   trantor agents <sessionId>     → that specific session
+//   trantor agents --json          → structured manifest (for tools)
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+import { deriveSubagentManifest, formatSubagentManifest, resolveTranscriptForSid } from "../lib/subagent-manifest.mjs";
+
+const args = process.argv.slice(2);
+const json = args.includes("--json");
+const sid = args.find((a) => !a.startsWith("--"));
+
+const HANDOFF_DIR = join(process.env.RELAY_DATA_DIR || join(homedir(), ".agent-bus"), "handoffs");
+
+// Newest handoff record whose project matches the cwd — gives us the predecessor's transcript
+// path + project root directly (no glob needed), so `trantor agents` with no arg "just works"
+// for a fresh session taking over.
+function newestHandoffForCwd() {
+  try {
+    if (!existsSync(HANDOFF_DIR)) return null;
+    const cwd = process.cwd(), name = basename(cwd);
+    const recs = readdirSync(HANDOFF_DIR)
+      .filter((f) => /-\d+\.json$/.test(f))
+      .map((f) => { try { return JSON.parse(readFileSync(join(HANDOFF_DIR, f), "utf8")); } catch { return null; } })
+      .filter((r) => r && (r.project === cwd || r.projectName === name))
+      .sort((a, b) => (Number(b.stamp) || 0) - (Number(a.stamp) || 0));
+    return recs[0] || null;
+  } catch { return null; }
+}
+
+let transcript = "", projectRoot = process.cwd();
+if (sid) {
+  transcript = resolveTranscriptForSid(sid);
+  if (!transcript) {
+    console.error(`No transcript found for session ${sid} under ~/.claude/projects/*/.`);
+    process.exit(1);
+  }
+} else {
+  const h = newestHandoffForCwd();
+  if (!h) {
+    console.error(`No handoff found for this project. Pass a session id explicitly: trantor agents <sessionId>`);
+    process.exit(1);
+  }
+  transcript = h.transcript_path || resolveTranscriptForSid(h.session_id);
+  projectRoot = h.project || projectRoot;
+}
+
+const manifest = deriveSubagentManifest(transcript, { projectRoot });
+if (json) {
+  process.stdout.write(JSON.stringify(manifest, null, 2) + "\n");
+} else {
+  process.stdout.write(formatSubagentManifest(manifest) + "\n");
+}

package/bin/cli.mjs

@@ -26,6 +26,8 @@ switch (cmd) {
   case "hub":     run("hub.mjs"); break;
   case "watch":   run("bin/relay-watch.mjs"); break;
   case "catchup": run("bin/catchup.mjs"); break;
+  case "agents":  run("bin/agents.mjs"); break;
+  case "gates":   run("bin/gates.mjs"); break;
   case "backfill": run("bin/git-backfill.mjs"); break;
   case "handoff": run("bin/baton.mjs"); break;
   case "ui": {
@@ -48,6 +50,8 @@ switch (cmd) {
   trantor down        tear the crew down (kills processes, closes windows, no dialogs)
   trantor ui          open the live dashboard (board + flow views)
   trantor catchup     "where are we?" — the continuous board + git, with a synthesized brief
+  trantor agents      what this session's sub-agents did (task · returned? · files written · survived on disk) — [<sessionId>] [--json]
+  trantor gates       verification gates: "must verify before shipping" claims that survive handoffs — [--all] [--json]
   trantor backfill    card past GIT work onto the board (solo commits that were never carded) — [--since "14 days ago"] [--dry-run]
   trantor handoff     finish this session NOW: write a handoff, open a fresh session that takes over, and close this one (manual baton)
   trantor advise      ask the Advisor directly (JSON on stdin; --demo to see it)

package/bin/gates.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+// trantor gates [--all] [--json] — verification gates for THIS project: structured "must verify
+// before shipping" claims that survive handoffs and surface to whoever takes over. Open by default;
+// --all includes resolved ones. Set/resolve gates from inside a session via the relay_verify_gate tool.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { resolveProject } from "../lib/project.mjs";
+
+const args = process.argv.slice(2);
+const all = args.includes("--all");
+const asJson = args.includes("--json");
+
+function relayUrl() {
+  if (process.env.RELAY_URL) return process.env.RELAY_URL;
+  try { const u = JSON.parse(readFileSync(join(homedir(), ".agent-bus", "config.json"), "utf8")).url; if (u) return u; } catch {}
+  return "http://127.0.0.1:4477";
+}
+
+const project = resolveProject(process.cwd());
+const url = `${relayUrl()}/verify-gates?project=${encodeURIComponent(project)}${all ? "&all=1" : ""}`;
+let gates = [];
+try {
+  const r = await fetch(url, { signal: AbortSignal.timeout(2500) });
+  gates = (await r.json()).gates || [];
+} catch {
+  console.error(`could not reach the hub at ${relayUrl()} — is it running? (trantor setup / trantor hub)`);
+  process.exit(1);
+}
+
+if (asJson) { process.stdout.write(JSON.stringify(gates, null, 2) + "\n"); process.exit(0); }
+if (!gates.length) { console.log(`${project}: no ${all ? "" : "open "}verification gates`); process.exit(0); }
+
+console.log(`${project} — ${gates.length} ${all ? "" : "open "}verification gate(s):`);
+for (const g of gates) {
+  const badge = g.status === "open" ? "⚠️ OPEN" : `✓ ${g.status}`;
+  console.log(`\n#${g.id}  ${badge}  ${g.claim}`);
+  if (g.why) console.log(`    why: ${g.why}`);
+  if (g.howToVerify) console.log(`    how: ${g.howToVerify}`);
+  if (g.status !== "open" && g.resolvedNote) console.log(`    resolved: ${g.resolvedNote}`);
+}

package/hooks/lib/handoff.mjs

@@ -15,6 +15,7 @@ import { join, basename, dirname } from "node:path";
 import { homedir, hostname } from "node:os";
 import { execSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { deriveSubagentManifest } from "../../lib/subagent-manifest.mjs";
 
 export const HANDOFF_DIR = join(process.env.RELAY_DATA_DIR || join(homedir(), ".agent-bus"), "handoffs");
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -220,6 +221,21 @@ export function writeHandoff({ projectDir, sessionId, transcript, trigger, summa
   try { gitStatus = execSync("git -C " + JSON.stringify(projectDir) + " status --short 2>/dev/null | head -30", { encoding: "utf8" }).trim(); } catch {}
   const narrative = summary ?? buildSummary(transcript);
   const tail = verbatimRecentTail(transcript);
+  // Sub-agent manifest SNAPSHOT (fallback). The successor should re-derive it LIVE via
+  // `trantor agents <sid>` (catches files an agent finished that were clobbered AFTER this
+  // snapshot — the kill that motivated this corrupted a completed 30KB lib post-handoff). This
+  // baked copy is just orientation if the live command isn't available. Best-effort; never throws.
+  let subagents = null;
+  try { subagents = deriveSubagentManifest(transcript, { projectRoot: projectDir }); } catch {}
+  // Open verification gates for this project — structured "must verify before shipping" claims that
+  // MUST survive the handoff (a narrative line gets skimmed past; this is what the v0.17.31 incident
+  // taught — the "verify Gail coefficients" intent vanished into prose). Fetched synchronously from
+  // the local hub; best-effort, never blocks the handoff.
+  let verifyGates = [];
+  try {
+    const out = execSync(`curl -s --max-time 2 ${JSON.stringify(relayUrl() + "/verify-gates?project=" + encodeURIComponent(projectName))}`, { encoding: "utf8", timeout: 2500 });
+    verifyGates = JSON.parse(out).gates || [];
+  } catch {}
   const record = {
     id: `${projectName}-${stamp}`,
     project: projectDir, projectName, machine: hostname(),
@@ -227,7 +243,7 @@ export function writeHandoff({ projectDir, sessionId, transcript, trigger, summa
     transcript_path: transcript || "", stamp: Number(stamp) || 0,
     // narrative + a verbatim recent-exchange block so exact in-flight state always survives
     summary: narrative + (tail ? `\n\n---\n## Verbatim recent exchange (exact in-flight state — continue from here)\n${tail}` : ""),
-    gitStatus, consumed: false,
+    gitStatus, subagents, verifyGates, consumed: false,
   };
   const file = join(HANDOFF_DIR, `${record.id}.json`);
   writeFileSync(file, JSON.stringify(record, null, 2));

package/hooks/sessionstart.mjs

@@ -11,6 +11,7 @@ import { join, basename } from "node:path";
 import { homedir, hostname } from "node:os";
 import { execSync } from "node:child_process";
 import { resolveProject, hostId } from "../lib/project.mjs";
+import { formatSubagentManifest } from "../lib/subagent-manifest.mjs";
 import { updateAvailable, maybeNotifyDesktop, readConfig } from "./lib/update-check.mjs";
 
 // Load the most recent UNCONSUMED handoff for this project (written by precompact.mjs
@@ -196,8 +197,32 @@ try {
     process.stderr.write(`[trantor] ${isCompact ? "showing (not claiming, compact)" : "loaded"} pending handoff ${handoff.id}\n`);
     additionalContext += `<trantor-handoff id="${sanitize(handoff.id)}" from="${sanitize(handoff.machine)}" trigger="${sanitize(handoff.trigger)}">\n`;
     additionalContext += `🔄 **You are taking over from a prior session that hit its context limit.** This is a fresh full window. Resume the work below — the prior session's summary, git state, and a pointer to its full transcript (searchable; Foundation/Gaia has it ingested) follow. Continue from "OPEN THREADS & NEXT STEPS"; do not restart from scratch.\n\n`;
+    // Verification gates FIRST — these are structured "must verify before shipping" claims the prior
+    // session couldn't independently prove. They go above the summary on purpose: a safety-critical
+    // check must not be skimmed past (the lesson of the lost "verify Gail coefficients" intent).
+    if (Array.isArray(handoff.verifyGates) && handoff.verifyGates.length) {
+      additionalContext += `## ⚠️ UNVERIFIED — verify before shipping (${handoff.verifyGates.length})\n`;
+      additionalContext += `The prior session flagged these as NOT independently verified. Do NOT commit or ship the related work until each is verified (or explicitly waived WITH the user) — passing the author's own tests is not verification. Resolve via the \`relay_verify_gate\` tool (action "resolve") once checked.\n`;
+      for (const g of handoff.verifyGates) {
+        additionalContext += `- **#${sanitize(String(g.id))}: ${sanitize(g.claim)}**${g.why ? ` — ${sanitize(g.why)}` : ""}`;
+        if (g.howToVerify) additionalContext += `\n    how to verify: ${sanitize(g.howToVerify)}`;
+        additionalContext += `\n`;
+      }
+      additionalContext += `\n`;
+    }
     additionalContext += `## Handoff summary\n${sanitize(handoff.summary)}\n`;
     if (handoff.gitStatus) additionalContext += `\n## Git working-tree at handoff\n\`\`\`\n${sanitize(handoff.gitStatus)}\n\`\`\`\n`;
+    // Sub-agent manifest: LIVE-primary, snapshot-as-fallback. The prior session may have had
+    // sub-agents (Agent/Task, Workflow) building things you can't see in its narrative — and a
+    // kill can corrupt an agent's finished file on disk. Direct the successor to re-derive LIVE
+    // (reconciles against current disk) and trust that over the baked snapshot.
+    if (handoff.subagents && handoff.subagents.counts && handoff.subagents.counts.total) {
+      const sa = handoff.subagents;
+      additionalContext += `\n## Sub-agents the prior session ran (${sa.counts.total}: ${sa.counts.completed} completed, ${sa.counts.inFlight} in-flight at handoff)\n`;
+      additionalContext += `**Before continuing, get the LIVE manifest** — run \`trantor agents ${sanitize(handoff.session_id)}\` (or \`trantor agents\` from this project). It re-derives from CURRENT disk, flagging any file an agent finished that was later clobbered — do NOT assume "nothing survived"; recover from the agent's transcript. Trust the live command over the snapshot below.\n`;
+      if (sa.counts.suspectFiles) additionalContext += `⚠️ ${sa.counts.suspectFiles} file(s) an agent wrote looked CLOBBERED at handoff time — verify with the live command and recover.\n`;
+      additionalContext += `\n\`\`\`\n${sanitize(formatSubagentManifest(sa, { heading: false }))}\n\`\`\`\n`;
+    }
     if (handoff.transcript_path) additionalContext += `\n_Full prior transcript: ${sanitize(handoff.transcript_path)}_\n`;
     additionalContext += `</trantor-handoff>\n`;
   }

package/hub.mjs

@@ -50,11 +50,11 @@ function scanTelemetry() {
 
 // peers: { session: { lastSeen, status, project } } ; tasks: kanban cards
 // projectMeta: { project: { brief, by, updated } } — the "what & why" blurb per project
-let state = { messages: [], peers: {}, seq: 0, tasks: [], taskSeq: 0, projectMeta: {}, lessons: [], cardEvents: [], cardEventsBackfilled: false, aliases: {}, phaseMeta: {} };
+let state = { messages: [], peers: {}, seq: 0, tasks: [], taskSeq: 0, projectMeta: {}, lessons: [], cardEvents: [], cardEventsBackfilled: false, aliases: {}, phaseMeta: {}, verifyGates: [], verifyGateSeq: 0 };
 try {
   if (existsSync(DATA)) {
     const loaded = JSON.parse(readFileSync(DATA, "utf8"));
-    state = { messages: loaded.messages || [], peers: {}, seq: loaded.seq || 0, tasks: loaded.tasks || [], taskSeq: loaded.taskSeq || 0, projectMeta: loaded.projectMeta || {}, lessons: loaded.lessons || [], cardEvents: Array.isArray(loaded.cardEvents) ? loaded.cardEvents : [], cardEventsBackfilled: !!loaded.cardEventsBackfilled, aliases: (loaded.aliases && typeof loaded.aliases === "object") ? loaded.aliases : {}, phaseMeta: (loaded.phaseMeta && typeof loaded.phaseMeta === "object") ? loaded.phaseMeta : {} };
+    state = { messages: loaded.messages || [], peers: {}, seq: loaded.seq || 0, tasks: loaded.tasks || [], taskSeq: loaded.taskSeq || 0, projectMeta: loaded.projectMeta || {}, lessons: loaded.lessons || [], cardEvents: Array.isArray(loaded.cardEvents) ? loaded.cardEvents : [], cardEventsBackfilled: !!loaded.cardEventsBackfilled, aliases: (loaded.aliases && typeof loaded.aliases === "object") ? loaded.aliases : {}, phaseMeta: (loaded.phaseMeta && typeof loaded.phaseMeta === "object") ? loaded.phaseMeta : {}, verifyGates: Array.isArray(loaded.verifyGates) ? loaded.verifyGates : [], verifyGateSeq: loaded.verifyGateSeq || 0 };
     for (const [s, v] of Object.entries(loaded.peers || {})) // migrate old numeric form
       state.peers[s] = typeof v === "number" ? { lastSeen: v, status: "", project: "" } : { lastSeen: v.lastSeen || 0, status: v.status || "", project: v.project || "" };
   }
@@ -487,6 +487,34 @@ const server = http.createServer(async (req, res) => {
       if (state.lessons.length > 500) state.lessons.splice(0, 100);
       dirty = true; return json(res, 200, { ok: true, count: state.lessons.length });
     }
+    // --- verification gates: structured "must verify before shipping" claims that travel with
+    // handoffs and surface PROMINENTLY to whoever takes over (so a safety-critical check can't be
+    // skimmed past in narrative prose — the "verify Gail coefficients" intent that got lost). ---
+    if (req.method === "POST" && P === "/verify-gate") {
+      const b = await body(req); touch(b.by, undefined, b.project);
+      const project = canon(String(b.project || "").slice(0, 80));
+      if (b.resolve) {
+        const g = state.verifyGates.find(x => x.id === Number(b.id) && x.project === project);
+        if (!g) return json(res, 404, { error: "gate not found" });
+        g.status = ["verified", "failed", "waived"].includes(b.status) ? b.status : "verified";
+        g.resolvedBy = b.by || ""; g.resolvedNote = String(b.note || "").slice(0, 300); g.resolvedTs = now();
+        dirty = true; return json(res, 200, { ok: true, gate: g });
+      }
+      const claim = String(b.claim || "").trim().slice(0, 300);
+      if (!claim) return json(res, 400, { error: "claim required" });
+      const dup = state.verifyGates.find(x => x.project === project && x.claim === claim && x.status === "open");
+      if (dup) return json(res, 200, { ok: true, gate: dup, dedup: true });
+      const g = { id: ++state.verifyGateSeq, project, claim, why: String(b.why || "").slice(0, 300),
+        howToVerify: String(b.howToVerify || "").slice(0, 300), status: "open", by: b.by || "", ts: now() };
+      state.verifyGates.push(g); if (state.verifyGates.length > 500) state.verifyGates.splice(0, 100);
+      dirty = true; return json(res, 200, { ok: true, gate: g });
+    }
+    if (req.method === "GET" && P === "/verify-gates") {
+      const project = canon(String(q.project || ""));
+      let gates = state.verifyGates.filter(g => !project || g.project === project);
+      if (q.all !== "1") gates = gates.filter(g => g.status === "open");
+      return json(res, 200, { gates });
+    }
     if (req.method === "GET" && P === "/economics") {   // the brain's books, surfaced: scrooge ledger + quota profile
       const out = { scrooge: null, lifetime: null, profile: null };
       try { out.profile = JSON.parse(readFileSync(join(homedir(), ".agent-bus", "profile.json"), "utf8")).providers || {}; } catch {}

package/lib/subagent-manifest.mjs

@@ -0,0 +1,175 @@
+// trantor sub-agent manifest — reconstruct what a session's sub-agents (Agent/Task tool,
+// Workflow swarms, agent-teams) were doing, purely from on-disk transcripts. No new runtime
+// instrumentation: it's a READ-TIME projection of primary sources, so it can't drift and the
+// successor can re-derive it itself (that's the point — live-primary, snapshot-as-fallback).
+//
+// Born from the 2026-06-21 incident: an auto baton-pass SIGKILLed a session mid 2-agent build.
+// The fresh session had no idea two agents were even running, and one agent's COMPLETED 30KB
+// implementation had been clobbered on disk to a 17-byte stub by the kill — so the successor
+// rebuilt it from scratch believing "nothing survived." The manifest surfaces exactly that:
+// what each agent was tasked with, whether it returned, what it wrote, and — via a disk
+// reconcile — whether the files it wrote still survive or look clobbered.
+//
+// Four primary sources (all already on disk under ~/.claude/projects/<proj>/<sid>/):
+//   1. subagents/*.meta.json        → {name, agentType, description (the task), toolUseId}
+//   2. parent <sid>.jsonl           → tool_result ids ⇒ which agents RETURNED (completed)
+//   3. each subagents/agent-*.jsonl → files written, last activity, the result it reported
+//   4. disk reconcile               → agent wrote X@N bytes; does X still exist & match? (suspect)
+import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
+import { join, dirname, basename, relative } from "node:path";
+import { homedir } from "node:os";
+
+const EDIT_TOOLS = /^(Write|Edit|MultiEdit|NotebookEdit)$/;
+
+function parseLines(path) {
+  let raw; try { raw = readFileSync(path, "utf8"); } catch { return []; }
+  const out = [];
+  for (const ln of raw.split("\n")) { if (!ln) continue; try { out.push(JSON.parse(ln)); } catch {} }
+  return out;
+}
+
+// Resolve a bare session id to its transcript path by scanning ~/.claude/projects/*/<sid>.jsonl.
+export function resolveTranscriptForSid(sid) {
+  if (!sid) return "";
+  const base = join(homedir(), ".claude", "projects");
+  try {
+    for (const proj of readdirSync(base)) {
+      const p = join(base, proj, `${sid}.jsonl`);
+      if (existsSync(p)) return p;
+    }
+  } catch {}
+  return "";
+}
+
+// Walk subagents/ (recursing into workflows/<wf>/) collecting every *.meta.json paired with its
+// .jsonl. `workflow` is the workflow id when the agent lives under workflows/<wf>/, else null.
+function collectMetas(subdir) {
+  const out = [];
+  const walk = (dir, workflow) => {
+    let entries; try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const p = join(dir, e.name);
+      if (e.isDirectory()) { walk(p, e.name === "workflows" ? workflow : e.name); continue; }
+      if (!e.name.endsWith(".meta.json")) continue;
+      let meta; try { meta = JSON.parse(readFileSync(p, "utf8")); } catch { continue; }
+      out.push({ ...meta, jsonlPath: p.replace(/\.meta\.json$/, ".jsonl"), workflow: workflow || null });
+    }
+  };
+  walk(subdir, null);
+  return out;
+}
+
+function shortPath(absPath, projectRoot) {
+  try {
+    if (projectRoot && absPath.startsWith(projectRoot)) return relative(projectRoot, absPath) || absPath;
+  } catch {}
+  return absPath.split("/").slice(-4).join("/");
+}
+
+// Does the file the agent wrote still survive intact? agentBytes = the size the agent last wrote.
+// suspect = the file is gone, or shrank far below what the agent wrote (clobbered, e.g. by a kill).
+function reconcileFile(absPath, agentBytes, projectRoot) {
+  let onDiskNow = null, suspect = false;
+  try {
+    if (existsSync(absPath)) {
+      onDiskNow = statSync(absPath).size;
+      if (agentBytes > 200 && onDiskNow < Math.min(agentBytes * 0.5, agentBytes - 200)) suspect = true;
+    } else {
+      onDiskNow = 0;
+      suspect = agentBytes > 200; // the agent wrote real content but the file is gone
+    }
+  } catch {}
+  return { path: shortPath(absPath, projectRoot), agentBytes, onDiskNow, suspect };
+}
+
+function analyzeAgent(meta, completedIds, projectRoot) {
+  const wrote = new Map(); // absPath → last-write byte length
+  let lastMs = 0, result = "";
+  for (const r of parseLines(meta.jsonlPath)) {
+    const ts = r.timestamp ? Date.parse(r.timestamp) || 0 : 0;
+    if (ts > lastMs) lastMs = ts;
+    const c = r?.message?.content;
+    if (!Array.isArray(c)) continue;
+    for (const b of c) {
+      if (b?.type === "tool_use" && EDIT_TOOLS.test(b.name) && b.input?.file_path) {
+        const content = b.input.content ?? b.input.new_string ?? "";
+        wrote.set(b.input.file_path, content.length); // last write to a path wins
+      }
+      if (b?.type === "text" && typeof b.text === "string" && b.text.trim()) result = b.text.trim();
+    }
+  }
+  const status = meta.toolUseId && completedIds.has(meta.toolUseId) ? "completed" : "in-flight";
+  return {
+    name: meta.name || basename(meta.jsonlPath).replace(/\.jsonl$/, ""),
+    agentType: meta.agentType || "",
+    task: meta.description || "",
+    workflow: meta.workflow || null,
+    status,
+    wrote: [...wrote.entries()].map(([p, n]) => reconcileFile(p, n, projectRoot)),
+    lastActivity: lastMs ? new Date(lastMs).toISOString() : null,
+    lastActivityMs: lastMs,
+    transcript: meta.jsonlPath,
+    result: result.slice(0, 400),
+  };
+}
+
+// Derive the full manifest for a session from its parent transcript path. projectRoot (the repo
+// dir) is used only to shorten displayed file paths. Returns { sessionId, subagents[], counts }.
+export function deriveSubagentManifest(parentTranscript, { projectRoot } = {}) {
+  const out = { sessionId: "", subagents: [], counts: { total: 0, completed: 0, inFlight: 0, suspectFiles: 0 } };
+  try {
+    if (!parentTranscript || !existsSync(parentTranscript)) return out;
+    const sid = basename(parentTranscript).replace(/\.jsonl$/i, "");
+    out.sessionId = sid;
+    const subdir = join(dirname(parentTranscript), sid, "subagents");
+    if (!existsSync(subdir)) return out;
+
+    // (2) parent transcript → tool_result ids = agents that returned a result.
+    const completedIds = new Set();
+    for (const r of parseLines(parentTranscript)) {
+      const c = r?.message?.content;
+      if (Array.isArray(c)) for (const b of c) if (b?.type === "tool_result" && b.tool_use_id) completedIds.add(b.tool_use_id);
+    }
+
+    const metas = collectMetas(subdir);
+    out.subagents = metas.map((m) => analyzeAgent(m, completedIds, projectRoot))
+      .sort((a, b) => (a.lastActivityMs || 0) - (b.lastActivityMs || 0));
+
+    out.counts.total = out.subagents.length;
+    out.counts.completed = out.subagents.filter((s) => s.status === "completed").length;
+    out.counts.inFlight = out.subagents.filter((s) => s.status === "in-flight").length;
+    out.counts.suspectFiles = out.subagents.reduce((n, s) => n + s.wrote.filter((w) => w.suspect).length, 0);
+  } catch {}
+  return out;
+}
+
+// Human-readable rendering (the `trantor agents` output, and the handoff snapshot block).
+export function formatSubagentManifest(m, { heading = true } = {}) {
+  if (!m || !m.subagents.length) return "No sub-agents found for this session.";
+  const L = [];
+  if (heading) {
+    L.push(`Sub-agent manifest — ${m.counts.total} agents (${m.counts.completed} completed, ${m.counts.inFlight} in-flight at handoff)`);
+    if (m.counts.suspectFiles) {
+      L.push(`⚠️  ${m.counts.suspectFiles} file(s) an agent wrote look CLOBBERED on disk (gone or far smaller than written) — RECOVER from the agent's transcript before assuming the work was never done.`);
+    }
+  }
+  for (const s of m.subagents) {
+    const badge = s.status === "completed" ? "✅ completed" : "🛑 IN-FLIGHT at handoff";
+    L.push("");
+    L.push(`• ${s.name}  [${s.agentType}]${s.workflow ? ` · wf:${s.workflow}` : ""}  ${badge}`);
+    if (s.task) L.push(`    task: ${s.task}`);
+    if (s.wrote.length) {
+      for (const w of s.wrote) {
+        const size = w.onDiskNow != null ? (w.onDiskNow === 0 && w.suspect ? "MISSING" : `${w.onDiskNow}B on disk`) : "?";
+        const flag = w.suspect ? `   ⚠️ SUSPECT — agent wrote ${w.agentBytes}B, recover from transcript` : "";
+        L.push(`    wrote: ${w.path} (${size})${flag}`);
+      }
+    } else {
+      L.push(`    wrote: (no file edits)`);
+    }
+    L.push(`    transcript: ${s.transcript}`);
+  }
+  L.push("");
+  L.push(`Read any agent's transcript for its full reasoning/sourcing before trusting OR discarding its work.`);
+  return L.join("\n");
+}

package/mcp.mjs

@@ -105,6 +105,32 @@ server.tool("relay_lesson", "Record a LESSON learned from a failure so future cr
     return { content: [{ type: "text", text: r.dedup ? "lesson already recorded" : `lesson recorded (${r.count} total)` }] };
   });
 
+server.tool("relay_verify_gate", "Record a VERIFICATION GATE — a claim that MUST be independently verified before the related work ships (e.g. 'Gail breast coefficients match the published BCRAT model'). Unlike a note buried in a handoff narrative, a gate is STRUCTURED: it travels with handoffs and is shown PROMINENTLY to whoever takes over, so a safety-critical 'verify before commit' can't be skimmed past. action 'add' when you produce code whose correctness you have NOT independently proven (especially formulas/coefficients/security/data-shape); 'resolve' once you've verified it (or waived with the user); 'list' to see open gates. Defaults to THIS project.",
+  { action: z.enum(["add", "resolve", "list"]).describe("add a gate · resolve one · list open gates"),
+    claim: z.string().optional().describe("what must be verified (required for add) — a specific, checkable claim"),
+    why: z.string().optional().describe("why it matters / the risk if it ships unverified"),
+    howToVerify: z.string().optional().describe("the concrete check that would verify it (source to cross-check, command to run)"),
+    id: z.number().optional().describe("gate id to resolve"),
+    status: z.string().optional().describe("resolve status: 'verified' (default) | 'failed' | 'waived'"),
+    note: z.string().optional().describe("resolution note (what you checked / why waived)"),
+    project: z.string().optional().describe("target project (default: this session's project)") },
+  async ({ action, claim, why, howToVerify, id, status, note, project }) => {
+    const proj = project || PROJECT;
+    if (action === "list") {
+      const { gates } = await api("GET", `/verify-gates?project=${encodeURIComponent(proj)}`);
+      if (!gates || !gates.length) return { content: [{ type: "text", text: `${proj}: no open verification gates` }] };
+      return { content: [{ type: "text", text: gates.map(g => `#${g.id} ⚠️ ${g.claim}${g.why ? ` — ${g.why}` : ""}`).join("\n") }] };
+    }
+    if (action === "resolve") {
+      if (!id) return { content: [{ type: "text", text: "id required to resolve a gate" }] };
+      const r = await api("POST", "/verify-gate", { resolve: true, id, status: status || "verified", note, project: proj, by: SESSION });
+      return { content: [{ type: "text", text: r.error ? `error: ${r.error}` : `gate #${id} resolved (${r.gate?.status || status || "verified"})` }] };
+    }
+    if (!claim) return { content: [{ type: "text", text: "claim required to add a gate" }] };
+    const r = await api("POST", "/verify-gate", { claim, why, howToVerify, project: proj, by: SESSION });
+    return { content: [{ type: "text", text: r.dedup ? `gate already open (#${r.gate.id})` : `🔒 verification gate #${r.gate.id} recorded — surfaces on every handoff until you resolve it` }] };
+  });
+
 server.tool("relay_board", "Show a project's Kanban board (all cards + their status + assignee). Defaults to THIS project; pass `project` to read a crew board you orchestrate from elsewhere.",
   { project: z.string().optional().describe("board to show (default: this session's project)") },
   async ({ project }) => {

package/package.json

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