@hicaru/pi-rlm 0.3.18 → 0.3.19

package/README.md

@@ -43,24 +43,14 @@ models, recursively. Same Pi session, same tools, same keys: `/rlm` and go. Read
 
 ## Benchmarks
 
-**OOLONG (oolong-synth)** — paper-tier long-context suite; latest journal per model,
-cost per task from real `costUsd` (older journals estimated at OpenRouter list prices):
+**OOLONG (oolong-synth)** — paper-tier long-context suite (the only suite); latest
+journal per model, cost per task from real `costUsd`:
 
 | Model | Score | Avg. cost/task |
 |-------|-------|----------------|
-| `qwen/qwen3.8-27b` | **100%** | $0.0127 |
-| `google/gemma-3-27b-it` | 83.3% | $0.0013 |
-| `qwen/qwen3-30b-a3b-instruct-2507` | 66.7% | $0.0009 |
-| `mistralai/mistral-small-3.2-24b-instruct` | 66.7% | $0.0025 |
-
-Lite suite — `needle` multi-needle recall, `codeqa` repo-QA, `coding` fix task
-(7 tasks × 2 passes per model, deterministic graders, no LLM-as-judge):
-
-| Model | Score | Accuracy |
-|-------|-------|----------|
-| `qwen/qwen3-30b-a3b-instruct-2507` | **14/14** | **100%** |
-| `google/gemma-3-27b-it` | 12/14 | 86% |
-| `mistralai/mistral-small-3.2-24b-instruct` | 12/14 | 86% |
+| `qwen/qwen3.8-27b` | **87.5%** | $0.0460 |
+| `google/gemma-3-27b-it` | 50.0% | $0.0011 |
+| `inception/mercury-2.5` | — | — |
 
 Raw per-task rows (correct, recall, latency, tokens, cost) live in
 `bench/runs/*.jsonl` — one JSONL row per task, committed as history.
@@ -70,15 +60,13 @@ Raw per-task rows (correct, recall, latency, tokens, cost) live in
 ```bash
 export OPENROUTER_API_KEY=sk-or-...        # required — env vars are the only key transport
 
-bun run bench                              # lite suite: needle + codeqa + coding
-bun run bench --suite needle --limit 1     # one suite, first task only
-bun run bench --model openrouter/qwen/qwen3-30b-a3b-instruct-2507
+bun run bench                              # oolong suite, default model (qwen3.8-27b)
+bun run bench --model openrouter/google/gemma-3-27b-it
+bun run bench --model openrouter/inception/mercury-2.5
 bun run bench --list                       # print tasks, no engine / no key
-bun run bench --suite paper                # paper tier: s_niah, oolong, browsecomp, codeqa_lb (downloads datasets)
 ```
 
