@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/settlement/settlement.js

@@ -1,17 +1,19 @@
 import { FlowError } from "../../flow-error.js";
 import { readCurrentContractContext } from "../context.js";
-import { readLedger } from "../ledger.js";
-import { commissionTarget } from "../status/drift.js";
-import { deriveContractState } from "../status/lifecycle.js";
+import { convergeContractCarrier, withContractCarrierSession } from "../contract-carrier.js";
+import { createGit } from "../../git/core.js";
 import { getCurrentBranch, requireGitRepository } from "../../git/branches.js";
+import { getLatestCommitHash } from "../../git/staging.js";
 import { readContractLog } from "../log.js";
-import { listRefLogCommits } from "../ref-log.js";
-import { effectiveScope } from "../seal.js";
 import { scopePathEvidence } from "../scope.js";
 import { nextReviewResponseNumber } from "../transcripts.js";
+import { stableRepoRoot } from "../worktree-path.js";
+import { isCompleteLifecycleOutcome } from "../outcome-base.js";
 import { claimContract } from "./claim.js";
+import { assertClaimQueueHead, deriveQueueReadModel } from "./queue.js";
+import { classifyCurrentPetitionWindow } from "./petition-window.js";
 import { buildClaimGatePipeline, } from "./petition-claim-gates.js";
-import { resolveVerificationCommands } from "./verification.js";
+import { composeVerificationPlan, contractVerificationDeclarations, resolveVerificationPolicy } from "./verification.js";
 import { forfeitKeiyaku } from "./petition-forfeit.js";
 import { assertHeadUnchanged } from "./petition-head-guard.js";
 import { petitionContract } from "./petition.js";
