@hicaru/pi-rlm 0.3.8 → 0.3.13

package/src/index.ts

@@ -4,6 +4,8 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Markdown } from "@earendil-works/pi-tui";
 import { registerRlmCommand } from "./commands/rlm.ts";
 import { registerRlmConfigCommand } from "./commands/rlm-config.ts";
+import { registerRlmLlmCommand } from "./commands/rlm-llm.ts";
+import { registerRlmRlmCommand } from "./commands/rlm-rlm.ts";
 import type { RlmConfig } from "./core/types.ts";
 import { createRlmTool } from "./tool/rlm-tool.ts";
 import { createReplTool } from "./tool/repl-tool.ts";
@@ -12,6 +14,8 @@ import { RlmController } from "./mode/rlm-mode.ts";
 import { cheapestModel } from "./mode/llm-model.ts";
 import { postRlmGuide } from "./ui/intro.ts";
 import { setRlmModeStatus } from "./ui/status.ts";
+import { RunRegistry } from "./ui/panel/run-registry.ts";
+import { installTreePanel } from "./ui/panel/tree-panel.ts";
 import { markdownTheme } from "./ui/theme-adapter.ts";
 import { SANDBOX_WATCHDOG_HEARTBEAT_MS } from "./sandbox/sandbox.ts";
 import { SandboxManager } from "./sandbox/sandbox-manager.ts";
@@ -19,6 +23,7 @@ import { buildSessionGates, type SubcallGates } from "./util/concurrency.ts";
 import { BackgroundTasks } from "./tool/background-tasks.ts";
 import { MemoryStore } from "./core/memory.ts";
 import { modelComplete } from "./bridge/model.ts";
+import { retryPolicy } from "./util/retry.ts";
 import { resolve } from "node:path";
 import { resolveSource } from "./context/resolve.ts";
 import { formatContextListing } from "./context/listing.ts";
@@ -98,6 +103,19 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     maxTokens: config.maxTokens,
     maxErrors: config.maxErrors,
   });
+  // Session tree panel: every repl cell / rlm run / detached bg task registers here;
+  // the below-editor widget + agent modal read from it. Background is persistent
+  // and hides itself while idle.
+  const runRegistry = new RunRegistry();
+  runRegistry.register({
+    runId: "background",
+    label: "background tasks",
+    emitter: background.emitter,
+    subcalls: () => background.liveSubcalls(),
+    totals: () => background.liveTotals(),
+    hideWhenEmpty: true,
+  });
+  let treePanelInstalled = false;
   // A detached child works in its OWN sandbox, so this one sees no frames and its request
   // watchdog would fire mid-await and SIGKILL a healthy worker, taking the REPL namespace
   // with it. Keep it alive while detached work is genuinely in flight.
