@astrosheep/keiyaku 2.9.9 → 2.9.10

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

@@ -1,6 +1,8 @@
 import { createOathGate } from "./petition-claim-gates.js";
-import { assertPetitionArcReady, assertPetitionFresh, assertPetitionable, loadPetitionPreflightContext, } from "./petition.js";
-import { petitionSealSource, previewSeal } from "../seal.js";
+import { assertFoldedPetitionable, } from "./petition.js";
+import { captureFoldedSeal } from "../seal.js";
+import { withContractCarrierSession } from "../contract-carrier.js";
+import { FlowError } from "../../flow-error.js";
 export const PETITION_PREVIEW_GATE_NAMES = [
     "contract",
     "freshness",
@@ -23,8 +25,8 @@ async function gate(name, evaluate) {
         return { name, result: "failed", detail: failureDetail(error) };
     }
 }
-function sealPathDetail(paths) {
-    return `${paths.length} ${paths.length === 1 ? "file" : "files"} · ${paths.length > 0 ? paths.join(", ") : "(none)"}`;
+function sealFileDetail(files) {
+    return `${files} ${files === 1 ? "file" : "files"}`;
 }
 const notEvaluated = (name) => ({
     name,
@@ -36,62 +38,72 @@ const notEvaluated = (name) => ({
  * target/source coordinate and therefore propagates as dry-run exit 2.
  */
 export async function previewPetition(input) {
-    const context = await loadPetitionPreflightContext(input.cwd, input.contractId);
-    const gates = [{ name: "contract", result: "pass" }];
-    const freshness = await gate("freshness", async () => {
-        await assertPetitionFresh(input.cwd, input.contractId, context.ledger.entries, context.base);
-    });
-    gates.push(freshness);
-    const arc = freshness.result === "pass"
-        ? await gate("arc", async () => {
-            await assertPetitionArcReady(context.deliveryCwd, input.contractId, context.ledger.entries);
-        })
-        : notEvaluated("arc");
-    gates.push(arc);
-    const state = await gate("state", () => {
-        assertPetitionable(input.contractId, context.ledger.entries);
-    });
-    gates.push(state);
-    let seal;
-    if (freshness.result === "pass" && arc.result === "pass" && state.result === "pass") {
-        try {
-            const sealPreview = await previewSeal(context.deliveryCwd, context.ledger.entries, "HEAD");
-            seal = { name: "seal", result: "pass", detail: sealPathDetail(sealPreview.paths) };
+    return withContractCarrierSession({ cwd: input.cwd, contractId: input.contractId, mode: "observe-only", signal: input.signal }, async (session) => {
+        if (session.target.status !== "available")
+            throw new FlowError("INTERNAL_STATE", session.target.reason);
+        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 gates = [{ name: "contract", result: "pass" }];
+        const freshness = await gate("freshness", async () => {
+            if (!session.pins.target.head || context.base !== session.pins.target.head) {
+                throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} must renew onto ${context.target.branch} before petition`);
+            }
+        });
+        gates.push(freshness);
+        const arc = freshness.result === "pass"
+            ? await gate("arc", async () => {
+                if (context.lifecycle.phase !== "active")
+                    throw new FlowError("NO_OPEN_ARC", "no active folded arc requires sealing");
+            })
+            : notEvaluated("arc");
+        gates.push(arc);
+        const state = await gate("state", () => {
+            assertFoldedPetitionable(input.contractId, context.lifecycle);
+        });
+        gates.push(state);
+        let seal;
+        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) };
+            }
+            catch (error) {
+                seal = { name: "seal", result: "failed", detail: failureDetail(error) };
+            }
         }
-        catch (error) {
-            seal = { name: "seal", result: "failed", detail: failureDetail(error) };
+        else {
+            seal = notEvaluated("seal");
         }
-    }
-    else {
-        seal = notEvaluated("seal");
-    }
-    gates.push(seal);
-    const oathOwner = createOathGate();
-    const oath = await gate("oath", async () => {
-        const result = await oathOwner.evaluate({
-            cwd: input.cwd,
-            contractId: input.contractId,
-            input: {
+        gates.push(seal);
+        const oathOwner = createOathGate();
+        const oath = await gate("oath", async () => {
+            const result = await oathOwner.evaluate({
                 cwd: input.cwd,
                 contractId: input.contractId,
-                intent: "CLAIM",
-                title: `Petition ${input.contractId}`,
-                plea: `Settle contract ${input.contractId} through the petition pipeline.`,
-                oath: input.oath,
-            },
-            verificationCommands: [],
-            baseBranch: context.target.branch,
-            reviewNumber: 0,
+                input: {
+                    cwd: input.cwd,
+                    contractId: input.contractId,
+                    intent: "CLAIM",
+                    title: `Petition ${input.contractId}`,
+                    plea: `Settle contract ${input.contractId} through the petition pipeline.`,
+                    oath: input.oath,
+                },
+                verificationPlan: [],
+                verificationCandidate: { head: "", tree: "" },
+                baseBranch: context.target.branch,
+                reviewNumber: 0,
+            });
+            if (!result.pass)
+                throw new Error(result.message);
         });
-        if (!result.pass)
-            throw new Error(result.message);
+        gates.push(oath, notEvaluated("verification"), notEvaluated("review"));
+        return {
+            contract: input.contractId,
+            target: context.target.ref,
+            arc: { source: { arc: context.lifecycle.phase === "active" ? context.lifecycle.intent.arc : null, fence: context.lifecycle.pins.delivery } },
+            gates,
+            verdict: gates.some((item) => item.result === "failed") ? "would_fail" : "would_succeed",
+        };
     });
-    gates.push(oath, notEvaluated("verification"), notEvaluated("review"));
-    return {
-        contract: input.contractId,
-        target: context.target.ref,
-        arc: { source: petitionSealSource(context.ledger.entries) },
-        gates,
-        verdict: gates.some((item) => item.result === "failed") ? "would_fail" : "would_succeed",
-    };
 }

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

@@ -0,0 +1,50 @@
+export function inspectCurrentPetition(lifecycle) {
+    const petitionObjectId = lifecycle.petition.state === "none" ? undefined : lifecycle.petition.objectId;
+    const petitionIndex = petitionObjectId === undefined
+        ? -1
+        : lifecycle.history.findIndex(({ objectId }) => objectId === petitionObjectId);
+    if (petitionIndex < 0)
+        return undefined;
+    const petition = lifecycle.history[petitionIndex]?.entry;
+    if (!petition || petition.kind !== "petition")
+        return undefined;
+    const preceding = lifecycle.history[petitionIndex - 1]?.entry;
+    const seal = preceding?.kind === "seal" && preceding.data.sealedBy === "petition"
+        ? preceding
+        : undefined;
+    const verdictRow = lifecycle.verdict === null
+        ? undefined
+        : lifecycle.history.find(({ objectId }) => objectId === lifecycle.verdict?.objectId);
+    const verdict = verdictRow?.entry.kind === "verdict" ? verdictRow.entry : undefined;
+    return {
+        petitionIndex,
+        petition,
+        candidateHead: seal?.data.newFence ?? lifecycle.pins.delivery,
+        ...(seal ? { seal } : {}),
+        ...(verdict ? { verdict } : {}),
+    };
+}
+export function classifyCurrentPetitionWindow(lifecycle, pins) {
+    if (lifecycle.phase !== "awaiting-verdict" && lifecycle.phase !== "approved")
+        return { status: "none" };
+    const current = inspectCurrentPetition(lifecycle);
+    if (!current)
+        return { status: "none" };
+    if (current.verdict?.data.result === "approved") {
+        return { status: "approved-awaiting-claim", entries: current };
+    }
+    if (current.verdict) {
+        return { status: "invalid", reason: "petitioned window has a non-approved verdict", entries: current };
+    }
+    const base = lifecycle.pins.base;
+    if (!base || !pins.target.head || !pins.delivery.head) {
+        return { status: "invalid", reason: "current petition coordinates do not resolve", entries: current };
+    }
+    if (base !== pins.target.head) {
+        return { status: "unjudged", coordinates: "target-drift", entries: current };
+    }
+    if (current.candidateHead !== pins.delivery.head) {
+        return { status: "unjudged", coordinates: "delivery-drift", entries: current };
+    }
+    return { status: "unjudged", coordinates: "fresh", entries: current };
+}

package/build/core/settlement/petition.js

@@ -1,148 +1,269 @@
 import { FlowError } from "../../flow-error.js";
-import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../../git/core.js";
 import { parseCommandMarkdown } from "../command-markdown.js";
-import { activeLedgerRef, appendWithRetry, readLedger } from "../ledger.js";
-import { allocateSettlementSeat, queueMembership, readQueueReadModel } from "./queue.js";
-import { appendScopeTerms, findOpenArc, getMaxArc, receiptsAfterFence, sealCurrentArc } from "../seal.js";
-import { deriveContractState } from "../status/lifecycle.js";
-import { commissionTarget, latestBase } from "../status/drift.js";
-import { findContractWorktreePath } from "../worktree-path.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 { assertCleanTrackedWorkingTree } from "../../git/worktree.js";
-async function resolveCommit(cwd, ref) {
-    const git = createGit(cwd);
-    try {
-        return (await git.raw(["rev-parse", "--verify", `${ref}^{commit}`])).trim();
-    }
-    catch (error) {
-        if (errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS))
-            return null;
-        throw wrapGitError(`rev-parse ${ref}`, error, cwd);
-    }
-}
-export async function loadPetitionPreflightContext(cwd, contractId) {
-    const ledger = await readLedger(cwd, contractId);
-    if (!ledger) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} not found or not active`);
-    }
-    const base = latestBase(ledger.entries);
-    if (!base)
-        throw new FlowError("INTERNAL_STATE", "ledger must contain bind entry");
-    const target = commissionTarget(ledger.entries);
-    if (!target) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} missing commission target`);
-    }
-    return {
-        ledger,
-        deliveryCwd: (await findContractWorktreePath(cwd, contractId)) ?? cwd,
-        base,
-        target,
-    };
-}
-export async function assertPetitionFresh(cwd, contractId, entries, base) {
-    const target = commissionTarget(entries);
-    if (!target) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} missing commission target`);
-    }
-    const head = await resolveCommit(cwd, target.ref);
-    if (!head) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} commission target ${target.ref} does not resolve`);
-    }
-    if (base !== head) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} must renew onto ${target.branch} before petition`, { facts: { kind: "needs_renew", contractId } });
-    }
-}
-export async function assertPetitionArcReady(deliveryCwd, contractId, entries) {
-    if (getMaxArc(entries) <= 0 || findOpenArc(entries))
-        return;
-    const loose = await receiptsAfterFence(deliveryCwd, entries);
-    if (loose.length > 0) {
-        throw new FlowError("NO_OPEN_ARC", `${loose.length} commits after fence have no arc to receipt them`, { facts: { kind: "loose_commits", contractId, nextVerb: "petition" } });
-    }
-}
-export function assertPetitionable(contractId, entries) {
-    const state = deriveContractState(entries);
-    // bound is legal for derived a0 (sealCurrentArc appends seal 0 before petition).
+import { normalizeScopePattern } from "../scope.js";
+export function assertFoldedPetitionable(contractId, model) {
+    const state = currentLifecycleState(model);
     if (state.state !== "active" && state.state !== "bound") {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot petition from state ${state.state}`);
     }
 }
+function nextSettlementSeat(read, target) {
+    let floor = 0;
+    for (const model of read.contracts) {
+        for (const { entry } of model.history) {
+            if (entry.kind !== "petition" || !("target" in entry.data) || entry.data.target !== target)
+                continue;
+            floor = Math.max(floor, entry.data.seat);
+        }
+    }
+    const seat = floor + 1;
+    if (!Number.isSafeInteger(seat) || seat <= 0)
+        throw new FlowError("INTERNAL_STATE", `settlement seats exhausted for ${target}`);
+    return seat;
+}
 export async function petitionContract(input) {
     const at = new Date(input.nowMs).toISOString();
-    const { ledger, deliveryCwd, base, target } = await loadPetitionPreflightContext(input.cwd, input.contractId);
-    await assertCleanTrackedWorkingTree(deliveryCwd);
-    await assertPetitionFresh(input.cwd, input.contractId, ledger.entries, base);
-    await assertPetitionArcReady(deliveryCwd, input.contractId, ledger.entries);
-    assertPetitionable(input.contractId, ledger.entries);
-    await appendScopeTerms({
+    const patterns = input.intent === "claim" ? (input.appendScope ?? []).map(normalizeScopePattern) : [];
+    const generatedAmendment = "Scope extended by lifecycle command.";
+    const matchesAccepted = (history) => {
+        const petitionIndex = history.length - 1;
+        const accepted = history[petitionIndex]?.entry;
+        if (accepted?.kind !== "petition" || accepted.data.intent !== input.intent)
+            return false;
+        if (input.intent === "claim" && (accepted.data.intent !== "claim" || accepted.data.oath !== input.oath))
+            return false;
+        let prefixIndex = petitionIndex - 1;
+        const preceding = history[prefixIndex]?.entry;
+        if (preceding?.kind === "seal" && preceding.data.sealedBy === "petition")
+            prefixIndex -= 1;
+        const acceptedAmend = history[prefixIndex]?.entry;
+        const hasGeneratedAmend = acceptedAmend?.kind === "amend" && acceptedAmend.data.amendment === generatedAmendment;
+        if (patterns.length === 0)
+            return !hasGeneratedAmend;
+        return hasGeneratedAmend
+            && JSON.stringify(acceptedAmend.data.scopeDelta ?? null) === JSON.stringify({ add: patterns });
+    };
+    const execution = await runLifecycle({
         cwd: input.cwd,
-        renderCwd: deliveryCwd,
-        contractId: input.contractId,
-        patterns: input.intent === "claim" ? input.appendScope : undefined,
-        actor: input.actor,
-        nowMs: input.nowMs,
-    });
-    const sealed = await sealCurrentArc({
-        cwd: deliveryCwd,
-        renderCwd: deliveryCwd,
         contractId: input.contractId,
-        sealedBy: "petition",
-        nowMs: input.nowMs,
-    });
-    const allocated = await allocateSettlementSeat(input.cwd, {
-        target: target.ref,
-        actor: input.actor,
-        at,
-    });
-    const ref = activeLedgerRef(input.contractId);
-    const result = await appendWithRetry(input.cwd, ref, (_head, entries) => {
-        const state = deriveContractState(entries);
-        if (state.state === "petitioned")
-            return null;
-        assertPetitionable(input.contractId, entries);
-        const data = input.intent === "claim"
-            ? {
-                intent: "claim",
-                oath: input.oath,
-                target: target.ref,
-                seat: allocated.seat,
+        mutation: { verb: "petition", matchesAccepted: (transaction) => matchesAccepted(transaction.entries.map((entry, index) => ({ objectId: transaction.entryObjectIds[index], entry }))) },
+        signal: input.signal,
+        admit: async (session, replay) => {
+            if (replay.state === "verb-committed")
+                return { lifecycle: session.lifecycle };
+            if (session.target.status !== "available")
+                throw new FlowError("INTERNAL_STATE", session.target.reason);
+            const deliveryCwd = session.target.root;
+            const base = session.lifecycle.pins.base;
+            const target = session.lifecycle.pins.target.ref;
+            await assertCleanTrackedWorkingTree(deliveryCwd);
+            if (!session.pins.target.head)
+                throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} commission target ${session.pins.target.ref} does not resolve`);
+            if (base !== session.pins.target.head) {
+                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 } });
             }
-            : {
-                intent: "forfeit",
-                target: target.ref,
-                seat: allocated.seat,
+            assertFoldedPetitionable(input.contractId, session.lifecycle);
+            return { lifecycle: session.lifecycle, deliveryCwd };
+        },
+        prepare: async (admission) => {
+            if (admission.replay.state === "verb-committed") {
+                const transaction = admission.replay.transaction;
+                const accepted = transaction.entries.at(-1);
+                if (!accepted || accepted.kind !== "petition")
+                    throw new FlowError("INTERNAL_STATE", `accepted transaction ${transaction.transactionObjectId} is not a petition`);
+                let prefixIndex = transaction.entries.length - 2;
+                const acceptedSeal = transaction.entries[prefixIndex];
+                let capture = null;
+                if (acceptedSeal?.kind === "seal" && acceptedSeal.data.sealedBy === "petition") {
+                    capture = {
+                        arc: acceptedSeal.data.arc,
+                        oldFence: acceptedSeal.data.oldFence,
+                        newFence: acceptedSeal.data.newFence,
+                        receipts: [...acceptedSeal.data.receipts],
+                        diffstat: { ...acceptedSeal.data.diffstat },
+                        scopeAudit: { violations: [...acceptedSeal.data.scopeAudit.violations] },
+                        scopeViolationEvidence: [],
+                    };
+                    prefixIndex -= 1;
+                }
+                const acceptedAmend = transaction.entries[prefixIndex];
+                if (patterns.length > 0) {
+                    if (acceptedAmend?.kind !== "amend" || acceptedAmend.data.amendment !== generatedAmendment) {
+                        throw new FlowError("INTERNAL_STATE", `accepted petition transaction ${transaction.transactionObjectId} is missing its scope amendment`);
+                    }
+                }
+                return {
+                    additions: [],
+                    capture,
+                    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,
+                kind: "amend",
+                contract: input.contractId,
+                at,
+                actor: input.actor,
+                data: { amendment: generatedAmendment, scopeDelta: { add: patterns } },
             };
-        const entry = {
-            v: 1,
-            kind: "petition",
-            contract: input.contractId,
-            at,
-            actor: input.actor,
-            data,
-        };
-        return entry;
-    });
-    if (!result.ok) {
-        // Race/abort: allocated seat remains a legal hole; do not report success.
-        if (result.reason === "aborted") {
-            const current = await readLedger(input.cwd, input.contractId);
-            if (current) {
-                assertPetitionable(input.contractId, current.entries);
+            const deliveryCwd = admission.business.deliveryCwd;
+            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
+                ? null
+                : await captureFoldedSeal(deliveryCwd, lifecycle, "HEAD", patterns);
+            let sealEntry = null;
+            if (capture) {
+                const { scopeViolationEvidence: _evidence, ...durableCapture } = capture;
+                sealEntry = {
+                    v: 2,
+                    kind: "seal",
+                    contract: input.contractId,
+                    at,
+                    actor: "engine",
+                    data: { ...durableCapture, sealedBy: "petition" },
+                };
             }
-            throw new FlowError("INTERNAL_STATE", `failed to petition contract ${input.contractId}: aborted`);
-        }
-        throw new FlowError("INTERNAL_STATE", `failed to petition contract ${input.contractId}: ${result.reason}`);
-    }
-    const model = await readQueueReadModel(input.cwd);
-    const membership = queueMembership(model, input.contractId);
-    const position = membership?.position ?? 0;
-    if (position <= 0) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} missing target-local queue position after petition`);
-    }
-    return {
-        contractId: input.contractId,
-        position,
-        ...(sealed ? { sealed } : {}),
-    };
+            const additions = scopeEntry
+                ? sealEntry ? [scopeEntry, sealEntry] : [scopeEntry]
+                : sealEntry ? [sealEntry] : [];
+            const targetHead = admission.pins.target.head;
+            if (!targetHead)
+                throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} commission target does not resolve`);
+            return {
+                additions,
+                capture,
+                seat: nextSettlementSeat(admission.repository, admission.pins.target.ref),
+                targetHead,
+            };
+        },
+        revalidate: async ({ session, admission, prepared }) => {
+            if (prepared.existing) {
+                return session.repository.topology.nodes.some((node) => node.objectId === prepared.existing.transactionObjectId)
+                    ? undefined
+                    : { code: "PETITION_STATE_CHANGED", message: "accepted petition changed during replay preparation" };
+            }
+            if (session.target.status !== "available" || session.target.root !== admission.business.deliveryCwd)
+                return { code: "DELIVERY_WORKTREE_CHANGED", message: "registered delivery worktree changed during petition preparation" };
+            await assertCleanTrackedWorkingTree(session.target.root);
+            if (input.reviewPersistence && session.pins.delivery.head !== input.reviewPersistence.reviewedHead) {
+                return {
+                    code: "REVIEWED_DELIVERY_CHANGED",
+                    message: "delivery HEAD changed after independent review",
+                    pinned: { deliveryHead: input.reviewPersistence.reviewedHead },
+                    current: { deliveryHead: session.pins.delivery.head },
+                };
+            }
+            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);
+            return undefined;
+        },
+        effect: async ({ context, prepared }) => {
+            let reviewHistoryPath;
+            if (!prepared.existing)
+                await input.afterSeat?.(prepared.seat);
+            const data = input.intent === "claim"
+                ? {
+                    intent: "claim",
+                    oath: input.oath,
+                    target: context.session.pins.target.ref,
+                    targetHead: prepared.targetHead,
+                    seat: prepared.seat,
+                }
+                : {
+                    intent: "forfeit",
+                    target: context.session.pins.target.ref,
+                    seat: prepared.seat,
+                };
+            const entry = {
+                v: 2,
+                kind: "petition",
+                contract: input.contractId,
+                at,
+                actor: input.actor,
+                data,
+            };
+            const additions = prepared.additions.length === 0
+                ? [entry]
+                : prepared.additions[0].kind === "seal"
+                    ? [prepared.additions[0], entry]
+                    : prepared.additions.length === 1
+                        ? [prepared.additions[0], entry]
+                        : [prepared.additions[0], prepared.additions[1], entry];
+            const result = prepared.existing
+                ? 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,
+                    entries: additions,
+                });
+            if (result.status === "indeterminate") {
+                return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? context.session.lifecycle.observedLedgerHead };
+            }
+            if (result.status !== "committed") {
+                const authoritativeHead = result.currentHead ?? context.session.lifecycle.observedLedgerHead;
+                return { kind: "refused-before-effects", authoritativeHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during petition` } };
+            }
+            if (input.reviewPersistence) {
+                await context.journal.run({
+                    effect: "review-response-persistence",
+                    ...(context.journal.all().some((row) => row.effect === "ledger-cas" && row.status === "succeeded")
+                        ? { dependency: `${input.contractId}:${result.head}:ledger-cas` }
+                        : {}),
+                    run: async () => {
+                        const persisted = await input.reviewPersistence.persist();
+                        reviewHistoryPath = persisted.responsePath;
+                        return { artifactId: persisted.artifactId, responsePath: persisted.responsePath };
+                    },
+                });
+            }
+            let position = 0;
+            await context.journal.run({
+                effect: "settlement-queue-observation",
+                ...(context.journal.all().some((row) => row.effect === "ledger-cas" && row.status === "succeeded")
+                    ? { dependency: `${input.contractId}:${result.head}:ledger-cas` }
+                    : {}),
+                run: async () => {
+                    const model = await readQueueReadModel(context.session.stableRoot);
+                    position = queueMembership(model, input.contractId)?.position ?? 0;
+                    if (position <= 0)
+                        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} missing target-local queue position after petition`);
+                    return { position };
+                },
+            });
+            return {
+                kind: "committed",
+                commit: result,
+                entryKind: "petition",
+                value: {
+                    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,
+                },
+            };
+        },
+    });
+    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 };
 }
 export function buildPetitionClaimInput(input) {
     const parts = parseCommandMarkdown(input.stdin ?? "");