@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -1,125 +0,0 @@
-import { createOathGate } from "./petition-claim-gates.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",
-    "arc",
-    "state",
-    "seal",
-    "oath",
-    "verification",
-    "review",
-];
-function failureDetail(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-async function gate(name, evaluate) {
-    try {
-        await evaluate();
-        return { name, result: "pass" };
-    }
-    catch (error) {
-        return { name, result: "failed", detail: failureDetail(error) };
-    }
-}
-function sealFileDetail(files) {
-    return `${files} ${files === 1 ? "file" : "files"}`;
-}
-const notEvaluated = (name) => ({
-    name,
-    result: "not_evaluated",
-});
-/**
- * Build a petition preflight without crossing any settlement or provider boundary.
- * Loading the addressed contract is construction: failure there leaves no truthful
- * target/source coordinate and therefore propagates as dry-run exit 2.
- */
-export async function previewPetition(input) {
-    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 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) {
-                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", 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 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) };
-            }
-        }
-        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: {
-                    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);
-        });
-        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 } },
-            scopeWarning,
-            gates,
-            verdict: gates.some((item) => item.result === "failed") ? "would_fail" : "would_succeed",
-        };
-    });
-}

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

@@ -1,50 +0,0 @@
-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,315 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-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, lookupCurrentContract } from "../repository-ledger/read-model.js";
-import { assertCleanTrackedWorkingTree } from "../../git/worktree.js";
-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;
-    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 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,
-        contractId: input.contractId,
-        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 } });
-            }
-            await assertFoldedPetitionable(input.contractId, session.lifecycle, session.repository, session.stableRoot);
-            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: await scopePathEvidence(input.cwd, admission.business.lifecycle.effectiveScope, acceptedSeal.data.scopeAudit.violations),
-                    };
-                    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,
-                    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: 2,
-                kind: "amend",
-                contract: input.contractId,
-                at,
-                actor: input.actor,
-                data: { amendment: generatedAmendment, scopeDelta: { add: patterns } },
-            };
-            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 precedingRenewSeal = patterns.length === 0
-                ? await precedingRenewSealResult(input.cwd, lifecycle)
-                : null;
-            const capture = precedingRenewSeal
-                ? null
-                : await captureFoldedSeal(deliveryCwd, lifecycle, "HEAD", patterns, "warn");
-            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" },
-                };
-            }
-            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,
-                precedingRenewSeal,
-                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" };
-            await assertFoldedPetitionable(input.contractId, session.lifecycle, session.repository, session.stableRoot);
-            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.pins.repositoryLedgerHead,
-                    acceptedLifecycleTail: context.session.lifecycle.contractHead,
-                    entries: additions,
-                });
-            if (result.status === "indeterminate") {
-                return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? context.session.pins.repositoryLedgerHead };
-            }
-            if (result.status !== "committed") {
-                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) {
-                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")] }
-                        : prepared.precedingRenewSeal ?? 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 ?? "");
-    const oath = parts.sections.get("oath")?.trim() ?? "";
-    return {
-        cwd: input.cwd,
-        contractId: input.contractId,
-        intent: "CLAIM",
-        title: `Petition ${input.contractId}`,
-        plea: `Settle contract ${input.contractId} through the petition pipeline.`,
-        oath,
-        signal: input.signal,
-        appendScope: input.appendScope,
-    };
-}

package/build/core/settlement/queue-read-model.js

