mixdog 0.7.18 → 0.8.0

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

@@ -1,113 +0,0 @@
-import { createHash } from 'crypto';
-import { statSync } from 'fs';
-import { hashText } from './hash-utils.mjs';
-import { statMatchesSnapshot } from './snapshot-helpers.mjs';
-
-export function lineRangesForByteSpans(rawBuf, spans) {
-    if (!Buffer.isBuffer(rawBuf) || !Array.isArray(spans) || spans.length === 0) return [];
-    const sorted = spans
-        .filter((span) => span && Number.isFinite(span.start) && Number.isFinite(span.end) && span.start >= 0 && span.end >= span.start)
-        .sort((a, b) => a.start - b.start);
-    const out = [];
-    let lineNo = 1;
-    let scanned = 0;
-    for (const span of sorted) {
-        const start = Math.min(rawBuf.length, span.start);
-        const end = Math.min(rawBuf.length, span.end);
-        for (let i = scanned; i < start; i++) {
-            if (rawBuf[i] === 10) lineNo++;
-        }
-        const startLine = lineNo;
-        let lineCount = 1;
-        for (let i = start; i < end; i++) {
-            if (rawBuf[i] === 10) lineCount++;
-        }
-        for (let i = start; i < end; i++) {
-            if (rawBuf[i] === 10) lineNo++;
-        }
-        scanned = end;
-        out.push({ startLine, endLine: startLine + lineCount - 1 });
-    }
-    return out;
-}
-
-export function bufferWithTrailingLf(buf) {
-    const out = Buffer.allocUnsafe(buf.length + 1);
-    buf.copy(out, 0);
-    out[buf.length] = 10;
-    return out;
-}
-
-export function concatByteReplacements(rawBuf, replacements) {
-    const parts = [];
-    let cursor = 0;
-    let totalLength = 0;
-    for (const span of replacements) {
-        if (span.start < cursor) return null;
-        const before = rawBuf.subarray(cursor, span.start);
-        parts.push(before, span.newBytes);
-        totalLength += before.length + span.newBytes.length;
-        cursor = span.end;
-    }
-    const tail = rawBuf.subarray(cursor);
-    parts.push(tail);
-    totalLength += tail.length;
-    return Buffer.concat(parts, totalLength);
-}
-
-export function hashBytesWithReplacements(rawBuf, replacements) {
-    const hasher = createHash('sha256');
-    let cursor = 0;
-    const sorted = Array.isArray(replacements)
-        ? replacements.slice().sort((a, b) => a.start - b.start || a.end - b.end)
-        : [];
-    for (const span of sorted) {
-        if (!span || span.start < cursor || span.end < span.start || !Buffer.isBuffer(span.newBytes)) return hashText(rawBuf);
-        hasher.update(rawBuf.subarray(cursor, span.start));
-        hasher.update(span.newBytes);
-        cursor = span.end;
-    }
-    hasher.update(rawBuf.subarray(cursor));
-    return hasher.digest('hex');
-}
-
-export function materialiseByteReplacements(rawBuf, replacements) {
-    return concatByteReplacements(rawBuf, replacements);
-}
-
-export function partialByteWriteEnabled() {
-    return !/^(0|false|no|off|atomic)$/i.test(String(process.env.MIXDOG_EDIT_PARTIAL_WRITE || process.env.MIXDOG_PARTIAL_WRITE || ''));
-}
-
-export function captureStableBaseStatSnapshot(fullPath, statHint, rawBuf) {
-    if (!fullPath || !statHint || !Buffer.isBuffer(rawBuf)) return null;
-    try {
-        const postReadStat = statSync(fullPath);
-        if (statMatchesSnapshot(postReadStat, statHint) && postReadStat.size === rawBuf.length) {
-            return {
-                mtimeMs: postReadStat.mtimeMs,
-                ctimeMs: postReadStat.ctimeMs,
-                size: postReadStat.size,
-                ino: Number(postReadStat.ino),
-            };
-        }
-    } catch {}
-    return null;
-}
-
-/** TOCTOU guard for atomicWrite — same shape as write-tool captureTargetSnapshot. */
-export function captureExpectedTargetSnapshot(fullPath, statHint = null) {
-    try {
-        const st = statHint || statSync(fullPath);
-        return {
-            exists: true,
-            size: st.size,
-            mtimeMs: Number(st.mtimeMs),
-            ctimeMs: Number(st.ctimeMs),
-            ino: Number(st.ino),
-        };
-    } catch (err) {
-        if (err && err.code === 'ENOENT') return { exists: false };
-        throw err;
-    }
-}

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