@@ -161,9 +179,11 @@ export default function rlmExtension(pi: ExtensionAPI): void {
   // ── Commands ──
   registerRlmCommand(pi, controller);
   registerRlmConfigCommand(pi, controller);
+  registerRlmLlmCommand(pi, controller);
+  registerRlmRlmCommand(pi, controller);
 
   // ── Tool registration ──
-  pi.registerTool(createRlmTool(controller));
+  pi.registerTool(createRlmTool(controller, runRegistry));
   let guidePosted = false;
 
   pi.on("session_start", async (_event, ctx) => {
@@ -172,6 +192,7 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     const persisted = await loadSettings();
     controller.config = mergeConfig(persisted.config);
     controller.savedLlmRef = persisted.llm ?? undefined;
+    controller.savedRlmRef = persisted.rlm ?? undefined;
 
     // An explicit --rlm flag wins over the persisted setting for this session.
     const flag = pi.getFlag("rlm");
@@ -188,6 +209,25 @@ export default function rlmExtension(pi: ExtensionAPI): void {
       console.warn(`[rlm] model registry refresh failed: ${errorMessage(err)}`);
     }
 
+    if (controller.savedRlmRef) {
+      const resolvedRlm = resolveModelId(ctx.modelRegistry, controller.savedRlmRef);
+      if (resolvedRlm) {
+        controller.rlmModel = resolvedRlm;
+      } else {
+        console.warn(
+          `[rlm] pinned rlm model ${controller.savedRlmRef} not in registry; following session model until it reappears`,
+        );
+        try {
+          ctx.ui.notify(
+            `RLM: pinned rlm=${controller.savedRlmRef} unavailable — following session model until it is`,
+            "warning",
+          );
+        } catch {
+          // Some hosts have no UI at session_start.
+        }
+      }
+    }
+
     if (controller.savedLlmRef) {
       const resolved = resolveModelId(ctx.modelRegistry, controller.savedLlmRef);
       if (resolved) {
@@ -217,7 +257,11 @@ export default function rlmExtension(pi: ExtensionAPI): void {
       // the workspace root is only known once the session starts.
       const consolidateModel = llmModel;
       memory.setLlm((prompt) =>
-        modelComplete([{ role: "user", content: prompt }], { model: consolidateModel, registry: ctx.modelRegistry })
+        modelComplete([{ role: "user", content: prompt }], {
+          model: consolidateModel,
+          registry: ctx.modelRegistry,
+          retry: retryPolicy(controller.config),
+        })
           .then((r) => r.text));
       memory.setRoot(ctx.cwd ?? process.cwd());
       // v5 provider caps (audit C1/C6): ONE resolver shared by both composition roots — the
@@ -259,6 +303,7 @@ export default function rlmExtension(pi: ExtensionAPI): void {
           gates: resolveSessionGates(),
           resolveGates: resolveSessionGates,
           background,
+          runRegistry,
           memory,
           registerDiscardHook: (reset) => { onSandboxDiscardExtra = reset; },
           registerContextBundle: (bundle) => {
@@ -282,7 +327,11 @@ export default function rlmExtension(pi: ExtensionAPI): void {
       }
     }
 
-    setRlmModeStatus(ctx.ui, controller, ctx.getContextUsage());
+    setRlmModeStatus(ctx, controller, ctx.getContextUsage());
+    if (!treePanelInstalled) {
+      treePanelInstalled = true;
+      installTreePanel(ctx, runRegistry);
+    }
     if (!guidePosted && controller.enabled) {
       guidePosted = true;
       postRlmGuide(pi, controller);
@@ -291,7 +340,7 @@ export default function rlmExtension(pi: ExtensionAPI): void {
 
   // ── Keep the footer's context reading live (RLM exists to shrink this number) ──
   pi.on("turn_end", async (_event, ctx) => {
-    setRlmModeStatus(ctx.ui, controller, ctx.getContextUsage());
+    setRlmModeStatus(ctx, controller, ctx.getContextUsage());
   });
 
   /** True when the native-mode trade holds: enabled AND repl is in the active tool set. */

package/src/mode/rlm-mode.ts

@@ -35,6 +35,11 @@ export class RlmController {
   savedLlmRef: string | undefined;
   /** Set by applyLlmSelection when the user explicitly picks "cheapest (auto)". */
   explicitClearPin = false;
+  /** Pinned rlm root/worker model — when unset, child engines follow pi's session model. */
+  rlmModel: Model<Api> | undefined;
+  savedRlmRef: string | undefined;
+  /** Set by applyRlmSelection when the user explicitly picks "(follow session model)". */
+  explicitClearRlmPin = false;
   private active: AbortController | null = null;
   /** v5: session admission gates (provider-capped), shared with the repl() tool — set at
    *  session_start so BOTH composition roots admit through one pool (audit C1). */
@@ -78,6 +83,9 @@ export class RlmController {
       llm: this.explicitClearPin
         ? null
         : (modelRef(this.llmModel) ?? this.savedLlmRef),
+      rlm: this.explicitClearRlmPin
+        ? null
+        : (modelRef(this.rlmModel) ?? this.savedRlmRef),
     });
   }
 
@@ -91,7 +99,9 @@ export class RlmController {
 
   resolveModels(ctx: ExtensionContext): { model: Model<Api>; llm: Model<Api> } | undefined {
     if (!this.llmModel && this.savedLlmRef) this.llmModel = resolveModelId(ctx.modelRegistry, this.savedLlmRef);
-    const model = ctx.model ?? cheapestModel(ctx.modelRegistry);
+    if (!this.rlmModel && this.savedRlmRef) this.rlmModel = resolveModelId(ctx.modelRegistry, this.savedRlmRef);
+    // The rlm pin wins over the session model; unset → follow pi's active model.
+    const model = this.rlmModel ?? ctx.model ?? cheapestModel(ctx.modelRegistry);
     if (!model) return undefined;
     const llm = this.llmModel ?? cheapestModel(ctx.modelRegistry) ?? model;
     return { model, llm };

package/src/prompts/glossary.ts

@@ -357,9 +357,17 @@ export function replGlossary(
     "  verified result in `answers` — see the decomposition doctrine below.",
     "- `SHOW_VARS() -> str`: list every variable currently in the REPL (Task handles show as `<Task …>`).",
     "- `list_tasks()`: every Task this REPL created — [{kind, label, done, var}].",
-    "- `memory.query(q) -> str` / `memory.add(text, paths=…, tags=…)`: durable notes under `.rlm/`",
-    "  that survive across sessions. Query before re-studying a known area; add concise findings",
-    "  (facts, locations, decisions) — never secrets or API keys (notes persist on disk).",
+    ...(delegation
+      ? [
+          "- `memory.query(q) -> str`: durable notes under `.rlm/` that survive across sessions.",
+          "  **READ-ONLY here** — `memory.add` is root-only. Query before re-studying a known area;",
+          "  your own final answer is recorded as an episode automatically.",
+        ]
+      : [
+          "- `memory.query(q) -> str` / `memory.add(text, paths=…, tags=…)`: durable notes under `.rlm/`",
+          "  that survive across sessions. Query before re-studying a known area; add concise findings",
+          "  (facts, locations, decisions) — never secrets or API keys (notes persist on disk).",
+        ]),
     "- `list_claims()`: the live `[ledger]` table of inflight/done agent work.",
     '- `answer`: a dict initialized to {"content": "", "ready": False}. To submit your final answer,',
     '  set `answer["content"]` to the answer text and `answer["ready"] = True`.',

package/src/prompts/native.ts

@@ -1,6 +1,6 @@
 /** Native-mode prompts — the main Pi agent drives the sandbox through the `repl` tool.
  *
- * Structure mirrors rlm_test api_v5_anthropic (best bake-off arm): role → contract → routing →
+ * Structure mirrors api_v5_anthropic (best bake-off arm): role → contract → routing →
  * few-shots → anti-patterns → REPL surface. Goal: multi-area work fires rlm_batch / rlm_query
  * as Task (BG), not serial repl+native read.
  */

package/src/tool/repl-render.ts

@@ -1,9 +1,10 @@
-/** repl() tool TUI views — collapsed one-liner card and the expanded output/sub-call tree. */
+/** repl() tool TUI views — the single-line card and the expanded output view.
+ * Sub-call trees are not rendered here; the live tree widget owns agent visualization. */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 import type { ReplDetails } from "./repl-details.ts";
-import { cardHeader, cardStatsLine, renderCollapsedCard, renderExpandedSubcallTree } from "./subcall-render.ts";
+import { cardHeader, cardStatsLine, renderCollapsedCard } from "./subcall-render.ts";
 
 /** Chars of stdout/stderr shown in the expanded view. */
 const EXPANDED_STDOUT_CHARS = 2_000;
@@ -17,7 +18,7 @@ export function replStats(details: ReplDetails, theme: Theme): string {
 }
 
 export function renderReplCollapsed(details: ReplDetails, theme: Theme): Text {
-  return renderCollapsedCard("REPL", details.status, replStats(details, theme), details.subcalls, theme);
+  return renderCollapsedCard("REPL", details.status, replStats(details, theme), theme);
 }
 
 // ── Expanded view ──
@@ -47,12 +48,5 @@ export function renderReplExpanded(details: ReplDetails, theme: Theme): Containe
     container.addChild(new Text(theme.fg("error", details.stderr.slice(0, EXPANDED_STDERR_CHARS)), 0, 0));
   }
 
-  // Sub-call tree
-  if (details.subcalls.length > 0) {
-    container.addChild(new Spacer(1));
-    container.addChild(new Text(theme.fg("muted", "─── Sub-calls ───"), 0, 0));
-    container.addChild(renderExpandedSubcallTree(details.subcalls, theme));
-  }
-
   return container;
 }

package/src/tool/repl-tool.ts

@@ -33,10 +33,12 @@ import type { MemoryStore } from "../core/memory.ts";
 import { BackgroundTasks } from "./background-tasks.ts";
 import type { ReplResult } from "../sandbox/protocol.ts";
 import { RlmEmitter } from "./rlm-events.ts";
+import type { RunRegistry } from "../ui/panel/run-registry.ts";
 import { SubcallStore } from "./subcall-store.ts";
 import type { ReplDetails } from "./repl-details.ts";
 import type { RlmSubcall } from "./rlm-details.ts";
 import { createEngine } from "../core/engine.ts";
+import { modelRef } from "../config/settings.ts";
 import { spinnerFrame } from "../ui/theme.ts";
 import { previewText } from "../text/preview.ts";
 import { errorMessage } from "../util/errors.ts";
@@ -117,6 +119,8 @@ export interface ReplToolDeps {
   readonly resolveGates?: () => SubcallGates;
   /** Session-scoped home for detached spawn() work. */
   readonly background: BackgroundTasks;
+  /** Session tree panel index; omitted → runs don't appear in the widget. */
+  readonly runRegistry?: RunRegistry;
   /** v5 durable memory (session-wide `.rlm` store); omitted → memory off for this tool. */
   readonly memory?: MemoryStore;
   readonly signal?: AbortSignal;
@@ -250,6 +254,20 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
 
       const emitter = new RlmEmitter();
       const store = new SubcallStore(emitter);
+      // Surface the cell in the tree panel for its whole lifetime (unregistered in finally).
+      const unregisterRun = deps.runRegistry?.register({
+        runId: `repl-${_toolCallId}`,
+        label: `repl: ${previewText(params.code, 40)}`,
+        emitter,
+        subcalls: () => store.getSubcalls(),
+        totals: () => store.getTotals(),
+        // Root = the session's default (pi) model driving this repl cell, own spend only.
+        rootModel: () => {
+          const m = getModel();
+          return modelRef(m) ?? m.id;
+        },
+        rootTokens: () => store.getRootUsage().tokens,
+      });
       let capturedStdout = "";
       let capturedStderr = "";
       let progressStatus: ReplDetails["status"] = "running";
@@ -319,23 +337,17 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         }
 
         const start = Date.now();
-        // v5 blackboard (audit C3 / R1): ancestors are the rlm_query/rlm_batch task
-        // strings inside this cell, not the Python soup (`print`, `await_task`). A
-        // child restating the user's goal then echoes. Popped in finally: detached
-        // work spawned by this cell already claimed at spawn time, inside this window.
-        const ledgerActive = getConfig().enableLedger;
-        const ancestorN = ledgerActive ? sessionLedger.beginNativeCell(params.code) : 0;
-        let result: ReplResult;
-        try {
-          result = await sandboxManager.execWithSetup(params.code, () => {
-            // Wire per-invocation mutable state only after the serialized exec slot
-            // is active. Swapping earlier would let queued repl() calls overwrite
-            // emitter/limits for the currently running REPL execution.
-            bridgeState.swap({ emitter, parentId: undefined, depth: 0, limits });
-          }, execSignal);
-        } finally {
-          if (ledgerActive) sessionLedger.endNativeCell(ancestorN);
-        }
+        // v5 blackboard (audit C3 / BUG-1): ancestors are RUNNING engines only — engine.ts
+        // brackets each child run with beginRun/endRun. A native cell pushes NOTHING: its
+        // spawns claim against an empty stack, so an originator can never echo against
+        // itself. Duplicates are caught by the ledger's claim store (exact/near
+        // coalescing + rlmBudget demotion), never by silent suppression.
+        const result: ReplResult = await sandboxManager.execWithSetup(params.code, () => {
+          // Wire per-invocation mutable state only after the serialized exec slot
+          // is active. Swapping earlier would let queued repl() calls overwrite
+          // emitter/limits for the currently running REPL execution.
+          bridgeState.swap({ emitter, parentId: undefined, depth: 0, limits });
+        }, execSignal);
         const elapsed = Date.now() - start;
         capturedStdout = result.stdout;
         capturedStderr = result.stderr;
@@ -427,6 +439,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         };
       } finally {
         progress.stop();
+        unregisterRun?.();
         for (const off of detachTracers) off();
         store.dispose();
         emitter.shutdown();

package/src/tool/rlm-aggregator.ts

@@ -13,16 +13,17 @@
  */
 
 import type { AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
-import type { RlmEmitter, TurnEvent, RootUsageEvent, AnswerEvent, StatusEvent, RootPromptEvent } from "./rlm-events.ts";
-import type { RlmDetails, RlmRunStatus } from "./rlm-details.ts";
+import type { RlmEmitter, TurnEvent, RootUsageEvent, AnswerEvent, StatusEvent, RootPromptEvent, RootPhaseEvent } from "./rlm-events.ts";
+import type { RlmDetails, RlmRunStatus, SubcallPhase } from "./rlm-details.ts";
 import { EmitterListener } from "./emitter-listener.ts";
-import { SubcallStore } from "./subcall-store.ts";
+import { SubcallStore, type SubcallTotals } from "./subcall-store.ts";
 
 export class RlmEventAggregator extends EmitterListener {
   private readonly store: SubcallStore;
 
   // Root-level state
   private rootStatus: RlmRunStatus = "running";
+  private rootPhase?: SubcallPhase;
   private rootPrompt = "";
   private turnCurrent = 0;
   private turnMax = 0;
@@ -41,6 +42,7 @@ export class RlmEventAggregator extends EmitterListener {
       emitter.onAnswer((e) => this.handleAnswer(e)),
       emitter.onStatus((e) => this.handleStatus(e)),
       emitter.onRootPrompt((e) => this.handleRootPrompt(e)),
+      emitter.onRootPhase((e) => this.handleRootPhase(e)),
     ]);
   }
 
@@ -72,12 +74,18 @@ export class RlmEventAggregator extends EmitterListener {
     // No notify — root prompt is set before listeners exist; no TUI re-render needed
   }
 
+  private handleRootPhase(event: RootPhaseEvent): void {
+    this.rootPhase = event.phase;
+    this.notify();
+  }
+
   // ── Read ──
 
   /** Snapshot the current accumulated state. O(1). */
   getState(): RlmDetails {
     return {
       status: this.rootStatus,
+      rootPhase: this.rootPhase,
       rootPrompt: this.rootPrompt,
       turns: { current: this.turnCurrent, max: this.turnMax },
       subcalls: this.store.getSubcalls(),
@@ -86,6 +94,11 @@ export class RlmEventAggregator extends EmitterListener {
     };
   }
 
+  /** Root engine's OWN spend (driver-model turns) — never blends sub-call models. */
+  getRootUsage(): SubcallTotals {
+    return this.store.getRootUsage();
+  }
+
   // ── Lifecycle ──
 
   /** Detach all emitter listeners. Call after the run completes. */

package/src/tool/rlm-details.ts

@@ -8,6 +8,10 @@
 
 export type SubcallKind = "root" | "rlm" | "llm" | "batch" | "tool";
 export type SubcallStatus = "running" | "done" | "error";
+
+/** Live activity of a node while status is "running" — powers the tree/modal UI.
+ *  "queued" = parked on the rate-limit cooldown (util/throttle.ts), not in flight. */
+export type SubcallPhase = "thinking" | "texting" | "repl" | "waiting" | "spawning" | "queued";
 export type RlmRunStatus = "running" | "done" | "error" | "aborted";
 
 export interface RlmSubcall {
@@ -20,6 +24,8 @@ export interface RlmSubcall {
   readonly label: string;
   readonly model?: string;
   readonly status: SubcallStatus;
+  /** Current activity while running (undefined = not reported). */
+  readonly phase?: SubcallPhase;
   readonly detail?: string;
   readonly args?: string;
   readonly resultPreview?: string;
@@ -35,6 +41,8 @@ export interface RlmSubcall {
 
 export interface RlmDetails {
   readonly status: RlmRunStatus;
+  /** Root node's live activity phase (root has no subcall entry). */
+  readonly rootPhase?: SubcallPhase;
   readonly rootPrompt: string;
   readonly turns: { readonly current: number; readonly max: number };
   readonly subcalls: readonly RlmSubcall[];

package/src/tool/rlm-events.ts

@@ -11,7 +11,7 @@
  */
 
 import { EventEmitter } from "node:events";
-import type { SubcallKind, SubcallStatus, RlmRunStatus } from "./rlm-details.ts";
+import type { SubcallKind, SubcallStatus, RlmRunStatus, SubcallPhase } from "./rlm-details.ts";
 
 // ── Event payloads ──
 
@@ -32,6 +32,8 @@ export interface SubcallCreatedEvent {
 export interface SubcallUpdatedEvent {
   readonly id: string;
   readonly status?: SubcallStatus;
+  /** Live activity while running (thinking/repl/waiting…). */
+  readonly phase?: SubcallPhase;
   readonly detail?: string;
   readonly args?: string;
   readonly resultPreview?: string;
@@ -67,6 +69,10 @@ export interface RootPromptEvent {
   readonly text: string;
 }
 
+export interface RootPhaseEvent {
+  readonly phase: SubcallPhase;
+}
+
 // ── RlmEmitter ──
 
 /**
@@ -127,6 +133,11 @@ export class RlmEmitter {
     this.ee.emit("root-prompt", { text } satisfies RootPromptEvent);
   }
 
+  /** Set the root node's live activity phase (root-only; children use subcall updates). */
+  emitRootPhase(phase: SubcallPhase): void {
+    this.ee.emit("root-phase", { phase } satisfies RootPhaseEvent);
+  }
+
   // ── Subscribe (returns unsubscribe function) ──
 
   onSubcallCreated(handler: (event: SubcallCreatedEvent) => void): () => void {
@@ -149,6 +160,11 @@ export class RlmEmitter {
     return () => { this.ee.off("root-usage", handler); };
   }
 
+  onRootPhase(handler: (event: RootPhaseEvent) => void): () => void {
+    this.ee.on("root-phase", handler);
+    return () => { this.ee.off("root-phase", handler); };
+  }
+
   onAnswer(handler: (event: AnswerEvent) => void): () => void {
     this.ee.on("answer", handler);
     return () => { this.ee.off("answer", handler); };

package/src/tool/rlm-tool.ts

@@ -9,19 +9,16 @@ import { type Theme, type ToolDefinition } from "@earendil-works/pi-coding-agent
 import { Container, Markdown, Spacer, Text, type Component } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import type { RlmController, StartInput } from "../mode/rlm-mode.ts";
+import { modelRef } from "../config/settings.ts";
 import { spinnerFrame } from "../ui/theme.ts";
+import type { RunRegistry } from "../ui/panel/run-registry.ts";
 import { markdownTheme } from "../ui/theme-adapter.ts";
 import { previewText } from "../text/preview.ts";
 import { errorMessage } from "../util/errors.ts";
 import { type RlmDetails } from "./rlm-details.ts";
 import { RlmEmitter } from "./rlm-events.ts";
 import { RlmEventAggregator } from "./rlm-aggregator.ts";
-import {
-  cardHeader,
-  cardStatsLine,
-  renderCollapsedCard,
-  renderExpandedSubcallTree,
-} from "./subcall-render.ts";
+import { cardHeader, cardStatsLine, renderCollapsedCard } from "./subcall-render.ts";
 import { createProgressNotifier, validateToolParams } from "./tool-utils.ts";
 
 /** Chars of the prompt shown on the tool call line. */
@@ -43,7 +40,7 @@ function rootStats(details: RlmDetails, theme: Theme): string {
 
 // ── Tool definition ──
 
-export function createRlmTool(controller: RlmController): ToolDefinition<typeof RlmToolParams, RlmDetails> {
+export function createRlmTool(controller: RlmController, runRegistry?: RunRegistry): ToolDefinition<typeof RlmToolParams, RlmDetails> {
   return {
     name: "rlm",
     label: "RLM",
@@ -65,6 +62,25 @@ export function createRlmTool(controller: RlmController): ToolDefinition<typeof
       const aggregator = new RlmEventAggregator(emitter, onUpdate ?? (() => {}));
       emitter.emitRootPrompt(params.prompt);
 
+      // Surface the run in the tree panel for its whole lifetime (unregistered in finally).
+      const unregisterRun = runRegistry?.register({
+        runId: `rlm-${_toolCallId}`,
+        label: previewText(params.prompt, 48),
+        emitter,
+        subcalls: () => aggregator.getState().subcalls,
+        totals: () => aggregator.getState().totals,
+        rootStatus: () => aggregator.getState().status,
+        rootPhase: () => aggregator.getState().rootPhase,
+        turns: () => aggregator.getState().turns,
+        // Reuses controller.resolveModels — the ONE model-resolution path (DRY); lazy so
+        // the pin resolution inside start() is reflected, and it shows own spend only.
+        rootModel: () => {
+          const m = controller.resolveModels(ctx)?.model;
+          return m === undefined ? undefined : modelRef(m) ?? m.id;
+        },
+        rootTokens: () => aggregator.getRootUsage().tokens,
+      });
+
       // Wire abort signal to controller
       if (signal) {
         signal.addEventListener("abort", () => controller.abort(), { once: true });
@@ -102,6 +118,7 @@ export function createRlmTool(controller: RlmController): ToolDefinition<typeof
         };
       } finally {
         progress.stop();
+        unregisterRun?.();
         aggregator.dispose();
         emitter.shutdown();
       }
@@ -134,12 +151,6 @@ function renderExpanded(details: RlmDetails, theme: Theme): Component {
   const container = new Container();
   container.addChild(new Text(cardHeader("RLM", details.status, rootStats(details, theme), theme), 0, 0));
 
-  if (details.subcalls.length > 0) {
-    container.addChild(new Spacer(1));
-    container.addChild(new Text(theme.fg("muted", "─── Sub-calls ───"), 0, 0));
-    container.addChild(renderExpandedSubcallTree(details.subcalls, theme));
-  }
-
   if (details.answer) {
     container.addChild(new Spacer(1));
     container.addChild(new Text(theme.fg("muted", "─── Answer ───"), 0, 0));
@@ -152,5 +163,5 @@ function renderExpanded(details: RlmDetails, theme: Theme): Component {
 // ── Collapsed view ──
 
 function renderCollapsed(details: RlmDetails, theme: Theme): Text {
-  return renderCollapsedCard("RLM", details.status, rootStats(details, theme), details.subcalls, theme);
+  return renderCollapsedCard("RLM", details.status, rootStats(details, theme), theme);
 }