@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/core/renew.js

@@ -1,19 +1,19 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { FlowError } from "../flow-error.js";
-import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../git/core.js";
-import { KEIYAKU_FILE } from "../keiyaku.js";
-import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
-import { readProjectionStatusBoard } from "./projection-status.js";
-import { renderContractView } from "./contract-view.js";
-import { captureSeal, findOpenArc, getMaxArc, receiptsAfterFence, sealCurrentArc } from "./seal.js";
+import { asMessage, FlowError } from "../flow-error.js";
+import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, parseRevListOutput, runGitProcess, wrapGitError } from "../git/core.js";
+import { readLedger } from "./ledger.js";
+import { hasStrandableProjectionGeneration } from "./projection/index.js";
+import { refreshContractView } from "./contract-view.js";
+import { appendRenewSettlement, captureRenewSeal, captureSeal, findOpenArc, getFence, getMaxArc, receiptsAfterFence } from "./seal.js";
 import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 import { commissionTarget, latestBase } from "./status/drift.js";
-import { findContractWorktreePath } from "./worktree-path.js";
+import { findContractWorktreePath, findRegisteredContractWorktreePath, stableRepoRoot } from "./worktree-path.js";
 import { getCurrentBranch, requireGitRepository } from "../git/branches.js";
+import { assertCleanTrackedWorkingTree, getUnmergedPaths, hasActiveRebase } from "../git/worktree.js";
+import { createRecoveryRef, deleteRecoveryRef } from "../git/refs.js";
 import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
 import { ACTOR_IDENTITY } from "../keiyaku.js";
 import { persistResponseHistory } from "./transcripts.js";
