@hicaru/pi-rlm 0.1.9 → 0.2.0

package/package.json

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

package/src/bridge/llm-query.ts

@@ -5,88 +5,112 @@
  *
  * Caps enforce the divide-and-conquer budget from the RLM method: per-prompt size and batch
  * fan-out are bounded, and batches run through a fixed-size concurrency pool.
+ *
+ * Every input that can change between calls (worker model, emitter, parent node, depth,
+ * remaining budget) is an accessor, so a single bridge instance serves both the headless
+ * engine — which binds them once per run — and the native `repl` tool, which swaps them per
+ * invocation without recreating the sandbox.
  */
 
 import type { Api, Model, Usage } from "@earendil-works/pi-ai";
 import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
 import type { RlmEmitter } from "../tool/rlm-events.ts";
-import { modelRef, resolveModelId } from "../config/settings.ts";
+import { displayModelRef, resolveModelId } from "../config/settings.ts";
 import { checkResourceLimits, type RemainingResources } from "../core/resource-limits.ts";
 import type { Sampling } from "../core/types.ts";
 import { type ChatMsg, modelComplete } from "./model.ts";
 import { previewText } from "../text/preview.ts";
-import { formatError, isErrorText } from "../util/errors.ts";
+import { errorMessage, formatError, isErrorText } from "../util/errors.ts";
 import { mapPool } from "../util/concurrency.ts";
 
+/**
+ * The config slice this bridge reads. Structurally satisfied by `RlmConfig`, and re-read on
+ * every call so `/rlm-config` changes take effect without rebuilding the sandbox.
+ */
+export interface LlmBridgeConfig {
+  readonly maxPromptChars: number;
+  readonly maxConcurrentSubcalls: number;
+  readonly subSystemPrompt?: string;
+  readonly subSampling?: Sampling;
+}
+
 export interface LlmBridgeOptions {
-  readonly workerModel: Model<Api>;
+  /** Resolved per call so provider/config changes between calls are picked up. */
+  readonly workerModel: () => Model<Api>;
   readonly registry: ModelRegistry;
-  readonly subSystem?: string;
-  readonly maxPromptChars?: number;
-  readonly maxConcurrent?: number;
-  readonly sampling?: Sampling;
+  readonly config: () => LlmBridgeConfig;
   readonly signal?: AbortSignal;
   readonly onUsage?: (usage: Usage, model: Model<Api>) => void;
   /** Parent run's remaining budget/timeout; checked before every sub-call. */
-  readonly remainingBudget?: () => RemainingResources;
-  /** Live RlmDetails reporting via onUpdate. */
-  readonly emitter?: RlmEmitter;
-  readonly parentId?: string;
-  readonly depth?: number;
+  readonly remainingBudget?: () => RemainingResources | undefined;
+  /** Live RlmDetails reporting target, resolved per call. */
+  readonly emitter?: () => RlmEmitter | undefined;
+  readonly parentId?: () => string | undefined;
+  readonly depth?: () => number;
 }
 
