@astrosheep/keiyaku 0.1.87 → 1.0.0

package/build/tools/amend/run.js

@@ -1,44 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { KEIYAKU_BRANCH_PREFIX, KEIYAKU_FILE } from "../../keiyaku.js";
-import { FlowError, requireText } from "../../flow-error.js";
-import { isGitRepo } from "../../git/branches.js";
-import { getActiveKeiyakuGitState } from "../../git/keiyaku-state.js";
-import { addFiles, commit, getLatestCommitHash } from "../../git/staging.js";
-import { assertKeiyakuProtocolFiles } from "../../protocol/file-guards.js";
-import { appendKeiyakuAmendment } from "../../protocol/render-keiyaku.js";
-import { buildNoActiveKeiyakuGuidance } from "../round/guidance.js";
-import { assertCleanWorkingTree } from "../round/worktree.js";
-function buildAmendCommitMessage(titleToken, amendmentNumber) {
-    return `keiyaku(${titleToken}): amend ${amendmentNumber}`;
-}
-export async function amendKeiyaku(input) {
-    const isRepo = await isGitRepo(input.cwd);
-    if (!isRepo) {
-        throw new FlowError("NOT_GIT_REPO", `${input.cwd} is not a git repository`);
-    }
-    const activeState = await getActiveKeiyakuGitState(input.cwd);
-    if (!activeState) {
-        const guidance = await buildNoActiveKeiyakuGuidance(input.cwd, "amend");
-        throw new FlowError("NOT_ACTIVE_KEIYAKU_BRANCH", guidance.message, { hints: guidance.hints });
-    }
-    await assertCleanWorkingTree(input.cwd, []);
-    await assertKeiyakuProtocolFiles(input.cwd);
-    const amendment = requireText("amendment", input.amendment);
-    const keiyakuPath = path.join(input.cwd, KEIYAKU_FILE);
-    const currentKeiyaku = await fs.readFile(keiyakuPath, "utf-8");
-    const nextKeiyaku = appendKeiyakuAmendment(currentKeiyaku, { amendment });
-    await fs.writeFile(keiyakuPath, nextKeiyaku.content, "utf-8");
-    await addFiles(input.cwd, [KEIYAKU_FILE]);
-    const title = activeState.branch.slice(KEIYAKU_BRANCH_PREFIX.length);
-    await commit(input.cwd, buildAmendCommitMessage(title, nextKeiyaku.amendmentNumber));
-    const commitHash = await getLatestCommitHash(input.cwd);
-    return {
-        status: "success",
-        amendmentNumber: nextKeiyaku.amendmentNumber,
-        currentBranch: activeState.branch,
-        baseBranch: activeState.baseBranch,
-        commit: commitHash,
-        summary: `Appended Amendment ${nextKeiyaku.amendmentNumber} to ${KEIYAKU_FILE}.`,
-    };
-}

package/build/tools/bind/index.js

@@ -1,44 +0,0 @@
-import { bindKeiyaku } from "./run.js";
-import { buildBindSuccessResponse, } from "../../responses/responses.js";
-import { createToolHandler } from "../create-handler.js";
-function normalizeOptionalArg(value) {
-    if (value === undefined)
-        return undefined;
-    return value.trim().length > 0 ? value : undefined;
-}
-export function createBindHandler() {
-    return createToolHandler({
-        logLabel: "tool bind",
-        doneLog: (result) => `tool bind success branch=${result.currentBranch} base=${result.baseBranch} round=${result.round}`,
-        async run({ from_draft, draft_only, title, goal, context, rules, criteria, cwd }, extra) {
-            const normalizedFromDraft = normalizeOptionalArg(from_draft);
-            const parsedCriteria = normalizeOptionalArg(criteria);
-            const parsedRules = normalizeOptionalArg(rules);
-            return normalizedFromDraft
-                ? bindKeiyaku({
-                    cwd,
-                    from_draft: normalizedFromDraft,
-                    draft_only,
-                    title: normalizeOptionalArg(title),
-                    goal: normalizeOptionalArg(goal),
-                    context: normalizeOptionalArg(context),
-                    rules: parsedRules,
-                    criteria: parsedCriteria,
-                    signal: extra.signal,
-                })
-                : bindKeiyaku({
-                    cwd,
-                    draft_only,
-                    title: title ?? "",
-                    goal: goal ?? "",
-                    context: context ?? "",
-                    rules: parsedRules,
-                    criteria: parsedCriteria ?? "",
-                    signal: extra.signal,
-                });
-        },
-        buildResponse(result) {
-            return buildBindSuccessResponse(result);
-        },
-    });
-}

