@astrosheep/keiyaku 2.9.12 → 4.0.0

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

@@ -1,97 +0,0 @@
-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";
-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 { 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 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 (!context.contractId || !context.namespace)
-        return 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) {
-    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 = await openTaskCommandRepository(cwd);
-    const gitMode = store.mode === "git";
-    const lockHeld = (await inspectTaskLock(cwd)).state === "held";
-    return inspectTaskDoctor(store, repository, {
-        contractIds: gitMode ? await taskContractIds(cwd) : new Set(),
-        landingDiagnostics: [],
-        lockHeld,
-    });
-}

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

@@ -1,400 +0,0 @@
-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 { 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 { 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";
-export const TASK_LOCK_ADMISSION_TIMEOUT_MS = 4_000;
-export const TASK_LOCK_ADMISSION_INITIAL_DELAY_MS = 10;
-export const TASK_LOCK_ADMISSION_MAX_DELAY_MS = 100;
-export class TaskLockHeldError extends Error {
-    path;
-    code = "TASK_LOCK_HELD";
-    constructor(path, options) {
-        super(`task lock is already held: ${path}`, options);
-        this.path = path;
-        this.name = "TaskLockHeldError";
-    }
-}
-export class TaskLockAdmissionTimeoutError extends FlowError {
-    path;
-    timeoutMs;
-    constructor(path, timeoutMs, options) {
-        super("TASK_LOCK_ADMISSION_TIMEOUT", `task lock admission timed out after ${timeoutMs}ms: ${path}`, { cause: options?.cause });
-        this.path = path;
-        this.timeoutMs = timeoutMs;
-        this.name = "TaskLockAdmissionTimeoutError";
-    }
-}
-function errorText(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function isSqliteBusy(error) {
-    return typeof error === "object"
-        && error !== null
-        && "errcode" in error
-        && error.errcode === SQLITE_BUSY;
-}
-async function defaultRunGit(cwd, args, input) {
-    return await runGitProcess(cwd, args, { input });
-}
-function nearestDirectoryBoard(cwd) {
-    const original = path.resolve(normalizeFilesystemCoordinate(cwd));
-    let candidate = original;
-    while (true) {
-        if (lstatIfPresent(path.join(candidate, ".keiyaku")))
-            return candidate;
-        const parent = path.dirname(candidate);
-        if (parent === candidate)
-            return original;
-        candidate = parent;
-    }
-}
-export function taskBoardRootFromGitDir(rawGitDir, platform = process.platform) {
-    return gitCommonRootPath(rawGitDir, platform);
-}
-export async function locateTaskBoard(cwd, runGitProbe = defaultRunGit) {
-    cwd = normalizeFilesystemCoordinate(cwd);
-    const probe = await runGitProbe(cwd, ["rev-parse", "--is-inside-work-tree", "--is-bare-repository"]);
-    if (probe.error && !isGitExecutableUnavailable(probe.error)) {
-        throw new FlowError("INTERNAL_STATE", `cannot inspect task repository: ${probe.error.message}`, { cause: probe.error });
-    }
-    if (probe.error) {
-        return { mode: "directory", root: nearestDirectoryBoard(cwd), capability: "unavailable" };
-    }
-    if (probe.status !== 0) {
-        if (NOT_GIT_REPOSITORY_PATTERNS.some((pattern) => probe.stderr.includes(pattern))) {
-            return { mode: "directory", root: nearestDirectoryBoard(cwd) };
-        }
-        const detail = probe.stderr.trim() || `exit ${String(probe.status)}`;
-        throw new FlowError("INTERNAL_STATE", `cannot inspect task repository: ${detail}`);
-    }
-    const [insideWorktree, bare] = probe.stdout.trim().split(/\r?\n/);
-    if (bare === "true" || insideWorktree !== "true") {
-        throw new FlowError("NOT_GIT_REPO", "bare repositories are not supported for task storage");
-    }
-    const facts = await runGitProbe(cwd, ["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir"]);
-    if (facts.error) {
-        throw new FlowError("INTERNAL_STATE", `git rev-parse failed: ${facts.error.message}`, { cause: facts.error });
-    }
-    if (facts.status !== 0) {
-        const detail = facts.stderr.trim() || `exit ${String(facts.status)}`;
-        throw new FlowError("INTERNAL_STATE", `git rev-parse failed: ${detail}`);
-    }
-    const [checkoutRoot, rawGitDir] = facts.stdout.trimEnd().split(/\r?\n/);
-    const gitDir = rawGitDir === undefined ? undefined : normalizeGitPath(rawGitDir);
-    const normalizedCheckoutRoot = checkoutRoot === undefined ? undefined : normalizeGitPath(checkoutRoot);
-    if (!normalizedCheckoutRoot || !gitDir || !path.isAbsolute(normalizedCheckoutRoot) || !path.isAbsolute(gitDir)) {
-        throw new FlowError("INTERNAL_STATE", "git returned incomplete task-board location facts");
-    }
-    return {
-        mode: "git",
-        root: taskBoardRootFromGitDir(gitDir),
-        surfaceRoot: normalizedCheckoutRoot,
-        gitDir,
-    };
-}
-function taskDirectory(board) {
-    return path.join(board.mode === "git" ? board.surfaceRoot : board.root, ".keiyaku", "tasks");
-}
-const TASK_HISTORY_FORMAT = "%aI%x00%an%x00%s";
-function taskHistoryPath(coordinate) {
-    return `.keiyaku/tasks/${coordinate}.md`;
-}
-function parseTaskHistory(output) {
-    const fields = output.split("\0");
-    if (fields.at(-1) !== "") {
-        throw new FlowError("INTERNAL_STATE", "task history returned an incomplete record");
-    }
-    fields.pop();
-    if (fields.length % 3 !== 0) {
-        throw new FlowError("INTERNAL_STATE", "task history returned an incomplete record");
-    }
-    const entries = [];
-    for (let index = 0; index < fields.length; index += 3) {
-        entries.push({
-            timestamp: fields[index],
-            actor: fields[index + 1],
-            subject: fields[index + 2],
-        });
-    }
-    return entries;
-}
-function assertKeiyakuDirectory(board) {
-    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}`);
-    }
-}
-function taskLockPath(board) {
-    return board.mode === "git"
-        ? path.join(board.gitDir, GIT_LOCK_FILE)
-        : path.join(board.root, ".keiyaku", LOCK_FILE);
-}
-function closeQuietly(database) {
-    try {
-        database.close();
-    }
-    catch {
-        // The original operation remains authoritative.
-    }
-}
-function acquireTaskLock(lockPath) {
-    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-    let database;
-    try {
-        database = new DatabaseSync(lockPath);
-    }
-    catch (error) {
-        throw new FlowError("INTERNAL_STATE", `cannot open task lock: ${errorText(error)}`, { cause: error });
-    }
-    try {
-        database.exec("PRAGMA busy_timeout=0");
-        database.exec("PRAGMA journal_mode=DELETE");
-        database.exec("CREATE TABLE IF NOT EXISTS lock_anchor (id INTEGER PRIMARY KEY CHECK (id = 1))");
-        database.exec("BEGIN EXCLUSIVE");
-        database.prepare("SELECT id FROM lock_anchor LIMIT 1").get();
-        return database;
-    }
-    catch (error) {
-        closeQuietly(database);
-        if (isSqliteBusy(error))
-            throw new TaskLockHeldError(lockPath, { cause: error });
-        throw new FlowError("INTERNAL_STATE", `cannot acquire task lock: ${errorText(error)}`, { cause: error });
-    }
-}
-async function acquireTaskLockWithAdmission(lockPath, deps) {
-    const now = deps.now ?? Date.now;
-    const random = deps.random ?? Math.random;
-    const sleep = deps.sleep ?? ((milliseconds, signal) => (delay(milliseconds, undefined, signal ? { signal } : undefined)));
-    const deadline = now() + TASK_LOCK_ADMISSION_TIMEOUT_MS;
-    let delayCapMs = TASK_LOCK_ADMISSION_INITIAL_DELAY_MS;
-    for (;;) {
-        deps.signal?.throwIfAborted();
-        try {
-            return acquireTaskLock(lockPath);
-        }
-        catch (error) {
-            if (!(error instanceof TaskLockHeldError))
-                throw error;
-            const observedAt = now();
-            if (observedAt >= deadline) {
-                throw new TaskLockAdmissionTimeoutError(lockPath, TASK_LOCK_ADMISSION_TIMEOUT_MS, { cause: error });
-            }
-            const unit = Math.max(0, Math.min(1, random()));
-            const jitteredDelayMs = Math.ceil((delayCapMs / 2) + ((delayCapMs / 2) * unit));
-            await sleep(Math.min(jitteredDelayMs, deadline - observedAt), deps.signal);
-            delayCapMs = Math.min(TASK_LOCK_ADMISSION_MAX_DELAY_MS, delayCapMs * 2);
-        }
-    }
-}
-export async function inspectTaskLock(cwd) {
-    const lockPath = taskLockPath(await locateTaskBoard(cwd));
-    if (!fs.existsSync(lockPath))
-        return { state: "free", path: lockPath };
-    let database;
-    try {
-        database = new DatabaseSync(lockPath, { readOnly: true });
-    }
-    catch (error) {
-        throw new FlowError("INTERNAL_STATE", `cannot inspect task lock: ${errorText(error)}`, { cause: error });
-    }
-    try {
-        database.exec("PRAGMA busy_timeout=0");
-        database.exec("BEGIN DEFERRED");
-        database.prepare("SELECT id FROM lock_anchor LIMIT 1").get();
-        database.exec("ROLLBACK");
-        return { state: "free", path: lockPath };
-    }
-    catch (error) {
-        if (isSqliteBusy(error))
-            return { state: "held", path: lockPath };
-        throw new FlowError("INTERNAL_STATE", `cannot inspect task lock: ${errorText(error)}`, { cause: error });
-    }
-    finally {
-        closeQuietly(database);
-    }
-}
-/** Read the current checkout branch's task-specific Git history without acquiring the task lock. */
-export async function readTaskHistory(cwd, taskId, deps = {}) {
-    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.surfaceRoot, [
-        "log",
-        "-z",
-        "--topo-order",
-        "--reverse",
-        `--format=${TASK_HISTORY_FORMAT}`,
-        "--",
-        taskHistoryPath(coordinate),
-    ]);
-    if (result.error) {
-        throw new FlowError("INTERNAL_STATE", `cannot read task history: ${result.error.message}`, { cause: result.error });
-    }
-    if (result.status !== 0) {
-        const detail = result.stderr.trim() || `exit ${String(result.status)}`;
-        throw new FlowError("INTERNAL_STATE", `cannot read task history: ${detail}`);
-    }
-    return parseTaskHistory(result.stdout);
-}
-function lstatIfPresent(target) {
-    try {
-        return fs.lstatSync(target);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return undefined;
-        throw error;
-    }
-}
-async function readTaskSources(directory) {
-    const directoryStat = lstatIfPresent(directory);
-    if (!directoryStat)
-        return [];
-    if (directoryStat.isSymbolicLink() || !directoryStat.isDirectory()) {
-        throw new FlowError("INTERNAL_STATE", `task directory is not a regular directory: ${directory}`);
-    }
-    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}`);
-            }
-        }
-    };
-    visit(directory, 0);
-    return sources;
-}
-function releaseTaskLock(database, deps) {
-    try {
-        if (deps.releaseLock)
-            deps.releaseLock();
-        else
-            database.exec("COMMIT");
-    }
-    catch {
-        try {
-            database.exec("ROLLBACK");
-        }
-        catch { /* close releases the advisory lock */ }
-    }
-    finally {
-        closeQuietly(database);
-    }
-}
-export function openTaskStoreAt(board, deps = {}) {
-    const directory = taskDirectory(board);
-    return {
-        mode: board.mode,
-        read: async () => {
-            assertKeiyakuDirectory(board);
-            return readTaskSources(directory);
-        },
-        async mutate(apply) {
-            return withLockHeldTaskBoard(board.root, async (transaction) => {
-                const previousSources = transaction.sources;
-                const plan = await apply(transaction.sources);
-                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.surfaceRoot, deps.signal);
-                }
-                await transaction.replace(plan.writes);
-                if (transaction.location.mode === "git") {
-                    try {
-                        await (deps.publishMutation ?? publishTaskMutationCommit)({
-                            cwd: transaction.location.surfaceRoot,
-                            gitDir: transaction.location.gitDir,
-                            writes: plan.writes,
-                            subject: subject,
-                            requireCommit: plan.requireCommit,
-                            signal: deps.signal,
-                        });
-                    }
-                    catch (error) {
-                        await transaction.restore(plan.writes, previousSources);
-                        throw error;
-                    }
-                }
-                return plan.value;
-            }, deps, board);
-        },
-    };
-}
-export async function openTaskStore(cwd, deps = {}) {
-    return openTaskStoreAt(await locateTaskBoard(cwd, deps.runGit), deps);
-}
-export async function withLockHeldTaskBoard(cwd, apply, deps = {}, locatedBoard) {
-    const board = locatedBoard ?? await locateTaskBoard(cwd, deps.runGit);
-    const directory = taskDirectory(board);
-    assertKeiyakuDirectory(board);
-    const database = await acquireTaskLockWithAdmission(taskLockPath(board), deps);
-    try {
-        let sources = await readTaskSources(directory);
-        const transaction = createTaskFileTransaction({
-            location: board,
-            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-repository.js

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

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

@@ -1,96 +0,0 @@
-import { requireHealthy } from "./board.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,
-        ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
-        ...(task.contractId === undefined ? {} : { contractId: task.contractId }),
-        body: task.body,
-        blocks: [...task.blocks],
-        blocked: task.blocked,
-        releasedNeeds: [...task.releasedNeeds],
-        supersededBy: [...task.supersededBy],
-        relatedTasks: [...task.relatedTasks],
-    }));
-    return {
-        tasks,
-        diseases: sourceBoard.diseases.map((disease) => ({
-            code: disease.code,
-            message: disease.message,
-            ...(disease.id === undefined ? {} : { id: disease.id }),
-            ...(disease.relatedIds === undefined ? {} : { relatedIds: [...disease.relatedIds] }),
-        })),
-        byId: new Map(tasks.map((task) => [task.coordinate, task])),
-    };
-}
-export function prepareTaskDocumentReplacements(sources, replacements) {
-    const serialized = replacements.map((document) => ({
-        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 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.
-            return true;
-        }
-    });
-    const replacementSources = serialized.map((replacement) => ({
-        path: paths.get(replacement.id) ?? `${replacement.id}.md`,
-        text: replacement.text,
-    }));
-    const resultingSources = [...retained, ...replacementSources];
-    const board = taskBoardFromSourceBoard(buildTaskSourceBoard(resultingSources));
-    requireHealthy(board);
-    return {
-        sources: resultingSources,
-        writes: serialized,
-        board,
-    };
-}
-function mutationPlan(sources, mutation) {
-    const prepared = prepareTaskDocumentReplacements(sources, mutation.replacements);
-    return {
-        writes: prepared.writes,
-        value: mutation.select(prepared.board),
-        ...(mutation.subject === undefined ? {} : { subject: mutation.subject }),
-        requireCommit: mutation.requireCommit ?? true,
-    };
-}
-export function taskRepositoryFromStore(store) {
-    return {
-        read: async () => taskBoardFromSourceBoard(buildTaskSourceBoard(await store.read())),
-        mutate: async (apply) => store.mutate(async (sources) => mutationPlan(sources, await apply(taskBoardFromSourceBoard(buildTaskSourceBoard(sources))))),
-    };
-}
-export function taskRepositoryFromLockedBoard(transaction) {
-    return {
-        read: async () => taskBoardFromSourceBoard(buildTaskSourceBoard(transaction.sources)),
-        mutate: async (apply) => {
-            const plan = mutationPlan(transaction.sources, await apply(taskBoardFromSourceBoard(buildTaskSourceBoard(transaction.sources))));
-            await transaction.replace(plan.writes);
-            return plan.value;
-        },
-    };
-}

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

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

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

