@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/core/{verdict.js → settlement/verdict.js}

@@ -1,8 +1,7 @@
-import { FlowError } from "../flow-error.js";
-import { claimContract } from "./claim.js";
-import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
-import { assertClaimQueueHead, queueMembership, readQueueReadModel } from "./queue.js";
-import { deriveContractState } from "./status/lifecycle.js";
+import { FlowError } from "../../flow-error.js";
+import { activeLedgerRef, appendWithRetry, readLedger } from "../ledger.js";
+import { assertClaimQueueHead, readQueueReadModel } from "./queue.js";
+import { deriveContractState } from "../status/lifecycle.js";
 function latestVerdict(entries) {
     for (let index = entries.length - 1; index >= 0; index -= 1) {
         const entry = entries[index];
@@ -19,6 +18,10 @@ function assertPetitioned(contractId, entries) {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot verdict from state ${state.state}`);
     }
 }
+/**
+ * Append a verdict entry and return typed judgment facts.
+ * Does not claim, clean up, or otherwise execute delivery.
+ */
 export async function verdictContract(input) {
     const at = new Date(input.nowMs).toISOString();
     const current = await readLedger(input.cwd, input.contractId);
@@ -69,40 +72,9 @@ export async function verdictContract(input) {
     if (verdict.data.result !== input.result) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} already has ${verdict.data.result} verdict`);
     }
-    if (verdict.data.result === "rejected") {
-        // Rejected verdict naturally returns state to active and clears membership.
-        return {
-            contractId: input.contractId,
-            result: "rejected",
-            summary: verdict.data.summary,
-            queuePosition: null,
-        };
-    }
-    const claimOnApproval = input.claimOnApproval ?? true;
-    if (claimOnApproval) {
-        const claimed = await claimContract({
-            cwd: input.cwd,
-            contractId: input.contractId,
-            actor: "keiyaku",
-            nowMs: input.nowMs,
-            mergeDelivery: input.mergeDelivery,
-            afterMerge: input.afterMerge,
-        });
-        return {
-            contractId: input.contractId,
-            result: "approved",
-            summary: verdict.data.summary,
-            claimed,
-            queuePosition: null,
-        };
-    }
-    // claimOnApproval false remains petitioned at target-local position 1.
-    const model = await readQueueReadModel(input.cwd);
-    const membership = queueMembership(model, input.contractId);
     return {
         contractId: input.contractId,
-        result: "approved",
+        result: verdict.data.result,
         summary: verdict.data.summary,
-        queuePosition: membership?.position ?? 1,
     };
 }

package/build/core/status/board.js

@@ -1,15 +1,13 @@
 import { loadKeiyakuSettings } from "../../config/settings/loader.js";
 import { observeGitRepository } from "../../git/branches.js";
-import { listContractIds, readLedger } from "../ledger.js";
-import { readProjectionStatusBoard } from "../projection-status.js";
-import { deriveQueueReadModel, queueMembership, } from "../queue.js";
+import { readProjectionStatusBoard } from "../projection/index.js";
+import { deriveQueueReadModel, queueMembership, } from "../settlement/index.js";
 import { findOpenArc, getMaxArc, receiptsAfterFence } from "../seal.js";
-import { readTaskBoard } from "../task.js";
-import { openTaskStore } from "../task-git-store.js";
-import { taskRepositoryFromStore } from "../task-store-repository.js";
+import { openTaskStore, readTaskBoard, taskRepositoryFromStore, } from "../task/index.js";
 import { deriveBootstrapDiagnostics, deriveContractState, hasCurrentPetitionVerdict, isTerminalState, } from "./lifecycle.js";
 import { commissionTarget, evaluateBaseDrift, latestBase, resolveDefaultBranchFromSettings, } from "./drift.js";
 import { computeClaimReconciliation, } from "./reconciliation.js";
