@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/settlement/petition.js

@@ -1,281 +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 } from "../repository-ledger/read-model.js";
-import { assertCleanTrackedWorkingTree } from "../../git/worktree.js";
-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 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 } });
-            }
-            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 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" },
-                };
-            }
-            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 ?? "");
-    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,
-    };
-}

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";