@hicaru/pi-rlm 0.1.8 → 0.2.0

package/README.md

@@ -100,8 +100,8 @@ sub-LLM calls, hence the name.
 
 While a run is active, a **live tree** shows the root orchestrator and every sub-LLM /
 recursive child with status, model, cost, tokens, and duration. The final answer is posted
-to the chat as markdown; any code edits are collected as diffs and reviewed via a popup
-(unless `yolo` is on).
+to the chat as markdown. File changes use Pi's native `edit` / `write` tools (with their
+built-in diff preview).
 
 ## Sandbox API
 
@@ -117,10 +117,9 @@ These functions are injected into the model's Python namespace inside the REPL:
 | `rlm_query_batched` | `(prompts, model=None) -> list[str]` | Concurrent recursive child RLMs |
 | `todo` | `(action, **kwargs) -> str` | Task list: `create`/`update`/`list`/`get`/`delete`/`clear` |
 | `ask_user_question` | `(questions) -> list[dict]` | Ask the user structured questions (depth 0 only) |
-| `load_library` | `(source) -> dict \| str` | Load an external dir, file, or git URL into a new `context_N` slot |
-| `stage_edit` | `(path, old_text, new_text) -> str` | Stage a file edit; relayed to the host's native edit flow |
-| `save_artifact` | `(kind, content) -> str` | Persist a stage artifact (`clarification` / `research` / `plan` / `validation`) under `.rlm/artifacts/` (root depth only) |
-| `advance_phase` | `(phase, summary=None) -> str` | Advance one step in order `clarify → research → blueprint → implement → validate` (clarify skipped when `askUserQuestion` is off). **Engine-gated** on the latest artifact + interview rounds. Rejected transitions return the gate error. |
+| `load_library` | `(source) -> dict \| str` | Append an external dir, file, or git URL into `context` under `lib/<id>/` |
+| `save_artifact` | `(kind, content) -> str` | Persist a stage artifact (`clarification` / `research` / `plan` / `validation`) under `.rlm/artifacts/` (root depth only). Returns preflight gate critique. |
+| `advance_phase` | `(phase, summary=None) -> str` | Advance one step in order `clarify → research → blueprint → validate` (clarify skipped when `askUserQuestion` is off). **Engine-gated** on the latest artifact + interview rounds. Rejected transitions return the gate error. |
 | `SHOW_VARS` | `() -> str` | List currently defined variables & their types |
 | `answer` | `dict` | Set `answer["content"]=...; answer["ready"]=True` to finalize |
 
@@ -130,27 +129,31 @@ When the task needs an **external library, another source tree, or standalone do
 not in the packed repo `context`, the model calls `load_library(source)` mid-run:
 
 ```python
-info = load_library("../some-lib")           # local directory → repomix-packed list[dict]
-info = load_library("docs/api.md")           # single file → plain str
-info = load_library("https://github.com/x/y.git")  # shallow clone, then pack
-# info == {"index": 1, "var": "context_1", "files": …, "chars": …}
-# then chunk context_1 exactly like context
+info = load_library("../some-lib")                # local directory → packed + appended
+info = load_library("docs/api.md")                # single file → one entry in context
+info = load_library("https://github.com/x/y.git") # shallow clone, then pack + append
+# Files land in the SAME `context` list under lib/<source_id>/…
+# info == {"source_id", "path_prefix", "files", "chars", "context_len", "already_loaded", …}
+lib = [f for f in context if f["path"].startswith(info["path_prefix"])]
 ```
 
-Slots start at `context_1` (`context` / `context_0` remains the repo). Toggle via
-`/rlm-config` → **Library loader** (`libraryLoader`, default on). On headless runs with
-persistence, each loaded slot is written as a resume sidecar (`context.<N>.json`).
+There is no `context_1` / `context_2` — only `context`. Paths are namespaced so multiple
+libraries do not collide. Toggle via `/rlm-config` → **Library loader** (`libraryLoader`,
+default on). On headless runs with persistence, each load writes a resume sidecar
+(`context.<N>.json`) that is **merged back into `context`** on resume.
 
 ### Artifact-gated pipeline (opt-in via `pipeline: true`)
 
 When enabled at root depth:
 
 1. **Goal capture** — the brief is written verbatim to `.rlm/artifacts/goal/goal-<ts>.md` with a pre-run dirty-tree baseline.
