@astrosheep/keiyaku 2.9.9 → 2.9.11

package/build/core/task/task-bind-preparation.js

@@ -0,0 +1,193 @@
+import { FlowError } from "../../flow-error.js";
+import { runGitProcess } from "../../git/core.js";
+import { assertGitObservation, requireGitRepository } from "../../git/branches.js";
+import { inspectCurrentBranch, createTaskBoardCommit, publishForwardTaskBoardCommit, reconcileTaskPathsetIndex, refHead, taskSourcesAtCommit, taskWritesFromSources, } from "./settlement-git.js";
+import { taskCoordinateFromSourcePath } from "./coordinate.js";
+import { advancedTaskUpdatedAt } from "./model.js";
+import { requireHealthySettlementBoard, selectReadyTasksForBind } from "./settlement-policy.js";
+import { buildTaskSourceBoard } from "./source-board.js";
+import { prepareTaskDocumentReplacements, taskBoardFromSourceBoard } from "./task-store-repository.js";
+import { withLockHeldTaskBoard, } from "./task-git-store.js";
+function linkedTaskDocument(task, contractId, at) {
+    return {
+        id: task.id,
+        namespace: task.namespace,
+        coordinate: task.coordinate,
+        title: task.title,
+        state: "open",
+        pri: task.pri,
+        needs: [...task.needs],
+        parent: task.parent,
+        from: [...task.from],
+        supersedes: [...task.supersedes],
+        relatesTo: [...task.relatesTo],
+        createdAt: task.createdAt,
+        updatedAt: advancedTaskUpdatedAt(task, at),
+        creator: task.creator,
+        contractId,
+        body: task.body,
+    };
+}
+function selectedEvidence(board, selected) {
+    return selected.map((task) => ({
+        taskId: task.coordinate,
+        needs: task.needs.map((taskId) => {
+            const state = board.byId.get(taskId)?.state;
+            if (state !== "done" && state !== "drop") {
+                throw new FlowError("INTERNAL_STATE", `ready task ${task.coordinate} has unsatisfied need ${taskId}`);
+            }
+            return { taskId, state };
+        }),
+    }));
+}
+async function prepareLockedTaskBind(transaction, input, deps) {
+    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 board = requireHealthySettlementBoard(taskBoardFromSourceBoard(buildTaskSourceBoard(transaction.sources)));
+    const selected = selectReadyTasksForBind(board, input.taskIds);
+    if (selected.length === 0) {
+        throw new FlowError("INVALID_TARGET", "task bind requires at least one selected task");
+    }
+    const attempt = await input.prepare(selected);
+    const evidence = selectedEvidence(board, selected);
+    const linked = prepareTaskDocumentReplacements(transaction.sources, selected.map((task) => linkedTaskDocument(task, attempt.contractId, attempt.at)));
+    const linkedIds = new Set(selected.map((task) => task.coordinate));
+    const linkedSources = linked.sources.filter((source) => linkedIds.has(taskCoordinateFromSourcePath(source.path).coordinate));
+    const originalSources = transaction.sources.filter((source) => linkedIds.has(taskCoordinateFromSourcePath(source.path).coordinate));
+    if (linkedSources.length !== selected.length) {
+        throw new FlowError("INTERNAL_STATE", "task bind preparation did not resolve the exact selected task pathset");
+    }
+    if (originalSources.length !== selected.length) {
+        throw new FlowError("INTERNAL_STATE", "task bind preparation did not retain the exact original task pathset");
+    }
+    const branch = await inspectCurrentBranch(transaction.location.root);
+    const newHead = await (deps.createTaskBoardCommit ?? createTaskBoardCommit)({
+        cwd: transaction.location.root,
+        gitDir: transaction.location.gitDir,
+        root: transaction.location.root,
+        parent: branch.head,
+        sources: linkedSources,
+        subject: selected.length === 1
+            ? `Bind task ${selected[0].coordinate} to contract ${attempt.contractId}`
+            : `Bind ${selected.length} tasks to contract ${attempt.contractId}`,
+    });
+    const taskBoard = { ref: branch.ref, expectedHead: branch.head, head: newHead };
+    return {
+        boardRef: taskBoard.ref,
+        expectedHead: taskBoard.expectedHead,
+        newHead,
+        entryBase: newHead,
+        taskIds: selected.map((task) => task.coordinate),
+        selected: evidence,
+        taskBoard,
+        replay: {
+            paths: selected.map((task) => `.keiyaku/tasks/${task.coordinate}.md`).sort(),
+            linkedSources,
+            originalSources,
+        },
+    };
+}
+/** Hold the repository task lock across build and the caller-owned ref transaction. */
+export async function withPreparedTaskBind(input, deps = {}) {
+    await requireGitRepository(input.cwd, "task bind");
+    return await withLockHeldTaskBoard(input.cwd, async (transaction) => {
+        const preparation = await prepareLockedTaskBind(transaction, input, deps);
+        const result = await input.transact(preparation, transaction);
+        return { preparation, result };
+    }, { signal: input.signal });
+}
+/** Complete the prepared task projection while its authority transaction still owns the task lock. */
+export async function replayPreparedTaskBindLocked(transaction, prepared) {
+    if (transaction.location.mode !== "git")
+        throw new FlowError("NOT_GIT_REPO", "task bind replay requires Git task storage");
+    const currentHead = await refHead(transaction.location.root, prepared.boardRef);
+    const sources = await taskSourcesAtCommit(transaction.location.root, transaction.location.root, currentHead, prepared.replay.paths);
+    if (!sources)
+        throw new FlowError("INTERNAL_STATE", "committed task bind paths are missing from board authority");
+    await transaction.replace(taskWritesFromSources(sources));
+    await reconcileTaskPathsetIndex(transaction.location.root, currentHead, prepared.replay.paths);
+}
+export async function replayPreparedTaskBind(cwd, prepared) {
+    await withLockHeldTaskBoard(cwd, async (transaction) => {
+        await replayPreparedTaskBindLocked(transaction, prepared);
+    });
+}
+async function projectionMatchesCommit(cwd, commit, paths) {
+    const cached = await runGitProcess(cwd, ["diff", "--quiet", "--cached", commit, "--", ...paths]);
+    if (cached.error || (cached.status !== 0 && cached.status !== 1))
+        return false;
+    if (cached.status !== 0)
+        return false;
+    const worktree = await runGitProcess(cwd, ["diff", "--quiet", "--", ...paths]);
+    return !worktree.error && worktree.status === 0;
+}
+/** Rebuild the selected task working-tree projection from the authoritative bind base. */
+export async function replayCommittedTaskBind(cwd, commit, taskIds) {
+    const paths = taskIds.map((taskId) => `.keiyaku/tasks/${taskId}.md`).sort();
+    if (await projectionMatchesCommit(cwd, commit, paths))
+        return "already-present";
+    return await withLockHeldTaskBoard(cwd, async (transaction) => {
+        if (transaction.location.mode !== "git")
+            throw new FlowError("NOT_GIT_REPO", "task bind replay requires Git task storage");
+        const sources = await taskSourcesAtCommit(transaction.location.root, transaction.location.root, commit, paths);
+        if (!sources)
+            throw new FlowError("INTERNAL_STATE", "committed task bind paths are missing from board authority");
+        const current = new Map(transaction.sources.map((source) => [source.path, source.text]));
+        const alreadyPresent = sources.every((source) => current.get(source.path) === source.text);
+        if (!alreadyPresent)
+            await transaction.replace(taskWritesFromSources(sources));
+        await reconcileTaskPathsetIndex(transaction.location.root, commit, paths);
+        return alreadyPresent ? "already-present" : "created";
+    });
+}
+/** Reopen task projections from the authoritative parent of a task-selected bind base. */
+export async function replayCommittedTaskBindForfeit(cwd, commit, boardRef, taskIds) {
+    return await withLockHeldTaskBoard(cwd, async (transaction) => {
+        if (transaction.location.mode !== "git")
+            throw new FlowError("NOT_GIT_REPO", "task forfeit replay requires Git task storage");
+        const parentResult = await runGitProcess(transaction.location.root, ["rev-parse", "--verify", `${commit}^`]);
+        if (parentResult.status !== 0 || parentResult.error) {
+            throw new FlowError("INTERNAL_STATE", `committed task bind base ${commit} has no readable parent`, { cause: parentResult.error });
+        }
+        const parent = parentResult.stdout.trim();
+        const paths = taskIds.map((taskId) => `.keiyaku/tasks/${taskId}.md`).sort();
+        const originalSources = await taskSourcesAtCommit(transaction.location.root, transaction.location.root, parent, paths);
+        if (!originalSources)
+            throw new FlowError("INTERNAL_STATE", "committed task bind parent is missing selected task paths");
+        const current = new Map(transaction.sources.map((source) => [source.path, source.text]));
+        const alreadyPresent = originalSources.every((source) => current.get(source.path) === source.text);
+        if (alreadyPresent)
+            return "already-present";
+        await transaction.replace(taskWritesFromSources(originalSources));
+        await publishForwardTaskBoardCommit({
+            cwd: transaction.location.root,
+            ref: boardRef,
+            gitDir: transaction.location.gitDir,
+            root: transaction.location.root,
+            sources: originalSources,
+            paths,
+            subject: `Reopen ${taskIds.length === 1 ? `task ${taskIds[0]}` : `${taskIds.length} tasks`} after bind failure`,
+        }, {});
+        return "created";
+    });
+}
+export async function replayPreparedTaskBindForfeit(cwd, prepared) {
+    await withLockHeldTaskBoard(cwd, async (transaction) => {
+        if (transaction.location.mode !== "git")
+            throw new FlowError("NOT_GIT_REPO", "task forfeit replay requires Git task storage");
+        await transaction.replace(taskWritesFromSources(prepared.replay.originalSources));
+        await publishForwardTaskBoardCommit({
+            cwd: transaction.location.root,
+            ref: prepared.boardRef,
+            gitDir: transaction.location.gitDir,
+            root: transaction.location.root,
+            sources: prepared.replay.originalSources,
+            paths: prepared.replay.paths,
+            subject: `Reopen ${prepared.taskIds.length === 1 ? `task ${prepared.taskIds[0]}` : `${prepared.taskIds.length} tasks`} after bind failure`,
+        }, {});
+    });
+}

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

