@hicaru/pi-rlm 0.3.8 → 0.3.9

package/README.md

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

package/package.json

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

package/src/bridge/handlers/emitting.ts

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

package/src/bridge/handlers/index.ts

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

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

@@ -5,8 +5,8 @@
 import type { Usage } from "@earendil-works/pi-ai";
 import { modelRef } from "../../config/settings.ts";
 import { complete1, type Complete1Deps } from "./completion.ts";
-import { emitting, summarizeBatch } from "./emitting.ts";
-import { formatError, isErrorText, errorMessage } from "../../util/errors.ts";
+import { emitting, summarizeLeaf } from "./emitting.ts";
+import { formatError, errorMessage } from "../../util/errors.ts";
 import { previewText } from "../../text/preview.ts";
 import type { SpawnResult, SubcallHandlerDeps } from "./types.ts";
 import type { SubcallOpts } from "../../sandbox/interrupts.ts";
@@ -107,10 +107,7 @@ export function createLlmQueryHandler(
           model: displayModel(deps),
         },
         (track: (u: Usage) => void) => complete1(inv, prompt, track, cdeps),
-        (out) => ({
-          preview: previewText(out),
-          error: isErrorText(out) ? out : undefined,
-        }),
+        summarizeLeaf,
       );
     // v5 TaskLedger for leaves: identical prompts coalesce onto one completion (key has no
     // context — a leaf's entire world is the prompt text itself).
