@astrosheep/keiyaku 2.9.12 → 2.9.13

package/build/core/audit/candidate.js

@@ -2,18 +2,11 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { FlowError, asMessage } from "../../flow-error.js";
-import { createGit, wrapGitError } from "../../git/core.js";
+import { requireCommitCoordinate } from "../../git/commits.js";
+import { createGit } from "../../git/core.js";
 import { readStructuredDiff } from "../../git/diff/structured.js";
 import { abortDetachedRenewChain, buildDetachedRenewChain, renewScratchName } from "../renew-rewrite.js";
 import { isBootstrapSuccess, runWorktreeBootstrap } from "../worktree-bootstrap.js";
-async function resolveObject(cwd, revision, kind) {
-    try {
-        return (await createGit(cwd).raw(["rev-parse", "--verify", `${revision}^{${kind}}`])).trim();
-    }
-    catch (error) {
-        throw wrapGitError(`rev-parse ${revision}^{${kind}}`, error, cwd);
-    }
-}
 export async function createAuditCandidate(input) {
     const cwd = await fs.mkdtemp(path.join(os.tmpdir(), "keiyaku-audit-"));
     const git = createGit(input.root);
@@ -30,7 +23,8 @@ export async function createAuditCandidate(input) {
         const rewrite = await buildDetachedRenewChain({
             cwd,
             scratchName,
-            observedLedgerHead: input.frozen.coordinates.ledger.head,
+            observedLedgerHead: input.frozen.repository.observedLedgerHead,
+            lifecycleHead: input.frozen.lifecycle.contractHead,
             deliveryRef: input.frozen.coordinates.delivery.ref,
             targetRef: input.frozen.coordinates.target.ref,
             effectiveScope: input.frozen.scope,
@@ -44,8 +38,8 @@ export async function createAuditCandidate(input) {
             return { cwd, rehearsal: { status: "conflict", paths: [...rewrite.conflictPaths], pathCapture: "captured" }, candidate: null };
         }
         await candidateGit.raw(["reset", "--hard", rewrite.newHead]);
-        const [head, tree] = await Promise.all([resolveObject(cwd, "HEAD", "commit"), resolveObject(cwd, "HEAD", "tree")]);
-        return { cwd, rehearsal: { status: "clean", oldBase: input.frozen.base, newBase: input.frozen.coordinates.target.head, oldHead: input.frozen.coordinates.delivery.head }, candidate: { base: input.frozen.coordinates.target.head, head, tree, rewritten: true } };
+        const coordinate = await requireCommitCoordinate(cwd, "HEAD");
+        return { cwd, rehearsal: { status: "clean", oldBase: input.frozen.base, newBase: input.frozen.coordinates.target.head, oldHead: input.frozen.coordinates.delivery.head }, candidate: { base: input.frozen.coordinates.target.head, head: coordinate.commit, tree: coordinate.tree, rewritten: true } };
     }
     catch (error) {
         return { cwd, rehearsal: { status: "unknown", cause: { code: error instanceof FlowError ? error.code : "INTERNAL_STATE", message: asMessage(error) } }, candidate: null };
@@ -59,13 +53,11 @@ export async function readAuditCandidateDiff(candidateResult) {
     return readStructuredDiff(candidateResult.cwd, candidate.base, candidate.head);
 }
 async function readCandidateIntegrity(cwd) {
-    const git = createGit(cwd);
-    const [head, tree, status] = await Promise.all([
-        resolveObject(cwd, "HEAD", "commit"),
-        resolveObject(cwd, "HEAD", "tree"),
-        git.raw(["status", "--porcelain=v1", "-z", "--untracked-files=no"]),
+    const [coordinate, status] = await Promise.all([
+        requireCommitCoordinate(cwd, "HEAD"),
+        createGit(cwd).raw(["status", "--porcelain=v1", "-z", "--untracked-files=no"]),
     ]);
-    return { head, tree, trackedChanges: status.split("\0").filter(Boolean) };
+    return { head: coordinate.commit, tree: coordinate.tree, trackedChanges: status.split("\0").filter(Boolean) };
 }
 function preparationPlan(plan) {
     return { command: [...plan.command], timeoutMs: plan.timeoutMs };

package/build/core/audit/coordinates.js

@@ -2,6 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { createHash } from "node:crypto";
 import { FlowError, asMessage } from "../../flow-error.js";
+import { requireCommitCoordinate } from "../../git/commits.js";
 import { createGit, wrapGitError } from "../../git/core.js";
 import { effectiveCriteria } from "../amendment-criteria.js";
 import { hasStrandableProjectionGeneration } from "../projection/index.js";
@@ -9,15 +10,7 @@ import { admitRepositoryLifecycleContract, } from "../repository-ledger/admissio
 import { lookupCurrentContract, readRepositoryLifecycle, } from "../repository-ledger/read-model.js";
 import { deriveQueueReadModel, queueMembership } from "../settlement/queue.js";
 import { findRegisteredContractWorktreePathFromModel } from "../worktree-path.js";
-async function resolveObject(cwd, revision, kind) {
-    const git = createGit(cwd);
-    try {
-        return (await git.raw(["rev-parse", "--verify", `${revision}^{${kind}}`])).trim();
-    }
-    catch (error) {
-        throw wrapGitError(`rev-parse ${revision}^{${kind}}`, error, cwd);
-    }
-}
+import { readRemainingTaskNeedsForSettlement } from "../task/settlement-policy.js";
 export function appendedScopeTerms(model) {
     return model.history.flatMap(({ entry }) => entry.kind === "amend" && entry.data.scopeDelta ? entry.data.scopeDelta.add : []);
 }
@@ -63,17 +56,17 @@ async function pinLedgerCoordinates(input) {
     const bind = model.history.find(({ entry }) => entry.kind === "bind")?.entry;
     if (!bind || bind.kind !== "bind")
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} is missing folded bind terms`);
-    const [deliveryHead, deliveryTree, targetHead, targetTree] = await Promise.all([
-        resolveObject(input.root, model.resources.deliveryRef, "commit"), resolveObject(input.root, model.resources.deliveryRef, "tree"),
-        resolveObject(input.root, model.pins.target.ref, "commit"), resolveObject(input.root, model.pins.target.ref, "tree"),
+    const [delivery, target] = await Promise.all([
+        requireCommitCoordinate(input.root, model.resources.deliveryRef),
+        requireCommitCoordinate(input.root, model.pins.target.ref),
     ]);
-    if (model.pins.target.approvedHead !== null && model.petition.state === "approved" && model.pins.target.approvedHead !== targetHead) {
+    if (model.pins.target.approvedHead !== null && model.petition.state === "approved" && model.pins.target.approvedHead !== target.commit) {
         throw new FlowError("INTERNAL_STATE", `target ref ${model.pins.target.ref} moved from approved petition pin`);
     }
     return {
         criteria: auditCriteria(model), scope: [...model.effectiveScope], appendScope: appendedScopeTerms(model), base: model.pins.base,
         lifecycle: model, repository,
-        coordinates: { ledger: { head: repository.observedLedgerHead }, delivery: { ref: model.resources.deliveryRef, head: deliveryHead, tree: deliveryTree }, target: { ref: model.pins.target.ref, head: targetHead, tree: targetTree } },
+        coordinates: { ledger: { head: repository.observedLedgerHead }, delivery: { ref: model.resources.deliveryRef, head: delivery.commit, tree: delivery.tree }, target: { ref: model.pins.target.ref, head: target.commit, tree: target.tree } },
     };
 }
 async function deliveryResidue(cwd) {
@@ -123,8 +116,8 @@ async function residueFingerprint(cwd, residue) {
     return digest.digest("hex");
 }
 async function deliveryCoordinate(cwd) {
-    const [head, tree, residue] = await Promise.all([resolveObject(cwd, "HEAD", "commit"), resolveObject(cwd, "HEAD", "tree"), deliveryResidue(cwd)]);
-    return { head, tree, residue, residueFingerprint: await residueFingerprint(cwd, residue) };
+    const [coordinate, residue] = await Promise.all([requireCommitCoordinate(cwd, "HEAD"), deliveryResidue(cwd)]);
+    return { head: coordinate.commit, tree: coordinate.tree, residue, residueFingerprint: await residueFingerprint(cwd, residue) };
 }
 async function checkedOutRef(cwd) {
     try {
@@ -146,7 +139,7 @@ async function receiptsAfterPinnedFence(input) {
 }
 async function readReadiness(input) {
     const model = input.frozen.lifecycle;
-    const [residue, looseCommits, queue, liveProjection, dependencies] = await Promise.all([
+    const [residue, looseCommits, queue, liveProjection, afterDependencies, taskNeeds] = await Promise.all([
         deliveryResidue(input.deliveryCwd), receiptsAfterPinnedFence({ root: input.root, model, deliveryHead: input.frozen.coordinates.delivery.head }), Promise.resolve(deriveQueueReadModel(input.frozen.repository)),
         hasStrandableProjectionGeneration({ cwd: input.root, commissionId: input.contractId, deliveryWorktree: input.deliveryCwd, nowMs: Date.now() }),
         Promise.resolve(model.causal.after.map((id) => {
@@ -154,7 +147,9 @@ async function readReadiness(input) {
             const state = outcome.status === "healthy" ? outcome.model.phase : outcome.status;
             return { id, satisfied: outcome.status === "healthy" && (state === "claimed" || state === "forfeited"), state };
         })),
+        readRemainingTaskNeedsForSettlement(input.root, model.causal.needs),
     ]);
+    const dependencies = [...afterDependencies, ...taskNeeds];
     const membership = queueMembership(queue, input.contractId);
     return { deliveryResidue: residue, arc: { open: model.phase === "active" ? model.intent.arc : null, max: model.intent.arc, fence: model.pins.delivery, looseCommits }, rewriteGuard: { liveProjection }, dependencies, petition: { state: model.phase, queue: membership ? { position: membership.position, length: membership.queueLength, head: membership.queueHead, diagnostics: membership.diagnostics.map((item) => item.kind) } : null } };
 }

package/build/core/audit/evidence.js

@@ -133,14 +133,16 @@ export async function evaluateVerification(input) {
     const plan = input.plan;
     if (plan.length === 0)
         return { status: "not_configured", results: [] };
-    const executed = await runVerificationPlan({ cwd: input.cwd, candidate: { head: input.candidate.head, tree: input.candidate.tree }, plan, signal: input.signal, coordinationKey: input.coordinationKey, coordinationRoot: input.coordinationRoot });
-    const results = executed.map((result) => {
+    const invocation = await runVerificationPlan({ cwd: input.cwd, candidate: { head: input.candidate.head, tree: input.candidate.tree }, plan, signal: input.signal, root: input.root });
+    // runId is addressable immediately; owner await cancels on abort and observes terminal cleanup.
+    const completion = await invocation.awaitTerminal();
+    const results = completion.results.map((result) => {
         const common = { source: result.source, declaration: result.declaration, label: result.label, executor: result.executor, command: result.command, argv: [result.command, ...result.args], candidate: result.candidate };
         if (result.execution.status === "runner_failed")
             return { ...common, ...result.execution };
         return { status: "executed", ...common, body: result.shell ? result.command : result.args.at(-1) ?? "", exitCode: result.execution.code, durationMs: result.execution.durationMs, stdout: result.execution.stdout, stderr: result.execution.stderr };
     });
-    return { status: "evaluated", results };
+    return { status: "evaluated", runId: completion.runId, results };
 }
 export async function collectEvidence(input) {
     const candidate = input.candidateResult.candidate;
@@ -150,5 +152,5 @@ export async function collectEvidence(input) {
         return null;
     const diff = input.diff;
     const scope = await evaluateScope({ cwd: input.candidateResult.cwd, frozen: input.frozen, diff });
-    return { diff, scope, presentation: presentDiff({ diff, scope, budget: input.diffBudgetBytes, retrievalCoordinates: { from: input.frozen.base, to: input.frozen.coordinates.delivery.head } }), files: fileFacts(diff, scope), verification: input.verificationOverride ?? await evaluateVerification({ cwd: input.candidateResult.cwd, candidate, plan: input.verificationPlan, signal: input.signal, coordinationKey: input.coordinationKey, coordinationRoot: input.coordinationRoot }), candidate };
+    return { diff, scope, presentation: presentDiff({ diff, scope, budget: input.diffBudgetBytes, retrievalCoordinates: { from: input.frozen.base, to: input.frozen.coordinates.delivery.head } }), files: fileFacts(diff, scope), verification: input.verificationOverride ?? await evaluateVerification({ cwd: input.candidateResult.cwd, root: input.root, candidate, plan: input.verificationPlan, signal: input.signal }), candidate };
 }

package/build/core/audit/facade.js

@@ -3,11 +3,11 @@ import { completeAuditCoordinates, initialCoordinateRace, pinAuditSnapshot, rere
 import { collectEvidence, resolveAuditVerificationPlan } from "./evidence.js";
 import { collectFindings, emptyRaceReport } from "./report.js";
 import { readinessFromFacts } from "./readiness.js";
+import { effectiveVerification } from "../lifecycle-history.js";
 export async function auditContract(input) {
     const contractId = input.address.binding.commissionId;
     const frozenSnapshot = await pinAuditSnapshot({ address: input.address });
-    const bind = frozenSnapshot.lifecycle.history.find(({ entry }) => entry.kind === "bind")?.entry;
-    const contractVerification = bind?.kind === "bind" ? bind.data.verification : [];
+    const contractVerification = effectiveVerification(frozenSnapshot.lifecycle.history.map(({ entry }) => entry));
     const admission = {
         frozen: frozenSnapshot,
         contractVerification,
@@ -43,7 +43,7 @@ export async function auditContract(input) {
             }
         }
         const diff = await readAuditCandidateDiff(candidateResult);
-        evidence = await collectEvidence({ candidateResult, frozen, diff, diffBudgetBytes: input.diffBudgetBytes ?? 32_000, verificationPlan, signal: input.signal, coordinationKey: JSON.stringify({ repository: input.address.repo.stableRoot, candidate: candidateResult.candidate, preparation: bind?.kind === "bind" && bind.data.workspace === "worktree" ? bind.data.bootstrap : null, plan: verificationPlan }), coordinationRoot: input.address.repo.stableRoot, ...(verificationOverride ? { verificationOverride } : {}) });
+        evidence = await collectEvidence({ candidateResult, frozen, diff, diffBudgetBytes: input.diffBudgetBytes ?? 32_000, verificationPlan, signal: input.signal, root: input.address.repo.stableRoot, ...(verificationOverride ? { verificationOverride } : {}) });
         verification = evidence?.verification ?? verificationOverride ?? { status: "not_evaluated", reason: candidateResult.rehearsal.status === "conflict" ? "renew_conflict" : "renew_unknown", results: [] };
         await input.afterEvidence?.();
     }

package/build/core/audit/report.js

@@ -8,7 +8,7 @@ export function collectFindings(input) {
     if (input.rehearsal.status === "unknown")
         findings.push({ code: "RENEW_UNKNOWN", detail: `${input.rehearsal.cause.code}: ${input.rehearsal.cause.message}`, nextCommand: `${selector} audit` });
     for (const row of input.scope?.filter((item) => item.class === "violated") ?? [])
-        findings.push({ code: "SCOPE_RESIDUE", detail: `${row.path}: ${row.residue.length} unexplained changes`, nextCommand: `${selector} amend --scope-add ${JSON.stringify(row.path)}` });
+        findings.push({ code: "SCOPE_RESIDUE", severity: "warning", detail: `${row.path}: ${row.residue.length} unexplained changes`, nextCommand: `${selector} amend --scope-add ${JSON.stringify(row.path)}` });
     if (input.candidatePreparation.status === "failed")
         findings.push({ code: "CANDIDATE_PREPARATION_FAILED", detail: `${input.candidatePreparation.cause.code}: ${input.candidatePreparation.cause.message}`, nextCommand: `${selector} audit` });
     if (input.verification.status === "evaluated") {

package/build/core/bind-reconciliation.js

@@ -1,22 +1,32 @@
 import { FlowError } from "../flow-error.js";
 import { access } from "node:fs/promises";
-import { lookupCurrentContract, readRepositoryLifecycle } from "./repository-ledger/read-model.js";
-import { withContractCarrierSession } from "./contract-carrier.js";
-import { stableRepoRoot, contractWorktreePathFromBind, findRegisteredContractWorktreePath } from "./worktree-path.js";
+import { lookupCurrentContract, readRepositoryLifecycle, } from "./repository-ledger/read-model.js";
+import { withContractCarrierSession, withObservedContractCarrierSession } from "./contract-carrier.js";
+import { contractWorktreePathFromStableRoot, findRegisteredContractWorktreePathFromModel } from "./worktree-path.js";
 import { defaultCreateWorktree } from "./bind-workspace.js";
 import { isCommissionId } from "./ids.js";
 import { REPOSITORY_LEDGER_REF, repositoryDeliveryRef } from "./repository-ledger/codec.js";
 import { resolveLocalBranchHead } from "../git/refs.js";
 import { runWorktreeBootstrap, bootstrapEntryDataFromObservation, isBootstrapSuccess } from "./worktree-bootstrap.js";
 import { committedLifecycleFacts, containedCommittedLifecycleFacts, EffectJournal } from "./outcome-base.js";
+/**
+ * Repository admission can only recover a bind whose authority remains active.
+ * A terminal contract may retain its historical bootstrap disposition, but its
+ * projection is addressed recovery work and must not be adopted by another bind.
+ */
+export function requiresBindRecovery(lifecycle) {
+    if (lifecycle.phase !== "active")
+        return false;
+    return lifecycle.bootstrapReplay.state === "pending" || lifecycle.bootstrapReplay.state === "failed-interrupted";
+}
 export async function publishBindBootstrap(session, entry, expectedLedgerHead) {
-    return await session.publishAuthoritative({ verb: "bootstrap", admittedLedgerHead: expectedLedgerHead, acceptedLifecycleTail: session.lifecycle.history.at(-1).objectId, entries: [entry] });
+    return await session.publishAuthoritative({ verb: "bootstrap", admittedLedgerHead: expectedLedgerHead, acceptedLifecycleTail: session.lifecycle.contractHead, entries: [entry] });
 }
 export async function publishBindFailedForfeit(session, entry, delivery, expectedLedgerHead) {
     return await session.publishAuthoritative({
         verb: "forfeit",
         admittedLedgerHead: expectedLedgerHead,
-        acceptedLifecycleTail: session.lifecycle.history.at(-1).objectId,
+        acceptedLifecycleTail: session.lifecycle.contractHead,
         entries: [entry],
         delivery: {
             ref: repositoryDeliveryRef(entry.contract),
@@ -40,7 +50,7 @@ function copyAcceptedBindEntry(entry) {
         ...(entry.data.taskIds ? { taskIds: [...entry.data.taskIds] } : {}),
     };
     return {
-        v: 2,
+        v: 3,
         kind: "bind",
         contract: entry.contract,
         at: entry.at,
@@ -76,18 +86,6 @@ function bootstrapProgressLine(command) {
 function workspaceBindView(entry) {
     return entry;
 }
-export async function revalidateBindAuthority(input) {
-    const [target, delivery] = await Promise.all([
-        resolveLocalBranchHead(input.cwd, input.target),
-        resolveLocalBranchHead(input.cwd, input.deliveryRef),
-    ]);
-    if (target?.head !== input.targetHead) {
-        throw new FlowError("CONCURRENT_MODIFICATION", `bind target changed from ${input.targetHead}`);
-    }
-    if (delivery !== null) {
-        throw new FlowError("CONCURRENT_MODIFICATION", `bind delivery ref already exists: ${input.deliveryRef}`);
-    }
-}
 export function committedOrThrow(result, operation) {
     if (result.family === "committed")
         return result;
@@ -163,6 +161,18 @@ function bindSurfaceReceipts(journal) {
     }
     return receipts;
 }
+export async function reconcileCommittedBindFromSnapshot(input, admittedScopeOverlaps, snapshot) {
+    const result = await withObservedContractCarrierSession({
+        stableRoot: snapshot.stableRoot,
+        contractId: input.contractId,
+        observation: snapshot.observation,
+        signal: input.signal,
+        ...(input.terminalWorkspaceCleanup ? { terminalWorkspaceCleanup: input.terminalWorkspaceCleanup } : {}),
+    }, async (session) => reconcileBindContractLocked({ ...input, cwd: snapshot.stableRoot }, session, admittedScopeOverlaps));
+    if (!("continueAfterFailedBootstrap" in result))
+        return result;
+    return reconcileCommittedBind(input, admittedScopeOverlaps);
+}
 /**
  * Sole replay-only entry for a committed bind. It never allocates identity or
  * reads draft input; every coordinate is reconstructed from the accepted bind.
@@ -186,11 +196,11 @@ export async function reconcileCommittedBind(input, admittedScopeOverlaps) {
     throw new FlowError("INTERNAL_STATE", `bind-failed finalization for ${input.contractId} did not settle after bootstrap re-admission`);
 }
 async function reconcileBindContractLocked(input, replaySession, admittedScopeOverlaps) {
-    const stableRoot = await stableRepoRoot(input.cwd);
+    const stableRoot = replaySession.stableRoot;
     if (!isCommissionId(input.contractId)) {
         throw new FlowError("INVALID_TARGET", `bind replay requires a full canonical contract id; got ${input.contractId}`);
     }
-    const initialRead = await readRepositoryLifecycle(stableRoot);
+    const initialRead = replaySession.repository;
     const outcome = lookupCurrentContract(initialRead, input.contractId);
     if (outcome.status === "absent")
         throw new FlowError("CONTRACT_NOT_FOUND", `contract ${input.contractId} not found`);
@@ -213,7 +223,7 @@ async function reconcileBindContractLocked(input, replaySession, admittedScopeOv
     const entry = copyAcceptedBindEntry(bindRow.entry);
     const workspace = entry.data.workspace;
     const branch = `keiyaku/${entry.contract}`;
-    const worktreePath = await contractWorktreePathFromBind(stableRoot, entry.contract, workspaceBindView(entry));
+    const worktreePath = contractWorktreePathFromStableRoot(stableRoot, entry.contract, workspaceBindView(entry));
     const targetRoot = workspace === "here" ? stableRoot : worktreePath;
     const deps = input.dependencies ?? {};
     const heads = {
@@ -231,12 +241,21 @@ async function reconcileBindContractLocked(input, replaySession, admittedScopeOv
     let containedCause;
     const rememberFailure = (row) => { containedCause ??= effectCause(row); };
     const scopeOverlaps = [...admittedScopeOverlaps];
+    if (input.preparedTask && input.preparedTaskProjectionSucceeded) {
+        replaySession.journal.beginDerivedReplay();
+        replaySession.journal.record({
+            effect: "task-board-projection",
+            idempotencyKey: `${entry.contract}:${outcome.model.contractHead}:task-board`,
+            status: "succeeded",
+            receipt: { surface: "task-board", status: "created", authoritativeHead: outcome.model.contractHead, facts: { taskCount: input.preparedTask.taskIds.length } },
+        });
+    }
     const bootstrapPlan = entry.data.workspace === "worktree" ? entry.data.bootstrap : undefined;
     if (!replayingBindFailedTerminal && bootstrapPlan) {
         const worktreeReplay = await journal.run({
             effect: "bootstrap-worktree-prerequisite",
             run: async () => {
-                const registered = await findRegisteredContractWorktreePath(stableRoot, entry.contract);
+                const registered = await findRegisteredContractWorktreePathFromModel(stableRoot, outcome.model);
                 if (registered === worktreePath)
                     return { status: "already-present", path: worktreePath };
                 try {
@@ -261,7 +280,7 @@ async function reconcileBindContractLocked(input, replaySession, admittedScopeOv
         : undefined;
     let publishedFailedBootstrapThroughSession = false;
     if (bootstrapPlan) {
-        const locked = lookupCurrentContract(await readRepositoryLifecycle(stableRoot), entry.contract);
+        const locked = lookupCurrentContract(replaySession.repository, entry.contract);
         if (locked.status !== "healthy")
             throw new FlowError("INTERNAL_STATE", `contract ${entry.contract} became unavailable during bootstrap replay`);
         const existingBootstrap = locked.model.history.find((row) => row.entry.kind === "bootstrap")?.entry;