@astrosheep/keiyaku 2.9.12 → 2.9.13

package/build/core/renew-build.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { assertHostObjectId, deriveHostGitCoordinates, readCommitObject } from "./repository-ledger/git-object-store.js";
 import { runGitProcess, runGitProcessBytes } from "../git/core.js";
 import { stableRepoRoot } from "./worktree-path.js";
-const SCRATCH_VERSION = 1;
+const SCRATCH_VERSION = 3;
 const SCRATCH_DIRECTORY = path.join("keiyaku", "renew-scratch");
 const SCRATCH_STATE_FILE = "state.json";
 const SCRATCH_FILES_DIRECTORY = "files";
@@ -136,11 +136,31 @@ async function mergeCommitTree(input) {
     await assertTree(input.cwd, input.coordinates, tree);
     if (result.status === 0)
         return { status: "clean", tree };
-    const paths = Array.from(new Set(lines.flatMap((line) => {
-        const match = /^\d{6} [0-9a-f]+ [123]\t(.+)$/.exec(line);
-        return match ? [match[1]] : [];
-    })));
-    return { status: "conflict", tree, paths };
+    const index = lines.flatMap((line) => {
+        const match = /^(\d{6}) ([0-9a-f]+) ([123])\t(.+)$/.exec(line);
+        return match ? [{ mode: match[1], objectId: match[2], stage: Number(match[3]), path: match[4] }] : [];
+    });
+    const paths = Array.from(new Set(index.map((entry) => entry.path)));
+    return { status: "conflict", tree, paths, index };
+}
+/** Replay a resolved delivery tree from its captured target onto a later target. */
+export async function replayResolvedDelivery(input) {
+    for (const commit of [input.capturedTarget, input.latestTarget]) {
+        assertHostObjectId(input.coordinates, commit);
+        await readCommitObject(input.cwd, input.coordinates, commit);
+    }
+    const resolvedCommit = await buildCommit(input.cwd, input.coordinates, input.identity, input.resolvedTree, input.capturedTarget);
+    const replay = await mergeCommitTree({
+        cwd: input.cwd,
+        coordinates: input.coordinates,
+        original: {
+            ...input.identity,
+            objectId: resolvedCommit,
+            parent: input.capturedTarget,
+        },
+        currentHead: input.latestTarget,
+    });
+    return { ...replay, resolvedCommit };
 }
 export async function buildCommit(cwd, coordinates, original, tree, parent) {
     await assertTree(cwd, coordinates, tree);
@@ -170,41 +190,64 @@ export function interrupted(signal) {
         });
     }
 }
