@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -1,371 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { assertGitObservation, requireGitRepository } from "../../git/branches.js";
-import { assertTaskBoardGeneration, withLockHeldTaskBoard, } from "./task-git-store.js";
-import { prepareTaskDocumentReplacements, taskBoardFromSourceBoard, taskRepositoryFromLockedBoard } from "./task-store-repository.js";
-import { buildTaskSourceBoard } from "./source-board.js";
-import { formatTaskCoordinate } from "./coordinate.js";
-import { createTaskBoardCommit, publishTaskMutationCommit, inspectCurrentBranch, publishForwardTaskBoardCommit, reconcileTaskPathsetIndex, refHead, taskContractAtCommit, taskSourcesAtCommit, taskWritesFromSources, trackedTaskPaths, updateBranch, } from "./settlement-git.js";
-import { boundTaskDocument, contractPointerDocument, doneTaskReplacements, reopenedTaskDocument, requireHealthySettlementBoard, requireSettledTask, selectReadyTasksForBind, tasksForContract, } from "./settlement-policy.js";
-import { stableRepoRoot } from "../worktree-path.js";
-/**
- * Read the same healthy task board and run the same ready-task selector as bind
- * under the task admission lock, without replacing sources or publishing.
- */
-export async function previewTaskBoardForBind(input) {
-    await requireGitRepository(input.cwd, "task bind");
-    return await 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 repository = taskRepositoryFromLockedBoard(transaction);
-        const board = requireHealthySettlementBoard(await repository.read());
-        return { tasks: input.taskIds === undefined ? [] : selectReadyTasksForBind(board, input.taskIds) };
-    });
-}
-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.coordinate));
-            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.coordinate);
-            return current.contractId === input.contractId
-                ? [contractPointerDocument(current, undefined, input.updatedAt)]
-                : [];
-        });
-        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.coordinate ?? 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) => boundTaskDocument(task, contractId, updatedAt)));
-        }
-        const taskIds = taskBound ? selectedTasks.map((t) => t.coordinate) : undefined;
-        const selectedPaths = ownedTaskPaths(await repository.read(), taskIds);
-        const mutationPaths = taskBound ? selectedTasks.map((t) => taskPath(t.coordinate)) : [];
-        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].coordinate}`
-                    : `${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.coordinate), 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.coordinate)) === 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.coordinate), 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.coordinate)) } : {}),
-                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");
-        }
-        assertTaskBoardGeneration(transaction, input.expectedGeneration);
-        const repository = taskRepositoryFromLockedBoard(transaction);
-        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 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,
-            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 };
-    });
-}
-/** 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);
-    return await withLockHeldTaskBoard(hubRoot, async (transaction) => {
-        if (transaction.location.mode !== "git") {
-            if (transaction.location.capability === "unavailable") {
-                assertGitObservation({ capability: "unavailable" }, "task claim replay");
-            }
-            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);
-            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);
-                }
-                return { taskCount: input.taskIds.length, commit: targetHead, worktree: materializeHub ? "materialized" : "ref-only" };
-            }
-            const prepared = prepareTaskDocumentReplacements(sources, replacements);
-            const commit = await createTaskBoardCommit({
-                cwd: input.cwd,
-                gitDir: transaction.location.gitDir,
-                root: transaction.location.root,
-                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}`,
-            });
-            try {
-                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) {
-                if (attempt === 3)
-                    throw error;
-            }
-        }
-        throw new FlowError("CONCURRENT_MODIFICATION", `claim target ${input.targetRef} kept moving during task replay`);
-    });
-}

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

@@ -1,14 +0,0 @@
-import { rollbackOrphanTaskPointers } from "./task.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();
-    const board = buildTaskSourceBoard(sources);
-    return {
-        board,
-        sources,
-        orphans,
-        landingDiagnostics: facts.landingDiagnostics ?? [],
-        lockHeld: facts.lockHeld === true,
-    };
-}

package/build/core/task/task-file-transaction.js

@@ -1,171 +0,0 @@
-import { createHash, randomBytes } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { FlowError } from "../../flow-error.js";
-import { syncDirectorySync } from "../../fs/durability.js";
-import { isTaskCoordinate } from "./coordinate.js";
-export function atomicReplaceTaskFile(filePath, text, _deps) {
-    const directory = path.dirname(filePath);
-    fs.mkdirSync(directory, { recursive: true });
-    const temporary = path.join(directory, `.${path.basename(filePath)}.${process.pid}.${randomBytes(12).toString("hex")}.tmp`);
-    let descriptor;
-    try {
-        descriptor = fs.openSync(temporary, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o644);
-        fs.writeFileSync(descriptor, text, { encoding: "utf8" });
-        fs.fsyncSync(descriptor);
-        fs.closeSync(descriptor);
-        descriptor = undefined;
-        fs.renameSync(temporary, filePath);
-        syncDirectorySync(directory);
-    }
-    catch (error) {
-        if (descriptor !== undefined) {
-            try {
-                fs.closeSync(descriptor);
-            }
-            catch { /* preserve original failure */ }
-        }
-        try {
-            fs.unlinkSync(temporary);
-        }
-        catch { /* absent after rename or already cleaned */ }
-        throw error;
-    }
-}
-function lstatIfPresent(target) {
-    try {
-        return fs.lstatSync(target);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return undefined;
-        throw error;
-    }
-}
-export function validateTaskMutationWrites(writes) {
-    if (writes.length === 0) {
-        throw new FlowError("INTERNAL_STATE", "task mutation must contain at least one write");
-    }
-    const targets = new Set();
-    for (const write of writes) {
-        const target = `${write.id}.md`;
-        if (!isTaskCoordinate(write.id)) {
-            throw new FlowError("INTERNAL_STATE", `invalid task mutation coordinate: ${write.id}`);
-        }
-        if (targets.has(target))
-            throw new FlowError("INTERNAL_STATE", `duplicate task mutation target: ${target}`);
-        targets.add(target);
-    }
-}
-function mutationTarget(write) {
-    return `${write.id}.md`;
-}
-function capturePreviousFiles(directory, writes) {
-    return writes.map((write) => {
-        const destination = path.join(directory, mutationTarget(write));
-        const stat = lstatIfPresent(destination);
-        if (!stat)
-            return { path: destination };
-        if (stat.isSymbolicLink() || !stat.isFile()) {
-            throw new FlowError("INTERNAL_STATE", `task destination is not a regular file: ${destination}`);
-        }
-        return { path: destination, text: fs.readFileSync(destination, "utf8") };
-    });
-}
-export function sameSources(left, right) {
-    return left.length === right.length && left.every((source, index) => {
-        const candidate = right[index];
-        return candidate !== undefined && source.path === candidate.path && source.text === candidate.text;
-    });
-}
-export function generationFor(location, sources) {
-    const digest = createHash("sha256").update("keiyaku-task-board-v1\0");
-    for (const source of [...sources].sort((left, right) => Buffer.from(left.path).compare(Buffer.from(right.path)))) {
-        const relativePath = path.relative(location.mode === "git" ? location.surfaceRoot : location.root, source.path).split(path.sep).join("/");
-        digest.update(String(Buffer.byteLength(relativePath))).update(":").update(relativePath);
-        digest.update(String(Buffer.byteLength(source.text))).update(":").update(source.text);
-    }
-    return { root: location.root, fingerprint: digest.digest("hex") };
-}
-export function taskBoardGeneration(transaction) {
-    return generationFor(transaction.location, transaction.sources);
-}
-export function assertTaskBoardGeneration(transaction, expected) {
-    const current = taskBoardGeneration(transaction);
-    if (current.root === expected.root && current.fingerprint === expected.fingerprint)
-        return;
-    throw new FlowError("CONCURRENT_MODIFICATION", "task board generation changed during lifecycle preparation", {
-        facts: { kind: "task_board_generation_changed", expected, current },
-    });
-}
-function removeTaskFile(filePath) {
-    try {
-        fs.unlinkSync(filePath);
-        syncDirectorySync(path.dirname(filePath));
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-}
-function restoreFiles(previous, deps) {
-    for (const entry of previous) {
-        if (entry.text === undefined)
-            removeTaskFile(entry.path);
-        else
-            (deps.atomicReplace ?? atomicReplaceTaskFile)(entry.path, entry.text);
-    }
-}
-function writeTaskFile(directory, write, deps) {
-    const destination = path.join(directory, mutationTarget(write));
-    (deps.atomicReplace ?? atomicReplaceTaskFile)(destination, write.text);
-}
-function assertTaskDirectorySafety(directory) {
-    const stat = lstatIfPresent(directory);
-    if (stat && (stat.isSymbolicLink() || !stat.isDirectory())) {
-        throw new FlowError("INTERNAL_STATE", `task directory is not a regular directory: ${directory}`);
-    }
-}
-export function createTaskFileTransaction(input) {
-    return {
-        location: input.location,
-        get sources() { return input.getSources(); },
-        async replace(writes) {
-            validateTaskMutationWrites(writes);
-            input.assertBoardSafety();
-            assertTaskDirectorySafety(input.directory);
-            const currentSources = await input.readSources();
-            if (!sameSources(input.getSources(), currentSources)) {
-                throw new FlowError("CONCURRENT_MODIFICATION", "task sources changed while applying the mutation");
-            }
-            input.assertBoardSafety();
-            assertTaskDirectorySafety(input.directory);
-            const previous = capturePreviousFiles(input.directory, writes);
-            let applied = 0;
-            try {
-                for (const write of writes) {
-                    writeTaskFile(input.directory, write, input.deps);
-                    applied += 1;
-                }
-            }
-            catch (error) {
-                try {
-                    restoreFiles(previous.slice(0, applied + 1), input.deps);
-                }
-                catch { /* the original replacement failure remains authoritative */ }
-                throw error;
-            }
-            input.setSources(await input.readSources());
-        },
-        async restore(writes, previousSources) {
-            validateTaskMutationWrites(writes);
-            const currentSources = await input.readSources();
-            if (!sameSources(input.getSources(), currentSources)) {
-                throw new FlowError("CONCURRENT_MODIFICATION", "task sources changed while rolling back a failed publication");
-            }
-            const previousById = new Map(previousSources.map((source) => [path.relative(input.directory, source.path).slice(0, -3).split(path.sep).join("/"), source.text]));
-            restoreFiles(writes.map((write) => ({ path: path.join(input.directory, mutationTarget(write)), text: previousById.get(write.id) })), input.deps);
-            input.setSources(await input.readSources());
-        },
-    };
-}

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

@@ -1,33 +0,0 @@
-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"];
-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 async function resolveTaskCreator(cwd, deps = {}) {
-    const sourceEnv = deps.env ?? process.env;
-    const environmentActor = attribution(sourceEnv[TASK_ACTOR_ENV]);
-    if (environmentActor)
-        return environmentActor;
-    const gitEnv = { ...sourceEnv, GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" };
-    const runGit = deps.runGit ?? defaultRunGit;
-    for (const key of GIT_ACTOR_KEYS) {
-        try {
-            const result = await runGit(cwd, ["config", "--get", key], gitEnv);
-            if (!result.error && result.status === 0) {
-                const configuredActor = attribution(result.stdout);
-                if (configuredActor)
-                    return configuredActor;
-            }
-        }
-        catch {
-            // Creator attribution is advisory and must not prevent task creation.
-        }
-    }
-    return ANONYMOUS_TASK_CREATOR;
-}