@hicaru/pi-rlm 0.3.17 → 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.17",
+	"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,
@@ -56,25 +63,29 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   // bare-number finalize gets one coached redo instead of being accepted. Opt-in via rlm.json.
   enableVerificationNudge: false,
   // SKILL.state integration: Σ_t execution state + cross-session distilled knowledge.
-  enableRunState: true,
+  // Paradigm flags are ENFORCED (R0, /tmp/ROOT_FULL_SKILLSTATE_PLAN.md) — validateEnforcedOn
+  // forces true whatever rlm.json carries; only calibrations are tunable.
+  enableRunState: true, // ENFORCED — see /tmp/ROOT_FULL_SKILLSTATE_PLAN.md R0
   runStateRetryMax: 2,
-  enableSkillState: true,
+  enableSkillState: true, // ENFORCED — see /tmp/ROOT_FULL_SKILLSTATE_PLAN.md R0
   // Default ON (bench rec #3): deterministic harvest — one cheap distill leaf per finalize
   // replaces the stochastic fence-emission harvest (0 vs 4 notes across identical ON arms).
-  enableSkillStateDistill: true,
+  enableSkillStateDistill: true, // ENFORCED — see /tmp/ROOT_FULL_SKILLSTATE_PLAN.md R0
   skillStateMaxTokens: 1_200,
   skillStateLeafTokens: 200,
   skillStateMinScore: 4.0,
   skillStateNotesPerProject: 128,
-  // Root Σ integration (WS-2..WS-4): digest compaction ON (it only swaps the summarizer for
-  // a deterministic digest — zero tokens, strictly less latency); the context transform and
-  // model-proposed fences soak with flags OFF until the A/B says otherwise.
-  enableRootDigestCompaction: true,
+  // Root Σ integration (WS-2..WS-4): every LLM call assembles A_t = (P, Σ_t, O_t) — discard
+  // semantics on stale payloads + exactly one Σ snapshot splice, and model-proposed ΔΣ_t
+  // fences taught in the native prompt (v2 R1/R2). Digest compaction swaps Pi's summarizer
+  // for a deterministic digest. Flags are ENFORCED (R0); RLM_BENCH_NO_ROOTCONTEXT=1 remains
+  // the dev-only A/B measurement hatch — it alters measurement, never ships as a disable path.
+  enableRootDigestCompaction: true, // ENFORCED — see /tmp/ROOT_FULL_SKILLSTATE_PLAN.md R0
   rootDigestKeepRecentChars: 12_000,
   rootDigestMaxChars: 8_000,
-  enableRootContextTransform: false,
+  enableRootContextTransform: true, // ENFORCED — see /tmp/ROOT_FULL_SKILLSTATE_PLAN.md R0 (was soak-OFF pre-v2)
   rootContextKeepTurns: 2,
   rootContextElideChars: 1_500,
   rootContextSnapshot: true,
-  enableRootStateFences: false,
+  enableRootStateFences: true, // ENFORCED — see /tmp/ROOT_FULL_SKILLSTATE_PLAN.md R0 (was soak-OFF pre-v2)
 });

package/src/config/settings.ts

@@ -5,6 +5,7 @@ import { dirname, join } from "node:path";
 import { getAgentDir, type ModelRegistry } from "@earendil-works/pi-coding-agent";
 import type { Api, Model, ThinkingLevel } from "@earendil-works/pi-ai";
 import type { RlmConfig } from "../core/types.ts";
