@hicaru/pi-rlm 0.1.9 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hicaru/pi-rlm",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "type": "module",
   "description": "Save 99% tokens, Recursive Language Model (RLM) for the Pi",
   "license": "MIT",

package/src/bridge/fallback-todo.ts

@@ -90,12 +90,22 @@ function withPatch(task: Task, params: TodoParams): Task {
   });
 }
 
+/** The actions `worker.py::_todo` documents. Anything else is a caller error, not a missing task. */
+const TODO_ACTIONS: ReadonlySet<string> = Object.freeze(new Set([
+  "create", "update", "list", "get", "delete", "clear",
+]));
+
 export function createTodoFallback(): (action: string, params: Record<string, unknown>) => Promise<string> {
   let nextId = 1;
   let tasks: readonly Task[] = Object.freeze([]);
   const fmt = (task: Task): string => taskLines(task)[0] ?? `#${task.id}`;
 
   const apply = (action: string, rawParams: Record<string, unknown>): string => {
+    // Validated BEFORE the id lookup below: an unknown action used to fall through to it and
+    // report "task #? not found", which reads as a missing task rather than a bad action.
+    if (!TODO_ACTIONS.has(action)) {
+      return formatError(`unknown todo action '${action}' — expected ${[...TODO_ACTIONS].join(", ")}`);
+    }
     const params = toTodoParams(rawParams);
     if (action === "clear") {
       const count = tasks.length;
@@ -131,7 +141,8 @@ export function createTodoFallback(): (action: string, params: Record<string, un
       tasks = Object.freeze(tasks.map((item) => item.id === task.id ? updated : item));
       return `Updated ${fmt(updated)}`;
     }
-    return formatError(`unknown todo action '${action}'`);
+    // Unreachable: every TODO_ACTIONS member is handled above. Kept as the exhaustiveness arm.
+    return formatError(`unhandled todo action '${action}'`);
   };
   return async (action, params) => apply(action, params);
 }

package/src/bridge/subcall-handlers.ts

@@ -0,0 +1,336 @@
+/**
+ * The single implementation of the sub-LLM handler set (llm_query, llm_query_batched,
+ * rlm_query, rlm_query_batched).
+ *
+ * Resolves AGENTS.md DRY #1–#5, which previously lived twice: once in `createLlmBridge` /
+ * `createRlmHandlers` for the headless engine, once in `NativeBridgeState` for the repl()
+ * tool. The two callers only ever differed in how they answer one question — "which emitter,
+ * limits and parent node does THIS interrupt belong to?" — so that is the only thing they
+ * still supply, as `resolve`. The engine binds one Invocation for a whole run; the repl()
+ * tool swaps one per turn and routes `spawn()`ed work to its session registry.
+ *
+ * Concurrency: every leaf completion passes through `gates.leaf`, every child engine through
+ * `gates.rlm.at(depth)`, so a sandbox that puts 25 batches on the wire at once is still
+ * bounded session-wide. See util/concurrency.ts for why the rlm gate is per-depth.
+ */
+
+import type { Api, Model, Usage } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+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 type { RlmInput, RlmResult, Sampling } from "../core/types.ts";
+import type { SubcallGates } from "../util/concurrency.ts";
+import type { SubcallOpts, SubLlmHandlers } from "../sandbox/sandbox.ts";
+import type { RlmEmitter } from "../tool/rlm-events.ts";
+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
+ * shapes satisfy this.
+ */
+export interface InvocationLimits {
+  remainingBudgetUsd(): number | undefined;
+  remainingTimeoutMs(): number | undefined;
+  addUsage(usage: Usage): void;
+  addRaw(costUsd: number, inputTokens: number, outputTokens: number): void;
+}
+
+/**
+ * Adapt a "how much is left?" callback to InvocationLimits.
+ *
+ * The headless engine owns the real LimitGuard and folds usage in through `onUsage` /
+ * `onChildUsage`, so the accounting methods here are deliberately inert.
+ */
+export function limitsFromRemaining(
+  remaining?: () => { readonly budgetUsd?: number; readonly timeoutMs?: number },
+): InvocationLimits {
+  return {
+    remainingBudgetUsd: () => remaining?.().budgetUsd,
+    remainingTimeoutMs: () => remaining?.().timeoutMs,
+    addUsage: () => {},
+    addRaw: () => {},
+  };
+}
+
+/**
+ * Where one interrupt's reporting and accounting go.
+ *
+ * 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.
+ */
+export interface Invocation {
+  readonly emitter: RlmEmitter;
+  readonly parentId: string | undefined;
+  readonly depth: number;
+  readonly limits: InvocationLimits;
+}
+
+/**
+ * The config slice these handlers read. Structurally satisfied by `RlmConfig`, and re-read on
+ * every call so `/rlm-config` changes take effect without rebuilding the sandbox.
+ */
+export interface SubcallConfig {
+  readonly maxPromptChars: number;
+  readonly maxDepth: number;
+  readonly subSampling?: Sampling;
+  readonly subSystemPrompt?: string;
+}
+
+export interface SubcallHandlerDeps {
+  /**
+   * Pick the Invocation for this interrupt. `null` ⇒ the bridge is not wired yet.
+   *
+   * `depth` is the depth the sandbox reported. The headless engine trusts it (its handlers
+   * serve one sandbox per depth); the repl() tool overrides it with its own turn depth.
+   */
+  readonly resolve: (opts: SubcallOpts, depth: number) => Invocation | null;
+  /** Session-wide admission control. Required — a per-caller default would silently unbound it. */
+  readonly gates: SubcallGates;
+  readonly registry: ModelRegistry;
+  readonly getWorkerModel: () => Model<Api>;
+  /** Live accessor — `/rlm-config` replaces the config object, so never capture the value. */
+  readonly getConfig: () => SubcallConfig;
+  readonly signal?: AbortSignal;
+  readonly onUsage?: (usage: Usage, role: "sub") => void;
+
+  // ── recursion (omit all three to get llm-only handlers) ──
+  /**
+   * Spawns a child RLM for rlm_query.
+   *
+   * Receives the parent's Invocation so the child can report on the same emitter its
+   * parent subcall node lives on — a child of detached work must not emit to a turn
+   * emitter that will be shut down before it finishes, and keeping parent and child on
+   * one emitter is what lets the session registry drain the subtree intact.
+   */
+  readonly runChild?: (input: RlmInput, inv: Invocation) => Promise<RlmResult>;
+  readonly getModel?: () => Model<Api>;
+  /**
+   * What rlm_query degrades to at the depth cap. A child RLM there would just be an LM, so
+   * both callers hand in their own one-shot path rather than re-deriving one here.
+   */
+  readonly degrade?: (prompt: string, model: string | null, depth: number) => Promise<string>;
+  /** Called with a child run's totals so a caller-side guard can debit them too. */
+  readonly onChildUsage?: (costUsd: number, inputTokens: number, outputTokens: number) => void;
+  /** Wraps detached work so a session registry can count what is still in flight. */
+  readonly trackDetached?: <T>(run: () => Promise<T>) => Promise<T>;
+}
+
+/** DRY #4 — the batch failure summary, previously written out in both copies. */
+export function summarizeBatch(out: readonly string[]): { readonly failed: number; readonly error?: string } {
+  let failed = 0;
+  for (const item of out) if (isErrorText(item)) failed += 1;
+  if (failed === 0) return { failed: 0 };
+  const error = failed === out.length
+    ? `all ${out.length} sub-calls failed — reduce batch size or try llm_query individually`
+    : `${failed}/${out.length} sub-calls failed`;
+  return { failed, error };
+}
+
+export type SubcallHandlers = Pick<
+  SubLlmHandlers,
+  "llmQuery" | "llmQueryBatched" | "rlmQuery" | "rlmQueryBatched"
+>;
+
+const UNWIRED = formatError("RLM bridge not wired for this invocation");
+
+function emptyResult(answer: string): RlmResult {
+  return { answer, iterations: 0, costUsd: 0, inputTokens: 0, outputTokens: 0, durationMs: 0 };
+}
+
+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());
+
+  /** Detached work is counted by the session registry; attached work runs as-is. */
+  const detachable = <T>(opts: SubcallOpts, run: () => Promise<T>): Promise<T> =>
+    opts.detached && deps.trackDetached !== undefined ? deps.trackDetached(run) : run();
+
+  /** One leaf completion. Reports cost/tokens via `track`; never throws. */
+  async function complete1(
+    inv: Invocation,
+    prompt: string,
+    model: string | null,
+    track: (usage: Usage) => void,
+  ): Promise<string> {
+    const config = deps.getConfig();
+    const limitError = checkResourceLimits({
+      budgetUsd: inv.limits.remainingBudgetUsd(),
+      timeoutMs: inv.limits.remainingTimeoutMs(),
+    });
+    if (limitError !== undefined) return limitError;
+    if (prompt.length > config.maxPromptChars) {
+      return formatError(
+        `sub-LLM prompt exceeded the size limit (${prompt.length.toLocaleString()} chars > ` +
+        `${config.maxPromptChars.toLocaleString()}). Shorten or chunk the prompt before calling llm_query.`,
+      );
+    }
+    const resolved = model ? resolveModelId(deps.registry, model) : undefined;
+    if (model && !resolved) return formatError(`unknown model override '${model}'`);
+    try {
+      const messages: ChatMsg[] = [{ role: "user", content: prompt }];
+      const res = await deps.gates.leaf.run(() => modelComplete(messages, {
+        model: resolved ?? deps.getWorkerModel(),
+        registry: deps.registry,
+        system: config.subSystemPrompt,
+        maxTokens: config.subSampling?.maxTokens,
+        temperature: config.subSampling?.temperature,
+        reasoning: config.subSampling?.reasoning,
+        signal: deps.signal,
+      }));
+      inv.limits.addUsage(res.usage);
+      deps.onUsage?.(res.usage, "sub");
+      track(res.usage);
+      return res.text;
+    } catch (err) {
+      const msg = errorMessage(err);
+      const hint = /credit|402|payment|quota|rate.limit/i.test(msg)
+        ? " — try smaller batches or individual llm_query calls"
+        : "";
+      return formatError(`${msg}${hint}`);
+    }
+  }
+
+  /**
+   * DRY #5 — the create → execute → update emit pattern for leaf sub-calls, in one place.
+   * rlm_query does NOT use this: its node is created inside `childRun`, and a wrapper here
+   * would double-report it.
+   */
+  async function emitting<T>(
+    opts: SubcallOpts,
+    depth: number,
+    init: { kind: "llm" | "batch"; label: string; model: string | null; args: string },
+    run: (inv: Invocation, track: (usage: Usage) => void) => Promise<T>,
+    summarize: (out: T) => {
+      readonly preview: string;
+      readonly error?: string;
+      readonly failed?: number;
+      readonly total?: number;
+    },
+    unwired: () => T,
+  ): Promise<T> {
+    const inv = deps.resolve(opts, depth);
+    if (inv === null) return unwired();
+    const id = inv.emitter.emitSubcallCreated({
+      kind: init.kind, parentId: inv.parentId, label: init.label,
+      model: displayModel(init.model), args: init.args, depth: inv.depth,
+    });
+    let costUsd = 0;
+    let tokens = 0;
+    const track = (usage: Usage): void => { costUsd += usage.cost.total; tokens += usage.totalTokens; };
+    const out = await detachable(opts, () => run(inv, track));
+    const summary = summarize(out);
+    inv.emitter.emitSubcallUpdated({
+      id,
+      status: summary.error !== undefined ? "error" : "done",
+      costUsd, tokens,
+      resultPreview: summary.preview,
+      detail: summary.error,
+      failedCount: summary.failed,
+      totalCount: summary.total,
+    });
+    return out;
+  }
+
+  /**
+   * 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> {
+    const childDepth = inv.depth + 1;
+    const run = deps.runChild;
+    const maxDepth = deps.getConfig().maxDepth;
+
+    // At the cap a child RLM would just be an LM — short-circuit to the caller's one-shot path.
+    if (run === undefined || childDepth >= maxDepth) {
+      const degrade = deps.degrade;
+      const answer = degrade !== undefined
+        ? await degrade(prompt, model, inv.depth)
+        : await complete1(inv, prompt, model, () => {});
+      return emptyResult(answer);
+    }
+
+    const remBudget = inv.limits.remainingBudgetUsd();
+    const remTimeout = inv.limits.remainingTimeoutMs();
+    const limitError = checkResourceLimits({ budgetUsd: remBudget, timeoutMs: remTimeout });
+    if (limitError) return emptyResult(limitError);
+
+    const rootModel = deps.getModel?.();
+    const resolvedOverride = model ? resolveModelId(deps.registry, model) : undefined;
+    const modelLabel = model
+      ? (modelRef(resolvedOverride) ?? `unknown/${model}`)
+      : (rootModel === undefined ? undefined : (modelRef(rootModel) ?? rootModel.id));
+    const subId = inv.emitter.emitSubcallCreated({
+      kind: "rlm", parentId: inv.parentId, label: "rlm_query",
+      model: modelLabel, detail: prompt.slice(0, 60), depth: childDepth,
+    });
+    try {
+      const res = await deps.gates.rlm.at(childDepth).run(() => run({
+        rootPrompt: "",
+        context: prompt,
+        depth: childDepth,
+        parentNodeId: subId,
+        modelOverride: model ?? undefined,
+        remainingBudgetUsd: remBudget,
+        remainingTimeoutMs: remTimeout,
+      }, inv));
+      inv.limits.addRaw(res.costUsd, res.inputTokens, res.outputTokens);
+      deps.onChildUsage?.(res.costUsd, res.inputTokens, res.outputTokens);
+      // The child emits live usage deltas on the shared emitter, so no aggregate cost here
+      // — adding it would double-count against SubcallStore's running totals.
+      inv.emitter.emitSubcallUpdated({ id: subId, status: "done", resultPreview: res.answer.slice(0, 200) });
+      return res;
+    } catch (err) {
+      const msg = errorMessage(err);
+      inv.emitter.emitSubcallUpdated({ id: subId, status: "error", detail: msg });
+      return emptyResult(formatError(`child RLM failed - ${msg}`));
+    }
+  }
+
+  return {
+    llmQuery: (prompt, model, depth, opts) => emitting(
+      opts, depth,
+      { kind: "llm", label: "llm_query", model, args: `prompt: ${previewText(prompt)}` },
+      (inv, track) => complete1(inv, prompt, model, track),
+      (out) => ({ preview: previewText(out), error: isErrorText(out) ? out : undefined }),
+      () => UNWIRED,
+    ),
+
+    llmQueryBatched: (prompts, model, depth, opts) => emitting(
+      opts, depth,
+      { kind: "batch", label: `llm_query ×${prompts.length}`, model, args: `prompt: ${previewText(prompts[0] ?? "")}` },
+      // NO outer gate. `complete1` already takes the single `leaf` slot each prompt needs;
+      // an outer `gates.leaf.map` here deadlocked every batch of >= limit prompts.
+      (inv, track) => Promise.all(prompts.map((p) => complete1(inv, p, model, track))),
+      (out) => {
+        const { failed, error } = summarizeBatch(out);
+        const first = previewText(out[0] ?? "");
+        return {
+          preview: out.length > 1 ? `${first}  (+${out.length - 1} more)` : first,
+          error, failed, total: out.length,
+        };
+      },
+      () => prompts.map(() => UNWIRED),
+    ),
+
+    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);
+    },
+
+    async rlmQueryBatched(prompts, model, depth, opts) {
+      const inv = deps.resolve(opts, depth);
+      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)));
+        return results.map((r) => r.answer);
+      });
+    },
+  };
+}

package/src/commands/rlm-config.ts

@@ -11,15 +11,15 @@ export async function runRlmConfig(controller: RlmController, ctx: ExtensionCont
   const models = ctx.modelRegistry.getAvailable();
 
   const worker = await selectModel(ctx, "Worker model (sub-LLM / llm_query)", models, controller.workerModel, controller.config.subSampling.reasoning);
-  if (worker === null) {
-    controller.workerModel = undefined;
-    controller.config.subSampling.reasoning = undefined;
-  } else if (worker) {
-    controller.workerModel = worker.model;
-    controller.config.subSampling.reasoning = worker.thinkingLevel;
+  if (worker !== undefined) {
+    controller.workerModel = worker?.model;
+    controller.setConfig(Object.freeze({
+      ...controller.config,
+      subSampling: Object.freeze({ ...controller.config.subSampling, reasoning: worker?.thinkingLevel }),
+    }));
   }
 
-  await showConfigPanel(ctx, controller.config);
+  controller.setConfig(await showConfigPanel(ctx, controller.config));
 
   if (worker === null) {
     controller.savedWorkerRef = undefined;
@@ -29,7 +29,7 @@ export async function runRlmConfig(controller: RlmController, ctx: ExtensionCont
   }
   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);
+  setRlmModeStatus(ctx.ui, controller, ctx.getContextUsage());
 
   const w = controller.workerModel;
   ctx.ui.notify(

package/src/commands/rlm.ts

@@ -1,6 +1,7 @@
 /** `/rlm` — toggle persistent Recursive Language Model mode. */
 
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+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";
@@ -13,13 +14,19 @@ 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;
 
 export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController): void {
   pi.registerCommand("rlm", {
     description: "Toggle persistent RLM mode (route plain prompts through the RLM engine).",
     handler: async (_args, ctx) => {
       const enabled = controller.toggle();
-      setRlmModeStatus(ctx.ui, controller);
+      setRlmModeStatus(ctx.ui, controller, ctx.getContextUsage());
       ctx.ui.notify(`RLM mode ${enabled ? "ON" : "OFF"}`, "info");
     },
   });
@@ -45,6 +52,15 @@ export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController):
 
   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");
