@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/seal.js

@@ -1,352 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { createGit, parseRevListOutput, wrapGitError } from "../git/core.js";
-import { effectiveScope } from "./lifecycle-history.js";
-import { scopePathEvidence, } from "./scope.js";
-import { isTerminalState } from "./status/lifecycle.js";
-import { currentLifecycleState, lookupCurrentContract, readRepositoryLifecycle, } from "./repository-ledger/read-model.js";
-import { runLifecycle } from "./lifecycle-runner.js";
-import { taskNamespaceFromScope } from "./task/coordinate.js";
-export { effectiveScope } from "./lifecycle-history.js";
-function findBind(entries) {
-    const bind = entries.find((entry) => entry.kind === "bind");
-    if (!bind)
-        throw new FlowError("INTERNAL_STATE", "ledger must contain bind entry");
-    return bind;
-}
-export function findOpenArc(entries) {
-    let open = null;
-    for (const entry of entries) {
-        if (entry.kind === "arc")
-            open = entry;
-        if (entry.kind === "seal" && open?.data.arc === entry.data.arc)
-            open = null;
-    }
-    return open;
-}
-export function getMaxArc(entries) {
-    return entries.reduce((max, entry) => entry.kind === "arc" ? Math.max(max, entry.data.arc) : max, 0);
-}
-export function getFence(entries) {
-    let fence = findBind(entries).data.base;
-    for (const entry of entries) {
-        if (entry.kind === "seal") {
-            fence = entry.data.newFence;
-            continue;
-        }
-        if (entry.kind === "renew")
-            fence = entry.data.newHead;
-    }
-    return fence;
-}
-export async function receiptsAfterFence(cwd, entries, head = "HEAD") {
-    return revList(cwd, getFence(entries), await resolveCommit(cwd, head));
-}
-async function resolveCommit(cwd, revision) {
-    const git = createGit(cwd);
-    try {
-        return (await git.raw(["rev-parse", "--verify", `${revision}^{commit}`])).trim();
-    }
-    catch (error) {
-        throw wrapGitError(`rev-parse ${revision}`, error, cwd);
-    }
-}
-async function revList(cwd, from, to) {
-    const git = createGit(cwd);
-    try {
-        return parseRevListOutput(await git.raw(["rev-list", "--reverse", `${from}..${to}`]));
-    }
-    catch (error) {
-        throw wrapGitError(`rev-list ${from}..${to}`, error, cwd);
-    }
-}
-async function changedPaths(cwd, from, to) {
-    const git = createGit(cwd);
-    try {
-        return (await git.raw(["diff", "--name-only", "-z", `${from}..${to}`]))
-            .split("\0")
-            .filter(Boolean);
-    }
-    catch (error) {
-        throw wrapGitError(`diff --name-only ${from}..${to}`, error, cwd);
-    }
-}
-async function diffstat(cwd, from, to) {
-    const git = createGit(cwd);
-    try {
-        const output = await git.raw(["diff", "--numstat", `${from}..${to}`]);
-        return output.split(/\r?\n/).reduce((total, line) => {
-            if (!line.trim())
-                return total;
-            const [added, removed] = line.split("\t");
-            total.files += 1;
-            total.insertions += Number.parseInt(added ?? "0", 10) || 0;
-            total.deletions += Number.parseInt(removed ?? "0", 10) || 0;
-            return total;
-        }, { files: 0, insertions: 0, deletions: 0 });
-    }
-    catch (error) {
-        throw wrapGitError(`diff --numstat ${from}..${to}`, error, cwd);
-    }
-}
-async function scopeViolations(cwd, paths, scope) {
-    return (await scopePathEvidence(cwd, scope, paths)).filter((evidence) => !evidence.matched);
-}
-function taskNamespaceViolations(paths, scope) {
-    const taskPaths = paths.filter((path) => path.startsWith(".keiyaku/tasks/"));
-    if (taskPaths.length === 0)
-        return [];
-    const namespaces = scope.flatMap((term) => taskNamespaceFromScope(term) ?? []);
-    if (namespaces.length !== 1) {
-        throw new FlowError("INTERNAL_STATE", "accepted bind must carry exactly one contract task namespace");
-    }
-    const prefix = `.keiyaku/tasks/${namespaces[0]}/`;
-    return taskPaths
-        .filter((path) => !path.startsWith(prefix))
-        .map((path) => ({ path, patterns: [], matched: false, outcome: "no-positive-match" }));
-}
-async function acceptedBindScope(cwd, contract) {
-    const outcome = lookupCurrentContract(await readRepositoryLifecycle(cwd), contract);
-    if (outcome.status !== "healthy") {
-        throw new FlowError("INTERNAL_STATE", `cannot resolve accepted bind namespace for contract ${contract}`);
-    }
-    const bind = outcome.model.history.find(({ entry }) => entry.kind === "bind")?.entry;
-    if (!bind || bind.kind !== "bind")
-        throw new FlowError("INTERNAL_STATE", `contract ${contract} has no accepted bind entry`);
-    return bind.data.scope;
-}
-async function auditScope(cwd, entries, paths) {
-    const scope = effectiveScope(entries);
-    const scopeViolationEvidence = [
-        ...await scopeViolations(cwd, paths, scope),
-        ...taskNamespaceViolations(paths, findBind(entries).data.scope),
-    ].filter((row, index, all) => all.findIndex((candidate) => candidate.path === row.path) === index);
-    if (scopeViolationEvidence.length > 0) {
-        throw new ScopeAuditError(findBind(entries).contract, scope, scopeViolationEvidence);
-    }
-    const violations = scopeViolationEvidence.map((violation) => violation.path);
-    return {
-        scopeAudit: { violations },
-        scopeViolationEvidence,
-    };
-}
-export class ScopeAuditError extends FlowError {
-    scopeViolationEvidence;
-    constructor(_contractId, scope, evidence) {
-        const count = evidence.length;
-        const fileLabel = count === 1 ? "file" : "files";
-        super("SCOPE_VIOLATION", `scope violation — ${count} ${fileLabel} outside declared scope`, {
-            facts: {
-                kind: "scope_violation",
-                scope: [...scope],
-                violations: evidence,
-            },
-        });
-        this.name = "ScopeAuditError";
-        this.scopeViolationEvidence = evidence;
-    }
-}
-function assertOperable(contractId, model) {
-    const state = currentLifecycleState(model);
-    if (isTerminalState(state) || state.state === "petitioned") {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot seal from state ${state.state}`);
-    }
-}
-function currentFoldedSealArc(model) {
-    return model.seal === null ? model.intent.arc : null;
-}
-/** Current-read admission capture: scope and fence come only from the folded model. */
-export async function captureFoldedSeal(cwd, model, head = "HEAD", scopeAppend = []) {
-    const arc = currentFoldedSealArc(model);
-    if (arc === null)
-        return null;
-    const oldFence = model.pins.delivery;
-    const newFence = await resolveCommit(cwd, head);
-    const [receipts, paths, stat] = await Promise.all([
-        revList(cwd, oldFence, newFence),
-        changedPaths(cwd, oldFence, newFence),
-        diffstat(cwd, oldFence, newFence),
-    ]);
-    const effectiveScope = [...model.effectiveScope, ...scopeAppend];
-    const bind = model.history.find((row) => row.entry.kind === "bind")?.entry;
-    const scopeViolationEvidence = [
-        ...await scopeViolations(cwd, paths, effectiveScope),
-        ...taskNamespaceViolations(paths, bind?.kind === "bind" ? bind.data.scope : []),
-    ].filter((row, index, all) => all.findIndex((candidate) => candidate.path === row.path) === index);
-    if (scopeViolationEvidence.length > 0) {
-        throw new ScopeAuditError(model.contract, effectiveScope, scopeViolationEvidence);
-    }
-    return { arc, oldFence, newFence, receipts, diffstat: stat, scopeAudit: { violations: [] }, scopeViolationEvidence };
-}
-/** Current seal intent: open explicit arc, else derived a0 while no explicit arc has ever existed. */
-export function currentSealArc(entries) {
-    const open = findOpenArc(entries);
-    if (open)
-        return open.data.arc;
-    if (getMaxArc(entries) === 0)
-        return 0;
-    return null;
-}
-/** Stable read-only coordinate naming the receipt source a petition would seal. */
-export function petitionSealSource(entries) {
-    return {
-        arc: currentSealArc(entries),
-        fence: getFence(entries),
-    };
-}
-/** Shared read-only owner for the seal capture and its compact changed-path evidence. */
-export async function previewSeal(cwd, entries, head = "HEAD") {
-    const arc = currentSealArc(entries);
-    if (arc === null)
-        return { capture: null, paths: [] };
-    const oldFence = getFence(entries);
-    const newFence = await resolveCommit(cwd, head);
-    const [receipts, paths, stat] = await Promise.all([
-        revList(cwd, oldFence, newFence),
-        changedPaths(cwd, oldFence, newFence),
-        diffstat(cwd, oldFence, newFence),
-    ]);
-    const scopeAudit = await auditScope(cwd, entries, paths);
-    return {
-        capture: {
-            arc,
-            oldFence,
-            newFence,
-            receipts,
-            diffstat: stat,
-            ...scopeAudit,
-        },
-        paths,
-    };
-}
-export async function captureSeal(cwd, entries, head = "HEAD") {
-    return (await previewSeal(cwd, entries, head)).capture;
-}
-/** Folded renew capture: preserve receipt hashes while auditing rebased delivery content. */
-export async function captureFoldedRenewSeal(input) {
-    if (!input.receiptSegmentOpen)
-        return null;
-    const arc = input.intent.arc;
-    const oldFence = input.deliveryFence;
-    const [receiptHead, contentBase, contentHead] = await Promise.all([
-        resolveCommit(input.cwd, input.receiptHead),
-        resolveCommit(input.cwd, input.contentBase),
-        resolveCommit(input.cwd, input.contentHead),
-    ]);
-    const [receipts, paths, stat] = await Promise.all([
-        revList(input.cwd, oldFence, receiptHead),
-        changedPaths(input.cwd, contentBase, contentHead),
-        diffstat(input.cwd, contentBase, contentHead),
-    ]);
-    const scope = [...input.effectiveScope, ...input.pendingScopeOverlay];
-    const bindScope = await acceptedBindScope(input.cwd, input.contract);
-    const scopeViolationEvidence = [
-        ...await scopeViolations(input.cwd, paths, scope),
-        ...taskNamespaceViolations(paths, bindScope),
-    ].filter((row, index, all) => all.findIndex((candidate) => candidate.path === row.path) === index);
-    if (scopeViolationEvidence.length > 0) {
-        throw new ScopeAuditError(input.contract, scope, scopeViolationEvidence);
-    }
-    return {
-        arc,
-        oldFence,
-        newFence: receiptHead,
-        receipts,
-        diffstat: stat,
-        scopeAudit: { violations: [] },
-        scopeViolationEvidence,
-    };
-}
-export async function sealCurrentArc(input) {
-    const execution = await runLifecycle({
-        cwd: input.cwd,
-        contractId: input.contractId,
-        mutation: {
-            verb: "seal",
-            matchesAccepted: (transaction) => {
-                const accepted = transaction.entries.at(-1);
-                if (transaction.entries.length !== 1 || accepted?.kind !== "seal" || accepted.data.sealedBy !== input.sealedBy)
-                    return false;
-                if (input.capture === undefined)
-                    return true;
-                if (input.capture === null)
-                    return false;
-                const { scopeViolationEvidence: _evidence, ...durableCapture } = input.capture;
-                return JSON.stringify(accepted.data) === JSON.stringify({ ...durableCapture, sealedBy: input.sealedBy });
-            },
-        },
-        signal: input.signal,
-        admit: (session, replay) => {
-            assertOperable(input.contractId, session.lifecycle);
-            if (session.target.status !== "available")
-                throw new FlowError("INTERNAL_STATE", session.target.reason);
-            const transaction = replay.state === "verb-committed" ? replay.transaction : undefined;
-            const accepted = transaction?.entries.at(-1);
-            let existing;
-            if (accepted?.kind === "seal") {
-                existing = {
-                    transactionObjectId: transaction.transactionObjectId,
-                    capture: {
-                        arc: accepted.data.arc,
-                        oldFence: accepted.data.oldFence,
-                        newFence: accepted.data.newFence,
-                        receipts: [...accepted.data.receipts],
-                        diffstat: { ...accepted.data.diffstat },
-                        scopeAudit: { violations: [...accepted.data.scopeAudit.violations] },
-                        scopeViolationEvidence: [],
-                    },
-                };
-            }
-            return { lifecycle: session.lifecycle, targetRoot: session.target.root, ...(existing ? { existing } : {}) };
-        },
-        prepare: async (admission) => {
-            if (admission.business.existing)
-                return { capture: admission.business.existing.capture, existing: { transactionObjectId: admission.business.existing.transactionObjectId } };
-            return { capture: input.capture ?? await captureFoldedSeal(admission.business.targetRoot, admission.business.lifecycle, "HEAD") };
-        },
-        revalidate: ({ session, prepared }) => {
-            assertOperable(input.contractId, session.lifecycle);
-            if (prepared.existing) {
-                return session.repository.topology.nodes.some((node) => node.objectId === prepared.existing.transactionObjectId)
-                    ? undefined
-                    : { code: "SEAL_STATE_CHANGED", message: "accepted seal changed during replay preparation" };
-            }
-            if (!prepared.capture)
-                return;
-            const currentArc = currentFoldedSealArc(session.lifecycle);
-            if (currentArc !== prepared.capture.arc || session.lifecycle.pins.delivery !== prepared.capture.oldFence)
-                return { code: "SEAL_COORDINATES_CHANGED", message: `contract ${input.contractId} changed while sealing arc a${prepared.capture.arc}` };
-        },
-        effect: async ({ context, prepared }) => {
-            const capture = prepared.capture;
-            if (!capture)
-                return { kind: "refused-before-effects", authoritativeHead: context.session.lifecycle.observedLedgerHead, refusal: { code: "NO_OPEN_ARC", message: "no current arc requires sealing" } };
-            const at = new Date(input.nowMs).toISOString();
-            {
-                const { scopeViolationEvidence: _scopeViolationEvidence, ...durableCapture } = capture;
-                const entry = {
-                    v: 2,
-                    kind: "seal",
-                    contract: input.contractId,
-                    at,
-                    actor: "engine",
-                    data: { ...durableCapture, sealedBy: input.sealedBy },
-                };
-                const result = prepared.existing
-                    ? await context.replayCommitted({ transactionObjectId: prepared.existing.transactionObjectId })
-                    : await context.publishAuthoritative({ verb: "seal", admittedLedgerHead: context.session.lifecycle.observedLedgerHead, acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId, entries: [entry] });
-                if (result.status === "indeterminate")
-                    return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? context.session.lifecycle.observedLedgerHead };
-                if (result.status !== "committed")
-                    return { kind: "refused-before-effects", authoritativeHead: result.currentHead ?? context.session.lifecycle.observedLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed while sealing` } };
-                return { kind: "committed", commit: result, entryKind: "seal", value: {
-                        ...capture,
-                        sealedBy: input.sealedBy,
-                        ledgerHead: result.transaction.entryObjectIds[result.transaction.entries.findIndex((candidate) => candidate.kind === "seal")],
-                    } };
-            }
-        },
-    });
-    if (execution.kind === "noncommitted" || execution.kind === "contained")
-        return execution.outcome;
-    return execution.payload;
-}

