@hicaru/pi-rlm 0.3.17 → 0.3.18

package/package.json

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

package/src/config/defaults.ts

@@ -56,25 +56,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/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,28 @@ 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 {
+    if (this.mode.kind !== "active") return { fences: fences.length, accepted: 0, problems: 0 };
+    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,16 +225,21 @@ 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) {
       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;
     this.pendingObservation = statePatchObservation(problems);
@@ -192,9 +249,22 @@ export class RootStateTracker {
     this.touch();
     if (retries > this.retryMax) {
       this.mode = { kind: "degraded", reason: `state-patch retry cap exceeded (${retries} rejected)` };
-    } else {
+    } 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 };
     }
+    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`,
+      };
+    }
   }
 
   /** Consume (and clear) the pending fence-rejection observation, if any. */

package/src/core/run-state.ts

@@ -560,18 +560,28 @@ export const STATE_FENCE_INSTRUCTION: string =
   `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.";
 
+/** 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/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,54 @@ 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,
+      });
+    }
+    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 +503,14 @@ 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: a DEGRADED tracker stops splicing Σ (isActive gate) — pure input tax otherwise.
+        if (
+          controller.config.rootContextSnapshot && tracker !== undefined &&
+          tracker.isActive && !tracker.isEmpty
+        ) {
+          spliceSigmaSnapshot(filtered, tracker.snapshot(), tracker.rectifyHint(), {
+            withContract: controller.config.enableRootStateFences,
+          });
           sigmaSplices += 1;
         }
         if (traceEnabled && (elided > 0 || sigmaSplices > 0)) {
@@ -554,8 +603,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/ui/config-panel.ts

@@ -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" });
 }