trantor 0.18.104 → 0.18.106

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.104",
+  "version": "0.18.106",
   "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/balances.mjs

@@ -1,14 +1,13 @@
 #!/usr/bin/env node
 /* oxlint-disable anti-slop/no-runtime-typeof -- SAFETY: config.json is user-editable external input; thresholds validates its optional number/object fields at that I/O boundary. */
-// trantor balances — show how much credit is left on each prepaid provider (DeepSeek, Kimi, OpenRouter…)
-// so you can refill BEFORE a build stalls. Reads keys from the environment, queries each provider's
-// balance API, prints them, and pushes the snapshot to the hub so the dashboard + other sessions see it.
-//
+// trantor balances: how much credit is left on each provider, so you can refill before a build
+// stalls. Queries each provider with the env keys and pushes the snapshot to the hub.
 // Usage: trantor balances [--json] [--no-push]
 import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { fetchBalances, isLow, fmtBalance, DEFAULT_LOW, DEFAULT_LOW_QUOTA_PCT } from "../lib/balances.mjs";
+import { fetchBalances, isLow, fmtBalance, snapshotPayload, DEFAULT_LOW, DEFAULT_LOW_QUOTA_PCT } from "../lib/balances.mjs";
+import { hostId } from "../lib/project.mjs";
 import { detectedCliBalanceRows } from "../lib/providers.mjs";
 import { loadProfile } from "./profile.mjs";
 import { resolveKeys } from "../lib/provider-keys.mjs";
@@ -19,9 +18,10 @@ const noPush = args.includes("--no-push");
 
 // API-key providers stay profile-scoped so ambient keys are never scraped. Claude and Codex are
 // machine CLI logins: the registry admits them from binary + credential + live-probe detection.
-const configured = Object.keys(loadProfile().providers || {});
+const profileProviders = loadProfile().providers || {};
+const configured = Object.keys(profileProviders);
 
