@hicaru/pi-rlm 0.1.9 → 0.2.0

package/src/tool/repl-tool.ts

@@ -6,9 +6,10 @@
  * 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) use mutable refs
- * so the tool can swap per-invocation state (emitter, depth, limits) without recreating
- * the sandbox — preserving REPL variable state across calls.
+ * 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.
  */
 
 import { Type } from "typebox";
@@ -16,34 +17,39 @@ 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 { modelRef, resolveModelId } from "../config/settings.ts";
+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 { type ChatMsg, modelComplete } from "../bridge/model.ts";
-import { previewText } from "../text/preview.ts";
-import { mapPool } from "../util/concurrency.ts";
-import { LimitGuard } from "../core/limits.ts";
-import { checkResourceLimits } from "../core/resource-limits.ts";
-import type { InteractiveDeps, RlmConfig, Sampling } from "../core/types.ts";
+import { createLlmBridge } from "../bridge/llm-query.ts";
+import { createRlmHandlers } from "../bridge/rlm-query.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 { SandboxManager } from "../sandbox/sandbox-manager.ts";
-import type { SubLlmHandlers } from "../sandbox/sandbox.ts";
 import type { ReplResult } from "../sandbox/protocol.ts";
 import { RlmEmitter } from "./rlm-events.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 { formatCost, formatTokens, spinnerFrame } from "../ui/theme.ts";
-import { errorMessage, formatError, isErrorText } from "../util/errors.ts";
+import { spinnerFrame } from "../ui/theme.ts";
+import { previewText } from "../text/preview.ts";
+import { errorMessage } from "../util/errors.ts";
 import {
-  headlineStatusGlyph,
-  renderCollapsedSubcallTree,
+  cardHeader,
+  cardStatsLine,
+  renderCollapsedCard,
   renderExpandedSubcallTree,
 } from "./subcall-render.ts";
 import { createProgressNotifier, validateToolParams } from "./tool-utils.ts";
 import { capReplResultText, replDelegationNudge } from "../mode/native-guards.ts";
 