+import { trace, traceEnabled } from "../util/trace.ts";
 import { DEFAULT_CONFIG } from "./defaults.ts";
 
 interface PersistedSettings {
@@ -31,6 +32,21 @@ function validateBoolean(v: unknown): boolean | undefined {
   return typeof v === "boolean" ? v : undefined;
 }
 
+/**
+ * R0 enforcement (/tmp/ROOT_FULL_SKILLSTATE_PLAN.md): the SKILL.state paradigm flags are
+ * operating law — they ALWAYS resolve to `true`, whatever rlm.json says. An explicit `false`
+ * is not an error (fail-soft by contract): it is traced (`skillstate.override-ignored`) and
+ * ignored, so a hostile or typo'd config loses visibly instead of crashing the load or
+ * silently unbounding the root context. Calibrations (window sizes, budgets) stay tunable —
+ * the PARADIGM is enforced, the calibrations are not.
+ */
+function validateEnforcedOn(value: unknown, flag: string): true {
+  if (value === false && traceEnabled) {
+    trace("skillstate.override-ignored", { flag, value });
+  }
+  return true;
+}
+
 function validateString(v: unknown): string | undefined {
   return typeof v === "string" && v.trim() ? v : undefined;
 }
@@ -138,15 +154,13 @@ export function validateConfig(raw: unknown): Partial<RlmConfig> {
   // Verification-discipline nudge (default OFF).
   const enableVerificationNudge = validateBoolean(r.enableVerificationNudge);
   if (enableVerificationNudge !== undefined) out.enableVerificationNudge = enableVerificationNudge;
-  // SKILL.state integration (Workstreams A–F)
-  const enableRunState = validateBoolean(r.enableRunState);
-  if (enableRunState !== undefined) out.enableRunState = enableRunState;
+  // SKILL.state integration (Workstreams A–F) — paradigm flags ENFORCED (R0); runStateRetryMax
+  // is a calibration and stays tunable.
+  out.enableRunState = validateEnforcedOn(r.enableRunState, "enableRunState");
   const runStateRetryMax = validateNumber(r.runStateRetryMax, 0);
   if (runStateRetryMax !== undefined) out.runStateRetryMax = runStateRetryMax;
-  const enableSkillState = validateBoolean(r.enableSkillState);
-  if (enableSkillState !== undefined) out.enableSkillState = enableSkillState;
-  const enableSkillStateDistill = validateBoolean(r.enableSkillStateDistill);
-  if (enableSkillStateDistill !== undefined) out.enableSkillStateDistill = enableSkillStateDistill;
+  out.enableSkillState = validateEnforcedOn(r.enableSkillState, "enableSkillState");
+  out.enableSkillStateDistill = validateEnforcedOn(r.enableSkillStateDistill, "enableSkillStateDistill");
   const skillStateMaxTokens = validateNumber(r.skillStateMaxTokens, 50);
   if (skillStateMaxTokens !== undefined) out.skillStateMaxTokens = skillStateMaxTokens;
   const skillStateLeafTokens = validateNumber(r.skillStateLeafTokens, 0);
@@ -155,23 +169,21 @@ export function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (skillStateMinScore !== undefined) out.skillStateMinScore = skillStateMinScore;
   const skillStateNotesPerProject = validateNumber(r.skillStateNotesPerProject, 1);
   if (skillStateNotesPerProject !== undefined) out.skillStateNotesPerProject = skillStateNotesPerProject;
-  // Root Σ integration (WS-2..WS-4)
-  const enableRootDigestCompaction = validateBoolean(r.enableRootDigestCompaction);
-  if (enableRootDigestCompaction !== undefined) out.enableRootDigestCompaction = enableRootDigestCompaction;
+  // Root Σ integration (WS-2..WS-4) — paradigm flags ENFORCED (R0); the window/byte knobs
+  // below are calibrations and stay tunable.
+  out.enableRootDigestCompaction = validateEnforcedOn(r.enableRootDigestCompaction, "enableRootDigestCompaction");
   const rootDigestKeepRecentChars = validateNumber(r.rootDigestKeepRecentChars, 200);
   if (rootDigestKeepRecentChars !== undefined) out.rootDigestKeepRecentChars = rootDigestKeepRecentChars;
   const rootDigestMaxChars = validateNumber(r.rootDigestMaxChars, 200);
   if (rootDigestMaxChars !== undefined) out.rootDigestMaxChars = rootDigestMaxChars;
-  const enableRootContextTransform = validateBoolean(r.enableRootContextTransform);
-  if (enableRootContextTransform !== undefined) out.enableRootContextTransform = enableRootContextTransform;
+  out.enableRootContextTransform = validateEnforcedOn(r.enableRootContextTransform, "enableRootContextTransform");
   const rootContextKeepTurns = validateNumber(r.rootContextKeepTurns, 0);
   if (rootContextKeepTurns !== undefined) out.rootContextKeepTurns = rootContextKeepTurns;
   const rootContextElideChars = validateNumber(r.rootContextElideChars, 100);
   if (rootContextElideChars !== undefined) out.rootContextElideChars = rootContextElideChars;
   const rootContextSnapshot = validateBoolean(r.rootContextSnapshot);
   if (rootContextSnapshot !== undefined) out.rootContextSnapshot = rootContextSnapshot;
-  const enableRootStateFences = validateBoolean(r.enableRootStateFences);
-  if (enableRootStateFences !== undefined) out.enableRootStateFences = enableRootStateFences;
+  out.enableRootStateFences = validateEnforcedOn(r.enableRootStateFences, "enableRootStateFences");
   if (typeof r.subSampling === "object" && r.subSampling !== null) {
     const ss = r.subSampling as Record<string, unknown>;
     const sampling: { maxTokens?: number; temperature?: number; reasoning?: ThinkingLevel } = {};

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-context.ts

@@ -19,6 +19,7 @@
 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 { truncateOutput } from "../text/parsing.ts";
 import { textContentOf } from "../text/agent-text.ts";
 
@@ -33,15 +34,29 @@ export interface ElideOptions {
 const ELIDE_MARK = "chars elided — full result in session log";
 
 /**
- * WS-3a: elide stale tool payloads. The newest `keepTurns` assistant turns and the final
- * user message stay verbatim; older toolResult content over `elideChars` becomes a
- * head+tail preview (same truncation shape as repl stdout). `role:"custom"` messages with
- * `customType: "rlm-sigma"` are immune (WS-3b owns them). Mutates the array in place;
- * returns the number of messages elided (telemetry), for zero-cost counters at the seam.
+ * WS-3a: elide stale turns. The newest `keepTurns` assistant turns and the final user message
+ * stay verbatim. Older turns collapse in two tiers (§5.3 discard semantics + R5/G4 honest
+ * strictness, and the only way the R6 acceptance bound — per-call ≤ Σ + window — can hold):
+ *   - 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).
+ * `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 {
   const keepTurns = Math.max(0, Math.floor(opts.keepTurns));
-  if (keepTurns === 0 || messages.length === 0) return 0;
+  if (messages.length === 0) return 0;
+  // Preview ring: stale turns recent enough to deserve the §5.3 head+tail preview. Scales with
+  // the window knob — one calibration, two tiers (preview ring, then stub) — and never zero,
+  // so keepTurns=0 still previews the single closest stale payload instead of stubbing blind.
+  const previewRing = Math.max(keepTurns, 1);
+  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);
+  }
 
   // Index of the assistant message that opens the keepTurns-th-from-last turn — everything
   // from there on is the protected tail (same walk as core/compaction.ts elideOldToolPayloads).
@@ -57,15 +72,55 @@ 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);
+}
+
+/** Custom messages the elision never touches — the Σ snapshot/observation and the intro. */
+const IMMUNE_CUSTOM_TYPES: ReadonlySet<string> = new Set(["rlm-sigma", "rlm-sigma-observation", "rlm-intro"]);
+
+function isImmuneCustom(m: RootMessage): boolean {
+  if (m.role !== "custom") return false;
+  const customType: unknown = (m as { customType?: unknown }).customType;
+  return typeof customType === "string" && IMMUNE_CUSTOM_TYPES.has(customType);
+}
 
+/** R5: elide [from, to) — stale assistant prose always becomes the one-line Σ stub; stale
+ *  toolResults get the §5.3 preview while `assistantsAfter < previewRing` and the stub beyond
+ *  (two-tier elision — previews must not accumulate linearly). Immune customs and the final
+ *  user message are never touched. Mutates in place; returns the elided count. */
+function elideRange(
+  messages: RootMessage[],
+  from: number,
+  to: number,
+  opts: ElideOptions,
+  previewRing: number,
+): number {
   const lastUser = lastIndexOfRole(messages, "user");
+  // Pre-pass: stale assistant indices in [from, to) — a payload's recency is measured by the
+  // stale turns AFTER it (pre-allocated walk, no per-message allocation).
+  let staleAssistants = 0;
+  for (let i = from; i < to; i++) {
+    if (messages[i]?.role === "assistant") staleAssistants += 1;
+  }
   let elided = 0;
-  for (let i = 0; i < tailStart; i++) {
+  for (let i = from; i < to; i++) {
     const m = messages[i];
-    if (m === undefined || m.role !== "toolResult") continue;
+    if (m === undefined || isImmuneCustom(m)) continue;
     if (i === lastUser) continue; // paranoia: the final user message is never touched
-    const total = totalTextLength(m);
-    if (total <= opts.elideChars) continue;
+    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;
+      elided += 1;
+      continue;
+    }
+    if (m.role !== "toolResult") continue;
+    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;
+      elided += 1;
+      continue;
+    }
+    if (totalTextLength(m) <= opts.elideChars) continue;
     messages[i] = {
       ...m,
       content: [{ type: "text", text: previewToolText(m, opts.elideChars) }],
@@ -75,13 +130,16 @@ export function elideStalePayloads(messages: RootMessage[], opts: ElideOptions):
   return elided;
 }
 
-/** WS-3b: exactly one live Σ snapshot, immediately before the LAST user message. */
+/** WS-3b: exactly one live Σ snapshot, immediately before the LAST user message.
+ *  R2 (G2): `withContract` makes the splice carry the fence contract (A.4 authoring mode) —
+ *  pass-through to runStateRootBlock; without it, the v1 observation-only block. */
 export function spliceSigmaSnapshot(
   messages: RootMessage[],
   state: RunState,
   rectifyHint: string | undefined,
+  opts?: { readonly withContract?: boolean },
 ): void {
-  const block = runStateRootBlock(state);
+  const block = runStateRootBlock(state, opts);
   const text = rectifyHint === undefined ? block : `${block}\n${rectifyHint}`;
   // Remove any previous instance (only one lives at a time — idempotent across calls).
   for (let i = messages.length - 1; i >= 0; i--) {

package/src/core/root-state.ts

@@ -6,7 +6,8 @@
  * controller/sandboxManager. It is runtime-derived — tool outcomes, engine-run mirrors,
  * the user's latest prompt — zero model cooperation required (paper §5.3: observation
  * override; §5.7: small models must not be the state's author by default). The optional
- * fence protocol (enableRootStateFences, default OFF) is the only model-proposed input and
+ * fence protocol (enableRootStateFences — ENFORCED ON since Root Σ v2 R0) is the only
+ * model-proposed input and
  * rides the SAME V(ΔΣ_t,Σ_t) validator + retry/degrade ladder as engine runs.
  *
  * Caps/dedup/serialization are the engine's own machinery: RUN_STATE_LIMITS, dedupStrings,
@@ -35,6 +36,23 @@ const RECTIFY_FAILURE_THRESHOLD = 2;
 /** Task restatement cap — mirrors run-state.ts TASK_MAX_CHARS (kept in sync by comment). */
 const ROOT_TASK_MAX_CHARS = 200;
 
+/** R4: idle-degrade threshold for the NATIVE root tracker — deliberately ROOT-SPECIFIC
+ *  (soak finding, 2025-09-08 live sessions: qwen3.8-27b ×3, qwen3-30b/32b, gemini-flash).
+ *  The engine's `RUN_STATE_IDLE_DEGRADE_TURNS = 4` is bench-tuned for runs conditioned on Σ
+ *  from turn 1; NATIVE sessions have a cold-start ramp — first fences land on turn 3 (short
+ *  tasks) or turn 5–6 (study tasks), so 4 amputated exactly before the first commit (2/2
+ *  study sessions degraded at 4, then fenced at 5). 6 clears the observed ramp while still
+ *  bounding the fence tax. The engine const and its tuning are untouched.
+ */
+export const ROOT_IDLE_DEGRADE_TURNS = 6;
+
+/** R3 soak observability: per-turn fence outcome, returned by applyFences. */
+export interface FenceOutcome {
+  readonly fences: number;
+  readonly accepted: number;
+  readonly problems: number;
+}
+
 /** Root Σ mode — same discriminated union shape as the engine's (active | degraded). */
 type RootStateMode =
   | { readonly kind: "active"; readonly retries: number }
@@ -45,6 +63,8 @@ export class RootStateTracker {
   private mode: RootStateMode = { kind: "active", retries: 0 };
   private opCounter = 0;
   private dirtyFlag = false;
+  /** R4: consecutive fence-eligible turns with zero accepted deltas (idle streak). */
+  private idleFenceTurns = 0;
   private readonly failures = new Map<string, number>();
   private pendingObservation: string | undefined;
   private readonly retryMax: number;
@@ -82,6 +102,21 @@ export class RootStateTracker {
     return this.dirtyFlag;
   }
 
+  /** R4: true while the tracker accepts fences and the context transform may splice Σ. */
+  get isActive(): boolean {
+    return this.mode.kind === "active";
+  }
+
+  /** R4 telemetry: consecutive fence-eligible turns with zero accepted deltas. */
+  get idleTurns(): number {
+    return this.idleFenceTurns;
+  }
+
+  /** R4 telemetry: the degrade reason while degraded; undefined while active. */
+  get degradeReason(): string | undefined {
+    return this.mode.kind === "degraded" ? this.mode.reason : undefined;
+  }
+
   snapshot(): RunState {
     const capped = enforceCaps(this.draft);
     // enforceCaps never fails in practice; the fallback keeps the tracker fail-soft anyway.
@@ -160,11 +195,32 @@ export class RootStateTracker {
    * deltas land sequentially, ALL problems accumulate into ONE observation (error-as-
    * observation), and only past `runStateRetryMax` total rejections the tracker degrades and
    * fences stop being applied. Wording delegates to run-state.ts (N1) — one source.
+   *
+   * R4 (G6, /tmp/ROOT_FULL_SKILLSTATE_PLAN.md): idle-degrade parity with the engine — once
+   * the native prompt teaches the fence contract, EVERY finalized assistant turn is
+   * fence-eligible; a turn with zero accepted deltas grows `idleFenceTurns` and
+   * `ROOT_IDLE_DEGRADE_TURNS` consecutive idle turns degrade the tracker (an idle Σ is
+   * pure input tax — bench rec #2, paper §5.7; root threshold is 6, not the engine's 4 —
+   * 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).
    */
-  applyFences(fences: readonly StateFenceResult[]): void {
-    if (this.mode.kind !== "active" || fences.length === 0) return;
+  applyFences(fences: readonly StateFenceResult[]): 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) {
+      // 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;
+      this.degradeIfIdle();
+      return { fences: 0, accepted: 0, problems: 0 };
+    }
     let state = this.snapshot();
     const problems: string[] = [];
+    let accepted = 0;
     for (const fence of fences) {
       if (!fence.ok) {
         problems.push(malformedFenceProblem(fence.error));
@@ -173,27 +229,50 @@ export class RootStateTracker {
       const next: Result<RunState, PatchError> = applyPatch(state, fence.value, ++this.opCounter);
       if (next.ok) {
         state = next.value;
+        accepted += 1;
       } else {
         problems.push(patchErrorText(next.error));
       }
     }
+    // Accepted deltas reset the idle streak — even in a partially-failing batch (engine
+    // parity: real work is never punished for a sibling's malformed fence).
+    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;
+      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 {
-      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 };
+  }
+
+  /** R4: fire the idle degrade at the root threshold (active trackers only). */
+  private degradeIfIdle(): void {
+    if (this.mode.kind === "active" && this.idleFenceTurns >= ROOT_IDLE_DEGRADE_TURNS) {
+      this.mode = {
+        kind: "degraded",
+        reason: `idle degrade — ${this.idleFenceTurns} consecutive turns with zero accepted deltas`,
+      };
     }
   }
 

package/src/core/run-state.ts

@@ -552,26 +552,41 @@ 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;
+ *  without it, observation-only mode. */
+function sigmaBlock(state: RunState, withContract: boolean): string {
+  const sigma = `[Σ] ${compactJSON(state)}`;
+  return withContract ? `${STATE_FENCE_INSTRUCTION}\n\n${sigma}` : sigma;
+}
 
 /** The per-turn A_t block: the fence contract + the current Σ (paper A_t = (P, Σ_t, O_t)). */
 export function runStateTurnBlock(state: RunState): string {
-  return `${STATE_FENCE_INSTRUCTION}\n\n[Σ] ${compactJSON(state)}`;
+  return sigmaBlock(state, true);
 }
 
 /**
- * Root Σ (WS-3b): the ROOT's A_t block — the snapshot WITHOUT the patch-fence contract (the
- * root answers through Pi, not the engine's fence parser; WS-4.2 teaches fences separately
- * when enabled). Recall line comes from the glossary (one wording source).
+ * 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
+ * splice paper-faithful A.4 authoring mode; without it, byte-identical to the v1
+ * observation-only snapshot. Recall line comes from the glossary (one wording source).
  */
-export function runStateRootBlock(state: RunState): string {
-  return `[Σ] ${compactJSON(state)}\n` +
+export function runStateRootBlock(state: RunState, opts?: { readonly withContract?: boolean }): string {
+  return sigmaBlock(state, opts?.withContract === true) +
+    "\n" +
     "Fresh tool results outrank Σ when they disagree.\n" +
     `[Project facts recall: skill_search()] — ${SKILL_RECALL_LINE}`;
 }

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

@@ -13,7 +13,7 @@ import { loadSettings, mergeConfig, resolveModelId } from "./config/settings.ts"
 import { RlmController } from "./mode/rlm-mode.ts";
 import { cheapestModel } from "./mode/llm-model.ts";
 import { postRlmGuide } from "./ui/intro.ts";
-import { setRlmModeStatus } from "./ui/status.ts";
+import { setRlmModeStatus, type RootSigmaTelemetry } from "./ui/status.ts";
 import { RunRegistry } from "./ui/panel/run-registry.ts";
 import { installTreePanel } from "./ui/panel/tree-panel.ts";
 import { markdownTheme } from "./ui/theme-adapter.ts";
@@ -113,11 +113,20 @@ export default function rlmExtension(pi: ExtensionAPI): void {
   /** Root Σ (WS-3/4): the native session's digest-level Σ_t — runtime-derived (tool outcomes,
    *  engine mirrors, prompts); lazily born on the first prompt, harvested + dropped at shutdown. */
   let rootTracker: RootStateTracker | undefined;
-  // Root Σ WS-5.1 telemetry — journal counters (trace lines only; no TUI surface by design).
+  // Root Σ WS-5.1 telemetry — journal counters (trace lines + status widget when tracing).
   let xiCompositions = 0;
   let rootDigests = 0;
   let elidedMessages = 0;
   let sigmaSplices = 0;
+  let idleDegrades = 0;
+  /** R6: Σ counter snapshot for the status line — a fresh readonly object per render. */
+  const sigmaTelemetry = (): RootSigmaTelemetry => ({
+    xiCompositions,
+    rootDigests,
+    elidedMessages,
+    sigmaSplices,
+    idleDegrades,
+  });
   // A detached child works in its OWN sandbox, so this one sees no frames and its request
   // watchdog would fire mid-await and SIGKILL a healthy worker, taking the REPL namespace
   // with it. Keep it alive while detached work is genuinely in flight.
@@ -162,7 +171,8 @@ export default function rlmExtension(pi: ExtensionAPI): void {
   /** Ξ (Workstream C): BM25 slice of the SkillState store for a query; undefined when off. */
   const composeSkillBlock = (query: string): string | undefined => {
     const cfg = controller.config;
-    if (!cfg.enableSkillState || skillStore === undefined) return undefined;
+    // R0: enableSkillState is enforced (validateEnforcedOn) — no config check remains.
+    if (skillStore === undefined) return undefined;
     const block = skillStore.blockFor(query, cfg.skillStateMaxTokens);
     return block === "" ? undefined : block;
   };
@@ -204,10 +214,10 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     controller.savedLlmRef = persisted.llm ?? undefined;
     controller.savedRlmRef = persisted.rlm ?? undefined;
 
-    // SKILL.state (Workstream B): hydrate the cross-session note store (fail-soft).
-    skillStore = controller.config.enableSkillState
-      ? await SkillStore.hydrate(controller.config.skillStateNotesPerProject)
-      : undefined;
+    // SKILL.state (Workstream B / R0): hydrate the cross-session note store UNCONDITIONALLY —
+    // the SkillStore is operating law; no rlm.json, command, or UI path can prevent its birth
+    // (hostile configs are traced + ignored at the validateEnforcedOn seam; fail-soft).
+    skillStore = await SkillStore.hydrate(controller.config.skillStateNotesPerProject);
     controller.skillStore = skillStore;
 
     // An explicit --rlm flag wins over the persisted setting for this session.
@@ -336,7 +346,7 @@ export default function rlmExtension(pi: ExtensionAPI): void {
       }
     }
 
-    setRlmModeStatus(ctx, controller, ctx.getContextUsage());
+    setRlmModeStatus(ctx, controller, ctx.getContextUsage(), sigmaTelemetry());
     if (!treePanelInstalled) {
       treePanelInstalled = true;
       installTreePanel(ctx, runRegistry);
@@ -349,7 +359,7 @@ export default function rlmExtension(pi: ExtensionAPI): void {
 
   // ── Keep the footer's context reading live (RLM exists to shrink this number) ──
   pi.on("turn_end", async (_event, ctx) => {
-    setRlmModeStatus(ctx, controller, ctx.getContextUsage());
+    setRlmModeStatus(ctx, controller, ctx.getContextUsage(), sigmaTelemetry());
   });
 
   /** True when the native-mode trade holds: enabled AND repl is in the active tool set. */
@@ -387,21 +397,56 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     const message = observation === undefined
       ? undefined
       : { customType: "rlm-sigma-observation", content: observation, display: false, details: undefined };
+    // R1 + R3 soak instrumentation: what the plugin RETURNS as the system prompt — the host
+    // applies result.systemPrompt verbatim (agent-session.js), so this line + the journal
+    // decide "wiring bug vs model non-compliance" for the fence contract.
+    const nativePrompt = buildNativeSystemPrompt({ stateFences: controller.config.enableRootStateFences });
+    if (traceEnabled) {
+      trace("root-prompt.composed", {
+        chars: nativePrompt.length,
+        fences: controller.config.enableRootStateFences,
+        contract: nativePrompt.includes("[state] Alongside"),
+        xi: xi !== undefined,
+      });
+    }
     return {
       ...(message === undefined ? {} : { message }),
-      systemPrompt: event.systemPrompt + "\n\n" + xiPart + buildNativeSystemPrompt(),
+      systemPrompt: event.systemPrompt + "\n\n" + xiPart + nativePrompt,
     };
   });
 
-  // Root Σ WS-4.2 (default OFF): capture model-proposed ΔΣ_t fences from finalized assistant
-  // replies and run them through the ONE patch validator (run-state.ts applyPatch).
+  // Root Σ WS-4.2 + v2 R4: capture model-proposed ΔΣ_t fences from finalized assistant
+  // replies and run them through the ONE patch validator (run-state.ts applyPatch). EVERY
+  // assistant turn feeds the ladder — a fence-free turn grows the idle streak, and
+  // RUN_STATE_IDLE_DEGRADE_TURNS consecutive idle turns degrade the tracker (G6 parity).
   pi.on("message_end", async (event) => {
     const tracker = rootTracker;
     if (tracker === undefined || !controller.config.enableRootStateFences) return;
     if (event.message.role !== "assistant") return;
-    const text = agentMessageText(event.message);
-    if (text === "") return;
-    tracker.applyFences(findStatePatches(text));
+    const wasActive = tracker.isActive;
+    const outcome = tracker.applyFences(findStatePatches(agentMessageText(event.message)));
+    // R3 soak observability: per-turn fence outcomes — the soak-B bars (≥50% of turns commit
+    // ≥1 accepted delta, rejection storms <10%) are computed from these journal lines.
+    if (traceEnabled) {
+      trace("root-state.turn", {
+        ...outcome,
+        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) {
+      idleDegrades += 1;
+      if (traceEnabled) {
+        const reason = tracker.degradeReason ?? "unknown";
+        trace(reason.startsWith("idle") ? "root-state.idle-degrade" : "root-state.degrade", {
+          idleTurns: tracker.idleTurns,
+          reason,
+        });
+      }
+    }
   });
 
   // ── Root Σ WS-2: deterministic root compaction (no summary LLM call) ──
@@ -460,8 +505,22 @@ export default function rlmExtension(pi: ExtensionAPI): void {
         });
         elidedMessages += elided;
         const tracker = rootTracker;
-        if (controller.config.rootContextSnapshot && tracker !== undefined && !tracker.isEmpty) {
-          spliceSigmaSnapshot(filtered, tracker.snapshot(), tracker.rectifyHint());
+        // 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.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;
         }
         if (traceEnabled && (elided > 0 || sigmaSplices > 0)) {
@@ -554,8 +613,9 @@ export default function rlmExtension(pi: ExtensionAPI): void {
   pi.on("session_shutdown", async () => {
     // Root Σ WS-4 harvest symmetry: the root tracker teaches the store exactly like engine
     // runs — the ONE notesFromRunState path — then the existing flush persists everything.
+    // R0: enableSkillState is enforced; no config check remains on this path.
     const tracker = rootTracker;
-    if (skillStore !== undefined && tracker !== undefined && tracker.dirty && controller.config.enableSkillState) {
+    if (skillStore !== undefined && tracker !== undefined && tracker.dirty) {
       try {
         skillStore.merge(notesFromRunState(tracker.snapshot()));
         if (traceEnabled) trace("root-harvest.merged", { notes: tracker.snapshot().verifiedFacts.length });

package/src/prompts/glossary.ts

@@ -62,6 +62,11 @@ const SKILL_SEARCH_GLOSSARY_LINES: readonly string[] = Object.freeze([
 export const SKILL_RECALL_LINE =
   "Recall more anytime inside repl: `skill_search(query, k=8)` → [{id, text, tags, score}].";
 
+/** R5 (G4, /tmp/ROOT_FULL_SKILLSTATE_PLAN.md): the one-line replacement for assistant prose
+ *  older than the keep window — durable facts live in Σ, the full text in the session log. */
+export const ROOT_TURN_ELIDED_LINE =
+  "… turn elided — durable facts live in Σ; full text in session log";
+
 export function skillStateLines(noteCount: number, body: string): string {
   return [
     `[Project facts — SkillState, ${noteCount} note${noteCount === 1 ? "" : "s"}, distilled from prior sessions]`,

package/src/prompts/native.ts

@@ -12,6 +12,7 @@ import {
   DEFAULT_PROMPT_CAP,
   promptCapTokensK,
 } from "./glossary.ts";
+import { STATE_FENCE_INSTRUCTION } from "../core/run-state.ts";
 
 /** Adapts the REPL glossary for native mode — agent calls `repl({code})` instead of writing ```repl``` blocks. */
 function nativeReplGlossary(): string {
@@ -67,8 +68,15 @@ function nativeReplGlossary(): string {
   ].join("\n");
 }
 
-/** Build the native-mode system prompt for the main Pi agent. */
-export function buildNativeSystemPrompt(): string {
+/** Build the native-mode system prompt for the main Pi agent.
+ *
+ *  R1 (G1, /tmp/ROOT_FULL_SKILLSTATE_PLAN.md): `stateFences` appends the ONE Σ fence contract
+ *  (STATE_FENCE_INSTRUCTION verbatim — one wording source, engine and native share it) so the
+ *  native model can author ΔΣ_t through ```state fences. The fence text is STATIC, so it may
+ *  ride call-time composition; the FLAG decision happens at the call site — NATIVE_PROMPT_STATIC
+ *  (the frozen module-load snapshot) is composed with no options and stays contract-free.
+ */
+export function buildNativeSystemPrompt(opts?: { readonly stateFences?: boolean }): string {
   return [
     "╔══════════════════════════════════════════════════════════════════╗",
     "║  NATIVE RLM MODE — YOU ARE AN ORCHESTRATOR, NOT A READER      ║",
@@ -162,6 +170,22 @@ export function buildNativeSystemPrompt(): string {
     "</rules>",
     "",
     nativeReplGlossary(),
+    ...(opts?.stateFences === true
+      ? [
+          "",
+          STATE_FENCE_INSTRUCTION,
+          // Soak-B finding (R3): models ignore the contract when it only speaks headless
+          // \u201c```repl block(s)\u201d \u2014 in native mode those are repl({code}) TOOL calls. The engine
+          // wording above stays byte-identical (one source); this line maps it 1:1 onto the
+          // native tool-call loop so the fence obligation is unambiguous.
+          "NATIVE MODE: you emit repl({code}) as TOOL calls, not ```repl text blocks \u2014 the " +
+            "contract above maps 1:1 onto this loop. In ANY reply where you learned something " +
+            "durable (a path, a fact, a failed approach, the next step), ALSO emit a ```state " +
+            'fenced block in that same reply: {"state_patch": {"verifiedFacts[+]": ' +
+            '"src/x.ts \u2014 what you just verified"}}. Deltas only; one small patch per turn; ' +
+            "never restate unchanged keys.",
+        ]
+      : []),
   ].join("\n");
 }
 

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."),
@@ -68,6 +68,18 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
       "Allow add_context() to pull an external dir, file, document, or git repo into context."),
     item("autoSeedCwd", "Auto-seed cwd", config.autoSeedCwd ? "on" : "off", CHOICES.autoSeedCwd,
       "Seed the working directory into context on the first repl() call (otherwise starts empty)."),
+    // R0 (/tmp/ROOT_FULL_SKILLSTATE_PLAN.md): the SKILL.state / Root Σ paradigm flags are
+    // ENFORCED — rendered as a read-only badge so the truth is visible instead of hidden.
+    // No toggle exists: applySetting has no case for them and the validator forces true.
+    item("__sigma_enforced__", "SKILL.state / Root Σ", "enforced", ["enforced"],
+      "ENFORCED (no opt-out): run state, skill state + distill, root context transform, state fences, digest compaction. " +
+        "Override attempts in rlm.json are traced (skillstate.override-ignored) and ignored; RLM_BENCH_NO_ROOTCONTEXT=1 is the dev-only measurement hatch."),
+    // R5: the window calibrations are rlm.json-only knobs — shown read-only with live values.
+    item("__sigma_window__", "Root Σ window (calibration)",
+      `keepTurns=${config.rootContextKeepTurns} · elide=${config.rootContextElideChars} · snapshot=${config.rootContextSnapshot ? "on" : "off"}`,
+      ["rlm.json"],
+      "Query-time window calibrations, rlm.json only: rootContextKeepTurns (1 = strict: Σ + current turn; 2 = default), rootContextElideChars, rootContextSnapshot. " +
+        "Session resume/fork: the tracker is reborn lazily and Σ re-grows from live observations — the first call after a resume has an empty Σ by design."),
     item("__save__", "Save & close", "↵", ["↵"], "Save these settings and close (Esc also saves)."),
   ];
 

package/src/ui/status.ts

@@ -3,23 +3,47 @@
  * The footer's extension-status row is sanitized to a single line, so the
  * two-model layout lives in a dedicated multi-line widget instead: one line
  * for the mode, one per model lane (llm = leaf sub-calls, rlm = child engines),
- * each with the live context token spend.
+ * each with the live context token spend — and, when trace mode is on, a Root Σ
+ * telemetry line (R6): Ξ compositions, digest compactions, elisions, Σ splices,
+ * idle degrades.
  */
 
 import type { ContextUsage, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { RlmController } from "../mode/rlm-mode.ts";
+import { traceEnabled } from "../util/trace.ts";
 import { formatTokens } from "./theme.ts";
 
 const KEY = "rlm";
 
+/** R6: Root Σ closure-counter snapshot (fresh readonly object per render). */
+export interface RootSigmaTelemetry {
+  readonly xiCompositions: number;
+  readonly rootDigests: number;
+  readonly elidedMessages: number;
+  readonly sigmaSplices: number;
+  readonly idleDegrades: number;
+}
+
 export function modelLabel(model: Model<Api> | undefined, fallback: string): string {
   return model ? `${model.provider}/${model.id}` : fallback;
 }
 
+/** R6: the Σ telemetry line — built only when tracing and at least one counter is live. */
+function sigmaLine(telemetry: RootSigmaTelemetry): string | undefined {
+  const parts: string[] = [];
+  if (telemetry.xiCompositions > 0) parts.push(`Ξ${telemetry.xiCompositions}`);
+  if (telemetry.elidedMessages > 0) parts.push(`elided ${telemetry.elidedMessages}`);
+  if (telemetry.sigmaSplices > 0) parts.push(`Σ${telemetry.sigmaSplices}`);
+  if (telemetry.rootDigests > 0) parts.push(`digest ${telemetry.rootDigests}`);
+  if (telemetry.idleDegrades > 0) parts.push(`degraded ${telemetry.idleDegrades}`);
+  return parts.length === 0 ? undefined : ` Σ ${parts.join(" · ")}`;
+}
+
 export function formatRlmStatusLines(
   controller: RlmController,
   contextUsage?: ContextUsage,
+  telemetry?: RootSigmaTelemetry,
 ): readonly string[] {
   if (!controller.enabled) return ["○ RLM OFF"];
   const tokens = contextUsage?.tokens;
@@ -28,14 +52,25 @@ export function formatRlmStatusLines(
   const llmSuffix = controller.config.subSampling.reasoning ? `:${controller.config.subSampling.reasoning}` : "";
   const rlm = modelLabel(controller.rlmModel, controller.savedRlmRef ?? "session");
   const rlmSuffix = controller.config.rootSampling?.reasoning ? `:${controller.config.rootSampling.reasoning}` : "";
-  return [
+  const lines = [
     "● RLM ON",
     ` llm=${llm}${llmSuffix}${tokSuffix}`,
     ` rlm=${rlm}${rlmSuffix}${tokSuffix}`,
   ];
+  // R6: counters surface only under trace mode — the default UI stays clean.
+  if (traceEnabled && telemetry !== undefined) {
+    const sigma = sigmaLine(telemetry);
+    if (sigma !== undefined) lines.push(sigma);
+  }
+  return lines;
 }
 
 /** Set the above-editor status widget. Idempotent — call on every state change. */
-export function setRlmModeStatus(ctx: ExtensionContext, controller: RlmController, contextUsage?: ContextUsage): void {
-  ctx.ui.setWidget(KEY, [...formatRlmStatusLines(controller, contextUsage)], { placement: "aboveEditor" });
+export function setRlmModeStatus(
+  ctx: ExtensionContext,
+  controller: RlmController,
+  contextUsage?: ContextUsage,
+  telemetry?: RootSigmaTelemetry,
+): void {
+  ctx.ui.setWidget(KEY, [...formatRlmStatusLines(controller, contextUsage, telemetry)], { placement: "aboveEditor" });
 }

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}`;