@@ -1,74 +0,0 @@
-import { markCodeGraphDirtyPaths } from '../code-graph.mjs';
-import { atomicWrite } from './atomic-write.mjs';
-import {
-    invalidateBuiltinResultCache,
-    seedRawContentCacheAfterWrite,
-} from './cache-layers.mjs';
-import { captureExpectedTargetSnapshot, materialiseByteReplacements } from './edit-byte-utils.mjs';
-import { postEditSnapshotMeta } from './edit-context-utils.mjs';
-import { tryWriteSameSizeByteReplacementsSync } from './edit-partial-write.mjs';
-import { recordReadSnapshot } from './read-snapshot-runtime.mjs';
-import { validatePreparedEditBase } from './edit-base-guard.mjs';
-
-function commitHooks(hooks = {}) {
-    return {
-        ioTraceStart: typeof hooks.ioTraceStart === 'function' ? hooks.ioTraceStart : () => 0,
-        ioTraceDone: typeof hooks.ioTraceDone === 'function' ? hooks.ioTraceDone : () => {},
-    };
-}
-
-export async function commitPreparedEditUnlocked(prepared, readStateScope, options = {}, hooks = {}) {
-    const traceHooks = commitHooks(hooks);
-    if (Array.isArray(prepared.sameSizeByteReplacements) && prepared.sameSizeByteReplacements.length > 0) {
-        const partial = tryWriteSameSizeByteReplacementsSync(prepared.fullPath, prepared.sameSizeByteReplacements, {
-            baseStatSnapshot: prepared.baseStatSnapshot,
-            baseMutationGeneration: prepared.baseMutationGeneration,
-            baseContentHash: prepared.baseContentHash,
-            contentHash: prepared.contentHash,
-            fsync: options?.fsync,
-            filePath: prepared.filePath,
-        }, {
-            ...traceHooks,
-            validatePreparedEditBase,
-        });
-        if (partial?.ok) {
-            invalidateBuiltinResultCache([prepared.fullPath]);
-            markCodeGraphDirtyPaths([prepared.fullPath]);
-            const afterBuf = materialiseByteReplacements(prepared.baseRawContent, prepared.sameSizeByteReplacements);
-            const snapMeta = postEditSnapshotMeta(prepared.snapshot, 'edit', afterBuf, {
-                contentBeforeEdit: prepared.baseRawContent,
-                shiftRanges: false,
-            });
-            recordReadSnapshot(prepared.fullPath, partial.stat || undefined, readStateScope, snapMeta);
-            return;
-        }
-        if (partial?.error) throw new Error(partial.error.replace(/^Error:\s*/, ''));
-        if (!Buffer.isBuffer(prepared.content) && Buffer.isBuffer(prepared.baseRawContent)) {
-            prepared.content = materialiseByteReplacements(prepared.baseRawContent, prepared.sameSizeByteReplacements);
-        }
-    }
-    if (!Buffer.isBuffer(prepared.content) && typeof prepared.content !== 'string') {
-        throw new Error('prepared edit missing materialised content');
-    }
-    const expectedTargetSnapshot = prepared.expectedTargetSnapshot
-        || captureExpectedTargetSnapshot(prepared.fullPath);
-    await atomicWrite(prepared.fullPath, prepared.content, {
-        sessionId: options?.sessionId,
-        mode: prepared.baseMode,
-        expectedTargetSnapshot,
-    });
-    invalidateBuiltinResultCache([prepared.fullPath]);
-    const writtenStat = seedRawContentCacheAfterWrite(prepared.fullPath, prepared.content);
-    markCodeGraphDirtyPaths([prepared.fullPath]);
-    recordReadSnapshot(prepared.fullPath, writtenStat || undefined, readStateScope, postEditSnapshotMeta(prepared.snapshot, 'edit', prepared.content, {
-        contentBeforeEdit: prepared.baseRawContent,
-        shiftRanges: false,
-    }));
-}
-
-export async function commitPreparedEditCheckedUnlocked(prepared, readStateScope, options = {}, hooks = {}) {
-    const prewriteErr = validatePreparedEditBase(prepared);
-    if (prewriteErr) return { ok: false, error: prewriteErr };
-    await commitPreparedEditUnlocked(prepared, readStateScope, options, hooks);
-    return { ok: true };
-}

