@hicaru/pi-rlm 0.3.20 → 0.3.21

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, 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";
@@ -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
@@ -281,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.
@@ -368,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,
@@ -382,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
           }
         }
 
@@ -401,15 +427,22 @@ 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,
@@ -424,6 +457,7 @@ export function createEngine(deps: EngineDeps): RunRlm {
             .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, {
@@ -439,6 +473,7 @@ export function createEngine(deps: EngineDeps): RunRlm {
           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);
@@ -465,13 +500,33 @@ export function createEngine(deps: EngineDeps): RunRlm {
         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 {
@@ -484,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
@@ -495,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) {
@@ -639,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/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 — repl sandbox persists: print(answers[k]) or re-run repl to re-derive";
+/** 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 — repl sandbox persists: print(answers[k]) or
  *   - 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,6 +158,8 @@ 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
+      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
@@ -116,25 +167,31 @@ function elideRange(
       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: ROOT_TURN_ELIDED_LINE }]
-          : [{ type: "text", text: ROOT_TURN_ELIDED_LINE }];
+        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;
   }
@@ -184,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.