trantor 0.18.23 → 0.18.25

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.23",
+  "version": "0.18.25",
   "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-payload.mjs

@@ -0,0 +1,115 @@
+// Payload composition for crew-runner turn prompts — pure, unit-testable (card #5683).
+//
+// A fresh codex seat burned 306k tokens and crash-looped into a remote-compact 404. The runner-side
+// part of that: every turn re-feeds the FULL lessons block (22,298 of the 24,698 chars in codex's
+// last turn file — 90%), plus an unbounded FYI-broadcast backlog that grows across a failure streak
+// and is replayed on every redelivery, on a RESUMED session where it all stacks. So every section
+// here is capped, and the assembled prompt has ONE hard total cap with a visible truncation notice.
+// Below the caps the output is byte-identical to the old string concatenation.
+
+export const PAYLOAD_CAPS = Object.freeze({
+  wakeCount: 10,       // direct/@mention messages: keep the last ~10
+  wakeMsgChars: 2000,  // per-message body cap (the hub caps card notes at 2000 too)
+  bcastCount: 10,      // FYI broadcast context: keep the last ~10
+  bcastMsgChars: 1000,
+  lessonsCount: 15,    // top ~15 lessons, ranked by relevance to this turn's trigger
+  lessonsChars: 16000,
+  totalChars: 40000,   // ONE hard total cap for the whole prompt
+});
+
+const WORD_RE = /[a-z0-9]{4,}/g;
+const n = v => Number(v).toLocaleString("en-US");
+
+// ---- wake messages (the task): keep the last `wakeCount`, cap each body ----
+export function capWake(wake, caps = PAYLOAD_CAPS) {
+  const list = Array.isArray(wake) ? wake : [];
+  const kept = list.slice(-caps.wakeCount);
+  const lines = kept.map(m => {
+    let body = String(m?.text ?? "");
+    if (body.length > caps.wakeMsgChars)
+      body = body.slice(0, caps.wakeMsgChars) + ` …[+${n(body.length - caps.wakeMsgChars)} chars of this message dropped]`;
+    return `[${m?.from}${m?.to === "all" ? " -> all (mentions you)" : ""}]: ${body}`;
+  });
+  return { text: lines.join("\n"), kept: kept.length, total: list.length };
+}
+
+// ---- FYI broadcast context (context only): keep the last `bcastCount`, cap each body ----
+export function capBcast(bcast, caps = PAYLOAD_CAPS) {
+  const list = Array.isArray(bcast) ? bcast : [];
+  const kept = list.slice(-caps.bcastCount);
+  const lines = kept.map(m => {
+    let body = String(m?.text ?? "");
+    if (body.length > caps.bcastMsgChars)
+      body = body.slice(0, caps.bcastMsgChars) + ` …[+${n(body.length - caps.bcastMsgChars)} chars dropped]`;
+    return `[${m?.from} -> all]: ${body}`;
+  });
+  return { text: lines.join("\n"), kept: kept.length, total: list.length };
+}
+
+// ---- lessons: top `lessonsCount` ranked by word overlap with this turn's trigger, then char-capped.
+// No trigger (kickoff/pulse) → no signal to rank on, so original order stands.
+export function pickLessons(lessons, trigger = "", caps = PAYLOAD_CAPS) {
+  const list = Array.isArray(lessons) ? lessons.filter(Boolean) : [];
+  if (!list.length) return { text: "", kept: 0, total: 0 };
+  const tw = new Set(String(trigger).toLowerCase().match(WORD_RE) || []);
+  const ranked = list
+    .map((l, i) => {
+      const words = String(l?.text || "").toLowerCase().match(WORD_RE) || [];
+      let score = 0;
+      for (const w of words) if (tw.has(w)) score++;
+      return { l, i, score };
+    })
+    .sort((a, b) => b.score - a.score || a.i - b.i)
+    .slice(0, caps.lessonsCount)
+    .sort((a, b) => a.i - b.i);
+  let budget = caps.lessonsChars;
+  const lines = [];
+  for (const { l } of ranked) {
+    const line = `- [${l?.scope}] ${l?.text}`;
+    if (line.length > budget) continue;   // doesn't fit — a shorter one may
+    budget -= line.length + 1;
+    lines.push(line);
+  }
+  if (!lines.length) return { text: "", kept: 0, total: list.length };
+  return {
+    text: "\n\nLESSONS from previous crews (hard-won — follow them):\n" + lines.join("\n"),
+    kept: lines.length,
+    total: list.length,
+  };
+}
+
+// ---- one composer, one hard total cap ----
+// sections: [{ name, text, trim?, order? }] joined in order. `trim: "drop"` removes the whole
+// section when the total is over `totalChars` (lowest `order` dropped first); `trim: "truncate"`
+// cuts the section to the remaining budget. Sections without `trim` are never touched — they are
+// the runner-authored frame. The payload carries a visible notice naming every trim.
+export function composePrompt(sections, caps = PAYLOAD_CAPS) {
+  const secs = sections.map(s => ({ ...s, text: String(s?.text ?? "") }));
+  let total = secs.reduce((a, s) => a + s.text.length, 0);
+  const dropped = [];
+  const trimmable = secs.filter(s => s.trim).sort((a, b) => a.order - b.order);
+  for (const s of trimmable) {
+    if (total <= caps.totalChars) break;
+    if (s.trim === "drop") {
+      dropped.push(`${s.name} (${n(s.text.length)} chars dropped)`);
+      total -= s.text.length;
+      s.text = "";
+    } else {
+      const rest = total - s.text.length;
+      const budget = Math.max(0, caps.totalChars - rest);
+      dropped.push(`${s.name} (${n(s.text.length)} → ${n(budget)} chars)`);
+      s.text = s.text.slice(0, budget) + " …[truncated — payload hit the hard cap]";
+      total = rest + s.text.length;
+    }
+  }
+  const prompt = secs.map(s => s.text).join("")
+    + (dropped.length
+      ? `\n\n[PAYLOAD TRUNCATED: hard cap ${n(caps.totalChars)} chars — ${dropped.join("; ")}.]`
+      : "");
+  return {
+    prompt,
+    sections: secs.map(s => ({ name: s.name, chars: s.text.length })),
+    truncated: dropped.length > 0,
+    dropped,
+  };
+}

