mixdog 0.7.18 → 0.8.0

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

@@ -1,126 +0,0 @@
-import { readFileSync } from 'fs';
-import { findActualString } from '../edit-normalize.mjs';
-import { normalizeOutputPath } from './path-utils.mjs';
-import { READ_MAX_SIZE_BYTES } from './read-constants.mjs';
-import { isBinaryFile } from './binary-file.mjs';
-import { hashText } from './hash-utils.mjs';
-import { rangeHashesForReadRanges } from './snapshot-helpers.mjs';
-import {
-    compactEditContext,
-    countOccurrences,
-    lineContextAround,
-} from './edit-context-utils.mjs';
-import { findEditHint } from './edit-hint.mjs';
-import { recordReadSnapshot } from './read-snapshot-runtime.mjs';
-
-export function recordPreviewSnapshot(fullPath, scope, content, range) {
-    if (!fullPath || !range) return false;
-    try {
-        recordReadSnapshot(fullPath, undefined, scope, {
-            source: 'edit_failure_preview',
-            ranges: [range],
-            rangeHashes: rangeHashesForReadRanges(content, [range]),
-        });
-        return true;
-    } catch {
-        return false;
-    }
-}
-
-export function editFailureContextHint(content, startLine, endLine, options = {}, meta = {}) {
-    if (options.includePreview === false) return '';
-    const rendered = compactEditContext(content, startLine, endLine, {
-        maxLines: options.previewMaxLines || 20,
-        maxChars: options.previewMaxChars || 1400,
-    });
-    const canRecord = options.recordPreviewSnapshot === true && meta.matchesLength === 1;
-    const recorded = canRecord
-        ? recordPreviewSnapshot(options.fullPath, options.scope, options.snapshotContent ?? content, rendered.range)
-        : false;
-    return `\n  context ${rendered.range.startLine}-${rendered.range.endLine}${recorded ? ' (snapshot recorded)' : ''}:\n${rendered.text}`;
-}
-
-export function buildStaleEditRecovery({ fullPath, scope, oldStrings = [], recordPreviewSnapshot: shouldRecordPreview = false } = {}) {
-    let content = '';
-    try { content = readFileSync(fullPath, 'utf-8'); }
-    catch { return ''; }
-    const candidates = (Array.isArray(oldStrings) ? oldStrings : [])
-        .map((entry) => typeof entry === 'string' ? entry : entry?.old_string)
-        .filter((s) => typeof s === 'string' && s.length > 0)
-        .slice(0, 3);
-    for (const oldString of candidates) {
-        const actual = findActualString(content, oldString) || oldString;
-        const count = countOccurrences(content, actual);
-        if (count !== 1) continue;
-        const idx = content.indexOf(actual);
-        const startLine = lineForIndex(content, idx);
-        const endLine = startLine + actual.split('\n').length - 1;
-        return editFailureContextHint(content, startLine, endLine, {
-            fullPath,
-            scope,
-            snapshotContent: content,
-            recordPreviewSnapshot: shouldRecordPreview,
-            previewMaxLines: 12,
-            previewMaxChars: 1000,
-        }, { matchesLength: 1 });
-    }
-    if (candidates[0]) {
-        const hint = findEditHint(content, candidates[0], null);
-        if (hint) return `\n  current file:${hint}`;
-    }
-    return '';
-}
-
-export function lineForIndex(content, index) {
-    if (index <= 0) return 1;
-    const end = Math.min(index, content.length);
-    let lineNo = 1;
-    for (let i = 0; i < end; i++) {
-        if (content.charCodeAt(i) === 10) lineNo++;
-    }
-    return lineNo;
-}
-
-export function primeReadSnapshotForEdit({ fullPath, filePath, st, scope, oldStrings = [], lineRange = null }) {
-    if (!/^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_EDIT_AUTO_SNAPSHOT || ''))) return null;
-    if (!st || st.size > READ_MAX_SIZE_BYTES || isBinaryFile(fullPath, st.size)) return null;
-    let rawBuf;
-    try { rawBuf = readFileSync(fullPath); }
-    catch { return null; }
-    if (!Buffer.isBuffer(rawBuf)) return null;
-    const content = rawBuf.toString('utf-8');
-    const lines = content.split('\n');
-    recordReadSnapshot(fullPath, st, scope, {
-        source: 'auto_snapshot',
-        contentHash: hashText(content),
-    });
-
-    const out = [
-        `Edit snapshot primed from disk for ${normalizeOutputPath(filePath)} (no prior read in this scope).`,
-    ];
-    const checks = [];
-    let firstContext = null;
-    for (let i = 0; i < Math.min(oldStrings.length, 5); i++) {
-        const entry = oldStrings[i] || {};
-        const label = entry.label || `edit ${i}`;
-        const oldString = entry.old_string;
-        if (typeof oldString !== 'string' || oldString.length === 0) continue;
-        const count = countOccurrences(content, oldString);
-        checks.push(`${label}: old_string ${count === 1 ? 'found once' : count === 0 ? 'not found' : `found ${count} times`}`);
-        if (!firstContext && count > 0) {
-            const idx = content.indexOf(oldString);
-            const startLine = lineForIndex(content, idx);
-            const endLine = startLine + oldString.split('\n').length - 1;
-            firstContext = lineContextAround(content, startLine, endLine);
-        }
-    }
-    if (checks.length > 0) out.push(`Match check: ${checks.join('; ')}`);
-    if (lineRange) {
-        out.push(`Line check: requested ${lineRange.startLine}-${lineRange.endLine}; file has ${lines.length} lines.`);
-        out.push(`Context around requested lines:\n${lineContextAround(content, lineRange.startLine, lineRange.endLine)}`);
-    } else if (firstContext) {
-        out.push(`Context around first match:\n${firstContext}`);
-    }
-    const diagnostic = out.join('\n');
-    return { content, rawBuf, diagnostic: diagnostic || undefined };
-}

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

