@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/settlement/queue-seat-allocation.js

@@ -1,65 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { readRepositoryLifecycle } from "../repository-ledger/read-model.js";
-import { queueMembership, } from "./queue-read-model.js";
-function isPositiveSafeInteger(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
-}
-export function assertClaimQueueHead(model, contractId) {
-    const lifecycleDisease = model.diagnosticsByContract.get(contractId)?.find((diagnostic) => diagnostic.kind === "lifecycle-disease");
-    if (lifecycleDisease?.kind === "lifecycle-disease") {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is unavailable because its repository ledger history is ${lifecycleDisease.status}`, {
-            facts: {
-                kind: "repository_lifecycle_disease",
-                contractId,
-                status: lifecycleDisease.status,
-                diagnostics: lifecycleDisease.diagnostics.map((diagnostic) => ({ ...diagnostic })),
-            },
-        });
-    }
-    const membership = queueMembership(model, contractId);
-    if (!membership) {
-        if (model.unattributedDiagnostics.length > 0) {
-            throw new FlowError("INTERNAL_STATE", `contract ${contractId} queue membership is indeterminate because the repository ledger is diseased`, {
-                facts: {
-                    kind: "repository_lifecycle_disease",
-                    contractId,
-                    status: "indeterminate",
-                    diagnostics: model.unattributedDiagnostics.map((diagnostic) => ({ ...diagnostic })),
-                },
-            });
-        }
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is not queue head; position=not queued`);
-    }
-    const collision = membership.diagnostics.find((diagnostic) => diagnostic.kind === "duplicate-seat");
-    if (collision && collision.kind === "duplicate-seat") {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} has duplicate settlement seat ${collision.seat} with ${collision.with}; reject its petition and petition again`);
-    }
-    if (membership.position !== 1) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is not queue head; position=${membership.position ?? "not queued"}`);
-    }
-    return membership;
-}
-async function ledgerSeatFloor(cwd, target) {
-    const lifecycle = await readRepositoryLifecycle(cwd);
-    let maxSeat = 0;
-    for (const model of lifecycle.contracts) {
-        for (const { entry } of model.history) {
-            if (entry.kind !== "petition")
-                continue;
-            if (entry.data.target !== target)
-                continue;
-            if (entry.data.seat > maxSeat)
-                maxSeat = entry.data.seat;
-        }
-    }
-    return maxSeat;
-}
-export async function allocateSettlementSeat(cwd, input) {
-    // The candidate is derived from one typed ledger observation. The later
-    // repository-ledger transaction owns the only authoritative CAS and commit.
-    const seat = (await ledgerSeatFloor(cwd, input.target)) + 1;
-    if (!isPositiveSafeInteger(seat)) {
-        throw new FlowError("INTERNAL_STATE", `settlement seats exhausted for ${input.target}`);
-    }
-    return { seat };
-}

package/build/core/settlement/queue.js

@@ -1,6 +0,0 @@
-/**
- * Settlement queue surface: read-model derivation/query and seat allocation/assertion.
- * Implementation lives in sibling files; this module preserves the historical import path.
- */
-export { deriveQueueReadModel, queueMembership, readQueueReadModel, } from "./queue-read-model.js";
-export { allocateSettlementSeat, assertClaimQueueHead, } from "./queue-seat-allocation.js";

package/build/core/settlement/settlement.js