-Suites: `all` (lite, default) · `needle` · `codeqa` · `coding` · `paper` · `s_niah` ·
-`oolong` · `browsecomp` · `codeqa_lb`. Regenerate the hero chart:
+One suite (`oolong`). Regenerate the hero chart:
 `python3 bench/hero.py` (needs `matplotlib`).
 
 ## How it works

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hicaru/pi-rlm",
-	"version": "0.3.18",
+	"version": "0.3.19",
 	"author": "hicaru",
 	"repository": {
 		"type": "git",

package/src/config/defaults.ts

@@ -9,7 +9,10 @@ const DEFAULT_SUB_SYSTEM_PROMPT =
 export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   enabled: true,
   maxDepth: 4,
-  maxIterations: 30,
+  // Max-long runs: the engine may keep iterating until budget/compaction walls hit. The budget
+  // cascade and compactionThresholdPct are the real length controls; this ceiling only stops
+  // truly runaway loops. Was 30 — capped long tasks prematurely.
+  maxIterations: 200,
   execTimeoutS: 120,
   requestTimeoutMs: 15 * 60_000,
   // Session-wide, not per-batch: spawn() puts many requests on the wire at once, so this is
@@ -34,7 +37,11 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   maxErrors: 5,
   orchestrator: true,
   compaction: true,
-  compactionThresholdPct: 0.65,
+  // Compact only near the hard ceiling: ≈125K of the default 128K window (0.976). Earlier
+  // compaction (0.65) amputated usable working memory long before it was needed.
+  // DEPRECATED: ignored since the absolute 256k compaction ceiling (limits.ts); kept so old
+  // rlm.json files still load. Do not read this value in new code.
+  compactionThresholdPct: 0.976,
   python: "python3",
   sandboxInitTimeoutMs: 30_000,
   contextLoader: true,

package/src/core/budget.ts

@@ -1,7 +1,9 @@
 /**
  * Token budget cascade (port of the v4/v5 `budget.py` engine).
  *
- * The budget is the PRIMARY run-length control: cap = budgetShare × model context window,
+ * The budget is the PRIMARY run-length control: above COMPACTION_CEILING_TOKENS the cap is
+ * max(ceiling, budgetShare × model context window) — the share can only stretch the working
+ * budget further out, never cut under the ceiling;
  * one soft wrap-up turn at `softFrac` of the cap, and at the hard cap a deterministic
  * handoff (`distillTrajectory`) is handed to a fresh continuation run — chain-capped at
  * `maxContinuations`. Wall-clock timeouts stay only as hang backstops.
@@ -16,6 +18,7 @@ import type { ChatMsg } from "../bridge/model.ts";
 import type { RlmConfig } from "./types.ts";
 import type { RunState } from "./run-state.ts";
 import { compactJSON } from "./run-state.ts";
+import { COMPACTION_CEILING_TOKENS } from "./limits.ts";
 
 interface TokenBudgetOptions {
   readonly softFrac?: number;
@@ -110,14 +113,13 @@ export class TokenBudget {
 /**
  * Minimum context window (tokens) for the token-budget cascade to engage at all.
  *
- * The formula (window × budgetShare) assumes the window is large enough that a fraction of it
- * is a meaningful working budget. Below this floor the derived cap shrinks below a task's FIXED
- * overhead (system prompt + per-turn history re-send + sub-LLM calls) and strangles the run —
- * a 32k window would cap a task at 8k tokens, less than the protocol scaffolding alone.
- * So for smaller windows the rule does not apply: the budget is effectively unbounded and runs
- * stay bounded by maxIterations / maxErrors / wall-clock instead.
+ * LO rule (2025-09-09): windows at/below COMPACTION_CEILING_TOKENS (256k) are never
+ * budget-amputated — the derived share would shrink below a task's FIXED overhead (system
+ * prompt + per-turn history re-send + sub-LLM calls); a 32k window would cap a task at 8k
+ * tokens, less than the protocol scaffolding alone. Windows above the ceiling are budgeted
+ * AT the ceiling, never below it. Unbounded runs stay bounded by
+ * maxIterations / maxErrors / wall-clock instead.
  */
-export const BUDGET_WINDOW_FLOOR = 250_000;
 
 /** One TokenBudget construction shape — the cap varies, the policy knobs never do (DRY). */
 function makeBudget(config: RlmConfig, cap: number): TokenBudget {
@@ -135,8 +137,9 @@ function unboundedBudget(config: RlmConfig): TokenBudget {
 
 export function resolveBudget(contextWindow: number | undefined, config: RlmConfig): TokenBudget {
   const ctx = contextWindow !== undefined && contextWindow > 0 ? contextWindow : 32_000;
-  if (ctx < BUDGET_WINDOW_FLOOR) return unboundedBudget(config);
-  const shareCap = Math.floor(ctx * config.budgetShare);
+  if (ctx <= COMPACTION_CEILING_TOKENS) return unboundedBudget(config);
+  // The share only stretches the budget BEYOND the absolute ceiling — never under it.
+  const shareCap = Math.max(COMPACTION_CEILING_TOKENS, Math.floor(ctx * config.budgetShare));
   const cap = config.budgetTaskCap > 0 ? Math.min(shareCap, config.budgetTaskCap) : shareCap;
   return makeBudget(config, Math.max(cap, 1));
 }

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,18 @@ 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;
 }
 
 /**
@@ -142,6 +142,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,7 +26,7 @@ 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 { compactHistory, elideOldToolPayloads, rebaseWithState, shouldCompact } from "./compaction.ts";
@@ -364,16 +364,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"
@@ -602,8 +602,13 @@ export function createEngine(deps: EngineDeps): RunRlm {
 }
 
 function result(answer: string, iterations: number, limits: LimitGuard): 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, costUsd: u.costUsd, inputTokens: u.inputTokens, outputTokens: u.outputTokens, durationMs: u.durationMs };
 }
 
 /** Model metadata window, else the offline registry fallback (disk cache → table → 32k). */

package/src/core/limits.ts

@@ -8,6 +8,15 @@
 
 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).
+ */
+export const COMPACTION_CEILING_TOKENS = 256_000;
+
 export interface Limits {
   readonly maxTimeoutMs?: number;
   readonly maxTokens?: number;

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

@@ -54,7 +54,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;

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/text/parsing.ts

@@ -49,10 +49,55 @@ export type StateFenceResult =
 
 const STATE_FENCE = /(`{3,})[ \t]*state[ \t]*\r?\n([\s\S]*?)\1/g;
 
+/** Tolerant fallback: a payload object whose FIRST key is the patch key, emitted without a
+ *  (well-formed) fence — soak keeps catching `...report.state {"state_patch": …}}` blobs from
+ *  small models that mangle the opening backticks. Matched literally so ordinary prose or
+ *  example JSON never trips the scanner. */
+const BARE_PATCH = /\{"state_patch"\s*:/g;
+
+/** String-aware balanced-brace scan from `start` (an index of `{`). Honors string literals and
+ *  backslash escapes so braces inside JSON strings cannot unbalance the count. Returns the
+ *  complete object slice, or undefined when braces never balance before EOF. */
+function balancedJsonObject(text: string, start: number): string | undefined {
+  let depth = 0;
+  let inStr = false;
+  let esc = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text.charAt(i);
+    if (inStr) {
+      if (esc) esc = false;
+      else if (ch === "\\") esc = true;
+      else if (ch === '"') inStr = false;
+      continue;
+    }
+    if (ch === '"') inStr = true;
+    else if (ch === "{") depth += 1;
+    else if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return undefined;
+}
+
+/** A dangling opener/closer pair after the fence body was mangled (e.g. `.state {…}}` followed
+ *  by a lone ``` line) — cosmetic residue we scrub alongside the object itself. */
+const ORPHAN_FENCE = /^ {0,3}`{3,}[ \t]*\r?$/gm;
+
+/** Bookkeeping transport, never content: remove well-formed ```state fences AND the bare
+ *  {"state_patch"…} objects models leak when they botch the fence syntax (both directions —
+ *  parse for Σ harvest, strip for user-visible answers). Order: well-formed fences out first,
+ *  then the bare-object scan over the remainder can never double-count the same payload. */
+function sansFences(text: string): string {
+  return text.replace(STATE_FENCE, "");
+}
+
 /**
  * Workstream A: extract ```state fences (model-proposed ΔΣ_t) from a response, in document
- * order. ```repl parsing is untouched — the two fences coexist in one response. Malformed
- * JSON is surfaced as an error result for the retry loop, never thrown.
+ * order. ```repl parsing is untouched — the two fences coexist in one response. Well-formed
+ * fences yield parsed payloads or a parse error (error-as-observation for the retry ladder);
+ * malformed-fence payloads are recovered by the tolerant bare-object scanner, so a mangled
+ * opening fence never orphans a valid delta.
  */
 export function findStatePatches(text: string): readonly StateFenceResult[] {
   const out: StateFenceResult[] = [];
@@ -67,9 +112,50 @@ export function findStatePatches(text: string): readonly StateFenceResult[] {
       out.push({ ok: false, error: errorMessage(err) });
     }
   }
+  // Tolerant harvest over fence-free remainder (well-formed payloads already taken above).
+  const rest = sansFences(text);
+  BARE_PATCH.lastIndex = 0;
+  while ((m = BARE_PATCH.exec(rest)) !== null) {
+    const obj = balancedJsonObject(rest, m.index);
+    if (obj === undefined) continue;
+    try {
+      out.push({ ok: true, value: JSON.parse(obj) as unknown });
+    } catch (err: unknown) {
+      out.push({ ok: false, error: errorMessage(err) });
+    }
+  }
   return out;
 }
 