-2. **Stages** — `clarify → research → blueprint → implement → validate`. Each produces a durable markdown artifact with frontmatter contracts; chat history is **reset** at every phase boundary (artifacts are the only channel; REPL vars persist).
+2. **Stages** — `clarify → research → blueprint → validate` (**read-only** — produces a validated plan; does not write code). Each produces a durable markdown artifact with frontmatter contracts; chat history is **reset** at every phase boundary (artifacts are the only channel; REPL vars persist).
 3. **Clarify (intake)** — interviews the user via `ask_user_question` (intent first, then evidence-confirmed decisions). Writes `.rlm/artifacts/clarifications/*` with `decisions_count` / `open_questions_count`. Engine gate: **≥1 serviced ask round** + artifact contract. When **`askUserQuestion` is off**, clarify is skipped and the run starts at research.
-4. **Gates (TypeScript, never LLM judgment)** — `status: ready`; clarify structure; plan `phases:` ≡ fence-aware `## Phase N:` headings; every `file:line` citation resolves; validate carries `blockers_count` + `verdict`.
-5. **Implement fanout** — on `advance_phase("implement")` the engine runs one **serial** child RLM per plan phase and applies that child's edits before the next phase starts.
-6. **Corrective loop** — `blockers_count > 0` re-enters blueprint, bounded by `maxBackwardJumps` (default 2).
+4. **Gates (TypeScript, never LLM judgment)** — `status: ready`; clarify structure; plan `phases:` ≡ fence-aware `## Phase N:` headings; every `file:line` citation resolves; validate carries `blockers_count` + `verdict`. Preflight critique runs on every `save_artifact`.
+5. **Validate** — adversarial plan review against the tree (not a post-implementation diff check). Final answer is the validated plan.
+6. **Corrective loop** — `blockers_count > 0` re-enters blueprint (superseded plan kept for context), bounded by `maxBackwardJumps` (default 2).
+
+Native RLM mode authors file changes with Pi's native `edit` / `write` tools. Sub-LLMs extract and locate; they never ship code.
 
 ## Settings (`/rlm-config`)
 
@@ -167,7 +170,7 @@ When enabled at root depth:
 | Token ceiling | none | total input+output token cap for the whole recursive tree |
 | Max consecutive errors | `5` | stop after N consecutive failing turns (none = off) |
 | Orchestrator addendum | on | divide-and-conquer guidance in the root system prompt |
-| Phase pipeline | off | artifact-gated clarify→research→blueprint→implement fanout→validate |
+| Phase pipeline | off | artifact-gated clarify→research→blueprint→validate (read-only plan pipeline) |
 | Max validate→blueprint loops | `2` | bounded corrective re-entries when validation reports blockers |
 | Ask user question | on | when pipeline is on, enables clarify intake; when off, pipeline starts at research |
 | Trajectory compaction | on (0.65) | summarize old turns when history nears the context window |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hicaru/pi-rlm",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "type": "module",
   "description": "Save 99% tokens, Recursive Language Model (RLM) for the Pi",
   "license": "MIT",