package/build/tools/bind/run.js

@@ -1,237 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { KEIYAKU_BRANCH_PREFIX, KEIYAKU_FILE } from "../../keiyaku.js";
-import { isErrnoException } from "../../errno.js";
-import { logInfo, logWarn } from "../../telemetry/logger.js";
-import { FlowError } from "../../flow-error.js";
-import { assertValidBranchName, checkoutBranch, createAndCheckoutBranch, deleteBranch, getCurrentBranch, hasLocalBranch, isGitRepo, listLocalKeiyakuBranches } from "../../git/branches.js";
-import { clearKeiyakuBase, getActiveKeiyakuGitState, setKeiyakuBase } from "../../git/keiyaku-state.js";
-import { addFiles, addFilesForce, commit as commitChanges, getLatestCommitHash } from "../../git/staging.js";
-import { discardAllWorkingTreeChanges } from "../../git/stash.js";
-import { isPathTracked } from "../../git/worktree.js";
-import { assertCleanWorkingTree } from "../round/worktree.js";
-import { renderKeiyaku } from "../../protocol/render-keiyaku.js";
-import { readBaseRules } from "../../config/base-rules.js";
-import { buildBindRollbackFailureWarning, evaluateWorkflowHints, getBindProtocolFileWarning, } from "../../config/architect-hints.js";
-import { persistResponseHistory } from "../../protocol/response-history.js";
-import { appendDebugLog } from "../../telemetry/debug-log.js";
-import { writeDraftArtifact } from "../../protocol/draft-artifacts.js";
-import { captureRollbackDraftSnapshots, handleBindFailure, resolveGitRelativePath, resolveBindInput, restoreRollbackDraftSnapshots, } from "../../protocol/bind-draft.js";
-const BIND_CONSUME_FROM_DRAFT_COMMIT_SUFFIX = "consume from_draft";
-const BIND_READY_SUMMARY = "Bound keiyaku branch and KEIYAKU.md. Run round open to frame round 1.";
-const BIND_READY_DIFF = "No diff.";
-function buildActiveKeiyakuBindMessage(branch) {
-    return `Active keiyaku detected on branch '${branch}'.`;
-}
-async function fileExists(filePath) {
-    try {
-        await fs.access(filePath);
-        return true;
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return false;
-        }
-        throw error;
-    }
-}
-async function assertBindPreFlight(cwd) {
-    const existing = (await fileExists(path.join(cwd, KEIYAKU_FILE))) ? [KEIYAKU_FILE] : [];
-    if (existing.length > 0) {
-        throw new FlowError("KEIYAKU_FILE_EXISTS", `pre-flight failed: ${existing.join(", ")} already exist in cwd — remove them before starting`);
-    }
-}
-function normalizeTitleForBranch(title) {
-    const normalized = title
-        .trim()
-        .toLowerCase()
-        .replace(/[^\p{Script=Han}a-z0-9]+/gu, "-")
-        .replace(/-+/g, "-")
-        .replace(/^-+/, "")
-        .replace(/-+$/, "");
-    if (!normalized) {
-        throw new FlowError("INVALID_BRANCH_TITLE", "title cannot be converted to a valid branch name; branch tokens support letters and numbers");
-    }
-    return normalized;
-}
-async function buildKeiyakuContent(cwd, resolved) {
-    const baseRules = (await readBaseRules(cwd)) ?? "";
-    const content = renderKeiyaku(resolved.title, resolved.goal, resolved.context, baseRules, resolved.rules, resolved.criteria);
-    return { content, baseRules };
-}
-async function initKeiyakuBranch(cwd, resolved, keiyakuContent) {
-    const isRepo = await isGitRepo(cwd);
-    if (!isRepo) {
-        throw new FlowError("NOT_GIT_REPO", `${cwd} is not a git repository`);
-    }
-    const activeState = await getActiveKeiyakuGitState(cwd);
-    if (activeState) {
-        throw new FlowError("ACTIVE_KEIYAKU_EXISTS", buildActiveKeiyakuBindMessage(activeState.branch));
-    }
-    let existingBranches;
-    const existingKeiyakuBranches = await listLocalKeiyakuBranches(cwd);
-    if (existingKeiyakuBranches.length > 0) {
-        existingBranches = existingKeiyakuBranches;
-        const branchWarning = `[keiyaku] existing local keiyaku branches detected (non-blocking): ${existingKeiyakuBranches.join(", ")}`;
-        logInfo(branchWarning, { cwd, section: "script", progressOnly: true });
-    }
-    await assertBindPreFlight(cwd);
-    const dirtyAllowlist = Array.from(new Set(resolved.dirtyAllowlist));
-    await assertCleanWorkingTree(cwd, dirtyAllowlist);
-    const baseBranch = await getCurrentBranch(cwd);
-    const branchToken = normalizeTitleForBranch(resolved.title);
-    const keiyakuBranch = `${KEIYAKU_BRANCH_PREFIX}${branchToken}`;
-    await assertValidBranchName(cwd, keiyakuBranch);
-    await createAndCheckoutBranch(cwd, keiyakuBranch);
-    await setKeiyakuBase(cwd, keiyakuBranch, baseBranch);
-    logInfo(`Switched to branch: ${keiyakuBranch} (base: ${baseBranch})`, { cwd, section: "script", progressOnly: true });
-    await fs.writeFile(path.join(cwd, KEIYAKU_FILE), keiyakuContent);
-    await addFilesForce(cwd, [KEIYAKU_FILE]);
-    await commitChanges(cwd, `keiyaku(${branchToken}): open`);
-    const commit = await getLatestCommitHash(cwd);
-    return {
-        branchToken,
-        keiyakuBranch,
-        baseBranch,
-        commit,
-        existingBranches,
-    };
-}
-async function finalizeBindKeiyaku(input, resolved, setup, baseRules) {
-    const { cwd } = input;
-    const { branchToken, baseBranch, existingBranches, keiyakuBranch } = setup;
-    const summary = BIND_READY_SUMMARY;
-    const diff = BIND_READY_DIFF;
-    let commit = setup.commit;
-    let consumedFromDraft;
-    if (resolved.fromDraft && resolved.fromDraftPath) {
-        const trackedFromDraftPath = resolveGitRelativePath(cwd, resolved.fromDraftPath);
-        const shouldCommitDeletion = trackedFromDraftPath !== null && (await isPathTracked(cwd, trackedFromDraftPath));
-        await fs.unlink(resolved.fromDraftPath);
-        if (shouldCommitDeletion && trackedFromDraftPath) {
-            await addFiles(cwd, trackedFromDraftPath);
-            await commitChanges(cwd, `keiyaku(${branchToken}): ${BIND_CONSUME_FROM_DRAFT_COMMIT_SUFFIX}`);
-            commit = await getLatestCommitHash(cwd);
-        }
-        consumedFromDraft = resolved.fromDraft;
-        logInfo(`[keiyaku] Consumed from_draft and deleted source draft: ${resolved.fromDraft}`, {
-            cwd,
-            section: "script",
-            progressOnly: true,
-        });
-    }
-    let responsePath;
-    try {
-        responsePath = await persistResponseHistory({
-            cwd,
-            tool: "bind",
-            title: resolved.title.trim() || branchToken || "bind",
-            goal: resolved.goal,
-            criteria: resolved.criteria,
-            summary,
-            diff,
-            branch: keiyakuBranch,
-            commit,
-        });
-    }
-    catch (historyError) {
-        const historyErrorMessage = historyError instanceof Error ? historyError.message : String(historyError);
-        logWarn(`Failed to persist bind response: ${historyErrorMessage}`, { cwd, section: "script" });
-        appendDebugLog(`tool bind response persistence failed: ${historyErrorMessage}`, {
-            cwd,
-            section: "script",
-        });
-    }
-    return {
-        status: "success",
-        round: 0,
-        diff,
-        summary,
-        rules: baseRules,
-        responsePath,
-        consumedFromDraft,
-        existingBranches,
-        currentBranch: keiyakuBranch,
-        baseBranch,
-        commit,
-        meta: {
-            warnings: [getBindProtocolFileWarning()],
-            hints: evaluateWorkflowHints("bind"),
-        },
-    };
-}
-async function rollbackBranchCreation(cwd, keiyakuBranch, baseBranch) {
-    // Discard all working tree changes before switching branches to avoid checkout conflicts
-    await discardAllWorkingTreeChanges(cwd);
-    await checkoutBranch(cwd, baseBranch);
-    if (await hasLocalBranch(cwd, keiyakuBranch)) {
-        await deleteBranch(cwd, keiyakuBranch, true);
-    }
-    await clearKeiyakuBase(cwd, keiyakuBranch);
-}
-export async function bindKeiyaku(input) {
-    const { cwd, signal, draft_only } = input;
-    const resolved = await resolveBindInput(cwd, input);
-    let keiyakuContent;
-    let setup;
-    let rollbackDraftSnapshots = [];
-    let baseRules = "";
-    try {
-        // Eagerly render content to enable draft recovery on early failures.
-        const rendered = await buildKeiyakuContent(cwd, resolved);
-        keiyakuContent = rendered.content;
-        baseRules = rendered.baseRules;
-        if (draft_only) {
-            const draftPath = await writeDraftArtifact({
-                cwd,
-                title: resolved.title,
-                content: keiyakuContent,
-            });
-            logInfo(`[keiyaku] Draft-only bind wrote ${draftPath}.`, { cwd, section: "script", progressOnly: true });
-            return {
-                status: "success",
-                round: 0,
-                diff: BIND_READY_DIFF,
-                summary: `Draft generated at ${draftPath}.`,
-                rules: baseRules,
-                draftPath,
-                draftOnly: true,
-                currentBranch: "",
-                baseBranch: "",
-                meta: {
-                    warnings: [getBindProtocolFileWarning()],
-                    hints: evaluateWorkflowHints("bind"),
-                },
-            };
-        }
-        setup = await initKeiyakuBranch(cwd, resolved, keiyakuContent);
-        rollbackDraftSnapshots = await captureRollbackDraftSnapshots(cwd, resolved.fromDraftPath);
-        return await finalizeBindKeiyaku({ cwd, signal }, resolved, setup, baseRules);
-    }
-    catch (err) {
-        if (setup?.baseBranch && setup.keiyakuBranch) {
-            try {
-                await rollbackBranchCreation(cwd, setup.keiyakuBranch, setup.baseBranch);
-            }
-            catch (rollbackError) {
-                const rollbackMessage = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
-                logWarn(buildBindRollbackFailureWarning(rollbackMessage, setup.baseBranch, setup.keiyakuBranch), {
-                    cwd,
-                    section: "script",
-                });
-            }
-            finally {
-                if (rollbackDraftSnapshots.length > 0) {
-                    try {
-                        await restoreRollbackDraftSnapshots(cwd, rollbackDraftSnapshots);
-                    }
-                    catch (restoreError) {
-                        const restoreMessage = restoreError instanceof Error ? restoreError.message : String(restoreError);
-                        logWarn(`[keiyaku] Bind rollback draft restoration failed: ${restoreMessage}`, { cwd, section: "script" });
-                    }
-                }
-            }
-        }
-        return handleBindFailure(cwd, err, keiyakuContent, resolved.title, resolved.fromDraft);
-    }
-}