-// Signed via the shared client (2026-07-31, agent-UX audit): unsigned POST rejected under enforce.
+// Signed via the shared client: an unsigned POST is rejected under enforce.
 import { signedPost } from "../hooks/lib/api.mjs";
 let _qpct = DEFAULT_LOW_QUOTA_PCT;
 function thresholds() {
@@ -35,14 +35,10 @@ const profileScoped = await fetchBalances(env, { only: configured.filter((provid
 const balances = [...detected, ...profileScoped];
 const low = thresholds();
 
-// push the snapshot to the hub (best-effort) so the dashboard + warning line can use it.
-// TWO pushes on purpose: the project hub (fleet visibility) AND the LOCAL hub explicitly —
-// the desktop app reads balances from 127.0.0.1 because the data is machine-local, and the
-// project-resolved push goes to the REMOTE hub for pinned projects. That mismatch left the
-// local snapshot 11 days stale on 2026-08-28: the header chips faithfully rendered Aug-16
-// numbers, dimmed, while fresh pushes landed on a hub the app never asks.
+// Push the snapshot to the project hub and the LOCAL hub (best-effort); the machine key and
+// profile let a shared hub keep one snapshot per machine.
 if (!noPush) {
-  const snap = { balances, ts: Date.now() };
+  const snap = snapshotPayload(balances, { machine: hostId(), profile: profileProviders });
   try { await signedPost("/balances", snap, { timeoutMs: 2500 }); } catch {}
   try { await signedPost("http://127.0.0.1:4477/balances", snap, { timeoutMs: 2500 }); } catch {}
 }

package/bin/crew-runner.mjs

@@ -23,7 +23,7 @@ import {
 } from "../lib/classify-failure.mjs";
 import { capWake, capBcast, pickLessons, composePrompt, contractBase, baseLine } from "./crew-payload.mjs";
 import {
-  cardRefs, servedContractCard, carriesWork, parseTurnTokens, parseResetAt, reasonWithBalances, quotaResetAt, PARKING_REASONS,
+  cardRefs, servedContractCard, carriesWork, parseTurnTokens, parseResetAt, reasonWithBalances, quotaResetAt, queuedWording, turnDelivered, budgetPause, PARKING_REASONS,
   senderProjectOf, isLinkedProject, stateSkipReason, isMessageCardTitle, OPEN_CARD_STATUSES,
   CUT_CHAIN_PARK_MIN, cutChainEvidence, isBoundedPark, askDuringTurn, askedVerdict,
 } from "../lib/turn-policy.mjs";
@@ -627,6 +627,13 @@ async function notifyAssigners(pairs, text) {
 async function latestBusEventId() {
   try { const r = await api("/events?limit=1"); return Number(r?.latest) || 0; } catch { return 0; }
 }
+// #11860: this seat's direct messages since `seq`, to tell a reply to the assigner from silence.
+async function busMessagesSince(seq) {
+  try {
+    const r = await api(`/events?by=${encodeURIComponent(SESSION)}&since=${seq}&limit=500`);
+    return Array.isArray(r?.events) ? r.events.filter(e => e?.type === "message") : [];
+  } catch { return []; }
+}
 async function busActivitySince(seq) {
   try {
     const r = await api(`/events?by=${encodeURIComponent(SESSION)}&since=${seq}&limit=500`);
@@ -1149,9 +1156,10 @@ exit $turn_exit`;
   // Judged on hub reads of the card status; a failed read keeps today's label, never no-delivery.
   let cardStatusAtEnd = "", noDelivery = false, blockedVerdict = "";
   if (!cut && !opts.state && realExit === 0 && effExit === 0 && sessionCard > 0 && cardStatusBefore !== null) {
-    let endStatus = null;
+    let endStatus = null, endTask = null;
     try {
       const { task } = await api(`/card?project=${encodeURIComponent(PROJ)}&id=${sessionCard}`);
+      endTask = task;
       endStatus = task ? String(task.status || "") : null;
       const freshNote = (task?.log || []).filter(n => n.by === SESSION && n.ts >= t0
         && !cardLogBefore.some(old => old.ts === n.ts && old.by === n.by && old.text === n.text)).at(-1);
@@ -1170,7 +1178,11 @@ exit $turn_exit`;
       // still IS testing/done: a mid-turn bounce to doing (endStatus doing) reopens the contract.
       const alreadyDelivered = ["testing", "done"].includes(cardStatusBefore)
         && ["testing", "done"].includes(endStatus);
-      noDelivery = !newCommit && !moved && !alreadyDelivered && !askVerdict && !blockedVerdict;
+      noDelivery = !alreadyDelivered && !askVerdict && !blockedVerdict && !newCommit && !moved;
+      if (noDelivery) {
+        const events = await busMessagesSince(busSeqBefore);
+        noDelivery = !turnDelivered({ newCommit, moved, session: SESSION, t0, cardLogBefore, cardLog: endTask?.log || [], events, assigners: opts.assigners, seqBefore: busSeqBefore });
+      }
     }
   }
   lastNoDelivery = noDelivery;
@@ -1692,7 +1704,7 @@ async function resolveWakeCard(messages, { session }) {
     }
     // Respect an active backoff: a new message during an outage joins the batch, it does not
     // reset the clock and hammer a CLI that is already failing.
-    if (Date.now() < retryAt) { log(`queued — ${pendingWake.length} undelivered, next attempt in ${Math.max(0, Math.round((retryAt - Date.now()) / 1000))}s`); continue; }
+    if (Date.now() < retryAt) { log(queuedWording(retryAt, parkState?.reason, AGENT, pendingWake.length)); continue; }
     await deliverWake();
     log("parked — waiting for the next message");
   }
@@ -1761,7 +1773,7 @@ async function resolveWakeCard(messages, { session }) {
       await releaseDutyNudgeClaims({ ids: skippedNudgeIds, statePath: DUTY_NUDGE_STATE, owner: dutyOwner });
     }
     const claimedIds = new Set(dutyPlan.items.map(item => item.id));
-    const wakeForTurn = DUTY_NUDGES
+    let wakeForTurn = DUTY_NUDGES
       ? wake.filter(message => {
         const escalation = dutyEscalations([message])[0];
         return !escalation || claimedIds.has(escalation.id);
@@ -1773,6 +1785,21 @@ async function resolveWakeCard(messages, { session }) {
       log("duty escalation already nudged or reserved by another turn — consumed without a duplicate model wake");
       return;
     }
+    // #11864: the pause lifts when its card moves on, and a newer contract for another card beats
+    // the stale messages that still cite the paused one.
+    if (budgetStop) {
+      const status = await api(`/card?project=${encodeURIComponent(PROJ)}&id=${budgetStop.card}`).then(r => String(r?.task?.status || "")).catch(() => "");
+      const bp = budgetPause({ paused: budgetStop, status, messages: wakeForTurn, session: SESSION });
+      if (bp.action === "lift") {
+        log(`#${budgetStop.card} is ${status} — token-budget pause lifted`);
+        budgetStop = null; budgetRetryAt = 0; cardTokens = 0;
+      } else if (bp.action === "bind") {
+        log(`#${budgetStop.card} is paused over its token budget — serving the newer contract for #${bp.card}, dropping ${bp.drop.length} stale message(s)`);
+        wakeForTurn = wakeForTurn.filter(m => !bp.drop.includes(m));
+        pendingWake = pendingWake.filter(m => !bp.drop.includes(m));
+        savePending(pendingWake, pendingBcast);
+      }
+    }
     const wakeCapped = capWake(wakeForTurn);
     const bcastCapped = capBcast(pendingBcast);
     const wakeText = wakeCapped.text

package/hooks/lib/balance-check.mjs

@@ -5,7 +5,8 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { fetchBalances, isLow, fmtBalance, DEFAULT_LOW, DEFAULT_LOW_QUOTA_PCT } from "../../lib/balances.mjs";
+import { fetchBalances, isLow, fmtBalance, snapshotPayload, DEFAULT_LOW, DEFAULT_LOW_QUOTA_PCT } from "../../lib/balances.mjs";
+import { hostId } from "../../lib/project.mjs";
 import { loadProfile } from "../../bin/profile.mjs";
 import { resolveKeys } from "../../lib/provider-keys.mjs";
 import { signedPost } from "./api.mjs";
@@ -38,7 +39,7 @@ export async function maybeCheckBalances() {
   if (!Array.isArray(balances) || !balances.length) { try { writeFileSync(STAMP, JSON.stringify({ ts: Date.now(), low: [] })); } catch {} return { low: [] }; }
 
   // push the fresh snapshot to the hub for the dashboard + other sessions (best-effort, signed)
-  const snap = { balances, ts: Date.now(), by: process.env.TRANTOR_SESSION || "" };
+  const snap = snapshotPayload(balances, { machine: hostId(), profile: loadProfile().providers, by: process.env.TRANTOR_SESSION || "" });
   await signedPost("/balances", snap, { timeoutMs: 2000 });
   // The desktop reads balances from the LOCAL hub (machine-local data); a pinned project's
   // default push lands on the REMOTE one — the 11-day-stale-header bug. Push both.

package/hooks/statusline.mjs

@@ -40,6 +40,8 @@ async function main() {
   try { writeFileSync(join(dir, "usage-claude-live.json"), JSON.stringify({ ts: Date.now(), ...payload })); } catch {}
   // SECONDARY, best-effort: the hub copy, for dashboard surfaces that read hub state.
   const { signedPost } = await import("./lib/api.mjs");
+  const { hostId } = await import("../lib/project.mjs");
+  payload.machine = hostId();
   await signedPost("/usage/claude", payload, { timeoutMs: 2500 });
 }
 

package/hub/routes/admin.mjs

@@ -387,8 +387,21 @@ export async function routeAdmin({ req, res, q, P, auth, ctx }) {
       const b = await body(req);
       const entries = Array.isArray(b.balances) ? b.balances.slice(0, 30) : [];
       const ts = (Number.isFinite(b.ts) && b.ts > 0) ? Math.floor(b.ts) : now();
+      const by = String(b.by || "").slice(0, 120);
       // only accept a newer snapshot (avoid an older session clobbering a fresh push)
-      if (ts >= (state.balances?.ts || 0)) { state.balances = { ts, by: String(b.by || "").slice(0, 120), entries }; markDirty(); }
+      if (ts >= (state.balances?.ts || 0)) { state.balances = { ts, by, entries }; markDirty(); }
+      // Per-machine copy: two Macs on one hub each keep their own providers and profile.
+      const machine = String(b.machine || "").trim().slice(0, 60);
+      if (machine) {
+        const byM = (state.balancesByMachine ||= {});
+        if (ts >= (byM[machine]?.ts || 0)) {
+          const prof = (b.profile && typeof b.profile === "object" && !Array.isArray(b.profile)) ? Object.fromEntries(Object.entries(b.profile).slice(0, 30)) : {};
+          byM[machine] = { ts, by, entries, profile: prof };
+          const keys = Object.keys(byM);
+          if (keys.length > 20) for (const k of keys.sort((x, y) => byM[x].ts - byM[y].ts).slice(0, keys.length - 20)) delete byM[k];
+          markDirty();
+        }
+      }
       return json(res, 200, { ok: true });
     }
     // USAGE v2: the Claude statusline sidechannel. Claude Code >=2.1.80 pipes rate_limits into the
@@ -402,14 +415,23 @@ export async function routeAdmin({ req, res, q, P, auth, ctx }) {
       const wins = [["fiveHour", "5h"], ["sevenDay", "7d"], ["fable", "Fable"]]
         .map(([k, n]) => win(b[k], n)).filter(Boolean);
       if (!wins.length) return json(res, 400, { error: "no usable windows" });
-      state.balances ||= { ts: 0, by: "", entries: [] };
-      let e = state.balances.entries.find(x => x.provider === "claude");
-      if (!e) { e = { provider: "claude", label: "Claude", kind: "windows", ok: true, windows: [] }; state.balances.entries.push(e); }
+      const patchSnaps = [(state.balances ||= { ts: 0, by: "", entries: [] })];
+      const machine = String(b.machine || "").trim().slice(0, 60);
+      if (machine) patchSnaps.push(((state.balancesByMachine ||= {})[machine] ||= { ts: now(), by: "", entries: [], profile: {} }));
+      const claudeEntry = (snap) => {
+        let c = snap.entries.find(x => x.provider === "claude");
+        if (!c) { c = { provider: "claude", label: "Claude", kind: "windows", ok: true, windows: [] }; snap.entries.push(c); }
+        return c;
+      };
+      const e = claudeEntry(patchSnaps[patchSnaps.length - 1]);   // dedupe against the most specific copy
       // Same-value posts inside 30s are dropped (the statusline ticks ~3x/sec while streaming).
       const sig = JSON.stringify(wins);
       if (e._liveSig === sig && now() - (e.liveTs || 0) < 30_000) return json(res, 200, { ok: true, deduped: true });
-      for (const w of wins) { const cur = (e.windows ||= []).find(x => x.name === w.name); if (cur) Object.assign(cur, w); else e.windows.push(w); }
-      e.ok = true; e.liveTs = now(); e._liveSig = sig; e.liveSource = "statusline";
+      for (const snap of patchSnaps) {
+        const t = claudeEntry(snap);
+        for (const w of wins) { const cur = (t.windows ||= []).find(x => x.name === w.name); if (cur) Object.assign(cur, w); else t.windows.push({ ...w }); }
+        t.ok = true; t.liveTs = now(); t._liveSig = sig; t.liveSource = "statusline";
+      }
       markDirty();
       return json(res, 200, { ok: true, windows: wins.length });
     }
@@ -422,7 +444,12 @@ export async function routeAdmin({ req, res, q, P, auth, ctx }) {
         : (e.remaining != null && e.remaining < (low[e.currency] ?? low.USD ?? 5)));
       const ALIAS = { kimi: "moonshot", moonshot: "moonshot", glm: "zhipu", zai: "zhipu", zhipu: "zhipu" };
       const canonP = p => ALIAS[p] || p;
-      let prof = {}; try { prof = JSON.parse(readFileSync(join(homedir(), ".agent-bus", "profile.json"), "utf8")).providers || {}; } catch {}
+      // ?machine=X serves that machine's own snapshot and profile; otherwise the legacy latest.
+      const mSnap = q.machine ? state.balancesByMachine?.[String(q.machine).trim().slice(0, 60)] : null;
+      const snap = mSnap || state.balances;
+      let prof = {};
+      if (mSnap?.profile && Object.keys(mSnap.profile).length) prof = mSnap.profile;
+      else { try { prof = JSON.parse(readFileSync(join(homedir(), ".agent-bus", "profile.json"), "utf8")).providers || {}; } catch {} }
       const profByCanon = {}; for (const [p, v] of Object.entries(prof)) profByCanon[canonP(p)] = v;
       const detectedCli = new Set(["claude", "codex"]);
       // API-key rows remain profile-scoped so a stray ambient key never appears. Claude and Codex
@@ -430,7 +457,7 @@ export async function routeAdmin({ req, res, q, P, auth, ctx }) {
       // missing quota declaration must not hide those machine-login rows from the bottom bar. A
       // prepaid entry that ERRORED but is a subscription per profile is really one (401 expected).
       const isSub = (t) => !!t && t !== "api";   // capped-sub / high-sub → a subscription (nothing to refill)
-      const entries = (state.balances?.entries || []).filter(e => detectedCli.has(e.provider) || profByCanon[canonP(e.provider)]).map(e => {
+      const entries = (snap?.entries || []).filter(e => detectedCli.has(e.provider) || profByCanon[canonP(e.provider)]).map(e => {
         const pv = profByCanon[canonP(e.provider)];
         if (!e.ok && isSub(pv?.tier)) return { provider: e.provider, label: e.label, kind: "subscription", plan: pv.plan, ok: true, remaining: null, low: false };
         return { ...e, low: lowOf(e) };
@@ -441,8 +468,8 @@ export async function routeAdmin({ req, res, q, P, auth, ctx }) {
       const subs = Object.entries(prof)
         .filter(([p, v]) => !detectedCli.has(p) && isSub(v?.tier) && !known.has(canonP(p)))
         .map(([p, v]) => ({ provider: p, label: p, kind: "subscription", plan: v.plan, ok: true, remaining: null, low: false }));
-      return json(res, 200, { ts: state.balances?.ts || 0, by: state.balances?.by || "", thresholds: low,
-        entries: [...entries, ...subs], lowCount: entries.filter(e => e.low).length, stale: (now() - (state.balances?.ts || 0)) > 6 * 3600e3 });
+      return json(res, 200, { ts: snap?.ts || 0, by: snap?.by || "", thresholds: low,
+        entries: [...entries, ...subs], lowCount: entries.filter(e => e.low).length, stale: (now() - (snap?.ts || 0)) > 6 * 3600e3 });
     }
     // Rebuild cc-subagent notional cards for a project from recomputed on-disk transcript costs
     // (`trantor recost`). REPLACES the project's existing cc-subagent cards with the supplied set so the

package/hub/store.mjs

@@ -6,7 +6,7 @@ import { DEFAULT_ORG } from "../lib/store-contract.mjs";
 
 export async function createStoreRuntime({ STORE_KIND, PG_URL, ORG_ID, DATA }) {
 function emptyState() {
-  return { messages: [], peers: {}, seq: 0, tasks: [], taskSeq: 0, projectMeta: {}, lessons: [], events: [], cardEventsBackfilled: false, aliases: {}, phaseMeta: {}, verifyGates: [], verifyGateSeq: 0, proposals: [], proposalSeq: 0, balances: { ts: 0, by: "", entries: [] }, subagentCostReset: false, handoffLog: [], identities: {}, inviteTokens: {}, focus: {}, orgPolicy: {}, overseerState: {}, instances: {}, dutySession: "", contractReap: {}, eventSeq: 0 };
+  return { messages: [], peers: {}, seq: 0, tasks: [], taskSeq: 0, projectMeta: {}, lessons: [], events: [], cardEventsBackfilled: false, aliases: {}, phaseMeta: {}, verifyGates: [], verifyGateSeq: 0, proposals: [], proposalSeq: 0, balances: { ts: 0, by: "", entries: [] }, balancesByMachine: {}, subagentCostReset: false, handoffLog: [], identities: {}, inviteTokens: {}, focus: {}, orgPolicy: {}, overseerState: {}, instances: {}, dutySession: "", contractReap: {}, eventSeq: 0 };
 }
 
 const CARD_LOG_MAX = 40;
@@ -103,6 +103,7 @@ function normalizeState(loaded = {}) {
   s.proposals = Array.isArray(loaded.proposals) ? loaded.proposals : [];
   s.proposalSeq = Number(loaded.proposalSeq || Math.max(0, ...s.proposals.map(p => Number(p.id) || 0))) || 0;
   s.balances = loaded.balances && typeof loaded.balances === "object" ? loaded.balances : { ts: 0, by: "", entries: [] };
+  s.balancesByMachine = loaded.balancesByMachine && typeof loaded.balancesByMachine === "object" ? loaded.balancesByMachine : {};
   s.subagentCostReset = !!loaded.subagentCostReset;
   s.handoffLog = Array.isArray(loaded.handoffLog) ? loaded.handoffLog : [];
   s.identities = loaded.identities && typeof loaded.identities === "object" ? loaded.identities : {};

package/lib/balances.mjs

@@ -313,3 +313,11 @@ export function fmtReset(t) {
   if (hrs < 48) return `${Math.round(hrs)}h`;
   return `${Math.round(hrs / 24)}d`;
 }
+
+// The snapshot a machine pushes to a hub: its balances plus the machine key and the provider
+// profile, so a shared hub can keep one snapshot per machine and filter by that machine's profile.
+export function snapshotPayload(balances, { machine, profile, by, ts = Date.now() }) {
+  const snap = { balances, ts, machine: String(machine || ""), profile: profile ?? {} };
+  if (by) snap.by = by;
+  return snap;
+}

package/lib/store-pg.mjs

@@ -162,6 +162,7 @@ function kvFromState(state) {
       eventSeq: Number(state.eventSeq || 0),
       inviteTokens: state.inviteTokens || {},
       instances: state.instances || {},
+      balancesByMachine: state.balancesByMachine || {},
     },
     subagentCostReset: !!state.subagentCostReset,
     seq: Number(state.seq || 0),
@@ -731,6 +732,7 @@ export class PgStore {
       identities,
       inviteTokens: meta.inviteTokens && typeof meta.inviteTokens === "object" ? meta.inviteTokens : {},
       instances: meta.instances && typeof meta.instances === "object" ? meta.instances : {},
+      balancesByMachine: meta.balancesByMachine && typeof meta.balancesByMachine === "object" ? meta.balancesByMachine : {},
       focus: kv.focus && typeof kv.focus === "object" ? kv.focus : {},
       overseerState: meta.overseerState || {},
       orgPolicy: kv.orgPolicy && typeof kv.orgPolicy === "object" ? kv.orgPolicy : {},

package/lib/turn-policy.mjs

@@ -173,8 +173,11 @@ const RESET_ABS_RE = new RegExp(
   "i",
 );
 const RESET_REL_RE = /try again in\s+(\d+)\s*(second|minute|hour|day)s?/i;
+// A fixed rolling window ("5-hour usage limit") names no timestamp; the error time + N hours is the bound.
+const RESET_WINDOW_RE = /\b(\d{1,3})[-\s]hours?\s+(?:usage\s+)?limit/i;
 
 /// The epoch ms at which this seat may be retried, or 0 when the output named no time.
+/// A "<N>-hour usage limit" window counts as N hours from `now`, the moment of the error.
 export function parseResetAt(text, now = Date.now()) {
   const s = String(text || "");
 
@@ -191,9 +194,50 @@ export function parseResetAt(text, now = Date.now()) {
     if (unit) return now + Number(rel[1]) * unit;
   }
 
+  const win = RESET_WINDOW_RE.exec(s);
+  if (win && Number(win[1]) > 0) return now + Number(win[1]) * 3600e3;
+
   return 0;
 }
 
+/// #11860: a design, research or drill step legitimately ends with no commit and the card unmoved.
+/// It still delivered when this seat wrote a note on its OWN card during the turn, or messaged
+/// the contract's sender directly. Reading and saying nothing stays no-delivery.
+export function turnDelivered({ newCommit, moved, session, t0, cardLogBefore = [], cardLog = [], events = [], assigners = [], seqBefore = 0 }) {
+  if (newCommit || moved) return true;
+  const ownNote = (cardLog || []).some(n => n && n.by === session && n.ts >= t0
+    && !(cardLogBefore || []).some(old => old.ts === n.ts && old.by === n.by && old.text === n.text));
+  if (ownNote) return true;
+  const owed = new Set((assigners || []).map(a => a && a.from).filter(f => f && f !== session));
+  return (events || []).some(e => e && e.type === "message" && e.by === session
+    && Number(e.id) > seqBefore && owed.has(e.toSession));
+}
+
+/// #11864: what a card's token-budget pause means for this wake batch. `lift` once the paused card
+/// is in testing/done/failed; `bind` when the batch also holds a newer contract for ANOTHER card
+/// (the turn serves that card, and `drop` are the stale messages for the paused one); else `hold`.
+/// `none` when nothing in the batch cites the paused card.
+export function budgetPause({ paused, status = "", messages = [], session = "" }) {
+  if (!paused || !(paused.card > 0)) return { action: "none" };
+  if (["testing", "done", "failed"].includes(status)) return { action: "lift" };
+  const all = (Array.isArray(messages) ? messages : []).filter(Boolean);
+  if (!all.some((m) => cardRefs(m.text).includes(paused.card) || Number(m.card) === paused.card)) return { action: "none" };
+  const own = (m) => (Number(m.card) > 0 ? Number(m.card) : (assignedCardRef(m.text) || cardRefs(m.text)[0] || 0));
+  const direct = newestLast(all.filter((m) => !session || m.to === session));
+  const fresh = direct.at(-1);
+  const next = fresh ? own(fresh) : 0;
+  if (!(next > 0) || next === paused.card) return { action: "hold" };
+  const drop = all.filter((m) => m !== fresh && cardRefs(m.text).includes(paused.card) && !cardRefs(m.text).includes(next));
+  return { action: "bind", card: next, drop };
+}
+
+/// The "queued" log line for an undelivered batch behind a park: a clock time when the retry is
+/// bounded, a `trantor up` pointer when it is not.
+export function queuedWording(retryAt, reason, agent, undelivered, now = Date.now()) {
+  if (retryAt >= Number.MAX_SAFE_INTEGER / 2) return `parked (${reason || "exhausted"}) until \`trantor up ${agent}\` — ${undelivered} undelivered`;
+  return `queued — ${undelivered} undelivered, next attempt at ${new Date(retryAt).toLocaleTimeString()} (in ${Math.max(0, Math.round((retryAt - now) / 1000))}s)`;
+}
+
 /// #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.

package/package.json

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