@hicaru/pi-rlm 0.2.0 → 0.2.1

package/src/tool/background-tasks.ts

@@ -0,0 +1,95 @@
+/**
+ * Session-scoped home for detached `spawn()` work in native repl() mode.
+ *
+ * A spawned sub-call may settle after the repl() call that started it has returned, when
+ * that turn's RlmEmitter has been shut down and its LimitGuard discarded. Both live here for
+ * the whole session instead. The turn that awaits a task — or simply the next turn to run —
+ * adopts its settled subtree into its own ReplDetails, so background spend is reported even
+ * when the model never collects the result.
+ *
+ * The headless engine needs none of this: its emitter and guard already outlive every
+ * sub-call it services (see core/engine.ts).
+ */
+
+import { RlmEmitter } from "./rlm-events.ts";
+import { SubcallStore, type SubcallTotals } from "./subcall-store.ts";
+import type { RlmSubcall } from "./rlm-details.ts";
+import { LimitGuard, type Limits } from "../core/limits.ts";
+import type { Invocation } from "../bridge/subcall-handlers.ts";
+import { trace, traceEnabled } from "../util/trace.ts";
+
+/** What a drain hands to the turn that is reporting it. */
+export interface BackgroundDrain {
+  readonly subcalls: readonly RlmSubcall[];
+  readonly totals: SubcallTotals;
+}
+
+export class BackgroundTasks {
+  /** "bg" prefix so these IDs can never collide with a turn emitter's `s1, s2, …`. */
+  private readonly _emitter = new RlmEmitter("bg");
+  private readonly store = new SubcallStore(this._emitter);
+  private readonly limits: LimitGuard;
+  private active = 0;
+
+  constructor(limits: Limits) {
+    this.limits = new LimitGuard(limits);
+  }
+
+  /** Read-only access for the progressive tracer (scope "background"). */
+  get emitter(): RlmEmitter {
+    return this._emitter;
+  }
+
+  /** The Invocation detached sub-calls resolve to. Stable for the session. */
+  get invocation(): Invocation {
+    return {
+      emitter: this._emitter,
+      parentId: undefined,
+      depth: 0,
+      limits: this.limits,
+    };
+  }
+
+  /** Detached sub-calls still in flight. The single pending counter for the session. */
+  get pending(): number {
+    return this.active;
+  }
+
+  /** Live snapshot of detached sub-calls, settled or not — progressive rendering only. */
+  liveSubcalls(): readonly RlmSubcall[] {
+    return this.store.getSubcalls();
+  }
+
+  /** Live totals for that same snapshot. Accounting still flows through `drain()`. */
+  liveTotals(): SubcallTotals {
+    return this.store.getTotals();
+  }
+
+  /** Count `run` as in-flight detached work for its duration. */
+  async track<T>(run: () => Promise<T>): Promise<T> {
+    this.active += 1;
+    const startedAt = Date.now();
+    if (traceEnabled) trace("bg.start", { pending: this.active });
+    try {
+      return await run();
+    } finally {
+      this.active -= 1;
+      if (traceEnabled) trace("bg.settle", { pending: this.active, durationMs: Date.now() - startedAt });
+    }
+  }
+
+  /**
+   * Hand over every fully-settled subtree and forget it.
+   *
+   * Called at the end of every repl() call, not only when a task was awaited, so a spawn
+   * the model never collects still reaches the user's cost totals.
+   */
+  drain(): BackgroundDrain {
+    return this.store.takeSettledSubtrees();
+  }
+
+  dispose(): void {
+    this.store.dispose();
+    this._emitter.shutdown();
+  }
+}

package/src/tool/repl-details.ts

@@ -22,6 +22,8 @@ export interface ReplDetails {
   readonly totals: { readonly costUsd: number; readonly tokens: number };
   /** Final answer submitted through answer["ready"] without echoing it to the model. */
   readonly finalAnswer?: string;
+  /** Detached spawn() sub-calls still running when this call returned. Absent when none. */
+  readonly backgroundPending?: number;
   /** Advisory diagnostics — surfaced to the user, never a failure. */
   readonly warnings?: readonly string[];
 }

package/src/tool/repl-tool.ts

@@ -6,10 +6,13 @@
  * 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";
