trantor 0.18.76 → 0.18.78

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.76",
+  "version": "0.18.78",
   "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/agents.mjs

@@ -1,16 +1,8 @@
 #!/usr/bin/env node
-// trantor agents [sessionId] [--json] — the LIVE sub-agent manifest for a session.
-//
-// What were this session's sub-agents (Agent/Task tool, Workflow swarms, agent-teams) doing —
-// what was each tasked with, did it return, what did it write, and do those files still survive
-// on disk? Derived fresh from the on-disk transcripts every run (so it reflects CURRENT disk,
-// catching files an agent finished that were later clobbered — the 2026-06-21 kill corrupted a
-// completed 30KB lib down to a 17-byte stub).
-//
-//   trantor agents                 → the session of the newest handoff for THIS project (the
-//                                     predecessor a fresh session is taking over from)
-//   trantor agents <sessionId>     → that specific session
-//   trantor agents --json          → structured manifest (for tools)
+// trantor agents [sessionId] [--json] [--since <epochMs>] — the LIVE sub-agent manifest for a
+// session: what was each sub-agent tasked with, did it return, what did it write, did it survive
+// on disk — re-derived fresh from the transcripts every run. `--since <epochMs>` (#10007) reads
+// agents launched before that instant "stale", never "in-flight"; the app polls this for liveness.
 import { readFileSync, readdirSync, existsSync } from "node:fs";
 import { join, basename } from "node:path";
 import { homedir } from "node:os";
