@astrosheep/keiyaku 2.9.4 → 2.9.6

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

@@ -166,12 +166,6 @@ export async function trackedTaskPaths(cwd, commit) {
 export async function refHead(cwd, ref) {
     return (await git(cwd, ["rev-parse", ref])).trim();
 }
-export async function readableRefHead(cwd, ref) {
-    const result = await gitResult(cwd, ["rev-parse", ref]);
-    if (result.status !== 0)
-        return undefined;
-    return result.stdout.trim();
-}
 export async function taskContractAtCommit(cwd, commit, id) {
     const sourcePath = `.keiyaku/tasks/${id}.md`;
     const result = await gitResult(cwd, ["show", `${commit}:${sourcePath}`]);
@@ -179,6 +173,37 @@ export async function taskContractAtCommit(cwd, commit, id) {
         return undefined;
     return parseTaskDocument({ path: sourcePath, text: result.stdout }).contractId;
 }
+/** Bound task ids and their complete parent ancestry from the immutable bind base. */
+export async function taskSettlementOwnershipAtCommit(cwd, commit, contractId) {
+    const documents = new Map();
+    for (const entry of await taskTreeEntries(cwd, commit)) {
+        const text = await git(cwd, ["cat-file", "blob", entry.oid]);
+        const document = parseTaskDocument({ path: entry.path, text });
+        documents.set(document.id, document);
+    }
+    const taskIds = [...documents.values()]
+        .filter((document) => document.contractId === contractId)
+        .map((document) => document.id)
+        .sort();
+    const ownedIds = new Set();
+    for (const taskId of taskIds) {
+        let current = taskId;
+        while (current !== null) {
+            if (ownedIds.has(current))
+                break;
+            ownedIds.add(current);
+            const document = documents.get(current);
+            if (!document) {
+                throw new FlowError("INTERNAL_STATE", `bind base ${commit} lost task ${current} from the owned ancestry`);
+            }
+            current = document.parent;
+        }
+    }
+    return {
+        taskIds,
+        paths: [...ownedIds].map((id) => `.keiyaku/tasks/${id}.md`).sort(),
+    };
+}
 export async function updateBranch(input, deps) {
     if (deps.updateBranch)
         await deps.updateBranch(input);
@@ -216,7 +241,7 @@ async function treeWithoutTasks(cwd, commit, gitDir) {
         fs.rmSync(temporaryDirectory, { recursive: true, force: true });
     }
 }
-async function composeLandingTree(input) {
+export async function composeLandingTree(input) {
     const baseTree = await treeWithoutTasks(input.cwd, input.base, input.gitDir);
     const targetTree = await treeWithoutTasks(input.cwd, input.target, input.gitDir);
     const deliveryTree = await treeWithoutTasks(input.cwd, input.delivery, input.gitDir);
@@ -263,24 +288,98 @@ async function composeLandingTree(input) {
         fs.rmSync(temporaryDirectory, { recursive: true, force: true });
     }
 }
+function landingCommitMessage(contractId, targetBranch) {
+    return `keiyaku: claim ${contractId}\n\nMerge contract ${contractId} into ${targetBranch}.\n`;
+}
+async function isAncestor(cwd, ancestor, descendant) {
+    return (await gitResult(cwd, ["merge-base", "--is-ancestor", ancestor, descendant])).status === 0;
+}
+export async function taskSourcesAtCommit(cwd, root, commit, paths) {
+    const sources = [];
+    for (const sourcePath of paths) {
+        const result = await gitResult(cwd, ["show", `${commit}:${sourcePath}`]);
+        if (result.status !== 0)
+            return undefined;
+        sources.push({ path: path.join(root, ...sourcePath.split("/")), text: result.stdout });
+    }
+    return sources;
+}
+/**
+ * Find the durable landing receipt on the target's first-parent history.
+ * Equivalent trees and lookalike messages are insufficient: the commit must
+ * have our parent shape, settle every bind-base-owned task, and exactly match
+ * a recomposed landing tree over its own first parent.
+ */
+export async function findAcceptedLandingCommit(input) {
+    const commits = (await git(input.cwd, ["rev-list", "--first-parent", input.target, `^${input.base}`]))
+        .trim()
+        .split("\n")
+        .filter(Boolean);
+    for (const commit of commits) {
+        const message = await git(input.cwd, ["show", "-s", "--format=%B", commit]);
+        if (message.trimEnd() !== landingCommitMessage(input.contractId, input.targetBranch).trimEnd())
+            continue;
+        const record = (await git(input.cwd, ["rev-list", "--parents", "-n", "1", commit])).trim().split(/\s+/);
+        const parents = record.slice(1);
+        const parentShapeAccepted = parents.length === 2
+            ? parents[1] === input.delivery
+            : parents.length === 1 && await isAncestor(input.cwd, input.delivery, parents[0]);
+        if (!parentShapeAccepted)
+            continue;
+        const sources = await taskSourcesAtCommit(input.cwd, input.root, commit, input.ownedPaths);
+        if (!sources)
+            continue;
+        let settled = false;
+        try {
+            const sourceByPath = new Map(sources.map((source) => [boardPath(input.root, source), source]));
+            settled = input.settledPaths.every((settledPath) => {
+                const source = sourceByPath.get(settledPath);
+                if (!source)
+                    return false;
+                const document = parseTaskDocument(source);
+                return document.state === "done" && document.contractId === undefined;
+            });
+        }
+        catch {
+            // A malformed lookalike is not this operation's durable receipt.
+        }
+        if (!settled)
+            continue;
+        const expectedTree = await composeLandingTree({
+            cwd: input.cwd,
+            gitDir: input.gitDir,
+            root: input.root,
+            base: input.base,
+            target: parents[0],
+            delivery: input.delivery,
+            sources,
+        });
+        const actualTree = (await git(input.cwd, ["rev-parse", `${commit}^{tree}`])).trim();
+        if (actualTree === expectedTree)
+            return commit;
+    }
+    return undefined;
+}
+export async function containsCommit(cwd, ancestor, descendant) {
+    return await isAncestor(cwd, ancestor, descendant);
+}
+/** Create the landing commit over a previously composed candidate tree. */
 export async function createLandingCommit(input) {
-    const tree = await composeLandingTree(input);
+    // Once delivery is already reachable from target, a single-parent landing
+    // records this claim without fabricating a redundant merge parent.
+    const parents = input.target === input.delivery || await isAncestor(input.cwd, input.delivery, input.target)
+        ? ["-p", input.target]
+        : ["-p", input.target, "-p", input.delivery];
     return (await git(input.cwd, [
         "commit-tree",
-        tree,
-        "-p",
-        input.target,
-        "-p",
-        input.delivery,
+        input.tree,
+        ...parents,
         "-m",
         `keiyaku: claim ${input.contractId}`,
         "-m",
         `Merge contract ${input.contractId} into ${input.targetBranch}.`,
     ])).trim();
 }
-export async function containsCommit(cwd, ancestor, descendant) {
-    return (await gitResult(cwd, ["merge-base", "--is-ancestor", ancestor, descendant])).status === 0;
-}
 export async function updateTargetRef(cwd, ref, next, expected) {
     await git(cwd, ["update-ref", ref, next, expected]);
 }

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.6";
+export const GIT_HASH = "cb7f9ef";

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"));