@hicaru/pi-rlm 0.1.8 → 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,103 +17,91 @@ 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 { ProposedEdit, ReplResult } from "../sandbox/protocol.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 type { EditRegistry } from "../registry/edit-registry.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({
   code: Type.String({ description: "Python code to execute in the persistent REPL sandbox" }),
 }));
 
-export function surfaceReplEdits(edits: readonly ProposedEdit[], raised: boolean): readonly ProposedEdit[] | undefined {
-  return edits.length > 0 && !raised ? edits : undefined;
-}
-
-/** Model-visible text assembled from a repl() result, plus the surfaced edits for `details`. */
+/** Model-visible text assembled from a repl() result. */
 export interface ReplResultText {
   readonly text: string;
-  readonly surfacedEdits: readonly ProposedEdit[] | undefined;
-}
-
-function countLines(text: string): number {
-  if (text.length === 0) return 0;
-  let count = 1;
-  for (const ch of text) if (ch === "\n") count++;
-  return count;
-}
-
-function stagedEditSummary(edits: readonly ProposedEdit[]): string {
-  const rows = new Array<string>(edits.length);
-  for (let i = 0; i < edits.length; i++) {
-    const edit = edits[i];
-    rows[i] = `  ${edit.id}  ${edit.path}  (-${countLines(edit.oldText)}/+${countLines(edit.newText)} lines)`;
-  }
-  return [
-    "STAGED_EDITS (apply by id with apply_edits; do NOT re-type content):",
-    ...rows,
-  ].join("\n");
 }
 
 /**
- * Assemble the model-visible text for a repl() result: cap stdout, append a zero-subcall
- * delegation nudge (suppressed when edits were staged), and summarize staged edits by ID
- * without exposing oldText/newText bodies to the root model.
+ * Assemble the model-visible text for a repl() result: cap stdout and append a
+ * zero-subcall delegation nudge when a bulk read went undelegated.
  */
 export function buildReplResultText(
   stdout: string,
   finalAnswer: string | undefined,
-  edits: readonly ProposedEdit[],
-  raised: boolean,
   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)";
-  const surfacedEdits = surfaceReplEdits(edits, raised);
-  const editsBlock = surfacedEdits ? `\n\n${stagedEditSummary(surfacedEdits)}` : "";
-  const modelText = rawText + editsBlock;
-  // Model-visible text is capped; the caller keeps full stdout/final answer in `details` for the TUI.
-  const cappedText = capReplResultText(modelText) ?? modelText;
+  // 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 = surfacedEdits || answerSubmitted ? undefined : replDelegationNudge(rawText.length, delegated);
-  return { text: cappedText + (nudge ?? ""), surfacedEdits };
+  const nudge = answerSubmitted ? undefined : replDelegationNudge(rawText.length, delegated);
+  return { text: cappedText + (nudge ?? "") };
+}
+
+/** 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`]);
 }
 
 // ── 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;
@@ -129,202 +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,
-        });
-        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() };
   }
 }
 
@@ -337,8 +135,8 @@ export interface ReplToolDeps {
   readonly getModel?: () => Model<Api> | undefined;
   readonly getWorkerModel?: () => Model<Api> | undefined;
   readonly registry: ModelRegistry;
-  readonly editRegistry?: EditRegistry;
-  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>;
@@ -347,40 +145,64 @@ export interface ReplToolDeps {
 }
 
 export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplToolParams, ReplDetails> {
-  const { sandboxManager, workerModel, registry, editRegistry, 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,
@@ -396,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) {
@@ -421,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>({
@@ -458,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,
@@ -508,14 +333,11 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         if (queuedId) emitter.emitSubcallUpdated({ id: queuedId, status: "done" });
 
         const finalAnswer = result.finalAnswer ?? undefined;
-        const { text: resultText, surfacedEdits } = buildReplResultText(
+        const { text: resultText } = buildReplResultText(
           result.stdout,
           finalAnswer,
-          result.edits,
-          result.raised,
           store.getSubcalls(),
         );
-        editRegistry?.registerAll(surfacedEdits);
 
         const details: ReplDetails = {
           status: "done",
@@ -525,7 +347,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           subcalls: store.getSubcalls(),
           totals: store.getTotals(),
           finalAnswer,
-          edits: surfacedEdits,
+          warnings: collectReplWarnings(store.getSubcalls()),
         };
         const progressText = finalAnswer !== undefined
           ? `ANSWER_SUBMITTED (${finalAnswer.length} chars)`
@@ -557,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,
       );
     },
@@ -579,29 +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`);
-  if (details.edits && details.edits.length > 0) {
-    parts.push(theme.fg("success", `${details.edits.length} staged`));
-  }
-  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 ──
@@ -609,35 +413,26 @@ 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));
   }
 
-  if (details.edits && details.edits.length > 0) {
-    const editFiles = new Set<string>();
-    for (const edit of details.edits) editFiles.add(edit.path);
+  if (details.warnings && details.warnings.length > 0) {
     container.addChild(new Spacer(1));
-    container.addChild(new Text(theme.fg("success",
-      `${details.edits.length} edit${details.edits.length > 1 ? "s" : ""} staged across ${editFiles.size} file${editFiles.size > 1 ? "s" : ""}`,
-    ), 0, 0));
+    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, 500)), 0, 0));
+    container.addChild(new Text(theme.fg("error", details.stderr.slice(0, EXPANDED_STDERR_CHARS)), 0, 0));
   }
 
   // Sub-call tree