+import { convergeRenewRecoverySession, readRenewRecoverySession, removeRenewRecoverySession, writeRenewRecoverySession, } from "./renew-session.js";
 function assertOperable(contractId, entries) {
     const state = deriveContractState(entries);
     if (state.state === "corrupt") {
@@ -43,15 +43,14 @@ async function resolveCommitOrNull(cwd, rev) {
         throw wrapGitError(`rev-parse ${rev}`, error, cwd);
     }
 }
-async function renderUpdatedContract(ledgerCwd, renderCwd, contractId) {
-    const ledger = await readLedger(ledgerCwd, contractId);
-    if (!ledger) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} active ledger disappeared before render`);
-    }
-    await fs.writeFile(path.join(renderCwd, KEIYAKU_FILE), renderContractView({ id: contractId, entries: ledger.entries }), "utf8");
+const RENEW_RECOVERY_REF_PREFIX = "refs/keiyaku/recovery/renew";
+function renewRecoveryRef(contractId, oldHead) {
+    return `${RENEW_RECOVERY_REF_PREFIX}/${contractId}/${oldHead}`;
 }
-async function rewriteBranch(cwd, newBase, oldBase, branch) {
+async function rewriteBranch(input) {
+    const { cwd, contractId, oldHead, recoveryRef, newBase, oldBase, branch, preserveConflict } = input;
     const git = createGit(cwd);
+    const originalBranch = branch ? await getCurrentBranch(cwd) : undefined;
     const args = branch
         ? ["rebase", "--onto", newBase, oldBase, branch]
         : ["rebase", "--onto", newBase, oldBase];
@@ -59,31 +58,155 @@ async function rewriteBranch(cwd, newBase, oldBase, branch) {
         await git.raw(args);
     }
     catch (error) {
+        const isConflict = errorContainsAnyPattern(error, ["CONFLICT", "could not apply", "Resolve all conflicts manually"]);
+        let conflictPaths = [];
+        let conflictPathDiagnostic;
+        if (isConflict) {
+            try {
+                conflictPaths = await getUnmergedPaths(cwd);
+            }
+            catch (captureError) {
+                conflictPathDiagnostic = asMessage(captureError);
+            }
+        }
+        if (isConflict && preserveConflict) {
+            throw new FlowError("RENEW_SESSION_OPEN", `renew recovery session is open for ${contractId}`, {
+                cause: error,
+                facts: { kind: "renew_session", commission: contractId, nextAction: "resolve-conflicts" },
+            });
+        }
         try {
             await git.raw(["rebase", "--abort"]);
         }
-        catch {
-            // Preserve the rewrite failure after best-effort restoration.
+        catch (abortError) {
+            throw wrapGitError("rebase --abort", abortError, cwd);
         }
-        if (errorContainsAnyPattern(error, ["CONFLICT", "could not apply", "Resolve all conflicts manually"])) {
-            throw new FlowError("CLOSE_MERGE_CONFLICT", "renew conflict; working tree restored", { cause: error });
+        if (originalBranch && originalBranch !== branch) {
+            try {
+                await git.raw(["switch", originalBranch]);
+            }
+            catch (switchError) {
+                throw wrapGitError(`switch ${originalBranch}`, switchError, cwd);
+            }
+        }
+        if (isConflict) {
+            const restoredHead = await resolveCommit(cwd, `keiyaku/${contractId}`);
+            if (restoredHead !== oldHead) {
+                throw new FlowError("INTERNAL_STATE", `renew abort did not restore keiyaku/${contractId}: expected ${oldHead}, found ${restoredHead}`);
+            }
+            await assertCleanTrackedWorkingTree(cwd);
+            throw new FlowError("CLOSE_MERGE_CONFLICT", "renew conflict", {
+                cause: error,
+                facts: {
+                    kind: "renew_conflict",
+                    contractId,
+                    oldHead,
+                    recoveryRef,
+                    conflictPaths,
+                    conflictPathCapture: conflictPathDiagnostic
+                        ? { status: "failed", diagnostic: conflictPathDiagnostic }
+                        : { status: "captured" },
+                    workspaceRestored: true,
+                    ledgerWrites: false,
+                },
+            });
         }
         throw wrapGitError(`renew ${branch ?? "current branch"}`, error, cwd);
     }
 }
-function assertNoInFlightProjection(cwd, contractId, nowMs) {
-    const board = readProjectionStatusBoard(cwd, nowMs);
-    const unsafe = new Set(["out", "minting", "startup-timeout", "unknown"]);
-    if (!board?.rows.some((row) => unsafe.has(row.state)))
+async function assertNoInFlightProjection(repositoryRoot, contractId, deliveryWorktree, nowMs) {
+    if (!await hasStrandableProjectionGeneration({
+        cwd: repositoryRoot,
+        commissionId: contractId,
+        deliveryWorktree,
+        nowMs,
+    }))
         return;
-    throw new FlowError("INTERNAL_STATE", `akuma still out on ${contractId}'s worktree; rewriting under it would strand its work`, { hints: ["keiyaku status — watch for the akuma to land, then renew"] });
+    throw new FlowError("INTERNAL_STATE", `akuma still out on ${contractId}'s worktree; rewriting under it would strand its work`, { facts: { kind: "projection_in_flight", contractId } });
 }
 function looseCommitError(contractId, receipts) {
-    return new FlowError("NO_OPEN_ARC", `${receipts.length} commits after fence have no arc to receipt them`, {
-        hints: [`keiyaku @${contractId} arc — opens a new arc to receipt them, then renew`],
+    return new FlowError("NO_OPEN_ARC", `${receipts.length} commits after fence have no arc to receipt them`, { facts: { kind: "loose_commits", contractId, nextVerb: "renew" } });
+}
+async function mergeBase(cwd, left, right) {
+    const git = createGit(cwd);
+    try {
+        return (await git.raw(["merge-base", left, right])).trim();
+    }
+    catch (error) {
+        throw wrapGitError(`merge-base ${left} ${right}`, error, cwd);
+    }
+}
+async function assertRenewCoordinates(input) {
+    const fence = getFence(input.entries);
+    let branchBase;
+    let fenceBase;
+    try {
+        [branchBase, fenceBase] = await Promise.all([
+            mergeBase(input.cwd, input.oldHead, input.targetHead),
+            mergeBase(input.cwd, fence, input.oldHead),
+        ]);
+    }
+    catch (error) {
+        throw new FlowError("RENEW_COORDINATE_DRIFT", `renew coordinates for ${input.contractId} are detached from the ledger`, {
+            cause: error,
+            facts: { kind: "renew_coordinate_drift", commission: input.contractId, oldBase: input.oldBase, oldHead: input.oldHead, fence, targetHead: input.targetHead },
+        });
+    }
+    if (branchBase === input.oldBase && fenceBase === fence)
+        return;
+    throw new FlowError("RENEW_COORDINATE_DRIFT", `renew coordinates for ${input.contractId} drifted from the ledger before scope audit`, {
+        facts: { kind: "renew_coordinate_drift", commission: input.contractId, oldBase: input.oldBase, oldHead: input.oldHead, fence, targetHead: input.targetHead },
+    });
+}
+async function finishRenew(input) {
+    const capture = input.capture === undefined
+        ? await captureSeal(input.repositoryRoot, input.entries, input.oldHead, input.waivePaths)
+        : input.capture;
+    const settlement = await appendRenewSettlement({
+        cwd: input.repositoryRoot,
+        contractId: input.contractId,
+        expectedLedgerHead: input.ledgerHead,
+        capture,
+        oldBase: input.oldBase,
+        newBase: input.newBase,
+        oldHead: input.oldHead,
+        newHead: input.newHead,
+        actor: input.actor,
+        nowMs: input.nowMs,
+    });
+    await input.afterLedgerCas?.();
+    await refreshContractView({
+        ledgerCwd: input.repositoryRoot,
+        renderCwd: input.rewriteCwd,
+        contractId: input.contractId,
     });
+    const recoveryCleanup = await deleteRecoveryRef(input.repositoryRoot, input.recoveryRef, input.oldHead);
+    await removeRenewRecoverySession(input.repositoryRoot, input.contractId);
+    return {
+        contractId: input.contractId,
+        oldBase: input.oldBase,
+        newBase: input.newBase,
+        oldHead: input.oldHead,
+        newHead: input.newHead,
+        ledgerHead: settlement.ledgerHead,
+        alreadyFresh: false,
+        sealed: settlement.sealed,
+        recoveryCleanup,
+    };
 }
 export async function renewContract(input) {
+    const repositoryRoot = await stableRepoRoot(input.cwd);
+    const worktreePath = await findContractWorktreePath(repositoryRoot, input.contractId);
+    const rewriteCwd = worktreePath ?? input.cwd;
+    if (await readRenewRecoverySession(repositoryRoot, input.contractId)) {
+        throw new FlowError("RENEW_SESSION_OPEN", `renew recovery session is open for ${input.contractId}`, {
+            facts: { kind: "renew_session", commission: input.contractId, nextAction: "continue-or-abort" },
+        });
+    }
+    if (input.resolveConflicts && !worktreePath) {
+        throw new FlowError("INTERNAL_STATE", `renew --resolve requires ${input.contractId}'s registered contract worktree`);
+    }
+    await assertCleanTrackedWorkingTree(rewriteCwd);
     const ledger = await readLedger(input.cwd, input.contractId);
     if (!ledger) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found or not active`);
@@ -102,6 +225,14 @@ export async function renewContract(input) {
         throw new FlowError("INTERNAL_STATE", "ledger must contain bind entry");
     const branch = `keiyaku/${input.contractId}`;
     const oldHead = await resolveCommit(input.cwd, branch);
+    await assertRenewCoordinates({
+        cwd: repositoryRoot,
+        contractId: input.contractId,
+        oldBase,
+        oldHead,
+        targetHead,
+        entries: ledger.entries,
+    });
     const capture = await captureSeal(input.cwd, ledger.entries, oldHead, input.waivePaths);
     if (getMaxArc(ledger.entries) > 0 && !findOpenArc(ledger.entries)) {
         const loose = await receiptsAfterFence(input.cwd, ledger.entries, oldHead);
@@ -118,51 +249,216 @@ export async function renewContract(input) {
             ledgerHead: ledger.head,
             alreadyFresh: true,
             sealed: null,
+            recoveryCleanup: null,
         };
     }
-    const worktreePath = await findContractWorktreePath(input.cwd, input.contractId);
-    const rewriteCwd = worktreePath ?? input.cwd;
-    assertNoInFlightProjection(rewriteCwd, input.contractId, input.nowMs);
-    await rewriteBranch(rewriteCwd, targetHead, oldBase, worktreePath ? undefined : branch);
-    const newHead = await resolveCommit(input.cwd, branch);
-    const sealed = await sealCurrentArc({
-        cwd: input.cwd,
-        renderCwd: rewriteCwd,
-        contractId: input.contractId,
-        sealedBy: "renew",
-        nowMs: input.nowMs,
-        capture: capture ? { ...capture, newFence: newHead } : null,
-    });
-    const at = new Date(input.nowMs).toISOString();
-    const result = await appendWithRetry(input.cwd, activeLedgerRef(input.contractId), (_head, entries) => {
-        assertOperable(input.contractId, entries);
-        if (latestBase(entries) !== oldBase) {
-            throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} changed while renewing`);
+    const deliveryWorktree = worktreePath ?? repositoryRoot;
+    await assertNoInFlightProjection(repositoryRoot, input.contractId, deliveryWorktree, input.nowMs);
+    const recoveryRef = renewRecoveryRef(input.contractId, oldHead);
+    await createRecoveryRef(input.cwd, recoveryRef, oldHead);
+    if (input.resolveConflicts) {
+        await writeRenewRecoverySession(repositoryRoot, {
+            commission: input.contractId,
+            oldBase,
+            oldHead,
+            newBase: targetHead,
+            recoveryRef,
+        });
+    }
+    try {
+        await rewriteBranch({
+            cwd: rewriteCwd,
+            contractId: input.contractId,
+            oldHead,
+            recoveryRef,
+            newBase: targetHead,
+            oldBase,
+            branch: worktreePath ? undefined : branch,
+            preserveConflict: input.resolveConflicts,
+        });
+    }
+    catch (error) {
+        if (input.resolveConflicts && !(error instanceof FlowError && error.code === "RENEW_SESSION_OPEN")) {
+            await removeRenewRecoverySession(repositoryRoot, input.contractId);
         }
-        return {
-            v: 1,
-            kind: "renew",
-            contract: input.contractId,
-            at,
-            actor: input.actor,
-            data: { oldBase, newBase: targetHead, oldHead, newHead },
-        };
-    });
-    if (!result.ok) {
-        throw new FlowError("INTERNAL_STATE", `failed to append renew for ${input.contractId}: ${result.reason}`);
+        throw error;
     }
-    await renderUpdatedContract(input.cwd, rewriteCwd, input.contractId);
-    return {
+    const newHead = await resolveCommit(input.cwd, branch);
+    return await finishRenew({
+        repositoryRoot,
+        rewriteCwd,
+        ledgerHead: ledger.head,
+        entries: ledger.entries,
         contractId: input.contractId,
         oldBase,
-        newBase: targetHead,
         oldHead,
+        newBase: targetHead,
         newHead,
-        ledgerHead: result.head,
+        recoveryRef,
+        actor: input.actor,
+        nowMs: input.nowMs,
+        capture,
+        afterLedgerCas: input.afterLedgerCas,
+    });
+}
+async function revListRange(cwd, range) {
+    const git = createGit(cwd);
+    try {
+        return parseRevListOutput(await git.raw(["rev-list", "--reverse", range]));
+    }
+    catch (error) {
+        throw wrapGitError(`rev-list ${range}`, error, cwd);
+    }
+}
+async function assertRecoveryFacts(repositoryRoot, contractId, session) {
+    if (session.commission !== contractId) {
+        throw new FlowError("INTERNAL_STATE", `renew recovery session belongs to ${session.commission}, not ${contractId}`);
+    }
+    const rewriteCwd = await findRegisteredContractWorktreePath(repositoryRoot, contractId);
+    if (!rewriteCwd)
+        throw new FlowError("INTERNAL_STATE", `registered contract worktree disappeared for ${contractId}`);
+    const ledger = await readLedger(repositoryRoot, contractId);
+    if (!ledger)
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} not found or not active`);
+    const savedHead = await resolveCommit(repositoryRoot, session.recoveryRef);
+    if (savedHead !== session.oldHead || latestBase(ledger.entries) !== session.oldBase) {
+        throw new FlowError("RENEW_SESSION_OPEN", `renew recovery session facts no longer match the owned rewrite for ${contractId}`, {
+            facts: { kind: "renew_session", commission: contractId, nextAction: "abort" },
+        });
+    }
+    return { ledger, rewriteCwd };
+}
+async function resultFromSpentSession(repositoryRoot, spent) {
+    const seal = spent.seal;
+    const sealed = seal ? {
+        ...seal.data,
+        scopeViolationEvidence: [],
+        ledgerHead: await resolveCommit(repositoryRoot, `${spent.ledger.head}^`),
+    } : null;
+    return {
+        contractId: spent.session.commission,
+        ...spent.renew.data,
+        ledgerHead: spent.ledger.head,
         alreadyFresh: false,
         sealed,
+        recoveryCleanup: spent.recoveryCleanup,
     };
 }
+export async function continueRenewContract(input) {
+    const repositoryRoot = await stableRepoRoot(input.cwd);
+    const sessionState = await convergeRenewRecoverySession(repositoryRoot, input.contractId);
+    if (sessionState.state === "spent")
+        return await resultFromSpentSession(repositoryRoot, sessionState);
+    if (sessionState.state === "none") {
+        throw new FlowError("RENEW_SESSION_NOT_FOUND", `no renew recovery session is open for ${input.contractId}`);
+    }
+    const session = sessionState.session;
+    const { ledger, rewriteCwd } = await assertRecoveryFacts(repositoryRoot, input.contractId, session);
+    const delivery = await revListRange(repositoryRoot, `${session.oldBase}..${session.oldHead}`);
+    if (await hasActiveRebase(rewriteCwd)) {
+        const stoppedAt = await resolveCommitOrNull(rewriteCwd, "REBASE_HEAD");
+        if (!stoppedAt) {
+            throw new FlowError("RENEW_SESSION_OPEN", `owned rebase state has no stopped receipt for ${input.contractId}`, {
+                facts: { kind: "renew_session", commission: input.contractId, nextAction: "abort" },
+            });
+        }
+        const stoppedIndex = delivery.indexOf(stoppedAt);
+        const rewrittenPrefix = await revListRange(rewriteCwd, `${session.newBase}..HEAD`);
+        if (stoppedIndex < 0 || rewrittenPrefix.length !== stoppedIndex) {
+            throw new FlowError("RENEW_SESSION_OPEN", `loose commits do not belong to the owned renew rebase for ${input.contractId}`, {
+                facts: { kind: "renew_session", commission: input.contractId, nextAction: "continue-or-abort" },
+            });
+        }
+        const continued = await runGitProcess(rewriteCwd, ["rebase", "--continue"], {
+            env: { GIT_EDITOR: "true" },
+        });
+        if (continued.status !== 0) {
+            const error = continued.error ?? { message: "git rebase --continue failed", stderr: continued.stderr, stdout: continued.stdout };
+            if (errorContainsAnyPattern(error, ["CONFLICT", "could not apply", "Resolve all conflicts manually"])) {
+                throw new FlowError("RENEW_SESSION_OPEN", `renew recovery session is open for ${input.contractId}`, {
+                    cause: error,
+                    facts: { kind: "renew_session", commission: input.contractId, nextAction: "resolve-conflicts" },
+                });
+            }
+            throw wrapGitError("rebase --continue", error, rewriteCwd);
+        }
+    }
+    const newHead = await resolveCommit(repositoryRoot, `keiyaku/${input.contractId}`);
+    const rewritten = await revListRange(repositoryRoot, `${session.newBase}..${newHead}`);
+    if (await mergeBase(repositoryRoot, session.newBase, newHead) !== session.newBase || rewritten.length !== delivery.length) {
+        throw new FlowError("RENEW_SESSION_OPEN", `rewritten delivery no longer corresponds to the saved renew receipts for ${input.contractId}`, {
+            facts: { kind: "renew_session", commission: input.contractId, nextAction: "abort" },
+        });
+    }
+    const capture = await captureRenewSeal({
+        cwd: repositoryRoot,
+        entries: ledger.entries,
+        receiptHead: session.oldHead,
+        contentBase: session.newBase,
+        contentHead: newHead,
+        waivePaths: input.waivePaths,
+    });
+    return await finishRenew({
+        repositoryRoot,
+        rewriteCwd,
+        ledgerHead: ledger.head,
+        entries: ledger.entries,
+        contractId: input.contractId,
+        oldBase: session.oldBase,
+        oldHead: session.oldHead,
+        newBase: session.newBase,
+        newHead,
+        recoveryRef: session.recoveryRef,
+        actor: input.actor,
+        nowMs: input.nowMs,
+        capture,
+        afterLedgerCas: input.afterLedgerCas,
+    });
+}
+export async function abortRenewContract(input) {
+    const repositoryRoot = await stableRepoRoot(input.cwd);
+    const sessionState = await convergeRenewRecoverySession(repositoryRoot, input.contractId);
+    if (sessionState.state !== "live") {
+        throw new FlowError("RENEW_SESSION_NOT_FOUND", `no renew recovery session is open for ${input.contractId}`);
+    }
+    const session = sessionState.session;
+    const { rewriteCwd } = await assertRecoveryFacts(repositoryRoot, input.contractId, session);
+    const git = createGit(rewriteCwd);
+    if (await hasActiveRebase(rewriteCwd)) {
+        try {
+            await git.raw(["rebase", "--abort"]);
+        }
+        catch (error) {
+            throw wrapGitError("rebase --abort", error, rewriteCwd);
+        }
+    }
+    let branch;
+    try {
+        branch = (await git.raw(["symbolic-ref", "--quiet", "--short", "HEAD"])).trim();
+    }
+    catch {
+        branch = undefined;
+    }
+    const expectedBranch = `keiyaku/${input.contractId}`;
+    if (branch !== expectedBranch) {
+        try {
+            await git.raw(["switch", expectedBranch]);
+        }
+        catch (error) {
+            throw wrapGitError(`switch ${expectedBranch}`, error, rewriteCwd);
+        }
+    }
+    try {
+        await git.raw(["reset", "--hard", session.oldHead]);
+    }
+    catch (error) {
+        throw wrapGitError(`reset --hard ${session.recoveryRef}`, error, rewriteCwd);
+    }
+    await assertCleanTrackedWorkingTree(rewriteCwd);
+    await removeRenewRecoverySession(repositoryRoot, input.contractId);
+    const recoveryCleanup = await deleteRecoveryRef(repositoryRoot, session.recoveryRef, session.oldHead);
+    return { contractId: input.contractId, oldHead: session.oldHead, recoveryCleanup };
+}
 export async function renewKeiyaku(input) {
     await requireGitRepository(input.cwd, "renew");
     const address = input.address ?? await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
@@ -174,47 +470,78 @@ export async function renewKeiyaku(input) {
             actor: ACTOR_IDENTITY,
             nowMs: Date.now(),
             waivePaths: input.waivePaths,
+            resolveConflicts: input.resolveConflicts,
         });
-        const currentBranch = await getCurrentBranch(input.cwd);
-        const baseBranch = address.target.branch.slice("refs/heads/".length);
-        const diff = renewed.sealed?.incrementalDiff ?? "nothing sealed";
-        const summary = renewed.alreadyFresh
-            ? `Contract ${contractId} is already fresh; nothing touched.`
-            : `Contract ${contractId} renewed onto ${renewed.newBase}.`;
-        let responsePath;
-        let artifactId;
-        try {
-            const persisted = await persistResponseHistory({
-                cwd: input.cwd,
-                tool: "renew",
-                provenance: { authority: { kind: "repository" }, binding: address.binding, evidenceCwd: input.cwd },
-                title: contractId,
-                oldBase: renewed.oldBase,
-                newBase: renewed.newBase,
-                oldHead: renewed.oldHead,
-                newHead: renewed.newHead,
-                ledgerCommit: renewed.ledgerHead,
-                summary,
-                diff,
-                ...(renewed.sealed ? { sealed: renewed.sealed } : {}),
-            });
-            responsePath = persisted.responsePath;
-            artifactId = persisted.artifactId;
-        }
-        catch {
-            responsePath = undefined;
-        }
+        return await buildRenewOutcome(input.cwd, address, renewed);
+    });
+}
+async function buildRenewOutcome(cwd, address, renewed) {
+    const contractId = address.binding.commissionId;
+    const currentBranch = await getCurrentBranch(cwd);
+    const baseBranch = address.target.branch.slice("refs/heads/".length);
+    const summary = renewed.alreadyFresh
+        ? `Contract ${contractId} is already fresh; nothing touched.`
+        : `Contract ${contractId} renewed onto ${renewed.newBase}.`;
+    const cleanupWarnings = renewed.recoveryCleanup?.status === "retained"
+        ? [`Renew succeeded, but recovery ref ${renewed.recoveryCleanup.ref} was retained: ${renewed.recoveryCleanup.diagnostic}`]
+        : [];
+    let responsePath;
+    let artifactId;
+    try {
+        const persisted = await persistResponseHistory({
+            cwd,
+            tool: "renew",
+            provenance: { authority: { kind: "repository" }, binding: address.binding, evidenceCwd: cwd },
+            title: contractId,
+            oldBase: renewed.oldBase,
+            newBase: renewed.newBase,
+            oldHead: renewed.oldHead,
+            newHead: renewed.newHead,
+            ledgerCommit: renewed.ledgerHead,
+            summary,
+            emptyDiffLabel: "nothing sealed",
+            ...(renewed.sealed ? { sealed: renewed.sealed } : {}),
+        });
+        responsePath = persisted.responsePath;
+        artifactId = persisted.artifactId;
+    }
+    catch {
+        responsePath = undefined;
+    }
+    return {
+        status: "success",
+        ...renewed,
+        currentBranch,
+        baseBranch,
+        // CLI/render synthesizes public face bytes from sealed typed facts.
+        diff: "",
+        sealed: renewed.sealed ?? undefined,
+        summary,
+        ...(cleanupWarnings.length > 0 ? { meta: { warnings: cleanupWarnings } } : {}),
+        responsePath,
+        artifactId,
+        address,
+    };
+}
+export async function continueRenewKeiyaku(input) {
+    await requireGitRepository(input.cwd, "renew --continue");
+    return await withResolvedAddress(input.address, async () => buildRenewOutcome(input.cwd, input.address, await continueRenewContract({
+        cwd: input.cwd,
+        contractId: input.address.binding.commissionId,
+        actor: ACTOR_IDENTITY,
+        nowMs: Date.now(),
+        waivePaths: input.waivePaths,
+    })));
+}
+export async function abortRenewKeiyaku(input) {
+    await requireGitRepository(input.cwd, "renew --abort");
+    return await withResolvedAddress(input.address, async () => {
+        const result = await abortRenewContract({ cwd: input.cwd, contractId: input.address.binding.commissionId });
         return {
             status: "success",
-            ...renewed,
-            currentBranch,
-            baseBranch,
-            diff,
-            sealed: renewed.sealed ?? undefined,
-            summary,
-            responsePath,
-            artifactId,
-            address,
+            ...result,
+            address: input.address,
+            summary: `Renew recovery for ${result.contractId} aborted; delivery restored to ${result.oldHead}.`,
         };
     });
 }