package/src/agent/orchestrator/tools/builtin/edit-context-utils.mjs

@@ -1,242 +0,0 @@
-import { hashText } from './hash-utils.mjs';
-import { renderReadLine } from './read-formatting.mjs';
-import {
-    snapshotCoversFullFile,
-    snapshotRangesCoverAllLines,
-} from './snapshot-helpers.mjs';
-
-export function countLfInString(value) {
-    let n = 0;
-    const s = String(value ?? '');
-    for (let i = 0; i < s.length; i++) {
-        if (s.charCodeAt(i) === 10) n++;
-    }
-    return n;
-}
-
-function normaliseSnapshotRange(r) {
-    if (!r) return null;
-    const startLine = Math.max(1, Number(r.startLine) || 1);
-    const endLine = r.endLine === Infinity ? Infinity : Number(r.endLine);
-    if (!Number.isFinite(startLine)) return null;
-    if (endLine !== Infinity && (!Number.isFinite(endLine) || endLine < startLine)) return null;
-    return { startLine, endLine };
-}
-
-function isFullFileSentinelRange(r) {
-    return r && r.startLine <= 1 && r.endLine === Infinity;
-}
-
-export function lineRangeForSubstring(content, needle, { replaceAll = false } = {}) {
-    if (typeof content !== 'string' || typeof needle !== 'string' || needle.length === 0) return null;
-    let oldLineCount = 1;
-    for (let i = 0; i < needle.length; i++) {
-        if (needle.charCodeAt(i) === 10) oldLineCount++;
-    }
-    // A needle ending in "\n" terminates its last content line rather than
-    // starting a new one. Without this, endLine over-counts by 1 and the edit
-    // marks the FOLLOWING line as part of its (inclusive) range, mis-shifting
-    // snapshot/context ranges. Reviewer-verified: ranges are inclusive
-    // end-to-end with no downstream compensation. No effect for needles that
-    // do not end in "\n".
-    if (needle.endsWith('\n')) oldLineCount--;
-    let idx = 0;
-    let scanned = 0;
-    let lineNo = 1;
-    let minStart = Infinity;
-    let maxEnd = 0;
-    let found = false;
-    while ((idx = content.indexOf(needle, idx)) !== -1) {
-        for (let i = scanned; i < idx; i++) {
-            if (content.charCodeAt(i) === 10) lineNo++;
-        }
-        scanned = idx;
-        const startLine = lineNo;
-        const endLine = startLine + oldLineCount - 1;
-        minStart = Math.min(minStart, startLine);
-        maxEnd = Math.max(maxEnd, endLine);
-        found = true;
-        idx += needle.length;
-        if (!replaceAll) break;
-    }
-    if (!found) return null;
-    return { startLine: minStart, endLine: maxEnd };
-}
-
-export function shiftSnapshotRangesForEdit(snapshot, opts = {}) {
-    if (!snapshot || !Array.isArray(snapshot.ranges)) return snapshot;
-    const lineDelta = Number(opts.lineDelta);
-    const delta = Number.isFinite(lineDelta) ? lineDelta : 0;
-    const editStart = Number(opts.editStartLine);
-    const editEnd = Number(opts.editEndLine);
-    const hasSpan = Number.isFinite(editStart) && Number.isFinite(editEnd) && editStart >= 1 && editEnd >= editStart;
-
-    const out = [];
-    for (const raw of snapshot.ranges) {
-        const r = normaliseSnapshotRange(raw);
-        if (!r) continue;
-        if (isFullFileSentinelRange(r)) {
-            out.push({ startLine: 1, endLine: Infinity });
-            continue;
-        }
-        let { startLine, endLine } = r;
-        if (!hasSpan) {
-            if (delta !== 0) {
-                startLine = Math.max(1, startLine + delta);
-                if (endLine !== Infinity) endLine = endLine + delta;
-            }
-        } else if (endLine !== Infinity && endLine < editStart) {
-            // entirely before the edited span
-        } else if (startLine > editEnd) {
-            startLine = Math.max(1, startLine + delta);
-            if (endLine !== Infinity) endLine = endLine + delta;
-        } else {
-            // overlaps the edited span — keep start, extend/shrink end safely
-            if (endLine !== Infinity) {
-                endLine = Math.max(startLine, endLine + delta);
-            }
-        }
-        if (endLine !== Infinity && endLine < startLine) continue;
-        out.push({ startLine, endLine });
-    }
-    return { ...snapshot, ranges: out };
-}
-
-export function shiftSnapshotRangesByLineDelta(snapshot, lineDelta) {
-    return shiftSnapshotRangesForEdit(snapshot, { lineDelta });
-}
-
-export function isStrongExactEditTarget(oldStr, stage) {
-    const s = String(oldStr ?? '').trim();
-    const fuzzy = stage && stage !== 'exact';
-    const singleLineMin = fuzzy ? 16 : 32;
-    const multiLineMin = fuzzy ? 10 : 20;
-    if (s.length >= singleLineMin) return true;
-    if (s.includes('\n') && s.length >= multiLineMin) return true;
-    return false;
-}
-
-function snapshotMetaHasFullCoverage(meta, content) {
-    if (!meta || !Array.isArray(meta.ranges)) return false;
-    if (snapshotCoversFullFile(meta)) return true;
-    const lineCount = String(content ?? '').split(/\r?\n/).length;
-    return snapshotRangesCoverAllLines(meta, lineCount);
-}
-
-export function postEditSnapshotMeta(prevSnapshot, source, content, opts = {}) {
-    const text = Buffer.isBuffer(content) ? content.toString('utf-8') : String(content ?? '');
-    let lineDelta = Number(opts.lineDelta);
-    if (!Number.isFinite(lineDelta) && opts.contentBeforeEdit != null) {
-        const before = Buffer.isBuffer(opts.contentBeforeEdit)
-            ? opts.contentBeforeEdit.toString('utf-8')
-            : String(opts.contentBeforeEdit ?? '');
-        const after = text;
-        lineDelta = countLfInString(after) - countLfInString(before);
-    }
-    if (!Number.isFinite(lineDelta) && opts.oldStr != null && opts.newStr != null) {
-        const per = countLfInString(opts.newStr) - countLfInString(opts.oldStr);
-        const beforeText = Buffer.isBuffer(opts.contentBeforeEdit)
-            ? opts.contentBeforeEdit.toString('utf-8')
-            : String(opts.contentBeforeEdit ?? '');
-        const occ = opts.replaceAll === true
-            ? Math.max(1, countOccurrences(beforeText, opts.oldStr))
-            : 1;
-        lineDelta = per * occ;
-    }
-    if (!Number.isFinite(lineDelta)) lineDelta = 0;
-
-    let editStartLine = Number(opts.editStartLine);
-    let editEndLine = Number(opts.editEndLine);
-    if (!(Number.isFinite(editStartLine) && Number.isFinite(editEndLine)) && typeof opts.oldStr === 'string' && opts.contentBeforeEdit != null) {
-        const beforeText = Buffer.isBuffer(opts.contentBeforeEdit)
-            ? opts.contentBeforeEdit.toString('utf-8')
-            : String(opts.contentBeforeEdit ?? '');
-        const span = lineRangeForSubstring(beforeText, opts.oldStr, { replaceAll: opts.replaceAll === true });
-        if (span) {
-            editStartLine = span.startLine;
-            editEndLine = span.endLine;
-        }
-    }
-
-    const meta = { source };
-    if (prevSnapshot && Array.isArray(prevSnapshot.ranges)) {
-        if (opts.shiftRanges === false) {
-            meta.ranges = prevSnapshot.ranges.map((r) => ({ ...r }));
-        } else {
-            const shifted = shiftSnapshotRangesForEdit(prevSnapshot, {
-                lineDelta,
-                editStartLine,
-                editEndLine,
-            });
-            if (shifted && Array.isArray(shifted.ranges)) meta.ranges = shifted.ranges;
-        }
-    }
-    if (snapshotMetaHasFullCoverage(meta, text)) {
-        meta.contentHash = hashText(text);
-    }
-    return meta;
-}
-
-export function maybeAutoStripLineNumberPrefixes(oldStr) {
-    if (typeof oldStr !== 'string' || oldStr.length === 0) return null;
-    if (!/^\s*\d+[\t│→]/.test(oldStr)) return null;
-    const lines = oldStr.split('\n');
-    const stripped = [];
-    for (const ln of lines) {
-        const m = ln.match(/^\s*\d+[\t│→](.*)$/);
-        if (!m) return null;
-        stripped.push(m[1]);
-    }
-    return stripped.join('\n');
-}
-
-export function countOccurrences(haystack, needle) {
-    if (typeof needle !== 'string' || needle.length === 0) return 0;
-    let count = 0;
-    let idx = 0;
-    while ((idx = haystack.indexOf(needle, idx)) !== -1) {
-        count++;
-        idx += needle.length;
-    }
-    return count;
-}
-
-export function lineContextAround(content, startLine, endLine, radius = 3, maxChars = 1600) {
-    const lines = String(content ?? '').split('\n');
-    const total = lines.length;
-    const start = Math.max(1, Math.min(total, startLine) - radius);
-    const end = Math.min(total, Math.max(startLine, endLine) + radius);
-    let out = lines
-        .slice(start - 1, end)
-        .map((line, i) => renderReadLine(start + i, line, { truncateLongLine: false }))
-        .join('\n');
-    if (out.length > maxChars) {
-        const head = out.slice(0, Math.floor(maxChars * 0.6));
-        const tail = out.slice(Math.max(0, out.length - Math.floor(maxChars * 0.4)));
-        out = `${head}\n... [context middle omitted] ...\n${tail}`;
-    }
-    return out;
-}
-
-export function compactEditContext(content, startLine, endLine, opts = {}) {
-    const lines = String(content ?? '').split('\n');
-    const total = Math.max(1, lines.length);
-    const maxLines = Math.max(1, Math.min(20, Number(opts.maxLines) || 20));
-    const targetStart = Math.max(1, Math.min(total, Number(startLine) || 1));
-    const targetEnd = Math.max(targetStart, Math.min(total, Number(endLine) || targetStart));
-    const targetLines = Math.max(1, targetEnd - targetStart + 1);
-    const extra = Math.max(0, maxLines - targetLines);
-    let start = Math.max(1, targetStart - Math.floor(extra / 2));
-    let end = Math.min(total, start + maxLines - 1);
-    start = Math.max(1, Math.min(start, Math.max(1, end - maxLines + 1)));
-    const range = { startLine: start, endLine: end };
-    const maxLineChars = Math.max(80, Math.min(240, Number(opts.maxLineChars) || 180));
-    let text = lines.slice(start - 1, end).map((line, i) => {
-        let s = String(line ?? '');
-        if (s.length > maxLineChars) s = `${s.slice(0, Math.max(20, maxLineChars - 24))} ... [line truncated]`;
-        return renderReadLine(start + i, s, { truncateLongLine: false });
-    }).join('\n');
-    const maxChars = Math.max(300, Math.min(1800, Number(opts.maxChars) || 1400));
-    if (text.length > maxChars) text = `${text.slice(0, maxChars - 28)}\n... [context truncated]`;
-    return { range, text };
-}

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

