@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/renew-plan.js

@@ -1,239 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { currentLifecycleState } from "./repository-ledger/read-model.js";
-import { buildDetachedRenewChain, continueDetachedRenewChain, renewScratchName } from "./renew-rewrite.js";
-import { hasStrandableProjectionGeneration } from "./projection/index.js";
-import { runGitProcess } from "../git/core.js";
-import { assertCleanTrackedWorkingTree } from "../git/worktree.js";
-import { normalizeScopePattern } from "./scope.js";
-import { captureFoldedRenewSeal } from "./seal.js";
-function assertOperable(contractId, model) {
-    if ((model.phase !== "active" && model.phase !== "sealed") || model.petition.state !== "none") {
-        const state = currentLifecycleState(model);
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot renew from state ${state.state}`);
-    }
-}
-export function checkCancellation(signal) {
-    if (signal?.aborted)
-        throw new FlowError("CARRIER_GATE_CANCELLED", "contract lifecycle operation cancelled before durable effects");
-}
-async function deliveryChain(cwd, oldBase, oldHead) {
-    if (oldBase === oldHead)
-        return [];
-    const result = await runGitProcess(cwd, ["rev-list", "--reverse", "--ancestry-path", `${oldBase}..${oldHead}`]);
-    if (result.status !== 0 || result.error) {
-        throw new FlowError("INTERNAL_STATE", result.stderr.trim() || result.error?.message || "cannot read renew delivery chain", { cause: result.error });
-    }
-    return result.stdout.split(/\r?\n/).filter(Boolean);
-}
-export function scopeEntry(input) {
-    const patterns = (input.appendScope ?? []).map(normalizeScopePattern);
-    return patterns.length === 0 ? null : {
-        v: 1,
-        kind: "amend",
-        contract: input.contractId,
-        at: new Date(input.nowMs).toISOString(),
-        actor: input.actor,
-        data: { amendment: "Scope extended by lifecycle command.", scopeDelta: { add: patterns } },
-    };
-}
-function effectiveScope(model, amendment) {
-    return [...model.effectiveScope, ...(amendment?.data.scopeDelta?.add ?? [])];
-}
-async function gitTree(cwd, revision) {
-    const result = await runGitProcess(cwd, ["rev-parse", "--verify", `${revision}^{tree}`]);
-    return result.status === 0 && !result.error ? result.stdout.trim() : null;
-}
-async function acceptedRenewIsReplayable(targetRoot, entry) {
-    const [index, oldTree, newTree, worktree] = await Promise.all([
-        runGitProcess(targetRoot, ["write-tree"]),
-        gitTree(targetRoot, entry.data.oldHead),
-        gitTree(targetRoot, entry.data.newHead),
-        runGitProcess(targetRoot, ["diff-files", "--quiet"]),
-    ]);
-    if (index.status !== 0 || index.error || oldTree === null || newTree === null)
-        return false;
-    const indexTree = index.stdout.trim();
-    return (indexTree === oldTree || indexTree === newTree) && worktree.status === 0 && !worktree.error;
-}
-async function acceptedRenewFromReplay(model, targetRoot, deliveryHead, targetHead, replay) {
-    if (replay.state !== "verb-committed")
-        return null;
-    const renewIndex = replay.transaction.entries.findIndex((entry) => entry.kind === "renew");
-    const sealIndex = replay.transaction.entries.findIndex((entry) => entry.kind === "seal");
-    const renew = renewIndex < 0 ? undefined : replay.transaction.entries[renewIndex];
-    const seal = sealIndex < 0 ? undefined : replay.transaction.entries[sealIndex];
-    if (renew?.kind !== "renew" ||
-        seal?.kind !== "seal" ||
-        seal.data.sealedBy !== "renew" ||
-        renew.data.newBase !== targetHead ||
-        renew.data.newHead !== deliveryHead ||
-        model.pins.base !== renew.data.newBase ||
-        model.pins.delivery !== renew.data.newHead ||
-        !await acceptedRenewIsReplayable(targetRoot, renew))
-        return null;
-    return {
-        transactionObjectId: replay.transaction.transactionObjectId,
-        renewObjectId: replay.transaction.entryObjectIds[renewIndex],
-        sealObjectId: replay.transaction.entryObjectIds[sealIndex],
-        entry: structuredClone(renew),
-        seal: structuredClone(seal),
-    };
-}
-function acceptedFreshScopeFromReplay(model, replay, expected) {
-    if (replay.state !== "verb-committed" || !expected)
-        return null;
-    const accepted = replay.transaction.entries.at(-1);
-    if (accepted?.kind !== "amend")
-        return null;
-    return accepted.data.amendment === expected.data.amendment
-        && JSON.stringify(accepted.data.scopeDelta ?? null) === JSON.stringify(expected.data.scopeDelta ?? null)
-        ? { transactionObjectId: replay.transaction.transactionObjectId, entry: structuredClone(accepted) }
-        : null;
-}
-export async function admitRenew(session, input, replay, expected) {
-    const model = session.lifecycle;
-    assertOperable(input.contractId, model);
-    if (session.target.status !== "available")
-        throw new FlowError("INTERNAL_STATE", session.target.reason);
-    const oldHead = session.pins.delivery.head;
-    const newBase = session.pins.target.head;
-    if (!oldHead || !newBase)
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} has missing delivery or target coordinates`);
-    if (session.pins.delivery.ref !== model.resources.deliveryRef || session.pins.target.ref !== model.pins.target.ref) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} carrier pins disagree with the lifecycle read model`);
-    }
-    const amendment = scopeEntry(input);
-    const acceptedReplay = await acceptedRenewFromReplay(model, session.target.root, oldHead, newBase, replay);
-    if (acceptedReplay) {
-        return {
-            model,
-            repository: session.repository,
-            targetRoot: session.target.root,
-            oldBase: acceptedReplay.entry.data.oldBase,
-            oldFence: acceptedReplay.seal.data.oldFence,
-            oldHead: acceptedReplay.entry.data.oldHead,
-            newBase: acceptedReplay.entry.data.newBase,
-            deliveryRef: model.resources.deliveryRef,
-            targetRef: model.pins.target.ref,
-            effectiveScope: [...model.effectiveScope],
-            amendment: null,
-            acceptedReplay,
-            acceptedScopeReplay: null,
-        };
-    }
-    const acceptedScopeReplay = acceptedFreshScopeFromReplay(model, replay, amendment);
-    if (acceptedScopeReplay) {
-        return {
-            model,
-            repository: session.repository,
-            targetRoot: session.target.root,
-            oldBase: model.pins.base,
-            oldFence: model.pins.delivery,
-            oldHead,
-            newBase,
-            deliveryRef: model.resources.deliveryRef,
-            targetRef: model.pins.target.ref,
-            effectiveScope: [...model.effectiveScope],
-            amendment: null,
-            acceptedReplay: null,
-            acceptedScopeReplay,
-        };
-    }
-    await assertCleanTrackedWorkingTree(session.target.root);
-    if (await hasStrandableProjectionGeneration({ cwd: session.stableRoot, commissionId: input.contractId, deliveryWorktree: session.target.root, nowMs: input.nowMs })) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} has a live projection that owns the delivery worktree`);
-    }
-    const scope = effectiveScope(model, amendment);
-    const admission = {
-        model,
-        repository: session.repository,
-        targetRoot: session.target.root,
-        oldBase: model.pins.base,
-        oldFence: model.pins.delivery,
-        oldHead,
-        newBase,
-        deliveryRef: model.resources.deliveryRef,
-        targetRef: model.pins.target.ref,
-        effectiveScope: scope,
-        amendment,
-        acceptedReplay: null,
-        acceptedScopeReplay: null,
-    };
-    if (expected && (expected.observedLedgerHead !== model.observedLedgerHead ||
-        expected.deliveryRef !== admission.deliveryRef ||
-        expected.targetRef !== admission.targetRef ||
-        expected.oldBase !== admission.oldBase ||
-        expected.oldHead !== admission.oldHead ||
-        expected.newBase !== admission.newBase ||
-        JSON.stringify(expected.effectiveScope) !== JSON.stringify(scope))) {
-        throw new FlowError("CONCURRENT_MODIFICATION", `renew scratch coordinates no longer match ${input.contractId}`);
-    }
-    return admission;
-}
-export async function prepareRenew(admission, input, continuation) {
-    if (admission.acceptedReplay || admission.acceptedScopeReplay)
-        return { build: null, capture: null, prefix: [], entry: null };
-    if (admission.oldBase === admission.newBase) {
-        return { build: null, capture: null, prefix: admission.amendment ? [admission.amendment] : [], entry: null };
-    }
-    const build = continuation
-        ? await continueDetachedRenewChain({ cwd: input.cwd, scratchName: continuation.scratch.scratchName, resolution: continuation.resolution, signal: input.signal })
-        : await buildDetachedRenewChain({
-            cwd: input.cwd,
-            scratchName: renewScratchName(input.contractId),
-            observedLedgerHead: admission.model.observedLedgerHead,
-            deliveryRef: admission.deliveryRef,
-            targetRef: admission.targetRef,
-            effectiveScope: admission.effectiveScope,
-            oldBase: admission.oldBase,
-            oldHead: admission.oldHead,
-            newBase: admission.newBase,
-            deliveryCommits: await deliveryChain(input.cwd, admission.oldBase, admission.oldHead),
-            signal: input.signal,
-        });
-    if (build.status === "conflict")
-        return { build, capture: null, prefix: [], entry: null };
-    const capture = await captureFoldedRenewSeal({
-        cwd: input.cwd,
-        contract: admission.model.contract,
-        intent: admission.model.intent,
-        receiptSegmentOpen: admission.model.seal === null,
-        deliveryFence: admission.model.pins.delivery,
-        effectiveScope: admission.model.effectiveScope,
-        pendingScopeOverlay: admission.amendment?.data.scopeDelta?.add ?? [],
-        receiptHead: admission.oldHead,
-        contentBase: admission.newBase,
-        contentHead: build.newHead,
-    });
-    if (!capture)
-        throw new FlowError("NO_OPEN_ARC", `contract ${input.contractId} has no active folded receipt segment to renew`);
-    const { scopeViolationEvidence: _scopeViolationEvidence, ...durableCapture } = capture;
-    const seal = {
-        v: 2,
-        kind: "seal",
-        contract: input.contractId,
-        at: new Date(input.nowMs).toISOString(),
-        actor: "engine",
-        data: { ...durableCapture, newFence: build.newHead, sealedBy: "renew" },
-    };
-    const entry = {
-        v: 1,
-        kind: "renew",
-        contract: input.contractId,
-        at: new Date(input.nowMs).toISOString(),
-        actor: input.actor,
-        data: { oldBase: admission.oldBase, newBase: admission.newBase, oldHead: admission.oldHead, newHead: build.newHead },
-    };
-    const prefix = admission.amendment ? [admission.amendment, seal] : [seal];
-    return { build, capture, prefix, entry };
-}
-export function sameAdmission(current, pinned) {
-    return current.model.observedLedgerHead === pinned.model.observedLedgerHead &&
-        current.oldBase === pinned.oldBase && current.oldFence === pinned.oldFence &&
-        current.oldHead === pinned.oldHead && current.newBase === pinned.newBase &&
-        current.deliveryRef === pinned.deliveryRef && current.targetRef === pinned.targetRef &&
-        current.targetRoot === pinned.targetRoot &&
-        JSON.stringify(current.effectiveScope) === JSON.stringify(pinned.effectiveScope) &&
-        current.acceptedReplay?.renewObjectId === pinned.acceptedReplay?.renewObjectId &&
-        current.acceptedScopeReplay?.transactionObjectId === pinned.acceptedScopeReplay?.transactionObjectId;
-}

