@hicaru/pi-rlm 0.1.0 → 0.1.1

package/src/prompts/system.ts

@@ -162,11 +162,13 @@ function nativeReplGlossary(): string {
     "- `rlm_query(prompt, model=None) -> str` — recursive RLM with its own REPL for complex sub-tasks needing iterative reasoning.",
     "- `rlm_query_batched(prompts, model=None) -> list[str]` — concurrent recursive RLM calls.",
     "",
-    "**Choosing between `llm_query` and `rlm_query`:** default to `llm_query` (fast/cheap) for one-shot tasks",
-    "and fan out with `llm_query_batched`; reach for `rlm_query` only when a sub-task needs its own iterative",
-    "reasoning. Avoid excessive recursive sub-calls when a batched one-shot suffices.",
+    "**Choosing between `llm_query` and `rlm_query`:** default to `llm_query`/batched; use `rlm_query` only for iterative sub-tasks.",
     "- `todo(action, **kwargs) -> str` — manage a task list. Actions: create, update, list, get, delete, clear. Statuses: pending → in_progress → completed.",
     "- `SHOW_VARS() -> str` — list all variables currently in the REPL.",
+    "- `stage_edit(path, old_text, new_text) -> str`: stage a file edit computed inside the REPL.",
+    "  Read the file from `context`, compute the exact change in Python, then call",
+    "  stage_edit once per file. The repl() result will include a STAGED_EDITS JSON block.",
+    "  The main agent must then call `edit` for each entry verbatim — zero analysis needed.",
     "- `answer`: dict `{\"content\": \"\", \"ready\": False}`. To submit: `answer[\"content\"] = \"...\"; answer[\"ready\"] = True`.",
     "",
     "### Orchestrator Pattern",
@@ -198,45 +200,23 @@ function nativeReplGlossary(): string {
     "| `repl({code})` | Need to chunk/delegate `context` to sub-LLMs; need Python scripting; need REPL state across calls |",
     "| `read` / `grep` | Inspect a few specific files directly; small codebase |",
     "| `zebra-mcp` | Semantic search over the codebase |",
-    "| `apply_diff({diff})` | Apply a unified diff to any file — shows patch preview before writing |",
+    "| `edit` | Modify an existing file with exact text replacement (native Pi flow, visible to all plugins) |",
+    "| `write` | Create a new file (native Pi flow, visible to all plugins) |",
     "| `llm_query` (inside repl) | Extract, summarize, or classify a chunk of text |",
     "| `rlm_query` (inside repl) | Complex sub-task needing iterative reasoning with its own REPL |",
     "| `todo` (inside repl) | Track multi-step progress visibly to the user |",
+    "| `stage_edit(path, old, new)` (inside repl) | Sub-agent stages exact edit params; relay STAGED_EDITS to `edit` |",
     "",
     "### Workflow",
     "1. **Plan**: Create todos for the multi-step analysis. Probe `context` — print length, inspect a few entries.",
     "2. **Chunk & Delegate**: Slice `context` into batches, delegate each batch to sub-LLMs via `llm_query_batched`.",
     "3. **Aggregate**: Collect results in Python, pass aggregated results to a final `llm_query` or produce the answer directly.",
-    "4. **Finalize**: Set `answer[\"content\"]` and `answer[\"ready\"] = True`, or just write your final answer as a normal message.",
+    "4. **Finalize**: For file changes, stage them inside repl() via stage_edit(path, old, new), then relay the STAGED_EDITS from the result to `edit`. For analysis tasks, write a normal message.",
     "",
     "### Task-Specific Patterns",
-    "",
-    "**Architecture analysis / \"learn this project\" / diagram**:",
-    "1. Probe → `repl()` to list all files grouped by directory",
-    "2. Chunk → split files into module batches (~10-15 files each)",
-    "3. **DELEGATE ALL** → `llm_query_batched` on EVERY module: \"Summarize each file's role, what it exports, and how it connects\". Send ALL batches.",
-    "4. Aggregate → collect all sub-LLM summaries, synthesize diagram from them.",
-    "5. If sub-LLM credits exhausted → report to user: \"Credits exhausted after N batches. Results so far: ...\"",
-    "",
-    "**Bug investigation / \"find the issue\"**:",
-    "1. `repl()` → grep context for keywords (use Python re/in operators)",
-    "2. `llm_query` on matching files: \"Is there a bug here? What could cause X?\"",
-    "",
-    "**Full code review / audit**:",
-    "1. `repl()` → chunk all files, delegate ALL to `llm_query_batched` with review criteria",
-    "2. Aggregate findings, report to user",
-    "",
-    "CRITICAL: Never read files directly. If sub-LLMs fail → report, don't fall back to read.",
-    "",
-    "### Handling Sub-LLM Failures",
-    "Sub-LLM calls can fail (credit limits, rate limits, timeouts). Handle gracefully:",
-    "",
-    "| Failure | Action |",
-    "|---------|--------|",
-    "| `llm_query_batched` all fail | Reduce batch size (try 3-5 instead of 10+). If still failing, use individual `llm_query` calls. |",
-    "| Individual `llm_query` fails | Check error message. If credit/rate-limit, wait and retry once. If still failing, read files directly with `read`/`grep`. |",
-    "| `rlm_query` fails | Fall back to `llm_query` — it's a one-shot call that uses fewer resources. |",
-    "| All sub-LLMs exhausted | Read key files directly. For small repos (<20 files), direct reading is fine. For large repos, prioritize the most important files. |",
+    "- Architecture/code review: chunk relevant files and delegate summaries or review to `llm_query_batched`.",
+    "- Bug investigation: use Python string/regex search over `context`; delegate matching files for analysis.",
+    "- If sub-LLM credits are exhausted, report partial results and stop — do not bypass REPL restrictions.",
     "",
     "Reserve your own tokens for high-level decisions: what to ask next, how to combine sub-LLM outputs, when to finalize.",
     "Delegate everything else. Do not submit a final answer before inspecting `context`.",
@@ -252,12 +232,14 @@ export function buildNativeSystemPrompt(): string {
     "",
     "ABSOLUTE RESTRICTION: Do NOT use `read`, `grep`, or `bash` to access files.",
     "All file content is pre-loaded in the REPL `context` variable. Use ONLY `repl({code})`.",
-    "You may read at most 2 hub files directly (README.md, package.json) for quick orientation.",
     "If sub-LLM credits are exhausted → report the error to the user and stop.",
     "",
-    "ABSOLUTE RESTRICTION: Do NOT use `write` or `edit` to modify files directly.",
-    "All file modifications MUST go through apply_diff({diff}).",
-    "The diff MUST be a complete unified diff with --- a/<path> / +++ b/<path> header and @@ hunk markers.",
+    "For file changes, use `edit` (modify existing) or `write` (create new) — these route through",
+    "Pi's native tool flow, visible to all plugins with a `+/-` diff preview.",
+    "",
+    "When repl() returns a STAGED_EDITS block, apply each entry by calling `edit` verbatim:",
+    "  edit({ path: entry.path, edits: [{ oldText: entry.oldText, newText: entry.newText }] })",
+    "Do not analyze or modify the parameters — relay them exactly as provided by the sub-agent.",
     "",
     nativeReplGlossary(),
   ].join("\n");

package/src/sandbox/protocol.ts

@@ -32,10 +32,6 @@ export interface ProposedEdit {
   readonly newText: string;
 }
 
-export interface ProposedDiffEdit {
-  readonly diff: string;
-}
-
 /** A normal response to a request (keyed by the request `id`). */
 export interface WorkerResponse {
   readonly id: string;
@@ -47,7 +43,6 @@ export interface WorkerResponse {
   readonly final_answer?: string | null;
   readonly answer_content?: string;
   readonly edits?: readonly ProposedEdit[];
-  readonly diffs?: readonly ProposedDiffEdit[];
   readonly raised?: boolean;
   readonly execution_time?: number;
   // user-created variable names after this exec (filters builtins/context) — Metadata(stdout) for history orientation
@@ -183,7 +178,6 @@ export interface ReplResult {
   readonly finalAnswer: string | null;
   readonly answerContent: string;
   readonly edits: readonly ProposedEdit[];
-  readonly diffs: readonly ProposedDiffEdit[];
   readonly raised: boolean;
   readonly executionTimeMs: number;
   /** User-created variable names after this exec (builtins/context filtered out). */

package/src/sandbox/sandbox.ts

@@ -189,7 +189,6 @@ export class PythonSandbox {
       finalAnswer: res.final_answer ?? null,
       answerContent: res.answer_content ?? "",
       edits: res.edits ?? [],
-      diffs: res.diffs ?? [],
       raised: res.raised ?? false,
       executionTimeMs: Math.round((res.execution_time ?? 0) * 1000),
       varNames: res.var_names ?? [],

package/src/sandbox/worker.py

@@ -65,7 +65,8 @@ RESERVED = frozenset(
         "llm_query", "llm_query_batched", "rlm_query", "rlm_query_batched",
         "advance_phase",
         "ask_user_question", "todo",
-        "SHOW_EDITS", "SHOW_DIFFS", "SHOW_VARS", "answer", "context",
+        "stage_edit",
+        "SHOW_VARS", "answer", "context",
     }
 )
 
@@ -103,6 +104,7 @@ class Worker:
     def _setup(self) -> None:
         self.ns = {"__builtins__": _SAFE_BUILTINS.copy(), "__name__": "__main__"}
         self._ctx_payloads: dict[int, Any] = {}
+        self._staged_edits: list[dict[str, str]] = []
         self._restore_scaffold()
 
     def _capture_answer(self, content: Any) -> None:
@@ -118,8 +120,7 @@ class Worker:
         ns["advance_phase"] = self._advance_phase
         ns["ask_user_question"] = self._ask_user_question
         ns["todo"] = self._todo
-        ns["SHOW_EDITS"] = self._show_edits
-        ns["SHOW_DIFFS"] = self._show_diffs
+        ns["stage_edit"] = self._stage_edit
         ns["SHOW_VARS"] = self._show_vars
         if not isinstance(ns.get("answer"), _AnswerDict):
             cur = ns.get("answer")
@@ -153,12 +154,6 @@ class Worker:
         avail = {k: type(self.ns[k]).__name__ for k in self._user_var_names()}
         return f"Available variables: {avail}" if avail else "No variables created yet."
 
-    def _show_edits(self) -> str:
-        return "No edits — edit tools are not available in this run."
-
-    def _show_diffs(self) -> str:
-        return "No diffs — edit tools are not available in this run."
-
     # ---- sub-LLM bridge over stdio --------------------------------------------------------
 
     def _rpc(self, kind: str, payload: dict[str, Any]) -> dict[str, Any]:
@@ -263,6 +258,12 @@ class Worker:
             return f"Error: {r['error']}"
         return str(r.get("response", "ok"))
 
+    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)"
+
     def _advance_phase(self, phase: str, summary: str | None = None) -> str:
         """Transition the root RLM pipeline to a new phase.
 
@@ -348,6 +349,7 @@ class Worker:
                 stdout = out.getvalue()
                 stderr = err.getvalue() + f"\n{type(e).__name__}: {e}\n" + traceback.format_exc()
         final, self._final_answer = self._final_answer, None
+        edits, self._staged_edits = self._staged_edits, []
         answer = self.ns.get("answer")
         answer_content = answer.get("content", "") if isinstance(answer, dict) else ""
         return {
@@ -355,8 +357,7 @@ class Worker:
             "stderr": stderr,
             "final_answer": final,
             "answer_content": str(answer_content),
-            "edits": [],
-            "diffs": [],
+            "edits": edits,
             "raised": raised,
             "execution_time": time.perf_counter() - start,
             "var_names": self._user_var_names(),

package/src/tool/repl-details.ts

@@ -6,6 +6,7 @@
  * accumulated into the subcalls array for tree rendering.
  */
 
+import type { ProposedEdit } from "../sandbox/protocol.ts";
 import type { RlmSubcall } from "./rlm-details.ts";
 
 export interface ReplDetails {
@@ -20,4 +21,6 @@ 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(). */
+  readonly edits?: readonly ProposedEdit[];
 }

package/src/tool/repl-tool.ts

@@ -27,7 +27,7 @@ import { checkResourceLimits } from "../core/resource-limits.ts";
 import type { RlmConfig, Sampling } 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 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";
@@ -47,6 +47,10 @@ 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;
+}
+
 // ── Mutable bridge state (handler indirection) ──
 
 /**
@@ -411,6 +415,12 @@ 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 details: ReplDetails = {
           status: "done",
           output: result.stdout,
@@ -418,10 +428,11 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           executionTimeMs: elapsed,
           subcalls: store.getSubcalls(),
           totals: store.getTotals(),
+          edits: surfacedEdits,
         };
         // Final progressive update
         onUpdate?.({ content: [{ type: "text", text: result.stdout.slice(0, 500) || "(no output)" }], details });
-        return { content: [{ type: "text", text: result.stdout || result.answerContent || "(no output)" }], details };
+        return { content: [{ type: "text", text: baseText + editsBlock }], details };
       } catch (e) {
         progressStatus = "error";
         const msg = errorMessage(e);
@@ -477,6 +488,9 @@ function renderReplCollapsed(details: ReplDetails, theme: Theme): Text {
   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}`;
@@ -511,6 +525,15 @@ function renderReplExpanded(details: ReplDetails, theme: Theme): Container {
     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);
+    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));
+  }
+
   // Stderr
   if (details.stderr) {
     container.addChild(new Spacer(1));

package/src/tool/rlm-events.ts

@@ -2,8 +2,8 @@
  * RlmEmitter — typed EventEmitter wrapper for RLM lifecycle events.
  *
  * Replaces RlmToolBridge mutation methods. The engine and bridges emit typed
- * events instead of calling bridge.addSubcall/updateSubcall/etc. Listeners
- * (RlmEventAggregator, TelemetrySink) subscribe to build derived state.
+ * events instead of calling bridge.addSubcall/updateSubcall/etc. The
+ * RlmEventAggregator subscribes to build derived state.
  *
  * Node.js EventEmitter is synchronous — listeners run in registration order
  * during emit. No backpressure needed: engine events are sequential, one at
@@ -11,7 +11,6 @@
  */
 
 import { EventEmitter } from "node:events";
-import type { TelemetrySink } from "../telemetry/sink.ts";
 import type { SubcallKind, SubcallStatus, RlmRunStatus } from "./rlm-details.ts";
 import type { ProposedEdit } from "../sandbox/protocol.ts";
 
@@ -76,7 +75,6 @@ export interface RootPromptEvent {
  *
  * Auto-generates monotonic subcall IDs (`s1`, `s2`, …) via `emitSubcallCreated()`.
  * Provides typed `on*` methods that return unsubscribe functions.
- * `attachSink()` wires all events to a TelemetrySink and returns a detach function.
  */
 export class RlmEmitter {
   private readonly ee = new EventEmitter();
@@ -169,43 +167,6 @@ export class RlmEmitter {
     return () => { this.ee.off("root-prompt", handler); };
   }
 
-  // ── Sink integration ──
-
-  /**
-   * Wire all lifecycle events to a TelemetrySink.
-   * Returns a detach function that unsubscribes all sink listeners.
-   * The caller is responsible for calling `sink.shutdown()` after detaching.
-   */
-  attachSink(sink: TelemetrySink): () => void {
-    const unsubs: (() => void)[] = [];
-
-    unsubs.push(this.onSubcallCreated((event) => {
-      sink.start(event.id, {
-        kind: event.kind,
-        depth: event.depth,
-        parentId: event.parentId,
-        model: event.model,
-        label: event.label,
-        detail: event.detail,
-        args: event.args,
-      });
-    }));
-
-    unsubs.push(this.onSubcallUpdated((event) => {
-      if (event.costUsd !== undefined || event.tokens !== undefined) {
-        sink.usage(event.id, event.costUsd ?? 0, event.tokens ?? 0);
-      }
-      if (event.status !== undefined && event.status !== "running") {
-        sink.end(event.id, {
-          error: event.status === "error" ? (event.detail ?? "error") : undefined,
-          resultPreview: event.resultPreview,
-        });
-      }
-    }));
-
-    return () => { unsubs.forEach((fn) => fn()); };
-  }
-
   // ── Lifecycle ──
 
   /** Remove all listeners. Call after the run completes to prevent leaks. */

package/src/tool/rlm-tool.ts

@@ -11,7 +11,6 @@ import { Container, Markdown, Spacer, Text, type Component } from "@earendil-wor
 import { Type } from "typebox";
 import { createPiInteractiveDeps } from "../bridge/pi-interactive.ts";
 import type { RlmController, StartInput } from "../mode/rlm-mode.ts";
-import { createTelemetrySink } from "../telemetry/index.ts";
 import { formatCost, formatTokens, spinnerFrame } from "../ui/theme.ts";
 import { errorMessage } from "../util/errors.ts";
 import { type RlmDetails } from "./rlm-details.ts";
@@ -23,8 +22,6 @@ import {
   renderExpandedSubcallTree,
 } from "./subcall-render.ts";
 import { createProgressNotifier, validateToolParams } from "./tool-utils.ts";
-import { applyEdits } from "../patch/index.ts";
-import { tryExtractDiff } from "../core/answer.ts";
 
 // ── Parameter schema ──
 
@@ -63,11 +60,8 @@ export function createRlmTool(controller: RlmController): ToolDefinition<typeof
       if (!validation.ok) return validation.error;
       const params = validation.value;
 
-      const sink = await createTelemetrySink(controller.config.telemetry);
       const emitter = new RlmEmitter();
       const aggregator = new RlmEventAggregator(emitter, onUpdate ?? (() => {}));
-      let detachSink: (() => void) | undefined;
-      if (sink) detachSink = emitter.attachSink(sink);
       emitter.emitRootPrompt(params.prompt);
 
       // Wire abort signal to controller
@@ -98,10 +92,6 @@ export function createRlmTool(controller: RlmController): ToolDefinition<typeof
         const result = await done;
 
         emitter.emitAnswer(result.answer);
-        const proposedEdits = result.edits ?? [];
-        const proposedDiffs = result.diffs?.length ? result.diffs : tryExtractDiff(result.answer);
-        if (proposedEdits.length > 0) emitter.emitEdits(proposedEdits);
-        await applyEdits(proposedEdits, proposedDiffs, ctx);
 
         return {
           content: [{ type: "text", text: result.answer }],
@@ -116,11 +106,8 @@ export function createRlmTool(controller: RlmController): ToolDefinition<typeof
         };
       } finally {
         progress.stop();
-        detachSink?.();
         aggregator.dispose();
         emitter.shutdown();
-        try { await sink?.shutdown(); }
-        catch (err) { console.warn(`[rlm] telemetry shutdown failed: ${errorMessage(err)}`); }
       }
     },
 

package/src/ui/model-picker.ts

@@ -14,12 +14,19 @@ export interface ModelSelection {
 const LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
 type SelectableThinkingLevel = (typeof LEVELS)[number];
 
-function items(models: Model<Api>[]): SelectItem[] {
-  return models.map((m) => ({
+const CHEAPEST_VALUE = "__rlm_cheapest__";
+
+function items(models: Model<Api>[], includeCheapest = false): SelectItem[] {
+  const modelItems = models.map((m) => ({
     value: `${m.provider}/${m.id}`,
     label: `${m.provider}/${m.id}`,
     description: `in ${formatCost(m.cost.input)}/Mtok · out ${formatCost(m.cost.output)}/Mtok${m.reasoning ? " · reasoning" : ""}`,
   }));
+  if (!includeCheapest) return modelItems;
+  return [
+    { value: CHEAPEST_VALUE, label: "⟳ cheapest (auto)", description: "Always use the cheapest available model" },
+    ...modelItems,
+  ];
 }
 
 function supportedThinkingLevels(model: Model<Api>): SelectableThinkingLevel[] {
@@ -75,7 +82,7 @@ export async function selectModel(
   models: Model<Api>[],
   current?: Model<Api>,
   currentThinking?: ThinkingLevel,
-): Promise<ModelSelection | undefined> {
+): Promise<ModelSelection | null | undefined> {
   if (models.length === 0) {
     ctx.ui.notify("RLM: no models with configured auth", "warning");
     return undefined;
@@ -96,7 +103,7 @@ export async function selectModel(
       render: (w) => [truncateToWidth(theme.fg("dim", `Filter: ${query || "type to filter…"}`), w)],
       invalidate: () => {},
     };
-    const list = new SelectList(items(models), Math.min(models.length, 12), {
+    const list = new SelectList(items(models, true), Math.min(models.length + 1, 13), {
       selectedPrefix: (t) => theme.fg("accent", t),
       selectedText: (t) => theme.fg("accent", t),
       description: (t) => theme.fg("muted", t),
@@ -133,6 +140,7 @@ export async function selectModel(
     };
   });
 
+  if (chosen === CHEAPEST_VALUE) return null;
   const model = chosen ? models.find((m) => `${m.provider}/${m.id}` === chosen) : undefined;
   if (!model) return undefined;
   return { model, thinkingLevel: await selectThinkingLevel(ctx, model, currentThinking) };

package/src/patch/apply.ts

@@ -1,148 +0,0 @@
-/**
- * Applies RLM-proposed edits to disk.
- *
- * Two edit kinds from the sandbox protocol:
- *   ProposedEdit      — oldText / newText anchor replacement
- *   ProposedDiffEdit  — unified diff string (applied via `diff.applyPatch`)
- *
- * Returns a Result. Caller decides whether to show errors in UI.
- */
-
-import { readFile, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import * as Diff from "diff";
-import type { ProposedDiffEdit, ProposedEdit } from "../sandbox/protocol.ts";
-import { err, ok, type Result } from "../util/errors.ts";
-
-// ── Shared private helpers ─────────────────────────────────────────────────
-
-/** Normalise to LF so string-replace is CRLF-safe. */
-function toLF(s: string): string {
-  return s.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-
-/** Restore original line endings after replacement. */
-function restoreEndings(s: string, crlf: boolean): string {
-  return crlf ? s.replace(/\n/g, "\r\n") : s;
-}
-
-function hasCRLF(s: string): boolean {
-  return s.includes("\r\n");
-}
-
-// ── ApplyResult ─────────────────────────────────────────────────────────────
-
-export interface ApplySuccess {
-  readonly applied: number;
-}
-
-export interface ApplyFailure {
-  readonly failures: ReadonlyArray<{ readonly path: string; readonly reason: string }>;
-}
-
-export type ApplyResult = Result<ApplySuccess, ApplyFailure>;
-
-// ── Generic accumulator (shared by anchor + diff apply) ─────────────────────
-
-/**
- * Runs `applyOne` for every item, tallying successes and collecting failures.
- * The only thing that differs between anchor and diff apply is the per-item
- * helper and the failure-path key — both passed in, so the loop is written once.
- */
-async function applyAll<T>(
-  items: readonly T[],
-  applyOne: (item: T, cwd: string) => Promise<Result<void, string>>,
-  getKey: (item: T) => string,
-  cwd: string,
-): Promise<ApplyResult> {
-  const failures: Array<{ readonly path: string; readonly reason: string }> = [];
-  let applied = 0;
-  for (const item of items) {
-    const r = await applyOne(item, cwd);
-    if (r.ok) {
-      applied++;
-    } else {
-      failures.push({ path: getKey(item), reason: r.error });
-    }
-  }
-  return failures.length === 0 ? ok({ applied }) : err({ failures });
-}
-
-// ── ProposedEdit (oldText / newText) ────────────────────────────────────────
-
-async function applySingleAnchor(
-  edit: ProposedEdit,
-  cwd: string,
-): Promise<Result<void, string>> {
-  const abs = resolve(cwd, edit.path);
-  let raw: string;
-  try {
-    raw = await readFile(abs, "utf8");
-  } catch (e) {
-    return err(`read error: ${e instanceof Error ? e.message : String(e)}`);
-  }
-  const crlf = hasCRLF(raw);
-  const content = toLF(raw);
-  const needle = toLF(edit.oldText);
-  if (!content.includes(needle)) {
-    return err(`oldText not found in ${edit.path}`);
-  }
-  const replaced = content.replace(needle, toLF(edit.newText));
-  try {
-    await writeFile(abs, restoreEndings(replaced, crlf), "utf8");
-    return ok(undefined);
-  } catch (e) {
-    return err(`write error: ${e instanceof Error ? e.message : String(e)}`);
-  }
-}
-
-export function applyAnchorEdits(
-  edits: readonly ProposedEdit[],
-  cwd: string,
-): Promise<ApplyResult> {
-  return applyAll(edits, applySingleAnchor, (e) => e.path, cwd);
-}
-
-// ── ProposedDiffEdit (unified diff string) ──────────────────────────────────
-
-async function applySingleDiff(
-  diffEdit: ProposedDiffEdit,
-  cwd: string,
-): Promise<Result<void, string>> {
-  // Extract file path from diff header: "--- a/path" or "--- path"
-  const match = /^--- (?:a\/)?(.+)$/m.exec(diffEdit.diff);
-  const relPath = match?.[1]?.trim();
-  if (relPath === undefined) {
-    return err("diff has no '---' header; cannot determine target file");
-  }
-  const abs = resolve(cwd, relPath);
-  let raw: string;
-  try {
-    raw = await readFile(abs, "utf8");
-  } catch (e) {
-    return err(`read error: ${e instanceof Error ? e.message : String(e)}`);
-  }
-  const crlf = hasCRLF(raw);
-  let patched: string | false;
-  try {
-    patched = Diff.applyPatch(toLF(raw), diffEdit.diff);
-  } catch (e) {
-    return err(`invalid diff — ${e instanceof Error ? e.message : String(e)}`);
-  }
-  if (patched === false) {
-    return err(`patch does not apply cleanly to ${relPath}`);
-  }
-  try {
-    await writeFile(abs, restoreEndings(patched, crlf), "utf8");
-    return ok(undefined);
-  } catch (e) {
-    return err(`write error: ${e instanceof Error ? e.message : String(e)}`);
-  }
-}
-
-export function applyDiffEdits(
-  diffs: readonly ProposedDiffEdit[],
-  cwd: string,
-): Promise<ApplyResult> {
-  return applyAll(diffs, applySingleDiff, (d) => d.diff.slice(0, 40), cwd);
-}

package/src/patch/index.ts

@@ -1,37 +0,0 @@
-/**
- * applyEdits — THE single call site for applying proposed edits/diffs.
- *
- * Both rlm-tool.ts and rlm.ts must call this and nothing else.
- * No duplication allowed.
- */
-
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { ProposedDiffEdit, ProposedEdit } from "../sandbox/protocol.ts";
-import { applyAnchorEdits, applyDiffEdits, type ApplyResult } from "./apply.ts";
-
-/** Surface an apply outcome through a single notify — used for both edit kinds. */
-function notifyApplyResult(r: ApplyResult, label: string, ctx: ExtensionContext): void {
-  if (!r.ok) {
-    const lines = r.error.failures.map((f) => `• ${f.path}: ${f.reason}`);
-    ctx.ui.notify(`Some ${label}s failed:\n${lines.join("\n")}`, "error");
-  } else {
-    ctx.ui.notify(`Applied ${r.value.applied} ${label}${r.value.applied !== 1 ? "s" : ""}.`, "info");
-  }
-}
-
-export async function applyEdits(
-  edits: readonly ProposedEdit[],
-  diffs: readonly ProposedDiffEdit[],
-  ctx: ExtensionContext,
-): Promise<void> {
-  const hasEdits = edits.length > 0 || diffs.length > 0;
-  if (!hasEdits) return;
-  const cwd = ctx.cwd ?? process.cwd();
-
-  if (edits.length > 0) {
-    notifyApplyResult(await applyAnchorEdits(edits, cwd), "edit", ctx);
-  }
-  if (diffs.length > 0) {
-    notifyApplyResult(await applyDiffEdits(diffs, cwd), "diff", ctx);
-  }
-}

package/src/state/events.ts

@@ -1,22 +0,0 @@
-/**
- * SubcallStart — parameter object carried forward for telemetry compatibility.
- *
- * The SubcallObserver interface, treeObserver(), observerWith(), and NOOP_OBSERVER
- * have been removed. The engine and bridges now call RlmToolBridge directly.
- */
-
-import type { SubcallKind } from "../tool/rlm-details.ts";
-
-export interface SubcallStart {
-  readonly kind: SubcallKind;
-  readonly depth: number;
-  readonly parentId?: string;
-  readonly model?: string;
-  readonly label: string;
-  readonly detail?: string;
-  readonly args?: string;
-  /** Run ID for the root node — lets MLflow correlate a resumed trace with the original. */
-  readonly runId?: string;
-  /** True when this is a resumed root node (not a fresh start). */
-  readonly resume?: boolean;
-}