@hicaru/pi-rlm 0.3.19 → 0.3.21

package/src/core/limits.ts

@@ -3,19 +3,20 @@
  * (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): model windows AT/BELOW this value are never
- * compacted or budget-amputated — the agent runs its full window. Windows ABOVE it are
- * compacted/budgeted exactly AT the ceiling (e.g. a 1M-context model works up to ~256k tokens
- * of history, then rebases/compacts). Single source of truth for budget.ts (resolveBudget)
- * and compaction.ts (shouldCompact + rebaseWithState token bound).
+ * 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 = 256_000;
+export const COMPACTION_CEILING_TOKENS = 1_000_000;
 
 export interface Limits {
   readonly maxTimeoutMs?: number;
@@ -36,7 +37,6 @@ export function limitsFromConfig(config: Limits): Limits {
 interface UsageSnapshot {
   readonly inputTokens: number;
   readonly outputTokens: number;
-  readonly costUsd: number;
   readonly durationMs: number;
 }
 
@@ -54,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) {
@@ -73,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;
   }
@@ -99,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

@@ -9,7 +9,9 @@
  * array) to honor the zero-extra-allocations rule.
  *
  * - `elideStalePayloads` — discard semantics (paper §5.3): tool payloads older than the
- *   keep window become head+tail previews; the full bytes remain in the session log.
+ *   keep window become head+tail previews; the full bytes ride the optional `onElide`
+ *   sink into the SessionArchive (recall W1) so elision stays dereferenceable — search()
+ *   over `ctx/session-log/*` recalls what the stub replaced.
  * - `spliceSigmaSnapshot` — the fresh Σ snapshot rides immediately before the last user
  *   message, exactly one instance (previous ones are removed — idempotent per call).
  *
@@ -19,7 +21,13 @@
 import type { ContextEvent } from "@earendil-works/pi-coding-agent";
 import type { RunState } from "./run-state.ts";
 import { runStateRootBlock } from "./run-state.ts";
-import { ROOT_TURN_ELIDED_LINE } from "../prompts/glossary.ts";
+import {
+  ROOT_ELIDE_PREVIEW_MARK,
+  ROOT_ELIDE_PREVIEW_MARK_REPL,
+  ROOT_TURN_ELIDED_ARCHIVE_LINE,
+  ROOT_TURN_ELIDED_LINE,
+  ROOT_TURN_ELIDED_PLAIN_LINE,
+} from "../prompts/glossary.ts";
 import { truncateOutput } from "../text/parsing.ts";
 import { textContentOf } from "../text/agent-text.ts";
 
@@ -29,9 +37,43 @@ export type RootMessage = ContextEvent["messages"][number];
 export interface ElideOptions {
   readonly keepTurns: number;
   readonly elideChars: number;
+  /** When true (SessionArchive wired + enabled), stubs point at the searchable archive;
+   *  when false they stay honest by promising less (no phantom recovery channel). */
+  readonly archiveActive?: boolean;
 }
 