+/** Strip ```state fences from free text. A Σ fence is bookkeeping, never content — but models
+ *  that finalize right after a Σ splice tend to echo the fence verbatim as their final output,
+ *  which leaked raw state JSON into RlmResult.answer (bench graders scored JSON, reports showed
+ *  bookkeeping). Deterministic scrub on the answer path; parse semantics stay in findStatePatches.
+ *  Also removes bare {"state_patch"…} objects (mangled-fence leaks), a `state` token glued to
+ *  preceding prose, and orphan ``` lines left behind by the mangled pair. */
+export function stripStateFences(text: string): string {
+  let out = sansFences(text);
+  const parts: string[] = [];
+  let cursor = 0;
+  BARE_PATCH.lastIndex = 0;
+  let m: RegExpExecArray | null;
+  while ((m = BARE_PATCH.exec(out)) !== null) {
+    const obj = balancedJsonObject(out, m.index);
+    if (obj === undefined) continue;
+    // Glom any immediately-preceding bare `state`/`.state` token (prose like "...report.state {").
+    const before = out.slice(cursor, m.index).replace(/\s*(?:\.?state)\s*$/i, "");
+    parts.push(before);
+    cursor = m.index + obj.length;
+    BARE_PATCH.lastIndex = cursor;
+  }
+  // No bare objects → leave the text exactly as the well-formed pass left it (a lone ```
+  // line can be a legitimate unclosed code fence in real content; only scrub residue that
+  // our own removal created).
+  if (parts.length === 0) return out.trim();
+  parts.push(out.slice(cursor));
+  return parts.join("").replace(ORPHAN_FENCE, "").trim();
+}
+
 /** Truncate REPL stdout for the model's context window (head + tail, with an elision note).
  *  `mark` lets callers specialize the wording (root elision cites the session log) while the
  *  head/tail math stays the one implementation. */

