@hicaru/pi-rlm 0.2.0 → 0.2.2

package/src/tool/repl-tool.ts

@@ -6,27 +6,29 @@
  * and collects sub-calls manually from emitter events. No RlmEventAggregator is used
  * (ReplDetails ≠ RlmDetails structural mismatch).
  *
- * Sandbox handlers (llm_query, rlm_query, todo, ask_user_question) are the *shared* bridges
- * from bridge/llm-query.ts and bridge/rlm-query.ts, bound to NativeBridgeState accessors so
- * the tool can swap per-invocation state (emitter, depth, limits) without recreating the
- * sandbox — preserving REPL variable state across calls.
+ * Sub-call handling itself lives in bridge/subcall-handlers.ts; this file only supplies the
+ * per-invocation Invocation those handlers resolve against, swapping it inside the
+ * serialized exec slot so a queued repl() cannot claim the running one's emitter.
+ *
+ * Work started with `spawn()` may still be running when the call returns, so it resolves to
+ * the session-scoped BackgroundTasks registry instead and is drained back into whichever
+ * turn is reporting next.
  */
 
 import { Type } from "typebox";
-import type { Theme, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
 import type { Model, Usage, Api } from "@earendil-works/pi-ai";
 import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
-import { displayModelRef } from "../config/settings.ts";
-import { buildInteractiveHandlers } from "../bridge/interactive.ts";
 import { buildLibraryHandler } from "../bridge/library.ts";
-import { createPiInteractiveDeps } from "../bridge/pi-interactive.ts";
-import { createLlmBridge } from "../bridge/llm-query.ts";
-import { createRlmHandlers } from "../bridge/rlm-query.ts";
+import { libraryPrefixesIn } from "../context/library-context.ts";
+import type { SubcallGates } from "../util/concurrency.ts";
 import { LimitGuard, limitsFromConfig } from "../core/limits.ts";
-import type { RemainingResources } from "../core/resource-limits.ts";
-import type { InteractiveDeps, RlmConfig, RunRlm } from "../core/types.ts";
+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/subcall-handlers.ts";
+import { BackgroundTasks } from "./background-tasks.ts";
 import type { ReplResult } from "../sandbox/protocol.ts";
 import { RlmEmitter } from "./rlm-events.ts";
 import { SubcallStore } from "./subcall-store.ts";
@@ -36,19 +38,23 @@ import { createEngine } from "../core/engine.ts";
 import { spinnerFrame } from "../ui/theme.ts";
 import { previewText } from "../text/preview.ts";
 import { errorMessage } from "../util/errors.ts";
-import {
-  cardHeader,
-  cardStatsLine,
-  renderCollapsedCard,
-  renderExpandedSubcallTree,
-} from "./subcall-render.ts";
 import { createProgressNotifier, validateToolParams } from "./tool-utils.ts";
-import { capReplResultText, replDelegationNudge } from "../mode/native-guards.ts";
+import { buildReplResultText, collectReplWarnings } from "./repl-result.ts";
+import { renderReplCollapsed, renderReplExpanded } from "./repl-render.ts";
+import { attachTracer, trace, traceEnabled } from "../util/trace.ts";
 
-/** Chars of code shown on the tool call line, and of stdout in the expanded view. */
+/** Chars of code shown on the tool call line. */
 const CALL_PREVIEW_CHARS = 80;
-const EXPANDED_STDOUT_CHARS = 2_000;
-const EXPANDED_STDERR_CHARS = 500;
+
+/** Last non-empty line of a Python traceback — the `TypeError: …` line, not the frames. */
+function lastLine(text: string): string {
+  const lines = text.trimEnd().split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]?.trim();
+    if (line) return line.slice(0, 200);
+  }
+  return "";
+}
 
 // ── Parameter schema ──
 
@@ -56,87 +62,56 @@ export const ReplToolParams = Object.freeze(Type.Object({
   code: Type.String({ description: "Python code to execute in the persistent REPL sandbox" }),
 }));
 