@@ -17,16 +20,16 @@ import type { Theme, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Container, Spacer, 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 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 { InteractiveDeps, 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";
@@ -44,6 +47,7 @@ import {
 } from "./subcall-render.ts";
 import { createProgressNotifier, validateToolParams } from "./tool-utils.ts";
 import { capReplResultText, replDelegationNudge } from "../mode/native-guards.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. */
 const CALL_PREVIEW_CHARS = 80;
@@ -56,29 +60,61 @@ export const ReplToolParams = Object.freeze(Type.Object({
   code: Type.String({ description: "Python code to execute in the persistent REPL sandbox" }),
 }));
 
+/** 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 "";
+}
+
 /** Model-visible text assembled from a repl() result. */
 export interface ReplResultText {
   readonly text: string;
 }
 
 /**
- * Assemble the model-visible text for a repl() result: cap stdout and append a
- * zero-subcall delegation nudge when a bulk read went undelegated.
+ * Assemble the model-visible text for a repl() result: cap stdout, append a zero-subcall
+ * delegation nudge when a bulk read went undelegated, and report tasks still running.
+ *
+ * The pending line is the model's only signal that `spawn()`ed work is outstanding — without
+ * it a model that spawned and moved on has no way to know it should still collect.
+ *
+ * `varNames` covers the opposite failure: a block that stores its results in `answers` and
+ * prints nothing reads as a bare "(no output)", so the model concludes the block did nothing
+ * and re-runs it — paying twice for the same sub-calls. The headless engine already answers
+ * this with the same hint (core/answer.ts); native mode was the only path missing it.
  */
 export function buildReplResultText(
   stdout: string,
   finalAnswer: string | undefined,
   subcalls: readonly RlmSubcall[],
+  backgroundPending = 0,
+  varNames: readonly string[] = [],
 ): 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)";
+    : stdout || `(no output)${varsHint}`;
   // 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 ?? "") };
+  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 — rlm_await_all(tasks) to collect.`
+    : "";
+  const failedLine = failedBg > 0
+    ? `\n[rlm] ${failedBg} background sub-call(s) FAILED — their rlm_await value is an "Error: …" string, not data.`
+    : "";
+  return { text: cappedText + (nudge ?? "") + pendingLine + failedLine };
 }
 
 /** Advisory diagnostics derived from a completed invocation's sub-calls. */
@@ -99,33 +135,41 @@ export function collectReplWarnings(subcalls: readonly RlmSubcall[]): readonly s
 // ── Mutable bridge state (handler indirection) ──
 
 /**
- * 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).
+ * 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 resumed.
+ *
+ * Detached work resolves to the session-scoped background Invocation instead, whose emitter
+ * and LimitGuard are not torn down at the end of a turn.
  */
 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;
+  private current: Invocation | null = null;
+  /** Interactive callbacks for the turn in progress; child engines inherit them. */
+  interactive: InteractiveDeps | null = null;
+
+  constructor(private readonly background: BackgroundTasks) {}
+
+  swap(inv: Invocation, interactive: InteractiveDeps): void {
+    this.current = Object.freeze({ ...inv });
+    this.interactive = interactive;
   }
 
-  /** 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() };
+  /** Detached ⇒ session registry; otherwise the turn that is currently executing. */
+  resolve(opts: SubcallOpts): Invocation | null {
+    return opts.detached ? this.background.invocation : this.current;
+  }
+
+  /** 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 {
@@ -137,6 +181,10 @@ export interface ReplToolDeps {
   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,61 +193,48 @@ 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, workerModel, 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 getWorkerModel = (): Model<Api> => deps.getWorkerModel?.() ?? workerModel;
+  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(),
+    workerModel: getWorkerModel(),
     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()),
+    onTodo: bridgeState.interactive?.onTodo,
+    onAskUserQuestion: bridgeState.interactive?.onAskUserQuestion,
+  })(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,
+    getWorkerModel,
+    getModel,
+    getConfig,
+    signal,
+    onUsage,
+    runChild,
+    trackDetached: (task) => background.track(task),
   });
 
   const libraryBundle = getConfig().libraryLoader
@@ -233,7 +268,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 +288,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)"),
       });
@@ -295,8 +342,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
 
         await deps.ensureContext?.();
         await sandboxManager.getOrCreate({
-          ...llmHandlers,
-          ...rlmHandlers,
+          ...subcallHandlers,
           askUserQuestion: interactiveHandlers.askUserQuestion,
           todo: interactiveHandlers.todo,
           ...(libraryBundle?.handlers ?? {}),
@@ -311,19 +357,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 }, interactive);
+        }, 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 +409,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 +419,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 +434,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 +456,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         };
       } finally {
         progress.stop();
+        for (const off of detachTracers) off();
         store.dispose();
         emitter.shutdown();
       }
@@ -401,7 +485,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
 
 function replStats(details: ReplDetails, theme: Theme): string {
   const elapsed = details.executionTimeMs > 0 ? `${details.executionTimeMs}ms` : undefined;
-  return cardStatsLine(details.totals, theme, elapsed);
+  return cardStatsLine(details.totals, theme, elapsed, details.backgroundPending);
 }
 
 function renderReplCollapsed(details: ReplDetails, theme: Theme): Text {

package/src/tool/rlm-events.ts

@@ -76,18 +76,26 @@ export interface RootPromptEvent {
 /**
  * Typed wrapper around a Node.js EventEmitter for RLM lifecycle events.
  *
- * Auto-generates monotonic subcall IDs (`s1`, `s2`, …) via `emitSubcallCreated()`.
+ * Auto-generates monotonic subcall IDs (`s1`, `s2`, …) via `emitSubcallCreated()`, with a
+ * configurable prefix so a second emitter's IDs cannot collide with the default ones.
  * Provides typed `on*` methods that return unsubscribe functions.
  */
 export class RlmEmitter {
   private readonly ee = new EventEmitter();
   private seq = 0;
 
+  /**
+   * `idPrefix` namespaces generated IDs. The counter is per-instance, so two emitters
+   * would both start at `s1`; a distinct prefix is what lets one emitter's subcalls be
+   * merged into another's tree without colliding IDs or corrupting parentId links.
+   */
+  constructor(private readonly idPrefix = "s") {}
+
   // ── Emit ──
 
   /** Create a new sub-call entry. Returns the auto-generated ID. */
   emitSubcallCreated(init: Omit<SubcallCreatedEvent, "id">): string {
-    const id = `s${++this.seq}`;
+    const id = `${this.idPrefix}${++this.seq}`;
     const event: SubcallCreatedEvent = { id, ...init };
     this.ee.emit("subcall:created", event);
     return id;

package/src/tool/subcall-render.ts

@@ -52,11 +52,21 @@ export function cardStatsLine(
   totals: { readonly costUsd: number; readonly tokens: number },
   theme: Theme,
   extra?: string,
+  backgroundPending?: number,
 ): string {
   const parts: string[] = [formatCost(totals.costUsd)];
   if (totals.tokens > 0) parts.push(`${formatTokens(totals.tokens)} tok`);
   if (extra) parts.push(extra);
-  return theme.fg("dim", parts.join(" · "));
+  const line = theme.fg("dim", parts.join(" · "));
+  // The one thing no tree can show: spawned work that may outlive this block.
+  return backgroundPending !== undefined && backgroundPending > 0
+    ? `${line} ${theme.fg("warning", `↯${backgroundPending} bg`)}`
+    : line;
+}
+
+/** Detached nodes carry BackgroundTasks' "bg" id prefix (RlmEmitter("bg")). */
+function backgroundTag(sc: RlmSubcall, theme: Theme): string {
+  return sc.id.startsWith("bg") ? ` ${theme.fg("warning", "↯bg")}` : "";
 }
 
 /** `<glyph> <TITLE> <stats>` — the first line of both tools' collapsed and expanded views. */
@@ -128,7 +138,8 @@ export function renderCollapsedSubcallTree(
       const branch = isLast ? "└─" : "├─";
       const gGlyph = subcallStatusGlyph(sc, theme);
       const gStats = subcallStatsLine(sc);
-      lines.push(`${prefix}${branch} ${sc.label}  ${gGlyph}  ${gStats}`);
+      const gBg = backgroundTag(sc, theme);
+      lines.push(`${prefix}${branch} ${sc.label}  ${gGlyph}  ${gStats}${gBg}`);
       const childPrefix = prefix + (isLast ? "   " : "│  ");
       lines.push(...walk(sc.id, childPrefix));
     }
@@ -155,7 +166,8 @@ export function renderExpandedSubcallTree(
     const sKind = theme.fg("muted", sc.label);
     const sModel = sc.model ? theme.fg("dim", ` ${sc.model}`) : "";
     const sStats = sc.endedAt ? `  ${theme.fg("dim", subcallStatsLine(sc))}` : "";
-    let line = `${pad}${sGlyph} ${sKind}${sModel}${sStats}`;
+    const sBg = backgroundTag(sc, theme);
+    let line = `${pad}${sGlyph} ${sKind}${sModel}${sStats}${sBg}`;
 
     if (sc.args) {
       line += `\n${pad}  ${theme.fg("dim", previewText(sc.args, ARGS_PREVIEW_CHARS))}`;