trantor 0.18.34 → 0.18.35

package/.claude-plugin/plugin.json

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

@@ -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();
@@ -272,7 +275,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.`;
 
 // ---- 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 +356,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 +397,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 +482,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).
@@ -515,7 +569,15 @@ async function runTurn(prompt, isFirst, trigger = "kickoff") {
   // 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`;
   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,
+    ...(TURN_MAX_MS ? { timeout: TURN_MAX_MS, 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 +593,14 @@ async function runTurn(prompt, isFirst, trigger = "kickoff") {
     maxBuffer: 16 * 1024 * 1024,
   });
   try { unlinkSync(STAMPF); } catch {}   // turn over — disarm the watchdog
+  // #6134: node's timeout signals only the shell it spawned. The CLI and its children share the
+  // detached group, so sweep the whole group — otherwise a boxed turn leaves a model still running
+  // (and still billing) against a runner that has moved on.
+  const cut = !!TURN_MAX_MS && (r.error?.code === "ETIMEDOUT" || (r.signal === "SIGKILL" && Date.now() - t0 >= TURN_MAX_MS));
+  if (cut && r.pid) {
+    try { process.kill(-r.pid, "SIGKILL"); } catch {}
+    log(`\x1b[33mturn cut at the ${Math.round(TURN_MAX_MS / 1000)}s time box — CLI process group ended\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 {}
@@ -578,12 +648,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 +736,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 +856,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 +905,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

@@ -2786,7 +2786,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/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/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.",

package/package.json

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