@@ -1,385 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { readCurrentContractContext } from "../context.js";
-import { convergeContractCarrier, withContractCarrierSession } from "../contract-carrier.js";
-import { requireCommitCoordinate } from "../../git/commits.js";
-import { getCurrentBranch, requireGitRepository } from "../../git/branches.js";
-import { readContractLog } from "../log.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 { composeVerificationPlan, contractVerificationDeclarations, resolveVerificationPolicy } from "./verification.js";
-import { forfeitKeiyaku } from "./petition-forfeit.js";
-import { assertHeadUnchanged } from "./petition-head-guard.js";
-import { petitionContract } from "./petition.js";
-import { verdictContract } from "./verdict.js";
-const VERDICT_DENIED_CODE = "VERDICT_DENIED";
-async function resolveClaimGateConfig(cwd) {
-    const merged = {
-        repositoryGates: [],
-        verificationTimeoutMs: 300_000,
-    };
-    try {
-        const policy = await resolveVerificationPolicy(cwd);
-        merged.repositoryGates = policy.commands;
-        merged.verificationTimeoutMs = policy.timeoutMs;
-        return merged;
-    }
-    catch (error) {
-        if (error instanceof FlowError && error.code === "INVALID_SETTINGS") {
-            throw new FlowError(VERDICT_DENIED_CODE, `Configuration Error: ${error.message}`, {
-                cause: error,
-                facts: error.facts,
-            });
-        }
-        throw error;
-    }
-}
-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 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`);
-        }
-        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) {
-    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,
-            verificationPreparation: pinned.preparation,
-            keiyakuBranch: `keiyaku/${requestedContractId}`,
-            baseBranch: lifecycle.pins.target.ref.slice("refs/heads/".length),
-            contractId: requestedContractId,
-        };
-    }
-    let contractContext;
-    try {
-        contractContext = await readCurrentContractContext(cwd);
-    }
-    catch (error) {
-        if (!(error instanceof FlowError) || error.code !== "EMPTY_PARAM") {
-            throw error;
-        }
-        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,
-        verificationPreparation: pinned.preparation,
-        keiyakuBranch,
-        baseBranch: contractContext.baseBranch,
-        contractId: contractContext.contractId,
-    };
-}
-async function throwClaimGateFailure(failure, _input, context, _dependencies) {
-    void _input;
-    void _dependencies;
-    void context.contractId;
-    if (failure.reviewHeadBeforeWrite) {
-        await assertHeadUnchanged(context.cwd, failure.reviewHeadBeforeWrite, "claim review");
-    }
-    throw new FlowError(failure.code, failure.message, {
-        review: failure.review,
-        facts: failure.facts,
-    });
-}
-async function runClaimGatePipelineOrThrow(input, context, dependencies) {
-    const deliveryCwd = context.deliveryCwd ?? context.cwd;
-    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 repositoryRoot = 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: deliveryCwd,
-            repositoryRoot,
-            contractId: context.contractId,
-            input,
-            verificationPlan,
-            verificationCandidate,
-            verificationPreparation,
-            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.reviewPersistence)
-            reviewPersistence = result.reviewPersistence;
-        if ("verification" in result && result.verification)
-            verification = result.verification;
-    }
-    await assertHeadUnchanged(deliveryCwd, verificationCandidate.head, "claim verification");
-    return { review, reviewHeadBeforeWrite, reviewerActor, reviewPersistence, verification };
-}
-function maxArc(entries) {
-    return entries.filter((entry) => entry.kind === "arc").length;
-}
-function cleanupWarnings(cleanup) {
-    return [
-        ...(cleanup.worktreeRemoveFailure
-            ? [`Could not remove contract worktree ${cleanup.worktreeRemoveFailure.path}: ${cleanup.worktreeRemoveFailure.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.`]
-            : []),
-    ];
-}
-/**
- * Crash-recovery head: petition → approved verdict → no claim.
- * Orchestrator resumes claim delivery only; no gates, petition, or re-judgment.
- */
-function isApprovedVerdictAwaitingClaim(lifecycle) {
-    return lifecycle.phase === "approved"
-        && lifecycle.petition.state === "approved"
-        && lifecycle.petition.intent === "claim";
-}
-/** 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 = lifecycle.history[petitionIndex - 1];
-    if (seal?.entry.kind !== "seal" || seal.entry.data.sealedBy !== "petition")
-        return undefined;
-    const scopeViolationEvidence = await scopePathEvidence(cwd, lifecycle.effectiveScope, seal.entry.data.scopeAudit.violations);
-    return {
-        ...seal.entry.data,
-        receipts: [...seal.entry.data.receipts],
-        diffstat: { ...seal.entry.data.diffstat },
-        scopeAudit: { violations: [...seal.entry.data.scopeAudit.violations] },
-        scopeViolationEvidence,
-        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, signal: options.signal });
-    const claimed = await claimContract({
-        cwd,
-        contractId,
-        actor: "keiyaku",
-        nowMs: options.nowMs,
-        signal: options.signal,
-    });
-    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),
-        currentBranch: baseBranch,
-        baseBranch,
-        commit: claimed.mergeCommit,
-        mergedInto: baseBranch,
-        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,
-    };
-}
-/**
- * Settlement claim path: gates → petition → pure verdict → claim delivery.
- * Stage modules do not call each other; this orchestrator owns the sequence.
- *
- * Atomicity equivalence: previously verdictContract appended the verdict entry
- * then immediately invoked claimContract. That remains two sequential append
- * windows (verdict then claim). Crash after approved verdict leaves state
- * petitioned with an approved verdict; the orchestrator detects that head and
- * resumes claimContract idempotently without re-running gates or judgment.
- */
-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 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, reviewPersistence: undefined, bypassedByArchitect: true }
-        : {
-            ...(await runClaimGatePipelineOrThrow(input, context, {
-                ...dependencies,
-                baseBranch,
-                reviewNumber: await nextReviewResponseNumber(cwd),
-            })),
-            bypassedByArchitect: false,
-        };
-    const oath = String(input.oath ?? "").trim();
-    if (!oath) {
-        throw new FlowError("OATH_MISSING", "Oath missing.");
-    }
-    // 1. Petition: seal + admit onto the target-local settlement queue.
-    const petition = await petitionContract({
-        cwd,
-        contractId,
-        actor: "keiyaku",
-        nowMs: Date.now(),
-        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).
-    const judgmentNowMs = Date.now();
-    const verdict = await verdictContract({
-        cwd,
-        contractId,
-        actor: claimResult.reviewerActor ?? "keiyaku",
-        nowMs: judgmentNowMs,
-        result: "approved",
-        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}`);
-    }
-    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, input.signal);
-    const { intent } = input;
-    if (intent === "FORFEIT") {
-        return forfeitKeiyaku(context, input.signal);
-    }
-    if (intent === "CLAIM") {
-        return claimKeiyaku(input, context, {
-            resolveClaimGateConfig,
-        });
-    }
-    throw new FlowError("INVALID_CLOSE_INTENT", `unsupported close intent: ${intent}`);
-}

package/build/core/settlement/verdict.js

@@ -1,126 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-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 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;
-            },
-        },
-        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.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.pins.repositoryLedgerHead, 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 (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 };
-}