trantor 0.18.34 → 0.18.36

package/.claude-plugin/plugin.json

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

@@ -9,7 +9,7 @@
 // agent arrives it RESUMES the CLI session (native resume = full context kept) with that
 // message as the prompt. The model just works and ends its turn; the runner does the rest.
 import { execSync, spawnSync, spawn } from "node:child_process";
-import { readFileSync, writeFileSync, unlinkSync, existsSync, appendFileSync, mkdirSync } from "node:fs";
+import { readFileSync, writeFileSync, unlinkSync, existsSync, appendFileSync, mkdirSync, realpathSync } from "node:fs";
 import { join, basename } from "node:path";
 import { homedir } from "node:os";
 import { resolveProject, resolveHub, withEnvFiles, hostId } from "../lib/project.mjs";
@@ -23,6 +23,9 @@ import {
   readPromptText, stripPromptEcho,
 } from "../lib/classify-failure.mjs";
 import { capWake, capBcast, pickLessons, composePrompt } from "./crew-payload.mjs";
+import {
+  cardRef, carriesWork, parseTurnTokens, parseResetAt, reasonWithBalances, PARKING_REASONS,
+} from "../lib/turn-policy.mjs";
 
 const AGENT = process.argv[2];
 const DIR = process.argv[3] || process.cwd();
@@ -106,6 +109,26 @@ function ensureSeatWorktree(sourceDir) {
 }
 
 const TURN_DIR = ensureSeatWorktree(DIR);
+
+// #6154: opencode prints no session id on stdout, but it records every session in its own sqlite
+// DB with the directory the session was created in. The newest row for OUR worktree is the only
+// session a resume may pin — anything else in that DB belongs to another project on this machine,
+// which is exactly what `run -c` used to hand us. Read-only, fail-open: no DB or no row means the
+// next turn starts fresh, which is always safe, instead of resuming a stranger, which never is.
+const OC_DB = join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "opencode", "opencode.db");
+function ocSid(dir) {
+  try {
+    // opencode stores the directory as IT sees its cwd, which on macOS can be the /private/var
+    // realpath of the /var/... path the runner holds — query both spellings.
+    const dirs = [dir];
+    try { const real = realpathSync(dir); if (real !== dir) dirs.push(real); } catch {}
+    const list = dirs.map((d) => `'${d.replaceAll("'", "''")}'`).join(", ");
+    const q = `SELECT id FROM session WHERE directory IN (${list}) ORDER BY time_updated DESC LIMIT 1;`;
+    const r = spawnSync("sqlite3", ["-readonly", OC_DB, q], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 });
+    const id = String(r.stdout || "").trim();
+    return /^ses_[A-Za-z0-9]+$/.test(id) ? id : "";
+  } catch { return ""; }
+}
 // RUNNER_SESSION override: an orchestrator seat (bin/orchestrate.mjs) runs the same CLI as a crew
 // seat but must live on the bus under its own name (claude-orch:proj), or it would collide with a
 // plain claude crew seat on the same project.