package/build/tools/contracts.js

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

package/build/tools/create-handler.js

@@ -1,31 +0,0 @@
-import { appendDebugLog } from "../telemetry/debug-log.js";
-import { handleToolError } from "../responses/tool-errors.js";
-const TOOL_LOG_SECTION = "script";
-function resolveWorkingDirectory(cwd) {
-    return typeof cwd === "string" && cwd.length > 0 ? cwd : process.cwd();
-}
-export function createToolHandler(config) {
-    return async (input, extra) => {
-        const normalizedInput = { ...input, cwd: resolveWorkingDirectory(input.cwd) };
-        try {
-            appendDebugLog(`${config.logLabel} cwd=${normalizedInput.cwd}`, {
-                cwd: normalizedInput.cwd,
-                section: TOOL_LOG_SECTION,
-            });
-            const result = await config.run(normalizedInput, extra);
-            const doneLog = typeof config.doneLog === "function" ? config.doneLog(result) : config.doneLog;
-            appendDebugLog(doneLog, {
-                cwd: normalizedInput.cwd,
-                section: TOOL_LOG_SECTION,
-            });
-            return config.buildResponse(result, normalizedInput);
-        }
-        catch (error) {
-            return await handleToolError({
-                error,
-                cwd: normalizedInput.cwd,
-                logLabel: config.logLabel,
-            });
-        }
-    };
-}