@@ -69,7 +85,7 @@ export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController):
       let recon: ReconstructResult;
       try { recon = await reconstructRlmState(cwd, dir, runId, systemPrompt); }
       catch (e) {
-        ctx.ui.notify(`RLM resume failed: corrupt run state — ${e instanceof Error ? e.message : String(e)}`, "error");
+        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; }
@@ -94,12 +110,29 @@ export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController):
     description: "Toggle RLM mode (off also stops a running query)",
     handler: async (ctx) => {
       const enabled = controller.toggle();
-      setRlmModeStatus(ctx.ui, controller);
+      setRlmModeStatus(ctx.ui, controller, ctx.getContextUsage());
       ctx.ui.notify(`RLM mode ${enabled ? "ON" : "OFF"}`, "info");
     },
   });
 }
 
+/** 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,
@@ -113,13 +146,16 @@ async function executeRlmRunWithResume(
   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) => {
-      const d = partial.details;
-      if (!d) return;
-      const turn = d.turns.max > 0 ? ` · turn ${d.turns.current}/${d.turns.max}` : "";
-      const cost = d.totals.costUsd > 0 ? ` · $${d.totals.costUsd.toFixed(4)}` : "";
-      const glyph = d.status === "running" ? "⏳" : d.status === "done" ? "✓" : "✗";
-      ctx.ui.setWidget?.("rlm-status", [`${glyph} RLM resume${turn}${cost}`], { placement: "aboveEditor" });
+      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);
@@ -131,7 +167,7 @@ async function executeRlmRunWithResume(
       onTodo: controller.config.todo ? interactive.onTodo : undefined,
     });
   } catch (e) {
-    ctx.ui.notify(`RLM resume failed: ${e instanceof Error ? e.message : String(e)}`, "error");
+    ctx.ui.notify(`RLM resume failed: ${errorMessage(e)}`, "error");
     return;
   }
   pi.sendMessage({ customType: "rlm-question", content: `[resume] ${header.rootPrompt}`, display: true });
@@ -140,7 +176,7 @@ async function executeRlmRunWithResume(
     const result = await done;
     pi.sendMessage({ customType: "rlm-answer", content: result.answer, display: true });
   } catch (e) {
-    ctx.ui.notify(`RLM resume failed: ${e instanceof Error ? e.message : String(e)}`, "error");
+    ctx.ui.notify(`RLM resume failed: ${errorMessage(e)}`, "error");
   } finally {
     clearRlmStatus(ctx.ui);
     ctx.ui.setWidget?.("rlm-status", undefined);

package/src/config/defaults.ts

@@ -16,7 +16,10 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   maxIterations: 30,
   execTimeoutS: 120,
   requestTimeoutMs: 10 * 60_000,
-  maxConcurrentSubcalls: 4,
+  // 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,
   maxPromptChars: 400_000,
   maxErrors: 5,
   orchestrator: true,

package/src/config/settings.ts

@@ -30,6 +30,19 @@ function validateString(v: unknown): string | undefined {
   return typeof v === "string" && v.trim() ? v : undefined;
 }
 
+/**
+ * Every value pi-ai accepts for `reasoning`. Keyed by the union so a new level added upstream
+ * is a compile error here rather than a silently-rejected setting. Note `off` and `max` are
+ * NOT ThinkingLevels — a hand-edited rlm.json carrying one is dropped, not forwarded.
+ */
+const THINKING_LEVELS: Readonly<Record<ThinkingLevel, true>> = Object.freeze({
+  minimal: true, low: true, medium: true, high: true, xhigh: true,
+});
+
+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>;
@@ -83,7 +96,8 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (compactionThresholdPct !== undefined && compactionThresholdPct <= 1) out.compactionThresholdPct = compactionThresholdPct;
   const python = validateString(r.python);
   if (python !== undefined) out.python = python;