@@ -153,21 +150,23 @@ export function createLlmBatchHandler(
       sd,
       "llm_batch",
       prompts.length,
+      // One visible node per prompt — no collapsed "×N" row, no hidden failures: each item
+      // reports its own status/tokens/error (UI parity with pi: every concurrent call renders).
       () =>
-        emitting(
-          inv,
-          {
-            kind: "batch",
-            label: `llm_batch ×${prompts.length}`,
-            args: `prompt: ${previewText(prompts[0] ?? "")}`,
-            model: displayModel(deps),
-          },
-          // NO outer gate — complete1 takes the single leaf slot per prompt.
-          // v5 (audit H3): every item routes through the ledger — duplicate prompts inside
-          // one batch (or twins of other in-flight leaves) coalesce instead of paying N times.
-          (track: (u: Usage) => void) =>
-            Promise.all(
-              prompts.map((p) =>
+        Promise.all(
+          prompts.map((p) =>
+            emitting(
+              inv,
+              {
+                kind: "llm",
+                label: "llm_query",
+                args: `prompt: ${previewText(p)}`,
+                model: displayModel(deps),
+              },
+              // NO outer gate — complete1 takes the single leaf slot per prompt.
+              // v5 (audit H3): every item routes through the ledger — duplicate prompts inside
+              // one batch (or twins of other in-flight leaves) coalesce instead of paying N times.
+              (track: (u: Usage) => void) =>
                 runClaimedLeaf(
                   ledger,
                   ledger === undefined ? undefined : leafClaimKey(deps, p),
@@ -175,9 +174,9 @@ export function createLlmBatchHandler(
                   inv.depth,
                   () => complete1(inv, p, track, cdeps),
                 ),
-              ),
+              summarizeLeaf,
             ),
-          summarizeBatch,
+          ),
         ),
       deps.trackDetached,
       opts.detached,

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

@@ -15,8 +15,7 @@ import type { Invocation, SpawnResult, SubcallHandlerDeps } from "./types.ts";
 import type { SubcallOpts } from "../../sandbox/interrupts.ts";
 import { SPAWN_HINT, spawnAndRun, type SpawnDeps } from "./task-registry.ts";
 import { complete1, type Complete1Deps } from "./completion.ts";
-import { emitting } from "./emitting.ts";
-import { isErrorText } from "../../util/errors.ts";
+import { emitting, summarizeLeaf } from "./emitting.ts";
 import { leafClaimKey, runClaimedLeaf } from "./llm-query.ts";
 
 const UNWIRED = formatError("RLM bridge not wired for this invocation");
@@ -159,6 +158,7 @@ async function childRun(
     detail: prompt.slice(0, 60),
     depth: childDepth,
   });
+  inv.emitter.emitSubcallUpdated({ id: subId, phase: "spawning" });
 
   if (decision?.type === "echo") {
     inv.emitter.emitSubcallUpdated({ id: subId, status: "done", resultPreview: ECHO_STUB.slice(0, 80) });
@@ -266,10 +266,7 @@ export function createRlmQueryHandler(deps: SubcallHandlerDeps, sd: SpawnDeps) {
                   args: previewText(task),
                 },
                 (track) => complete1(inv, task, track, completeDeps(deps)),
-                (out) => ({
-                  preview: previewText(out),
-                  error: isErrorText(out) ? out : undefined,
-                }),
+                summarizeLeaf,
               ),
           ),
         deps.trackDetached,
@@ -311,36 +308,17 @@ export function createRlmBatchHandler(deps: SubcallHandlerDeps, sd: SpawnDeps) {
     }
 
     const pathArg = opts.paths;
-    const id = inv.emitter.emitSubcallCreated({
-      kind: "batch",
-      parentId: inv.parentId,
-      label: `rlm_batch ×${tasks.length}`,
-      args: previewText(tasks[0] ?? ""),
-      depth: inv.depth,
-    });
-
+    // No wrapper "rlm_batch ×N" node: every task already gets its own rlm_query node from
+    // childRun (DRY #2), parented to the caller — the batch is spawn fan-out, not a UI row.
     return spawnAndRun(
       sd,
       "rlm_batch",
       tasks.length,
       async () => {
-        try {
-          const results = await Promise.all(
-            tasks.map((t) => childRun(deps, inv, t, pathArg)),
-          );
-          const answers = results.map((r) => r.answer);
-          inv.emitter.emitSubcallUpdated({
-            id,
-            status: "done",
-            resultPreview: previewText(answers[0] ?? ""),
-            totalCount: answers.length,
-          });
-          return answers;
-        } catch (err: unknown) {
-          const msg = errorMessage(err);
-          inv.emitter.emitSubcallUpdated({ id, status: "error", detail: msg });
-          throw err;
-        }
+        const results = await Promise.all(
+          tasks.map((t) => childRun(deps, inv, t, pathArg)),
+        );
+        return results.map((r) => r.answer);
       },
       deps.trackDetached,
       opts.detached,

package/src/commands/pins.ts

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

package/src/commands/rlm-config.ts

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

package/src/commands/rlm-llm.ts

@@ -0,0 +1,59 @@
+/** `/rlm-llm` — pin the leaf-LLM model (llm_query / llm_batch / map_files). */
+
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { modelRef } from "../config/settings.ts";
+import { cheapestModel } from "../mode/llm-model.ts";
+import type { RlmController } from "../mode/rlm-mode.ts";
+import { pickableModels, selectModel } from "../ui/model-picker.ts";
+import { setRlmModeStatus } from "../ui/status.ts";
+import { applyLlmSelection } from "./pins.ts";
+
+/** Newer Pi hosts expose session-scoped models; 0.79 peers do not — duck-type safely. */
+function sessionScopedModels(
+  ctx: ExtensionContext,
+): readonly { readonly model: Model<Api> }[] | undefined {
+  const scoped: unknown = Reflect.get(ctx, "scopedModels");
+  return Array.isArray(scoped) ? scoped as readonly { readonly model: Model<Api> }[] : undefined;
+}
+
+async function runRlmLlm(controller: RlmController, ctx: ExtensionContext): Promise<void> {
+  try {
+    await ctx.modelRegistry.refresh();
+  } catch {
+    // Fail-soft: show the cached available snapshot rather than aborting config.
+  }
+  const models = pickableModels(ctx.modelRegistry, sessionScopedModels(ctx));
+  const llm = await selectModel(
+    ctx,
+    "llm",
+    models,
+    controller.llmModel,
+    controller.config.subSampling.reasoning,
+    controller.savedLlmRef,
+  );
+  applyLlmSelection(controller, llm);
+  const persisted = await controller.persist();
+  if (!persisted) ctx.ui.notify("RLM: failed to save settings to ~/.pi/agent/rlm.json", "error");
+  setRlmModeStatus(ctx, controller, ctx.getContextUsage());
+
+  // Name the model that actually resolved, not "(cheapest)" — otherwise there is no way to
+  // tell whether the free model in the catalog was the one picked.
+  const pinned = controller.llmModel;
+  const effective = pinned ?? cheapestModel(ctx.modelRegistry);
+  const reasoning = controller.config.subSampling.reasoning;
+  ctx.ui.notify(
+    `RLM: llm=${modelRef(effective) ?? "(none available)"}`
+    + `${pinned ? "" : " (cheapest, auto)"}${reasoning ? `/${reasoning}` : ""}`,
+    "info",
+  );
+}
+
+export function registerRlmLlmCommand(pi: ExtensionAPI, controller: RlmController): void {
+  pi.registerCommand("rlm-llm", {
+    description: "Pin the LLM model used by llm_query / llm_batch / map_files sub-calls.",
+    handler: async (_args, ctx) => {
+      await runRlmLlm(controller, ctx);
+    },
+  });
+}

package/src/commands/rlm-rlm.ts

@@ -0,0 +1,58 @@
+/** `/rlm-rlm` — pin the root/worker model for rlm_query / rlm_batch child engines.
+ *
+ * Unpinned (default), child engines follow pi's active session model — exactly
+ * the pre-pin behavior, now an explicit picker row.
+ */
+
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { modelRef } from "../config/settings.ts";
+import type { RlmController } from "../mode/rlm-mode.ts";
+import { pickableModels, selectModel } from "../ui/model-picker.ts";
+import { setRlmModeStatus } from "../ui/status.ts";
+import { applyRlmSelection } from "./pins.ts";
+
+function sessionScopedModels(
+  ctx: ExtensionContext,
+): readonly { readonly model: Model<Api> }[] | undefined {
+  const scoped: unknown = Reflect.get(ctx, "scopedModels");
+  return Array.isArray(scoped) ? scoped as readonly { readonly model: Model<Api> }[] : undefined;
+}
+
+async function runRlmRlm(controller: RlmController, ctx: ExtensionContext): Promise<void> {
+  try {
+    await ctx.modelRegistry.refresh();
+  } catch {
+    // Fail-soft: show the cached available snapshot rather than aborting config.
+  }
+  const models = pickableModels(ctx.modelRegistry, sessionScopedModels(ctx));
+  const rlm = await selectModel(
+    ctx,
+    "rlm",
+    models,
+    controller.rlmModel,
+    controller.config.rootSampling?.reasoning,
+    controller.savedRlmRef,
+  );
+  applyRlmSelection(controller, rlm);
+  const persisted = await controller.persist();
+  if (!persisted) ctx.ui.notify("RLM: failed to save settings to ~/.pi/agent/rlm.json", "error");
+  setRlmModeStatus(ctx, controller, ctx.getContextUsage());
+
+  const reasoning = controller.config.rootSampling?.reasoning;
+  ctx.ui.notify(
+    controller.rlmModel
+      ? `RLM: rlm=${modelRef(controller.rlmModel) ?? "(none)"}${reasoning ? `/${reasoning}` : ""}`
+      : "RLM: rlm follows session model",
+    "info",
+  );
+}
+
+export function registerRlmRlmCommand(pi: ExtensionAPI, controller: RlmController): void {
+  pi.registerCommand("rlm-rlm", {
+    description: "Pin the model used by rlm_query / rlm_batch child engines (default: session model).",
+    handler: async (_args, ctx) => {
+      await runRlmRlm(controller, ctx);
+    },
+  });
+}

package/src/commands/rlm.ts

@@ -9,7 +9,7 @@ export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController):
     description: "Toggle persistent RLM mode (route plain prompts through the RLM engine).",
     handler: async (_args, ctx) => {
       const enabled = controller.toggle();
-      setRlmModeStatus(ctx.ui, controller, ctx.getContextUsage());
+      setRlmModeStatus(ctx, controller, ctx.getContextUsage());
       ctx.ui.notify(`RLM mode ${enabled ? "ON" : "OFF"}`, "info");
     },
   });