@@ -18,7 +10,10 @@ import { deriveSubagentManifest, formatSubagentManifest, resolveTranscriptForSid
 
 const args = process.argv.slice(2);
 const json = args.includes("--json");
-const sid = args.find((a) => !a.startsWith("--"));
+const sinceIdx = args.indexOf("--since");
+const sinceVal = sinceIdx !== -1 ? args[sinceIdx + 1] : undefined;
+const sinceMs = sinceVal != null ? Number(sinceVal) : undefined;
+const sid = args.find((a) => !a.startsWith("--") && a !== sinceVal);
 
 const HANDOFF_DIR = join(process.env.RELAY_DATA_DIR || join(homedir(), ".agent-bus"), "handoffs");
 
@@ -55,7 +50,7 @@ if (sid) {
   projectRoot = h.project || projectRoot;
 }
 
-const manifest = deriveSubagentManifest(transcript, { projectRoot });
+const manifest = deriveSubagentManifest(transcript, { projectRoot, sinceMs: Number.isFinite(sinceMs) ? sinceMs : undefined });
 if (json) {
   process.stdout.write(JSON.stringify(manifest, null, 2) + "\n");
 } else {

package/bin/crew-runner.mjs

@@ -16,13 +16,13 @@ import { applyWorktreeDeclaration, ensureSeatWorktree, provisioningLines, readWo
 import {
   AUTH_MARKER_RE, classifyFailure, looksLikeAuthDeath,
   verdictFor, substantiveOutput, stallVerdict, cutSignalFor,
-  BILLING_RE, looksLikeBillingDeath, usageSaysNoWork, zeroUsageVerdict,
+  BILLING_RE, looksLikeBillingDeath, usageSaysNoWork, zeroUsageVerdict, noDeliveryVerdict,
   permissionRejection, looksLikePermissionDeath,
   readPromptText, stripPromptEcho,
 } from "../lib/classify-failure.mjs";
 import { capWake, capBcast, pickLessons, composePrompt, contractBase, baseLine } from "./crew-payload.mjs";
 import {
-  cardRefs, wakeCard, carriesWork, parseTurnTokens, parseResetAt, reasonWithBalances, quotaResetAt, PARKING_REASONS,
+  cardRefs, servedContractCard, carriesWork, parseTurnTokens, parseResetAt, reasonWithBalances, quotaResetAt, PARKING_REASONS,
   senderProjectOf, isLinkedProject, stateSkipReason, isMessageCardTitle, OPEN_CARD_STATUSES,
   CUT_CHAIN_PARK_MIN, cutChainEvidence, isBoundedPark,
 } from "../lib/turn-policy.mjs";
@@ -279,6 +279,11 @@ let lastEmptyOutput = false;
 // the CLI printed its banner and quit. The both-streams-silent rule above stays; this is the
 // second, harder-to-see empty shape.
 let lastEmptyTurn = false;
+// #10197: exit 0 on a turn BOUND to a card contract with neither a new commit nor a card move to
+// testing/done — the ibkr shape (48s, prose, card still todo, announced done). The card's status
+// at turn end rides along so the assigner's notice can name it.
+let lastNoDelivery = false;
+let lastNoDeliveryStatus = "";
 const ERRF = join(homedir(), ".agent-bus", `err-${AGENT}-${PROJ}.txt`);
 const DUTY_NUDGES = process.env.RUNNER_DUTY_NUDGES === "1";
 const DUTY_NUDGE_STATE = process.env.RUNNER_DUTY_NUDGE_STATE
@@ -742,6 +747,16 @@ async function runTurn(prompt, isFirst, trigger = "kickoff", opts = {}) {
   // #7759: the worktree snapshot the turn is judged against at its end — porcelain covers edits
   // AND new untracked files, which a HEAD-only comparison misses.
   const statusBefore = gitOut(["status", "--porcelain"], TURN_DIR);
+  // #10197: the card status snapshot the turn is judged against at its end — a move to
+  // testing/done under the turn is delivery even without a commit. null = the hub read failed:
+  // the delivery check stands down rather than claim no-delivery on a transport error.
+  let cardStatusBefore = null;
+  if (!opts.state && sessionCard > 0) {
+    try {
+      const { task } = await api(`/card?project=${encodeURIComponent(PROJ)}&id=${sessionCard}`);
+      cardStatusBefore = task ? String(task.status || "") : null;
+    } catch { cardStatusBefore = null; }
+  }
   // #9778: the docker snapshot the turn is judged against — containers the CLI spawns are recorded
   // against the seat's card at turn end, then stopped when the card closes or the seat parks.
   const dockerBefore = listContainers();
@@ -1011,16 +1026,38 @@ exit $turn_exit`;
     effExit = 1;
     log("\x1b[31mexit 0 but the session usage record resolved to all zeros — no model work happened; treating as FAILED\x1b[0m");
   }
+  // #10197: a turn BOUND to a card contract reads done only on DELIVERY — a NEW commit since the
+  // turn started, or the card moved to testing/done under it. The ibkr shape (exit 0, output, no
+  // commit, card still todo) is NO-DELIVERY: the ledger names it and the contract stays owed.
+  // Judged on hub reads of the card status; a failed read keeps today's label, never no-delivery.
+  let cardStatusAtEnd = "", noDelivery = false;
+  if (!cut && !opts.state && realExit === 0 && effExit === 0 && sessionCard > 0 && cardStatusBefore !== null) {
+    let endStatus = null;
+    try {
+      const { task } = await api(`/card?project=${encodeURIComponent(PROJ)}&id=${sessionCard}`);
+      endStatus = task ? String(task.status || "") : null;
+    } catch { endStatus = null; }
+    if (endStatus !== null) {
+      cardStatusAtEnd = endStatus;
+      const moved = ["testing", "done"].includes(endStatus) && !["testing", "done"].includes(cardStatusBefore);
+      noDelivery = !newCommit && !moved;
+    }
+  }
+  lastNoDelivery = noDelivery;
+  lastNoDeliveryStatus = cardStatusAtEnd;
+  if (noDelivery) log(`\x1b[33mexit 0 but the turn DELIVERED NOTHING on #${sessionCard} — no new commit, card still ${cardStatusAtEnd || "unknown"}\x1b[0m`);
   // #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. A silent cut names its own
   // verdict (#7752): the exit under it is the sweep's SIGPIPE. A box cut passes `cut` so its 137
   // reads as the sweep's SIGKILL (#7099); a zero-usage turn names its own verdict too (#9724).
-  const verdict = stallCut ? stallVerdict() : zeroUsage ? zeroUsageVerdict() : verdictFor(realExit, effExit, lastEmptyOutput, ownOut, lastEmptyTurn, cut);
+  const verdict = stallCut ? stallVerdict() : zeroUsage ? zeroUsageVerdict()
+    : noDelivery ? noDeliveryVerdict(sessionCard, cardStatusAtEnd || "unknown")
+    : verdictFor(realExit, effExit, lastEmptyOutput, ownOut, lastEmptyTurn, cut);
   // #6289: every ledger row names in ONE field what happened to the turn — cut, stalled (#7752),
   // api-error, completed — and what it cost (0 means "not reported", never "free"). #7762: `card`
   // binds the row to the card the turn worked (0 = kickoff/pulse) so the seat record attributes
   // empty/stalled turns to the card that produced nothing. `cut` stays too: the drills read it.
-  const outcome = cut ? (stallCut ? "stalled" : "cut") : (effExit !== 0 ? "api-error" : lastEmptyTurn ? "empty" : "completed");
+  const outcome = cut ? (stallCut ? "stalled" : "cut") : (effExit !== 0 ? "api-error" : noDelivery ? "no-delivery" : lastEmptyTurn ? "empty" : "completed");
   // #7756: a clean turn that ASKED its assigner is demoted-but-owed, not "completed". The judge
   // (deliverWake's /contracts read) renames the ledger row, so "asked" is what the log keeps.
   let finalOutcome = outcome;
@@ -1251,7 +1288,9 @@ async function newestOwnCard(session, why) {
   } catch { return 0; }   // board unreadable: no binding beats a guessed one
 }
 async function resolveWakeCard(messages, { session }) {
-  const cited = wakeCard(messages, { session });
+  // #10824: the contract message BEING SERVED names the card — the newest direct message's own
+  // binding — never a contract still queued behind it and never the session's previous card.
+  const cited = servedContractCard(messages, { session });
   if (!(cited > 0)) return 0;
   try {
     const { task } = await api(`/card?project=${encodeURIComponent(PROJ)}&id=${cited}`);
@@ -1312,6 +1351,7 @@ async function resolveWakeCard(messages, { session }) {
   }
   let retryAt = 0;            // 0 = deliver at the next opportunity
   let deliveryFails = 0;      // consecutive failed attempts at the SAME pending batch
+  let noDeliveryRetry = false;
   if (pendingWake.length) log(`\x1b[33m${pendingWake.length} message(s) survived from a previous run — redelivering\x1b[0m`);
 
   // #7060: the turn the boot line was read as a promise about. It is a transcript turn by
@@ -1455,6 +1495,12 @@ async function resolveWakeCard(messages, { session }) {
     // a bounded park instead of queueing behind the window; a mention does not, because the room
     // talking is not a request. An exhausted or auth park is a wall and stands anyway (#6134).
     const directWake = wake.filter(m => m.to === SESSION);
+    // #10197: no-delivery owes the old contract, but its retry delay must not batch away
+    // fresh contracts. Only actual CLI failures impose backoff on a new wake.
+    if (noDeliveryRetry) {
+      unpark("new wake after no-delivery");
+      retryAt = 0; deliveryFails = 0; noDeliveryRetry = false;
+    }
     if (parkState && directWake.length) {
       if (isBoundedPark(parkState.reason)) {
         unpark(`direct message from ${directWake[0].from || "?"}`);
@@ -1491,6 +1537,7 @@ async function resolveWakeCard(messages, { session }) {
     } catch { return 0; }
   }
   async function deliverWake() {
+    noDeliveryRetry = false;
     // #7756: captured and cleared HERE so an early return below never leaks the flag into a
     // later turn — only the turn the answer released reads it.
     const resumedAfterAsk = askReleased;
@@ -1560,12 +1607,13 @@ async function resolveWakeCard(messages, { session }) {
     // #6134: ONE SESSION PER CARD; a different card starts a fresh CLI session and the seat is told.
     // #7061: bound by SHAPE, not position, so an order opening with what shipped binds the right card.
     // #7763: a message-card (or phantom) citation never binds — the seat's own newest card does.
-    const card = await resolveWakeCard(wakeForTurn, { session: SESSION });
+    // #10824: the binding is the SERVED contract's; #7756's answer-released turn keeps the held card.
+    const card = resumedAfterAsk ? sessionCard : await resolveWakeCard(wakeForTurn, { session: SESSION });
     // #7754: a `base:` sha this worktree cannot resolve is never worked from origin/main — the card
     // goes to blocked, the assigner is told, and no model turn is spent. The check keeps the id the
-    // wake cites in its text: #7763's rebinding covers confirmed message-card ids only, never a
+    // served contract cites: #7763's rebinding covers confirmed message-card ids only, never a
     // card cited in the text, so the unresolvable-base branch blocks the cited card.
-    const baseCard = card || wakeCard(wakeForTurn, { session: SESSION });
+    const baseCard = card || servedContractCard(wakeForTurn, { session: SESSION });
     const base = contractBase(wakeForTurn) || localMainHead();
     if (base && baseCard && !resolvesHere(base)) {
       const text = `cannot resolve base ${base} in ${TURN_DIR} (git cat-file -e failed) — #${baseCard} moved to blocked; push or fetch that sha, or name one this worktree can reach`;
@@ -1579,13 +1627,13 @@ async function resolveWakeCard(messages, { session }) {
       return;
     }
     const baseText = base ? `\n${baseLine(base)}\n` : "";
-    // #6289: the card the SESSION belongs to reads the citation when the rebinding binds nothing —
-    // #7763 decides WHICH card work binds to, never the turn shape. #7756: the turn an ask's
-    // ANSWER releases is the exception — it resumes the session the held contract already owns,
-    // whatever card the batch cites; only a new contract for a different card opens fresh.
+    // #6289: the session SHAPE (fresh vs resume) reads the served contract's raw citation — a wake
+    // whose card the board lacks still opens fresh, never a bare resume of the kickoff's CLI.
+    // #10824: the LABEL is the binding, 0 included — a wake that binds nothing labels its turn 0
+    // and never inherits the previous contract's card (#10197's judge then reads the right card).
     const sessionCardForTurn = card || baseCard;
     const fresh = !resumedAfterAsk && sessionCardForTurn > 0 && sessionCardForTurn !== sessionCard;
-    if (card) sessionCard = card;
+    sessionCard = card;
     const cited = [...new Set(wakeForTurn.flatMap(m => cardRefs(m.text)))];
     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`
@@ -1602,6 +1650,7 @@ async function resolveWakeCard(messages, { session }) {
     const stopDutyNudgeWatcher = startDutyNudgeWatcher(dutyPlan, tStart);
     let ec;
     turnAsk = null;   // #7756: the judge reads THIS turn's ending, never a previous turn's ask
+    lastNoDelivery = false; lastNoDeliveryStatus = "";   // #10197: runTurn judges THIS turn only
     const stateStep = !stateSkip("wake", card);
     try {
       ec = stateStep
@@ -1723,6 +1772,27 @@ async function resolveWakeCard(messages, { session }) {
       savePending(pendingWake, pendingBcast);
       await reportHealthy();
       log(`turn asked its assigner — holding the contract until ask #${awaitingAsk.id} is answered`);
+    } else if (lastNoDelivery) {
+      // #10197: the turn exited 0 but DELIVERED NOTHING on its card — no new commit, the card
+      // still short of testing/done. "⚠ no commit" is not a receipt, so the sender's ledger keeps
+      // the contract owed; the queue is kept and the ladder retries — a second no-delivery
+      // attempt parks, exactly like the empty-turn ladder it sits beside.
+      deliveryFails++;
+      noDeliveryRetry = true;
+      savePending(pendingWake, pendingBcast);
+      const still = lastNoDeliveryStatus || "unresolved";
+      if (deliveryFails >= 2) {
+        retryAt = await parkSeat("no-delivery", pendingWake.length);
+        await notifyAssigners(assigners,
+          `⛔ your contract is PARKED on ${SESSION} (no-delivery: two exit-0 turns with no commit and card #${sessionCard} unmoved) · asked: "${asked}"`);
+        lastTurnAt = Date.now();
+        return;
+      }
+      const wait = RETRY_MS[Math.min(deliveryFails - 1, RETRY_MS.length - 1)];
+      retryAt = Date.now() + wait;
+      log(`\x1b[33mno commit, card #${sessionCard} still ${still} — wake not consumed, ${pendingWake.length} message(s) stay owed; retrying in ${Math.round(wait / 1000)}s\x1b[0m`);
+      await notifyAssigners(assigners,
+        `⚠ no commit, card #${sessionCard} still ${still} on ${SESSION} (exit 0, ${secs}s) · asked: "${asked}"`);
     } else if (lastEmptyTurn) {
       // #7759: the turn exited 0 but was HOLLOW — a banner is not work. The wake is NOT
       // consumed: the queue is kept and the ladder retries, and the assigner hears EMPTY,

package/bin/summarize.mjs

@@ -1,18 +1,8 @@
 #!/usr/bin/env node
-// trantor summarize — narrative cards: what was ASSIGNED and what was DONE, in plain language.
-//
-//   trantor summarize [--project <p>] [--limit N] [--all] [--dry] [--quiet]
-//
-// Title-cleaning makes machine-generated cards readable; it cannot make them MEAN anything. This
-// gives each card a one-line narrative ("assigned — did") written by a CHEAP model from the card's
-// own thread (its events + the messages that cite it). The board then reads as a story a human can
-// follow, which was the ask: "what the agent was assigned, what the agent did, what the flow was."
-//
-// Economics by design (the Scrooge doctrine): candidates are MACHINE-TITLED cards without a
-// summary (--all widens to every unsummarized card), batched into ONE cheap-model call per hub,
-// difficulty easy, capped per run. The summary lands via /task/update and rides the tasks.extra
-// column — permanent, never recomputed. Runs ambiently from the heartbeat (hourly, detached) and
-// on demand as `trantor summarize`.
+// trantor summarize [--project <p>] [--limit N] [--all] [--dry] [--quiet] — gives each machine-titled
+// card a one-line "assigned — did" narrative written by ONE cheap-model call per hub from the card's
+// own thread; lands via /task/update on tasks.extra (permanent, never recomputed). Runs ambiently
+// from the heartbeat (hourly, detached) and on demand as `trantor summarize`.
 import { execSync, spawnSync } from "node:child_process";
 import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
@@ -40,7 +30,7 @@ const scroogeBin = () => process.env.SCROOGE_BIN
 // A title no human wrote: protocol frames, dumped prompts, id soup. These are the cards whose
 // board presence is noise until a narrative replaces them.
 const machineTitled = (t) =>
-  /^\s*[<{[]/.test(t) || /<task-notification>|<system-reminder>|toolu_[A-Za-z0-9]/.test(t) ||
+  /^\s*[<{[]/.test(t) || /<task-notification>|<system-reminder>|<trantor-succession>|<trantor-takeover>|toolu_[A-Za-z0-9]/.test(t) ||
   /^\s*(subagent|general-purpose|Explore|Task|Plan):/i.test(t) || t.length > 130;
 
 const hubs = new Set([config.url || "http://127.0.0.1:4477", ...Object.values(config.hubs || {})]);

package/hooks/heartbeat.mjs

@@ -119,10 +119,12 @@ async function maybeEarlyWarn(stdinRaw, session) {
     // It is marked where the baton fires (here on the backstop, in Stop on the normal path).
     armBaton(sessionId, { projectDir, transcript, reason: "context-warn", windowId, tty, tokens: usage.tokens });
     // Tell the RUNNING agent (once, at arm time): wrap up and author the boundary handoff yourself.
-    ARM_CTX = `<system-reminder>TRANTOR SUCCESSION ARMED — this session is at ${Math.round(usage.frac * 100)}% of its context window, and the baton is armed: your NEXT STOP fires the handoff. You are now responsible for your own succession:\n`
+    // NOT <system-reminder>: CC 2.1.292 escapes that tag in hook output, so the notice would
+    // arrive as literal text (#11110). Our own <trantor-…> tags pass through like the other hooks'.
+    ARM_CTX = `<trantor-succession>TRANTOR SUCCESSION ARMED — this session is at ${Math.round(usage.frac * 100)}% of its context window, and the baton is armed: your NEXT STOP fires the handoff. You are now responsible for your own succession:\n`
       + `1. Reach a real task boundary — finish, pause, or checkpoint your in-flight work NOW; do not start new work.\n`
       + `2. Author (or refresh) the rich handoff from your CURRENT state — via the handoff skill or the relay_handoff MCP tool — so the successor gets the freshest picture, not a digest of a session 36 seconds stale. A fresh model-authored handoff supersedes the auto-digest.\n`
-      + `3. Then end your turn. The Stop hook fires the baton at that boundary.</system-reminder>`;
+      + `3. Then end your turn. The Stop hook fires the baton at that boundary.</trantor-succession>`;
   } catch {}
 }
 

package/hooks/prompt-focus.mjs

@@ -18,6 +18,25 @@ function readStdin() {
 }
 // A prompt that is JUST an acknowledgement/continuation (anchored to end) — not a new focus.
 const ACK = /^(y|yes|yep|yeah|ok|okay|sure|go|go ahead|continue|proceed|do it|please|thanks|thank you|ty|next|k|cool|nice|great|perfect|sounds good|👍)[\s.!]*$/i;
+// A paste arrives wrapped in `<pasted_content id="…">…</pasted_content>`: the wrapper is transport,
+// not content — the operator typed what is inside (#10027's chat.rs rule, same channel). Peel it so
+// the marker check and the focus title see the words, never the tag. Unwrapped text passes through.
+function unwrapPasted(t) {
+  const s = String(t || "").trim();
+  if (!s.startsWith("<pasted_content")) return s;
+  const gt = s.indexOf(">");
+  if (gt < 0) return s;
+  const close = s.lastIndexOf("</pasted_content>");
+  return (close > gt ? s.slice(gt + 1, close) : s.slice(gt + 1)).trim();
+}
+// HARNESS-INJECTED prompts are not a human's focus. A CLOSED list of known prefixes, not "starts
+// with <": a paste merely happens to start with a tag, and a human quoting JSON is still a human.
+// (The old ^\s*[<{[] heuristic silently dropped every pasted operator prompt, #11110.)
+const HARNESS_MARKERS = [
+  "<task-notification", "<system-reminder", "<teammate-message",
+  "<command-name", "<environment_context", "[SYSTEM NOTIFICATION",
+];
+const isHarnessInjection = (t) => HARNESS_MARKERS.some(m => t.startsWith(m));
 function titleFrom(prompt) {
   let s = String(prompt || "").replace(/\s+/g, " ").trim();
   // strip a leading politeness/imperative wrapper so the card reads as the WORK, not "can you please…"
@@ -42,7 +61,7 @@ function loadRecapCtx(sessionId) {
     const mandate = rec.mode === "unattended"
       ? " Then RESUME the handoff's OPEN THREADS immediately — they are your work order; this succession is unattended, do NOT wait for the user."
       : " Then WAIT for the user.";
-    return `<system-reminder>You took over via handoff ${rec.handoffId}. If you have not yet recapped it, your reply MUST begin with the ≤3-sentence recap (task, state, next step) before anything else — including before answering this message.${mandate}</system-reminder>`;
+    return `<trantor-takeover>You took over via handoff ${rec.handoffId}. If you have not yet recapped it, your reply MUST begin with the ≤3-sentence recap (task, state, next step) before anything else — including before answering this message.${mandate}</trantor-takeover>`;
   } catch { return ""; }
 }
 function emitAndExit() {
@@ -61,17 +80,16 @@ try {
   // don't card home-dir sessions (matches sessionstart's phantom-project guard)
   if (!process.env.RELAY_SESSION && !process.env.RELAY_PROJECT && cwd === homedir()) { emitAndExit(); }
   const trimmed = prompt.replace(/\s+/g, " ").trim();
+  const text = unwrapPasted(trimmed);   // a paste's wrapper is transport; judge the words inside
   // skip empties, tiny continuations, and pure acks — they're not a new focus
-  if (!trimmed || trimmed.length < 12 || ACK.test(trimmed)) { emitAndExit(); }
+  if (!text || text.length < 12 || ACK.test(text)) { emitAndExit(); }
   // The Accounts ask drill launches a real Claude session, so its scripted prompt traverses this
   // hook just like operator work. It is harness traffic, though, and must never become a focus card.
-  if (/\bTRANTOR ASK DRILL\b/.test(trimmed)) { emitAndExit(); }
-  // HARNESS-INJECTED prompts are not a human's focus. Task notifications, hook system-reminders and
-  // protocol frames arrive through the same UserPromptSubmit channel, and carding one titled a board
-  // card "<task-notification> <task-id>bavlqfmzq</task-id>…" — pure noise a human cannot read.
-  if (/^\s*[<{[]/.test(trimmed) || /<task-notification>|<system-reminder>|<teammate-message/i.test(trimmed)) {
-    emitAndExit();
-  }
+  if (/\bTRANTOR ASK DRILL\b/.test(text)) { emitAndExit(); }
+  // Task notifications, hook reminders and protocol frames arrive through the same UserPromptSubmit
+  // channel, and carding one titled a board card "<task-notification> <task-id>bavlqfmzq</task-id>…"
+  // — pure noise a human cannot read.
+  if (isHarnessInjection(text)) { emitAndExit(); }
   const project = resolveProject(cwd);
   const session = process.env.RELAY_SESSION
     || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${project}` : `${hostId()}:${project}`);
@@ -79,18 +97,18 @@ try {
   // two Claude sessions in one project share (and fight over) a single focus card, and sub-agent
   // cards, whose `parent` is exactly this UUID, have nothing to nest under.
   const cc = String(input.session_id || "").slice(0, 120);
-  const r = await signedPost("/focus", { session, project, title: titleFrom(trimmed), by: session, cc }, { session });
+  const r = await signedPost("/focus", { session, project, title: titleFrom(text), by: session, cc }, { session });
 
   // Only pay a model when the heuristic actually mangles the prompt. A short, already-clear ask
   // ("fix the login redirect") reads fine as-is and buying a rewrite for it is exactly the kind of
   // reflexive spend the economics doctrine exists to stop.
   const id = r?.json?.id;
-  if (id && trimmed.length > 90 && process.env.TRANTOR_NO_SCROOGE_TITLES !== "1") {
+  if (id && text.length > 90 && process.env.TRANTOR_NO_SCROOGE_TITLES !== "1") {
     try {
       const busDir = process.env.AGENT_BUS_DIR || join(homedir(), ".agent-bus");
       mkdirSync(busDir, { recursive: true });
       const pf = join(busDir, `focus-prompt-${String(cc || session).replace(/[^A-Za-z0-9_.-]/g, "_")}.txt`);
-      writeFileSync(pf, trimmed);
+      writeFileSync(pf, text);
       const worker = join(dirname(dirname(fileURLToPath(import.meta.url))), "bin", "focus-title.mjs");
       // Detached + unref'd + stdio ignored: the hook returns NOW. Nothing downstream waits on this,
       // and a worker that dies takes the heuristic title with it, which is a fine outcome.

package/lib/classify-failure.mjs

@@ -200,6 +200,13 @@ export function zeroUsageVerdict() {
   return "classified zero-usage because the session usage record resolved to all zeros — no model work happened";
 }
 
+/** #10197: the verdict line for a card-bound turn that DELIVERED NOTHING — exit 0 with output but
+ *  no new commit since turn start and the card unmoved (the ibkr specimen: 48s, prose, card still
+ *  todo, announced done). Named here so the drill pins the string. */
+export function noDeliveryVerdict(card, status) {
+  return `classified no-delivery because exit 0 with no new commit and card #${card} still ${status}`;
+}
+
 /** Classify one failed turn. Returns { reason, matched } — matched is the evidence excerpt the
  *  runner logs, so the next misclassification is diagnosable from the seat log alone. `cut` is the
  *  runner's box/stall marker: 137 reads as the sweep's SIGKILL only under it — without the marker

package/lib/subagent-manifest.mjs

@@ -68,11 +68,12 @@ function reconcileFile(absPath, agentBytes, projectRoot) {
   return { path: shortPath(absPath, projectRoot), agentBytes, onDiskNow, suspect };
 }
 
-function analyzeAgent(meta, completedIds, projectRoot) {
+function analyzeAgent(meta, completedIds, projectRoot, sinceMs) {
   const wrote = new Map(); // absPath → last-write byte length
-  let lastMs = 0, result = "";
+  let lastMs = 0, launchMs = 0, result = "";
   for (const r of parseLines(meta.jsonlPath)) {
     const ts = r.timestamp ? Date.parse(r.timestamp) || 0 : 0;
+    if (!launchMs && ts) launchMs = ts; // jsonl is append-ordered: first timestamped line = launch
     if (ts > lastMs) lastMs = ts;
     const c = r?.message?.content;
     if (!Array.isArray(c)) continue;
@@ -84,13 +85,22 @@ function analyzeAgent(meta, completedIds, projectRoot) {
       if (b?.type === "text") { const text = asString(b.text)?.trim(); if (text) result = text; }
     }
   }
-  const status = meta.toolUseId && completedIds.has(meta.toolUseId) ? "completed" : "in-flight";
+  // #10007 liveness: "in-flight" means launched and never returned a result. But an agent whose
+  // launch predates the session's CURRENT process (sinceMs = process start) can never return —
+  // its turn died with the old process — so it reads "stale" and never counts as live.
+  const returned = meta.toolUseId && completedIds.has(meta.toolUseId);
+  let status = returned ? "completed" : "in-flight";
+  if (!returned) {
+    if (!launchMs) { try { launchMs = statSync(meta.jsonlPath).birthtimeMs || 0; } catch {} }
+    if (sinceMs != null && launchMs < sinceMs) status = "stale";
+  }
   return {
     name: meta.name || basename(meta.jsonlPath).replace(/\.jsonl$/, ""),
     agentType: meta.agentType || "",
     task: meta.description || "",
     workflow: meta.workflow || null,
     status,
+    launchMs: launchMs || null,
     wrote: [...wrote.entries()].map(([p, n]) => reconcileFile(p, n, projectRoot)),
     lastActivity: lastMs ? new Date(lastMs).toISOString() : null,
     lastActivityMs: lastMs,
@@ -99,10 +109,12 @@ function analyzeAgent(meta, completedIds, projectRoot) {
   };
 }
 
-// Derive the full manifest for a session from its parent transcript path. projectRoot (the repo
-// dir) is used only to shorten displayed file paths. Returns { sessionId, subagents[], counts }.
-export function deriveSubagentManifest(parentTranscript, { projectRoot } = {}) {
-  const out = { sessionId: "", subagents: [], counts: { total: 0, completed: 0, inFlight: 0, suspectFiles: 0 } };
+// Derive the full manifest for a session from its parent transcript path. projectRoot shortens
+// displayed file paths. sinceMs (epoch ms, #10007) marks agents launched before it "stale" instead
+// of "in-flight" — pass the session process's start when the answer feeds a LIVE claim (ACTIVE
+// NOW), never for a handoff record. Returns { sessionId, subagents[], counts }.
+export function deriveSubagentManifest(parentTranscript, { projectRoot, sinceMs } = {}) {
+  const out = { sessionId: "", subagents: [], counts: { total: 0, completed: 0, inFlight: 0, stale: 0, suspectFiles: 0 } };
   try {
     if (!parentTranscript || !existsSync(parentTranscript)) return out;
     const sid = basename(parentTranscript).replace(/\.jsonl$/i, "");
@@ -118,12 +130,13 @@ export function deriveSubagentManifest(parentTranscript, { projectRoot } = {}) {
     }
 
     const metas = collectMetas(subdir);
-    out.subagents = metas.map((m) => analyzeAgent(m, completedIds, projectRoot))
+    out.subagents = metas.map((m) => analyzeAgent(m, completedIds, projectRoot, sinceMs))
       .sort((a, b) => (a.lastActivityMs || 0) - (b.lastActivityMs || 0));
 
     out.counts.total = out.subagents.length;
     out.counts.completed = out.subagents.filter((s) => s.status === "completed").length;
     out.counts.inFlight = out.subagents.filter((s) => s.status === "in-flight").length;
+    out.counts.stale = out.subagents.filter((s) => s.status === "stale").length;
     out.counts.suspectFiles = out.subagents.reduce((n, s) => n + s.wrote.filter((w) => w.suspect).length, 0);
   } catch {}
   return out;
@@ -140,7 +153,9 @@ export function formatSubagentManifest(m, { heading = true } = {}) {
     }
   }
   for (const s of m.subagents) {
-    const badge = s.status === "completed" ? "✅ completed" : "🛑 IN-FLIGHT at handoff";
+    const badge = s.status === "completed" ? "✅ completed"
+      : s.status === "stale" ? "⏸  never returned, and launched before the current session process — stale"
+      : "🛑 IN-FLIGHT at handoff";
     L.push("");
     L.push(`• ${s.name}  [${s.agentType}]${s.workflow ? ` · wf:${s.workflow}` : ""}  ${badge}`);
     if (s.task) L.push(`    task: ${s.task}`);

package/lib/turn-policy.mjs

@@ -53,6 +53,29 @@ export function assignedCardRef(text) {
   return m ? Number(m.slice(1).find((g) => g != null)) : 0;
 }
 
+/// #10824: the CONTRACT MESSAGE BEING SERVED decides the card — the newest direct message's own
+/// binding: a hub-stamped `card` field, else the id its own text ASSIGNS (#7061 shape), else its
+/// first citation — never a contract queued behind it or the previous turn's card. Deference: a
+/// newest message that re-cites an older assignment is commentary on it, and #7061's reading stands.
+export function servedContractCard(messages, { session = "" } = {}) {
+  const all = (Array.isArray(messages) ? messages : []).filter(Boolean);
+  if (!all.length) return 0;
+  const direct = session ? all.filter((m) => m.to === session) : [];
+  if (!direct.length) return wakeCard(all, { session });
+  const sorted = newestLast(direct);
+  const served = sorted[sorted.length - 1];
+  const stamped = Number(served?.card);
+  if (Number.isFinite(stamped) && stamped > 0) return stamped;
+  const own = assignedCardRef(served?.text);
+  if (own) return own;
+  const named = cardRefs(served?.text);
+  if (named.length) {
+    const olderAssigned = new Set(sorted.slice(0, -1).map((m) => assignedCardRef(m?.text)).filter(Boolean));
+    if (!named.some((c) => olderAssigned.has(c))) return named[0];
+  }
+  return wakeCard(all, { session });
+}
+
 /// #7061: the card a wake batch binds to. Direct messages outrank @mentions, the NEWEST assignment wins,
 /// and only an assignment-free batch falls back to the newest message's first citation.
 export function wakeCard(messages, { session = "" } = {}) {

package/package.json

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