@hicaru/pi-rlm 0.3.16 → 0.3.17

package/src/bridge/handlers/llm-query.ts

@@ -4,29 +4,20 @@
 
 import type { Usage } from "@earendil-works/pi-ai";
 import { modelRef } from "../../config/settings.ts";
-import { complete1, type Complete1Deps } from "./completion.ts";
-import { emitting, summarizeLeaf, throttleHooks } from "./emitting.ts";
+import { complete1, completeDeps } from "./completion.ts";
+import { emitting, summarizeLeaf, throttleHooks, type EmitNote } from "./emitting.ts";
 import { formatError, errorMessage } from "../../util/errors.ts";
 import { previewText } from "../../text/preview.ts";
-import type { SpawnResult, SubcallHandlerDeps } from "./types.ts";
+import type { Invocation, SpawnResult, SubcallHandlerDeps } from "./types.ts";
 import type { SubcallOpts } from "../../sandbox/interrupts.ts";
 import { SPAWN_HINT, spawnAndRun, type SpawnDeps } from "./task-registry.ts";
 import { ECHO_STUB, taskKey, type TaskLedger } from "../../core/ledger.ts";
 
-const UNWIRED = formatError("RLM bridge not wired for this invocation");
+/** Shared with rlm-query.ts — the unwired rejection sentinel (AGENTS DRY). */
+export const UNWIRED = formatError("RLM bridge not wired for this invocation");
 
