@hicaru/pi-rlm 0.3.18 → 0.3.20

package/src/core/compaction.ts

@@ -13,8 +13,7 @@ import type { RetryPolicy } from "../util/retry.ts";
 import { estimateMessageTokens } from "../text/tokens.ts";
 import type { RunState } from "../core/run-state.ts";
 import { compactJSON } from "../core/run-state.ts";
-
-const DEFAULT_CONTEXT_WINDOW = 128_000;
+import { COMPACTION_CEILING_TOKENS } from "./limits.ts";
 
 const SUMMARY_REQUEST =
   "Summarize your progress so far. Include: (1) which sub-tasks are done and which remain; " +
@@ -25,17 +24,46 @@ interface CompactionDeps {
   readonly model: Model<Api>;
   readonly registry: ModelRegistry;
   readonly contextWindow?: number;
-  readonly thresholdPct?: number;
   readonly signal?: AbortSignal;
   /** v5.1 retry policy for modelComplete; defaults apply when omitted. */
   readonly retry?: RetryPolicy;
 }
 
-/** True if the history is at/over the compaction threshold. */
-export function shouldCompact(history: ChatMsg[], deps: CompactionDeps): boolean {
-  const contextWindow = deps.contextWindow && deps.contextWindow > 0 ? deps.contextWindow : DEFAULT_CONTEXT_WINDOW;
-  const threshold = (deps.thresholdPct ?? 0.85) * contextWindow;
-  return estimateMessageTokens(history) >= threshold;
+/**
+ * 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.
+ */
+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;
+  }
 }
 
 /**
@@ -44,6 +72,11 @@ export function shouldCompact(history: ChatMsg[], deps: CompactionDeps): boolean
  * 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;
@@ -142,6 +218,16 @@ export function rebaseWithState(history: ChatMsg[], state: RunState, count = 1):
       }
     }
   }
+  // Token-bounded tail (LO rule 2025-09-09): the kept turns must also fit under the absolute
+  // ceiling; walk tailStart forward until the tail does. Σ carries everything dropped turns held.
+  const sizes: number[] = new Array<number>(history.length);
+  for (let i = 0; i < history.length; i++) sizes[i] = estimateMessageTokens([history[i]]);
+  let tailTokens = 0;
+  for (let i = tailStart; i < history.length; i++) tailTokens += sizes[i];
+  while (tailStart < history.length && tailTokens > COMPACTION_CEILING_TOKENS) {
+    tailTokens -= sizes[tailStart];
+    tailStart += 1;
+  }
   const window: ChatMsg[] = tailStart < history.length ? history.slice(tailStart) : [];
   return [
     ...head,

package/src/core/engine.ts

@@ -26,9 +26,9 @@ 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 } from "../text/parsing.ts";
+import { 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 { findStatePatches } from "../text/parsing.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);
         },
       },
     };
@@ -269,6 +269,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;
@@ -364,16 +367,16 @@ export function createEngine(deps: EngineDeps): RunRlm {
           // v5 G1 first: elide old tool payloads head+tail — often avoids the summary entirely.
           history = elideOldToolPayloads(history);
           const compactionDeps = {
-            // Summarisation is done by the cheap worker model; the threshold stays on the
-            // root model's context window (that is the window the history fills each turn).
+            // 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).
             model: deps.llmModel,
             registry: deps.registry,
             contextWindow: model.contextWindow,
-            thresholdPct: deps.config.compactionThresholdPct,
             retry: retryPolicy(deps.config),
             signal: deps.signal,
           };
-          if (shouldCompact(history, compactionDeps)) {
+          if (shouldCompact(history)) {
             // Workstream A: with Σ active, rebase structurally — [P, Σ_t, window(O)] — and
             // the summarizer call disappears entirely; degraded runs keep compactHistory.
             history = runStateMode.kind === "active"
@@ -412,7 +415,9 @@ export function createEngine(deps: EngineDeps): RunRlm {
             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,
           ]
@@ -427,6 +432,9 @@ 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,
         });
@@ -441,18 +449,21 @@ 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);
         if (final != null) {
@@ -464,7 +475,7 @@ export function createEngine(deps: EngineDeps): RunRlm {
             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;
           }
@@ -546,7 +557,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 +568,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,9 +611,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, 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). */

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);

