@hicaru/pi-rlm 0.3.6 → 0.3.9

package/README.md

@@ -18,8 +18,8 @@
 
 **The ONLY Recursive Language Model plugin for Pi.** No new agent to learn, no
 separate CLI, no YAML workflows — just `/rlm` and your existing Pi session becomes a
-recursive orchestration engine that saves **99% tokens** by delegating work to cheap
-worker models.
+recursive orchestration engine — your best model orchestrates, cheap worker models
+do the reading.
 
 > **One install. One toggle. Infinite context.**
 

package/package.json

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

package/src/bridge/handlers/emitting.ts

@@ -42,6 +42,8 @@ export async function emitting<T>(
     args: opts.args,
     depth: inv.depth,
   });
+  // Leaf nodes spend their whole lifetime waiting on the model — say so from birth.
+  inv.emitter.emitSubcallUpdated({ id, phase: "waiting" });
 
   let costUsd = 0;
   let tokens = 0;
@@ -78,27 +80,7 @@ export async function emitting<T>(
   }
 }
 
-/** Summarize a batch result for the emitter. */
-export function summarizeBatch(out: readonly string[]): EmitSummary {
-  let failed = 0;
-  let firstError: string | undefined;
-  for (const s of out) {
-    if (isErrorText(s)) {
-      failed += 1;
-      firstError ??= s;
-    }
-  }
-  const first = previewText(out[0] ?? "");
-  const error =
-    failed === 0
-      ? undefined
-      : failed === out.length
-        ? `all ${out.length} sub-calls failed — reduce batch size or try llm_query individually`
-        : `${failed}/${out.length} sub-calls failed`;
-  return {
-    preview: out.length > 1 ? `${first}  (+${out.length - 1} more)` : first,
-    error: error ?? firstError,
-    failed,
-    total: out.length,
-  };
+/** Summarize a single leaf answer for the emitter — shared by llm_query and every llm_batch item. */
+export function summarizeLeaf(out: string): EmitSummary {
+  return { preview: previewText(out), error: isErrorText(out) ? out : undefined };
 }

package/src/bridge/handlers/index.ts

@@ -43,6 +43,6 @@ export type {
 } from "./types.ts";
 
 export { limitsFromRemaining } from "./types.ts";
-export { summarizeBatch } from "./emitting.ts";
+export { summarizeLeaf } from "./emitting.ts";
 export { createTaskRegistry, SPAWN_HINT } from "./task-registry.ts";
 export type { TaskRegistry, SpawnDeps, AwaitDeps } from "./task-registry.ts";

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

@@ -5,12 +5,13 @@
 import type { Usage } from "@earendil-works/pi-ai";
 import { modelRef } from "../../config/settings.ts";
 import { complete1, type Complete1Deps } from "./completion.ts";
-import { emitting, summarizeBatch } from "./emitting.ts";
-import { formatError, isErrorText } from "../../util/errors.ts";
+import { emitting, summarizeLeaf } 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 { 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");
 
@@ -34,6 +35,45 @@ 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 {
+  return deps.getConfig().enableLedger ? deps.ledger : undefined;
+}
+
+/** 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.
+ *  Exported for tests. */
+export async function runClaimedLeaf(
+  ledger: TaskLedger | undefined,
+  key: string | undefined,
+  prompt: string,
+  depth: number,
+  exec: () => Promise<string>,
+): Promise<string> {
+  if (ledger === undefined || key === undefined) return exec();
+  const decision = ledger.tryClaim({ kind: "llm", prompt, paths: [], depth }, key);
+  if (decision.type === "echo") return ECHO_STUB;
+  if (decision.type === "coalesce") {
+    return ledger.waitFor(decision.key).catch((err: unknown): string => formatError(errorMessage(err)));
+  }
+  ledger.markRunning(key);
+  try {
+    const out = await exec();
+    ledger.finish(key, out);
+    return out;
+  } catch (err: unknown) {
+    ledger.fail(key, errorMessage(err));
+    throw err;
+  }
+}
+
+export function leafClaimKey(deps: SubcallHandlerDeps, prompt: string): string | undefined {
+  const ledger = activeLedger(deps);
+  if (ledger === undefined) return undefined;
+  return taskKey("llm", prompt, [], displayModel(deps) ?? "", "");
+}
+
 export function createLlmQueryHandler(
   deps: SubcallHandlerDeps,
   sd: SpawnDeps,
@@ -57,25 +97,25 @@ export function createLlmQueryHandler(
     }
 
     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) => complete1(inv, prompt, track, cdeps),
+        summarizeLeaf,
+      );
+    // 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(
       sd,
       "llm",
       1,
-      () =>
-        emitting(
-          inv,
-          {
-            kind: "llm",
-            label: "llm_query",
-            args: `prompt: ${previewText(prompt)}`,
-            model: displayModel(deps),
-          },
-          (track: (u: Usage) => void) => complete1(inv, prompt, track, cdeps),
-          (out) => ({
-            preview: previewText(out),
-            error: isErrorText(out) ? out : undefined,
-          }),
-        ),
+      () => runClaimedLeaf(activeLedger(deps), leafClaimKey(deps, prompt), prompt, inv.depth, runLeaf),
       deps.trackDetached,
       opts.detached,
     );