-function completeDeps(deps: SubcallHandlerDeps): Complete1Deps {
-  return {
-    leafGate: deps.gates.leaf,
-    registry: deps.registry,
-    getLlmModel: deps.getLlmModel,
-    getConfig: deps.getConfig,
-    signal: deps.signal,
-    onUsage: deps.onUsage,
-  };
-}
-
-function displayModel(deps: SubcallHandlerDeps): string | undefined {
+/** Shared with rlm-query.ts — one display-model resolution (AGENTS DRY #3). */
+export function displayModel(deps: SubcallHandlerDeps): string | undefined {
   try {
     const m = deps.getLlmModel();
     return modelRef(m) ?? m.id;
@@ -36,10 +27,36 @@ function displayModel(deps: SubcallHandlerDeps): string | undefined {
 }
 
 /** The ledger active for leaf calls — undefined when disabled by config or not threaded in. */
-function activeLedger(deps: SubcallHandlerDeps): TaskLedger | undefined {
+export function activeLedger(deps: SubcallHandlerDeps): TaskLedger | undefined {
   return deps.getConfig().enableLedger ? deps.ledger : undefined;
 }
 
+/** DRY: one unwired-spawn shape — kind/n vary, everything else is the same rejection.
+ *  Shared with rlm-query.ts. */
+export function unwiredSpawn(kind: SpawnResult["kind"], n: number): SpawnResult {
+  return { ok: false, task_id: null, kind, n, status: "pending", hint: SPAWN_HINT, error: UNWIRED };
+}
+
+/** DRY: the shared leaf recipe — one UI node, one complete1 execution, one summarizer. */
+function emitLeaf(
+  inv: Invocation,
+  deps: SubcallHandlerDeps,
+  prompt: string,
+  exec: (track: (u: Usage) => void, note: EmitNote) => Promise<string>,
+): Promise<string> {
+  return emitting(
+    inv,
+    {
+      kind: "llm",
+      label: "llm_query",
+      args: `prompt: ${previewText(prompt)}`,
+      model: displayModel(deps),
+    },
+    (track, note) => exec(track, note),
+    summarizeLeaf,
+  );
+}
+
 /** v5 TaskLedger routing for ONE leaf prompt (audit H3 — shared by llm_query and every
  *  llm_batch item, which v5 routed through `_spawn_single` too): echo → stub string,
  *  coalesce → the twin's result (bounded wait), run → caller executes then finish/fail.
@@ -84,31 +101,12 @@ export function createLlmQueryHandler(
     opts: SubcallOpts,
   ): Promise<SpawnResult> => {
     const inv = deps.resolve(opts, depth);
-    if (inv === null) {
-      return {
-        ok: false,
-        task_id: null,
-        kind: "llm",
-        n: 1,
-        status: "pending",
-        hint: SPAWN_HINT,
-        error: UNWIRED,
-      };
-    }
+    if (inv === null) return unwiredSpawn("llm", 1);
 
     const cdeps = completeDeps(deps);
     const runLeaf = (): Promise<string> =>
-      emitting(
-        inv,
-        {
-          kind: "llm",
-          label: "llm_query",
-          args: `prompt: ${previewText(prompt)}`,
-          model: displayModel(deps),
-        },
-        (track: (u: Usage) => void, note) => complete1(inv, prompt, track, cdeps, throttleHooks(note)),
-        summarizeLeaf,
-      );
+      emitLeaf(inv, deps, prompt, (track, note) =>
+        complete1(inv, prompt, track, cdeps, throttleHooks(note)));
     // v5 TaskLedger for leaves: identical prompts coalesce onto one completion (key has no
     // context — a leaf's entire world is the prompt text itself).
     return spawnAndRun(
@@ -132,17 +130,7 @@ export function createLlmBatchHandler(
     opts: SubcallOpts,
   ): Promise<SpawnResult> => {
     const inv = deps.resolve(opts, depth);
-    if (inv === null) {
-      return {
-        ok: false,
-        task_id: null,
-        kind: "llm_batch",
-        n: prompts.length,
-        status: "pending",
-        hint: SPAWN_HINT,
-        error: UNWIRED,
-      };
-    }
+    if (inv === null) return unwiredSpawn("llm_batch", prompts.length);
 
     const cdeps = completeDeps(deps);
     const ledger = activeLedger(deps);
@@ -155,27 +143,17 @@ export function createLlmBatchHandler(
       () =>
         Promise.all(
           prompts.map((p) =>
-            emitting(
-              inv,
-              {
-                kind: "llm",
-                label: "llm_query",
-                args: `prompt: ${previewText(p)}`,
-                model: displayModel(deps),
-              },
+            emitLeaf(inv, deps, p, (track, note) =>
               // NO outer gate — complete1 takes the single leaf slot per prompt.
               // v5 (audit H3): every item routes through the ledger — duplicate prompts inside
               // one batch (or twins of other in-flight leaves) coalesce instead of paying N times.
-              (track: (u: Usage) => void, note) =>
-                runClaimedLeaf(
-                  ledger,
-                  ledger === undefined ? undefined : leafClaimKey(deps, p),
-                  p,
-                  inv.depth,
-                  () => complete1(inv, p, track, cdeps, throttleHooks(note)),
-                ),
-              summarizeLeaf,
-            ),
+              runClaimedLeaf(
+                ledger,
+                ledger === undefined ? undefined : leafClaimKey(deps, p),
+                p,
+                inv.depth,
+                () => complete1(inv, p, track, cdeps, throttleHooks(note)),
+              )),
           ),
         ),
       deps.trackDetached,

package/src/bridge/handlers/rlm-query.ts

@@ -4,7 +4,7 @@
  * AGENTS.md DRY #2: childRun exists once, here.
  */
 
-import { modelRef } from "../../config/settings.ts";
+import { modelLabelOf } from "../../config/settings.ts";
 import { errorMessage, formatError } from "../../util/errors.ts";
 import { filterContextByPaths } from "../../context/merge.ts";
 import { previewText } from "../../text/preview.ts";
@@ -13,12 +13,11 @@ import { checkResourceLimits } from "../../core/resource-limits.ts";
 import { contextSig, ECHO_STUB, taskKey } from "../../core/ledger.ts";
 import type { Invocation, SpawnResult, SubcallHandlerDeps } from "./types.ts";
 import type { SubcallOpts } from "../../sandbox/interrupts.ts";
-import { SPAWN_HINT, spawnAndRun, type SpawnDeps } from "./task-registry.ts";
-import { complete1, type Complete1Deps } from "./completion.ts";
+import { spawnAndRun, type SpawnDeps } from "./task-registry.ts";
+import { complete1, completeDeps } from "./completion.ts";
 import { emitting, summarizeLeaf, throttleHooks } from "./emitting.ts";
-import { leafClaimKey, runClaimedLeaf } from "./llm-query.ts";
+import { activeLedger, leafClaimKey, runClaimedLeaf, unwiredSpawn } from "./llm-query.ts";
 
-const UNWIRED = formatError("RLM bridge not wired for this invocation");
 const NO_UNMATCHED: readonly string[] = Object.freeze([]);
 
 function emptyResult(answer: string): RlmResult {
@@ -56,25 +55,9 @@ function childContextFor(
   });
 }
 
-function completeDeps(deps: SubcallHandlerDeps): Complete1Deps {
-  return {
-    leafGate: deps.gates.leaf,
-    registry: deps.registry,
-    getLlmModel: deps.getLlmModel,
-    getConfig: deps.getConfig,
-    signal: deps.signal,
-    onUsage: deps.onUsage,
-  };
-}
-
-/** Ledger active for this call — undefined when disabled by config or not threaded in. */
-function activeLedger(deps: SubcallHandlerDeps) {
-  return deps.getConfig().enableLedger ? deps.ledger : undefined;
-}
-
 function claimKeyFor(deps: SubcallHandlerDeps, kind: "llm" | "rlm", prompt: string, paths: readonly string[], ctx: string): string {
   const rootModel = deps.getModel?.();
-  const modelId = rootModel === undefined ? "" : (modelRef(rootModel) ?? rootModel.id);
+  const modelId = rootModel === undefined ? "" : modelLabelOf(rootModel);
   return taskKey(kind, prompt, paths, modelId, ctx);
 }
 
@@ -111,31 +94,8 @@ async function childRun(
       ? prompt
       : `${prompt}\n\n[rlm] paths=${child.unmatched.join(", ")} matched no files; you received the full context.`;
 
-  // ── v5 memory replay: an identical, still-fresh child answer replays for zero API calls ──
-  const memory = deps.memory;
   const sig = contextSig(child.context);
   const key = claimKeyFor(deps, "rlm", prompt, paths ?? [], sig);
-  if (memory !== undefined && deps.getConfig().enableMemory !== false) {
-    const hit = memory.replay(key);
-    if (hit !== undefined) {
-      const replayId = inv.emitter.emitSubcallCreated({
-        kind: "rlm",
-        parentId: inv.parentId,
-        label: "rlm_query (replay)",
-        detail: prompt.slice(0, 60),
-        depth: childDepth,
-      });
-      inv.emitter.emitSubcallUpdated({ id: replayId, status: "done", resultPreview: hit.result.slice(0, 200) });
-      return {
-        answer: hit.result,
-        iterations: 0,
-        costUsd: 0,
-        inputTokens: 0,
-        outputTokens: 0,
-        durationMs: 0,
-      };
-    }
-  }
 
   // ── v5 TaskLedger: echo → stub; duplicate → coalesce onto the existing runner ──────
   const ledger = activeLedger(deps);
@@ -148,8 +108,7 @@ async function childRun(
   // ONE subcall node per childRun (audit C2 / DRY #5): the decision branch reuses it, the
   // run branch reports the engine's turns/cost on it. Never a second emit below.
   const rootModel = deps.getModel?.();
-  const modelLabel =
-    rootModel === undefined ? undefined : (modelRef(rootModel) ?? rootModel.id);
+  const modelLabel = rootModel === undefined ? undefined : modelLabelOf(rootModel);
   const subId = inv.emitter.emitSubcallCreated({
     kind: "rlm",
     parentId: inv.parentId,
@@ -168,13 +127,14 @@ async function childRun(
     const twin = await ledger
       .waitFor(decision.key)
       .catch((err: unknown) => errorMessage(err));
-    inv.emitter.emitSubcallUpdated({ id: subId, status: "done", resultPreview: previewText(String(twin).slice(0, 80)) });
-    return emptyResult(String(twin));
+    inv.emitter.emitSubcallUpdated({ id: subId, status: "done", resultPreview: previewText(twin.slice(0, 80)) });
+    return emptyResult(twin);
   }
   if (ledger !== undefined && claimKey !== undefined) {
     ledger.markRunning(claimKey);
   }
 
+  const skillBlock = deps.getSkillBlock?.(prompt);
   const input: RlmInput = {
     rootPrompt,
     context: child.context,
@@ -182,6 +142,9 @@ async function childRun(
     parentNodeId: subId,
     remainingTimeoutMs: remTimeout,
     ledger, // DRY #6: the one seam — children share the parent's blackboard
+    // SKILL.state Ξ (Workstream C, DRY #6): the parent's block rides along — the only
+    // child-RlmInput construction site, so inheritance cannot grow a second path.
+    ...(skillBlock === undefined ? {} : { skillBlock }),
   };
 
   try {
@@ -189,19 +152,6 @@ async function childRun(
     inv.limits.addRaw(res.costUsd, res.inputTokens, res.outputTokens);
     deps.onChildUsage?.(res.costUsd, res.inputTokens, res.outputTokens);
     if (ledger !== undefined && claimKey !== undefined) ledger.finish(claimKey, res.answer);
-    // v5: child answers persist unconditionally — this is what later identical runs replay.
-    if (memory !== undefined && deps.getConfig().enableMemory !== false) {
-      memory.recordEpisode({
-        key,
-        kind: "rlm",
-        model: modelLabel ?? "",
-        prompt,
-        paths: paths ?? [],
-        result: res.answer,
-        tokensIn: res.inputTokens,
-        tokensOut: res.outputTokens,
-      });
-    }
     inv.emitter.emitSubcallUpdated({
       id: subId,
       status: "done",
@@ -225,17 +175,7 @@ export function createRlmQueryHandler(deps: SubcallHandlerDeps, sd: SpawnDeps) {
     opts: SubcallOpts,
   ): Promise<SpawnResult> => {
     const inv = deps.resolve(opts, depth);
-    if (inv === null) {
-      return {
-        ok: false,
-        task_id: null,
-        kind: "rlm",
-        n: 1,
-        status: "pending",
-        hint: SPAWN_HINT,
-        error: UNWIRED,
-      };
-    }
+    if (inv === null) return unwiredSpawn("rlm", 1);
 
     const pathArg = opts.paths;
 
@@ -297,17 +237,7 @@ export function createRlmBatchHandler(deps: SubcallHandlerDeps, sd: SpawnDeps) {
     opts: SubcallOpts,
   ): Promise<SpawnResult> => {
     const inv = deps.resolve(opts, depth);
-    if (inv === null) {
-      return {
-        ok: false,
-        task_id: null,
-        kind: "rlm_batch",
-        n: tasks.length,
-        status: "pending",
-        hint: SPAWN_HINT,
-        error: UNWIRED,
-      };
-    }
+    if (inv === null) return unwiredSpawn("rlm_batch", tasks.length);
 
     const pathArg = opts.paths;
     // No wrapper "rlm_batch ×N" node: every task already gets its own rlm_query node from

package/src/bridge/handlers/task-registry.ts

@@ -7,6 +7,7 @@
  */
 
 import type { AwaitResult, SpawnResult, TaskEntry } from "./types.ts";
+import { formatError, isErrorText } from "../../util/errors.ts";
 
 export const SPAWN_HINT =
   "Call await_task(task_id=...) to get the result — this is NOT the answer.";
@@ -24,6 +25,22 @@ export interface AwaitDeps {
   unawaitedIds(): readonly string[];
 }
 
+/** DRY: the ONE TaskEntry → AwaitResult mapping — shared by the await handler and the registry. */
+export function entryToAwaitResult(entry: TaskEntry): AwaitResult {
+  const status = entry.status === "pending" ? "error" : entry.status;
+  return {
+    ok: entry.status === "done",
+    task_id: entry.taskId,
+    kind: entry.kind,
+    status,
+    result: entry.result,
+    results: entry.results,
+    error:
+      entry.error ??
+      (entry.status === "pending" ? "Task still pending" : undefined),
+  };
+}
+
 export interface TaskRegistry {
   readonly spawnDeps: SpawnDeps;
   readonly awaitDeps: AwaitDeps;
@@ -32,8 +49,8 @@ export interface TaskRegistry {
 }
 
 interface Waiter {
-  resolve: (entry: TaskEntry) => void;
-  reject: (err: Error) => void;
+  readonly resolve: (entry: TaskEntry) => void;
+  readonly reject: (err: Error) => void;
   timer?: ReturnType<typeof setTimeout>;
 }
 
@@ -146,19 +163,7 @@ export function createTaskRegistry(): TaskRegistry {
           error: `Task ${taskId} not found`,
         };
       }
-      const status =
-        entry.status === "pending" ? "error" : entry.status;
-      return {
-        ok: entry.status === "done",
-        task_id: entry.taskId,
-        kind: entry.kind,
-        status,
-        result: entry.result,
-        results: entry.results,
-        error:
-          entry.error ??
-          (entry.status === "pending" ? "Task still pending" : undefined),
-      };
+      return entryToAwaitResult(entry);
     },
   };
 }
@@ -185,14 +190,14 @@ export function spawnAndRun(
       sd.resolve(taskId, result);
     } catch (err: unknown) {
       const message = err instanceof Error ? err.message : String(err);
-      sd.reject(taskId, message.startsWith("Error:") ? message : `Error: ${message}`);
+      sd.reject(taskId, isErrorText(message) ? message : formatError(message));
     }
   };
 
   if (trackDetached !== undefined && detached) {
     void trackDetached(run).catch((err: unknown) => {
       const message = err instanceof Error ? err.message : String(err);
-      sd.reject(taskId, message.startsWith("Error:") ? message : `Error: ${message}`);
+      sd.reject(taskId, isErrorText(message) ? message : formatError(message));
     });
   } else {
     void run();

package/src/bridge/handlers/types.ts

@@ -13,7 +13,6 @@ import type { SubcallGates } from "../../util/concurrency.ts";
 import type { SubcallOpts } from "../../sandbox/interrupts.ts";
 import type { RlmEmitter } from "../../tool/rlm-events.ts";
 import type { TaskLedger } from "../../core/ledger.ts";
-import type { MemoryStore } from "../../core/memory.ts";
 
 // ---------------------------------------------------------------------------
 // Spawn / Await / Finish — the three shapes the model sees
@@ -73,7 +72,7 @@ export function limitsFromRemaining(
 
 export interface Invocation {
   readonly emitter: RlmEmitter;
-  readonly parentId: string | undefined;
+  readonly parentId?: string;
   readonly depth: number;
   readonly limits: InvocationLimits;
 }
@@ -91,8 +90,6 @@ export interface SubcallConfig {
   readonly enableLedger?: boolean;
   /** v5: real rlm spawns before demotion to llm (0 = never demote). */
   readonly rlmBudget?: number;
-  /** v5 durable memory gates (optional; omitted → memory off). */
-  readonly enableMemory?: boolean;
   /** v5.1 retry knobs — structural slice of RlmConfig so retryPolicy() can read them. */
   readonly retryMaxAttempts?: number;
   readonly rateLimitMaxAttempts?: number;
@@ -121,8 +118,13 @@ export interface SubcallHandlerDeps {
   readonly trackDetached?: <T>(run: () => Promise<T>) => Promise<T>;
   /** v5 TaskLedger blackboard shared across the whole run tree (claim/coalesce/echo/demote). */
   readonly ledger?: TaskLedger;
-  /** v5 durable memory (session-wide store) for child replay + episode persistence. */
-  readonly memory?: MemoryStore;
+  /** SKILL.state (Workstream D): ground a leaf prompt with verified facts. Applied ONCE in
+   *  complete1 (DRY #1) so every leaf path inherits it; returns the prompt unchanged when
+   *  nothing clears the score threshold — below it, byte-identical. */
+  readonly groundLeaf?: (prompt: string) => string;
+  /** SKILL.state (Workstream C): the parent run's Ξ block source, for childRun to copy
+   *  into the child RlmInput (DRY #6 — one construction site). */
+  readonly getSkillBlock?: (task: string) => string | undefined;
 }
 
 // ---------------------------------------------------------------------------

package/src/bridge/model.ts

@@ -14,7 +14,7 @@ import { type Api, completeSimple, type Message, type Model, type ThinkingLevel,
 import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
 import { completeWithRetry, DEFAULT_RETRY_POLICY, type RetryPolicy } from "../util/retry.ts";
 
-export type Role = "system" | "user" | "assistant";
+type Role = "system" | "user" | "assistant";
 export interface ChatMsg {
   readonly role: Role;
   readonly content: string;
@@ -55,17 +55,20 @@ function assistantMessage(text: string, model: Model<Api>): Message {
 }
 
 function toPiMessages(messages: readonly ChatMsg[], model: Model<Api>): { readonly systemPrompt?: string; readonly messages: Message[] } {
-  let systemPrompt: string | undefined;
+  // System segments joined once below — no quadratic re-copy of the accumulated prompt (rule:
+  // never build large text with `+`/template concat inside a loop).
+  const systemParts: string[] = [];
   const out: Message[] = [];
   for (const m of messages) {
     if (m.role === "system") {
-      systemPrompt = systemPrompt ? `${systemPrompt}\n\n${m.content}` : m.content;
+      systemParts.push(m.content);
     } else if (m.role === "user") {
       out.push({ role: "user", content: m.content, timestamp: Date.now() });
     } else {
       out.push(assistantMessage(m.content, model));
     }
   }
+  const systemPrompt = systemParts.length > 0 ? systemParts.join("\n\n") : undefined;
   return { systemPrompt, messages: out };
 }
 

package/src/commands/rlm-llm.ts

@@ -1,22 +1,13 @@
 /** `/rlm-llm` — pin the leaf-LLM model (llm_query / llm_batch / map_files). */
 
-import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { modelRef } from "../config/settings.ts";
-import { cheapestModel } from "../mode/llm-model.ts";
+import { cheapestModel, sessionScopedModels } from "../mode/llm-model.ts";
 import type { RlmController } from "../mode/rlm-mode.ts";
 import { pickableModels, selectModel } from "../ui/model-picker.ts";
 import { setRlmModeStatus } from "../ui/status.ts";
 import { applyLlmSelection } from "./pins.ts";
 
-/** Newer Pi hosts expose session-scoped models; 0.79 peers do not — duck-type safely. */
-function sessionScopedModels(
-  ctx: ExtensionContext,
-): readonly { readonly model: Model<Api> }[] | undefined {
-  const scoped: unknown = Reflect.get(ctx, "scopedModels");
-  return Array.isArray(scoped) ? scoped as readonly { readonly model: Model<Api> }[] : undefined;
-}
-
 async function runRlmLlm(controller: RlmController, ctx: ExtensionContext): Promise<void> {
   try {
     await ctx.modelRegistry.refresh();

package/src/commands/rlm-rlm.ts

@@ -4,21 +4,14 @@
  * the pre-pin behavior, now an explicit picker row.
  */
 
-import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { modelRef } from "../config/settings.ts";
+import { sessionScopedModels } from "../mode/llm-model.ts";
 import type { RlmController } from "../mode/rlm-mode.ts";
 import { pickableModels, selectModel } from "../ui/model-picker.ts";
 import { setRlmModeStatus } from "../ui/status.ts";
 import { applyRlmSelection } from "./pins.ts";
 
-function sessionScopedModels(
-  ctx: ExtensionContext,
-): readonly { readonly model: Model<Api> }[] | undefined {
-  const scoped: unknown = Reflect.get(ctx, "scopedModels");
-  return Array.isArray(scoped) ? scoped as readonly { readonly model: Model<Api> }[] : undefined;
-}
-
 async function runRlmRlm(controller: RlmController, ctx: ExtensionContext): Promise<void> {
   try {
     await ctx.modelRegistry.refresh();

package/src/config/defaults.ts

@@ -20,11 +20,12 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   // of the context it inherited, where a leaf is one HTTP request. Worst case is
   // (maxDepth - 1) × this many concurrent child engines. Default 4.
   maxConcurrentChildren: 4,
-  // v5.1 rate-limit resilience (util/retry.ts): 3 total attempts, 500ms→15s backoff,
-  // 2s→60s adaptive per-provider cooldown. All overridable in rlm.json.
-  retryMaxAttempts: 3,
-  // 429s park on the cooldown instead of dying — up to 8 windows (2s→4s→…≤60s ≈ 4 min).
-  rateLimitMaxAttempts: 8,
+  // v5.1 rate-limit resilience (util/retry.ts): 15 total attempts on the SAME model —
+  // 500ms→15s backoff, 2s→60s adaptive per-provider cooldown. DOCTRINE: NO fallback —
+  // when the attempts are exhausted the call fails loudly; model/provider never switch.
+  retryMaxAttempts: 15,
+  // 429s park on the cooldown instead of dying — up to 15 windows (2s→4s→…≤60s).
+  rateLimitMaxAttempts: 15,
   retryBaseDelayMs: 500,
   retryMaxDelayMs: 15_000,
   throttleBaseMs: 2_000,
@@ -51,14 +52,29 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   // v5 TaskLedger blackboard
   enableLedger: true,
   rlmBudget: 8,
-  // v5 durable memory
-  enableMemory: true,
-  injectNoteTokens: 2_000,
-  evolveEvery: 8,
-  memoryDir: null,
-  // v5 role separation: children delegate (llm + memory/ledger); "legacy" = full child surface.
-  childSurface: "delegation",
   // Verification-discipline nudge — deliberately OFF (plan guardrail): when on, an early
   // 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,
+  runStateRetryMax: 2,
+  enableSkillState: true,
+  // 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,
+  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,
+  rootDigestKeepRecentChars: 12_000,
+  rootDigestMaxChars: 8_000,
+  enableRootContextTransform: false,
+  rootContextKeepTurns: 2,
+  rootContextElideChars: 1_500,
+  rootContextSnapshot: true,
+  enableRootStateFences: false,
 });