-/** Model-visible text assembled from a repl() result. */
-export interface ReplResultText {
-  readonly text: string;
-}
+// ── Mutable bridge state (handler indirection) ──
 
 /**
- * Assemble the model-visible text for a repl() result: cap stdout and append a
- * zero-subcall delegation nudge when a bulk read went undelegated.
+ * Holds per-invocation state that the sandbox handlers resolve against.
+ *
+ * The sandbox is created once, so the tool swaps the current Invocation between repl()
+ * calls rather than rebuilding handlers (which would lose REPL variable state). Handlers
+ * capture the Invocation synchronously at interrupt entry and never re-read it — with
+ * spawn() a sub-call can outlive its exec, and a later read would attribute it to whichever
+ * turn happened to be current when it settled.
+ *
+ * Detached work resolves to the session-scoped background Invocation instead, whose emitter
+ * and LimitGuard are not torn down at the end of a turn.
  */
-export function buildReplResultText(
-  stdout: string,
-  finalAnswer: string | undefined,
-  subcalls: readonly RlmSubcall[],
-): ReplResultText {
-  const answerSubmitted = finalAnswer !== undefined;
-  const rawText = answerSubmitted
-    ? `ANSWER_SUBMITTED (${finalAnswer.length} chars) — delivered to user. Do not restate it.`
-    : stdout || "(no output)";
-  // 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);
-  return { text: cappedText + (nudge ?? "") };
-}
+class NativeBridgeState {
+  private current: Invocation | null = null;
 
-/** Advisory diagnostics derived from a completed invocation's sub-calls. */
-export function collectReplWarnings(subcalls: readonly RlmSubcall[]): readonly string[] | undefined {
-  let failed = 0;
-  let total = 0;
-  for (let i = 0; i < subcalls.length; i++) {
-    const call = subcalls[i];
-    if (call.status !== "error") continue;
-    // A batch subcall stands for many prompts; a single call stands for one.
-    failed += call.failedCount ?? 1;
-    total += call.totalCount ?? 1;
-  }
-  if (failed === 0) return undefined;
-  return Object.freeze([`${failed}/${total} sub-call(s) failed — results may be incomplete`]);
-}
+  constructor(private readonly background: BackgroundTasks) {}
 
-// ── Mutable bridge state (handler indirection) ──
+  swap(inv: Invocation): void {
+    this.current = Object.freeze({ ...inv });
+  }
 
-/**
- * Holds per-invocation mutable state that the shared bridges dereference through accessors.
- * The sandbox is created once with handlers bound to this object, so the tool can swap
- * emitter/depth/limits between calls without recreating the sandbox (preserving REPL state).
- */
-class NativeBridgeState {
-  currentEmitter: RlmEmitter | null = null;
-  currentParentId: string | undefined;
-  currentDepth = 0;
-  currentLimits: LimitGuard | null = null;
-  currentInteractive: InteractiveDeps | null = null;
-
-  swap(inv: { emitter: RlmEmitter; parentId?: string; depth: number; limits: LimitGuard; interactive: InteractiveDeps }): void {
-    this.currentEmitter = inv.emitter;
-    this.currentParentId = inv.parentId;
-    this.currentDepth = inv.depth;
-    this.currentLimits = inv.limits;
-    this.currentInteractive = inv.interactive;
+  /** Detached ⇒ session registry; otherwise the turn that is currently executing. */
+  resolve(opts: SubcallOpts): Invocation | null {
+    return opts.detached ? this.background.invocation : this.current;
   }
 
-  /** Remaining budget/timeout of the invocation that currently owns the exec slot. */
-  remainingBudget(): RemainingResources | undefined {
-    const limits = this.currentLimits;
-    if (!limits) return undefined;
-    return { budgetUsd: limits.remainingBudgetUsd(), timeoutMs: limits.remainingTimeoutMs() };
+  /** The turn emitter, for library-load reporting. Null between repl() calls. */
+  get currentEmitter(): RlmEmitter | null {
+    return this.current?.emitter ?? null;
   }
 }
 
+
 // ── Tool factory ──
 
 export interface ReplToolDeps {
   readonly sandboxManager: SandboxManager;
   readonly model: Model<Api>;
-  readonly workerModel: Model<Api>;
+  readonly llmModel: Model<Api>;
   readonly getModel?: () => Model<Api> | undefined;
-  readonly getWorkerModel?: () => Model<Api> | undefined;
+  readonly getLlmModel?: () => Model<Api> | undefined;
   readonly registry: ModelRegistry;
   /** Live accessor — `/rlm-config` replaces the config object, so never capture the value. */
   readonly getConfig: () => RlmConfig;
+  /** Session-wide sub-call admission, shared with every child engine this tool spawns. */
+  readonly gates: SubcallGates;
+  /** Session-scoped home for detached spawn() work. */
+  readonly background: BackgroundTasks;
   readonly signal?: AbortSignal;
   readonly onUsage?: (usage: Usage, role: "sub") => void;
   readonly ensureContext?: () => Promise<void>;
@@ -145,73 +120,72 @@ export interface ReplToolDeps {
 }
 
 export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplToolParams, ReplDetails> {
-  const { sandboxManager, workerModel, registry, getConfig, signal, onUsage } = deps;
-  const bridgeState = new NativeBridgeState();
+  const { sandboxManager, llmModel, registry, getConfig, signal, onUsage, background } = deps;
+  const bridgeState = new NativeBridgeState(background);
 
   // Late-bound cwd — getOrCreate installs handlers only at spawn; never rebuild the closure.
   let sessionCwd = process.cwd();
 
-  const rootModel = (): Model<Api> => deps.getModel?.() ?? deps.model;
+  const getLlmModel = (): Model<Api> => deps.getLlmModel?.() ?? llmModel;
+  const getModel = (): Model<Api> => deps.getModel?.() ?? deps.model;
 
-  // Build handlers once — llm/rlm/library read late-bound state so the same closures stay
-  // correct across repl() calls; counters reset when the sandbox is discarded and re-spawned.
-  const llmHandlers = createLlmBridge({
-    workerModel: () => deps.getWorkerModel?.() ?? workerModel,
+  // 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
+  // progress and cost deltas land on the emitter the parent invocation is using.
+  const runChild = (input: RlmInput, inv: Invocation): Promise<RlmResult> => createEngine({
+    model: getModel(),
+    llmModel: getLlmModel(),
     registry,
-    config: getConfig,
+    config: getConfig(),
     signal,
-    onUsage: (usage) => { bridgeState.currentLimits?.addUsage(usage); },
-    remainingBudget: () => bridgeState.remainingBudget(),
-    emitter: () => bridgeState.currentEmitter ?? undefined,
-    parentId: () => bridgeState.currentParentId,
-    depth: () => bridgeState.currentDepth,
-  });
-
-  // Real recursive rlm_query — each call spawns a child RLM with its own sandbox and turn
-  // loop, bound to the *current* invocation's emitter so child sub-calls, turn progress, and
-  // cost deltas land on the live visual tree.
-  const runChildRlm: RunRlm = (input) => {
-    const emitter = bridgeState.currentEmitter;
-    // Only reachable while an invocation owns the exec slot, which always swaps in an emitter.
-    if (!emitter) throw new Error("RLM bridge not wired for this invocation");
-    const config = getConfig();
-    return createEngine({
-      model: rootModel(),
-      workerModel: deps.getWorkerModel?.() ?? workerModel,
-      registry,
-      config,
-      signal,
-      emitter,
-      onUsage: onUsage === undefined ? undefined : (usage, role) => { if (role === "sub") onUsage(usage, role); },
-      limits: limitsFromConfig(config),
-      onTodo: bridgeState.currentInteractive?.onTodo,
-      onAskUserQuestion: bridgeState.currentInteractive?.onAskUserQuestion,
-    })(input);
-  };
-
-  const rlmHandlers = createRlmHandlers({
-    run: runChildRlm,
-    llm: llmHandlers,
-    config: getConfig,
-    modelLabel: (override) => displayModelRef(registry, override, rootModel()),
-    emitter: () => bridgeState.currentEmitter ?? undefined,
-    parentNodeId: () => bridgeState.currentParentId,
-    remainingBudget: () => bridgeState.remainingBudget(),
-    onChildUsage: (costUsd, inputTokens, outputTokens) => {
-      bridgeState.currentLimits?.addRaw(costUsd, inputTokens, outputTokens);
-    },
+    gates: deps.gates,
+    // 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
+    // the child's own root turns — so fold both roles into "sub" rather than casting.
+    onUsage: onUsage === undefined ? undefined : (usage: Usage) => onUsage(usage, "sub"),
+    limits: limitsFromConfig(getConfig()),
+  })(input);
+
+  // Built once: the same closures stay correct across repl() calls because everything
+  // per-invocation is reached through bridgeState.resolve, not captured here.
+  const subcallHandlers = createSubcallHandlers({
+    resolve: (opts) => bridgeState.resolve(opts),
+    gates: deps.gates,
+    registry,
+    getLlmModel,
+    getModel,
+    getConfig,
+    signal,
+    onUsage,
+    runChild,
+    // The session sandbox's context is the child's world. Read lazily so a load_library from an
+    // 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,
+    trackDetached: (task) => background.track(task),
   });
 
   const libraryBundle = getConfig().libraryLoader
     ? buildLibraryHandler({
         getCwd: () => sessionCwd,
         getEmitter: () => bridgeState.currentEmitter,
+        // Refuse pre-flight whatever the worker would reject, so host idempotency is never
+        // committed for an append that did not happen.
+        getContext: () => sandboxManager.contextPayload,
         parentId: undefined,
         signal,
-        startIndex: 1,
+        // Keep the manager's replay copy in step with the worker's live `context`, and with it
+        // whatever a child spawned after this load will inherit.
+        onLoaded: (payload) => { sandboxManager.appendLibrary(payload); },
       })
     : undefined;
-  if (libraryBundle) deps.registerDiscardHook?.(libraryBundle.reset);
+  if (libraryBundle) {
+    // Re-derive the loaded-prefix cache from the payload that will actually be replayed —
+    // clearing it outright would make the host re-clone a library the recreated worker already has.
+    const bundle = libraryBundle;
+    deps.registerDiscardHook?.(() => bundle.reset(libraryPrefixesIn(sandboxManager.contextPayload)));
+  }
 
   return {
     name: "repl",
@@ -223,7 +197,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
       "semantic reading to map_files / llm_query / llm_query_batched / llm_query_chunked " +
       "(rlm_query for iterative sub-tasks) — stdout returned to you is hard-capped at 4K chars, " +
       "so printing file bodies is useless. Variables, imports, and the `answers`/`plan` memo " +
-      "persist across calls. Also supports todo, ask_user_question, and load_library.",
+      "persist across calls. Also supports load_library.",
     promptSnippet:
       "repl: run Python in a persistent sandbox holding the whole repository in `context`; " +
       "search/grep_context/outline to locate, map_files/llm_query* to read.",
@@ -233,7 +207,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
     ],
     parameters: ReplToolParams,
 
-    async execute(_toolCallId, rawParams, _execSignal, onUpdate, ctx) {
+    async execute(_toolCallId, rawParams, execSignal, onUpdate, ctx) {
       const validation = validateToolParams(ReplToolParams, rawParams, "REPL", (errors): ReplDetails => ({
         status: "error",
         output: "",
@@ -253,17 +227,29 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
       const startedAt = Date.now();
       const limits = new LimitGuard(limitsFromConfig(getConfig()));
 
+      const detachTracers = traceEnabled
+        ? [attachTracer(emitter, "turn"), attachTracer(background.emitter, "background")]
+        : [];
+
       // ── Progressive rendering: spinner + live sub-call tree ──
       const progress = createProgressNotifier<ReplDetails>({
         onUpdate,
-        getDetails: () => ({
-          status: progressStatus,
-          output: capturedStdout,
-          stderr: capturedStderr,
-          executionTimeMs: Date.now() - startedAt,
-          subcalls: store.getSubcalls(),
-          totals: store.getTotals(),
-        }),
+        getDetails: () => {
+          // Detached spawn() nodes live on the SESSION emitter, so without this merge the card
+          // stays empty for the entire time background work is running.
+          const live = background.liveSubcalls();
+          const bg = background.liveTotals();
+          const own = store.getTotals();
+          return {
+            status: progressStatus,
+            output: capturedStdout,
+            stderr: capturedStderr,
+            executionTimeMs: Date.now() - startedAt,
+            subcalls: live.length > 0 ? [...store.getSubcalls(), ...live] : store.getSubcalls(),
+            totals: { costUsd: own.costUsd + bg.costUsd, tokens: own.tokens + bg.tokens },
+            backgroundPending: background.pending > 0 ? background.pending : undefined,
+          };
+        },
         isRunning: (details) => details.status === "running",
         renderText: (details) => details.output.slice(0, 500) || (details.status === "running" ? `${spinnerFrame()} Running…` : "(no output)"),
       });
@@ -280,25 +266,11 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
       }
 
       try {
-        // Build interactive handlers (session-stable callbacks)
-        const interactive = createPiInteractiveDeps(ctx);
-        const interactiveHandlers = buildInteractiveHandlers({
-          onAskUserQuestion: getConfig().askUserQuestion ? interactive.onAskUserQuestion : undefined,
-          onTodo: interactive.onTodo,
-          onTodoRow: undefined,
-          emitter,
-          depth: 0,
-          parentId: undefined,
-        });
-
         sessionCwd = ctx.cwd ?? process.cwd();
 
         await deps.ensureContext?.();
         await sandboxManager.getOrCreate({
-          ...llmHandlers,
-          ...rlmHandlers,
-          askUserQuestion: interactiveHandlers.askUserQuestion,
-          todo: interactiveHandlers.todo,
+          ...subcallHandlers,
           ...(libraryBundle?.handlers ?? {}),
         });
 
@@ -311,19 +283,46 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           });
         }
 
+        if (traceEnabled) {
+          trace("repl.exec.start", { chars: params.code.length, code: params.code.slice(0, 400) });
+        }
+
         const start = Date.now();
         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, interactive });
-        });
+          bridgeState.swap({ emitter, parentId: undefined, depth: 0, limits });
+        }, execSignal);
         const elapsed = Date.now() - start;
         capturedStdout = result.stdout;
         capturedStderr = result.stderr;
         progressStatus = "done";
 
-        const totals = store.getTotals();
+        if (traceEnabled) {
+          trace("repl.exec.end", {
+            ms: elapsed,
+            stdout: result.stdout.length,
+            raised: result.raised,
+            pending: background.pending,
+            // A block that raised delegated nothing; without the exception the trace shows a
+            // silent turn and the reason is only in the TUI card.
+            error: result.raised ? lastLine(result.stderr) : undefined,
+          });
+        }
+
+        // Adopt every background subtree that has settled, whether or not this turn awaited
+        // it — otherwise a spawn the model never collects would never reach the user's cost
+        // totals. IDs are "bg"-prefixed, so they cannot collide with this turn's.
+        // (drain() removes what it hands over, so live view + accounted view never double-count.)
+        const adopted = background.drain();
+        const subcalls: readonly RlmSubcall[] = adopted.subcalls.length > 0
+          ? [...store.getSubcalls(), ...adopted.subcalls]
+          : store.getSubcalls();
+        const totals = {
+          costUsd: store.getTotals().costUsd + adopted.totals.costUsd,
+          tokens: store.getTotals().tokens + adopted.totals.tokens,
+        };
         const subUsage: Usage = {
           input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: totals.tokens,
           cost: { total: totals.costUsd, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
@@ -336,7 +335,9 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         const { text: resultText } = buildReplResultText(
           result.stdout,
           finalAnswer,
-          store.getSubcalls(),
+          subcalls,
+          background.pending,
+          result.varNames,
         );
 
         const details: ReplDetails = {
@@ -344,10 +345,11 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           output: result.stdout,
           stderr: result.stderr,
           executionTimeMs: elapsed,
-          subcalls: store.getSubcalls(),
-          totals: store.getTotals(),
+          subcalls,
+          totals,
           finalAnswer,
-          warnings: collectReplWarnings(store.getSubcalls()),
+          backgroundPending: background.pending > 0 ? background.pending : undefined,
+          warnings: collectReplWarnings(subcalls),
         };
         const progressText = finalAnswer !== undefined
           ? `ANSWER_SUBMITTED (${finalAnswer.length} chars)`
@@ -358,13 +360,20 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
       } catch (e) {
         progressStatus = "error";
         const msg = errorMessage(e);
+        // Drain here too: a failing turn must not swallow the cost of background work that
+        // settled during it, or a run that keeps erroring would never report any of it.
+        const adopted = background.drain();
         const details: ReplDetails = {
           status: "error",
           output: "",
           stderr: msg,
           executionTimeMs: 0,
-          subcalls: store.getSubcalls(),
-          totals: store.getTotals(),
+          subcalls: [...store.getSubcalls(), ...adopted.subcalls],
+          totals: {
+            costUsd: store.getTotals().costUsd + adopted.totals.costUsd,
+            tokens: store.getTotals().tokens + adopted.totals.tokens,
+          },
+          backgroundPending: background.pending > 0 ? background.pending : undefined,
         };
         onUpdate?.({ content: [{ type: "text", text: `REPL error: ${msg}` }], details });
         return {
@@ -373,6 +382,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         };
       } finally {
         progress.stop();
+        for (const off of detachTracers) off();
         store.dispose();
         emitter.shutdown();
       }
@@ -396,51 +406,3 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
     },
   };
 }
-
-// ── Collapsed view ──
-
-function replStats(details: ReplDetails, theme: Theme): string {
-  const elapsed = details.executionTimeMs > 0 ? `${details.executionTimeMs}ms` : undefined;
-  return cardStatsLine(details.totals, theme, elapsed);
-}
-
-function renderReplCollapsed(details: ReplDetails, theme: Theme): Text {
-  return renderCollapsedCard("REPL", details.status, replStats(details, theme), details.subcalls, theme);
-}
-
-// ── Expanded view ──
-
-function renderReplExpanded(details: ReplDetails, theme: Theme): Container {
-  const container = new Container();
-
-  container.addChild(new Text(cardHeader("REPL", details.status, replStats(details, theme), theme), 0, 0));
-
-  // Output
-  if (details.output) {
-    container.addChild(new Spacer(1));
-    const out = details.output.length > EXPANDED_STDOUT_CHARS
-      ? `${details.output.slice(0, EXPANDED_STDOUT_CHARS)}…`
-      : details.output;
-    container.addChild(new Text(out, 0, 0));
-  }
-
-  if (details.warnings && details.warnings.length > 0) {
-    container.addChild(new Spacer(1));
-    container.addChild(new Text(theme.fg("muted", details.warnings.join("\n")), 0, 0));
-  }
-
-  // Stderr
-  if (details.stderr) {
-    container.addChild(new Spacer(1));
-    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/rlm-aggregator.ts

@@ -6,14 +6,14 @@
  * getState(): RlmDetails for direct access (spinner loop, final return).
  *
  * Subcall storage and totals are delegated to SubcallStore. Root-level state
- * (status, prompt, turns, answer, warnings) is kept in the aggregator.
+ * (status, prompt, turns, answer) is kept in the aggregator.
  *
  * Replaces RlmToolBridge's internal state accumulation. The emitter is pure
  * dispatch; the aggregator is pure state. Separated for independent testing.
  */
 
 import type { AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
-import type { RlmEmitter, TurnEvent, RootUsageEvent, AnswerEvent, StatusEvent, RootPromptEvent, WarningsEvent } from "./rlm-events.ts";
+import type { RlmEmitter, TurnEvent, RootUsageEvent, AnswerEvent, StatusEvent, RootPromptEvent } from "./rlm-events.ts";
 import type { RlmDetails, RlmRunStatus } from "./rlm-details.ts";
 import { EmitterListener } from "./emitter-listener.ts";
 import { SubcallStore } from "./subcall-store.ts";
@@ -27,7 +27,6 @@ export class RlmEventAggregator extends EmitterListener {
   private turnCurrent = 0;
   private turnMax = 0;
   private answer?: string;
-  private warnings?: readonly string[];
 
   constructor(
     emitter: RlmEmitter,
@@ -40,7 +39,6 @@ export class RlmEventAggregator extends EmitterListener {
       emitter.onTurn((e) => this.handleTurn(e)),
       emitter.onRootUsage((e) => this.handleRootUsage(e)),
       emitter.onAnswer((e) => this.handleAnswer(e)),
-      emitter.onWarnings((e) => this.handleWarnings(e)),
       emitter.onStatus((e) => this.handleStatus(e)),
       emitter.onRootPrompt((e) => this.handleRootPrompt(e)),
     ]);
@@ -64,11 +62,6 @@ export class RlmEventAggregator extends EmitterListener {
     this.notify();
   }
 
-  private handleWarnings(event: WarningsEvent): void {
-    this.warnings = event.warnings;
-    this.notify();
-  }
-
   private handleStatus(event: StatusEvent): void {
     this.rootStatus = event.status;
     this.notify();
@@ -90,7 +83,6 @@ export class RlmEventAggregator extends EmitterListener {
       subcalls: this.store.getSubcalls(),
       totals: this.store.getTotals(),
       answer: this.answer,
-      warnings: this.warnings,
     };
   }
 

package/src/tool/rlm-details.ts

@@ -40,7 +40,5 @@ export interface RlmDetails {
   readonly subcalls: readonly RlmSubcall[];
   readonly totals: { readonly costUsd: number; readonly tokens: number };
   readonly answer?: string;
-  /** Advisory diagnostics — surfaced to the user, never a failure. */
-  readonly warnings?: readonly string[];
 }