package/src/core/limits.ts

@@ -3,11 +3,21 @@
  * (ported from rlm/core/rlm.py `_check_timeout` / `_check_iteration_limits`). Any breach throws
  * a LimitError; the engine catches it and returns the best partial answer it has.
  *
- * Cost is tracked for reporting only — there is no USD spend ceiling.
+ * Cost is NOT tracked: there is no USD spend ceiling and no cost reporting.
  */
 
 import type { Usage } from "@earendil-works/pi-ai";
 
+/**
+ * Absolute working ceiling (LO rule 2025-09-09, raised 2025-09-10): model windows AT/BELOW
+ * this value are never compacted or budget-amputated — the agent runs its full window, and
+ * tree-wide spend (root turns + sub-LLM calls) is NOT metered against it. Windows ABOVE it
+ * are budgeted exactly AT the ceiling — an outlier context-fit guard, not a cost meter.
+ * Single source of truth for budget.ts (resolveBudget) and compaction.ts (shouldCompact +
+ * rebaseWithState token bound).
+ */
+export const COMPACTION_CEILING_TOKENS = 1_000_000;
+
 export interface Limits {
   readonly maxTimeoutMs?: number;
   readonly maxTokens?: number;
@@ -27,7 +37,6 @@ export function limitsFromConfig(config: Limits): Limits {
 interface UsageSnapshot {
   readonly inputTokens: number;
   readonly outputTokens: number;
-  readonly costUsd: number;
   readonly durationMs: number;
 }
 
@@ -45,7 +54,6 @@ export class LimitGuard {
   private start: number;
   private inputTokens = 0;
   private outputTokens = 0;
-  private costUsd = 0;
   private consecutiveErrors = 0;
 
   constructor(private readonly limits: Limits = {}, seedElapsedMs = 0) {
@@ -64,12 +72,10 @@ export class LimitGuard {
   addUsage(usage: Usage): void {
     this.inputTokens += usage.input;
     this.outputTokens += usage.output;
-    this.costUsd += usage.cost.total;
   }
 
-  /** Fold a recursive child run's total cost/tokens into this guard. */
-  addRaw(costUsd: number, inputTokens: number, outputTokens: number): void {
-    this.costUsd += costUsd;
+  /** Fold a recursive child run's total tokens into this guard. */
+  addRaw(inputTokens: number, outputTokens: number): void {
     this.inputTokens += inputTokens;
     this.outputTokens += outputTokens;
   }
@@ -90,7 +96,6 @@ export class LimitGuard {
     return {
       inputTokens: this.inputTokens,
       outputTokens: this.outputTokens,
-      costUsd: this.costUsd,
       durationMs: Date.now() - this.start,
     };
   }

package/src/core/root-context.ts

@@ -31,7 +31,7 @@ export interface ElideOptions {
   readonly elideChars: number;
 }
 
-const ELIDE_MARK = "chars elided — full result in session log";
+const ELIDE_MARK = "chars elided — repl sandbox persists: print(answers[k]) or re-run repl to re-derive";
 
 /**
  * WS-3a: elide stale turns. The newest `keepTurns` assistant turns and the final user message
@@ -109,7 +109,18 @@ function elideRange(
     if (i === lastUser) continue; // paranoia: the final user message is never touched
     if (m.role === "assistant") {
       staleAssistants -= 1; // turns AFTER this one = count minus itself
-      messages[i] = { ...m, content: [{ type: "text", text: ROOT_TURN_ELIDED_LINE }] } as RootMessage;
+      // Provider pairing invariant: Anthropic requires every tool_result to follow the
+      // assistant message carrying its tool_use; OpenAI requires each tool/function_call_output
+      // to pair with its tool_call/function_call. Eliding the toolCall blocks here orphaned the
+      // surviving toolResults and broke the request. Elide only the prose — keep toolCall blocks.
+      const toolCalls = Array.isArray(m.content)
+        ? (m.content as Array<{ type?: string }>).filter((b) => b?.type === "toolCall")
+        : [];
+      const content: unknown[] =
+        toolCalls.length > 0
+          ? [...toolCalls, { type: "text", text: ROOT_TURN_ELIDED_LINE }]
+          : [{ type: "text", text: ROOT_TURN_ELIDED_LINE }];
+      messages[i] = { ...m, content } as RootMessage;
       elided += 1;
       continue;
     }

package/src/core/root-state.ts

@@ -206,7 +206,11 @@ export class RootStateTracker {
    * while runtime `observeToolResult` remains the Σ floor (degrade, never crash).
    */
   applyFences(fences: readonly StateFenceResult[]): FenceOutcome {
-    if (this.mode.kind !== "active") return { fences: fences.length, accepted: 0, problems: 0 };
+    // R7-fix (recoverable degrade): a DEGRADED tracker no longer drops fences on the floor.
+    // The old early-return turned idle degrade into a one-way amnesia valve — every later
+    // fence vanished silently while the context transform kept eliding turns. Now the same
+    // validation ladder runs in degraded mode, and a CLEAN batch re-activates compensation.
+    // Degrade stays sticky only against zero-progress storms (all-malformed batches).
     if (fences.length === 0) {
       // R4 (G6): a fence-free turn on a conditioned loop is IDLE — the contract rode the
       // prompt for nothing. Grow the streak; degrade at the engine's threshold.
@@ -235,24 +239,29 @@ export class RootStateTracker {
     this.idleFenceTurns = accepted > 0 ? 0 : this.idleFenceTurns + 1;
     this.degradeIfIdle();
     if (problems.length === 0) {
+      // Recovery seam: a clean batch re-activates a degraded tracker, so one honest fence
+      // ends the amnesia window instead of requiring a session restart.
       this.mode = { kind: "active", retries: 0 };
       this.pendingObservation = undefined;
       this.draft = this.toMutable(state);
       this.touch();
       return { fences: fences.length, accepted, problems: 0 };
     }
-    const retries = this.mode.retries + problems.length;
+    // Degraded variant carries `reason`, not `retries` — recovery is clean-batch-only, so a
+    // degraded tracker neither accumulates retries nor re-activates on a partial batch.
+    const retries = (this.mode.kind === "active" ? this.mode.retries : 0) + problems.length;
     this.pendingObservation = statePatchObservation(problems);
     // Accepted deltas in a partially-failing batch still land — engine parity: real work is
     // never rolled back just because a sibling fence was malformed.
     this.draft = this.toMutable(state);
     this.touch();
-    if (retries > this.retryMax) {
-      this.mode = { kind: "degraded", reason: `state-patch retry cap exceeded (${retries} rejected)` };
-    } else if (this.mode.kind === "active") {
-      // An idle degrade fired earlier in this call wins over re-activating — degrade is
-      // sticky; the runtime observation floor keeps Σ alive until the session ends.
-      this.mode = { kind: "active", retries };
+    if (this.mode.kind === "active") {
+      if (retries > this.retryMax) {
+        this.mode = { kind: "degraded", reason: `state-patch retry cap exceeded (${retries} rejected)` };
+      } else {
+        // Persist the running rejection count — the retry cap is CUMULATIVE across turns.
+        this.mode = { kind: "active", retries };
+      }
     }
     return { fences: fences.length, accepted, problems: problems.length };
   }

package/src/core/run-state.ts

@@ -552,13 +552,18 @@ export function statePatchObservation(problems: readonly string[]): string | und
 }
 
 export const STATE_FENCE_INSTRUCTION: string =
-  "[state] Alongside your ```repl block(s), commit durable progress to Σ with a ```state fence:\n" +
+  "[state] Your user-facing reply is normal prose — a readable report. The ```state fence is OPTIONAL compact metadata that trails it, never a replacement for the report:\n" +
   '{"state_patch": {"verifiedFacts[+]": "src/x.ts — fact", "testedApproaches.h1.status": "failed"}}\n' +
+  "Σ is an index of pointers, not a report: ≤ 5 keys per patch, every string value ≤ 120 chars, " +
+  "telegraphic style (`path — fact`, `verdict — numbers`). NEVER paste findings, tables, JSON " +
+  "blobs, or long excerpts into Σ — the prose carries the story, Σ carries only the pointers.\n" +
   "Keys: dotted paths write record leaves; [+] appends; [N] sets an array slot; null deletes.\n" +
   "Commit DELTAS only — never restate unchanged records or arrays; touch single dotted keys " +
   `or append with [+]. Whole-record restatements must keep EVERY key (implicit drops are ` +
   `rejected), and a patch over ${RUN_STATE_LIMITS.patchBytes} bytes is rejected whole.\n` +
-  "Commit anything possibly relevant NOW; the raw observation will not be shown again.";
+  "If this turn produced nothing durable and new, end your reply on the prose — NO fence at all. " +
+  "An absent fence is free; a malformed or oversized one costs a retry. " +
+  "Stale turns are elided and compensated by Σ, so a durable fact you skip here is gone.";
 
 /** ONE Σ-block composer (R2): the engine turn block and the root splice both delegate here —
  *  never duplicate the contract + Σ assembly. `withContract` is paper A.4 authoring mode;

package/src/core/types.ts

@@ -13,7 +13,8 @@ export interface RlmConfig {
   readonly enabled: boolean;
   /** Max recursion depth. depth >= maxDepth ⇒ rlm_query falls back to a plain llm_query. */
   readonly maxDepth: number;
-  /** Max turns before the engine must finalize. */
+  /** Max turns before the engine must finalize. Deliberately large — runs end on FINAL
+   *  answer, errors, or wall-clock long before this bites. */
   readonly maxIterations: number;
   /** Per-`repl`-block wall-clock timeout inside the worker (seconds).
    *  v5 doctrine: content limits are the token budget's job — this is a HANG backstop only. */
@@ -54,7 +55,8 @@ export interface RlmConfig {
   readonly orchestrator: boolean;
   /** Summarize the trajectory when it grows past the threshold (keeps the root window small). */
   readonly compaction: boolean;
-  /** Compact when estimated history tokens reach this fraction of the model's context window. */
+  /** DEPRECATED (LO rule 2025-09-09): ignored — compaction is governed by the absolute
+   *  COMPACTION_CEILING_TOKENS (limits.ts). Kept for settings/UI compatibility only. */
   readonly compactionThresholdPct: number;
   /** Python executable used to launch the sandbox worker. */
   readonly python: string;
@@ -180,10 +182,14 @@ export interface RlmInput {
 export interface RlmResult {
   readonly answer: string;
   readonly iterations: number;
-  readonly costUsd: number;
   readonly inputTokens: number;
   readonly outputTokens: number;
   readonly durationMs: number;
+  /** Last non-empty repl stdout of the run (capped, P2 §3.4). The engine itself never reads
+   *  it: a run that ends without `answer[...]` (no final frame) would otherwise score as an
+   *  empty submission even though the winning value was printed. The bench/grader recovers
+   *  that value from here instead of re-running the whole task. */
+  readonly lastStdout: string;
 }
 
 /** A function that runs an RLM to completion — used to wire recursion (rlm_query). */

package/src/index.ts

@@ -433,6 +433,8 @@ export default function rlmExtension(pi: ExtensionAPI): void {
         idle: tracker.idleTurns,
         active: tracker.isActive,
         degraded: wasActive && !tracker.isActive,
+        // R7-fix: recovery observability — a degraded tracker that accepted a clean batch.
+        recovered: !wasActive && tracker.isActive,
       });
     }
     if (wasActive && !tracker.isActive) {
@@ -503,12 +505,20 @@ export default function rlmExtension(pi: ExtensionAPI): void {
         });
         elidedMessages += elided;
         const tracker = rootTracker;
-        // R4: a DEGRADED tracker stops splicing Σ (isActive gate) — pure input tax otherwise.
+        // R4 REV (amnesia fix): degrade suspends fence WRITES (applyFences gate) — never Σ
+        // READBACK. SKILL.state §5.3 makes elision lossless precisely because Σ rides with
+        // the elided turns; stubbing history while withholding Σ amnesia-loops the agent
+        // (announce-continue-then-stop). Splice whenever Σ has content, active or degraded;
+        // the fence CONTRACT rides only while active — a degraded tracker ignores fences
+        // (applyFences early-returns), so teaching the contract is pure tax.
         if (
           controller.config.rootContextSnapshot && tracker !== undefined &&
-          tracker.isActive && !tracker.isEmpty
+          !tracker.isEmpty
         ) {
           spliceSigmaSnapshot(filtered, tracker.snapshot(), tracker.rectifyHint(), {
+            // R7-fix: teach the contract while DEGRADED too — it is the only road back.
+            // Recovery is a clean fence; hiding the notation after degrade made the
+            // amnesia window permanent (the fence turns that taught it get elided).
             withContract: controller.config.enableRootStateFences,
           });
           sigmaSplices += 1;

package/src/prompts/glossary.ts

@@ -63,9 +63,11 @@ export const SKILL_RECALL_LINE =
   "Recall more anytime inside repl: `skill_search(query, k=8)` → [{id, text, tags, score}].";
 
 /** R5 (G4, /tmp/ROOT_FULL_SKILLSTATE_PLAN.md): the one-line replacement for assistant prose
- *  older than the keep window — durable facts live in Σ, the full text in the session log. */
+ *  older than the keep window — durable facts live in Σ; the repl sandbox (answers/vars) is
+ *  the model-reachable recovery channel — the session log is host-side only, never re-openable
+ *  by the model, so stubs must not promise it. */
 export const ROOT_TURN_ELIDED_LINE =
-  "… turn elided — durable facts live in Σ; full text in session log";
+  "… turn elided — durable facts live in Σ; your repl sandbox persists: print(answers) / SHOW_VARS() to re-derive";
 
 export function skillStateLines(noteCount: number, body: string): string {
   return [

package/src/prompts/user.ts

@@ -21,7 +21,8 @@ export function buildTurnPrompt(
 
 /** Asked once when the engine runs out of turns without a submitted answer. Same finalize
  *  dialect as the budget wrap-up note (audit M6): answer-ready first, plain text only as an
- *  explicit fallback the engine still accepts. */
+ *  explicit fallback the engine still accepts. Deliberately near-unreachable: the cap is
+ *  large by design (the old 16-cap all-failed oolong mid-retrieval). */
 export const FINALIZE_PROMPT =
   "You are out of turns. Finalize NOW: set `answer[\"content\"]` and `answer[\"ready\"] = True` " +
     "(fenced ```repl```) with your best final answer from everything you have gathered. " +

package/src/sandbox/sandbox.ts

@@ -92,7 +92,10 @@ export class PythonSandbox {
   private scanOffset = 0;
   private seq = 0;
   private readonly pending = new Map<string, Pending>();
-  private readonly handlers: SubLlmHandlers;
+  // Not readonly: the engine's continuation handoff re-installs a successor run's closures
+  // on a live worker (installHandlers) instead of respawning it — respawn would destroy the
+  // pinned context accumulator, which is exactly what the chain must preserve.
+  private handlers: SubLlmHandlers;
   private readonly requestTimeoutMs: number;
   private readonly initTimeoutMs: number;
   /** Bounded stderr tail (chunks, newest last) — avoids rebuilding the buffer per chunk. */
@@ -224,6 +227,15 @@ export class PythonSandbox {
     return res.index ?? 0;
   }
 
+  /**
+   * Continuation handoff (engine chain): re-install a successor run's sub-call handlers on
+   * THIS live worker so a chained engine run can adopt it without a respawn. Respawning
+   * would destroy the pinned context accumulator — the one thing the chain must preserve.
+   */
+  installHandlers(handlers: SubLlmHandlers): void {
+    this.handlers = { ...REJECT, ...handlers };
+  }
+
   async exec(code: string, signal?: AbortSignal): Promise<ReplResult> {
     const res = await this.request({ type: "exec", code }, signal);
     if (!res.ok) throw new Error(res.error ?? "exec failed");