@astrosheep/keiyaku 2.9.12 → 4.0.0

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,246 +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 { createGit } from "../../git/core.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, coordinationRoot, verificationPlan, verificationCandidate, input }) {
-            const repositoryRoot = coordinationRoot ?? cwd;
-            for (const verification of verificationPlan) {
-                logInfo(`[CLAIM] Running ${verification.source}: ${verification.label}`, { cwd, section: "script", progressOnly: true });
-            }
-            const evidence = await runVerificationPlan({ cwd, candidate: verificationCandidate, plan: verificationPlan, signal: input.signal, coordinationKey: JSON.stringify({ repository: repositoryRoot, candidate: verificationCandidate, plan: verificationPlan }), coordinationRoot: repositoryRoot });
-            const runnerFailure = evidence.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.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] };
-        },
-    };
-}
-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 createGit(cwd).revparse(["--verify", "HEAD^{commit}"])).trim();
-            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,13 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { createGit } from "../../git/core.js";
-const CONCURRENT_MODIFICATION_CODE = "CONCURRENT_MODIFICATION";
-export async function assertHeadUnchanged(cwd, expectedHead, operation) {
-    const git = createGit(cwd);
-    const [expectedCommit, currentHead] = await Promise.all([
-        git.raw(["rev-parse", "--verify", `${expectedHead}^{commit}`]),
-        git.raw(["rev-parse", "--verify", "HEAD^{commit}"]),
-    ]);
-    if (currentHead.trim() === expectedCommit.trim())
-        return;
-    throw new FlowError(CONCURRENT_MODIFICATION_CODE, `concurrent ${operation} modification detected: repository HEAD changed from ${expectedHead} to ${currentHead.trim()} while the ${operation} was running`);
-}

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

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

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

@@ -1,109 +0,0 @@
-import { createOathGate } from "./petition-claim-gates.js";
-import { assertFoldedPetitionable, } from "./petition.js";
-import { captureFoldedSeal } from "../seal.js";
-import { withContractCarrierSession } from "../contract-carrier.js";
-import { FlowError } from "../../flow-error.js";
-export const PETITION_PREVIEW_GATE_NAMES = [
-    "contract",
-    "freshness",
-    "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 gates = [{ name: "contract", result: "pass" }];
-        const freshness = await gate("freshness", async () => {
-            if (!session.pins.target.head || context.base !== session.pins.target.head) {
-                throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} must renew onto ${context.target.branch} before petition`);
-            }
-        });
-        gates.push(freshness);
-        const arc = freshness.result === "pass"
-            ? await gate("arc", async () => {
-                if (context.lifecycle.phase !== "active")
-                    throw new FlowError("NO_OPEN_ARC", "no active folded arc requires sealing");
-            })
-            : notEvaluated("arc");
-        gates.push(arc);
-        const state = await gate("state", () => {
-            assertFoldedPetitionable(input.contractId, context.lifecycle);
-        });
-        gates.push(state);
-        let seal;
-        if (freshness.result === "pass" && arc.result === "pass" && state.result === "pass") {
-            try {
-                const capture = await captureFoldedSeal(context.deliveryCwd, context.lifecycle, "HEAD");
-                seal = { name: "seal", result: "pass", detail: sealFileDetail(capture?.diffstat.files ?? 0) };
-            }
-            catch (error) {
-                seal = { name: "seal", result: "failed", detail: failureDetail(error) };
-            }
-        }
-        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 } },
-            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 };
-}