trantor 0.18.95 → 0.18.97

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.95",
+  "version": "0.18.97",
   "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/crew/open.mjs

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { existsSync, openSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { existsSync, openSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { spawn, execSync } from "node:child_process";
@@ -43,19 +43,44 @@ function sessionId(ctx) {
   return id;
 }
 
-export function hasPendingHandoff(ctx) {
+// #11641: a handoff is stale once its own session kept working after writing it (auto handoffs fire
+// at a context threshold, not at the end). Slack so the write itself, and the hook flushing the
+// transcript around it, never read as "later work".
+export const HANDOFF_SUPERSEDE_GRACE_SECS = 120;
+
+function unconsumedHandoffs(ctx) {
   const dir = join(ctx.env.AGENT_BUS_DIR || ctx.env.RELAY_DATA_DIR || join(ctx.home, ".agent-bus"), "handoffs");
-  if (!existsSync(dir)) return false;
+  if (!existsSync(dir)) return [];
   const prefix = `${ctx.project}-`;
+  const out = [];
   for (const file of readdirSync(dir).filter(name => name.startsWith(prefix) && name.endsWith(".json")).sort().reverse()) {
-    try { if (!JSON.parse(readFileSync(join(dir, file), "utf8")).consumed) return true; }
+    try { const rec = JSON.parse(readFileSync(join(dir, file), "utf8")); if (!rec.consumed) out.push({ file, rec }); }
     catch {}
   }
-  return false;
+  return out;
+}
+
+// The handoff written BY the recorded session `id` whose transcript has since grown past it, or null.
+export function supersededHandoff(ctx, id) {
+  for (const { file, rec } of unconsumedHandoffs(ctx)) {
+    if (!id || rec.session_id !== id || !(Number(rec.stamp) > 0)) continue;
+    const slug = String(rec.project || ctx.dir || "").replace(/[/.]/g, "-");
+    const transcript = rec.transcript_path || join(ctx.home, ".claude", "projects", slug, `${id}.jsonl`);
+    try {
+      const workedAt = statSync(transcript).mtimeMs / 1000;
+      if (workedAt > Number(rec.stamp) + HANDOFF_SUPERSEDE_GRACE_SECS) return { file, handoffAt: Number(rec.stamp), workedAt };
+    } catch {}
+  }
+  return null;
+}
+
+export function hasPendingHandoff(ctx, id) {
+  const sup = id ? supersededHandoff(ctx, id) : null;
+  return unconsumedHandoffs(ctx).some(({ file }) => !sup || file !== sup.file);
 }
 
 export function takeoverSessionId(ctx, id) {
-  return hasPendingHandoff(ctx) ? randomUUID() : id;
+  return hasPendingHandoff(ctx, id) ? randomUUID() : id;
 }
 
 function harnessFlag(ctx) {
@@ -201,7 +226,12 @@ export function openOrchestrator(ctx, args) {
     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)) {
+    const stale = supersededHandoff(ctx, id);
+    if (stale) {
+      const at = secs => new Date(secs * 1000).toISOString();
+      console.error(`— handoff ${stale.file} was superseded by later work in session ${id} (handoff ${at(stale.handoffAt)}, transcript ${at(stale.workedAt)}): resuming it, leaving the handoff unclaimed —`);
+    }
+    if (hasPendingHandoff(ctx, id)) {
       const fresh = takeoverSessionId(ctx, id);
       console.error(`— recorded session ${id} handed off: starting fresh as ${fresh} to claim it —`);
       id = fresh;

package/bin/crew-runner.mjs

@@ -30,6 +30,7 @@ import {
 import { snapshotBeforeCut } from "./cut-snapshot.mjs";
 import { ocTurnUsage, dshTurnUsage, usageTotal } from "../lib/turn-usage.mjs";
 import { ocCompactionContent, ocCompactionLogLine } from "../lib/seat-compaction.mjs";
+import { seatSignalPrefix } from "../lib/seat-signal-guard.mjs";
 import { listContainers, newContainers, recordContainers, statePathFor as dockerStatePathFor, sweep as dockerSweep } from "../lib/docker-janitor.mjs";
 import {
   auditDutyNudges, claimDutyNudges, claudeTranscriptDir, dutyEscalations, dutyNudgeDirective,
@@ -834,7 +835,7 @@ async function runTurn(prompt, isFirst, trigger = "kickoff", opts = {}) {
   // #6393: the store's keys ride the spawn env under shadow names and the shell re-exports them
   // AFTER the sources ran, so the keychain wins over a stale .env line and no file is ever copied.
   const secrets = resolveSecrets(process.env);
-  cmd = withEnvFiles(withSecretExports(cmd, Object.keys(secrets)), envs);
+  cmd = withEnvFiles(withSecretExports(seatSignalPrefix(TURN_DIR) + cmd, Object.keys(secrets)), envs);
   log(`turn starting (${isFirst ? "fresh session" : "resume"})${MODEL ? ` · model=${MODEL}` : ""}`);
   // #7777: the one effort line — which effort parameters were set, or that the model is uncatalogued.
   if (EFFORT && EFFORT_FLAG.text) log(EFFORT_FLAG.text);

package/bin/seat-signal.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { constants } from "node:os";
+import { basename } from "node:path";
+
+const [command, ...args] = process.argv.slice(2);
+const refuse = reason => { throw new Error(reason); };
+
+function signalValue(value) {
+  if (/^\d+$/.test(value)) {
+    const n = Number(value);
+    if (n === 0 || Object.values(constants.signals).includes(n)) return n;
+  }
+  const name = value.toUpperCase().replace(/^SIG/, "");
+  if (constants.signals[`SIG${name}`]) return constants.signals[`SIG${name}`];
+  return refuse("unknown signal");
+}
+
+function processTable() {
+  const ps = spawnSync("/bin/ps", ["-axo", "pid=,ppid=,comm="], { encoding: "utf8", timeout: 5000 });
+  if (ps.error || ps.status !== 0) refuse("cannot inspect process ancestry");
+  const rows = new Map();
+  for (const line of ps.stdout.split("\n")) {
+    const match = /^\s*(\d+)\s+(\d+)\s+(.+)$/.exec(line);
+    if (match) rows.set(Number(match[1]), { parent: Number(match[2]), name: basename(match[3].trim()) });
+  }
+  return rows;
+}
+
+function descendant(pid, root, rows) {
+  const seen = new Set();
+  while (pid !== root && rows.has(pid) && !seen.has(pid)) {
+    seen.add(pid);
+    pid = rows.get(pid).parent;
+  }
+  return seen.size > 0 && pid === root;
+}
+
+function targets(rows) {
+  let signal = constants.signals.SIGTERM;
+  let at = 0;
+  if (["-s", "--signal"].includes(args[at])) {
+    if (!args[at + 1]) refuse("missing signal");
+    signal = signalValue(args[at + 1]); at += 2;
+  } else if (/^-(?:\d+|(?:SIG)?[A-Z]+)$/i.test(args[at] || "") && !/^-[fix]+$/.test(args[at])) {
+    signal = signalValue(args[at].slice(1)); at++;
+  }
+  if (command === "kill") {
+    if (args[at] === "--") at++;
+    const pids = args.slice(at);
+    if (!pids.length || pids.some(p => !/^[1-9]\d*$/.test(p) || !Number.isSafeInteger(Number(p)))) {
+      refuse("kill requires positive PIDs; process groups and job specs are refused");
+    }
+    return { signal, pids: pids.map(Number) };
+  }
+  if (command === "pkill") {
+    const flags = [];
+    while (/^-[fix]+$/.test(args[at] || "")) flags.push(args[at++]);
+    if (args.length - at !== 1 || args[at].startsWith("-")) {
+      refuse("pkill requires options before one pattern; ambiguous or unsupported arguments");
+    }
+    // pgrep resolves native regex semantics without ever invoking the signalling binary.
+    const result = spawnSync("/usr/bin/pgrep", [...flags, args[at]], { encoding: "utf8", timeout: 5000 });
+    if (result.error || ![0, 1].includes(result.status)) refuse("cannot resolve pkill pattern");
+    return { signal, pids: result.stdout.trim().split(/\s+/).filter(Boolean).map(Number) };
+  }
+  if (command === "killall") {
+    const names = args.slice(at);
+    if (!names.length || names.some(name => name.startsWith("-") || name.includes("/"))) {
+      refuse("killall requires exact process names; unsupported arguments");
+    }
+    return { signal, pids: [...rows].filter(([, row]) => names.includes(row.name)).map(([pid]) => pid) };
+  }
+  return refuse("unknown signal command");
+}
+
+try {
+  const root = Number(process.env.TRANTOR_SIGNAL_ROOT);
+  if (!Number.isSafeInteger(root) || root <= 1) refuse("missing seat process root");
+  const rows = processTable();
+  if (!descendant(process.pid, root, rows)) refuse("guard is outside the seat process tree");
+  const selected = targets(rows);
+  const pids = [...new Set(selected.pids)].filter(pid => pid !== process.pid);
+  if (!pids.length) process.exit(1);
+  for (const pid of pids) {
+    if (!descendant(pid, root, rows)) refuse(`PID ${pid} is outside the seat process tree`);
+  }
+  // Recheck the whole set before sending anything; never partially apply a broad match.
+  const current = processTable();
+  for (const pid of pids) {
+    if (!descendant(pid, root, current)) refuse(`PID ${pid} left the seat process tree`);
+  }
+  for (const pid of pids) process.kill(pid, selected.signal);
+} catch (error) {
+  console.error(`seat signal guard: refused ${command}: ${error.message}`);
+  process.exitCode = 1;
+}

package/hooks/sessionstart.mjs

@@ -405,6 +405,11 @@ try {
   // A RESUMED session must never claim a handoff: it already carries its history, so the takeover banner
   // would land in the same maxed-out context and look right while the window never reset.
   const isResume = source === "resume";
+  // A print-mode one-shot (`claude -p`) is never the successor either (#11577): SessionStart fires
+  // for it with source "startup" — the hook INPUT is indistinguishable from a human start — but
+  // the CLI marks the hook ENV (CLAUDE_CODE_ENTRYPOINT=sdk-cli; interactive "cli", SDKs sdk-*).
+  // Unguarded, it claimed the waiting handoff and superseded the live orchestrator.
+  const isPrintRun = String(process.env.CLAUDE_CODE_ENTRYPOINT || "cli").startsWith("sdk-");
   const orchEnv = process.env.TRANTOR_ORCH || "";
   const isOrchPane = !!orchEnv && (orchEnv === "1" || orchEnv === project);   // project-matched: a child claude in another dir must not inherit the badge
   const orchSid = readOrchSession(project);
@@ -413,19 +418,24 @@ try {
   const orchOrigin = !!(peek && orchSid && peek.session_id && peek.session_id === orchSid);
   const ageMs = peek ? Date.now() - (Number(peek.stamp) || 0) * 1000 : 0;
   const held = orchOrigin && !isOrchPane && !isCompact && ageMs < holdMs;
-  const handoff = !peek ? null
+  const handoff = !peek || isPrintRun ? null
     : (isCompact || held || isResume) ? peek
     : loadPendingHandoff(basename(projectDir), {
         claim: true,
         freshSession: { session_id: stdinObj.session_id || "", transcript_path: stdinObj.transcript_path || "" },
       });
   const claimed = !!handoff && !isCompact && !held && !isResume;
+  // The handoff banner never rides a one-shot either: it is not the successor and nobody asked it
+  // to recap, so a print start with a pending handoff gets one quiet stderr line and nothing else.
+  if (isPrintRun && peek && !isCompact) {
+    process.stderr.write(`[trantor] pending handoff ${peek.id} NOT claimed — print-mode one-shot (claude -p) is never the successor\n`);
+  }
   // Follow the thread: claiming the orchestrator's baton makes THIS session the orchestrator
   // thread, so the map `trantor open` resumes and the app's chat reads moves with it. The pane
   // also records itself on every fresh start — that keeps the map honest even if a future
   // claude forks the session id on resume.
   if (claimed && orchOrigin && stdinObj.session_id) writeOrchSession(project, String(stdinObj.session_id), "sessionstart-claim");
-  if (isOrchPane && !isCompact && stdinObj.session_id) writeOrchSession(project, String(stdinObj.session_id), "orch-pane-start");
+  if (isOrchPane && !isCompact && !isPrintRun && stdinObj.session_id) writeOrchSession(project, String(stdinObj.session_id), "orch-pane-start");
   if (handoff && held) {
     process.stderr.write(`[trantor] pending handoff ${handoff.id} HELD for the orch pane (${Math.round(ageMs / 60000)}m old)\n`);
     const mins = Math.max(1, Math.round((holdMs - ageMs) / 60000));

package/lib/project.mjs

@@ -1,17 +1,23 @@
 // trantor — canonical project identity (client side): one repo = one lane, keyed by the id recorded
 // in the checkout (.trantor/project.json) or, unmarked, by the git repo root basename; an explicit
 // RELAY_PROJECT always wins and the hub folds aliases on top.
-import { execSync } from "node:child_process";
+import { execSync, execFileSync } from "node:child_process";
 import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, readdirSync, statSync, realpathSync } from "node:fs";
 import { basename, join, dirname, resolve, sep } from "node:path";
 import { homedir, hostname } from "node:os";
 import { asRecord, asString } from "./decode.mjs";
 
 export function gitRoot(dir) {
-  try {
-    return execSync(`git -C ${JSON.stringify(dir)} rev-parse --show-toplevel`,
-      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 2000 }).trim();
-  } catch { return ""; }
+  // A loaded runner can miss the short deadline; retry timeouts, not non-repository errors (#11580).
+  for (const timeout of [2000, 10000]) {
+    try {
+      return execFileSync("git", ["-C", dir, "rev-parse", "--show-toplevel"],
+        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout }).trim();
+    } catch (error) {
+      if (error.code !== "ETIMEDOUT") return "";
+    }
+  }
+  return "";
 }
 
 // A BUS SEAT WORKTREE is named for its project BY CONSTRUCTION — the bus creates

package/lib/seat-signal-guard.mjs

@@ -0,0 +1,30 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const quote = value => `'${String(value).replaceAll("'", "'\\''")}'`;
+
+// Install after env files are sourced so a provider's PATH cannot hide the guard.
+export function seatSignalPrefix(workdir, env = process.env, root = process.pid) {
+  const parent = join(workdir, ".agent-bus-out", "signal-guard");
+  const dir = join(parent, String(root));
+  mkdirSync(dir, { recursive: true });
+  // Runtime shims must not count as seat work or enter a cut snapshot in arbitrary repositories.
+  writeFileSync(join(parent, ".gitignore"), "*\n");
+  const guard = fileURLToPath(new URL("../bin/seat-signal.mjs", import.meta.url));
+  for (const name of ["kill", "pkill", "killall"]) {
+    writeFileSync(join(dir, name), `#!/bin/sh\nexec ${quote(process.execPath)} ${quote(guard)} ${name} "$@"\n`, { mode: 0o755 });
+  }
+  const path = `export PATH=${quote(dir)}:"$PATH"\n`;
+  const bash = join(dir, "bash-env");
+  const previousBash = env.BASH_ENV && env.BASH_ENV !== bash
+    ? `[ ! -f ${quote(env.BASH_ENV)} ] || . ${quote(env.BASH_ENV)}\n` : "";
+  writeFileSync(bash, `${previousBash}${path}enable -n kill\n`);
+  const previousZdot = env.ZDOTDIR || env.HOME;
+  for (const name of [".zshenv", ".zprofile", ".zshrc", ".zlogin"]) {
+    const original = previousZdot && previousZdot !== dir ? join(previousZdot, name) : "";
+    const source = original ? `[ ! -f ${quote(original)} ] || . ${quote(original)}\n` : "";
+    writeFileSync(join(dir, name), `${source}${path}disable kill\n`);
+  }
+  return `export TRANTOR_SIGNAL_ROOT=${quote(root)} BASH_ENV=${quote(bash)} ZDOTDIR=${quote(dir)}\n${path}enable -n kill\n`;
+}

package/mcp.mjs

@@ -4,12 +4,10 @@
 // via the agent's MCP config. Identity + hub URL come from env (RELAY_SESSION, RELAY_URL).
 // Loading this server AUTO-REGISTERS the session — so presence works on every agent.
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
-import { join, basename, dirname } from "node:path";
+import { join, basename } from "node:path";
 import { homedir, hostname } from "node:os";
 import { execSync, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { createRequire } from "node:module";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { advise, loadWorld } from "./bin/advise.mjs";
 import { loadSeatRecord } from "./lib/seat-record.mjs";
 import { resolveProject, hostId, resolveHubInfo, nonSeatReason, handoffDir, orchWriterSid } from "./lib/project.mjs";
@@ -20,43 +18,7 @@ import { assertNoSecrets } from "./lib/scrub.mjs";
 import { isMessageCardTitle, OPEN_CARD_STATUSES } from "./lib/turn-policy.mjs";
 import { markDoing, hollowVerdict, blastRadius, blastLine } from "./hooks/lib/hollow-move.mjs";
 
-// Runtime dep resolution: `claude plugin install` snapshots the repo, not an npm tarball, so a
-// GitHub-sourced plugin ships no node_modules and a static SDK import dies with
-// ERR_MODULE_NOT_FOUND before any line runs — silently: every relay tool just disappears.
-// Resolve ourselves: plain import(spec) first; on NOT_FOUND borrow the global trantor's tree.
-const HERE = dirname(fileURLToPath(import.meta.url));
-const req = createRequire(import.meta.url);
-
-let fallbackRoots = null;
-function borrowRoots() {
-  if (fallbackRoots) return fallbackRoots;
-  const roots = [];
-  const add = (p) => { if (p && !roots.includes(p)) roots.push(p); };
-  // Cheap guesses first — every one of these is a string join, no process spawn.
-  if (process.env.npm_config_prefix) add(join(process.env.npm_config_prefix, "lib", "node_modules"));
-  add(join(dirname(process.execPath), "..", "lib", "node_modules"));   // homebrew, nvm, volta, asdf
-  // Only shell out if the guesses missed — `npm root -g` costs ~0.5s of MCP startup.
-  if (!roots.some((r) => existsSync(join(r, "trantor")))) {
-    try { add(execSync("npm root -g", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim()); } catch {}
-  }
-  fallbackRoots = roots.flatMap((r) => [join(r, "trantor"), r]);
-  return fallbackRoots;
-}
-
-async function dep(spec) {
-  try {
-    return await import(spec);
-  } catch (err) {
-    if (err?.code !== "ERR_MODULE_NOT_FOUND" && err?.code !== "ERR_PACKAGE_PATH_NOT_EXPORTED") throw err;
-  }
-  for (const path of [HERE, ...borrowRoots()]) {
-    try { return await import(pathToFileURL(req.resolve(spec, { paths: [path] })).href); } catch {}
-  }
-  throw new Error(
-    `[trantor-mcp] cannot resolve '${spec}'. This plugin snapshot has no node_modules and no global ` +
-    `trantor install was found to borrow from. Fix: npm i -g trantor  (or: cd ${HERE} && npm install --omit=dev)`,
-  );
-}
+import { dep } from "./lib/dep.mjs";
 
 const { McpServer } = await dep("@modelcontextprotocol/sdk/server/mcp.js");
 const { StdioServerTransport } = await dep("@modelcontextprotocol/sdk/server/stdio.js");

package/package.json

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