trantor 0.18.103 → 0.18.105

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.103",
+  "version": "0.18.105",
   "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/core.mjs

@@ -4,6 +4,9 @@ import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { STATE_FLAGS } from "../../lib/state/flags.mjs";
 
+// the card limits the runner reads (#11559 budget, #11855 context cap), tunable at `trantor up`
+export const RUNNER_LIMIT_FLAGS = ["TRANTOR_CARD_TOKEN_BUDGET", "TRANTOR_CARD_CONTEXT_CAP", "TRANTOR_CARD_CAP_MIN_STEPS", "TRANTOR_CARD_CAP_MAX_HANDOFFS"];
+
 export const ROOT = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
 
 export function commandExists(name, env = process.env) {
@@ -149,7 +152,7 @@ export function gridColumns(size) {
 // in lib/state/flags.mjs beside the resolver: the launcher env stays the forwarder (the runner boots
 // before any file is sourced), and #7159 lets the runner fall back to ~/.agent-bus/.env itself, so a
 // flag documented there finally arms the seat that reads it.
-const FORWARDED_ENV = STATE_FLAGS;
+const FORWARDED_ENV = [...STATE_FLAGS, ...RUNNER_LIMIT_FLAGS];
 
 export function runnerCommand(ctx, agent, model = "", effort = null, persona = agent) {
   const forwarded = FORWARDED_ENV

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";
@@ -250,7 +250,9 @@ const CLI = {
   // kimi-code (successor to kimi-cli) has no --print (-p alone is non-interactive), REJECTS
   // --yolo in prompt mode (prompt mode auto-approves tools), and emits session_-prefixed ids.
   kimi:     { first: `kimi{M} -p "$(cat {P})" < /dev/null`,
-              next:  `kimi{M} -r {SID} -p "$(cat {P})" < /dev/null`, mflag: " --model ", sid: /To resume this session: kimi -r (\S+)/ },
+              // -S resumes; kimi-code 0.34 silently ignores -r (its own exit hint still prints -r) and
+              // opens a new session, so every kimi turn ran cold with no history
+              next:  `kimi{M} -S {SID} -p "$(cat {P})" < /dev/null`, mflag: " --model ", sid: /To resume this session:\s*kimi (?:-r|-S|--session) (\S+)/ },
   // #6154: `run -c` resumes the globally last session on this machine, any project's, and its stored
   // directory becomes the path root. So every spawn pins --dir and a resume pins -s (ocSid below).
   deepseek: { first: `opencode run --dir {DIR}{M} "$(cat {P})"`,
@@ -625,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`);
@@ -1051,7 +1060,8 @@ exit $turn_exit`;
     if (env.turn) log(`state step: ${describeTurn(env.turn)} · ${costLine(env.cost)}`);
     else log(`\x1b[33mstate step: no TurnResult — ${env.error}\x1b[0m`);
   }
-  if (cli.sid && r.stdout) { const m = r.stdout.match(cli.sid); if (m) sid = m[1]; }
+  // kimi prints its resume hint on stderr, so a stdout-only match never captured its sid
+  if (cli.sid) { const all = [...`${r.stdout || ""}\n${ownOut}`.matchAll(new RegExp(cli.sid.source, "g"))]; if (all.length) sid = all.at(-1)[1]; }
   // #6154: the opencode family prints no sid on stdout — the id comes from opencode's own DB,
   // keyed by the worktree the session was created in. Fail-open: nothing found leaves sid empty,
   // and the next turn starts fresh rather than resuming whatever other project ran last.
@@ -1146,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);
@@ -1167,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;
@@ -1689,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");
   }
@@ -1758,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);
@@ -1770,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/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.103",
+  "version": "0.18.105",
   "type": "module",
   "bin": {
     "trantor": "bin/cli.mjs"