@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/task/query.js

@@ -1,204 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { isCommissionId } from "../ids.js";
-import { taskUpdatedAt } from "./model.js";
-import { isTaskCoordinate } from "./coordinate.js";
-import { parseStructuredQuery, STRUCTURED_QUERY_COMPLETION, STRUCTURED_QUERY_GRAMMAR, } from "../structured-query.js";
-export const TASK_FILTER_FIELDS = [
-    "title", "state", "priority", "parent", "needs", "blocks", "contract", "created", "updated",
-];
-export const TASK_FILTER_OPERATORS = ["=", "!=", "~", "<", "<=", ">", ">="];
-export const TASK_FILTER_GRAMMAR = STRUCTURED_QUERY_GRAMMAR;
-export const TASK_FILTER_COMPLETION = STRUCTURED_QUERY_COMPLETION;
-const FILTER_FIELDS = new Set(TASK_FILTER_FIELDS);
-const ORDERED_FIELDS = new Set(["priority", "created", "updated"]);
-const TITLE_OPERATORS = new Set(["=", "!=", "~"]);
-const ORDERED_OPERATORS = new Set(["=", "!=", "<", "<=", ">", ">="]);
-const DISPLAY_VALUES = new Set(["ready", "blocked", "in_progress", "on_hold", "done", "dropped", "bound"]);
-const SORT_KEYS = new Set(["priority", "modified", "created"]);
-const RELATIVE_TIME = /^now-([1-9][0-9]*)([smhdw])$/;
-const UNIT_MS = { s: 1_000, m: 60_000, h: 3_600_000, d: 86_400_000, w: 604_800_000 };
-export function deriveTaskDisplay(task) {
-    if (task.state === "done")
-        return "done";
-    if (task.state === "drop")
-        return "dropped";
-    if (task.state === "on_hold")
-        return "on_hold";
-    if (task.contractId !== undefined)
-        return "bound";
-    if (task.state === "in_progress")
-        return "in_progress";
-    return task.blocked ? "blocked" : "ready";
-}
-function invalidFilter(detail, recoveredTerms = []) {
-    throw new FlowError("INVALID_TARGET", `invalid task filter: ${detail}`, {
-        facts: {
-            kind: "invalid_task_filter",
-            detail,
-            grammar: TASK_FILTER_GRAMMAR,
-            fields: [...TASK_FILTER_FIELDS],
-            operators: [...TASK_FILTER_OPERATORS],
-            recoveredTerms: recoveredTerms.map((term) => ({
-                field: term.field,
-                operator: term.operator,
-                values: [...term.values],
-            })),
-        },
-    });
-}
-function validateTaskFilterTerm(field, operator, values, recoveredTerms) {
-    if (field === "title" && !TITLE_OPERATORS.has(operator)) {
-        invalidFilter(`field '${field}' does not support operator '${operator}'`, recoveredTerms);
-    }
-    if (field !== "title" && (ORDERED_FIELDS.has(field)
-        ? !ORDERED_OPERATORS.has(operator)
-        : operator !== "=" && operator !== "!=")) {
-        invalidFilter(`field '${field}' does not support operator '${operator}'`, recoveredTerms);
-    }
-    validateFilterValues(field, values, recoveredTerms);
-}
-export function parseTaskFilter(expression) {
-    return parseStructuredQuery({
-        expression,
-        fields: FILTER_FIELDS,
-        invalid: invalidFilter,
-        validate: validateTaskFilterTerm,
-    });
-}
-function parseTimestamp(value, nowMs, recoveredTerms = []) {
-    const relative = RELATIVE_TIME.exec(value);
-    if (relative) {
-        const amount = Number(relative[1]);
-        const offset = amount * UNIT_MS[relative[2]];
-        if (!Number.isSafeInteger(offset))
-            invalidFilter(`timestamp '${value}' is outside the supported range`, recoveredTerms);
-        return nowMs - offset;
-    }
-    const timestamp = Date.parse(value);
-    if (!Number.isFinite(timestamp) || new Date(timestamp).toISOString() !== value) {
-        invalidFilter(`timestamp '${value}' must be canonical ISO-8601 or now-<duration>`, recoveredTerms);
-    }
-    return timestamp;
-}
-function validateFilterValues(field, values, recoveredTerms) {
-    if (field === "title")
-        return;
-    if (field === "state") {
-        for (const value of values)
-            if (!DISPLAY_VALUES.has(value))
-                invalidFilter(`unknown state '${value}'`, recoveredTerms);
-        return;
-    }
-    if (field === "priority") {
-        for (const value of values)
-            if (!/^[0-3]$/.test(value))
-                invalidFilter(`priority '${value}' must be 0 through 3`, recoveredTerms);
-        return;
-    }
-    if (field === "created" || field === "updated") {
-        for (const value of values)
-            parseTimestamp(value, 0, recoveredTerms);
-        return;
-    }
-    if (field === "parent" || field === "needs" || field === "blocks") {
-        for (const value of values) {
-            if (field === "parent" && value === "none")
-                continue;
-            if (!isTaskCoordinate(value))
-                invalidFilter(`value '${value}' must be a canonical full task coordinate`, recoveredTerms);
-        }
-        return;
-    }
-    if (field === "contract") {
-        for (const value of values) {
-            if (value !== "none" && !isCommissionId(value))
-                invalidFilter(`value '${value}' must be a full commission id or none`, recoveredTerms);
-        }
-    }
-}
-export function parseTaskSort(value) {
-    if (value === undefined)
-        return undefined;
-    const keys = value.split(",");
-    if (keys.some((key) => !SORT_KEYS.has(key))) {
-        const invalid = keys.find((key) => !SORT_KEYS.has(key));
-        throw new FlowError("INVALID_TARGET", `invalid task sort key '${String(invalid)}'; expected priority, modified, or created`);
-    }
-    if (new Set(keys).size !== keys.length) {
-        throw new FlowError("INVALID_TARGET", "task sort keys must not repeat");
-    }
-    return keys;
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function compareValue(left, right, operator) {
-    switch (operator) {
-        case "=": return left === right;
-        case "!=": return left !== right;
-        case "<": return left < right;
-        case "<=": return left <= right;
-        case ">": return left > right;
-        case ">=": return left >= right;
-        case "~": return false;
-    }
-}
-function matchesFilter(task, filter, nowMs) {
-    return filter.values.some((raw) => {
-        if (filter.field === "title") {
-            if (filter.operator === "~")
-                return task.title.toLowerCase().includes(raw.toLowerCase());
-            return compareValue(task.title, raw, filter.operator);
-        }
-        if (filter.field === "state")
-            return compareValue(deriveTaskDisplay(task), raw, filter.operator);
-        if (filter.field === "priority")
-            return compareValue(task.pri, Number(raw), filter.operator);
-        if (filter.field === "created")
-            return compareValue(Date.parse(task.createdAt), parseTimestamp(raw, nowMs), filter.operator);
-        if (filter.field === "updated")
-            return compareValue(Date.parse(taskUpdatedAt(task)), parseTimestamp(raw, nowMs), filter.operator);
-        const expected = raw === "none" ? null : raw;
-        if (filter.field === "parent")
-            return compareValue(task.parent ?? "\0", expected ?? "\0", filter.operator);
-        if (filter.field === "contract")
-            return compareValue(task.contractId ?? "\0", expected ?? "\0", filter.operator);
-        const relations = filter.field === "needs" ? task.needs : task.blocks;
-        return filter.operator === "=" ? relations.includes(raw) : !relations.includes(raw);
-    });
-}
-function selected(task, selection) {
-    const terminal = task.state === "done" || task.state === "drop";
-    return selection === "all" || (selection === "done" ? terminal : !terminal);
-}
-function displayOrder(task) {
-    const display = deriveTaskDisplay(task);
-    return display === "in_progress" ? 0 : display === "on_hold" ? 1 : display === "ready" ? 2 : display === "blocked" ? 3 : display === "bound" ? 4 : display === "done" ? 5 : 6;
-}
-function defaultCompare(left, right) {
-    return displayOrder(left) - displayOrder(right)
-        || left.pri - right.pri
-        || compareText(left.createdAt, right.createdAt)
-        || compareText(left.id, right.id);
-}
-function explicitCompare(keys, left, right) {
-    for (const key of keys) {
-        const difference = key === "priority"
-            ? left.pri - right.pri
-            : key === "modified"
-                ? compareText(taskUpdatedAt(right), taskUpdatedAt(left))
-                : compareText(right.createdAt, left.createdAt);
-        if (difference !== 0)
-            return difference;
-    }
-    return compareText(left.id, right.id);
-}
-export function selectTaskList(tasks, options = {}) {
-    const filters = (options.filters ?? []).map(parseTaskFilter);
-    const sort = parseTaskSort(options.sort);
-    const nowMs = options.nowMs ?? Date.now();
-    return tasks
-        .filter((task) => selected(task, options.selection ?? "default"))
-        .filter((task) => filters.every((filter) => filter.some((term) => matchesFilter(task, term, nowMs))))
-        .sort(sort === undefined ? defaultCompare : (left, right) => explicitCompare(sort, left, right));
-}

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

@@ -1,423 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { FlowError } from "../../flow-error.js";
-import { runGitProcess } from "../../git/core.js";
-import { openGitStreamingBatch } from "../../git/streaming-batch.js";
-import { parseTaskDocument } from "./task.js";
-import { parseTaskCoordinate } from "./coordinate.js";
-function observePublicationEffect(observer, effect) {
-    try {
-        observer?.(effect);
-    }
-    catch { /* observation cannot participate in the Git transaction */ }
-}
-async function gitResult(cwd, args, input, env, signal) {
-    return await runGitProcess(cwd, args, { input, env, signal });
-}
-async function git(cwd, args, input, env, signal) {
-    const result = await gitResult(cwd, args, input, env, signal);
-    if (result.error) {
-        if (result.error.name === "AbortError")
-            throw result.error;
-        throw new FlowError("INTERNAL_STATE", `git ${args[0]} failed: ${result.error.message}`, { cause: result.error });
-    }
-    if (result.status !== 0) {
-        throw new FlowError("INTERNAL_STATE", `git ${args[0]} failed: ${result.stderr.trim() || `exit ${String(result.status)}`}`);
-    }
-    return result.stdout;
-}
-function boardPath(root, source) {
-    const relative = path.relative(root, source.path).split(path.sep).join("/");
-    if (!relative.startsWith(".keiyaku/tasks/") || relative.includes("..")) {
-        throw new FlowError("INTERNAL_STATE", `task source is outside the board: ${source.path}`);
-    }
-    return relative;
-}
-export async function inspectCurrentBranch(cwd, signal) {
-    const branch = await gitResult(cwd, ["symbolic-ref", "--quiet", "HEAD"], undefined, undefined, signal);
-    if (branch.error) {
-        if (branch.error.name === "AbortError")
-            throw branch.error;
-        throw new FlowError("INTERNAL_STATE", `cannot inspect HEAD: ${branch.error.message}`, { cause: branch.error });
-    }
-    if (branch.status !== 0 || branch.stdout.trim() === "") {
-        throw new FlowError("DETACHED_HEAD", "cannot publish task board from detached HEAD");
-    }
-    return { ref: branch.stdout.trim(), head: (await git(cwd, ["rev-parse", "HEAD"], undefined, undefined, signal)).trim() };
-}
-export async function createTaskBoardCommit(input) {
-    const temporaryDirectory = fs.mkdtempSync(path.join(input.gitDir, "keiyaku-task-index-"));
-    const indexPath = path.join(temporaryDirectory, "index");
-    const env = { GIT_INDEX_FILE: indexPath };
-    try {
-        await git(input.cwd, ["read-tree", input.parent], undefined, env);
-        for (const source of input.sources) {
-            const oid = (await git(input.cwd, ["hash-object", "-w", "--stdin"], source.text)).trim();
-            await git(input.cwd, ["update-index", "--add", "--cacheinfo", `100644,${oid},${boardPath(input.root, source)}`], undefined, env);
-        }
-        const tree = (await git(input.cwd, ["write-tree"], undefined, env)).trim();
-        return (await git(input.cwd, ["commit-tree", tree, "-p", input.parent, "-m", input.subject])).trim();
-    }
-    finally {
-        fs.rmSync(temporaryDirectory, { recursive: true, force: true });
-    }
-}
-function taskMutationPath(write) {
-    return `.keiyaku/tasks/${write.id}.md`;
-}
-/** Build a commit that updates only the listed task paths on top of parent. */
-export async function createTaskMutationCommit(input) {
-    if (input.writes.length === 0) {
-        throw new FlowError("INTERNAL_STATE", "task mutation commit requires at least one write");
-    }
-    const temporaryDirectory = fs.mkdtempSync(path.join(input.gitDir, "keiyaku-task-index-"));
-    const env = { GIT_INDEX_FILE: path.join(temporaryDirectory, "index") };
-    try {
-        await git(input.cwd, ["read-tree", input.parent], undefined, env, input.signal);
-        for (const write of input.writes) {
-            const oid = (await git(input.cwd, ["hash-object", "-w", "--stdin"], write.text, undefined, input.signal)).trim();
-            await git(input.cwd, [
-                "update-index",
-                "--add",
-                "--cacheinfo",
-                `100644,${oid},${taskMutationPath(write)}`,
-            ], undefined, env, input.signal);
-        }
-        const tree = (await git(input.cwd, ["write-tree"], undefined, env, input.signal)).trim();
-        if (!input.requireCommit) {
-            const parentTree = (await git(input.cwd, ["show", "-s", "--format=%T", input.parent], undefined, undefined, input.signal)).trim();
-            if (tree === parentTree)
-                return input.parent;
-        }
-        return (await git(input.cwd, ["commit-tree", tree, "-p", input.parent, "-m", input.subject], undefined, undefined, input.signal)).trim();
-    }
-    finally {
-        fs.rmSync(temporaryDirectory, { recursive: true, force: true });
-    }
-}
-/** Stage only the mutated task paths into the real index; leave unrelated entries alone. */
-async function reconcileTaskMutationIndexPath(cwd, write, signal) {
-    const oid = (await git(cwd, ["hash-object", "-w", "--stdin"], write.text, undefined, signal)).trim();
-    await git(cwd, [
-        "update-index",
-        "--add",
-        "--cacheinfo",
-        `100644,${oid},${taskMutationPath(write)}`,
-    ], undefined, undefined, signal);
-}
-export async function reconcileTaskMutationIndex(cwd, writes, signal, reconcilePath = async (input) => {
-    await reconcileTaskMutationIndexPath(input.cwd, input.write, input.signal);
-}) {
-    for (const write of writes) {
-        await reconcilePath({ cwd, write, signal });
-    }
-}
-async function snapshotTaskMutationIndex(cwd, writes, signal) {
-    const snapshot = [];
-    for (const write of writes) {
-        const taskPath = taskMutationPath(write);
-        const output = await git(cwd, ["ls-files", "--stage", "-z", "--", taskPath], undefined, undefined, signal);
-        snapshot.push({ path: taskPath, entries: output.split("\0").filter(Boolean) });
-    }
-    return snapshot;
-}
-async function restoreTaskMutationIndex(cwd, snapshot, signal) {
-    for (const item of snapshot) {
-        await git(cwd, ["update-index", "--force-remove", "--", item.path], undefined, undefined, signal);
-        if (item.entries.length > 0) {
-            await git(cwd, ["update-index", "-z", "--index-info"], `${item.entries.join("\0")}\0`, undefined, signal);
-        }
-    }
-}
-/**
- * Atomically publish a pathspec-scoped task micro-commit on the current checkout branch.
- * Unrelated staged and unstaged non-task bytes are never read into the commit.
- */
-export async function publishTaskMutationCommit(input, deps = {}) {
-    let lastError;
-    for (let attempt = 0; attempt < 4; attempt += 1) {
-        input.signal?.throwIfAborted();
-        const branch = await inspectCurrentBranch(input.cwd, input.signal);
-        const commit = await createTaskMutationCommit({
-            cwd: input.cwd,
-            gitDir: input.gitDir,
-            parent: branch.head,
-            writes: input.writes,
-            subject: input.subject,
-            requireCommit: input.requireCommit,
-            signal: input.signal,
-        });
-        if (commit === branch.head) {
-            const indexBefore = await snapshotTaskMutationIndex(input.cwd, input.writes, input.signal);
-            try {
-                await reconcileTaskMutationIndex(input.cwd, input.writes, input.signal, deps.reconcileIndexPath);
-                observePublicationEffect(input.observeEffect, { effect: "task-reconciliation", status: "succeeded", commit, detail: "current" });
-                observePublicationEffect(input.observeEffect, { effect: "task-index-reconciliation", status: "succeeded", commit });
-                return commit;
-            }
-            catch (error) {
-                try {
-                    await restoreTaskMutationIndex(input.cwd, indexBefore, input.signal);
-                }
-                catch (restoreError) {
-                    observePublicationEffect(input.observeEffect, { effect: "task-index-reconciliation", status: "failed", commit, error: restoreError });
-                    throw new FlowError("INTERNAL_STATE", "cannot restore task index after reconciliation failure", { cause: restoreError });
-                }
-                observePublicationEffect(input.observeEffect, { effect: "task-index-reconciliation", status: "failed", commit, error });
-                throw error;
-            }
-        }
-        const indexBefore = await snapshotTaskMutationIndex(input.cwd, input.writes, input.signal);
-        try {
-            await reconcileTaskMutationIndex(input.cwd, input.writes, input.signal, deps.reconcileIndexPath);
-            observePublicationEffect(input.observeEffect, { effect: "task-index-reconciliation", status: "succeeded", commit });
-            await updateBranch({
-                cwd: input.cwd,
-                ref: branch.ref,
-                next: commit,
-                expected: branch.head,
-                signal: input.signal,
-            }, deps);
-            observePublicationEffect(input.observeEffect, { effect: "task-reconciliation", status: "succeeded", commit, detail: "published" });
-            return commit;
-        }
-        catch (error) {
-            lastError = error;
-            try {
-                await restoreTaskMutationIndex(input.cwd, indexBefore, input.signal);
-            }
-            catch (restoreError) {
-                observePublicationEffect(input.observeEffect, { effect: "task-index-reconciliation", status: "failed", commit, error: restoreError });
-                throw new FlowError("INTERNAL_STATE", "cannot restore task index after publication failure", { cause: restoreError });
-            }
-            observePublicationEffect(input.observeEffect, { effect: "task-index-reconciliation", status: "failed", commit, error });
-        }
-    }
-    observePublicationEffect(input.observeEffect, { effect: "task-reconciliation", status: "failed", error: lastError });
-    throw lastError;
-}
-async function taskTreeEntries(cwd, commit) {
-    return (await git(cwd, ["ls-tree", "-r", "-z", commit, "--", ".keiyaku/tasks"]))
-        .split("\0")
-        .filter(Boolean)
-        .map((record) => {
-        const tab = record.indexOf("\t");
-        const [mode, type, oid] = record.slice(0, tab).split(" ");
-        if (tab < 0 || type !== "blob" || !mode || !oid) {
-            throw new FlowError("INTERNAL_STATE", `invalid task tree entry in ${commit}`);
-        }
-        return { mode, oid, path: record.slice(tab + 1) };
-    });
-}
-/** Reconcile only settlement-owned task paths; never rewrite an unrelated index entry. */
-export async function reconcileTaskPathsetIndex(cwd, commit, paths) {
-    const entries = new Map((await taskTreeEntries(cwd, commit)).map((entry) => [entry.path, entry]));
-    for (const taskPath of paths) {
-        const entry = entries.get(taskPath);
-        if (entry) {
-            await git(cwd, ["update-index", "--add", "--cacheinfo", `${entry.mode},${entry.oid},${entry.path}`]);
-        }
-        else {
-            await git(cwd, ["update-index", "--force-remove", "--", taskPath]);
-        }
-    }
-}
-/** Task paths tracked by one authoritative commit, independent of the worktree index. */
-export async function trackedTaskPaths(cwd, commit) {
-    return (await taskTreeEntries(cwd, commit)).map((entry) => entry.path).sort();
-}
-export async function refHead(cwd, ref) {
-    return (await git(cwd, ["rev-parse", ref])).trim();
-}
-export async function taskContractAtCommit(cwd, commit, id) {
-    const coordinate = parseTaskCoordinate(id).coordinate;
-    const sourcePath = `.keiyaku/tasks/${coordinate}.md`;
-    const result = await gitResult(cwd, ["show", `${commit}:${sourcePath}`]);
-    if (result.status !== 0)
-        return undefined;
-    return parseTaskDocument({ path: sourcePath, text: result.stdout }).contractId;
-}
-async function taskDocumentAtCommit(cwd, commit, taskId) {
-    let coordinate;
-    try {
-        coordinate = parseTaskCoordinate(taskId);
-    }
-    catch {
-        throw new FlowError("INTERNAL_STATE", `bind base ${commit} names noncanonical task id ${taskId}`);
-    }
-    const sourcePath = `.keiyaku/tasks/${coordinate.coordinate}.md`;
-    const result = await gitResult(cwd, ["show", `${commit}:${sourcePath}`]);
-    if (result.status !== 0 || result.error) {
-        throw new FlowError("INTERNAL_STATE", `bind base ${commit} is missing task ${taskId}`, { cause: result.error });
-    }
-    const document = parseTaskDocument({ path: sourcePath, text: result.stdout });
-    if (document.id !== coordinate.localId) {
-        throw new FlowError("INTERNAL_STATE", `bind base ${commit} task path ${taskId} contains ${document.id}`);
-    }
-    return document;
-}
-async function readTaskAdmissionEvidence(input, readDocument = taskDocumentAtCommit) {
-    if (input.selectedTaskIds.length === 0 || new Set(input.selectedTaskIds).size !== input.selectedTaskIds.length) {
-        throw new FlowError("INTERNAL_STATE", `task-selected bind ${input.bindObjectId} must name unique selected tasks`);
-    }
-    const cache = new Map();
-    const read = async (taskId) => {
-        const cached = cache.get(taskId);
-        if (cached)
-            return cached;
-        const document = await readDocument(input.cwd, input.base, taskId);
-        cache.set(taskId, document);
-        return document;
-    };
-    const selected = [];
-    for (const taskId of input.selectedTaskIds) {
-        const document = await read(taskId);
-        if (document.contractId !== input.contract || document.state !== "open") {
-            throw new FlowError("INTERNAL_STATE", `bind base ${input.base} task ${taskId} does not carry open linkage to ${input.contract}`);
-        }
-        const needs = [];
-        for (const need of document.needs) {
-            const prerequisite = await read(need);
-            needs.push({ taskId: need, state: prerequisite.state, ...(prerequisite.contractId === undefined ? {} : { contractId: prerequisite.contractId }) });
-        }
-        selected.push({ taskId, needs });
-    }
-    return {
-        bindObjectId: input.bindObjectId,
-        base: input.base,
-        selected,
-    };
-}
-/** Immutable current bind-time task linkage and needs evidence; never reads the current board. */
-export async function readTaskAdmissionEvidenceAtCommit(input) {
-    return await readTaskAdmissionEvidence(input);
-}
-/** Read every bind-time task document in one lifecycle observation through one Git process. */
-export function openTaskAdmissionEvidenceReader(cwd) {
-    const batch = openGitStreamingBatch(cwd);
-    const documents = new Map();
-    let transportFailed = false;
-    const readDocument = async (_cwd, commit, taskId) => {
-        let coordinate;
-        try {
-            coordinate = parseTaskCoordinate(taskId);
-        }
-        catch {
-            throw new FlowError("INTERNAL_STATE", `bind base ${commit} names noncanonical task id ${taskId}`);
-        }
-        const sourcePath = `.keiyaku/tasks/${coordinate.coordinate}.md`;
-        const expression = `${commit}:${sourcePath}`;
-        const cached = documents.get(expression);
-        if (cached)
-            return cached;
-        let result;
-        try {
-            result = await batch.request(expression);
-        }
-        catch (error) {
-            transportFailed = true;
-            throw new FlowError("INTERNAL_STATE", `cannot read bind base ${commit} task ${taskId}`, { cause: error });
-        }
-        if (result.kind !== "object" || result.record.type !== "blob") {
-            throw new FlowError("INTERNAL_STATE", `bind base ${commit} is missing task ${taskId}`);
-        }
-        const document = parseTaskDocument({ path: sourcePath, text: result.record.content.toString("utf8") });
-        if (document.id !== coordinate.localId) {
-            throw new FlowError("INTERNAL_STATE", `bind base ${commit} task path ${taskId} contains ${document.id}`);
-        }
-        documents.set(expression, document);
-        return document;
-    };
-    return {
-        read: async (input) => await readTaskAdmissionEvidence(input, readDocument),
-        close: async () => {
-            try {
-                const fact = await batch.close();
-                if (!transportFailed && (fact.timedOut || fact.code !== 0 || fact.signal !== null)) {
-                    const detail = fact.stderr.toString("utf8").trim() || `exit ${String(fact.code)}`;
-                    throw new FlowError("INTERNAL_STATE", `git cat-file --batch failed while reading task evidence: ${detail}`);
-                }
-            }
-            catch (error) {
-                if (transportFailed)
-                    return;
-                if (error instanceof FlowError)
-                    throw error;
-                throw new FlowError("INTERNAL_STATE", "cannot close task evidence batch reader", { cause: error });
-            }
-        },
-    };
-}
-/** Bound task ids and their complete parent ancestry from the immutable bind base. */
-export async function taskSettlementOwnershipAtCommit(cwd, commit, contractId) {
-    const documents = new Map();
-    for (const entry of await taskTreeEntries(cwd, commit)) {
-        const text = await git(cwd, ["cat-file", "blob", entry.oid]);
-        const document = parseTaskDocument({ path: entry.path, text });
-        const coordinate = parseTaskCoordinate(entry.path.slice(".keiyaku/tasks/".length, -3)).coordinate;
-        documents.set(coordinate, document);
-    }
-    const taskIds = [...documents]
-        .filter(([, document]) => document.contractId === contractId)
-        .map(([coordinate]) => coordinate)
-        .sort();
-    const ownedIds = new Set();
-    for (const taskId of taskIds) {
-        let current = taskId;
-        while (current !== null) {
-            if (ownedIds.has(current))
-                break;
-            ownedIds.add(current);
-            const document = documents.get(current);
-            if (!document) {
-                throw new FlowError("INTERNAL_STATE", `bind base ${commit} lost task ${current} from the owned ancestry`);
-            }
-            current = document.parent;
-        }
-    }
-    return {
-        taskIds,
-        paths: [...ownedIds].map((id) => `.keiyaku/tasks/${id}.md`).sort(),
-    };
-}
-export async function updateBranch(input, deps) {
-    if (deps.updateBranch)
-        await deps.updateBranch(input);
-    else
-        await git(input.cwd, ["update-ref", input.ref, input.next, input.expected], undefined, undefined, input.signal);
-}
-export async function publishForwardTaskBoardCommit(input, deps) {
-    let lastError;
-    for (let attempt = 0; attempt < 4; attempt += 1) {
-        const parent = await refHead(input.cwd, input.ref);
-        const commit = await createTaskBoardCommit({ ...input, parent });
-        try {
-            await updateBranch({ cwd: input.cwd, ref: input.ref, next: commit, expected: parent }, deps);
-            try {
-                await reconcileTaskPathsetIndex(input.cwd, commit, input.paths);
-            }
-            catch { /* the forward branch fact remains authoritative */ }
-            return commit;
-        }
-        catch (error) {
-            lastError = error;
-        }
-    }
-    throw lastError;
-}
-export async function taskSourcesAtCommit(cwd, root, commit, paths) {
-    const sources = [];
-    for (const sourcePath of paths) {
-        const result = await gitResult(cwd, ["show", `${commit}:${sourcePath}`]);
-        if (result.status !== 0)
-            return undefined;
-        sources.push({ path: path.join(root, ...sourcePath.split("/")), text: result.stdout });
-    }
-    return sources;
-}
-export function taskWritesFromSources(sources) {
-    return sources.map((source) => ({
-        id: parseTaskCoordinate(source.path.replaceAll("\\", "/").split("/.keiyaku/tasks/").at(-1).slice(0, -3)).coordinate,
-        text: source.text,
-    }));
-}