@@ -105,23 +145,38 @@ export function createLlmBatchHandler(
     }
 
     const cdeps = completeDeps(deps);
+    const ledger = activeLedger(deps);
     return spawnAndRun(
       sd,
       "llm_batch",
       prompts.length,
+      // One visible node per prompt — no collapsed "×N" row, no hidden failures: each item
+      // reports its own status/tokens/error (UI parity with pi: every concurrent call renders).
       () =>
-        emitting(
-          inv,
-          {
-            kind: "batch",
-            label: `llm_batch ×${prompts.length}`,
-            args: `prompt: ${previewText(prompts[0] ?? "")}`,
-            model: displayModel(deps),
-          },
-          // NO outer gate — complete1 takes the single leaf slot per prompt.
-          (track: (u: Usage) => void) =>
-            Promise.all(prompts.map((p) => complete1(inv, p, track, cdeps))),
-          summarizeBatch,
+        Promise.all(
+          prompts.map((p) =>
+            emitting(
+              inv,
+              {
+                kind: "llm",
+                label: "llm_query",
+                args: `prompt: ${previewText(p)}`,
+                model: displayModel(deps),
+              },
+              // 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) =>
+                runClaimedLeaf(
+                  ledger,
+                  ledger === undefined ? undefined : leafClaimKey(deps, p),
+                  p,
+                  inv.depth,
+                  () => complete1(inv, p, track, cdeps),
+                ),
+              summarizeLeaf,
+            ),
+          ),
         ),
       deps.trackDetached,
       opts.detached,

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

@@ -10,10 +10,13 @@ import { filterContextByPaths } from "../../context/merge.ts";
 import { previewText } from "../../text/preview.ts";
 import type { RlmInput, RlmResult } from "../../core/types.ts";
 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 { emitting, summarizeLeaf } from "./emitting.ts";
+import { leafClaimKey, runClaimedLeaf } from "./llm-query.ts";
 
 const UNWIRED = formatError("RLM bridge not wired for this invocation");
 const NO_UNMATCHED: readonly string[] = Object.freeze([]);
@@ -64,9 +67,20 @@ function completeDeps(deps: SubcallHandlerDeps): Complete1Deps {
   };
 }
 
+/** 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);
+  return taskKey(kind, prompt, paths, modelId, ctx);
+}
+
 /**
- * One child RLM run: depth cap → resource guard → depth gate → spawn engine → debit parent.
- * Emits its own subcall node (do not wrap in emitting()).
+ * One child RLM run: depth cap → resource guard → ledger gate → depth gate → spawn engine →
+ * debit parent. Emits its own subcall node (do not wrap in emitting()).
  */
 async function childRun(
   deps: SubcallHandlerDeps,
@@ -91,23 +105,75 @@ async function childRun(
   const limitError = checkResourceLimits({ timeoutMs: remTimeout });
   if (limitError !== undefined) return emptyResult(limitError);
 
+  const child = childContextFor(deps, prompt, paths);
+  const rootPrompt =
+    child.unmatched.length === 0
+      ? 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);
+  const claimKey = ledger === undefined ? undefined : key;
+  const decision =
+    ledger !== undefined && claimKey !== undefined
+      ? ledger.tryClaim({ kind: "rlm", prompt, paths: paths ?? [], depth: childDepth }, claimKey)
+      : undefined;
+
+  // 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 subId = inv.emitter.emitSubcallCreated({
     kind: "rlm",
     parentId: inv.parentId,
-    label: "rlm_query",
+    label: decision === undefined || decision.type === "run" ? "rlm_query" : `rlm_query (${decision.type})`,
     model: modelLabel,
     detail: prompt.slice(0, 60),
     depth: childDepth,
   });