package/build/tools/help.js

@@ -1,9 +0,0 @@
-import { buildHelpBody } from "../config/architect-hints.js";
-import { buildHelpResponse } from "../responses/responses.js";
-export function createHelpHandler(version) {
-    return async ({}) => {
-        return buildHelpResponse({
-            text: buildHelpBody(version),
-        });
-    };
-}

package/build/tools/petition/claim.js

@@ -1,174 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { KEIYAKU_FILE, RESPONSE_HISTORY_DIR, } from "../../keiyaku.js";
-import { FlowError, wrapFlowError } from "../../flow-error.js";
-import { checkoutBranch, deleteBranch } from "../../git/branches.js";
-import { getDiffStats } from "../../git/diff/preview.js";
-import { clearKeiyakuBase } from "../../git/keiyaku-state.js";
-import { commitAllowEmpty, getLatestCommitHash, getUnmergedFiles, mergeSquashStaged, restoreFilesFromHead } from "../../git/staging.js";
-import { resetHardHead } from "../../git/stash.js";
-import { logInfo, logWarn } from "../../telemetry/logger.js";
-import { renderRoundLedgerHistory, scanRoundLedger, } from "../../protocol/ledger.js";
-import { assertKeiyakuProtocolFiles } from "../../protocol/file-guards.js";
-import { assertCleanWorkingTree } from "../round/worktree.js";
-import { buildClaimGatePipeline, } from "./claim-gates.js";
-import { assertHeadUnchanged } from "../round/head-guard.js";
-function buildMergeMessage(title, plea, keiyakuContent, reportContent) {
-    return `keiyaku(${title}): done\n\nPlea: ${plea}\n\n---\n${keiyakuContent}\n---\n${reportContent}\n---\n`;
-}
-function formatCloseDiffSummary(stats, baseBranch) {
-    return `Range ${baseBranch}...HEAD | Files ${stats.filesChanged} | +${stats.insertions} / -${stats.deletions}`;
-}
-function renderReviewForAudit(review) {
-    return [
-        `## Review ${review.review}`,
-        `Result: ${review.result}`,
-        ...(review.historyPath ? [`See: ${review.historyPath}`] : []),
-        ...(review.findings ? ["", review.findings.trim()] : []),
-        "",
-    ].join("\n");
-}
-function renderVerdictForAudit(input) {
-    const lines = [
-        "## Verdict",
-        `**Status**: ${input.status}`,
-        `**Title**: ${input.title}`,
-        `**Plea**: ${input.plea}`,
-    ];
-    if (input.bypassedByArchitect) {
-        lines.push("**Gates**: bypassed by Architect");
-    }
-    if (input.checkFailures?.length) {
-        lines.push("", "### Check Failures", ...input.checkFailures.map((failure) => `- ${failure}`));
-    }
-    return `${lines.join("\n")}\n`;
-}
-async function throwClaimGateFailure(failure, input, context, dependencies) {
-    const { cwd, titleToken } = context;
-    void titleToken;
-    void dependencies;
-    if (failure.reviewHeadBeforeWrite) {
-        await assertHeadUnchanged(cwd, failure.reviewHeadBeforeWrite, "petition claim review");
-    }
-    throw new FlowError(failure.code, failure.message, {
-        hints: failure.hints,
-        review: failure.review,
-    });
-}
-async function runClaimGatePipelineOrThrow(input, context, dependencies) {
-    const { verificationCommands } = await dependencies.resolveClaimGateConfig(context.cwd);
-    let review;
-    let reviewHeadBeforeWrite;
-    for (const gate of buildClaimGatePipeline()) {
-        const result = await gate.evaluate({
-            cwd: context.cwd,
-            input,
-            verificationCommands,
-            baseBranch: dependencies.baseBranch,
-            reviewNumber: dependencies.reviewNumber,
-        });
-        if (result.review) {
-            review = result.review;
-            reviewHeadBeforeWrite = result.reviewHeadBeforeWrite;
-        }
-        if (!result.pass) {
-            await throwClaimGateFailure(result, input, context, dependencies);
-        }
-    }
-    return { review, reviewHeadBeforeWrite };
-}
-export async function claimKeiyaku(input, context, dependencies) {
-    const { cwd, baseBranch, keiyakuBranch, titleToken } = context;
-    await assertKeiyakuProtocolFiles(cwd);
-    const ledgerEntries = await scanRoundLedger(cwd);
-    const ledgerView = renderRoundLedgerHistory(ledgerEntries);
-    let attemptedBaseMerge = false;
-    const claimTitle = input.title;
-    const claimPlea = input.plea;
-    const claimResult = "dangerouslyBypassGates" in input && input.dangerouslyBypassGates
-        ? { review: undefined, reviewHeadBeforeWrite: undefined, bypassedByArchitect: true }
-        : {
-            ...(await runClaimGatePipelineOrThrow(input, { cwd, titleToken }, {
-                ...dependencies,
-                baseBranch,
-                reviewNumber: ledgerEntries.length + 1,
-            })),
-            bypassedByArchitect: false,
-        };
-    await assertCleanWorkingTree(cwd, [RESPONSE_HISTORY_DIR]);
-    try {
-        logInfo(`[CLAIM] Collecting diff preview against base '${baseBranch}'`, { cwd, section: "script", progressOnly: true });
-        logInfo("[CLAIM] Reading keiyaku protocol files", { cwd, section: "script", progressOnly: true });
-        const keiyakuContent = await fs.readFile(path.join(cwd, KEIYAKU_FILE), "utf-8");
-        if (claimResult.review && claimResult.reviewHeadBeforeWrite) {
-            await assertHeadUnchanged(cwd, claimResult.reviewHeadBeforeWrite, "petition claim review");
-        }
-        const reportContent = [
-            "# Keiyaku Ledger",
-            "",
-            ledgerView,
-            "",
-            claimResult.review ? renderReviewForAudit(claimResult.review) : "",
-            renderVerdictForAudit({
-                status: "ACCEPTED",
-                title: claimTitle,
-                plea: claimPlea,
-                bypassedByArchitect: claimResult.bypassedByArchitect,
-            }),
-        ].filter((chunk) => chunk.trim().length > 0).join("\n");
-        const message = buildMergeMessage(claimTitle, claimPlea, keiyakuContent, reportContent);
-        const diffStats = await getDiffStats(cwd, baseBranch);
-        const diff = formatCloseDiffSummary(diffStats, baseBranch);
-        logInfo(`[CLAIM] Checking out base branch '${baseBranch}'`, { cwd, section: "script", progressOnly: true });
-        await checkoutBranch(cwd, baseBranch);
-        attemptedBaseMerge = true;
-        logInfo(`[CLAIM] Merging '${keiyakuBranch}' into '${baseBranch}'`, { cwd, section: "script", progressOnly: true });
-        await mergeSquashStaged(cwd, keiyakuBranch);
-        logInfo("[CLAIM] Restoring protocol files from base branch before merge commit", {
-            cwd,
-            section: "script",
-            progressOnly: true,
-        });
-        await restoreFilesFromHead(cwd, [KEIYAKU_FILE]);
-        await commitAllowEmpty(cwd, message);
-        const commit = await getLatestCommitHash(cwd);
-        logInfo(`[CLAIM] Deleting merged branch '${keiyakuBranch}' and clearing metadata`, {
-            cwd,
-            section: "script",
-            progressOnly: true,
-        });
-        await deleteBranch(cwd, keiyakuBranch, true);
-        await clearKeiyakuBase(cwd, keiyakuBranch);
-        const round = ledgerEntries.reduce((max, entry) => Math.max(max, entry.round), 0);
-        return {
-            status: "success",
-            result: "merged",
-            review: claimResult.review,
-            round,
-            currentBranch: baseBranch,
-            baseBranch,
-            commit,
-            mergedInto: baseBranch,
-            deletedBranch: keiyakuBranch,
-            ledgerView,
-            diff,
-        };
-    }
-    catch (error) {
-        const conflictFiles = attemptedBaseMerge ? await getUnmergedFiles(cwd) : [];
-        if (attemptedBaseMerge) {
-            try {
-                await resetHardHead(cwd);
-                await checkoutBranch(cwd, keiyakuBranch);
-            }
-            catch (recoveryError) {
-                const warning = `[CLAIM] Failed to restore keiyaku branch state after merge error: ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`;
-                logWarn(warning, { cwd, section: "script" });
-            }
-        }
-        if (conflictFiles.length > 0) {
-            throw new FlowError("CLOSE_MERGE_CONFLICT", `CLAIM merge conflict between ${keiyakuBranch} and ${baseBranch} (CONFLICTS: ${conflictFiles.join(", ")})`, { cause: error });
-        }
-        throw wrapFlowError(`execute CLAIM (merge ${keiyakuBranch} into ${baseBranch})`, error);
-    }
-}