@@ -30,7 +30,7 @@ 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, ctx.getContextUsage());
+      setRlmModeStatus(ctx, controller, ctx.getContextUsage());
       ctx.ui.notify(`RLM mode ${enabled ? "ON" : "OFF"}`, "info");
     },
   });

package/src/config/settings.ts

@@ -12,6 +12,9 @@ export interface PersistedSettings {
   /** "provider/id" of the pinned sub-LLM, or undefined for "cheapest (auto)".
    *  `null` = explicit "cheapest" clear (omit key on disk). */
   readonly llm?: string | null;
+  /** "provider/id" of the pinned rlm root/worker model, or undefined for "follow session".
+   *  `null` = explicit "follow session model" clear (omit key on disk). */
+  readonly rlm?: string | null;
 }
 
 type MutablePartialRlmConfig = { -readonly [K in keyof RlmConfig]?: RlmConfig[K] };
@@ -167,6 +170,7 @@ export async function loadSettings(): Promise<PersistedSettings> {
       config: validateConfig(r.config),
       // `worker` is the pre-rename key — still read so an existing pin survives the upgrade.
       llm: validateString(r.llm) ?? validateString(r.worker),
+      rlm: validateString(r.rlm),
     };
   } catch {
     return { config: {} };
@@ -178,13 +182,19 @@ export async function saveSettings(s: PersistedSettings): Promise<boolean> {
     const p = settingsPath();
     await mkdir(dirname(p), { recursive: true });
     const body: Record<string, unknown> = { config: s.config };
+    const mergeDisk = s.llm === undefined || s.rlm === undefined;
+    const existing = mergeDisk ? await loadSettings() : undefined;
     if (s.llm !== undefined) {
       // Explicit: string → write pin, null → omit key (cheapest).
       if (s.llm !== null) body.llm = s.llm;
-    } else {
+    } else if (existing?.llm) {
       // Merge: preserve existing disk pin so config-only saves never strip it.
-      const existing = await loadSettings();
-      if (existing.llm) body.llm = existing.llm;
+      body.llm = existing.llm;
+    }
+    if (s.rlm !== undefined) {
+      if (s.rlm !== null) body.rlm = s.rlm;
+    } else if (existing?.rlm) {
+      body.rlm = existing.rlm;
     }
     await writeFile(p, `${JSON.stringify(body, null, 2)}\n`);
     return true;

package/src/core/engine.ts

@@ -22,6 +22,7 @@ import { type ChatMsg, modelComplete } from "../bridge/model.ts";
 import { buildRlmSystemPrompt } from "../prompts/system.ts";
 import { buildTurnPrompt, FINALIZE_PROMPT } from "../prompts/user.ts";
 import type { RlmEmitter } from "../tool/rlm-events.ts";
+import type { SubcallPhase } from "../tool/rlm-details.ts";
 import { PythonSandbox, SANDBOX_WATCHDOG_HEARTBEAT_MS } from "../sandbox/sandbox.ts";
 import { pinContext, type PinnedContext } from "../sandbox/context-file.ts";
 import { previewStdout, previewText } from "../text/preview.ts";
@@ -119,6 +120,12 @@ export function createEngine(deps: EngineDeps): RunRlm {
         },
       },
     };
