mixdog 0.7.17 → 0.8.0

package/src/agent/orchestrator/tools/builtin/builtin-tools.mjs

@@ -1,256 +0,0 @@
-// --- Tool definitions for external models ---
-//
-// Ordered to match the previous hand-maintained tools.json entries
-// (read / edit / write / bash / grep / glob) so
-// build-tools-manifest reproduces the legacy ordering.
-// CANONICAL SOURCE for all tool annotations (compressible, readOnlyHint,
-// destructiveHint, etc.). tools.json is GENERATED from this array by
-// dev/scripts/build-tools-manifest.mjs — do not edit annotations in tools.json
-// directly. To verify sync: node dev/scripts/check-tools-sync.mjs
-export const BUILTIN_TOOLS = [
-    {
-        name: 'read',
-        title: 'Mixdog Read',
-        annotations: { title: 'Mixdog Read', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false },
-        description: 'Read file contents (path required). symbol=NAME = whole definition; offset/limit or line/context = window; mode/max_lines = whole-file glance. Batch all regions of a file in one call. Output is the file text verbatim (line-number prefix only, no character escaping) — a \\uXXXX you see is literally in the file.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: { type: 'string' },
-                offset: { type: 'number', description: 'Start line for a windowed read (1-based).' },
-                limit: { type: 'number', description: 'Max lines to read (default 2000; full:true uncaps).' },
-                line: { type: 'number' },
-                context: { type: 'number', description: 'Lines around `line` (default 20).' },
-                pages: { type: 'string' },
-                symbol: { type: 'string', description: 'Read a whole symbol body (function/class/const) via the code graph.' },
-                language: { type: 'string', description: 'Language hint for symbol resolution.' },
-                mode: { type: 'string', enum: ['head', 'tail', 'count', 'summary', 'hex'], description: 'Whole-file glance: head/tail (first/last n), count (line/word/byte stats), summary (stats+head), hex (binary preview). For a window use offset/limit.' },
-                n: { type: 'number', description: 'Line count for mode head/tail/summary (default 20).' },
-                full: { type: 'boolean', description: 'Default false. true = return whole file (bypass 2000-line cap; still byte-capped).' },
-                max_lines: { type: 'number', description: 'Whole-file read: cap output to ~N lines. Ignored with offset/limit/mode.' },
-                budget: { type: 'string', enum: ['compact'], description: 'Auto-shrink: whole-file -> count; line -> context<=20; range -> limit<=120.' },
-            },
-        },
-    },
-    {
-        name: 'edit',
-        title: 'Mixdog Edit',
-        annotations: { title: 'Mixdog Edit', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
-        description: 'Exact-string editor for small known substitutions; for large or structural changes prefer apply_patch. operation: replace (default) | notebook | rename.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                operation: { type: 'string', enum: ['replace', 'notebook', 'rename'], description: 'Edit mode: "replace" (default, exact text edit), "notebook" (Jupyter cell edit), or "rename" (symbol rename).' },
-                path: { type: 'string' },
-                old_string: { type: 'string' },
-                new_string: { type: 'string' },
-                replace_all: { type: 'boolean' },
-                edits: {
-                    type: 'array',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            path: { type: 'string' },
-                            old_string: { type: 'string' },
-                            new_string: { type: 'string' },
-                            replace_all: { type: 'boolean' },
-                        },
-                        required: ['old_string', 'new_string'],
-                        additionalProperties: false,
-                    },
-                    minItems: 1,
-                    description: 'Batch replacements (operation:"replace").',
-                },
-                notebook_path: { type: 'string', description: 'operation:"notebook" — path to the .ipynb notebook to edit.' },
-                cell_id: { type: 'string', description: 'operation:"notebook" — target cell: a real cell.id or a cell-N index. For insert, the new cell is placed after this cell (or at the start if omitted).' },
-                new_source: { type: 'string', description: 'operation:"notebook" — new source for the cell (not required for delete).' },
-                cell_type: { type: 'string', enum: ['code', 'markdown'], description: 'operation:"notebook" — cell type. Required for insert; otherwise defaults to the current cell type.' },
-                edit_mode: { type: 'string', enum: ['replace', 'insert', 'delete'], description: 'operation:"notebook" — replace (default), insert, or delete.' },
-                symbol: { type: 'string', description: 'operation:"rename" — identifier to rename.' },
-                new_name: { type: 'string', description: 'operation:"rename" — new identifier.' },
-                file: { type: 'string', description: 'operation:"rename" — optional file to scope the reference search.' },
-                apply: { type: 'boolean', description: 'operation:"rename" — default false (preview). Set true to perform the rename.' },
-            },
-        },
-    },
-    {
-        name: 'write',
-        title: 'Mixdog Write',
-        annotations: { title: 'Mixdog Write', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
-        description: 'Write a whole file — new, or a full rewrite of one already read. For partial edits use apply_patch; never overwrite an unread file.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: { type: 'string' },
-                content: { type: 'string' },
-                allow_unread_overwrite: { type: 'boolean', description: 'Default false. true = skip ONLY the read-before-overwrite snapshot gate when you already know the full intended content; all other write safety checks still apply.' },
-                writes: {
-                    type: 'array',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            path: { type: 'string' },
-                            content: { type: 'string' },
-                        },
-                        required: ['path', 'content'],
-                        additionalProperties: false,
-                    },
-                    minItems: 1,
-                    description: 'Batch writes.',
-                },
-            },
-        },
-    },
-    {
-        name: 'diagnostics',
-        title: 'Mixdog Diagnostics',
-        annotations: { title: 'Mixdog Diagnostics', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: 'Run the matching type/lint checker under path (tsc/eslint/ruff/etc.). Default cwd; no LSP.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: { type: 'string', description: 'File or directory to diagnose. Defaults to cwd.' },
-            },
-            required: [],
-        },
-    },
-    {
-        name: 'open_config',
-        title: 'Open Config UI',
-        annotations: { title: 'Open Config UI', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-        description: 'Open the mixdog settings UI (Providers + Presets) in the browser. Starts the resident config server if needed and returns the UI URL. No params.',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'bash',
-        title: 'Mixdog Shell',
-        annotations: { title: 'Mixdog Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: "Shell for git/build/test/run. ALWAYS set `shell` explicitly ('bash' = POSIX via Git Bash, 'powershell' = PS cmdlets); omitting defaults to the OS shell (Windows = PowerShell, POSIX = /bin/sh) and mis-parses the other syntax. run_in_background works for both shells, including Windows shell:'bash' (Git Bash). Single shell entry point; not for inline code you were asked to return.",
-        inputSchema: {
-            type: 'object',
-            properties: {
-                command: { type: 'string' },
-                cwd: { type: 'string' },
-                timeout: { type: 'number', description: 'Timeout in ms, or seconds when <=600.' },
-                merge_stderr: { type: 'boolean' },
-                run_in_background: { type: 'boolean' },
-                persistent: { type: 'boolean' },
-                session_id: { type: 'string' },
-                create: { type: 'boolean', description: 'Allow creating a new persistent session for an explicit session_id.' },
-                close: { type: 'boolean' },
-                shell: { type: 'string', enum: ['bash', 'powershell'], description: "Force the shell. On Windows: 'bash' runs the command through Git Bash (POSIX syntax), 'powershell' forces PowerShell. On POSIX: 'powershell' resolves pwsh if installed (errors if absent); 'bash' is /bin/sh (already the default). Always set this explicitly; omitting uses the OS default (PowerShell on Windows), where POSIX syntax fails to parse." },
-            },
-            required: ['command'],
-        },
-    },
-    {
-        name: 'job_wait',
-        title: 'Background Job Control',
-        annotations: { title: 'Background Job Control', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
-        description: 'Control a bash run_in_background job by job_id. action: wait (default) | peek | kill. Not for bridge_*/sess_* ids.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                job_id: { type: 'string', description: 'job_id from bash with run_in_background:true.' },
-                action: { type: 'string', enum: ['wait', 'peek', 'kill'], description: 'wait (default) = block until done; peek = non-blocking status + output tail; kill = terminate.' },
-                timeout_ms: { type: 'number' },
-                poll_ms: { type: 'number' },
-            },
-            required: ['job_id'],
-        },
-    },
-    {
-        name: 'grep',
-        title: 'Mixdog Grep',
-        annotations: { title: 'Mixdog Grep', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
-        description: 'Search file contents (ripgrep): free-text / non-symbol content. For a symbol by name use code_graph, not grep. pattern (regex) or glob. output_mode: content (default) | files_with_matches | count. Array pattern matches several in ONE call. -A/-B/-C is line-based — useless on minified/single-line files; use -o or multiline.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                pattern: {
-                    anyOf: [
-                        { type: 'string' },
-                        { type: 'array', items: { type: 'string' }, minItems: 1 },
-                    ],
-                    description: 'Ripgrep regex, or an array of regexes (OR-matched; <=20, <=5 with multiline) to match several in one call.',
-                },
-                path: { type: 'string' },
-                glob: {
-                    anyOf: [
-                        { type: 'string' },
-                        { type: 'array', items: { type: 'string' }, minItems: 1 },
-                    ],
-                    description: 'Glob, or an array of globs, to filter files.',
-                },
-                output_mode: { type: 'string', enum: ['files_with_matches', 'content', 'count'], description: 'Default content (matching lines). files_with_matches = paths only; count = per-file counts.' },
-                head_limit: { type: 'number', description: 'Max result lines (default 80; 0 = unlimited). Truncated output says how many results remain.' },
-                offset: { type: 'number', description: 'Skip N result lines before head_limit applies — for paging large result sets.' },
-                '-i': { type: 'boolean' },
-                '-n': { type: 'boolean' },
-                '-A': { type: 'number' },
-                '-B': { type: 'number' },
-                '-C': { type: 'number', description: 'Context lines (with -A/-B). Line-based; no effect on single-line/minified files — use -o.' },
-                context: { type: 'number' },
-                multiline: { type: 'boolean', description: 'Dot matches newlines; patterns span lines (rg -U). Pair with -o on single-line/minified files.' },
-                '-o': { type: 'boolean', description: 'Only matching parts (rg --only-matching).' },
-                type: { type: 'string' },
-            },
-            required: [],
-        },
-    },
-    {
-        name: 'glob',
-        title: 'Mixdog Glob',
-        annotations: { title: 'Mixdog Glob', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
-        description: 'Find files by glob pattern (mtime-sorted). For name/size/date filters use list mode:find.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                pattern: {
-                    anyOf: [
-                        { type: 'string' },
-                        { type: 'array', items: { type: 'string' }, minItems: 1 },
-                    ],
-                    description: 'Glob or array.',
-                },
-                path: {
-                    anyOf: [
-                        { type: 'string' },
-                        { type: 'array', items: { type: 'string' }, minItems: 1 },
-                    ],
-                    description: 'Base dir or array.',
-                },
-                head_limit: { type: 'number', description: 'Max entries returned (mtime-sorted). A truncated listing ends with "pass offset:N to continue" — re-call with that offset to page.' },
-                offset: { type: 'number', description: 'Skip N entries before head_limit applies; use the footer-suggested value to page.' },
-            },
-            required: ['pattern'],
-        },
-    },
-    {
-        name: 'list',
-        title: 'Mixdog List Directory',
-        annotations: { title: 'Mixdog List Directory', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
-        description: 'List or find directory entries. mode: list | tree | find (name/size/date filter). fuzzy ranks by partial name. Default cwd.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: { type: 'string' },
-                mode: { type: 'string', enum: ['list', 'tree', 'find'], description: 'Default list (flat dir). tree = recursive tree; find = name/size/date filter.' },
-                depth: { type: 'number' },
-                hidden: { type: 'boolean' },
-                sort: { type: 'string', enum: ['name', 'mtime', 'size'] },
-                type: { type: 'string', enum: ['any', 'file', 'dir'] },
-                head_limit: { type: 'number', description: 'Max entries returned. A truncated listing ends with "[entries X-Y of T; pass offset:N to continue]" — re-call with that offset to page.' },
-                offset: { type: 'number', description: 'Skip N entries before head_limit applies; use the footer-suggested value to page.' },
-                include_noise: { type: 'boolean' },
-                name: { type: 'string' },
-                min_size: { type: 'number' },
-                max_size: { type: 'number' },
-                modified_after: { type: 'string' },
-                modified_before: { type: 'string' },
-                fuzzy: { type: 'string', description: 'Rank files by subsequence match of this partial name; overrides mode. e.g. "edeng" -> edit-engine.mjs.' },
-            },
-            required: [],
-        },
-    },
-];