-const DEFAULT_MAX_PROMPT_CHARS = 400_000;
-const DEFAULT_MAX_CONCURRENT = 4;
+/** Provider failures that a smaller batch or a cheaper model might get past. */
+const RETRYABLE_HINT = /credit|402|payment|quota|rate.limit/i;
 
 export interface LlmBridge {
   llmQuery(prompt: string, model: string | null, depth: number): Promise<string>;
-  llmQueryBatched(prompts: string[], model: string | null, depth: number): Promise<string[]>;
+  llmQueryBatched(prompts: readonly string[], model: string | null, depth: number): Promise<string[]>;
+}
+
+/** Batch outcome summary, or undefined when every prompt succeeded. */
+function batchError(failed: number, total: number): string | undefined {
+  if (failed === 0) return undefined;
+  return failed === total
+    ? `all ${total} sub-calls failed — reduce batch size or try llm_query individually`
+    : `${failed}/${total} sub-calls failed`;
 }
 
 export function createLlmBridge(opts: LlmBridgeOptions): LlmBridge {
-  const maxPromptChars = opts.maxPromptChars ?? DEFAULT_MAX_PROMPT_CHARS;
-  const maxConcurrent = opts.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
-  const { emitter } = opts;
   const displayModel = (model: string | null): string =>
-    modelRef(model ? (resolveModelId(opts.registry, model) ?? opts.workerModel) : opts.workerModel) ?? opts.workerModel.id;
+    displayModelRef(opts.registry, model, opts.workerModel());
 
   // Run one completion; report cost/tokens via `track` (a per-call or per-batch accumulator).
   async function complete1(prompt: string, model: string | null, track: (u: Usage) => void): Promise<string> {
+    const config = opts.config();
     const rem = opts.remainingBudget?.();
     if (rem !== undefined) {
       const limitError = checkResourceLimits(rem);
       if (limitError !== undefined) return limitError;
     }
-    if (prompt.length > maxPromptChars) {
-      return formatError(`sub-LLM prompt exceeded the size limit (${prompt.length.toLocaleString()} chars > ${maxPromptChars.toLocaleString()}). Shorten or chunk the prompt before calling llm_query.`);
+    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(opts.registry, model) : undefined;
     if (model && !resolved) return formatError(`unknown model override '${model}'`);
+    const target = resolved ?? opts.workerModel();
     try {
       const messages: ChatMsg[] = [{ role: "user", content: prompt }];
       const res = await modelComplete(messages, {
-        model: resolved ?? opts.workerModel,
+        model: target,
         registry: opts.registry,
-        system: opts.subSystem,
-        maxTokens: opts.sampling?.maxTokens,
-        temperature: opts.sampling?.temperature,
-        reasoning: opts.sampling?.reasoning,
+        system: config.subSystemPrompt,
+        maxTokens: config.subSampling?.maxTokens,
+        temperature: config.subSampling?.temperature,
+        reasoning: config.subSampling?.reasoning,
         signal: opts.signal,
       });
-      opts.onUsage?.(res.usage, resolved ?? opts.workerModel);
+      opts.onUsage?.(res.usage, target);
       track(res.usage);
       return res.text;
     } catch (err) {
-      return formatError(err instanceof Error ? err.message : String(err));
+      const msg = errorMessage(err);
+      const hint = RETRYABLE_HINT.test(msg) ? " — try smaller batches or individual llm_query calls" : "";
+      return formatError(`${msg}${hint}`);
     }
   }
 
   return {
     async llmQuery(prompt, model) {
+      const emitter = opts.emitter?.();
       const id = emitter?.emitSubcallCreated({
-        kind: "llm", parentId: opts.parentId, label: "llm_query",
+        kind: "llm", parentId: opts.parentId?.(), label: "llm_query",
         model: displayModel(model), args: `prompt: ${previewText(prompt)}`,
-        depth: opts.depth ?? 0,
+        depth: opts.depth?.() ?? 0,
       });
       let cost = 0;
       let tokens = 0;
@@ -103,23 +127,22 @@ export function createLlmBridge(opts: LlmBridgeOptions): LlmBridge {
     },
 
     async llmQueryBatched(prompts, model) {
+      const emitter = opts.emitter?.();
       const id = emitter?.emitSubcallCreated({
-        kind: "batch", parentId: opts.parentId, label: `llm_query ×${prompts.length}`,
+        kind: "batch", parentId: opts.parentId?.(), label: `llm_query ×${prompts.length}`,
         model: displayModel(model), args: `prompt: ${previewText(prompts[0] ?? "")}`,
-        depth: opts.depth ?? 0,
+        depth: opts.depth?.() ?? 0,
       });
       let cost = 0;
       let tokens = 0;
-      const out = await mapPool(prompts, maxConcurrent, (p) =>
+      const out = await mapPool(prompts, opts.config().maxConcurrentSubcalls, (p) =>
         complete1(p, model, (u) => {
           cost += u.cost.total;
           tokens += u.totalTokens;
         }),
       );
       const failed = out.filter(isErrorText).length;
-      const error = failed === out.length && out.length > 0
-        ? `all ${out.length} sub-calls failed`
-        : failed > 0 ? `${failed}/${out.length} sub-calls failed` : undefined;
+      const error = batchError(failed, out.length);
       const firstPreview = previewText(out[0] ?? "");
       const resultPreview = out.length > 1 ? `${firstPreview}  (+${out.length - 1} more)` : firstPreview;
       if (emitter && id !== undefined) emitter.emitSubcallUpdated({ id,

package/src/bridge/rlm-query.ts

@@ -5,118 +5,104 @@
  * depth cap it degrades to a plain `llm_query` (ported from rlm/core/rlm.py `_subcall`). The
  * concurrency pool bounds parallel children for `rlm_query_batched`.
  *
- * `childRun` is the single spawn path shared by `rlmQuery` / `rlmQueryBatched`.
+ * As with the llm bridge, everything that can change between calls is an accessor, so the
+ * headless engine (which binds them once per run) and the native `repl` tool (which swaps them
+ * per invocation) share one implementation.
  */
 
 import type { RlmResult, RunRlm } from "../core/types.ts";
 import type { LlmBridge } from "./llm-query.ts";
 import type { RlmEmitter } from "../tool/rlm-events.ts";
-import { checkResourceLimits } from "../core/resource-limits.ts";
-import { formatError } from "../util/errors.ts";
+import { checkResourceLimits, type RemainingResources } from "../core/resource-limits.ts";
+import { errorMessage, formatError } from "../util/errors.ts";
 import { mapPool } from "../util/concurrency.ts";
+import { previewText } from "../text/preview.ts";
 
-export interface ChildRunInput {
-  readonly rootPrompt: string;
-  readonly context: unknown;
-  readonly depth: number;
-  readonly label?: string;
-  readonly model?: string | null;
+/** The config slice this bridge reads; structurally satisfied by `RlmConfig`. */
+export interface RlmBridgeConfig {
+  readonly maxDepth: number;
+  readonly maxConcurrentSubcalls: number;
 }
 
 export interface RlmHandlers {
   rlmQuery(prompt: string, model: string | null, depth: number): Promise<string>;
-  rlmQueryBatched(prompts: string[], model: string | null, depth: number): Promise<string[]>;
-  /** Full child-run result (answer + usage) for recursive spawns. */
-  childRun(input: ChildRunInput): Promise<RlmResult>;
+  rlmQueryBatched(prompts: readonly string[], model: string | null, depth: number): Promise<string[]>;
 }
 
 export interface RlmBridgeOptions {
+  /**
+   * Spawns one child run. The engine passes its own `run` (self-recursion); the native tool
+   * passes a closure that builds a child engine bound to the current invocation's emitter.
+   */
   readonly run: RunRlm;
   readonly llm: LlmBridge;
-  /** Live RlmDetails reporting via onUpdate. Required — replaces SubcallObserver for recursive subcalls. */
-  readonly emitter: RlmEmitter;
-  readonly maxDepth: number;
-  readonly maxConcurrent: number;
-  /** Parent subcall ID that this run is attached under. */
-  readonly parentNodeId?: string;
+  readonly config: () => RlmBridgeConfig;
+  /** "provider/id" shown on the sub-call node; see `displayModelRef` in config/settings.ts. */
+  readonly modelLabel?: (override: string | null) => string;
+  /** Live RlmDetails reporting target, resolved per call. */
+  readonly emitter: () => RlmEmitter | undefined;
+  /** Parent subcall ID that this run is attached under, resolved per call. */
+  readonly parentNodeId?: () => string | undefined;
   /** Returns the parent's remaining budget/timeout for seeding child runs. */
-  readonly remainingBudget?: () => { readonly budgetUsd?: number; readonly timeoutMs?: number };
+  readonly remainingBudget?: () => RemainingResources | undefined;
   /** Called with a child run's total cost/tokens so the parent LimitGuard debits it. */
   readonly onChildUsage?: (costUsd: number, inputTokens: number, outputTokens: number) => void;
 }
 
-function emptyResult(answer: string): RlmResult {
-  return {
-    answer,
-    iterations: 0,
-    costUsd: 0,
-    inputTokens: 0,
-    outputTokens: 0,
-    durationMs: 0,
-  };
-}
-
 export function createRlmHandlers(opts: RlmBridgeOptions): RlmHandlers {
-  async function childRun(input: ChildRunInput): Promise<RlmResult> {
-    const childDepth = input.depth;
+  /**
+   * One child spawn. `childDepth` is the absolute depth the child will run at.
+   * Never throws: failures come back as "Error: ..." strings, matching the sandbox contract.
+   */
+  async function child(prompt: string, model: string | null, childDepth: number): Promise<string> {
     // At the cap, a child RLM would just be an LM — short-circuit to a one-shot llm_query.
-    // (Callers pass the absolute child depth; rlmQuery wraps with depth+1.)
-    if (childDepth >= opts.maxDepth) {
-      const answer = await opts.llm.llmQuery(
-        input.rootPrompt || String(input.context),
-        input.model ?? null,
-        childDepth - 1,
-      );
-      return emptyResult(answer);
+    if (childDepth >= opts.config().maxDepth) {
+      return opts.llm.llmQuery(prompt, model, childDepth - 1);
     }
-    let subId: string | undefined;
-    try {
-      const rem = opts.remainingBudget?.() ?? {};
+
+    const rem = opts.remainingBudget?.();
+    if (rem !== undefined) {
       // Pre-spawn guard: refuse if the parent's budget or timeout is already exhausted
       // (reference: _subcall checks remaining_budget/timeout before spawning).
       const limitError = checkResourceLimits(rem);
-      if (limitError) return emptyResult(limitError);
-      const label = input.label ?? "rlm_query";
-      const detailSource = input.rootPrompt || String(input.context);
-      subId = opts.emitter.emitSubcallCreated({
-        kind: "rlm", parentId: opts.parentNodeId, label,
-        model: input.model ?? undefined, detail: detailSource.slice(0, 60),
-        depth: childDepth,
-      });
-      const res = await opts.run({
-        rootPrompt: input.rootPrompt,
-        context: input.context,
+      if (limitError !== undefined) return limitError;
+    }
+
+    const emitter = opts.emitter();
+    const subId = emitter?.emitSubcallCreated({
+      kind: "rlm", parentId: opts.parentNodeId?.(), label: "rlm_query",
+      model: opts.modelLabel?.(model) ?? model ?? undefined,
+      detail: prompt.slice(0, 60),
+      depth: childDepth,
+    });
+
+    try {
+      const res: RlmResult = await opts.run({
+        rootPrompt: "",
+        context: prompt,
         depth: childDepth,
         parentNodeId: subId,
-        modelOverride: input.model ?? undefined,
-        remainingBudgetUsd: rem.budgetUsd,
-        remainingTimeoutMs: rem.timeoutMs,
+        modelOverride: model ?? undefined,
+        remainingBudgetUsd: rem?.budgetUsd,
+        remainingTimeoutMs: rem?.timeoutMs,
       });
       opts.onChildUsage?.(res.costUsd, res.inputTokens, res.outputTokens);
-      opts.emitter.emitSubcallUpdated({ id: subId,
-        status: "done", resultPreview: res.answer.slice(0, 200),
-      });
-      return res;
+      // The child emits live cost/token deltas on the shared emitter as it runs, so the node
+      // must NOT also receive a final aggregate — that would double-count.
+      if (emitter && subId !== undefined) {
+        emitter.emitSubcallUpdated({ id: subId, status: "done", resultPreview: previewText(res.answer) });
+      }
+      return res.answer;
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      if (subId) opts.emitter.emitSubcallUpdated({ id: subId, status: "error", detail: msg });
-      return emptyResult(formatError(`child RLM failed - ${msg}`));
+      const msg = errorMessage(err);
+      if (emitter && subId !== undefined) emitter.emitSubcallUpdated({ id: subId, status: "error", detail: msg });
+      return formatError(`child RLM failed - ${msg}`);
     }
   }
 
-  async function child(prompt: string, model: string | null, depth: number): Promise<string> {
-    const res = await childRun({
-      rootPrompt: "",
-      context: prompt,
-      depth: depth + 1,
-      model,
-    });
-    return res.answer;
-  }
-
   return {
-    rlmQuery: (prompt, model, depth) => child(prompt, model, depth),
-    rlmQueryBatched: (prompts, model, depth) => mapPool(prompts, opts.maxConcurrent, (p) => child(p, model, depth)),
-    childRun,
+    rlmQuery: (prompt, model, depth) => child(prompt, model, depth + 1),
+    rlmQueryBatched: (prompts, model, depth) =>
+      mapPool(prompts, opts.config().maxConcurrentSubcalls, (p) => child(p, model, depth + 1)),
   };
 }

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/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;