@astrosheep/keiyaku 2.9.3 → 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,30 +17,28 @@ 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;
 }
-export function selectReadyTaskForBind(board, taskId) {
-    requireHealthySettlementBoard(board);
-    const id = resolveTaskReadId(board, taskId);
-    const task = board.byId.get(id);
+function validateReadyForBind(board, task) {
     if (task.state === "in_progress") {
-        throw new FlowError("INVALID_TARGET", `task ${id} is in_progress; stop it before bind`);
+        throw new FlowError("INVALID_TARGET", `task ${task.id} is in_progress; stop it before bind`);
     }
     if (task.state !== "open") {
-        throw new FlowError("INVALID_TARGET", `task ${id} is ${task.state}, not ready for bind`);
+        throw new FlowError("INVALID_TARGET", `task ${task.id} is ${task.state}, not ready for bind`);
     }
     const unsatisfied = task.needs
         .filter((need) => {
@@ -48,22 +47,70 @@ export function selectReadyTaskForBind(board, taskId) {
     })
         .sort();
     if (unsatisfied.length > 0) {
-        throw new FlowError("INVALID_TARGET", `task ${id} is blocked by: ${unsatisfied.join(", ")}`);
+        throw new FlowError("INVALID_TARGET", `task ${task.id} is blocked by: ${unsatisfied.join(", ")}`);
     }
     if (task.contractId !== undefined) {
-        throw new FlowError("INVALID_TARGET", `task ${id} is already bound to contract ${task.contractId}`);
+        throw new FlowError("INVALID_TARGET", `task ${task.id} is already bound to contract ${task.contractId}`);
     }
-    return task;
 }
-export function taskForContract(board, contractId) {
+export function selectReadyTasksForBind(board, taskIds) {
     requireHealthySettlementBoard(board);
-    const matches = board.tasks
+    const rootIds = taskIds.map((taskId) => resolveTaskReadId(board, taskId));
+    const duplicates = rootIds.filter((id, index) => rootIds.indexOf(id) !== index);
+    if (duplicates.length > 0) {
+        throw new FlowError("INVALID_TARGET", `task ${[...new Set(duplicates)].sort().join(", ")} selected more than once`);
+    }
+    const admitted = new Set();
+    const tasks = [];
+    for (const rootId of rootIds) {
+        const root = board.byId.get(rootId);
+        if (!admitted.has(root.id)) {
+            admitted.add(root.id);
+            tasks.push(root);
+        }
+        for (const candidate of board.tasks) {
+            if (candidate.parent === null || admitted.has(candidate.id))
+                continue;
+            if (candidate.state === "done" || candidate.state === "drop")
+                continue;
+            if (isDescendantOf(board, candidate, rootId)) {
+                admitted.add(candidate.id);
+                tasks.push(candidate);
+            }
+        }
+    }
+    for (const task of tasks)
+        validateReadyForBind(board, task);
+    return tasks;
+}
+function isDescendantOf(board, task, ancestorId) {
+    let current = task.parent;
+    while (current !== null) {
+        if (current === ancestorId)
+            return true;
+        current = board.byId.get(current)?.parent ?? null;
+    }
+    return false;
+}
+export function tasksForContract(board, contractId) {
+    requireHealthySettlementBoard(board);
+    return board.tasks
         .filter((task) => task.contractId === contractId)
         .sort((left, right) => left.id.localeCompare(right.id));
-    if (matches.length > 1) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is referenced by multiple tasks: ${matches.map((task) => task.id).join(", ")}`);
-    }
-    return matches[0];
+}
+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];
+    });
 }
 export function requireSettledTask(board, id) {
     const task = requireHealthySettlementBoard(board).byId.get(id);
@@ -71,12 +118,3 @@ export function requireSettledTask(board, id) {
         throw new FlowError("INTERNAL_STATE", `task ${id} disappeared from the board`);
     return task;
 }
-export function doneTaskReplacement(board, contractId) {
-    const bound = taskForContract(board, contractId);
-    if (!bound)
-        return undefined;
-    const settled = settlementDocument(bound, undefined);
-    settled.state = "done";
-    delete settled.startedAt;
-    return settled;
-}

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

@@ -0,0 +1,444 @@
+import { FlowError } from "../../flow-error.js";
+import { assertGitObservation, requireGitRepository } from "../../git/branches.js";
+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 { 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) {
+    return source.path.slice(root.length + 1).split("\\").join("/");
+}
+function taskPath(id) {
+    return `.keiyaku/tasks/${id}.md`;
+}
+function ownedTaskPaths(board, taskIds) {
+    if (!taskIds || taskIds.length === 0)
+        return [];
+    const paths = new Set();
+    for (const taskId of taskIds) {
+        let current = board.byId.get(taskId);
+        while (current) {
+            paths.add(taskPath(current.id));
+            current = current.parent === null ? undefined : board.byId.get(current.parent);
+        }
+    }
+    return [...paths].sort();
+}
+function selectSettlementSources(input) {
+    const tracked = new Set(input.trackedPaths);
+    const sourceByPath = new Map(input.sources.map((source) => [sourcePath(input.root, source), source]));
+    // An ancestry path is eligible only when it was already tracked. A mutation is
+    // the sole explicit adoption authority for an untracked task document.
+    const selected = new Set([
+        ...input.ownedPaths.filter((taskSourcePath) => tracked.has(taskSourcePath)),
+        ...input.mutationPaths,
+    ].filter((taskSourcePath) => sourceByPath.has(taskSourcePath)));
+    const selectedPaths = [...selected].sort();
+    const adoptedPaths = selectedPaths.filter((taskSourcePath) => !tracked.has(taskSourcePath));
+    const observedPaths = new Set([...tracked, ...sourceByPath.keys()]);
+    return {
+        sources: selectedPaths.map((taskSourcePath) => sourceByPath.get(taskSourcePath)),
+        evidence: {
+            selectedPaths,
+            rejectedPaths: [...observedPaths].filter((taskSourcePath) => !selected.has(taskSourcePath)).sort(),
+            adoptedPaths,
+        },
+    };
+}
+function repositoryForSettlement(transaction, sources) {
+    let currentSources = sources;
+    return {
+        read: async () => taskBoardFromSourceBoard(buildTaskSourceBoard(currentSources)),
+        sources: () => currentSources,
+        mutate: async (apply) => {
+            const board = taskBoardFromSourceBoard(buildTaskSourceBoard(currentSources));
+            const mutation = await apply(board);
+            const prepared = prepareTaskDocumentReplacements(currentSources, mutation.replacements);
+            await transaction.replace(prepared.writes);
+            currentSources = prepared.sources;
+            return mutation.select(prepared.board);
+        },
+    };
+}
+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, input.updatedAt)]
+                : [];
+        });
+        return { replacements, select: () => replacements.map((replacement) => replacement.id) };
+    });
+}
+async function replaceTaskDocuments(repository, replacements) {
+    return repository.mutate(() => ({
+        replacements,
+        select: (resulting) => replacements.map((replacement) => requireSettledTask(resulting, replacement.id)),
+    }));
+}
+async function restorePreAdmissionTaskMutations(input) {
+    // Write text is ignored by restore; the id selects the path whose prior bytes return.
+    await input.transaction.restore(input.taskIds.map((id) => ({ id, text: "" })), input.previousSources);
+}
+async function rollForwardClearAttemptedPointer(input) {
+    const clearedIds = await clearAttemptedPointers({
+        repository: input.repository,
+        tasks: input.selected,
+        contractId: input.contractId,
+        updatedAt: input.updatedAt,
+    });
+    if (clearedIds.length === 0)
+        return;
+    const rollbackSelection = selectSettlementSources({
+        root: input.root,
+        sources: input.repository.sources(),
+        trackedPaths: await trackedTaskPaths(input.hubCwd, input.trackedHead),
+        ownedPaths: input.selectedPaths,
+        mutationPaths: clearedIds.map(taskPath),
+    });
+    await publishForwardTaskBoardCommit({
+        cwd: input.hubCwd,
+        ref: input.branchRef,
+        gitDir: input.gitDir,
+        root: input.root,
+        sources: rollbackSelection.sources,
+        paths: rollbackSelection.evidence.selectedPaths,
+        subject: `Clear failed contract ${input.contractId} from ${clearedIds.length === 1 ? `task ${clearedIds[0]}` : `${clearedIds.length} tasks`}`,
+    }, 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") {
+            if (transaction.location.capability === "unavailable") {
+                assertGitObservation({ capability: "unavailable" }, "task bind");
+            }
+            throw new FlowError("NOT_GIT_REPO", "task bind requires Git task storage");
+        }
+        const hubCwd = transaction.location.root;
+        const branch = await inspectCurrentBranch(hubCwd);
+        const previousSources = transaction.sources;
+        const repository = repositoryForSettlement(transaction, transaction.sources);
+        const board = requireHealthySettlementBoard(await repository.read());
+        const taskBound = "taskIds" in input;
+        const selectedTasks = taskBound ? selectReadyTasksForBind(board, input.taskIds) : [];
+        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, updatedAt)));
+        }
+        const taskIds = taskBound ? selectedTasks.map((t) => t.id) : undefined;
+        const selectedPaths = ownedTaskPaths(await repository.read(), taskIds);
+        const mutationPaths = taskBound ? selectedTasks.map((t) => taskPath(t.id)) : [];
+        const selectCurrentSettlement = async () => selectSettlementSources({
+            root: transaction.location.root,
+            sources: repository.sources(),
+            trackedPaths: await trackedTaskPaths(hubCwd, branch.head),
+            ownedPaths: selectedPaths,
+            mutationPaths,
+        });
+        const selection = await selectCurrentSettlement();
+        const makeBoardCommit = deps.createTaskBoardCommit ?? createTaskBoardCommit;
+        const reconcileIndex = deps.reconcileTaskPathsetIndex ?? reconcileTaskPathsetIndex;
+        let firstCommit;
+        try {
+            const taskLabel = taskBound
+                ? selectedTasks.length === 1
+                    ? `task ${selectedTasks[0].id}`
+                    : `${selectedTasks.length} tasks`
+                : "";
+            firstCommit = await makeBoardCommit({
+                cwd: hubCwd,
+                gitDir: transaction.location.gitDir,
+                root: transaction.location.root,
+                parent: branch.head,
+                sources: selection.sources,
+                subject: taskBound
+                    ? `Bind ${taskLabel} to contract ${contractId}`
+                    : `Flush task board for contract ${contractId}`,
+            });
+        }
+        catch (error) {
+            if (taskBound) {
+                await restorePreAdmissionTaskMutations({ transaction, taskIds: selectedTasks.map((task) => task.id), previousSources });
+            }
+            throw error;
+        }
+        try {
+            await updateBranch({ cwd: hubCwd, ref: branch.ref, next: firstCommit, expected: branch.head }, deps);
+        }
+        catch (error) {
+            if (taskBound) {
+                const concurrentHead = await refHead(hubCwd, branch.ref);
+                const concurrentMatches = await Promise.all(selectedTasks.map(async (task) => (await taskContractAtCommit(hubCwd, concurrentHead, task.id)) === contractId));
+                if (concurrentMatches.every(Boolean)) {
+                    await rollForwardClearAttemptedPointer({
+                        repository, selected: selectedTasks, contractId, hubCwd,
+                        branchRef: branch.ref, trackedHead: branch.head,
+                        gitDir: transaction.location.gitDir, root: transaction.location.root,
+                        selectedPaths, deps, updatedAt,
+                    });
+                }
+                else {
+                    await restorePreAdmissionTaskMutations({ transaction, taskIds: selectedTasks.map((task) => task.id), previousSources });
+                }
+            }
+            throw error;
+        }
+        try {
+            await reconcileIndex(hubCwd, firstCommit, selection.evidence.selectedPaths);
+        }
+        catch (indexError) {
+            if (taskBound) {
+                await rollForwardClearAttemptedPointer({
+                    repository, selected: selectedTasks, contractId, hubCwd,
+                    branchRef: branch.ref, trackedHead: branch.head,
+                    gitDir: transaction.location.gitDir, root: transaction.location.root,
+                    selectedPaths, deps, updatedAt,
+                });
+            }
+            throw indexError;
+        }
+        try {
+            const ledger = await prepared.publishLedger(firstCommit);
+            const boardAfter = requireHealthySettlementBoard(await repository.read());
+            return {
+                boardCommit: firstCommit,
+                contractId,
+                ledger,
+                ...(taskBound && selectedTasks.length > 0 ? { tasks: selectedTasks.map((t) => requireSettledTask(boardAfter, t.id)) } : {}),
+                evidence: selection.evidence,
+            };
+        }
+        catch (publishError) {
+            if (!taskBound)
+                throw publishError;
+            await rollForwardClearAttemptedPointer({
+                repository, selected: selectedTasks, contractId, hubCwd,
+                branchRef: branch.ref, trackedHead: branch.head,
+                gitDir: transaction.location.gitDir, root: transaction.location.root,
+                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) => {
+        if (transaction.location.mode !== "git") {
+            if (transaction.location.capability === "unavailable") {
+                assertGitObservation({ capability: "unavailable" }, "task forfeit");
+            }
+            throw new FlowError("NOT_GIT_REPO", "task forfeit requires Git task storage");
+        }
+        const repository = taskRepositoryFromLockedBoard(transaction);
+        const matched = tasksForContract(await repository.read(), input.contractId);
+        const ledger = await input.publishLedger();
+        if (matched.length === 0)
+            return { ledger };
+        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({
+            cwd: transaction.location.root,
+            gitDir: transaction.location.gitDir,
+            writes: reopenedDocuments.map((document) => ({ id: document.id, text: serializeTaskDocument(document) })),
+            subject: `Reopen ${taskLabel} after forfeit of ${input.contractId}`,
+        });
+        return { ledger, tasks: reopened };
+    });
+}
+/**
+ * Claim owns the sole task-board settlement after target CAS. Contract branch
+ * 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, 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 lastPostCasError;
+    let acceptedMovement;
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+        const result = await withLockHeldTaskBoard(hubRoot, async (transaction) => {
+            if (transaction.location.mode !== "git") {
+                if (transaction.location.capability === "unavailable") {
+                    assertGitObservation({ capability: "unavailable" }, "task landing");
+                }
+                throw new FlowError("NOT_GIT_REPO", "task landing requires Git task storage");
+            }
+            // Each attempt reads fresh target and board facts while holding the
+            // 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, ownership.taskIds, updatedAt);
+            const prepared = replacements.length > 0
+                ? prepareTaskDocumentReplacements(transaction.sources, replacements)
+                : { sources: transaction.sources, board };
+            const finalSources = prepared.sources;
+            requireHealthySettlementBoard(prepared.board);
+            const selection = selectSettlementSources({
+                root: transaction.location.root,
+                sources: finalSources,
+                trackedPaths: await trackedTaskPaths(input.cwd, targetHead),
+                ownedPaths: selectedPaths,
+                // Bind-base ownership, unlike incidental hub bytes, authorizes a path
+                // even when a concurrent target commit removed it.
+                mutationPaths: selectedPaths,
+            });
+            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 reconcileIndex(transaction.location.root, mergeCommit, selectedPaths);
+            }
+            catch (error) {
+                lastPostCasError = error;
+                return { kind: "retry" };
+            }
+            try {
+                await input.publishLedger?.(mergeCommit);
+            }
+            catch (error) {
+                lastPostCasError = error;
+                return { kind: "retry" };
+            }
+            const reconcileWarnings = await input.afterCas?.(mergeCommit, movement.oldHead);
+            warnings.push(...(reconcileWarnings ?? []));
+            return {
+                kind: "accepted",
+                mergeCommit,
+                oldHead: movement.oldHead,
+                ...(warnings.length > 0 ? { warnings } : {}),
+                evidence: selection.evidence,
+            };
+        });
+        if (result.kind === "retry")
+            continue;
+        if (result.kind === "idempotent") {
+            return {
+                mergeCommit: result.mergeCommit,
+                ...(result.warnings ? { warnings: result.warnings } : {}),
+                ...(result.evidence ? { evidence: result.evidence } : {}),
+            };
+        }
+        return {
+            mergeCommit: result.mergeCommit,
+            oldHead: result.oldHead,
+            ...(result.warnings ? { warnings: result.warnings } : {}),
+            ...(result.evidence ? { evidence: result.evidence } : {}),
+        };
+    }
+    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-doctor.js → task/task-doctor.js}

@@ -1,5 +1,5 @@
 import { rollbackOrphanTaskPointers } from "./task.js";
-import { buildTaskSourceBoard } from "./task/source-board.js";
+import { buildTaskSourceBoard } from "./source-board.js";
 export async function inspectTaskDoctor(store, repository, facts) {
     const orphans = facts.lockHeld ? [] : await rollbackOrphanTaskPointers(repository, facts.contractIds);
     const sources = await store.read();

package/build/core/{task-git-actor.js → task/task-git-actor.js}

@@ -1,20 +1,15 @@
-import { spawnSync } from "node:child_process";
+import { runGitProcess } from "../../git/core.js";
 const ANONYMOUS_TASK_CREATOR = "(anonymous)";
 const TASK_ACTOR_ENV = "KEIYAKU_ACTOR";
 const GIT_ACTOR_KEYS = ["keiyaku.actor", "user.name"];
-function defaultRunGit(cwd, args, env) {
-    return spawnSync("git", [...args], {
-        cwd,
-        encoding: "utf8",
-        env,
-        stdio: ["ignore", "pipe", "pipe"],
-    });
+async function defaultRunGit(cwd, args, env) {
+    return await runGitProcess(cwd, args, { env: { ...env } });
 }
 function attribution(value) {
     const trimmed = value?.trim();
     return trimmed ? trimmed : undefined;
 }
-export function resolveTaskCreator(cwd, deps = {}) {
+export async function resolveTaskCreator(cwd, deps = {}) {
     const sourceEnv = deps.env ?? process.env;
     const environmentActor = attribution(sourceEnv[TASK_ACTOR_ENV]);
     if (environmentActor)
@@ -23,7 +18,7 @@ export function resolveTaskCreator(cwd, deps = {}) {
     const runGit = deps.runGit ?? defaultRunGit;
     for (const key of GIT_ACTOR_KEYS) {
         try {
-            const result = runGit(cwd, ["config", "--get", key], gitEnv);
+            const result = await runGit(cwd, ["config", "--get", key], gitEnv);
             if (!result.error && result.status === 0) {
                 const configuredActor = attribution(result.stdout);
                 if (configuredActor)

package/build/core/{task-git-runtime.js → task/task-git-runtime.js}

@@ -1,6 +1,6 @@
-import { observeGitRepository } from "../git/branches.js";
-import { listContractIds } from "./ledger.js";
-import { contractBoundByEngineWorktree, stableRepoRoot } from "./worktree-path.js";
+import { observeGitRepository } from "../../git/branches.js";
+import { listContractIds } from "../ledger.js";
+import { contractBoundByEngineWorktree, stableRepoRoot } from "../worktree-path.js";
 import { inspectTaskLock, openTaskStore } from "./task-git-store.js";
 import { taskRepositoryFromStore } from "./task-store-repository.js";
 import { withTaskWorktreePolicy } from "./task-worktree.js";