@hicaru/pi-rlm 0.1.3 → 0.1.6

package/src/sandbox/worker.py

@@ -21,6 +21,7 @@ import io
 import json
 import os
 import pickle
+import re
 import signal
 import sys
 import time
@@ -28,10 +29,11 @@ import traceback
 from contextlib import contextmanager
 from typing import Any
 
-# Capture the REAL stdout/stdin before exec() redirects sys.stdout into a buffer.
+# Capture the REAL stdio before exec() redirects sys.stdout/sys.stderr into buffers.
 # All protocol writes must go to the real stdout even while user code's prints are captured.
 _REAL_STDOUT = sys.stdout
 _REAL_STDIN = sys.stdin
+_REAL_STDERR = sys.stderr
 
 
 def _builtin(name: str):
@@ -62,13 +64,37 @@ for _blocked in ("eval", "exec", "compile", "input", "globals", "locals"):
 
 RESERVED = frozenset(
     {
-        "llm_query", "llm_query_batched", "rlm_query", "rlm_query_batched",
+        "llm_query", "llm_query_batched", "llm_query_chunked",
+        "rlm_query", "rlm_query_batched",
         "advance_phase",
         "ask_user_question", "todo",
         "stage_edit",
         "SHOW_VARS", "answer", "context",
     }
 )
+_CONTEXT_SLOT = re.compile(r"context(_\d+)?\Z")
+
+# Sizing for llm_query_chunked: leave room for the instruction and the chunk header.
+_CHUNK_HEADER_OVERHEAD = 64
+_MAX_CHUNK_BATCH = 20          # fan-out per llm_query_batched call (matches prompt guidance)
+_MAX_CHUNKS = 500              # ceiling: above this, force pre-filtering in Python
+_NUDGE_CHARS = 500_000         # str/bytes vars above this trigger a one-time stdout hint
+
+
+def _chunk_text(text: str, chunk_chars: int) -> list[str]:
+    """Split text into <=chunk_chars pieces, preferring newline boundaries."""
+    chunks: list[str] = []
+    n = len(text)
+    start = 0
+    while start < n:
+        end = min(start + chunk_chars, n)
+        if end < n:
+            nl = text.rfind("\n", start, end)
+            if nl > start:
+                end = nl + 1
+        chunks.append(text[start:end])
+        start = end
+    return chunks
 
 
 class _AnswerDict(dict):
@@ -92,9 +118,10 @@ def _send(obj: dict[str, Any]) -> None:
 
 
 class Worker:
-    def __init__(self, depth: int, exec_timeout_s: float):
+    def __init__(self, depth: int, exec_timeout_s: float, max_prompt_chars: int):
         self.depth = depth
         self.exec_timeout_s = exec_timeout_s
+        self.max_prompt_chars = max_prompt_chars
         self._rid = 0
         self._final_answer: str | None = None
         self._context_count = 0
@@ -105,6 +132,8 @@ class Worker:
         self.ns = {"__builtins__": _SAFE_BUILTINS.copy(), "__name__": "__main__"}
         self._ctx_payloads: dict[int, Any] = {}
         self._staged_edits: list[dict[str, str]] = []
+        self._edit_counter = 0
+        self._nudged: set[str] = set()
         self._restore_scaffold()
 
     def _capture_answer(self, content: Any) -> None:
@@ -115,6 +144,7 @@ class Worker:
         ns = self.ns
         ns["llm_query"] = self._llm_query
         ns["llm_query_batched"] = self._llm_query_batched
+        ns["llm_query_chunked"] = self._llm_query_chunked
         ns["rlm_query"] = self._rlm_query
         ns["rlm_query_batched"] = self._rlm_query_batched
         ns["advance_phase"] = self._advance_phase
@@ -131,11 +161,14 @@ class Worker:
                 if cur.get("ready") and self._final_answer is None:
                     self._final_answer = str(cur.get("content", ""))
             ns["answer"] = ans
-        # Restore context slots from immutable originals so REPL mutations don't persist.
+        # Context slots are ordinary variables (RLM paper: the context lives in the
+        # environment and the model may transform it in place). Re-inject only if the
+        # model deleted the name entirely; mutations and re-binds persist within the run.
+        # Resume reloads pristine context; keep derived resume-critical values in user vars.
         for idx, payload in self._ctx_payloads.items():