+    // Live activity phase for the tree UI: child engines report on their own subcall
+    // node; the root engine has no node, so it reports via the root-phase channel.
+    const reportPhase = (phase: SubcallPhase): void => {
+      if (selfReportId !== undefined) emitter.emitSubcallUpdated({ id: selfReportId, phase });
+      else emitter.emitRootPhase(phase);
+    };
     // Detached work must not outlive the sandbox we dispose in `finally`: track it so the
     // run can settle or abort it first (a child engine left running would keep spending).
     let detachedInFlight = 0;
@@ -276,9 +283,12 @@ export function createEngine(deps: EngineDeps): RunRlm {
           }).handlers
         : {};
 
+      // v5 doctrine: one condition feeds BOTH the python surface and the memory scope —
+      // delegation children keep llm/memory-read/ledger, never repo retrieval or memory.add.
+      const surface = input.depth > 0 && deps.config.childSurface === "delegation" ? "child" : "root";
       sandbox = await PythonSandbox.spawn({
         depth: input.depth,
-        surface: input.depth > 0 && deps.config.childSurface === "delegation" ? "child" : "root",
+        surface,
         execTimeoutS: deps.config.execTimeoutS,
         requestTimeoutMs: deps.config.requestTimeoutMs,
         python: deps.config.python,
@@ -290,7 +300,10 @@ export function createEngine(deps: EngineDeps): RunRlm {
           ...subcalls,
           ...contextHandlers,
           ledgerClaims: () => Promise.resolve(runLedger.listClaims()),
-          memoryOp: (op, args) => Promise.resolve(rootMemory?.serviceOp(op, args) ?? "memory off"),
+          memoryOp: (op, args) =>
+            Promise.resolve(
+              rootMemory === undefined ? "memory off" : rootMemory.serviceOp(op, args, surface === "child" ? "child" : "root"),
+            ),
         },
       });
 
