@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/renew.js

@@ -1,566 +1,341 @@
-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, appendScopeTerms, 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, findRegisteredContractWorktreePath, stableRepoRoot } from "./worktree-path.js";
+import { FlowError } from "../flow-error.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 { resolveContractAddress, withResolvedAddress } from "./addressing.js";
+import { withContractCarrierSession } from "./contract-carrier.js";
+import { runLifecycle } from "./lifecycle-runner.js";
+import { committedLifecycleFacts, derivedCleanupFacts, isCompleteLifecycleOutcome, } from "./outcome-base.js";
+import { abortDetachedRenewChain, readDetachedRenewScratch, renewScratchName, } from "./renew-rewrite.js";
 import { persistResponseHistory } from "./transcripts.js";
-import { convergeRenewRecoverySession, assertNoRenewRecoverySession, removeRenewRecoverySession, writeRenewRecoverySession, } from "./renew-session.js";
-function assertOperable(contractId, entries) {
-    const state = deriveContractState(entries);
-    if (state.state === "corrupt") {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is corrupt at entry ${state.at}: ${state.reason}`);
-    }
-    if (isTerminalState(state) || state.state === "petitioned") {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot renew from state ${state.state}`);
-    }
-}
-async function resolveCommit(cwd, rev) {
-    const git = createGit(cwd);
-    try {
-        return (await git.raw(["rev-parse", "--verify", `${rev}^{commit}`])).trim();
-    }
-    catch (error) {
-        throw wrapGitError(`rev-parse ${rev}`, error, cwd);
-    }
-}
-async function resolveCommitOrNull(cwd, rev) {
-    const git = createGit(cwd);
-    try {
-        return (await git.raw(["rev-parse", "--verify", `${rev}^{commit}`])).trim();
-    }
-    catch (error) {
-        if (errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS))
-            return null;
-        throw wrapGitError(`rev-parse ${rev}`, error, cwd);
+import { admitRenew, checkCancellation, prepareRenew, sameAdmission, scopeEntry } from "./renew-plan.js";
+async function persistRenewResponse(journal, facts, persist) {
+    if (!persist)
+        return;
+    let response;
+    await journal.run({
+        effect: "response-history-persistence",
+        idempotencyKey: `${facts.contractId}:${facts.ledgerHead}:response-history-persistence`,
+        run: async () => { response = await persist(facts); return response; },
+    });
+    if (response) {
+        facts.responsePath = response.responsePath;
+        facts.artifactId = response.artifactId;
     }
 }
-const RENEW_RECOVERY_REF_PREFIX = "refs/keiyaku/recovery/renew";
-function renewRecoveryRef(contractId, oldHead) {
-    return `${RENEW_RECOVERY_REF_PREFIX}/${contractId}/${oldHead}`;
-}
-export async function rewriteRenewBranch(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];
-    try {
-        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);
+async function executeRenew(input, continuation) {
+    const execution = await runLifecycle({
+        cwd: input.cwd,
+        contractId: input.contractId,
+        mutation: {
+            verb: "renew",
+            matchesAccepted: (transaction) => {
+                const accepted = transaction.entries.at(-1);
+                const expectedAmend = scopeEntry(input);
+                if (accepted?.kind === "amend") {
+                    return transaction.entries.length === 1
+                        && expectedAmend !== null
+                        && accepted.data.amendment === expectedAmend.data.amendment
+                        && JSON.stringify(accepted.data.scopeDelta ?? null) === JSON.stringify(expectedAmend.data.scopeDelta ?? null);
+                }
+                if (accepted?.kind !== "renew")
+                    return false;
+                const acceptedAmend = transaction.entries.find((entry) => entry.kind === "amend");
+                return JSON.stringify(acceptedAmend?.kind === "amend" ? acceptedAmend.data.scopeDelta ?? null : null)
+                    === JSON.stringify(expectedAmend?.data.scopeDelta ?? null);
+            },
+        },
+        signal: input.signal,
+        ...(input.renewDeliveryProjector ? { renewDeliveryProjector: input.renewDeliveryProjector } : {}),
+        admit: (session, replay) => admitRenew(session, input, replay, continuation?.scratch),
+        prepare: (admission) => prepareRenew(admission.business, input, continuation),
+        revalidate: async ({ session, admission }) => {
+            const current = await admitRenew(session, input, admission.replay, continuation?.scratch);
+            if (!sameAdmission(current, admission.business)) {
+                return { code: "RENEW_COORDINATES_CHANGED", message: "renew coordinates changed during detached construction" };
             }
-            catch (captureError) {
-                conflictPathDiagnostic = asMessage(captureError);
+        },
+        effect: async ({ context, admission, prepared }) => {
+            if (admission.business.acceptedScopeReplay) {
+                const accepted = admission.business.acceptedScopeReplay;
+                const replayed = await context.replayCommitted({ transactionObjectId: accepted.transactionObjectId });
+                const value = {
+                    ...committedLifecycleFacts({ head: accepted.transactionObjectId, entryKind: "amend", contractId: input.contractId, carrier: replayed.carrier }),
+                    contractId: input.contractId,
+                    oldBase: admission.business.oldBase,
+                    newBase: admission.business.newBase,
+                    oldHead: admission.business.oldHead,
+                    newHead: admission.business.oldHead,
+                    ledgerHead: accepted.transactionObjectId,
+                    alreadyFresh: true,
+                    sealOid: null,
+                    renewOid: null,
+                    sealed: null,
+                    carrier: replayed.carrier,
+                    targetRoot: admission.business.targetRoot,
+                };
+                await persistRenewResponse(context.journal, value, input.persistResponse);
+                return { kind: "committed", commit: replayed, entryKind: "amend", value };
             }
-        }
-        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 (abortError) {
-            throw wrapGitError("rebase --abort", abortError, cwd);
-        }
-        if (originalBranch && originalBranch !== branch) {
-            try {
-                await git.raw(["switch", originalBranch]);
+            if (admission.business.acceptedReplay) {
+                const accepted = admission.business.acceptedReplay;
+                const replayed = await context.replayCommitted({ transactionObjectId: accepted.transactionObjectId });
+                const sealed = { ...accepted.seal.data, scopeViolationEvidence: [], ledgerHead: accepted.sealObjectId };
+                const value = {
+                    ...committedLifecycleFacts({ head: accepted.transactionObjectId, entryKind: "renew", contractId: input.contractId, carrier: replayed.carrier }),
+                    contractId: input.contractId,
+                    oldBase: accepted.entry.data.oldBase,
+                    newBase: accepted.entry.data.newBase,
+                    oldHead: accepted.entry.data.oldHead,
+                    newHead: accepted.entry.data.newHead,
+                    ledgerHead: accepted.transactionObjectId,
+                    alreadyFresh: false,
+                    sealOid: accepted.sealObjectId,
+                    renewOid: accepted.renewObjectId,
+                    sealed,
+                    carrier: replayed.carrier,
+                    targetRoot: admission.business.targetRoot,
+                };
+                if (continuation) {
+                    await context.journal.run({
+                        effect: "renew-scratch-cleanup",
+                        idempotencyKey: `${input.contractId}:${accepted.transactionObjectId}:renew-scratch-cleanup`,
+                        run: async () => abortDetachedRenewChain({ cwd: input.cwd, scratchName: continuation.scratch.scratchName }),
+                    });
+                }
+                await persistRenewResponse(context.journal, value, input.persistResponse);
+                return { kind: "committed", commit: replayed, entryKind: "renew", value };
             }
-            catch (switchError) {
-                throw wrapGitError(`switch ${originalBranch}`, switchError, cwd);
+            if (prepared.build?.status === "conflict") {
+                const conflict = prepared.build;
+                context.beginEffects();
+                context.journal.record({
+                    effect: "renew-conflict-scratch",
+                    idempotencyKey: `${input.contractId}:${admission.ledgerHead}:renew-conflict-scratch:${conflict.scratchName}`,
+                    status: "failed",
+                    cause: {
+                        code: "CLOSE_MERGE_CONFLICT",
+                        message: `renew conflict for ${input.contractId}`,
+                        facts: {
+                            kind: "renew_conflict_scratch",
+                            contractId: input.contractId,
+                            scratchName: conflict.scratchName,
+                            scratchPath: conflict.scratchPath,
+                            observedLedgerHead: admission.ledgerHead,
+                            deliveryRef: admission.business.deliveryRef,
+                            targetRef: admission.business.targetRef,
+                            oldBase: admission.business.oldBase,
+                            oldHead: admission.business.oldHead,
+                            newBase: admission.business.newBase,
+                            effectiveScope: admission.business.effectiveScope,
+                            conflictCommit: conflict.conflictCommit,
+                            conflictPaths: [...conflict.conflictPaths],
+                            nextAction: "continue-or-abort",
+                            authoritativeRefsChanged: false,
+                        },
+                    },
+                });
+                return { kind: "precommit-effects-only", authoritativeHead: admission.ledgerHead };
             }
-        }
-        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}`);
+            if (admission.business.oldBase === admission.business.newBase) {
+                if (!admission.business.amendment) {
+                    const transactionObjectId = admission.replay.state === "verb-committed"
+                        ? admission.replay.transaction.transactionObjectId
+                        : admission.ledgerHead;
+                    const replayed = await context.replayCommitted({ transactionObjectId });
+                    const accepted = replayed.transaction.entries.at(-1);
+                    if (!accepted)
+                        throw new FlowError("INTERNAL_STATE", `transaction ${transactionObjectId} has no accepted lifecycle entry`);
+                    const value = {
+                        ...committedLifecycleFacts({ head: transactionObjectId, entryKind: accepted.kind, contractId: input.contractId, carrier: replayed.carrier }),
+                        contractId: input.contractId,
+                        oldBase: admission.business.oldBase,
+                        newBase: admission.business.newBase,
+                        oldHead: admission.business.oldHead,
+                        newHead: admission.business.oldHead,
+                        ledgerHead: transactionObjectId,
+                        alreadyFresh: true,
+                        sealOid: null,
+                        renewOid: null,
+                        sealed: null,
+                        carrier: replayed.carrier,
+                        targetRoot: admission.business.targetRoot,
+                    };
+                    await persistRenewResponse(context.journal, value, input.persistResponse);
+                    return { kind: "committed", commit: replayed, entryKind: accepted.kind, value };
+                }
+                const published = await context.publishAuthoritative({
+                    verb: "renew",
+                    admittedLedgerHead: admission.ledgerHead,
+                    acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId,
+                    entries: [admission.business.amendment],
+                });
+                if (published.status === "refused-before-effects")
+                    return { kind: "refused-before-effects", authoritativeHead: admission.ledgerHead, refusal: { code: "CONCURRENT_MODIFICATION", message: "repository ledger changed before scope amendment" } };
+                if (published.status === "indeterminate")
+                    return { kind: "precommit-effects-only", authoritativeHead: admission.ledgerHead };
+                const value = {
+                    ...committedLifecycleFacts({ head: published.head, entryKind: "amend", contractId: input.contractId, carrier: published.carrier }),
+                    contractId: input.contractId,
+                    oldBase: admission.business.oldBase,
+                    newBase: admission.business.newBase,
+                    oldHead: admission.business.oldHead,
+                    newHead: admission.business.oldHead,
+                    ledgerHead: published.head,
+                    alreadyFresh: true,
+                    sealOid: null,
+                    renewOid: null,
+                    sealed: null,
+                    carrier: published.carrier,
+                    targetRoot: admission.business.targetRoot,
+                };
+                await persistRenewResponse(context.journal, value, input.persistResponse);
+                return { kind: "committed", commit: published, entryKind: "amend", value };
             }
-            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,
+            if (!prepared.entry || prepared.build?.status !== "clean" || !prepared.capture)
+                throw new FlowError("INTERNAL_STATE", "renew detached build is incomplete");
+            const entries = prepared.prefix.length === 0
+                ? [prepared.entry]
+                : prepared.prefix[0].kind === "seal"
+                    ? [prepared.prefix[0], prepared.entry]
+                    : prepared.prefix.length === 1
+                        ? [prepared.entry]
+                        : [prepared.prefix[0], prepared.prefix[1], prepared.entry];
+            const published = await context.publishAuthoritative({
+                verb: "renew",
+                admittedLedgerHead: admission.ledgerHead,
+                acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId,
+                entries,
+                delivery: {
+                    ref: admission.business.deliveryRef,
+                    expectedOid: prepared.entry.data.oldHead,
                 },
             });
-        }
-        throw wrapGitError(`renew ${branch ?? "current branch"}`, error, cwd);
-    }
-}
-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`, { 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`, { 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.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,
+            if (published.status === "refused-before-effects")
+                return { kind: "refused-before-effects", authoritativeHead: admission.ledgerHead, refusal: { code: "CONCURRENT_MODIFICATION", message: "repository ledger or delivery ref changed before renew transaction" } };
+            if (published.status === "indeterminate")
+                return { kind: "precommit-effects-only", authoritativeHead: admission.ledgerHead };
+            const sealIndex = published.transaction.entries.findIndex((entry) => entry.kind === "seal");
+            const renewIndex = published.transaction.entries.findIndex((entry) => entry.kind === "renew");
+            const sealOid = sealIndex < 0 ? null : published.transaction.entryObjectIds[sealIndex];
+            const renewOid = renewIndex < 0 ? null : published.transaction.entryObjectIds[renewIndex];
+            const sealed = {
+                ...prepared.capture,
+                newFence: prepared.build.newHead,
+                sealedBy: "renew",
+                ledgerHead: sealOid,
+            };
+            const value = {
+                ...committedLifecycleFacts({ head: published.head, entryKind: "renew", contractId: input.contractId, carrier: published.carrier }),
+                contractId: input.contractId,
+                oldBase: admission.business.oldBase,
+                newBase: admission.business.newBase,
+                oldHead: admission.business.oldHead,
+                newHead: prepared.build.newHead,
+                ledgerHead: published.head,
+                alreadyFresh: false,
+                sealOid,
+                renewOid,
+                sealed,
+                carrier: published.carrier,
+                targetRoot: admission.business.targetRoot,
+            };
+            if (continuation) {
+                await context.journal.run({
+                    effect: "renew-scratch-cleanup",
+                    idempotencyKey: `${input.contractId}:${published.head}:renew-scratch-cleanup`,
+                    run: async () => abortDetachedRenewChain({ cwd: input.cwd, scratchName: continuation.scratch.scratchName }),
+                });
+            }
+            await persistRenewResponse(context.journal, value, input.persistResponse);
+            return { kind: "committed", commit: published, entryKind: "renew", value };
+        },
     });
-    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,
-    };
+    if (execution.kind === "noncommitted")
+        return execution.outcome;
+    if (execution.kind === "contained")
+        return { ...execution.outcome, contractId: input.contractId };
+    return { ...execution.payload, ...execution.outcome };
 }
 export async function renewContract(input) {
-    const repositoryRoot = await stableRepoRoot(input.cwd);
-    const worktreePath = await findContractWorktreePath(repositoryRoot, input.contractId);
-    const rewriteCwd = worktreePath ?? input.cwd;
-    await assertNoRenewRecoverySession(repositoryRoot, input.contractId);
-    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`);
-    }
-    assertOperable(input.contractId, ledger.entries);
-    const commission = commissionTarget(ledger.entries);
-    if (!commission) {
-        throw new FlowError("INTERNAL_STATE", `cannot renew ${input.contractId}: missing commission target`);
-    }
-    const targetHead = await resolveCommitOrNull(input.cwd, commission.ref);
-    if (!targetHead) {
-        throw new FlowError("INTERNAL_STATE", `cannot renew ${input.contractId}: commission target ${commission.ref} does not resolve`);
-    }
-    const oldBase = latestBase(ledger.entries);
-    if (!oldBase)
-        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,
-    });
-    if (getMaxArc(ledger.entries) > 0 && !findOpenArc(ledger.entries)) {
-        const loose = await receiptsAfterFence(input.cwd, ledger.entries, oldHead);
-        if (loose.length > 0)
-            throw looseCommitError(input.contractId, loose);
-    }
-    if (oldBase !== targetHead) {
-        const deliveryWorktree = worktreePath ?? repositoryRoot;
-        await assertNoInFlightProjection(repositoryRoot, input.contractId, deliveryWorktree, input.nowMs);
-    }
-    await appendScopeTerms({
-        cwd: repositoryRoot,
-        renderCwd: rewriteCwd,
-        contractId: input.contractId,
-        patterns: input.appendScope,
-        actor: input.actor,
-        nowMs: input.nowMs,
-    });
-    const currentLedger = input.appendScope?.length ? await readLedger(repositoryRoot, input.contractId) : ledger;
-    if (!currentLedger)
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} disappeared while appending scope`);
-    const capture = await captureSeal(input.cwd, currentLedger.entries, oldHead);
-    if (oldBase === targetHead) {
-        return {
-            contractId: input.contractId,
-            oldBase,
-            newBase: targetHead,
-            oldHead,
-            newHead: oldHead,
-            ledgerHead: currentLedger.head,
-            alreadyFresh: true,
-            sealed: null,
-            recoveryCleanup: null,
-        };
-    }
-    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 rewriteRenewBranch({
-            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);
-        }
-        throw error;
-    }
-    const newHead = await resolveCommit(input.cwd, branch);
-    return await finishRenew({
-        repositoryRoot,
-        rewriteCwd,
-        ledgerHead: currentLedger.head,
-        entries: currentLedger.entries,
-        contractId: input.contractId,
-        oldBase,
-        oldHead,
-        newBase: targetHead,
-        newHead,
-        recoveryRef,
-        actor: input.actor,
-        nowMs: input.nowMs,
-        capture,
-        afterLedgerCas: input.afterLedgerCas,
-    });
+    return executeRenew(input);
 }
-async function revListRange(cwd, range) {
-    const git = createGit(cwd);
+export async function continueRenewContract(input) {
+    const scratchName = renewScratchName(input.contractId);
+    let scratch;
     try {
-        return parseRevListOutput(await git.raw(["rev-list", "--reverse", range]));
+        scratch = await readDetachedRenewScratch({ cwd: input.cwd, scratchName });
     }
     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" },
-        });
+        throw new FlowError("RENEW_SCRATCH_NOT_FOUND", `no renew conflict scratch is open for ${input.contractId}`, { cause: error });
     }
-    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" },
-        });
-    }
-    await appendScopeTerms({
-        cwd: repositoryRoot,
-        renderCwd: rewriteCwd,
-        contractId: input.contractId,
-        patterns: input.appendScope,
-        actor: input.actor,
-        nowMs: input.nowMs,
-    });
-    const currentLedger = input.appendScope?.length ? await readLedger(repositoryRoot, input.contractId) : ledger;
-    if (!currentLedger)
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} disappeared while appending scope`);
-    const capture = await captureRenewSeal({
-        cwd: repositoryRoot,
-        entries: currentLedger.entries,
-        receiptHead: session.oldHead,
-        contentBase: session.newBase,
-        contentHead: newHead,
-    });
-    return await finishRenew({
-        repositoryRoot,
-        rewriteCwd,
-        ledgerHead: currentLedger.head,
-        entries: currentLedger.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,
-    });
+    return executeRenew(input, { scratch, resolution: input.resolution ?? { kind: "scratch-files" } });
 }
 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)) {
+    checkCancellation(input.signal);
+    return withContractCarrierSession({ cwd: input.cwd, contractId: input.contractId, mode: "observe-only", signal: input.signal }, async (session) => {
+        const scratchName = renewScratchName(input.contractId);
+        let scratch;
         try {
-            await git.raw(["rebase", "--abort"]);
+            scratch = await readDetachedRenewScratch({ cwd: input.cwd, scratchName });
         }
         catch (error) {
-            throw wrapGitError("rebase --abort", error, rewriteCwd);
+            throw new FlowError("RENEW_SCRATCH_NOT_FOUND", `no renew conflict scratch is open for ${input.contractId}`, { cause: error });
         }
-    }
-    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 };
+        checkCancellation(input.signal);
+        const cleanup = await abortDetachedRenewChain({ cwd: input.cwd, scratchName });
+        return {
+            ...derivedCleanupFacts({
+                contractId: input.contractId,
+                authoritativeHead: session.lifecycle.observedLedgerHead,
+                effect: "renew-conflict-scratch-cleanup",
+                receipt: { status: cleanup.status, scratchName, oldHead: scratch.oldHead },
+            }),
+            contractId: input.contractId,
+            oldHead: scratch.oldHead,
+            scratchName,
+            carrier: session.initialCarrier,
+        };
+    });
 }
 export async function renewKeiyaku(input) {
     await requireGitRepository(input.cwd, "renew");
     const address = input.address ?? await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
-    return await withResolvedAddress(address, async () => {
-        const contractId = address.binding.commissionId;
-        const renewed = await renewContract({
-            cwd: input.cwd,
-            contractId,
-            actor: ACTOR_IDENTITY,
-            nowMs: Date.now(),
-            appendScope: input.appendScope,
-            resolveConflicts: input.resolveConflicts,
-        });
-        return await buildRenewOutcome(input.cwd, address, renewed);
+    return withResolvedAddress(address, async () => {
+        const result = await renewContract({ cwd: input.cwd, contractId: address.binding.commissionId, actor: ACTOR_IDENTITY, nowMs: Date.now(), appendScope: input.appendScope, signal: input.signal, persistResponse: renewResponsePersistence(input.cwd, address) });
+        return isCompleteLifecycleOutcome(result) ? buildRenewOutcome(address, result) : result;
     });
 }
-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;
-    }
+function renewResponsePersistence(cwd, address) {
+    return async (facts) => {
+        const contractId = address.binding.commissionId;
+        const summary = facts.alreadyFresh ? `Contract ${contractId} is already fresh; nothing touched.` : `Contract ${contractId} renewed onto ${facts.newBase}.`;
+        return persistResponseHistory({ cwd, tool: "renew", provenance: { authority: { kind: "repository" }, binding: address.binding, evidenceCwd: cwd }, title: contractId, oldBase: facts.oldBase, newBase: facts.newBase, oldHead: facts.oldHead, newHead: facts.newHead, ledgerCommit: facts.ledgerHead, summary, emptyDiffLabel: "nothing sealed", ...(facts.sealed ? { sealed: facts.sealed } : {}) });
+    };
+}
+async function buildRenewOutcome(address, renewed) {
+    const { targetRoot, ...facts } = renewed;
     return {
         status: "success",
-        ...renewed,
-        currentBranch,
-        baseBranch,
-        // CLI/render synthesizes public face bytes from sealed typed facts.
+        ...facts,
+        currentBranch: await getCurrentBranch(targetRoot),
+        baseBranch: address.target.branch.slice("refs/heads/".length),
         diff: "",
         sealed: renewed.sealed ?? undefined,
-        summary,
-        ...(cleanupWarnings.length > 0 ? { meta: { warnings: cleanupWarnings } } : {}),
-        responsePath,
-        artifactId,
+        summary: renewed.alreadyFresh ? `Contract ${renewed.contractId} is already fresh; nothing touched.` : `Contract ${renewed.contractId} renewed onto ${renewed.newBase}.`,
         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(),
-        appendScope: input.appendScope,
-    })));
+    return withResolvedAddress(input.address, async () => {
+        const result = await continueRenewContract({ cwd: input.cwd, contractId: input.address.binding.commissionId, actor: ACTOR_IDENTITY, nowMs: Date.now(), appendScope: input.appendScope, signal: input.signal, persistResponse: renewResponsePersistence(input.cwd, input.address) });
+        return isCompleteLifecycleOutcome(result) ? buildRenewOutcome(input.address, result) : result;
+    });
 }
 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",
-            ...result,
-            address: input.address,
-            summary: `Renew recovery for ${result.contractId} aborted; delivery restored to ${result.oldHead}.`,
-        };
+    return withResolvedAddress(input.address, async () => {
+        const result = await abortRenewContract({ cwd: input.cwd, contractId: input.address.binding.commissionId, signal: input.signal });
+        return { status: "success", ...result, address: input.address, summary: `Renew conflict scratch for ${result.contractId} aborted; authoritative refs were untouched.` };
     });
 }