trantor 0.18.32 → 0.18.33

package/.claude-plugin/plugin.json

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

@@ -1,16 +1,42 @@
 #!/usr/bin/env node
-// `trantor handoff` — one-command manual baton (auto-summary variant). Discovers the current session's
-// transcript, writes a whole-session handoff (auto-summary + verbatim in-flight tail), opens a fresh
-// self-announcing session, and closes THIS window once it takes over. Run from inside the session you
-// want to hand off. (The richer MODEL-authored handoff is the /trantor:handoff skill.)
-import { readdirSync, statSync } from "node:fs";
-import { join, basename } from "node:path";
+// `trantor handoff` — one-command manual baton. Discovers the current session's transcript, writes
+// a whole-session handoff (auto-summary + verbatim in-flight tail), opens a fresh self-announcing
+// session, and closes THIS window once it takes over. Run from inside the session you want to hand
+// off. (The richer MODEL-authored handoff is the /trantor:handoff skill.)
+import { readdirSync, statSync, fstatSync } from "node:fs";
+import { join, basename, dirname } from "node:path";
 import { homedir } from "node:os";
-import { resolveProject } from "../lib/project.mjs";
-import { writeHandoff, spawnBaton } from "../hooks/lib/handoff.mjs";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { writeHandoff, spawnBaton, resolveHandoffSurface } 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
+// from the session's registration (TRANTOR_ORCH / RELAY_PROJECT / orch-sessions.txt) before the
+// cwd — a subfolder cwd never renames the project.
 const cwd = process.cwd();
-const project = resolveProject(cwd);
+const resolved = resolveHandoffSurface({ projectDir: process.env.CLAUDE_PROJECT_DIR || cwd, sessionId: process.env.CLAUDE_SESSION_ID || "" });
+const project = resolved.project;
+
+// Model-authored handoffs ride THIS binary too (`trantor handoff` — always the global install's
+// CURRENT code, never the plugin-cache copy a session booted with, the stale-0.18.20 bug). A piped
+// stdin (a heredoc, a cat, `<<HANDOFF`) means "here is the handoff markdown" — exactly the skill's
+// contract — so forward to write-handoff.mjs in the SAME package (same version, same resolution)
+// and exit with its status. --latest forwards too. A true pipe is a FIFO; a TTY and /dev/null are
+// character devices, so a plain `trantor handoff` typed at a prompt (or run by a hook with stdin
+// at /dev/null) keeps the auto-summary behavior. Detection must NOT be `!process.stdin.isTTY` —
+// that misreads /dev/null as a handoff and errors where auto-summary used to work.
+function stdinIsPipe() {
+  try { return fstatSync(0).isFIFO(); } catch { return false; }
+}
+if (stdinIsPipe() || process.argv.includes("--latest")) {
+  const helper = join(dirname(fileURLToPath(import.meta.url)), "write-handoff.mjs");
+  const child = spawn(process.execPath, [helper, ...process.argv.slice(2)], { stdio: ["inherit", "inherit", "inherit"] });
+  child.on("exit", (c) => process.exit(c ?? 1));
+  child.on("error", () => process.exit(1));
+} else {
+  autoBaton();
+}
 
 // The active session's transcript = newest *.jsonl directly in this project's Claude dir
 // (~/.claude/projects/<cwd-with-slashes-as-dashes>/), excluding the subagents/ subtree.
@@ -29,20 +55,22 @@ function findTranscript() {
   return best;
 }
 
