@hicaru/pi-rlm 0.1.8 → 0.1.9

package/src/tool/repl-tool.ts

@@ -28,14 +28,13 @@ import { checkResourceLimits } from "../core/resource-limits.ts";
 import type { InteractiveDeps, RlmConfig, Sampling } 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 {
   headlineStatusGlyph,
@@ -51,59 +50,44 @@ 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) ──
@@ -214,6 +198,7 @@ class NativeBridgeState {
         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;
       },
@@ -337,7 +322,6 @@ 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;
@@ -347,7 +331,7 @@ 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, config, signal, onUsage } = deps;
   const bridgeState = new NativeBridgeState();
 
   // Late-bound cwd — getOrCreate installs handlers only at spawn; never rebuild the closure.
@@ -508,14 +492,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 +506,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)`
@@ -588,9 +569,6 @@ 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}`;
@@ -625,13 +603,9 @@ 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);
+  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

package/src/tool/rlm-aggregator.ts

@@ -6,14 +6,14 @@
  * getState(): RlmDetails for direct access (spinner loop, final return).
  *
  * Subcall storage and totals are delegated to SubcallStore. Root-level state
- * (status, prompt, turns, answer, edits) is kept in the aggregator.
+ * (status, prompt, turns, answer, warnings) is kept in the aggregator.
  *
  * Replaces RlmToolBridge's internal state accumulation. The emitter is pure
  * dispatch; the aggregator is pure state. Separated for independent testing.
  */
 
 import type { AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
-import type { RlmEmitter, TurnEvent, RootUsageEvent, AnswerEvent, EditsEvent, StatusEvent, RootPromptEvent } from "./rlm-events.ts";
+import type { RlmEmitter, TurnEvent, RootUsageEvent, AnswerEvent, StatusEvent, RootPromptEvent, WarningsEvent } from "./rlm-events.ts";
 import type { RlmDetails, RlmRunStatus } from "./rlm-details.ts";
 import { EmitterListener } from "./emitter-listener.ts";
 import { SubcallStore } from "./subcall-store.ts";
@@ -27,7 +27,7 @@ export class RlmEventAggregator extends EmitterListener {
   private turnCurrent = 0;
   private turnMax = 0;
   private answer?: string;
-  private edits: RlmDetails["edits"] = [];
+  private warnings?: readonly string[];
 
   constructor(
     emitter: RlmEmitter,
@@ -40,7 +40,7 @@ export class RlmEventAggregator extends EmitterListener {
       emitter.onTurn((e) => this.handleTurn(e)),
       emitter.onRootUsage((e) => this.handleRootUsage(e)),
       emitter.onAnswer((e) => this.handleAnswer(e)),
-      emitter.onEdits((e) => this.handleEdits(e)),
+      emitter.onWarnings((e) => this.handleWarnings(e)),
       emitter.onStatus((e) => this.handleStatus(e)),
       emitter.onRootPrompt((e) => this.handleRootPrompt(e)),
     ]);
@@ -64,8 +64,8 @@ export class RlmEventAggregator extends EmitterListener {
     this.notify();
   }
 
-  private handleEdits(event: EditsEvent): void {
-    this.edits = event.edits;
+  private handleWarnings(event: WarningsEvent): void {
+    this.warnings = event.warnings;
     this.notify();
   }
 
@@ -90,7 +90,7 @@ export class RlmEventAggregator extends EmitterListener {
       subcalls: this.store.getSubcalls(),
       totals: this.store.getTotals(),
       answer: this.answer,
-      edits: this.edits,
+      warnings: this.warnings,
     };
   }
 

package/src/tool/rlm-details.ts

@@ -6,8 +6,6 @@
  * after every mutation, enabling Pi's built-in progressive TUI re-render.
  */
 
-import type { ProposedEdit } from "../sandbox/protocol.ts";
-
 export type SubcallKind = "root" | "rlm" | "llm" | "batch" | "tool";
 export type SubcallStatus = "running" | "done" | "error";
 export type RlmRunStatus = "running" | "done" | "error" | "aborted";
@@ -29,6 +27,10 @@ export interface RlmSubcall {
   readonly endedAt?: number;
   readonly costUsd: number;
   readonly tokens: number;
+  /** For batch subcalls: failed prompt count (partial failure). */
+  readonly failedCount?: number;
+  /** For batch subcalls: total prompt count. */
+  readonly totalCount?: number;
 }
 
 export interface RlmDetails {
@@ -38,7 +40,8 @@ export interface RlmDetails {
   readonly subcalls: readonly RlmSubcall[];
   readonly totals: { readonly costUsd: number; readonly tokens: number };
   readonly answer?: string;
-  readonly edits?: readonly ProposedEdit[];
+  /** Advisory diagnostics — surfaced to the user, never a failure. */
+  readonly warnings?: readonly string[];
 }
 
 export interface SubcallInit {

package/src/tool/rlm-events.ts

@@ -12,7 +12,6 @@
 
 import { EventEmitter } from "node:events";
 import type { SubcallKind, SubcallStatus, RlmRunStatus } from "./rlm-details.ts";
-import type { ProposedEdit } from "../sandbox/protocol.ts";
 
 // ── Event payloads ──
 
@@ -40,6 +39,14 @@ export interface SubcallUpdatedEvent {
   readonly costUsd?: number;
   /** Delta — additive on both the subcall and running totals. */
   readonly tokens?: number;
+  /** For batch subcalls: failed prompt count. */
+  readonly failedCount?: number;
+  /** For batch subcalls: total prompt count. */
+  readonly totalCount?: number;
+}
+
+export interface WarningsEvent {
+  readonly warnings: readonly string[];
 }
 
 export interface TurnEvent {
@@ -56,10 +63,6 @@ export interface AnswerEvent {
   readonly text: string;
 }
 
-export interface EditsEvent {
-  readonly edits: readonly ProposedEdit[];
-}
-
 export interface StatusEvent {
   readonly status: RlmRunStatus;
 }
@@ -110,9 +113,9 @@ export class RlmEmitter {
     this.ee.emit("answer", { text } satisfies AnswerEvent);
   }
 
-  /** Set proposed edits (root-only). */
-  emitEdits(edits: readonly ProposedEdit[]): void {
-    this.ee.emit("edits", { edits } satisfies EditsEvent);
+  /** Set advisory warnings (root-only; never a failure). */
+  emitWarnings(warnings: readonly string[]): void {
+    this.ee.emit("warnings", { warnings } satisfies WarningsEvent);
   }
 
   /** Set the root run status (done/error/aborted). */
@@ -152,9 +155,9 @@ export class RlmEmitter {
     return () => { this.ee.off("answer", handler); };
   }
 
-  onEdits(handler: (event: EditsEvent) => void): () => void {
-    this.ee.on("edits", handler);
-    return () => { this.ee.off("edits", handler); };
+  onWarnings(handler: (event: WarningsEvent) => void): () => void {
+    this.ee.on("warnings", handler);
+    return () => { this.ee.off("warnings", handler); };
   }
 
   onStatus(handler: (event: StatusEvent) => void): () => void {

package/src/tool/rlm-tool.ts

@@ -156,14 +156,9 @@ function renderExpanded(details: RlmDetails, theme: Theme): Component {
     container.addChild(new Markdown(details.answer, 0, 0, getMarkdownTheme()));
   }
 
-  if (details.edits && details.edits.length > 0) {
+  if (details.warnings && details.warnings.length > 0) {
     container.addChild(new Spacer(1));
-    const editFiles = new Set(details.edits.map(e => e.path));
-    container.addChild(new Text(
-      theme.fg("muted", "─── Edits ───") +
-      `\n  ${theme.fg("dim", `${details.edits.length} edit${details.edits.length > 1 ? "s" : ""} proposed across ${editFiles.size} file${editFiles.size > 1 ? "s" : ""}`)}`,
-      0, 0,
-    ));
+    container.addChild(new Text(theme.fg("muted", details.warnings.join("\n")), 0, 0));
   }
 
   return container;

package/src/tool/subcall-store.ts

@@ -66,6 +66,8 @@ export class SubcallStore extends EmitterListener {
       sc.tokens += event.tokens;
       this.totalTokens += event.tokens;
     }
+    if (event.failedCount !== undefined) sc.failedCount = event.failedCount;
+    if (event.totalCount !== undefined) sc.totalCount = event.totalCount;
   }
 
   // ── Read ──

package/src/ui/config-panel.ts

@@ -41,7 +41,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 artifact-gated phases: clarify→research→blueprint→implement fanout→validate (clarify needs Ask user on)."),
+    item("pipeline", "Phase pipeline", config.pipeline ? "on" : "off", CHOICES.pipeline, "Enable artifact-gated phases: clarify→research→blueprint→validate (read-only plan pipeline; clarify needs Ask user on)."),
     item("maxBackwardJumps", "Max validate→blueprint loops", String(config.maxBackwardJumps), CHOICES.maxBackwardJumps, "Bounded corrective re-entries when validation reports blockers_count > 0."),
     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."),
@@ -49,7 +49,7 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
     item("askUserQuestion", "[Interactive] Ask user", config.askUserQuestion ? "on" : "off", CHOICES.askUserQuestion, "Allow root REPL code to present structured ask_user_question dialogs."),
     item("todo", "[Interactive] Todo", config.todo ? "on" : "off", CHOICES.todo, "Allow REPL code to manage a visible todo task list."),
     item("libraryLoader", "Library loader", config.libraryLoader ? "on" : "off", CHOICES.libraryLoader,
-      "Allow load_library() to pull an external dir, file, or git repo into a new context_N slot."),
+      "Allow load_library() to pull an external dir, file, or git repo into the shared context list."),
     item("__save__", "Save & close", "↵", ["↵"], "Save these settings and close (Esc also saves)."),
   ];
 

package/src/registry/edit-registry.ts

@@ -1,22 +0,0 @@
-import type { ProposedEdit } from "../sandbox/protocol.ts";
-
-export class EditRegistry {
-  private readonly edits = new Map<string, ProposedEdit>();
-
-  registerAll(edits: readonly ProposedEdit[] | undefined): void {
-    if (edits === undefined) return;
-    for (const edit of edits) this.edits.set(edit.id, edit);
-  }
-
-  get(id: string): ProposedEdit | undefined {
-    return this.edits.get(id);
-  }
-
-  delete(id: string): boolean {
-    return this.edits.delete(id);
-  }
-
-  clear(): void {
-    this.edits.clear();
-  }
-}

package/src/text/edits.ts

@@ -1,164 +0,0 @@
-import { access, mkdir, readFile, writeFile } from "node:fs/promises";
-import { constants } from "node:fs";
-import { dirname, resolve } from "node:path";
-import type { ProposedEdit } from "../sandbox/protocol.ts";
-import { errorMessage, formatError } from "../util/errors.ts";
-
-export interface AnchorEdit {
-  readonly oldText: string;
-  readonly newText: string;
-}
-
-export function countOccurrences(haystack: string, needle: string): number {
-  if (needle.length === 0) return 0;
-  let count = 0;
-  let offset = 0;
-  for (;;) {
-    const match = haystack.indexOf(needle, offset);
-    if (match < 0) return count;
-    count++;
-    offset = match + needle.length;
-  }
-}
-
-/**
- * Literal string replace of the first occurrence of `oldText` with `newText`.
- * Splice-based so `$&` / `$$` / `$'` in newText are NOT treated as
- * special replacement patterns (String.prototype.replace string-form hazard).
- */
-export function replaceOnceLiteral(content: string, oldText: string, newText: string): string {
-  const idx = content.indexOf(oldText);
-  if (idx < 0) return content;
-  return content.slice(0, idx) + newText + content.slice(idx + oldText.length);
-}
-
-export type PlanEditResult =
-  | {
-      readonly ok: true;
-      /** create = new file; replace = one-shot anchor swap; already-applied = idempotent skip */
-      readonly kind: "create" | "replace" | "already-applied";
-      readonly before: string;
-      readonly after: string;
-    }
-  | { readonly ok: false; readonly error: string };
-
-async function pathExists(abs: string): Promise<boolean> {
-  try {
-    await access(abs, constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Validate and compute an edit without writing.
- * Shared by headless apply and the native apply_edits tool (DRY).
- *
- * Idempotent retry: if a prior unit already landed the change
- * (oldText absent + newText already present for replace; create with identical content),
- * returns kind "already-applied" so a failed fanout can be retried without wedging.
- *
- * Create-file: refuses to clobber when the target exists with different content.
- */
-export async function planEdit(
-  cwd: string,
-  path: string,
-  oldText: string,
-  newText: string,
-): Promise<PlanEditResult> {
-  try {
-    const fullPath = resolve(cwd, path);
-    if (oldText.length === 0) {
-      if (await pathExists(fullPath)) {
-        const existing = await readFile(fullPath, "utf8");
-        if (existing === newText) {
-          return { ok: true, kind: "already-applied", before: existing, after: existing };
-        }
-        return {
-          ok: false,
-          error: formatError(
-            `${path}: file already exists with different content — refuse to clobber (create requires empty target or identical content)`,
-          ),
-        };
-      }
-      return { ok: true, kind: "create", before: "", after: newText };
-    }
-
-    const content = await readFile(fullPath, "utf8");
-    const occurrences = countOccurrences(content, oldText);
-    if (occurrences === 0) {
-      // Idempotent skip: prior apply already removed the anchor and left newText.
-      // Deletions (newText === "") always "include" empty string — treat them as
-      // retry-unsafe so a typo'd anchor fails instead of silently skipping.
-      if (newText.length > 0 && content.includes(newText)) {
-        return { ok: true, kind: "already-applied", before: content, after: content };
-      }
-      return { ok: false, error: formatError(`anchor occurs 0 times in ${path}`) };
-    }
-    if (occurrences !== 1) {
-      return { ok: false, error: formatError(`anchor occurs ${occurrences} times in ${path}`) };
-    }
-    const after = replaceOnceLiteral(content, oldText, newText);
-    return { ok: true, kind: "replace", before: content, after };
-  } catch (err: unknown) {
-    return { ok: false, error: formatError(`${path}: ${errorMessage(err)}`) };
-  }
-}
-
-export type ApplyOneEditResult =
-  | { readonly ok: true; readonly before: string; readonly after: string; readonly kind: "create" | "replace" | "already-applied" }
-  | { readonly ok: false; readonly error: string };
-
-/**
- * Apply a single anchor edit to the working tree (direct disk write).
- * Used by the implement fanout and any headless apply path.
- */
-export async function applyOneEdit(
-  cwd: string,
-  path: string,
-  oldText: string,
-  newText: string,
-): Promise<ApplyOneEditResult> {
-  const planned = await planEdit(cwd, path, oldText, newText);
-  if (!planned.ok) return planned;
-  if (planned.kind === "already-applied") {
-    return { ok: true, before: planned.before, after: planned.after, kind: "already-applied" };
-  }
-  try {
-    const fullPath = resolve(cwd, path);
-    if (planned.kind === "create") {
-      await mkdir(dirname(fullPath), { recursive: true });
-    }
-    await writeFile(fullPath, planned.after, "utf8");
-    return { ok: true, before: planned.before, after: planned.after, kind: planned.kind };
-  } catch (err: unknown) {
-    return { ok: false, error: formatError(`${path}: ${errorMessage(err)}`) };
-  }
-}
-
-export type ApplyProposedEditsResult =
-  | { readonly ok: true; readonly applied: number }
-  | { readonly ok: false; readonly error: string; readonly applied: number };
-
-/**
- * Apply a series of proposed edits to the working tree (patch series, not a race).
- * Shared by the implement fanout and any headless apply path.
- * Safe to re-run: already-applied units succeed without re-writing.
- */
-export async function applyProposedEdits(
-  edits: readonly ProposedEdit[],
-  cwd: string,
-): Promise<ApplyProposedEditsResult> {
-  let applied = 0;
-  for (let i = 0; i < edits.length; i++) {
-    const edit = edits[i];
-    if (edit === undefined) continue;
-    const one = await applyOneEdit(cwd, edit.path, edit.oldText, edit.newText);
-    if (!one.ok) {
-      return { ok: false, error: one.error, applied };
-    }
-    applied++;
-  }
-  return { ok: true, applied };
-}