@hicaru/pi-rlm 0.2.1 → 0.2.2

package/src/bridge/subcall-handlers.ts

@@ -20,6 +20,7 @@ import { displayModelRef, modelRef, resolveModelId } from "../config/settings.ts
 import { type ChatMsg, modelComplete } from "./model.ts";
 import { previewText } from "../text/preview.ts";
 import { checkResourceLimits } from "../core/resource-limits.ts";
+import { filterContextByPaths } from "../context/library-context.ts";
 import type { RlmInput, RlmResult, Sampling } from "../core/types.ts";
 import type { SubcallGates } from "../util/concurrency.ts";
 import type { SubcallOpts, SubLlmHandlers } from "../sandbox/sandbox.ts";
@@ -28,11 +29,10 @@ import { errorMessage, formatError, isErrorText } from "../util/errors.ts";
 
 /**
  * The slice of LimitGuard these handlers need. Narrow on purpose: the headless bridge is
- * constructed from a `remainingBudget()` callback rather than owning a guard, and both
+ * constructed from a remaining-timeout callback rather than owning a guard, and both
  * shapes satisfy this.
  */
 export interface InvocationLimits {
-  remainingBudgetUsd(): number | undefined;
   remainingTimeoutMs(): number | undefined;
   addUsage(usage: Usage): void;
   addRaw(costUsd: number, inputTokens: number, outputTokens: number): void;
@@ -45,10 +45,9 @@ export interface InvocationLimits {
  * `onChildUsage`, so the accounting methods here are deliberately inert.
  */
 export function limitsFromRemaining(
-  remaining?: () => { readonly budgetUsd?: number; readonly timeoutMs?: number },
+  remaining?: () => { readonly timeoutMs?: number },
 ): InvocationLimits {
   return {
-    remainingBudgetUsd: () => remaining?.().budgetUsd,
     remainingTimeoutMs: () => remaining?.().timeoutMs,
     addUsage: () => {},
     addRaw: () => {},
@@ -60,7 +59,7 @@ export function limitsFromRemaining(
  *
  * Captured at interrupt entry and threaded down, never re-read: once handlers can outlive
  * their exec, re-reading mutable tool state after an await would attribute a sub-call to
- * whichever turn happens to be current when it resumes.
+ * whichever turn happens to be current when it settles.
  */
 export interface Invocation {
   readonly emitter: RlmEmitter;
@@ -91,7 +90,7 @@ export interface SubcallHandlerDeps {
   /** Session-wide admission control. Required — a per-caller default would silently unbound it. */
   readonly gates: SubcallGates;
   readonly registry: ModelRegistry;
-  readonly getWorkerModel: () => Model<Api>;
+  readonly getLlmModel: () => Model<Api>;
   /** Live accessor — `/rlm-config` replaces the config object, so never capture the value. */
   readonly getConfig: () => SubcallConfig;
   readonly signal?: AbortSignal;
@@ -107,6 +106,15 @@ export interface SubcallHandlerDeps {
    * one emitter is what lets the session registry drain the subtree intact.
    */
   readonly runChild?: (input: RlmInput, inv: Invocation) => Promise<RlmResult>;
+  /**
+   * The parent's live context, read at spawn time and never captured: a library loaded on turn 3
+   * must reach a child spawned on turn 4. `undefined`/`null` ⇒ no inheritance, and the child falls
+   * back to prompt-as-context.
+   *
+   * This is the ONLY inheritance seam. Adding a second construction path for a child's world
+   * would re-open issue #4 on whichever path forgets to grow.
+   */
+  readonly getChildContext?: () => unknown;
   readonly getModel?: () => Model<Api>;
   /**
    * What rlm_query degrades to at the depth cap. A child RLM there would just be an LM, so
@@ -141,10 +149,18 @@ function emptyResult(answer: string): RlmResult {
   return { answer, iterations: 0, costUsd: 0, inputTokens: 0, outputTokens: 0, durationMs: 0 };
 }
 
+/** What a child RLM will see, plus any `paths=` prefix that selected nothing. */
+interface ChildContext {
+  readonly context: unknown;
+  readonly unmatched: readonly string[];
+}
+
+const NO_UNMATCHED: readonly string[] = Object.freeze([]);
+
 export function createSubcallHandlers(deps: SubcallHandlerDeps): SubcallHandlers {
   /** DRY #3 — the one display-model resolution. */
   const displayModel = (model: string | null): string =>
-    displayModelRef(deps.registry, model, deps.getWorkerModel());
+    displayModelRef(deps.registry, model, deps.getLlmModel());
 
   /** Detached work is counted by the session registry; attached work runs as-is. */
   const detachable = <T>(opts: SubcallOpts, run: () => Promise<T>): Promise<T> =>
@@ -159,7 +175,6 @@ export function createSubcallHandlers(deps: SubcallHandlerDeps): SubcallHandlers
   ): Promise<string> {
     const config = deps.getConfig();
     const limitError = checkResourceLimits({
-      budgetUsd: inv.limits.remainingBudgetUsd(),
       timeoutMs: inv.limits.remainingTimeoutMs(),
     });
     if (limitError !== undefined) return limitError;
@@ -174,7 +189,7 @@ export function createSubcallHandlers(deps: SubcallHandlerDeps): SubcallHandlers
     try {
       const messages: ChatMsg[] = [{ role: "user", content: prompt }];
       const res = await deps.gates.leaf.run(() => modelComplete(messages, {
-        model: resolved ?? deps.getWorkerModel(),
+        model: resolved ?? deps.getLlmModel(),
         registry: deps.registry,
         system: config.subSystemPrompt,
         maxTokens: config.subSampling?.maxTokens,
@@ -236,11 +251,38 @@ export function createSubcallHandlers(deps: SubcallHandlerDeps): SubcallHandlers
     return out;
   }
 
+  /**
+   * Resolve the child's world: the parent's live context, optionally narrowed by path prefixes.
+   *
+   * Falls back to prompt-as-context when nothing is wired, and to the FULL context when `paths`
+   * matched nothing — a silently blind child is exactly the bug this fixes, so a bad prefix
+   * degrades loudly (see the note childRun folds into rootPrompt) rather than quietly.
+   */
+  function childContextFor(prompt: string, paths: readonly string[] | undefined): ChildContext {
+    const inherited = deps.getChildContext?.();
+    if (inherited === undefined || inherited === null) {
+      return Object.freeze({ context: prompt, unmatched: NO_UNMATCHED });
+    }
+    if (paths === undefined || paths.length === 0) {
+      return Object.freeze({ context: inherited, unmatched: NO_UNMATCHED });
+    }
+    const filtered = filterContextByPaths(inherited, paths);
+    return Object.freeze({
+      context: filtered.files.length > 0 ? filtered.files : inherited,
+      unmatched: filtered.unmatched,
+    });
+  }
+
   /**
    * One child RLM run: depth cap → resource guard → spawn engine → debit parent.
    * Emits its own subcall node, so callers must not wrap it in another.
    */
-  async function childRun(inv: Invocation, prompt: string, model: string | null): Promise<RlmResult> {
+  async function childRun(
+    inv: Invocation,
+    prompt: string,
+    model: string | null,
+    paths: readonly string[] | undefined,
+  ): Promise<RlmResult> {
     const childDepth = inv.depth + 1;
     const run = deps.runChild;
     const maxDepth = deps.getConfig().maxDepth;
@@ -254,9 +296,8 @@ export function createSubcallHandlers(deps: SubcallHandlerDeps): SubcallHandlers
       return emptyResult(answer);
     }
 
-    const remBudget = inv.limits.remainingBudgetUsd();
     const remTimeout = inv.limits.remainingTimeoutMs();
-    const limitError = checkResourceLimits({ budgetUsd: remBudget, timeoutMs: remTimeout });
+    const limitError = checkResourceLimits({ timeoutMs: remTimeout });
     if (limitError) return emptyResult(limitError);
 
     const rootModel = deps.getModel?.();
@@ -268,14 +309,19 @@ export function createSubcallHandlers(deps: SubcallHandlerDeps): SubcallHandlers
       kind: "rlm", parentId: inv.parentId, label: "rlm_query",
       model: modelLabel, detail: prompt.slice(0, 60), depth: childDepth,
     });
+    // The child's context is the parent's world, not the prompt text. The prompt becomes the
+    // child's rootPrompt, exactly as a depth-0 run takes the user's question.
+    const child = childContextFor(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.`;
     try {
       const res = await deps.gates.rlm.at(childDepth).run(() => run({
-        rootPrompt: "",
-        context: prompt,
+        rootPrompt,
+        context: child.context,
         depth: childDepth,
         parentNodeId: subId,
         modelOverride: model ?? undefined,
-        remainingBudgetUsd: remBudget,
         remainingTimeoutMs: remTimeout,
       }, inv));
       inv.limits.addRaw(res.costUsd, res.inputTokens, res.outputTokens);
@@ -320,7 +366,7 @@ export function createSubcallHandlers(deps: SubcallHandlerDeps): SubcallHandlers
     async rlmQuery(prompt, model, depth, opts) {
       const inv = deps.resolve(opts, depth);
       if (inv === null) return UNWIRED;
-      return detachable(opts, async () => (await childRun(inv, prompt, model)).answer);
+      return detachable(opts, async () => (await childRun(inv, prompt, model, opts.paths)).answer);
     },
 
     async rlmQueryBatched(prompts, model, depth, opts) {
@@ -328,7 +374,7 @@ export function createSubcallHandlers(deps: SubcallHandlerDeps): SubcallHandlers
       if (inv === null) return prompts.map(() => UNWIRED);
       // Bounded by the per-depth rlm gate inside childRun, not by an outer pool.
       return detachable(opts, async () => {
-        const results = await Promise.all(prompts.map((p) => childRun(inv, p, model)));
+        const results = await Promise.all(prompts.map((p) => childRun(inv, p, model, opts.paths)));
         return results.map((r) => r.answer);
       });
     },

package/src/commands/rlm-config.ts

@@ -1,47 +1,76 @@
-/** `/rlm-config` — choose worker model, reasoning level, and run settings (smart is always pi's active model). */
+/** `/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. */
 
+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, type RlmController } from "../mode/rlm-mode.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 { selectModel } from "../ui/model-picker.ts";
+import { pickableModels, selectModel } 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;
+}
 
 export async function runRlmConfig(controller: RlmController, ctx: ExtensionContext): Promise<boolean> {
-  const models = ctx.modelRegistry.getAvailable();
+  // 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 worker = await selectModel(ctx, "Worker model (sub-LLM / llm_query)", models, controller.workerModel, controller.config.subSampling.reasoning);
-  if (worker !== undefined) {
-    controller.workerModel = worker?.model;
+  const llm = await selectModel(
+    ctx,
+    "LLM model (sub-calls: llm_query / map_files / rlm_query)",
+    models,
+    controller.llmModel,
+    controller.config.subSampling.reasoning,
+  );
+  if (llm !== undefined) {
+    controller.llmModel = llm?.model;
     controller.setConfig(Object.freeze({
       ...controller.config,
-      subSampling: Object.freeze({ ...controller.config.subSampling, reasoning: worker?.thinkingLevel }),
+      subSampling: Object.freeze({ ...controller.config.subSampling, reasoning: llm?.thinkingLevel }),
     }));
   }
 
   controller.setConfig(await showConfigPanel(ctx, controller.config));
 
-  if (worker === null) {
-    controller.savedWorkerRef = undefined;
-  } else {
-    const effectiveWorker = controller.workerModel ?? cheapestModel(ctx.modelRegistry);
-    controller.savedWorkerRef = modelRef(controller.workerModel) ?? modelRef(effectiveWorker);
-  }
+  // Only an explicit choice touches the persisted pin. ESC (`undefined`) used to fall through
+  // here and freeze whatever cheapest resolved to at that moment, which silently ended
+  // "cheapest (auto)" for every later session — including once a cheaper model appeared.
+  if (llm === null) controller.savedLlmRef = undefined;          // "⟳ cheapest (auto)"
+  else if (llm !== undefined) controller.savedLlmRef = modelRef(llm.model);
+
   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());
 
-  const w = controller.workerModel;
+  // 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: worker=${w ? `${w.provider}/${w.id}` : "(cheapest)"}${controller.config.subSampling.reasoning ? `/${controller.config.subSampling.reasoning}` : ""}`,
+    `RLM: llm=${modelRef(effective) ?? "(none available)"}`
+    + `${pinned ? "" : " (cheapest, auto)"}${reasoning ? `/${reasoning}` : ""}`,
     "info",
   );
-  return worker !== undefined;
+  return llm !== undefined;
 }
 
 export function registerRlmConfigCommand(pi: ExtensionAPI, controller: RlmController): void {
   pi.registerCommand("rlm-config", {
-    description: "Configure RLM worker model and run settings.",
+    description: "Configure the RLM sub-LLM model and run settings.",
     handler: async (_args, ctx) => {
       await runRlmConfig(controller, ctx);
     },

package/src/commands/rlm.ts

@@ -1,25 +1,8 @@
 /** `/rlm` — toggle persistent Recursive Language Model mode. */
 
-import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
-import { Container, Text, type Component } from "@earendil-works/pi-tui";
-import { createPiInteractiveDeps } from "../bridge/pi-interactive.ts";
-import type { RlmController, RunHandle } from "../mode/rlm-mode.ts";
-import { postRlmGuide } from "../ui/intro.ts";
-import { clearRlmStatus, setRlmModeStatus } from "../ui/status.ts";
-import { listRunIds, readContextSidecar, readHeader, resolveRunId } from "../state/index.ts";
-import { DEFAULT_RUN_DIR } from "../config/defaults.ts";
-import { reconstructRlmState } from "../state/resume.ts";
-import type { ReconstructResult } from "../state/resume.ts";
-import type { RunHeader } from "../state/rows.ts";
-import { buildRlmSystemPrompt } from "../prompts/system.ts";
-import { RlmEmitter } from "../tool/rlm-events.ts";
-import { RlmEventAggregator } from "../tool/rlm-aggregator.ts";
-import type { RlmDetails } from "../tool/rlm-details.ts";
-import { cardHeader, cardStatsLine, renderCollapsedSubcallTree } from "../tool/subcall-render.ts";
-import { errorMessage } from "../util/errors.ts";
-
-/** Run ids offered for `/rlm-resume <TAB>`. */
-const MAX_COMPLETIONS = 20;
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { RlmController } from "../mode/rlm-mode.ts";
+import { setRlmModeStatus } from "../ui/status.ts";
 
 export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController): void {
   pi.registerCommand("rlm", {
@@ -43,69 +26,6 @@ export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController):
     },
   });
 
-  pi.registerCommand("rlm-help", {
-    description: "Show the RLM startup guide and command cheatsheet.",
-    handler: async () => {
-      postRlmGuide(pi, controller);
-    },
-  });
-
-  pi.registerCommand("rlm-resume", {
-    description: "Resume an interrupted RLM run (default @latest).",
-    getArgumentCompletions: async (prefix) => {
-      const dir = controller.config.runLog?.dir ?? DEFAULT_RUN_DIR;
-      const ids = await listRunIds(process.cwd(), dir);
-      const candidates = ["@latest", ...ids];
-      return candidates
-        .filter((value) => value.startsWith(prefix))
-        .slice(0, MAX_COMPLETIONS)
-        .map((value) => ({ value, label: value }));
-    },
-    handler: async (args, ctx) => {
-      if (controller.isBusy()) {
-        ctx.ui.notify("RLM is busy (use /rlm-stop to cancel).", "warning");
-        return;
-      }
-      const ref = args.trim() || "@latest";
-      const dir = controller.config.runLog?.dir ?? DEFAULT_RUN_DIR;
-      const cwd = ctx.cwd ?? process.cwd();
-      const runId = await resolveRunId(cwd, dir, ref);
-      if (!runId) { ctx.ui.notify(`No resumable RLM run for '${ref}'.`, "error"); return; }
-      const header = await readHeader(cwd, dir, runId);
-      if (!header) { ctx.ui.notify(`Run ${runId} has no header.`, "error"); return; }
-      const systemPrompt = buildRlmSystemPrompt(
-        { contextType: header.context.type, contextChars: header.context.chars, rootPrompt: header.rootPrompt },
-        {
-          orchestrator: header.meta.orchestrator,
-          recursion: 1 < header.meta.maxDepth,
-          askUserQuestion: controller.config.askUserQuestion,
-          todo: controller.config.todo,
-        },
-      );
-      let recon: ReconstructResult;
-      try { recon = await reconstructRlmState(cwd, dir, runId, systemPrompt); }
-      catch (e) {
-        ctx.ui.notify(`RLM resume failed: corrupt run state — ${errorMessage(e)}`, "error");
-        return;
-      }
-      if (!recon.ok) { ctx.ui.notify(`Cannot resume ${runId}: ${recon.reason}.`, "error"); return; }
-      if (recon.terminated) { ctx.ui.notify(`Run ${runId} already finished.`, "info"); return; }
-      const context = await readContextSidecar(cwd, dir, runId, header.context.json);
-      if (context === undefined) // R-C2: warn instead of silently resuming on empty context
-        ctx.ui.notify(`Warning: context sidecar missing for ${runId} — resuming without original context.`, "warning");
-      await executeRlmRunWithResume(pi, controller, ctx, recon, header, context ?? "");
-    },
-  });
-
-  pi.registerCommand("rlm-runs", {
-    description: "List recent RLM runs.",
-    handler: async (_args, ctx) => {
-      const dir = controller.config.runLog?.dir ?? DEFAULT_RUN_DIR;
-      const ids = (await listRunIds(ctx.cwd ?? process.cwd(), dir)).slice(0, 20);
-      ctx.ui.notify(ids.length ? ids.join("\n") : "No RLM runs recorded.", "info");
-    },
-  });
-
   pi.registerShortcut?.("ctrl+shift+r", {
     description: "Toggle RLM mode (off also stops a running query)",
     handler: async (ctx) => {
@@ -115,72 +35,3 @@ export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController):
     },
   });
 }
-
-/** Above-editor progress card for a `/rlm-resume` run: header + the live sub-call tree. */
-function renderResumeWidget(details: RlmDetails | undefined, theme: Theme): Component {
-  const container = new Container();
-  if (!details) return container;
-  const turns = details.turns;
-  const stats = cardStatsLine(
-    details.totals,
-    theme,
-    turns.max > 0 ? `turn ${turns.current}/${turns.max}` : undefined,
-  );
-  container.addChild(new Text(cardHeader("RLM resume", details.status, stats, theme), 0, 0));
-  if (details.subcalls.length > 0) {
-    container.addChild(new Text(renderCollapsedSubcallTree(details.subcalls, theme), 0, 0));
-  }
-  return container;
-}
-
-async function executeRlmRunWithResume(
-  pi: ExtensionAPI,
-  controller: RlmController,
-  ctx: ExtensionContext,
-  recon: ReconstructResult & { ok: true },
-  header: RunHeader,
-  context: unknown,
-): Promise<void> {
-  let handle: RunHandle | undefined;
-  let emitter: RlmEmitter | undefined;
-  let aggregator: RlmEventAggregator | undefined;
-  try {
-    emitter = new RlmEmitter();
-    // Component factory rather than the string[] form: the array form is hard-capped at 10
-    // lines by pi, which the live sub-call tree exceeds as soon as a run fans out. The factory
-    // also receives the live theme, so the widget follows /theme switches.
-    let latest: RlmDetails | undefined;
-    aggregator = new RlmEventAggregator(emitter, (partial) => {
-      latest = partial.details;
-      if (!latest) return;
-      ctx.ui.setWidget?.("rlm-status", (_tui, theme) => renderResumeWidget(latest, theme), {
-        placement: "aboveEditor",
-      });
-    });
-    emitter.emitRootPrompt(header.rootPrompt);
-    const interactive = createPiInteractiveDeps(ctx);
-    if (controller.config.todo) {
-      for (const row of recon.todoRows) await interactive.onTodo?.(row.action, row.params);
-    }
-    handle = controller.start(ctx, { kind: "resume", resume: recon, context }, emitter, {
-      onAskUserQuestion: controller.config.askUserQuestion ? interactive.onAskUserQuestion : undefined,
-      onTodo: controller.config.todo ? interactive.onTodo : undefined,
-    });
-  } catch (e) {
-    ctx.ui.notify(`RLM resume failed: ${errorMessage(e)}`, "error");
-    return;
-  }
-  pi.sendMessage({ customType: "rlm-question", content: `[resume] ${header.rootPrompt}`, display: true });
-  const { done } = handle;
-  try {
-    const result = await done;
-    pi.sendMessage({ customType: "rlm-answer", content: result.answer, display: true });
-  } catch (e) {
-    ctx.ui.notify(`RLM resume failed: ${errorMessage(e)}`, "error");
-  } finally {
-    clearRlmStatus(ctx.ui);
-    ctx.ui.setWidget?.("rlm-status", undefined);
-    aggregator?.dispose();
-    emitter?.shutdown();
-  }
-}

package/src/config/defaults.ts

@@ -1,8 +1,4 @@
 import type { RlmConfig } from "../core/types.ts";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-export const DEFAULT_RUN_DIR = join(tmpdir(), "rlm-runs");
 
 /** Frozen default sub-LLM system prompt — avoids re-allocation on every llm_query call. */
 const DEFAULT_SUB_SYSTEM_PROMPT =
@@ -17,28 +13,21 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   execTimeoutS: 120,
   requestTimeoutMs: 10 * 60_000,
   // Session-wide, not per-batch: spawn() puts many requests on the wire at once, so this is
-  // the only thing bounding fan-out. Worst case is maxDepth × this many child engines (each
-  // owning a Python subprocess) plus this many leaf completions — keep it modest.
-  maxConcurrentSubcalls: 6,
+  // the only thing bounding leaf fan-out.
+  maxConcurrentSubcalls: 16,
+  // Children are bounded separately and lower: each is a Python subprocess holding its own copy
+  // of the context it inherited, where a leaf is one HTTP request. Worst case is
+  // (maxDepth - 1) × this many concurrent child engines.
+  maxConcurrentChildren: 6,
   maxPromptChars: 400_000,
   maxErrors: 5,
   orchestrator: true,
-  pipeline: false,
-  maxBackwardJumps: 2,
   compaction: true,
   compactionThresholdPct: 0.65,
   python: "python3",
   sandboxInitTimeoutMs: 30_000,
-  askUserQuestion: true,
-  todo: true,
   libraryLoader: true,
   rootSampling: Object.freeze({ maxTokens: 16_384 }),
   subSystemPrompt: DEFAULT_SUB_SYSTEM_PROMPT,
   subSampling: Object.freeze({ maxTokens: 8192 }),
-  runLog: Object.freeze({
-    enabled: true,
-    dir: DEFAULT_RUN_DIR,
-    snapshot: true,
-    maxRuns: 50,
-  }),
 });

package/src/config/settings.ts

@@ -1,15 +1,16 @@
-/** Persist RLM settings (tunable config + chosen worker model id). */
+/** Persist RLM settings (tunable config + pinned sub-LLM model id). */
 
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 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, RunLogConfig } from "../core/types.ts";
+import type { RlmConfig } from "../core/types.ts";
 import { DEFAULT_CONFIG } from "./defaults.ts";
 
 export interface PersistedSettings {
   readonly config: Partial<RlmConfig>;
-  readonly worker?: string;
+  /** "provider/id" of the pinned sub-LLM, or undefined for "cheapest (auto)". */
+  readonly llm?: string;
 }
 
 type MutablePartialRlmConfig = { -readonly [K in keyof RlmConfig]?: RlmConfig[K] };
@@ -43,21 +44,6 @@ function validateThinkingLevel(v: unknown): ThinkingLevel | undefined {
   return typeof v === "string" && Object.hasOwn(THINKING_LEVELS, v) ? (v as ThinkingLevel) : undefined;
 }
 
-function validateRunLog(raw: unknown): Partial<RunLogConfig> | undefined {
-  if (typeof raw !== "object" || raw === null) return undefined;
-  const r = raw as Record<string, unknown>;
-  const out: { enabled?: boolean; dir?: string; snapshot?: boolean; maxRuns?: number } = {};
-  const enabled = validateBoolean(r.enabled);
-  if (enabled !== undefined) out.enabled = enabled;
-  const dir = validateString(r.dir);
-  if (dir !== undefined) out.dir = dir;
-  const snapshot = validateBoolean(r.snapshot);
-  if (snapshot !== undefined) out.snapshot = snapshot;
-  const maxRuns = validateNumber(r.maxRuns, 1);
-  if (maxRuns !== undefined) out.maxRuns = maxRuns;
-  return Object.keys(out).length > 0 ? Object.freeze(out) : undefined;
-}
-
 function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (typeof raw !== "object" || raw === null) return {};
   const r = raw as Record<string, unknown>;
@@ -74,10 +60,10 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (requestTimeoutMs !== undefined) out.requestTimeoutMs = requestTimeoutMs;
   const maxConcurrentSubcalls = validateNumber(r.maxConcurrentSubcalls, 1);
   if (maxConcurrentSubcalls !== undefined) out.maxConcurrentSubcalls = maxConcurrentSubcalls;
+  const maxConcurrentChildren = validateNumber(r.maxConcurrentChildren, 1);
+  if (maxConcurrentChildren !== undefined) out.maxConcurrentChildren = maxConcurrentChildren;
   const maxPromptChars = validateNumber(r.maxPromptChars, 1000);
   if (maxPromptChars !== undefined) out.maxPromptChars = maxPromptChars;
-  const maxBudgetUsd = validateNumber(r.maxBudgetUsd, 0.01);
-  if (maxBudgetUsd !== undefined) out.maxBudgetUsd = maxBudgetUsd;
   const maxTimeoutMs = validateNumber(r.maxTimeoutMs, 1000);
   if (maxTimeoutMs !== undefined) out.maxTimeoutMs = maxTimeoutMs;
   const maxTokens = validateNumber(r.maxTokens, 1);
@@ -86,10 +72,6 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (maxErrors !== undefined) out.maxErrors = maxErrors;
   const orchestrator = validateBoolean(r.orchestrator);
   if (orchestrator !== undefined) out.orchestrator = orchestrator;
-  const pipeline = validateBoolean(r.pipeline);
-  if (pipeline !== undefined) out.pipeline = pipeline;
-  const maxBackwardJumps = validateNumber(r.maxBackwardJumps, 0);
-  if (maxBackwardJumps !== undefined) out.maxBackwardJumps = maxBackwardJumps;
   const compaction = validateBoolean(r.compaction);
   if (compaction !== undefined) out.compaction = compaction;
   const compactionThresholdPct = validateNumber(r.compactionThresholdPct, 0);
@@ -100,14 +82,8 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (smartReasoning !== undefined) out.smartReasoning = smartReasoning;
   const subSystemPrompt = validateString(r.subSystemPrompt);
   if (subSystemPrompt !== undefined) out.subSystemPrompt = subSystemPrompt;
-  const runLog = validateRunLog(r.runLog);
-  if (runLog) out.runLog = runLog;
   const sandboxInitTimeoutMs = validateNumber(r.sandboxInitTimeoutMs, 100);
   if (sandboxInitTimeoutMs !== undefined) out.sandboxInitTimeoutMs = sandboxInitTimeoutMs;
-  const askUserQuestion = validateBoolean(r.askUserQuestion);
-  if (askUserQuestion !== undefined) out.askUserQuestion = askUserQuestion;
-  const todo = validateBoolean(r.todo);
-  if (todo !== undefined) out.todo = todo;
   const libraryLoader = validateBoolean(r.libraryLoader);
   if (libraryLoader !== undefined) out.libraryLoader = libraryLoader;
   if (typeof r.subSampling === "object" && r.subSampling !== null) {
@@ -142,7 +118,8 @@ export async function loadSettings(): Promise<PersistedSettings> {
     const r = raw as Record<string, unknown>;
     return {
       config: validateConfig(r.config),
-      worker: typeof r.worker === "string" ? r.worker : undefined,
+      // `worker` is the pre-rename key — still read so an existing pin survives the upgrade.
+      llm: validateString(r.llm) ?? validateString(r.worker),
     };
   } catch {
     return { config: {} };
@@ -167,7 +144,6 @@ export function mergeConfig(partial: Partial<RlmConfig>): RlmConfig {
     ...partial,
     subSampling: { ...DEFAULT_CONFIG.subSampling, ...partial.subSampling },
     rootSampling: Object.freeze({ ...DEFAULT_CONFIG.rootSampling, ...partial.rootSampling }),
-    ...(partial.runLog ? { runLog: Object.freeze({ ...DEFAULT_CONFIG.runLog, ...partial.runLog }) } : {}),
   };
 }