-const transcript = findTranscript();
-// The transcript's filename IS the writing session's id — record it, or an orchestrator-thread
-// handoff carries no writer and the baton-hold + map-follow logic in sessionstart.mjs can't fire.
-const sessionId = transcript ? basename(transcript, ".jsonl") : "";
-const { file } = writeHandoff({ projectDir: cwd, sessionId, transcript, trigger: "manual-cli", force: true });   // manual = intentional, bypass the storm guard
-console.log(`📋 handoff saved for ${project}: ${file}`);
-// --write-only: the in-app flow (#5509). The app ends the pane's session itself and reopens it
-// through `trantor open`, which claims this handoff — a Terminal window here would be exactly the
-// wrong surface, so the flag writes, announces, and stops.
-if (process.argv.includes("--write-only")) {
-  console.log(`🔄 write-only: no window spawned — the pane takeover (trantor open) claims it next.`);
-  process.exit(0);
+function autoBaton() {
+  const transcript = findTranscript();
+  // The transcript's filename IS the writing session's id — record it, or an orchestrator-thread
+  // handoff carries no writer and the baton-hold + map-follow logic in sessionstart.mjs can't fire.
+  const sessionId = transcript ? basename(transcript, ".jsonl") : "";
+  const { file } = writeHandoff({ projectDir: cwd, sessionId, transcript, trigger: "manual-cli", force: true, projectName: project });   // manual = intentional, bypass the storm guard
+  console.log(`📋 handoff saved for ${project}: ${file}`);
+  // --write-only: the in-app flow (#5509). The app ends the pane's session itself and reopens it
+  // through `trantor open`, which claims this handoff — a Terminal window here would be exactly the
+  // wrong surface, so the flag writes, announces, and stops.
+  if (process.argv.includes("--write-only")) {
+    console.log(`🔄 write-only: no window spawned — the pane takeover (trantor open) claims it next.`);
+    process.exit(0);
+  }
+  const { spawned, armed, windowId } = spawnBaton({ projectDir: cwd, handoffFile: file });
+  console.log(spawned
+    ? `🔄 baton: a fresh session is opening (it'll recap the handoff)${armed ? ` — this window (${windowId}) closes once it takes over` : " — couldn't detect this window; close it yourself once the new one is up"}`
+    : `handoff saved, but couldn't spawn a fresh session (non-macOS or spawn disabled) — open a new session here to take over`);
 }
-const { spawned, armed, windowId } = spawnBaton({ projectDir: cwd, handoffFile: file });
-console.log(spawned
-  ? `🔄 baton: a fresh session is opening (it'll recap the handoff)${armed ? ` — this window (${windowId}) closes once it takes over` : " — couldn't detect this window; close it yourself once the new one is up"}`
-  : `handoff saved, but couldn't spawn a fresh session (non-macOS or spawn disabled) — open a new session here to take over`);

package/bin/connect.mjs

@@ -40,6 +40,10 @@ function patchJson(path, mutate) {
 // while its runner sat on the pinned one — the residual split-brain mechanism (2026-08-20).
 // mcp.mjs resolves the hub from the session's project pin; that resolution must stay in charge.
 const relayEnv = (agent) => ({ RELAY_AGENT: agent });
+// OpenCode hosts several differently-named seats. Its global MCP environment must not stamp all
+// of them "opencode": ambient runner identity wins, while this fallback names a normal interactive
+// OpenCode session that has no RELAY_AGENT/RELAY_SESSION of its own.
+const hostedRelayEnv = (agent) => ({ RELAY_AGENT_FALLBACK: agent });
 
 // ---- Claude Code: plugin handles it; verify only ----
 if (has("claude")) {
@@ -87,7 +91,13 @@ if (has("opencode")) {
   report("opencode", patchJson(p, d => {
     d.$schema ||= "https://opencode.ai/config.json";
     d.mcp ||= {};
-    d.mcp.relay ||= { type: "local", command: ["node", MCP], enabled: true, environment: relayEnv("opencode") };
+    d.mcp.relay ||= { type: "local", command: ["node", 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.
+    delete d.mcp.relay.environment.RELAY_AGENT;
+    delete d.mcp.relay.environment.RELAY_SESSION;
+    Object.assign(d.mcp.relay.environment, hostedRelayEnv("opencode"));
   }), p);
 }
 

package/bin/crew-runner.mjs

@@ -358,7 +358,7 @@ async function reportFailure(exit, trigger, undelivered = 0) {
   const reason = classify(exit);
   const down = consecFails >= 2;
   const status = down ? `down: ${reason} · ${consecFails} fails` : `errored: ${reason}`;
-  await api("/register", { session: SESSION, project: PROJ, status, llm: AGENT, model: MODEL }).catch(() => {});
+  await api("/register", { session: SESSION, project: PROJ, status, llm: AGENT, model: MODEL, kind: "agent" }).catch(() => {});
   const hint = reason === "exhausted" ? " — needs `trantor swap`"
     : reason === "auth" ? " — check credentials"
     : reason === "backend-error" ? " — provider backend error (NOT quota): retry, or `trantor swap` to another provider"
@@ -446,7 +446,7 @@ async function reportHealthy() {
   consecFails = 0;
   // Recovery is a change too, so the next failure is news again.
   announced = "";
-  await api("/register", { session: SESSION, project: PROJ, status: `active in ${PROJ}`, llm: AGENT, model: MODEL }).catch(() => {});
+  await api("/register", { session: SESSION, project: PROJ, status: `active in ${PROJ}`, llm: AGENT, model: MODEL, kind: "agent" }).catch(() => {});
   await api("/send", { from: SESSION, to: "all", text: `✅ ${SESSION} recovered`, project: PROJ, kind: "status" }).catch(() => {});
   cmuxStatus("ok", "#14b8a6", "check"); herdrAgent("idle");
 }
@@ -512,7 +512,7 @@ async function runTurn(prompt, isFirst, trigger = "kickoff") {
   } catch {}
   const r = spawnSync("/bin/bash", ["-c", `set -o pipefail; { ${inner} ; } 2> >(${SCRUB} --tee2 ${ERRF})`], {
     cwd: TURN_DIR, encoding: "utf8", stdio: cli.sid ? ["ignore", "pipe", "inherit"] : "inherit",
-    env: { ...process.env, RELAY_URL: HUB, RELAY_AGENT: AGENT, RELAY_PROJECT: PROJ,
+    env: { ...process.env, RELAY_URL: HUB, RELAY_AGENT: AGENT, RELAY_SESSION: SESSION, RELAY_PROJECT: PROJ,
       // A RUNNER-MANAGED SEAT MUST NEVER HAND ITSELF A BATON.
       //
       // The handoff machinery exists for an INTERACTIVE session: near its context limit it writes a
@@ -673,7 +673,11 @@ function askedExcerpt(message) {
   // start cursor at the CURRENT tip so we don't replay history
   let cursor = 0;
   try { const r = await api(`/inbox?session=${encodeURIComponent(SESSION)}&since=0`); cursor = r.cursor || 0; } catch {}
-  await api("/register", { session: SESSION, project: PROJ, status: "crew member booting", llm: AGENT, model: MODEL }).catch(() => {});
+  // kind "agent" on every beat (#6075): the peer row's kind is the hub's OWN record of what a
+  // session is — the overseer's declared-crew exemption reads it, and on the remote hub there is
+  // no crew-windows.txt to fall back to. /register preserves absent fields, so a seat running an
+  // older runner never loses a kind an updated one stamped.
+  await api("/register", { session: SESSION, project: PROJ, status: "crew member booting", llm: AGENT, model: MODEL, kind: "agent" }).catch(() => {});
   // Announce runner-side, signed as THIS seat. Asking the seat to announce itself sent glm's hello
   // out under deepseek's identity whenever opencode seats shared one MCP daemon (lesson on the bus,
   // 2026-07-29): the runner process is per-seat by construction, so its signature cannot be borrowed.
@@ -726,7 +730,12 @@ function askedExcerpt(message) {
     let msgs = [];
     try {
       const r = await api(`/poll?session=${encodeURIComponent(SESSION)}&since=${cursor}&wait=${holdS}`);
-      msgs = r.messages || []; cursor = r.cursor ?? cursor;
+      msgs = r.messages || [];
+      if (r.cursor !== undefined && r.cursor !== null && Number.isFinite(Number(r.cursor))) {
+        const reportedCursor = Number(r.cursor);
+        if (reportedCursor < cursor) log(`cursor rewound by hub ${cursor} -> ${reportedCursor}`);
+        cursor = reportedCursor;
+      }
     } catch (e) {
       // Deadline-abort on the LONG-POLL is not an outage — it means the hold expired with no hub
       // response (stalled event loop, napped machine, dead socket). Reconnect immediately and say

package/bin/new.mjs

@@ -129,9 +129,14 @@ try {
   // way crew seats do: the operator's owner key mints a project-scoped write invite and the genesis
   // identity spends it. Only when NO owner key is configured (a loopback hub with no owner identity)
   // do we fall back to the plain TOFU enroll.
-  const viaOwner = await enrollViaOwnerInvite(hub, identity, name, { timeoutMs: 8000 });
-  if (!viaOwner.ok && viaOwner.reason === "no-owner-key") await enrollTofu(session, identity, name);
+  const viaOwner = await enrollViaOwnerInvite(hub, identity, name, { timeoutMs: 8000, kind: "tool" });
+  if (!viaOwner.ok && viaOwner.reason === "no-owner-key") await enrollTofu(session, identity, name, { kind: "tool" });
   else if (!viaOwner.ok) console.error(`genesis: enrollment via owner invite failed: ${viaOwner.reason}`);
+  // #6068: say WHAT this session is. The genesis identity exists to post the brief — without a
+  // kind on its peer row the app's seat strip renders it as a seat ("no terminal pane — start it
+  // with trantor up genesis"). /register is presence, not speech: no message rides it, nobody
+  // wakes. The hub stamps kind on the session row and /peers returns it to the app.
+  await signedPost("/register", { session, kind: "tool" }, { session, project: name, timeoutMs: 8000 }).catch(() => {});
   const briefForHub = (brief || `Genesis of ${name} — created by trantor new.`).slice(0, 600);
   const r1 = await signedPost("/project", { project: name, brief: briefForHub, by: session }, { session, project: name, timeoutMs: 8000 });
   if (!r1.ok) throw new Error(`hub ${r1.status} on /project${r1.json?.error ? `: ${r1.json.error}` : ""}`);

package/bin/write-handoff.mjs

@@ -6,7 +6,7 @@ import { writeFileSync, readFileSync, existsSync, mkdirSync, readdirSync } from
 import { join, basename } from "node:path";
 import { homedir, hostname } from "node:os";
 import { execSync } from "node:child_process";
-import { spawnBaton, handoffMode } from "../hooks/lib/handoff.mjs";
+import { spawnBaton, handoffMode, resolveHandoffSurface } from "../hooks/lib/handoff.mjs";
 import { handoffDir } from "../lib/project.mjs";
 
 const baton = process.argv.includes("--baton");
@@ -14,8 +14,14 @@ const baton = process.argv.includes("--baton");
 // fresh one on stdin", so a session that had just written a 5KB handoff had to write it again to
 // hand it over — 2m28s of regenerated prose on a live scribe session, 2026-08-24.
 const latest = process.argv.includes("--latest");
-const project = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-const name = basename(project);
+// #6074: ONE resolver for which project this is and where the session lives — shared with
+// bin/baton.mjs (the `trantor handoff` CLI path) so the two cannot diverge. The name comes from
+// the session's registration (TRANTOR_ORCH / RELAY_PROJECT / orch-sessions.txt) before the cwd;
+// the witnessed crebral-scribe/ios handoff recorded project "ios" from a subfolder cwd and never
+// found its pane.
+const resolved = resolveHandoffSurface({ sessionId: process.env.CLAUDE_SESSION_ID || "" });
+const project = resolved.projectDir;
+const name = resolved.project;
 let summary = "";
 if (!latest) {
   process.stdin.setEncoding("utf8");

package/deploy/restart-hub.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+# Guarded production restart: an unhealthy durable writer means RAM contains the only current copy.
+set -euo pipefail
+
+FORCE=0
+if [ "${1:-}" = "--force" ]; then
+  FORCE=1
+  shift
+fi
+if [ "$#" -ne 0 ]; then
+  echo "usage: deploy/restart-hub.sh [--force]" >&2
+  exit 2
+fi
+
+# The hub binds RELAY_HOST (the tailnet IP on netcup, where 127.0.0.1 refuses), so the guard reads the
+# same env the service does; RELAY_HUB_URL still overrides.
+ENV_FILE="${RELAY_ENV_FILE:-$(dirname "$0")/hub.env}"
+if [ -f "$ENV_FILE" ]; then
+  # shellcheck disable=SC1090
+  set -a; . "$ENV_FILE"; set +a
+fi
+HUB_URL="${RELAY_HUB_URL:-http://${RELAY_HOST:-127.0.0.1}:${RELAY_PORT:-4477}}"
+HEALTH=""
+if HEALTH="$(curl --fail --silent --show-error --max-time 5 "$HUB_URL/health")"; then
+  REFUSAL="$(node --input-type=module -e '
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    let health;
+    try { health = JSON.parse(Buffer.concat(chunks).toString("utf8")); }
+    catch { process.stdout.write("hub health response was not valid JSON"); process.exit(0); }
+    const p = health.persist;
+    if (!p || p.ok !== false) process.exit(0);
+    const age = Number(p.failingSinceMs || 0);
+    const span = age >= 60000 ? `${Math.floor(age / 60000)}m ${Math.floor((age % 60000) / 1000)}s` : `${Math.floor(age / 1000)}s`;
+    process.stdout.write(`hub persistence has failed for ${span} (${Number(p.retries || 0)} retries): ${String(p.lastError || "unknown error")}. Restarting risks losing every state change since persistence stopped.`);
+  ' <<<"$HEALTH")"
+  if [ -n "$REFUSAL" ] && [ "$FORCE" -ne 1 ]; then
+    echo "REFUSED: $REFUSAL" >&2
+    echo "Resolve persistence first, or rerun with --force to accept the data-loss risk." >&2
+    exit 1
+  fi
+  if [ -n "$REFUSAL" ]; then
+    echo "WARNING: --force accepted: $REFUSAL" >&2
+  fi
+else
+  echo "WARNING: $HUB_URL/health was unreachable; proceeding because no running hub state can be inspected." >&2
+fi
+
+systemctl restart trantor-hub
+echo "restarted trantor-hub"

package/deploy/setup-netcup.sh

@@ -72,10 +72,15 @@ echo "  schema applied"
 # systemd unit
 cp deploy/trantor-hub.service /etc/systemd/system/trantor-hub.service
 systemctl daemon-reload
-systemctl enable --now trantor-hub
+systemctl enable trantor-hub
+if systemctl is-active --quiet trantor-hub; then
+  bash deploy/restart-hub.sh
+else
+  systemctl start trantor-hub
+fi
 
 # crons: daily backup + nightly retention
-chmod +x deploy/backup.sh deploy/retention.sh deploy/restore.sh
+chmod +x deploy/backup.sh deploy/retention.sh deploy/restore.sh deploy/restart-hub.sh
 echo "0 2 * * * root /opt/trantor/deploy/backup.sh" > /etc/cron.d/trantor
 echo "0 3 * * * root /opt/trantor/deploy/retention.sh" >> /etc/cron.d/trantor
 

package/hooks/lib/api.mjs

@@ -112,7 +112,7 @@ function enrolledPath(session) {
   const busDir = process.env.AGENT_BUS_DIR || join(homedir(), ".agent-bus");
   return join(busDir, "keys", `${String(session).replace(/[^A-Za-z0-9_.-]/g, "_")}.enrolled`);
 }
-export async function ensureEnrolled(session, identity, project) {
+export async function ensureEnrolled(session, identity, project, { kind = "agent" } = {}) {
   if (!identity?.pubkey) return;
   const hub = relayUrl(project);
   const stamp = enrolledPath(session);
@@ -126,7 +126,7 @@ export async function ensureEnrolled(session, identity, project) {
     // payload, sets content-type, and signs — so every hook signs identically with zero hand-rolling.
     const r = await sfetchJson(`${hub}/enroll`, {
       method: "POST",
-      payload: { pubkey: identity.pubkey, name: session, kind: "agent" },
+      payload: { pubkey: identity.pubkey, name: session, kind },
       identity,
       signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
     });

package/hooks/lib/handoff.mjs

@@ -18,6 +18,7 @@ import { fileURLToPath } from "node:url";
 import { deriveSubagentManifest } from "../../lib/subagent-manifest.mjs";
 import { signedPost } from "./api.mjs";
 import { loadAutonomy, resolveAutonomy } from "../../lib/autonomy.mjs";
+import { resolveProject, orchSessionsPath } from "../../lib/project.mjs";
 
 // Writer and reader MUST resolve the same directory — see lib/project.mjs busDir(). This used to
 // honour only RELAY_DATA_DIR while the reader honoured neither override.
@@ -389,8 +390,10 @@ export function appendHandoffState(id, state, by = "") {
   } catch { return false; }
 }
 
-export function writeHandoff({ projectDir, sessionId, transcript, trigger, summary, force = false }) {
-  const projectName = basename(projectDir);
+export function writeHandoff({ projectDir, sessionId, transcript, trigger, summary, force = false, projectName: projectNameArg }) {
+  // #6074: the NAME may come from the session's registration (resolveHandoffSurface), not from
+  // this directory's basename — a subfolder cwd must not rename the project on the record.
+  const projectName = projectNameArg || basename(projectDir);
   // Server-side storm guard: a session running OLD hooks (before the local markHandedOff guard) re-fires
   // context-warn handoffs every few minutes — the crebral-cortex storm (9 in 49 min, each spawning a
   // window). Ask the hub for clearance (rate-limit per project+session); a non-forced handoff inside the
@@ -541,6 +544,12 @@ export function maybeSpawn(projectDir, conf = readConfig()) {
   try {
     if (process.platform !== "darwin") return false;
     if (process.env.TRANTOR_NO_HANDOFF_SPAWN === "1") return false;
+    // #6074: a session in a hosted pane never gets a Terminal window — the pane is the successor
+    // surface, and the pane claims the handoff (trantor open) on its own.
+    if (paneSurfaceEnv()) {
+      process.stderr.write(`[trantor] session lives in herdr pane ${paneSurfaceEnv()} — no Terminal window; the pane claims the handoff\n`);
+      return false;
+    }
     if (conf.autoHandoffPrompt === false) return false;
     if (hasOrchPane(basename(projectDir))) {
       process.stderr.write(`[trantor] orch pane hosts ${basename(projectDir)} — no Terminal window; the pane claims the handoff on its next open\n`);
@@ -585,9 +594,52 @@ export function hasOrchPane(projectName) {
   } catch { return false; }
 }
 
+// ---- #6074: WHERE the session lives, and WHICH project it is ----------------
+// Witnessed 2026-09-02 (crebral-scribe/ios): a pane session ran the handoff skill with its shell
+// cwd in a subfolder. The project name came from basename(cwd) = "ios", the pane lookup found no
+// "ios" row, and the baton fell to the window leg — whose front-Terminal-window fallback picked a
+// window the pane session never owned, spawned a stray Terminal session, and armed a close on a
+// stranger's window. Two facts the code ignored: a session's OWN env knows where it lives
+// (HERDR_PANE_ID — herdr sets it in every pane), and the project's REGISTRATION knows its name
+// (the `trantor open` badge, RELAY_PROJECT, the orch-sessions map) long before cwd is worth
+// consulting. One resolver, shared by write-handoff.mjs --baton AND bin/baton.mjs, so the skill
+// path and the CLI path cannot diverge.
+export function paneSurfaceEnv(env = process.env) {
+  return String(env.HERDR_PANE_ID || "").trim();
+}
+
+// Reverse orch-sessions.txt lookup: which project recorded THIS session id as its orchestrator
+// thread. One row per project, "<project>\t<sid>" — written by `trantor open` / adopt / claim.
+export function orchProjectForSession(sid) {
+  try {
+    if (!sid) return "";
+    for (const line of readFileSync(orchSessionsPath(), "utf8").split("\n")) {
+      const [p, s] = line.split("\t");
+      if (p && s && s.trim() === String(sid).trim()) return p.trim();
+    }
+  } catch {}
+  return "";
+}
+
+// The one resolver. Returns { project, projectDir, pane, surface }:
+//   pane    — the session's own pane id ("" when it is not a hosted pane)
+//   surface — "pane" (the baton MUST take the pane leg) or "window" (today's behavior)
+//   project — the REGISTERED project name; a subfolder cwd never renames it
+export function resolveHandoffSurface({ projectDir, sessionId, env = process.env } = {}) {
+  const dir = projectDir || env.CLAUDE_PROJECT_DIR || process.cwd();
+  const badge = String(env.TRANTOR_ORCH || "").trim();
+  let project = "";
+  if (badge && badge !== "1") project = badge;                       // `trantor open` badge carries the name
+  if (!project && env.RELAY_PROJECT) project = String(env.RELAY_PROJECT).trim();
+  if (!project) project = orchProjectForSession(sessionId);
+  if (!project) project = resolveProject(dir);                       // last resort: cwd (git-root aware)
+  return { project, projectDir: dir, pane: paneSurfaceEnv(env), surface: paneSurfaceEnv(env) ? "pane" : "window" };
+}
+
 export function spawnFresh(projectDir) {
   try {
     if (process.platform !== "darwin" || spawnSuppressed()) return false;
+    if (paneSurfaceEnv()) return false;                    // #6074: pane sessions never open windows
     if (hasOrchPane(basename(projectDir))) return false;   // the pane is the successor surface (#5509)
     const script = join(HERE, "..", "..", "bin", "open-session.sh");
     if (!existsSync(script)) return false;
@@ -624,11 +676,15 @@ export function resolveOriginalWindow() {
 // window machinery (resolve/arm-close) is deliberately absent here: there is no window to close,
 // and the old path's answer ("spawn disabled — open manually") left the operator doing the
 // machine's job by hand.
-export function spawnPaneBaton(projectDir, handoffFile) {
+export function spawnPaneBaton(projectDir, handoffFile, paneId = "") {
   try {
     const script = join(HERE, "..", "..", "bin", "baton-pane.mjs");
     if (!existsSync(script)) return false;
-    const child = spawn(process.execPath, [script, "--project", projectDir, "--handoff", handoffFile], { detached: true, stdio: "ignore" });
+    // #6074: when the dying session KNOWS its pane (HERDR_PANE_ID), pass it — the driver must
+    // replace THAT pane, not guess one from a crew-windows row keyed by a cwd-derived name.
+    const args = [script, "--project", projectDir, "--handoff", handoffFile];
+    if (paneId) args.push("--pane", paneId);
+    const child = spawn(process.execPath, args, { detached: true, stdio: "ignore" });
     child.unref();
     return true;
   } catch { return false; }
@@ -643,15 +699,30 @@ export function spawnPaneBaton(projectDir, handoffFile) {
 // regression-tested headlessly.
 export function spawnBaton({ projectDir, handoffFile, conf = readConfig(),
   _resolveWindow = resolveOriginalWindow, _spawnFresh = spawnFresh, _armClose = armBatonClose,
-  _hasPane = hasOrchPane, _spawnPane = spawnPaneBaton }) {
+  _hasPane = hasOrchPane, _spawnPane = spawnPaneBaton, _env = process.env }) {
   // A DRILL MUST BE ABLE TO SAY NO. There was no such switch, so exercising the baton path in a
   // test opened real Terminal windows running real `claude` sessions in temp directories the test
   // then deleted, each parked on a "do you trust this folder?" prompt. Five of them were found by
   // the operator on 2026-08-24. A code path that spawns windows needs an off switch, or it cannot
-  // be tested honestly and someone will fake one that does not exist.
-  if (spawnSuppressed() || conf.batonSpawn === false) {
+  // be tested honestly and someone will fake one that does not exist. The check reads the REAL env
+  // (spawnSuppressed) AND the injected one (_env) — a crew runner exports TRANTOR_NO_*_SPAWN for
+  // its seats, and a drill that inherits that must still be able to exercise each branch by
+  // passing its own env, not by mutating the runner's.
+  const suppressed = spawnSuppressed()
+    || String(_env.TRANTOR_NO_HANDOFF_SPAWN || "") === "1" || String(_env.TRANTOR_NO_BATON_SPAWN || "") === "1";
+  if (suppressed || conf.batonSpawn === false) {
     return { spawned: false, armed: false, windowId: "", suppressed: true };
   }
+  // #6074, checked FIRST: the session's OWN env is the truth about where it lives. HERDR_PANE_ID
+  // set means the pane leg, keyed by THAT pane id — regardless of cwd or project name — and the
+  // whole window machinery (resolve + spawn + arm-close) is forbidden here: a pane session has no
+  // Terminal window, so the front-window fallback can only ever pick a stranger's (the witnessed
+  // crebral-scribe/ios incident armed a close on a window this session never owned).
+  const paneId = paneSurfaceEnv(_env);
+  if (paneId) {
+    const spawned = _spawnPane(projectDir, handoffFile, paneId);
+    return { spawned, armed: false, windowId: "", pane: true, paneId };
+  }
   // Hosted pane (#5643): the pane IS the successor surface — no window is resolved, spawned, or
   // armed for closing. The detached driver replaces the session at the turn boundary.
   if (_hasPane(basename(projectDir))) {

package/hooks/sessionstart.mjs

@@ -221,8 +221,15 @@ try {
   // instead of silently routing to the default.
   const { url, via: hubVia } = resolveHubInfo(project);
 
-  // register self + post an initial presence status (no LLM turn — instant for others to read)
-  await jpost(`${url}/register`, { session, project, status: `active in ${project}` }, session).catch(() => {});
+  // register self + post an initial presence status (no LLM turn — instant for others to read).
+  // kind "orch" when `trantor open` badged THIS session as the project's orchestrator pane
+  // (#6075): the peer row's kind is the hub's own record of what a session is — the overseer's
+  // declared-crew exemption reads it, and on the remote hub there is no local crew-windows.txt.
+  // Strict match (badge === project), same rule the doctrine gate below uses; a badge of "1"
+  // carries no name, so it stamps nothing. Absent kind is preserved by /register, so the MCP's
+  // kindless heartbeats never erase this.
+  const orchBadge = process.env.TRANTOR_ORCH || "";
+  await jpost(`${url}/register`, { session, project, status: `active in ${project}`, ...(orchBadge === project ? { kind: "orch" } : {}) }, session).catch(() => {});
 
   // fetch roster of OTHER online sessions
   let peers = [], hubAnswered = false;

package/hooks/stop-inbox.mjs

@@ -21,12 +21,12 @@
 //   * Only claim delivery once we have actually decided to surface it (peek first). Marking a message
 //     delivered and then letting the stop through would hide it from the waker too — a silent hole.
 //   * Any error, or a hub that is down -> allow the stop. Never trap a session because of us.
-import { readFileSync, writeFileSync, existsSync, unlinkSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, unlinkSync, mkdirSync, renameSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
-import { resolveProject, hostId, handoffDir } from "../lib/project.mjs";
+import { resolveProject, hostId, handoffDir, busDir } from "../lib/project.mjs";
 import { signedGet } from "./lib/api.mjs";   // signed: enforce hubs 401 unsigned reads — unsigned, T2 delivery is silently dead
 import { ledgerPaths, ensureStart, anchorCursor, writeCursor } from "./lib/inbox-ledger.mjs";
 import { readArm, clearArm, markHandedOff, appendHandoffState } from "./lib/handoff.mjs";
@@ -71,6 +71,32 @@ const OVERDUE_MS = (() => {
   return Number.isFinite(n) && n >= 0 ? n : 10 * 60 * 1000;
 })();
 
+function stalledSeenPath(session) {
+  const safe = String(session).replace(/[^A-Za-z0-9_.-]/g, "_");
+  return join(busDir(), `stop-stalled-seen-${safe}.json`);
+}
+
+function readStalledSeen(session) {
+  try {
+    const ids = JSON.parse(readFileSync(stalledSeenPath(session), "utf8"));
+    return new Set(Array.isArray(ids) ? ids.map(String) : []);
+  } catch { return new Set(); }
+}
+
+function writeStalledSeen(session, seen) {
+  const path = stalledSeenPath(session);
+  const tmp = `${path}.${process.pid}.tmp`;
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(tmp, JSON.stringify([...seen]) + "\n");
+    renameSync(tmp, path);
+    return true;
+  } catch {
+    try { unlinkSync(tmp); } catch {}
+    return false;
+  }
+}
+
 async function stalledContractCheck({ session, project, instanceId }) {
   if (process.env.RELAY_STOP_CONTRACTS === "0") return allow();
   let contracts = [];
@@ -89,8 +115,19 @@ async function stalledContractCheck({ session, project, instanceId }) {
   const abandoned = contracts.filter(c => c.disposition === "abandoned");
   if (!stalled.length) return allow();
 
+  const seen = readStalledSeen(session);
+  const fresh = stalled.filter(c => !seen.has(String(c.id)));
+  if (!fresh.length) {
+    process.stderr.write(`[trantor] ${stalled.length} stalled contract(s) already surfaced for ${sanitize(session)}; allowing stop\n`);
+    return allow();
+  }
+  for (const contract of stalled) seen.add(String(contract.id));
+  // Persist before blocking: if the harness stops this process immediately after reading stdout,
+  // the next Stop must still know this exact stalled episode was already surfaced.
+  if (!writeStalledSeen(session, seen)) return allow();
+
   const mins = (ms) => (ms >= 60000 ? `${Math.round(ms / 60000)}m` : `${Math.round(ms / 1000)}s`);
-  const lines = stalled.slice(0, 6).map(c => {
+  const lines = fresh.slice(0, 6).map(c => {
     const health = c.assigneeOnline ? `online, status "${sanitize(c.assigneeStatus || "?")}"`
       : c.assigneeLastSeenMs == null ? "never seen on the bus"
       : `LAST SEEN ${mins(c.assigneeLastSeenMs)} ago`;
@@ -104,7 +141,7 @@ async function stalledContractCheck({ session, project, instanceId }) {
     : "";
 
   const reason =
-    `You dispatched ${stalled.length} contract(s) that have gone quiet, and you were about to go idle:\n` +
+    `You dispatched ${fresh.length} NEW contract(s) that have gone quiet, and you were about to go idle:\n` +
     lines + ghosts + `\n\n` +
     `Do not just wait, and do not ask the human to check. Use relay_contracts to see everything you are owed, ` +
     `relay_peers to see whether the seat is alive, and relay_send to ask it directly. If a seat is down, say so and ` +

package/hub.mjs

@@ -6,12 +6,13 @@
 // private network, or add auth first. See "Always-on / remote hub" in the README (roadmap).
 import http from "node:http";
 import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync, readdirSync } from "node:fs";
-import { homedir } from "node:os";
+import { homedir, hostname } from "node:os";
 import { join } from "node:path";
 import { timingSafeEqual, randomBytes } from "node:crypto";
 import { verifyRequest, verifyEndorsement, publicView } from "./lib/identity.mjs";
 import { DEFAULT_ORG } from "./lib/store-contract.mjs";
 import { assertNoSecrets } from "./lib/scrub.mjs";
+import { createPersistHealth } from "./lib/persist-health.mjs";
 
 const PORT = Number(process.env.RELAY_PORT || 4477);
 const HOST = process.env.RELAY_HOST || "127.0.0.1";
@@ -125,6 +126,7 @@ function emptyState() {
 const CARD_LOG_MAX = 40;
 const CARD_LOG_TEXT_MAX = 2000;
 const CARD_LOG_BY_MAX = 120;
+const stripNulText = (value) => String(value ?? "").replace(/\u0000/g, "");
 function normalizeTaskLog(t) {
   if (!Array.isArray(t.log)) { if (t.log !== undefined) delete t.log; return false; }
   const before = JSON.stringify(t.log);
@@ -133,7 +135,7 @@ function normalizeTaskLog(t) {
     .map(e => ({
       ts: Number.isFinite(Number(e.ts)) && Number(e.ts) > 0 ? Math.floor(Number(e.ts)) : Date.now(),
       by: String(e.by || "").slice(0, CARD_LOG_BY_MAX),
-      text: String(e.text || "").slice(0, CARD_LOG_TEXT_MAX),
+      text: stripNulText(e.text).slice(0, CARD_LOG_TEXT_MAX),
     }))
     .slice(-CARD_LOG_MAX);
   if (!t.log.length) delete t.log;
@@ -144,7 +146,7 @@ function appendTaskLog(t, by, text, ts = Date.now()) {
   const entry = {
     ts: Number.isFinite(Number(ts)) && Number(ts) > 0 ? Math.floor(Number(ts)) : Date.now(),
     by: String(by || "").slice(0, CARD_LOG_BY_MAX),
-    text: String(text).slice(0, CARD_LOG_TEXT_MAX),
+    text: stripNulText(text).slice(0, CARD_LOG_TEXT_MAX),
   };
   const log = Array.isArray(t.log) ? t.log : [];
   log.push(entry);
@@ -251,6 +253,11 @@ let dirty = false;
 // `cardEvents` key — so downgrading to a pre-0.17.54 hub still boots with its full TIMELINE
 // instead of a silently empty history. Cheap insurance on a live hub; drop the mirror later.
 let persisting = false;
+const persistHealth = createPersistHealth({
+  baseMs: process.env.RELAY_PERSIST_RETRY_BASE_MS,
+  maxMs: process.env.RELAY_PERSIST_RETRY_MAX_MS,
+  logIntervalMs: process.env.RELAY_PERSIST_LOG_INTERVAL_MS,
+});
 const snapshotState = () => JSON.parse(JSON.stringify({ ...state, cardEvents: state.events.filter(e => ["created", "moved", "updated"].includes(e?.type)) }));
 // This hub's writer id: saveDelta stamps it into every NOTIFY so we can tell our own change
 // notifications apart from a second writer's (importer, admin psql, another hub instance).
@@ -260,25 +267,38 @@ const HUB_SRC = `hub-${process.pid}-${randomBytes(4).toString("hex")}`;
 // survive our persist ticks (the old saveSnapshot wholesale delete+rewrite destroyed them).
 let lastPersisted = durableStore ? snapshotState() : null;
 if (runTaskBootMigrations()) dirty = true;
+const recordPersistFailure = (kind, error) => {
+  dirty = true;
+  const failure = persistHealth.failed(error);
+  if (failure.shouldLog) {
+    process.stderr.write(`[trantor] ${kind} persist failing: ${failure.health.retries} retries over ${failure.health.failingSinceMs}ms; last error: ${failure.health.lastError}\n`);
+  }
+};
 const persist = () => {
-  if (!dirty || persisting) return;
+  if (!dirty || persisting || !persistHealth.canAttempt()) return;
   if (durableStore) {
     const snapshot = snapshotState();
     dirty = false; persisting = true;
     durableStore.saveDelta(ORG_ID, lastPersisted, snapshot, { src: HUB_SRC }).then(() => {
       lastPersisted = snapshot;
+      persistHealth.succeeded();
     }).catch(e => {
-      dirty = true;
-      process.stderr.write(`[trantor] Postgres persist failed: ${e.message || e}\n`);
+      recordPersistFailure("Postgres", e);
     }).finally(() => {
       persisting = false;
-      if (dirty) persist();
     });
     return;
   }
-  try { writeFileSync(DATA, JSON.stringify(snapshotState())); dirty = false; } catch {}
+  try {
+    writeFileSync(DATA, JSON.stringify(snapshotState()));
+    dirty = false;
+    persistHealth.succeeded();
+  } catch (e) {
+    recordPersistFailure("JSON", e);
+  }
 };
-setInterval(persist, 1000).unref?.();
+const persistTickMs = Math.min(1000, Math.max(10, Number(process.env.RELAY_PERSIST_RETRY_BASE_MS) || 1000));
+setInterval(persist, persistTickMs).unref?.();
 
 // --- reload on external change (the boot-cache fix) -------------------------------------------
 // A NOTIFY from any writer that isn't us means Postgres has rows our in-memory projection has
@@ -320,6 +340,14 @@ async function reloadFromStore() {
 // not spam the feed; at level >= 3 a file-conflict opens a verify gate (the go/no-go primitive).
 let _overseer = null;
 import("./lib/overseer.mjs").then(m => { _overseer = m; }).catch(() => {});
+// #5760: the same-project episode rule (lib/same-project.mjs, pure) — lazy like the detector, so
+// a hub booted before the module lands still runs (the same-project branch fails QUIET until it
+// arrives: a missing rule must never re-instate the hourly metronome).
+let _sameProject = null;
+import("./lib/same-project.mjs").then(m => { _sameProject = m; }).catch(() => {});
+// This hub runs on the operator's machine, so the machine's own sessions ("<host>:<project>") ARE
+// the orchestrator side of every declared crew.
+const HOST_NAME = hostname().split(".")[0];
 const OVERSEER_TICK_MS = Number(process.env.RELAY_OVERSEER_TICK_MS || 30 * 1000);
 // How long a condition must be ABSENT before we consider the episode over. This is NOT a re-warn
 // timer: see overseerTick.
@@ -353,6 +381,37 @@ function overseerInputs() {
     now: now(),
   };
 }
+
+// --- #5760: the same-project warning is an EPISODE keyed by the MEMBER SET -------------------
+// The night of 08-31 the same-project DM re-fired hourly for a membership that never changed and
+// woke every seat into metered chatter turns. The rule (lib/same-project.mjs, pure) decides
+// fire-or-not from (previous set, current set, declared crew, last-fired-at): a declared crew is
+// the NORMAL state of a project and is not a collision at all; a set that never changed re-warns
+// never. The warn itself rides the SAME episode machinery as every other kind (#5350: one warn at
+// open, newcomer-only intros while standing, a genuine clear ends it) — the record below only
+// feeds the pure rule the set it judged last, so "unchanged" is one hash comparison and the
+// record line reports DURATION ("same-project for 6h"), never a count of warnings.
+const sameProjectFired = new Map(); // project -> { hash, sessions, ts } — the set as of the last verdict
+
+// The declared crew: HUB state, never a file on the operator's machine (#6075). The production
+// hub runs on netcup, where ~/.agent-bus/crew-windows.txt does not exist — the file describes the
+// OPERATOR'S machine (it is written by `trantor up` there), so on the remote hub the old reader
+// found nothing and every same-project set looked like intruders: the crew-only exemption simply
+// never held remotely. What the hub itself knows is the peer row's `kind` (#6148): "agent" is a
+// crew seat — crew-runner stamps it on every /register its seats make — and "orch" is the
+// project's orchestrator pane (sessionstart stamps it when TRANTOR_ORCH names this project).
+// The HOST_NAME exemption is gone with the file: the hub's hostname is the hub machine's
+// (netcup), never the operator's, so `<HOST_NAME>:<project>` exempted a session that cannot
+// exist. Genesis is deliberately NOT crew (#6068: a bookkeeping identity, not a seat).
+function declaredCrewFor(project) {
+  const crew = new Set();
+  for (const [sid, p] of Object.entries(state.peers)) {
+    if ((p.project || "") !== project) continue;
+    if (p.kind === "agent" || p.kind === "orch") crew.add(sid);
+  }
+  return [...crew];
+}
+
 function overseerTick() {
   if (!_overseer?.detectCollisions) return;
   let collisions = [];
@@ -365,8 +424,8 @@ function overseerTick() {
   // sessions to "coordinate over the bus" is useless if neither knows the other's id, and the
   // warning alone went only to the duty seat and the log — so coordination needed a human to carry
   // the ids across. Shared by the episode-start branch (all parties) and the standing branch
-  // (newcomers only): existing members never re-hear it, so a standing condition must not re-wake
-  // every party every tick.
+  // (newcomers only, same-project included): existing members never
+  // re-hear it, so a standing condition must not re-wake every party every tick.
   const intro = (c, me, others) => {
     const rest = others.filter(p => p !== me);
     if (rest.length === 0) return;
@@ -374,7 +433,58 @@ function overseerTick() {
       `🤝 OVERSEER ${c.kind}: you and ${rest.join(", ")} are working on overlapping ground${c.files?.length ? ` (${c.files.slice(0, 3).join(", ")})` : ""}. ${c.detail || ""} Coordinate directly — relay_send to ${rest[0]} — and split the work between you. No human needs to relay this.`,
       c.project);
   };
+  // #5760: same-project sets judged crew-only are dropped entirely — the normal state of a
+  // project, not a collision — so not even the context feed narrates them.
+  const kept = [];
   for (const c of collisions) {
+    // #5760: same-project gets the pure episode rule (lib/same-project.mjs) ON TOP of the shared
+    // episode machinery below: a crew-only set is not a collision at all (dropped — no warn, no
+    // context, no state); a standing set re-warns never (a liveness flap replays the SAME set —
+    // 08-31's metronome — and must stay silent, only genuine newcomers hear the intro once); and
+    // the record line reports DURATION. Without the rule module this branch is invisible and
+    // same-project rides the generic loop exactly as before — a missing rule must never
+    // re-instate the hourly metronome, so the fallback is the pre-#5760 behavior, never stricter.
+    if (c.kind === "same-project-sessions" && _sameProject?.sameProjectDecision) {
+      const prior = sameProjectFired.get(c.project) || null;
+      const d = _sameProject.sameProjectDecision({
+        previous: prior?.sessions ?? null,
+        current: c.sessions,
+        declaredCrew: declaredCrewFor(c.project),
+        lastFiredAt: prior?.ts ?? null,
+        now: t,
+      });
+      if (d.reason === "crew-only") continue;
+      const key = `${c.project} ${c.kind}`;
+      c.key = key;
+      seen.add(key);
+      kept.push(c);
+      const parties = [...new Set(c.sessions || [])].filter(s => s && s !== DUTY_SESSION);
+      const standing = overseerActive.get(key);
+      if (standing) {
+        // The episode HOLDS: no new warn, whoever was introed once is never re-heard.
+        standing.lastTick = t;
+        c.since = standing.since;
+        if (_sameProject.durationLabel) c.detail = `${c.detail || ""} (same-project for ${_sameProject.durationLabel(t - standing.since)})`.trim();
+        for (const me of parties) if (!standing.sessions.has(me)) intro(c, me, parties);
+        for (const me of parties) standing.sessions.add(me);
+        // The record tracks the live membership (ts stays at the last warn) so a later open
+        // judges the true previous set and can say how long the old one held.
+        if (d.fire && prior) sameProjectFired.set(c.project, { hash: _sameProject.memberSetHash(c.sessions), sessions: c.sessions, ts: prior.ts });
+        continue;
+      }
+      // The episode OPENS and the pure rule said fire — first sighting, or a membership change
+      // on a remembered set; the record line states how long the previous state held.
+      overseerActive.set(key, { since: t, lastTick: t, sessions: new Set(parties) });
+      c.since = t;
+      if (d.reason === "membership-changed") c.detail = `${c.detail || ""} (same-project for ${_sameProject.durationLabel(d.durationMs)})`.trim();
+      sameProjectFired.set(c.project, { hash: _sameProject.memberSetHash(c.sessions), sessions: c.sessions, ts: t });
+      appendEvent("overseer.warn", c.project, "overseer",
+        { kind: c.kind, sessions: c.sessions || [], files: c.files || [], detail: c.detail || "", narrated: false });
+      if (DUTY_SESSION) hubSend(DUTY_SESSION, `⚠️ OVERSEER ${c.kind} [${c.project}]: ${c.detail || ""} — if the parties are not already coordinating, message them.`, c.project);
+      if (parties.length > 1) for (const me of parties) intro(c, me, parties);
+      continue;
+    }
+    kept.push(c);
     // Episode identity is the CONDITION (project+kind+files), never the session list (#5350):
     // membership is volatile — a third seat bouncing in and out of a standing collision minted a
     // fresh key, so a fresh episode, so a fresh warn (+ duty wake + party intros) per permutation.
@@ -413,9 +523,14 @@ function overseerTick() {
   // Episode end: a condition gone for the whole clear window is over, so a LATER recurrence is a
   // new episode and warns again. Without this the map would grow forever and nothing could re-fire.
   for (const [k, v] of overseerActive) {
-    if (!seen.has(k) && t - v.lastTick > OVERSEER_CLEAR_MS) overseerActive.delete(k);
+    if (!seen.has(k) && t - v.lastTick > OVERSEER_CLEAR_MS) {
+      overseerActive.delete(k);
+      // #5760: the same-project verdict record dies WITH its episode — a set that returns after a
+      // genuine clear is a new episode (it warns again, first sighting), not the old one continuing.
+      if (k.endsWith(" same-project-sessions")) sameProjectFired.delete(k.slice(0, -" same-project-sessions".length));
+    }
   }
-  overseerLastCollisions = collisions;
+  overseerLastCollisions = kept;
 }
 setInterval(overseerTick, OVERSEER_TICK_MS).unref?.();
 // setInterval waits a FULL period before its first call, so for 30s after every restart the watcher
@@ -1173,6 +1288,22 @@ function markDelivered(session, upTo) {
 function pushToStreams(msg) {
   for (const s of streams) if (deliverable(msg, s.session)) { try { s.res.write(`data: ${JSON.stringify(msg)}\n\n`); } catch {} }
 }
+// A live runner can outlast the durable snapshot it was polling. If its cursor is now beyond the
+// message high-water mark, echoing that impossible value leaves it deaf forever. Clamp it to the
+// current tip and say explicitly that time moved backwards so clients can adopt the lower cursor.
+function inboxWindow(value) {
+  const parsed = Number(value || 0);
+  const requested = Number.isFinite(parsed) ? Math.max(0, parsed) : 0;
+  const tip = Math.max(Number(state.seq || 0), Number(state.messages[state.messages.length - 1]?.id || 0));
+  const rewound = requested > tip;
+  return { since: rewound ? tip : requested, tip, rewound };
+}
+function inboxResponse(auth, messages, cursor, rewound = false) {
+  const response = { messages, cursor };
+  if (rewound) response.rewound = true;
+  if (auth?.superseded) response.superseded = true;
+  return response;
+}
 // Live push for the FEED. Sent ONLY to streams that opted in with /stream?events=1, and as a NAMED
 // SSE event ("event: ev") so an existing consumer's default onmessage handler — which expects a bus
 // message and nothing else — can never see it. Backwards-safe by construction.
@@ -1390,7 +1521,9 @@ const server = http.createServer(async (req, res) => {
       // WHO is this, really: the LLM brand + the exact model currently loaded. In-memory like the
       // rest of presence — the next heartbeat re-supplies it after a restart.
       const pr = state.peers[b.session];
-      if (pr) { if (b.model) pr.model = String(b.model).slice(0, 80); if (b.llm) pr.llm = String(b.llm).slice(0, 40); }
+      // #6148: WHAT a session is rides its peer row (kind "genesis" = the CLI's brief-poster,
+      // "agent" = a crew seat) — /peers hands it to the app so the seat strip can tell them apart.
+      if (pr) { if (b.model) pr.model = String(b.model).slice(0, 80); if (b.llm) pr.llm = String(b.llm).slice(0, 40); if (b.kind) pr.kind = String(b.kind).slice(0, 40); }
       return json(res, 200, { ok: true, session: b.session, peers: Object.keys(state.peers) });
     }
     if (req.method === "POST" && P === "/status") { const b = await body(req); touch(b.session, b.status ?? "", b.project, b.hookVersion, auth); return json(res, 200, { ok: true }); }
@@ -1558,8 +1691,29 @@ const server = http.createServer(async (req, res) => {
       const inflight = [...fileClaims.values()].filter(c => c.project === proj)
         .map(c => ({ file: c.file, session: c.session, agoSec: Math.round((now() - c.ts) / 1000) }));
       let warnings = [];
-      try { warnings = (_overseer?.detectCollisions ? _overseer.detectCollisions(overseerInputs()) : [])
-        .filter(c => c.project === proj || linked.has(c.project)); } catch {}
+      try {
+        warnings = (_overseer?.detectCollisions ? _overseer.detectCollisions(overseerInputs()) : [])
+          .filter(c => c.project === proj || linked.has(c.project));
+        // #5760: a declared crew is the NORMAL state of a project, not a collision — the tick
+        // loop drops crew-only sets before they ever become episodes, and this live view must
+        // agree with it: the SessionStart hook narrates exactly these lines, so a crew-only leak
+        // here would re-wake every booting seat into a metered turn for no membership change.
+        warnings = warnings.filter(c => !(c.kind === "same-project-sessions" && _sameProject?.sameProjectDecision &&
+          _sameProject.sameProjectDecision({
+            current: c.sessions,
+            declaredCrew: declaredCrewFor(c.project),
+            now: now(),
+          }).reason === "crew-only"));
+        // The record line reports DURATION ("same-project for 6h"), never a count of warnings.
+        for (const c of warnings) {
+          if (c.kind !== "same-project-sessions") continue;
+          const ep = overseerActive.get(`${c.project} same-project-sessions`);
+          if (ep) {
+            c.since = ep.since;
+            if (_sameProject?.durationLabel) c.detail = `${c.detail || ""} (same-project for ${_sameProject.durationLabel(now() - ep.since)})`.trim();
+          }
+        }
+      } catch {}
       return json(res, 200, { level, links: links.map(l => ({ projects: l.projects, reason: l.reason })), peers: peersOut, inflight, warnings });
     }
     // Supersession (docs/INSTANCE-KEYS-CONTRACT.md): EXPLICIT, never automatic — the baton-claim
@@ -1639,7 +1793,7 @@ const server = http.createServer(async (req, res) => {
       const peerRows = filterDiscoverable(auth, Object.entries(state.peers), ([, v]) => v.project || "");
       return json(res, 200, { hubVersion: HUB_VERSION, authMode: AUTH_MODE, peers: peerRows.map(([s, v]) => ({ session: s, lastSeen: v.lastSeen, online: v.lastSeen > cutoff, status: v.status || "", health: healthOf(v.status), project: v.project || "",
         pubkey: v.pubkey || "", identity: v.identity || null, authWarning: v.authWarning || "",
-        llm: v.llm || "", model: v.model || "", hookVersion: v.hookVersion || "", staleHooks: !!(v.lastSeen > cutoff && v.hookVersion && HUB_VERSION && cmpSemver(v.hookVersion, HUB_VERSION) < 0) })) });
+        kind: v.kind || v.identity?.kind || "", llm: v.llm || "", model: v.model || "", hookVersion: v.hookVersion || "", staleHooks: !!(v.lastSeen > cutoff && v.hookVersion && HUB_VERSION && cmpSemver(v.hookVersion, HUB_VERSION) < 0) })) });
     }
     // --- Provider balances (prepaid credit) ---
     // The hub runs under launchd with no provider keys, so it can't fetch balances itself. Env-having
@@ -1766,6 +1920,8 @@ const server = http.createServer(async (req, res) => {
     // --- Kanban tasks ---
     if (req.method === "POST" && P === "/task") {           // create a card
       const b = await body(req); touch(b.by, undefined, b.project, undefined, auth);
+      if (b.title !== undefined) b.title = stripNulText(b.title);
+      if (b.note !== undefined) b.note = stripNulText(b.note);
       const st0 = ["todo","doing","testing","failed","done","blocked"].includes(b.status) ? b.status : "todo";
       // optional historical ts (backfill from git/import) — accept a past epoch-ms; else now().
       const ts0 = (Number.isFinite(b.ts) && b.ts > 0 && b.ts <= now() + 864e5) ? Math.floor(b.ts) : now();
@@ -1919,6 +2075,8 @@ const server = http.createServer(async (req, res) => {
     if (req.method === "POST" && P === "/task/update") {    // move/edit a card
       const b = await body(req); const t = state.tasks.find(x => x.id === Number(b.id));
       if (!t) return json(res, 404, { error: "no such task" });
+      if (b.title !== undefined) b.title = stripNulText(b.title);
+      if (b.note !== undefined) b.note = stripNulText(b.note);
       // Board integrity (#5406): a card can never change hands silently. The assignee is frozen once
       // set; a mutation is legitimate only as a HANDOFF (the current assignee reassigning to someone
       // else) or an EXPLICIT reassign (reassign:true — e.g. the orchestrator re-routing work after a
@@ -2279,7 +2437,7 @@ const server = http.createServer(async (req, res) => {
     // --- lessons: cross-agent learning from failures. scope = "global" or an agent brand ("kimi") ---
     if (req.method === "POST" && P === "/lesson") {
       const b = await body(req);
-      const text = String(b.text || "").trim().slice(0, 400);
+      const text = stripNulText(b.text).trim().slice(0, 400);
       const scope = String(b.scope || "global").toLowerCase().slice(0, 40);
       if (!text) return json(res, 400, { error: "text required" });
       if (state.lessons.some(l => l.scope === scope && l.text === text)) return json(res, 200, { ok: true, dedup: true });
@@ -2614,7 +2772,7 @@ const server = http.createServer(async (req, res) => {
     }
     if (req.method === "POST" && P === "/send") {
       const b = await body(req);
-      const text = String(b.text ?? "");
+      const text = stripNulText(b.text);
       if (!b.from || !text.trim()) return json(res, 400, { error: "from and non-empty text required" });
       const secretCheck = assertNoSecrets(text);
       if (!secretCheck.ok) return json(res, 400, { error: "secret detected", kinds: secretCheck.kinds || [] });
@@ -2693,7 +2851,8 @@ const server = http.createServer(async (req, res) => {
 
     if (req.method === "GET" && P === "/inbox") {
       if (!canUseInboxSession(auth, q.session)) return json(res, 403, { error: "forbidden" });
-      touch(q.session, undefined, undefined, undefined, auth); const since = Number(q.since || 0);
+      touch(q.session, undefined, undefined, undefined, auth); const window = inboxWindow(q.since);
+      const { since, rewound } = window;
       const msgs = state.messages.filter(m => m.id > since && deliverable(m, q.session) && inboxReadable(auth, m, q.session));
       const cursor = msgs.length ? msgs[msgs.length - 1].id : since;
       // peek=1 -> LOOK without claiming delivery. The Stop hook has to ask "is anything waiting?" before
@@ -2703,16 +2862,21 @@ const server = http.createServer(async (req, res) => {
       if (q.peek !== "1") markDelivered(q.session, cursor);
       // superseded (instance-keys contract): a baton twin that lost the claim learns it HERE, via
       // its own read — its hooks turn this into a stand-down note for the model. Never a block.
-      return json(res, 200, auth?.superseded ? { messages: msgs, cursor, superseded: true } : { messages: msgs, cursor });
+      return json(res, 200, inboxResponse(auth, msgs, cursor, rewound));
     }
     if (req.method === "GET" && P === "/poll") {
       if (!canUseInboxSession(auth, q.session)) return json(res, 403, { error: "forbidden" });
-      touch(q.session, undefined, undefined, undefined, auth); const since = Number(q.since || 0);
+      touch(q.session, undefined, undefined, undefined, auth); const window = inboxWindow(q.since);
+      const { since, rewound } = window;
+      if (rewound) {
+        markDelivered(q.session, window.tip);
+        return json(res, 200, inboxResponse(auth, [], window.tip, true));
+      }
       const waitMs = Math.min(Number(q.wait || 25), 290) * 1000;   // allow long idle-park
       const deadline = now() + waitMs;
       const tick = () => {
         const msgs = state.messages.filter(m => m.id > since && deliverable(m, q.session) && inboxReadable(auth, m, q.session));
-        if (msgs.length || now() >= deadline) { touch(q.session, undefined, undefined, undefined, auth); const cursor = msgs.length ? msgs[msgs.length - 1].id : since; markDelivered(q.session, cursor); return json(res, 200, auth?.superseded ? { messages: msgs, cursor, superseded: true } : { messages: msgs, cursor }); }
+        if (msgs.length || now() >= deadline) { touch(q.session, undefined, undefined, undefined, auth); const cursor = msgs.length ? msgs[msgs.length - 1].id : since; markDelivered(q.session, cursor); return json(res, 200, inboxResponse(auth, msgs, cursor)); }
         setTimeout(tick, 300);
       };
       return tick();
@@ -2738,6 +2902,7 @@ const server = http.createServer(async (req, res) => {
       res.writeHead(200, { "content-type": "text/html; charset=utf-8" }); return res.end(UI || "<h1>trantor</h1><p>dashboard unavailable</p>");
     }
     if (P === "/health") return json(res, 200, { ok: true, authMode: AUTH_MODE, peers: Object.keys(state.peers).length, messages: state.messages.length, streams: streams.length,
+      persist: persistHealth.view(),
       // #5686: duty liveness rides /health so the app's Home strip and doctor read one truth.
       duty: { ...dutyLiveness(), darkSinceMs: dutyDarkSince ? now() - dutyDarkSince : 0, queuedEscalations: dutyQueuedEscalations() } });
     json(res, 404, { error: "not found" });

package/lib/enroll.mjs

@@ -32,7 +32,7 @@ export function ownerIdentity() {
 
 // Returns { ok, reason }. NEVER throws and never blocks a turn — a hub that is down, or an operator
 // key that is absent, must degrade to "unenrolled" rather than take the seat with it.
-export async function ensureEnrolled(hubUrl, identity, project, { timeoutMs = 4000 } = {}) {
+export async function ensureEnrolled(hubUrl, identity, project, { timeoutMs = 4000, kind } = {}) {
   if (!hubUrl || !identity?.pubkey) return { ok: false, reason: "no-identity" };
   try {
     // Cheapest possible probe that the hub authorises: if we are already known this is a no-op.
@@ -55,7 +55,7 @@ export async function ensureEnrolled(hubUrl, identity, project, { timeoutMs = 40
 
     const en = await sfetch(`${hubUrl}/enroll`, {
       method: "POST", headers: { "content-type": "application/json" },
-      body: JSON.stringify({ name: identity.name, kind: identity.kind || "agent", token }),
+      body: JSON.stringify({ name: identity.name, kind: kind || identity.kind || "agent", token }),
       signal: AbortSignal.timeout(timeoutMs),
     }, identity);
     return en.ok ? { ok: true, reason: "enrolled" } : { ok: false, reason: `enroll-${en.status}` };

package/lib/persist-health.mjs

@@ -0,0 +1,56 @@
+// Persistence is a standing health condition, not a stream of retry errors. This tracker keeps the
+// retry schedule and the operator-facing state together so they cannot disagree.
+export const PERSIST_RETRY_BASE_MS = 1000;
+export const PERSIST_RETRY_MAX_MS = 60_000;
+export const PERSIST_LOG_INTERVAL_MS = 60_000;
+
+const positive = (value, fallback) => {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+};
+
+export function createPersistHealth(options = {}) {
+  const baseMs = positive(options.baseMs, PERSIST_RETRY_BASE_MS);
+  const maxMs = Math.max(baseMs, positive(options.maxMs, PERSIST_RETRY_MAX_MS));
+  const logIntervalMs = positive(options.logIntervalMs, PERSIST_LOG_INTERVAL_MS);
+  let failedAt = 0;
+  let lastError = "";
+  let retries = 0;
+  let retryMs = baseMs;
+  let nextAttemptAt = 0;
+  let lastLogAt = -Infinity;
+
+  const view = (at = Date.now()) => ({
+    ok: retries === 0,
+    failingSinceMs: retries === 0 ? 0 : Math.max(0, Number(at) - failedAt),
+    lastError,
+    retries,
+  });
+
+  return {
+    canAttempt(at = Date.now()) {
+      return retries === 0 || Number(at) >= nextAttemptAt;
+    },
+    failed(error, at = Date.now()) {
+      const when = Number(at);
+      if (retries === 0) failedAt = when;
+      retries += 1;
+      lastError = String(error?.message || error || "persist failed").replace(/\u0000/g, "").replace(/\s+/g, " ").slice(0, 500);
+      const delayMs = retryMs;
+      nextAttemptAt = when + delayMs;
+      retryMs = Math.min(maxMs, retryMs * 2);
+      const shouldLog = when - lastLogAt >= logIntervalMs;
+      if (shouldLog) lastLogAt = when;
+      return { delayMs, shouldLog, health: view(when) };
+    },
+    succeeded() {
+      failedAt = 0;
+      lastError = "";
+      retries = 0;
+      retryMs = baseMs;
+      nextAttemptAt = 0;
+      lastLogAt = -Infinity;
+    },
+    view,
+  };
+}

package/lib/same-project.mjs

@@ -0,0 +1,65 @@
+// #5760 — the same-project OVERSEER warning is an EPISODE, not a timer. The night of 08-31 the
+// "🤝 OVERSEER same-project-sessions" DM re-fired hourly and woke every seat into metered chatter
+// turns for a membership that never changed. The monitoring doctrine this project holds everyone
+// else to — report duration, not repetition — applied to its own emitter:
+//
+//   1. The warning fires ONCE when the membership set CHANGES — a session joins or leaves —
+//      keyed by a stable hash of the member set. Never on a clock.
+//   2. An unchanged set re-warns never. When a change does fire, the record line reports
+//      DURATION ("same-project for 6h"), not repetition.
+//   3. An operator-declared crew (the seats `trantor up` spawned plus the orchestrator) is the
+//      NORMAL state of a project, not a collision: only sessions OUTSIDE the declared crew
+//      trigger the warning at all.
+//
+// Pure module: no I/O, no imports. The hub owns persistence (the previously-fired set and when)
+// and the crew declaration; this file only decides.
+const clean = (v) => String(v ?? "").trim();
+
+// The member SET: sorted, deduped — so set comparison and hashing never see order or repeats.
+export function memberSet(sessions) {
+  return [...new Set((sessions ?? []).map(clean).filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+
+// A stable hash of the member set, so "did the membership change" is one comparison that
+// survives process restarts and set reordering. FNV-1a over the joined members: deterministic
+// everywhere, no dependencies.
+export function memberSetHash(sessions) {
+  let h = 0x811c9dc5;
+  for (const ch of memberSet(sessions).join("\u0000")) {
+    h ^= ch.codePointAt(0);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h.toString(16);
+}
+
+// "6h" / "12m" / "<1m" — the record line states how long the episode has held, never a count
+// of warnings. An unchanged state is not news; its DURATION is.
+export function durationLabel(ms) {
+  const m = Math.floor(Math.max(0, Number(ms) || 0) / 60000);
+  if (m < 1) return "<1m";
+  if (m < 60) return `${m}m`;
+  return `${Math.floor(m / 60)}h`;
+}
+
+// Fire-or-not. previous = the member set as of the LAST fire (null = never fired); current = the
+// live sessions on the project now; declaredCrew = the operator's crew (seats + orchestrator);
+// lastFiredAt = when the last fire happened (null = never). The clock inputs exist ONLY to state
+// duration — there is no elapsed-time threshold anywhere: a change fires, a hold never does.
+export function sameProjectDecision({ previous = null, current = [], declaredCrew = [], lastFiredAt = null, now = 0 } = {}) {
+  const cur = memberSet(current);
+  const crew = new Set(memberSet(declaredCrew));
+  const intruders = cur.filter((s) => !crew.has(s));
+  if (intruders.length === 0) return { fire: false, reason: "crew-only", intruders: [], durationMs: 0 };
+  if (previous == null || lastFiredAt == null) {
+    return { fire: true, reason: "first-sighting", intruders, durationMs: 0 };
+  }
+  if (memberSetHash(previous) === memberSetHash(cur)) {
+    return { fire: false, reason: "unchanged", intruders, durationMs: 0 };
+  }
+  return {
+    fire: true,
+    reason: "membership-changed",
+    intruders,
+    durationMs: Math.max(0, (Number(now) || 0) - (Number(lastFiredAt) || 0)),
+  };
+}

package/lib/store-pg.mjs

@@ -1,6 +1,9 @@
 // trantor Phase 1 Postgres store.
 // Implements the frozen STORE_API from ./store-contract.mjs. The hub still keeps its existing
 // in-memory projection while running; this store is the durable backing when RELAY_STORE=pg.
+// SAFETY: This module is the Postgres I/O decoder/encoder boundary. Its runtime `typeof` checks
+// validate untrusted jsonb rows and caller-supplied JSON before those values enter the hub domain.
+/* oxlint-disable anti-slop/no-runtime-typeof */
 import { SCHEMA_SQL, SCHEMA_VERSION, KV_KEYS, DEFAULT_ORG, CHANGE_CHANNEL } from "./store-contract.mjs";
 
 const asJson = (v, fallback) => (v === undefined ? fallback : v);
@@ -10,9 +13,21 @@ const ms = (v, fallback = Date.now()) => {
 };
 const num = (v) => (v == null ? v : Number(v));
 
+// PostgreSQL rejects U+0000 in both text and jsonb. Sanitize the complete row projection here,
+// below every caller, so an old client or an imported nested payload cannot poison the delta.
+export function stripNulDeep(value) {
+  if (typeof value === "string") return value.replace(/\u0000/g, "");
+  if (Array.isArray(value)) return value.map(stripNulDeep);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key.replace(/\u0000/g, ""), stripNulDeep(child)]));
+  }
+  return value;
+}
+
 const EVENT_COLUMN_KEYS = ["id", "ts", "type", "project", "by", "by_session", "taskId", "task_id", "payload"];
 function stripEventPayload(evt = {}) {
-  const payload = { ...(evt.payload && typeof evt.payload === "object" ? evt.payload : {}) };
+  const payload = {};
+  if (evt.payload && typeof evt.payload === "object") Object.assign(payload, evt.payload);
   // The nested payload gets the same treatment as the top level. It used to be copied in wholesale,
   // so a column key riding inside it (an `id` from an imported event) was stored and then clobbered
   // the real column on the way back out.
@@ -512,7 +527,10 @@ export class PgStore {
   // Emits NOTIFY on CHANGE_CHANNEL inside the transaction (delivered on commit) so other hubs
   // reload; `src` lets a hub ignore its own notifications.
   async saveDelta(orgId, prev, next, { src = "" } = {}) {
-    prev = prev || {};
+    orgId = String(stripNulDeep(orgId));
+    src = String(stripNulDeep(src));
+    prev = stripNulDeep(prev || {});
+    next = stripNulDeep(next || {});
     const tasks = diffById(prev.tasks, next.tasks, t => Number(t.id));
     const events = diffById(prev.events, next.events, e => Number(e.id));
     const messages = diffById(prev.messages, next.messages, m => Number(m.id));

package/mcp.mjs

@@ -68,10 +68,12 @@ const PROJECT = resolveProject(process.env.CLAUDE_PROJECT_DIR || process.cwd());
 // global `url` → local default. A project lives on exactly one hub; codependent projects
 // must share one, so both are pinned to the same hub via `trantor hub set`.
 const URL_BASE = resolveHub(PROJECT);   // boot-time snapshot: startup log only — every api() call re-resolves
-// Identity: RELAY_SESSION wins; else RELAY_AGENT ("codex", "kimi", …) brands the session per-project
-// (set it once in the CLI's global MCP config — works in every project); else hostname:project.
+// Identity: the runner's exact RELAY_SESSION wins, then its RELAY_AGENT. A multi-seat host such as
+// OpenCode contributes only RELAY_AGENT_FALLBACK in its global MCP config, so qwen/glm/deepseek do
+// not get rebranded "opencode" when that config is overlaid on the runner environment.
+const SESSION_AGENT = process.env.RELAY_AGENT || process.env.RELAY_AGENT_FALLBACK;
 const SESSION = process.env.RELAY_SESSION
-  || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${PROJECT}` : `${hostId()}:${PROJECT}`);
+  || (SESSION_AGENT ? `${SESSION_AGENT}:${PROJECT}` : `${hostId()}:${PROJECT}`);
 let cursor = 0;
 // First-call guard: a brand-new MCP process must NOT replay the entire historical backlog (observed:
 // 2,379 msgs / 520KB back to an old asteroids project) the instant relay_inbox/relay_wait is called.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.32",
+  "version": "0.18.33",
   "type": "module",
   "bin": {
     "trantor": "bin/cli.mjs"
@@ -11,7 +11,7 @@
     "zod": "^4.4.3"
   },
   "scripts": {
-    "test": "node bin/slop-gate.mjs --surface desktop/src && node test.mjs && node test-scenarios.mjs && node test-failure.mjs && node test-redelivery.mjs && node test-crew-completion.mjs && node test-contracts.mjs && node test-autonomy.mjs && node test-integrate.mjs && node test-handoff.mjs && node test-handoff-summarizer.mjs && node test-baton-turn-boundary.mjs && node test-agents.mjs && node test-update.mjs && node test-handoff-guard.mjs && node test-baton-latest.mjs && node test-balances.mjs && node test-usage-live.mjs && node test-subagent-cost.mjs && node test-inbox.mjs && node test-inflight.mjs && node test-notify.mjs && node test-focus.mjs && node test-cardlog.mjs && node test-checklist.mjs && node test-relay-note.mjs && node test-reaper.mjs && node test-events.mjs && node test-proposals.mjs && node test-scrub.mjs && node test-store-delta.mjs && node test-message-re.mjs && node test-claims.mjs && node test-adopt.mjs && node test-summarize.mjs && node test-identity-core.mjs && node test-identity.mjs && node test-identity-instances.mjs && node test-duty.mjs && node test-duty-dark.mjs && node test-duty-seat.mjs && node test-discovery.mjs && node test-doctor.mjs && node test-crew-env.mjs && node test-desktop-transport.mjs && node test-crew-worktree.mjs && node test-crew-redact.mjs && node test-crew-classify.mjs && bash test-crew-herdr.sh && npm --prefix desktop run test --silent && node test-splitbrain.mjs && node test-overseer.mjs && node test-overseer-lib.mjs && node test-overseer-warn.mjs && node test-provider-keys.mjs && node test-provider-cli.mjs && node test-crew-model-defaults.mjs && node test-inbox-delivery.mjs && node test-identity-drift.mjs && node test-inbox-staleness.mjs && node test-seats.mjs && node test-seat-identity.mjs && node test-hub-routing.mjs && node test-hook-routing.mjs && node test-relay-wait.mjs && node test-dsh-seat.mjs && node test-kimi-bridge.mjs && node test-kimi-events.mjs && python3 engine/test-routing.py && node test-new.mjs && node test-reconcile.mjs && node test-resources.mjs && node test-patrol.mjs && node test-bridge.mjs && bash test-crew.sh"
+    "test": "node bin/slop-gate.mjs --surface desktop/src && node test.mjs && node test-scenarios.mjs && node test-failure.mjs && node test-redelivery.mjs && node test-crew-completion.mjs && node test-contracts.mjs && node test-autonomy.mjs && node test-integrate.mjs && node test-handoff.mjs && node test-handoff-summarizer.mjs && node test-baton-turn-boundary.mjs && node test-agents.mjs && node test-update.mjs && node test-handoff-guard.mjs && node test-baton-latest.mjs && node test-balances.mjs && node test-usage-live.mjs && node test-subagent-cost.mjs && node test-inbox.mjs && node test-cursor-rewind.mjs && node test-inflight.mjs && node test-notify.mjs && node test-focus.mjs && node test-cardlog.mjs && node test-checklist.mjs && node test-relay-note.mjs && node test-reaper.mjs && node test-events.mjs && node test-proposals.mjs && node test-scrub.mjs && node test-store-delta.mjs && node test-persist-safety.mjs && node test-message-re.mjs && node test-claims.mjs && node test-adopt.mjs && node test-summarize.mjs && node test-identity-core.mjs && node test-identity.mjs && node test-identity-instances.mjs && node test-duty.mjs && node test-duty-dark.mjs && node test-duty-seat.mjs && node test-discovery.mjs && node test-doctor.mjs && node test-crew-env.mjs && node test-desktop-transport.mjs && node test-crew-worktree.mjs && node test-crew-redact.mjs && node test-crew-classify.mjs && bash test-crew-herdr.sh && npm --prefix desktop run test --silent && node test-splitbrain.mjs && node test-overseer.mjs && node test-overseer-lib.mjs && node test-overseer-warn.mjs && node test-provider-keys.mjs && node test-provider-cli.mjs && node test-crew-model-defaults.mjs && node test-inbox-delivery.mjs && node test-identity-drift.mjs && node test-inbox-staleness.mjs && node test-seats.mjs && node test-seat-identity.mjs && node test-hub-routing.mjs && node test-hook-routing.mjs && node test-relay-wait.mjs && node test-dsh-seat.mjs && node test-kimi-bridge.mjs && node test-kimi-events.mjs && python3 engine/test-routing.py && node test-new.mjs && node test-reconcile.mjs && node test-resources.mjs && node test-patrol.mjs && node test-bridge.mjs && bash test-crew.sh"
   },
   "description": "The hub-world for AI agent crews — orchestrate Claude Code, Codex, GLM, Kimi, DeepSeek & any OpenRouter model as live crews with a plan-aware Advisor, a Kanban/flow command center, a testing gate, and an economics brain (Scrooge).",
   "files": [

package/skills/handoff/SKILL.md

@@ -20,8 +20,19 @@ only to plain Terminal sessions.
 
 ## Instructions
 
+PREFER THE GLOBAL `trantor` BINARY when it is on PATH (`command -v trantor`): it runs the
+INSTALLED version's code, while `${CLAUDE_PLUGIN_ROOT}` is the plugin-cache copy pinned when this
+session booted — a session opened before an update runs stale logic (witnessed 2026-09-02: a
+0.18.20 cache copy mis-resolved the project from a subfolder cwd and closed a Terminal window that
+was not its own). Use `trantor handoff …` for both commands below; fall back to the
+`node "${CLAUDE_PLUGIN_ROOT}/bin/write-handoff.mjs" …` form only when `trantor` is absent.
+`trantor handoff` takes piped markdown (a heredoc) and `--latest` exactly like the helper, because
+it forwards to the same package's `write-handoff.mjs`.
+
 0. **Already written one this session?** Then do NOT write it again — pass the baton on it:
    ```bash
+   trantor handoff --latest
+   # or, without the global binary:
    node "${CLAUDE_PLUGIN_ROOT}/bin/write-handoff.mjs" --baton --latest
    ```
    That picks this project's newest unconsumed handoff and hands it over untouched, and exits
@@ -39,10 +50,12 @@ only to plain Terminal sessions.
 
 2. Save it AND pass the baton in one shot — pipe the markdown to the helper with `--baton`:
    ```bash
-   cat << 'HANDOFF' | node "${CLAUDE_PLUGIN_ROOT}/bin/write-handoff.mjs" --baton
+   trantor handoff --baton << 'HANDOFF'
    <your handoff markdown>
    HANDOFF
    ```
+   (or `cat << 'HANDOFF' | node "${CLAUDE_PLUGIN_ROOT}/bin/write-handoff.mjs" --baton` without the
+   global binary.)
    `--baton` writes the handoff, opens a FRESH session that takes over (it auto-recaps the handoff
    on open), and closes THIS Terminal window once the fresh session has consumed it — a true baton
    pass, one session at a time. (Omit `--baton` to only write the handoff without spawning/closing.)