@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/settlement/claim.js

@@ -1,258 +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.contractHead,
-                    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 warnings = ["task-board-projection", "target-worktree-projection"].flatMap((effect) => {
-                const row = context.journal.all().find((candidate) => candidate.effect === effect && candidate.status === "succeeded");
-                const facts = row?.status === "succeeded" ? row.receipt?.facts : undefined;
-                return isJsonObject(facts) && Array.isArray(facts.warnings)
-                    ? facts.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,
-    };
-}

package/build/core/settlement/index.js

@@ -1,19 +0,0 @@
-/**
- * Public surface for the settlement package.
- * Only symbols required by current external consumers are re-exported.
- * Package-internal modules must import each other directly, not through this file.
- *
- * Orchestrator owns: gates → petition → pure verdict → claim delivery / reject publish.
- * Foundations (queue, claim-delivery) may be depended on downward by stage modules.
- * Stage modules (petition, verdict, claim) do not import one another.
- */
-export { claimKeiyaku, petitionKeiyaku, reconcilePetitionRetry, } from "./settlement.js";
-export { buildPetitionClaimInput, petitionContract, } from "./petition.js";
-export { previewPetition, PETITION_PREVIEW_GATE_NAMES, } from "./petition-preview.js";
-export { verdictContract, } from "./verdict.js";
-export { claimContract, previewClaimContract, } from "./claim.js";
-export { relativeDisplayPath, resolveCommit, resolveCommitOrNull, } from "./claim-delivery.js";
-export { assertClaimQueueHead, deriveQueueReadModel, queueMembership, readQueueReadModel, } from "./queue.js";
-export { buildClaimGatePipeline, createAgentReviewGate, createOathGate, } from "./petition-claim-gates.js";
-export { assertHeadUnchanged } from "./petition-head-guard.js";
-export { forfeitKeiyaku } from "./petition-forfeit.js";

package/build/core/settlement/petition-claim-gates.js