-            ns[f"context_{idx}"] = payload
+            ns.setdefault(f"context_{idx}", payload)
         if 0 in self._ctx_payloads:
-            ns["context"] = self._ctx_payloads[0]
+            ns.setdefault("context", self._ctx_payloads[0])
 
     def _user_var_names(self) -> list[str]:
         """User-created variable names — filters builtins, scaffold, and context slots.
@@ -146,7 +179,7 @@ class Worker:
         return [
             k for k in self.ns
             if not k.startswith("_")
-            and not k.startswith("context_")
+            and not _CONTEXT_SLOT.match(k)
             and k not in RESERVED
         ]
 
@@ -174,8 +207,11 @@ class Worker:
                 msg = json.loads(line)
                 if msg.get("type") == "llm_reply" and msg.get("rid") == rid:
                     return msg
-                # The parent only ever sends our reply mid-exec; anything else is a protocol error.
-                raise RuntimeError(f"unexpected parent message during sub-LLM request: {msg!r}")
+                # Stray/late message (e.g. a reply to an earlier timed-out request): skip it.
+                print(
+                    f"[rlm-sandbox] ignoring unexpected message during sub-LLM request: {str(msg)[:200]}",
+                    file=_REAL_STDERR,
+                )
         finally:
             if pause and remaining > 0:
                 signal.setitimer(signal.ITIMER_REAL, remaining)
@@ -196,6 +232,35 @@ class Worker:
             return ["Error: malformed batched response"] * len(prompts)
         return [s if isinstance(s, str) else f"Error: {s}" for s in out]
 
+    def _llm_query_chunked(self, text, prompt: str, model: str | None = None) -> list[str]:
+        """Split oversized text into cap-sized chunks and fan out via llm_query_batched.
+
+        Returns one answer per chunk, order preserved. No exceptions escape: errors come
+        back as "Error: ..." strings per chunk (same contract as llm_query_batched).
+
+        NOTE: budget uses Python code-point length (len) while the parent-side cap check counts
+        UTF-16 units (JS string.length); astral/emoji-heavy text may be marginally larger on the
+        parent and get per-chunk rejected. Acceptable trade-off for typical code/log/profile text.
+        """
+        text, prompt = str(text), str(prompt)
+        if not text:
+            return []
+        budget = self.max_prompt_chars - len(prompt) - _CHUNK_HEADER_OVERHEAD
+        if budget < 1_000:
+            return [f"Error: prompt leaves under 1,000 chars per chunk (cap {self.max_prompt_chars:,}) — shorten the instruction"]
+        chunks = _chunk_text(text, budget)
+        total = len(chunks)
+        if total > _MAX_CHUNKS:
+            return [f"Error: {total} chunks would be needed — filter/slice the text in Python first"]
+        results: list[str] = []
+        for i in range(0, total, _MAX_CHUNK_BATCH):
+            batch = [
+                f"{prompt}\n\n[chunk {i + j + 1}/{total} of the input]\n{c}"
+                for j, c in enumerate(chunks[i:i + _MAX_CHUNK_BATCH])
+            ]
+            results.extend(self._llm_query_batched(batch, model))
+        return results
+
     def _rlm_query(self, prompt: str, model: str | None = None) -> str:
         r = self._rpc("rlm_query", {"prompt": str(prompt), "model": model})
         return f"Error: {r['error']}" if r.get("error") else r.get("response", "")
@@ -261,8 +326,10 @@ class Worker:
     def _stage_edit(self, path: str, old_text: str, new_text: str) -> str:
         if not isinstance(path, str) or not isinstance(old_text, str) or not isinstance(new_text, str):
             return "Error: path, old_text, new_text must be strings"
-        self._staged_edits.append({"path": path, "oldText": old_text, "newText": new_text})
-        return f"Staged edit for {path} ({len(old_text)} → {len(new_text)} chars)"
+        self._edit_counter += 1
+        edit_id = f"e{self._edit_counter}"
+        self._staged_edits.append({"id": edit_id, "path": path, "oldText": old_text, "newText": new_text})
+        return edit_id
 
     def _advance_phase(self, phase: str, summary: str | None = None) -> str:
         """Transition the root RLM pipeline to a new phase.
@@ -334,6 +401,24 @@ class Worker:
             signal.setitimer(signal.ITIMER_REAL, 0)
             signal.signal(signal.SIGALRM, old)
 
