@hheei/pi-apply-patch 0.2.0 → 0.3.1

package/dist/apply-patch/executor.js

@@ -1,6 +1,7 @@
-import { acquireMutationLock, errorMessage } from "@hheei/pi-ext-core";
+import { errorMessage } from "@hheei/pi-ext-core";
 import { APPLY_PATCH_MAX_FILE_SIZE, createLocalPatchFs, FsTransportError, fileTooLarge, gcAgentPatchTemps, publishPreparedFile, sftpTimeoutMs, } from "./fs.js";
-import { runJsDiffUpdate } from "./jsdiff.js";
+import { diagnoseRejectedHunk, runJsDiffUpdate } from "./jsdiff.js";
+import { CONFIRMED_STATUSES } from "./outcome.js";
 import { findV4aPatchConflicts, operationTouchedPaths, parseV4aPatch, } from "./parser.js";
 import { assertPatchPath } from "./paths.js";
 const SNAPSHOT_MAX_LINES = 150;
@@ -36,20 +37,15 @@ function plannedDelta(operation, content) {
         return { addedLines: 0, removedLines: lineCount(content) };
     return hunkDelta(operation.hunks);
 }
+/** Totals sum the rows, so the header can never disagree with the table drawn below it. */
 function progressTotals(operations) {
-    const paths = new Set();
     let addedLines = 0;
     let removedLines = 0;
     for (const operation of operations) {
-        paths.add(operation.path);
-        if (operation.status === "applied" ||
-            operation.status === "fuzzy" ||
-            operation.status === "partial") {
-            addedLines += operation.addedLines;
-            removedLines += operation.removedLines;
-        }
+        addedLines += operation.addedLines;
+        removedLines += operation.removedLines;
     }
-    return { files: paths.size, addedLines, removedLines };
+    return { addedLines, removedLines };
 }
 function splitTextLines(content) {
     const lines = new TextDecoder().decode(content).split(/\r\n|\n|\r/);
@@ -218,6 +214,50 @@ async function applyUpdate(fs, index, operation, policy, signal) {
         };
     }
 }
+/**
+ * A rejection reports lines of the file it left behind. Later operations on the same path publish
+ * their own shifts over those lines, so a diagnostic taken mid-patch can end up naming lines the
+ * model cannot find. Resolving it once more against the published file keeps the numbers usable.
+ * Best effort: an unreadable or vanished file keeps the original diagnostic.
+ */
+async function relocateRejections(fs, patch, rejected, applied, signal) {
+    for (const [position, entry] of rejected.entries()) {
+        if (entry.diagnostics.length === 0)
+            continue;
+        const lastIndex = Math.max(...entry.operationIndices);
+        const shifted = applied.some((operation) => operation.operationIndex > lastIndex &&
+            operation.paths.some((path) => entry.paths.includes(path)));
+        if (!shifted)
+            continue;
+        const path = entry.paths[0];
+        if (path === undefined)
+            continue;
+        let content;
+        try {
+            content = await fs.readFollow(path, signal);
+        }
+        catch {
+            continue;
+        }
+        const update = entry.operationIndices
+            .map((index) => patch.operations[index])
+            .find((operation) => operation?.kind === "update");
+        if (update?.kind !== "update")
+            continue;
+        const diagnostics = entry.diagnostics.map((diagnostic) => {
+            const hunk = update.hunks[diagnostic.hunkIndex - 1];
+            if (hunk === undefined)
+                return diagnostic;
+            try {
+                return diagnoseRejectedHunk(content, hunk, diagnostic.hunkIndex);
+            }
+            catch {
+                return diagnostic;
+            }
+        });
+        rejected[position] = Object.freeze({ ...entry, diagnostics: Object.freeze(diagnostics) });
+    }
+}
 export async function applyPatchInWorkspace(options) {
     options.signal?.throwIfAborted();
     const fs = options.fs ?? createLocalPatchFs(options.workspaceRoot);
@@ -238,20 +278,35 @@ export async function applyPatchInWorkspace(options) {
         operationIndex: index,
         kind: operation.kind,
         path: operation.kind === "update" ? (operation.moveTo ?? operation.path) : operation.path,
-        ...plannedDelta(operation, undefined),
+        // A pending row previews the bytes it is about to write; a row refused before execution
+        // reports none, because it wrote nothing.
+        ...(rejectedIndices.has(index)
+            ? { addedLines: 0, removedLines: 0 }
+            : plannedDelta(operation, undefined)),
         status: rejectedIndices.has(index) ? "rejected" : "pending",
     }));
