mixdog 0.7.1

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

@@ -0,0 +1,126 @@
+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

@@ -0,0 +1,141 @@
+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

@@ -0,0 +1,194 @@
+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

@@ -0,0 +1,60 @@
+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 };
+}