@@ -1,211 +0,0 @@
-// Render the first `n` chars of a string as `"<glyph>" U+XXXX` units so
-// invisible / look-alike chars surface in a single glance from a
-// match-failure hint, without needing a separate hex dumper.
-export function renderCodepointPreview(str, n) {
-    const arr = Array.from(String(str || '').slice(0, n * 2)).slice(0, n);
-    return arr.map((ch) => {
-        const cp = ch.codePointAt(0);
-        const hex = cp.toString(16).toUpperCase().padStart(4, '0');
-        const glyph = (cp >= 0x20 && cp !== 0x7f) ? ch : ' ';
-        return `"${glyph}" U+${hex}`;
-    }).join(' | ');
-}
-
-// Compare two strings char-by-char (codepoint-aware) and return the
-// first divergence, or null if oldStr is a prefix of sliceStr.
-export function firstDivergence(oldStr, sliceStr) {
-    const a = Array.from(String(oldStr || ''));
-    const b = Array.from(String(sliceStr || ''));
-    const len = Math.min(a.length, b.length);
-    for (let i = 0; i < len; i++) {
-        if (a[i] !== b[i]) {
-            return { index: i, expected: a[i], found: b[i] };
-        }
-    }
-    if (a.length > b.length) return { index: b.length, expected: a[b.length], found: '<eol>' };
-    return null;
-}
-
-// 1-based {line, col} for a UTF-16 code-unit `index` into `content`. Used by
-// failure diagnostics so misses report a file coordinate, not a raw offset.
-export function indexToLineCol(content, index) {
-    const s = String(content || '');
-    const clamped = Math.max(0, Math.min(Number(index) | 0, s.length));
-    let line = 1;
-    let col = 1;
-    for (let i = 0; i < clamped; i++) {
-        if (s.charCodeAt(i) === 10) { line++; col = 1; }
-        else col++;
-    }
-    return { line, col };
-}
-
-// Invariant-based "closest candidate region" finder: scans every position
-// in `content` and returns the one whose common prefix with `oldStr` is
-// longest. Ties resolve to the lowest index (earliest in file). Worst case
-// O(n*m) but exits at the first divergence per position, so most positions
-// cost O(1) when no shared prefix exists. Returns null on empty inputs.
-export function bestPrefixWindow(content, oldStr) {
-    const s = String(content || '');
-    const needle = String(oldStr || '');
-    if (!needle || !s) return null;
-    const nlen = needle.length;
-    const slen = s.length;
-    let bestIdx = 0;
-    let bestPrefix = -1;
-    for (let i = 0; i <= slen; i++) {
-        const cap = Math.min(nlen, slen - i);
-        let k = 0;
-        while (k < cap && s.charCodeAt(i + k) === needle.charCodeAt(k)) k++;
-        if (k > bestPrefix) {
-            bestPrefix = k;
-            bestIdx = i;
-            if (k === nlen) break;
-        }
-    }
-    return { index: bestIdx, prefixLen: Math.max(0, bestPrefix) };
-}
-
-// Pair `bestPrefixWindow` with `firstDivergence` semantics so callers get
-// a complete first-divergence record (window start line/col, divergence
-// line/col, expected vs found char, common-prefix length). Returns null
-// when there is nothing to compare against.
-export function describeFirstDivergence(content, oldStr) {
-    const win = bestPrefixWindow(content, oldStr);
-    if (!win) return null;
-    const s = String(content);
-    const needle = String(oldStr);
-    const divIndex = win.index + win.prefixLen;
-    const expectedCh = win.prefixLen < needle.length ? needle.charAt(win.prefixLen) : '<eol>';
-    const foundCh = divIndex < s.length ? s.charAt(divIndex) : '<eol>';
-    const start = indexToLineCol(s, win.index);
-    const div = indexToLineCol(s, divIndex);
-    return {
-        windowIndex: win.index,
-        startLine: start.line,
-        startCol: start.col,
-        prefixLen: win.prefixLen,
-        line: div.line,
-        col: div.col,
-        expected: expectedCh,
-        found: foundCh,
-    };
-}
-
-// Per-index batch-peer diagnoser. The multi-edit loop applies edits
-// sequentially to an in-memory transaction buffer and aborts atomically
-// at `failedIndex`, so labels key off that boundary instead of re-matching
-// every edit against the already-mutated content:
-//   j <  failedIndex  -> `applied` (matched + applied earlier this txn)
-//   j === failedIndex -> `*` + live diagnosis (miss/ambig + diverge point)
-//   j >  failedIndex  -> `blocked` (never evaluated; txn aborted first)
-// This stops already-applied edits from being mislabeled `miss` once their
-// old_string bytes are consumed (the "1 error reads as N failures" fix).
-// `findCrlf` is injected to avoid pulling edit-match-utils.mjs (shared
-// matcher, off-limits) into this module's import graph.
-export function diagnoseBatchPeers(content, edits, failedIndex, findCrlf) {
-    if (!Array.isArray(edits) || edits.length === 0) return '';
-    const labels = [];
-    for (let j = 0; j < edits.length; j++) {
-        const tag = j === failedIndex ? `${j}*` : `${j}`;
-        const e = edits[j];
-        if (!e || typeof e.old_string !== 'string' || typeof e.new_string !== 'string') {
-            labels.push(`[${tag}]=invalid`); continue;
-        }
-        // Edits before the failure were already matched + applied to the
-        // in-memory transaction content; their old_string bytes are now
-        // consumed, so re-matching against the mutated content would
-        // mislabel them `miss`. They PASSED — report `applied`, skip re-check.
-        if (j < failedIndex) { labels.push(`[${tag}]=applied`); continue; }
-        // Edits after the failure were never evaluated: the atomic batch
-        // aborts at failedIndex, so their real-turn content differs from this
-        // intermediate snapshot and any match here is not authoritative.
-        if (j > failedIndex) { labels.push(`[${tag}]=blocked`); continue; }
-        const oldStr = e.old_string;
-        if (oldStr.length === 0) { labels.push(`[${tag}]=empty`); continue; }
-        // Literal occurrence count.
-        let cnt = 0;
-        let firstIdx = -1;
-        {
-            let idx = 0;
-            while ((idx = content.indexOf(oldStr, idx)) !== -1) {
-                if (firstIdx === -1) firstIdx = idx;
-                cnt++;
-                if (cnt >= 2) break;
-                idx += oldStr.length || 1;
-            }
-        }
-        if (cnt === 1) { labels.push(`[${tag}]=ok`); continue; }
-        if (cnt > 1) {
-            labels.push(e.replace_all === true ? `[${tag}]=ok(replace_all)` : `[${tag}]=ambig(${cnt}+)`);
-            continue;
-        }
-        // CRLF-fold fallback when a matcher is supplied. Keeps the label
-        // honest when the only divergence is line endings.
-        if (typeof findCrlf === 'function') {
-            try {
-                const crlf = findCrlf(content, oldStr);
-                const crlfCnt = crlf && Array.isArray(crlf.ranges) ? crlf.ranges.length : 0;
-                if (crlfCnt === 1) { labels.push(`[${tag}]=ok(crlf-fold)`); continue; }
-                if (crlfCnt > 1) {
-                    labels.push(e.replace_all === true ? `[${tag}]=ok(crlf-fold,replace_all)` : `[${tag}]=ambig(${crlfCnt},crlf-fold)`);
-                    continue;
-                }
-            } catch {}
-        }
-        // True miss — report the first divergence point against the closest
-        // candidate region so the caller knows which line+col to inspect.
-        const div = describeFirstDivergence(content, oldStr);
-        if (!div) { labels.push(`[${tag}]=miss`); continue; }
-        labels.push(
-            `[${tag}]=miss(line ${div.line} col ${div.col}: expected ${renderCharForDiff(div.expected)} got ${renderCharForDiff(div.found)}; common prefix ${div.prefixLen} chars from line ${div.startLine} col ${div.startCol})`
-        );
-    }
-    if (labels.length === 0) return '';
-    return `\n  Edits: ${labels.join(' ')}`;
-}
-
-function unicodeEscape(ch) {
-    const cp = String(ch).codePointAt(0);
-    if (!Number.isFinite(cp)) return '';
-    return cp <= 0xffff
-        ? `\\u${cp.toString(16).padStart(4, '0')}`
-        : `\\u{${cp.toString(16)}}`;
-}
-
-function shortUtf8Hex(str) {
-    const bytes = Buffer.from(String(str), 'utf8');
-    const shown = [...bytes.subarray(0, 24)]
-        .map((b) => b.toString(16).padStart(2, '0'))
-        .join(' ');
-    return bytes.length > 24 ? `${shown} ...` : shown;
-}
-
-export function editNeedleEncodingNote(content, oldStr) {
-    const old = String(oldStr || '');
-    if (!old) return '';
-    const interesting = Array.from(old).find((ch) => {
-        const cp = ch.codePointAt(0);
-        return cp > 0x7e || (cp < 0x20 && cp !== 0x09 && cp !== 0x0a && cp !== 0x0d);
-    });
-    if (!interesting) return '';
-    const esc = unicodeEscape(interesting);
-    const lower = esc.toLowerCase();
-    const upper = esc.toUpperCase().replace('\\U', '\\u');
-    const fileHasLiteralEscape = String(content || '').includes(lower) || String(content || '').includes(upper);
-    const suffix = fileHasLiteralEscape ? `; file contains literal escape ${lower}` : '';
-    return `\n  old_string decoded char ${renderCharForDiff(interesting)} utf8=[${shortUtf8Hex(interesting)}] escape=${lower}${suffix}`;
-}
-
-// Render a single divergence char (or the '<eol>' sentinel) as a compact
-// `"<glyph>" U+XXXX` token. Used by both the per-edit miss labels and the
-// nearest-match diverge line so output stays consistent.
-export function renderCharForDiff(ch) {
-    if (ch === undefined || ch === null || ch === '<eol>') return '"⏎" U+000A';
-    const s = String(ch);
-    if (s.length === 0) return '"⏎" U+000A';
-    const cp = s.codePointAt(0);
-    const hex = cp.toString(16).toUpperCase().padStart(4, '0');
-    const visible = (cp >= 0x20 && cp !== 0x7f) ? s : ' ';
-    return `"${visible}" U+${hex}`;
-}