trantor 0.17.29 → 0.17.30

package/.claude-plugin/plugin.json

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

@@ -2,15 +2,25 @@
 // trantor baton-close — the second half of the baton pass. Runs DETACHED, armed by the handoff hook.
 // Waits until the FRESH session has consumed the handoff (consumed:true on the handoff file = it
 // started and loaded the context), THEN closes the ORIGINAL session's Terminal window — so you're never
-// left with two live sessions on one project, and never a gap where neither is alive. Defensive: aborts
-// if the fresh session never shows (timeout), and re-validates the window's tty before closing so it can
-// NEVER close the wrong window. Args: <handoffFile> <originalWindowId> <originalTty>
-import { readFileSync, existsSync } from "node:fs";
+// left with two live sessions on one project, and never a gap where neither is alive.
+//
+// NON-DESTRUCTIVE by contract (incident 2026-06-21): this NEVER force-kills a session. It only ever
+// runs for an OPT-IN auto-close (config.autoCloseOriginal) or a manual /trantor:handoff, and before
+// closing it (a) waits for the fresh session's first real turn, (b) re-validates the window's tty so it
+// can never close the wrong window, and (c) ABORTS if the original session is still working (recent
+// transcript activity or live sub-agents) — leaving it alive for you to close yourself. The old code
+// SIGKILLed every process on the original tty the instant the fresh session emitted one turn, which
+// killed an in-flight 2-agent build mid-flight. Args: <handoffFile> <originalWindowId> <originalTty>
+import { readFileSync, existsSync, statSync } from "node:fs";
 import { execSync } from "node:child_process";
 import { pathToFileURL } from "node:url";
+import { subagentsActive } from "../hooks/lib/handoff.mjs";
 
 const [, , handoffFile, windowId, originalTty] = process.argv;
 const POLL_MS = 1500, TIMEOUT_MS = 180_000;
+// The original session counts as "still working" if its OWN transcript was written within this window
+// (it's mid-turn / mid-tool-call) — we leave it alone rather than risk closing live work.
+const ORIG_QUIET_MS = 12_000, SUBAGENT_ACTIVE_MS = 90_000;
 // Once the handoff is consumed (= injected into the fresh session's context), wait up to this long for
 // the fresh session to actually PRODUCE its first assistant turn (it boots with `claude 'Recap…'`, so it
 // genuinely reads the handoff and replies) before we close the original. If the fresh session never
@@ -56,6 +66,18 @@ async function waitForTakeover() {
   process.stderr.write(`[trantor] baton-close: fresh session consumed but produced no turn within ${ENGAGE_GRACE_MS / 1000}s — closing anyway (handoff already injected)\n`);
 }
 