@@ -1,10 +1,10 @@
 import { FlowError } from "../../flow-error.js";
 import { assertGitObservation, requireGitRepository } from "../../git/branches.js";
-import { withLockHeldTaskBoard } from "./task-git-store.js";
+import { assertTaskBoardGeneration, 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 { formatTaskCoordinate } from "./coordinate.js";
+import { createTaskBoardCommit, publishTaskMutationCommit, inspectCurrentBranch, publishForwardTaskBoardCommit, reconcileTaskPathsetIndex, refHead, taskContractAtCommit, taskSourcesAtCommit, taskWritesFromSources, trackedTaskPaths, updateBranch, } from "./settlement-git.js";
 import { contractPointerDocument, doneTaskReplacements, reopenedTaskDocument, requireHealthySettlementBoard, requireSettledTask, selectReadyTasksForBind, tasksForContract, } from "./settlement-policy.js";
 import { stableRepoRoot } from "../worktree-path.js";
 /**
@@ -38,7 +38,7 @@ function ownedTaskPaths(board, taskIds) {
     for (const taskId of taskIds) {
         let current = board.byId.get(taskId);
         while (current) {
-            paths.add(taskPath(current.id));
+            paths.add(taskPath(current.coordinate));
             current = current.parent === null ? undefined : board.byId.get(current.parent);
         }
     }
@@ -83,18 +83,18 @@ function repositoryForSettlement(transaction, sources) {
 async function clearAttemptedPointers(input) {
     return input.repository.mutate((board) => {
         const replacements = input.tasks.flatMap((task) => {
-            const current = requireSettledTask(board, task.id);
+            const current = requireSettledTask(board, task.coordinate);
             return current.contractId === input.contractId
                 ? [contractPointerDocument(current, undefined, input.updatedAt)]
                 : [];
         });
-        return { replacements, select: () => replacements.map((replacement) => replacement.id) };
+        return { replacements, select: () => replacements.map((replacement) => replacement.coordinate ?? replacement.id) };
     });
 }
 async function replaceTaskDocuments(repository, replacements) {
     return repository.mutate(() => ({
         replacements,
-        select: (resulting) => replacements.map((replacement) => requireSettledTask(resulting, replacement.id)),
+        select: (resulting) => replacements.map((replacement) => requireSettledTask(resulting, replacement.coordinate ?? replacement.id)),
     }));
 }
 async function restorePreAdmissionTaskMutations(input) {
@@ -149,9 +149,9 @@ export async function settleTaskBoardForBind(input, deps = {}) {
         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 taskIds = taskBound ? selectedTasks.map((t) => t.coordinate) : undefined;
         const selectedPaths = ownedTaskPaths(await repository.read(), taskIds);
-        const mutationPaths = taskBound ? selectedTasks.map((t) => taskPath(t.id)) : [];
+        const mutationPaths = taskBound ? selectedTasks.map((t) => taskPath(t.coordinate)) : [];
         const selectCurrentSettlement = async () => selectSettlementSources({
             root: transaction.location.root,
             sources: repository.sources(),
@@ -166,7 +166,7 @@ export async function settleTaskBoardForBind(input, deps = {}) {
         try {
             const taskLabel = taskBound
                 ? selectedTasks.length === 1
-                    ? `task ${selectedTasks[0].id}`
+                    ? `task ${selectedTasks[0].coordinate}`
                     : `${selectedTasks.length} tasks`
                 : "";
             firstCommit = await makeBoardCommit({
@@ -182,7 +182,7 @@ export async function settleTaskBoardForBind(input, deps = {}) {
         }
         catch (error) {
             if (taskBound) {
-                await restorePreAdmissionTaskMutations({ transaction, taskIds: selectedTasks.map((task) => task.id), previousSources });
+                await restorePreAdmissionTaskMutations({ transaction, taskIds: selectedTasks.map((task) => task.coordinate), previousSources });
             }
             throw error;
         }
@@ -192,7 +192,7 @@ export async function settleTaskBoardForBind(input, 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));
+                const concurrentMatches = await Promise.all(selectedTasks.map(async (task) => (await taskContractAtCommit(hubCwd, concurrentHead, task.coordinate)) === contractId));
                 if (concurrentMatches.every(Boolean)) {
                     await rollForwardClearAttemptedPointer({
                         repository, selected: selectedTasks, contractId, hubCwd,
@@ -202,7 +202,7 @@ export async function settleTaskBoardForBind(input, deps = {}) {
                     });
                 }
                 else {
-                    await restorePreAdmissionTaskMutations({ transaction, taskIds: selectedTasks.map((task) => task.id), previousSources });
+                    await restorePreAdmissionTaskMutations({ transaction, taskIds: selectedTasks.map((task) => task.coordinate), previousSources });
                 }
             }
             throw error;
@@ -228,7 +228,7 @@ export async function settleTaskBoardForBind(input, deps = {}) {
                 boardCommit: firstCommit,
                 contractId,
                 ledger,
-                ...(taskBound && selectedTasks.length > 0 ? { tasks: selectedTasks.map((t) => requireSettledTask(boardAfter, t.id)) } : {}),
+                ...(taskBound && selectedTasks.length > 0 ? { tasks: selectedTasks.map((t) => requireSettledTask(boardAfter, t.coordinate)) } : {}),
                 evidence: selection.evidence,
             };
         }
@@ -256,207 +256,116 @@ export async function reconcileTaskForfeit(input) {
             }
             throw new FlowError("NOT_GIT_REPO", "task forfeit requires Git task storage");
         }
+        assertTaskBoardGeneration(transaction, input.expectedGeneration);
         const repository = taskRepositoryFromLockedBoard(transaction);
-        const matched = tasksForContract(await repository.read(), input.contractId);
-        const ledger = await input.publishLedger();
-        if (matched.length === 0)
-            return { ledger };
+        const branch = await inspectCurrentBranch(transaction.location.root);
+        const trackedPaths = await trackedTaskPaths(transaction.location.root, branch.head);
+        const branchSources = await taskSourcesAtCommit(transaction.location.root, transaction.location.root, branch.head, trackedPaths);
+        if (!branchSources)
+            throw new FlowError("INTERNAL_STATE", `task branch ${branch.head} lost tracked task sources`);
+        const branchBoard = requireHealthySettlementBoard(taskBoardFromSourceBoard(buildTaskSourceBoard(branchSources)));
+        const matched = tasksForContract(branchBoard, input.contractId);
+        const worktreeMatched = tasksForContract(await repository.read(), input.contractId);
+        if (matched.length === 0 && worktreeMatched.length === 0) {
+            input.observeEffect?.({ effect: "task-source-reconciliation", status: "succeeded", taskCount: 0, detail: "current" });
+            input.observeEffect?.({ effect: "task-reconciliation", status: "succeeded", commit: branch.head, detail: "current" });
+            input.observeEffect?.({ effect: "task-index-reconciliation", status: "succeeded", commit: branch.head });
+            return { ledger: await input.publishLedger() };
+        }
         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`;
+        const prepared = prepareTaskDocumentReplacements(branchSources, reopenedDocuments);
+        const projectionIds = matched.length > 0 ? matched.map((task) => task.coordinate) : worktreeMatched.map((task) => task.coordinate);
+        const branchSourcesByPath = new Map(branchSources.map((source) => [sourcePath(transaction.location.root, source), source]));
+        const writes = matched.length > 0
+            ? prepared.writes
+            : taskWritesFromSources(projectionIds.map((id) => {
+                const source = branchSourcesByPath.get(taskPath(id));
+                if (!source)
+                    throw new FlowError("INTERNAL_STATE", `task ${id} is missing from authoritative task branch ${branch.head}`);
+                return source;
+            }));
+        const reopened = projectionIds.map((id) => requireSettledTask(prepared.board, id));
+        const taskLabel = projectionIds.length === 1 ? `task ${projectionIds[0]}` : `${projectionIds.length} tasks`;
+        let indexSucceeded = false;
         await publishTaskMutationCommit({
             cwd: transaction.location.root,
             gitDir: transaction.location.gitDir,
-            writes: reopenedDocuments.map((document) => ({ id: document.id, text: serializeTaskDocument(document) })),
+            writes,
             subject: `Reopen ${taskLabel} after forfeit of ${input.contractId}`,
+            observeEffect: (effect) => {
+                input.observeEffect?.(effect);
+                if (effect.effect === "task-index-reconciliation" && effect.status === "succeeded")
+                    indexSucceeded = true;
+            },
         });
+        if (!indexSucceeded)
+            throw new FlowError("INTERNAL_STATE", "task index reconciliation failed before forfeit ledger publication");
+        try {
+            await transaction.replace(writes);
+            input.observeEffect?.({ effect: "task-source-reconciliation", status: "succeeded", taskCount: reopened.length, detail: "materialized" });
+        }
+        catch (error) {
+            input.observeEffect?.({ effect: "task-source-reconciliation", status: "failed", error });
+            throw error;
+        }
+        const ledger = await input.publishLedger();
         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");
+/** Replay the claim's folded task selection after target+ledger authority commits. */
+export async function replayClaimTasks(input) {
+    await requireGitRepository(input.cwd, "task claim replay");
     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");
+    return await withLockHeldTaskBoard(hubRoot, async (transaction) => {
+        if (transaction.location.mode !== "git") {
+            if (transaction.location.capability === "unavailable") {
+                assertGitObservation({ capability: "unavailable" }, "task claim replay");
             }
-            // Each attempt reads fresh target and board facts while holding the
-            // common task lock. A losing CAS exits before the next attempt.
+            throw new FlowError("NOT_GIT_REPO", "task claim replay requires Git task storage");
+        }
+        const hubBranch = await inspectCurrentBranch(transaction.location.root);
+        const materializeHub = hubBranch.ref === input.targetRef;
+        const selectedPaths = input.taskIds.map(taskPath);
+        for (let attempt = 0; attempt < 4; attempt += 1) {
             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 paths = await trackedTaskPaths(input.cwd, targetHead);
+            const sources = await taskSourcesAtCommit(input.cwd, transaction.location.root, targetHead, paths);
+            if (!sources)
+                throw new FlowError("INTERNAL_STATE", `claim target ${targetHead} lost tracked task sources`);
+            const board = requireHealthySettlementBoard(taskBoardFromSourceBoard(buildTaskSourceBoard(sources)));
+            const replacements = doneTaskReplacements(board, input.contractId, input.taskIds, input.updatedAt);
+            if (replacements.length === 0) {
+                const selected = new Set(selectedPaths);
+                const writes = taskWritesFromSources(sources.filter((source) => selected.has(sourcePath(transaction.location.root, source))));
+                if (materializeHub) {
+                    if (writes.length > 0)
+                        await transaction.replace(writes);
+                    await reconcileTaskPathsetIndex(transaction.location.root, targetHead, selectedPaths);
                 }
-                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(", ")}`);
+                return { taskCount: input.taskIds.length, commit: targetHead, worktree: materializeHub ? "materialized" : "ref-only" };
             }
-            const candidateTree = await composeLandingTree({
+            const prepared = prepareTaskDocumentReplacements(sources, replacements);
+            const commit = await createTaskBoardCommit({
                 cwd: input.cwd,
                 gitDir: transaction.location.gitDir,
                 root: transaction.location.root,
-                base: input.baseCommit,
-                target: targetHead,
-                delivery: input.deliveryHead,
-                sources: selection.sources,
+                parent: targetHead,
+                sources: prepared.sources,
+                subject: `Complete ${replacements.length === 1 ? `task ${replacements[0].coordinate ?? formatTaskCoordinate(replacements[0].namespace ?? null, replacements[0].id)}` : `${replacements.length} tasks`} after claim of ${input.contractId}`,
             });
-            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);
+                await updateBranch({ cwd: input.cwd, ref: input.targetRef, next: commit, expected: targetHead }, {});
+                if (materializeHub) {
+                    await transaction.replace(prepared.writes);
+                    await reconcileTaskPathsetIndex(transaction.location.root, commit, selectedPaths);
+                }
+                return { taskCount: input.taskIds.length, commit, worktree: materializeHub ? "materialized" : "ref-only" };
             }
             catch (error) {
-                lastPostCasError = error;
-                return { kind: "retry" };
+                if (attempt === 3)
+                    throw error;
             }
-            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}`);
+        throw new FlowError("CONCURRENT_MODIFICATION", `claim target ${input.targetRef} kept moving during task replay`);
+    });
 }