@@ -1,25 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { formatTaskCoordinate } from "./coordinate.js";
-export function validateTaskWorktreeMutation(_before, replacements, _after, contractId, namespace) {
-    for (const replacement of replacements) {
-        if (replacement.namespace === namespace)
-            continue;
-        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, namespace) {
-    return {
-        read: repository.read.bind(repository),
-        mutate: async (apply) => repository.mutate(async (before) => {
-            const mutation = await apply(before);
-            return {
-                replacements: mutation.replacements,
-                ...(mutation.subject === undefined ? {} : { subject: mutation.subject }),
-                select(after) {
-                    validateTaskWorktreeMutation(before, mutation.replacements, after, contractId, namespace);
-                    return mutation.select(after);
-                },
-            };
-        }),
-    };
-}

package/build/core/task/task.js

@@ -1,7 +0,0 @@
-export { deriveTaskDisplay, parseTaskFilter, parseTaskSort, selectTaskList } from "./query.js";
-export { advancedTaskUpdatedAt, taskUpdatedAt } from "./model.js";
-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, updateTaskWithReceipt, startTask, stopTask, holdTask, resumeTask, doneTask, dropTask, selectSoleInProgress, rollbackOrphanTaskPointers, } from "./commands.js";

package/build/core/task/tree.js