package/src/agent/orchestrator/tools/builtin/edit-base-guard.mjs

@@ -1,58 +0,0 @@
-import { readFileSync, statSync } from 'fs';
-import { hashText } from './hash-utils.mjs';
-import { statMatchesSnapshot } from './snapshot-helpers.mjs';
-import { normalizeErrorMessage } from './path-diagnostics.mjs';
-import { getPathMutationGeneration } from './cache-layers.mjs';
-
-// Change detection: a full stat match (size + mtime±1 + ctime±1) is
-// proof the file is untouched since the preflight snapshot — accept
-// without re-reading the body (fast-path). Only when stat drifts do we
-// fall back to the authoritative content-hash compare. Tradeoff
-// (accepted policy, parity with write's isSnapshotStale): a size-
-// preserving write that ALSO restores mtime AND ctime is not caught —
-// vanishingly rare, since ctime is not userland-settable on the usual
-// platforms.
-export function validatePreparedEditBase(prepared) {
-    if (!prepared || !prepared.fullPath) return 'Error [code 7]: edit prewrite check failed — missing prepared file path';
-    // In-process CAS, checked before the stat fast-path below. Every committed
-    // write bumps the target's mutation generation (bumpPathMutationGeneration,
-    // reached via invalidateBuiltinResultCache after each atomic/byte write).
-    // If the generation captured at preflight no longer matches, a concurrent
-    // in-process edit committed between this edit's snapshot and now. This
-    // signal is deterministic and independent of mtime/size granularity — it
-    // closes the window where the stat fast-path (size + mtime±1 + ctime±1)
-    // false-negatives on a same-size write that lands within the mtime
-    // tolerance (e.g. two concurrent cross-file batches racing the same
-    // targets), which would otherwise wave drift through. Only enforced when a
-    // generation was captured (Number.isFinite) so callers that omit it keep
-    // their prior behavior; sequential edits capture and commit without an
-    // intervening write, so the generation is stable and never false-positives.
-    if (Number.isFinite(prepared.baseMutationGeneration)
-        && getPathMutationGeneration(prepared.fullPath) !== prepared.baseMutationGeneration) {
-        return `Error [code 7]: file modified between edit preflight and write — read it again before editing: ${prepared.filePath}`;
-    }
-    let currentStat;
-    try { currentStat = statSync(prepared.fullPath); }
-    catch (err) {
-        return `Error [code 7]: file changed before edit write — read it again before editing: ${prepared.filePath} (${normalizeErrorMessage(err instanceof Error ? err.message : String(err))})`;
-    }
-    // Fast-path: clean stat match ⇒ untouched, accept without reading.
-    // statMatchesSnapshot returns false when baseStatSnapshot is missing
-    // or incomplete, so an incomplete snapshot falls through to the
-    // fail-closed / content-hash path below (no fail-open).
-    if (statMatchesSnapshot(currentStat, prepared.baseStatSnapshot)) return null;
-    // Stat drifted (or no stat material) → content hash is authoritative.
-    // Without baseContentHash we cannot prove identity, so fail closed.
-    if (!prepared.baseContentHash) {
-        return `Error [code 7]: file modified between edit preflight and write — read it again before editing: ${prepared.filePath}`;
-    }
-    let current;
-    try { current = readFileSync(prepared.fullPath); }
-    catch (err) {
-        return `Error [code 7]: file changed before edit write — read it again before editing: ${prepared.filePath} (${normalizeErrorMessage(err instanceof Error ? err.message : String(err))})`;
-    }
-    if (hashText(current) !== prepared.baseContentHash) {
-        return `Error [code 7]: file modified between edit preflight and write — read it again before editing: ${prepared.filePath}`;
-    }
-    return null;
-}