-const ELIDE_MARK = "chars elided — full result in session log";
+/** One message the elision is about to destroy — the SessionArchive record shape. */
+export interface ElidedEntry {
+  readonly role: "assistant" | "toolResult";
+  readonly toolName: string | undefined;
+  /** The FULL original text (pre-preview, pre-stub) — the archive exists to hold it. */
+  readonly text: string;
+}
+export type ElideSink = (entry: ElidedEntry) => void;
+
+const REPL_TOOL = "repl";
+
+function elidedLineFor(role: string, toolName: string | undefined, archiveActive: boolean): string {
+  if (role === "toolResult" && toolName === REPL_TOOL) return ROOT_TURN_ELIDED_LINE;
+  return archiveActive ? ROOT_TURN_ELIDED_ARCHIVE_LINE : ROOT_TURN_ELIDED_PLAIN_LINE;
+}
+
+/** Normalized `archiveActive` — optional knob, resolved once per elide walk. */
+function archiveFlag(opts: ElideOptions): boolean {
+  return opts.archiveActive === true;
+}
+
+function previewMarkFor(toolName: string | undefined, archiveActive: boolean): string {
+  if (toolName === REPL_TOOL) return ROOT_ELIDE_PREVIEW_MARK_REPL;
+  // Recall W1: the archive mark may only promise what the archive actually holds.
+  return archiveActive ? ROOT_ELIDE_PREVIEW_MARK : "chars elided";
+}
+
+/** Narrow the toolName field off a toolResult message (indexed — host evolution safe). */
+function toolNameOf(message: RootMessage): string | undefined {
+  const name: unknown = (message as { toolName?: unknown }).toolName;
+  return typeof name === "string" ? name : undefined;
+}
 
 /**
  * WS-3a: elide stale turns. The newest `keepTurns` assistant turns and the final user message
@@ -40,12 +82,18 @@ const ELIDE_MARK = "chars elided — full result in session log";
  *   - recent stale ring (the last `max(keepTurns, 1)` stale turns): toolResult payloads over
  *     `elideChars` become head+tail previews (same truncation shape as repl stdout); assistant
  *     prose always collapses to the one-line stub.
- *   - older still: EVERYTHING (payloads included) becomes the one-line session-log stub —
- *     a stale preview per turn would itself accumulate linearly and re-create O(T).
+ *   - older still: EVERYTHING (payloads included) becomes the one-line stub — a stale preview
+ *     per turn would itself accumulate linearly and re-create O(T).
+ * When `onElide` is provided, every destroyed message's FULL text is handed to the sink
+ * BEFORE the stub replaces it (recall W1: the archive keeps elision dereferenceable).
  * `role:"custom"` messages of the Σ/intro kinds are immune (WS-3b owns them). Mutates the
  * array in place; returns the number of messages elided (telemetry), for zero-cost counters.
  */
-export function elideStalePayloads(messages: RootMessage[], opts: ElideOptions): number {
+export function elideStalePayloads(
+  messages: RootMessage[],
+  opts: ElideOptions,
+  onElide?: ElideSink,
+): number {
   const keepTurns = Math.max(0, Math.floor(opts.keepTurns));
   if (messages.length === 0) return 0;
   // Preview ring: stale turns recent enough to deserve the §5.3 head+tail preview. Scales with
@@ -55,7 +103,7 @@ export function elideStalePayloads(messages: RootMessage[], opts: ElideOptions):
   if (keepTurns === 0) {
     // R5 strict-0: nothing inside the window — Σ + immune customs + the final user message
     // are all that survive verbatim.
-    return elideRange(messages, 0, messages.length, opts, previewRing);
+    return elideRange(messages, 0, messages.length, opts, previewRing, onElide);
   }
 
   // Index of the assistant message that opens the keepTurns-th-from-last turn — everything
@@ -72,7 +120,7 @@ export function elideStalePayloads(messages: RootMessage[], opts: ElideOptions):
     }
   }
   if (tailStart <= 0) return 0; // fewer turns than the window — nothing to elide
-  return elideRange(messages, 0, tailStart, opts, previewRing);
+  return elideRange(messages, 0, tailStart, opts, previewRing, onElide);
 }
 
 /** Custom messages the elision never touches — the Σ snapshot/observation and the intro. */
@@ -94,6 +142,7 @@ function elideRange(
   to: number,
   opts: ElideOptions,
   previewRing: number,
+  onElide: ElideSink | undefined,
 ): number {
   const lastUser = lastIndexOfRole(messages, "user");
   // Pre-pass: stale assistant indices in [from, to) — a payload's recency is measured by the
@@ -109,21 +158,40 @@ 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;
+      const prose = textContentOf(m.content);
+      onElide?.({ role: "assistant", toolName: undefined, text: prose });
+      // 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 line = elidedLineFor("assistant", undefined, archiveFlag(opts));
+      const content: unknown[] =
+        toolCalls.length > 0 ? [...toolCalls, { type: "text", text: line }] : [{ type: "text", text: line }];
+      messages[i] = { ...m, content } as RootMessage;
       elided += 1;
       continue;
     }
     if (m.role !== "toolResult") continue;