@@ -1,141 +0,0 @@
-import { snapshotCoversFullFile } from './snapshot-helpers.mjs';
-import {
-    firstDivergence,
-    renderCodepointPreview,
-    describeFirstDivergence,
-    renderCharForDiff,
-} from './edit-diagnostics.mjs';
-import { editFailureSuffix } from './edit-match-utils.mjs';
-
-function leadingWhitespaceColumns(line) {
-    let cols = 0;
-    for (const ch of String(line ?? '')) {
-        if (ch === ' ') cols++;
-        else if (ch === '\t') cols += 4;
-        else break;
-    }
-    return cols;
-}
-
-function formatIndentKind(line) {
-    const raw = /^[ \t]*/.exec(String(line ?? ''))?.[0] || '';
-    if (!raw) return 'none';
-    const spaces = (raw.match(/ /g) || []).length;
-    const tabs = (raw.match(/\t/g) || []).length;
-    return [spaces ? `${spaces} spaces` : '', tabs ? `${tabs} tabs` : ''].filter(Boolean).join(' + ');
-}
-
-function indentMismatchHint(sentLine, fileLine) {
-    return '';
-}
-
-function firstLineFallbackStageHint(content, line) {
-    return '';
-}
-
-function editRetryCallHint(options, candidate) {
-    return '';
-}
-
-function editNearestReadHint(options, line) {
-    return '';
-}
-
-// Lightweight nearest-match hint for `Error [code 8]: old_string not
-// found`. Probes by the first non-empty line of `old_string` (trimmed,
-// capped at 60 chars then 30) so callers see where they likely meant
-// to land. Substring only, no fuzzy diff, to keep the failure path cheap.
-export function findEditHint(content, oldStr, snapshot = null, options = {}) {
-    const oldLines = String(oldStr || '').split(/\r?\n/);
-    const firstNonEmptyIndex = oldLines.findIndex((l) => l.trim().length > 0);
-    const firstNonEmpty = firstNonEmptyIndex >= 0 ? oldLines[firstNonEmptyIndex] : '';
-    const trimmed = firstNonEmpty.trim();
-    const editIdx = Number.isInteger(options?.editIndex) ? options.editIndex : null;
-    const idxTag = editIdx !== null ? ` [edit ${editIdx}]` : '';
-    if (trimmed.length < 8) {
-        // No probe long enough to anchor a nearest-match search. Still emit
-        // an invariant divergence line so the caller knows where the closest
-        // prefix landed instead of getting silence.
-        const div = describeFirstDivergence(content, oldStr);
-        if (!div) return '';
-        return `${idxTag ? `\n  edit ${editIdx} miss:` : ''}`
-            + `\n  diverge${idxTag}: at line ${div.line} col ${div.col} expected ${renderCharForDiff(div.expected)} but file has ${renderCharForDiff(div.found)} (common prefix ${div.prefixLen} chars from line ${div.startLine} col ${div.startCol})`;
-    }
-    const probes = [trimmed.slice(0, 60), trimmed.slice(0, 30)].filter((p) => p.length >= 8);
-    const lines = String(content).split('\n');
-
-    let normHint = '';
-    try {
-        const rawContent = String(content);
-        const rawOld = String(oldStr);
-        if (rawContent.indexOf(rawOld) === -1) {
-            const nfcContent = rawContent.normalize('NFC');
-            const nfcOld = rawOld.normalize('NFC');
-            const nfdContent = rawContent.normalize('NFD');
-            const nfdOld = rawOld.normalize('NFD');
-            if (nfcOld !== rawOld && nfcContent.indexOf(nfcOld) !== -1) {
-                normHint = ' Unicode normalisation mismatch: NFC-normalising old_string matches the file. Re-send old_string in NFC form (e.g. JS `s.normalize("NFC")`).';
-            } else if (nfdOld !== rawOld && nfdContent.indexOf(nfdOld) !== -1 && nfcContent.indexOf(nfcOld) === -1) {
-                normHint = ' Unicode normalisation mismatch: NFD form of old_string matches the file but NFC does not. The file likely stores NFD; re-send old_string in NFD form.';
-            }
-        }
-    } catch {}
-
-    let winStart = 1;
-    let winEnd = lines.length;
-    if (snapshot && !snapshotCoversFullFile(snapshot)) {
-        const ranges = Array.isArray(snapshot.ranges) ? snapshot.ranges : [];
-        if (ranges.length === 0) return normHint;
-        winStart = ranges[0].startLine;
-        const last = ranges[ranges.length - 1];
-        winEnd = last.endLine === Infinity ? lines.length : Math.min(lines.length, last.endLine);
-    }
-    for (const probe of probes) {
-        for (let i = winStart - 1; i < winEnd; i++) {
-            if (lines[i] !== undefined && lines[i].includes(probe)) {
-                const preview = lines[i].length > 80 ? lines[i].slice(0, 77) + '...' : lines[i];
-                const sentPreview = renderCodepointPreview(firstNonEmpty, 40);
-                const filePreview = renderCodepointPreview(lines[i], 40);
-                const probeIdx = lines[i].indexOf(probe);
-                const sliceForDiff = probeIdx >= 0 ? lines[i].slice(probeIdx, probeIdx + trimmed.length) : lines[i];
-                const div = firstDivergence(trimmed, sliceForDiff);
-                // Translate the intra-slice char offset back into absolute
-                // file line+col so the operator can jump straight to the
-                // mismatch. lines[] is split on \n, so col is 1-based within
-                // the line. The probe sits at probeIdx (0-based) inside the
-                // nearest line; the divergence sits div.index codepoints
-                // further along. Fall back to `describeFirstDivergence` when
-                // the probe-vs-trimmed compare reports no divergence (i.e.
-                // probe is a true prefix of the slice) — we still want a
-                // global coordinate against the full old_string.
-                let divLine = '';
-                if (div) {
-                    const lineNo = i + 1;
-                    const col = (probeIdx >= 0 ? probeIdx : 0) + div.index + 1;
-                    divLine = `\n  diverge${idxTag}: at line ${lineNo} col ${col} expected ${renderCharForDiff(div.expected)} but file has ${renderCharForDiff(div.found)}`;
-                } else {
-                    const globalDiv = describeFirstDivergence(content, oldStr);
-                    if (globalDiv && globalDiv.prefixLen < String(oldStr).length) {
-                        divLine = `\n  diverge${idxTag}: at line ${globalDiv.line} col ${globalDiv.col} expected ${renderCharForDiff(globalDiv.expected)} but file has ${renderCharForDiff(globalDiv.found)} (common prefix ${globalDiv.prefixLen} chars from line ${globalDiv.startLine} col ${globalDiv.startCol})`;
-                    }
-                }
-                return ` Nearest match${idxTag} at line ${i + 1}: ${JSON.stringify(preview)}.${normHint}`
-                    + `\n  sent : ${sentPreview}`
-                    + `\n  file : ${filePreview}`
-                    + divLine
-                    + indentMismatchHint(firstNonEmpty, lines[i])
-                    + firstLineFallbackStageHint(content, firstNonEmpty)
-                    + editNearestReadHint(options, i + 1)
-                    + editFailureSuffix(content, oldStr);
-            }
-        }
-    }
-    // Invariant fallback: no probe landed, but the operator still needs a
-    // file coordinate. Run the longest-common-prefix scan against the full
-    // old_string so the miss is debuggable rather than silent.
-    const globalDiv = describeFirstDivergence(content, oldStr);
-    const globalLine = globalDiv && globalDiv.prefixLen < String(oldStr).length
-        ? `\n  diverge${idxTag}: at line ${globalDiv.line} col ${globalDiv.col} expected ${renderCharForDiff(globalDiv.expected)} but file has ${renderCharForDiff(globalDiv.found)} (common prefix ${globalDiv.prefixLen} chars from line ${globalDiv.startLine} col ${globalDiv.startCol})`
-        : '';
-    return normHint + globalLine + editFailureSuffix(content, oldStr);
-}

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