+import { readStatusLedgers } from "./ledger-batch.js";
 function compareTaskStatusRows(left, right) {
     if (left.pri !== right.pri)
         return left.pri - right.pri;
@@ -32,7 +30,15 @@ async function readTaskStatusSummary(cwd) {
         const blocked = eligible.filter((task) => task.state === "open" && task.blocked).length;
         if (board.tasks.length === 0 && board.diseases.length === 0)
             return undefined;
-        return { total: board.tasks.length, inProgress, ready, blocked, topTasks, diseases: board.diseases };
+        return {
+            total: board.tasks.length,
+            inProgress,
+            ready,
+            blocked,
+            omitted: inProgress + ready - topTasks.length,
+            topTasks,
+            diseases: board.diseases,
+        };
     }
     catch (error) {
         return {
@@ -40,6 +46,7 @@ async function readTaskStatusSummary(cwd) {
             inProgress: 0,
             ready: 0,
             blocked: 0,
+            omitted: 0,
             topTasks: [],
             diseases: [],
             diagnostic: error instanceof Error ? error.message : String(error),
@@ -148,7 +155,7 @@ export async function readKanshiBoard(cwd, now, opts) {
     if (repository.capability !== "available" || repository.coordinate !== "repository") {
         return {
             contracts: [],
-            projections: readProjectionStatusBoard(cwd, now, { showAll: opts?.showAllProjections }),
+            projections: await readProjectionStatusBoard(cwd, now, { showAll: opts?.showAllProjections }),
             queueLength: 0,
             diseases: loadedSettings.diseases,
             claimReconciliation: null,
@@ -165,22 +172,14 @@ export async function readKanshiBoard(cwd, now, opts) {
     catch {
         defaultBranch = null;
     }
-    const contractIds = await listContractIds(cwd);
     const terminalById = new Map();
-    const ledgers = [];
+    const ledgers = await readStatusLedgers(cwd);
     const readableLedgers = [];
-    for (const id of contractIds) {
-        try {
-            const ledger = await readLedger(cwd, id);
-            if (ledger) {
-                ledgers.push(ledger);
-                readableLedgers.push(ledger);
-                terminalById.set(id, isTerminalState(deriveContractState(ledger.entries)));
-            }
-        }
-        catch (error) {
-            ledgers.push({ id, error: error instanceof Error ? error : new Error(String(error)) });
-        }
+    for (const ledger of ledgers) {
+        if ("error" in ledger)
+            continue;
+        readableLedgers.push(ledger);
+        terminalById.set(ledger.contractId, isTerminalState(deriveContractState(ledger.entries)));
     }
     const queueModel = deriveQueueReadModel(readableLedgers);
     const boardQueueLength = queueModel.targetQueues.reduce((sum, queue) => sum + queue.ordered.length, 0);
@@ -194,6 +193,7 @@ export async function readKanshiBoard(cwd, now, opts) {
             contracts.push({
                 id: item.id,
                 slug: contractSlugFromId(item.id),
+                title: contractSlugFromId(item.id),
                 state: { state: "corrupt", at: 0, reason: item.error.message },
                 queueHeadStalled: false,
                 arcs: 0,
@@ -245,6 +245,7 @@ export async function readKanshiBoard(cwd, now, opts) {
         contracts.push({
             id: item.contractId,
             slug: contractSlugFromId(item.contractId),
+            title: bind?.data.name ?? contractSlugFromId(item.contractId),
             state,
             queuePosition,
             queueHeadStalled: isQueueHeadStall({
@@ -277,7 +278,7 @@ export async function readKanshiBoard(cwd, now, opts) {
     const claimReconciliation = await computeClaimReconciliation(cwd, defaultBranch);
     return {
         contracts: filteredContracts,
-        projections: readProjectionStatusBoard(cwd, now, { showAll: opts?.showAllProjections }),
+        projections: await readProjectionStatusBoard(cwd, now, { showAll: opts?.showAllProjections }),
         queueLength,
         defaultBranch: defaultBranch?.branch,
         defaultHead: defaultBranch?.head,

package/build/core/status/ledger-batch.js

@@ -0,0 +1,158 @@
+import { wrapGitError, runGitProcess } from "../../git/core.js";
+import { GitStreamingBatchFramingError, GitStreamingBatchResponseEndedError, openGitStreamingBatch, } from "../../git/streaming-batch.js";
+import { parseLedgerEntryCommitMessage } from "../entry.js";
+import { ACTIVE_LEDGER_REF_PREFIX, } from "../ledger.js";
+const MAX_LEDGER_COMMIT_BYTES = 1024 * 1024;
+async function runStatusGit(cwd, args) {
+    const result = await runGitProcess(cwd, args);
+    if (result.error || result.status !== 0) {
+        throw wrapGitError(args.join(" "), {
+            message: result.error?.message
+                ?? `git exited with status ${result.status ?? "unknown"}`,
+            stderr: result.stderr,
+            stdout: result.stdout,
+        }, cwd);
+    }
+    return Buffer.from(result.stdout, "utf8");
+}
+async function queryBatchObject(batch, expression) {
+    const record = await batch.request(expression, {
+        maxContentBytes: MAX_LEDGER_COMMIT_BYTES,
+    });
+    if (record.kind === "missing" || record.kind === "ambiguous") {
+        throw new Error(`[git cat-file ${expression}] object is ${record.kind === "missing" ? "missing" : "ambiguous"}`);
+    }
+    return {
+        oid: record.record.oid,
+        type: record.record.type,
+        content: record.record.content,
+    };
+}
+function parseCommitObject(object) {
+    if (object.type !== "commit") {
+        throw new Error(`git cat-file expected commit ${object.oid}, received ${object.type}`);
+    }
+    const content = object.content.toString("utf8");
+    const messageStart = content.indexOf("\n\n");
+    if (messageStart < 0)
+        throw new Error(`git commit ${object.oid} has no message separator`);
+    const parents = [];
+    for (const line of content.slice(0, messageStart).split("\n")) {
+        if (!line.startsWith("parent "))
+            continue;
+        const parent = line.slice("parent ".length);
+        if (!/^[0-9a-f]{40,64}$/.test(parent)) {
+            throw new Error(`git commit ${object.oid} has an invalid parent header`);
+        }
+        parents.push(parent);
+    }
+    return { oid: object.oid, parents, message: content.slice(messageStart + 2) };
+}
+function parseLedgerRefs(output) {
+    return output
+        .toString("utf8")
+        .split(/\r?\n/)
+        .filter((ref) => ref.startsWith(ACTIVE_LEDGER_REF_PREFIX))
+        .map((ref) => ({ contractId: ref.slice(ACTIVE_LEDGER_REF_PREFIX.length), ref }));
+}
+async function readLedgerFromBatch(batch, ref, commits) {
+    const headObject = await queryBatchObject(batch, `${ref.ref}^{commit}`);
+    const head = parseCommitObject(headObject);
+    commits.set(head.oid, Promise.resolve(head));
+    const ordered = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const visit = async (oid) => {
+        if (visited.has(oid))
+            return;
+        if (visiting.has(oid))
+            throw new Error(`git ledger ancestry contains a cycle at ${oid}`);
+        visiting.add(oid);
+        let pending = commits.get(oid);
+        if (!pending) {
+            pending = queryBatchObject(batch, oid).then(parseCommitObject);
+            commits.set(oid, pending);
+        }
+        const commit = await pending;
+        for (const parent of commit.parents)
+            await visit(parent);
+        visiting.delete(oid);
+        visited.add(oid);
+        ordered.push(commit);
+    };
+    await visit(head.oid);
+    return {
+        contractId: ref.contractId,
+        ref: ref.ref,
+        head: head.oid,
+        entries: ordered.map((commit) => parseLedgerEntryCommitMessage(commit.message)),
+    };
+}
+/**
+ * Read the aggregate status ledger snapshot with at most two Git processes:
+ * ref-name discovery and one framed, streaming object session.
+ */
+export async function readStatusLedgers(cwd) {
+    const refOutput = await runStatusGit(cwd, [
+        "for-each-ref",
+        "--sort=refname",
+        "--format=%(refname)",
+        ACTIVE_LEDGER_REF_PREFIX,
+    ]);
+    const refs = parseLedgerRefs(refOutput);
+    if (refs.length === 0)
+        return [];
+    const batch = openGitStreamingBatch(cwd);
+    const commits = new Map();
+    const results = [];
+    let readError;
+    try {
+        for (let index = 0; index < refs.length; index += 1) {
+            const ref = refs[index];
+            try {
+                results.push(await readLedgerFromBatch(batch, ref, commits));
+            }
+            catch (error) {
+                const diagnostic = error instanceof Error ? error : new Error(String(error));
+                results.push({ id: ref.contractId, error: diagnostic });
+                // Framing and mid-frame EOF both destroy the batch channel; isolate remaining refs.
+                if (error instanceof GitStreamingBatchFramingError
+                    || error instanceof GitStreamingBatchResponseEndedError) {
+                    const isolationReason = error instanceof GitStreamingBatchResponseEndedError
+                        ? "response ended"
+                        : "malformed frame";
+                    for (const pending of refs.slice(index + 1)) {
+                        results.push({
+                            id: pending.contractId,
+                            error: new Error(`git cat-file batch terminated after ${isolationReason}: ${diagnostic.message}`),
+                        });
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    catch (error) {
+        readError = error;
+    }
+    try {
+        const close = await batch.close();
+        if (!close.aborted && (close.timedOut || close.signal || close.code !== 0)) {
+            throw wrapGitError("cat-file --batch", {
+                message: close.timedOut
+                    ? "git timed out"
+                    : close.signal
+                        ? `git exited from signal ${close.signal}`
+                        : `git exited with status ${close.code ?? "unknown"}`,
+                stderr: close.stderr.toString("utf8"),
+            }, cwd);
+        }
+    }
+    catch (error) {
+        if (!readError)
+            readError = error;
+    }
+    if (readError)
+        throw readError;
+    return results;
+}

package/build/core/status/reconciliation.js

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { createGit } from "../../git/core.js";
+import { createGit, parseRevListOutput, wrapGitError } from "../../git/core.js";
 import { stableRepoRoot } from "../worktree-path.js";
 function isClaimReceipt(value) {
     if (!value || typeof value !== "object")
@@ -51,7 +51,13 @@ export async function computeClaimReconciliation(cwd, defaultBranch) {
     if (receiptLines.length === 0)
         return null;
     const git = createGit(cwd);
-    const firstParentHistory = (await git.raw(["rev-list", "--first-parent", defaultBranch.head])).trim().split("\n").filter(Boolean);
+    let firstParentHistory;
+    try {
+        firstParentHistory = parseRevListOutput(await git.raw(["rev-list", "--first-parent", defaultBranch.head]));
+    }
+    catch (error) {
+        throw wrapGitError(`rev-list --first-parent ${defaultBranch.head}`, error, cwd);
+    }
     const firstParentSet = new Set(firstParentHistory);
     let baselineIndex = -1;
     for (let index = receiptLines.length - 1; index >= 0; index -= 1) {
@@ -70,10 +76,10 @@ export async function computeClaimReconciliation(cwd, defaultBranch) {
         return line.record?.kind === "baseline" ? [{ line: line.line, reason: "non-chain" }] : [];
     });
     // Only records after the latest valid baseline belong to this fence window.
+    // Intentional degrade: rev-list failure yields empty segments plus non-chain receipt issues.
     let revList;
     try {
-        const output = await git.raw(["rev-list", "--first-parent", "--reverse", `${baseline.head}..${defaultBranch.head}`]);
-        revList = output.trim().split("\n").filter((h) => h.length > 0);
+        revList = parseRevListOutput(await git.raw(["rev-list", "--first-parent", "--reverse", `${baseline.head}..${defaultBranch.head}`]));
     }
     catch {
         return {

package/build/core/stored-agent-event.js

@@ -8,6 +8,9 @@ const optionalString = (value, key) => value[key] === undefined || typeof value[
 const nonNegativeSafeInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 const safeIntegerOrNull = (value) => value === null || (typeof value === "number" && Number.isSafeInteger(value));
 function isValidStoredWarning(warning) {
+    if (warning.reason === "rate-limit") {
+        return warning.state === "exhausted" && Object.keys(warning).length === 2;
+    }
     if (warning.reason === "retry") {
         return nonNegativeSafeInteger(warning.attempt)
             && nonNegativeSafeInteger(warning.maxRetries)

package/build/core/task/board.js

@@ -1,6 +1,5 @@
 import { FlowError } from "../../flow-error.js";
-import { TASK_ID } from "./validation.js";
-const TASK_READ_ID = /^k-[0-9a-f]{7,12}$/;
+import { isTaskId } from "./validation.js";
 function compareText(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
@@ -60,6 +59,30 @@ function cycleComponents(tasks) {
             visit(id);
     return cycles;
 }
+function parentCycleComponents(tasks) {
+    const cycles = [];
+    const visited = new Set();
+    for (const start of [...tasks.keys()].sort()) {
+        if (visited.has(start))
+            continue;
+        const path = [];
+        const positions = new Map();
+        let current = start;
+        while (current !== null && tasks.has(current) && !visited.has(current)) {
+            const prior = positions.get(current);
+            if (prior !== undefined) {
+                cycles.push(new Set(path.slice(prior)));
+                break;
+            }
+            positions.set(current, path.length);
+            path.push(current);
+            current = tasks.get(current).parent;
+        }
+        for (const id of path)
+            visited.add(id);
+    }
+    return cycles;
+}
 /** Derive the complete storage-neutral board from domain records. */
 export function buildTaskBoardFromDocuments(documents) {
     const diseases = [];
@@ -91,6 +114,17 @@ export function buildTaskBoardFromDocuments(documents) {
             candidates.delete(id);
         }
     }
+    for (const component of parentCycleComponents(candidates)) {
+        const relatedIds = [...component].sort();
+        for (const id of relatedIds) {
+            diseases.push({
+                code: "parent_cycle",
+                message: `task ${id} participates in a parent cycle`,
+                id,
+                relatedIds,
+            });
+        }
+    }
     let changed = true;
     while (changed) {
         changed = false;
@@ -148,9 +182,11 @@ export function resolveTaskReadId(board, input) {
     return resolveTaskId(board, input);
 }
 export function resolveTaskId(board, input) {
-    if (!TASK_READ_ID.test(input)) {
+    if (!isTaskId(input)) {
         throw new FlowError("INVALID_TARGET", `invalid task id '${input}'`);
     }
+    if (board.byId.has(input))
+        return input;
     const matches = board.tasks
         .map((task) => task.id)
         .filter((id) => id.startsWith(input))
@@ -163,7 +199,7 @@ export function resolveTaskId(board, input) {
     return matches[0];
 }
 export function requireCanonicalTaskId(input) {
-    if (!TASK_ID.test(input)) {
+    if (!isTaskId(input)) {
         throw new FlowError("INVALID_TARGET", "task mutations require a canonical full task id");
     }
     return input;

package/build/core/task/commands.js

@@ -1,4 +1,5 @@
 import { FlowError } from "../../flow-error.js";
+import { IdentifierSlugError, normalizeIdentifierSlug, SUFFIXABLE_IDENTIFIER_SLUG_MAX_UTF8_BYTES, } from "../identifier-slug.js";
 import { requireCanonicalTaskId, requireHealthy, resolveTaskId, } from "./board.js";
 import { dateTimestamp, invalid, nonblank, } from "./validation.js";
 export async function readTaskBoard(repository) {
@@ -20,9 +21,10 @@ function documentFromView(view) {
         body: view.body,
     };
 }
-function replaceDocument(document) {
+function replaceDocument(document, subject) {
     return {
         replacements: [document],
+        subject,
         select(resulting) {
             const value = resulting.byId.get(document.id);
             if (!value)
@@ -43,6 +45,16 @@ function resolveMutationIds(board, ids) {
 export async function createTask(repository, input, deps) {
     nonblank("title", input.title);
     nonblank("creator", input.creator);
+    let baseId;
+    try {
+        baseId = normalizeIdentifierSlug(input.title, SUFFIXABLE_IDENTIFIER_SLUG_MAX_UTF8_BYTES);
+    }
+    catch (error) {
+        if (error instanceof IdentifierSlugError) {
+            throw new FlowError("INVALID_TARGET", `task title ${error.message}`, { cause: error });
+        }
+        throw error;
+    }
     const pri = input.pri ?? 2;
     if (!Number.isInteger(pri) || pri < 0 || pri > 3)
         invalid("task priority must be an integer from 0 through 3");
@@ -55,19 +67,13 @@ export async function createTask(repository, input, deps) {
         const from = resolveMutationIds(board, input.from ?? []);
         if (new Set(from).size !== from.length)
             invalid("task from edges must be unique");
-        let id;
-        for (let attempt = 0; attempt < 32; attempt += 1) {
-            const bytes = deps.randomBytes(6);
-            if (bytes.byteLength !== 6)
-                throw new FlowError("INTERNAL_STATE", "randomBytes(6) must return exactly 6 bytes");
-            const candidate = `k-${Buffer.from(bytes).toString("hex")}`;
-            if (!board.byId.has(candidate)) {
-                id = candidate;
-                break;
+        let id = baseId;
+        for (let ordinal = 2; board.byId.has(id); ordinal += 1) {
+            if (!Number.isSafeInteger(ordinal)) {
+                throw new FlowError("INTERNAL_STATE", `task id collision ordinal exceeded the safe integer range for ${baseId}`);
             }
+            id = `${baseId}-${ordinal}`;
         }
-        if (!id)
-            throw new FlowError("CONCURRENT_MODIFICATION", "could not allocate a unique task id after 32 attempts");
         const document = {
             id,
             title: input.title,
@@ -80,7 +86,7 @@ export async function createTask(repository, input, deps) {
             creator: input.creator,
             body: input.body ?? "",
         };
-        return replaceDocument(document);
+        return replaceDocument(document, `Add task ${id}`);
     });
 }
 export async function updateTask(repository, fullIdValue, patch) {
@@ -112,10 +118,10 @@ export async function updateTask(repository, fullIdValue, patch) {
         if (JSON.stringify(document) === JSON.stringify(documentFromView(current))) {
             throw new FlowError("EMPTY_PARAM", "task update requires at least one change");
         }
-        return replaceDocument(document);
+        return replaceDocument(document, `Update task ${id}`);
     });
 }
-async function transition(repository, fullIdValue, apply) {
+async function transition(repository, fullIdValue, apply, subject) {
     return repository.mutate((board) => {
         requireHealthy(board);
         const id = fullIdValue === undefined
@@ -123,7 +129,7 @@ async function transition(repository, fullIdValue, apply) {
             : resolveTaskId(board, fullIdValue);
         const document = documentFromView(requireExisting(board, id));
         apply(document);
-        return replaceDocument(document);
+        return replaceDocument(document, subject(id));
     });
 }
 function rejectBound(document, action = "state") {
@@ -141,7 +147,7 @@ export async function startTask(repository, fullId, now) {
             invalid(`task ${document.id} is ${document.state}, not open`);
         document.state = "in_progress";
         document.startedAt = dateTimestamp("startedAt", now);
-    });
+    }, (id) => `Start task ${id}`);
 }
 export async function stopTask(repository, fullId) {
     return transition(repository, fullId, (document) => {
@@ -150,7 +156,7 @@ export async function stopTask(repository, fullId) {
             invalid(`task ${document.id} is ${document.state}, not in_progress`);
         document.state = "open";
         delete document.startedAt;
-    });
+    }, (id) => `Stop task ${id}`);
 }
 export async function doneTask(repository, fullId) {
     return transition(repository, fullId, (document) => {
@@ -160,7 +166,7 @@ export async function doneTask(repository, fullId) {
         }
         document.state = "done";
         delete document.startedAt;
-    });
+    }, (id) => `Done task ${id}`);
 }
 export async function dropTask(repository, fullId) {
     return transition(repository, fullId, (document) => {
@@ -170,7 +176,7 @@ export async function dropTask(repository, fullId) {
         }
         document.state = "drop";
         delete document.startedAt;
-    });
+    }, (id) => `Drop task ${id}`);
 }
 export function selectSoleInProgress(board) {
     const candidates = board.tasks.filter((task) => task.state === "in_progress");
@@ -205,7 +211,10 @@ export async function rollbackOrphanTaskPointers(repository, contractIds) {
         });
         if (replacements.length === 0)
             throw new FlowError("CONCURRENT_MODIFICATION", "task pointers changed while doctor was reconciling them");
-        return { replacements, select: () => undefined };
+        const subject = replacements.length === 1
+            ? `Clear orphan contract pointer from task ${replacements[0].id}`
+            : `Clear orphan contract pointers from ${replacements.length} tasks`;
+        return { replacements, subject, select: () => undefined };
     });
     return orphans;
 }

package/build/core/task/index.js

@@ -0,0 +1,12 @@
+/**
+ * Public surface for the task package.
+ * Only symbols required by current external consumers are re-exported.
+ * Package-internal modules must import each other directly, not through this file.
+ */
+export { reconcileTaskForfeit, settleTaskBoardForBind, settleTaskBoardForLanding, } from "./task-contract.js";
+export { resolveTaskCreator } from "./task-git-actor.js";
+export { openTaskCommandRepository, readTaskDoctor, taskCommandContractId, } from "./task-git-runtime.js";
+export { openTaskStore } 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, } from "./task.js";