@astrosheep/keiyaku 2.9.2 → 2.9.4

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

@@ -0,0 +1,370 @@
+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 { containsCommit, createLandingCommit, createTaskBoardCommit, publishTaskMutationCommit, inspectCurrentBranch, publishForwardTaskBoardCommit, readableRefHead, reconcileTaskPathsetIndex, refHead, taskContractAtCommit, 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)] : [];
+        });
+        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,
+    });
+    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 = {}) {
+    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)));
+        }
+        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,
+                    });
+                }
+                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,
+                });
+            }
+            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,
+            });
+            throw publishError;
+        }
+    }, { signal: input.signal });
+}
+export async function reconcileTaskForfeit(input) {
+    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(reopenedTaskDocument);
+        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) {
+    await requireGitRepository(input.cwd, "task landing");
+    const hubRoot = await stableRepoRoot(input.cwd);
+    let lastTargetHead = input.targetHead;
+    let lastPublishError;
+    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 repository = repositoryForSettlement(transaction, transaction.sources);
+            const board = requireHealthySettlementBoard(await repository.read());
+            const replacements = doneTaskReplacements(board, input.contractId);
+            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)),
+            });
+            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 warnings = [];
+            if (replacements.length > 0) {
+                await transaction.replace(taskWritesFromSources(selection.sources));
+            }
+            try {
+                await reconcileTaskPathsetIndex(transaction.location.root, mergeCommit, selection.evidence.selectedPaths);
+            }
+            catch (error) {
+                warnings.push(`Accepted landing ${mergeCommit}, but task index reconciliation failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            try {
+                await input.publishLedger?.(mergeCommit);
+            }
+            catch (error) {
+                lastPublishError = error;
+                return { kind: "retry" };
+            }
+            const reconcileWarnings = movement
+                ? await input.afterCas?.(mergeCommit, movement.oldHead)
+                : undefined;
+            warnings.push(...(reconcileWarnings ?? []));
+            return {
+                kind: movement ? "accepted" : "idempotent",
+                mergeCommit,
+                ...(movement ? { 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 (lastPublishError !== undefined)
+        throw lastPublishError;
+    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";

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

@@ -1,15 +1,21 @@
 import { randomBytes } from "node:crypto";
-import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { FlowError } from "../flow-error.js";
-import { isGitExecutableUnavailable, NOT_GIT_REPOSITORY_PATTERNS } from "../git/core.js";
-import { gitCommonRootPath, normalizeGitPath } from "./path-coordinate.js";
-const TASK_ID = /^k-[0-9a-f]{12}$/;
+import { setTimeout as delay } from "node:timers/promises";
+import { FlowError } from "../../flow-error.js";
+import { syncDirectorySync } from "../../fs/durability.js";
+import { normalizeFilesystemCoordinate } from "../../fs/path-coordinate.js";
+import { isGitExecutableUnavailable, NOT_GIT_REPOSITORY_PATTERNS, runGitProcess } from "../../git/core.js";
+import { gitCommonRootPath, normalizeGitPath } from "../../git/path-coordinate.js";
+import { inspectCurrentBranch, publishTaskMutationCommit } from "./settlement-git.js";
+import { isTaskId } from "./validation.js";
 const SQLITE_BUSY = 5;
 const LOCK_FILE = "task-lock.sqlite";
 const GIT_LOCK_FILE = "keiyaku-task-lock.sqlite";
+export const TASK_LOCK_ADMISSION_TIMEOUT_MS = 4_000;
+export const TASK_LOCK_ADMISSION_INITIAL_DELAY_MS = 10;
+export const TASK_LOCK_ADMISSION_MAX_DELAY_MS = 100;
 export class TaskLockHeldError extends Error {
     path;
     code = "TASK_LOCK_HELD";
@@ -19,6 +25,16 @@ export class TaskLockHeldError extends Error {
         this.name = "TaskLockHeldError";
     }
 }
+export class TaskLockAdmissionTimeoutError extends FlowError {
+    path;
+    timeoutMs;
+    constructor(path, timeoutMs, options) {
+        super("TASK_LOCK_ADMISSION_TIMEOUT", `task lock admission timed out after ${timeoutMs}ms: ${path}`, { cause: options?.cause });
+        this.path = path;
+        this.timeoutMs = timeoutMs;
+        this.name = "TaskLockAdmissionTimeoutError";
+    }
+}
 function errorText(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -28,17 +44,11 @@ function isSqliteBusy(error) {
         && "errcode" in error
         && error.errcode === SQLITE_BUSY;
 }
-function defaultRunGit(cwd, args, input) {
-    return spawnSync("git", [...args], {
-        cwd,
-        input,
-        encoding: "utf8",
-        env: { ...process.env, GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" },
-        stdio: ["pipe", "pipe", "pipe"],
-    });
+async function defaultRunGit(cwd, args, input) {
+    return await runGitProcess(cwd, args, { input });
 }
 function nearestDirectoryBoard(cwd) {
-    const original = path.resolve(cwd);
+    const original = path.resolve(normalizeFilesystemCoordinate(cwd));
     let candidate = original;
     while (true) {
         if (lstatIfPresent(path.join(candidate, ".keiyaku")))
@@ -53,7 +63,8 @@ export function taskBoardRootFromGitDir(rawGitDir, platform = process.platform)
     return gitCommonRootPath(rawGitDir, platform);
 }
 export async function locateTaskBoard(cwd, runGitProbe = defaultRunGit) {
-    const probe = runGitProbe(cwd, ["rev-parse", "--is-inside-work-tree", "--is-bare-repository"]);
+    cwd = normalizeFilesystemCoordinate(cwd);
+    const probe = await runGitProbe(cwd, ["rev-parse", "--is-inside-work-tree", "--is-bare-repository"]);
     if (probe.error && !isGitExecutableUnavailable(probe.error)) {
         throw new FlowError("INTERNAL_STATE", `cannot inspect task repository: ${probe.error.message}`, { cause: probe.error });
     }
@@ -71,7 +82,7 @@ export async function locateTaskBoard(cwd, runGitProbe = defaultRunGit) {
     if (bare === "true" || insideWorktree !== "true") {
         throw new FlowError("NOT_GIT_REPO", "bare repositories are not supported for task storage");
     }
-    const facts = runGitProbe(cwd, ["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir"]);
+    const facts = await runGitProbe(cwd, ["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir"]);
     if (facts.error) {
         throw new FlowError("INTERNAL_STATE", `git rev-parse failed: ${facts.error.message}`, { cause: facts.error });
     }
@@ -138,6 +149,31 @@ function acquireTaskLock(lockPath) {
         throw new FlowError("INTERNAL_STATE", `cannot acquire task lock: ${errorText(error)}`, { cause: error });
     }
 }
+async function acquireTaskLockWithAdmission(lockPath, deps) {
+    const now = deps.now ?? Date.now;
+    const random = deps.random ?? Math.random;
+    const sleep = deps.sleep ?? ((milliseconds, signal) => (delay(milliseconds, undefined, signal ? { signal } : undefined)));
+    const deadline = now() + TASK_LOCK_ADMISSION_TIMEOUT_MS;
+    let delayCapMs = TASK_LOCK_ADMISSION_INITIAL_DELAY_MS;
+    for (;;) {
+        deps.signal?.throwIfAborted();
+        try {
+            return acquireTaskLock(lockPath);
+        }
+        catch (error) {
+            if (!(error instanceof TaskLockHeldError))
+                throw error;
+            const observedAt = now();
+            if (observedAt >= deadline) {
+                throw new TaskLockAdmissionTimeoutError(lockPath, TASK_LOCK_ADMISSION_TIMEOUT_MS, { cause: error });
+            }
+            const unit = Math.max(0, Math.min(1, random()));
+            const jitteredDelayMs = Math.ceil((delayCapMs / 2) + ((delayCapMs / 2) * unit));
+            await sleep(Math.min(jitteredDelayMs, deadline - observedAt), deps.signal);
+            delayCapMs = Math.min(TASK_LOCK_ADMISSION_MAX_DELAY_MS, delayCapMs * 2);
+        }
+    }
+}
 export async function inspectTaskLock(cwd) {
     const lockPath = taskLockPath(await locateTaskBoard(cwd));
     if (!fs.existsSync(lockPath))
@@ -177,7 +213,7 @@ export function atomicReplaceTaskFile(filePath, text, _deps) {
         fs.closeSync(descriptor);
         descriptor = undefined;
         fs.renameSync(temporary, filePath);
-        fsyncDirectory(directory);
+        syncDirectorySync(directory);
     }
     catch (error) {
         if (descriptor !== undefined) {
@@ -193,15 +229,6 @@ export function atomicReplaceTaskFile(filePath, text, _deps) {
         throw error;
     }
 }
-function fsyncDirectory(directory) {
-    const descriptor = fs.openSync(directory, fs.constants.O_RDONLY);
-    try {
-        fs.fsyncSync(descriptor);
-    }
-    finally {
-        fs.closeSync(descriptor);
-    }
-}
 function lstatIfPresent(target) {
     try {
         return fs.lstatSync(target);
@@ -244,7 +271,7 @@ function validateWrites(writes) {
     const targets = new Set();
     for (const write of writes) {
         const target = `${write.id}.md`;
-        if (!TASK_ID.test(write.id)) {
+        if (!isTaskId(write.id)) {
             throw new FlowError("INTERNAL_STATE", `invalid task mutation id: ${write.id}`);
         }
         if (targets.has(target))
@@ -276,7 +303,7 @@ function sameSources(left, right) {
 function removeTaskFile(filePath) {
     try {
         fs.unlinkSync(filePath);
-        fsyncDirectory(path.dirname(filePath));
+        syncDirectorySync(path.dirname(filePath));
     }
     catch (error) {
         if (error.code !== "ENOENT")
@@ -329,9 +356,32 @@ export async function openTaskStore(cwd, deps = {}) {
         },
         async mutate(apply) {
             return withLockHeldTaskBoard(cwd, async (transaction) => {
+                const previousSources = transaction.sources;
                 const plan = await apply(transaction.sources);
                 validatePlan(plan);
+                let subject;
+                if (transaction.location.mode === "git") {
+                    subject = plan.subject?.trim();
+                    if (!subject) {
+                        throw new FlowError("INTERNAL_STATE", "git task mutation requires a micro-commit subject");
+                    }
+                    await inspectCurrentBranch(transaction.location.root);
+                }
                 await transaction.replace(plan.writes);
+                if (transaction.location.mode === "git") {
+                    try {
+                        await (deps.publishMutation ?? publishTaskMutationCommit)({
+                            cwd: transaction.location.root,
+                            gitDir: transaction.location.gitDir,
+                            writes: plan.writes,
+                            subject: subject,
+                        });
+                    }
+                    catch (error) {
+                        await transaction.restore(plan.writes, previousSources);
+                        throw error;
+                    }
+                }
                 return plan.value;
             }, deps, board);
         },
@@ -341,7 +391,7 @@ export async function withLockHeldTaskBoard(cwd, apply, deps = {}, locatedBoard)
     const board = locatedBoard ?? await locateTaskBoard(cwd, deps.runGit);
     const directory = taskDirectory(board);
     assertKeiyakuDirectory(board);
-    const database = acquireTaskLock(taskLockPath(board));
+    const database = await acquireTaskLockWithAdmission(taskLockPath(board), deps);
     try {
         let sources = await readTaskSources(directory);
         const transaction = {
@@ -376,6 +426,19 @@ export async function withLockHeldTaskBoard(cwd, apply, deps = {}, locatedBoard)
                 }
                 sources = await readTaskSources(directory);
             },
+            async restore(writes, previousSources) {
+                validateWrites(writes);
+                const currentSources = await readTaskSources(directory);
+                if (!sameSources(sources, currentSources)) {
+                    throw new FlowError("CONCURRENT_MODIFICATION", "task sources changed while rolling back a failed publication");
+                }
+                const previousById = new Map(previousSources.map((source) => [path.basename(source.path, ".md"), source.text]));
+                restoreFiles(writes.map((write) => ({
+                    path: path.join(directory, mutationTarget(write)),
+                    text: previousById.get(write.id),
+                })), deps);
+                sources = await readTaskSources(directory);
+            },
         };
         return await apply(transaction);
     }

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

@@ -0,0 +1 @@
+export {};

package/build/core/{task-store-repository.js → task/task-store-repository.js}

@@ -1,7 +1,7 @@
-import { requireHealthy } from "./task/board.js";
-import { parseTaskDocument, serializeTaskDocument } from "./task/document.js";
-import { buildTaskSourceBoard } from "./task/source-board.js";
-function taskBoardFromSourceBoard(sourceBoard) {
+import { requireHealthy } from "./board.js";
+import { parseTaskDocument, serializeTaskDocument } from "./document.js";
+import { buildTaskSourceBoard } from "./source-board.js";
+export function taskBoardFromSourceBoard(sourceBoard) {
     const tasks = sourceBoard.tasks.map((task) => ({
         id: task.id,
         title: task.title,
@@ -66,6 +66,7 @@ function mutationPlan(sources, mutation) {
     return {
         writes: prepared.writes,
         value: mutation.select(prepared.board),
+        ...(mutation.subject === undefined ? {} : { subject: mutation.subject }),
     };
 }
 export function taskRepositoryFromStore(store) {

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

@@ -0,0 +1 @@
+export {};