@astrosheep/keiyaku 2.9.12 → 2.9.13

package/build/core/settlement/claim-delivery.js

@@ -1,6 +1,6 @@
 import { FlowError } from "../../flow-error.js";
-import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, runGitProcess } from "../../git/core.js";
-import { shortCommitHash } from "../../git/commits.js";
+import { createGit, runGitProcess } from "../../git/core.js";
+import { readCommitCoordinate, shortCommitHash } from "../../git/commits.js";
 import { assertHonestClaimEvidence, buildHonestClaimMerge, } from "../repository-ledger/claim-evidence.js";
 async function successfulGit(cwd, args, input) {
     const result = await runGitProcess(cwd, args, input === undefined ? undefined : { input });
@@ -22,16 +22,29 @@ export async function buildClaimLanding(input) {
     }
 }
 export async function resolveCommit(cwd, rev) {
-    return await successfulGit(cwd, ["rev-parse", "--verify", `${rev}^{commit}`]);
+    const read = await readCommitCoordinate(cwd, rev);
+    if (read.status === "ok")
+        return read.coordinate.commit;
+    if (read.status === "failed") {
+        const detail = read.result.stderr.trim() || read.error.message || `exit ${String(read.result.status)}`;
+        throw new FlowError("INTERNAL_STATE", `git rev-parse ${rev} failed: ${detail}`, { cause: read.error });
+    }
+    if (read.status === "malformed") {
+        throw new FlowError("INTERNAL_STATE", `git rev-parse ${rev} failed: ${read.detail}`);
+    }
+    throw new FlowError("INTERNAL_STATE", `git rev-parse ${rev} failed: revision does not resolve to a commit`);
 }
 export async function resolveCommitOrNull(cwd, rev) {
-    const result = await runGitProcess(cwd, ["rev-parse", "--verify", `${rev}^{commit}`]);
-    if (result.status === 0 && !result.error)
-        return result.stdout.trim();
-    if (errorContainsAnyPattern(result.stderr, MISSING_HEAD_PATTERNS))
+    const read = await readCommitCoordinate(cwd, rev);
+    if (read.status === "ok")
+        return read.coordinate.commit;
+    if (read.status === "missing" || read.status === "non-commit")
         return null;
-    const detail = result.stderr.trim() || result.error?.message || `exit ${String(result.status)}`;
-    throw new FlowError("INTERNAL_STATE", `git rev-parse ${rev} failed: ${detail}`, { cause: result.error });
+    if (read.status === "malformed") {
+        throw new FlowError("INTERNAL_STATE", `git rev-parse ${rev} failed: ${read.detail}`);
+    }
+    const detail = read.result.stderr.trim() || read.error.message || `exit ${String(read.result.status)}`;
+    throw new FlowError("INTERNAL_STATE", `git rev-parse ${rev} failed: ${detail}`, { cause: read.error });
 }
 /** Prove parent order and tree identity independently of mutable refs. */
 export async function proveClaimLanding(cwd, landing) {

package/build/core/settlement/claim.js

@@ -179,7 +179,7 @@ export async function claimContract(input) {
                 : await context.publishAuthoritative({
                     verb: "claim",
                     admittedLedgerHead: admission.ledgerHead,
-                    acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId,
+                    acceptedLifecycleTail: context.session.lifecycle.contractHead,
                     entries: [{
                             v: 2,
                             kind: "claim",
@@ -221,11 +221,13 @@ export async function claimContract(input) {
                 },
             });
             await context.session.completeReplay("retire");
-            const taskRow = context.journal.all().find((row) => row.effect === "task-board-projection" && row.status === "succeeded");
-            const taskFacts = taskRow?.status === "succeeded" ? taskRow.receipt?.facts : undefined;
-            const warnings = isJsonObject(taskFacts) && Array.isArray(taskFacts.warnings)
-                ? taskFacts.warnings.filter((warning) => typeof warning === "string")
-                : [];
+            const warnings = ["task-board-projection", "target-worktree-projection"].flatMap((effect) => {
+                const row = context.journal.all().find((candidate) => candidate.effect === effect && candidate.status === "succeeded");
+                const facts = row?.status === "succeeded" ? row.receipt?.facts : undefined;
+                return isJsonObject(facts) && Array.isArray(facts.warnings)
+                    ? facts.warnings.filter((warning) => typeof warning === "string")
+                    : [];
+            });
             const cleanupRow = context.journal.all().find((row) => row.effect === "worktree-projection" && row.status === "succeeded");
             const cleanupFacts = cleanupRow?.status === "succeeded" ? cleanupRow.receipt?.facts : undefined;
             const deliveryRefRow = context.journal.all().find((row) => row.effect === "delivery-ref-projection" && row.status === "succeeded");

package/build/core/settlement/petition-claim-gates.js

@@ -8,7 +8,7 @@ import { getDiffStats } from "../../git/diff/preview.js";
 import { readDiff } from "../../git/diff/read.js";
 import { getCurrentBranch } from "../../git/branches.js";
 import { getLatestCommitHash } from "../../git/staging.js";
-import { createGit } from "../../git/core.js";
+import { requireCommitCoordinate } from "../../git/commits.js";
 import { DIFF_PREVIEW_TEXT_MAX_CHARS } from "../../keiyaku.js";
 import { FlowError } from "../../flow-error.js";
 import { persistResponseHistory } from "../transcripts.js";
@@ -100,13 +100,14 @@ export function createOathGate() {
 export function createCommandVerificationGate() {
     return {
         name: "command",
-        async evaluate({ cwd, coordinationRoot, verificationPlan, verificationCandidate, input }) {
-            const repositoryRoot = coordinationRoot ?? cwd;
+        async evaluate({ cwd, repositoryRoot, verificationPlan, verificationCandidate, input }) {
             for (const verification of verificationPlan) {
                 logInfo(`[CLAIM] Running ${verification.source}: ${verification.label}`, { cwd, section: "script", progressOnly: true });
             }
-            const evidence = await runVerificationPlan({ cwd, candidate: verificationCandidate, plan: verificationPlan, signal: input.signal, coordinationKey: JSON.stringify({ repository: repositoryRoot, candidate: verificationCandidate, plan: verificationPlan }), coordinationRoot: repositoryRoot });
-            const runnerFailure = evidence.find((result) => result.execution.status === "runner_failed");
+            const invocation = await runVerificationPlan({ cwd, candidate: verificationCandidate, plan: verificationPlan, signal: input.signal, root: repositoryRoot ?? cwd });
+            // Petition owns the run: abort cancels and awaitTerminal observes cleanup.
+            const evidence = await invocation.awaitTerminal();
+            const runnerFailure = evidence.results.find((result) => result.execution.status === "runner_failed");
             if (runnerFailure?.execution.status === "runner_failed") {
                 return {
                     pass: false,
@@ -120,7 +121,7 @@ export function createCommandVerificationGate() {
                     },
                 };
             }
-            const commandFailure = evidence.find((result) => result.execution.status === "executed" && result.execution.code !== 0);
+            const commandFailure = evidence.results.find((result) => result.execution.status === "executed" && result.execution.code !== 0);
             if (commandFailure?.execution.status === "executed") {
                 return {
                     pass: false,
@@ -134,7 +135,7 @@ export function createCommandVerificationGate() {
                     },
                 };
             }
-            return { pass: true, verification: [...evidence] };
+            return { pass: true, verification: [...evidence.results] };
         },
     };
 }
@@ -193,7 +194,7 @@ export function createAgentReviewGate() {
                 authority: { kind: "repository" },
                 binding: { kind: "commission", commissionId: contractId },
             });
-            const reviewHeadBeforeWrite = (await createGit(cwd).revparse(["--verify", "HEAD^{commit}"])).trim();
+            const reviewHeadBeforeWrite = (await requireCommitCoordinate(cwd, "HEAD")).commit;
             const raw = subagentResult.finalMessage.trim();
             const passed = raw.startsWith(REVIEW_PASS_TOKEN);
             const observations = passed ? raw.slice(REVIEW_PASS_TOKEN.length).trim() || undefined : undefined;

package/build/core/settlement/petition-head-guard.js

@@ -1,13 +1,12 @@
 import { FlowError } from "../../flow-error.js";
-import { createGit } from "../../git/core.js";
+import { requireCommitCoordinate } from "../../git/commits.js";
 const CONCURRENT_MODIFICATION_CODE = "CONCURRENT_MODIFICATION";
 export async function assertHeadUnchanged(cwd, expectedHead, operation) {
-    const git = createGit(cwd);
     const [expectedCommit, currentHead] = await Promise.all([
-        git.raw(["rev-parse", "--verify", `${expectedHead}^{commit}`]),
-        git.raw(["rev-parse", "--verify", "HEAD^{commit}"]),
+        requireCommitCoordinate(cwd, expectedHead),
+        requireCommitCoordinate(cwd, "HEAD"),
     ]);
-    if (currentHead.trim() === expectedCommit.trim())
+    if (currentHead.commit === expectedCommit.commit)
         return;
-    throw new FlowError(CONCURRENT_MODIFICATION_CODE, `concurrent ${operation} modification detected: repository HEAD changed from ${expectedHead} to ${currentHead.trim()} while the ${operation} was running`);
+    throw new FlowError(CONCURRENT_MODIFICATION_CODE, `concurrent ${operation} modification detected: repository HEAD changed from ${expectedHead} to ${currentHead.commit} while the ${operation} was running`);
 }

package/build/core/settlement/petition-preview.js

@@ -1,8 +1,9 @@
 import { createOathGate } from "./petition-claim-gates.js";
-import { assertFoldedPetitionable, } from "./petition.js";
+import { assertFoldedPetitionable, precedingRenewSealResult, } from "./petition.js";
 import { captureFoldedSeal } from "../seal.js";
 import { withContractCarrierSession } from "../contract-carrier.js";
 import { FlowError } from "../../flow-error.js";
+import { normalizeScopePattern } from "../scope.js";
 export const PETITION_PREVIEW_GATE_NAMES = [
     "contract",
     "freshness",
@@ -44,6 +45,7 @@ export async function previewPetition(input) {
         const base = session.lifecycle.pins.base;
         const target = { ref: session.lifecycle.pins.target.ref, branch: session.lifecycle.pins.target.ref.slice("refs/heads/".length) };
         const context = { lifecycle: session.lifecycle, deliveryCwd: session.target.root, base, target };
+        const appendScope = (input.appendScope ?? []).map(normalizeScopePattern);
         const gates = [{ name: "contract", result: "pass" }];
         const freshness = await gate("freshness", async () => {
             if (!session.pins.target.head || context.base !== session.pins.target.head) {
@@ -58,15 +60,28 @@ export async function previewPetition(input) {
             })
             : notEvaluated("arc");
         gates.push(arc);
-        const state = await gate("state", () => {
-            assertFoldedPetitionable(input.contractId, context.lifecycle);
+        const state = await gate("state", async () => {
+            await assertFoldedPetitionable(input.contractId, context.lifecycle, session.repository, session.stableRoot);
         });
         gates.push(state);
         let seal;
+        let scopeWarning = null;
         if (freshness.result === "pass" && arc.result === "pass" && state.result === "pass") {
             try {
-                const capture = await captureFoldedSeal(context.deliveryCwd, context.lifecycle, "HEAD");
-                seal = { name: "seal", result: "pass", detail: sealFileDetail(capture?.diffstat.files ?? 0) };
+                const precedingRenewSeal = appendScope.length === 0
+                    ? await precedingRenewSealResult(context.deliveryCwd, context.lifecycle)
+                    : null;
+                const capture = precedingRenewSeal
+                    ? null
+                    : await captureFoldedSeal(context.deliveryCwd, context.lifecycle, "HEAD", appendScope, "warn");
+                const scope = precedingRenewSeal ?? capture;
+                if (scope?.scopeAudit.violations.length) {
+                    scopeWarning = {
+                        violations: [...scope.scopeAudit.violations],
+                        evidence: [...scope.scopeViolationEvidence],
+                    };
+                }
+                seal = { name: "seal", result: "pass", detail: sealFileDetail(scope?.diffstat.files ?? 0) };
             }
             catch (error) {
                 seal = { name: "seal", result: "failed", detail: failureDetail(error) };
@@ -102,6 +117,7 @@ export async function previewPetition(input) {
             contract: input.contractId,
             target: context.target.ref,
             arc: { source: { arc: context.lifecycle.phase === "active" ? context.lifecycle.intent.arc : null, fence: context.lifecycle.pins.delivery } },
+            scopeWarning,
             gates,
             verdict: gates.some((item) => item.result === "failed") ? "would_fail" : "would_succeed",
         };

package/build/core/settlement/petition.js

@@ -3,14 +3,44 @@ import { parseCommandMarkdown } from "../command-markdown.js";
 import { runLifecycle } from "../lifecycle-runner.js";
 import { queueMembership, readQueueReadModel } from "./queue.js";
 import { captureFoldedSeal } from "../seal.js";
-import { currentLifecycleState } from "../repository-ledger/read-model.js";
+import { currentLifecycleState, lookupCurrentContract } from "../repository-ledger/read-model.js";
 import { assertCleanTrackedWorkingTree } from "../../git/worktree.js";
-import { normalizeScopePattern } from "../scope.js";
-export function assertFoldedPetitionable(contractId, model) {
+import { normalizeScopePattern, scopePathEvidence } from "../scope.js";
+import { readRemainingTaskNeedsForSettlement } from "../task/settlement-policy.js";
+export async function assertFoldedPetitionable(contractId, model, repository, stableRoot) {
     const state = currentLifecycleState(model);
     if (state.state !== "active" && state.state !== "bound") {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot petition from state ${state.state}`);
     }
+    const unavailable = model.causal.after.filter((dependency) => {
+        const prerequisite = lookupCurrentContract(repository, dependency);
+        return prerequisite.status !== "healthy" ||
+            (prerequisite.model.phase !== "claimed" && prerequisite.model.phase !== "forfeited");
+    });
+    if (unavailable.length > 0) {
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot petition before after dependencies settle: ${unavailable.join(", ")}`);
+    }
+    const pendingNeeds = (await readRemainingTaskNeedsForSettlement(stableRoot, model.causal.needs))
+        .filter((need) => !need.satisfied);
+    if (pendingNeeds.length > 0) {
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot petition before task needs settle: ${pendingNeeds.map((need) => need.id).join(", ")}`);
+    }
+}
+/** Rehydrate the seal consumed by an immediately preceding renew without auditing a new segment. */
+export async function precedingRenewSealResult(cwd, lifecycle, renewIndex = lifecycle.history.length - 1) {
+    const renew = lifecycle.history[renewIndex]?.entry;
+    const seal = lifecycle.history[renewIndex - 1];
+    if (renew?.kind !== "renew" || seal?.entry.kind !== "seal" || seal.entry.data.sealedBy !== "renew")
+        return null;
+    return {
+        ...seal.entry.data,
+        receipts: [...seal.entry.data.receipts],
+        diffstat: { ...seal.entry.data.diffstat },
+        scopeAudit: { violations: [...seal.entry.data.scopeAudit.violations] },
+        scopeViolationEvidence: await scopePathEvidence(cwd, lifecycle.effectiveScope, seal.entry.data.scopeAudit.violations),
+        sealedBy: "renew",
+        ledgerHead: seal.objectId,
+    };
 }
 function nextSettlementSeat(read, target) {
     let floor = 0;
@@ -68,7 +98,7 @@ export async function petitionContract(input) {
                 const branch = target.slice("refs/heads/".length);
                 throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} must renew onto ${branch} before petition`, { facts: { kind: "needs_renew", contractId: input.contractId } });
             }
-            assertFoldedPetitionable(input.contractId, session.lifecycle);
+            await assertFoldedPetitionable(input.contractId, session.lifecycle, session.repository, session.stableRoot);
             return { lifecycle: session.lifecycle, deliveryCwd };
         },
         prepare: async (admission) => {
@@ -88,7 +118,7 @@ export async function petitionContract(input) {
                         receipts: [...acceptedSeal.data.receipts],
                         diffstat: { ...acceptedSeal.data.diffstat },
                         scopeAudit: { violations: [...acceptedSeal.data.scopeAudit.violations] },
-                        scopeViolationEvidence: [],
+                        scopeViolationEvidence: await scopePathEvidence(input.cwd, admission.business.lifecycle.effectiveScope, acceptedSeal.data.scopeAudit.violations),
                     };
                     prefixIndex -= 1;
                 }
@@ -101,13 +131,14 @@ export async function petitionContract(input) {
                 return {
                     additions: [],
                     capture,
+                    precedingRenewSeal: await precedingRenewSealResult(input.cwd, admission.business.lifecycle, admission.business.lifecycle.history.findIndex(({ objectId }) => objectId === transaction.entryObjectIds.at(-1)) - 1),
                     seat: accepted.data.seat,
                     targetHead: accepted.data.intent === "claim" ? accepted.data.targetHead : admission.pins.target.head ?? "",
                     existing: { transactionObjectId: transaction.transactionObjectId },
                 };
             }
             const scopeEntry = patterns.length === 0 ? null : {
-                v: 1,
+                v: 2,
                 kind: "amend",
                 contract: input.contractId,
                 at,
@@ -118,12 +149,12 @@ export async function petitionContract(input) {
             if (!deliveryCwd)
                 throw new FlowError("INTERNAL_STATE", `petition ${input.contractId} is missing its delivery worktree`);
             const lifecycle = admission.business.lifecycle;
-            const followsRenewWithoutInterveningFact = lifecycle.phase === "active"
-                && lifecycle.seal === null
-                && lifecycle.history.at(-1)?.entry.kind === "renew";
-            const capture = followsRenewWithoutInterveningFact
+            const precedingRenewSeal = patterns.length === 0
+                ? await precedingRenewSealResult(input.cwd, lifecycle)
+                : null;
+            const capture = precedingRenewSeal
                 ? null
-                : await captureFoldedSeal(deliveryCwd, lifecycle, "HEAD", patterns);
+                : await captureFoldedSeal(deliveryCwd, lifecycle, "HEAD", patterns, "warn");
             let sealEntry = null;
             if (capture) {
                 const { scopeViolationEvidence: _evidence, ...durableCapture } = capture;
@@ -145,6 +176,7 @@ export async function petitionContract(input) {
             return {
                 additions,
                 capture,
+                precedingRenewSeal,
                 seat: nextSettlementSeat(admission.repository, admission.pins.target.ref),
                 targetHead,
             };
@@ -169,7 +201,7 @@ export async function petitionContract(input) {
             const base = session.lifecycle.pins.base;
             if (base !== session.pins.target.head)
                 return { code: "PETITION_TARGET_CHANGED", message: "petition target/base facts changed during preparation" };
-            assertFoldedPetitionable(input.contractId, session.lifecycle);
+            await assertFoldedPetitionable(input.contractId, session.lifecycle, session.repository, session.stableRoot);
             return undefined;
         },
         effect: async ({ context, prepared }) => {
@@ -208,15 +240,15 @@ export async function petitionContract(input) {
                 ? await context.replayCommitted({ transactionObjectId: prepared.existing.transactionObjectId })
                 : await context.publishAuthoritative({
                     verb: "petition",
-                    admittedLedgerHead: context.session.lifecycle.observedLedgerHead,
-                    acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId,
+                    admittedLedgerHead: context.session.pins.repositoryLedgerHead,
+                    acceptedLifecycleTail: context.session.lifecycle.contractHead,
                     entries: additions,
                 });
             if (result.status === "indeterminate") {
-                return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? context.session.lifecycle.observedLedgerHead };
+                return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? context.session.pins.repositoryLedgerHead };
             }
             if (result.status !== "committed") {
-                const authoritativeHead = result.currentHead ?? context.session.lifecycle.observedLedgerHead;
+                const authoritativeHead = result.currentHead ?? context.session.pins.repositoryLedgerHead;
                 return { kind: "refused-before-effects", authoritativeHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during petition` } };
             }
             if (input.reviewPersistence) {
@@ -254,7 +286,9 @@ export async function petitionContract(input) {
                     position,
                     seat: prepared.seat,
                     reviewHistoryPath,
-                    sealed: prepared.capture ? { ...prepared.capture, sealedBy: "petition", ledgerHead: result.transaction.entryObjectIds[result.transaction.entries.findIndex((entry) => entry.kind === "seal")] } : undefined,
+                    sealed: prepared.capture
+                        ? { ...prepared.capture, sealedBy: "petition", ledgerHead: result.transaction.entryObjectIds[result.transaction.entries.findIndex((entry) => entry.kind === "seal")] }
+                        : prepared.precedingRenewSeal ?? undefined,
                 },
             };
         },

package/build/core/settlement/settlement.js

@@ -1,9 +1,8 @@
 import { FlowError } from "../../flow-error.js";
 import { readCurrentContractContext } from "../context.js";
 import { convergeContractCarrier, withContractCarrierSession } from "../contract-carrier.js";
-import { createGit } from "../../git/core.js";
+import { requireCommitCoordinate } from "../../git/commits.js";
 import { getCurrentBranch, requireGitRepository } from "../../git/branches.js";
-import { getLatestCommitHash } from "../../git/staging.js";
 import { readContractLog } from "../log.js";
 import { scopePathEvidence } from "../scope.js";
 import { nextReviewResponseNumber } from "../transcripts.js";
@@ -45,15 +44,17 @@ async function pinnedCloseCandidate(cwd, contractId, signal) {
         if (session.target.status !== "available" || !session.pins.delivery.head) {
             throw new FlowError("INTERNAL_STATE", session.target.status === "available" ? `contract ${contractId} delivery ref does not resolve` : session.target.reason);
         }
-        const git = createGit(session.target.root);
-        const [head, tree] = await Promise.all([
-            git.raw(["rev-parse", "--verify", "HEAD^{commit}"]),
-            git.raw(["rev-parse", "--verify", "HEAD^{tree}"]),
-        ]);
-        if (head.trim() !== session.pins.delivery.head) {
+        const coordinate = await requireCommitCoordinate(session.target.root, "HEAD");
+        if (coordinate.commit !== session.pins.delivery.head) {
             throw new FlowError("INTERNAL_STATE", `contract ${contractId} delivery head changed while petition was being prepared`);
         }
-        return { deliveryCwd: session.target.root, candidate: { head: head.trim(), tree: tree.trim() }, contractVerification: contractVerificationDeclarations(session.lifecycle) };
+        const bind = session.lifecycle.history.find(({ entry }) => entry.kind === "bind")?.entry;
+        return {
+            deliveryCwd: session.target.root,
+            candidate: { head: coordinate.commit, tree: coordinate.tree },
+            contractVerification: contractVerificationDeclarations(session.lifecycle),
+            preparation: bind?.kind === "bind" && bind.data.workspace === "worktree" ? bind.data.bootstrap ?? null : null,
+        };
     });
 }
 async function loadCloseContext(cwd, requestedContractId, signal) {
@@ -66,6 +67,7 @@ async function loadCloseContext(cwd, requestedContractId, signal) {
             deliveryCwd: pinned.deliveryCwd,
             verificationCandidate: pinned.candidate,
             contractVerification: pinned.contractVerification,
+            verificationPreparation: pinned.preparation,
             keiyakuBranch: `keiyaku/${requestedContractId}`,
             baseBranch: lifecycle.pins.target.ref.slice("refs/heads/".length),
             contractId: requestedContractId,
@@ -88,6 +90,7 @@ async function loadCloseContext(cwd, requestedContractId, signal) {
         deliveryCwd: pinned.deliveryCwd,
         verificationCandidate: pinned.candidate,
         contractVerification: pinned.contractVerification,
+        verificationPreparation: pinned.preparation,
         keiyakuBranch,
         baseBranch: contractContext.baseBranch,
         contractId: contractContext.contractId,
@@ -107,14 +110,15 @@ async function throwClaimGateFailure(failure, _input, context, _dependencies) {
 }
 async function runClaimGatePipelineOrThrow(input, context, dependencies) {
     const deliveryCwd = context.deliveryCwd ?? context.cwd;
-    const verificationCandidate = context.verificationCandidate ?? {
-        head: await getLatestCommitHash(deliveryCwd),
-        tree: (await createGit(deliveryCwd).raw(["rev-parse", "--verify", "HEAD^{tree}"])).trim(),
-    };
+    const verificationCandidate = context.verificationCandidate ?? await (async () => {
+        const coordinate = await requireCommitCoordinate(deliveryCwd, "HEAD");
+        return { head: coordinate.commit, tree: coordinate.tree };
+    })();
+    const verificationPreparation = context.verificationPreparation ?? null;
     const gateConfig = await dependencies.resolveClaimGateConfig(context.cwd);
     const repositoryGates = gateConfig.repositoryGates ?? gateConfig.verificationCommands ?? [];
     const verificationPlan = composeVerificationPlan({ contract: context.contractVerification ?? [], repositoryGates, timeoutMs: gateConfig.verificationTimeoutMs });
-    const coordinationRoot = await stableRepoRoot(context.cwd);
+    const repositoryRoot = await stableRepoRoot(context.cwd);
     let review;
     let reviewHeadBeforeWrite;
     let reviewerActor;
@@ -123,11 +127,12 @@ async function runClaimGatePipelineOrThrow(input, context, dependencies) {
     for (const gate of buildClaimGatePipeline()) {
         const result = await gate.evaluate({
             cwd: deliveryCwd,
-            coordinationRoot,
+            repositoryRoot,
             contractId: context.contractId,
             input,
             verificationPlan,
             verificationCandidate,
+            verificationPreparation,
             baseBranch: dependencies.baseBranch,
             reviewNumber: dependencies.reviewNumber,
         });

package/build/core/settlement/verdict.js

@@ -103,12 +103,12 @@ export async function verdictContract(input) {
                     value: { result: admission.business.existing.result, summary: admission.business.existing.summary },
                 };
             }
-            const committed = await context.publishAuthoritative({ verb: "verdict", admittedLedgerHead: admission.ledgerHead, acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId, entries: [prepared.entry] });
+            const committed = await context.publishAuthoritative({ verb: "verdict", admittedLedgerHead: admission.ledgerHead, acceptedLifecycleTail: context.session.lifecycle.contractHead, entries: [prepared.entry] });
             if (committed.status === "indeterminate") {
                 return { kind: "precommit-effects-only", authoritativeHead: committed.currentHead ?? admission.ledgerHead };
             }
             if (committed.status !== "committed") {
-                return { kind: "refused-before-effects", authoritativeHead: committed.currentHead ?? context.session.lifecycle.observedLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during verdict` } };
+                return { kind: "refused-before-effects", authoritativeHead: committed.currentHead ?? context.session.pins.repositoryLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during verdict` } };
             }
             return {
                 kind: "committed",