@@ -1,194 +0,0 @@
-export function editFailureSuffix(content, oldStr) {
-    return '';
-}
-
-export function validateEditChunkSize(oldStr, replaceAll, allowLarge) {
-    if (replaceAll || allowLarge) return null;
-    const lines = String(oldStr || '').split(/\r?\n/).length;
-    if (lines < 30) return null;
-    return `Error [code 10]: old_string is ${lines} lines (>= 30).`;
-}
-
-export function occurrenceLinesPlain(content, needle, max = 3) {
-    if (typeof needle !== 'string' || needle.length === 0) return [];
-    const lines = [];
-    let pos = 0, scanned = 0, lineNo = 1;
-    while (lines.length < max) {
-        const idx = content.indexOf(needle, pos);
-        if (idx === -1) break;
-        for (let i = scanned; i < idx; i++) {
-            if (content.charCodeAt(i) === 10) lineNo++;
-        }
-        scanned = idx;
-        lines.push(lineNo);
-        pos = idx + needle.length;
-    }
-    return lines;
-}
-
-export function occurrenceLinesCrlf(content, ranges, max = 3) {
-    if (!Array.isArray(ranges) || ranges.length === 0) return [];
-    const lines = [];
-    let scanned = 0, lineNo = 1;
-    for (let k = 0; k < Math.min(max, ranges.length); k++) {
-        const idx = ranges[k].start;
-        for (let i = scanned; i < idx; i++) {
-            if (content.charCodeAt(i) === 10) lineNo++;
-        }
-        scanned = idx;
-        lines.push(lineNo);
-    }
-    return lines;
-}
-
-export function formatMatchLines(linesArr, totalCount) {
-    if (linesArr.length === 0) return '';
-    const more = totalCount > linesArr.length ? ` (+${totalCount - linesArr.length} more)` : '';
-    return ` Matches at lines: ${linesArr.join(', ')}${more}.`;
-}
-
-export function buildCrlfNormalisedViewWithMap(text) {
-    const source = String(text ?? '');
-    let normalised = '';
-    const map = [];
-    for (let i = 0; i < source.length;) {
-        map[normalised.length] = i;
-        if (source[i] === '\r' && source[i + 1] === '\n') {
-            normalised += '\n';
-            i += 2;
-        } else {
-            normalised += source[i];
-            i += 1;
-        }
-    }
-    map[normalised.length] = source.length;
-    return { normalised, map };
-}
-
-export function findCrlfNormalisedMatches(content, oldStr) {
-    if (typeof oldStr !== 'string' || oldStr.length === 0) return null;
-    if (String(content).indexOf('\r\n') === -1 && oldStr.indexOf('\r\n') === -1) return null;
-    const { normalised, map } = buildCrlfNormalisedViewWithMap(content);
-    const normalisedOld = oldStr.replace(/\r\n/g, '\n');
-    if (normalisedOld.length === 0 || normalisedOld === oldStr && normalised === content) return null;
-    const ranges = [];
-    let idx = 0;
-    while ((idx = normalised.indexOf(normalisedOld, idx)) !== -1) {
-        ranges.push({
-            normStart: idx,
-            normEnd: idx + normalisedOld.length,
-            start: map[idx],
-            end: map[idx + normalisedOld.length],
-        });
-        idx += normalisedOld.length;
-    }
-    return { normalised, normalisedOld, ranges };
-}
-
-export function replacementForOriginalSlice(newStr, originalSlice, fileContent) {
-    if (typeof newStr !== 'string') return newStr;
-    const slice = String(originalSlice);
-    if (!slice.includes('\r\n') && !slice.includes('\n')) {
-        if (typeof fileContent !== 'string') return newStr;
-        if (fileContent.indexOf('\r\n') === -1) return newStr;
-        // Pure-CRLF file: every bare \n is part of a \r\n pair. Mixed
-        // files (any bare \n that is not preceded by \r) stay untouched
-        // so we don't synthesise CRLF where the file uses LF.
-        for (let i = 0; i < fileContent.length; i += 1) {
-            if (fileContent.charCodeAt(i) === 10 && (i === 0 || fileContent.charCodeAt(i - 1) !== 13)) {
-                return newStr;
-            }
-        }
-        return newStr.replace(/\r\n/g, '\n').replace(/\n/g, '\r\n');
-    }
-    const lfReplacement = newStr.replace(/\r\n/g, '\n');
-    let result = slice.includes('\r\n')
-        ? lfReplacement.replace(/\n/g, '\r\n')
-        : lfReplacement;
-    // A matched slice can end on the last line's trailing EOL CR (split
-    // CRLF) while newStr — typically copied from a \r-stripped read view —
-    // has none. If the replacement ends mid-line, re-attach that consumed
-    // CR so the following LF still forms a \r\n instead of silently
-    // degrading to a lone \n (mixed-EOL corruption). A slice ending in a
-    // bare CR is always a split CRLF; the end-of-line guard avoids
-    // appending a stray CR when the replacement already carries its own
-    // line ending.
-    if (slice.endsWith('\r') && !/[\r\n]$/.test(result)) result += '\r';
-    return result;
-}
-
-export function replaceRangesFromOriginal(content, ranges, newStr) {
-    if (!Array.isArray(ranges) || ranges.length === 0) return content;
-    const sorted = ranges.slice().sort((a, b) => a.start - b.start);
-    let cursor = 0;
-    let out = '';
-    for (const range of sorted) {
-        if (!range || range.start < cursor || range.end < range.start) continue;
-        out += content.slice(cursor, range.start);
-        const originalSlice = content.slice(range.start, range.end);
-        out += replacementForOriginalSlice(newStr, originalSlice);
-        cursor = range.end;
-    }
-    return out + content.slice(cursor);
-}
-
-export function replaceSingleLiteralAt(content, index, needle, replacement) {
-    return content.slice(0, index) + replacement + content.slice(index + needle.length);
-}
-
-export function findLiteralOccurrenceState(haystack, needle) {
-    if (!needle) return { count: 0, index: -1 };
-    const first = haystack.indexOf(needle);
-    if (first === -1) return { count: 0, index: -1 };
-    // Overlap-aware ambiguity: `aa` in `aaa` has a second hit at first+1,
-    // not only at first+needle.length (which misses overlapping pairs).
-    const second = haystack.indexOf(needle, first + 1);
-    if (second === -1) return { count: 1, index: first };
-    return { count: 2, index: first };
-}
-
-export function countLiteralOccurrences(haystack, needle, limit = Infinity) {
-    if (!needle) return 0;
-    let count = 0;
-    let idx = 0;
-    while ((idx = haystack.indexOf(needle, idx)) !== -1) {
-        count++;
-        if (count >= limit) return count;
-        idx += 1;
-    }
-    return count;
-}
-
-export function diagnoseOtherEdits(content, edits, failedIndex) {
-    if (!Array.isArray(edits) || edits.length <= 1) return '';
-    let okCount = 0;
-    const problems = [];
-    for (let j = 0; j < edits.length; j++) {
-        if (j === failedIndex) continue;
-        const e = edits[j];
-        if (!e || typeof e.old_string !== 'string' || typeof e.new_string !== 'string') {
-            problems.push(`${j}=invalid`); continue;
-        }
-        const oldStr = e.old_string;
-        if (oldStr.length === 0) { problems.push(`${j}=empty`); continue; }
-        const cnt = countLiteralOccurrences(content, oldStr);
-        if (cnt === 1) { okCount++; continue; }
-        if (cnt > 1) {
-            if (e.replace_all === true) okCount++;
-            else problems.push(`${j}=ambig(${cnt})`);
-            continue;
-        }
-        const crlf = findCrlfNormalisedMatches(content, oldStr);
-        const crlfCnt = crlf ? crlf.ranges.length : 0;
-        if (crlfCnt === 1) { okCount++; continue; }
-        if (crlfCnt > 1) {
-            if (e.replace_all === true) okCount++;
-            else problems.push(`${j}=ambig(${crlfCnt})`);
-            continue;
-        }
-        problems.push(`${j}=miss`);
-    }
-    if (problems.length === 0) return '';
-    const head = okCount > 0 ? `${okCount} ok, ` : '';
-    return `\n  Peers: ${head}${problems.join(', ')}`;
-}

