@hicaru/pi-rlm 0.3.6 → 0.3.9

package/src/sandbox/sandbox.ts

@@ -14,6 +14,7 @@ import { fileURLToPath } from "node:url";
 import {
   isInterrupt,
   isWorkerMessage,
+  parsePendingTasks,
   type ParentMessage,
   type ReplResult,
   type WorkerMessage,
@@ -29,6 +30,9 @@ export type { AddContextResult, SubcallOpts, SubLlmHandlers } from "./interrupts
 export interface SandboxOptions {
   /** Sandbox recursion depth label (passed to the worker, used in interrupt routing). */
   readonly depth?: number;
+  /** v5 role separation: "child" sandboxes install the delegation-only scaffold (no
+   *  search/grep_context/outline/add_context — retrieval belongs to the root). */
+  readonly surface?: "root" | "child";
   /** Per-`repl`-block wall-clock timeout inside the worker (seconds). */
   readonly execTimeoutS?: number;
   /** Parent-side watchdog per request (ms); on breach the worker is SIGKILLed. */
@@ -52,6 +56,8 @@ export interface SandboxOptions {
 
 const WORKER_PATH = join(dirname(fileURLToPath(import.meta.url)), "py", "worker.py");
 const STDERR_TAIL_CHARS = 8_192;
+/** How often to refresh the parent request watchdog (and ping the worker) during silent host work. */
+export const SANDBOX_WATCHDOG_HEARTBEAT_MS = 30_000;
 /** How long dispose() waits for a clean worker exit before escalating to SIGKILL. */
 const SHUTDOWN_GRACE_MS = 50;
 
@@ -118,6 +124,7 @@ export class PythonSandbox {
       "-X", "utf8=1",
       "-u", WORKER_PATH,
       "--depth", String(opts.depth ?? 1),
+      "--surface", opts.surface === "child" ? "child" : "root",
       "--timeout", String(opts.execTimeoutS ?? 600),
     ];
     if (opts.maxPromptChars !== undefined) {
@@ -224,6 +231,7 @@ export class PythonSandbox {
       raised: res.raised ?? false,
       executionTimeMs: Math.round((res.execution_time ?? 0) * 1000),
       varNames: res.var_names ?? [],
+      pendingTasks: parsePendingTasks(res.pending_tasks),
     };
   }
 
@@ -312,12 +320,22 @@ export class PythonSandbox {
   }
 
   /**
-   * Refresh the parent-side request watchdog for every pending request.
-   * Used during long mid-exec work that does not
-   * produce additional worker interrupts on this sandbox.
+   * Refresh the parent-side request watchdog and ping the worker.
+   * Used during long mid-exec work that does not produce additional worker
+   * interrupts on this sandbox. The heartbeat rearms the worker's stall alarm
+   * so a healthy long sub-call is not reported as `_StallTimeout`.
    */
   refreshWatchdog(): void {
     this.touchPending();
+    if (this.hasPendingRequest()) this.send({ type: "heartbeat" });
+  }
+
+  /** True when an exec/load_context/shutdown (not the init handshake) is in flight. */
+  private hasPendingRequest(): boolean {
+    for (const id of this.pending.keys()) {
+      if (id !== "_init") return true;
+    }
+    return false;
   }
 
   private send(msg: ParentMessage): void {

package/src/text/repl-output.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared REPL output formatting used by headless history and native repl() tool results.
+ * Lives in text/ so tool/ does not import from core/.
+ */
+
+import { truncateOutput } from "./parsing.ts";
+
+/** Max stderr kept in model-visible REPL output (headless history and native tool_result). */
+export const STDERR_LIMIT = 8_000;
+
+/** Prefix stderr so the model can tell prints from exceptions. Empty when stderr is blank. */
+export function formatReplStderr(stderr: string, limit = STDERR_LIMIT): string {
+  const err = stderr.trim();
+  return err ? `\n[stderr]\n${truncateOutput(err, limit)}` : "";
+}

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-result.ts

@@ -5,7 +5,9 @@
  */
 
 import type { RlmSubcall } from "./rlm-details.ts";
+import type { PendingTaskInfo } from "../sandbox/protocol.ts";
 import { capReplResultText, replDelegationNudge } from "../mode/native-guards.ts";
+import { formatReplStderr } from "../text/repl-output.ts";
 
 /** Model-visible text assembled from a repl() result. */
 export interface ReplResultText {
@@ -30,23 +32,20 @@ export function buildReplResultText(
   subcalls: readonly RlmSubcall[],
   backgroundPending = 0,
   varNames: readonly string[] = [],
+  stderr = "",
+  raised = false,
+  pendingTasks: readonly PendingTaskInfo[] = [],
 ): ReplResultText {
   const answerSubmitted = finalAnswer !== undefined;
-  const noOutput = !answerSubmitted && !stdout;
-  const varsHint = noOutput && varNames.length > 0
-    ? ` — the block ran fine and these REPL vars are defined: ${varNames.join(", ")}. `
-      + "Do NOT re-run it; read them in the next block."
-    : "";
-  const rawText = answerSubmitted
-    ? `ANSWER_SUBMITTED (${finalAnswer.length} chars) — delivered to user. Do not restate it.`
-    : stdout || `(no output)${varsHint}`;
+  const stderrBlock = formatReplStderr(stderr);
+  const rawText = assembleReplBody(stdout, finalAnswer, varNames, stderrBlock, raised);
   // Model-visible text is capped; the caller keeps full stdout in `details` for the TUI.
   const cappedText = capReplResultText(rawText) ?? rawText;
   const delegated = subcalls.some((s) => s.kind === "llm" || s.kind === "batch" || s.kind === "rlm");
-  const nudge = answerSubmitted ? undefined : replDelegationNudge(rawText.length, delegated);
+  const nudge = answerSubmitted || raised ? undefined : replDelegationNudge(rawText.length, delegated);
   const failedBg = subcalls.filter((s) => s.id.startsWith("bg") && s.status === "error").length;
   const pendingLine = backgroundPending > 0
-    ? `\n\n[rlm] ${backgroundPending} background task(s) still running — await_task(tasks) to collect.`
+    ? `\n\n[rlm] ${backgroundPending} background task(s) still running — ${pendingCollectHint(pendingTasks)}.`
     : "";
   const failedLine = failedBg > 0
     ? `\n[rlm] ${failedBg} background sub-call(s) FAILED — their await_task value is an "Error: …" string, not data.`
@@ -54,6 +53,51 @@ export function buildReplResultText(
   return { text: cappedText + (nudge ?? "") + pendingLine + failedLine };
 }
 
+function assembleReplBody(
+  stdout: string,
+  finalAnswer: string | undefined,
+  varNames: readonly string[],
+  stderrBlock: string,
+  raised: boolean,
+): string {
+  if (finalAnswer !== undefined) {
+    return `ANSWER_SUBMITTED (${finalAnswer.length} chars) — delivered to user. Do not restate it.`;
+  }
+  if (raised) {
+    const body = [stdout.trimEnd(), stderrBlock.trimStart()].filter((s) => s.length > 0).join("\n");
+    return body.length > 0 ? body : "(raised — see [stderr])";
+  }
+  const noOutput = !stdout;
+  const varsHint = noOutput && varNames.length > 0
+    ? ` — the block ran fine and these REPL vars are defined: ${varNames.join(", ")}. `
+      + "Do NOT re-run it; read them in the next block."
+    : "";
+  return stdout || `(no output)${varsHint}`;
+}
+
+/** Name the Python handle when we know it; otherwise point at await_task() / list_tasks(). */
+function pendingCollectHint(pendingTasks: readonly PendingTaskInfo[]): string {
+  if (pendingTasks.length === 0) {
+    return "collect with await_task(<Task var>) or await_task(); answers[] is for results AFTER await_task";
+  }
+  const names = new Array<string>(pendingTasks.length);
+  for (let i = 0; i < pendingTasks.length; i++) {
+    const t = pendingTasks[i];
+    const kind = t?.kind ?? "task";
+    const label = t?.label ?? "";
+    names[i] = t?.var ?? `<${kind}${label.length > 0 ? ` ${label}` : ""}>`;
+  }
+  if (pendingTasks.length === 1) {
+    const only = names[0] ?? "";
+    const first = pendingTasks[0];
+    const detail = first !== undefined && first.label.length > 0 ? ` (${first.kind} ${first.label})` : "";
+    return only.startsWith("<")
+      ? `collect with await_task()${detail}; answers[] is for results AFTER await_task`
+      : `collect with await_task(${only})${detail}; answers[] is for results AFTER await_task`;
+  }
+  return `collect with await_task()  (${names.join(", ")}); answers[] is for results AFTER await_task`;
+}
+
 /** Advisory diagnostics derived from a completed invocation's sub-calls. */
 export function collectReplWarnings(subcalls: readonly RlmSubcall[]): readonly string[] | undefined {
   let failed = 0;

package/src/tool/repl-tool.ts

@@ -28,13 +28,17 @@ import type { RlmConfig, RlmInput, RlmResult } from "../core/types.ts";
 import { SandboxManager } from "../sandbox/sandbox-manager.ts";
 import type { SubcallOpts } from "../sandbox/sandbox.ts";
 import { createSubcallHandlers, type Invocation } from "../bridge/handlers/index.ts";
+import { TaskLedger } from "../core/ledger.ts";
+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";
@@ -110,8 +114,15 @@ export interface ReplToolDeps {
   readonly getConfig: () => RlmConfig;
   /** Session-wide sub-call admission, shared with every child engine this tool spawns. */
   readonly gates: SubcallGates;
+  /** v5: live re-resolution of the session gates (provider caps change via /rlm-config without
+   *  a restart). Falls back to `gates` when omitted. Read lazily per sub-call. */
+  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;
   readonly onUsage?: (usage: Usage, role: "sub") => void;
   readonly ensureContext?: () => Promise<void>;
@@ -127,12 +138,17 @@ export interface ReplToolDeps {
 export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplToolParams, ReplDetails> {
   const { sandboxManager, llmModel, registry, getConfig, signal, onUsage, background } = deps;
   const bridgeState = new NativeBridgeState(background);
+  // v5: one session-wide blackboard for the native repl() path — the same claim/coalesce/
+  // demote logic the engine gets per run, shared by every turn and every child it spawns.
+  const sessionLedger = new TaskLedger();
 
   // Late-bound cwd — getOrCreate installs handlers only at spawn; never rebuild the closure.
   let sessionCwd = process.cwd();
 
   const getLlmModel = (): Model<Api> => deps.getLlmModel?.() ?? llmModel;
   const getModel = (): Model<Api> => deps.getModel?.() ?? deps.model;
+  // v5 (audit C6): resolve lazily per call so provider-cap edits via /rlm-config apply live.
+  const currentGates = (): SubcallGates => deps.resolveGates?.() ?? deps.gates;
 
   // Each rlm_query spawns a child RLM with its own sandbox and turn loop, not a flat
   // one-shot llm_query. The engine is created per call so the child's subcalls, turn
@@ -143,7 +159,8 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
     registry,
     config: getConfig(),
     signal,
-    gates: deps.gates,
+    memory: deps.memory,
+    gates: currentGates(),
     // Same emitter the parent subcall node lives on — see SubcallHandlerDeps.runChild.
     emitter: inv.emitter,
     // Everything a child engine spends is sub-work from this tool's perspective, including
@@ -156,7 +173,10 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
   // per-invocation is reached through bridgeState.resolve, not captured here.
   const subcallHandlers = createSubcallHandlers({
     resolve: (opts) => bridgeState.resolve(opts),
-    gates: deps.gates,
+    // Getter, not a captured value: sub-call deps read gates lazily per call.
+    get gates(): SubcallGates {
+      return currentGates();
+    },
     registry,
     getLlmModel,
     getModel,
@@ -168,6 +188,8 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
     // earlier repl() reaches a child spawned in a later one. Populated before any interrupt can
     // fire: execute() awaits ensureContext() before getOrCreate().
     getChildContext: () => sandboxManager.contextPayload ?? undefined,
+    ledger: sessionLedger,
+    memory: deps.memory,
     trackDetached: (task) => background.track(task),
   });
 
@@ -213,7 +235,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
       "repl: free search/outline; fire rlm_batch|map_files|llm_batch as Task (BG); await_task for results.",
     promptGuidelines: [
       "Multi-area analysis: rlm_batch([...]) or map_files(paths, q); free search; await_task — not serial native read.",
-      "Always-spawn tools return Task; only await_task has content. Fire-all independent work before await.",
+      "Always-spawn tools return Task; only await_task has content. Fire-all then await; await_task() collects every still-running Task.",
       "llm_query/llm_batch have no disk — never 'Read path/to/file.ts'; use map_files or rlm_* (see context).",
     ],
     parameters: ReplToolParams,
@@ -232,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";
@@ -283,6 +319,8 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         await sandboxManager.getOrCreate({
           ...subcallHandlers,
           ...(contextBundle?.handlers ?? {}),
+          ledgerClaims: () => Promise.resolve(sessionLedger.listClaims()),
+          memoryOp: (op, args) => Promise.resolve(deps.memory?.serviceOp(op, args) ?? "memory off"),
         });
 
         // Detect queue contention AFTER sandbox init (initPromise settled, isExecuting now accurate)
@@ -299,6 +337,11 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         }
 
         const start = Date.now();
+        // 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
@@ -349,6 +392,9 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           subcalls,
           background.pending,
           result.varNames,
+          result.stderr,
+          result.raised,
+          result.pendingTasks,
         );
 
         const details: ReplDetails = {
@@ -393,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,9 @@
 
 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. */
+export type SubcallPhase = "thinking" | "texting" | "repl" | "waiting" | "spawning";
 export type RlmRunStatus = "running" | "done" | "error" | "aborted";
 
 export interface RlmSubcall {
@@ -20,6 +23,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 +40,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);
 }