@astrosheep/keiyaku 4.6.3 → 4.6.6

package/build/src/git/hooks.d.ts

@@ -61,14 +61,12 @@ export declare const worktreeHookLagSchema: z.ZodObject<{
     }, z.core.$strict>]>;
 }, z.core.$strict>;
 export type WorktreeHookLag = z.infer<typeof worktreeHookLagSchema>;
-export type HookPhase = "create" | "destroy";
 type WorktreeHooksFromInput = Readonly<{
     settings: Settings;
 }>;
 export declare function worktreeHooksFrom(input: WorktreeHooksFromInput): WorktreeHooks;
-export declare function normalizedWorktreeHooks(value: unknown): WorktreeHooks;
 export declare const EMPTY_WORKTREE_HOOKS: WorktreeHooks;
-export type HookCommandRun = Readonly<{
+type HookCommandRun = Readonly<{
     kind: "ok";
 }> | Readonly<{
     kind: "cancelled";
@@ -85,7 +83,7 @@ export declare function runHookCommands(worktree: string, commands: readonly Hoo
     stream: "stdout" | "stderr";
     text: string;
 }>) => void): Promise<HookCommandRun>;
-export type HookPhaseRun = Readonly<{
+type HookPhaseRun = Readonly<{
     lag: WorktreeHookLag | null;
     runs: readonly string[];
 }>;

package/build/src/git/hooks.js

@@ -94,18 +94,6 @@ export function worktreeHooksFrom(input) {
     };
     return Object.freeze({ create: selected("create"), destroy: selected("destroy") });
 }