-  if (typeof r.smartReasoning === "string") out.smartReasoning = r.smartReasoning as ThinkingLevel;
+  const smartReasoning = validateThinkingLevel(r.smartReasoning);
+  if (smartReasoning !== undefined) out.smartReasoning = smartReasoning;
   const subSystemPrompt = validateString(r.subSystemPrompt);
   if (subSystemPrompt !== undefined) out.subSystemPrompt = subSystemPrompt;
   const runLog = validateRunLog(r.runLog);
@@ -103,7 +117,8 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
     if (maxTokensValue !== undefined) sampling.maxTokens = maxTokensValue;
     const temperature = validateNumber(ss.temperature, 0);
     if (temperature !== undefined) sampling.temperature = temperature;
-    if (typeof ss.reasoning === "string") sampling.reasoning = ss.reasoning as ThinkingLevel;
+    const ssReasoning = validateThinkingLevel(ss.reasoning);
+    if (ssReasoning !== undefined) sampling.reasoning = ssReasoning;
     out.subSampling = sampling;
   }
   if (typeof r.rootSampling === "object" && r.rootSampling !== null) {
@@ -113,7 +128,8 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
     if (rsMaxTokens !== undefined) rootSampling.maxTokens = rsMaxTokens;
     const rsTemperature = validateNumber(rs.temperature, 0);
     if (rsTemperature !== undefined) rootSampling.temperature = rsTemperature;
-    if (typeof rs.reasoning === "string") rootSampling.reasoning = rs.reasoning as ThinkingLevel;
+    const rsReasoning = validateThinkingLevel(rs.reasoning);
+    if (rsReasoning !== undefined) rootSampling.reasoning = rsReasoning;
     out.rootSampling = Object.freeze(rootSampling);
   }
   return out;
