@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/task/document.js

@@ -1,5 +1,5 @@
 import { isAlias, isMap, isScalar, isSeq, parseDocument, stringify, } from "yaml";
-import { canonicalTimestamp, fullId, invalid, nonblank, TASK_STATES, } from "./validation.js";
+import { canonicalTimestamp, fullId, isTaskId, invalid, nonblank, TASK_STATES, } from "./validation.js";
 const FIELD_ORDER = [
     "id",
     "title",
@@ -8,6 +8,8 @@ const FIELD_ORDER = [
     "needs",
     "parent",
     "from",
+    "supersedes",
+    "relatesTo",
     "createdAt",
     "updatedAt",
     "creator",
@@ -100,11 +102,13 @@ export function parseTaskDocument(source) {
             invalid(`task field '${key}' must be a scalar or string array`);
         }
     }
-    const id = fullId("id", values.get("id"));
+    const id = nonblank("id", values.get("id"));
+    if (!isTaskId(id))
+        invalid("task field 'id' must be a canonical local task id");
     const title = nonblank("title", values.get("title"));
     const state = values.get("state");
     if (typeof state !== "string" || !TASK_STATES.has(state)) {
-        invalid("task field 'state' must be open, in_progress, done, or drop");
+        invalid("task field 'state' must be open, in_progress, on_hold, done, or drop");
     }
     const pri = values.get("pri");
     if (typeof pri !== "number" || !Number.isInteger(pri) || pri < 0 || pri > 3) {
@@ -120,10 +124,7 @@ export function parseTaskDocument(source) {
         const value = values.get(field);
         if (value === null)
             return null;
-        const related = fullId(field, value);
-        if (related === id)
-            invalid(`task field '${field}' must not reference itself`);
-        return related;
+        return fullId(field, value);
     };
     const parent = relationship("parent");
     const fromValue = values.get("from");
@@ -132,8 +133,19 @@ export function parseTaskDocument(source) {
     const from = fromValue.map((related) => fullId("from", related));
     if (new Set(from).size !== from.length)
         invalid("task field 'from' must be unique");
-    if (from.includes(id))
-        invalid("task field 'from' must not reference itself");
+    const relationships = (field) => {
+        const value = values.get(field);
+        if (value === undefined)
+            return [];
+        if (!Array.isArray(value))
+            invalid(`task field '${field}' must be a string array`);
+        const related = value.map((item) => fullId(field, item));
+        if (new Set(related).size !== related.length)
+            invalid(`task field '${field}' must be unique`);
+        return related;
+    };
+    const supersedes = relationships("supersedes");
+    const relatesTo = relationships("relatesTo");
     const createdAt = canonicalTimestamp("createdAt", values.get("createdAt"));
     const updatedValue = values.get("updatedAt");
     const updatedAt = updatedValue === undefined ? undefined : canonicalTimestamp("updatedAt", updatedValue);
@@ -156,6 +168,8 @@ export function parseTaskDocument(source) {
         needs,
         parent,
         from,
+        supersedes,
+        relatesTo,
         createdAt,
         ...(updatedAt === undefined ? {} : { updatedAt }),
         creator,
@@ -177,6 +191,8 @@ function serializeUnchecked(document) {
         needs: [...document.needs],
         parent: document.parent,
         from: document.from,
+        ...(document.supersedes.length === 0 ? {} : { supersedes: document.supersedes }),
+        ...(document.relatesTo.length === 0 ? {} : { relatesTo: document.relatesTo }),
         createdAt: document.createdAt,
         ...(document.updatedAt === undefined ? {} : { updatedAt: document.updatedAt }),
         creator: document.creator,

package/build/core/task/index.js

@@ -3,10 +3,13 @@
  * Only symbols required by current external consumers are re-exported.
  * Package-internal modules must import each other directly, not through this file.
  */
-export { previewTaskBoardForBind, reconcileTaskForfeit, settleTaskBoardForBind, settleTaskBoardForLanding, } from "./task-contract.js";
+export { previewTaskBoardForBind, reconcileTaskForfeit, replayClaimTasks, } from "./task-contract.js";
+export { replayPreparedTaskBind, replayPreparedTaskBindLocked, replayCommittedTaskBind, replayCommittedTaskBindForfeit, replayPreparedTaskBindForfeit, withPreparedTaskBind, } from "./task-bind-preparation.js";
+export { readTaskBoardGeneration } from "./task-git-store.js";
 export { resolveTaskCreator } from "./task-git-actor.js";
-export { openTaskCommandRepository, readTaskDoctor, taskCommandContractId, } from "./task-git-runtime.js";
-export { openTaskStore, readTaskHistory } from "./task-git-store.js";
+export { openTaskCommandRepository, openTaskMutationContext, readTaskDoctor, taskCommandContractId, taskCommandNamespace, } from "./task-git-runtime.js";
+export { openTaskStore, readTaskHistory, readTaskNamespaces } from "./task-git-store.js";
 export { taskRepositoryFromStore } from "./task-store-repository.js";
 export { isTaskId } from "./validation.js";
-export { buildTaskTree, createTask, doneTask, dropTask, parseTaskDocument, readTaskBoard, resolveTaskReadId, serializeTaskDocument, startTask, stopTask, updateTask, deriveTaskDisplay, selectTaskList, taskUpdatedAt, advancedTaskUpdatedAt, } from "./task.js";
+export { isTaskCoordinate, parseTaskCoordinate, taskCoordinateFromSourcePath } from "./coordinate.js";
+export { buildTaskTree, createTask, doneTask, dropTask, parseTaskDocument, readTaskBoard, resolveTaskReadId, serializeTaskDocument, startTask, stopTask, holdTask, resumeTask, updateTask, updateTaskWithReceipt, deriveTaskDisplay, selectTaskList, taskUpdatedAt, advancedTaskUpdatedAt, } from "./task.js";

package/build/core/task/query.js

@@ -1,18 +1,19 @@
 import { FlowError } from "../../flow-error.js";
 import { isCommissionId } from "../ids.js";
 import { taskUpdatedAt } from "./model.js";
-import { isTaskId } from "./validation.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 = "FIELD OP VALUE[,VALUE...] [| FIELD OP VALUE[,VALUE...]]...";
-export const TASK_FILTER_COMPLETION = "FIELD OP VALUE[,VALUE...]|FIELD OP VALUE[,VALUE...]";
+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", "done", "dropped", "bound"]);
+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 };
@@ -21,6 +22,8 @@ export function deriveTaskDisplay(task) {
         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")
@@ -43,14 +46,7 @@ function invalidFilter(detail, recoveredTerms = []) {
         },
     });
 }
-function parseTaskFilterTerm(term, expression, recoveredTerms) {
-    const match = /^([a-z][a-z0-9_-]*)(!=|<=|>=|~|=|<|>)(.*)$/.exec(term);
-    if (!match)
-        invalidFilter(`'${expression}' must use ${TASK_FILTER_GRAMMAR}`, recoveredTerms);
-    const field = match[1];
-    const operator = match[2];
-    if (!FILTER_FIELDS.has(field))
-        invalidFilter(`unknown field '${field}'`, recoveredTerms);
+function validateTaskFilterTerm(field, operator, values, recoveredTerms) {
     if (field === "title" && !TITLE_OPERATORS.has(operator)) {
         invalidFilter(`field '${field}' does not support operator '${operator}'`, recoveredTerms);
     }
@@ -59,21 +55,15 @@ function parseTaskFilterTerm(term, expression, recoveredTerms) {
         : operator !== "=" && operator !== "!=")) {
         invalidFilter(`field '${field}' does not support operator '${operator}'`, recoveredTerms);
     }
-    const values = match[3].split(",");
-    if (values.some((value) => value.length === 0))
-        invalidFilter(`field '${field}' has an empty value`, recoveredTerms);
     validateFilterValues(field, values, recoveredTerms);
-    return { field, operator, values };
 }
 export function parseTaskFilter(expression) {
-    const terms = expression.split("|");
-    const parsed = [];
-    for (const term of terms) {
-        if (term.length === 0)
-            invalidFilter(`'${expression}' must use ${TASK_FILTER_GRAMMAR}`, parsed);
-        parsed.push(parseTaskFilterTerm(term, expression, parsed));
-    }
-    return parsed;
+    return parseStructuredQuery({
+        expression,
+        fields: FILTER_FIELDS,
+        invalid: invalidFilter,
+        validate: validateTaskFilterTerm,
+    });
 }
 function parseTimestamp(value, nowMs, recoveredTerms = []) {
     const relative = RELATIVE_TIME.exec(value);
@@ -114,8 +104,8 @@ function validateFilterValues(field, values, recoveredTerms) {
         for (const value of values) {
             if (field === "parent" && value === "none")
                 continue;
-            if (!isTaskId(value))
-                invalidFilter(`value '${value}' must be a canonical full task id`, recoveredTerms);
+            if (!isTaskCoordinate(value))
+                invalidFilter(`value '${value}' must be a canonical full task coordinate`, recoveredTerms);
         }
         return;
     }
@@ -183,7 +173,7 @@ function selected(task, selection) {
 }
 function displayOrder(task) {
     const display = deriveTaskDisplay(task);
-    return display === "in_progress" ? 0 : display === "ready" ? 1 : display === "blocked" ? 2 : display === "bound" ? 3 : display === "done" ? 4 : 5;
+    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)

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

@@ -2,13 +2,17 @@ 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";
-async function gitResult(cwd, args, input, env) {
-    return await runGitProcess(cwd, args, { input, env });
+import { parseTaskCoordinate } from "./coordinate.js";
+async function gitResult(cwd, args, input, env, signal) {
+    return await runGitProcess(cwd, args, { input, env, signal });
 }
-async function git(cwd, args, input, env) {
-    const result = await gitResult(cwd, args, input, env);
+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) {
@@ -23,15 +27,17 @@ function boardPath(root, source) {
     }
     return relative;
 }
-export async function inspectCurrentBranch(cwd) {
-    const branch = await gitResult(cwd, ["symbolic-ref", "--quiet", "HEAD"]);
+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"])).trim() };
+    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-"));
@@ -61,55 +67,64 @@ export async function createTaskMutationCommit(input) {
     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);
+        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)).trim();
+            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);
+            ], undefined, env, input.signal);
         }
