@hicaru/pi-rlm 0.3.19 → 0.3.21

package/src/core/budget.ts

@@ -1,12 +1,13 @@
 /**
  * Token budget cascade (port of the v4/v5 `budget.py` engine).
  *
- * The budget is the PRIMARY run-length control: above COMPACTION_CEILING_TOKENS the cap is
+ * The budget is an OUTLIER CEILING, not a progress control (progress = maxIterations):
+ * windows at/below COMPACTION_CEILING_TOKENS are never metered; above it the cap is
  * max(ceiling, budgetShare × model context window) — the share can only stretch the working
- * budget further out, never cut under the ceiling;
- * one soft wrap-up turn at `softFrac` of the cap, and at the hard cap a deterministic
- * handoff (`distillTrajectory`) is handed to a fresh continuation run — chain-capped at
- * `maxContinuations`. Wall-clock timeouts stay only as hang backstops.
+ * budget further out, never cut under the ceiling. One soft wrap-up turn at `softFrac` of
+ * the cap, and at the hard cap a deterministic handoff (`distillTrajectory`) is handed to
+ * a fresh continuation run — chain-capped at `maxContinuations`. Wall-clock timeouts stay
+ * only as hang backstops.
  *
  * v5 counts the whole tree (root turns + sub-LLM usage) against the cap; the engine feeds
  * the run's LimitGuard totals in via `observeTotal` after every turn. Each continuation
@@ -30,22 +31,25 @@ type BudgetState = "" | "soft" | "hard";
 
 /** v5 verbatim: the soft wrap-up note prepended to the single turn after crossing soft. */
 export const WRAP_UP_BUDGET: string =
-  "[budget] ~80% of your token cap — ONE turn left. If the task is answerable NOW, finalize " +
-    '(set answer["ready"] = True). Otherwise print a compact findings dump: what is confirmed, ' +
-    "current file/line or search position, and the exact next step — a fresh continuation picks " +
-    "it up. Do not start new exploration.";
+  "[budget] ~80% of this run's outlier cap — ONE turn left. If the task is answerable NOW, " +
+    'finalize (set answer["ready"] = True). Otherwise print a compact findings dump IN THE ' +
+    "NOTES: what is confirmed, current file/line or search position, and the exact next " +
+    "step — a continuation picks it up. The task, the packed context and the ledger carry " +
+    "over; only repl variables are re-derived. Do not start new exploration.";
 
 export const DEFAULT_NEXT_STEP: string =
   "continue the probing that was in flight, then finalize";
 
 /** v5 verbatim template (adapting the finalize spelling to this plugin's REPL). */
 const HANDOFF_TEMPLATE: string =
-  "A prior RLM run hit its token cap mid-task.\n" +
+  "A prior RLM run hit its outlier token ceiling mid-task.\n" +
     "You are its continuation — pick up EXACTLY where it stopped.\n\n" +
     "ORIGINAL TASK:\n{query}\n\n" +
     "CONFIRMED FINDINGS SO FAR:\n{findings}\n\n" +
     "CURRENT STATE / LAST ACTIONS:\n{state}\n\n" +
     "NEXT STEP: {next}\n" +
+    "NOTE: repl variables are re-derived, but the task, the packed context and the ledger " +
+    "carry over. `add_context()` the same external sources again if you still need them.\n" +
     "Do not re-do confirmed work; continue from the NEXT STEP and finalize as\n" +
     'soon as the task is answerable (answer["ready"] = True).';
 