+/** Chars of code shown on the tool call line, and of stdout in the expanded view. */
+const CALL_PREVIEW_CHARS = 80;
+const EXPANDED_STDOUT_CHARS = 2_000;
+const EXPANDED_STDERR_CHARS = 500;
+
 // ── Parameter schema ──
 
 export const ReplToolParams = Object.freeze(Type.Object({
@@ -93,10 +99,9 @@ export function collectReplWarnings(subcalls: readonly RlmSubcall[]): readonly s
 // ── Mutable bridge state (handler indirection) ──
 
 /**
- * Holds per-invocation mutable state that sandbox handlers dereference.
- * The sandbox is created once with handlers that read from this object's
- * current fields, so the tool can swap emitter/depth/limits between calls
- * without recreating the sandbox (preserving REPL variable state).
+ * 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;
@@ -113,203 +118,11 @@ class NativeBridgeState {
     this.currentInteractive = inv.interactive;
   }
 
-  buildLlmHandlers(deps: {
-    workerModel: Model<Api>;
-    getWorkerModel?: () => Model<Api> | undefined;
-    registry: ModelRegistry;
-    maxPromptChars: number;
-    maxConcurrent: number;
-    sampling?: Sampling;
-    subSystem?: string;
-    signal?: AbortSignal;
-  }): Pick<SubLlmHandlers, "llmQuery" | "llmQueryBatched"> {
-    const state = this;
-
-    const workerModel = (): Model<Api> => deps.getWorkerModel?.() ?? deps.workerModel;
-    const displayModel = (model: string | null): string =>
-      modelRef(model ? (resolveModelId(deps.registry, model) ?? workerModel()) : workerModel()) ?? workerModel().id;
-
-    async function complete1(prompt: string, model: string | null, track: (u: Usage) => void): Promise<string> {
-      const limits = state.currentLimits;
-      if (limits) {
-        const limitError = checkResourceLimits({ budgetUsd: limits.remainingBudgetUsd(), timeoutMs: limits.remainingTimeoutMs() });
-        if (limitError !== undefined) return limitError;
-      }
-      if (prompt.length > deps.maxPromptChars) {
-        return formatError(`sub-LLM prompt exceeded size limit (${prompt.length.toLocaleString()} chars > ${deps.maxPromptChars.toLocaleString()})`);
-      }
-      const resolved = model ? resolveModelId(deps.registry, model) : undefined;
-      if (model && !resolved) return formatError(`unknown model override '${model}'`);
-      try {
-        const messages: ChatMsg[] = [{ role: "user", content: prompt }];
-        const res = await modelComplete(messages, {
-          model: resolved ?? workerModel(),
-          registry: deps.registry,
-          system: deps.subSystem,
-          maxTokens: deps.sampling?.maxTokens,
-          temperature: deps.sampling?.temperature,
-          reasoning: deps.sampling?.reasoning,
-          signal: deps.signal,
-        });
-        limits?.addUsage(res.usage);
-        track(res.usage);
-        return res.text;
-      } catch (err) {
-        const msg = errorMessage(err);
-        const hint = /credit|402|payment|quota|rate.limit/i.test(msg)
-          ? " — try smaller batches or individual llm_query calls"
-          : "";
-        return formatError(`${msg}${hint}`);
-      }
-    }
-
-    return {
-      async llmQuery(prompt, model, _depth) {
-        const id = state.currentEmitter?.emitSubcallCreated({
-          kind: "llm", parentId: state.currentParentId, label: "llm_query",
-          model: displayModel(model), args: `prompt: ${previewText(prompt)}`,
-          depth: state.currentDepth,
-        });
-        let cost = 0; let tokens = 0;
-        const out = await complete1(prompt, model, (u) => { cost += u.cost.total; tokens += u.totalTokens; });
-        if (id) state.currentEmitter?.emitSubcallUpdated({ id,
-          status: isErrorText(out) ? "error" : "done",
-          costUsd: cost, tokens, resultPreview: previewText(out),
-          detail: isErrorText(out) ? out : undefined,
-        });
-        return out;
-      },
-
-      async llmQueryBatched(prompts: readonly string[], model, _depth): Promise<string[]> {
-        const id = state.currentEmitter?.emitSubcallCreated({
-          kind: "batch", parentId: state.currentParentId, label: `llm_query ×${prompts.length}`,
-          model: displayModel(model), args: `prompt: ${previewText(prompts[0] ?? "")}`,
-          depth: state.currentDepth,
-        });
-        let cost = 0; let tokens = 0;
-        const out: string[] = await mapPool(prompts, deps.maxConcurrent, (p) =>
-          complete1(p, model, (u) => { cost += u.cost.total; tokens += u.totalTokens; }),
-        );
-        const failed = out.filter(isErrorText).length;
-        const allFailed = failed === out.length;
-        const error = allFailed
-          ? `all ${out.length} sub-calls failed — reduce batch size or try llm_query individually`
-          : failed > 0 ? `${failed}/${out.length} sub-calls failed` : undefined;
-        if (id) state.currentEmitter?.emitSubcallUpdated({ id,
-          status: error ? "error" : "done", costUsd: cost, tokens,
-          resultPreview: previewText(out[0] ?? ""), detail: error,
-          failedCount: failed, totalCount: out.length,
-        });
-        return out;
-      },
-    };
-  }
-
-  /**
-   * Build real recursive rlm_query / rlm_query_batched handlers that spawn
-   * child RLM engines (each with its own sandbox and turn loop) rather than
-   * falling back to a one-shot llm_query.
-   *
-   * At the maxDepth cap the handler degrades to a plain llm_query via the
-   * already-wired llmHandlers (which read from the same mutable state).
-   */
-  buildRlmHandlers(deps: {
-    model: Model<Api>;
-    workerModel: Model<Api>;
-    getModel?: () => Model<Api> | undefined;
-    getWorkerModel?: () => Model<Api> | undefined;
-    registry: ModelRegistry;
-    config: RlmConfig;
-    signal?: AbortSignal;
-    onUsage?: (usage: Usage, role: "sub") => void;
-    llmHandlers: Pick<SubLlmHandlers, "llmQuery" | "llmQueryBatched">;
-  }): Pick<SubLlmHandlers, "rlmQuery" | "rlmQueryBatched"> {
-    const state = this;
-
-    async function rlmQueryImpl(prompt: string, model: string | null, depth: number): Promise<string> {
-      const emitter = state.currentEmitter;
-      const limits = state.currentLimits;
-      if (!emitter || !limits) return formatError("RLM bridge not wired for this invocation");
-
-      const childDepth = state.currentDepth + 1;
-
-      // Depth cap: degrade to a one-shot llm_query.
-      if (childDepth >= deps.config.maxDepth) {
-        return deps.llmHandlers.llmQuery(prompt, model, depth);
-      }
-
-      const remBudget = limits.remainingBudgetUsd();
-      const remTimeout = limits.remainingTimeoutMs();
-      const limitError = checkResourceLimits({ budgetUsd: remBudget, timeoutMs: remTimeout });
-      if (limitError) return limitError;
-
-      const rootModel = deps.getModel?.() ?? deps.model;
-      const workerModel = deps.getWorkerModel?.() ?? deps.workerModel;
-      const resolvedOverride = model ? resolveModelId(deps.registry, model) : undefined;
-      const subId = emitter.emitSubcallCreated({
-        kind: "rlm", parentId: state.currentParentId, label: "rlm_query",
-        model: model ? (modelRef(resolvedOverride) ?? `unknown/${model}`) : (modelRef(rootModel) ?? rootModel.id),
-        detail: prompt.slice(0, 60),
-        depth: childDepth,
-      });
-
-      // Per-call engine creation with the visible emitter — child llm_query subcalls,
-      // turn progress, and cost deltas land on the per-invocation emitter, visible to
-      // SubcallStore and the live visual tree.
-      const runRlm = createEngine({
-        model: rootModel,
-        workerModel,
-        registry: deps.registry,
-        config: deps.config,
-        signal: deps.signal,
-        emitter: emitter,
-        onUsage: deps.onUsage as ((usage: Usage, role: "root" | "sub") => void) | undefined,
-        limits: {
-          maxBudgetUsd: deps.config.maxBudgetUsd,
-          maxTimeoutMs: deps.config.maxTimeoutMs,
-          maxTokens: deps.config.maxTokens,
-          maxErrors: deps.config.maxErrors,
-        },
-        onTodo: state.currentInteractive?.onTodo,
-        onAskUserQuestion: state.currentInteractive?.onAskUserQuestion,
-      });
-
-      try {
-        const res = await runRlm({
-          rootPrompt: "",
-          context: prompt,
-          depth: childDepth,
-          parentNodeId: subId,
-          modelOverride: model ?? undefined,
-          remainingBudgetUsd: remBudget,
-          remainingTimeoutMs: remTimeout,
-        });
-
-        // Debit parent limit guard for the entire child run.
-        limits.addRaw(res.costUsd, res.inputTokens, res.outputTokens);
-
-        // Child engine emits live usage deltas via the shared emitter — SubcallStore
-        // accumulates them. No final aggregate costUsd/tokens to prevent double-counting
-        // (matches canonical rlm-query.ts:60-63).
-        emitter.emitSubcallUpdated({
-          id: subId,
-          status: "done",
-          resultPreview: res.answer.slice(0, 200),
-        });
-
-        return res.answer;
-      } catch (err) {
-        const msg = errorMessage(err);
-        emitter.emitSubcallUpdated({ id: subId, status: "error", detail: msg });
-        return formatError(`child RLM failed - ${msg}`);
-      }
-    }
-
-    return {
-      rlmQuery: rlmQueryImpl,
-      rlmQueryBatched: (prompts, model, depth) =>
-        mapPool(prompts, deps.config.maxConcurrentSubcalls, (p) => rlmQueryImpl(p, model, depth)),
-    };
+  /** 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() };
   }
 }
 
@@ -322,7 +135,8 @@ export interface ReplToolDeps {
   readonly getModel?: () => Model<Api> | undefined;
   readonly getWorkerModel?: () => Model<Api> | undefined;
   readonly registry: ModelRegistry;
-  readonly config: RlmConfig;
+  /** Live accessor — `/rlm-config` replaces the config object, so never capture the value. */
+  readonly getConfig: () => RlmConfig;
   readonly signal?: AbortSignal;
   readonly onUsage?: (usage: Usage, role: "sub") => void;
   readonly ensureContext?: () => Promise<void>;
@@ -331,40 +145,64 @@ export interface ReplToolDeps {
 }
 
 export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplToolParams, ReplDetails> {
-  const { sandboxManager, workerModel, registry, config, signal, onUsage } = deps;
+  const { sandboxManager, workerModel, registry, getConfig, signal, onUsage } = deps;
   const bridgeState = new NativeBridgeState();
 
   // Late-bound cwd — getOrCreate installs handlers only at spawn; never rebuild the closure.
   let sessionCwd = process.cwd();
 
-  // Build handlers once — llm/rlm/library use late-bound deps so the same closures stay correct
-  // across repl() calls; counter resets when the sandbox is discarded and re-spawned.
-  const llmHandlers = bridgeState.buildLlmHandlers({
-    workerModel,
-    getWorkerModel: deps.getWorkerModel,
+  const rootModel = (): 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,
     registry,
-    maxPromptChars: config.maxPromptChars,
-    maxConcurrent: config.maxConcurrentSubcalls,
-    sampling: config.subSampling,
-    subSystem: config.subSystemPrompt,
+    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 via createEngine — each call spawns a child RLM
-  // with its own sandbox and turn loop, not a flat one-shot llm_query.
-  const rlmHandlers = bridgeState.buildRlmHandlers({
-    model: deps.model,
-    workerModel,
-    getModel: deps.getModel,
-    getWorkerModel: deps.getWorkerModel,
-    registry,
-    config,
-    signal,
-    onUsage,
-    llmHandlers,
+  // 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);
+    },
   });
 
-  const libraryBundle = config.libraryLoader
+  const libraryBundle = getConfig().libraryLoader
     ? buildLibraryHandler({
         getCwd: () => sessionCwd,
         getEmitter: () => bridgeState.currentEmitter,
@@ -380,11 +218,19 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
     label: "REPL",
     description:
       "PRIMARY tool for ALL repository reading and analysis (read/grep are disabled in RLM mode). " +
-      "Persistent Python sandbox with every file pre-loaded in `context`. You are an orchestrator: " +
-      "chunk `context` and delegate semantic work to llm_query / llm_query_batched / " +
-      "llm_query_chunked / rlm_query — stdout returned to you is hard-capped at 4K chars, so " +
-      "printing file bodies is useless. Variables, imports, and state persist across calls. " +
-      "Also supports todo, ask_user_question, and load_library inside the sandbox.",
+      "Persistent Python sandbox with every file pre-loaded in `context`. Locate first with the " +
+      "free primitives search(query) / grep_context(pattern) / outline(path), then delegate the " +
+      "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.",
+    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.",
+    promptGuidelines: [
+      "In RLM mode, read the repository through `repl` only — `read`/`grep` and bash readers are blocked.",
+      "Inside `repl`, locate with search()/grep_context()/outline() before delegating bulk reading to map_files()/llm_query_batched().",
+    ],
     parameters: ReplToolParams,
 
     async execute(_toolCallId, rawParams, _execSignal, onUpdate, ctx) {
@@ -405,12 +251,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
       let capturedStderr = "";
       let progressStatus: ReplDetails["status"] = "running";
       const startedAt = Date.now();
-      const limits = new LimitGuard({
-        maxBudgetUsd: config.maxBudgetUsd,
-        maxTimeoutMs: config.maxTimeoutMs,
-        maxTokens: config.maxTokens,
-        maxErrors: config.maxErrors,
-      });
+      const limits = new LimitGuard(limitsFromConfig(getConfig()));
 
       // ── Progressive rendering: spinner + live sub-call tree ──
       const progress = createProgressNotifier<ReplDetails>({
@@ -442,7 +283,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         // Build interactive handlers (session-stable callbacks)
         const interactive = createPiInteractiveDeps(ctx);
         const interactiveHandlers = buildInteractiveHandlers({
-          onAskUserQuestion: config.askUserQuestion ? interactive.onAskUserQuestion : undefined,
+          onAskUserQuestion: getConfig().askUserQuestion ? interactive.onAskUserQuestion : undefined,
           onTodo: interactive.onTodo,
           onTodoRow: undefined,
           emitter,
@@ -538,10 +379,8 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
     },
 
     renderCall(args, theme) {
-      const preview = args.code.length > 80 ? `${args.code.slice(0, 80)}...` : args.code;
       return new Text(
-        theme.fg("toolTitle", theme.bold("repl ")) +
-        theme.fg("dim", preview.replace(/\n/g, " ")),
+        theme.fg("toolTitle", theme.bold("repl ")) + theme.fg("dim", previewText(args.code, CALL_PREVIEW_CHARS)),
         0, 0,
       );
     },
@@ -560,26 +399,13 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
 
 // ── Collapsed view ──
 
-function renderReplCollapsed(details: ReplDetails, theme: Theme): Text {
-  const glyph = details.status === "running"
-    ? headlineStatusGlyph("running", theme)
-    : details.status === "error" ? theme.fg("error", "✗") : theme.fg("success", "✓");
-
-  const parts: string[] = [];
-  parts.push(formatCost(details.totals.costUsd));
-  if (details.totals.tokens > 0) parts.push(`${formatTokens(details.totals.tokens)} tok`);
-  if (details.executionTimeMs > 0) parts.push(`${details.executionTimeMs}ms`);
-  const stats = parts.length > 0 ? ` ${theme.fg("dim", parts.join(" · "))}` : "";
-
-  const header = `${glyph} ${theme.fg("toolTitle", theme.bold("REPL"))}${stats}`;
-
-  let body = "";
-  if (details.subcalls.length > 0) {
-    body = `\n${renderCollapsedSubcallTree(details.subcalls, theme)}`;
-  }
+function replStats(details: ReplDetails, theme: Theme): string {
+  const elapsed = details.executionTimeMs > 0 ? `${details.executionTimeMs}ms` : undefined;
+  return cardStatsLine(details.totals, theme, elapsed);
+}
 
-  const expandHint = details.status === "running" ? "" : `\n${theme.fg("muted", "(Ctrl+O to expand)")}`;
-  return new Text(`${header}${body}${expandHint}`, 0, 0);
+function renderReplCollapsed(details: ReplDetails, theme: Theme): Text {
+  return renderCollapsedCard("REPL", details.status, replStats(details, theme), details.subcalls, theme);
 }
 
 // ── Expanded view ──
@@ -587,19 +413,14 @@ function renderReplCollapsed(details: ReplDetails, theme: Theme): Text {
 function renderReplExpanded(details: ReplDetails, theme: Theme): Container {
   const container = new Container();
 
-  // Header: status + stats
-  const glyph = details.status === "error" ? theme.fg("error", "✗") : theme.fg("success", "✓");
-  const parts: string[] = [];
-  parts.push(formatCost(details.totals.costUsd));
-  if (details.totals.tokens > 0) parts.push(`${formatTokens(details.totals.tokens)} tok`);
-  if (details.executionTimeMs > 0) parts.push(`${details.executionTimeMs}ms`);
-  const stats = parts.length > 0 ? ` · ${theme.fg("dim", parts.join(" · "))}` : "";
-  container.addChild(new Text(`${glyph} ${theme.fg("toolTitle", theme.bold("REPL"))}${stats}`, 0, 0));
+  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 > 2000 ? `${details.output.slice(0, 2000)}...` : details.output;
+    const out = details.output.length > EXPANDED_STDOUT_CHARS
+      ? `${details.output.slice(0, EXPANDED_STDOUT_CHARS)}…`
+      : details.output;
     container.addChild(new Text(out, 0, 0));
   }
 
@@ -611,7 +432,7 @@ function renderReplExpanded(details: ReplDetails, theme: Theme): Container {
   // Stderr
   if (details.stderr) {
     container.addChild(new Spacer(1));
-    container.addChild(new Text(theme.fg("error", details.stderr.slice(0, 500)), 0, 0));
+    container.addChild(new Text(theme.fg("error", details.stderr.slice(0, EXPANDED_STDERR_CHARS)), 0, 0));
   }
 
   // Sub-call tree

package/src/tool/rlm-details.ts

@@ -44,13 +44,3 @@ export interface RlmDetails {
   readonly warnings?: readonly string[];
 }
 
-export interface SubcallInit {
-  readonly parentId?: string;
-  readonly kind: SubcallKind;
-  readonly label: string;
-  readonly model?: string;
-  readonly detail?: string;
-  readonly args?: string;
-  /** Recursion depth. Required — all call sites pass this. */
-  readonly depth: number;
-}

package/src/tool/rlm-tool.ts

@@ -5,23 +5,29 @@
  * onUpdate(partialResult) for progressive TUI re-rendering.
  */
 
-import { getMarkdownTheme, type Theme, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+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 { createPiInteractiveDeps } from "../bridge/pi-interactive.ts";
 import type { RlmController, StartInput } from "../mode/rlm-mode.ts";
-import { formatCost, formatTokens, spinnerFrame } from "../ui/theme.ts";
+import { spinnerFrame } from "../ui/theme.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 {
-  headlineStatusGlyph,
-  renderCollapsedSubcallTree,
+  cardHeader,
+  cardStatsLine,
+  renderCollapsedCard,
   renderExpandedSubcallTree,
 } from "./subcall-render.ts";
 import { createProgressNotifier, validateToolParams } from "./tool-utils.ts";
 
+/** Chars of the prompt shown on the tool call line. */
+const CALL_PREVIEW_CHARS = 80;
+
 // ── Parameter schema ──
 
 export const RlmToolParams = Object.freeze(Type.Object({
@@ -32,11 +38,8 @@ export const RlmToolParams = Object.freeze(Type.Object({
 // ── Rendering helpers ──
 
 function rootStats(details: RlmDetails, theme: Theme): string {
-  const parts: string[] = [];
-  parts.push(formatCost(details.totals.costUsd));
-  parts.push(`${formatTokens(details.totals.tokens)} tok`);
-  if (details.turns.current > 0) parts.push(`${details.turns.current} turn${details.turns.current > 1 ? "s" : ""}`);
-  return theme.fg("dim", parts.join(" · "));
+  const turns = details.turns.current;
+  return cardStatsLine(details.totals, theme, turns > 0 ? `${turns} turn${turns > 1 ? "s" : ""}` : undefined);
 }
 
 // ── Tool definition ──
@@ -110,18 +113,14 @@ export function createRlmTool(controller: RlmController): ToolDefinition<typeof
       }
     },
 
-    renderCall(args, theme, _context) {
-      const preview = args.prompt.length > 80
-        ? `${args.prompt.slice(0, 80)}...`
-        : args.prompt;
+    renderCall(args, theme) {
       return new Text(
-        theme.fg("toolTitle", theme.bold("rlm ")) +
-        theme.fg("dim", preview.replace(/\n/g, " ")),
+        theme.fg("toolTitle", theme.bold("rlm ")) + theme.fg("dim", previewText(args.prompt, CALL_PREVIEW_CHARS)),
         0, 0,
       );
     },
 
-    renderResult(result, { expanded, isPartial: _isPartial }, theme, _context) {
+    renderResult(result, { expanded }, theme) {
       const details = result.details as RlmDetails | undefined;
       if (!details) {
         const text = result.content[0];
@@ -139,10 +138,7 @@ export function createRlmTool(controller: RlmController): ToolDefinition<typeof
 
 function renderExpanded(details: RlmDetails, theme: Theme): Component {
   const container = new Container();
-
-  const glyph = headlineStatusGlyph(details.status, theme);
-  const header = `${glyph} ${theme.fg("toolTitle", theme.bold("RLM"))} · ${rootStats(details, theme)}`;
-  container.addChild(new Text(header, 0, 0));
+  container.addChild(new Text(cardHeader("RLM", details.status, rootStats(details, theme), theme), 0, 0));
 
   if (details.subcalls.length > 0) {
     container.addChild(new Spacer(1));
@@ -153,7 +149,7 @@ function renderExpanded(details: RlmDetails, theme: Theme): Component {
   if (details.answer) {
     container.addChild(new Spacer(1));
     container.addChild(new Text(theme.fg("muted", "─── Answer ───"), 0, 0));
-    container.addChild(new Markdown(details.answer, 0, 0, getMarkdownTheme()));
+    container.addChild(new Markdown(details.answer, 0, 0, markdownTheme(theme)));
   }
 
   if (details.warnings && details.warnings.length > 0) {
@@ -167,14 +163,5 @@ function renderExpanded(details: RlmDetails, theme: Theme): Component {
 // ── Collapsed view ──
 
 function renderCollapsed(details: RlmDetails, theme: Theme): Text {
-  const glyph = headlineStatusGlyph(details.status, theme);
-  const header = `${glyph} ${theme.fg("toolTitle", theme.bold("RLM"))} · ${rootStats(details, theme)}`;
-
-  let body = "";
-  if (details.subcalls.length > 0) {
-    body = `\n${renderCollapsedSubcallTree(details.subcalls, theme)}`;
-  }
-
-  const expandHint = details.status === "running" ? "" : `\n${theme.fg("muted", "(Ctrl+O to expand)")}`;
-  return new Text(`${header}${body}${expandHint}`, 0, 0);
+  return renderCollapsedCard("RLM", details.status, rootStats(details, theme), details.subcalls, theme);
 }