package/src/agent/orchestrator/tools/builtin/edit-partial-write.mjs

@@ -1,60 +0,0 @@
-import { openSync, writeSync, closeSync, fsyncSync, statSync } from 'fs';
-import { normalizeErrorMessage } from './path-diagnostics.mjs';
-import { hashText } from './hash-utils.mjs';
-import { partialByteWriteEnabled } from './edit-byte-utils.mjs';
-import { atomicWriteShouldFsync } from './atomic-write.mjs';
-
-function partialWriteHooks(hooks = {}) {
-    return {
-        ioTraceStart: typeof hooks.ioTraceStart === 'function' ? hooks.ioTraceStart : () => 0,
-        ioTraceDone: typeof hooks.ioTraceDone === 'function' ? hooks.ioTraceDone : () => {},
-        validatePreparedEditBase: typeof hooks.validatePreparedEditBase === 'function' ? hooks.validatePreparedEditBase : () => null,
-    };
-}
-
-export function tryWriteSameSizeByteReplacementsSync(fullPath, replacements, { baseStatSnapshot, baseMutationGeneration, baseContentHash, contentHash, fsync, filePath } = {}, hooks = {}) {
-    const { ioTraceStart, ioTraceDone, validatePreparedEditBase } = partialWriteHooks(hooks);
-    if (!partialByteWriteEnabled()) return null;
-    if (!Array.isArray(replacements) || replacements.length === 0 || !baseStatSnapshot) return null;
-    const sorted = replacements.slice().sort((a, b) => a.start - b.start || a.end - b.end);
-    for (let i = 0; i < sorted.length; i++) {
-        const span = sorted[i];
-        if (!span || !Buffer.isBuffer(span.newBytes)) return null;
-        if (!Number.isFinite(span.start) || !Number.isFinite(span.end) || span.start < 0 || span.end < span.start) return null;
-        if (span.end - span.start !== span.newBytes.length) return null;
-        if (i > 0 && span.start < sorted[i - 1].end) return null;
-    }
-    const prewriteErr = validatePreparedEditBase({
-        fullPath,
-        filePath: filePath || fullPath,
-        baseStatSnapshot,
-        baseMutationGeneration,
-        baseContentHash,
-    });
-    if (prewriteErr) return { ok: false, error: prewriteErr };
-    const traceStart = ioTraceStart();
-    let fd = null;
-    try {
-        fd = openSync(fullPath, 'r+');
-        for (const span of sorted) {
-            writeSync(fd, span.newBytes, 0, span.newBytes.length, span.start);
-        }
-        if (atomicWriteShouldFsync(fsync)) {
-            try { fsyncSync(fd); } catch (err) {
-                if (!['EPERM', 'ENOTSUP', 'EINVAL'].includes(err?.code)) throw err;
-            }
-        }
-    } catch (err) {
-        return { ok: false, error: `Error: partial byte write failed — ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}` };
-    } finally {
-        try { if (fd !== null) closeSync(fd); } catch {}
-    }
-    let stat = null;
-    try { stat = statSync(fullPath); } catch {}
-    ioTraceDone('edit_partial_write', traceStart, {
-        pathHash: hashText(fullPath).slice(0, 12),
-        replacements: sorted.length,
-        bytes: sorted.reduce((sum, span) => sum + span.newBytes.length, 0),
-    });
-    return { ok: true, stat, contentHash };
-}