@@ -113,7 +117,7 @@ export class TokenBudget {
 /**
  * Minimum context window (tokens) for the token-budget cascade to engage at all.
  *
- * LO rule (2025-09-09): windows at/below COMPACTION_CEILING_TOKENS (256k) are never
+ * LO rule (2025-09-09): windows at/below COMPACTION_CEILING_TOKENS (1M) are never
  * budget-amputated — the derived share would shrink below a task's FIXED overhead (system
  * prompt + per-turn history re-send + sub-LLM calls); a 32k window would cap a task at 8k
  * tokens, less than the protocol scaffolding alone. Windows above the ceiling are budgeted
@@ -137,10 +141,14 @@ function unboundedBudget(config: RlmConfig): TokenBudget {
 
 export function resolveBudget(contextWindow: number | undefined, config: RlmConfig): TokenBudget {
   const ctx = contextWindow !== undefined && contextWindow > 0 ? contextWindow : 32_000;
-  if (ctx <= COMPACTION_CEILING_TOKENS) return unboundedBudget(config);
   // The share only stretches the budget BEYOND the absolute ceiling — never under it.
   const shareCap = Math.max(COMPACTION_CEILING_TOKENS, Math.floor(ctx * config.budgetShare));
   const cap = config.budgetTaskCap > 0 ? Math.min(shareCap, config.budgetTaskCap) : shareCap;
+  // LO rule (2025-09-10): small windows are never budget-amputated — but an EXPLICIT
+  // budgetTaskCap that actually binds (below shareCap) must still be honored. The old
+  // early-return swallowed the explicit cap on windows ≤ the ceiling (task-cap bug).
+  const userCapped = config.budgetTaskCap > 0 && config.budgetTaskCap < shareCap;
+  if (!userCapped && ctx <= COMPACTION_CEILING_TOKENS) return unboundedBudget(config);
   return makeBudget(config, Math.max(cap, 1));
 }
 
@@ -150,20 +158,34 @@ export function resolveBudget(contextWindow: number | undefined, config: RlmConf
  */
 export function truncateMid(text: string, maxChars: number): string {
   if (text.length <= maxChars) return text;
-  const half = Math.max(0, maxChars - ELISION_MARK.length) >> 1;
+  // Reserve for the WORST-CASE rendered mark, not the shortest (FINDING-5): the elision
+  // count is substituted at render time, so a 2+ digit count grows the mark past the
+  // length `half` was budgeted from. digits(text.length) upper-bounds digits(elided) —
+  // one pass, and the output can never exceed maxChars.
+  const reserve = maxChars - (ELISION_MARK.length - 1 + String(text.length).length);
+  if (reserve <= 0) {
+    // Cap smaller than even a mark-only render: head-truncate to keep the exact
+    // ≤ maxChars guarantee instead of emitting an oversized degenerate mark.
+    return text.slice(0, maxChars);
+  }
+  const half = reserve >> 1;
   const elided = text.length - (half * 2);
   return text.slice(0, half) + ELISION_MARK.replace("N", String(elided)) + text.slice(text.length - half);
 }
 
 /** Digest/handoff section caps — ONE source: budget.ts's handoff distillation and the root
  *  digest (core/root-digest.ts) must never drift apart on the same trajectory heuristics. */
-export const FINDINGS_MAX = 6;
+export const FINDINGS_MAX = 12; // aligns with RUN_STATE_LIMITS.findings — Σ and handoff agree
 export const FINDINGS_MIN_CHARS = 20;
 export const STATE_MAX = 8;
-const QUERY_CHARS = 800;
+const QUERY_CHARS = 4_000; // full task statement fits; 800 forced the model to "forget" its own goal
 const STATE_NEEDLE = "REPL stdout";
-/** Next-step probe shared by the engine handoff and the root digest (one wording source). */
-export const NEXT_STEP_RE = /next|then|will |todo/i;
+/** Next-step probe shared by the engine handoff and the root digest (one wording source).
+ *  Recall W4: word-boundary anchored — the old bare alternation matched substrings, so
+ *  "annex", "welfare", "willpower" pulled prose bullets in as the next step. Knowlange
+ *  tightening: bare "next/then/will/todo" prose still hijacked ("the next release will…"),
+ *  so only explicit step shapes match now — colon labels, "next step", or commitments. */
+export const NEXT_STEP_RE = /\b(?:(?:next|then|todo)\s*:|next step\b|(?:i|we)\s+(?:will|'ll|’ll)\b)/i;
 
 /**
  * Deterministic trajectory → handoff (v5 `distill_trajectory`). No LLM call: the model was

package/src/core/compaction.ts

@@ -31,19 +31,52 @@ interface CompactionDeps {
 
 /**
  * True if the history is at/over the compaction threshold — the ABSOLUTE
- * COMPACTION_CEILING_TOKENS (LO rule 2025-09-09): windows ≤ 256k never compact; larger
- * windows compact exactly at 256k. `contextWindow`/`thresholdPct` percentage math is gone.
+ * COMPACTION_CEILING_TOKENS (LO rule 2025-09-09): windows ≤ 1M never compact; larger
+ * windows compact exactly at 1M. `contextWindow`/`thresholdPct` percentage math is gone.
  */
 export function shouldCompact(history: ChatMsg[]): boolean {
   return estimateMessageTokens(history) >= COMPACTION_CEILING_TOKENS;
 }
 
+/**
+ * P3.2 (plan §3.4): never elide an ANSWER FRAME — `answer['content'] = …` is the run's only
+ * durable output, and dropping it from history is how a finished run still reports empty.
+ */
+const ANSWER_FRAME_RE = /answer\[\s*['"](?:content|ready)['"]\s*\]|answers\s*\.\s*update\s*\(/;
+
+/** Identifier shape used by the last-reference scan (`counter_a`, `rows_by_label`, …). */
+const REF_TOKEN_RE = /[A-Za-z_][A-Za-z0-9_]{2,}/g;
+/** Bounds: per-payload ids and the growing "future" set stay tiny (O(T·N) with small N). */
+const PAYLOAD_TOKEN_CAP = 64;
+const REF_TOKEN_CAP = 512;
+
+/** Whitespace-collapsed body skeleton — two identical page dumps share it even when the
+ *  turn banner differs (P3.2 "按内容签名去重"). Exact text, NOT digit-normalised: two
+ *  `counter_a=875` / `counter_a=499` payloads are different conclusions and must not collapse. */
+function payloadSignature(content: string): string {
+  return content.replace(/\s+/g, " ").trim().slice(0, 400) + "#" + content.length;
+}
+
+function payloadTokens(content: string, into: Set<string>): void {
+  let n = 0;
+  REF_TOKEN_RE.lastIndex = 0;
+  for (let m = REF_TOKEN_RE.exec(content); m !== null; m = REF_TOKEN_RE.exec(content)) {
+    into.add(m[0]);
+    if (++n >= PAYLOAD_TOKEN_CAP) return;
+  }
+}
+
 /**
  * v5 G1: elide old tool/repl payload bodies, keep the head (system) and the working-set tail
  * intact. Runs BEFORE `shouldCompact` — v3 measured −97% tokens on coding tasks with this
  * alone, often avoiding the summarizer entirely. Head-ONLY elision was a measured v3 bug
  * (turns grew 3→8): the tail carries the current working set, so the last `keepTurns` turns
  * are never touched.
+ *
+ * P3.2 adds a whitelist on top of the volume rule (which stays as the floor — dedup and
+ * exemptions only ever REMOVE bytes, never add them back):
+ *  - answer frames and payloads whose identifiers a later turn still mentions are kept verbatim;
+ *  - a payload byte-identical to an earlier one collapses to a one-line stub.
  */
 export function elideOldToolPayloads(
   history: ChatMsg[],
@@ -65,17 +98,60 @@ export function elideOldToolPayloads(
     }
   }
   if (tailStart === 0) return history; // fewer turns than keepTurns — nothing to elide
+
+  // Last-reference scan (descending): `future` holds the identifiers mentioned by everything
+  // AFTER the message we are looking at — the working set the model still has in hand.
+  const future = new Set<string>();
+  const referenced = new Array<boolean>(history.length).fill(false);
+  const ids = new Set<string>();
+  for (let i = history.length - 1; i >= 0; i--) {
+    const m = history[i];
+    if (m.role === "assistant") {
+      if (future.size < REF_TOKEN_CAP) payloadTokens(m.content, future);
+      continue;
+    }
+    if (m.role !== "user" || i >= tailStart || m.content.length <= toolChars) continue;
+    if (ANSWER_FRAME_RE.test(m.content)) continue; // answer frames are kept anyway
+    ids.clear();
+    payloadTokens(m.content.slice(0, 2_000), ids);
+    for (const id of ids) {
+      if (future.has(id)) {
+        referenced[i] = true;
+        break;
+      }
+    }
+  }
+
   let changed = false;
-  const marker = "\n…[elided v5-G1]…";
+  const marker =
+    "\n…[elided v5-G1 — your repl sandbox is INTACT: variables/answers persist; re-run or " +
+    "print(answers) in the next repl to re-derive this content]…";
+  const dupMarker =
+    "\n…[dup v5-G1 — byte-identical payload already in this history; sandbox INTACT: " +
+    "print(<expr>) to inspect it again]…";
+  const signatures = new Set<string>();
   const out: ChatMsg[] = new Array<ChatMsg>(history.length); // pre-allocated
   for (let i = 0; i < history.length; i++) {
     const m = history[i];
-    if (
-      i < tailStart &&
-      m.role === "user" &&
-      m.content.length > toolChars
-    ) {
-      out[i] = { role: "user", content: m.content.slice(0, toolChars) + marker };
+    if (i < tailStart && m.role === "user" && m.content.length > toolChars) {
+      if (ANSWER_FRAME_RE.test(m.content)) {
+        out[i] = m; // never touch the answer frame
+        continue;
+      }
+      const sig = payloadSignature(m.content);
+      if (signatures.has(sig)) {
+        out[i] = { role: "user", content: dupMarker.trimStart() };
+        changed = true;
+        continue;
+      }
+      signatures.add(sig);
+      if (referenced[i]) {
+        out[i] = m; // a later turn still names what this payload produced
+        continue;
+      }
+      // Elided message is capped at exactly toolChars total (§5.3 preview + marker).
+      const body = m.content.slice(0, Math.max(0, toolChars - marker.length));
+      out[i] = { role: "user", content: body + marker };
       changed = true;
     } else {
       out[i] = m;

package/src/core/engine.ts

@@ -26,11 +26,11 @@ import { PythonSandbox, SANDBOX_WATCHDOG_HEARTBEAT_MS } from "../sandbox/sandbox
 import type { ReplResult } from "../sandbox/protocol.ts";
 import { pinContext, type PinnedContext } from "../sandbox/context-file.ts";
 import { previewStdout, previewText } from "../text/preview.ts";
-import { findReplBlocks, stripStateFences } from "../text/parsing.ts";
+import { finalVarRepairCode, findFinalTag, findReplBlocks, stripStateFences } from "../text/parsing.ts";
 import { contextLength, contextSizeStats, contextTypeLabel } from "../text/tokens.ts";
-import { finalAnswerOf, formatReplOutputs, latestAnswerContentOf, turnHadError } from "./answer.ts";
+import { finalAnswerOf, formatReplOutputs, latestAnswerContentOf, latestStdoutOf, turnHadError } from "./answer.ts";
 import { compactHistory, elideOldToolPayloads, rebaseWithState, shouldCompact } from "./compaction.ts";
-import { applyStatePatches, freshRunState, runStateTurnBlock, type RunState, type RunStateMode } from "./run-state.ts";
+import { applyStatePatches, compactJSON, freshRunState, runStateTurnBlock, SIGMA_UNCHANGED_LINE, type RunState, type RunStateMode } from "./run-state.ts";
 import { findStatePatches } from "../text/parsing.ts";
 import { complete1, completeDeps } from "../bridge/handlers/completion.ts";
 import type { SubcallHandlerDeps } from "../bridge/handlers/types.ts";
@@ -141,8 +141,8 @@ export function createEngine(deps: EngineDeps): RunRlm {
           limits.addUsage(u);
           deps.onUsage?.(u, "sub");
         },
-        addRaw: (costUsd, inputTokens, outputTokens) => {
-          limits.addRaw(costUsd, inputTokens, outputTokens);
+        addRaw: (inputTokens, outputTokens) => {
+          limits.addRaw(inputTokens, outputTokens);
         },
       },
     };
@@ -202,12 +202,27 @@ export function createEngine(deps: EngineDeps): RunRlm {
           if (detachedInFlight === 0) detachedIdle?.();
         }
       },
-      // SKILL.state: leaf grounding (Workstream D, DRY #1) + the parent Ξ for children (C, DRY #6).
+      // SKILL.state: leaf grounding (Workstream D, DRY #1) + the Ξ block for children (C, DRY #6).
       groundLeaf:
         skillStore === undefined || !deps.config.enableSkillState
           ? undefined
           : (prompt: string) => groundLeafPrompt(skillStore, deps.config, prompt),
-      getSkillBlock: () => input.skillBlock,
+      // The child's Ξ is re-ranked against the CHILD's task from the live store — inheriting
+      // the parent's block verbatim wasted the Ξ budget on facts ranked for someone else's
+      // question. Falls back to the inherited block when re-ranking comes up empty (or for
+      // the degenerate same-task call), and to `undefined` semantics when the store is off.
+      getSkillBlock:
+        skillStore === undefined || !deps.config.enableSkillState
+          ? () => input.skillBlock
+          : (task: string): string | undefined => {
+              if (task === input.rootPrompt || task.trim() === "") return input.skillBlock;
+              const block = skillStore.blockFor(
+                task,
+                deps.config.skillStateMaxTokens,
+                deps.config.skillStateXiMinScore,
+              );
+              return block !== "" ? block : input.skillBlock;
+            },
     } satisfies SubcallHandlerDeps;
     const subcalls = createSubcallHandlers(subcallDeps, taskRegistry);
 
@@ -220,8 +235,13 @@ export function createEngine(deps: EngineDeps): RunRlm {
       // off (one source, two sinks; never a second harvest implementation).
       deps.onRunState?.(runStateMode.state);
       if (skillStore === undefined || !deps.config.enableSkillState) return;
-      skillStore.merge(notesFromRunState(runStateMode.state));
+      // Depth-tagged deterministic harvest runs at every depth; the LLM distill is ROOT-ONLY —
+      // every child distilling into the same project section crowded the note cap with
+      // sub-task fragments (A-Mem store hygiene). Fail-soft: a distill failure must never
+      // damage a finished run.
+      skillStore.merge(notesFromRunState(runStateMode.state, input.depth));
       if (!deps.config.enableSkillStateDistill || deps.signal?.aborted === true) return;
+      if (input.depth > 0) return;
       try {
         const raw = await complete1(
           invocation,
@@ -229,7 +249,7 @@ export function createEngine(deps: EngineDeps): RunRlm {
           () => {},
           completeDeps(subcallDeps),
         );
-        const parsed = parseDistilledNotes(raw);
+        const parsed = parseDistilledNotes(raw, runStateMode.state.task);
         if (parsed.length > 0) skillStore.merge(parsed);
       } catch {
         // fail-soft by design
@@ -269,6 +289,9 @@ export function createEngine(deps: EngineDeps): RunRlm {
       await previous?.release();
     };
     let best = "";
+    // P2 §3.4: last non-empty repl stdout across the whole run — recovered by the bench when
+    // the run ends with no `answer[…]` frame (the value was printed, just never submitted).
+    let lastStdout = "";
     let lastAnswer = "";
     let compactions = 0;
     let completedTurns = 0;
@@ -278,6 +301,11 @@ export function createEngine(deps: EngineDeps): RunRlm {
     let softNoteTurn = -1;
     // H3: retrieval-discipline coach — one-shot per run; children inherit it via the same loop.
     let sawRetrieval = false;
+    let sawDelegation = false;
+    // Σ economics: the compact JSON of the Σ last sent to the model — an unchanged Σ
+    // re-sends as SIGMA_UNCHANGED_LINE instead of the full block. Reset by compaction/rebase
+    // (the rebase message re-anchors Σ verbatim) and by degrade (no more Σ blocks at all).
+    let lastSigmaSent: string | undefined;
     let retrievalNudged = false;
     // Verification-discipline coach (enableVerificationNudge, default OFF): one coached redo
     // when an early finalize looks like the confident-wrong bench shape.
@@ -365,8 +393,8 @@ export function createEngine(deps: EngineDeps): RunRlm {
           history = elideOldToolPayloads(history);
           const compactionDeps = {
             // Summarisation is done by the cheap worker model; compaction fires on the ABSOLUTE
-            // COMPACTION_CEILING_TOKENS (limits.ts): ≤256k windows never compact, larger ones
-            // compact exactly at 256k (LO rule 2025-09-09).
+            // COMPACTION_CEILING_TOKENS (limits.ts): ≤1M windows never compact, larger ones
+            // compact exactly at 1M (LO rule 2025-09-09).
             model: deps.llmModel,
             registry: deps.registry,
             contextWindow: model.contextWindow,
@@ -379,6 +407,7 @@ export function createEngine(deps: EngineDeps): RunRlm {
             history = runStateMode.kind === "active"
               ? rebaseWithState(history, runStateMode.state, ++compactions)
               : await compactHistory(history, compactionDeps, ++compactions, (u) => limits.addUsage(u));
+            lastSigmaSent = undefined; // the rebase message re-anchors Σ — full block next turn
           }
         }
 
@@ -398,27 +427,37 @@ export function createEngine(deps: EngineDeps): RunRlm {
 
         // v5 [ledger] blackboard — silent ("") when it has nothing to say.
         const ledgerBlock = deps.config.enableLedger ? runLedger.injectBlock() : "";
+        const sigmaJson = runStateMode.kind === "active" ? compactJSON(runStateMode.state) : "";
         // H3: after two retrieval-free turns, inject the coach nudge exactly once, for one turn.
-        const nudgeNow = i >= 2 && !sawRetrieval && !retrievalNudged;
+        // Surface-aware: delegation children (depth > 0) have NO search/grep_context — nudging
+        // them taught a tool their prompt elsewhere forbids (NameError bait).
+        const nudgeNow = input.depth === 0 && i >= 2 && !sawRetrieval && !retrievalNudged;
         if (nudgeNow) retrievalNudged = true;
         const notes =
           [
             i === softNoteTurn ? WRAP_UP_BUDGET : undefined,
             // Workstream A: from iteration 3 the run conditions on Σ (A_t = (P, Σ_t, O_t)) and
             // the state fence is requested — exploratory cold-start stays as-built (§12.2).
-            runStateMode.kind === "active" && i >= 2 ? runStateTurnBlock(runStateMode.state) : undefined,
+            // Σ economics: an unchanged Σ re-sends as a one-line marker, not the full JSON —
+            // full re-send happens only after compaction/rebase (lastSigmaSent reset below).
+            runStateMode.kind === "active" && i >= 2
+              ? (sigmaJson === lastSigmaSent ? SIGMA_UNCHANGED_LINE : runStateTurnBlock(runStateMode.state))
+              : undefined,
             ledgerBlock === "" ? undefined : ledgerBlock,
             nudgeNow ? RETRIEVAL_NUDGE : undefined,
             verificationNudgePending ? VERIFICATION_NUDGE : undefined,
             // One-shot (turn 0 only): thinking tokens share the completion budget — mirror of
             // the bench's doubling rule. Advisory; never fatal, never repeated.
-            i === 0 && rootSampling.reasoning !== undefined && (rootSampling.maxTokens ?? 16_384) < 8_192
+            // P3.1a (plan §3.4): `<= 8_192` — the bench pins maxTokens = 8192 exactly, so the old
+            // strict `<` made this a dead condition and REASONING_BUDGET_HINT never fired.
+            i === 0 && rootSampling.reasoning !== undefined && (rootSampling.maxTokens ?? 16_384) <= 8_192
               ? REASONING_BUDGET_HINT
               : undefined,
           ]
             .filter((s): s is string => s !== undefined)
             .join("\n\n") || undefined;
         verificationNudgePending = false;
+        if (runStateMode.kind === "active" && i >= 2) lastSigmaSent = sigmaJson;
         appendUserMessage(history, buildTurnPrompt(i, deps.config.maxIterations, notes));
 
         const turn = await runTurn(history, sandbox, {
@@ -427,10 +466,14 @@ export function createEngine(deps: EngineDeps): RunRlm {
           sampling: rootSampling,
           retry: deps.complete === undefined ? retryPolicy(deps.config) : undefined,
           signal: deps.signal,
+          // Long-context providers: bigmodel.cn TTFB scales ~1 min per 10k ctx chars; the
+          // pi-ai default idle cap aborts such turns as "Request timed out". One knob, both seams.
+          timeoutMs: deps.config.requestTimeoutMs,
           complete: deps.complete,
           onPhase: reportPhase,
         });
         if (turn.blocks.some((b) => /\b(?:search|grep_context)\s*\(/.test(b))) sawRetrieval = true;
+        if (turn.blocks.some((b) => /\b(?:llm_query|llm_batch|rlm_query|rlm_batch|map_files|llm_query_chunked|llm_map_reduce|spawn)\s*\(/.test(b))) sawDelegation = true;
         const allBlocks = turn.blocks.length > 0
           ? turn.blocks.map((b) => previewText(b, 400)).join("\n")
           : previewText(turn.response, 400);
@@ -441,30 +484,53 @@ export function createEngine(deps: EngineDeps): RunRlm {
         if (selfReportId) {
           emitter.emitSubcallUpdated({
             id: selfReportId,
-            costUsd: turn.usage.cost.total,
             tokens: turn.usage.totalTokens,
             tokensIn: turn.usage.input,
             tokensOut: turn.usage.output,
           });
         } else {
-          emitter.emitRootUsage(turn.usage.cost.total, turn.usage.totalTokens, turn.usage.input, turn.usage.output);
+          emitter.emitRootUsage(turn.usage.totalTokens, turn.usage.input, turn.usage.output);
         }
         deps.onUsage?.(turn.usage, "root");
         const answerContent = latestAnswerContentOf(turn.results);
         if (answerContent) best = answerContent;
         else if (!best && turn.response.trim()) best = turn.response;
+        // Stdout fallback floor (P2 §3.4): keep the newest non-empty block output, always —
+        // cheapest possible recovery for a run that never submits a final frame.
+        const turnStdout = latestStdoutOf(turn.results);
+        if (turnStdout) lastStdout = turnStdout;
         completedTurns = i + 1;
-        const final = finalAnswerOf(turn.results);
+        let final = finalAnswerOf(turn.results);
+        // RLM-paper App. A template repair: a finalize written as FINAL(x) / FINAL_VAR(v)
+        // instead of an `answer` flip is converted (16%/13% of small-model turns in the
+        // paper). The repair note rides the next observation so the model learns the channel.
+        let repairNote: string | undefined;
+        if (final == null && sandbox !== undefined) {
+          const tag = findFinalTag(turn.response);
+          if (tag?.kind === "final") {
+            final = tag.value;
+            repairNote = "[runtime] Converted FINAL(...) from your prose into the final answer — flip `answer[\"ready\"]` directly next time.";
+          } else if (tag?.kind === "final_var") {
+            const repaired = await sandbox.exec(finalVarRepairCode(tag.value));
+            const recovered = finalAnswerOf([repaired]);
+            if (recovered !== null && !recovered.startsWith("Error:")) {
+              final = recovered;
+              repairNote = `[runtime] Converted FINAL_VAR(${tag.value}) into the final answer — flip \`answer["ready"]\` directly next time.`;
+            } else if (recovered !== null) {
+              repairNote = recovered;
+            }
+          }
+        }
         if (final != null) {
-          // Verification-discipline nudge (enableVerificationNudge, default OFF): an early
-          // finalize whose answer is a bare number / short label is the confident-wrong shape
-          // that dominated bench failures. ONE coached redo, then the answer is accepted.
+          // Verification-discipline nudge (default ON — bench: 28/33 failures were early
+          // confident wrong answers): a finalize that is bare, or arrived without any
+          // inspection of the context, gets ONE coached redo, then the answer is accepted.
           if (deps.config.enableVerificationNudge === true && !verificationNudged
-            && completedTurns < VERIFICATION_NUDGE_TURN_CAP && isBareAnswer(final)) {
+            && completedTurns < VERIFICATION_NUDGE_TURN_CAP && isBareAnswer(final, sawRetrieval, sawDelegation)) {
             verificationNudged = true;
             verificationNudgePending = true;
           } else {
-            const done = result(final, i + 1, limits);
+            const done = result(final, i + 1, limits, lastStdout);
             lastAnswer = done.answer;
             return done;
           }
@@ -473,6 +539,9 @@ export function createEngine(deps: EngineDeps): RunRlm {
         limits.observe(turnHadError(turn.results));
         history.push({ role: "assistant", content: turn.response });
         pendingReplOutputs = formatReplOutputs(turn.results, turn.skippedBlocks);
+        if (repairNote !== undefined) {
+          pendingReplOutputs = `${pendingReplOutputs}\n\n${repairNote}`;
+        }
         // ── Workstream A: apply ΔΣ_t AFTER the environment reply — Algorithm 1 ordering:
         // state reflects intended effects; feedback arrives as the next O_t. Rejections roll
         // back and lead the next observation (error-as-observation retry); retries exhausted
@@ -484,6 +553,9 @@ export function createEngine(deps: EngineDeps): RunRlm {
             i + 1,
             deps.config,
             i >= 2, // the fence was requested this turn → empty turns count as idle (bench rec #2)
+            // Productive-turn parity (root tracker, recall W2): executed work that neither
+            // raised nor skipped resets the idle streak — repl progress is progress.
+            turn.blocks.length > 0 && !turnHadError(turn.results) && turn.skippedBlocks === 0,
           );
           runStateMode = applied.mode;
           if (applied.observation !== undefined) {
@@ -546,7 +618,6 @@ export function createEngine(deps: EngineDeps): RunRlm {
                 iterations: inner.iterations + completedTurns,
                 inputTokens: inner.inputTokens + u.inputTokens,
                 outputTokens: inner.outputTokens + u.outputTokens,
-                costUsd: inner.costUsd + u.costUsd,
               };
               // R2: lastAnswer must be set before return — `finally` emitAnswer reads it.
               lastAnswer = chained.answer;
@@ -558,19 +629,19 @@ export function createEngine(deps: EngineDeps): RunRlm {
         }
       }
       if (pendingReplOutputs) appendUserMessage(history, pendingReplOutputs);
-      const finalized = result(await finalize(history, model, deps, limits, sandbox), deps.config.maxIterations, limits);
+      const finalized = result(await finalize(history, model, deps, limits, sandbox), completedTurns, limits, lastStdout);
       lastAnswer = finalized.answer;
       return finalized;
     } catch (err) {
       // Abort is a user action — resolve with the best partial, not an error.
       if (deps.signal?.aborted) {
-        const aborted = result(best.trim() || "(aborted)", completedTurns, limits);
+        const aborted = result(best.trim() || "(aborted)", completedTurns, limits, lastStdout);
         lastAnswer = aborted.answer;
         return aborted;
       }
       if (err instanceof LimitError) {
         nodeStatus = "error";
-        const stopped = result(best.trim() || `(stopped: ${err.message})`, completedTurns, limits);
+        const stopped = result(best.trim() || `(stopped: ${err.message})`, completedTurns, limits, lastStdout);
         lastAnswer = stopped.answer;
         return stopped;
       }
@@ -601,14 +672,21 @@ export function createEngine(deps: EngineDeps): RunRlm {
   return run;
 }
 
-function result(answer: string, iterations: number, limits: LimitGuard): RlmResult {
+function result(answer: string, iterations: number, limits: LimitGuard, lastStdout: string): RlmResult {
   // State fences are a Σ transport, never user-visible output (§7): scrub them from the
   // FINAL answer. A fence-only answer means the model spent its last turn committing state
   // and never re-answered — surface the stub instead of a raw patch JSON.
   const clean = stripStateFences(answer);
   const final = clean.trim().length > 0 ? clean.trim() : "(no final answer — last turn committed state only; see Σ)";
   const u = limits.usage();
-  return { answer: final, iterations, costUsd: u.costUsd, inputTokens: u.inputTokens, outputTokens: u.outputTokens, durationMs: u.durationMs };
+  return {
+    answer: final,
+    iterations,
+    inputTokens: u.inputTokens,
+    outputTokens: u.outputTokens,
+    durationMs: u.durationMs,
+    lastStdout,
+  };
 }
 
 /** Model metadata window, else the offline registry fallback (disk cache → table → 32k). */
@@ -622,11 +700,18 @@ function contextWindowOrFallback(model: Model<Api>, registry: ModelContextRegist
   return registry.limitFor(`${model.provider}/${model.id}`);
 }
 
-/** Bare number / short label — the early-confident answer shape the verification nudge
- *  targets (28/33 bench failures were early confident wrong answers). */
-function isBareAnswer(answer: string): boolean {
+/** Early-confident answer shape — the target of the verification nudge (28/33 bench failures
+ *  were early confident wrong answers). Bare when: tiny, ≤3 words, a pure number/date/label,
+ *  or — strongest signal — the run NEVER inspected its context (no retrieval, no delegation):
+ *  the answer was then guessed, whatever its length. */
+function isBareAnswer(answer: string, sawRetrieval: boolean, sawDelegation: boolean): boolean {
   const t = answer.trim();
-  return t.length <= 12 || /^[-+$(€£¥]?\d+(?:[.,]\d+)*\s*%?$/.test(t);
+  if (t.length === 0) return true;
+  if (!sawRetrieval && !sawDelegation) return true;
+  if (t.length <= 12) return true;
+  if (t.split(/\s+/).length <= 3) return true;
+  if (/^[-+$(€£¥]?\d+(?:[.,]\d+)*\s*%?$/.test(t)) return true;
+  return false;
 }
 
 /** Out of turns: ask the model for its best final answer. FINALIZE_PROMPT asks for a fenced

package/src/core/iteration.ts

@@ -30,6 +30,9 @@ interface TurnDeps {
   readonly registry: ModelRegistry;
   readonly sampling?: Sampling;
   readonly signal?: AbortSignal;
+  /** Wall-clock cap per provider request (ms) — forwarded to the modelComplete seam.
+   *  Long-context providers (zai bigmodel TTFB ~1 min per 10k ctx chars) need it raised. */
+  readonly timeoutMs?: number;
   /** Test-only override for model completion (scripted responses). */
   readonly complete?: CompleteFn;
   /** v5.1 retry policy for modelComplete (rate-limit resilience); defaults apply when omitted. */
@@ -52,6 +55,7 @@ export async function runTurn(history: readonly ChatMsg[], sandbox: PythonSandbo
     onThrottlePark: deps.onPhase ? () => deps.onPhase?.("queued") : undefined,
     onThrottleRelease: deps.onPhase ? () => deps.onPhase?.("thinking") : undefined,
     signal: deps.signal,
+    timeoutMs: deps.timeoutMs,
   });
 
   const blocks = findReplBlocks(text);