+    const toolName = toolNameOf(m);
+    const fullText = textContentOf(m.content);
     if (staleAssistants >= previewRing) {
       // Deep-stale payload: even the preview would accumulate — collapse to the stub.
-      messages[i] = { ...m, content: [{ type: "text", text: ROOT_TURN_ELIDED_LINE }] } as RootMessage;
+      onElide?.({ role: "toolResult", toolName, text: fullText });
+      messages[i] = {
+        ...m,
+        content: [{ type: "text", text: elidedLineFor("toolResult", toolName, archiveFlag(opts)) }],
+      } as RootMessage;
       elided += 1;
       continue;
     }
-    if (totalTextLength(m) <= opts.elideChars) continue;
+    if (fullText.length <= opts.elideChars) continue;
+    onElide?.({ role: "toolResult", toolName, text: fullText });
     messages[i] = {
       ...m,
-      content: [{ type: "text", text: previewToolText(m, opts.elideChars) }],
+      content: [{ type: "text", text: previewToolText(fullText, opts.elideChars, toolName, archiveFlag(opts)) }],
     } as RootMessage;
     elided += 1;
   }
@@ -173,12 +241,8 @@ function lastIndexOfRole(messages: readonly RootMessage[], role: "user"): number
   return -1;
 }
 
-function totalTextLength(message: RootMessage): number {
-  return textContentOf((message as { content?: unknown }).content).length;
-}
-
-function previewToolText(message: RootMessage, elideChars: number): string {
-  const text = textContentOf((message as { content?: unknown }).content);
+/** Preview truncation moved the FULL text out to the caller first — this shapes what stays. */
+function previewToolText(fullText: string, elideChars: number, toolName: string | undefined, archiveActive: boolean): string {
   // The preview REPLACES the payload, so `elideChars` budgets the WHOLE head+tail result.
-  return truncateOutput(text, Math.max(100, elideChars), ELIDE_MARK);
+  return truncateOutput(fullText, Math.max(100, elideChars), previewMarkFor(toolName, archiveActive));
 }

package/src/core/root-digest.ts

@@ -25,9 +25,11 @@ import type { CompactionResult, SessionEntry } from "@earendil-works/pi-coding-a
 import type { RlmConfig } from "./types.ts";
 import { DEFAULT_NEXT_STEP, FINDINGS_MAX, FINDINGS_MIN_CHARS, NEXT_STEP_RE, STATE_MAX, truncateMid } from "./budget.ts";
 import { estimateMessageTokens } from "../text/tokens.ts";
+import { bm25Rank } from "../util/bm25.ts";
 import { agentMessageText } from "../text/agent-text.ts";
 import { isRecord } from "../util/type-guards.ts";
 import { ROOT_DIGEST_HEADER, ROOT_DIGEST_SECTIONS } from "../prompts/glossary.ts";
+import { trace, traceEnabled } from "../util/trace.ts";
 
 /** Marker persisted on the session's compaction entry — tests and soaks assert on it. */
 export interface RootDigestDetails {
@@ -106,17 +108,47 @@ function taskSection(messages: readonly unknown[]): string {
   return "";
 }
 
-/** [Findings] — newest-first substantive assistant blobs, capped, then chronological. */
-function findingsSection(messages: readonly unknown[]): readonly string[] {
-  const findings: string[] = [];
-  for (let i = messages.length - 1; i >= 0 && findings.length < FINDINGS_MAX; i--) {
+/** [Findings] — hybrid selection, then chronological render. Candidates keep the dedup
+ *  discipline (recall W4: exact + 80-char prefix), but the final pick is no longer pure
+ *  recency: each candidate scores `BM25(task) normalized + recency share`, so load-bearing
+ *  findings outrank newer rambles while recency breaks ties (and keeps no-overlap corpora
+ *  byte-compatible with the old newest-first behavior). */
+const FINDING_CANDIDATES_MAX = 40;
+
+function findingsSection(messages: readonly unknown[], task: string): readonly string[] {
+  const candidates: string[] = [];
+  const seenExact = new Set<string>();
+  const seenPrefix = new Set<string>();
+  for (let i = messages.length - 1; i >= 0 && candidates.length < FINDING_CANDIDATES_MAX; i--) {
     const m = messages[i];
     if (!isRecord(m) || m.role !== "assistant") continue;
     const text = agentMessageText(m).trim();
-    if (text.length > FINDINGS_MIN_CHARS) findings.push(text);
+    if (text.length <= FINDINGS_MIN_CHARS) continue;
+    const exactKey = text.toLowerCase().replace(/\s+/g, " ");
+    const prefixKey = exactKey.slice(0, 80);
+    if (seenExact.has(exactKey) || seenPrefix.has(prefixKey)) continue;
+    seenExact.add(exactKey);
+    seenPrefix.add(prefixKey);
+    candidates.push(text);
   }
-  findings.reverse();
-  return findings;
+  if (candidates.length <= FINDINGS_MAX) {
+    candidates.reverse();
+    return candidates;
+  }
+  // Hybrid rank: BM25 relevance to the live task + recency share (newest ≈ 1, oldest ≈ 0).
+  // `candidates` is collected newest-first, so recency decays with the index.
+  const ranked = bm25Rank(task, candidates.map((text) => ({ item: text, text })), candidates.length);
+  const relevance = new Map<string, number>();
+  const maxRel = ranked[0]?.score ?? 0;
+  for (const { item, score } of ranked) relevance.set(item, maxRel > 0 ? score / maxRel : 0);
+  const n = candidates.length;
+  const scored = candidates.map((text, i) => ({
+    text,
+    hybrid: (relevance.get(text) ?? 0) + (n - i) / n,
+  }));
+  scored.sort((a, b) => b.hybrid - a.hybrid);
+  const picked = new Set(scored.slice(0, FINDINGS_MAX).map((s) => s.text));
+  return candidates.filter((text) => picked.has(text));
 }
 
 /** [State] — newest-first toolResult first-lines (the last observed machinery state). */
@@ -163,10 +195,10 @@ export function buildRootDigestCompaction(
 
   const max = Math.max(200, args.config.rootDigestMaxChars);
   const task = truncateMid(taskSection(messages), Math.floor(max * TASK_FRACTION));
-  const findings = findingsSection(messages).map((f) => truncateMid(f, BULLET_CHARS));
+  const findings = findingsSection(messages, task).map((f) => truncateMid(f, BULLET_CHARS));
   const states = stateSection(messages);
   // Next-step probe mirrors distillTrajectory: newest-first scan, chronological render.
-  const next = findings.find((f) => NEXT_STEP_RE.test(f)) ?? DEFAULT_NEXT_STEP;
+  const next = [...findings].reverse().find((f) => NEXT_STEP_RE.test(f)) ?? DEFAULT_NEXT_STEP;
   const facts = args.store === undefined
     ? ""
     : args.store.sliceForPrompt(
@@ -190,12 +222,17 @@ export function buildRootDigestCompaction(
 
   // Over-cap drop order: [Project facts] → [State] → [Findings]; [Task]/[Next] survive to a
   // final truncate — task continuity beats trivia (paper §3.1 sufficient statistic).
+  // Recall W4: drops are traced (they were invisible before — a fat facts section could
+  // silently eat the entire [State] continuity floor).
+  let dropped = "";
   let summary = render(facts, states, findings);
-  if (summary.length > max) summary = render("", states, findings);
-  if (summary.length > max) summary = render("", [], findings);
+  if (summary.length > max) { summary = render("", states, findings); dropped = "facts"; }
+  if (summary.length > max) { summary = render("", [], findings); dropped += " state"; }
   if (summary.length > max) {
     summary = render("", [], findings.slice(0, Math.max(1, Math.floor(findings.length / 2))));
+    dropped += " findings-half";
   }
+  if (dropped !== "" && traceEnabled) trace("root-digest.drop", { dropped, max, finalChars: summary.length });
   summary = truncateMid(summary, max);
 
   const boundary = cut >= 0 ? args.branchEntries[cut] : undefined;

package/src/core/root-state.ts

@@ -124,14 +124,17 @@ export class RootStateTracker {
   }
 
   noteFinding(text: string): void {
-    const trimmed = text.trim();
+    // Runtime-harvested findings are clamped at the source — fence-sourced ones arrive ≤120
+    // via the patch clamp; this is the defense for direct feeds (engine mirrors arrive capped).
+    const trimmed = text.trim().slice(0, 300);
     if (trimmed === "") return;
     this.draft.findings = dedupStrings([...this.draft.findings, trimmed]).slice(-RUN_STATE_LIMITS.findings);
     this.touch();
   }
 
   noteFact(text: string): void {
-    const trimmed = text.trim();
+    // Clamp before dedup (recall W2): a verbose runtime feed must not eat the κ_Σ budget.
+    const trimmed = text.trim().slice(0, 200);
     if (trimmed === "") return;
     this.draft.verifiedFacts = dedupStrings([...this.draft.verifiedFacts, trimmed])
       .slice(-RUN_STATE_LIMITS.verifiedFacts);
@@ -150,17 +153,27 @@ export class RootStateTracker {
     this.touch();
   }
 
-  /** Tool-outcome feed (WS-4 v1 source): failures become approach outcomes, verbatim. */
+  /** Tool-outcome feed (WS-4 v1 source; recall W2 pollution fix): a SINGLE transient failure
+   *  (binary read, typo'd path) no longer writes a `testedApproaches` record — that record
+   *  evicted real approach entries and fired spurious [rectify] hints. Failures always grow
+   *  the rectify counter, but only PROMOTE to Σ once the failure repeats (threshold parity)
+   *  or a record already exists (then the record refreshes, keeping recency truthful). */
   observeToolResult(toolName: string, isError: boolean, reasonFirstLine: string): void {
+    const key = `tool:${toolName}`;
     if (isError) {
-      this.noteOutcome(`tool:${toolName}`, { status: "failed", reason: reasonFirstLine });
+      const streak = (this.failures.get(key) ?? 0) + 1;
+      this.failures.set(key, streak);
+      if (streak >= RECTIFY_FAILURE_THRESHOLD || this.draft.testedApproaches[key] !== undefined) {
+        this.noteOutcome(key, { status: "failed", reason: reasonFirstLine });
+      }
     } else {
       // A success clears the tool's failure streak — the state reflects the newest truth.
-      if (this.draft.testedApproaches[`tool:${toolName}`] !== undefined) {
-        this.noteOutcome(`tool:${toolName}`, { status: "succeeded", evidence: reasonFirstLine });
-      } else {
-        this.failures.delete(`tool:${toolName}`);
+      if (this.draft.testedApproaches[key] !== undefined) {
+        const failures = this.failures.get(key) ?? 0;
+        const evidence = failures > 0 ? `recovered after ${failures} failure(s)` : reasonFirstLine;
+        this.noteOutcome(key, { status: "succeeded", evidence });
       }
+      this.failures.delete(key);
     }
   }
 
@@ -204,14 +217,27 @@ export class RootStateTracker {
    * see the const's soak citation). Any accepted delta resets the streak. In
    * degraded mode fences stop applying and the context transform stops splicing (`isActive`),
    * while runtime `observeToolResult` remains the Σ floor (degrade, never crash).
+   *
+   * Recall W2 amendments (root-only, engine ladder untouched):
+   *  - `productiveTurn` — a turn that RAN TOOLS did work; growing the idle streak over it
+   *    degraded file-editing sessions whose turns legitimately need no fence. Productive
+   *    turns neither grow nor reset the streak (neutral).
+   *  - Retry accounting — a batch that ACCEPTED deltas does not accumulate its problems into
+   *    the session-wide retry counter (real work is never punished for a sibling's malformed
+   *    fence — the observation still reports them); the counter only grows over zero-progress
+   *    batches, so the storm cap stays a storm cap, not a session-lifetime budget.
    */
-  applyFences(fences: readonly StateFenceResult[]): FenceOutcome {
+  applyFences(fences: readonly StateFenceResult[], opts?: { readonly productiveTurn?: boolean }): FenceOutcome {
     // 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) {
+      if (opts?.productiveTurn === true) {
+        // Recall W2: tool-running turns are work, not fence idleness — neutral, no degrade.
+        return { fences: 0, accepted: 0, problems: 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.
       this.idleFenceTurns += 1;
@@ -247,9 +273,10 @@ export class RootStateTracker {
       this.touch();
       return { fences: fences.length, accepted, problems: 0 };
     }
-    // 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;
+    // Recall W2: a productive batch (accepted > 0) starts its retry count at zero instead of
+    // accumulating the session's history — the storm cap then measures CONSECUTIVE failure
+    // storms, not session age. Zero-progress batches accumulate exactly as before.
+    const retries = accepted > 0 ? problems.length : (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.

package/src/core/run-state.ts

@@ -109,9 +109,32 @@ const RUN_STATE_FIELDS: ReadonlySet<string> = new Set([
 const ARRAY_FIELDS: ReadonlySet<string> = new Set(["findings", "verifiedFacts", "openQuestions"]);
 const TASK_MAX_CHARS = 200;
 const NEXT_STEP_MAX_CHARS = 300;
+// Recall W2 contract alignment: STATE_FENCE_INSTRUCTION promises "≤ 5 keys per patch, every
+// string value ≤ 120 chars" — the validator now MEANS it. Oversized values are CLAMPED
+// fail-soft (the prose carries the story; Σ carries pointers), while the key count is
+// rejected with an explicit error (a restatement-shaped patch must come back as feedback —
+// §5.7: consistent validator feedback is the small-model bottleneck).
+const STATE_PATCH_MAX_KEYS = 5;
+const STATE_VALUE_MAX_CHARS = 120;
 // `findings` | `findings[+]` | `findings[2]` | `testedApproaches.h1`
 const PATCH_KEY = /^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)(\[\+\]|\[\d+\])?$/;
 
+/** Fail-soft contract clamp — every string Σ value honors the promised ≤120 chars. */
+function clampStateValue(value: string): string {
+  return value.length > STATE_VALUE_MAX_CHARS ? value.slice(0, STATE_VALUE_MAX_CHARS) : value;
+}
+
+/** Clamp the string fields of a validated outcome record IN PLACE (string→clamped, everything
+ *  else — explicit `null` deletes included — passes through untouched; the strict-merge null
+ *  semantics live in strictMergeRecord and must never be eaten by the clamp). */
+function clampOutcomeRecord(value: Readonly<Record<string, unknown>>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [key, field] of Object.entries(value)) {
+    out[key] = typeof field === "string" ? clampStateValue(field) : field;
+  }
+  return out;
+}
+
 export function freshRunState(task: string): RunState {
   return {
     task,
@@ -256,20 +279,23 @@ export function enforceCaps(draft: MutableState): Result<RunState, PatchError> {
     artifacts: { ...draft.artifacts },
   };
   // bytesTotal: |Σ_t| must never exceed κ_Σ — deterministic eviction order keeps runs flat.
+  // Order (recall W2): diary entries (findings) go first, SPECULATIVE entries (openQuestions)
+  // next, FOUNDATION (verifiedFacts: paths/symbols/configs) survives longest — losing a
+  // foundational fact is the irreversible-recall failure the paper warns about (§7 case 2).
   let guard = 0;
   while (JSON.stringify(capped).length > RUN_STATE_LIMITS.bytesTotal && guard++ < 10_000) {
     if (capped.findings.length > 0) {
       capped.findings = capped.findings.slice(1);
       continue;
     }
-    if (capped.verifiedFacts.length > 0) {
-      capped.verifiedFacts = capped.verifiedFacts.slice(1);
-      continue;
-    }
     if (capped.openQuestions.length > 0) {
       capped.openQuestions = capped.openQuestions.slice(1);
       continue;
     }
+    if (capped.verifiedFacts.length > 0) {
+      capped.verifiedFacts = capped.verifiedFacts.slice(1);
+      continue;
+    }
     const approach = firstKey(capped.testedApproaches);
     if (approach !== undefined) {
       const rest = { ...capped.testedApproaches };
@@ -331,7 +357,7 @@ function applyKey(draft: MutableState, rawKey: string, value: unknown): Result<n
     }
     if (op === "[+]") {
       if (typeof value !== "string") return err({ kind: "type", path: rawKey, expected: "string" });
-      list.push(value);
+      list.push(clampStateValue(value));
     } else if (op !== undefined) {
       const index = Number.parseInt(op.slice(1, -1), 10);
       if (value === null) {
@@ -346,11 +372,11 @@ function applyKey(draft: MutableState, rawKey: string, value: unknown): Result<n
       if (index > list.length) {
         return err({ kind: "schema", detail: `${rawKey} would leave a hole (len=${list.length})` });
       }
-      list[index] = value;
+      list[index] = clampStateValue(value);
     } else {
       if (!isStringArray(value)) return err({ kind: "type", path: rawKey, expected: "string[]" });
       list.length = 0;
-      list.push(...dedupStrings(value));
+      list.push(...dedupStrings(value.map(clampStateValue)));
     }
     return ok(null);
   }
@@ -409,15 +435,17 @@ function applyKey(draft: MutableState, rawKey: string, value: unknown): Result<n
     if (!isPlainObject(value) || !isApproachOutcome(value)) {
       return err({ kind: "type", path: rawKey, expected: "ApproachOutcome" });
     }
+    // Contract clamp: outcome strings honor the promised ≤120 chars (nulls stay nulls).
+    const outcome = clampOutcomeRecord(value);
     const prev: unknown = cursor[leaf];
     const merged = isPlainObject(prev)
-      ? strictMergeRecord(prev, value, rawKey)
-      : ok<Record<string, unknown>, PatchError>({ ...value });
+      ? strictMergeRecord(prev, outcome, rawKey)
+      : ok<Record<string, unknown>, PatchError>(outcome);
     if (!merged.ok) return merged;
     refreshOrder(cursor, leaf, merged.value); // last-mention ordering for eviction
   } else {
     if (typeof value !== "string") return err({ kind: "type", path: rawKey, expected: "string" });
-    refreshOrder(cursor, leaf, value);
+    refreshOrder(cursor, leaf, clampStateValue(value));
   }
   commitRecord(draft, root, record);
   return ok(null);
@@ -454,6 +482,14 @@ export function applyPatch(prev: RunState, patch: unknown, t: number): Result<Ru
   }
   const ops = Object.entries(patch.state_patch);
   if (ops.length === 0) return err({ kind: "schema", detail: "empty state_patch" });
+  // Contract alignment (recall W2): the instruction promises ≤ 5 keys — a bigger patch is a
+  // restatement, and restatements must come back as feedback, not silently inflate Σ.
+  if (ops.length > STATE_PATCH_MAX_KEYS) {
+    return err({
+      kind: "schema",
+      detail: `${ops.length} keys — ≤ ${STATE_PATCH_MAX_KEYS} per patch; commit deltas only`,
+    });
+  }
   // Per-turn byte cap (bench rec #1): reject BEFORE the draft clone — a verbose restatement
   // must come back as an error observation, never silently eat output tokens.
   if (JSON.stringify(patch).length > RUN_STATE_LIMITS.patchBytes) {
@@ -469,6 +505,21 @@ export function applyPatch(prev: RunState, patch: unknown, t: number): Result<Ru
   return enforceCaps(draft);
 }
 
+/** The actual limits, spelled out at rejection time — a small model told only "cap exceeded"
+ *  thrashes blind retries into the degrade threshold. Field name → human limit (one source:
+ *  RUN_STATE_LIMITS + the scalar caps). */
+const CAP_LIMITS: Readonly<Record<string, string>> = Object.freeze({
+  task: `≤ ${TASK_MAX_CHARS} chars`,
+  nextStep: `≤ ${NEXT_STEP_MAX_CHARS} chars`,
+  findings: `≤ ${RUN_STATE_LIMITS.findings} entries`,
+  verifiedFacts: `≤ ${RUN_STATE_LIMITS.verifiedFacts} entries`,
+  testedApproaches: `≤ ${RUN_STATE_LIMITS.testedApproaches} entries`,
+  openQuestions: `≤ ${RUN_STATE_LIMITS.openQuestions} entries`,
+  artifacts: `≤ ${RUN_STATE_LIMITS.artifacts} entries`,
+  patchBytes: `≤ ${RUN_STATE_LIMITS.patchBytes} bytes per patch`,
+  bytesTotal: `≤ ${RUN_STATE_LIMITS.bytesTotal} bytes total`,
+});
+
 /** Human-facing patch rejection — becomes the next O_t prefix (error-as-observation). */
 export function patchErrorText(error: PatchError): string {
   switch (error.kind) {
@@ -478,8 +529,10 @@ export function patchErrorText(error: PatchError): string {
       return `type mismatch at "${error.path}" (expected ${error.expected})`;
     case "implicit-drop":
       return `implicit key drop at "${error.path}" — restate the key or delete it with null`;
-    case "cap":
-      return `cap exceeded on "${error.field}"`;
+    case "cap": {
+      const limit = CAP_LIMITS[error.field];
+      return `cap exceeded on "${error.field}"${limit === undefined ? "" : ` — the limit is ${limit}`}`;
+    }
   }
 }
 
@@ -491,6 +544,9 @@ export function patchErrorText(error: PatchError): string {
  * Idle degrade (bench rec #2): when `fenceRequested` is true (the turn conditioned on Σ)
  * and zero patches were accepted, the turn is IDLE — Σ inflated the prompt for nothing.
  * `RUN_STATE_IDLE_DEGRADE_TURNS` consecutive idle turns degrade, same as-built outcome.
+ * `productive` (root parity, recall W2): a turn that executed real repl work without
+ * raising RESETS the idle streak — heavy execution is progress even without a delta, and
+ * a mid-run amputation of Σ costs more than the prompt it saves.
  */
 export function applyStatePatches(
   mode: Extract<RunStateMode, { kind: "active" }>,
@@ -498,10 +554,11 @@ export function applyStatePatches(
   iteration: number,
   config: Pick<RlmConfig, "runStateRetryMax">,
   fenceRequested = false,
+  productive = false,
 ): { readonly mode: RunStateMode; readonly observation: string | undefined } {
   // Identity fast-path: a fence-free turn on a run that never asked for fences changes
   // nothing — keep the same mode object (callers may compare identity).
-  if (parsed.length === 0 && !fenceRequested) return { mode, observation: undefined };
+  if (parsed.length === 0 && !fenceRequested && !productive) return { mode, observation: undefined };
   let state = mode.state;
   let retries = mode.retries;
   let accepted = 0;
@@ -522,7 +579,8 @@ export function applyStatePatches(
     }
   }
   // Bench rec #2: accepted deltas reset the idle streak; a requested-but-empty turn grows it.
-  const idle = accepted > 0 || !fenceRequested ? 0 : mode.idle + 1;
+  // Productive-turn parity (root tracker): executed work resets the streak too.
+  const idle = accepted > 0 || !fenceRequested || productive ? 0 : mode.idle + 1;
   let nextMode: RunStateMode = { kind: "active", state, retries, idle };
   if (retries > config.runStateRetryMax) {
     nextMode = {
@@ -557,6 +615,9 @@ export const STATE_FENCE_INSTRUCTION: string =
   "Σ 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" +
+  `Caps: findings ≤ ${RUN_STATE_LIMITS.findings}, verifiedFacts ≤ ${RUN_STATE_LIMITS.verifiedFacts}, ` +
+  `testedApproaches ≤ ${RUN_STATE_LIMITS.testedApproaches}, openQuestions/artifacts ≤ ${RUN_STATE_LIMITS.openQuestions}/${RUN_STATE_LIMITS.artifacts} — ` +
+  "oldest entries are evicted automatically, so push new facts and let Σ prune itself.\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 ` +
@@ -578,6 +639,17 @@ export function runStateTurnBlock(state: RunState): string {
   return sigmaBlock(state, true);
 }
 
+/**
+ * Σ economics: re-sending a byte-identical Σ every turn is up to ~3K tokens of attention tax
+ * that carries zero new information — the model saw it one turn ago. The marker keeps the
+ * patch grammar within reach (a small model without it stops committing at all) while cutting
+ * the block ~10x. Callers must re-send the FULL block after compaction/rebase or degrade.
+ */
+export const SIGMA_UNCHANGED_LINE =
+  "[Σ] unchanged since last turn — deltas apply against it. Grammar: dotted keys, [+] append, " +
+  "[N] set slot, null delete; ≤ 5 keys per patch, every value ≤ 120 chars. Fence only NEW " +
+  "durable facts; an absent fence is free.";
+
 /**
  * Root Σ (WS-3b): the ROOT's A_t block. R2 (G2): with `withContract` the splice carries the
  * SAME fence contract (delegating to the one composer above — no re-wording), making the