package/src/ui/config-panel.ts

@@ -52,7 +52,7 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
     item("maxErrors", "Max consecutive errors", config.maxErrors != null ? String(config.maxErrors) : "none", CHOICES.maxErrors, "Stop after this many consecutive failing turns; none disables the guard."),
     item("orchestrator", "Orchestrator addendum", config.orchestrator ? "on" : "off", CHOICES.orchestrator, "Append extra divide-and-conquer guidance to the root model system prompt."),
     item("compaction", "Trajectory compaction", config.compaction ? "on" : "off", CHOICES.compaction, "Summarize old turns when history approaches the model context window."),
-    item("compactionThresholdPct", "Compaction threshold (%)", String(Math.round(config.compactionThresholdPct * 100)), CHOICES.compactionThresholdPct, "Compact once estimated history tokens reach this share of the root model's context window."),
+    item("compactionThresholdPct", "Compaction threshold (%)", String(Math.round(config.compactionThresholdPct * 100)), CHOICES.compactionThresholdPct, "DEPRECATED — ignored: compaction uses the absolute 256k ceiling (COMPACTION_CEILING_TOKENS)."),
     item("rootSamplingMaxTokens", "Root model output cap (tok)", String(config.rootSampling?.maxTokens ?? 16384), CHOICES.rootSamplingMaxTokens, "Max output tokens per root-model turn. Lower values keep each turn lean."),
     item("rootSamplingTemperature", "Root sampling temperature", config.rootSampling?.temperature === undefined ? "default" : String(config.rootSampling?.temperature), CHOICES.rootSamplingTemperature,
       "Sampling temperature for RLM root turns, finalize included — 0 = deterministic (the r3 reproducibility setting); 'default' = provider default. Applies to RLM-mode runs, rlm() delegation and child recursion; the native Pi agent loop follows Pi's own session settings."),

package/src/ui/tree/tree-model.ts

@@ -6,11 +6,14 @@
  *
  * Nothing is ever hidden: every sub-call renders as its own row (parity with
  * pi, which shows each concurrent tool call individually) — except runs of
- * IDENTICAL sibling leaves (same label+model+status), which collapse into one
- * expandable "label ×N" group row so a 20-item llm_batch is one line, not 20.
- * Error leaves are NEVER grouped — each keeps its own row and reason.
- * Collapsed subtrees are skipped at the user's explicit request (chevron flips).
- * Token rows are own-spend only — a row never blends models.
+ * CONSECUTIVE IDENTICAL sibling leaves (same label+model+status), which
+ * collapse into one expandable "label ×N" group row so a 20-item llm_batch is
+ * one line, not 20 and a wholesale batch failure is one `✗ label ×N` line.
+ * Errors group exactly like successes; distinct failures keep their own rows
+ * and reasons, and singletons render as plain rows. Interleaved siblings (✗ ✓
+ * ✗ with different keys between) stay in encounter order — position is never
+ * rewritten. Collapsed subtrees are skipped at the user's explicit request
+ * (chevron flips). Token rows are own-spend only — a row never blends models.
  */
 
 import type { RlmSubcall, RlmRunStatus, SubcallPhase, SubcallStatus } from "../../tool/rlm-details.ts";
@@ -81,9 +84,13 @@ type Entry =
   | { readonly type: "node"; readonly sc: RlmSubcall }
   | { readonly type: "group"; readonly key: string; readonly label: string; readonly model?: string; readonly status: SubcallStatus; readonly members: RlmSubcall[] };
 
-/** Errors never group — each keeps its own row and its own reason. */
+/**
+ * Any childless llm leaf may group — errors included. groupKey pins status, so
+ * only runs of identical failures merge; per-item reasons stay in the detail
+ * modal (expand the group).
+ */
 const groupable = (sc: RlmSubcall, byParent: ReadonlyMap<string | undefined, RlmSubcall[]>): boolean =>
-  sc.kind === "llm" && sc.status !== "error" && (byParent.get(sc.id)?.length ?? 0) === 0;
+  sc.kind === "llm" && (byParent.get(sc.id)?.length ?? 0) === 0;
 
 const groupKey = (sc: RlmSubcall): string => `${sc.label}|${sc.model ?? ""}|${sc.status}`;