@@ -27,6 +27,7 @@
   ],
   "scripts": {
     "check": "tsc --noEmit",
+    "test": "bun run test/smoke.ts",
     "prepublishOnly": "npm run check"
   },
   "pi": {

package/src/bridge/library.ts

@@ -1,8 +1,13 @@
 /**
  * Shared load_library handler for headless engine and native repl() mode.
  *
- * Host assigns context slot indices (slot 0 = repo); packs the source via
- * resolveLibrarySource; optional onLoaded writes resume sidecars.
+ * Host packs the source via resolveLibrarySource (namespaced under lib/<id>/),
+ * assigns a resume-sidecar index, and returns the payload for the worker to
+ * append into the single `context` list.
+ *
+ * Idempotency is host-side: re-loading a source that was already packed does
+ * not consume an index, write a sidecar, or re-clone/pack. That keeps resume
+ * trails free of duplicate library slots.
  *
  * Late-bound deps (getCwd / getEmitter) keep a single handler closure correct
  * across native repl() calls — getOrCreate only installs handlers at spawn.
@@ -10,7 +15,10 @@
 
 import type { RlmEmitter } from "../tool/rlm-events.ts";
 import type { SubLlmHandlers } from "../sandbox/sandbox.ts";
-import { resolveLibrarySource } from "../context/library-context.ts";
+import {
+  libraryNamespace,
+  resolveLibrarySource,
+} from "../context/library-context.ts";
 import { previewText } from "../text/preview.ts";
 
 export interface LibraryBridgeOpts {
@@ -23,22 +31,35 @@ export interface LibraryBridgeOpts {
   readonly getEmitter?: () => RlmEmitter | null | undefined;
   readonly parentId?: string;
   readonly signal?: AbortSignal;
-  /** First slot to assign (slot 0 is the repo context). Resume passes 1 + restored slots. */
+  /** First resume-sidecar index (slot 0 = repo). Resume passes 1 + max restored. */
   readonly startIndex: number;
+  /**
+   * Prefixes already present in context (e.g. restored from sidecars).
+   * Seeded so re-load after resume is still a no-op without re-packing.
+   */
+  readonly loadedPrefixes?: readonly string[];
   /** Post-load hook — the engine writes the resume sidecar here; native mode omits it. */
   readonly onLoaded?: (index: number, payload: unknown) => void | Promise<void>;
 }
 
 export interface LibraryHandlerBundle {
   readonly handlers: Pick<SubLlmHandlers, "loadLibrary">;
-  /** Reset the slot counter (call when the sandbox is discarded and will re-spawn). */
+  /** Reset the sidecar index counter (call when the sandbox is discarded and will re-spawn). */
   readonly reset: () => void;
+  /** Prefixes loaded in this sandbox lifetime (for tests). */
+  readonly loadedPrefixes: () => ReadonlySet<string>;
 }
 
 export function buildLibraryHandler(opts: LibraryBridgeOpts): LibraryHandlerBundle {
   let nextIndex = opts.startIndex;
+  /** Prefixes already loaded in this sandbox — mirrors the worker's context state. */
+  const loaded = new Set<string>(opts.loadedPrefixes ?? []);
   return {
-    reset: () => { nextIndex = opts.startIndex; },
+    reset: () => {
+      nextIndex = opts.startIndex;
+      loaded.clear();
+    },
+    loadedPrefixes: () => loaded,
     handlers: {
       async loadLibrary(source, depth) {
         const emitter = opts.getEmitter?.() ?? opts.emitter;
@@ -53,19 +74,76 @@ export function buildLibraryHandler(opts: LibraryBridgeOpts): LibraryHandlerBund
           depth,
         });
         try {
+          // Cheap pre-check BEFORE cloning/packing: same namespace ⇒ nothing to do.
+          const { sourceId: preId, pathPrefix: prefix } = libraryNamespace(source, cwd);
+          if (loaded.has(prefix)) {
+            if (id) {
+              emitter?.emitSubcallUpdated({
+                id,
+                status: "done",
+                resultPreview: `already loaded (${prefix}*)`,
+              });
+            }
+            // No index consumed, no sidecar written — resume stays consistent.
+            return {
+              payload: Object.freeze([]),
+              index: -1,
+              files: 0,
+              chars: 0,
+              sourceId: preId,
+              pathPrefix: prefix,
+              alreadyLoaded: true,
+            };
+          }
+
           const resolved = await resolveLibrarySource(source, cwd, opts.signal);
           if (!resolved.ok) throw new Error(resolved.error);
-          const index = nextIndex++;
-          await opts.onLoaded?.(index, resolved.value.payload);
-          if (id) emitter?.emitSubcallUpdated({
-            id, status: "done",
-            resultPreview: `context_${index}: ${resolved.value.files ?? 1} file(s), ${resolved.value.chars.toLocaleString()} chars`,
-          });
+          const { payload, files, chars, sourceId, pathPrefix } = resolved.value;
+
+          // Race: another concurrent load of the same prefix finished while we packed.
+          if (loaded.has(pathPrefix)) {
+            if (id) {
+              emitter?.emitSubcallUpdated({
+                id,
+                status: "done",
+                resultPreview: `already loaded (${pathPrefix}*)`,
+              });
+            }
+            return {
+              payload: Object.freeze([]),
+              index: -1,
+              files: 0,
+              chars: 0,
+              sourceId,
+              pathPrefix,
+              alreadyLoaded: true,
+            };
+          }
+
+          // Increment only after a successful sidecar write (or when no hook is set).
+          const index = nextIndex;
+          if (opts.onLoaded) {
+            await opts.onLoaded(index, payload);
+          }
+          nextIndex = index + 1;
+          loaded.add(pathPrefix);
+
+          if (id) {
+            emitter?.emitSubcallUpdated({
+              id,
+              status: "done",
+              resultPreview:
+                `+${files} file(s) → context (${pathPrefix}*, ${chars.toLocaleString()} chars)`,
+            });
+          }
           return {
-            payload: resolved.value.payload,
+            payload,
             index,
-            files: resolved.value.files,
-            chars: resolved.value.chars,
+            files,
+            chars,
+            sourceId,
+            pathPrefix,
+            alreadyLoaded: false,
           };
         } catch (err) {
           if (id) emitter?.emitSubcallUpdated({ id, status: "error", detail: String(err) });

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,28 +127,28 @@ 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,
         status: error ? "error" : "done", costUsd: cost, tokens,
         resultPreview, detail: error,
+        failedCount: failed, totalCount: out.length,
       });
       return out;
     },

package/src/bridge/rlm-query.ts

@@ -5,120 +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: rlmQuery returns `.answer`; implement fanout also
- * needs `.edits` — both share this implementation (DRY).
+ * 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 + edits + usage) for engine-driven fanout. */
-  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,
-    edits: [],
-    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(