@@ -19,10 +21,13 @@ import { verdictContract } from "./verdict.js";
 const VERDICT_DENIED_CODE = "VERDICT_DENIED";
 async function resolveClaimGateConfig(cwd) {
     const merged = {
-        verificationCommands: [],
+        repositoryGates: [],
+        verificationTimeoutMs: 300_000,
     };
     try {
-        merged.verificationCommands = await resolveVerificationCommands(cwd);
+        const policy = await resolveVerificationPolicy(cwd);
+        merged.repositoryGates = policy.commands;
+        merged.verificationTimeoutMs = policy.timeoutMs;
         return merged;
     }
     catch (error) {
@@ -35,21 +40,34 @@ async function resolveClaimGateConfig(cwd) {
         throw error;
     }
 }
-async function loadCloseContext(cwd, requestedContractId) {
-    await requireGitRepository(cwd, "petition");
-    if (requestedContractId) {
-        const ledger = await readLedger(cwd, requestedContractId);
-        if (!ledger) {
-            throw new FlowError("INTERNAL_STATE", `contract ${requestedContractId} not found or not active`);
+async function pinnedCloseCandidate(cwd, contractId, signal) {
+    return withContractCarrierSession({ cwd, contractId, mode: "observe-only", signal }, async (session) => {
+        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 target = commissionTarget(ledger.entries);
-        if (!target) {
-            throw new FlowError("INTERNAL_STATE", `contract ${requestedContractId} active ledger is missing commission target`);
+        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) {
+            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) };
+    });
+}
+async function loadCloseContext(cwd, requestedContractId, signal) {
+    await requireGitRepository(cwd, "petition");
+    if (requestedContractId) {
+        const lifecycle = (await convergeContractCarrier({ cwd, contractId: requestedContractId, signal, mode: "observe-only" })).lifecycle;
+        const pinned = await pinnedCloseCandidate(cwd, requestedContractId, signal);
         return {
             cwd,
+            deliveryCwd: pinned.deliveryCwd,
+            verificationCandidate: pinned.candidate,
+            contractVerification: pinned.contractVerification,
             keiyakuBranch: `keiyaku/${requestedContractId}`,
-            baseBranch: target.branch,
+            baseBranch: lifecycle.pins.target.ref.slice("refs/heads/".length),
             contractId: requestedContractId,
         };
     }
@@ -64,8 +82,12 @@ async function loadCloseContext(cwd, requestedContractId) {
         throw new FlowError("NOT_ACTIVE_KEIYAKU_BRANCH", "Current workspace is not addressing an active Keiyaku contract.");
     }
     const keiyakuBranch = await getCurrentBranch(cwd);
+    const pinned = await pinnedCloseCandidate(cwd, contractContext.contractId, signal);
     return {
         cwd,
+        deliveryCwd: pinned.deliveryCwd,
+        verificationCandidate: pinned.candidate,
+        contractVerification: pinned.contractVerification,
         keiyakuBranch,
         baseBranch: contractContext.baseBranch,
         contractId: contractContext.contractId,
@@ -84,30 +106,47 @@ async function throwClaimGateFailure(failure, _input, context, _dependencies) {
     });
 }
 async function runClaimGatePipelineOrThrow(input, context, dependencies) {
-    const { verificationCommands } = await dependencies.resolveClaimGateConfig(context.cwd);
+    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 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);
     let review;
     let reviewHeadBeforeWrite;
     let reviewerActor;
+    let reviewPersistence;
+    let verification;
     for (const gate of buildClaimGatePipeline()) {
         const result = await gate.evaluate({
-            cwd: context.cwd,
+            cwd: deliveryCwd,
+            coordinationRoot,
             contractId: context.contractId,
             input,
-            verificationCommands,
+            verificationPlan,
+            verificationCandidate,
             baseBranch: dependencies.baseBranch,
             reviewNumber: dependencies.reviewNumber,
         });
+        if (!result.pass) {
+            await throwClaimGateFailure(result, input, context, dependencies);
+        }
         if (result.review) {
             review = result.review;
             reviewHeadBeforeWrite = result.reviewHeadBeforeWrite;
         }
         if (result.reviewerActor)
             reviewerActor = result.reviewerActor;
-        if (!result.pass) {
-            await throwClaimGateFailure(result, input, context, dependencies);
-        }
+        if (result.reviewPersistence)
+            reviewPersistence = result.reviewPersistence;
+        if ("verification" in result && result.verification)
+            verification = result.verification;
     }
-    return { review, reviewHeadBeforeWrite, reviewerActor };
+    await assertHeadUnchanged(deliveryCwd, verificationCandidate.head, "claim verification");
+    return { review, reviewHeadBeforeWrite, reviewerActor, reviewPersistence, verification };
 }
 function maxArc(entries) {
     return entries.filter((entry) => entry.kind === "arc").length;
@@ -117,75 +156,108 @@ function cleanupWarnings(cleanup) {
         ...(cleanup.worktreeRemoveFailure
             ? [`Could not remove contract worktree ${cleanup.worktreeRemoveFailure.path}: ${cleanup.worktreeRemoveFailure.reason}`]
             : []),
-        ...(cleanup.branchDeleteFailure
-            ? [`Could not delete contract branch ${cleanup.branchDeleteFailure.name}: ${cleanup.branchDeleteFailure.reason}`]
+        ...(cleanup.deliveryRef.status === "mismatch"
+            ? [`Delivery ref ${cleanup.deliveryRef.mismatch.ref} remains present at ${cleanup.deliveryRef.mismatch.observed.head}; terminal replay preserved it as a projected-surface mismatch.`]
             : []),
     ];
 }
-function findClaimEntry(entries) {
-    return entries.find((entry) => entry.kind === "claim");
-}
-/** Verdict for the open petition window (after last petition, before claim). */
-function latestCurrentPetitionVerdict(entries) {
-    for (let index = entries.length - 1; index >= 0; index -= 1) {
-        const entry = entries[index];
-        if (entry.kind === "verdict")
-            return entry;
-        if (entry.kind === "petition")
-            return undefined;
-    }
-    return undefined;
-}
 /**
  * Crash-recovery head: petition → approved verdict → no claim.
  * Orchestrator resumes claim delivery only; no gates, petition, or re-judgment.
  */
-function isApprovedVerdictAwaitingClaim(entries) {
-    const state = deriveContractState(entries);
-    if (state.state !== "petitioned")
-        return false;
-    if (findClaimEntry(entries))
-        return false;
-    return latestCurrentPetitionVerdict(entries)?.data.result === "approved";
+function isApprovedVerdictAwaitingClaim(lifecycle) {
+    return lifecycle.phase === "approved"
+        && lifecycle.petition.state === "approved"
+        && lifecycle.petition.intent === "claim";
 }
-async function recoverCurrentPetitionSeal(cwd, ledger) {
-    let petitionIndex = -1;
-    for (let index = ledger.entries.length - 1; index >= 0; index -= 1) {
-        if (ledger.entries[index]?.kind === "petition") {
-            petitionIndex = index;
-            break;
-        }
+/** Resume the first missing stage of an existing petition settlement. */
+export async function reconcilePetitionRetry(input) {
+    const observed = await withContractCarrierSession({ ...input, mode: "observe-only" }, async (session) => ({
+        window: classifyCurrentPetitionWindow(session.lifecycle, session.pins),
+        queue: deriveQueueReadModel(session.repository),
+    }));
+    if (observed.window.status === "none")
+        return { status: "not-needed" };
+    if (observed.window.status === "approved-awaiting-claim") {
+        return { status: "approved-awaiting-claim" };
+    }
+    if (observed.window.status === "invalid") {
+        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} petition recovery is invalid: ${observed.window.reason}`);
+    }
+    assertClaimQueueHead(observed.queue, input.contractId);
+    if (observed.window.coordinates === "fresh") {
+        return {
+            status: "verdict",
+            result: "approved",
+            reason: "resume",
+            verdict: await verdictContract({
+                cwd: input.cwd,
+                contractId: input.contractId,
+                actor: "keiyaku",
+                nowMs: Date.now(),
+                result: "approved",
+                summary: "Recovered passed petition at its pinned candidate.",
+                signal: input.signal,
+            }),
+        };
     }
+    const reason = observed.window.coordinates;
+    return {
+        status: "verdict",
+        result: "rejected",
+        reason,
+        verdict: await verdictContract({
+            cwd: input.cwd,
+            contractId: input.contractId,
+            actor: "keiyaku",
+            nowMs: Date.now(),
+            result: "rejected",
+            summary: reason === "target-drift"
+                ? "Petition target advanced before verdict."
+                : "Petition delivery changed before verdict.",
+            signal: input.signal,
+        }),
+    };
+}
+export async function recoverCurrentPetitionSeal(cwd, lifecycle) {
+    if (lifecycle.petition.state !== "approved" || lifecycle.petition.intent !== "claim")
+        return undefined;
+    const petitionObjectId = lifecycle.petition.objectId;
+    const petitionIndex = lifecycle.history.findIndex(({ objectId }) => objectId === petitionObjectId);
     if (petitionIndex <= 0)
         return undefined;
-    const seal = ledger.entries[petitionIndex - 1];
-    if (seal.kind !== "seal" || seal.data.sealedBy !== "petition")
+    const seal = lifecycle.history[petitionIndex - 1];
+    if (seal?.entry.kind !== "seal" || seal.entry.data.sealedBy !== "petition")
         return undefined;
-    const commits = await listRefLogCommits(cwd, ledger.head, ledger.ref);
-    const ledgerHead = commits[petitionIndex - 1];
-    if (!ledgerHead || commits.length !== ledger.entries.length) {
-        throw new FlowError("INTERNAL_STATE", `contract ${ledger.contractId} ledger entries do not align with ref-log commits during petition recovery`);
-    }
-    const scopeViolationEvidence = await scopePathEvidence(cwd, effectiveScope(ledger.entries), seal.data.scopeAudit.violations);
+    const scopeViolationEvidence = await scopePathEvidence(cwd, lifecycle.effectiveScope, seal.entry.data.scopeAudit.violations);
     return {
-        ...seal.data,
+        ...seal.entry.data,
+        receipts: [...seal.entry.data.receipts],
+        diffstat: { ...seal.entry.data.diffstat },
+        scopeAudit: { violations: [...seal.entry.data.scopeAudit.violations] },
         scopeViolationEvidence,
-        ledgerHead,
+        ledgerHead: seal.objectId,
     };
 }
 async function finishApprovedClaim(context, options) {
     const { cwd, baseBranch, contractId } = context;
     // Capture arc facts before claim cleanup may remove the delivery worktree cwd.
-    const log = await readContractLog({ cwd, contractId });
+    const log = await readContractLog({ cwd, contractId, signal: options.signal });
     const claimed = await claimContract({
         cwd,
         contractId,
         actor: "keiyaku",
         nowMs: options.nowMs,
+        signal: options.signal,
     });
-    const cleanup = claimed.cleanup ?? { absent: ["worktree", "branch"] };
+    if (!isCompleteLifecycleOutcome(claimed))
+        return claimed;
+    if (!claimed.cleanup)
+        throw new FlowError("INTERNAL_STATE", "complete claim has no terminal cleanup facts");
+    const cleanup = claimed.cleanup;
     const warnings = [...(claimed.warnings ?? []), ...cleanupWarnings(cleanup)];
     return {
+        ...claimed,
         status: "success",
         result: "merged",
         arc: maxArc(log.entries),
@@ -193,12 +265,12 @@ async function finishApprovedClaim(context, options) {
         baseBranch,
         commit: claimed.mergeCommit,
         mergedInto: baseBranch,
-        ...(cleanup.deletedBranch ? { deletedBranch: cleanup.deletedBranch } : {}),
         cleanup,
         diff: `Merged contract ${contractId} with merge-tree/commit-tree CAS.`,
         // Prior public outcome carried sealed facts when petition sealed an open arc.
         ...(options.sealed ? { sealed: options.sealed } : {}),
         ...(warnings.length > 0 ? { meta: { warnings } } : {}),
+        carrier: claimed.carrier,
     };
 }
 /**
@@ -213,29 +285,35 @@ async function finishApprovedClaim(context, options) {
  */
 export async function claimKeiyaku(input, context, dependencies) {
     const { cwd, baseBranch, contractId } = context;
+    const retry = await reconcilePetitionRetry({
+        cwd,
+        contractId,
+        signal: input.signal,
+    });
+    if (retry.status === "verdict" && !isCompleteLifecycleOutcome(retry.verdict)) {
+        return retry.verdict;
+    }
     // Crash recovery: petition → approved verdict → no claim.
     // Resume claim delivery only; do not re-gate, re-petition, or re-judge.
-    const existing = await readLedger(cwd, contractId);
-    if (existing && isApprovedVerdictAwaitingClaim(existing.entries)) {
-        const sealed = await recoverCurrentPetitionSeal(cwd, existing);
+    const existing = await convergeContractCarrier({ cwd, contractId, signal: input.signal, mode: "observe-only" });
+    if (isApprovedVerdictAwaitingClaim(existing.lifecycle)) {
+        const sealed = await recoverCurrentPetitionSeal(cwd, existing.lifecycle);
         return finishApprovedClaim(context, {
             nowMs: Date.now(),
+            signal: input.signal,
             ...(sealed ? { sealed } : {}),
         });
     }
     const claimResult = "dangerouslyBypassGates" in input && input.dangerouslyBypassGates
-        ? { review: undefined, reviewHeadBeforeWrite: undefined, bypassedByArchitect: true }
+        ? { review: undefined, reviewHeadBeforeWrite: undefined, reviewPersistence: undefined, bypassedByArchitect: true }
         : {
-            ...(await runClaimGatePipelineOrThrow(input, { cwd, contractId }, {
+            ...(await runClaimGatePipelineOrThrow(input, context, {
                 ...dependencies,
                 baseBranch,
                 reviewNumber: await nextReviewResponseNumber(cwd),
             })),
             bypassedByArchitect: false,
         };
-    if (claimResult.review && claimResult.reviewHeadBeforeWrite) {
-        await assertHeadUnchanged(cwd, claimResult.reviewHeadBeforeWrite, "claim review");
-    }
     const oath = String(input.oath ?? "").trim();
     if (!oath) {
         throw new FlowError("OATH_MISSING", "Oath missing.");
@@ -249,7 +327,14 @@ export async function claimKeiyaku(input, context, dependencies) {
         intent: "claim",
         oath,
         appendScope: input.appendScope,
+        reviewPersistence: claimResult.reviewPersistence,
+        signal: input.signal,
     });
+    if (!isCompleteLifecycleOutcome(petition))
+        return petition;
+    const review = claimResult.review
+        ? { ...claimResult.review, ...(petition.reviewHistoryPath ? { historyPath: petition.reviewHistoryPath } : {}) }
+        : undefined;
     // 2. Pure verdict: judgment facts only; no claim execution.
     // Capture one clock for verdict + claim so ledger timestamps match the prior
     // verdict→claim atomic pair (verdict previously forwarded its own nowMs).
@@ -260,24 +345,31 @@ export async function claimKeiyaku(input, context, dependencies) {
         actor: claimResult.reviewerActor ?? "keiyaku",
         nowMs: judgmentNowMs,
         result: "approved",
-        summary: claimResult.review?.findings?.trim() || "礼成",
+        summary: review?.findings?.trim() || "礼成",
+        signal: input.signal,
     });
+    if (!isCompleteLifecycleOutcome(verdict))
+        return verdict;
     // 3. Execution: approved → claim delivery (same sequential append window as before).
     // Rejected verdict publication is verdictContract itself (state returns active).
     if (verdict.result !== "approved") {
         throw new FlowError("INTERNAL_STATE", `settlement expected approved verdict for ${contractId}, got ${verdict.result}`);
     }
-    return finishApprovedClaim(context, {
+    const completed = await finishApprovedClaim(context, {
         nowMs: judgmentNowMs,
+        signal: input.signal,
         ...(petition.sealed ? { sealed: petition.sealed } : {}),
     });
+    if (!claimResult.verification || !isCompleteLifecycleOutcome(completed))
+        return completed;
+    return { ...completed, verification: claimResult.verification };
 }
 /** Public settlement entrypoint for CLI petition (claim or forfeit). */
 export async function petitionKeiyaku(input) {
-    const context = await loadCloseContext(input.cwd, input.contractId);
+    const context = await loadCloseContext(input.cwd, input.contractId, input.signal);
     const { intent } = input;
     if (intent === "FORFEIT") {
-        return forfeitKeiyaku(context);
+        return forfeitKeiyaku(context, input.signal);
     }
     if (intent === "CLAIM") {
         return claimKeiyaku(input, context, {

package/build/core/settlement/verdict.js

@@ -1,80 +1,126 @@
 import { FlowError } from "../../flow-error.js";
-import { activeLedgerRef, appendWithRetry, readLedger } from "../ledger.js";
-import { assertClaimQueueHead, readQueueReadModel } from "./queue.js";
-import { deriveContractState } from "../status/lifecycle.js";
-function latestVerdict(entries) {
-    for (let index = entries.length - 1; index >= 0; index -= 1) {
-        const entry = entries[index];
-        if (entry.kind === "verdict")
-            return entry;
-        if (entry.kind === "petition")
-            return undefined;
-    }
-    return undefined;
-}
-function assertPetitioned(contractId, entries) {
-    const state = deriveContractState(entries);
+import { runLifecycle } from "../lifecycle-runner.js";
+import { assertClaimQueueHead } from "./queue.js";
+import { deriveQueueReadModel } from "./queue-read-model.js";
+import { currentLifecycleState } from "../repository-ledger/read-model.js";
+function assertFoldedPetitioned(contractId, model) {
+    const state = currentLifecycleState(model);
     if (state.state !== "petitioned") {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot verdict from state ${state.state}`);
     }
 }
+function assertApprovedWindow(contractId, model, pins) {
+    if (model.petition.state !== "awaiting-verdict") {
+        throw new FlowError("VERDICT_DENIED", `contract ${contractId} cannot approve petition without an awaiting-verdict fold`);
+    }
+    if (!pins.target.head || !pins.delivery.head) {
+        throw new FlowError("VERDICT_DENIED", `contract ${contractId} cannot approve petition because current coordinates do not resolve`);
+    }
+    if (model.pins.base !== pins.target.head) {
+        throw new FlowError("VERDICT_DENIED", `contract ${contractId} cannot approve petition from target-drift`);
+    }
+    if (model.pins.delivery !== pins.delivery.head) {
+        throw new FlowError("VERDICT_DENIED", `contract ${contractId} cannot approve petition from delivery-drift`);
+    }
+}
 /**
  * Append a verdict entry and return typed judgment facts.
  * Does not claim, clean up, or otherwise execute delivery.
  */
 export async function verdictContract(input) {
     const at = new Date(input.nowMs).toISOString();
-    const current = await readLedger(input.cwd, input.contractId);
-    if (!current) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found or not active`);
-    }
-    assertPetitioned(input.contractId, current.entries);
-    // Rejected verdict is allowed for any petitioned ledger, including legacy and
-    // target mismatch, without a queue-head gate.
-    if (input.result === "approved") {
-        const model = await readQueueReadModel(input.cwd);
-        assertClaimQueueHead(model, input.contractId);
-    }
-    const ref = activeLedgerRef(input.contractId);
-    const appendResult = await appendWithRetry(input.cwd, ref, async (_head, entries) => {
-        const existingVerdict = latestVerdict(entries);
-        if (existingVerdict)
-            return null;
-        assertPetitioned(input.contractId, entries);
-        if (input.result === "approved") {
-            const model = await readQueueReadModel(input.cwd);
-            assertClaimQueueHead(model, input.contractId);
-        }
-        const entry = {
-            v: 1,
-            kind: "verdict",
-            contract: input.contractId,
-            at,
-            actor: input.actor,
-            data: {
-                result: input.result,
-                summary: input.summary,
+    const execution = await runLifecycle({
+        cwd: input.cwd,
+        contractId: input.contractId,
+        mutation: {
+            verb: "verdict",
+            matchesAccepted: (transaction) => {
+                const accepted = transaction.entries.at(-1);
+                return accepted?.kind === "verdict"
+                    && accepted.data.result === input.result
+                    && accepted.data.summary === input.summary;
             },
-        };
-        return entry;
+        },
+        signal: input.signal,
+        admit: async (session, replay) => {
+            const transaction = replay.state === "verb-committed" ? replay.transaction : undefined;
+            const accepted = transaction?.entries.at(-1);
+            if (accepted && accepted.kind !== "verdict") {
+                throw new FlowError("INTERNAL_STATE", `accepted transaction ${transaction.transactionObjectId} is not a verdict`);
+            }
+            if (!accepted)
+                assertFoldedPetitioned(input.contractId, session.lifecycle);
+            const queue = input.result === "approved" && !accepted ? deriveQueueReadModel(session.repository) : null;
+            if (queue) {
+                assertClaimQueueHead(queue, input.contractId);
+                assertApprovedWindow(input.contractId, session.lifecycle, session.pins);
+            }
+            return {
+                existing: accepted?.kind === "verdict"
+                    ? { transactionObjectId: transaction.transactionObjectId, result: accepted.data.result, summary: accepted.data.summary }
+                    : undefined,
+            };
+        },
+        prepare: () => ({ entry: {
+                v: 1,
+                kind: "verdict",
+                contract: input.contractId,
+                at,
+                actor: input.actor,
+                data: {
+                    result: input.result,
+                    summary: input.summary,
+                },
+            } }),
+        revalidate: async ({ session, admission }) => {
+            if (admission.business.existing) {
+                return session.repository.topology.nodes.some((node) => node.objectId === admission.business.existing.transactionObjectId)
+                    ? undefined
+                    : { code: "VERDICT_CHANGED", message: "current petition verdict changed during preparation" };
+            }
+            assertFoldedPetitioned(input.contractId, session.lifecycle);
+            if (input.result === "approved") {
+                const queue = deriveQueueReadModel(session.repository);
+                try {
+                    assertClaimQueueHead(queue, input.contractId);
+                    assertApprovedWindow(input.contractId, session.lifecycle, session.pins);
+                }
+                catch (error) {
+                    return {
+                        code: "VERDICT_COORDINATES_CHANGED",
+                        message: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            }
+            return undefined;
+        },
+        effect: async ({ context, admission, prepared }) => {
+            if (admission.business.existing) {
+                return {
+                    kind: "committed",
+                    commit: await context.replayCommitted({ transactionObjectId: admission.business.existing.transactionObjectId }),
+                    entryKind: "verdict",
+                    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] });
+            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: "committed",
+                commit: committed,
+                entryKind: "verdict",
+                value: { result: input.result, summary: input.summary },
+            };
+        },
     });
-    if (!appendResult.ok && appendResult.reason !== "aborted") {
-        throw new FlowError("INTERNAL_STATE", `failed to append verdict for ${input.contractId}: ${appendResult.reason}`);
-    }
-    const settled = await readLedger(input.cwd, input.contractId);
-    if (!settled) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} disappeared before verdict settlement`);
-    }
-    const verdict = latestVerdict(settled.entries);
-    if (!verdict) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} missing verdict after settlement write`);
-    }
-    if (verdict.data.result !== input.result) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} already has ${verdict.data.result} verdict`);
-    }
-    return {
-        contractId: input.contractId,
-        result: verdict.data.result,
-        summary: verdict.data.summary,
-    };
+    if (execution.kind === "noncommitted")
+        return execution.outcome;
+    if (execution.kind === "contained")
+        return { ...execution.outcome, contractId: input.contractId };
+    return { ...execution.outcome, contractId: input.contractId, ...execution.payload, carrier: execution.carrier };
 }