package/build/core/renew-rewrite.js

@@ -1,77 +0,0 @@
-import fs from "node:fs/promises";
-import { createHash } from "node:crypto";
-import { deriveHostGitCoordinates, readCommitObject } from "./repository-ledger/git-object-store.js";
-import { stableRepoRoot } from "./worktree-path.js";
-import { assertTree, buildCommit, evidenceResult, interrupted, readScratchState, renewScratchBase, replayFrom, scratchPaths, treeFromScratchFiles, validateCoordinates, validateScratchProgress, RenewBuildError } from "./renew-build.js";
-export * from "./renew-build.js";
-export function renewScratchName(contractId) {
-    return `renew-${createHash("sha256").update(contractId).digest("hex").slice(0, 24)}`;
-}
-export async function readDetachedRenewScratch(input) {
-    const repositoryRoot = await stableRepoRoot(input.cwd);
-    const scratch = scratchPaths(await renewScratchBase(repositoryRoot), input.scratchName);
-    const state = await readScratchState(scratch);
-    return {
-        status: "conflict",
-        ...evidenceResult(state),
-        scratchName: state.scratchName,
-        scratchPath: scratch.root,
-        filesPath: scratch.files,
-        conflictCommit: state.conflictCommit,
-        conflictPaths: [...state.conflictPaths],
-    };
-}
-export async function continueDetachedRenewChain(input) {
-    const repositoryRoot = await stableRepoRoot(input.cwd);
-    const scratchBase = await renewScratchBase(repositoryRoot);
-    const scratch = scratchPaths(scratchBase, input.scratchName);
-    const state = await readScratchState(scratch);
-    const coordinates = await deriveHostGitCoordinates(repositoryRoot);
-    const commits = await validateCoordinates({ ...state, cwd: repositoryRoot, coordinates });
-    await validateScratchProgress(repositoryRoot, coordinates, state, commits);
-    interrupted(input.signal);
-    const original = commits[state.nextIndex];
-    let resolvedHead;
-    if (input.resolution.kind === "tree") {
-        await assertTree(repositoryRoot, coordinates, input.resolution.tree);
-        resolvedHead = await buildCommit(repositoryRoot, coordinates, original, input.resolution.tree, state.currentHead);
-    }
-    else if (input.resolution.kind === "commit") {
-        const resolved = await readCommitObject(repositoryRoot, coordinates, input.resolution.commit);
-        if (resolved.parents.length !== 1 || resolved.parents[0] !== state.currentHead) {
-            throw new RenewBuildError("INVALID_RENEW_RESOLUTION", `resolved commit ${input.resolution.commit} must have exactly parent ${state.currentHead}`);
-        }
-        resolvedHead = input.resolution.commit;
-    }
-    else {
-        const tree = await treeFromScratchFiles(repositoryRoot, coordinates, scratch, state);
-        resolvedHead = await buildCommit(repositoryRoot, coordinates, original, tree, state.currentHead);
-    }
-    state.evidenceMap[original.objectId] = resolvedHead;
-    state.currentHead = resolvedHead;
-    state.nextIndex += 1;
-    const result = await replayFrom({
-        cwd: repositoryRoot,
-        scratchBase,
-        coordinates,
-        state,
-        commits,
-        createScratch: false,
-        signal: input.signal,
-    });
-    return result;
-}
-export async function abortDetachedRenewChain(input) {
-    const repositoryRoot = await stableRepoRoot(input.cwd);
-    const scratch = scratchPaths(await renewScratchBase(repositoryRoot), input.scratchName);
-    try {
-        await fs.lstat(scratch.root);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return { status: "absent", scratchName: input.scratchName };
-        throw error;
-    }
-    await fs.rm(scratch.root, { recursive: true, force: true });
-    return { status: "deleted", scratchName: input.scratchName };
-}