@@ -1,120 +0,0 @@
-import { lookupCurrentContract, readRepositoryLifecycle, } from "../repository-ledger/read-model.js";
-export function deriveQueueReadModel(read) {
-    const seatsByContract = new Map();
-    const diagnosticsByContract = new Map();
-    const candidatesByTarget = new Map();
-    const occupancyByTarget = new Map();
-    for (const contract of read.isolatedContracts) {
-        diagnosticsByContract.set(contract, [{
-                kind: "lifecycle-disease",
-                status: "isolated",
-                diagnostics: read.diagnostics.filter((diagnostic) => diagnostic.contract === contract),
-            }]);
-    }
-    for (const model of read.contracts) {
-        // Every accepted petition occupies its seat, even if a later transition
-        // diseased the contract and removed it from settlement ordering.
-        for (const { objectId, entry } of model.history) {
-            if (entry.kind !== "petition")
-                continue;
-            const occupancy = {
-                contract: model.contract,
-                target: entry.data.target,
-                seat: entry.data.seat,
-                objectId,
-            };
-            const occupancies = occupancyByTarget.get(occupancy.target) ?? [];
-            occupancies.push(occupancy);
-            occupancyByTarget.set(occupancy.target, occupancies);
-        }
-        // A diseased contract remains visible to status and occupies its persisted
-        // seat, but cannot participate in settlement ordering.
-        const outcome = lookupCurrentContract(read, model.contract);
-        if (outcome.status === "diseased") {
-            diagnosticsByContract.set(model.contract, [{
-                    kind: "lifecycle-disease",
-                    status: "diseased",
-                    diagnostics: outcome.diagnostics,
-                }]);
-            continue;
-        }
-        if (outcome.status !== "healthy")
-            continue;
-        if (model.phase !== "awaiting-verdict" && model.phase !== "approved")
-            continue;
-        if (model.petition.state === "none")
-            continue;
-        const seat = {
-            contract: model.contract,
-            target: model.petition.target,
-            seat: model.petition.seat,
-        };
-        const candidates = candidatesByTarget.get(seat.target) ?? [];
-        candidates.push({ seat, petitionObjectId: model.petition.objectId });
-        candidatesByTarget.set(seat.target, candidates);
-        seatsByContract.set(model.contract, seat);
-        diagnosticsByContract.set(model.contract, []);
-    }
-    const orderedByTarget = new Map();
-    for (const [target, candidates] of candidatesByTarget) {
-        for (const candidate of candidates) {
-            const collisions = (occupancyByTarget.get(target) ?? [])
-                .filter((occupancy) => occupancy.seat === candidate.seat.seat && occupancy.objectId !== candidate.petitionObjectId)
-                .sort((left, right) => left.contract.localeCompare(right.contract) || left.objectId.localeCompare(right.objectId));
-            if (collisions.length === 0)
-                continue;
-            const diagnostics = diagnosticsByContract.get(candidate.seat.contract);
-            for (const collision of collisions) {
-                diagnostics.push({ kind: "duplicate-seat", seat: candidate.seat.seat, with: collision.contract });
-            }
-        }
-        // A duplicated persisted seat is a resource collision, not a deterministic
-        // tie-break. Keep the affected petitions visible with diagnostics, but do
-        // not let either one participate in settlement ordering.
-        const ordered = candidates.map((candidate) => candidate.seat).filter((candidate) => !diagnosticsByContract.get(candidate.contract)?.some((diagnostic) => diagnostic.kind === "duplicate-seat"));
-        ordered.sort((a, b) => {
-            if (a.seat !== b.seat)
-                return a.seat - b.seat;
-            return a.contract.localeCompare(b.contract);
-        });
-        orderedByTarget.set(target, ordered);
-    }
-    const targetQueues = [...orderedByTarget.entries()]
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([target, ordered]) => ({ target, ordered }));
-    return {
-        observedLedgerHead: read.observedLedgerHead,
-        targetQueues,
-        seatsByContract,
-        diagnosticsByContract,
-        unattributedDiagnostics: read.diagnostics.filter((diagnostic) => diagnostic.contract === undefined),
-    };
-}
-export async function readQueueReadModel(cwd) {
-    return deriveQueueReadModel(await readRepositoryLifecycle(cwd));
-}
-export function queueMembership(model, contractId) {
-    const seat = model.seatsByContract.get(contractId);
-    if (!seat)
-        return undefined;
-    const diagnostics = model.diagnosticsByContract.get(contractId) ?? [];
-    const targetQueue = model.targetQueues.find((queue) => queue.target === seat.target);
-    if (!targetQueue) {
-        return {
-            seat,
-            position: null,
-            queueLength: 0,
-            queueHead: null,
-            diagnostics,
-        };
-    }
-    const index = targetQueue.ordered.findIndex((entry) => entry.contract === contractId);
-    const position = index < 0 ? null : index + 1;
-    return {
-        seat,
-        position,
-        queueLength: targetQueue.ordered.length,
-        queueHead: targetQueue.ordered[0]?.contract ?? null,
-        diagnostics,
-    };
-}