package/build/core/settlement/claim-delivery.js

@@ -1,69 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, runGitProcess } from "../../git/core.js";
-import { shortCommitHash } from "../../git/commits.js";
-import { assertHonestClaimEvidence, buildHonestClaimMerge, } from "../repository-ledger/claim-evidence.js";
-async function successfulGit(cwd, args, input) {
-    const result = await runGitProcess(cwd, args, input === undefined ? undefined : { input });
-    if (result.status !== 0 || result.error) {
-        const detail = result.stderr.trim() || result.error?.message || `exit ${String(result.status)}`;
-        throw new FlowError(args[0] === "merge-tree" ? "CLOSE_MERGE_CONFLICT" : "INTERNAL_STATE", `git ${args.join(" ")} failed: ${detail}`, { cause: result.error });
-    }
-    return result.stdout.trim();
-}
-/** Build unreachable claim objects using only the approved frozen coordinates. */
-export async function buildClaimLanding(input) {
-    try {
-        const built = await buildHonestClaimMerge(input);
-        return { ...input.coordinates, ...built };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new FlowError(message.includes("not conflict-free") ? "CLOSE_MERGE_CONFLICT" : "INTERNAL_STATE", message, { cause: error });
-    }
-}
-export async function resolveCommit(cwd, rev) {
-    return await successfulGit(cwd, ["rev-parse", "--verify", `${rev}^{commit}`]);
-}
-export async function resolveCommitOrNull(cwd, rev) {
-    const result = await runGitProcess(cwd, ["rev-parse", "--verify", `${rev}^{commit}`]);
-    if (result.status === 0 && !result.error)
-        return result.stdout.trim();
-    if (errorContainsAnyPattern(result.stderr, MISSING_HEAD_PATTERNS))
-        return null;
-    const detail = result.stderr.trim() || result.error?.message || `exit ${String(result.status)}`;
-    throw new FlowError("INTERNAL_STATE", `git rev-parse ${rev} failed: ${detail}`, { cause: result.error });
-}
-/** Prove parent order and tree identity independently of mutable refs. */
-export async function proveClaimLanding(cwd, landing) {
-    await assertHonestClaimEvidence(cwd, landing);
-}
-/** Display path for preview cleanup effects; delivery owns path mechanics. */
-export function relativeDisplayPath(from, to) {
-    return (to.startsWith(from) ? to.slice(from.length).replace(/^\//, "") : to) || ".";
-}
-async function findWorktreePathForRef(cwd, target) {
-    const output = await successfulGit(cwd, ["worktree", "list", "--porcelain", "-z"]);
-    let worktree;
-    for (const field of output.split("\0")) {
-        if (field.startsWith("worktree "))
-            worktree = field.slice("worktree ".length);
-        if (field === `branch ${target}`)
-            return worktree;
-    }
-    return undefined;
-}
-/** Align a checked-out target after the atomic claim. Failure leaves authority intact. */
-export async function replayClaimTargetWorktree(cwd, landing) {
-    const worktree = await findWorktreePathForRef(cwd, landing.target);
-    if (!worktree)
-        return [];
-    try {
-        await createGit(worktree).raw(["read-tree", "-m", "-u", landing.targetHead, landing.mergeCommit]);
-        return [];
-    }
-    catch {
-        return [
-            `Target worktree ${worktree} remains behind after claim advanced '${landing.target.slice("refs/heads/".length)}' to ${shortCommitHash(landing.mergeCommit)}.`,
-        ];
-    }
-}

package/build/core/settlement/claim.js

@@ -1,256 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { assertCleanTrackedWorkingTree } from "../../git/worktree.js";
-import { runLifecycle } from "../lifecycle-runner.js";
-import { isJsonObject } from "../outcome-base.js";
-import { terminalCleanupFacts } from "../worktree-path.js";
-import { assertClaimQueueHead, readQueueReadModel } from "./queue.js";
-import { buildClaimLanding, relativeDisplayPath, } from "./claim-delivery.js";
-export function claimDeliveryCoordinateMismatch(published, delivery) {
-    const assertion = published.observations.find((observation) => (observation.ref === delivery.ref
-        && observation.expectedOldOid === delivery.head));
-    if (!assertion || assertion.observed.status === "unknown")
-        return undefined;
-    if (assertion.observed.status === "present" && assertion.observed.objectId === delivery.head)
-        return undefined;
-    return {
-        code: "CONCURRENT_MODIFICATION",
-        message: "claim delivery coordinate changed before atomic publication",
-        facts: {
-            delivery: {
-                expected: { ref: delivery.ref, head: delivery.head },
-                observed: assertion.observed,
-            },
-        },
-    };
-}
-function acceptedClaim(model) {
-    const row = [...model.history].reverse().find(({ entry }) => entry.kind === "claim");
-    return row?.entry.kind === "claim" ? { objectId: row.objectId, entry: row.entry } : undefined;
-}
-function assertClaimable(contractId, model) {
-    const claim = acceptedClaim(model);
-    if (model.phase === "claimed" && claim)
-        return claim;
-    if (model.phase === "approved" && model.petition.state === "approved" && model.petition.intent === "claim")
-        return undefined;
-    if (model.phase === "forfeited") {
-        throw new FlowError("CONTRACT_TERMINAL", `contract ${contractId} is terminal (${model.phase})`);
-    }
-    if (model.phase === "awaiting-verdict") {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot claim without approved verdict for current petition`);
-    }
-    throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot claim from state ${model.phase}`);
-}
-function freezeClaimCoordinates(contractId, model, pins) {
-    if (model.petition.state !== "approved" || model.petition.intent !== "claim" || !model.petition.targetHead) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} has no approved claim coordinates`);
-    }
-    if (pins.target.ref !== model.petition.target ||
-        pins.target.head !== model.petition.targetHead ||
-        pins.delivery.head !== model.pins.delivery) {
-        throw new FlowError("CONCURRENT_MODIFICATION", `claim coordinates for ${contractId} no longer match approved petition`);
-    }
-    return {
-        base: model.pins.base,
-        target: model.petition.target,
-        targetHead: model.petition.targetHead,
-        deliveryHead: model.pins.delivery,
-    };
-}
-export async function previewClaimContract(input) {
-    const { withContractCarrierSession } = await import("../contract-carrier.js");
-    return withContractCarrierSession({ cwd: input.cwd, contractId: input.contractId, mode: "observe-only", signal: input.signal }, async (session) => {
-        const queue = await readQueueReadModel(session.stableRoot);
-        const membership = assertClaimQueueHead(queue, input.contractId);
-        assertClaimable(input.contractId, session.lifecycle);
-        const targetHead = session.pins.target.head;
-        const base = session.lifecycle.pins.base;
-        const deliveryBranch = `keiyaku/${input.contractId}`;
-        const cleanupPath = session.target.status === "available" ? session.target.root : undefined;
-        return {
-            contractId: input.contractId,
-            queueHead: membership.queueHead,
-            queuePosition: membership.position,
-            state: session.lifecycle.phase,
-            freshness: targetHead ? (base === targetHead ? "fresh" : "stale") : "unknown",
-            base,
-            targetBranch: session.lifecycle.pins.target.ref.slice("refs/heads/".length),
-            ...(targetHead ? { targetHead } : {}),
-            deliveryBranch,
-            ...(session.pins.delivery.head ? { deliveryHead: session.pins.delivery.head } : {}),
-            cleanupEffects: [
-                `release registry scope for ${input.contractId}`,
-                cleanupPath ? `remove worktree ${relativeDisplayPath(input.cwd, cleanupPath)} when present` : "no linked worktree to remove",
-                `delete branch ${deliveryBranch} when present`,
-            ],
-        };
-    });
-}
-export async function claimContract(input) {
-    const at = new Date(input.nowMs).toISOString();
-    const execution = await runLifecycle({
-        cwd: input.cwd,
-        contractId: input.contractId,
-        mutation: {
-            verb: "claim",
-            coordinateChangeRefusal: {
-                code: "CONCURRENT_MODIFICATION",
-                message: "claim target or repository ledger changed during atomic publication preparation",
-            },
-        },
-        signal: input.signal,
-        admit: async (session) => {
-            const existing = assertClaimable(input.contractId, session.lifecycle);
-            if (existing) {
-                return {
-                    existing,
-                    coordinates: null,
-                    closedDelivery: null,
-                    queuePin: null,
-                    taskIds: session.lifecycle.resources.tasks.map(({ taskId }) => taskId),
-                };
-            }
-            if (session.target.status !== "available")
-                throw new FlowError("INTERNAL_STATE", session.target.reason);
-            await assertCleanTrackedWorkingTree(session.target.root);
-            const queue = await readQueueReadModel(session.stableRoot);
-            assertClaimQueueHead(queue, input.contractId);
-            const coordinates = freezeClaimCoordinates(input.contractId, session.lifecycle, session.pins);
-            return {
-                coordinates,
-                closedDelivery: { ref: session.pins.delivery.ref, head: coordinates.deliveryHead },
-                targetRoot: session.target.root,
-                queuePin: JSON.stringify(queue),
-                taskIds: session.lifecycle.resources.tasks.map(({ taskId }) => taskId),
-            };
-        },
-        prepare: async (admission) => {
-            if (admission.business.coordinates === null)
-                return null;
-            const landing = await buildClaimLanding({
-                cwd: input.cwd,
-                contractId: input.contractId,
-                actor: input.actor,
-                at,
-                coordinates: admission.business.coordinates,
-            });
-            await input.beforePublication?.({
-                cwd: input.cwd,
-                contractId: input.contractId,
-                repositoryLedgerHead: admission.ledgerHead,
-                coordinates: Object.freeze({ ...admission.business.coordinates }),
-                landing: Object.freeze({ mergeCommit: landing.mergeCommit, mergeTree: landing.mergeTree }),
-            });
-            return landing;
-        },
-        revalidate: async ({ session, admission }) => {
-            if (admission.business.existing) {
-                const current = acceptedClaim(session.lifecycle);
-                return current?.objectId === admission.business.existing.objectId
-                    ? undefined
-                    : { code: "CLAIM_STATE_CHANGED", message: "accepted claim changed during replay admission" };
-            }
-            if (session.target.status !== "available" || session.target.root !== admission.business.targetRoot) {
-                return { code: "DELIVERY_WORKTREE_CHANGED", message: "registered delivery worktree changed during claim preparation" };
-            }
-            await assertCleanTrackedWorkingTree(session.target.root);
-            const currentCoordinates = freezeClaimCoordinates(input.contractId, session.lifecycle, session.pins);
-            if (JSON.stringify(currentCoordinates) !== JSON.stringify(admission.business.coordinates)) {
-                return { code: "CLAIM_COORDINATES_CHANGED", message: "claim coordinates changed during preparation" };
-            }
-            const queue = await readQueueReadModel(session.stableRoot);
-            try {
-                assertClaimQueueHead(queue, input.contractId);
-            }
-            catch (error) {
-                return { code: "QUEUE_HEAD_CHANGED", message: error instanceof Error ? error.message : String(error) };
-            }
-            return JSON.stringify(queue) === admission.business.queuePin
-                ? undefined
-                : { code: "QUEUE_CHANGED", message: "settlement queue changed during claim preparation" };
-        },
-        effect: async ({ context, admission, prepared }) => {
-            const existing = admission.business.existing;
-            const mergeCommit = existing?.entry.data.mergeCommit ?? prepared?.mergeCommit;
-            if (!mergeCommit)
-                throw new FlowError("INTERNAL_STATE", `claim ${input.contractId} has no merge commit`);
-            const published = existing
-                ? await context.replayCommitted({ transactionObjectId: admission.replay.state === "verb-committed" ? admission.replay.transaction.transactionObjectId : (() => { throw new FlowError("INTERNAL_STATE", "claim replay has no accepted transaction"); })(), carrier: "retire" })
-                : await context.publishAuthoritative({
-                    verb: "claim",
-                    admittedLedgerHead: admission.ledgerHead,
-                    acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId,
-                    entries: [{
-                            v: 2,
-                            kind: "claim",
-                            contract: input.contractId,
-                            at,
-                            actor: input.actor,
-                            data: {
-                                ...admission.business.coordinates,
-                                mergeCommit,
-                            },
-                        }],
-                    target: {
-                        ref: admission.business.coordinates.target,
-                        expectedOid: admission.business.coordinates.targetHead,
-                    },
-                    delivery: {
-                        ref: admission.business.closedDelivery.ref,
-                        expectedOid: admission.business.closedDelivery.head,
-                    },
-                });
-            if (published.status !== "committed") {
-                const deliveryMismatch = published.status === "refused-before-effects"
-                    ? claimDeliveryCoordinateMismatch(published, admission.business.closedDelivery)
-                    : undefined;
-                return {
-                    kind: "refused-before-effects",
-                    authoritativeHead: published.currentHead ?? admission.ledgerHead,
-                    refusal: deliveryMismatch ?? { code: "CONCURRENT_MODIFICATION", message: "claim target or repository ledger changed before atomic publication" },
-                };
-            }
-            await context.journal.run({
-                effect: "after-landing-hook",
-                ...(context.journal.all().some((row) => row.effect === "ledger-cas" && row.status === "succeeded")
-                    ? { dependency: `${input.contractId}:${published.head}:ledger-cas` }
-                    : {}),
-                run: async () => {
-                    await input.afterPublication?.({ mergeCommit });
-                    return { mergeCommit };
-                },
-            });
-            await context.session.completeReplay("retire");
-            const taskRow = context.journal.all().find((row) => row.effect === "task-board-projection" && row.status === "succeeded");
-            const taskFacts = taskRow?.status === "succeeded" ? taskRow.receipt?.facts : undefined;
-            const warnings = isJsonObject(taskFacts) && Array.isArray(taskFacts.warnings)
-                ? taskFacts.warnings.filter((warning) => typeof warning === "string")
-                : [];
-            const cleanupRow = context.journal.all().find((row) => row.effect === "worktree-projection" && row.status === "succeeded");
-            const cleanupFacts = cleanupRow?.status === "succeeded" ? cleanupRow.receipt?.facts : undefined;
-            const deliveryRefRow = context.journal.all().find((row) => row.effect === "delivery-ref-projection" && row.status === "succeeded");
-            const deliveryRefFacts = deliveryRefRow?.status === "succeeded" ? deliveryRefRow.receipt?.facts : undefined;
-            const cleanup = terminalCleanupFacts(cleanupFacts, deliveryRefFacts);
-            if (!cleanup)
-                throw new FlowError("INTERNAL_STATE", "terminal replay completed without typed cleanup facts");
-            return {
-                kind: "committed",
-                commit: published,
-                entryKind: "claim",
-                value: { mergeCommit, ...(warnings.length > 0 ? { warnings } : {}), ...(cleanup ? { cleanup } : {}) },
-            };
-        },
-    });
-    if (execution.kind === "noncommitted")
-        return execution.outcome;
-    if (execution.kind === "contained")
-        return { ...execution.outcome, contractId: input.contractId };
-    return {
-        ...execution.outcome,
-        contractId: input.contractId,
-        mergeCommit: execution.payload.mergeCommit,
-        ...(execution.payload.warnings ? { warnings: execution.payload.warnings } : {}),
-        ...(execution.payload.cleanup ? { cleanup: execution.payload.cleanup } : {}),
-        carrier: execution.carrier,
-    };
-}