package/build/tools/petition/forfeit.js

@@ -1,100 +0,0 @@
-import { KEIYAKU_ARCHIVE_TAG_PREFIX } from "../../keiyaku.js";
-import { FlowError, wrapFlowError } from "../../flow-error.js";
-import { restoreDraftSnapshot } from "../../protocol/draft-artifacts.js";
-import { checkoutBranch, deleteBranch } from "../../git/branches.js";
-import { clearKeiyakuBase } from "../../git/keiyaku-state.js";
-import { createTagAtHead } from "../../git/staging.js";
-import { applyStash, createSafetyStash, discardAllWorkingTreeChanges, dropStash } from "../../git/stash.js";
-import { getDirtyFiles, renderDirtyFileStatusLine } from "../../git/worktree.js";
-import { renderRoundLedgerHistory, scanRoundLedger } from "../../protocol/ledger.js";
-import { buildForfeitReturnBranchFailureHint, buildForfeitRollbackApplyHints, buildForfeitRollbackCheckoutHints, getForfeitRollbackRestoredHint, } from "../../config/architect-hints.js";
-function buildForfeitSafetyStashMessage(titleToken) {
-    return `keiyaku(${titleToken}): forfeit safety snapshot`;
-}
-function buildArchiveTag(titleToken, now = Date.now()) {
-    return `${KEIYAKU_ARCHIVE_TAG_PREFIX}${titleToken}-${now}`;
-}
-async function restoreForfeitSafetySnapshot(cwd, keiyakuBranch, stashRef) {
-    const hints = [];
-    try {
-        await checkoutBranch(cwd, keiyakuBranch);
-    }
-    catch (checkoutError) {
-        const checkoutFailure = checkoutError instanceof Error ? checkoutError.message : String(checkoutError);
-        hints.push(...buildForfeitRollbackCheckoutHints(keiyakuBranch, checkoutFailure, stashRef));
-        return hints;
-    }
-    try {
-        await applyStash(cwd, stashRef);
-        hints.push(getForfeitRollbackRestoredHint());
-    }
-    catch (applyError) {
-        const applyFailure = applyError instanceof Error ? applyError.message : String(applyError);
-        hints.push(...buildForfeitRollbackApplyHints(keiyakuBranch, stashRef, applyFailure));
-    }
-    return hints;
-}
-export async function forfeitKeiyaku(context) {
-    const { cwd, baseBranch, keiyakuBranch, titleToken, draftSnapshot } = context;
-    const archiveTag = buildArchiveTag(titleToken);
-    const ledgerEntries = await scanRoundLedger(cwd);
-    const round = ledgerEntries.reduce((max, entry) => Math.max(max, entry.round), 0);
-    const ledgerView = renderRoundLedgerHistory(ledgerEntries);
-    const dirtyFiles = await getDirtyFiles(cwd);
-    const droppedChanges = dirtyFiles.map((file) => renderDirtyFileStatusLine(file));
-    let safetyStashRef = null;
-    try {
-        if (dirtyFiles.length > 0) {
-            safetyStashRef = await createSafetyStash(cwd, buildForfeitSafetyStashMessage(titleToken));
-            await discardAllWorkingTreeChanges(cwd);
-        }
-        await createTagAtHead(cwd, archiveTag);
-        await checkoutBranch(cwd, baseBranch);
-        if (draftSnapshot) {
-            await restoreDraftSnapshot(cwd, draftSnapshot);
-        }
-        await deleteBranch(cwd, keiyakuBranch, true);
-        await clearKeiyakuBase(cwd, keiyakuBranch);
-        if (safetyStashRef) {
-            await dropStash(cwd, safetyStashRef);
-        }
-    }
-    catch (error) {
-        const rollbackHints = [];
-        if (safetyStashRef) {
-            const recoveryHints = await restoreForfeitSafetySnapshot(cwd, keiyakuBranch, safetyStashRef);
-            rollbackHints.push(...recoveryHints);
-        }
-        else {
-            try {
-                await checkoutBranch(cwd, keiyakuBranch);
-            }
-            catch (checkoutError) {
-                const checkoutFailure = checkoutError instanceof Error ? checkoutError.message : String(checkoutError);
-                rollbackHints.push(buildForfeitReturnBranchFailureHint(keiyakuBranch, checkoutFailure));
-            }
-        }
-        const wrappedError = wrapFlowError(`execute FORFEIT (${keiyakuBranch} -> ${baseBranch})`, error);
-        if (rollbackHints.length > 0) {
-            throw new FlowError("INTERNAL_STATE", wrappedError.message, {
-                cause: wrappedError,
-                hints: rollbackHints,
-            });
-        }
-        throw wrappedError;
-    }
-    return {
-        status: "success",
-        result: "dropped",
-        round,
-        currentBranch: baseBranch,
-        baseBranch,
-        deletedBranch: keiyakuBranch,
-        archiveTag,
-        ledgerView,
-        diff: droppedChanges.length > 0
-            ? `Forfeited without merge. Dropped ${droppedChanges.length} local change(s).`
-            : "Forfeited without merge.",
-        droppedChanges,
-    };
-}