+  inv.emitter.emitSubcallUpdated({ id: subId, phase: "spawning" });
 
-  const child = childContextFor(deps, prompt, paths);
-  const rootPrompt =
-    child.unmatched.length === 0
-      ? prompt
-      : `${prompt}\n\n[rlm] paths=${child.unmatched.join(", ")} matched no files; you received the full context.`;
+  if (decision?.type === "echo") {
+    inv.emitter.emitSubcallUpdated({ id: subId, status: "done", resultPreview: ECHO_STUB.slice(0, 80) });
+    return emptyResult(ECHO_STUB);
+  }
+  if (decision?.type === "coalesce" && ledger !== undefined) {
+    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));
+  }
+  if (ledger !== undefined && claimKey !== undefined) {
+    ledger.markRunning(claimKey);
+  }
 
   const input: RlmInput = {
     rootPrompt,
@@ -115,12 +181,27 @@ async function childRun(
     depth: childDepth,
     parentNodeId: subId,
     remainingTimeoutMs: remTimeout,
+    ledger, // DRY #6: the one seam — children share the parent's blackboard
   };
 
   try {
     const res = await deps.gates.rlm.at(childDepth).run(() => run(input, inv));
     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",
@@ -129,6 +210,7 @@ async function childRun(
     return res;
   } catch (err: unknown) {
     const msg = errorMessage(err);
+    if (ledger !== undefined && claimKey !== undefined) ledger.fail(claimKey, msg);
     inv.emitter.emitSubcallUpdated({ id: subId, status: "error", detail: msg });
     return emptyResult(formatError(`child RLM failed - ${msg}`));
   }
@@ -155,6 +237,43 @@ export function createRlmQueryHandler(deps: SubcallHandlerDeps, sd: SpawnDeps) {
 
     const pathArg = opts.paths;
 
+    // v5 rlmBudget demotion: once the ledger has started `rlmBudget` real rlm runs, extra
+    // rlm_query spawns demote to the leaf path (batch spawns are exempt — v5 `_spawn_single`).
+    const ledger = activeLedger(deps);
+    const rlmBudget = deps.getConfig().rlmBudget;
+    if (
+      ledger !== undefined &&
+      rlmBudget !== undefined &&
+      rlmBudget > 0 &&
+      ledger.rlmCount() >= rlmBudget
+    ) {
+      return spawnAndRun(
+        sd,
+        "llm",
+        1,
+        () =>
+          runClaimedLeaf(
+            ledger,
+            leafClaimKey(deps, task),
+            task,
+            inv.depth,
+            () =>
+              emitting(
+                inv,
+                {
+                  kind: "llm",
+                  label: "rlm_query→llm (demoted)",
+                  args: previewText(task),
+                },
+                (track) => complete1(inv, task, track, completeDeps(deps)),
+                summarizeLeaf,
+              ),
+          ),
+        deps.trackDetached,
+        opts.detached,
+      );
+    }
+
     return spawnAndRun(
       sd,
       "rlm",
@@ -189,36 +308,17 @@ export function createRlmBatchHandler(deps: SubcallHandlerDeps, sd: SpawnDeps) {
     }
 
     const pathArg = opts.paths;
-    const id = inv.emitter.emitSubcallCreated({
-      kind: "batch",
-      parentId: inv.parentId,
-      label: `rlm_batch ×${tasks.length}`,
-      args: previewText(tasks[0] ?? ""),
-      depth: inv.depth,
-    });
-
+    // No wrapper "rlm_batch ×N" node: every task already gets its own rlm_query node from
+    // childRun (DRY #2), parented to the caller — the batch is spawn fan-out, not a UI row.
     return spawnAndRun(
       sd,
       "rlm_batch",
       tasks.length,
       async () => {
-        try {
-          const results = await Promise.all(
-            tasks.map((t) => childRun(deps, inv, t, pathArg)),
-          );
-          const answers = results.map((r) => r.answer);
-          inv.emitter.emitSubcallUpdated({
-            id,
-            status: "done",
-            resultPreview: previewText(answers[0] ?? ""),
-            totalCount: answers.length,
-          });
-          return answers;
-        } catch (err: unknown) {
-          const msg = errorMessage(err);
-          inv.emitter.emitSubcallUpdated({ id, status: "error", detail: msg });
-          throw err;
-        }
+        const results = await Promise.all(
+          tasks.map((t) => childRun(deps, inv, t, pathArg)),
+        );
+        return results.map((r) => r.answer);
       },
       deps.trackDetached,
       opts.detached,

package/src/bridge/handlers/types.ts

@@ -12,6 +12,8 @@ import type { RlmInput, RlmResult, Sampling } from "../../core/types.ts";
 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
@@ -85,6 +87,12 @@ export interface SubcallConfig {
   readonly maxDepth: number;
   readonly subSampling?: Sampling;
   readonly subSystemPrompt?: string;
+  /** v5 TaskLedger: claim/coalesce/echo gates (optional — unwired callers keep ledger off). */
+  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;
 }
 
 export interface SubcallHandlerDeps {
@@ -104,6 +112,10 @@ export interface SubcallHandlerDeps {
   readonly degrade?: (prompt: string, depth: number) => Promise<string>;
   readonly onChildUsage?: (costUsd: number, inputTokens: number, outputTokens: number) => void;
   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;
 }
 
 // ---------------------------------------------------------------------------

package/src/commands/pins.ts

@@ -0,0 +1,51 @@
+/**
+ * pins — apply model-picker selections to controller pin state.
+ *
+ * One function per role; both follow the same contract:
+ *   `undefined` → ESC, no change · `null` → the role's top option (unpin) ·
+ *   `ModelSelection` → pin model + its thinking level into the matching sampling slot.
+ */
+
+import { modelRef } from "../config/settings.ts";
+import type { RlmController } from "../mode/rlm-mode.ts";
+import type { ModelSelection } from "../ui/model-picker.ts";
+
+export function applyLlmSelection(controller: RlmController, llm: ModelSelection | null | undefined): void {
+  if (llm === undefined) return;
+  if (llm === null) {
+    controller.llmModel = undefined;
+    controller.savedLlmRef = undefined;
+    controller.explicitClearPin = true;
+    return;
+  }
+  controller.llmModel = llm.model;
+  controller.savedLlmRef = modelRef(llm.model);
+  controller.explicitClearPin = false;
+  controller.setConfig(Object.freeze({
+    ...controller.config,
+    subSampling: Object.freeze({
+      ...controller.config.subSampling,
+      reasoning: llm.thinkingLevel,
+    }),
+  }));
+}
+
+export function applyRlmSelection(controller: RlmController, rlm: ModelSelection | null | undefined): void {
+  if (rlm === undefined) return;
+  if (rlm === null) {
+    controller.rlmModel = undefined;
+    controller.savedRlmRef = undefined;
+    controller.explicitClearRlmPin = true;
+    return;
+  }
+  controller.rlmModel = rlm.model;
+  controller.savedRlmRef = modelRef(rlm.model);
+  controller.explicitClearRlmPin = false;
+  controller.setConfig(Object.freeze({
+    ...controller.config,
+    rootSampling: Object.freeze({
+      ...(controller.config.rootSampling ?? {}),
+      reasoning: rlm.thinkingLevel,
+    }),
+  }));
+}

package/src/commands/rlm-config.ts

@@ -1,104 +1,20 @@
-/** `/rlm-config` — choose the sub-LLM model, reasoning level, and run settings.
- *  The root model is always pi's active model; only the sub-LLM is configurable here. */
+/** `/rlm-config` — run settings only. Model pins live in `/rlm-llm` and `/rlm-rlm`. */
 
-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 type { RlmController } from "../mode/rlm-mode.ts";
-import { cheapestModel } from "../mode/llm-model.ts";
 import { setRlmModeStatus } from "../ui/status.ts";
 import { showConfigPanel } from "../ui/config-panel.ts";
-import { pickableModels, selectModel, type ModelSelection } from "../ui/model-picker.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;
-}
-
-/**
- * Apply a model-picker result to controller pin state.
- *
- * - `null` → explicit "cheapest (auto)" (clear pin; leave reasoning alone)
- * - `ModelSelection` → pin that model (and its thinking level, which may be undefined)
- * - `undefined` → ESC / no change
- */
-export function applyLlmSelection(
-  controller: RlmController,
-  llm: ModelSelection | null | undefined,
-): void {
-  if (llm === undefined) return;
-  if (llm === null) {
-    controller.llmModel = undefined;
-    controller.savedLlmRef = undefined;
-    controller.explicitClearPin = true;
-    return;
-  }
-  controller.llmModel = llm.model;
-  controller.savedLlmRef = modelRef(llm.model);
-  controller.explicitClearPin = false;
-  controller.setConfig(Object.freeze({
-    ...controller.config,
-    subSampling: Object.freeze({
-      ...controller.config.subSampling,
-      reasoning: llm.thinkingLevel,
-    }),
-  }));
-}
-
-export async function runRlmConfig(controller: RlmController, ctx: ExtensionContext): Promise<boolean> {
-  // Match Pi's native list: refresh so a just-added key appears, then use scoped models when
-  // the session narrowed them, else every available (auth-configured) model. Never getAll().
-  try {
-    await ctx.modelRegistry.refresh();
-  } catch {
-    // Fail-soft: show the cached available snapshot rather than aborting config.
-  }
-  const models = pickableModels(ctx.modelRegistry, sessionScopedModels(ctx));
-
-  const llm = await selectModel(
-    ctx,
-    "LLM model (sub-calls: llm_query / map_files / rlm_query)",
-    models,
-    controller.llmModel,
-    controller.config.subSampling.reasoning,
-    controller.savedLlmRef,
-  );
-  // Only an explicit choice touches the pin. ESC leaves model + reasoning alone.
-  // Choosing cheapest must NOT wipe subSampling.reasoning (null !== undefined used to).
-  applyLlmSelection(controller, llm);
-
-  // Persist model choice immediately — if showConfigPanel throws or process exits before it
-  // returns, the pin survives (Root Cause #2, v0.3.2).
-  if (llm !== undefined) {
-    const saved = await controller.persist();
-    if (!saved) ctx.ui.notify("RLM: failed to save llm setting", "error");
-  }
 
+async function runRlmConfig(controller: RlmController, ctx: ExtensionContext): Promise<void> {
   controller.setConfig(await showConfigPanel(ctx, controller.config));
-
   const persisted = await controller.persist();
   if (!persisted) ctx.ui.notify("RLM: failed to save settings to ~/.pi/agent/rlm.json", "error");
-  setRlmModeStatus(ctx.ui, controller, ctx.getContextUsage());
-
-  // Name the model that actually resolved, not "(cheapest)" — otherwise there is no way to
-  // tell whether the free model in the catalog was the one picked.
-  const pinned = controller.llmModel;
-  const effective = pinned ?? cheapestModel(ctx.modelRegistry);
-  const reasoning = controller.config.subSampling.reasoning;
-  ctx.ui.notify(
-    `RLM: llm=${modelRef(effective) ?? "(none available)"}`
-    + `${pinned ? "" : " (cheapest, auto)"}${reasoning ? `/${reasoning}` : ""}`,
-    "info",
-  );
-  return llm !== undefined;
+  setRlmModeStatus(ctx, controller, ctx.getContextUsage());
 }
 
 export function registerRlmConfigCommand(pi: ExtensionAPI, controller: RlmController): void {
   pi.registerCommand("rlm-config", {
-    description: "Configure the RLM sub-LLM model and run settings.",
+    description: "Configure RLM run settings (models: /rlm-llm, /rlm-rlm).",
     handler: async (_args, ctx) => {
       await runRlmConfig(controller, ctx);
     },