@hicaru/pi-rlm 0.3.8 → 0.3.9

package/src/core/ledger.ts

@@ -139,111 +139,10 @@ export function taskKey(
 }
 
 export const ECHO_STUB: string = Object.freeze(
-  "[ledger echo] this task restates an ancestor goal — the parent run already covers it. " +
-    "Do not spawn a duplicate; answer from what you already know or await the existing task.",
+  "[ledger: ancestor echo rejected. You are already doing this task. " +
+    "Use context / answers / the files already in scope. Do not rlm_query the parent task.]",
 );
 
-const RLM_CALL_OPEN = /\brlm_(?:query|batch)\s*\(/g;
-
-/**
- * Native `repl()` cells are Python, not a task (audit R1). Pull quoted
- * `rlm_query` / `rlm_batch` arguments so `beginRun` has a task-shaped ancestor
- * instead of `print` / `await_task` tokens. Falls back to the raw cell when no
- * such call is present. `paths=` keyword args are not tasks.
- */
-export function nativeRunAncestors(code: string): readonly string[] {
-  const found = extractRlmTaskPrompts(code);
-  return Object.freeze(found.length > 0 ? found : [code]);
-}
-
-function extractRlmTaskPrompts(code: string): readonly string[] {
-  const out: string[] = [];
-  RLM_CALL_OPEN.lastIndex = 0;
-  for (const m of code.matchAll(RLM_CALL_OPEN)) {
-    const start = (m.index ?? 0) + m[0].length;
-    const body = sliceCallBody(code, start);
-    const pathSplit = body.split(/\bpaths\s*=/);
-    const taskPart = pathSplit[0] ?? body;
-    const strings = quotedStrings(taskPart);
-    for (let i = 0; i < strings.length; i++) {
-      const s = strings[i];
-      if (s !== undefined && s.trim() !== "") out.push(s);
-    }
-  }
-  return out;
-}
-
-function sliceCallBody(src: string, start: number): string {
-  let depth = 1;
-  let i = start;
-  while (i < src.length && depth > 0) {
-    const c = src[i];
-    if (c === "'" || c === '"') {
-      i = skipPyString(src, i);
-      continue;
-    }
-    if (c === "#") {
-      const nl = src.indexOf("\n", i);
-      i = nl === -1 ? src.length : nl + 1;
-      continue;
-    }
-    if (c === "(") depth++;
-    else if (c === ")") depth--;
-    i++;
-  }
-  return src.slice(start, depth === 0 ? i - 1 : i);
-}
-
-function quotedStrings(src: string): readonly string[] {
-  const out: string[] = [];
-  let i = 0;
-  while (i < src.length) {
-    const c = src[i];
-    if (c === "'" || c === '"') {
-      const parsed = readPyString(src, i);
-      if (parsed.keep) out.push(parsed.value);
-      i = parsed.end;
-      continue;
-    }
-    i++;
-  }
-  return out;
-}
-
-function skipPyString(src: string, quoteAt: number): number {
-  return readPyString(src, quoteAt).end;
-}
-
-function readPyString(
-  src: string,
-  quoteAt: number,
-): { readonly value: string; readonly end: number; readonly keep: boolean } {
-  const quote = src[quoteAt] ?? '"';
-  const prefix = quoteAt > 0 ? src[quoteAt - 1] : "";
-  const keep = prefix !== "f" && prefix !== "F";
-  const triple = src.startsWith(quote + quote + quote, quoteAt);
-  const delimLen = triple ? 3 : 1;
-  const from = quoteAt + delimLen;
-  if (triple) {
-    const close = src.indexOf(quote + quote + quote, from);
-    if (close === -1) return { value: src.slice(from), end: src.length, keep };
-    return { value: src.slice(from, close), end: close + 3, keep };
-  }
-  const parts: string[] = [];
-  let j = from;
-  while (j < src.length) {
-    const ch = src[j];
-    if (ch === "\\") {
-      parts.push(src[j + 1] ?? "");
-      j += 2;
-      continue;
-    }
-    if (ch === quote) return { value: parts.join(""), end: j + 1, keep };
-    parts.push(ch ?? "");
-    j++;
-  }
-  return { value: parts.join(""), end: src.length, keep };
-}
 
 export class TaskLedger {
   private readonly claims = new Map<string, Claim>();
@@ -252,7 +151,11 @@ export class TaskLedger {
   private readonly hitCounts = { exact: 0, echo: 0, near: 0 };
   private rlmRuns = 0;
 
-  /** Engine marks the active run's root prompt — the ancestor chain for echo detection. */
+  /** Engine marks the active run's root prompt — the ancestor chain for echo detection.
+   *  v5 `begin_run` parity: the ONLY producer. `endRun` pops in the engine's finally, so a
+   *  stack entry exists exactly while that engine is RUNNING — v5's `status in (pending,
+   *  running)` filter is structural here. Native `repl()` cells never push ancestors: their
+   * spawns claim against an empty stack, so an originator can never echo against itself. */
   beginRun(rootPrompt: string): void {
     this.stack.push(normalizePrompt(rootPrompt));
   }
@@ -261,20 +164,6 @@ export class TaskLedger {
     this.stack.pop();
   }
 
-  /** Native `repl()` path (audit R1): push task-shaped ancestors extracted from the cell. */
-  beginNativeCell(code: string): number {
-    const ancestors = nativeRunAncestors(code);
-    for (let i = 0; i < ancestors.length; i++) {
-      const a = ancestors[i];
-      if (a !== undefined) this.beginRun(a);
-    }
-    return ancestors.length;
-  }
-
-  endNativeCell(n: number): void {
-    for (let i = 0; i < n; i++) this.endRun();
-  }
-
   /** A child prompt echoing any ancestor (exact or ≥ 0.8 Jaccard) is rejected as a stub. */
   detectEcho(prompt: string): boolean {
     const np = normalizePrompt(prompt);
@@ -410,11 +299,13 @@ export class TaskLedger {
     return Object.freeze({ ...this.hitCounts });
   }
 
-  /** Compact table for the sandbox's `list_claims()` REPL call. */
+  /** Compact table for the sandbox's `list_claims()` REPL call. Echo hits are appended —
+   *  a suppressed spawn must be visible from inside the session (audit BUG-1). */
   listClaims(): string {
-    if (this.claims.size === 0) return "ledger: no claims";
+    const echoNote = this.hitCounts.echo > 0 ? ` (echo_rejected=${this.hitCounts.echo})` : "";
+    if (this.claims.size === 0) return `ledger: no claims${echoNote}`;
     const lines: string[] = new Array<string>(this.claims.size + 1);
-    lines[0] = "ledger claims:";
+    lines[0] = `ledger claims:${echoNote}`;
     let n = 1;
     for (const c of this.claims.values()) {
       lines[n++] = `  ${c.key.slice(0, 8)} ${c.kind} ${c.status} depth=${c.depth} paths=${pathSig(c.paths) || "-"} '${c.prompt.slice(0, PROMPT_PREVIEW)}'`;
@@ -435,7 +326,8 @@ export class TaskLedger {
     if (inflight.length === 0 && done.length === 0 && stackN <= 1) return "";
     const lines: string[] = [
       "[ledger]",
-      `  depth_stack=${stackN} inflight=${inflight.length} done=${done.length}`,
+      `  depth_stack=${stackN} inflight=${inflight.length} done=${done.length}` +
+        (this.hitCounts.echo > 0 ? ` echo_rejected=${this.hitCounts.echo}` : ""),
       "  rlm_query only for a disjoint goal. ancestor echo is rejected.",
     ];
     if (inflight.length > 0) {

package/src/core/memory.ts

@@ -15,6 +15,7 @@ import { createHash } from "node:crypto";
 import { closeSync, openSync, readSync } from "node:fs";
 import { readFileSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
+import { formatError } from "../util/errors.ts";
 
 const TOK = /[a-z0-9]{2,}/g;
 const EPISODE_CAP = 4_000;
@@ -123,6 +124,10 @@ export function rootContextPaths(context: unknown, max: number): readonly string
   return Object.freeze(out);
 }
 
+/** Who is calling serviceOp — delegation children read durable notes but never write them
+ *  (their findings persist via recordEpisode in the rlm_query handler, one per run). */
+export type MemoryScope = "root" | "child";
+
 export class MemoryStore {
   readonly enabled: boolean;
   private dir: string | undefined;
@@ -462,9 +467,16 @@ export class MemoryStore {
   serviceOp(
     op: "query" | "add" | "stats",
     args: { readonly query?: string; readonly k?: number; readonly content?: string; readonly paths?: readonly string[]; readonly tags?: readonly string[] },
+    scope: MemoryScope = "root",
   ): string {
     if (!this.enabled) return "memory disabled";
     if (op === "stats") return JSON.stringify(this.stats());
+    if (op === "add" && scope === "child") {
+      return formatError(
+        "memory.add is root-only — query durable notes with memory.query; " +
+          "your final answer is recorded as an episode automatically",
+      );
+    }
     if (op === "add") {
       const n = this.addNote({ content: args.content ?? "", paths: args.paths ?? [], tags: args.tags ?? [] });
       return n === undefined ? "add skipped (empty content)" : `ok note ${n.id}`;

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";
@@ -98,6 +102,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 +178,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 +191,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 +208,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) {
@@ -259,6 +298,7 @@ export default function rlmExtension(pi: ExtensionAPI): void {
           gates: resolveSessionGates(),
           resolveGates: resolveSessionGates,
           background,
+          runRegistry,
           memory,
           registerDiscardHook: (reset) => { onSandboxDiscardExtra = reset; },
           registerContextBundle: (bundle) => {
@@ -282,7 +322,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 +335,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/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,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); };