@@ -166,3 +182,17 @@ export function resolveModelId(registry: ModelRegistry, ref?: string): Model<Api
 export function modelRef(model: Model<Api> | undefined): string | undefined {
   return model ? `${model.provider}/${model.id}` : undefined;
 }
+
+/**
+ * Human-readable "provider/id" for a sub-call node: the resolved override when one was
+ * supplied and resolves, otherwise the fallback model. Shared by the llm and rlm bridges
+ * so sub-call trees label their nodes identically.
+ */
+export function displayModelRef(
+  registry: ModelRegistry,
+  override: string | null,
+  fallback: Model<Api>,
+): string {
+  const resolved = override ? (resolveModelId(registry, override) ?? fallback) : fallback;
+  return modelRef(resolved) ?? fallback.id;
+}

package/src/context/repomix-context.ts

@@ -10,9 +10,12 @@
 
 import { pack } from "repomix";
 import type { PackResult as RepomixPackResult } from "repomix";
+/** repomix's own config parameter type — `satisfies` keeps the literal checked against it. */
+type PackConfig = NonNullable<Parameters<typeof pack>[1]>;
 import { resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { errorMessage } from "../util/errors.ts";
+import { estimateTokens } from "../text/tokens.ts";
 
 // ── Public types ──
 
@@ -51,11 +54,6 @@ interface CacheEntry {
 const cache = new Map<string, CacheEntry>();
 const DEFAULT_CACHE_TTL_MS = 30_000;
 
-/** Exported for tests — empties the module-level cache. */
-export function clearCache(): void {
-  cache.clear();
-}
-
 function cacheKey(cwd: string): string {
   return resolve(cwd);
 }
@@ -76,8 +74,6 @@ function cacheSet(key: string, bundle: ContextBundle): void {
 
 // ── Core functions ──
 
-const ESTIMATED_CHARS_PER_TOKEN = 4;
-
 export async function packRepository(
   cwd: string,
   signal?: AbortSignal,
@@ -133,7 +129,7 @@ export async function packRepository(
         },
         security: { enableSecurityCheck: false },
         tokenCount: { encoding: "o200k_base" as const },
-      } as Parameters<typeof pack>[1]),
+      } satisfies PackConfig),
       new Promise<never>((_, reject) => {
         signal?.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
       }),
@@ -147,8 +143,7 @@ export async function packRepository(
 
     for (let i = 0; i < processedFiles.length; i++) {
       const file = processedFiles[i];
-      const tokens = tokenCounts[file.path]
-        ?? Math.ceil(file.content.length / ESTIMATED_CHARS_PER_TOKEN);
+      const tokens = tokenCounts[file.path] ?? estimateTokens(file.content.length);
       files[i] = { path: file.path, content: file.content, tokens };
       totalTokens += tokens;
       totalChars += file.content.length;