+    def _nudge_lines(self) -> list[str]:
+        """One-time hint for newly created huge raw-text variables (single line).
+
+        Collapses to one line so it survives headless stdout elision (head 200 + tail 200).
+        """
+        names: list[str] = []
+        for k in self._user_var_names():
+            v = self.ns.get(k)
+            if isinstance(v, (str, bytes)) and len(v) > _NUDGE_CHARS and k not in self._nudged:
+                self._nudged.add(k)
+                names.append(f"{k} ({len(v):,} chars)")
+        if not names:
+            return []
+        return [
+            f"[rlm] huge raw-text variable(s): {', '.join(names)} — do NOT analyze them yourself; "
+            'delegate with llm_query_chunked(name, "your question") or slice + llm_query_batched.'
+        ]
+
     def execute(self, code: str) -> dict[str, Any]:
         start = time.perf_counter()
         raised = False
@@ -352,6 +437,15 @@ class Worker:
         edits, self._staged_edits = self._staged_edits, []
         answer = self.ns.get("answer")
         answer_content = answer.get("content", "") if isinstance(answer, dict) else ""
+        # ready may have been flipped with empty content before content was assigned later
+        # in the same block; the dict's current content is the real submission.
+        if final is not None and not final.strip() and str(answer_content).strip():
+            final = str(answer_content)
+        nudges = self._nudge_lines()
+        if nudges:
+            parts = [stdout] if stdout else []
+            parts.extend(nudges)
+            stdout = "\n".join(parts) + "\n"
         return {
             "stdout": stdout,
             "stderr": stderr,
@@ -381,7 +475,7 @@ class Worker:
         out, skipped = {}, []
         MAX_VAR_BYTES = 50 * 1024 * 1024
         for k, v in self.ns.items():
-            if k.startswith("_") or k.startswith("context") or k in RESERVED or k == "__builtins__":
+            if k.startswith("_") or _CONTEXT_SLOT.match(k) or k in RESERVED or k == "__builtins__":
                 continue
             try:
                 blob = s.dumps(v)
@@ -392,7 +486,7 @@ class Worker:
             except Exception:
                 skipped.append(k)
         if skipped:
-            print(f"[rlm-sandbox] snapshot skipped {len(skipped)} unpicklable/oversized vars: {skipped}", file=sys.stderr)
+            print(f"[rlm-sandbox] snapshot skipped {len(skipped)} unpicklable/oversized vars: {skipped}", file=_REAL_STDERR)
         tmp = path + ".tmp"
         with open(tmp, "wb") as f:
             s.dump({"nonce": nonce, "vars": out}, f)
@@ -420,9 +514,12 @@ def main() -> None:
     ap = argparse.ArgumentParser()
     ap.add_argument("--depth", type=int, default=int(os.environ.get("RLM_DEPTH", "1")))
     ap.add_argument("--timeout", type=float, default=float(os.environ.get("RLM_EXEC_TIMEOUT_S", "600")))
+    ap.add_argument("--max-prompt-chars", type=int,
+                    default=int(os.environ.get("RLM_MAX_PROMPT_CHARS", "400000")))
     args = ap.parse_args()
 
-    worker = Worker(depth=args.depth, exec_timeout_s=args.timeout)
+    worker = Worker(depth=args.depth, exec_timeout_s=args.timeout,
+                    max_prompt_chars=args.max_prompt_chars)
     _send({"id": "_init", "ok": True})
 
     for raw in _REAL_STDIN:

package/src/text/parsing.ts

@@ -5,7 +5,7 @@
  * blocks in order; everything else is prose the model uses to think out loud.
  */
 
-const FENCE = /```[ \t]*repl[ \t]*\r?\n([\s\S]*?)```/g;
+const FENCE = /(`{3,})[ \t]*repl[ \t]*\r?\n([\s\S]*?)\1/g;
 
 /** Return every ```repl``` block body, in document order. */
 export function findReplBlocks(text: string): string[] {
@@ -13,7 +13,7 @@ export function findReplBlocks(text: string): string[] {
   let m: RegExpExecArray | null;
   FENCE.lastIndex = 0;
   while ((m = FENCE.exec(text)) !== null) {
-    const code = m[1] ?? "";
+    const code = m[2] ?? "";
     if (code.trim()) blocks.push(code.replace(/\s+$/, ""));
   }
   return blocks;

package/src/tool/apply-edits-tool.ts

@@ -0,0 +1,126 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { createEditToolDefinition, type AgentToolResult, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import type { EditToolDetails } from "@earendil-works/pi-coding-agent";
+import type { EditRegistry } from "../registry/edit-registry.ts";
+import { countOccurrences } from "../text/edits.ts";
+import { errorMessage, formatError } from "../util/errors.ts";
+
+export const ApplyEditsToolParams = Object.freeze(Type.Object({
+  ids: Type.Array(Type.String({ description: "A staged edit ID returned by stage_edit()." }), {
+    description: "Staged edit IDs to apply.",
+  }),
+}));
+
+export interface ApplyEditsFailure {
+  readonly id: string;
+  readonly error: string;
+}
+
+export interface ApplyEditsDetails {
+  readonly status: "done" | "partial" | "error";
+  readonly appliedIds: readonly string[];
+  readonly errors: readonly ApplyEditsFailure[];
+  readonly editDetails: readonly EditToolDetails[];
+}
+
+function statusFor(appliedCount: number, errorCount: number): ApplyEditsDetails["status"] {
+  if (errorCount === 0) return "done";
+  return appliedCount > 0 ? "partial" : "error";
+}
+
+function summarize(details: ApplyEditsDetails): string {
+  const head = details.errors.length > 0
+    ? `apply_edits: ${details.appliedIds.length} applied, ${details.errors.length} failed`
+    : `apply_edits: ${details.appliedIds.length} applied`;
+  if (details.errors.length === 0) return `${head}.`;
+  const rows = new Array<string>(details.errors.length);
+  for (let i = 0; i < details.errors.length; i++) {
+    const error = details.errors[i];
+    rows[i] = `${error.id}: ${error.error}`;
+  }
+  return `${head}.\n${rows.join("\n")}`;
+}
+
+export function createApplyEditsTool(editRegistry: EditRegistry): ToolDefinition<typeof ApplyEditsToolParams, ApplyEditsDetails> {
+  return {
+    name: "apply_edits",
+    label: "Apply Edits",
+    description: "Apply staged REPL edits by ID without re-typing file paths or edit bodies.",
+    parameters: ApplyEditsToolParams,
+
+    async execute(toolCallId, params, signal, _onUpdate, ctx): Promise<AgentToolResult<ApplyEditsDetails>> {
+      const appliedIds = new Array<string>(params.ids.length);
+      const errors = new Array<ApplyEditsFailure>(params.ids.length);
+      const editDetails = new Array<EditToolDetails>(params.ids.length);
+      let appliedCount = 0;
+      let errorCount = 0;
+      let detailCount = 0;
+
+      const editTool = createEditToolDefinition(ctx.cwd);
+      for (let i = 0; i < params.ids.length; i++) {
+        const id = params.ids[i];
+        const edit = editRegistry.get(id);
+        if (edit === undefined) {
+          errors[errorCount] = { id, error: formatError("unknown edit id") };
+          errorCount++;
+          continue;
+        }
+
+        try {
+          const fullPath = resolve(ctx.cwd, edit.path);
+          const content = await readFile(fullPath, "utf8");
+          const occurrences = countOccurrences(content, edit.oldText);
+          if (occurrences !== 1) {
+            errors[errorCount] = { id, error: formatError(`anchor occurs ${occurrences} times in ${edit.path}`) };
+            errorCount++;
+            continue;
+          }
+
+          const result = await editTool.execute(
+            toolCallId,
+            { path: edit.path, edits: [{ oldText: edit.oldText, newText: edit.newText }] },
+            signal,
+            undefined,
+            ctx,
+          );
+          if (result.details !== undefined) {
+            editDetails[detailCount] = result.details;
+            detailCount++;
+          }
+          editRegistry.delete(id);
+          appliedIds[appliedCount] = id;
+          appliedCount++;
+        } catch (error) {
+          errors[errorCount] = { id, error: formatError(errorMessage(error)) };
+          errorCount++;
+        }
+      }
+
+      const details: ApplyEditsDetails = {
+        status: statusFor(appliedCount, errorCount),
+        appliedIds: appliedIds.slice(0, appliedCount),
+        errors: errors.slice(0, errorCount),
+        editDetails: editDetails.slice(0, detailCount),
+      };
+      return { content: [{ type: "text", text: summarize(details) }], details };
+    },
+
+    renderCall(args, theme) {
+      return new Text(
+        theme.fg("toolTitle", theme.bold("apply_edits ")) + theme.fg("dim", args.ids.join(", ")),
+        0,
+        0,
+      );
+    },
+
+    renderResult(result, _options, theme) {
+      const details = result.details;
+      if (details === undefined) return new Text("(no apply_edits details)", 0, 0);
+      const summary = summarize(details);
+      return new Text(theme.fg(details.status === "error" ? "error" : "success", summary), 0, 0);
+    },
+  };
+}

package/src/tool/repl-details.ts

@@ -21,6 +21,8 @@ export interface ReplDetails {
   readonly subcalls: readonly RlmSubcall[];
   /** Running totals for this repl() call (cost + tokens from sub-LLM calls). */
   readonly totals: { readonly costUsd: number; readonly tokens: number };
-  /** File edits staged inside the REPL for native relay through edit(). */
+  /** Final answer submitted through answer["ready"] without echoing it to the model. */
+  readonly finalAnswer?: string;
+  /** File edits staged inside the REPL for native relay through apply_edits(). */
   readonly edits?: readonly ProposedEdit[];
 }

package/src/tool/repl-tool.ts

@@ -31,8 +31,10 @@ import type { ProposedEdit, 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 {
   headlineStatusGlyph,
@@ -40,6 +42,7 @@ import {
   renderExpandedSubcallTree,
 } from "./subcall-render.ts";
 import { createProgressNotifier, validateToolParams } from "./tool-utils.ts";
+import { capReplResultText, replDelegationNudge } from "../mode/native-guards.ts";
 
 // ── Parameter schema ──
 
@@ -51,6 +54,57 @@ export function surfaceReplEdits(edits: readonly ProposedEdit[], raised: boolean
   return edits.length > 0 && !raised ? edits : undefined;
 }
 
+/** Model-visible text assembled from a repl() result, plus the surfaced edits for `details`. */
+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.
+ */
+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;
+  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 };
+}
+
 // ── Mutable bridge state (handler indirection) ──
 
 /**
@@ -91,6 +145,11 @@ class NativeBridgeState {
       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()})`);
       }