+// True if the ORIGINAL session is still doing real work — its own transcript was written very recently
+// (mid-turn / mid-tool-call) or it has sub-agents running. We NEVER close a working session; if this is
+// true at takeover time we abort and leave the window alive. Exported for headless regression testing.
+export function originalStillWorking(rec, { quietMs = ORIG_QUIET_MS, subWithinMs = SUBAGENT_ACTIVE_MS } = {}) {
+  try {
+    const tp = rec?.transcript_path;
+    if (!tp || !existsSync(tp)) return false;
+    try { if (Date.now() - statSync(tp).mtimeMs < quietMs) return true; } catch {}
+    return subagentsActive(tp, subWithinMs);
+  } catch { return false; }
+}
+
 function ttyOfWindow(id) {
   try {
     return execSync(`osascript -e ${JSON.stringify(`tell application "Terminal" to get tty of selected tab of (first window whose id is ${id})`)}`,
@@ -70,10 +92,12 @@ function closeWindow(id, tty) {
     return false;
   }
   try {
-    // SIGKILL the processes on that tty first (claude traps SIGTERM; a live login makes close() pop a dialog)
+    // Gently ask the processes on that tty to exit (SIGTERM — never SIGKILL; we do not force-kill a
+    // session). We only reach here once the original is confirmed idle (no in-flight work), so claude
+    // exits cleanly. If something ignores SIGTERM the window close below still tidies up.
     const dev = (tty || cur).replace(/^\/dev\//, "");
     for (const pid of execSync(`ps -t ${dev} -o pid= 2>/dev/null || true`, { encoding: "utf8" }).trim().split("\n").filter(Boolean)) {
-      try { execSync(`kill -9 ${pid.trim()} 2>/dev/null || true`); } catch {}
+      try { execSync(`kill -TERM ${pid.trim()} 2>/dev/null || true`); } catch {}
     }
   } catch {}
   try { execSync(`osascript -e ${JSON.stringify(`tell application "Terminal" to close (first window whose id is ${id})`)}`, { timeout: 3000 }); return true; } catch { return false; }
@@ -88,6 +112,12 @@ if (isMain) (async () => {
   while (Date.now() < deadline) {
     if (consumed()) {
       await waitForTakeover(); // don't close until the fresh session has actually produced its recap turn
+      // Final safety gate: never close a session that's still working. If the original is mid-turn or has
+      // live sub-agents, abort and leave it alive — the user closes it when ready (incident 2026-06-21).
+      if (originalStillWorking(handoff())) {
+        process.stderr.write(`[trantor] baton-close: original session still working (recent activity / live sub-agents) — leaving it alive, NOT closing\n`);
+        process.exit(0);
+      }
       const ok = closeWindow(windowId, originalTty);
       process.stderr.write(`[trantor] baton-close: fresh session took over → original window ${windowId} ${ok ? "closed" : "left (validation/close failed)"}\n`);
       process.exit(0);

package/hooks/handoff-now.mjs

@@ -16,8 +16,11 @@ try {
   process.stderr.write(`[trantor] baton handoff written: ${file}\n`);
   await pingBus(basename(projectDir), record.id, conf);
   if (maybeSpawn(projectDir, conf)) {                 // open the fresh session that takes over
-    const armed = windowId ? armBatonClose(file, windowId, tty, conf) : false;  // close the original once fresh confirms
-    process.stderr.write(`[trantor] fresh session spawned${armed ? ` · baton-close armed for window ${windowId}` : " · no original-window close (none detected / disabled)"}\n`);
+    // AUTO baton: close the original ONLY if explicitly opted in (config.autoCloseOriginal:true).
+    // Default = leave the original alive (the fresh window takes over; you close the old one). This is
+    // the 2026-06-21 fix — an auto-close must never kill an in-flight session.
+    const armed = windowId ? armBatonClose(file, windowId, tty, conf, { auto: true }) : false;
+    process.stderr.write(`[trantor] fresh session spawned${armed ? ` · baton-close armed for window ${windowId}` : " · original window left alive (auto-close off by default)"}\n`);
   }
 } catch (e) {
   process.stderr.write(`[trantor] handoff-now error: ${e?.message || e}\n`);

package/hooks/heartbeat.mjs

@@ -18,7 +18,7 @@ import { join, basename, dirname } from "node:path";
 import { homedir, hostname } from "node:os";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { readConfig, contextUsage, warnFrac, alreadyHandedOff, markHandedOff, controllingTty, terminalWindowForTty } from "./lib/handoff.mjs";
+import { readConfig, contextUsage, warnFrac, alreadyHandedOff, markHandedOff, controllingTty, terminalWindowForTty, subagentsActive } from "./lib/handoff.mjs";
 import { resolveProject, hostId } from "../lib/project.mjs";
 
 const HEARTBEAT_MS = Number(process.env.RELAY_HEARTBEAT_MS || 60 * 1000);
@@ -49,6 +49,16 @@ async function maybeEarlyWarn(stdinRaw, session) {
     if (usage.frac < warnFrac(conf)) return;
     if (alreadyHandedOff(sessionId, usage.tokens)) return;
 
+    // Mid-build guard (incident 2026-06-21): never fire an auto baton-pass while this session is
+    // actively orchestrating sub-agents — popping a fresh window (or, before the fix, killing the
+    // original) mid 2-agent build is exactly the failure we must prevent. Defer: the next heartbeat
+    // re-checks once the agents finish, and PreCompact remains the at-the-wall backstop. We do NOT
+    // markHandedOff here, so the baton genuinely retries later instead of being silently skipped.
+    if (subagentsActive(transcript)) {
+      process.stderr.write(`[trantor] context ${Math.round(usage.frac * 100)}% but sub-agents active — deferring baton pass\n`);
+      return;
+    }
+
     // In-flight guard: the detached worker takes ~tens of seconds to summarize;
     // don't launch a second one on the next heartbeat tick meanwhile.
     const inflight = join(homedir(), ".agent-bus", `handoff-inflight-${String(sessionId).replace(/[^A-Za-z0-9_.-]/g, "_")}.stamp`);

package/hooks/lib/handoff.mjs

@@ -10,7 +10,7 @@
 // session that loads the handoff. The heartbeat path lets us do that BEFORE the
 // wall when we know the window size. Both paths share a per-session guard so we
 // never write/spawn twice for the same context window.
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, openSync, readSync, fstatSync, closeSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, openSync, readSync, fstatSync, closeSync } from "node:fs";
 import { join, basename, dirname } from "node:path";
 import { homedir, hostname } from "node:os";
 import { execSync, spawn } from "node:child_process";
@@ -105,6 +105,34 @@ export function markHandedOff(sessionId, curTokens = 0) {
 
 function nowSec() { try { return Number(execSync("date +%s", { encoding: "utf8" }).trim()) || 0; } catch { return 0; } }
 
+// ---- in-flight guard --------------------------------------------------------
+// True when this session is actively orchestrating sub-agents (Agent/Task tool, Workflow swarms,
+// agent-teams): any `agent-*.jsonl` under <transcriptDir>/<sid>/subagents/ (incl. workflows/) was
+// written within `withinMs`. The auto baton-pass uses this to DEFER — we must never yank a fresh
+// window up (or, before the 2026-06-21 fix, kill the original) while real in-flight agent work is
+// running. INCIDENT 2026-06-21: a 90% baton fired mid 2-agent build and the original session was
+// SIGKILLed mid-flight. Best-effort; returns false on any error.
+export function subagentsActive(transcriptPath, withinMs = 90_000) {
+  try {
+    if (!transcriptPath) return false;
+    const sub = join(dirname(transcriptPath), basename(transcriptPath).replace(/\.jsonl$/i, ""), "subagents");
+    if (!existsSync(sub)) return false;
+    const cutoff = Date.now() - withinMs;
+    const stack = [sub];
+    while (stack.length) {
+      const d = stack.pop();
+      let entries; try { entries = readdirSync(d, { withFileTypes: true }); } catch { continue; }
+      for (const e of entries) {
+        const p = join(d, e.name);
+        if (e.isDirectory()) { stack.push(p); continue; }
+        if (!/^agent-.*\.jsonl$/i.test(e.name)) continue;
+        try { if (statSync(p).mtimeMs >= cutoff) return true; } catch {}
+      }
+    }
+    return false;
+  } catch { return false; }
+}
+
 // ---- whole-session summary --------------------------------------------------
 function collectTurns(transcriptPath) {
   const rows = readFileSync(transcriptPath, "utf8").split("\n").filter(Boolean)
@@ -262,10 +290,17 @@ export function terminalWindowForTty(tty) {
 // Arm the baton-close watcher: a DETACHED process that waits until the fresh session consumes the
 // handoff (consumed:true), then closes the original Terminal window. Never closes blind: aborts on
 // timeout (fresh never showed) and re-validates the window's tty before closing.
-export function armBatonClose(handoffFile, originalWindowId, originalTty, conf = readConfig()) {
+export function armBatonClose(handoffFile, originalWindowId, originalTty, conf = readConfig(), { auto = false } = {}) {
   try {
     if (process.platform !== "darwin" || !originalWindowId) return false;
     if (process.env.TRANTOR_NO_BATON_CLOSE === "1" || conf.batonClose === false) return false;
+    // SAFETY (incident 2026-06-21): an AUTOMATIC baton must NEVER close the original session. At 90%
+    // (10% headroom) mid 2-agent build, auto-close SIGKILLed the original window's processes and killed
+    // in-flight work — the scariest possible failure. Auto-close is now strictly opt-in
+    // (config.autoCloseOriginal:true). The default auto baton just opens the fresh window and LEAVES the
+    // original alive. Manual /trantor:handoff still closes (the user explicitly invoked a wrap-up) — and
+    // even that is now non-destructive (baton-close never SIGKILLs and aborts if the original is busy).
+    if (auto && conf.autoCloseOriginal !== true) return false;
     const closer = join(HERE, "..", "..", "bin", "baton-close.mjs");
     if (!existsSync(closer)) return false;
     const child = spawn(process.execPath, [closer, handoffFile, String(originalWindowId), originalTty || ""], { detached: true, stdio: "ignore" });

package/hooks/precompact.mjs

@@ -37,11 +37,13 @@ try {
     process.stderr.write(`[trantor] fresh session already spawned for this window — handoff refreshed only\n`);
   } else if (maybeSpawn(projectDir, conf)) {
     markHandedOff(sessionId, cur);
-    // baton pass: arm the close of THIS window once the fresh session takes over (we have the tty here)
+    // baton pass: at-the-wall fresh session. Close THIS window ONLY if opted in
+    // (config.autoCloseOriginal:true) — default leaves the original alive (2026-06-21 fix: an auto
+    // baton must never kill a session). We have the controlling tty here for the opt-in case.
     const tty = controllingTty();
     const windowId = tty ? terminalWindowForTty(tty) : "";
-    const armed = windowId ? armBatonClose(file, windowId, tty, conf) : false;
-    process.stderr.write(`[trantor] fresh-session spawned (PreCompact)${armed ? ` · baton-close armed for window ${windowId}` : ""}\n`);
+    const armed = windowId ? armBatonClose(file, windowId, tty, conf, { auto: true }) : false;
+    process.stderr.write(`[trantor] fresh-session spawned (PreCompact)${armed ? ` · baton-close armed for window ${windowId}` : " · original window left alive (auto-close off by default)"}\n`);
   }
 } catch (err) {
   process.stderr.write(`[trantor] precompact error: ${err?.message || err}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.29",
+  "version": "0.17.30",
   "type": "module",
   "bin": {
     "trantor": "bin/cli.mjs"