@@ -1,247 +0,0 @@
-import { getConfig } from "../../config/env.js";
-import { assertSettingsKnobUsable } from "../../config/settings/disease.js";
-import { resolveReviewerAgentName } from "../../config/settings/knobs.js";
-import { loadKeiyakuSettings } from "../../config/settings/loader.js";
-import { loadAkumaCatalog } from "../../config/akuma-loader.js";
-import { formatAvailableAgentNames } from "../../agents/selector.js";
-import { getDiffStats } from "../../git/diff/preview.js";
-import { readDiff } from "../../git/diff/read.js";
-import { getCurrentBranch } from "../../git/branches.js";
-import { getLatestCommitHash } from "../../git/staging.js";
-import { requireCommitCoordinate } from "../../git/commits.js";
-import { DIFF_PREVIEW_TEXT_MAX_CHARS } from "../../keiyaku.js";
-import { FlowError } from "../../flow-error.js";
-import { persistResponseHistory } from "../transcripts.js";
-import { logInfo } from "../../telemetry/logger.js";
-import { execSubagent } from "../call/call.js";
-import { readContractLog } from "../log.js";
-import { runVerificationPlan } from "./verification.js";
-const CLAIM_VERIFICATION_OUTPUT_MAX_CHARS = 1200;
-const REVIEW_PASS_TOKEN = "PASS";
-const REVIEW_REJECTION_MESSAGE = "CLAIM rejected by independent reviewer.";
-const REVIEW_REJECTION_AUDIT_PREFIX = "Independent reviewer rejected CLAIM.";
-const REVIEW_RESPONSE_FALLBACK = "(no output)";
-const REVIEW_SKIPPED_RESULT = { pass: true };
-const REVIEW_ATTEMPT_SECTION_TITLE = "## Review Attempt";
-const REVIEW_PROMPT_LINES = [
-    "You are an independent reviewer.",
-    "Evaluate whether the submitted work fulfills the keiyaku.",
-    "You have full access to the repository. Read source files as needed to verify the changes in context.",
-    "You may use read-only repository inspection commands and tools as needed.",
-    "",
-    "## Workflow Context",
-    "- Commit messages in this branch are intermediate; the branch will be squash-merged. Do not evaluate commit hygiene.",
-    "",
-    "## Output Rules",
-    "- If the work fulfills the keiyaku: begin with `PASS`, optionally followed by observations.",
-    "- If not: begin with `REJECTED`, then state what is wrong and why.",
-    "  Be specific. Reference files and lines. Do not suggest fixes.",
-];
-function buildReviewAttemptBlock(reviewNumber) {
-    if (reviewNumber === 1) {
-        return [REVIEW_ATTEMPT_SECTION_TITLE, "This is review attempt 1."];
-    }
-    return [
-        REVIEW_ATTEMPT_SECTION_TITLE,
-        `This is review attempt ${reviewNumber}.`,
-        "The prior review was rejected.",
-        "Focus on whether the previous concerns have been addressed.",
-    ];
-}
-function clipCommandOutput(value, maxChars = CLAIM_VERIFICATION_OUTPUT_MAX_CHARS) {
-    const trimmed = value.trim();
-    if (!trimmed)
-        return "(no output)";
-    if (trimmed.length <= maxChars)
-        return trimmed;
-    return `${trimmed.slice(0, maxChars)}\n… (+${trimmed.length - maxChars} chars)`;
-}
-function buildReviewerPrompt(input) {
-    const lines = [
-        ...REVIEW_PROMPT_LINES,
-        "",
-        ...buildReviewAttemptBlock(input.reviewNumber),
-        "",
-        "## Keiyaku",
-        input.keiyakuContent,
-        "",
-        "## Plea",
-        input.claimPlea,
-        "",
-        "## Changes",
-        `Base: ${input.baseRef}`,
-        `Head: ${input.headRef}`,
-        "",
-        input.diffStat,
-        "",
-        input.fullDiff,
-    ];
-    if (input.priorFindings) {
-        lines.push("", "## Prior Review Findings", input.priorFindings);
-    }
-    return lines.join("\n");
-}
-export function createOathGate() {
-    return {
-        name: "oath",
-        evaluate({ input }) {
-            if (input.oath.trim().length > 0) {
-                return { pass: true };
-            }
-            return {
-                pass: false,
-                code: "OATH_MISSING",
-                message: "Oath missing.",
-                auditFailures: ["Oath missing."],
-            };
-        },
-    };
-}
-export function createCommandVerificationGate() {
-    return {
-        name: "command",
-        async evaluate({ cwd, repositoryRoot, verificationPlan, verificationCandidate, input }) {
-            for (const verification of verificationPlan) {
-                logInfo(`[CLAIM] Running ${verification.source}: ${verification.label}`, { cwd, section: "script", progressOnly: true });
-            }
-            const invocation = await runVerificationPlan({ cwd, candidate: verificationCandidate, plan: verificationPlan, signal: input.signal, root: repositoryRoot ?? cwd });
-            // Petition owns the run: abort cancels and awaitTerminal observes cleanup.
-            const evidence = await invocation.awaitTerminal();
-            const runnerFailure = evidence.results.find((result) => result.execution.status === "runner_failed");
-            if (runnerFailure?.execution.status === "runner_failed") {
-                return {
-                    pass: false,
-                    code: "CLOSE_QUALITY_GATE_FAILED",
-                    message: `CLAIM blocked: verification runner uncertainty at ${runnerFailure.source} '${runnerFailure.label}' (${runnerFailure.execution.cause.code}: ${runnerFailure.execution.cause.message}).`,
-                    facts: {
-                        kind: "verification_failure",
-                        label: `${runnerFailure.source} ${runnerFailure.label}`,
-                        stdout: clipCommandOutput(runnerFailure.execution.stdout.tail),
-                        stderr: clipCommandOutput(runnerFailure.execution.stderr.tail),
-                    },
-                };
-            }
-            const commandFailure = evidence.results.find((result) => result.execution.status === "executed" && result.execution.code !== 0);
-            if (commandFailure?.execution.status === "executed") {
-                return {
-                    pass: false,
-                    code: "CLOSE_QUALITY_GATE_FAILED",
-                    message: `CLAIM blocked: verification failed at ${commandFailure.source} '${commandFailure.label}' (exit ${commandFailure.execution.code}).`,
-                    facts: {
-                        kind: "verification_failure",
-                        label: `${commandFailure.source} ${commandFailure.label}`,
-                        stdout: clipCommandOutput(commandFailure.execution.stdout.tail),
-                        stderr: clipCommandOutput(commandFailure.execution.stderr.tail),
-                    },
-                };
-            }
-            return { pass: true, verification: [...evidence.results] };
-        },
-    };
-}
-export function createAgentReviewGate() {
-    return {
-        name: "agent-review",
-        async evaluate({ cwd, contractId, input, baseBranch, reviewNumber }) {
-            const reviewConfig = getConfig().review;
-            if (!reviewConfig.enabled) {
-                return REVIEW_SKIPPED_RESULT;
-            }
-            const diffStats = await getDiffStats(cwd, baseBranch);
-            const totalChangedLines = diffStats.insertions + diffStats.deletions;
-            if (totalChangedLines < reviewConfig.minLines) {
-                return REVIEW_SKIPPED_RESULT;
-            }
-            const loaded = await loadKeiyakuSettings(cwd);
-            // Always touch agents catalog disease + reviewer. Touch default only when reviewer is absent
-            // and resolution would fall back through resolveReviewerAgentName → default.
-            assertSettingsKnobUsable(loaded, "agents");
-            assertSettingsKnobUsable(loaded, "reviewer");
-            if (loaded.knobs?.reviewer === undefined) {
-                assertSettingsKnobUsable(loaded, "default");
-            }
-            const settings = loaded.knobs;
-            const reviewerAgentName = resolveReviewerAgentName(settings);
-            const catalog = await loadAkumaCatalog(cwd);
-            const availableNames = Object.keys(catalog.selected);
-            if (catalog.selected[reviewerAgentName] === undefined) {
-                throw new FlowError("UNKNOWN_SUBAGENT", `Unknown agent '${reviewerAgentName}'. Expected one of: ${formatAvailableAgentNames(availableNames)}`);
-            }
-            const [contractLog, diffStat, fullDiff, currentBranch, headRef] = await Promise.all([
-                readContractLog({ cwd, contractId }),
-                readDiff(cwd, `${baseBranch}...HEAD`, "stat", {
-                    maxChars: DIFF_PREVIEW_TEXT_MAX_CHARS,
-                }),
-                readDiff(cwd, `${baseBranch}...HEAD`, "patch", {
-                    algorithm: "histogram",
-                    maxChars: DIFF_PREVIEW_TEXT_MAX_CHARS,
-                }),
-                getCurrentBranch(cwd),
-                getLatestCommitHash(cwd),
-            ]);
-            const prompt = buildReviewerPrompt({
-                keiyakuContent: contractLog.markdown,
-                claimPlea: input.plea,
-                baseRef: baseBranch,
-                headRef,
-                reviewNumber,
-                diffStat: diffStat ?? "No diff.",
-                fullDiff: fullDiff ?? "No diff.",
-            });
-            const selectedReviewerAgentName = reviewerAgentName;
-            const subagentResult = await execSubagent(selectedReviewerAgentName, prompt, cwd, {
-                signal: input.signal,
-                authority: { kind: "repository" },
-                binding: { kind: "commission", commissionId: contractId },
-            });
-            const reviewHeadBeforeWrite = (await requireCommitCoordinate(cwd, "HEAD")).commit;
-            const raw = subagentResult.finalMessage.trim();
-            const passed = raw.startsWith(REVIEW_PASS_TOKEN);
-            const observations = passed ? raw.slice(REVIEW_PASS_TOKEN.length).trim() || undefined : undefined;
-            const review = {
-                review: reviewNumber,
-                result: passed ? "passed" : "rejected",
-                findings: passed ? observations : raw || REVIEW_RESPONSE_FALLBACK,
-            };
-            if (review.result === "passed") {
-                return {
-                    pass: true,
-                    review,
-                    reviewHeadBeforeWrite,
-                    reviewerActor: selectedReviewerAgentName,
-                    reviewPersistence: {
-                        reviewNumber,
-                        reviewedHead: reviewHeadBeforeWrite,
-                        persist: () => persistResponseHistory({
-                            cwd,
-                            tool: "review",
-                            provenance: { authority: { kind: "repository" }, binding: { kind: "commission", commissionId: contractId }, evidenceCwd: cwd },
-                            title: String(reviewNumber),
-                            prompt,
-                            response: subagentResult.finalMessage,
-                            session: subagentResult.session,
-                            subagentName: selectedReviewerAgentName,
-                            launchSnapshot: subagentResult.launchSnapshot,
-                        }),
-                    },
-                };
-            }
-            return {
-                pass: false,
-                code: "REVIEW_REJECTED",
-                message: REVIEW_REJECTION_MESSAGE,
-                auditFailures: [`${REVIEW_REJECTION_AUDIT_PREFIX} See Review ${review.review}.`],
-                review,
-                reviewHeadBeforeWrite,
-                reviewerActor: selectedReviewerAgentName,
-            };
-        },
-    };
-}
-export function buildClaimGatePipeline() {
-    return [
-        createOathGate(),
-        createCommandVerificationGate(),
-        createAgentReviewGate(),
-    ];
-}

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