-        const tree = (await git(input.cwd, ["write-tree"], undefined, env)).trim();
-        const parentTree = (await git(input.cwd, ["rev-parse", `${input.parent}^{tree}`])).trim();
+        const tree = (await git(input.cwd, ["write-tree"], undefined, env, input.signal)).trim();
+        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])).trim();
+        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. */
-export async function reconcileTaskMutationIndex(cwd, writes) {
+export async function reconcileTaskMutationIndex(cwd, writes, signal) {
     for (const write of writes) {
-        const oid = (await git(cwd, ["hash-object", "-w", "--stdin"], write.text)).trim();
+        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);
     }
 }
 /**
- * Atomically publish a pathspec-scoped task micro-commit under the hub branch.
+ * 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) {
-        const branch = await inspectCurrentBranch(input.cwd);
+        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,
+            signal: input.signal,
         });
         if (commit === branch.head) {
-            await reconcileTaskMutationIndex(input.cwd, input.writes);
+            input.observeEffect?.({ effect: "task-reconciliation", status: "succeeded", commit, detail: "current" });
+            try {
+                await reconcileTaskMutationIndex(input.cwd, input.writes, input.signal);
+                input.observeEffect?.({ effect: "task-index-reconciliation", status: "succeeded", commit });
+            }
+            catch (error) {
+                input.observeEffect?.({ effect: "task-index-reconciliation", status: "failed", commit, error });
+            }
             return commit;
         }
         try {
@@ -118,12 +133,16 @@ export async function publishTaskMutationCommit(input, deps = {}) {
                 ref: branch.ref,
                 next: commit,
                 expected: branch.head,
+                signal: input.signal,
             }, deps);
+            input.observeEffect?.({ effect: "task-reconciliation", status: "succeeded", commit, detail: "published" });
             try {
-                await reconcileTaskMutationIndex(input.cwd, input.writes);
+                await reconcileTaskMutationIndex(input.cwd, input.writes, input.signal);
+                input.observeEffect?.({ effect: "task-index-reconciliation", status: "succeeded", commit });
             }
-            catch {
+            catch (error) {
                 // Branch fact remains authoritative; index may be repaired by a later mutation.
+                input.observeEffect?.({ effect: "task-index-reconciliation", status: "failed", commit, error });
             }
             return commit;
         }
@@ -131,6 +150,7 @@ export async function publishTaskMutationCommit(input, deps = {}) {
             lastError = error;
         }
     }
+    input.observeEffect?.({ effect: "task-reconciliation", status: "failed", error: lastError });
     throw lastError;
 }
 async function taskTreeEntries(cwd, commit) {
@@ -167,23 +187,139 @@ export async function refHead(cwd, ref) {
     return (await git(cwd, ["rev-parse", ref])).trim();
 }
 export async function taskContractAtCommit(cwd, commit, id) {
-    const sourcePath = `.keiyaku/tasks/${id}.md`;
+    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);
+            if (prerequisite.state !== "done" && prerequisite.state !== "drop") {
+                throw new FlowError("INTERNAL_STATE", `bind base ${input.base} task ${taskId} has unsatisfied need ${need}`);
+            }
+            needs.push({ taskId: need, state: prerequisite.state });
+        }
+        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 });
-        documents.set(document.id, document);
+        const coordinate = parseTaskCoordinate(entry.path.slice(".keiyaku/tasks/".length, -3)).coordinate;
+        documents.set(coordinate, document);
     }
-    const taskIds = [...documents.values()]
-        .filter((document) => document.contractId === contractId)
-        .map((document) => document.id)
+    const taskIds = [...documents]
+        .filter(([, document]) => document.contractId === contractId)
+        .map(([coordinate]) => coordinate)
         .sort();
     const ownedIds = new Set();
     for (const taskId of taskIds) {
@@ -208,7 +344,7 @@ 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]);
+        await git(input.cwd, ["update-ref", input.ref, input.next, input.expected], undefined, undefined, input.signal);
 }
 export async function publishForwardTaskBoardCommit(input, deps) {
     let lastError;
@@ -229,71 +365,6 @@ export async function publishForwardTaskBoardCommit(input, deps) {
     }
     throw lastError;
 }
-async function treeWithoutTasks(cwd, commit, gitDir) {
-    const temporaryDirectory = fs.mkdtempSync(path.join(gitDir, "keiyaku-landing-index-"));
-    const env = { GIT_INDEX_FILE: path.join(temporaryDirectory, "index") };
-    try {
-        await git(cwd, ["read-tree", commit], undefined, env);
-        await git(cwd, ["rm", "-r", "--cached", "-f", "--ignore-unmatch", "--", ".keiyaku/tasks"], undefined, env);
-        return (await git(cwd, ["write-tree"], undefined, env)).trim();
-    }
-    finally {
-        fs.rmSync(temporaryDirectory, { recursive: true, force: true });
-    }
-}
-export async function composeLandingTree(input) {
-    const baseTree = await treeWithoutTasks(input.cwd, input.base, input.gitDir);
-    const targetTree = await treeWithoutTasks(input.cwd, input.target, input.gitDir);
-    const deliveryTree = await treeWithoutTasks(input.cwd, input.delivery, input.gitDir);
-    let mergedTree;
-    try {
-        mergedTree = (await git(input.cwd, [
-            "merge-tree",
-            "--write-tree",
-            "--merge-base",
-            baseTree,
-            targetTree,
-            deliveryTree,
-        ])).trim();
-    }
-    catch (error) {
-        throw new FlowError("CLOSE_MERGE_CONFLICT", "claim merge conflict outside task board", { cause: error });
-    }
-    const temporaryDirectory = fs.mkdtempSync(path.join(input.gitDir, "keiyaku-landing-index-"));
-    const env = { GIT_INDEX_FILE: path.join(temporaryDirectory, "index") };
-    try {
-        await git(input.cwd, ["read-tree", mergedTree], undefined, env);
-        // merge-tree deliberately excluded task paths. Restore the target board as
-        // the inherited baseline, then overlay only settlement-authorized writes.
-        for (const entry of await taskTreeEntries(input.cwd, input.target)) {
-            await git(input.cwd, [
-                "update-index",
-                "--add",
-                "--cacheinfo",
-                `${entry.mode},${entry.oid},${entry.path}`,
-            ], 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);
-        }
-        return (await git(input.cwd, ["write-tree"], undefined, env)).trim();
-    }
-    finally {
-        fs.rmSync(temporaryDirectory, { recursive: true, force: true });
-    }
-}
-function landingCommitMessage(contractId, targetBranch) {
-    return `keiyaku: claim ${contractId}\n\nMerge contract ${contractId} into ${targetBranch}.\n`;
-}
-async function isAncestor(cwd, ancestor, descendant) {
-    return (await gitResult(cwd, ["merge-base", "--is-ancestor", ancestor, descendant])).status === 0;
-}
 export async function taskSourcesAtCommit(cwd, root, commit, paths) {
     const sources = [];
     for (const sourcePath of paths) {
@@ -304,95 +375,9 @@ export async function taskSourcesAtCommit(cwd, root, commit, paths) {
     }
     return sources;
 }
-/**
- * Find the durable landing receipt on the target's first-parent history.
- * Equivalent trees and lookalike messages are insufficient: the commit must
- * have our parent shape, settle every bind-base-owned task, and exactly match
- * a recomposed landing tree over its own first parent.
- */
-export async function findAcceptedLandingCommit(input) {
-    const commits = (await git(input.cwd, ["rev-list", "--first-parent", input.target, `^${input.base}`]))
-        .trim()
-        .split("\n")
-        .filter(Boolean);
-    for (const commit of commits) {
-        const message = await git(input.cwd, ["show", "-s", "--format=%B", commit]);
-        if (message.trimEnd() !== landingCommitMessage(input.contractId, input.targetBranch).trimEnd())
-            continue;
-        const record = (await git(input.cwd, ["rev-list", "--parents", "-n", "1", commit])).trim().split(/\s+/);
-        const parents = record.slice(1);
-        const parentShapeAccepted = parents.length === 2
-            ? parents[1] === input.delivery
-            : parents.length === 1 && await isAncestor(input.cwd, input.delivery, parents[0]);
-        if (!parentShapeAccepted)
-            continue;
-        const sources = await taskSourcesAtCommit(input.cwd, input.root, commit, input.ownedPaths);
-        if (!sources)
-            continue;
-        let settled = false;
-        try {
-            const sourceByPath = new Map(sources.map((source) => [boardPath(input.root, source), source]));
-            settled = input.settledPaths.every((settledPath) => {
-                const source = sourceByPath.get(settledPath);
-                if (!source)
-                    return false;
-                const document = parseTaskDocument(source);
-                return document.state === "done" && document.contractId === undefined;
-            });
-        }
-        catch {
-            // A malformed lookalike is not this operation's durable receipt.
-        }
-        if (!settled)
-            continue;
-        const expectedTree = await composeLandingTree({
-            cwd: input.cwd,
-            gitDir: input.gitDir,
-            root: input.root,
-            base: input.base,
-            target: parents[0],
-            delivery: input.delivery,
-            sources,
-        });
-        const actualTree = (await git(input.cwd, ["rev-parse", `${commit}^{tree}`])).trim();
-        if (actualTree === expectedTree)
-            return commit;
-    }
-    return undefined;
-}
-export async function containsCommit(cwd, ancestor, descendant) {
-    return await isAncestor(cwd, ancestor, descendant);
-}
-/** Create the landing commit over a previously composed candidate tree. */
-export async function createLandingCommit(input) {
-    // Once delivery is already reachable from target, a single-parent landing
-    // records this claim without fabricating a redundant merge parent.
-    const parents = input.target === input.delivery || await isAncestor(input.cwd, input.delivery, input.target)
-        ? ["-p", input.target]
-        : ["-p", input.target, "-p", input.delivery];
-    return (await git(input.cwd, [
-        "commit-tree",
-        input.tree,
-        ...parents,
-        "-m",
-        `keiyaku: claim ${input.contractId}`,
-        "-m",
-        `Merge contract ${input.contractId} into ${input.targetBranch}.`,
-    ])).trim();
-}
-export async function updateTargetRef(cwd, ref, next, expected) {
-    await git(cwd, ["update-ref", ref, next, expected]);
-}
-export function sameTaskSourceBytes(root, left, right) {
-    const snapshot = (sources) => new Map(sources.map((source) => [boardPath(root, source), source.text]));
-    const leftSnapshot = snapshot(left);
-    const rightSnapshot = snapshot(right);
-    return leftSnapshot.size === rightSnapshot.size
-        && [...leftSnapshot].every(([sourcePath, sourceText]) => rightSnapshot.get(sourcePath) === sourceText);
-}
 export function taskWritesFromSources(sources) {
     return sources.map((source) => ({
-        id: path.basename(source.path, ".md"),
+        id: parseTaskCoordinate(source.path.replaceAll("\\", "/").split("/.keiyaku/tasks/").at(-1).slice(0, -3)).coordinate,
         text: source.text,
     }));
 }