+    /**
+     * The bytes one row reports, which are always this operation's own outcome rather than the
+     * request that asked for it. A pending row previews what it is about to write and a partial
+     * update counts only the hunks that landed; a row refused, never sent or never confirmed
+     * reports nothing, because nothing there is known to have been written.
+     */
+    const rowDelta = (current, status, update, prepared) => {
+        if (status !== "pending" && !CONFIRMED_STATUSES.has(status))
+            return { addedLines: 0, removedLines: 0 };
+        if (update !== undefined)
+            return update.kind === "update" && prepared !== undefined
+                ? { addedLines: prepared.addedLines, removedLines: prepared.removedLines }
+                : plannedDelta(update, undefined);
+        return { addedLines: current.addedLines, removedLines: current.removedLines };
+    };
     const setStatus = (index, status, outcome, update, partialReason, prepared) => {
         const current = progressOperations[index];
         if (current === undefined)
             throw new Error(`Missing patch progress operation: ${index}`);
         progressOperations[index] = Object.freeze({
             ...current,
-            ...(update === undefined
-                ? {}
-                : update.kind !== "update" || prepared === undefined
-                    ? plannedDelta(update, undefined)
-                    : { addedLines: prepared.addedLines, removedLines: prepared.removedLines }),
+            ...rowDelta(current, status, update, prepared),
             status,
             ...(status === "partial" && update !== undefined && outcome !== undefined
                 ? {
@@ -274,134 +329,127 @@ export async function applyPatchInWorkspace(options) {
         setStatus(index, "not_applied");
         notApplied.push(rejection(index, operationTouchedPaths(operation), "NotApplied"));
     };
-    const release = await acquireMutationLock(options.lockKey ?? fs.scope, options.signal);
-    try {
-        await gcAgentPatchTemps(fs, patch.operations.flatMap((operation) => operationTouchedPaths(operation).map((path) => {
-            const separator = path.lastIndexOf("/");
-            return separator < 0 ? "." : path.slice(0, separator);
-        })), options.signal);
-        emit("parsed");
-        for (const [index, operation] of patch.operations.entries()) {
-            if (rejectedIndices.has(index))
-                continue;
-            if (halt !== undefined) {
-                markNotApplied(index, operation);
-                continue;
-            }
-            if (options.signal?.aborted) {
-                if (applied.length === 0 && unconfirmed.length === 0)
-                    throw options.signal.reason ?? new Error("aborted");
-                halt = "not_applied";
-                markNotApplied(index, operation);
-                continue;
+    await gcAgentPatchTemps(fs, patch.operations.flatMap((operation) => operationTouchedPaths(operation).map((path) => {
+        const separator = path.lastIndexOf("/");
+        return separator < 0 ? "." : path.slice(0, separator);
+    })), options.signal);
+    emit("parsed");
+    for (const [index, operation] of patch.operations.entries()) {
+        if (rejectedIndices.has(index))
+            continue;
+        if (halt !== undefined) {
+            markNotApplied(index, operation);
+            continue;
+        }
+        if (options.signal?.aborted) {
+            if (applied.length === 0 && unconfirmed.length === 0)
+                throw options.signal.reason ?? new Error("aborted");
+            halt = "not_applied";
+            markNotApplied(index, operation);
+            continue;
+        }
+        try {
+            if (operation.kind === "add") {
+                const outcome = await applyAdd(fs, index, operation, options.signal);
+                applied.push(outcome);
+                setStatus(index, "applied", outcome);
             }
-            try {
-                if (operation.kind === "add") {
-                    const outcome = await applyAdd(fs, index, operation, options.signal);
-                    applied.push(outcome);
-                    setStatus(index, "applied", outcome);
+            else if (operation.kind === "delete") {
+                const deleted = await applyDelete(fs, index, operation, options.signal);
+                applied.push(deleted.outcome);
+                const current = progressOperations[index];
+                if (current !== undefined) {
+                    progressOperations[index] = Object.freeze({
+                        ...current,
+                        ...plannedDelta(operation, deleted.before),
+                        status: "applied",
+                    });
                 }
-                else if (operation.kind === "delete") {
-                    const deleted = await applyDelete(fs, index, operation, options.signal);
-                    applied.push(deleted.outcome);
-                    const current = progressOperations[index];
-                    if (current !== undefined) {
-                        progressOperations[index] = Object.freeze({
-                            ...current,
-                            ...plannedDelta(operation, deleted.before),
-                            status: "applied",
-                        });
-                    }
-                }
-                else {
-                    const published = await applyUpdate(fs, index, operation, options.policy, options.signal);
-                    if (published.mode === "exact")
-                        exactUpdateCount += 1;
-                    if (published.mode === "fuzzy")
-                        fuzzyUpdateCount += 1;
-                    applied.push(published.outcome);
-                    const partialReason = published.rejectedHunks.length === 0
-                        ? undefined
-                        : published.rejectedHunks[0]?.kind === "context_not_found"
-                            ? "context not found"
-                            : "exact context is ambiguous";
-                    if (published.rejectedHunks.length > 0)
-                        rejected.push(rejection(index, operationTouchedPaths(operation), "One or more update hunks failed", published.rejectedHunks));
-                    if (published.sourceError !== undefined) {
-                        if (published.sourceUnknown === true) {
-                            unconfirmed.push(rejection(index, [operation.path], published.sourceError));
-                            setStatus(index, "unconfirmed", published.outcome, operation, undefined, published.prepared);
-                            halt = "unconfirmed";
-                        }
-                        else {
-                            rejected.push(rejection(index, [operation.path], published.sourceError));
-                            setStatus(index, "partial", published.outcome, operation, partialReason ?? String(published.sourceError), published.prepared);
-                        }
+            }
+            else {
+                const published = await applyUpdate(fs, index, operation, options.policy, options.signal);
+                if (published.mode === "exact")
+                    exactUpdateCount += 1;
+                if (published.mode === "fuzzy")
+                    fuzzyUpdateCount += 1;
+                applied.push(published.outcome);
+                const partialReason = published.rejectedHunks.length === 0
+                    ? undefined
+                    : published.rejectedHunks[0]?.kind === "context_not_found"
+                        ? "context not found"
+                        : "exact context is ambiguous";
+                if (published.rejectedHunks.length > 0)
+                    rejected.push(rejection(index, operationTouchedPaths(operation), "One or more update hunks failed", published.rejectedHunks));
+                if (published.sourceError !== undefined) {
+                    if (published.sourceUnknown === true) {
+                        unconfirmed.push(rejection(index, [operation.path], published.sourceError));
+                        setStatus(index, "unconfirmed", published.outcome, operation, undefined, published.prepared);
+                        halt = "unconfirmed";
                     }
                     else {
-                        setStatus(index, partialReason === undefined
-                            ? published.mode === "fuzzy"
-                                ? "fuzzy"
-                                : "applied"
-                            : "partial", published.outcome, operation, partialReason, published.prepared);
+                        rejected.push(rejection(index, [operation.path], published.sourceError));
+                        setStatus(index, "partial", published.outcome, operation, partialReason ?? String(published.sourceError), published.prepared);
                     }
                 }
-            }
-            catch (error) {
-                if (options.signal?.aborted && applied.length === 0 && unconfirmed.length === 0)
-                    throw options.signal.reason ?? error;
-                if (error instanceof FsTransportError) {
-                    const bucket = error.phase === "write" ? notApplied : unconfirmed;
-                    const status = error.phase === "write" ? "not_applied" : "unconfirmed";
-                    bucket.push(rejection(index, operationTouchedPaths(operation), error));
-                    setStatus(index, status);
-                    halt = status;
-                }
-                else if (error instanceof PatchUpdateError) {
-                    rejected.push(rejection(index, operationTouchedPaths(operation), error, error.diagnostics));
-                    rejectedIndices.add(index);
-                    setStatus(index, "rejected");
-                }
-                else if (options.signal?.aborted) {
-                    notApplied.push(rejection(index, operationTouchedPaths(operation), error));
-                    setStatus(index, "not_applied");
-                    halt = "not_applied";
-                }
                 else {
-                    rejected.push(rejection(index, operationTouchedPaths(operation), error));
-                    rejectedIndices.add(index);
-                    setStatus(index, "rejected");
+                    setStatus(index, partialReason === undefined
+                        ? published.mode === "fuzzy"
+                            ? "fuzzy"
+                            : "applied"
+                        : "partial", published.outcome, operation, partialReason, published.prepared);
                 }
             }
-            emit("publishing");
-            await new Promise((resolve) => setImmediate(resolve));
         }
-        if (halt !== undefined) {
-            for (const [index, operation] of patch.operations.entries()) {
-                if (progressOperations[index]?.status !== "pending")
-                    continue;
-                markNotApplied(index, operation);
+        catch (error) {
+            if (options.signal?.aborted && applied.length === 0 && unconfirmed.length === 0)
+                throw options.signal.reason ?? error;
+            if (error instanceof FsTransportError) {
+                const bucket = error.phase === "write" ? notApplied : unconfirmed;
+                const status = error.phase === "write" ? "not_applied" : "unconfirmed";
+                bucket.push(rejection(index, operationTouchedPaths(operation), error));
+                setStatus(index, status);
+                halt = status;
+            }
+            else if (error instanceof PatchUpdateError) {
+                rejected.push(rejection(index, operationTouchedPaths(operation), error, error.diagnostics));
+                rejectedIndices.add(index);
+                setStatus(index, "rejected");
+            }
+            else if (options.signal?.aborted) {
+                notApplied.push(rejection(index, operationTouchedPaths(operation), error));
+                setStatus(index, "not_applied");
+                halt = "not_applied";
+            }
+            else {
+                rejected.push(rejection(index, operationTouchedPaths(operation), error));
+                rejectedIndices.add(index);
+                setStatus(index, "rejected");
             }
         }
-        emit("done");
-        const totals = progressTotals(progressOperations);
-        return Object.freeze({
-            changedPaths: Object.freeze([
-                ...new Set(applied.flatMap((operation) => [...operation.paths])),
-            ]),
-            addedLines: totals.addedLines,
-            removedLines: totals.removedLines,
-            operations: Object.freeze([...progressOperations]),
-            operationCount: patch.operations.length,
-            exactUpdateCount,
-            fuzzyUpdateCount,
-            applied: Object.freeze(applied),
-            rejected: Object.freeze(rejected),
-            unconfirmed: Object.freeze(unconfirmed),
-            notApplied: Object.freeze(notApplied),
-        });
+        emit("publishing");
+        await new Promise((resolve) => setImmediate(resolve));
     }
-    finally {
-        await release();
+    if (halt !== undefined) {
+        for (const [index, operation] of patch.operations.entries()) {
+            if (progressOperations[index]?.status !== "pending")
+                continue;
+            markNotApplied(index, operation);
+        }
     }
+    await relocateRejections(fs, patch, rejected, applied, options.signal);
+    emit("done");
+    const totals = progressTotals(progressOperations);
+    return Object.freeze({
+        changedPaths: Object.freeze([...new Set(applied.flatMap((operation) => [...operation.paths]))]),
+        addedLines: totals.addedLines,
+        removedLines: totals.removedLines,
+        operations: Object.freeze([...progressOperations]),
+        operationCount: patch.operations.length,
+        exactUpdateCount,
+        fuzzyUpdateCount,
+        applied: Object.freeze(applied),
+        rejected: Object.freeze(rejected),
+        unconfirmed: Object.freeze(unconfirmed),
+        notApplied: Object.freeze(notApplied),
+    });
 }

package/dist/apply-patch/index.d.ts

@@ -2,5 +2,6 @@ export { type ApplyPatchInWorkspaceOptions, applyPatchInWorkspace, } from "./exe
 export { APPLY_PATCH_MAX_FILE_SIZE, createLocalPatchFs, FsTransportError, fileTooLarge, gcAgentPatchTemps, type PatchFs, publishPreparedFile, } from "./fs.js";
 export { MUTATION_GLYPH, MUTATION_TONE } from "./glyph.js";
 export type { ApplyPatchAppliedOperation, ApplyPatchHunkSnapshot, ApplyPatchInWorkspaceResult, ApplyPatchOperationProgress, ApplyPatchProgress, ApplyPatchRejection, PatchHunkOutcome, PreparedPatchUpdate, } from "./outcome.js";
+export { CONFIRMED_STATUSES } from "./outcome.js";
 export { compileV4aUpdateToUnifiedDiff, createV4aPreviewCursor, findV4aPatchConflicts, MAX_V4A_HUNK_LINES, MAX_V4A_HUNKS_PER_UPDATE, MAX_V4A_OPERATIONS, MAX_V4A_PATCH_BYTES, MAX_V4A_PATH_BYTES, MAX_V4A_PATH_SEGMENT_BYTES, operationTouchedPaths, parseV4aPatch, parseV4aPatchProgressively, previewV4aPatchFileCount, previewV4aPatchPrefix, type V4aAddedLine, type V4aAddOperation, type V4aContextLine, type V4aDeleteOperation, type V4aPatch, type V4aPatchConflict, type V4aPatchOperation, type V4aPreviewCursor, type V4aPreviewOperation, type V4aRemovedLine, type V4aUpdateHunk, type V4aUpdateLine, type V4aUpdateOperation, } from "./parser.js";
 export { type ApplyPatchPolicy, DEFAULT_APPLY_PATCH_POLICY, type LoadApplyPatchPolicyOptions, loadApplyPatchPolicy, } from "./policy.js";

package/dist/apply-patch/index.js

@@ -1,5 +1,6 @@
 export { applyPatchInWorkspace, } from "./executor.js";
 export { APPLY_PATCH_MAX_FILE_SIZE, createLocalPatchFs, FsTransportError, fileTooLarge, gcAgentPatchTemps, publishPreparedFile, } from "./fs.js";
 export { MUTATION_GLYPH, MUTATION_TONE } from "./glyph.js";
+export { CONFIRMED_STATUSES } from "./outcome.js";
 export { compileV4aUpdateToUnifiedDiff, createV4aPreviewCursor, findV4aPatchConflicts, MAX_V4A_HUNK_LINES, MAX_V4A_HUNKS_PER_UPDATE, MAX_V4A_OPERATIONS, MAX_V4A_PATCH_BYTES, MAX_V4A_PATH_BYTES, MAX_V4A_PATH_SEGMENT_BYTES, operationTouchedPaths, parseV4aPatch, parseV4aPatchProgressively, previewV4aPatchFileCount, previewV4aPatchPrefix, } from "./parser.js";
 export { DEFAULT_APPLY_PATCH_POLICY, loadApplyPatchPolicy, } from "./policy.js";

package/dist/apply-patch/jsdiff-matching.d.ts

@@ -1,4 +1,4 @@
-import type { PreparedPatchUpdate } from "./outcome.js";
+import type { PreparedPatchUpdate, RejectedPatchHunk } from "./outcome.js";
 import type { V4aUpdateHunk } from "./parser.js";
 export interface JsDiffHunkInput {
     readonly unifiedDiff: string;
@@ -10,4 +10,11 @@ export interface JsDiffUpdateInput {
     readonly fuzzFactor: number;
     readonly snapshotPath: string;
 }
+/**
+ * Why one hunk cannot land in `content`, with any line numbers taken from that same content. Hunks
+ * and operations run in order over one growing copy, so a diagnostic computed when the hunk was
+ * tried would name lines that later writes had already moved; resolving it against the final file is
+ * what keeps the numbers readable by the model that has to retry.
+ */
+export declare function diagnoseRejectedHunk(content: Uint8Array, hunk: V4aUpdateHunk, hunkIndex: number): RejectedPatchHunk;
 export declare function prepareJsDiffUpdate(data: JsDiffUpdateInput): PreparedPatchUpdate;

package/dist/apply-patch/jsdiff-matching.js

@@ -364,6 +364,33 @@ function snapshotFromChange(path, hunkIndex, change, beforeLines, afterLines) {
         after: Object.freeze(afterLines.slice(afterStart, afterEnd)),
     });
 }
+/**
+ * Why one hunk cannot land in `content`, with any line numbers taken from that same content. Hunks
+ * and operations run in order over one growing copy, so a diagnostic computed when the hunk was
+ * tried would name lines that later writes had already moved; resolving it against the final file is
+ * what keeps the numbers readable by the model that has to retry.
+ */
+export function diagnoseRejectedHunk(content, hunk, hunkIndex) {
+    const lines = textLines(content);
+    const constraint = anchorConstraint(lines, hunk);
+    if ("kind" in constraint)
+        return { ...constraint, hunkIndex };
+    const oldTexts = oldSideTexts(hunk);
+    const isEof = constraint.endOfFile === true || hunk.endOfFile === true;
+    const anchored = lines.slice(constraint.prefixLines);
+    const eofLines = isEof ? Math.max(0, anchored.length - oldTexts.length) : 0;
+    const prefixLines = constraint.prefixLines + eofLines;
+    const searchable = lines.slice(prefixLines).map((line) => line.text);
+    const tiered = findTieredStarts(searchable, oldTexts);
+    if (oldTexts.length > 0 && tiered.tier === "ambiguous")
+        return {
+            kind: "ambiguous_exact",
+            hunkIndex,
+            candidateStartLines: tiered.starts.map((start) => start + prefixLines + 1),
+        };
+    const hint = findDiagnosticHint(searchable, oldTexts, prefixLines);
+    return { kind: "context_not_found", hunkIndex, ...(hint === undefined ? {} : { hint }) };
+}
 function parseOneHunk(parsePatch, unifiedDiff, hunk) {
     let parsed;
     try {
@@ -392,7 +419,7 @@ export function prepareJsDiffUpdate(data) {
     if (data.before.length > MAX_FILE_SIZE)
         throw new Error(`file_too_large: ${data.before.length} bytes`);
     const outcomes = [];
-    const rejected = [];
+    const pending = [];
     const snapshots = [];
     let addedLines = 0;
     let removedLines = 0;
@@ -412,7 +439,7 @@ export function prepareJsDiffUpdate(data) {
         }
         const constraint = anchorConstraint(original, hunk);
         if ("kind" in constraint) {
-            rejected.push({ ...constraint, hunkIndex });
+            pending.push({ hunkIndex, hunk });
             continue;
         }
         const oldTexts = oldSideTexts(hunk);
@@ -432,11 +459,7 @@ export function prepareJsDiffUpdate(data) {
         const tieredMatch = findTieredStarts(searchable.map((line) => line.text), oldTexts);
         const matchedStarts = tieredMatch.starts.map((start) => start + prefixLines);
         if (oldLength > 0 && tieredMatch.tier === "ambiguous") {
-            rejected.push({
-                kind: "ambiguous_exact",
-                hunkIndex,
-                candidateStartLines: matchedStarts.map((start) => start + 1),
-            });
+            pending.push({ hunkIndex, hunk });
             continue;
         }
         const sourceView = lfView(original);
@@ -514,17 +537,12 @@ export function prepareJsDiffUpdate(data) {
             parsed = parseOneHunk(parsePatch, input.unifiedDiff, hunk);
         }
         if ("kind" in parsed) {
-            rejected.push({ ...parsed, hunkIndex });
+            pending.push({ hunkIndex, hunk });
             continue;
         }
         const parsedHunk = parsed.hunks[0];
         if (parsedHunk === undefined) {
-            const hint = findDiagnosticHint(searchable.map((line) => line.text), oldTexts, prefixLines);
-            rejected.push({
-                kind: "context_not_found",
-                hunkIndex,
-                ...(hint !== undefined ? { hint } : {}),
-            });
+            pending.push({ hunkIndex, hunk });
             continue;
         }
         if (oldLength === 0) {
@@ -549,12 +567,7 @@ export function prepareJsDiffUpdate(data) {
             match = "fuzzy";
         }
         if (applied === false) {
-            const hint = findDiagnosticHint(searchable.map((line) => line.text), oldTexts, prefixLines);
-            rejected.push({
-                kind: "context_not_found",
-                hunkIndex,
-                ...(hint !== undefined ? { hint } : {}),
-            });
+            pending.push({ hunkIndex, hunk });
             continue;
         }
         const changes = structuredPatch("before", "after", sourceView, applied, undefined, undefined, {
@@ -601,6 +614,7 @@ export function prepareJsDiffUpdate(data) {
             mode ??= "exact";
         after = rebuilt;
     }
+    const rejected = pending.map((item) => diagnoseRejectedHunk(after, item.hunk, item.hunkIndex));
     return {
         after,
         mode,

package/dist/apply-patch/jsdiff.d.ts

@@ -6,4 +6,4 @@ interface RunJsDiffUpdateOptions {
     readonly signal?: AbortSignal;
 }
 export declare function runJsDiffUpdate(options: RunJsDiffUpdateOptions): Promise<PreparedPatchUpdate>;
-export {};
+export { diagnoseRejectedHunk } from "./jsdiff-matching.js";

package/dist/apply-patch/jsdiff.js

@@ -217,3 +217,4 @@ export async function runJsDiffUpdate(options) {
         }
     }
 }
+export { diagnoseRejectedHunk } from "./jsdiff-matching.js";

package/dist/apply-patch/outcome.d.ts

@@ -51,6 +51,12 @@ export interface ApplyPatchRejection {
 }
 export type ApplyPatchProgressStage = "parsed" | "publishing" | "done";
 export type ApplyPatchOperationStatus = "pending" | "applied" | "partial" | "fuzzy" | "rejected" | "unconfirmed" | "not_applied";
+/**
+ * Rows whose delta is a confirmed write. `changedPaths` comes from these rows only, so the model
+ * never reads a path as changed before the Publish that changed it, and the header totals count
+ * these rows plus the pending preview.
+ */
+export declare const CONFIRMED_STATUSES: ReadonlySet<ApplyPatchOperationStatus>;
 export type ApplyPatchOperationProgress = {
     readonly operationIndex: number;
     readonly kind: "add" | "delete" | "update";
@@ -64,7 +70,6 @@ export type ApplyPatchOperationProgress = {
 };
 export interface ApplyPatchProgress {
     readonly stage: ApplyPatchProgressStage;
-    readonly files: number;
     readonly addedLines: number;
     readonly removedLines: number;
     readonly operations: readonly ApplyPatchOperationProgress[];

package/dist/apply-patch/outcome.js

@@ -1 +1,10 @@
-export {};
+/**
+ * Rows whose delta is a confirmed write. `changedPaths` comes from these rows only, so the model
+ * never reads a path as changed before the Publish that changed it, and the header totals count
+ * these rows plus the pending preview.
+ */
+export const CONFIRMED_STATUSES = new Set([
+    "applied",
+    "fuzzy",
+    "partial",
+]);

package/dist/apply-patch/presentation.js

@@ -1,7 +1,7 @@
 import { stripTerminalSequences } from "@earendil-works/pi-tui";
 import { agentResultText, isRecord, } from "@hheei/pi-ext-core";
 import { createV4aPreviewCursor, previewV4aPatchPrefix } from "./parser.js";
-import { applyPatchResultFacts, applyPatchSummary, formatApplyPatchOperationRow, formatApplyPatchRejectionRows, formatApplyPatchSnapshotRows, } from "./view.js";
+import { applyPatchFilesInPlay, applyPatchResultFacts, applyPatchSummary, formatApplyPatchOperationRow, formatApplyPatchRejectionRows, formatApplyPatchSnapshotRows, } from "./view.js";
 /**
  * Preview cursors live in this module's own map, keyed by the row's shared render state: the cursor
  * is display-only progress, so it is never persisted and never read back from the session.
@@ -63,7 +63,9 @@ function resultStatus(facts, isError, isPartial) {
         return "error";
     if (facts.status === "partial")
         return "warn";
-    return "none";
+    // Live progress carries no verdict of its own, so a streamed success still reads as running
+    // until the result replaces it.
+    return isPartial ? "running" : "none";
 }
 /** Result sections: operation rows, one row block per applied snapshot, then the failure rows. */
 function resultSections(facts, theme) {
@@ -115,8 +117,12 @@ export const applyPatchPresentation = (args, result, theme, context) => {
         };
     }
     const rows = operationRows(facts.operations, theme);
+    // A live frame has no confirmed paths yet, so its file count comes from the rows it shows.
+    const files = context.isPartial
+        ? applyPatchFilesInPlay(facts.operations)
+        : new Set(facts.changedPaths).size;
     return {
-        summary: applyPatchSummary(new Set(facts.changedPaths).size, facts.addedLines, facts.removedLines),
+        summary: applyPatchSummary(files, facts.addedLines, facts.removedLines),
         status: resultStatus(facts, isError, context.isPartial),
         replaceCallOnPartial: true,
         ...(output === "" ? {} : { output }),

package/dist/apply-patch/tool.js

@@ -1,6 +1,6 @@
-import { createOptionalToolRenderers, createToolPresentationRenderers, defaultExtensionSettingsPaths, errorMessage, textToolResult, } from "@hheei/pi-ext-core";
+import { createOptionalToolRenderers, createRenderThrottle, createToolPresentationRenderers, defaultExtensionSettingsPaths, errorMessage, textToolResult, } from "@hheei/pi-ext-core";
 import { Type } from "typebox";
-import { applyPatchInWorkspace, loadApplyPatchPolicy, } from "./index.js";
+import { applyPatchInWorkspace, CONFIRMED_STATUSES, loadApplyPatchPolicy, } from "./index.js";
 import { isPatchPathOutsideWorkspace } from "./paths.js";
 import { applyPatchPresentation } from "./presentation.js";
 const MAX_CANDIDATES = 6;
@@ -108,7 +108,10 @@ function externalPathWarning(workspaceRoot, result) {
 }
 function progressDetails(progress) {
     return {
-        changedPaths: [],
+        // Live details report confirmed writes only, the same rows the header totals count.
+        changedPaths: progress.operations
+            .filter((operation) => CONFIRMED_STATUSES.has(operation.status))
+            .map((operation) => operation.path),
         addedLines: progress.addedLines,
         removedLines: progress.removedLines,
         operations: progress.operations,
@@ -134,6 +137,16 @@ export function createApplyPatchTool() {
         executionMode: "sequential",
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
             const { patch } = parseApplyPatchParameters(params);
+            // One operation per repaint used to rebuild the whole operation table. A patch with many
+            // operations now repaints on the shared streaming window; the returned result stays the
+            // only authority for the finished call.
+            let latestProgress;
+            const repaint = createRenderThrottle(() => {
+                const progress = latestProgress;
+                if (progress === undefined)
+                    return;
+                onUpdate?.({ content: [], details: progressDetails(progress) });
+            });
             try {
                 const policy = await loadApplyPatchPolicy({
                     paths: defaultExtensionSettingsPaths(ctx.cwd),
@@ -144,10 +157,10 @@ export function createApplyPatchTool() {
                     patch,
                     policy,
                     ...(signal === undefined ? {} : { signal }),
-                    onProgress: (progress) => onUpdate?.({
-                        content: [],
-                        details: progressDetails(progress),
-                    }),
+                    onProgress: (progress) => {
+                        latestProgress = progress;
+                        repaint.request();
+                    },
                 });
                 const warning = externalPathWarning(ctx.cwd, result);
                 const status = statusFor(result);
@@ -164,6 +177,11 @@ export function createApplyPatchTool() {
                 const message = errorMessage(error);
                 throw new Error(`apply_patch failed: ${message}`);
             }
+            finally {
+                // The result below is the only authority for the finished call, so the window closes
+                // here: a repaint after it is built would rewrite a settled body.
+                repaint.dispose();
+            }
         },
     };
 }

package/dist/apply-patch/view.d.ts

@@ -20,6 +20,12 @@ export interface ApplyPatchResultFacts {
 export declare function applyPatchResultFacts(details: unknown): ApplyPatchResultFacts | undefined;
 /** How one mutation outcome is drawn. One outcome never draws two symbols across the tools. */
 export declare function applyPatchGlyph(status: string, theme: Theme): string;
+/**
+ * Distinct paths a live frame still has in play: a pending row previews the write it is about to
+ * make, and a row that certainly wrote nothing is not counted. The finished result counts
+ * `changedPaths` instead, so a preview never claims a path was changed.
+ */
+export declare function applyPatchFilesInPlay(operations: readonly ApplyPatchOperationProgress[]): number;
 /** The header summary every apply_patch row shares, including nested calls. */
 export declare function applyPatchSummary(files: number, added: number, removed: number): string;
 /** One operation row: glyph, verb, path, delta, fuzzy marker, hunk summary. */

package/dist/apply-patch/view.js

@@ -165,6 +165,16 @@ export function applyPatchGlyph(status, theme) {
     const tone = MUTATION_TONE[status] ?? "error";
     return theme.fg(tone, glyph);
 }
+/**
+ * Distinct paths a live frame still has in play: a pending row previews the write it is about to
+ * make, and a row that certainly wrote nothing is not counted. The finished result counts
+ * `changedPaths` instead, so a preview never claims a path was changed.
+ */
+export function applyPatchFilesInPlay(operations) {
+    return new Set(operations
+        .filter((operation) => operation.status !== "rejected" && operation.status !== "not_applied")
+        .map((operation) => operation.path)).size;
+}
 /** The header summary every apply_patch row shares, including nested calls. */
 export function applyPatchSummary(files, added, removed) {
     return `modify ${String(files)}${files === 1 ? " file" : " files"} (+${String(added)} -${String(removed)})`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hheei/pi-apply-patch",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "V4A apply_patch editing tool with worker matching and per-path publishing.",
   "type": "module",
   "main": "dist/index.js",
@@ -36,7 +36,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@hheei/pi-ext-core": "^0.5.0",
+    "@hheei/pi-ext-core": "^0.6.1",
     "diff": "^9.0.0"
   },
   "peerDependencies": {