@@ -1,46 +0,0 @@
-import { forfeitContract } from "../forfeit.js";
-import { readContractLog } from "../log.js";
-import { isCompleteLifecycleOutcome } from "../outcome-base.js";
-function maxArc(entries) {
-    return entries.filter((entry) => entry.kind === "arc").length;
-}
-function cleanupWarnings(cleanup) {
-    return [
-        ...(cleanup.worktreeRemoveFailure
-            ? [`Could not remove contract worktree ${cleanup.worktreeRemoveFailure.path}: ${cleanup.worktreeRemoveFailure.reason}`]
-            : []),
-        ...(cleanup.deliveryRef.status === "mismatch"
-            ? [`Delivery ref ${cleanup.deliveryRef.mismatch.ref} remains present at ${cleanup.deliveryRef.mismatch.observed.head}; terminal replay preserved it as a projected-surface mismatch.`]
-            : []),
-    ];
-}
-export async function forfeitKeiyaku(context, signal) {
-    const { cwd, baseBranch, contractId } = context;
-    const log = await readContractLog({ cwd, contractId, signal });
-    const forfeited = await forfeitContract({
-        cwd,
-        contractId,
-        actor: "keiyaku",
-        nowMs: Date.now(),
-        reason: "manual",
-        signal,
-    });
-    if (!isCompleteLifecycleOutcome(forfeited))
-        return forfeited;
-    if (!forfeited.cleanup)
-        return forfeited;
-    return {
-        ...forfeited,
-        status: "success",
-        result: "dropped",
-        arc: maxArc(log.entries),
-        currentBranch: baseBranch,
-        baseBranch,
-        cleanup: forfeited.cleanup,
-        ledgerView: log.markdown,
-        diff: "Forfeited without merge.",
-        droppedChanges: [],
-        carrier: forfeited.carrier,
-        ...(cleanupWarnings(forfeited.cleanup).length > 0 ? { meta: { warnings: cleanupWarnings(forfeited.cleanup) } } : {}),
-    };
-}

package/build/core/settlement/petition-head-guard.js

@@ -1,12 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { requireCommitCoordinate } from "../../git/commits.js";
-const CONCURRENT_MODIFICATION_CODE = "CONCURRENT_MODIFICATION";
-export async function assertHeadUnchanged(cwd, expectedHead, operation) {
-    const [expectedCommit, currentHead] = await Promise.all([
-        requireCommitCoordinate(cwd, expectedHead),
-        requireCommitCoordinate(cwd, "HEAD"),
-    ]);
-    if (currentHead.commit === expectedCommit.commit)
-        return;
-    throw new FlowError(CONCURRENT_MODIFICATION_CODE, `concurrent ${operation} modification detected: repository HEAD changed from ${expectedHead} to ${currentHead.commit} while the ${operation} was running`);
-}

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

@@ -1 +0,0 @@
-export {};