trantor 0.18.96 → 0.18.97

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.96",
+  "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/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/package.json

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