@@ -1,37 +0,0 @@
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-/** Board task order is the deterministic order for every parent child list. */
-function compareBoardOrder(left, right) {
-    const leftTerminal = left.state === "done" || left.state === "drop" ? 1 : 0;
-    const rightTerminal = right.state === "done" || right.state === "drop" ? 1 : 0;
-    return leftTerminal - rightTerminal
-        || left.pri - right.pri
-        || compareText(left.createdAt, right.createdAt)
-        || compareText(left.coordinate, right.coordinate);
-}
-function diagnosticOrder(left, right) {
-    return compareText(left.code, right.code)
-        || compareText(left.id ?? "", right.id ?? "")
-        || compareText(left.message, right.message);
-}
-export function buildTaskTree(board, rootId) {
-    const childrenByParent = new Map();
-    for (const task of board.tasks) {
-        if (task.parent === null)
-            continue;
-        childrenByParent.set(task.parent, [...(childrenByParent.get(task.parent) ?? []), task]);
-    }
-    for (const children of childrenByParent.values())
-        children.sort(compareBoardOrder);
-    const visit = (parentId, ancestors) => (childrenByParent.get(parentId) ?? [])
-        .filter((child) => !ancestors.has(child.coordinate))
-        .map((child) => ({
-        task: child,
-        children: visit(child.coordinate, new Set([...ancestors, child.coordinate])),
-    }));
-    return {
-        descendants: visit(rootId, new Set([rootId])),
-        diagnostics: [...board.diseases].sort(diagnosticOrder),
-    };
-}