@@ -241,16 +264,25 @@ const CLI = {
   // --yolo in prompt mode (prompt mode auto-approves tools), and emits session_-prefixed ids.
   kimi:     { first: `kimi{M} -p "$(cat {P})" < /dev/null`,
               next:  `kimi{M} -r {SID} -p "$(cat {P})" < /dev/null`, mflag: " --model ", sid: /To resume this session: kimi -r (\S+)/ },
-  deepseek: { first: `opencode run{M} "$(cat {P})"`,
-              next:  `opencode run -c{M} "$(cat {P})"`, mflag: " -m ", env: join(homedir(), ".token-scrooge", ".env") },
-  opencode: { first: `opencode run{M} "$(cat {P})"`,
-              next:  `opencode run -c{M} "$(cat {P})"`, mflag: " -m ", env: join(homedir(), ".token-scrooge", ".env") },
+  // #6154: the opencode family never resumes blind. `run -c` continues the GLOBALLY last session
+  // on this machine — any project's (opencode.db showed a pr-os session interleaved between two
+  // trantor ones) — and the resumed session's stored directory becomes the Location every relative
+  // path resolves against. A seat then `cd desktop/src-tauri` inside its own worktree while
+  // opencode resolves it against a stranger's root, the bash tool reads it as external_directory
+  // and auto-rejects, and the turn dies mid-work with everything uncommitted. So: every spawn
+  // pins --dir to the seat worktree, and a resume pins -s to the session id looked up from
+  // opencode's own DB by directory — the session CREATED here (ocSid below). A missed lookup
+  // degrades to a fresh session, never to a foreign one.
+  deepseek: { first: `opencode run --dir {DIR}{M} "$(cat {P})"`,
+              next:  `opencode run --dir {DIR} -s {SID}{M} "$(cat {P})"`, mflag: " -m ", pinned: true, env: join(homedir(), ".token-scrooge", ".env") },
+  opencode: { first: `opencode run --dir {DIR}{M} "$(cat {P})"`,
+              next:  `opencode run --dir {DIR} -s {SID}{M} "$(cat {P})"`, mflag: " -m ", pinned: true, env: join(homedir(), ".token-scrooge", ".env") },
   // OpenRouter rides the opencode CLI exactly like deepseek/glm, but under its OWN agent label so
   // its bus identity is `openrouter:<project>` (RELAY_AGENT is set per-spawn) — never colliding with
   // the glm `opencode` seat. Model ids come pre-qualified (`openrouter/<vendor>/<model>`). Sources
   // the token-scrooge .env so an existing OPENROUTER_API_KEY authenticates with no extra wiring.
-  openrouter: { first: `opencode run{M} "$(cat {P})"`,
-              next:  `opencode run -c{M} "$(cat {P})"`, mflag: " -m ", env: join(homedir(), ".token-scrooge", ".env") },
+  openrouter: { first: `opencode run --dir {DIR}{M} "$(cat {P})"`,
+              next:  `opencode run --dir {DIR} -s {SID}{M} "$(cat {P})"`, mflag: " -m ", pinned: true, env: join(homedir(), ".token-scrooge", ".env") },
   claude:   { first: `claude{M} -p "$(cat {P})" --dangerously-skip-permissions`,
               next:  `claude -c{M} -p "$(cat {P})" --dangerously-skip-permissions`, mflag: " --model " },
   // DeepSeek Harness. Every turn is a FRESH session — headless has no resume yet — so the seat
@@ -272,7 +304,7 @@ if (!CLI[AGENT]) log(`'${AGENT}' is not a built-in seat — running it as an ope
 
 // RUNNER_RULES / RUNNER_KICKOFF env overrides: the runner is also the substrate for non-crew
 // always-on seats (the fleet DUTY agent, bin/duty.mjs) whose doctrine is not "work your card".
-const RULES = process.env.RUNNER_RULES || `Rules: you are ${SESSION} on the trantor crew. Before starting a card, query the board for related PAST cards and lessons (relay_board — 1900+ cards of tribal knowledge; prior work may already answer half of it). Work your assigned file(s), report on the bus (relay_send, <280 chars), move your Kanban card as you go with a NOTE saying what you did (doing -> testing -> done; in 'testing' run YOUR OWN test file — never the full npm test, suites collide across seats — plus \`node bin/slop-gate.mjs\` when the repo has one: it lints ONLY your changed files against the anti-slop rules, and a card must not reach done with slop-gate failing; use 'failed' + a report if anything breaks). If you need something from another session, message THAT SESSION (relay_peers to find its id, relay_send to reach it) — never ask the human to pass it along; carrying messages between agents is the job this bus exists to remove. When your work for THIS message is finished, END YOUR TURN — do NOT park, do NOT loop relay_wait; the runner waits for you and will wake you with the next message.`;
+const RULES = process.env.RUNNER_RULES || `Rules: you are ${SESSION} on the trantor crew. Before starting a card, read YOUR card: relay_board with card:<id> (the card, its deps, its notes, and the last five done cards whose title shares a word); never the whole board. Work your assigned file(s), report on the bus (relay_send, <280 chars), move your Kanban card as you go with a NOTE saying what you did (doing -> testing -> done; in 'testing' run YOUR OWN test file — never the full npm test, suites collide across seats — plus \`node bin/slop-gate.mjs\` when the repo has one: it lints ONLY your changed files against the anti-slop rules, and a card must not reach done with slop-gate failing; use 'failed' + a report if anything breaks). If you need something from another session, message THAT SESSION (relay_peers to find its id, relay_send to reach it) — never ask the human to pass it along; carrying messages between agents is the job this bus exists to remove. When your work for THIS message is finished, END YOUR TURN — do NOT park, do NOT loop relay_wait; the runner waits for you and will wake you with the next message. Path discipline: build/test from your worktree root ${TURN_DIR} with absolute paths or --manifest-path/--prefix instead of cd-ing into subdirs, and put anything that must land outside the repo under ${TURN_DIR}/.agent-bus-out/ (gitignored) — never ~/.agent-bus.`;
 
 // ---- the pulse (Scape's Lloyd/Argus loop, Trantor-shaped) --------------------
 // A message-driven seat is DEAF between messages. An orchestrator seat with a mission needs a
@@ -353,9 +385,9 @@ function classify(exit) {
   return reason;
 }
 
-async function reportFailure(exit, trigger, undelivered = 0) {
+async function reportFailure(exit, trigger, undelivered = 0, reasonOverride = "") {
   consecFails++;
-  const reason = classify(exit);
+  const reason = reasonOverride || 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, kind: "agent" }).catch(() => {});
@@ -394,6 +426,41 @@ async function reportFailure(exit, trigger, undelivered = 0) {
   }
   cmuxStatus(down ? "down" : "error", "#ef6a6a", "alert", { alert: true, priority: 90 }); herdrAgent("blocked"); cmuxLog(`turn failed: ${reason} (exit ${exit})`, "error");
   log(`\x1b[31mreported failure to bus: ${reason} (exit ${exit})\x1b[0m`);
+  return reason;
+}
+
+// ---- a dead seat is not retried (#6134) -------------------------------------------------------
+// The redelivery ladder assumes the next attempt might work. Against a spent plan or a rejected
+// key it never will, and the cost is real: codex burned 60 turns on 09-02 doing nothing but being
+// redelivered to. So those two reasons PARK — the queue is kept, the ladder stops, and the room is
+// told once, with the reset time when the CLI printed one. `trantor up` (a restart) resumes.
+let parkAnnounced = false;
+async function parkSeat(reason, undelivered) {
+  const resetAt = parseResetAt(lastErrText);
+  const when = resetAt ? new Date(resetAt).toLocaleString() : "";
+  if (!parkAnnounced) {
+    parkAnnounced = true;
+    const text = redactKeys(`⛔ ${SESSION} PARKED (${reason}) — holding ${undelivered} message(s), redelivery stopped ${when ? `until ${when}` : `until \`trantor up ${AGENT}\``}`);
+    await api("/send", { from: SESSION, to: "all", text, project: PROJ, kind: "status" }).catch(() => {});
+    const orch = `${hostId()}:${PROJ}`;
+    if (orch !== SESSION) await api("/send", { from: SESSION, to: orch, text, project: PROJ, kind: "alert" }).catch(() => {});
+  }
+  log(`\x1b[31mparked (${reason})${when ? ` — retrying after ${when}` : " — no reset time in the output; waiting for a restart"}\x1b[0m`);
+  // No reset time means no timer can clear it: hold until the operator restarts the seat.
+  return resetAt || Number.MAX_SAFE_INTEGER;
+}
+
+// The seat's own balance rows, for the #6131 read: a stalled turn that printed nothing on a seat
+// whose plan is spent is exhaustion, not a crash. Bounded and best-effort — a slow provider API
+// must never hold up the failure path, and an unreachable one just leaves the reason as it was.
+async function balanceRows() {
+  try {
+    const { fetchBalances } = await import("../lib/balances.mjs");
+    return await Promise.race([
+      fetchBalances(process.env, { only: [AGENT] }),
+      new Promise((r) => setTimeout(() => r([]), 4000)),
+    ]);
+  } catch { return []; }
 }
 
 // ---- activity truth (#5965): the RUNNER is the source for this seat ----------------
@@ -444,17 +511,33 @@ async function notifyAssigners(pairs, text) {
 async function reportHealthy() {
   if (consecFails === 0) return;        // already healthy — don't spam
   consecFails = 0;
-  // Recovery is a change too, so the next failure is news again.
+  // Recovery is a change too, so the next failure is news again — a park included.
   announced = "";
+  parkAnnounced = false;
   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");
 }
 
+// ---- the time box (#6134) --------------------------------------------------------------------
+// A turn with no ceiling is how a seat spends an afternoon on one card: the 09-02 baseline was 151
+// turns and ~16 agentic hours across the fleet. TRANTOR_TURN_MAX_MS ends the CLI's process group
+// at the box and runs ONE follow-up turn in the SAME session — "commit what is done, move the
+// card, report in one line" — so a cut turn lands its work instead of losing it.
+const TURN_MAX_MS = Math.max(0, Number(process.env.TRANTOR_TURN_MAX_MS || 20 * 60 * 1000));
+const TIME_BOX_PROMPT = "your previous turn was cut at the time box; commit what is done, move the card with a note, report in one line";
+let inFollowUp = false;
+// The card the CURRENT CLI session belongs to (#6134). 0 = the kickoff session, which belongs to
+// no card, so the first contract that names one starts a session of its own.
+let sessionCard = 0;
+
 let sid = "";
 async function runTurn(prompt, isFirst, trigger = "kickoff") {
   TURN++; banner(trigger);
   const t0 = Date.now();
+  // A fresh session must not resume the old one's id: `first` is chosen by isFirst OR a missing
+  // sid, so a stale sid would quietly resume the session this turn exists to leave behind.
+  if (isFirst) sid = "";
   // #5965 — TURN START. The hub peer row is where the app reads activity from, and the runner is
   // the only one who knows a turn is starting, so say so before the CLI spawn (awaited: the spawn
   // below blocks the loop, an unawaited fetch would not leave the machine until the turn ended).
@@ -466,9 +549,11 @@ async function runTurn(prompt, isFirst, trigger = "kickoff") {
   // exit-0 turn with real output must never be re-labelled "auth" by the #5405 escalation — the
   // qwen specimen committed aa3c340 while its captured stream still tripped the auth regex.
   const headBefore = gitOut(["rev-parse", "HEAD"], TURN_DIR);
-  let cmd = (isFirst || (cli.sid && !sid)) ? cli.first : cli.next;
+  // #6154: a pinned seat with no sid yet resumes as FRESH — the guard below fails open, because
+  // a resume without an id must fall back to a new session, never to `next`'s bare resume shape.
+  let cmd = (isFirst || ((cli.sid || cli.pinned) && !sid)) ? cli.first : cli.next;
   const mfrag = MODEL && cli.mflag ? `${cli.mflag}${MODEL}` : "";
-  cmd = cmd.replaceAll("{M}", mfrag).replaceAll("{P}", pf).replaceAll("{SID}", sid);
+  cmd = cmd.replaceAll("{M}", mfrag).replaceAll("{P}", pf).replaceAll("{SID}", sid).replaceAll("{DIR}", TURN_DIR);
   // PRECEDENCE, and it is easy to get backwards — this is the second time.
   // Each file is PREPENDED, so the one prepended LAST runs FIRST, and in shell the file that runs
   // LAST wins. To make ~/.agent-bus/.env (the CREW layer) win it must be prepended FIRST, i.e.
@@ -504,6 +589,10 @@ async function runTurn(prompt, isFirst, trigger = "kickoff") {
   // the window with no ERRF growth earns ONE direct stall report to the foreman, never a kill.
   const WD_MS = Number(process.env.TRANTOR_TURN_WATCHDOG_MS || 15 * 60 * 1000);
   const STAMPF = join(homedir(), ".agent-bus", `turnstamp-${AGENT}-${PROJ}.json`);
+  // Written by the shell's own time box (below) and read back here — the only honest signal that
+  // the turn was CUT rather than that the CLI failed on its own. Cleared before every turn.
+  const CUTF = join(homedir(), ".agent-bus", `turncut-${AGENT}-${PROJ}`);
+  try { unlinkSync(CUTF); } catch {}
   try {
     writeFileSync(STAMPF, JSON.stringify({ turn: TURN, startedAt: Date.now() }));
     const wd = spawn(process.execPath, [join(import.meta.dirname, "turn-watchdog.mjs"), STAMPF, ERRF, String(WD_MS), SESSION, PROJ, HUB],
@@ -513,9 +602,47 @@ async function runTurn(prompt, isFirst, trigger = "kickoff") {
   // Preserve the CLI's exit before waiting for the stderr process substitution. Without the
   // explicit wait, a short failing CLI can return while its error is still in the scrub pipe;
   // under load the classifier then reads an empty ERRF and reports the wrong failure reason.
-  const shell = `set -o pipefail; { ${inner} ; } 2> >(${SCRUB} --tee2 ${ERRF}); turn_exit=$?; wait; exit $turn_exit`;
+  // #6134-followup: the time box has to fire from INSIDE the shell, while the process tree is
+  // still standing. Killing the turn's process group from node missed a grandchild — codex runs
+  // its own commands via setsid, so `sleep 400` sat in a different group and survived
+  // process.kill(-pid). Worse, by the time node's timeout has killed bash the survivors have been
+  // reparented to init, so there is no tree left to walk and nothing to sweep.
+  //
+  // So bash boxes itself: at the deadline it walks its own descendants and kills them bottom-up.
+  // setsid changes a process's group and session but NEVER its parent, so `pgrep -P` recursion
+  // reaches exactly the children that a group signal cannot. Children first, then the parent, so
+  // nothing gets reparented mid-sweep and escapes the walk.
+  //
+  // The marker file is how node learns the turn was cut rather than merely failing: an exit status
+  // alone cannot tell "killed at the box" from "the CLI died on its own".
+  const sweep = `sweep() { local p; for p in $(pgrep -P $1 2>/dev/null); do sweep $p; done; kill -KILL $1 2>/dev/null; }`;
+  const box = TURN_MAX_MS ? `
+${sweep}
+( sleep ${Math.ceil(TURN_MAX_MS / 1000)}
+  kill -0 $job 2>/dev/null || exit 0
+  : > ${CUTF}
+  sweep $job
+) & boxpid=$!` : "boxpid=";
+  const shell = `set -o pipefail
+{ ${inner} ; } 2> >(${SCRUB} --tee2 ${ERRF}) &
+job=$!${box}
+wait $job; turn_exit=$?
+[ -n "$boxpid" ] && kill $boxpid 2>/dev/null
+wait
+exit $turn_exit`;
   const r = spawnSync("/bin/bash", ["-c", shell], {
-    cwd: TURN_DIR, encoding: "utf8", stdio: cli.sid ? ["ignore", "pipe", "inherit"] : "inherit",
+    // detached: bash leads its OWN process group, so the time box can kill the CLI and everything
+    // it spawned with one signal instead of orphaning the model process behind a dead shell.
+    // stdin is /dev/null for every seat (it already was for codex/kimi/dsh via `< /dev/null`):
+    // a detached group is a BACKGROUND group, and a background process that reads the terminal
+    // takes SIGTTIN and stops forever. Nothing here runs interactively — every CLI is in -p /
+    // exec / run mode — so closing stdin is what makes the group safe.
+    detached: true,
+    // A BACKSTOP only, deliberately later than the shell's own box: if bash itself wedges, node
+    // still ends the turn. When the in-shell box works — the normal path — this never fires, which
+    // is the point: the shell kills while the tree is still walkable, node cannot.
+    ...(TURN_MAX_MS ? { timeout: TURN_MAX_MS + 30000, killSignal: "SIGKILL" } : {}),
+    cwd: TURN_DIR, encoding: "utf8", stdio: cli.sid ? ["ignore", "pipe", "inherit"] : ["ignore", "inherit", "inherit"],
     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.
       //
@@ -531,6 +658,16 @@ async function runTurn(prompt, isFirst, trigger = "kickoff") {
     maxBuffer: 16 * 1024 * 1024,
   });
   try { unlinkSync(STAMPF); } catch {}   // turn over — disarm the watchdog
+  // The shell's box leaves the marker; the backstop leaves an ETIMEDOUT. Either way the turn was
+  // cut, not merely failed.
+  const boxed = existsSync(CUTF);
+  const cut = !!TURN_MAX_MS && (boxed || r.error?.code === "ETIMEDOUT");
+  if (cut) {
+    // Belt and braces after the shell's descendant sweep: anything still sharing the turn's group.
+    if (r.pid) { try { process.kill(-r.pid, "SIGKILL"); } catch {} }
+    try { unlinkSync(CUTF); } catch {}
+    log(`\x1b[33mturn cut at the ${Math.round(TURN_MAX_MS / 1000)}s time box — CLI and every descendant ended${boxed ? "" : " (node backstop: bash itself was wedged)"}\x1b[0m`);
+  }
   // #5869: scrub AT REST, synchronously, before anything reads the file back. The explicit shell
   // wait above drains the live stderr scrubber first; this pass is defense in depth for redaction.
   try { writeFileSync(ERRF, redactKeys(readFileSync(ERRF, "utf8"))); } catch {}
@@ -542,6 +679,10 @@ async function runTurn(prompt, isFirst, trigger = "kickoff") {
   try { ownOut = stripPromptEcho(readFileSync(ERRF, "utf8"), readPromptText(pf)); } catch { ownOut = ""; }
   lastErrText = ownOut.slice(-4000);
   if (cli.sid && r.stdout) { const m = r.stdout.match(cli.sid); if (m) sid = m[1]; }
+  // #6154: the opencode family prints no sid on stdout — the id comes from opencode's own DB,
+  // keyed by the worktree the session was created in. Fail-open: nothing found leaves sid empty,
+  // and the next turn starts fresh rather than resuming whatever other project ran last.
+  if (cli.pinned) { const found = ocSid(TURN_DIR); if (found) sid = found; }
   const realExit = r.status;
   // A zero exit is NOT proof the turn ran: opencode prints "401 Unauthorized" / "Invalid API key"
   // and exits 0, so a bare 0 made the runner ack "✅ done", clear the pending queue and heartbeat
@@ -578,12 +719,23 @@ async function runTurn(prompt, isFirst, trigger = "kickoff") {
   // #5868: the verdict rides the telemetry row so a classification survives the pane scrolling
   // away — the same "classified X because Y" shape the runner logs, in the seat's jsonl forever.
   const verdict = verdictFor(realExit, effExit, lastEmptyOutput, ownOut);
-  telemetry({ ts: Date.now(), agent: AGENT, project: PROJ, turn: TURN, trigger, model: MODEL || "cli-default", duration_ms: Date.now() - t0, exit: realExit, effExit, authFailed: effExit !== realExit, emptyOutput: lastEmptyOutput, verdict });
+  // #6134: what the turn COST, from the CLI's own usage line. Zero means this CLI printed none —
+  // never that the turn was free. `trantor seat-why` totals these into today's spend per seat.
+  const tokens = parseTurnTokens(ownOut);
+  telemetry({ ts: Date.now(), agent: AGENT, project: PROJ, turn: TURN, trigger, model: MODEL || "cli-default", duration_ms: Date.now() - t0, exit: realExit, effExit, authFailed: effExit !== realExit, emptyOutput: lastEmptyOutput, verdict, ...(tokens ? { tokens } : {}), ...(cut ? { cut: true } : {}) });
   log(`turn ended (exit ${realExit}${effExit !== realExit ? ` → effective ${effExit} (${lastEmptyOutput ? "empty-output" : "auth"})` : ""}, ${((Date.now() - t0) / 1000).toFixed(0)}s)`);
   if (realExit === 0 && effExit === 0) { cmuxStatus("idle", "#8a94a6", "robot"); herdrAgent("idle"); }   // finished this turn, waiting for the next
   // #5965 — TURN END. A clean exit means the seat is idle again; say so right away so the app stops
   // pulsing it even before the next /poll heartbeat. Failure keeps reportFailure's down/errored.
   if (realExit === 0 && effExit === 0) await registerStatus("idle");
+  // The follow-up rides the SAME session, so the model still has the turn it was cut out of and
+  // only has to land it. Exactly one — a follow-up that runs long is itself boxed, and boxing a
+  // boxed turn forever is the loop this card exists to end.
+  if (cut && !inFollowUp) {
+    inFollowUp = true;
+    try { return await runTurn(TIME_BOX_PROMPT, false, "time-box follow-up"); }
+    finally { inFollowUp = false; }
+  }
   return effExit;
 }
 
@@ -655,8 +807,19 @@ function isRunnerSession(session) {
 
 function shouldWake(message) {
   if (isReceipt(message) || isStatusBroadcast(message)) return false;
+  // #6134: the SENDER decides. `wake:false` says "this is context, not a contract" — it batches
+  // into the next turn's prompt like a broadcast and never buys a CLI session of its own.
+  if (message?.wake === false) return false;
   if (message?.to === SESSION) {
     if (message?.kind === "status") return false;
+    // The safety net for every sender that never set the flag: a direct message carrying no card
+    // and no instruction is an ack, an FYI or a queue note. Those made up most of the 09-02 burn.
+    // Two exemptions, both because the shape net reads WORDS and these carry their meaning in
+    // their type: a typed alert (a failure escalation, a bounce), and an OVERSEER warning that got
+    // this far — the one chatty overseer kind is already batched by name upstream, so anything
+    // still here is file-conflict or linked-activity, which #5760 deliberately kept waking.
+    const typed = message?.kind === "alert" || /^🤝 OVERSEER /.test(String(message?.text || ""));
+    if (!typed && !isContract(message) && !carriesWork(message?.text)) return false;
     return !isRunnerSession(message?.from) || isContract(message);
   }
   return message?.to === "all"
@@ -764,7 +927,10 @@ function askedExcerpt(message) {
     const rest = msgs.filter(m => !fyi.includes(m));
     const direct = rest.filter(m => m.to === SESSION && shouldWake(m));
     const mentions = rest.filter(m => m.to === "all" && shouldWake(m));
-    const bcast = [...rest.filter(m => m.to === "all" && !mentions.includes(m)), ...fyi];
+    // Everything that did not earn a turn still becomes CONTEXT — including a DIRECT message that
+    // batched (wake:false, or an ack by shape). Dropping those would trade a token problem for a
+    // deafness problem: the seat would never learn what it was told (#6134).
+    const bcast = [...rest.filter(m => !direct.includes(m) && !mentions.includes(m)), ...fyi];
     pendingBcast.push(...bcast);                      // wake-policy: plain broadcasts batch, they don't wake
     const wake = [...direct, ...mentions];
     if (!wake.length) { if (bcast.length) { savePending(pendingWake, pendingBcast); log(`${bcast.length} broadcast(s) batched (no wake) — ${pendingBcast.length} pending`); } continue; }
@@ -810,22 +976,43 @@ function askedExcerpt(message) {
     for (const m of wake) if (m.from && !assigners.some(a => a.from === m.from)) assigners.push({ from: m.from, id: m.id });
     const asked = askedExcerpt(wake[0]);
     const tStart = Date.now();
+    // #6134: ONE SESSION PER CARD. A seat that resumes forever carries every card it ever worked
+    // into every later turn — qwen's 85.7M tokens were 96.7% cached, i.e. replayed history. The
+    // card that moved this wake decides: a different one starts a fresh CLI session, and the seat
+    // is told so, because a fresh session remembers nothing and must be sent to its card.
+    const card = wake.map(m => cardRef(m.text)).find(Boolean) || 0;
+    const fresh = card > 0 && card !== sessionCard;
+    if (card) sessionCard = card;
+    const freshText = fresh
+      ? `\n(FRESH SESSION for card #${card} — you are not the session that worked earlier cards and you remember none of them. Read your card first: relay_board with card:${card}.)\n`
+      : "";
     const prompt = composedTurn({
-      wakeText, ctxText, againText,
+      wakeText, ctxText, againText: againText + freshText,
       tailText: "\nAct on what's addressed to you, then end your turn.\n\n",
       rulesText: RULES, lessons,
     });
-    const ec = await runTurn(prompt, false, deliveryFails ? `${trigger} (redelivery)` : trigger);
+    const ec = await runTurn(prompt, fresh, deliveryFails ? `${trigger} (redelivery)` : trigger);
     const secs = Math.round((Date.now() - tStart) / 1000);
     if (ec) {
       deliveryFails++;
+      // #6131: a silent turn on a seat whose plan reads spent is exhaustion wearing a crash's
+      // clothes. Only that one reason is ever re-read, and only from the seat's own balance rows.
+      let reason = classify(ec);
+      if (reason === "empty-output") reason = reasonWithBalances(reason, await balanceRows());
+      savePending(pendingWake, pendingBcast);
+      await reportFailure(ec, "message", pendingWake.length, reason);
+      if (PARKING_REASONS.has(reason)) {
+        retryAt = await parkSeat(reason, pendingWake.length);
+        await notifyAssigners(assigners,
+          `⛔ your contract is PARKED on ${SESSION} (${reason}) — not retrying · asked: "${asked}"`);
+        lastTurnAt = Date.now();
+        return;
+      }
       const wait = RETRY_MS[Math.min(deliveryFails - 1, RETRY_MS.length - 1)];
       retryAt = Date.now() + wait;
-      savePending(pendingWake, pendingBcast);
-      await reportFailure(ec, "message", pendingWake.length);
       // The room hears the broadcast above; the one who is actually blocked hears it directly.
       await notifyAssigners(assigners,
-        `⚠️ your contract FAILED on ${SESSION} (exit ${ec}, ${classify(ec)}) · retrying in ${Math.round(wait / 1000)}s · asked: "${asked}"`);
+        `⚠️ your contract FAILED on ${SESSION} (exit ${ec}, ${reason}) · retrying in ${Math.round(wait / 1000)}s · asked: "${asked}"`);
       log(`\x1b[31m${pendingWake.length} message(s) still UNDELIVERED — next attempt in ${Math.round(wait / 1000)}s\x1b[0m`);
     } else {
       pendingWake = []; pendingBcast = []; deliveryFails = 0; retryAt = 0;

package/bin/crew.sh

@@ -792,12 +792,16 @@ resolve_spec() {
   if [ -n "$FIELD" ]; then
     case "$FIELD" in
       */*) MODEL="$FIELD" ;;
-      *)   MODEL="$(resolve_model "$AGENT" "$FIELD" "$TASK" "$DIFF")" || {
+      # A NATIVE CLI takes its model id verbatim: `claude:opus`, `codex:o3`, `kimi:k2`. The router
+      # only knows opencode providers, so it refused `claude:opus` outright (2026-09-03) and the
+      # seat silently ran the CLI default, which for claude was the most expensive model on the plan.
+      *)   if [[ "$AGENT" =~ ^(claude|codex|kimi|gemini)$ ]]; then MODEL="$FIELD"; echo "  → $AGENT: model $MODEL (native pin)"; else
+           MODEL="$(resolve_model "$AGENT" "$FIELD" "$TASK" "$DIFF")" || {
              echo "[crew] ✗ skipping seat '$AGENT' — model resolution failed for $FIELD ($TASK/$DIFF); remaining seats still launch" >&2
              SKIPPED_SEATS+=("$AGENT: model resolution failed for $FIELD ($TASK/$DIFF)")
              return 1
            }
-           echo "  → $AGENT: live model $MODEL ($FIELD · $TASK/$DIFF)" ;;
+           echo "  → $AGENT: live model $MODEL ($FIELD · $TASK/$DIFF)"; fi ;;
     esac
   fi
 }

package/bin/seat-why.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // trantor seat-why <agent> [--json] — explain why a crew seat is (not) working, straight from
 // local ~/.agent-bus evidence. No hub needed; works even when the whole fleet is down.
-import { seatWhy } from "../lib/seat-why.mjs";
+import { seatWhy, fmtSpend } from "../lib/seat-why.mjs";
 import { resolveProject } from "../lib/project.mjs";
 
 const args = process.argv.slice(2);
@@ -23,5 +23,6 @@ if (asJson) {
 } else {
   console.log(`seat ${agent}:${project} -> ${out.state}`);
   console.log(`why:    ${out.why}`);
+  console.log(`today:  ${fmtSpend(out.today)}`);
   console.log(`advice: ${out.advice}`);
 }

package/hub.mjs

@@ -10,7 +10,7 @@ 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 { DEFAULT_ORG, IDENTITY_KINDS } from "./lib/store-contract.mjs";
 import { assertNoSecrets } from "./lib/scrub.mjs";
 import { createPersistHealth } from "./lib/persist-health.mjs";
 
@@ -220,7 +220,12 @@ function normalizeState(loaded = {}) {
     // migrate old numeric form
     s.peers[session] = typeof v === "number"
       ? { lastSeen: v, status: "", project: "" }
-      : { lastSeen: v.lastSeen || 0, status: v.status || "", project: v.project || "", pubkey: v.pubkey || "", identity: v.identity || null, authWarning: v.authWarning || "", hookVersion: v.hookVersion || "", deliveredUpTo: v.deliveredUpTo || v.delivered_up_to || 0, _on: v._on === true || v.online === true };
+      // #6170: `kind` must be carried across the load. This normalizer rebuilds every peer from an
+      // explicit field list, so a field missing here is dropped no matter how faithfully the store
+      // returned it — which is exactly what happened: the column was added, Postgres held the right
+      // values, and the kinds still came back empty on the first live restart. llm/model stay
+      // out on purpose: those ARE in-memory presence, re-supplied by the next heartbeat.
+      : { lastSeen: v.lastSeen || 0, status: v.status || "", project: v.project || "", pubkey: v.pubkey || "", identity: v.identity || null, authWarning: v.authWarning || "", hookVersion: v.hookVersion || "", kind: v.kind || "", deliveredUpTo: v.deliveredUpTo || v.delivered_up_to || 0, _on: v._on === true || v.online === true };
   }
   return s;
 }
@@ -1447,6 +1452,10 @@ const server = http.createServer(async (req, res) => {
       const raw = req._rawBody || "";
       const verified = verifyRequest({ headers: req.headers, method: req.method, path: authPath(u), body: raw });
       if (!verified.ok) return json(res, 401, { error: verified.reason || "bad signature" });
+      const requestedKind = String(b0.kind || "agent").slice(0, 40);
+      if (!IDENTITY_KINDS.includes(requestedKind)) {
+        return json(res, 400, { error: `kind must be one of: ${IDENTITY_KINDS.join(", ")}`, allowedKinds: IDENTITY_KINDS });
+      }
       const existing = findIdentity(verified.pubkey);
       if (existing) return json(res, 200, { ok: true, identity: publicView(existing), scopes: existing.scopes || [] });
       let enrolledBy = "";
@@ -1482,7 +1491,7 @@ const server = http.createServer(async (req, res) => {
       }
       const identity = {
         name: String(b0.name || "").slice(0, 120) || verified.pubkey.slice(0, 16),
-        kind: String(b0.kind || "agent").slice(0, 40),
+        kind: requestedKind,
         pubkey: verified.pubkey,
         createdAt: now(),
         enrolledBy,
@@ -1501,6 +1510,10 @@ const server = http.createServer(async (req, res) => {
       const az = authorize(auth, req.method, P, "*");
       if (!az.ok) return json(res, az.code || 403, { error: az.error || "forbidden" });
       const bi = await body(req);
+      const invitedKind = String(bi.kind || "agent").slice(0, 40);
+      if (!IDENTITY_KINDS.includes(invitedKind)) {
+        return json(res, 400, { error: `kind must be one of: ${IDENTITY_KINDS.join(", ")}`, allowedKinds: IDENTITY_KINDS });
+      }
       const scopes = (Array.isArray(bi.scopes) ? bi.scopes : []).map(cleanScope).filter(Boolean).slice(0, 20);
       if (!scopes.length) return json(res, 400, { error: "scopes required" });
       // Honour the requested TTL. A 60s FLOOR here silently inflated `ttlSec: 1` to a minute, so a
@@ -1508,7 +1521,7 @@ const server = http.createServer(async (req, res) => {
       // a live token straight through /enroll. Cap the ceiling, never the floor.
       const ttlSec = Math.min(Math.max(Number(bi.ttlSec) || 86400, 1), 30 * 86400);
       const token = randomBytes(24).toString("hex");
-      state.inviteTokens[token] = { scopes, expiresAt: now() + ttlSec * 1000, used: false,
+      state.inviteTokens[token] = { scopes, kind: invitedKind, expiresAt: now() + ttlSec * 1000, used: false,
         createdBy: auth.identity?.pubkey || "", createdAt: now() };
       dirty = true;
       return json(res, 200, { ok: true, token, scopes, expiresAt: state.inviteTokens[token].expiresAt });
@@ -2786,7 +2799,11 @@ const server = http.createServer(async (req, res) => {
       // side, which is how an orchestrator ends up waiting forever on a dead peer.
       const re = Number.isFinite(Number(b.re)) && Number(b.re) > 0 ? Number(b.re) : 0;
       const kind = String(b.kind || "").slice(0, 40);
-      const msg = { id: ++state.seq, ts: now(), from: b.from || "anon", to: b.to || "all", text, project: String(b.project || fromProj || "").slice(0, 80), ...(re ? { re } : {}), ...(kind ? { kind } : {}) };
+      // `wake:false` is the SENDER saying this message is context, not a contract: the receiving
+      // runner batches it into that seat's next turn instead of spending a whole CLI session on
+      // it (#6134). Stored only when false — absent means wake, so every older client is unchanged.
+      const wake = b.wake === false ? { wake: false } : {};
+      const msg = { id: ++state.seq, ts: now(), from: b.from || "anon", to: b.to || "all", text, project: String(b.project || fromProj || "").slice(0, 80), ...(re ? { re } : {}), ...(kind ? { kind } : {}), ...wake };
       state.messages.push(msg); if (state.messages.length > 5000) state.messages.splice(0, 1000);
       dirty = true; pushToStreams(msg);               // <-- instant push to live watchers
       // Mirror onto the unified log. `refs` = the card ids this message cites (#3701), which is what

package/lib/enroll.mjs

@@ -45,9 +45,10 @@ export async function ensureEnrolled(hubUrl, identity, project, { timeoutMs = 40
   if (!owner?.privkey) return { ok: false, reason: "no-owner-key" };
 
   try {
+    const identityKind = kind || identity.kind || "agent";
     const inv = await sfetch(`${hubUrl}/invite`, {
       method: "POST", headers: { "content-type": "application/json" },
-      body: JSON.stringify({ scopes: [{ project, role: "write" }], ttlSec: 300 }),
+      body: JSON.stringify({ scopes: [{ project, role: "write" }], ttlSec: 300, kind: identityKind }),
       signal: AbortSignal.timeout(timeoutMs),
     }, owner);
     if (!inv.ok) return { ok: false, reason: `invite-${inv.status}` };
@@ -55,7 +56,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: kind || identity.kind || "agent", token }),
+      body: JSON.stringify({ name: identity.name, kind: identityKind, token }),
       signal: AbortSignal.timeout(timeoutMs),
     }, identity);
     return en.ok ? { ok: true, reason: "enrolled" } : { ok: false, reason: `enroll-${en.status}` };

package/lib/seat-why.mjs

@@ -61,6 +61,32 @@ const rel = (ts) => {
   return `${Math.round(s / 3600)}h ago`;
 };
 
+// What this seat has SPENT today (#6134). The turn count is the number that mattered on 09-02:
+// 151 turns and ~16 agentic hours across the fleet, most of it redelivery and coordination noise.
+// Tokens come from each CLI's own usage line (the runner parses it onto the turn's row); CLIs that
+// print none contribute 0, which is why the count is reported alongside — "3 of 7 turns reported".
+export function todaySpend(telemetry, now = Date.now()) {
+  const midnight = new Date(now); midnight.setHours(0, 0, 0, 0);
+  const rows = telemetry.filter(r => typeof r.turn === "number" && r.ts >= midnight.getTime());
+  const withTokens = rows.filter(r => Number(r.tokens) > 0);
+  return {
+    turns: rows.length,
+    minutes: Math.round(rows.reduce((a, r) => a + (Number(r.duration_ms) || 0), 0) / 60000),
+    tokens: withTokens.reduce((a, r) => a + Number(r.tokens), 0),
+    reported: withTokens.length,
+    cut: rows.filter(r => r.cut).length,
+  };
+}
+
+export function fmtSpend(s) {
+  const bits = [`${s.turns} turn${s.turns === 1 ? "" : "s"}`, `${s.minutes}m`];
+  bits.push(s.reported
+    ? `${s.tokens.toLocaleString("en-US")} tokens (${s.reported}/${s.turns} turns reported)`
+    : "tokens not reported by this CLI");
+  if (s.cut) bits.push(`${s.cut} cut at the time box`);
+  return bits.join(" · ");
+}
+
 export function seatWhy(project, agent, opts = {}) {
   const dir = opts.dir || busDir();
   const errText = readF(join(dir, `err-${agent}-${project}.txt`));
@@ -117,7 +143,7 @@ export function seatWhy(project, agent, opts = {}) {
     }
   }
 
-  return { state, why, advice };
+  return { state, why, advice, today: todaySpend(telemetry, opts.now) };
 }
 
 export { fmt, rel };

package/lib/store-contract.mjs

@@ -20,6 +20,9 @@
 // an empty schema is free; adding it after 1,542 cards have migrated is surgery on live data.
 // ---------------------------------------------------------------------------------------------
 export const SCHEMA_VERSION = 1;
+export const IDENTITY_KINDS = Object.freeze(["human", "agent", "tool"]);
+
+const IDENTITY_KINDS_SQL = IDENTITY_KINDS.map(kind => `'${kind}'`).join(",");
 
 export const SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS orgs (
@@ -41,13 +44,19 @@ CREATE TABLE IF NOT EXISTS identities (
   pubkey      TEXT PRIMARY KEY,
   org_id      TEXT REFERENCES orgs(id) ON DELETE CASCADE,
   name        TEXT NOT NULL,
-  kind        TEXT NOT NULL CHECK (kind IN ('human','agent')),
+  kind        TEXT NOT NULL CHECK (kind IN (${IDENTITY_KINDS_SQL})),
   scopes      JSONB NOT NULL DEFAULT '{}'::jsonb,   -- { "<project>": "owner"|"write"|"read" }
   enrolled_by TEXT,
   created_at  BIGINT NOT NULL,
   revoked_at  BIGINT                                 -- set, never deleted: revocation is audit
 );
 
+-- 2026-09-03: installs created under CHECK (kind IN ('human','agent')) widen on boot; the genesis
+-- identity enrols as 'tool' (#6068) and the narrower check poisoned every persist delta for 13 min.
+ALTER TABLE identities DROP CONSTRAINT IF EXISTS identities_kind_check;
+ALTER TABLE identities ADD CONSTRAINT identities_kind_check CHECK (kind IN (${IDENTITY_KINDS_SQL}));
+
+
 -- THE LOG. Append-only, never updated, never deleted except by retention. Everything else derives.
 CREATE TABLE IF NOT EXISTS events (
   id         BIGSERIAL PRIMARY KEY,
@@ -120,8 +129,19 @@ CREATE TABLE IF NOT EXISTS peers (
   last_seen       BIGINT,
   online          BOOLEAN DEFAULT FALSE,
   delivered_up_to BIGINT DEFAULT 0,
+  kind            TEXT,                  -- #6170: WHAT this session is — 'agent' (crew seat),
+                                         -- 'orch', 'genesis', 'tool'. The overseer's crew
+                                         -- exemption reads it (#6075/#6148), so when a restart
+                                         -- forgot it the hub warned about its own crew.
   PRIMARY KEY (org_id, session)
 );
+-- additive migration for hubs whose peers table predates the kind column (#6170)
+ALTER TABLE peers ADD COLUMN IF NOT EXISTS kind TEXT;
+-- DELIBERATELY no CHECK on peers.kind, unlike identities.kind above. The hub accepts whatever a
+-- client stamps (hub.mjs /register takes any string up to 40 chars) and the vocabulary grows with
+-- the product — 'genesis' arrived in #6068, 'orch' in #6075. #6169 is the cost of getting this
+-- wrong in the other direction: a CHECK narrower than the values in flight poisoned every persist
+-- delta for 13 minutes. A column that stores what it is given cannot fail that way.
 
 -- The fields that currently ride in-memory and are LOST on restart. This is the debt being paid.
 CREATE TABLE IF NOT EXISTS kv (

package/lib/store-pg.mjs

@@ -117,6 +117,7 @@ function peerFromRow(row) {
     lastSeen: row.last_seen == null ? 0 : Number(row.last_seen),
     online: !!row.online,
     deliveredUpTo: row.delivered_up_to == null ? 0 : Number(row.delivered_up_to),
+    kind: row.kind || "",   // #6170: survives the restart that used to forget who was crew
   };
 }
 
@@ -332,8 +333,8 @@ export class PgStore {
   async touchPeer(orgId, session, patch = {}) {
     if (!session || session === "all") return;
     await this.pool.query(
-      `INSERT INTO peers(session, org_id, pubkey, project, status, hook_version, last_seen, online, delivered_up_to)
-       VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9)
+      `INSERT INTO peers(session, org_id, pubkey, project, status, hook_version, last_seen, online, delivered_up_to, kind)
+       VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)
        ON CONFLICT(org_id, session) DO UPDATE SET
          pubkey=COALESCE(EXCLUDED.pubkey, peers.pubkey),
          project=COALESCE(NULLIF(EXCLUDED.project,''), peers.project),
@@ -341,11 +342,17 @@ export class PgStore {
          hook_version=COALESCE(NULLIF(EXCLUDED.hook_version,''), peers.hook_version),
          last_seen=EXCLUDED.last_seen,
          online=EXCLUDED.online,
-         delivered_up_to=GREATEST(peers.delivered_up_to, EXCLUDED.delivered_up_to)`,
+         delivered_up_to=GREATEST(peers.delivered_up_to, EXCLUDED.delivered_up_to),
+         -- #6170: a KINDLESS beat must never demote a known peer. Most heartbeats carry no kind
+         -- (the MCP one only learns it under TRANTOR_ORCH), and plain last_seen refreshes are the
+         -- majority of writes here — overwriting on every one is how the orchestrator kept
+         -- reverting to a nameless agent between registrations.
+         kind=COALESCE(NULLIF(EXCLUDED.kind,''), peers.kind)`,
       [
         session, orgId, patch.pubkey || null, patch.project || "", patch.status ?? null,
         patch.hookVersion || patch.hook_version || "", ms(patch.lastSeen || patch.last_seen),
         patch.online ?? true, Number(patch.deliveredUpTo || patch.delivered_up_to || 0),
+        patch.kind || "",
       ],
     );
   }
@@ -474,11 +481,15 @@ export class PgStore {
       );
       for (const [session, p] of Object.entries(state.peers || {})) {
         await c.query(
-          `INSERT INTO peers(session, org_id, pubkey, project, status, hook_version, last_seen, online, delivered_up_to)
-           VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9)
+          `INSERT INTO peers(session, org_id, pubkey, project, status, hook_version, last_seen, online, delivered_up_to, kind)
+           VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)
            ON CONFLICT(org_id, session) DO UPDATE SET pubkey=EXCLUDED.pubkey, project=EXCLUDED.project, status=EXCLUDED.status,
-             hook_version=EXCLUDED.hook_version, last_seen=EXCLUDED.last_seen, online=EXCLUDED.online, delivered_up_to=GREATEST(peers.delivered_up_to, EXCLUDED.delivered_up_to)`,
-          [session, orgId, p.pubkey || "", p.project || "", p.status || "", p.hookVersion || "", Number(p.lastSeen || 0), p._on === true || p.online === true, Number(p.deliveredUpTo || 0)],
+             hook_version=EXCLUDED.hook_version, last_seen=EXCLUDED.last_seen, online=EXCLUDED.online, delivered_up_to=GREATEST(peers.delivered_up_to, EXCLUDED.delivered_up_to),
+             -- #6170: same non-demoting rule as touchPeer. A snapshot is written from MEMORY, and
+             -- memory is exactly where the kind was being lost, so a blank in the snapshot means
+             -- "not known right now", never "this peer is nothing".
+             kind=COALESCE(NULLIF(EXCLUDED.kind,''), peers.kind)`,
+          [session, orgId, p.pubkey || "", p.project || "", p.status || "", p.hookVersion || "", Number(p.lastSeen || 0), p._on === true || p.online === true, Number(p.deliveredUpTo || 0), p.kind || ""],
         );
       }
       await c.query(
@@ -598,11 +609,15 @@ export class PgStore {
       if (messages.deletes.length) await c.query("DELETE FROM messages WHERE org_id=$1 AND id = ANY($2::bigint[])", [orgId, messages.deletes]);
       for (const p of peers.upserts) {
         await c.query(
-          `INSERT INTO peers(session, org_id, pubkey, project, status, hook_version, last_seen, online, delivered_up_to)
-           VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9)
+          `INSERT INTO peers(session, org_id, pubkey, project, status, hook_version, last_seen, online, delivered_up_to, kind)
+           VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)
            ON CONFLICT(org_id, session) DO UPDATE SET pubkey=EXCLUDED.pubkey, project=EXCLUDED.project, status=EXCLUDED.status,
-             hook_version=EXCLUDED.hook_version, last_seen=EXCLUDED.last_seen, online=EXCLUDED.online, delivered_up_to=GREATEST(peers.delivered_up_to, EXCLUDED.delivered_up_to)`,
-          [p.session, orgId, p.pubkey || "", p.project || "", p.status || "", p.hookVersion || "", Number(p.lastSeen || 0), p._on === true || p.online === true, Number(p.deliveredUpTo || 0)],
+             hook_version=EXCLUDED.hook_version, last_seen=EXCLUDED.last_seen, online=EXCLUDED.online, delivered_up_to=GREATEST(peers.delivered_up_to, EXCLUDED.delivered_up_to),
+             -- #6170: THIS is the path a running hub actually persists through — saveDelta on the
+             -- persist tick, not touchPeer or saveSnapshot. Adding the column to the other two and
+             -- not this one is why the first live restart still came back with empty kinds.
+             kind=COALESCE(NULLIF(EXCLUDED.kind,''), peers.kind)`,
+          [p.session, orgId, p.pubkey || "", p.project || "", p.status || "", p.hookVersion || "", Number(p.lastSeen || 0), p._on === true || p.online === true, Number(p.deliveredUpTo || 0), p.kind || ""],
         );
       }
       if (peers.deletes.length) await c.query("DELETE FROM peers WHERE org_id=$1 AND session = ANY($2::text[])", [orgId, peers.deletes]);

package/lib/turn-policy.mjs

@@ -0,0 +1,114 @@
+// Per-turn policy for a crew seat (#6134) — the rules that decide whether a bus message is worth
+// a CLI turn at all, which card a session belongs to, what a turn cost, and when an exhausted seat
+// is allowed to be woken again.
+//
+// These live here rather than in bin/crew-runner.mjs because the runner is a self-executing script
+// (top-level await, spawns turns on import), so nothing in it can be unit-tested directly. The
+// drill still drives the REAL runner end to end; these functions are what it can assert on cheaply.
+//
+// The burn this exists to stop: on 09-02 the fleet spent 151 turns and ~16 agentic hours, codex
+// alone taking 60 turns of pure redelivery, and qwen 85.7M tokens at 96.7% cached — i.e. the same
+// history replayed over and over. Every rule below removes one class of turn that never had work
+// in it.
+
+/// The first card a message cites. A turn belongs to exactly one card, and this is how the runner
+/// knows when a wake has moved to a different one.
+export const CARD_REF_RE = /#(\d{1,7})(?!\d)/;
+
+/// Words that make a direct message an instruction rather than conversation. Deliberately short:
+/// the point is to catch a contract that forgot to cite its card, not to parse English.
+export const IMPERATIVE_RE = /\b(deliver|fix|bounce|contract|next|resume)\b/i;
+
+export function cardRef(text) {
+  const m = CARD_REF_RE.exec(String(text || ""));
+  return m ? Number(m[1]) : 0;
+}
+
+export function hasImperative(text) {
+  return IMPERATIVE_RE.test(String(text || ""));
+}
+
+/// The safety net for a sender that never set `wake`: a direct message with no card and no
+/// imperative is an ack, an FYI or a queue note, and it batches into the next turn's context.
+export function carriesWork(text) {
+  return cardRef(text) > 0 || hasImperative(text);
+}
+
+// ---- what a turn cost -------------------------------------------------------------------------
+// Each CLI reports its own usage in its own words, and some report none at all. Ordered most
+// specific first; the LAST match of the first pattern that hits wins, because a CLI that prints a
+// running total prints the real one last. Zero means "this CLI said nothing", never "free".
+const TOKEN_PATTERNS = [
+  /tokens used[:\s]+([\d,]+)/gi,        // codex
+  /\btotal tokens[:\s]+([\d,]+)/gi,     // opencode / glm / deepseek summaries
+  /\btokens[:\s]+([\d,]+)/gi,           // "Tokens: 12,345"
+  /([\d,]+)\s+tokens\b/gi,              // "12,345 tokens"
+];
+
+export function parseTurnTokens(text) {
+  const s = String(text || "");
+  for (const re of TOKEN_PATTERNS) {
+    re.lastIndex = 0;
+    let last = 0;
+    for (const m of s.matchAll(re)) {
+      const n = Number(String(m[1]).replace(/,/g, ""));
+      if (Number.isFinite(n)) last = n;
+    }
+    if (last) return last;
+  }
+  return 0;
+}
+
+// ---- when an exhausted seat may be woken again ------------------------------------------------
+// A CLI that hits its plan wall usually says when the wall lifts. Parsing it turns a blind retry
+// ladder (60 redelivery turns on codex, 09-02) into one wait.
+const MONTHS = "jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec";
+const RESET_ABS_RE = new RegExp(
+  String.raw`try again (?:at|on|after)\s+((?:${MONTHS})[a-z]*\.?\s+\d{1,2}(?:st|nd|rd|th)?,?\s+\d{4},?\s+\d{1,2}:\d{2}(?::\d{2})?\s*(?:am|pm)?)`,
+  "i",
+);
+const RESET_REL_RE = /try again in\s+(\d+)\s*(second|minute|hour|day)s?/i;
+
+/// The epoch ms at which this seat may be retried, or 0 when the output named no time.
+export function parseResetAt(text, now = Date.now()) {
+  const s = String(text || "");
+
+  const abs = RESET_ABS_RE.exec(s);
+  if (abs) {
+    // "Sep 3rd, 2026 3:34 AM" — Date.parse rejects the ordinal suffix, so drop it.
+    const t = Date.parse(abs[1].replace(/(\d{1,2})(st|nd|rd|th)/i, "$1"));
+    if (Number.isFinite(t) && t > now) return t;
+  }
+
+  const rel = RESET_REL_RE.exec(s);
+  if (rel) {
+    const unit = { second: 1e3, minute: 60e3, hour: 3600e3, day: 86400e3 }[rel[2].toLowerCase()];
+    if (unit) return now + Number(rel[1]) * unit;
+  }
+
+  return 0;
+}
+
+/// #6131: a qwen seat whose token plan is spent does not error — it stalls and returns nothing, so
+/// the runner classified it `empty-output` and kept the ladder running against a wall. A silent
+/// turn on a seat whose own balance row reads spent IS exhaustion, and parks like one.
+export function quotaSpent(rows) {
+  return (Array.isArray(rows) ? rows : []).some((r) => {
+    if (!r || !r.ok) return false;
+    if (r.kind === "quota") return r.remainingPct != null && r.remainingPct <= 0;
+    if (r.kind === "windows") {
+      return (r.windows || []).some((w) => w.locked || (w.usedPct != null && w.usedPct >= 100));
+    }
+    return r.remaining != null && r.remaining <= 0;
+  });
+}
+
+/// The failure reason a turn should be treated as, given what the seat's balances say. Only
+/// `empty-output` is ever re-read this way: every other reason already carries its own evidence.
+export function reasonWithBalances(reason, rows) {
+  return reason === "empty-output" && quotaSpent(rows) ? "exhausted" : reason;
+}
+
+/// Seats that park rather than retry. A backend error is the provider having a bad minute and the
+/// ladder is exactly right for it; a spent plan or a rejected key will not fix itself on a timer.
+export const PARKING_REASONS = new Set(["exhausted", "auth"]);

package/mcp.mjs

@@ -314,12 +314,55 @@ server.tool("relay_withdraw_proposal", "Withdraw one of THIS session's PENDING p
     return { content: [{ type: "text", text: `proposal #${id} withdrawn — one queue slot free` }] };
   });
 
+// ONE card, not the board (#6134). A seat used to be told to "query the board for related PAST
+// cards and lessons — 1900+ cards of tribal knowledge", and it did: the whole board, every turn,
+// almost all of it other people's work. This is the same intent at a thousandth of the tokens —
+// the card, what it waits on, its own notes, and the handful of done cards that actually rhyme
+// with it. Client-side on /tasks, so no hub change and it works against any hub version.
+const STOPWORDS = new Set(["the","a","an","and","or","of","to","in","on","for","with","is","it","its","that","this","not","but","by","at","as","from","into","out","up","down","when","then","than","so","no","new","one","two","every","all","any"]);
+function titleWords(title) {
+  return new Set(String(title || "").toLowerCase().match(/[a-z][a-z0-9_-]{2,}/g)?.filter(w => !STOPWORDS.has(w)) || []);
+}
+function cardView(tasks, id, proj) {
+  const card = tasks.find(t => t.id === id);
+  if (!card) return `${proj}: no card #${id}`;
+  const out = [`#${card.id} ${card.title}`,
+    `status: ${card.status}${card.assignee ? ` · @${card.assignee}` : ""}${card.difficulty ? ` · ${card.difficulty}` : ""}${card.model ? ` · ${card.model}` : ""}`];
+
+  const deps = (Array.isArray(card.deps) ? card.deps : []).map(d => {
+    const t = tasks.find(x => x.id === d);
+    return t ? `#${t.id} ${t.title} [${t.status}]` : `#${d} (not on this board)`;
+  });
+  if (deps.length) out.push(`depends on:\n  ${deps.join("\n  ")}`);
+
+  if (Array.isArray(card.checklist) && card.checklist.length) {
+    out.push(`checklist:\n  ${card.checklist.map((c, i) => `[${c.done ? "x" : " "}] ${i}. ${c.text || c}`).join("\n  ")}`);
+  }
+
+  const log = Array.isArray(card.log) ? card.log : [];
+  if (log.length) out.push(`notes (${log.length}):\n  ${log.map(e => `${e.by || "?"}: ${String(e.text || "").replace(/\s+/g, " ")}`).join("\n  ")}`);
+
+  // The prior art that is actually prior art: done cards whose title shares a real word with this
+  // one. Five, newest first — enough to catch "we already did this", short enough to stay cheap.
+  const mine = titleWords(card.title);
+  const kin = tasks
+    .filter(t => t.status === "done" && t.id !== card.id && [...titleWords(t.title)].some(w => mine.has(w)))
+    .sort((a, b) => (b.updated || b.ts || 0) - (a.updated || a.ts || 0))
+    .slice(0, 5)
+    .map(t => `#${t.id} ${t.title}${t.log?.length ? ` ·${t.log.length}` : ""}`);
+  if (kin.length) out.push(`related done cards:\n  ${kin.join("\n  ")}`);
+
+  return out.join("\n");
+}
+
 server.tool("relay_board", "Show a project's Kanban board (all cards + their status + assignee). Defaults to THIS project; pass `project` to read a crew board you orchestrate from elsewhere. Cards carrying log notes show a ·N count (the card's note-log size).",
-  { project: z.string().optional().describe("board to show (default: this session's project)") },
-  async ({ project }) => {
+  { project: z.string().optional().describe("board to show (default: this session's project)"),
+    card: z.number().optional().describe("read ONE card instead of the board: the card itself, its notes, and the last five done cards whose title shares a word with it. This is what a seat starting a card should call — the whole board is 1900+ cards of someone else's work.") },
+  async ({ project, card }) => {
   const proj = project || PROJECT;
   const { tasks } = await api("GET", `/tasks?project=${encodeURIComponent(proj)}`);
   if (!tasks.length) return { content: [{ type: "text", text: `${proj}: no cards yet` }] };
+  if (card) return { content: [{ type: "text", text: cardView(tasks, card, proj) }] };
   const by = { todo: [], doing: [], testing: [], failed: [], done: [], blocked: [] };
   for (const t of tasks) (by[t.status] || by.todo).push(`#${t.id} ${t.title}${t.assignee ? ` (@${t.assignee})` : ""}${t.log?.length ? ` ·${t.log.length}` : ""}`);
   const cols = Object.entries(by).filter(([, v]) => v.length).map(([k, v]) => `${k.toUpperCase()}:\n  ${v.join("\n  ")}`);
@@ -338,16 +381,17 @@ server.tool("relay_peers", "Find who you can talk to: the live agent sessions on
 });
 
 server.tool("relay_send", "Send a live message to another agent session (or 'all' to broadcast). Reach the other agent YOURSELF: if you are about to ask the human to pass something along, tell the session directly instead — asking a person to carry a message between two agents is a failure, not politeness. Don't know the id? relay_peers lists them, linked projects included. Cross-project sends are allowed.",
-  { to: z.string().describe("target session id, or 'all'"), text: z.string().describe("message body") },
-  async ({ to, text }) => {
+  { to: z.string().describe("target session id, or 'all'"), text: z.string().describe("message body"),
+    wake: z.boolean().optional().describe("false = context, not a contract: the message batches into the target's next turn instead of buying it a whole CLI session. Use it for acks, FYIs and queue notes; leave it unset for anything you expect worked on.") },
+  async ({ to, text, wake }) => {
     // The event log is append-only — a secret in it is unrecoverable, so refuse BEFORE
     // anything reaches the hub. Returns the offending kinds so the caller can fix it.
     const scrub = assertNoSecrets(text);
     if (!scrub.ok) {
       return { content: [{ type: "text", text: `REFUSED — not sent. Credential-shaped string(s) detected: ${scrub.kinds.join(", ")}. Remove them and resend.` }], isError: true };
     }
-    const { id } = await api("POST", "/send", { from: SESSION, to, text });
-    return { content: [{ type: "text", text: `sent #${id} to ${to}` }] };
+    const { id } = await api("POST", "/send", { from: SESSION, to, text, ...(wake === false ? { wake: false } : {}) });
+    return { content: [{ type: "text", text: `sent #${id} to ${to}${wake === false ? " (batched — no turn)" : ""}` }] };
   });
 
 server.tool("relay_status", "Set this session's one-line status on the presence board (what you're working on / idle). Cheap — other sessions read it instantly via relay_peers without messaging you.",
@@ -436,8 +480,15 @@ const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 const nonProjectReason = nonSeatReason(projectDir);
 const isHomeDirSession = !!nonProjectReason;
 
+// #6170: WHAT this session is, when it can know. sessionstart stamps kind "orch" on the
+// orchestrator pane, but that runs once — every MCP beat afterwards was kindless, and the hub's
+// crew exemption reads the peer row's kind, so the orchestrator kept being demoted by its own
+// heartbeat and then warned about as an intruder on its own project. Same test sessionstart uses:
+// TRANTOR_ORCH names the project this pane orchestrates.
+const KIND = process.env.TRANTOR_ORCH && process.env.TRANTOR_ORCH === PROJECT ? { kind: "orch" } : {};
+
 if (!isHomeDirSession) {
-  await api("POST", "/register", { session: SESSION, project: PROJECT, status: `active in ${PROJECT}`, hookVersion: MCP_VERSION })
+  await api("POST", "/register", { session: SESSION, project: PROJECT, status: `active in ${PROJECT}`, hookVersion: MCP_VERSION, ...KIND })
     .catch((err) => { process.stderr.write(`[trantor-mcp] initial register failed: ${err?.message || err}\n`); });
 
   // Heartbeat — keep this session's presence fresh for as long as the MCP process lives.
@@ -449,7 +500,7 @@ if (!isHomeDirSession) {
   // hub refreshes lastSeen but preserves the session's meaningful status. setInterval pauses during
   // sleep and fires on wake, so presence self-heals within one interval; .unref() lets the process
   // still exit cleanly when the agent closes the stdio transport (no phantom peers).
-  setInterval(() => { api("POST", "/register", { session: SESSION, project: PROJECT, hookVersion: MCP_VERSION }).catch(() => {}); }, HEARTBEAT_MS).unref?.();
+  setInterval(() => { api("POST", "/register", { session: SESSION, project: PROJECT, hookVersion: MCP_VERSION, ...KIND }).catch(() => {}); }, HEARTBEAT_MS).unref?.();
 } else {
   process.stderr.write(`[trantor-mcp] ${nonProjectReason} — not auto-registering on the bus (set RELAY_SESSION or RELAY_PROJECT to opt in)\n`);
 }

package/package.json

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