ucode-agent 1.54.0 → 1.56.0

package/src/core/window.js

@@ -87,10 +87,12 @@ function cutPoint(messages, budget) {
  * @param {Array} messages
  * @param {object} o
  * @param {number} o.limit          token budget
- * @param {Function} o.summarize    async (older) => string
+ * @param {Function} o.summarize    async (older, previousSummary) => string
+ * @param {boolean}  [o.force]      fold even below the threshold — the provider
+ *                                  has already said the request is too big
  */
-export async function fold(messages, { limit, summarize }) {
-  if (!tooBig(messages, limit)) return { messages, folded: false };
+export async function fold(messages, { limit, summarize, force = false }) {
+  if (!force && !tooBig(messages, limit)) return { messages, folded: false };
 
   // Half the size that triggered the fold, so there is room to work before
   // the next one. Sized off the same absolute rule, or a fold on a
@@ -103,7 +105,10 @@ export async function fold(messages, { limit, summarize }) {
   // Nothing old enough to fold — the tail on its own is already oversized.
   if (older.length === 0) return { messages, folded: false };
 
-  const summary = await summarize(older);
+  // A second fold must not summarize the first summary as if it were chat:
+  // it is handed over as the prior summary, to be merged rather than retold.
+  const previous = older.find((m) => m.folded)?.summary ?? null;
+  const summary = await summarize(older.filter((m) => !m.folded), previous);
 
   return {
     folded: true,
@@ -117,19 +122,87 @@ export async function fold(messages, { limit, summarize }) {
           `were folded away to stay inside the context window.\n\n${summary}\n\n` +
           'Treat all of that as settled context. Everything after this point is verbatim.',
         folded: true,
+        summary,
       },
       ...recent,
     ],
   };
 }
 
-/** What the summarizer is asked to do. */
-export const SUMMARY_PROMPT =
-  'Summarize this conversation so another engineer could pick it up mid-task with ' +
-  'nothing else to go on. Keep, in this order: (1) what the user is trying to achieve, ' +
-  '(2) which files were read or changed and what is in them, (3) decisions taken and the ' +
-  'reasoning, (4) commands run and what they printed, (5) what is still unfinished. ' +
-  'Name exact paths, functions and error messages. No preamble, no commentary.';
+/**
+ * What the summarizer is asked to do: opencode's anchored summary (MIT, see
+ * THIRD_PARTY_NOTICES.md). Fixed sections mean nothing gets dropped because
+ * the summarizer found it dull — the next step and the files that matter
+ * always have a place — and a second fold merges into the first instead of
+ * summarizing a summary.
+ */
+export const SUMMARY_PROMPT = `You summarize a coding session so another coding agent can continue the work with nothing else to go on.
+
+Output exactly the Markdown structure shown inside <template> and keep the section order unchanged. Do not include the <template> tags in your response.
+<template>
+## Objective
+- [one or two brief sentences describing what the user is trying to accomplish]
+
+## Important Details
+- [constraints/preferences, decisions and why, important facts/assumptions, exact context needed to continue, or "(none)"]
+
+## Work State
+### Completed
+- [finished work, verified facts, or changes made; otherwise "(none)"]
+
+### Active
+- [current work, partial changes, or investigation state; otherwise "(none)"]
+
+### Blocked
+- [blockers, failing commands, or unknowns; otherwise "(none)"]
+
+## Next Move
+1. [immediate concrete action, or "(none)"]
+2. [next action if known, or "(none)"]
+
+## Relevant Files
+- [file or directory path: why it matters, or "(none)"]
+</template>
+
+Rules:
+- Keep every section, even when empty.
+- Use terse bullets, not prose paragraphs.
+- Preserve exact file paths, symbols, commands, error strings, URLs, and identifiers when known.
+- Do not mention the summary process or that context was compacted.`;
+
+const MERGE = `The <prior-summary> summarizes everything that happened before the <conversation>. Construct a new summary that combines both. The <prior-summary> is discarded after this: anything you do not carry into the new summary is lost.
+
+When combining:
+- Carry forward objectives, constraints, user directives, decisions, and parallel workstreams from the <prior-summary> even when the <conversation> does not mention them. Drop only what is finished and no longer needed.
+- The <conversation> is more recent than the <prior-summary>. Where they conflict, the conversation wins: state the corrected fact and drop the old claim.
+- Add new progress, decisions, constraints, and context from the conversation.
+- Move completed work from "Active" to "Completed".
+- If a blocker has been resolved, update the summary to reflect that while keeping any details still needed to continue the work.
+- Update "Objective" and "Next Move" to reflect the current work state.`;
+
+/** The summarizer's user message: the conversation, and the summary it extends if there is one. */
+export function summaryRequest(conversation, previous = null) {
+  // File contents are in there too. One carrying "</conversation>" must not
+  // close the section early and speak to the summarizer as if it were us.
+  const fence = (s) => String(s).replace(/<\/?(?:conversation|prior-summary)>/gi, '');
+  conversation = fence(conversation);
+  if (previous) previous = fence(previous);
+  const parts = [`Here is the conversation so far:
+
+<conversation>
+${conversation}
+</conversation>`];
+  if (previous) {
+    parts.push(`Here is the summary of the conversation before the <conversation> above:
+
+<prior-summary>
+${previous}
+</prior-summary>`, MERGE);
+  } else {
+    parts.push('Create a new anchored summary from the conversation history in the <conversation> tags above so another coding agent can continue the work.');
+  }
+  return parts.join('\n\n');
+}
 
 /**
  * Flatten the messages being folded into plain text for the summarizer.

package/src/tools/files.js

@@ -17,8 +17,29 @@ import {
   noteFile, writeTracked, assertUnchanged,
 } from './shared.js';
 import { packageJsonWritten } from './shell.js';
+import { fuzzyReplace } from './fuzzy.js';
 import { parse as parseSource } from '@babel/parser';
 
+/**
+ * Up to three names beside a missing file that look like what was meant —
+ * "App.jsx" for "app.jsx", "index.html" for "index.htm". Named in the refusal
+ * (as opencode's read tool does), the next step is the right read instead of
+ * a list_dir to find out.
+ */
+async function lookalikes(target) {
+  const dir = path.dirname(target.abs);
+  const base = path.basename(target.abs).toLowerCase();
+  const shown = path.dirname(target.show);
+  try {
+    return (await fs.readdir(dir))
+      .filter((n) => n.toLowerCase().includes(base) || (n.length > 2 && base.includes(n.toLowerCase())))
+      .slice(0, 3)
+      .map((n) => (shown === '.' ? n : `${shown}/${n}`));
+  } catch {
+    return [];
+  }
+}
+
 export async function readFile({ path: p, offset = 1, limit = READ_LINES }) {
   const target = resolveIn(p, 'read_file');
   await guard(target, `read ${target.abs}`);
@@ -28,7 +49,12 @@ export async function readFile({ path: p, offset = 1, limit = READ_LINES }) {
   try {
     stat = await fs.stat(target.abs);
   } catch (err) {
-    throw fsFailure(err, attempted, target.show);
+    const failure = fsFailure(err, attempted, target.show);
+    // Outside the project the user said yes to one path, not to a listing of
+    // the folder around it — so no lookalikes there.
+    const near = err?.code === 'ENOENT' && target.inside ? await lookalikes(target) : [];
+    if (near.length) failure.fix = `Did you mean ${near.join(', ')}? ${failure.fix}`;
+    throw failure;
   }
 
   if (stat.isDirectory()) {
@@ -444,7 +470,7 @@ function explainMiss(original, oldString, show) {
 }
 
 /** Apply one replacement to a string, or explain precisely why it cannot. */
-function replaceOnce(text, { old_string, new_string }, { show, attempted, label = '' }) {
+function replaceOnce(text, { old_string, new_string, replace_all }, { show, attempted, label = '' }) {
   const prefix = label ? `${label}: ` : '';
 
   if (typeof old_string !== 'string' || typeof new_string !== 'string') {
@@ -467,7 +493,7 @@ function replaceOnce(text, { old_string, new_string }, { show, attempted, label
   // for exactly this loop. Saying "already done" ends it in one step.
   if (old_string === new_string) {
     const found = text.indexOf(old_string);
-    return { text, at: found < 0 ? 1 : toLines(text.slice(0, found)).length, loose: false };
+    return { text, at: found < 0 ? 1 : toLines(text.slice(0, found)).length, how: '', count: 0 };
   }
 
   // Models write \n. A file checked out on Windows is often \r\n, and then an
@@ -486,21 +512,45 @@ function replaceOnce(text, { old_string, new_string }, { show, attempted, label
     detail: { hits },
   });
 
+  // replace_all is for renames: every copy changes, and many copies is the point.
+  const all = replace_all === true || replace_all === 'true';
   const hits = text.split(oldText).length - 1;
-  if (hits > 1) throw ambiguous(hits);
-  if (hits === 1) {
+  if (hits > 1 && !all) throw ambiguous(hits);
+  if (hits >= 1) {
     const at = text.slice(0, text.indexOf(oldText)).split(/\r?\n/).length;
-    return { text: text.replace(oldText, () => newText), at, loose: false };
+    const out = all ? text.split(oldText).join(newText) : text.replace(oldText, () => newText);
+    return { text: out, at, how: '', count: hits };
   }
 
   // No exact match. The commonest reason by far is whitespace — tabs against
   // spaces, a different indent depth, trailing spaces — with every word right.
   // Match line by line ignoring that, and re-indent the replacement to fit.
   // Still unique or nothing: a loose match found twice is refused like any other.
-  const loose = looseReplace(text, old_string, new_string);
-  if (loose?.count === 1) return { text: loose.text, at: loose.at, loose: true };
+  const loose = all ? null : looseReplace(text, old_string, new_string);
+  if (loose?.count === 1) {
+    return { text: loose.text, at: loose.at, how: 'ignoring whitespace and re-indented to fit', count: 1 };
+  }
   if (loose?.count > 1) throw ambiguous(loose.count, ' once whitespace is ignored');
 
+  // Still nothing. The remaining slips — a middle line remembered slightly
+  // wrong, escapes written out, a blank line at either end — each have a
+  // matcher of their own (fuzzy.js). They are given the edit in the file's
+  // own line endings, and only the matched span changes: the rest of a file
+  // with mixed endings keeps every one it had.
+  const fuzzy = fuzzyReplace(text, oldText, newText, { all });
+  if (fuzzy?.ambiguous) throw ambiguous('several', ' once matched loosely');
+  if (fuzzy?.wide) {
+    throw new ToolFailure({
+      kind: 'no_match', attempted,
+      failed: `${prefix}old_string only matches ${show} loosely, across far more text than it contains. Refusing to replace that much.`,
+      fix: `Read ${show} again and copy the exact text you mean to replace.`,
+    });
+  }
+  if (fuzzy) {
+    const at = text.slice(0, fuzzy.index).split('\n').length;
+    return { text: fuzzy.text, at, how: fuzzy.how, count: fuzzy.count };
+  }
+
   const { failed, fix } = explainMiss(text, old_string, show);
   throw new ToolFailure({ kind: 'no_match', attempted, failed: prefix + failed, fix });
 }
@@ -548,7 +598,7 @@ function looseReplace(text, oldString, newString) {
   return { count: 1, text: out.join(eol), at: start + 1 };
 }
 
-export async function editFile({ path: p, old_string, new_string }) {
+export async function editFile({ path: p, old_string, new_string, replace_all }) {
   const target = resolveIn(p, 'edit_file');
   const attempted = `editing ${target.show}`;
   await guard(target, `edit ${target.abs}`);
@@ -560,7 +610,7 @@ export async function editFile({ path: p, old_string, new_string }) {
     throw fsFailure(err, attempted, target.show);
   }
 
-  const { text, at, loose } = replaceOnce(original, { old_string, new_string }, {
+  const { text, at, how, count } = replaceOnce(original, { old_string, new_string, replace_all }, {
     show: target.show, attempted,
   });
 
@@ -574,14 +624,18 @@ export async function editFile({ path: p, old_string, new_string }) {
 
   const delta = toLines(text).length - toLines(original).length;
   const change = delta === 0 ? 'same line count' : `${delta > 0 ? '+' : ''}${delta} lines`;
-  const how = loose ? ', matched ignoring whitespace and re-indented to fit' : '';
+  const where = count > 1
+    ? `${count} occurrences in ${target.show}, the first at line ${at}`
+    : `one occurrence in ${target.show} at line ${at}`;
+  const matched = how ? `, matched ${how}` : '';
 
   const span = toLines(new_string).length;
   const out = result(
-    `Replaced one occurrence in ${target.show} at line ${at} (${change}${how}).` +
+    `Replaced ${where} (${change}${matched}).` +
       parseNote(target.show, syntaxProblem(target.abs, text)) +
       nowReads(target.show, text, at, span),
-    `1 change at line ${at} · ${change}${loose ? ' · whitespace-tolerant' : ''}${syntaxProblem(target.abs, text) ? ' · does not parse' : ''}`,
+    `${count > 1 ? `${count} changes from line` : '1 change at line'} ${at} · ${change}` +
+      `${how ? ' · whitespace-tolerant' : ''}${syntaxProblem(target.abs, text) ? ' · does not parse' : ''}`,
     MAX_FILE_OUTPUT
   );
   // The replacement is diffed on its own and offset to where it landed, so

package/src/tools/fuzzy.js

@@ -0,0 +1,295 @@
+/**
+ * fuzzy.js — finding the text an edit meant when it is not in the file as written.
+ *
+ * Adapted from opencode's edit tool (MIT License, Copyright (c) 2025 opencode;
+ * see THIRD_PARTY_NOTICES.md).
+ *
+ * An old_string that misses costs a whole round trip: the refusal goes back,
+ * the model re-reads the file, and sends the edit again. Most misses are the
+ * same handful of slips — a line of the middle remembered slightly wrong,
+ * whitespace collapsed, the indent shifted, "\n" written out as an escape,
+ * a stray blank line at either end. Each matcher below yields the spans of the
+ * file that old_string plausibly means; the first span found exactly once is
+ * the one replaced. Found in two places is never guessed at.
+ *
+ * files.js tries an exact match and its own whitespace-tolerant, re-indenting
+ * match first; this is only reached when both have missed.
+ */
+
+/** How alike the middle lines of a block must be for block anchoring to accept it. */
+const SIMILARITY = 0.65;
+
+/**
+ * Past this, the file is not searched loosely at all. The matchers are plain
+ * scans and they run on the main thread, where a stale edit against a huge
+ * lockfile would freeze the session — Esc included — for minutes.
+ * ponytail: a flat cap, not a budget; move the chain to a worker if loose
+ * edits on files this big ever matter.
+ */
+const MAX_LINES = 20_000;
+const MAX_CHARS = 1_000_000;
+
+function levenshtein(a, b) {
+  if (a === '' || b === '') return Math.max(a.length, b.length);
+  // Two long minified lines would be a hundred million steps. Lines that long
+  // are not what a remembered-slightly-wrong edit is about: call them unlike.
+  if (a.length * b.length > 1_000_000) return a === b ? 0 : Math.max(a.length, b.length);
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const cur = [i];
+    for (let j = 1; j <= b.length; j++) {
+      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    }
+    prev = cur;
+  }
+  return prev[b.length];
+}
+
+/** The lines of `find`, without the empty string a trailing newline leaves. */
+function wantedLines(find) {
+  const lines = find.split('\n');
+  if (lines.length > 1 && lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}
+
+/** Lines joined into windows before a loose search gives up and calls it a miss. */
+const WINDOW_BUDGET = 200_000;
+
+/**
+ * Every run of `count` consecutive lines whose first line `could` start a
+ * match, joined back into text. The check is cheap and rules out nearly every
+ * window before it is built; the budget bounds the rest.
+ */
+function* windows(lines, count, could = () => true) {
+  let spent = 0;
+  for (let i = 0; i + count <= lines.length; i++) {
+    if (!could(lines[i])) continue;
+    if ((spent += count) > WINDOW_BUDGET) return;
+    yield lines.slice(i, i + count).join('\n');
+  }
+}
+
+/**
+ * First and last lines exact, the middle close enough. Catches an edit whose
+ * middle was remembered with a changed word or two — the commonest miss on a
+ * block the model read many steps ago.
+ */
+function* blockAnchor(content, find) {
+  if (find.split('\n').length < 3) return;
+  const want = wantedLines(find);
+  const lines = content.split('\n');
+  const first = want[0].trim();
+  const last = want[want.length - 1].trim();
+  const slack = Math.max(1, Math.floor(want.length * 0.25));
+
+  // Only the first closing line after an opening one counts, and a block is
+  // accepted within `slack` of the wanted length — so there is no point
+  // looking further than that. Scanning on to the end of the file made a
+  // blank first and last line quadratic in the file's length.
+  const blocks = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() !== first) continue;
+    const end = Math.min(lines.length, i + want.length + slack);
+    for (let j = i + 2; j < end; j++) {
+      if (lines[j].trim() !== last) continue;
+      if (Math.abs(j - i + 1 - want.length) <= slack) blocks.push([i, j]);
+      break;
+    }
+  }
+
+  const similarity = ([i, j]) => {
+    const inner = Math.min(want.length - 2, j - i - 1);
+    if (inner <= 0) return 1;
+    let total = 0;
+    for (let k = 1; k < want.length - 1 && k < j - i; k++) {
+      const a = lines[i + k].trim();
+      const b = want[k].trim();
+      const longest = Math.max(a.length, b.length);
+      if (longest) total += 1 - levenshtein(a, b) / longest;
+    }
+    return total / inner;
+  };
+
+  // opencode takes the best-scoring block. Every block close enough is
+  // offered instead, so two look-alike handlers read as ambiguous and are
+  // refused rather than the first one quietly edited.
+  for (const block of blocks) {
+    if (similarity(block) >= SIMILARITY) yield lines.slice(block[0], block[1] + 1).join('\n');
+  }
+}
+blockAnchor.how = 'by its first and last lines, the middle nearly the same';
+
+/** Every run of whitespace treated as one space. */
+function* whitespaceNormalized(content, find) {
+  const flat = (s) => s.replace(/\s+/g, ' ').trim();
+  const want = flat(find);
+  if (!want) return;
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const flatLine = flat(line);
+    if (flatLine === want) {
+      yield line;
+    } else if (flatLine.includes(want)) {
+      const pattern = find.trim().split(/\s+/).map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('\\s+');
+      const hit = line.match(new RegExp(pattern));
+      if (hit) yield hit[0];
+    }
+  }
+
+  const count = find.split('\n').length;
+  if (count > 1) {
+    for (const block of windows(lines, count, (l) => want.startsWith(flat(l)))) if (flat(block) === want) yield block;
+  }
+}
+whitespaceNormalized.how = 'with runs of whitespace collapsed';
+
+/** The same block at a different indent depth. */
+function* indentationFlexible(content, find) {
+  const dedent = (s) => {
+    const lines = s.split('\n');
+    const filled = lines.filter((l) => l.trim());
+    if (!filled.length) return s;
+    const least = Math.min(...filled.map((l) => /^\s*/.exec(l)[0].length));
+    return lines.map((l) => (l.trim() ? l.slice(least) : l)).join('\n');
+  };
+  const want = dedent(find);
+  // Dedenting keeps every line's text, so the first lines must match trimmed.
+  const head = find.split('\n')[0].trim();
+  for (const block of windows(content.split('\n'), find.split('\n').length, (l) => l.trim() === head)) {
+    if (dedent(block) === want) yield block;
+  }
+}
+indentationFlexible.how = 'ignoring indentation';
+
+const ESCAPES = { n: '\n', t: '\t', r: '\r', "'": "'", '"': '"', '`': '`', '\\': '\\', '\n': '\n', $: '$' };
+const unescape = (s) => s.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (_, c) => ESCAPES[c]);
+
+/** "\n" and "\"" written out as escapes, where the file has the real characters. */
+function* escapeNormalized(content, find) {
+  const want = unescape(find);
+  if (content.includes(want)) yield want;
+  // A trailing backslash may be escaping the line break, so it is left off.
+  const could = (l) => want.startsWith(unescape(l).replace(/\\$/, ''));
+  for (const block of windows(content.split('\n'), want.split('\n').length, could)) {
+    if (unescape(block) === want) yield block;
+  }
+}
+escapeNormalized.how = 'after undoing escaped characters';
+// A model that wrote old_string with "\n" for its line breaks wrote
+// new_string the same way; spliced in as is, the file would get a literal
+// backslash-n where each line break should be. A new_string with real line
+// breaks is already in the file's terms and is left alone.
+escapeNormalized.adapt = (replacement, find) =>
+  unescape(find) !== find && !replacement.includes('\n') ? unescape(replacement) : replacement;
+
+/** Blank lines or spaces at either end that the file does not have there. */
+function* trimmedBoundary(content, find) {
+  const want = find.trim();
+  if (want === find || !want) return;
+  if (content.includes(want)) yield want;
+  for (const block of windows(content.split('\n'), find.split('\n').length, (l) => want.startsWith(l.trimStart()))) {
+    if (block.trim() === want) yield block;
+  }
+}
+trimmedBoundary.how = 'ignoring leading and trailing whitespace';
+
+/** First and last lines exact, the same length, and at least half the middle identical. */
+function* contextAware(content, find) {
+  if (find.split('\n').length < 3) return;
+  const want = wantedLines(find);
+  const lines = content.split('\n');
+  const first = want[0].trim();
+  const last = want[want.length - 1].trim();
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() !== first) continue;
+    // Only a block exactly as long as the one wanted is accepted.
+    const end = Math.min(lines.length, i + want.length);
+    for (let j = i + 2; j < end; j++) {
+      if (lines[j].trim() !== last) continue;
+      const block = lines.slice(i, j + 1);
+      if (block.length === want.length) {
+        let same = 0;
+        let counted = 0;
+        for (let k = 1; k < block.length - 1; k++) {
+          const a = block[k].trim();
+          const b = want[k].trim();
+          if (a || b) {
+            counted++;
+            if (a === b) same++;
+          }
+        }
+        if (counted === 0 || same / counted >= 0.5) yield block.join('\n');
+      }
+      break;
+    }
+  }
+}
+contextAware.how = 'by its first and last lines';
+
+const MATCHERS = [blockAnchor, whitespaceNormalized, indentationFlexible, escapeNormalized, trimmedBoundary, contextAware];
+
+/**
+ * A match far bigger than what was asked for is a matcher reaching, not a
+ * find. Replacing it would delete code the model never meant to touch.
+ */
+function tooWide(match, find) {
+  const lines = find.split('\n').length;
+  if (match.split('\n').length >= Math.max(lines + 3, lines * 2)) return true;
+  if (lines === 1) return false;
+  return match.trim().length > Math.max(find.trim().length + 500, find.trim().length * 4);
+}
+
+/** How many separate places a set of [start, end) spans covers, overlaps counted once. */
+function places(spans) {
+  let count = 0;
+  let reach = -1;
+  for (const [start, end] of spans.sort((a, b) => a[0] - b[0])) {
+    if (start >= reach) count++;
+    reach = Math.max(reach, end);
+  }
+  return count;
+}
+
+/**
+ * Replace what `find` loosely means in `content`.
+ *
+ * `find` and `replacement` should already use the file's line endings; the
+ * file itself is never re-ended, so a mixed file keeps every line it had.
+ * Returns { text, index, count, how } on success, { ambiguous: true } when the
+ * first matcher to find anything finds it in more than one place,
+ * { wide: true } when the match is far bigger than `find`, and null when
+ * nothing matched at all. With `all`, every copy of the matched span changes.
+ *
+ * Unlike opencode, a matcher that finds two places is the end of it: a looser
+ * matcher further down picking one of them would be a guess.
+ */
+export function fuzzyReplace(content, find, replacement, { all = false } = {}) {
+  if (!find || content.length > MAX_CHARS || find.length > MAX_CHARS) return null;
+  if (content.split('\n', MAX_LINES + 1).length > MAX_LINES) return null;
+  for (const matcher of MATCHERS) {
+    // Spans built from whole lines of a \r\n file end on the last line's \r.
+    // That \r belongs to the line break after the match, which stays.
+    const own = (m) => (m.endsWith('\r') && !find.endsWith('\r') ? m.slice(0, -1) : m);
+    const hits = [...new Set([...matcher(content, find)].map(own))].filter((m) => m && content.includes(m));
+    if (!hits.length) continue;
+
+    const pick = hits[0];
+    if (tooWide(pick, find)) return { wide: true };
+    const text = matcher.adapt ? matcher.adapt(replacement, find) : replacement;
+    const index = content.indexOf(pick);
+    if (all) {
+      const copies = content.split(pick);
+      return { text: copies.join(text), index, count: copies.length - 1, how: matcher.how };
+    }
+
+    const spans = [];
+    for (const m of hits) {
+      for (let i = content.indexOf(m); i !== -1; i = content.indexOf(m, i + 1)) spans.push([i, i + m.length]);
+    }
+    if (places(spans) > 1) return { ambiguous: true };
+    return { text: content.slice(0, index) + text + content.slice(index + pick.length), index, count: 1, how: matcher.how };
+  }
+  return null;
+}

package/src/tools/index.js

@@ -3,7 +3,6 @@
  * line the user reads while each one runs.
  */
 
-import { jsonrepair } from 'jsonrepair';
 import { ToolFailure } from '../core/failure.js';
 import { readFile, readFiles, writeFile, batchWrite, editFile, multiEdit, editFiles } from './files.js';
 import { listDir, glob, grep } from './search.js';
@@ -231,15 +230,16 @@ export const tools = [
     description:
       'Replace one exact piece of text in a file. old_string must match the file ' +
       'character for character, including indentation, and must occur exactly once — ' +
-      'the edit is refused on zero matches and on two. This is the normal way to ' +
-      'change existing code. The result shows the file as it now stands, so do not ' +
-      'read it again afterwards.',
+      'the edit is refused on zero matches and on two. Set replace_all to change every ' +
+      'copy, for a rename. This is the normal way to change existing code. The result ' +
+      'shows the file as it now stands, so do not read it again afterwards.',
     parameters: {
       type: 'object',
       properties: {
         path: str('File path, relative to the project root.'),
-        old_string: str('The exact text to replace. Must be unique in the file.'),
+        old_string: str('The exact text to replace. Must be unique in the file unless replace_all is set.'),
         new_string: str('What to put there instead.'),
+        replace_all: bool('Replace every occurrence instead of exactly one. Default false.'),
       },
       required: ['path', 'old_string', 'new_string'],
     },
@@ -574,13 +574,6 @@ export const FILE_WRITES = new Set(['write_file', 'batch_write', 'edit_file', 'm
  */
 const LENIENT = new Set(['create_app.files']);
 
-/** Names models use for an argument that the schema calls something else. */
-const ALIASES = {
-  path: ['file', 'filename', 'file_path', 'filepath'],
-  content: ['contents', 'text', 'code', 'body'],
-  paths: ['files'],
-};
-
 function check(name, args) {
   const schema = tools.find((t) => t.name === name).parameters;
   const problems = [];
@@ -589,30 +582,6 @@ function check(name, args) {
     return ['the arguments must be a JSON object'];
   }
 
-  // One file named as "path" where the tool takes a list called "paths".
-  // DeepSeek did it to four read_files at once, a whole round trip spent being
-  // told a plural it could simply have been given.
-  // The same argument under a neighbouring name: write_file sent "file"
-  // instead of "path" cost DeepSeek two and a half minutes to be told so.
-  for (const [key, others] of Object.entries(ALIASES)) {
-    if (!schema.properties[key] || args[key] != null) continue;
-    const other = others.find((o) => args[o] != null && !schema.properties[o]);
-    if (other) { args[key] = args[other]; delete args[other]; }
-  }
-  // read_files sent as files: [{ path }], the shape batch_write takes.
-  if (Array.isArray(args.paths)) {
-    args.paths = args.paths.map((p) => (typeof p?.path === 'string' ? p.path : p));
-  }
-
-  for (const key of schema.required ?? []) {
-    const one = key.endsWith('s') ? key.slice(0, -1) : '';
-    if (args[key] == null && one && !schema.properties[one] && args[one] != null
-      && schema.properties[key]?.type === 'array') {
-      args[key] = Array.isArray(args[one]) ? args[one] : [args[one]];
-      delete args[one];
-    }
-  }
-
   for (const key of schema.required ?? []) {
     if (args[key] === undefined || args[key] === null) problems.push(`"${key}" is required and missing`);
   }
@@ -639,15 +608,7 @@ function check(name, args) {
         const parsed = JSON.parse(value);
         const kind = Array.isArray(parsed) ? 'array' : typeof parsed;
         if (kind === wanted || LENIENT.has(`${name}.${key}`)) { args[key] = parsed; actual = kind; }
-      } catch {
-        // Nearly JSON: DeepSeek sent a whole app's files this way and was
-        // told only that a string is not an array. Repair it before refusing.
-        try {
-          const parsed = JSON.parse(jsonrepair(value));
-          const kind = Array.isArray(parsed) ? 'array' : typeof parsed;
-          if (kind === wanted) { args[key] = parsed; actual = kind; }
-        } catch { /* not JSON either — the message below is the right answer */ }
-      }
+      } catch { /* not JSON either — the message below is the right answer */ }
     }
 
     // A list of files written as a { path: contents } map. The tool reads it