@astrosheep/keiyaku 2.9.7 → 2.9.8

package/build/core/projection/projection-wake.js

@@ -7,40 +7,12 @@ import { createProjectionExecutionId } from "./generation/projection-generation-
 import { PROJECTION_ADOPTION_POLL_MS, PROJECTION_ADOPTION_TIMEOUT_MS, startProjectionGeneration, } from "./generation/projection-generation-launcher.js";
 import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, } from "./generation/store.js";
 import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
-import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
+import { acquireProjectionRunnerLock, acquireProjectionRunnerSettlementLock, ProjectionRunnerLockUnavailableError, } from "./projection-runner-lock.js";
 import { setTimeout as delay } from "node:timers/promises";
-/** Persist an asynchronous interrupt wake failure at the generation boundary. */
-export function recordInterruptWakeFailure(projectionDirectory, cause, nowMs = Date.now()) {
-    const continuation = readProjectionGenerationContinuationSnapshot(projectionDirectory, 10);
-    const current = continuation.current;
-    if (!current || !current.verdict || current.verdict.facts.state !== "interrupted")
-        return;
-    const snapshot = continuation.successor;
-    const executionId = createProjectionExecutionId(nowMs);
-    const facts = successorFacts(current, snapshot, nowMs, false);
-    const store = openProjectionGenerationStore(projectionDirectory);
-    try {
-        const launch = store.launchIfSettled({ executionId, facts });
-        if (launch.status !== "committed")
-            return;
-        store.verdictIfOpen({
-            executionId,
-            verdict: "launch-failed",
-            facts: {
-                stage: "interrupt-wake",
-                cause,
-                tellRetained: true,
-                terminalAt: new Date(nowMs).toISOString(),
-            },
-        });
-    }
-    finally {
-        store.close();
-    }
-}
 function incompatibleProjectionError(projectionId) {
     const subject = projectionId ? `Projection '${projectionId}'` : "Projection";
-    return new FlowError("PROJECTION_INCOMPATIBLE", `${subject} has incompatible historical storage; keiyaku status --all can inspect it, but tell cannot change it.`);
+    const statusCoordinate = projectionId ?? "<projection-id>";
+    return new FlowError("PROJECTION_INCOMPATIBLE", `${subject} has incompatible historical storage; inspect it with keiyaku status ${statusCoordinate}, but tell cannot change it.`);
 }
 /**
  * Tell is a current-schema mutation only. This gate runs before the handler
@@ -127,10 +99,24 @@ export function assertTellEffortSupported(projectionDirectory, effort) {
         throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${effort}' is not permitted; legal values: ${effortOptions.join(", ")}.`);
     }
 }
-async function startCommittedSuccessor(projectionDirectory, projectionId, executionId, startGeneration) {
-    const started = await startGeneration(projectionDirectory, executionId);
+async function startCommittedSuccessor(projectionDirectory, projectionId, executionId, startGeneration, dependencies = {}) {
+    let started;
+    try {
+        started = await startGeneration(projectionDirectory, executionId, dependencies);
+    }
+    finally {
+        dependencies.launchOwnership?.close();
+    }
     if (started.status === "adopted")
         return "woken";
+    if (started.status === "pending")
+        return "pending";
+    const reconciled = readCurrentGeneration(projectionDirectory);
+    if (reconciled?.launch.executionId === executionId && reconciled.adoption)
+        return "woken";
+    if (reconciled && !reconciled.verdict && reconciled.launch.executionId !== executionId) {
+        return reconciled.adoption ? "active" : "pending";
+    }
     throw new FlowError("PROJECTION_WAKE_FAILED", `The tell was saved for '${projectionId}', but its successor could not be started (cause: ${started.cause}).`, {
         facts: {
             kind: "projection_wake_failure",
@@ -151,6 +137,31 @@ function sessionWakeFailure(projectionId, cause) {
         },
     });
 }
+export function persistInterruptWakeFailure(projectionDirectory, error, nowMs = Date.now()) {
+    if (!(error instanceof FlowError)
+        || error.code !== "PROJECTION_WAKE_FAILED"
+        || error.facts?.kind !== "projection_wake_failure")
+        return;
+    const continuation = readProjectionGenerationContinuationSnapshot(projectionDirectory, 10);
+    const current = continuation.current;
+    if (current?.verdict?.facts.state !== "interrupted" || !continuation.requiresWake)
+        return;
+    const successorExecutionId = createProjectionExecutionId(nowMs);
+    const facts = successorFacts(current, continuation.successor, nowMs, false);
+    const store = openProjectionGenerationStore(projectionDirectory);
+    try {
+        store.failInterruptWakeIfSettled({
+            predecessorExecutionId: current.launch.executionId,
+            successorExecutionId,
+            successorFacts: facts,
+            cause: error.facts.cause,
+            terminalAt: new Date(nowMs).toISOString(),
+        });
+    }
+    finally {
+        store.close();
+    }
+}
 export async function tellProjection(projectionDirectory, projectionId, effort, dependencies = {}) {
     const startGeneration = dependencies.startGeneration ?? startProjectionGeneration;
     const sleep = dependencies.sleep ?? ((milliseconds) => delay(milliseconds));
@@ -201,56 +212,144 @@ export async function tellProjection(projectionDirectory, projectionId, effort,
         try {
             if (life.phase === "startup-timeout") {
                 const terminalAt = new Date(nowMs).toISOString();
-                const transition = store.supersedeStartupTimeout({
-                    executionId: current.launch.executionId,
-                    observedAtMs: nowMs,
-                    startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
-                    diagnostic: { detail: "runner did not adopt before startup timeout" },
-                    successorExecutionId,
-                    successorFacts: facts,
-                    terminalAt,
-                });
-                if (transition.status === "committed") {
-                    return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration);
+                let deathEvidence;
+                try {
+                    deathEvidence = acquireProjectionRunnerSettlementLock(projectionDirectory);
                 }
-                if (transition.reason === "kill-requested")
+                catch (error) {
+                    if (error instanceof ProjectionRunnerLockUnavailableError)
+                        return "pending";
                     return "pending";
-                await sleep(PROJECTION_ADOPTION_POLL_MS);
-                continue;
+                }
+                try {
+                    store.beginWriteTransaction();
+                    const protectedCurrent = store.readCurrentGeneration();
+                    if (protectedCurrent?.launch.executionId !== current.launch.executionId
+                        || protectedCurrent.adoption
+                        || protectedCurrent.verdict) {
+                        store.rollbackWriteTransaction();
+                        return "pending";
+                    }
+                    if (protectedCurrent.killIntent) {
+                        const settled = store.settleKillIfRunnerDead({
+                            executionId: current.launch.executionId,
+                            releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
+                        });
+                        if (settled.status === "committed")
+                            store.commitWriteTransaction();
+                        else
+                            store.rollbackWriteTransaction();
+                        return "pending";
+                    }
+                    deathEvidence.close();
+                    let launchOwnership;
+                    try {
+                        launchOwnership = acquireProjectionRunnerLock(projectionDirectory);
+                    }
+                    catch (error) {
+                        store.rollbackWriteTransaction();
+                        if (error instanceof ProjectionRunnerLockUnavailableError)
+                            return "pending";
+                        return "pending";
+                    }
+                    return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration, {
+                        commitLaunch: () => {
+                            const transition = store.supersedeStartupTimeout({
+                                executionId: current.launch.executionId,
+                                releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
+                                diagnostic: { detail: "runner did not adopt before startup timeout" },
+                                successorExecutionId,
+                                successorFacts: facts,
+                                terminalAt,
+                            });
+                            if (transition.status === "committed")
+                                store.commitWriteTransaction();
+                            else
+                                store.rollbackWriteTransaction();
+                            return transition.status === "committed";
+                        },
+                        launchOwnership,
+                    });
+                }
+                finally {
+                    store.rollbackWriteTransaction();
+                    deathEvidence.close();
+                }
             }
             if (life.phase === "lost" && !current.verdict) {
-                const lock = observeProjectionRunnerLock(projectionDirectory);
-                if (lock.state !== "released")
-                    return lock.state === "held" ? "active" : "pending";
-                const terminalAt = new Date(nowMs).toISOString();
-                const transition = store.replaceDeadRunner({
-                    executionId: current.launch.executionId,
-                    releasedLockEvidence: { observedAt: terminalAt },
-                    successorExecutionId,
-                    successorFacts: facts,
-                    terminalAt,
-                });
-                if (transition.status === "committed") {
-                    return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration);
+                let deathEvidence;
+                try {
+                    deathEvidence = acquireProjectionRunnerSettlementLock(projectionDirectory);
                 }
-                if (transition.reason === "kill-requested")
+                catch (error) {
+                    if (error instanceof ProjectionRunnerLockUnavailableError)
+                        return "active";
                     return "pending";
-                await sleep(PROJECTION_ADOPTION_POLL_MS);
-                continue;
+                }
+                try {
+                    store.beginWriteTransaction();
+                    const protectedCurrent = store.readCurrentGeneration();
+                    if (protectedCurrent?.launch.executionId !== current.launch.executionId
+                        || !protectedCurrent.adoption
+                        || protectedCurrent.verdict) {
+                        store.rollbackWriteTransaction();
+                        return "pending";
+                    }
+                    const terminalAt = new Date(nowMs).toISOString();
+                    if (protectedCurrent.killIntent) {
+                        const settled = store.settleKillIfRunnerDead({
+                            executionId: current.launch.executionId,
+                            releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
+                        });
+                        if (settled.status === "committed")
+                            store.commitWriteTransaction();
+                        else
+                            store.rollbackWriteTransaction();
+                        return "pending";
+                    }
+                    deathEvidence.close();
+                    let launchOwnership;
+                    try {
+                        launchOwnership = acquireProjectionRunnerLock(projectionDirectory);
+                    }
+                    catch (error) {
+                        store.rollbackWriteTransaction();
+                        if (error instanceof ProjectionRunnerLockUnavailableError)
+                            return "active";
+                        return "pending";
+                    }
+                    return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration, {
+                        commitLaunch: () => {
+                            const transition = store.replaceDeadRunner({
+                                executionId: current.launch.executionId,
+                                releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
+                                successorExecutionId,
+                                successorFacts: facts,
+                                terminalAt,
+                            });
+                            if (transition.status === "committed")
+                                store.commitWriteTransaction();
+                            else
+                                store.rollbackWriteTransaction();
+                            return transition.status === "committed";
+                        },
+                        launchOwnership,
+                    });
+                }
+                finally {
+                    store.rollbackWriteTransaction();
+                    deathEvidence.close();
+                }
             }
             if (!["done", "failed", "lost", "dismissed", "killed"].includes(life.phase)) {
                 return "pending";
             }
-            const transition = store.launchIfSettled({
-                executionId: successorExecutionId,
-                facts,
+            return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration, {
+                commitLaunch: () => store.launchIfSettled({
+                    executionId: successorExecutionId,
+                    facts,
+                }).status === "committed",
             });
-            if (transition.status === "committed") {
-                return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration);
-            }
-            if (transition.reason === "kill-requested")
-                return "pending";
-            await sleep(PROJECTION_ADOPTION_POLL_MS);
         }
         finally {
             store.close();

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/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) {

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

@@ -395,8 +395,7 @@ function assertTaskDirectorySafety(directory) {
         throw new FlowError("INTERNAL_STATE", `task directory is not a regular directory: ${directory}`);
     }
 }
-export async function openTaskStore(cwd, deps = {}) {
-    const board = await locateTaskBoard(cwd, deps.runGit);
+export function openTaskStoreAt(board, deps = {}) {
     const directory = taskDirectory(board);
     return {
         mode: board.mode,
@@ -405,7 +404,7 @@ export async function openTaskStore(cwd, deps = {}) {
             return readTaskSources(directory);
         },
         async mutate(apply) {
-            return withLockHeldTaskBoard(cwd, async (transaction) => {
+            return withLockHeldTaskBoard(board.root, async (transaction) => {
                 const previousSources = transaction.sources;
                 const plan = await apply(transaction.sources);
                 validatePlan(plan);
@@ -437,6 +436,9 @@ export async function openTaskStore(cwd, deps = {}) {
         },
     };
 }
+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);