@astrosheep/keiyaku 2.9.8 → 2.9.10

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

@@ -1,30 +1,92 @@
-import { listContractIds } from "../ledger.js";
-import { contractBoundByEngineWorktree, stableRepoRoot } from "../worktree-path.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { KEIYAKU_FILE } from "../../keiyaku.js";
+import { readCurrentContractLifecycle, readRepositoryLifecycle } from "../repository-ledger/read-model.js";
+import { repositoryDeliveryRef } from "../repository-ledger/codec.js";
+import { contractIdentityFromWorktreeWitness, stableRepoRoot } from "../worktree-path.js";
 import { inspectTaskLock, locateTaskBoard, openTaskStore, openTaskStoreAt, } from "./task-git-store.js";
 import { taskRepositoryFromStore } from "./task-store-repository.js";
 import { withTaskWorktreePolicy } from "./task-worktree.js";
 import { inspectTaskDoctor } from "./task-doctor.js";
-export async function taskCommandContractId(cwd) {
-    const board = await locateTaskBoard(cwd);
+import { taskNamespaceFromScope } from "./coordinate.js";
+import { FlowError } from "../../flow-error.js";
+import { runGitProcess } from "../../git/core.js";
+function taskNamespaceFromBind(bind) {
+    const namespaces = bind.data.scope.flatMap((term) => taskNamespaceFromScope(term) ?? []);
+    if (namespaces.length !== 1)
+        throw new FlowError("INTERNAL_STATE", `contract ${bind.contract} must have exactly one bind task namespace`);
+    return namespaces[0];
+}
+async function taskCommandContext(cwd, signal) {
+    const board = await locateTaskBoard(cwd, (repository, args, input) => runGitProcess(repository, args, { input, signal }));
     if (board.mode !== "git")
-        return undefined;
-    return contractBoundByEngineWorktree(cwd, board.root);
+        return { board };
+    if (board.surfaceRoot === board.root)
+        return { board };
+    const identity = await contractIdentityFromWorktreeWitness(cwd, board.root, signal);
+    if (!identity) {
+        try {
+            await fs.access(path.join(board.surfaceRoot, KEIYAKU_FILE));
+            throw new FlowError("INVALID_TARGET", "contract task namespace is unavailable");
+        }
+        catch (error) {
+            if (error instanceof FlowError)
+                throw error;
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        return { board };
+    }
+    const outcome = await readCurrentContractLifecycle(board.root, identity.contractId, { signal });
+    if (outcome.status !== "healthy" || outcome.model.resources.worktree === null) {
+        throw new FlowError("INVALID_TARGET", `contract ${identity.contractId} task namespace is unavailable`);
+    }
+    const expectedPath = await fs.realpath(path.join(board.root, ".keiyaku", "wt", outcome.model.resources.worktree.place));
+    if (identity.branch !== repositoryDeliveryRef(identity.contractId)
+        || identity.branch !== outcome.model.resources.deliveryRef
+        || identity.path !== expectedPath) {
+        throw new FlowError("INVALID_TARGET", `contract ${identity.contractId} task namespace is unavailable`);
+    }
+    const bind = outcome.model.history.find((row) => row.entry.kind === "bind")?.entry;
+    if (!bind || bind.kind !== "bind")
+        throw new FlowError("INTERNAL_STATE", `contract ${identity.contractId} has no accepted bind`);
+    const namespace = taskNamespaceFromBind(bind);
+    return { board, contractId: identity.contractId, namespace };
 }
-export async function openTaskCommandRepository(cwd) {
-    const board = await locateTaskBoard(cwd);
-    const store = openTaskStoreAt(board);
+export async function taskCommandContractId(cwd) {
+    return (await taskCommandContext(cwd)).contractId;
+}
+export async function openTaskCommandRepository(cwd, signal) {
+    const context = await taskCommandContext(cwd, signal);
+    const board = context.board;
+    const store = openTaskStoreAt(board, { signal });
     const repository = taskRepositoryFromStore(store);
-    if (board.mode !== "git")
+    if (!context.contractId || !context.namespace)
         return repository;
-    const contractId = await contractBoundByEngineWorktree(cwd, board.root);
-    return contractId ? withTaskWorktreePolicy(repository, contractId) : repository;
+    return withTaskWorktreePolicy(repository, context.contractId, context.namespace);
+}
+export async function openTaskMutationContext(cwd, signal) {
+    const context = await taskCommandContext(cwd, signal);
+    const store = openTaskStoreAt(context.board, { signal });
+    const repository = taskRepositoryFromStore(store);
+    return {
+        repository: context.contractId && context.namespace
+            ? withTaskWorktreePolicy(repository, context.contractId, context.namespace)
+            : repository,
+        namespace: context.namespace ?? null,
+    };
+}
+export async function taskCommandNamespace(cwd) {
+    const context = await taskCommandContext(cwd);
+    return context.namespace ?? null;
 }
 export async function taskContractIds(cwd) {
-    return new Set(await listContractIds(await stableRepoRoot(cwd)));
+    const read = await readRepositoryLifecycle(await stableRepoRoot(cwd));
+    return new Set(read.contracts.map((model) => model.contract));
 }
 export async function readTaskDoctor(cwd) {
     const store = await openTaskStore(cwd);
-    const repository = taskRepositoryFromStore(store);
+    const repository = await openTaskCommandRepository(cwd);
     const gitMode = store.mode === "git";
     const lockHeld = (await inspectTaskLock(cwd)).state === "held";
     return inspectTaskDoctor(store, repository, {

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

@@ -1,15 +1,15 @@
-import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { setTimeout as delay } from "node:timers/promises";
 import { FlowError } from "../../flow-error.js";
-import { syncDirectorySync } from "../../fs/durability.js";
 import { normalizeFilesystemCoordinate } from "../../fs/path-coordinate.js";
 import { isGitExecutableUnavailable, NOT_GIT_REPOSITORY_PATTERNS, runGitProcess } from "../../git/core.js";
 import { gitCommonRootPath, normalizeGitPath } from "../../git/path-coordinate.js";
 import { inspectCurrentBranch, publishTaskMutationCommit } from "./settlement-git.js";
-import { isTaskId } from "./validation.js";
+import { createTaskFileTransaction, generationFor, sameSources, taskBoardGeneration, validateTaskMutationWrites, } from "./task-file-transaction.js";
+export { assertTaskBoardGeneration, atomicReplaceTaskFile } from "./task-file-transaction.js";
+import { isTaskCoordinate, parseTaskCoordinate, taskCoordinateFromSourcePath } from "./coordinate.js";
 const SQLITE_BUSY = 5;
 const LOCK_FILE = "task-lock.sqlite";
 const GIT_LOCK_FILE = "keiyaku-task-lock.sqlite";
@@ -99,15 +99,16 @@ export async function locateTaskBoard(cwd, runGitProbe = defaultRunGit) {
     return {
         mode: "git",
         root: taskBoardRootFromGitDir(gitDir),
+        surfaceRoot: normalizedCheckoutRoot,
         gitDir,
     };
 }
 function taskDirectory(board) {
-    return path.join(board.root, ".keiyaku", "tasks");
+    return path.join(board.mode === "git" ? board.surfaceRoot : board.root, ".keiyaku", "tasks");
 }
 const TASK_HISTORY_FORMAT = "%aI%x00%an%x00%s";
-function taskHistoryPath(taskId) {
-    return `.keiyaku/tasks/${taskId}.md`;
+function taskHistoryPath(coordinate) {
+    return `.keiyaku/tasks/${coordinate}.md`;
 }
 function parseTaskHistory(output) {
     const fields = output.split("\0");
@@ -129,7 +130,7 @@ function parseTaskHistory(output) {
     return entries;
 }
 function assertKeiyakuDirectory(board) {
-    const keiyakuDirectory = path.join(board.root, ".keiyaku");
+    const keiyakuDirectory = path.join(board.mode === "git" ? board.surfaceRoot : board.root, ".keiyaku");
     const stat = lstatIfPresent(keiyakuDirectory);
     if (stat && (stat.isSymbolicLink() || !stat.isDirectory())) {
         throw new FlowError("INTERNAL_STATE", `.keiyaku is not a regular directory: ${keiyakuDirectory}`);
@@ -224,23 +225,21 @@ export async function inspectTaskLock(cwd) {
         closeQuietly(database);
     }
 }
-/** Read the current hub branch's task-specific Git history without acquiring the task lock. */
+/** Read the current checkout branch's task-specific Git history without acquiring the task lock. */
 export async function readTaskHistory(cwd, taskId, deps = {}) {
-    if (!isTaskId(taskId)) {
-        throw new FlowError("INVALID_TARGET", `task history requires a canonical task id: ${taskId}`);
-    }
+    const coordinate = parseTaskCoordinate(taskId, "task history coordinate").coordinate;
     const board = await locateTaskBoard(cwd, deps.runGit);
     if (board.mode !== "git") {
         throw new FlowError("NOT_GIT_REPO", "task history is available only in a Git repository");
     }
-    const result = await (deps.runGit ?? defaultRunGit)(board.root, [
+    const result = await (deps.runGit ?? defaultRunGit)(board.surfaceRoot, [
         "log",
         "-z",
         "--topo-order",
         "--reverse",
         `--format=${TASK_HISTORY_FORMAT}`,
         "--",
-        taskHistoryPath(taskId),
+        taskHistoryPath(coordinate),
     ]);
     if (result.error) {
         throw new FlowError("INTERNAL_STATE", `cannot read task history: ${result.error.message}`, { cause: result.error });
@@ -251,34 +250,6 @@ export async function readTaskHistory(cwd, taskId, deps = {}) {
     }
     return parseTaskHistory(result.stdout);
 }
-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);
@@ -296,81 +267,29 @@ async function readTaskSources(directory) {
     if (directoryStat.isSymbolicLink() || !directoryStat.isDirectory()) {
         throw new FlowError("INTERNAL_STATE", `task directory is not a regular directory: ${directory}`);
     }
-    const names = fs.readdirSync(directory)
-        .filter((name) => name.endsWith(".md"))
-        .sort((left, right) => Buffer.from(left).compare(Buffer.from(right)));
-    return names.map((name) => {
-        const sourcePath = path.join(directory, name);
-        const sourceStat = fs.lstatSync(sourcePath);
-        if (sourceStat.isSymbolicLink() || !sourceStat.isFile()) {
-            throw new FlowError("INTERNAL_STATE", `task source is not a regular file: ${sourcePath}`);
-        }
-        return {
-            path: sourcePath,
-            text: fs.readFileSync(sourcePath, "utf8"),
-        };
-    });
-}
-function validatePlan(plan) {
-    validateWrites(plan.writes);
-}
-function validateWrites(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 (!isTaskId(write.id)) {
-            throw new FlowError("INTERNAL_STATE", `invalid task mutation id: ${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}`);
+    const sources = [];
+    const visit = (current, depth) => {
+        for (const name of fs.readdirSync(current).sort((left, right) => Buffer.from(left).compare(Buffer.from(right)))) {
+            const sourcePath = path.join(current, name);
+            const sourceStat = fs.lstatSync(sourcePath);
+            if (sourceStat.isSymbolicLink())
+                throw new FlowError("INTERNAL_STATE", `task source is a symbolic link: ${sourcePath}`);
+            if (sourceStat.isDirectory()) {
+                if (depth !== 0 || !isTaskCoordinate(name)) {
+                    throw new FlowError("INTERNAL_STATE", `task namespace must be one canonical directory level: ${sourcePath}`);
+                }
+                visit(sourcePath, depth + 1);
+            }
+            else if (sourceStat.isFile() && name.endsWith(".md")) {
+                sources.push({ path: sourcePath, text: fs.readFileSync(sourcePath, "utf8") });
+            }
+            else {
+                throw new FlowError("INTERNAL_STATE", `task source is not a Markdown file: ${sourcePath}`);
+            }
         }
-        return { path: destination, text: fs.readFileSync(destination, "utf8") };
-    });
-}
-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;
-    });
-}
-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);
+    };
+    visit(directory, 0);
+    return sources;
 }
 function releaseTaskLock(database, deps) {
     try {
@@ -389,12 +308,6 @@ function releaseTaskLock(database, deps) {
         closeQuietly(database);
     }
 }
-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 openTaskStoreAt(board, deps = {}) {
     const directory = taskDirectory(board);
     return {
@@ -407,23 +320,24 @@ export function openTaskStoreAt(board, deps = {}) {
             return withLockHeldTaskBoard(board.root, async (transaction) => {
                 const previousSources = transaction.sources;
                 const plan = await apply(transaction.sources);
-                validatePlan(plan);
+                validateTaskMutationWrites(plan.writes);
                 let subject;
                 if (transaction.location.mode === "git") {
                     subject = plan.subject?.trim();
                     if (!subject) {
                         throw new FlowError("INTERNAL_STATE", "git task mutation requires a micro-commit subject");
                     }
-                    await inspectCurrentBranch(transaction.location.root);
+                    await inspectCurrentBranch(transaction.location.surfaceRoot, deps.signal);
                 }
                 await transaction.replace(plan.writes);
                 if (transaction.location.mode === "git") {
                     try {
                         await (deps.publishMutation ?? publishTaskMutationCommit)({
-                            cwd: transaction.location.root,
+                            cwd: transaction.location.surfaceRoot,
                             gitDir: transaction.location.gitDir,
                             writes: plan.writes,
                             subject: subject,
+                            signal: deps.signal,
                         });
                     }
                     catch (error) {
@@ -446,55 +360,40 @@ export async function withLockHeldTaskBoard(cwd, apply, deps = {}, locatedBoard)
     const database = await acquireTaskLockWithAdmission(taskLockPath(board), deps);
     try {
         let sources = await readTaskSources(directory);
-        const transaction = {
+        const transaction = createTaskFileTransaction({
             location: board,
-            get sources() {
-                return sources;
-            },
-            async replace(writes) {
-                validateWrites(writes);
-                assertKeiyakuDirectory(board);
-                assertTaskDirectorySafety(directory);
-                const currentSources = await readTaskSources(directory);
-                if (!sameSources(sources, currentSources)) {
-                    throw new FlowError("CONCURRENT_MODIFICATION", "task sources changed while applying the mutation");
-                }
-                assertKeiyakuDirectory(board);
-                assertTaskDirectorySafety(directory);
-                const previous = capturePreviousFiles(directory, writes);
-                let applied = 0;
-                try {
-                    for (const write of writes) {
-                        writeTaskFile(directory, write, deps);
-                        applied += 1;
-                    }
-                }
-                catch (error) {
-                    try {
-                        restoreFiles(previous.slice(0, applied + 1), deps);
-                    }
-                    catch { /* the original replacement failure remains authoritative */ }
-                    throw error;
-                }
-                sources = await readTaskSources(directory);
-            },
-            async restore(writes, previousSources) {
-                validateWrites(writes);
-                const currentSources = await readTaskSources(directory);
-                if (!sameSources(sources, currentSources)) {
-                    throw new FlowError("CONCURRENT_MODIFICATION", "task sources changed while rolling back a failed publication");
-                }
-                const previousById = new Map(previousSources.map((source) => [path.basename(source.path, ".md"), source.text]));
-                restoreFiles(writes.map((write) => ({
-                    path: path.join(directory, mutationTarget(write)),
-                    text: previousById.get(write.id),
-                })), deps);
-                sources = await readTaskSources(directory);
-            },
-        };
+            directory,
+            getSources: () => sources,
+            setSources: (next) => { sources = next; },
+            readSources: () => readTaskSources(directory),
+            assertBoardSafety: () => assertKeiyakuDirectory(board),
+            deps,
+        });
         return await apply(transaction);
     }
     finally {
         releaseTaskLock(database, deps);
     }
 }
+export async function readTaskBoardGeneration(cwd, signal) {
+    return withLockHeldTaskBoard(cwd, taskBoardGeneration, { signal });
+}
+/** Read-only stable observation for preflight paths that must not create the task lock database. */
+export async function observeTaskBoardSnapshot(cwd, deps = {}) {
+    const location = await locateTaskBoard(cwd, deps.runGit);
+    const directory = taskDirectory(location);
+    const first = await readTaskSources(directory);
+    const generation = generationFor(location, first);
+    const second = await readTaskSources(directory);
+    if (!sameSources(first, second)) {
+        throw new FlowError("CONCURRENT_MODIFICATION", "task sources changed during read-only observation");
+    }
+    return { generation, sources: second };
+}
+export async function readTaskNamespaces(cwd) {
+    const snapshot = await observeTaskBoardSnapshot(cwd);
+    return new Set(snapshot.sources.flatMap((source) => {
+        const namespace = taskCoordinateFromSourcePath(source.path).namespace;
+        return namespace === null ? [] : [namespace];
+    }));
+}

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

@@ -1,15 +1,20 @@
 import { requireHealthy } from "./board.js";
-import { parseTaskDocument, serializeTaskDocument } from "./document.js";
+import { serializeTaskDocument } from "./document.js";
 import { buildTaskSourceBoard } from "./source-board.js";
+import { formatTaskCoordinate, taskCoordinateFromSourcePath } from "./coordinate.js";
 export function taskBoardFromSourceBoard(sourceBoard) {
     const tasks = sourceBoard.tasks.map((task) => ({
         id: task.id,
+        namespace: task.namespace,
+        coordinate: task.coordinate,
         title: task.title,
         state: task.state,
         pri: task.pri,
         needs: [...task.needs],
         parent: task.parent,
         from: [...task.from],
+        supersedes: [...task.supersedes],
+        relatesTo: [...task.relatesTo],
         createdAt: task.createdAt,
         ...(task.updatedAt === undefined ? {} : { updatedAt: task.updatedAt }),
         creator: task.creator,
@@ -19,6 +24,8 @@ export function taskBoardFromSourceBoard(sourceBoard) {
         blocks: [...task.blocks],
         blocked: task.blocked,
         releasedNeeds: [...task.releasedNeeds],
+        supersededBy: [...task.supersededBy],
+        relatedTasks: [...task.relatedTasks],
     }));
     return {
         tasks,
@@ -28,21 +35,21 @@ export function taskBoardFromSourceBoard(sourceBoard) {
             ...(disease.id === undefined ? {} : { id: disease.id }),
             ...(disease.relatedIds === undefined ? {} : { relatedIds: [...disease.relatedIds] }),
         })),
-        byId: new Map(tasks.map((task) => [task.id, task])),
+        byId: new Map(tasks.map((task) => [task.coordinate, task])),
     };
 }
 export function prepareTaskDocumentReplacements(sources, replacements) {
     const serialized = replacements.map((document) => ({
-        id: document.id,
+        id: document.coordinate ?? formatTaskCoordinate(document.namespace ?? null, document.id),
         text: serializeTaskDocument(document),
     }));
     const replacementIds = new Set(serialized.map((replacement) => replacement.id));
     const paths = new Map();
     const retained = sources.filter((source) => {
         try {
-            const id = parseTaskDocument(source).id;
-            paths.set(id, source.path);
-            return !replacementIds.has(id);
+            const sourceCoordinate = taskCoordinateFromSourcePath(source.path).coordinate;
+            paths.set(sourceCoordinate, source.path);
+            return !replacementIds.has(sourceCoordinate);
         }
         catch {
             // Malformed sources remain quarantined and visible to the resulting board.

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

@@ -1,40 +1,13 @@
 import { FlowError } from "../../flow-error.js";
-function documentFacts(task) {
-    return JSON.stringify({
-        id: task.id,
-        title: task.title,
-        state: task.state,
-        pri: task.pri,
-        needs: [...task.needs],
-        parent: task.parent,
-        from: [...task.from],
-        createdAt: task.createdAt,
-        creator: task.creator,
-        ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
-        ...(task.contractId === undefined ? {} : { contractId: task.contractId }),
-        body: task.body,
-    });
-}
-function isNeedsAppend(prior, next) {
-    return next.needs.length > prior.needs.length
-        && prior.needs.every((need, index) => next.needs[index] === need)
-        && new Set(next.needs).size === next.needs.length
-        && documentFacts(prior) === documentFacts({ ...next, needs: prior.needs });
-}
-export function validateTaskWorktreeMutation(before, replacements, after, contractId) {
-    const existing = new Map(before.tasks.map((task) => [task.id, task]));
-    const bound = before.tasks.filter((task) => task.contractId === contractId);
+import { formatTaskCoordinate } from "./coordinate.js";
+export function validateTaskWorktreeMutation(_before, replacements, _after, contractId, namespace) {
     for (const replacement of replacements) {
-        const prior = existing.get(replacement.id);
-        if (!prior)
-            continue;
-        const next = after.byId.get(replacement.id);
-        if (bound.length === 1 && prior.id === bound[0].id && next && isNeedsAppend(prior, next))
+        if (replacement.namespace === namespace)
             continue;
-        throw new FlowError("UNSUPPORTED_POLICY", `task ${replacement.id} is not yours; this checkout is bound to contract ${contractId}`);
+        throw new FlowError("UNSUPPORTED_POLICY", `task ${replacement.coordinate ?? formatTaskCoordinate(replacement.namespace ?? null, replacement.id)} is outside contract ${contractId} namespace ${namespace}`);
     }
 }
-export function withTaskWorktreePolicy(repository, contractId) {
+export function withTaskWorktreePolicy(repository, contractId, namespace) {
     return {
         read: repository.read.bind(repository),
         mutate: async (apply) => repository.mutate(async (before) => {
@@ -43,7 +16,7 @@ export function withTaskWorktreePolicy(repository, contractId) {
                 replacements: mutation.replacements,
                 ...(mutation.subject === undefined ? {} : { subject: mutation.subject }),
                 select(after) {
-                    validateTaskWorktreeMutation(before, mutation.replacements, after, contractId);
+                    validateTaskWorktreeMutation(before, mutation.replacements, after, contractId, namespace);
                     return mutation.select(after);
                 },
             };

package/build/core/task/task.js

@@ -4,4 +4,4 @@ export { parseTaskDocument, serializeTaskDocument, } from "./document.js";
 export { resolveTaskReadId, } from "./board.js";
 export { buildTaskBoard } from "./source-board.js";
 export { buildTaskTree } from "./tree.js";
-export { readTaskBoard, createTask, updateTask, startTask, stopTask, doneTask, dropTask, selectSoleInProgress, rollbackOrphanTaskPointers, } from "./commands.js";
+export { readTaskBoard, createTask, updateTask, updateTaskWithReceipt, startTask, stopTask, holdTask, resumeTask, doneTask, dropTask, selectSoleInProgress, rollbackOrphanTaskPointers, } from "./commands.js";

package/build/core/task/tree.js

@@ -8,7 +8,7 @@ function compareBoardOrder(left, right) {
     return leftTerminal - rightTerminal
         || left.pri - right.pri
         || compareText(left.createdAt, right.createdAt)
-        || compareText(left.id, right.id);
+        || compareText(left.coordinate, right.coordinate);
 }
 function diagnosticOrder(left, right) {
     return compareText(left.code, right.code)
@@ -25,10 +25,10 @@ export function buildTaskTree(board, rootId) {
     for (const children of childrenByParent.values())
         children.sort(compareBoardOrder);
     const visit = (parentId, ancestors) => (childrenByParent.get(parentId) ?? [])
-        .filter((child) => !ancestors.has(child.id))
+        .filter((child) => !ancestors.has(child.coordinate))
         .map((child) => ({
         task: child,
-        children: visit(child.id, new Set([...ancestors, child.id])),
+        children: visit(child.coordinate, new Set([...ancestors, child.coordinate])),
     }));
     return {
         descendants: visit(rootId, new Set([rootId])),

package/build/core/task/validation.js

@@ -1,6 +1,7 @@
 import { FlowError } from "../../flow-error.js";
 import { isNormalizedIdentifierSlug } from "../identifier-slug.js";
-export const TASK_STATES = new Set(["open", "in_progress", "done", "drop"]);
+import { isTaskCoordinate } from "./coordinate.js";
+export const TASK_STATES = new Set(["open", "in_progress", "on_hold", "done", "drop"]);
 const CANONICAL_ISO_UTC_MS = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
 export function invalid(message) {
     throw new FlowError("INVALID_TARGET", message);
@@ -13,8 +14,8 @@ export function nonblank(field, value) {
 }
 export function fullId(field, value) {
     const id = nonblank(field, value);
-    if (!isTaskId(id))
-        invalid(`task field '${field}' must be a canonical full task id`);
+    if (!isTaskCoordinate(id))
+        invalid(`task field '${field}' must be a canonical full task coordinate`);
     return id;
 }
 export function isTaskId(value) {