-export function normalizedWorktreeHooks(value) {
-    if (!record(value))
-        throw new TypeError("hooks must be an object");
-    for (const key of Object.keys(value)) {
-        if (key !== "create" && key !== "destroy")
-            throw new TypeError(`hooks has unknown field: ${key}`);
-    }
-    return Object.freeze({
-        create: commands(value.create, "hooks.create", TypeError),
-        destroy: commands(value.destroy, "hooks.destroy", TypeError),
-    });
-}
 export const EMPTY_WORKTREE_HOOKS = Object.freeze({
     create: Object.freeze([]),
     destroy: Object.freeze([]),

package/build/src/git/integration.d.ts

@@ -3,7 +3,7 @@ import type { Preparation } from "../core/decide.js";
 import type { ChangeId, ContractCoordinates, ContractId, SnapshotId } from "../core/facts/types.js";
 import { type GitObjectId } from "./identity.js";
 import { type GitRepository } from "./process.js";
-import type { DeliveryCommitMetadata, TenderCapture } from "./tender.js";
+import { type DeliveryCommitMetadata, type TenderCapture } from "./tender.js";
 import { workspaceMergeStatePresent } from "./workspace.js";
 export { workspaceMergeStatePresent };
 type IntegrationTender = Pick<TenderCapture, "head" | "tree">;
@@ -36,16 +36,18 @@ export declare const integrationPreparationRefusalSchema: z.ZodUnion<readonly [z
     requiredGit: z.ZodLiteral<"2.38">;
 }, z.core.$strict>]>;
 export type IntegrationPreparationRefusal = z.infer<typeof integrationPreparationRefusalSchema>;
-export type IntegrationCoordinates = Readonly<{
+type IntegrationCoordinates = Readonly<{
     contractId: ContractId;
     coordinates: ContractCoordinates;
 }>;
-export type IntegrationPlan = Readonly<{
+type IntegrationPlan = Readonly<{
     predecessor: SnapshotId;
     tree: GitObjectId;
 }>;
 /** Mint the one worktree-content identity shared by review and delivery. */
 export declare function worktreeChangeId(repository: GitRepository, input: IntegrationCoordinates, tender: TenderCapture): Promise<ChangeId>;
+/** Reuse only recorded commits with this exact tree and sole predecessor. */
+export declare function reusableIntegrationSnapshot(repository: GitRepository, tree: GitObjectId, parent: SnapshotId, recordedSnapshots: readonly SnapshotId[]): Promise<SnapshotId | undefined>;
 /** Materialize the exact integration tree against its observed predecessor. */
 export declare function materializeIntegrationSnapshot(repository: GitRepository, tree: GitObjectId, parent: SnapshotId, metadata: DeliveryCommitMetadata): Promise<SnapshotId>;
 export declare function persistedTender(repository: GitRepository, snapshot: SnapshotId): Promise<IntegrationTender>;

package/build/src/git/integration.js

@@ -3,13 +3,15 @@ import { z } from "zod";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { gitObjectId, gitObjectIdForSnapshot, mintChangeId, mintSnapshotId } from "./identity.js";
 import { decodeGitNameOnly, decodeGitNumstat, readRef } from "./repository.js";
-import { GitPlumbingError, runGit, runGitPipe, runGitWithEnvironment } from "./process.js";
+import { executeGit, GitPlumbingError, runGitPipe } from "./process.js";
+import { deliveryEnvironment, materializeSnapshotCommit, } from "./tender.js";
 import { workspaceMergeStatePresent } from "./workspace.js";
+import { withGitDecodeChannel } from "./read-observation.js";
 export { workspaceMergeStatePresent };
 const REQUIRED_GIT = "2.38";
 async function runAllowingNonzero(repository, args, input) {
     try {
-        return { stdout: await runGit(repository, args, input), stderr: Buffer.alloc(0), status: 0 };
+        return { stdout: await executeGit(repository, args, input), stderr: Buffer.alloc(0), status: 0 };
     }
     catch (error) {
         if (!(error instanceof GitPlumbingError))
@@ -76,22 +78,34 @@ export async function worktreeChangeId(repository, input, tender) {
     const id = result.toString("utf8").trim().split(/\s/, 1)[0] ?? "";
     return mintChangeId(id === "" ? "0000000000000000000000000000000000000000" : id);
 }
+/** Reuse only recorded commits with this exact tree and sole predecessor. */
+export async function reusableIntegrationSnapshot(repository, tree, parent, recordedSnapshots) {
+    if (recordedSnapshots.length === 0)
+        return undefined;
+    return await withGitDecodeChannel(repository, async (channel) => {
+        for (const snapshot of recordedSnapshots) {
+            const oid = gitObjectIdForSnapshot(snapshot);
+            const object = (await channel.readObjects([oid])).get(oid);
+            if (object.kind === "missing")
+                continue;
+            if (object.type !== "commit") {
+                throw new AuthorityCorruptionError(`recorded integration snapshot is not a Git commit: ${snapshot}`);
+            }
+            const headers = object.bytes.toString("utf8").split("\n\n", 1)[0].split("\n");
+            const parents = headers.filter((line) => line.startsWith("parent "));
+            if (headers[0] === `tree ${tree}` && parents.length === 1 && parents[0] === `parent ${parent}`) {
+                return snapshot;
+            }
+        }
+        return undefined;
+    });
+}
 /** Materialize the exact integration tree against its observed predecessor. */
 export async function materializeIntegrationSnapshot(repository, tree, parent, metadata) {
-    const commit = (await runGitWithEnvironment(repository, ["commit-tree", tree, "-p", gitObjectIdForSnapshot(parent)], metadata.message, {
-        GIT_AUTHOR_NAME: metadata.identity.name,
-        GIT_AUTHOR_EMAIL: metadata.identity.email,
-        GIT_COMMITTER_NAME: metadata.identity.name,
-        GIT_COMMITTER_EMAIL: metadata.identity.email,
-        GIT_AUTHOR_DATE: metadata.at,
-        GIT_COMMITTER_DATE: metadata.at,
-    }))
-        .toString("utf8")
-        .trim();
-    return mintSnapshotId(commit);
+    return await materializeSnapshotCommit(repository, tree, [parent], metadata.message, deliveryEnvironment(metadata));
 }
 export async function persistedTender(repository, snapshot) {
-    const tree = (await runGit(repository, ["show", "-s", "--format=%T", gitObjectIdForSnapshot(snapshot)]))
+    const tree = (await executeGit(repository, ["show", "-s", "--format=%T", gitObjectIdForSnapshot(snapshot)]))
         .toString("ascii")
         .trim();
     return { head: snapshot, tree: gitObjectId(tree, "persisted tender tree") };
@@ -100,7 +114,7 @@ export async function materializeReintegrationSnapshot(repository, tree, parent,
     const templateObject = gitObjectIdForSnapshot(template);
     let raw;
     try {
-        raw = await runGit(repository, ["cat-file", "commit", templateObject]);
+        raw = await executeGit(repository, ["cat-file", "commit", templateObject]);
     }
     catch (error) {
         if (error instanceof GitPlumbingError) {
@@ -114,7 +128,7 @@ export async function materializeReintegrationSnapshot(repository, tree, parent,
     const message = raw.subarray(separator + 2);
     let fields;
     try {
-        const formatted = (await runGit(repository, ["show", "-s", "--format=%an%x00%ae%x00%aI%x00%cn%x00%ce%x00%cI", templateObject]))
+        const formatted = (await executeGit(repository, ["show", "-s", "--format=%an%x00%ae%x00%aI%x00%cn%x00%ce%x00%cI", templateObject]))
             .toString("utf8")
             .replace(/\n$/u, "");
         fields = formatted.split("\0");
@@ -129,17 +143,14 @@ export async function materializeReintegrationSnapshot(repository, tree, parent,
         throw new AuthorityCorruptionError(`recorded delivery snapshot metadata is malformed: ${template}`);
     }
     const [authorName, authorEmail, authorDate, committerName, committerEmail, committerDate] = fields;
-    const commit = (await runGitWithEnvironment(repository, ["commit-tree", tree, "-p", gitObjectIdForSnapshot(parent)], message, {
+    return await materializeSnapshotCommit(repository, tree, [parent], message, {
         GIT_AUTHOR_NAME: authorName,
         GIT_AUTHOR_EMAIL: authorEmail,
         GIT_AUTHOR_DATE: authorDate,
         GIT_COMMITTER_NAME: committerName,
         GIT_COMMITTER_EMAIL: committerEmail,
         GIT_COMMITTER_DATE: committerDate,
-    }))
-        .toString("utf8")
-        .trim();
-    return mintSnapshotId(commit);
+    });
 }
 async function isAncestor(repository, ancestor, descendant) {
     const result = await runAllowingNonzero(repository, [
@@ -302,7 +313,7 @@ export async function planIntegration(repository, input, tender, requireBranches
 }
 async function deliverySnapshotAvailability(repository, predecessor, candidate) {
     const objects = [gitObjectIdForSnapshot(predecessor), gitObjectIdForSnapshot(candidate)];
-    const types = (await runGit(repository, ["cat-file", "--batch-check=%(objectname) %(objecttype)"], `${objects.join("\n")}\n`))
+    const types = (await executeGit(repository, ["cat-file", "--batch-check=%(objectname) %(objecttype)"], `${objects.join("\n")}\n`))
         .toString("ascii")
         .trimEnd()
         .split("\n")
@@ -323,7 +334,7 @@ export const deliveryDiffScopeSchema = z
 })
     .strict();
 export async function readDeliveryScope(repository, predecessor, candidate, includePaths) {
-    const scope = decodeGitNumstat(await runGit(repository, [
+    const scope = decodeGitNumstat(await executeGit(repository, [
         "diff",
         "--numstat",
         "-z",
@@ -334,7 +345,7 @@ export async function readDeliveryScope(repository, predecessor, candidate, incl
         return scope;
     return {
         ...scope,
-        paths: decodeGitNameOnly(await runGit(repository, [
+        paths: decodeGitNameOnly(await executeGit(repository, [
             "diff",
             "--name-only",
             "--no-renames",
@@ -349,7 +360,7 @@ export async function readDeliveryDiff(repository, predecessor, candidate) {
     if ((await deliverySnapshotAvailability(repository, predecessor, candidate)) === "unavailable")
         return null;
     try {
-        return (await runGit(repository, [
+        return (await executeGit(repository, [
             "diff",
             "--no-ext-diff",
             "--no-color",

package/build/src/git/nuke.js

@@ -1,7 +1,7 @@
 import { access, lstat, realpath, rm } from "node:fs/promises";
 import { isAbsolute, relative, sep } from "node:path";
 import { nukeEmptyPlaceAuthority, readPlaceRegister, releaseManagedWorktrees, withPlaceAuthorityFence, } from "../workspace-place.js";
-import { GitPlumbingError, runGit } from "./process.js";
+import { GitPlumbingError, executeGit } from "./process.js";
 import { confirmPrivateStatePublication, withPrivateStatePublicationSeat, } from "./private-state-seat.js";
 import { CANDIDATE_PIN_REF_NAMESPACE, DELIVERY_REF_NAMESPACE, GIT_REF, NoGitWorldError, readRef, registeredWorktrees, repositoryAt, worktreeGitDirectory, } from "./repository.js";
 import { worktreePath } from "./workspace.js";
@@ -89,7 +89,7 @@ async function removeManagedWorktree(repository, entry) {
         return await removeUnregisteredResidue(repository, entry);
     if (registered.branch !== null)
         return false;
-    await runGit(repository, ["worktree", "remove", "--force", entry.path]);
+    await executeGit(repository, ["worktree", "remove", "--force", entry.path]);
     if ((await registeredWorktrees(repository)).some((candidate) => candidate.path === entry.path)) {
         throw new GitResetStopError(`managed Place worktree remains registered: ${entry.path}`);
     }
@@ -104,7 +104,7 @@ async function removeManagedWorktree(repository, entry) {
     throw new GitResetStopError(`managed Place worktree remains present: ${entry.path}`);
 }
 async function deleteRefAt(repository, ref, expectedOid) {
-    await runGit(repository, ["update-ref", "--no-deref", "-d", ref, expectedOid]);
+    await executeGit(repository, ["update-ref", "--no-deref", "-d", ref, expectedOid]);
 }
 async function deleteObservedStateRef(repository, expectedOid, seat) {
     try {
@@ -126,7 +126,7 @@ async function removeOwnedRefs(repository, onRemoved) {
     let removed = 0;
     const roots = [DELIVERY_REF_NAMESPACE, CANDIDATE_PIN_REF_NAMESPACE];
     for (const root of roots) {
-        const refs = (await runGit(repository, ["for-each-ref", "--format=%(refname)", root]))
+        const refs = (await executeGit(repository, ["for-each-ref", "--format=%(refname)", root]))
             .toString("utf8")
             .split("\n")
             .filter((ref) => ref.length > root.length && ref.startsWith(`${root}/`));

package/build/src/git/observe.d.ts

@@ -3,7 +3,7 @@ import type { ContractsObservation } from "../core/facts/observation.js";
 import { type GitSnapshot, type GitOid } from "./repository.js";
 import { type GitRepository } from "./process.js";
 import { type GitDecodeChannel, type GitReadObservation, type GitTreeSelection } from "./read-observation.js";
-export type TargetObservation = Readonly<{
+type TargetObservation = Readonly<{
     head: SnapshotId | null;
     drift: boolean;
 }>;
@@ -12,11 +12,11 @@ type GitJournalRecord = Readonly<{
     entries: readonly JournalEntry[];
     state: ContractState | null;
 }>;
-export type ContractWorldObservation = Readonly<{
+type ContractWorldObservation = Readonly<{
     snapshot: SnapshotId | null;
     contracts: ReadonlyMap<ContractId, GitJournalRecord>;
 }>;
-export type ActiveContractWorldObservation = ContractWorldObservation & Readonly<{
+type ActiveContractWorldObservation = ContractWorldObservation & Readonly<{
     eligibility: ContractsObservation;
 }>;
 export type GitAdmissionSnapshot = Readonly<{
@@ -34,7 +34,7 @@ export type BindCoordinatesObservation = Readonly<{
     target?: string;
     branch: string | null;
 }>;
-export type UnbornHeadObservation = Readonly<{
+type UnbornHeadObservation = Readonly<{
     kind: "unborn-head";
     branch: string | null;
 }>;

package/build/src/git/observe.js

@@ -3,7 +3,7 @@ import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { foldJournal } from "../core/facts/fold.js";
 import { contractJournalPath, contractJournalPaths, mintContractHead, mintSnapshotId, } from "./identity.js";
 import { isKeiyakuOwnedRef } from "./repository.js";
-import { GitPlumbingError, runGit } from "./process.js";
+import { GitPlumbingError, executeGit } from "./process.js";
 import { readBlobResults, readGitTreeSelection, withGitTargetedReadObservation, } from "./read-observation.js";
 export async function observeDeliveryTargetAt(observation, state) {
     const target = state.coordinates.target;
@@ -29,7 +29,7 @@ export async function normalizeTargetBranch(repository, input) {
     if (branch.length === 0 || branch.startsWith("-") || isKeiyakuOwnedRef(target))
         return null;
     try {
-        const checked = (await runGit(repository, ["check-ref-format", "--branch", branch])).toString("utf8").trim();
+        const checked = (await executeGit(repository, ["check-ref-format", "--branch", branch])).toString("utf8").trim();
         return checked === branch ? target : null;
     }
     catch (error) {
@@ -41,7 +41,7 @@ export async function normalizeTargetBranch(repository, input) {
 /** Read one worktree's attached branch, or null for detached HEAD. */
 export async function currentBranch(repository, path) {
     try {
-        const ref = (await runGit(repository, [...(path === undefined ? [] : ["-C", path]), "symbolic-ref", "--quiet", "HEAD"]))
+        const ref = (await executeGit(repository, [...(path === undefined ? [] : ["-C", path]), "symbolic-ref", "--quiet", "HEAD"]))
             .toString("utf8")
             .trim();
         return ref.startsWith("refs/heads/") ? ref : null;
@@ -64,7 +64,7 @@ function structuredFields(output, fieldCount) {
 async function observeHeadCoordinates(repository) {
     try {
         return {
-            start: mintSnapshotId((await runGit(repository, ["rev-parse", "--verify", "HEAD"])).toString("utf8").trim()),
+            start: mintSnapshotId((await executeGit(repository, ["rev-parse", "--verify", "HEAD"])).toString("utf8").trim()),
             branch: await currentBranch(repository),
         };
     }
@@ -84,7 +84,7 @@ export async function observeBindCoordinates(repository, selection = { kind: "ta
         if (isKeiyakuOwnedRef(requestedTarget)) {
             throw new Error(`bind target names a Keiyaku-owned ref: ${requestedTarget}`);
         }
-        const output = await runGit(repository, [
+        const output = await executeGit(repository, [
             "for-each-ref",
             `--format=${TARGET_COORDINATES_FORMAT}`,
             "--",

package/build/src/git/process.d.ts

@@ -16,8 +16,6 @@ export type GitRepository = Readonly<{
     /** Test-only hook after the private-state seat close attempt. */
     readonly onPrivateStateSeatClose?: () => void;
 }>;
-/** Give one caller's Git capability view its cancellation boundary. */
-export declare function withGitAbortSignal(repository: GitRepository, signal: AbortSignal | undefined): GitRepository;
 export declare class GitPlumbingError extends Error {
     readonly stdout: Buffer;
     readonly stderr: Buffer;
@@ -31,8 +29,7 @@ export declare class GitPlumbingError extends Error {
         pid?: number | null;
     }>);
 }
-export declare function runGit(repository: GitRepository, args: readonly string[], input?: string | Uint8Array): Promise<Buffer>;
+export declare function executeGit(repository: GitRepository, args: readonly string[], input?: string | Uint8Array, environment?: NodeJS.ProcessEnv): Promise<Buffer>;
 /** Connect two owned Git commands without materializing the intermediate output. */
 export declare function runGitPipe(repository: GitRepository, sourceArgs: readonly string[], sinkArgs: readonly string[]): Promise<Buffer>;
 export declare function consumeGitStdout(repository: GitRepository, args: readonly string[], consume: (chunk: Buffer) => void): Promise<void>;
-export declare function runGitWithEnvironment(repository: GitRepository, args: readonly string[], input: string | Uint8Array | undefined, environment: NodeJS.ProcessEnv): Promise<Buffer>;

package/build/src/git/process.js

@@ -1,9 +1,5 @@
 import { consumeProcessStdout, spawnCancellableProcess } from "../runtime/proc/run.js";
 import { pipeline } from "node:stream/promises";
-/** Give one caller's Git capability view its cancellation boundary. */
-export function withGitAbortSignal(repository, signal) {
-    return signal === undefined ? repository : { ...repository, signal };
-}
 export class GitPlumbingError extends Error {
     stdout;
     stderr;
@@ -32,7 +28,7 @@ function commandError(command, error) {
         pid: candidate.pid ?? null,
     });
 }
-async function executeGit(repository, args, input, environment) {
+export async function executeGit(repository, args, input, environment) {
     if (repository.signal?.aborted === true) {
         throw commandError(args, { message: "git process cancelled", status: null });
     }
@@ -81,9 +77,6 @@ async function executeGit(repository, args, input, environment) {
         pid: child.pid,
     });
 }
-export async function runGit(repository, args, input) {
-    return await executeGit(repository, args, input);
-}
 function boundedPipeOutput(child, args) {
     const stdout = [];
     let bytes = 0;
@@ -212,6 +205,3 @@ export async function consumeGitStdout(repository, args, consume) {
         pid: result.pid ?? undefined,
     });
 }
-export async function runGitWithEnvironment(repository, args, input, environment) {
-    return await executeGit(repository, args, input, environment);
-}

package/build/src/git/read-observation.js

@@ -6,7 +6,7 @@ import { GIT_FORMAT_BYTES, GIT_FORMAT_PATH, GIT_REF, readRef } from "./repositor
 import { GitPlumbingError } from "./process.js";
 const gitReadObservationBrand = Symbol("GitReadObservation");
 const gitDecodeChannelBrand = Symbol("GitDecodeChannel");
-const BATCH_RETIREMENT_GRACE_MS = 1_000;
+const BATCH_RETIREMENT_GRACE_MS = 5_000;
 function streamCursor(stream) {
     const iterator = stream[Symbol.asyncIterator]();
     let buffer = Buffer.alloc(0);

package/build/src/git/reconcile.d.ts

@@ -142,7 +142,7 @@ type ReconcileBatchItem = Readonly<{
     state: ContractState | null;
     result: ReconcileResult;
 }>;
-export type GitReconcileObservation = Readonly<{
+type GitReconcileObservation = Readonly<{
     state: ContractState | null;
     result: ReconcileResult;
 }>;

package/build/src/git/reconcile.js

@@ -8,7 +8,7 @@ import { dirname, join } from "node:path";
 import { acquireSqliteTransactionLock, SqliteTransactionLockError, } from "../coordination/sqlite-transaction-lock.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { CANDIDATE_PIN_REF_NAMESPACE, commonGitDirectory, DELIVERY_REF_NAMESPACE, registeredWorktreePaths, } from "./repository.js";
-import { runGit, GitPlumbingError } from "./process.js";
+import { executeGit, GitPlumbingError } from "./process.js";
 import { contractLocator, contractPhysicalName, gitObjectIdForSnapshot } from "./identity.js";
 import { observeContractAt } from "./observe.js";
 import { acquireTargetPlacementFence, recoverTargetPlacement } from "./target-placement.js";
@@ -158,25 +158,27 @@ async function worktree(repository, topology, path, desired) {
     if (registered && (await pathExists(path)))
         return { kind: "worktree", path, action: "unchanged" };
     if (registered) {
-        await runGit(repository, ["worktree", "remove", path]);
+        await executeGit(repository, ["worktree", "remove", path]);
         topology.paths.delete(path);
     }
     if (await pathExists(path))
         throw new WorktreeCustodyError(`delivery worktree path is occupied: ${path}`);
     await mkdir(dirname(path), { recursive: true });
-    await runGit(repository, ["worktree", "add", "--detach", path, gitObjectIdForSnapshot(desired)]);
+    await executeGit(repository, ["worktree", "add", "--detach", path, gitObjectIdForSnapshot(desired)]);
     topology.paths.add(path);
     return { kind: "worktree", path, action: "created" };
 }
-async function removeCollectableScratch(repository, topology, acc) {
-    for (const removal of await removeCollectableScratchWorktrees(repository, topology.paths)) {
-        acc.recordEffect({ kind: "worktree", path: removal.path, action: removal.action });
-        if (removal.retained)
-            acc.recordLag({
-                kind: "worktree-retained",
-                path: removal.path,
-                ...(removal.diagnostic === undefined ? {} : { diagnostic: removal.diagnostic }),
-            });
+async function removeCollectableScratch(repository, topology, acc, terminalContract) {
+    for (const removal of await removeCollectableScratchWorktrees(repository, topology.paths, terminalContract)) {
+        if (!removal.retained) {
+            acc.recordEffect({ kind: "worktree", path: removal.path, action: "removed" });
+            continue;
+        }
+        acc.recordLag({
+            kind: "worktree-retained",
+            path: removal.path,
+            ...(removal.diagnostic === undefined ? {} : { diagnostic: removal.diagnostic }),
+        });
     }
 }
 async function reconcileTargetCheckouts(repository, state, onPhysical) {
@@ -288,7 +290,7 @@ async function reconcileWithTopology(input, state, topology) {
     const acc = reconcileAccumulation(input.onPhysical);
     const { effects, lag, hookRuns } = acc;
     try {
-        await removeCollectableScratch(repository, topology, acc);
+        await removeCollectableScratch(repository, topology, acc, state?.terminal ? state.id : undefined);
         if (!state)
             return complete(effects, lag);
         const targetCheckouts = await reconcileTargetCheckouts(repository, state, input.onPhysical);

package/build/src/git/repository.d.ts

@@ -7,7 +7,6 @@ export declare const CANDIDATE_PIN_REF_NAMESPACE = "refs/keiyaku/candidate";
 export declare const HANDOFF_RECEIPT_REF_NAMESPACE = "refs/keiyaku/handoff";
 export declare const GIT_FORMAT_PATH = "meta/format.json";
 export declare const GIT_FORMAT_BYTES = "{\"version\":4}\n";
-export declare const STATE_COMMIT_SUBJECT = "keiyaku authority - do not delete or rewrite";
 export declare function isKeiyakuOwnedRef(ref: string): boolean;
 export type GitOid = string;
 export type RefPublication = Readonly<{
@@ -31,7 +30,7 @@ export declare class NoGitWorldError extends Error {
     readonly path: string;
     constructor(path: string);
 }
-export type RegisteredWorktree = Readonly<{
+type RegisteredWorktree = Readonly<{
     path: string;
     branch: string | null;
 }>;
@@ -40,12 +39,9 @@ export declare function registeredWorktreePaths(repository: GitRepository): Prom
 export declare function repositoryAt(cwd: string, gitPath?: string): Promise<GitRepository>;
 export declare function commonGitDirectory(repository: GitRepository): string;
 export declare function worktreeGitDirectory(repository: GitRepository, worktree: string): Promise<string>;
-export declare function worktreeRoot(repository: GitRepository): Promise<string>;
 export declare function readRef(repository: GitRepository, ref: string): Promise<GitOid | null>;
 /** Read an explicit set of asserted refs from one fresh Git observation. */
 export declare function readRefs(repository: GitRepository, refs: readonly string[]): Promise<Map<any, any>>;
-export declare function readTreeEntries(repository: GitRepository, tree: GitOid): Promise<Map<string, TreeEntry>>;
-export declare function readGit(repository: GitRepository): Promise<GitSnapshot>;
 /** Read only the requested private Git paths from one immutable Git tree. */
 export declare function readGitPaths(repository: GitRepository, requestedPaths: readonly string[]): Promise<GitSnapshot>;
 export declare function writeBlob(repository: GitRepository, bytes: string | Uint8Array): Promise<GitOid>;
@@ -74,7 +70,7 @@ export declare function updateRefsAtomically(repository: GitRepository, updates:
     readonly newOid: GitOid;
     readonly expectedOid: GitOid;
 })[], assertions?: readonly GitRefAssertion[]): Promise<RefPublication>;
-export type GitDiffStat = Readonly<{
+type GitDiffStat = Readonly<{
     filesChanged: number;
     insertions: number;
     deletions: number;