package/bin/crew-runner.mjs

@@ -16,6 +16,7 @@ import { resolveProject, resolveHub, withEnvFiles, hostId } from "../lib/project
 import { loadOrCreate } from "../lib/identity.mjs";
 import { signedHeaders } from "../lib/signed-fetch.mjs";
 import { ensureEnrolled } from "../lib/enroll.mjs";
+import { capWake, capBcast, pickLessons, composePrompt } from "./crew-payload.mjs";
 
 const AGENT = process.argv[2];
 const DIR = process.argv[3] || process.cwd();
@@ -265,6 +266,10 @@ let consecFails = 0;
 // every live seat, so two working agents spent the evening reading the same sentence.
 let announced = "";
 let lastErrText = "";
+// #5481: the turn exited 0 with a NULL/empty transcript — the Inception/Mercury trap. The provider
+// burned its whole max_tokens budget on internal reasoning and returned a null completion; the
+// runner used to read that silence as a clean turn while nothing was produced.
+let lastEmptyOutput = false;
 const ERRF = join(homedir(), ".agent-bus", `err-${AGENT}-${PROJ}.txt`);
 
 // ---- undelivered wake messages (the runner owns delivery, not the hub) ----
@@ -311,7 +316,9 @@ function loadPending() {
 // classifyFailure's set (no bare /expired/) so a healthy transcript never trips it.
 const AUTH_MARKER_RE = /unauthor|401|403|forbidden|invalid[ _-]?api[ _-]?key|authentication? failed|token expired/i;
 
-function classifyFailure(exit, errText) {
+function classifyFailure(exit, errText, emptyOutput = false) {
+  // #5481: silence with a clean exit is a failure shape, not success — see lastEmptyOutput.
+  if (emptyOutput) return "empty-output";
   const t = (errText || "").toLowerCase();
   if (exit === 127) return "missing-cli";
   // #5684: a provider BACKEND failure is not quota — it wants retry/swap, not a window wait.
@@ -328,14 +335,20 @@ function classifyFailure(exit, errText) {
 
 async function reportFailure(exit, trigger, undelivered = 0) {
   consecFails++;
-  const reason = classifyFailure(exit, lastErrText);
+  const reason = classifyFailure(exit, lastErrText, lastEmptyOutput);
   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 }).catch(() => {});
   const hint = reason === "exhausted" ? " — needs `trantor swap`"
     : reason === "auth" ? " — check credentials"
     : reason === "backend-error" ? " — provider backend error (NOT quota): retry, or `trantor swap` to another provider"
-    : reason === "missing-cli" ? " — CLI not on PATH" : "";
+    : reason === "missing-cli" ? " — CLI not on PATH"
+    // #5481: name the suspected trap, not just the symptom — the dial lives in the provider's
+    // opencode model config (limit.output), not in the runner.
+    : reason === "empty-output" ? (AGENT === "inception"
+        ? " — inception: raise max_tokens — diffusion burns budget on reasoning"
+        : " — exit 0 with NULL output: raise the provider's max_tokens (reasoning may be eating the budget)")
+    : "";
   // The count of messages this seat is HOLDING is the operator-actionable half of a failure: a
   // crashed pulse costs nothing, a crashed turn sitting on three escalations is someone waiting.
   const held = undelivered ? ` · holding ${undelivered} undelivered message${undelivered > 1 ? "s" : ""} (will retry)` : "";
@@ -423,7 +436,8 @@ function runTurn(prompt, isFirst, trigger = "kickoff") {
   cmuxStatus("building", "#4a90d9", "hammer", { priority: 50 }); herdrAgent("working");
   // inherit stdio so the window shows the agent working live; also capture for sid-parsing.
   // Tee stderr to ERRF (still shown live in the window) so a failed turn can be classified.
-  try { appendFileSync(ERRF, "", { flag: "w" }); } catch {}
+  try { appendFileSync(ERRF, "", { flag: "w" }); } catch {}   // truncate
+  lastEmptyOutput = false;
   // pipefail: without it the sid-capture `| tee` makes a FAILED turn exit 0 (tee's status),
   // so the failure reporter never fires and a dead seat heartbeats green on the bus.
   // A CLI's own explanation for quitting often goes to STDOUT, not stderr — Claude's usage-limit
@@ -473,8 +487,20 @@ function runTurn(prompt, isFirst, trigger = "kickoff") {
     effExit = 1;
     log("\x1b[31mexit 0 but turn output shows an auth failure — treating as FAILED (auth)\x1b[0m");
   }
-  telemetry({ ts: Date.now(), agent: AGENT, project: PROJ, turn: TURN, trigger, model: MODEL || "default", duration_ms: Date.now() - t0, exit: realExit, effExit, authFailed: effExit !== realExit });
-  log(`turn ended (exit ${realExit}${effExit !== realExit ? ` → effective ${effExit} (auth)` : ""}, ${((Date.now() - t0) / 1000).toFixed(0)}s)`);
+  // #5481: the Inception/Mercury trap — exit 0 with a NULL completion. ERRF is the TOTAL output
+  // capture, not just stderr: every seat's stdout is tee'd into it (`| tee -a ERRF` for the
+  // opencode family, `| tee /dev/stderr` + the stderr tee for sid seats — line ~448). So an
+  // empty ERRF on a clean exit means the turn produced nothing on EITHER stream — and every
+  // real CLI prints something on success (drill C pins that), so silence is the trap, not a
+  // quiet victory. (Integration note: this was nearly "fixed" into stdout-only detection that
+  // never fired — the tee topology is the load-bearing fact; keep this comment with it.)
+  if (realExit === 0 && effExit === 0 && !lastErrText.trim()) {
+    effExit = 1;
+    lastEmptyOutput = true;
+    log("\x1b[31mexit 0 but the turn produced NO output — treating as FAILED (empty-output)\x1b[0m");
+  }
+  telemetry({ ts: Date.now(), agent: AGENT, project: PROJ, turn: TURN, trigger, model: MODEL || "default", duration_ms: Date.now() - t0, exit: realExit, effExit, authFailed: effExit !== realExit, emptyOutput: lastEmptyOutput });
+  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
   return effExit;
 }
@@ -483,14 +509,35 @@ function runTurn(prompt, isFirst, trigger = "kickoff") {
 const KICKOFF = process.env.CREW_KICKOFF ||
   `You just joined (your arrival was already announced on the bus). 1) relay_inbox — if a contract for you is already waiting, do it now per the Rules. 2) End your turn.\n\n${RULES}`;
 
-let LESSONS = "";
+let LESSONS_RAW = [];
 async function loadLessons() {
   try {
     const { lessons } = await api(`/lessons?agent=${encodeURIComponent(AGENT)}`);
-    if (lessons?.length) LESSONS = "\n\nLESSONS from previous crews (hard-won — follow them):\n" + lessons.map(l => `- [${l.scope}] ${l.text}`).join("\n");
+    if (lessons?.length) LESSONS_RAW = lessons;
   } catch {}
 }
 
+// card #5683: every section of a turn prompt is capped (bin/crew-payload.mjs) and the whole
+// payload has ONE hard total cap. Codex burned 306k tokens into a remote-compact 404 crash-loop
+// because a resumed session re-fed the full lessons block (22,298 of the 24,698 chars in its last
+// turn file — 90%) plus an unbounded broadcast backlog on EVERY turn, redelivery after redelivery.
+// Below the caps the composition is byte-identical to the old concatenation.
+function composedTurn({ base = "", wakeText = "", ctxText = "", againText = "", tailText = "", rulesText = "", lessons = null }) {
+  const built = composePrompt([
+    { name: "base", text: base },
+    { name: "wake", text: wakeText, trim: "truncate", order: 4 },
+    { name: "ctx", text: ctxText, trim: "drop", order: 1 },
+    { name: "again", text: againText },
+    { name: "tail", text: tailText },
+    { name: "rules", text: rulesText, trim: "drop", order: 3 },
+    { name: "lessons", text: lessons?.text || "", trim: "drop", order: 2 },
+  ]);
+  const parts = built.sections.filter(s => s.chars).map(s => `${s.name} ${s.chars.toLocaleString("en-US")}c`).join(" · ");
+  const lessonsNote = lessons && lessons.total ? ` (lessons ${lessons.kept}/${lessons.total})` : "";
+  log(`payload: ${parts}${lessonsNote} → ${built.prompt.length.toLocaleString("en-US")}c${built.truncated ? ` \x1b[33mTRUNCATED — ${built.dropped.join("; ")}\x1b[0m` : ""}`);
+  return built.prompt;
+}
+
 (async () => {
   await loadLessons();
   // start cursor at the CURRENT tip so we don't replay history
@@ -520,7 +567,7 @@ async function loadLessons() {
   let deliveryFails = 0;      // consecutive failed attempts at the SAME pending batch
   if (pendingWake.length) log(`\x1b[33m${pendingWake.length} message(s) survived from a previous run — redelivering\x1b[0m`);
 
-  const ec0 = runTurn(KICKOFF + LESSONS, true, "kickoff");
+  const ec0 = runTurn(composedTurn({ base: KICKOFF, lessons: pickLessons(LESSONS_RAW, "") }), true, "kickoff");
   if (ec0) await reportFailure(ec0, "kickoff", pendingWake.length);   // a failed kickoff = the "fired up, died, nobody knew" case
   let lastTurnAt = Date.now();
   if (PULSE_MS) log(`pulse armed — mission re-read every ${Math.round(PULSE_MS / 1000)}s (${MISSION_FILE})`);
@@ -530,7 +577,7 @@ async function loadLessons() {
     // pulse first: a due mission beat runs even on a silent bus. Measured from the END of the
     // last turn, so a long turn doesn't stack an immediate pulse on top of itself.
     if (PULSE_MS && Date.now() - lastTurnAt >= PULSE_MS) {
-      const ecp = runTurn(PULSE_PROMPT + "\n\n" + RULES + LESSONS, false, "pulse");
+      const ecp = runTurn(composedTurn({ base: PULSE_PROMPT + "\n\n", rulesText: RULES, lessons: pickLessons(LESSONS_RAW, PULSE_PROMPT) }), false, "pulse");
       if (ecp) await reportFailure(ecp, "pulse"); else await reportHealthy();
       lastTurnAt = Date.now();
       log("parked — waiting for the next message or pulse");
@@ -589,22 +636,33 @@ async function loadLessons() {
   // queued, on disk, with a backoff — which is the whole point of the change.
   async function deliverWake() {
     const wake = pendingWake;
-    const ctx = pendingBcast.length ? `\nFYI broadcasts since your last turn (context only):\n${pendingBcast.map(m => `[${m.from} -> all]: ${m.text}`).join("\n")}\n` : "";
-    const lines = wake.map(m => `[${m.from}${m.to === "all" ? " -> all (mentions you)" : ""}]: ${m.text}`).join("\n");
+    const wakeCapped = capWake(wake);
+    const bcastCapped = capBcast(pendingBcast);
+    const wakeText = wakeCapped.text
+      ? `NEW BUS MESSAGE${wake.length > 1 ? "S" : ""} for you:\n${wakeCapped.text}\n`
+      : "";
+    const ctxText = bcastCapped.text
+      ? `\nFYI broadcasts since your last turn (context only):\n${bcastCapped.text}\n`
+      : "";
     // Say plainly that this is a second look. Without it the model re-reads an old escalation as
     // brand new and can redo work it already half-did before the turn died.
-    const again = deliveryFails
+    const againText = deliveryFails
       ? `\n(REDELIVERY, attempt ${deliveryFails + 1} — an earlier turn failed before acting on ${wake.length > 1 ? "these" : "this"}. Check what you already did before repeating it.)\n`
       : "";
-    const prompt = `NEW BUS MESSAGE${wake.length > 1 ? "S" : ""} for you:\n${lines}\n${ctx}${again}\nAct on what's addressed to you, then end your turn.\n\n${RULES}`;
     await loadLessons();
+    const lessons = pickLessons(LESSONS_RAW, wakeCapped.text + " " + bcastCapped.text);
     const trigger = wake.some(m => m.to === SESSION) ? "direct message" : "@mention";
     // Who is owed an answer, captured BEFORE the turn: pendingWake is cleared on success.
     const assigners = [];
     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 = String(wake[0]?.text || "").replace(/\s+/g, " ").trim().slice(0, 90);
     const tStart = Date.now();
-    const ec = runTurn(prompt + LESSONS, false, deliveryFails ? `${trigger} (redelivery)` : trigger);
+    const prompt = composedTurn({
+      wakeText, ctxText, againText,
+      tailText: "\nAct on what's addressed to you, then end your turn.\n\n",
+      rulesText: RULES, lessons,
+    });
+    const ec = runTurn(prompt, false, deliveryFails ? `${trigger} (redelivery)` : trigger);
     const secs = Math.round((Date.now() - tStart) / 1000);
     if (ec) {
       deliveryFails++;

package/package.json

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