@@ -361,6 +374,7 @@ export function createEngine(deps: EngineDeps): RunRlm {
           sampling: rootSampling,
           signal: deps.signal,
           complete: deps.complete,
+          onPhase: reportPhase,
         });
         const allBlocks = turn.blocks.length > 0
           ? turn.blocks.map((b) => previewText(b, 400)).join("\n")

package/src/core/iteration.ts

@@ -10,6 +10,7 @@ import { type ChatMsg, type CompleteOptions, type CompleteResult, modelComplete
 import type { ReplResult } from "../sandbox/protocol.ts";
 import type { PythonSandbox } from "../sandbox/sandbox.ts";
 import { findReplBlocks } from "../text/parsing.ts";
+import type { SubcallPhase } from "../tool/rlm-details.ts";
 import type { Sampling } from "./types.ts";
 
 export interface Turn {
@@ -30,10 +31,13 @@ export interface TurnDeps {
   readonly signal?: AbortSignal;
   /** Test-only override for model completion (scripted responses). */
   readonly complete?: CompleteFn;
+  /** Live activity reporting for the tree UI (thinking → repl/texting per turn). */
+  readonly onPhase?: (phase: SubcallPhase) => void;
 }
 
 export async function runTurn(history: readonly ChatMsg[], sandbox: PythonSandbox, deps: TurnDeps): Promise<Turn> {
   const complete = deps.complete ?? modelComplete;
+  deps.onPhase?.("thinking");
   const { text, usage } = await complete(history, {
     model: deps.model,
     registry: deps.registry,
@@ -44,6 +48,7 @@ export async function runTurn(history: readonly ChatMsg[], sandbox: PythonSandbo
   });
 
   const blocks = findReplBlocks(text);
+  deps.onPhase?.(blocks.length > 0 ? "repl" : "texting");
   const results = new Array<ReplResult>(blocks.length);
   let executed = 0;
   for (let i = 0; i < blocks.length; i++) {