@astrosheep/keiyaku 2.9.6 → 2.9.8

package/build/core/registry.js

@@ -1,7 +1,7 @@
 import { FlowError } from "../flow-error.js";
 import { createGit, wrapGitError } from "../git/core.js";
 import { readLedger } from "./ledger.js";
-import { appendRefLogWithRetry } from "./ref-log.js";
+import { appendRefLogWithRetry, readRefLog } from "./ref-log.js";
 import { patternsOverlap, scopePathEvidence } from "./scope.js";
 import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 export const REGISTRY_REF = "refs/keiyaku/registry";
@@ -39,11 +39,9 @@ async function activeRegistrations(cwd, entries) {
     }
     return active;
 }
-export async function registerScope(cwd, input) {
-    let overlaps = [];
-    let trackedPaths;
+async function trackedRepositoryPaths(cwd) {
     try {
-        trackedPaths = (await createGit(cwd).raw(["ls-files", "-z"]))
+        return (await createGit(cwd).raw(["ls-files", "-z"]))
             .split("\0")
             .filter(Boolean)
             .sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
@@ -51,76 +49,91 @@ export async function registerScope(cwd, input) {
     catch (error) {
         throw wrapGitError("ls-files -z", error, cwd);
     }
-    const result = await appendRefLogWithRetry(cwd, REGISTRY_REF, registrySubject, parseRegistryEntry, async (entries) => {
-        const nextOverlaps = [];
-        const active = await activeRegistrations(cwd, entries);
-        if (input.exclusive && active.length > 0) {
-            const blocking = active.find((existing) => existing.contract !== input.contractId) ?? active[0];
-            throw new FlowError("ACTIVE_KEIYAKU_EXISTS", `exclusive bind rejected: active contract ${blocking.contract} already exists`);
+}
+async function scopeRegistrationAdmission(cwd, input, entries, trackedPaths) {
+    const nextOverlaps = [];
+    const active = await activeRegistrations(cwd, entries);
+    if (input.exclusive && active.length > 0) {
+        const blocking = active.find((existing) => existing.contract !== input.contractId) ?? active[0];
+        throw new FlowError("ACTIVE_KEIYAKU_EXISTS", `exclusive bind rejected: active contract ${blocking.contract} already exists`);
+    }
+    for (const existing of active) {
+        if (existing.contract === input.contractId)
+            continue;
+        if (existing.tree === input.tree) {
+            throw new FlowError("ACTIVE_KEIYAKU_EXISTS", [
+                `tree is already occupied by active contract ${existing.contract}`,
+                `Run \`keiyaku forfeit @${existing.contract}\` to free this tree.`,
+            ].join(" "));
         }
-        for (const existing of active) {
-            if (existing.contract === input.contractId)
+        const [nextEvidence, existingEvidence] = await Promise.all([
+            scopePathEvidence(cwd, input.scope, trackedPaths),
+            scopePathEvidence(cwd, existing.scope, trackedPaths),
+        ]);
+        const existingByPath = new Map(existingEvidence.map((evidence) => [evidence.path, evidence]));
+        const concreteByPatterns = new Map();
+        for (const next of nextEvidence) {
+            const prior = existingByPath.get(next.path);
+            if (!next.matched || !prior?.matched || !next.decisivePattern || !prior.decisivePattern)
                 continue;
-            if (existing.tree === input.tree) {
-                throw new FlowError("ACTIVE_KEIYAKU_EXISTS", [
-                    `tree is already occupied by active contract ${existing.contract}`,
-                    `Run \`keiyaku forfeit @${existing.contract}\` to free this tree.`,
-                ].join(" "));
-            }
-            const [nextEvidence, existingEvidence] = await Promise.all([
-                scopePathEvidence(cwd, input.scope, trackedPaths),
-                scopePathEvidence(cwd, existing.scope, trackedPaths),
-            ]);
-            const existingByPath = new Map(existingEvidence.map((evidence) => [evidence.path, evidence]));
-            const concreteByPatterns = new Map();
-            for (const next of nextEvidence) {
-                const prior = existingByPath.get(next.path);
-                if (!next.matched || !prior?.matched || !next.decisivePattern || !prior.decisivePattern)
-                    continue;
-                const key = `${next.decisivePattern.index}:${prior.decisivePattern.index}`;
-                const group = concreteByPatterns.get(key) ?? {
-                    next: next.decisivePattern.pattern,
-                    existing: prior.decisivePattern.pattern,
-                    paths: [],
-                };
-                group.paths.push(next.path);
-                concreteByPatterns.set(key, group);
-            }
-            for (const concrete of concreteByPatterns.values()) {
-                const preview = concrete.paths.slice(0, SCOPE_OVERLAP_PATH_PREVIEW_LIMIT);
-                nextOverlaps.push({
-                    contracts: [input.contractId, existing.contract],
-                    patterns: [concrete.next, concrete.existing],
-                    kind: "concrete",
-                    paths: {
-                        preview,
-                        count: concrete.paths.length,
-                        truncated: preview.length < concrete.paths.length,
-                    },
-                });
-            }
-            for (const nextPattern of input.scope) {
-                for (const existingPattern of existing.scope) {
-                    if (patternsOverlap(nextPattern, existingPattern)) {
-                        const [nextPatternEvidence, existingPatternEvidence] = await Promise.all([
-                            scopePathEvidence(cwd, [nextPattern], trackedPaths),
-                            scopePathEvidence(cwd, [existingPattern], trackedPaths),
-                        ]);
-                        const existingPatternByPath = new Map(existingPatternEvidence.map((evidence) => [evidence.path, evidence]));
-                        const hasCurrentWitness = nextPatternEvidence.some((evidence) => (evidence.matched && existingPatternByPath.get(evidence.path)?.matched));
-                        if (!hasCurrentWitness) {
-                            nextOverlaps.push({
-                                contracts: [input.contractId, existing.contract],
-                                patterns: [nextPattern, existingPattern],
-                                kind: "potential",
-                                paths: { preview: [], count: 0, truncated: false },
-                            });
-                        }
+            const key = `${next.decisivePattern.index}:${prior.decisivePattern.index}`;
+            const group = concreteByPatterns.get(key) ?? {
+                next: next.decisivePattern.pattern,
+                existing: prior.decisivePattern.pattern,
+                paths: [],
+            };
+            group.paths.push(next.path);
+            concreteByPatterns.set(key, group);
+        }
+        for (const concrete of concreteByPatterns.values()) {
+            const preview = concrete.paths.slice(0, SCOPE_OVERLAP_PATH_PREVIEW_LIMIT);
+            nextOverlaps.push({
+                contracts: [input.contractId, existing.contract],
+                patterns: [concrete.next, concrete.existing],
+                kind: "concrete",
+                paths: {
+                    preview,
+                    count: concrete.paths.length,
+                    truncated: preview.length < concrete.paths.length,
+                },
+            });
+        }
+        for (const nextPattern of input.scope) {
+            for (const existingPattern of existing.scope) {
+                if (patternsOverlap(nextPattern, existingPattern)) {
+                    const [nextPatternEvidence, existingPatternEvidence] = await Promise.all([
+                        scopePathEvidence(cwd, [nextPattern], trackedPaths),
+                        scopePathEvidence(cwd, [existingPattern], trackedPaths),
+                    ]);
+                    const existingPatternByPath = new Map(existingPatternEvidence.map((evidence) => [evidence.path, evidence]));
+                    const hasCurrentWitness = nextPatternEvidence.some((evidence) => (evidence.matched && existingPatternByPath.get(evidence.path)?.matched));
+                    if (!hasCurrentWitness) {
+                        nextOverlaps.push({
+                            contracts: [input.contractId, existing.contract],
+                            patterns: [nextPattern, existingPattern],
+                            kind: "potential",
+                            paths: { preview: [], count: 0, truncated: false },
+                        });
                     }
                 }
             }
         }
-        overlaps = nextOverlaps;
+    }
+    return nextOverlaps;
+}
+/** Read-only bind admission: validate exclusivity and classify scope overlap. */
+export async function previewScopeRegistration(cwd, input) {
+    const [entries, trackedPaths] = await Promise.all([
+        readRefLog(cwd, REGISTRY_REF, parseRegistryEntry),
+        trackedRepositoryPaths(cwd),
+    ]);
+    return await scopeRegistrationAdmission(cwd, input, entries, trackedPaths);
+}
+export async function registerScope(cwd, input) {
+    let overlaps = [];
+    const trackedPaths = await trackedRepositoryPaths(cwd);
+    const result = await appendRefLogWithRetry(cwd, REGISTRY_REF, registrySubject, parseRegistryEntry, async (entries) => {
+        overlaps = await scopeRegistrationAdmission(cwd, input, entries, trackedPaths);
         return {
             v: 1,
             kind: "register",

package/build/core/scope.js

@@ -38,17 +38,17 @@ export function isBlankScopePatternLine(line) {
 }
 /** Parse Keiyaku's source-line Scope opener, not a normalized Markdown node. */
 export function parseScopeFenceOpening(line) {
-    const match = line.match(/^(`{3,})$/);
-    return match ? { length: match[1].length } : null;
+    const match = line.match(/^(`{3,}|~{3,})$/);
+    return match ? { delimiter: match[1][0], length: match[1].length } : null;
 }
-/** Keiyaku closer: column-zero backticks, at least opener length, then whitespace. */
+/** Keiyaku closer: matching column-zero delimiter, at least opener length, then whitespace. */
 export function isScopeFenceClosing(line, fence) {
-    const match = line.match(/^(`+)[ \t]*$/);
-    return Boolean(match && match[1].length >= fence.length);
+    const match = line.match(/^(`+|~+)[ \t]*$/);
+    return Boolean(match && match[1][0] === fence.delimiter && match[1].length >= fence.length);
 }
 function fencedScopeError(heading, detail) {
     return new FlowError("INVALID_KEIYAKU_DRAFT", `${heading} must contain exactly one fenced gitignore-subset block; ${detail}. ` +
-        `Paste-ready canonical example:\n\n${heading}\n\`\`\`\nfoo\nbar\n\`\`\``);
+        `Paste-ready canonical example:\n\n${heading}\n~~~\nfoo\nbar\n~~~`);
 }
 /** Validate and normalize the one fenced block that constitutes a Scope body. */
 export function validateScopeFragmentLines(lines, options) {
@@ -152,14 +152,14 @@ export function markdownSourceSections(markdown) {
         return { ...heading, end: next?.start ?? markdown.length };
     });
 }
-/** Render canonical Scope bytes with a fence that content cannot close. */
+/** Render canonical Scope bytes with a tilde fence that content cannot close. */
 export function renderScopeFragment(patterns) {
     let longestRun = 0;
     for (const pattern of patterns) {
-        for (const run of pattern.match(/`+/g) ?? [])
+        for (const run of pattern.match(/~+/g) ?? [])
             longestRun = Math.max(longestRun, run.length);
     }
-    const fence = "`".repeat(Math.max(3, longestRun + 1));
+    const fence = "~".repeat(Math.max(3, longestRun + 1));
     return `${fence}\n${patterns.join("\n")}\n${fence}`;
 }
 /**

package/build/core/status/board.js

@@ -1,6 +1,7 @@
+import { availableParallelism } from "node:os";
 import { loadKeiyakuSettings } from "../../config/settings/loader.js";
 import { observeGitRepository } from "../../git/branches.js";
-import { readProjectionStatusBoard } from "../projection/index.js";
+import { readExactProjectionStatus, readOperationalProjectionStatusBoard, } from "../projection/index.js";
 import { deriveQueueReadModel, queueMembership, } from "../settlement/index.js";
 import { findOpenArc, getMaxArc, receiptsAfterFence } from "../seal.js";
 import { openTaskStore, readTaskBoard, taskRepositoryFromStore, taskUpdatedAt, } from "../task/index.js";
@@ -8,6 +9,9 @@ import { deriveBootstrapDiagnostics, deriveContractState, hasCurrentPetitionVerd
 import { commissionTarget, evaluateBaseDrift, latestBase, resolveDefaultBranchFromSettings, } from "./drift.js";
 import { computeClaimReconciliation, } from "./reconciliation.js";
 import { readStatusLedgers } from "./ledger-batch.js";
+// Git object reads benefit from overlap, but a hard cap avoids process and disk contention.
+const STATUS_DRIFT_MAX_CONCURRENCY = 8;
+const STATUS_DRIFT_CONCURRENCY = Math.min(STATUS_DRIFT_MAX_CONCURRENCY, availableParallelism());
 function compareTaskStatusRows(left, right) {
     const leftUpdated = taskUpdatedAt(left);
     const rightUpdated = taskUpdatedAt(right);
@@ -165,6 +169,23 @@ function deriveLastActiveAge(entries, now) {
         lastActiveMs: Math.max(0, now - atMs),
     };
 }
+export async function evaluateDistinctBaseDrifts(cwd, bases, defaultBranch, evaluate = evaluateBaseDrift) {
+    const uniqueBases = [...new Set(bases)];
+    const results = new Map();
+    let nextIndex = 0;
+    const worker = async () => {
+        while (nextIndex < uniqueBases.length) {
+            const index = nextIndex++;
+            const base = uniqueBases[index];
+            if (base === undefined)
+                return;
+            results.set(base, await evaluate(cwd, base, defaultBranch));
+        }
+    };
+    const workerCount = Math.min(STATUS_DRIFT_CONCURRENCY, uniqueBases.length);
+    await Promise.all(Array.from({ length: workerCount }, () => worker()));
+    return results;
+}
 export async function readKanshiBoard(cwd, now, opts) {
     const targetFilter = opts?.target ?? null;
     const loadedSettings = await loadKeiyakuSettings(cwd);
@@ -173,9 +194,14 @@ export async function readKanshiBoard(cwd, now, opts) {
     if (repository.capability === "unknown")
         throw repository.error;
     if (repository.capability !== "available" || repository.coordinate !== "repository") {
+        const exactProjection = opts?.projectionId === undefined
+            ? undefined
+            : await readExactProjectionStatus(cwd, now, opts.projectionId);
         return {
             contracts: [],
-            projections: await readProjectionStatusBoard(cwd, now, { showAll: opts?.showAllProjections }),
+            projections: opts?.projectionId === undefined
+                ? await readOperationalProjectionStatusBoard(cwd, now)
+                : exactProjection ? { rows: [exactProjection] } : null,
             queueLength: 0,
             diseases: loadedSettings.diseases,
             claimReconciliation: null,
@@ -203,6 +229,13 @@ export async function readKanshiBoard(cwd, now, opts) {
     }
     const queueModel = deriveQueueReadModel(readableLedgers);
     const boardQueueLength = queueModel.targetQueues.reduce((sum, queue) => sum + queue.ordered.length, 0);
+    const baseDrifts = await evaluateDistinctBaseDrifts(cwd, readableLedgers.flatMap((item) => {
+        const state = deriveContractState(item.entries);
+        return isTerminalState(state) ? [] : (() => {
+            const base = latestBase(item.entries);
+            return base ? [base] : [];
+        })();
+    }), defaultBranch);
     const contracts = [];
     // Readable-ledger commission targets retained for post-assembly filter only.
     const derivedTargetById = new Map();
@@ -236,7 +269,7 @@ export async function readKanshiBoard(cwd, now, opts) {
         const after = (bind?.data.after ?? []).map((id) => ({ id, terminal: terminalById.get(id) ?? false }));
         const currentArc = deriveCurrentArc(item.entries, bind?.data.objective, state);
         const baseDrift = base
-            ? await evaluateBaseDrift(cwd, base, defaultBranch)
+            ? baseDrifts.get(base) ?? { state: "unknown", label: "n/a (base drift unavailable)" }
             : { state: "unknown", label: "n/a (no default branch)" };
         const nextStep = deriveNextStep({
             id: item.contractId,
@@ -296,9 +329,14 @@ export async function readKanshiBoard(cwd, now, opts) {
         ? boardQueueLength
         : (queueModel.targetQueues.find((queue) => queue.target === targetFilter)?.ordered.length ?? 0);
     const claimReconciliation = await computeClaimReconciliation(cwd, defaultBranch);
+    const exactProjection = opts?.projectionId === undefined
+        ? undefined
+        : await readExactProjectionStatus(cwd, now, opts.projectionId);
     return {
         contracts: filteredContracts,
-        projections: await readProjectionStatusBoard(cwd, now, { showAll: opts?.showAllProjections }),
+        projections: opts?.projectionId === undefined
+            ? await readOperationalProjectionStatusBoard(cwd, now)
+            : exactProjection ? { rows: [exactProjection] } : null,
         queueLength,
         defaultBranch: defaultBranch?.branch,
         defaultHead: defaultBranch?.head,

package/build/core/status/drift.js

@@ -1,7 +1,7 @@
 import { assertSettingsKnobUsable } from "../../config/settings/disease.js";
 import { loadKeiyakuSettings } from "../../config/settings/loader.js";
 import { FlowError } from "../../flow-error.js";
-import { SETTINGS_FILE } from "../../keiyaku.js";
+import { resolveLocalBranchHead } from "../../git/refs.js";
 import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../../git/core.js";
 function findBindEntry(entries) {
     return entries.find((entry) => entry.kind === "bind");
@@ -49,10 +49,26 @@ export async function resolveDefaultBranchFromSettings(cwd, loaded, rejectDiseas
         assertSettingsKnobUsable(loaded, "defaultBranch");
     const override = loaded.knobs?.defaultBranch;
     if (override) {
-        const head = await resolveCommit(cwd, override);
-        if (!head)
-            throw new FlowError("INVALID_SETTINGS", `${SETTINGS_FILE} defaultBranch '${override}' does not resolve`);
-        return { branch: override, head };
+        const resolved = await resolveLocalBranchHead(cwd, override);
+        if (!resolved) {
+            const source = loaded.knobSources.defaultBranch;
+            if (source === undefined) {
+                throw new Error("admitted defaultBranch has no settings source coordinate");
+            }
+            throw new FlowError("INVALID_SETTINGS", `${source.coordinate} defaultBranch '${override}' does not resolve`, {
+                facts: {
+                    kind: "invalid_settings",
+                    diseases: [{
+                            source: source.source,
+                            coordinate: source.coordinate,
+                            knob: "defaultBranch",
+                            reason: `defaultBranch '${override}' does not resolve as a local branch`,
+                        }],
+                },
+            });
+        }
+        const branch = resolved.ref.slice("refs/heads/".length);
+        return { branch, head: resolved.head };
     }
     const git = createGit(cwd);
     for (const branch of ["main", "master"]) {

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

@@ -1,158 +1 @@
-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;
-}
+export { readAllLedgerSnapshots as readStatusLedgers, } from "../ledger-batch.js";

package/build/core/task/index.js

@@ -3,10 +3,10 @@
  * 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 { previewTaskBoardForBind, 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 { openTaskStore, readTaskHistory } 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";

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

@@ -7,6 +7,24 @@ import { buildTaskSourceBoard } from "./source-board.js";
 import { composeLandingTree, containsCommit, createLandingCommit, createTaskBoardCommit, findAcceptedLandingCommit, publishTaskMutationCommit, inspectCurrentBranch, publishForwardTaskBoardCommit, reconcileTaskPathsetIndex, refHead, taskContractAtCommit, taskSettlementOwnershipAtCommit, taskSourcesAtCommit, taskWritesFromSources, trackedTaskPaths, updateBranch, updateTargetRef, } from "./settlement-git.js";
 import { contractPointerDocument, doneTaskReplacements, reopenedTaskDocument, requireHealthySettlementBoard, requireSettledTask, selectReadyTasksForBind, tasksForContract, } from "./settlement-policy.js";
 import { stableRepoRoot } from "../worktree-path.js";
+/**
+ * Read the same healthy task board and run the same ready-task selector as bind
+ * under the task admission lock, without replacing sources or publishing.
+ */
+export async function previewTaskBoardForBind(input) {
+    await requireGitRepository(input.cwd, "task bind");
+    return await withLockHeldTaskBoard(input.cwd, async (transaction) => {
+        if (transaction.location.mode !== "git") {
+            if (transaction.location.capability === "unavailable") {
+                assertGitObservation({ capability: "unavailable" }, "task bind");
+            }
+            throw new FlowError("NOT_GIT_REPO", "task bind requires Git task storage");
+        }
+        const repository = taskRepositoryFromLockedBoard(transaction);
+        const board = requireHealthySettlementBoard(await repository.read());
+        return { tasks: input.taskIds === undefined ? [] : selectReadyTasksForBind(board, input.taskIds) };
+    });
+}
 function sourcePath(root, source) {
     return source.path.slice(root.length + 1).split("\\").join("/");
 }

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

@@ -1,24 +1,22 @@
-import { observeGitRepository } from "../../git/branches.js";
 import { listContractIds } from "../ledger.js";
 import { contractBoundByEngineWorktree, stableRepoRoot } from "../worktree-path.js";
-import { inspectTaskLock, openTaskStore } from "./task-git-store.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 observation = await observeGitRepository(cwd);
-    if (observation.capability === "unknown")
-        throw observation.error;
-    if (observation.capability !== "available" || observation.coordinate !== "repository")
+    const board = await locateTaskBoard(cwd);
+    if (board.mode !== "git")
         return undefined;
-    return contractBoundByEngineWorktree(cwd);
+    return contractBoundByEngineWorktree(cwd, board.root);
 }
 export async function openTaskCommandRepository(cwd) {
-    const store = await openTaskStore(cwd);
+    const board = await locateTaskBoard(cwd);
+    const store = openTaskStoreAt(board);
     const repository = taskRepositoryFromStore(store);
-    if (store.mode !== "git")
+    if (board.mode !== "git")
         return repository;
-    const contractId = await contractBoundByEngineWorktree(cwd);
+    const contractId = await contractBoundByEngineWorktree(cwd, board.root);
     return contractId ? withTaskWorktreePolicy(repository, contractId) : repository;
 }
 export async function taskContractIds(cwd) {