-async function materializeConflict(cwd, scratch, tree) {
-    await fs.rm(scratch.files, { recursive: true, force: true });
-    await fs.mkdir(scratch.files, { recursive: true });
-    const listingArgs = ["ls-tree", "-r", "-z", "--full-tree", tree];
-    const listing = await runGitProcessBytes(cwd, listingArgs);
-    if (listing.status !== 0 || listing.error) {
-        throw gitFailure(listingArgs, listing.stderr.toString("utf8").trim() || listing.error?.message || `exit ${String(listing.status)}`, listing.error);
-    }
-    for (const row of listing.stdout.toString("utf8").split("\0").filter(Boolean)) {
-        const match = /^(\d{6}) (blob|commit) ([0-9a-f]+)\t([\s\S]+)$/.exec(row);
-        if (!match)
-            throw new RenewBuildError("GIT_RENEW_BUILD_FAILED", `invalid ls-tree row while materializing renew scratch`);
-        const [, mode, type, objectId, relative] = match;
-        const destination = path.resolve(scratch.files, relative);
-        const withinScratch = path.relative(scratch.files, destination);
-        if (withinScratch === "" || path.isAbsolute(withinScratch) || withinScratch === ".." || withinScratch.startsWith(`..${path.sep}`)) {
-            throw new RenewBuildError("GIT_RENEW_BUILD_FAILED", `unsafe path in renew conflict tree: ${JSON.stringify(relative)}`);
-        }
-        await fs.mkdir(path.dirname(destination), { recursive: true });
-        if (type === "commit") {
-            await fs.writeFile(destination, `${objectId}\n`, "utf8");
-            continue;
-        }
-        const blobArgs = ["cat-file", "blob", objectId];
-        const blob = await runGitProcessBytes(cwd, blobArgs);
-        if (blob.status !== 0 || blob.error) {
-            throw gitFailure(blobArgs, blob.stderr.toString("utf8").trim() || blob.error?.message || `exit ${String(blob.status)}`, blob.error);
+async function materializeConflict(cwd, scratch, state, create) {
+    if (create) {
+        await successfulGit(cwd, ["worktree", "add", "--detach", scratch.files, state.currentHead]);
+    }
+    else {
+        await validateScratchWorktree(cwd, scratch, state, { requireRecordedHead: false });
+        await successfulGit(scratch.files, ["reset", "--hard", state.currentHead]);
+        await successfulGit(scratch.files, ["clean", "-ffdx"]);
+    }
+    await successfulGit(scratch.files, ["read-tree", "--reset", "-u", state.conflictTree]);
+    await successfulGit(scratch.files, [
+        "update-index",
+        "--force-remove",
+        "--",
+        ...Array.from(new Set(state.conflictIndex.map((entry) => entry.path))),
+    ]);
+    await successfulGit(scratch.files, ["update-index", "--index-info"], { input: state.conflictIndex.map((entry) => `${entry.mode} ${entry.objectId} ${entry.stage}\t${entry.path}\n`).join("") });
+}
+async function scratchCommonDirectory(cwd) {
+    const commonDirectory = (await successfulGit(cwd, [
+        "rev-parse",
+        "--path-format=absolute",
+        "--git-common-dir",
+    ])).trim();
+    return await fs.realpath(commonDirectory);
+}
+async function validateScratchWorktree(cwd, scratch, state, options) {
+    let filesPath;
+    try {
+        filesPath = await fs.realpath(scratch.files);
+    }
+    catch (error) {
+        throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${state.scratchName} has no linked worktree`, { cause: error });
+    }
+    try {
+        const [topLevel, commonDirectory] = await Promise.all([
+            successfulGit(filesPath, ["rev-parse", "--show-toplevel"]),
+            scratchCommonDirectory(filesPath),
+        ]);
+        if (path.resolve(topLevel.trim()) !== filesPath || commonDirectory !== await scratchCommonDirectory(cwd)) {
+            throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${state.scratchName} is not the recorded linked worktree`);
         }
-        if (mode === "120000") {
-            await fs.symlink(blob.stdout.toString("utf8"), destination);
+        const symbolicHead = await runGitProcess(filesPath, ["symbolic-ref", "-q", "HEAD"]);
+        if (symbolicHead.status === 0 || symbolicHead.status !== 1 || symbolicHead.error) {
+            throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${state.scratchName} must retain a detached HEAD`);
         }
-        else {
-            await fs.writeFile(destination, blob.stdout, { mode: mode === "100755" ? 0o755 : 0o644 });
+        if (options.requireRecordedHead) {
+            const head = (await successfulGit(filesPath, ["rev-parse", "HEAD"])).trim();
+            if (head !== state.currentHead) {
+                throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${state.scratchName} HEAD no longer matches the recorded replay head`);
+            }
         }
     }
+    catch (error) {
+        if (error instanceof RenewBuildError)
+            throw error;
+        throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${state.scratchName} has invalid linked worktree metadata`, { cause: error });
+    }
 }
 async function writeScratchState(scratch, state) {
     const temporary = `${scratch.state}.next`;
@@ -212,9 +255,40 @@ async function writeScratchState(scratch, state) {
     await fs.writeFile(temporary, `${JSON.stringify(state, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
     await fs.rename(temporary, scratch.state);
 }
+async function hasRegisteredScratchWorktree(cwd, scratch) {
+    const worktrees = await successfulGit(cwd, ["worktree", "list", "--porcelain", "-z"]);
+    const expected = path.resolve(scratch.files);
+    return worktrees.split("\0").some((field) => field.startsWith("worktree ") && path.resolve(field.slice("worktree ".length)) === expected);
+}
+async function scratchRootExists(scratch) {
+    try {
+        await fs.lstat(scratch.root);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+/** Remove only the deterministic scratch root and its exact Git registration. */
+export async function cleanupRenewScratch(input) {
+    const [registered, rootExists] = await Promise.all([
+        hasRegisteredScratchWorktree(input.cwd, input.scratch),
+        scratchRootExists(input.scratch),
+    ]);
+    if (!registered && !rootExists)
+        return { status: "absent" };
+    if (registered) {
+        await successfulGit(input.cwd, ["worktree", "remove", "--force", input.scratch.files]);
+    }
+    await fs.rm(input.scratch.root, { recursive: true, force: true });
+    return { status: "deleted" };
+}
 export function evidenceResult(state) {
     return {
         observedLedgerHead: state.observedLedgerHead,
+        lifecycleHead: state.lifecycleHead,
         deliveryRef: state.deliveryRef,
         targetRef: state.targetRef,
         effectiveScope: [...state.effectiveScope],
@@ -225,8 +299,9 @@ export function evidenceResult(state) {
         evidenceMap: { ...state.evidenceMap },
     };
 }
-async function persistConflict(cwd, scratchBase, state, create) {
+export async function persistConflict(cwd, scratchBase, state, create) {
     const scratch = scratchPaths(scratchBase, state.scratchName);
+    let previous;
     if (create) {
         await fs.mkdir(path.dirname(scratch.root), { recursive: true });
         try {
@@ -239,8 +314,27 @@ async function persistConflict(cwd, scratchBase, state, create) {
             throw error;
         }
     }
-    await materializeConflict(cwd, scratch, state.conflictTree);
-    await writeScratchState(scratch, state);
+    else {
+        previous = await readScratchState(scratch);
+    }
+    try {
+        await materializeConflict(cwd, scratch, state, create);
+        await writeScratchState(scratch, state);
+    }
+    catch (error) {
+        if (create) {
+            await cleanupRenewScratch({ cwd, scratch });
+        }
+        else if (previous) {
+            try {
+                await materializeConflict(cwd, scratch, previous, false);
+            }
+            catch (restoreError) {
+                throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${state.scratchName} could not restore its prior conflict state`, { cause: restoreError instanceof Error ? restoreError : undefined });
+            }
+        }
+        throw error;
+    }
     return {
         status: "conflict",
         ...evidenceResult(state),
@@ -270,6 +364,7 @@ export async function replayFrom(input) {
                 conflictCommit: original.objectId,
                 conflictTree: merged.tree,
                 conflictPaths: merged.paths,
+                conflictIndex: merged.index,
             };
             return await persistConflict(input.cwd, input.scratchBase, state, input.createScratch);
         }
@@ -292,38 +387,54 @@ export async function buildDetachedRenewChain(input) {
     const coordinates = await deriveHostGitCoordinates(repositoryRoot);
     const commits = await validateCoordinates({ ...input, cwd: repositoryRoot, coordinates });
     const existingScratch = scratchPaths(scratchBase, input.scratchName);
-    try {
-        await fs.lstat(existingScratch.root);
-        const state = await readScratchState(existingScratch);
-        if (state.observedLedgerHead !== input.observedLedgerHead
-            || state.deliveryRef !== input.deliveryRef
-            || state.targetRef !== input.targetRef
-            || state.oldBase !== input.oldBase
-            || state.oldHead !== input.oldHead
-            || state.newBase !== input.newBase
-            || JSON.stringify(state.effectiveScope) !== JSON.stringify(input.effectiveScope)
-            || JSON.stringify(state.deliveryCommits) !== JSON.stringify(input.deliveryCommits)) {
-            throw new RenewBuildError("RENEW_SCRATCH_EXISTS", `renew scratch ${input.scratchName} belongs to different coordinates`);
+    const hasExistingScratch = await Promise.all([
+        scratchRootExists(existingScratch),
+        hasRegisteredScratchWorktree(repositoryRoot, existingScratch),
+    ]).then(([rootExists, registered]) => rootExists || registered);
+    if (hasExistingScratch) {
+        let state;
+        try {
+            state = await readScratchState(existingScratch);
+        }
+        catch (error) {
+            if (!(error instanceof RenewBuildError)
+                || (error.code !== "RENEW_SCRATCH_NOT_FOUND" && error.code !== "INVALID_RENEW_SCRATCH")) {
+                throw error;
+            }
+            await cleanupRenewScratch({ cwd: repositoryRoot, scratch: existingScratch });
+        }
+        if (state) {
+            if (state.observedLedgerHead !== input.observedLedgerHead
+                || state.lifecycleHead !== input.lifecycleHead
+                || state.deliveryRef !== input.deliveryRef
+                || state.targetRef !== input.targetRef
+                || state.oldBase !== input.oldBase
+                || state.oldHead !== input.oldHead
+                || state.newBase !== input.newBase
+                || JSON.stringify(state.effectiveScope) !== JSON.stringify(input.effectiveScope)
+                || JSON.stringify(state.deliveryCommits) !== JSON.stringify(input.deliveryCommits)) {
+                await cleanupRenewScratch({ cwd: repositoryRoot, scratch: existingScratch });
+            }
+            else {
+                await validateScratchProgress(repositoryRoot, coordinates, state, commits);
+                await validateScratchWorktree(repositoryRoot, existingScratch, state, { requireRecordedHead: true });
+                return {
+                    status: "conflict",
+                    ...evidenceResult(state),
+                    scratchName: state.scratchName,
+                    scratchPath: existingScratch.root,
+                    filesPath: existingScratch.files,
+                    conflictCommit: state.conflictCommit,
+                    conflictPaths: [...state.conflictPaths],
+                };
+            }
         }
-        await validateScratchProgress(repositoryRoot, coordinates, state, commits);
-        return {
-            status: "conflict",
-            ...evidenceResult(state),
-            scratchName: state.scratchName,
-            scratchPath: existingScratch.root,
-            filesPath: existingScratch.files,
-            conflictCommit: state.conflictCommit,
-            conflictPaths: [...state.conflictPaths],
-        };
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
     }
     const state = {
         version: SCRATCH_VERSION,
         scratchName: input.scratchName,
         observedLedgerHead: input.observedLedgerHead,
+        lifecycleHead: input.lifecycleHead,
         deliveryRef: input.deliveryRef,
         targetRef: input.targetRef,
         effectiveScope: [...input.effectiveScope],
@@ -337,6 +448,7 @@ export async function buildDetachedRenewChain(input) {
         conflictCommit: "",
         conflictTree: "",
         conflictPaths: [],
+        conflictIndex: [],
     };
     return await replayFrom({
         cwd: repositoryRoot,
@@ -366,6 +478,7 @@ export async function readScratchState(scratch) {
         || parsed.version !== SCRATCH_VERSION
         || parsed.scratchName !== path.basename(scratch.root)
         || typeof parsed.observedLedgerHead !== "string"
+        || typeof parsed.lifecycleHead !== "string"
         || typeof parsed.deliveryRef !== "string"
         || typeof parsed.targetRef !== "string"
         || !Array.isArray(parsed.effectiveScope)
@@ -382,30 +495,47 @@ export async function readScratchState(scratch) {
         || typeof parsed.conflictCommit !== "string"
         || typeof parsed.conflictTree !== "string"
         || !Array.isArray(parsed.conflictPaths)
-        || parsed.conflictPaths.some((value) => typeof value !== "string")) {
+        || parsed.conflictPaths.some((value) => typeof value !== "string")
+        || !Array.isArray(parsed.conflictIndex)
+        || parsed.conflictIndex.some((entry) => !isRecord(entry)
+            || !/^\d{6}$/.test(String(entry.mode))
+            || !/^[0-9a-f]+$/.test(String(entry.objectId))
+            || ![1, 2, 3].includes(entry.stage)
+            || typeof entry.path !== "string")) {
         throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${path.basename(scratch.root)} has invalid state`);
     }
     return parsed;
 }
 export async function treeFromScratchFiles(cwd, coordinates, scratch, state) {
-    const index = path.join(scratch.root, "continue.index");
-    await fs.rm(index, { force: true });
-    const env = { GIT_INDEX_FILE: index, GIT_WORK_TREE: scratch.files };
+    await validateScratchWorktree(cwd, scratch, state, { requireRecordedHead: true });
+    const indexPath = (await successfulGit(scratch.files, [
+        "rev-parse",
+        "--path-format=absolute",
+        "--git-path",
+        "index",
+    ])).trim();
+    const temporaryDirectory = await fs.mkdtemp(path.join(scratch.root, "tree-index-"));
+    const temporaryIndex = path.join(temporaryDirectory, "index");
     try {
-        await successfulGit(cwd, ["read-tree", state.conflictTree], { env });
-        await successfulGit(cwd, ["add", "--all", "--", "."], { env });
-        const tree = (await successfulGit(cwd, ["write-tree"], { env })).trim();
+        // Candidate construction must not stage or otherwise alter the retryable scratch.
+        await fs.copyFile(indexPath, temporaryIndex);
+        const env = { ...process.env, GIT_INDEX_FILE: temporaryIndex };
+        await successfulGit(scratch.files, ["add", "--all", "--", "."], { env });
+        const tree = (await successfulGit(scratch.files, ["write-tree"], { env })).trim();
         await assertTree(cwd, coordinates, tree);
         return tree;
     }
     finally {
-        await fs.rm(index, { force: true });
+        await fs.rm(temporaryDirectory, { recursive: true, force: true });
     }
 }
 export async function validateScratchProgress(cwd, coordinates, state, commits) {
     if (state.nextIndex < 0 || state.nextIndex >= commits.length || commits[state.nextIndex]?.objectId !== state.conflictCommit) {
         throw new RenewBuildError("INVALID_RENEW_SCRATCH", "renew scratch does not identify the stopped delivery commit");
     }
+    if (state.conflictPaths.length === 0 || state.conflictIndex.length === 0) {
+        throw new RenewBuildError("INVALID_RENEW_SCRATCH", "renew scratch has no captured conflict index");
+    }
     let parent = state.newBase;
     for (let index = 0; index < state.nextIndex; index += 1) {
         const original = commits[index].objectId;

package/build/core/renew-plan.js

@@ -2,6 +2,7 @@ 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 { readCommitCoordinate } from "../git/commits.js";
 import { runGitProcess } from "../git/core.js";
 import { assertCleanTrackedWorkingTree } from "../git/worktree.js";
 import { normalizeScopePattern } from "./scope.js";
@@ -28,7 +29,7 @@ async function deliveryChain(cwd, oldBase, oldHead) {
 export function scopeEntry(input) {
     const patterns = (input.appendScope ?? []).map(normalizeScopePattern);
     return patterns.length === 0 ? null : {
-        v: 1,
+        v: 2,
         kind: "amend",
         contract: input.contractId,
         at: new Date(input.nowMs).toISOString(),
@@ -40,8 +41,8 @@ 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;
+    const read = await readCommitCoordinate(cwd, revision);
+    return read.status === "ok" ? read.coordinate.tree : null;
 }
 async function acceptedRenewIsReplayable(targetRoot, entry) {
     const [index, oldTree, newTree, worktree] = await Promise.all([
@@ -103,11 +104,16 @@ export async function admitRenew(session, input, replay, expected) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} carrier pins disagree with the lifecycle read model`);
     }
     const amendment = scopeEntry(input);
+    const observedLedgerHead = session.repository.observedLedgerHead;
+    if (!observedLedgerHead)
+        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} has no observed repository ledger head`);
+    const lifecycleHead = model.contractHead;
     const acceptedReplay = await acceptedRenewFromReplay(model, session.target.root, oldHead, newBase, replay);
     if (acceptedReplay) {
         return {
             model,
             repository: session.repository,
+            observedLedgerHead,
             targetRoot: session.target.root,
             oldBase: acceptedReplay.entry.data.oldBase,
             oldFence: acceptedReplay.seal.data.oldFence,
@@ -117,6 +123,7 @@ export async function admitRenew(session, input, replay, expected) {
             targetRef: model.pins.target.ref,
             effectiveScope: [...model.effectiveScope],
             amendment: null,
+            lifecycleHead,
             acceptedReplay,
             acceptedScopeReplay: null,
         };
@@ -126,6 +133,7 @@ export async function admitRenew(session, input, replay, expected) {
         return {
             model,
             repository: session.repository,
+            observedLedgerHead,
             targetRoot: session.target.root,
             oldBase: model.pins.base,
             oldFence: model.pins.delivery,
@@ -135,6 +143,7 @@ export async function admitRenew(session, input, replay, expected) {
             targetRef: model.pins.target.ref,
             effectiveScope: [...model.effectiveScope],
             amendment: null,
+            lifecycleHead,
             acceptedReplay: null,
             acceptedScopeReplay,
         };
@@ -147,6 +156,7 @@ export async function admitRenew(session, input, replay, expected) {
     const admission = {
         model,
         repository: session.repository,
+        observedLedgerHead,
         targetRoot: session.target.root,
         oldBase: model.pins.base,
         oldFence: model.pins.delivery,
@@ -156,16 +166,17 @@ export async function admitRenew(session, input, replay, expected) {
         targetRef: model.pins.target.ref,
         effectiveScope: scope,
         amendment,
+        lifecycleHead,
         acceptedReplay: null,
         acceptedScopeReplay: null,
     };
-    if (expected && (expected.observedLedgerHead !== model.observedLedgerHead ||
+    if (expected && (expected.lifecycleHead !== lifecycleHead ||
         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))) {
+        (JSON.stringify(expected.effectiveScope) !== JSON.stringify(model.effectiveScope)
+            && JSON.stringify(expected.effectiveScope) !== JSON.stringify(scope)))) {
         throw new FlowError("CONCURRENT_MODIFICATION", `renew scratch coordinates no longer match ${input.contractId}`);
     }
     return admission;
@@ -177,11 +188,23 @@ export async function prepareRenew(admission, input, continuation) {
         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 continueDetachedRenewChain({
+            cwd: input.cwd,
+            scratchName: continuation.scratch.scratchName,
+            resolution: continuation.resolution,
+            refresh: {
+                latestTarget: admission.newBase,
+                observedLedgerHead: admission.observedLedgerHead,
+                effectiveScope: admission.effectiveScope,
+                lifecycleHead: admission.lifecycleHead,
+            },
+            signal: input.signal,
+        })
         : await buildDetachedRenewChain({
             cwd: input.cwd,
             scratchName: renewScratchName(input.contractId),
-            observedLedgerHead: admission.model.observedLedgerHead,
+            observedLedgerHead: admission.observedLedgerHead,
+            lifecycleHead: admission.lifecycleHead,
             deliveryRef: admission.deliveryRef,
             targetRef: admission.targetRef,
             effectiveScope: admission.effectiveScope,
@@ -204,6 +227,7 @@ export async function prepareRenew(admission, input, continuation) {
         receiptHead: admission.oldHead,
         contentBase: admission.newBase,
         contentHead: build.newHead,
+        scopePolicy: "warn",
     });
     if (!capture)
         throw new FlowError("NO_OPEN_ARC", `contract ${input.contractId} has no active folded receipt segment to renew`);
@@ -228,11 +252,12 @@ export async function prepareRenew(admission, input, continuation) {
     return { build, capture, prefix, entry };
 }
 export function sameAdmission(current, pinned) {
-    return current.model.observedLedgerHead === pinned.model.observedLedgerHead &&
+    return current.observedLedgerHead === pinned.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 &&
+        current.lifecycleHead === pinned.lifecycleHead &&
         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,8 +1,8 @@
-import fs from "node:fs/promises";
 import { createHash } from "node:crypto";
+import { requireCommitCoordinate } from "../git/commits.js";
 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";
+import { assertTree, buildCommit, cleanupRenewScratch, evidenceResult, interrupted, persistConflict, readScratchState, renewScratchBase, replayFrom, replayResolvedDelivery, 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)}`;
@@ -11,6 +11,8 @@ export async function readDetachedRenewScratch(input) {
     const repositoryRoot = await stableRepoRoot(input.cwd);
     const scratch = scratchPaths(await renewScratchBase(repositoryRoot), input.scratchName);
     const state = await readScratchState(scratch);
+    const coordinates = await deriveHostGitCoordinates(repositoryRoot);
+    await assertTree(repositoryRoot, coordinates, state.conflictTree);
     return {
         status: "conflict",
         ...evidenceResult(state),
@@ -27,14 +29,17 @@ export async function continueDetachedRenewChain(input) {
     const scratch = scratchPaths(scratchBase, input.scratchName);
     const state = await readScratchState(scratch);
     const coordinates = await deriveHostGitCoordinates(repositoryRoot);
+    await assertTree(repositoryRoot, coordinates, state.conflictTree);
     const commits = await validateCoordinates({ ...state, cwd: repositoryRoot, coordinates });
     await validateScratchProgress(repositoryRoot, coordinates, state, commits);
     interrupted(input.signal);
     const original = commits[state.nextIndex];
     let resolvedHead;
+    let resolvedTree;
     if (input.resolution.kind === "tree") {
         await assertTree(repositoryRoot, coordinates, input.resolution.tree);
-        resolvedHead = await buildCommit(repositoryRoot, coordinates, original, input.resolution.tree, state.currentHead);
+        resolvedTree = input.resolution.tree;
+        resolvedHead = await buildCommit(repositoryRoot, coordinates, original, resolvedTree, state.currentHead);
     }
     else if (input.resolution.kind === "commit") {
         const resolved = await readCommitObject(repositoryRoot, coordinates, input.resolution.commit);
@@ -42,10 +47,54 @@ export async function continueDetachedRenewChain(input) {
             throw new RenewBuildError("INVALID_RENEW_RESOLUTION", `resolved commit ${input.resolution.commit} must have exactly parent ${state.currentHead}`);
         }
         resolvedHead = input.resolution.commit;
+        resolvedTree = (await requireCommitCoordinate(repositoryRoot, resolvedHead)).tree;
+        await assertTree(repositoryRoot, coordinates, resolvedTree);
     }
     else {
-        const tree = await treeFromScratchFiles(repositoryRoot, coordinates, scratch, state);
-        resolvedHead = await buildCommit(repositoryRoot, coordinates, original, tree, state.currentHead);
+        resolvedTree = await treeFromScratchFiles(repositoryRoot, coordinates, scratch, state);
+        resolvedHead = await buildCommit(repositoryRoot, coordinates, original, resolvedTree, state.currentHead);
+    }
+    if (input.refresh) {
+        state.observedLedgerHead = input.refresh.observedLedgerHead;
+        state.effectiveScope = [...input.refresh.effectiveScope];
+        state.lifecycleHead = input.refresh.lifecycleHead;
+        if (input.refresh.latestTarget !== state.newBase) {
+            const resolvedPrefix = commits.slice(0, state.nextIndex + 1).map((commit, index) => ({
+                original: commit,
+                resolvedHead: index === state.nextIndex ? resolvedHead : state.evidenceMap[commit.objectId],
+            }));
+            state.newBase = input.refresh.latestTarget;
+            state.currentHead = input.refresh.latestTarget;
+            state.evidenceMap = {};
+            for (let index = 0; index < resolvedPrefix.length; index += 1) {
+                const resolved = resolvedPrefix[index];
+                const commit = await readCommitObject(repositoryRoot, coordinates, resolved.resolvedHead);
+                if (commit.parents.length !== 1) {
+                    throw new RenewBuildError("INVALID_RENEW_SCRATCH", `resolved commit ${resolved.resolvedHead} must have exactly one parent`);
+                }
+                const tree = (await requireCommitCoordinate(repositoryRoot, resolved.resolvedHead)).tree;
+                const replay = await replayResolvedDelivery({
+                    cwd: repositoryRoot,
+                    coordinates,
+                    capturedTarget: commit.parents[0],
+                    latestTarget: state.currentHead,
+                    resolvedTree: tree,
+                    identity: resolved.original,
+                });
+                if (replay.status === "conflict") {
+                    state.nextIndex = index;
+                    state.conflictTree = replay.tree;
+                    state.conflictPaths = [...replay.paths];
+                    state.conflictIndex = [...replay.index];
+                    state.conflictCommit = resolved.original.objectId;
+                    return await persistConflict(repositoryRoot, scratchBase, state, false);
+                }
+                const refreshedHead = await buildCommit(repositoryRoot, coordinates, resolved.original, replay.tree, state.currentHead);
+                state.evidenceMap[resolved.original.objectId] = refreshedHead;
+                state.currentHead = refreshedHead;
+            }
+            resolvedHead = state.currentHead;
+        }
     }
     state.evidenceMap[original.objectId] = resolvedHead;
     state.currentHead = resolvedHead;
@@ -64,14 +113,6 @@ export async function continueDetachedRenewChain(input) {
 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 };
+    const cleanup = await cleanupRenewScratch({ cwd: repositoryRoot, scratch });
+    return { ...cleanup, scratchName: input.scratchName };
 }