@@ -107,6 +166,7 @@ class NativeBridgeState {
           reasoning: deps.sampling?.reasoning,
           signal: deps.signal,
         });
+        limits?.addUsage(res.usage);
         track(res.usage);
         return res.text;
       } catch (err) {
@@ -132,7 +192,6 @@ class NativeBridgeState {
           costUsd: cost, tokens, resultPreview: previewText(out),
           detail: isErrorText(out) ? out : undefined,
         });
-        state.currentLimits?.addRaw(cost, 0, tokens);
         return out;
       },
 
@@ -155,7 +214,6 @@ class NativeBridgeState {
           status: error ? "error" : "done", costUsd: cost, tokens,
           resultPreview: previewText(out[0] ?? ""), detail: error,
         });
-        state.currentLimits?.addRaw(cost, 0, tokens);
         return out;
       },
     };
@@ -278,6 +336,7 @@ export interface ReplToolDeps {
   readonly getModel?: () => Model<Api> | undefined;
   readonly getWorkerModel?: () => Model<Api> | undefined;
   readonly registry: ModelRegistry;
+  readonly editRegistry?: EditRegistry;
   readonly config: RlmConfig;
   readonly signal?: AbortSignal;
   readonly onUsage?: (usage: Usage, role: "sub") => void;
@@ -285,7 +344,7 @@ export interface ReplToolDeps {
 }
 
 export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplToolParams, ReplDetails> {
-  const { sandboxManager, workerModel, registry, config, signal, onUsage } = deps;
+  const { sandboxManager, workerModel, registry, editRegistry, config, signal, onUsage } = deps;
   const bridgeState = new NativeBridgeState();
 
   // Build handlers once — llm/rlm use mutable refs, interactive is session-stable
@@ -317,7 +376,13 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
   return {
     name: "repl",
     label: "REPL",
-    description: "Execute Python code in a persistent REPL sandbox with the full repository context pre-loaded. Variables, imports, and state persist across calls. Supports llm_query, rlm_query, todo, and ask_user_question inside the sandbox.",
+    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 and ask_user_question inside the sandbox.",
     parameters: ReplToolParams,
 
     async execute(_toolCallId, rawParams, _execSignal, onUpdate, ctx) {
@@ -421,11 +486,15 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
 
         if (queuedId) emitter.emitSubcallUpdated({ id: queuedId, status: "done" });
 
-        const baseText = result.stdout || result.answerContent || "(no output)";
-        const surfacedEdits = surfaceReplEdits(result.edits, result.raised);
-        const editsBlock = surfacedEdits
-          ? `\n\nSTAGED_EDITS:\n${JSON.stringify(surfacedEdits)}`
-          : "";
+        const finalAnswer = result.finalAnswer ?? undefined;
+        const { text: resultText, surfacedEdits } = buildReplResultText(
+          result.stdout,
+          finalAnswer,
+          result.edits,
+          result.raised,
+          store.getSubcalls(),
+        );
+        editRegistry?.registerAll(surfacedEdits);
 
         const details: ReplDetails = {
           status: "done",
@@ -434,11 +503,15 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           executionTimeMs: elapsed,
           subcalls: store.getSubcalls(),
           totals: store.getTotals(),
+          finalAnswer,
           edits: surfacedEdits,
         };
+        const progressText = finalAnswer !== undefined
+          ? `ANSWER_SUBMITTED (${finalAnswer.length} chars)`
+          : result.stdout.slice(0, 500) || "(no output)";
         // Final progressive update
-        onUpdate?.({ content: [{ type: "text", text: result.stdout.slice(0, 500) || "(no output)" }], details });
-        return { content: [{ type: "text", text: baseText + editsBlock }], details };
+        onUpdate?.({ content: [{ type: "text", text: progressText }], details });
+        return { content: [{ type: "text", text: resultText }], details };
       } catch (e) {
         progressStatus = "error";
         const msg = errorMessage(e);

package/src/ui/config-panel.ts

@@ -15,6 +15,7 @@ const CHOICES = Object.freeze({
   maxTokens: Object.freeze(["none", "10000", "50000", "100000"]),
   maxErrors: Object.freeze(["3", "5", "10", "none"]),
   orchestrator: Object.freeze(["on", "off"]),
+  pipeline: Object.freeze(["on", "off"]),
   compaction: Object.freeze(["on", "off"]),
   rootSamplingMaxTokens: Object.freeze(["4096", "8192", "16384", "32768"]),
   sandboxInitTimeoutMs: Object.freeze(["10000", "30000", "60000", "120000"]),
@@ -38,6 +39,7 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
     item("maxTokens", "Token ceiling", config.maxTokens != null ? String(config.maxTokens) : "none", CHOICES.maxTokens, "Total input+output token cap for the whole recursive tree."),
     item("maxErrors", "Max consecutive errors", config.maxErrors != null ? String(config.maxErrors) : "none", CHOICES.maxErrors, "Stop after this many consecutive failing turns; none disables the guard."),
     item("orchestrator", "Orchestrator addendum", config.orchestrator ? "on" : "off", CHOICES.orchestrator, "Append extra divide-and-conquer guidance to the root model system prompt."),
+    item("pipeline", "Phase pipeline", config.pipeline ? "on" : "off", CHOICES.pipeline, "Enable advance_phase plus phase-stall reminders at root depth."),
     item("compaction", "Trajectory compaction", config.compaction ? "on" : "off", CHOICES.compaction, "Summarize old turns when history approaches the model context window."),
     item("rootSamplingMaxTokens", "Root model output cap (tok)", String(config.rootSampling?.maxTokens ?? 16384), CHOICES.rootSamplingMaxTokens, "Max output tokens per root-model turn. Lower values keep each turn lean."),
     item("sandboxInitTimeoutMs", "Sandbox init timeout", String(config.sandboxInitTimeoutMs), CHOICES.sandboxInitTimeoutMs, "How long to wait for the Python worker to start."),
@@ -83,6 +85,7 @@ function applySetting(config: RlmConfig, id: string, value: string): void {
     case "maxTokens": config.maxTokens = value === "none" ? undefined : Number(value); break;
     case "maxErrors": config.maxErrors = value === "none" ? undefined : Number(value); break;
     case "orchestrator": config.orchestrator = value === "on"; break;
+    case "pipeline": config.pipeline = value === "on"; break;
     case "compaction": config.compaction = value === "on"; break;
     case "rootSamplingMaxTokens": config.rootSampling = Object.freeze({ ...config.rootSampling, maxTokens: Number(value) }); break;
     case "sandboxInitTimeoutMs": config.sandboxInitTimeoutMs = Number(value); break;