package/src/agent/orchestrator/tools/builtin/edit-byte-plan.mjs

@@ -1,240 +0,0 @@
-import { stripTrailingWhitespaceForEdit } from '../edit-normalize.mjs';
-import {
-    bufferWithTrailingLf,
-    concatByteReplacements,
-    hashBytesWithReplacements,
-} from './edit-byte-utils.mjs';
-import {
-    countLfInString,
-    maybeAutoStripLineNumberPrefixes,
-} from './edit-context-utils.mjs';
-import { replacementForOriginalSlice } from './edit-match-utils.mjs';
-
-export function tryBuildExactEditBuffer(rawBuf, oldStr, newStr, replaceAll, snapshot, filePath) {
-    if (!Buffer.isBuffer(rawBuf) || typeof oldStr !== 'string' || oldStr.length === 0 || typeof newStr !== 'string') return null;
-    const oldBytes = Buffer.from(oldStr, 'utf-8');
-    if (oldBytes.length === 0) return null;
-    let eOldStr = oldStr;
-    let eOldBytes = oldBytes;
-    const _pureDeletion = newStr === '' && !oldStr.endsWith('\n') && !oldStr.endsWith('\r');
-    // Single-occurrence pure deletion: probe globally so the unique
-    // match also covers its trailing line terminator (CRLF first to
-    // avoid leaving a stray \r on CRLF files, then LF, then lone-CR).
-    // Replace-all pure deletion CANNOT use a single global rewrite of
-    // eOldBytes — when occurrences are mixed (some followed by \n, some
-    // bare / at EOF), an eOldBytes that includes the terminator would
-    // silently skip every bare occurrence. Per-occurrence absorption
-    // below extends each span over its own trailing \r\n / \n / \r so
-    // every match is removed regardless of what follows it.
-    if (_pureDeletion && !replaceAll) {
-        // Judge ambiguity on the BARE oldBytes BEFORE newline absorption.
-        // Absorbing a trailing terminator first can narrow a >1-occurrence
-        // bare match down to a unique extended span (e.g. 'X' present as
-        // 'X\r\n...X'), silently single-deleting instead of surfacing the
-        // ambiguous-match error. If the bare oldBytes occurs more than once
-        // return null — the same signal the spans.length>1 path emits (→ the
-        // caller's code-9 ambiguous-match error). Only absorb when the bare
-        // match is unique.
-        const _firstBare = rawBuf.indexOf(oldBytes);
-        if (_firstBare !== -1 && rawBuf.indexOf(oldBytes, _firstBare + 1) !== -1) {
-            return null;
-        }
-        const oldWithCrlf = Buffer.from(`${oldStr}\r\n`, 'utf-8');
-        const oldWithLf = bufferWithTrailingLf(oldBytes);
-        const oldWithCr = Buffer.from(`${oldStr}\r`, 'utf-8');
-        if (rawBuf.indexOf(oldWithCrlf) !== -1) {
-            eOldStr = `${oldStr}\r\n`;
-            eOldBytes = oldWithCrlf;
-        } else if (rawBuf.indexOf(oldWithLf) !== -1) {
-            eOldStr = `${oldStr}\n`;
-            eOldBytes = oldWithLf;
-        } else if (rawBuf.indexOf(oldWithCr) !== -1) {
-            eOldStr = `${oldStr}\r`;
-            eOldBytes = oldWithCr;
-        }
-    }
-    const _perOccurrenceAbsorb = _pureDeletion && replaceAll;
-    if (!replaceAll) {
-        const _fb = rawBuf.indexOf(eOldBytes);
-        if (_fb !== -1 && rawBuf.indexOf(eOldBytes, _fb + 1) !== -1) return null;
-    }
-    const spans = [];
-    let idx = 0;
-    while ((idx = rawBuf.indexOf(eOldBytes, idx)) !== -1) {
-        let _end = idx + eOldBytes.length;
-        if (_perOccurrenceAbsorb) {
-            // CRLF (\r\n) first so we don't strand a stray \r; then LF;
-            // then lone-CR. Bare / EOF occurrences leave _end as-is.
-            if (rawBuf[_end] === 0x0d && rawBuf[_end + 1] === 0x0a) _end += 2;
-            else if (rawBuf[_end] === 0x0a) _end += 1;
-            else if (rawBuf[_end] === 0x0d) _end += 1;
-        }
-        spans.push({ start: idx, end: _end });
-        if (!replaceAll && spans.length > 1) return null;
-        idx += eOldBytes.length;
-    }
-    if (spans.length === 0) return null;
-    const fileUtf8 = rawBuf.toString('utf-8');
-    const replacements = spans.map((span) => ({
-        ...span,
-        newBytes: Buffer.from(
-            replacementForOriginalSlice(newStr, rawBuf.subarray(span.start, span.end).toString('utf-8'), fileUtf8),
-            'utf-8',
-        ),
-    }));
-    const sameSize = replacements.every((span) => span.end - span.start === span.newBytes.length);
-    if (spans.length === 1) {
-        const first = spans[0].start;
-        if (sameSize) {
-            return {
-                replacements,
-                sameSize: true,
-                contentHash: hashBytesWithReplacements(rawBuf, replacements),
-            };
-        }
-        return {
-            replacements,
-            sameSize: false,
-            updated: Buffer.concat([
-                rawBuf.subarray(0, first),
-                replacements[0].newBytes,
-                rawBuf.subarray(spans[0].end),
-            ], rawBuf.length - (spans[0].end - first) + replacements[0].newBytes.length),
-        };
-    }
-    if (sameSize) {
-        return {
-            replacements,
-            sameSize: true,
-            contentHash: hashBytesWithReplacements(rawBuf, replacements),
-        };
-    }
-    return {
-        replacements,
-        sameSize: false,
-        updated: concatByteReplacements(rawBuf, replacements),
-    };
-}
-
-export function tryBuildMultiExactEditBuffer(rawBuf, edits, args, snapshot, filePath) {
-    if (!Buffer.isBuffer(rawBuf) || !Array.isArray(edits) || edits.length === 0) return null;
-    // Fast path treats every edit as locating its span in the ORIGINAL buffer
-    // and applies all replacements at once. Sequential-apply semantics differ
-    // whenever edit A's new_string can synthesise (or destroy) bytes that
-    // edit B's old_string would match. Disable the fast path unless edits
-    // are provably independent — no pair where one's new_string contains
-    // another's old_string. The slow path runs them sequentially.
-    if (edits.length > 1) {
-        for (let a = 0; a < edits.length; a++) {
-            const ea = edits[a];
-            if (!ea || typeof ea.old_string !== 'string' || typeof ea.new_string !== 'string') return null;
-            for (let b = 0; b < edits.length; b++) {
-                if (a === b) continue;
-                const eb = edits[b];
-                if (!eb || typeof eb.old_string !== 'string') return null;
-                if (eb.old_string.length === 0) continue;
-                if (ea.new_string.indexOf(eb.old_string) !== -1) return null;
-            }
-        }
-    }
-    const isMarkdown = /\.(?:md|mdx)$/i.test(filePath);
-    const replacements = [];
-    const normalizedEdits = [];
-    for (let i = 0; i < edits.length; i++) {
-        const entry = edits[i];
-        if (!entry || typeof entry.old_string !== 'string' || typeof entry.new_string !== 'string') return null;
-        let oldString = entry.old_string;
-        let newString = entry.new_string;
-        {
-            const _nulIdx = newString.indexOf('\u0000');
-            if (_nulIdx !== -1) {
-                return { error: `Error [code 11]: edit ${i} — new_string contains NUL byte (U+0000) at offset ${_nulIdx} — source text must not contain NUL: ${filePath}` };
-            }
-        }
-        const replaceAll = entry.replace_all === true;
-        // Size gate moved out of the pre-loop guard: the exact byte
-        // path proves uniqueness below (spans.length === 1 for
-        // !replaceAll), so an exact-unique multi edit applies at any
-        // size. The fold-fallback path in edit-engine still enforces
-        // the >=30-line code-10 wording for genuine fold-misses.
-        if (/^\s*\d+[\t│→]/.test(oldString)) {
-            const stripped = maybeAutoStripLineNumberPrefixes(oldString);
-            if (stripped === null) return null;
-            oldString = stripped;
-        }
-        // Final-line-aware hygiene — same rule as the edit-engine slow path
-        // (stripTrailingWhitespaceForEdit), so fast/slow paths cannot diverge
-        // on identical inputs.
-        if (!isMarkdown) newString = stripTrailingWhitespaceForEdit(newString, oldString);
-        if (oldString.length === 0) {
-            return { error: `Error: edit ${i} — old_string must be non-empty` };
-        }
-        if (oldString === newString) {
-            return { error: `Error: edit ${i} — new_string must differ from old_string` };
-        }
-        if (newString === '' || countLfInString(oldString) !== countLfInString(newString)) return null;
-        const oldBytes = Buffer.from(oldString, 'utf-8');
-        const fileUtf8 = rawBuf.toString('utf-8');
-        if (oldBytes.length === 0) return null;
-        if (!replaceAll) {
-            const _fb = rawBuf.indexOf(oldBytes);
-            if (_fb !== -1 && rawBuf.indexOf(oldBytes, _fb + 1) !== -1) return null;
-        }
-        normalizedEdits.push({ oldString, newString, replaceAll });
-        const spans = [];
-        let idx = 0;
-        while ((idx = rawBuf.indexOf(oldBytes, idx)) !== -1) {
-            const spanEnd = idx + oldBytes.length;
-            const sliceText = rawBuf.subarray(idx, spanEnd).toString('utf-8');
-            const newBytes = Buffer.from(
-                replacementForOriginalSlice(newString, sliceText, fileUtf8),
-                'utf-8',
-            );
-            spans.push({ start: idx, end: spanEnd, editIndex: i, newBytes });
-            if (!replaceAll && spans.length > 1) return null;
-            idx += oldBytes.length;
-        }
-        if (spans.length === 0) return null;
-        replacements.push(...spans);
-    }
-    replacements.sort((a, b) => a.start - b.start || a.end - b.end);
-    for (let i = 1; i < replacements.length; i++) {
-        if (replacements[i].start < replacements[i - 1].end) return null;
-    }
-    // Independence guard (above) only checks new_string-contains-old_string; it
-    // misses old_strings SYNTHESISED across edit boundaries (e.g. "A"->"y" turns
-    // "Az yz" into "yz yz", making a later "yz"->Q match twice — which sequential
-    // apply would reject as ambiguous). Verify the fast (apply-in-original)
-    // result equals an in-order SEQUENTIAL replay; on any divergence or
-    // sequential-reject, return null so the caller runs the slow sequential
-    // path. Fail-safe: a false mismatch only costs a fallback, never corruption.
-    {
-        const _fastBytes = concatByteReplacements(rawBuf, replacements);
-        let seq = rawBuf.toString('utf-8');
-        for (const { oldString: _o, newString: _n, replaceAll: _ra } of normalizedEdits) {
-            const repl = replacementForOriginalSlice(_n, _o, seq);
-            if (_ra) {
-                if (!seq.includes(_o)) return null;
-                seq = seq.split(_o).join(repl);
-            } else {
-                const first = seq.indexOf(_o);
-                if (first === -1 || seq.indexOf(_o, first + _o.length) !== -1) return null;
-                seq = seq.slice(0, first) + repl + seq.slice(first + _o.length);
-            }
-        }
-        if (!Buffer.from(seq, 'utf-8').equals(_fastBytes)) return null;
-    }
-    const sameSize = replacements.every((span) => span.end - span.start === span.newBytes.length);
-    if (sameSize) {
-        return {
-            replacements,
-            sameSize: true,
-            contentHash: hashBytesWithReplacements(rawBuf, replacements),
-        };
-    }
-    return {
-        replacements,
-        sameSize: false,
-        updated: concatByteReplacements(rawBuf, replacements),
-    };
-}