package/build/core/renew.js

@@ -1,341 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { getCurrentBranch, requireGitRepository } from "../git/branches.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 { 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;
-    }
-}
-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" };
-            }
-        },
-        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 (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 };
-            }
-            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 (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 };
-            }
-            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,
-                },
-            });
-            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 };
-        },
-    });
-    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) {
-    return executeRenew(input);
-}
-export async function continueRenewContract(input) {
-    const scratchName = renewScratchName(input.contractId);
-    let scratch;
-    try {
-        scratch = await readDetachedRenewScratch({ cwd: input.cwd, scratchName });
-    }
-    catch (error) {
-        throw new FlowError("RENEW_SCRATCH_NOT_FOUND", `no renew conflict scratch is open for ${input.contractId}`, { cause: error });
-    }
-    return executeRenew(input, { scratch, resolution: input.resolution ?? { kind: "scratch-files" } });
-}
-export async function abortRenewContract(input) {
-    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 {
-            scratch = await readDetachedRenewScratch({ cwd: input.cwd, scratchName });
-        }
-        catch (error) {
-            throw new FlowError("RENEW_SCRATCH_NOT_FOUND", `no renew conflict scratch is open for ${input.contractId}`, { cause: error });
-        }
-        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 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;
-    });
-}
-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",
-        ...facts,
-        currentBranch: await getCurrentBranch(targetRoot),
-        baseBranch: address.target.branch.slice("refs/heads/".length),
-        diff: "",
-        sealed: renewed.sealed ?? undefined,
-        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 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 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.` };
-    });
-}