@astrosheep/keiyaku 2.9.4 → 2.9.5

package/build/core/task/settlement-policy.js

@@ -1,12 +1,13 @@
 import { FlowError } from "../../flow-error.js";
 import { resolveTaskReadId } from "./board.js";
+import { advancedTaskUpdatedAt } from "./model.js";
 export function requireHealthySettlementBoard(board) {
     if (board.diseases.length > 0) {
         throw new FlowError("INTERNAL_STATE", `authoritative task board is diseased: ${board.diseases.map((disease) => disease.message).join("; ")}`);
     }
     return board;
 }
-function settlementDocument(task, contractId) {
+function settlementDocument(task, contractId, updatedAt) {
     return {
         id: task.id,
         title: task.title,
@@ -16,17 +17,18 @@ function settlementDocument(task, contractId) {
         parent: task.parent,
         from: [...task.from],
         createdAt: task.createdAt,
+        updatedAt: advancedTaskUpdatedAt(task, updatedAt),
         creator: task.creator,
         ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
         ...(contractId === undefined ? {} : { contractId }),
         body: task.body,
     };
 }
-export function contractPointerDocument(task, contractId) {
-    return settlementDocument(task, contractId);
+export function contractPointerDocument(task, contractId, updatedAt) {
+    return settlementDocument(task, contractId, updatedAt);
 }
-export function reopenedTaskDocument(task) {
-    const document = settlementDocument(task, undefined);
+export function reopenedTaskDocument(task, updatedAt) {
+    const document = settlementDocument(task, undefined, updatedAt);
     document.state = "open";
     delete document.startedAt;
     return document;
@@ -96,12 +98,18 @@ export function tasksForContract(board, contractId) {
         .filter((task) => task.contractId === contractId)
         .sort((left, right) => left.id.localeCompare(right.id));
 }
-export function doneTaskReplacements(board, contractId) {
-    return tasksForContract(board, contractId).map((task) => {
-        const settled = settlementDocument(task, undefined);
+export function doneTaskReplacements(board, contractId, taskIds, updatedAt) {
+    return taskIds.flatMap((taskId) => {
+        const task = requireSettledTask(board, taskId);
+        if (task.state === "done" && task.contractId === undefined)
+            return [];
+        if (task.contractId !== contractId) {
+            throw new FlowError("INTERNAL_STATE", `task ${task.id} no longer points to contract ${contractId} while settling its immutable bind-base ownership`);
+        }
+        const settled = settlementDocument(task, undefined, updatedAt);
         settled.state = "done";
         delete settled.startedAt;
-        return settled;
+        return [settled];
     });
 }
 export function requireSettledTask(board, id) {

package/build/core/task/source-board.js

@@ -23,6 +23,7 @@ function taskDocument(parsed) {
         parent: parsed.parent,
         from: [...parsed.from],
         createdAt: parsed.createdAt,
+        ...(parsed.updatedAt === undefined ? {} : { updatedAt: parsed.updatedAt }),
         creator: parsed.creator,
         ...(parsed.startedAt === undefined ? {} : { startedAt: parsed.startedAt }),
         ...(parsed.contractId === undefined ? {} : { contractId: parsed.contractId }),

package/build/core/task/task-contract.js

@@ -4,7 +4,7 @@ import { withLockHeldTaskBoard } from "./task-git-store.js";
 import { prepareTaskDocumentReplacements, taskBoardFromSourceBoard, taskRepositoryFromLockedBoard } from "./task-store-repository.js";
 import { serializeTaskDocument } from "./document.js";
 import { buildTaskSourceBoard } from "./source-board.js";
-import { containsCommit, createLandingCommit, createTaskBoardCommit, publishTaskMutationCommit, inspectCurrentBranch, publishForwardTaskBoardCommit, readableRefHead, reconcileTaskPathsetIndex, refHead, taskContractAtCommit, taskWritesFromSources, trackedTaskPaths, updateBranch, updateTargetRef, } from "./settlement-git.js";
+import { composeLandingTree, containsCommit, createLandingCommit, createTaskBoardCommit, findAcceptedLandingCommit, publishTaskMutationCommit, inspectCurrentBranch, publishForwardTaskBoardCommit, reconcileTaskPathsetIndex, refHead, taskContractAtCommit, taskSettlementOwnershipAtCommit, taskSourcesAtCommit, taskWritesFromSources, trackedTaskPaths, updateBranch, updateTargetRef, } from "./settlement-git.js";
 import { contractPointerDocument, doneTaskReplacements, reopenedTaskDocument, requireHealthySettlementBoard, requireSettledTask, selectReadyTasksForBind, tasksForContract, } from "./settlement-policy.js";
 import { stableRepoRoot } from "../worktree-path.js";
 function sourcePath(root, source) {
@@ -66,7 +66,9 @@ async function clearAttemptedPointers(input) {
     return input.repository.mutate((board) => {
         const replacements = input.tasks.flatMap((task) => {
             const current = requireSettledTask(board, task.id);
-            return current.contractId === input.contractId ? [contractPointerDocument(current, undefined)] : [];
+            return current.contractId === input.contractId
+                ? [contractPointerDocument(current, undefined, input.updatedAt)]
+                : [];
         });
         return { replacements, select: () => replacements.map((replacement) => replacement.id) };
     });
@@ -86,6 +88,7 @@ async function rollForwardClearAttemptedPointer(input) {
         repository: input.repository,
         tasks: input.selected,
         contractId: input.contractId,
+        updatedAt: input.updatedAt,
     });
     if (clearedIds.length === 0)
         return;
@@ -107,6 +110,7 @@ async function rollForwardClearAttemptedPointer(input) {
     }, input.deps);
 }
 export async function settleTaskBoardForBind(input, deps = {}) {
+    const updatedAt = new Date().toISOString();
     await requireGitRepository(input.cwd, "task bind");
     return withLockHeldTaskBoard(input.cwd, async (transaction) => {
         if (transaction.location.mode !== "git") {
@@ -125,7 +129,7 @@ export async function settleTaskBoardForBind(input, deps = {}) {
         const prepared = taskBound ? await input.prepare(selectedTasks) : input;
         const contractId = prepared.contractId;
         if (taskBound && selectedTasks.length > 0) {
-            await replaceTaskDocuments(repository, selectedTasks.map((task) => contractPointerDocument(task, contractId)));
+            await replaceTaskDocuments(repository, selectedTasks.map((task) => contractPointerDocument(task, contractId, updatedAt)));
         }
         const taskIds = taskBound ? selectedTasks.map((t) => t.id) : undefined;
         const selectedPaths = ownedTaskPaths(await repository.read(), taskIds);
@@ -176,7 +180,7 @@ export async function settleTaskBoardForBind(input, deps = {}) {
                         repository, selected: selectedTasks, contractId, hubCwd,
                         branchRef: branch.ref, trackedHead: branch.head,
                         gitDir: transaction.location.gitDir, root: transaction.location.root,
-                        selectedPaths, deps,
+                        selectedPaths, deps, updatedAt,
                     });
                 }
                 else {
@@ -194,7 +198,7 @@ export async function settleTaskBoardForBind(input, deps = {}) {
                     repository, selected: selectedTasks, contractId, hubCwd,
                     branchRef: branch.ref, trackedHead: branch.head,
                     gitDir: transaction.location.gitDir, root: transaction.location.root,
-                    selectedPaths, deps,
+                    selectedPaths, deps, updatedAt,
                 });
             }
             throw indexError;
@@ -217,13 +221,14 @@ export async function settleTaskBoardForBind(input, deps = {}) {
                 repository, selected: selectedTasks, contractId, hubCwd,
                 branchRef: branch.ref, trackedHead: branch.head,
                 gitDir: transaction.location.gitDir, root: transaction.location.root,
-                selectedPaths, deps,
+                selectedPaths, deps, updatedAt,
             });
             throw publishError;
         }
     }, { signal: input.signal });
 }
 export async function reconcileTaskForfeit(input) {
+    const updatedAt = new Date().toISOString();
     await requireGitRepository(input.cwd, "task forfeit");
     const hubRoot = await stableRepoRoot(input.cwd);
     return withLockHeldTaskBoard(hubRoot, async (transaction) => {
@@ -238,7 +243,7 @@ export async function reconcileTaskForfeit(input) {
         const ledger = await input.publishLedger();
         if (matched.length === 0)
             return { ledger };
-        const reopenedDocuments = matched.map(reopenedTaskDocument);
+        const reopenedDocuments = matched.map((task) => reopenedTaskDocument(task, updatedAt));
         const reopened = await replaceTaskDocuments(repository, reopenedDocuments);
         const taskLabel = matched.length === 1 ? `task ${matched[0].id}` : `${matched.length} tasks`;
         await publishTaskMutationCommit({
@@ -255,11 +260,14 @@ export async function reconcileTaskForfeit(input) {
  * task trees are fossils: the candidate is the code-only three-way merge plus
  * one complete snapshot of the common hub board held under its repository lock.
  */
-export async function settleTaskBoardForLanding(input) {
+export async function settleTaskBoardForLanding(input, deps = {}) {
+    const updatedAt = new Date().toISOString();
     await requireGitRepository(input.cwd, "task landing");
     const hubRoot = await stableRepoRoot(input.cwd);
+    const ownership = await taskSettlementOwnershipAtCommit(input.cwd, input.baseCommit, input.contractId);
+    const reconcileIndex = deps.reconcileTaskPathsetIndex ?? reconcileTaskPathsetIndex;
     let lastTargetHead = input.targetHead;
-    let lastPublishError;
+    let lastPostCasError;
     let acceptedMovement;
     for (let attempt = 0; attempt < 4; attempt += 1) {
         const result = await withLockHeldTaskBoard(hubRoot, async (transaction) => {
@@ -273,77 +281,143 @@ export async function settleTaskBoardForLanding(input) {
             // common task lock. A losing CAS exits before the next attempt.
             const targetHead = await refHead(input.cwd, input.targetRef);
             lastTargetHead = targetHead;
+            const selectedPaths = ownership.paths;
+            const acceptedLanding = acceptedMovement?.mergeCommit === targetHead
+                ? targetHead
+                : await findAcceptedLandingCommit({
+                    cwd: input.cwd,
+                    gitDir: transaction.location.gitDir,
+                    root: transaction.location.root,
+                    base: input.baseCommit,
+                    target: targetHead,
+                    delivery: input.deliveryHead,
+                    contractId: input.contractId,
+                    targetBranch: input.targetBranch,
+                    ownedPaths: selectedPaths,
+                    settledPaths: ownership.taskIds.map(taskPath),
+                });
+            const deliveryAlreadyAccepted = ownership.taskIds.length === 0
+                && await containsCommit(input.cwd, input.deliveryHead, targetHead);
+            if (acceptedLanding !== undefined || deliveryAlreadyAccepted) {
+                const mergeCommit = acceptedLanding ?? targetHead;
+                const movement = acceptedMovement?.mergeCommit === targetHead ? acceptedMovement : undefined;
+                const authoritativeSources = selectedPaths.length > 0
+                    ? await taskSourcesAtCommit(input.cwd, transaction.location.root, targetHead, selectedPaths)
+                    : [];
+                if (!authoritativeSources) {
+                    throw new FlowError("INTERNAL_STATE", `accepted landing ${mergeCommit} lost an owned task path`);
+                }
+                const selection = selectSettlementSources({
+                    root: transaction.location.root,
+                    sources: authoritativeSources,
+                    trackedPaths: await trackedTaskPaths(input.cwd, targetHead),
+                    ownedPaths: selectedPaths,
+                    mutationPaths: selectedPaths,
+                });
+                const currentText = new Map(transaction.sources.map((source) => [sourcePath(transaction.location.root, source), source.text]));
+                const writes = authoritativeSources.filter((source) => currentText.get(sourcePath(transaction.location.root, source)) !== source.text);
+                if (writes.length > 0)
+                    await transaction.replace(taskWritesFromSources(writes));
+                try {
+                    await reconcileIndex(transaction.location.root, targetHead, selectedPaths);
+                }
+                catch (error) {
+                    lastPostCasError = error;
+                    return { kind: "retry" };
+                }
+                try {
+                    await input.publishLedger?.(mergeCommit);
+                }
+                catch (error) {
+                    lastPostCasError = error;
+                    return { kind: "retry" };
+                }
+                const reconcileWarnings = movement
+                    ? await input.afterCas?.(mergeCommit, movement.oldHead)
+                    : undefined;
+                return {
+                    kind: movement ? "accepted" : "idempotent",
+                    mergeCommit,
+                    ...(movement ? { oldHead: movement.oldHead } : {}),
+                    ...(reconcileWarnings && reconcileWarnings.length > 0 ? { warnings: reconcileWarnings } : {}),
+                    evidence: selection.evidence,
+                };
+            }
+            // No durable receipt exists, so this remains a first-publication attempt:
+            // validate mutable hub authority before composing or publishing anything.
             const repository = repositoryForSettlement(transaction, transaction.sources);
             const board = requireHealthySettlementBoard(await repository.read());
-            const replacements = doneTaskReplacements(board, input.contractId);
+            const replacements = doneTaskReplacements(board, input.contractId, ownership.taskIds, updatedAt);
             const prepared = replacements.length > 0
                 ? prepareTaskDocumentReplacements(transaction.sources, replacements)
                 : { sources: transaction.sources, board };
             const finalSources = prepared.sources;
             requireHealthySettlementBoard(prepared.board);
-            const replacementIds = replacements.map((r) => r.id);
-            const selectedPaths = ownedTaskPaths(prepared.board, replacementIds.length > 0 ? replacementIds : undefined);
             const selection = selectSettlementSources({
                 root: transaction.location.root,
                 sources: finalSources,
                 trackedPaths: await trackedTaskPaths(input.cwd, targetHead),
                 ownedPaths: selectedPaths,
-                mutationPaths: replacements.map((r) => taskPath(r.id)),
+                // Bind-base ownership, unlike incidental hub bytes, authorizes a path
+                // even when a concurrent target commit removed it.
+                mutationPaths: selectedPaths,
             });
-            let mergeCommit = targetHead;
-            let movement = acceptedMovement?.mergeCommit === targetHead ? acceptedMovement : undefined;
-            if (!(await containsCommit(input.cwd, input.deliveryHead, targetHead))) {
-                mergeCommit = await createLandingCommit({
-                    cwd: input.cwd,
-                    gitDir: transaction.location.gitDir,
-                    root: transaction.location.root,
-                    base: input.baseCommit,
-                    target: targetHead,
-                    delivery: input.deliveryHead,
-                    sources: selection.sources,
-                    contractId: input.contractId,
-                    targetBranch: input.targetBranch,
-                });
-                await input.beforeCas?.(mergeCommit, targetHead);
-                try {
-                    await updateTargetRef(input.cwd, input.targetRef, mergeCommit, targetHead);
-                    movement = { mergeCommit, oldHead: targetHead };
-                    acceptedMovement = movement;
-                }
-                catch {
-                    const current = await readableRefHead(input.cwd, input.targetRef);
-                    if (!current || !(await containsCommit(input.cwd, input.deliveryHead, current))) {
-                        return { kind: "retry" };
-                    }
-                    mergeCommit = current;
-                    movement = acceptedMovement?.mergeCommit === mergeCommit ? acceptedMovement : undefined;
-                }
+            const selected = new Set(selection.evidence.selectedPaths);
+            const missingOwnedPaths = selectedPaths.filter((ownedPath) => !selected.has(ownedPath));
+            if (missingOwnedPaths.length > 0) {
+                throw new FlowError("INTERNAL_STATE", `hub board lost bind-base-owned task paths: ${missingOwnedPaths.join(", ")}`);
+            }
+            const candidateTree = await composeLandingTree({
+                cwd: input.cwd,
+                gitDir: transaction.location.gitDir,
+                root: transaction.location.root,
+                base: input.baseCommit,
+                target: targetHead,
+                delivery: input.deliveryHead,
+                sources: selection.sources,
+            });
+            const mergeCommit = await createLandingCommit({
+                cwd: input.cwd,
+                target: targetHead,
+                delivery: input.deliveryHead,
+                tree: candidateTree,
+                contractId: input.contractId,
+                targetBranch: input.targetBranch,
+            });
+            await input.beforeCas?.(mergeCommit, targetHead);
+            let movement;
+            try {
+                await updateTargetRef(input.cwd, input.targetRef, mergeCommit, targetHead);
+                movement = { mergeCommit, oldHead: targetHead };
+                acceptedMovement = movement;
+            }
+            catch {
+                return { kind: "retry" };
             }
             const warnings = [];
             if (replacements.length > 0) {
                 await transaction.replace(taskWritesFromSources(selection.sources));
             }
             try {
-                await reconcileTaskPathsetIndex(transaction.location.root, mergeCommit, selection.evidence.selectedPaths);
+                await reconcileIndex(transaction.location.root, mergeCommit, selectedPaths);
             }
             catch (error) {
-                warnings.push(`Accepted landing ${mergeCommit}, but task index reconciliation failed: ${error instanceof Error ? error.message : String(error)}`);
+                lastPostCasError = error;
+                return { kind: "retry" };
             }
             try {
                 await input.publishLedger?.(mergeCommit);
             }
             catch (error) {
-                lastPublishError = error;
+                lastPostCasError = error;
                 return { kind: "retry" };
             }
-            const reconcileWarnings = movement
-                ? await input.afterCas?.(mergeCommit, movement.oldHead)
-                : undefined;
+            const reconcileWarnings = await input.afterCas?.(mergeCommit, movement.oldHead);
             warnings.push(...(reconcileWarnings ?? []));
             return {
-                kind: movement ? "accepted" : "idempotent",
+                kind: "accepted",
                 mergeCommit,
-                ...(movement ? { oldHead: movement.oldHead } : {}),
+                oldHead: movement.oldHead,
                 ...(warnings.length > 0 ? { warnings } : {}),
                 evidence: selection.evidence,
             };
@@ -364,7 +438,7 @@ export async function settleTaskBoardForLanding(input) {
             ...(result.evidence ? { evidence: result.evidence } : {}),
         };
     }
-    if (lastPublishError !== undefined)
-        throw lastPublishError;
+    if (lastPostCasError !== undefined)
+        throw lastPostCasError;
     throw new FlowError("CONCURRENT_MODIFICATION", `target branch kept moving while claiming ${input.contractId}; last observed ${lastTargetHead}`);
 }

package/build/core/task/task-store-repository.js

@@ -11,6 +11,7 @@ export function taskBoardFromSourceBoard(sourceBoard) {
         parent: task.parent,
         from: [...task.from],
         createdAt: task.createdAt,
+        ...(task.updatedAt === undefined ? {} : { updatedAt: task.updatedAt }),
         creator: task.creator,
         ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
         ...(task.contractId === undefined ? {} : { contractId: task.contractId }),

package/build/core/task/task.js

@@ -1,3 +1,5 @@
+export { deriveTaskDisplay, parseTaskFilter, parseTaskSort, selectTaskList } from "./query.js";
+export { advancedTaskUpdatedAt, taskUpdatedAt } from "./model.js";
 export { parseTaskDocument, serializeTaskDocument, } from "./document.js";
 export { resolveTaskReadId, } from "./board.js";
 export { buildTaskBoard } from "./source-board.js";

package/build/flow-error.js

@@ -53,9 +53,7 @@ export function resolveFlowErrorHints(code, context, facts) {
         return ["keiyaku status — watch for the akuma to land, then renew"];
     }
     if (facts?.kind === "projection_wake_failure") {
-        return [
-            `keiyaku tell ${facts.projectionId} [--wait DURATION] "retry the saved tell" — retries the same-projection wake; the saved tell remains queued`,
-        ];
+        return [];
     }
     switch (code) {
         case "NOT_GIT_REPO":
@@ -119,7 +117,7 @@ export function resolveFlowErrorHints(code, context, facts) {
         case "INTERNAL_STATE":
             return ["An internal state error occurred. Please verify your repository status."];
         case "SCOPE_VIOLATION":
-            return ["Files outside the contract's declared scope were modified. Widen the scope (amend), waive the violations, or move the changes back."];
+            return ["Files outside the contract's declared scope were modified. Append ordered scope terms with `--append-scope`, amend the contract, or move the changes back."];
         case "NO_OPEN_ARC":
             return ["Open an arc to receipt delivery commits after the fence, then retry."];
         case "REVIEW_REJECTED":

package/build/generated/version.js

@@ -1,3 +1,3 @@
 // Generated into build output by scripts/build.mjs
-export const VERSION = "2.9.4";
-export const GIT_HASH = "0aa48ab";
+export const VERSION = "2.9.5";
+export const GIT_HASH = "ade1510";

package/build/git/diff/parsers.js

@@ -32,8 +32,10 @@ export function parseUnifiedHunks(section) {
                     hunks.push({
                         header: current[0] ?? "",
                         lines: current.slice(1),
-                        newStart: parsed.start,
-                        newEnd: parsed.end,
+                        oldStart: parsed.oldStart,
+                        oldEnd: parsed.oldEnd,
+                        newStart: parsed.newStart,
+                        newEnd: parsed.newEnd,
                     });
                 }
             }
@@ -49,25 +51,33 @@ export function parseUnifiedHunks(section) {
             hunks.push({
                 header: current[0] ?? "",
                 lines: current.slice(1),
-                newStart: parsed.start,
-                newEnd: parsed.end,
+                oldStart: parsed.oldStart,
+                oldEnd: parsed.oldEnd,
+                newStart: parsed.newStart,
+                newEnd: parsed.newEnd,
             });
         }
     }
     return { prelude, hunks };
 }
-function parseHunkRange(hunkHeader) {
-    const match = hunkHeader.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+export function parseHunkRange(hunkHeader) {
+    const match = hunkHeader.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
     if (!match)
         return null;
-    const start = Number.parseInt(match[1] ?? "", 10);
-    const countRaw = match[2];
-    const count = countRaw ? Number.parseInt(countRaw, 10) : 1;
-    if (!Number.isFinite(start) || !Number.isFinite(count))
+    const oldStart = Number.parseInt(match[1] ?? "", 10);
+    const oldLines = match[2] === undefined ? 1 : Number.parseInt(match[2], 10);
+    const newStart = Number.parseInt(match[3] ?? "", 10);
+    const newLines = match[4] === undefined ? 1 : Number.parseInt(match[4], 10);
+    if (![oldStart, oldLines, newStart, newLines].every(Number.isFinite))
         return null;
-    if (count <= 0)
-        return { start, end: start - 1 };
-    return { start, end: start + count - 1 };
+    return {
+        oldStart,
+        oldLines,
+        oldEnd: oldLines <= 0 ? oldStart - 1 : oldStart + oldLines - 1,
+        newStart,
+        newLines,
+        newEnd: newLines <= 0 ? newStart - 1 : newStart + newLines - 1,
+    };
 }
 export function isDeletedDiffSection(section) {
     return section.some((line) => line.startsWith("deleted file mode ") || line.startsWith("+++ /dev/null"));

package/build/git/diff/structured.js

@@ -0,0 +1,127 @@
+import { createGit, wrapGitError } from "../core.js";
+import { diffPathspecArgs } from "./pathspec.js";
+import { parseHunkRange, parseUnifiedHunks, splitDiffByFile } from "./parsers.js";
+function parseRawDiff(output) {
+    const fields = output.split("\0");
+    const files = [];
+    let index = 0;
+    while (index < fields.length) {
+        const header = fields[index++];
+        if (!header)
+            continue;
+        const statusToken = header.trim().split(/\s+/).at(-1) ?? "";
+        const status = statusToken[0];
+        if (status !== "A" && status !== "M" && status !== "D" && status !== "R" && status !== "C" && status !== "T" && status !== "U")
+            continue;
+        const firstPath = fields[index++] ?? "";
+        if (status === "R" || status === "C") {
+            const path = fields[index++] ?? "";
+            files.push({
+                oldPath: firstPath,
+                path,
+                status,
+                similarity: Number.parseInt(statusToken.slice(1), 10) || 0,
+            });
+        }
+        else {
+            files.push({ path: firstPath, status });
+        }
+    }
+    return files;
+}
+function withoutTerminalPatchDelimiter(patch) {
+    return patch.endsWith("\n") ? patch.slice(0, -1) : patch;
+}
+function parseNumstat(output) {
+    const fields = output.split("\0");
+    const stats = [];
+    let index = 0;
+    while (index < fields.length) {
+        const record = fields[index++];
+        if (!record)
+            continue;
+        const [added = "0", removed = "0", path = ""] = record.split("\t");
+        const binary = added === "-" || removed === "-";
+        if (path) {
+            stats.push({ path, insertions: binary ? 0 : Number.parseInt(added, 10) || 0, deletions: binary ? 0 : Number.parseInt(removed, 10) || 0, binary });
+            continue;
+        }
+        const oldPath = fields[index++] ?? "";
+        const newPath = fields[index++] ?? "";
+        stats.push({ path: newPath, oldPath, insertions: binary ? 0 : Number.parseInt(added, 10) || 0, deletions: binary ? 0 : Number.parseInt(removed, 10) || 0, binary });
+    }
+    return stats;
+}
+function structuredLines(raw, oldStart, newStart) {
+    let oldLine = oldStart;
+    let newLine = newStart;
+    const lines = [];
+    for (const line of raw) {
+        if (line.startsWith("\"))
+            continue;
+        if (line.startsWith("+")) {
+            lines.push({ kind: "addition", content: line.slice(1), oldLine: null, newLine: newLine++ });
+        }
+        else if (line.startsWith("-")) {
+            lines.push({ kind: "deletion", content: line.slice(1), oldLine: oldLine++, newLine: null });
+        }
+        else {
+            lines.push({ kind: "context", content: line.startsWith(" ") ? line.slice(1) : line, oldLine: oldLine++, newLine: newLine++ });
+        }
+    }
+    return lines;
+}
+function parsePatchHunks(section) {
+    return parseUnifiedHunks([...section]).hunks.flatMap((hunk, index) => {
+        const range = parseHunkRange(hunk.header);
+        if (!range)
+            return [];
+        return [{
+                index,
+                header: hunk.header,
+                oldStart: range.oldStart,
+                oldLines: range.oldLines,
+                newStart: range.newStart,
+                newLines: range.newLines,
+                lines: structuredLines(hunk.lines, range.oldStart, range.newStart),
+            }];
+    });
+}
+export async function readStructuredDiff(cwd, from, to, options = {}) {
+    const git = createGit(cwd);
+    const range = `${from}..${to}`;
+    const pathspec = diffPathspecArgs({ excludePaths: options.excludePaths });
+    try {
+        const [raw, numstat, patch] = await Promise.all([
+            git.raw(["diff", "--raw", "-z", "--find-renames", range, ...pathspec]),
+            git.raw(["diff", "--numstat", "-z", "--find-renames", range, ...pathspec]),
+            git.raw(["diff", "--no-color", "--no-ext-diff", "--unified=3", "--find-renames", range, ...pathspec]),
+        ]);
+        const rawFiles = parseRawDiff(raw);
+        const stats = parseNumstat(numstat);
+        const sections = splitDiffByFile(withoutTerminalPatchDelimiter(patch));
+        const files = rawFiles.map((file, index) => {
+            const stat = stats[index];
+            return {
+                ...file,
+                insertions: stat?.insertions ?? 0,
+                deletions: stat?.deletions ?? 0,
+                binary: stat?.binary ?? false,
+                hunks: parsePatchHunks(sections[index] ?? []),
+            };
+        });
+        return {
+            from,
+            to,
+            files,
+            stat: {
+                filesChanged: files.length,
+                insertions: files.reduce((sum, file) => sum + file.insertions, 0),
+                deletions: files.reduce((sum, file) => sum + file.deletions, 0),
+            },
+        };
+    }
+    catch (error) {
+        throw wrapGitError(`diff --find-renames ${range}`, error, cwd);
+    }
+}

package/build/index.js

@@ -3,10 +3,10 @@ import { VERSION, GIT_HASH } from "./generated/version.js";
 import * as fs from "node:fs/promises";
 import { getConfig, initializeConfig } from "./config/env.js";
 import { ENV_KEYS } from "./config/env-keys.js";
-import { logErrorWithCause } from "./telemetry/logger.js";
+import { formatErrorWithCause } from "./telemetry/logger.js";
 import { runProjectionGenerationRuntime } from "./core/projection/index.js";
 import { renderCliHelp, runCliCommand } from "./cli/index.js";
-import { installCliOutputStreamErrorPolicy } from "./cli/output-stream-error-policy.js";
+import { installCliOutputStreamErrorPolicy, writeCliOutput } from "./cli/output-stream-error-policy.js";
 import { assertSubagentCliCommandAllowed } from "./cli/subagent-guard.js";
 installCliOutputStreamErrorPolicy(process.stdout, process.stderr);
 const packageVersion = VERSION;
@@ -45,16 +45,16 @@ async function main() {
         args: cliArgs,
     });
     if (cliArgs.length === 1 && cliArgs[0] === "--version") {
-        console.log(GIT_HASH ? `${packageVersion} (${GIT_HASH})` : packageVersion);
+        await writeCliOutput(process.stdout, `${GIT_HASH ? `${packageVersion} (${GIT_HASH})` : packageVersion}\n`);
         return;
     }
     if (cliArgs.length === 0 || (cliArgs.length === 1 && (cliArgs[0] === "--help" || cliArgs[0] === "-h"))) {
-        console.log(renderCliHelp(packageVersion));
+        await writeCliOutput(process.stdout, `${renderCliHelp(packageVersion)}\n`);
         return;
     }
     process.exitCode = await runCliCommand(cliArgs);
 }
-main().catch((err) => {
-    logErrorWithCause("Fatal error:", err, { mirrorToDebugLog: false });
-    process.exit(1);
+await main().catch(async (err) => {
+    await writeCliOutput(process.stderr, `${formatErrorWithCause("Fatal error:", err)}\n`);
+    process.exitCode = 1;
 });

package/build/telemetry/logger.js

@@ -31,6 +31,9 @@ function stringifyUnknown(error) {
         return String(error);
     }
 }
+export function formatErrorWithCause(message, error) {
+    return `${message} ${stringifyUnknown(error)}`;
+}
 export function logInfo(message, options = {}) {
     log("info", message, options);
 }
@@ -41,6 +44,5 @@ export function logError(message, options = {}) {
     log("error", message, options);
 }
 export function logErrorWithCause(message, error, options = {}) {
-    const details = stringifyUnknown(error);
-    logError(`${message} ${details}`, options);
+    logError(formatErrorWithCause(message, error), options);
 }