@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/git/repository.js

@@ -6,15 +6,21 @@ import { parseTreeObject, prepareTreeUpdate, treeUpdate, validPath, } from "./tr
 export const GIT_REF = "refs/heads/keiyaku-state";
 export const DELIVERY_REF_NAMESPACE = "refs/heads/keiyaku-delivery";
 export const CANDIDATE_PIN_REF_NAMESPACE = "refs/heads/keiyaku-candidate";
+export const MIGRATION_DELIVERY_REF_NAMESPACE = "refs/keiyaku/delivery";
+export const MIGRATION_CANDIDATE_PIN_REF_NAMESPACE = "refs/keiyaku/candidate";
 export const GIT_FORMAT_PATH = "meta/format.json";
 const CURRENT_FORMAT_VERSION = 4;
 export const GIT_FORMAT_BYTES = `{"version":${CURRENT_FORMAT_VERSION}}\n`;
 export function isKeiyakuOwnedRef(ref) {
-    return ref === GIT_REF
-        || ref === DELIVERY_REF_NAMESPACE
-        || ref.startsWith(`${DELIVERY_REF_NAMESPACE}/`)
-        || ref === CANDIDATE_PIN_REF_NAMESPACE
-        || ref.startsWith(`${CANDIDATE_PIN_REF_NAMESPACE}/`);
+    return (ref === GIT_REF ||
+        ref === DELIVERY_REF_NAMESPACE ||
+        ref.startsWith(`${DELIVERY_REF_NAMESPACE}/`) ||
+        ref === CANDIDATE_PIN_REF_NAMESPACE ||
+        ref.startsWith(`${CANDIDATE_PIN_REF_NAMESPACE}/`) ||
+        ref === MIGRATION_DELIVERY_REF_NAMESPACE ||
+        ref.startsWith(`${MIGRATION_DELIVERY_REF_NAMESPACE}/`) ||
+        ref === MIGRATION_CANDIDATE_PIN_REF_NAMESPACE ||
+        ref.startsWith(`${MIGRATION_CANDIDATE_PIN_REF_NAMESPACE}/`));
 }
 export class NoGitWorldError extends Error {
     path;
@@ -181,15 +187,7 @@ export async function readGitPaths(repository, requestedPaths) {
     if (commit === null)
         return { commit: null, tree: null, paths: new Map() };
     const tree = await readTreeForCommit(repository, commit);
-    const paths = parseTreeEntries(await runGit(repository, [
-        "ls-tree",
-        "-z",
-        "--full-tree",
-        tree,
-        "--",
-        GIT_FORMAT_PATH,
-        ...requestedPaths,
-    ]));
+    const paths = parseTreeEntries(await runGit(repository, ["ls-tree", "-z", "--full-tree", tree, "--", GIT_FORMAT_PATH, ...requestedPaths]));
     await validateGitFormat(repository, paths);
     return { commit, tree, paths };
 }
@@ -394,14 +392,7 @@ export async function updateRefsAtomically(repository, updates, assertions = [])
     if (git === undefined || git.ref !== GIT_REF) {
         throw new Error(`the first atomic update must be the Git ref: ${GIT_REF}`);
     }
-    const lines = [
-        "start",
-        ...assertions.map(refAssertionLine),
-        ...updates.map(refUpdateLine),
-        "prepare",
-        "commit",
-        "",
-    ];
+    const lines = ["start", ...assertions.map(refAssertionLine), ...updates.map(refUpdateLine), "prepare", "commit", ""];
     try {
         await runGit(repository, ["update-ref", "--stdin"], lines.join("\n"));
         return { kind: "published" };

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

@@ -4,14 +4,17 @@ export type MaterializedScratchCandidate = Readonly<{
     cwd: string;
     dispose: () => Promise<WorktreeLeak | null>;
 }>;
-export type CollectableScratchWorktree = Readonly<{
-    path: string;
-    release(): void;
-}>;
 export type WorktreeLeak = Readonly<{
     path: string;
     diagnostic: string;
 }>;
-export declare function collectableScratchWorktrees(paths: Iterable<string>): Promise<readonly CollectableScratchWorktree[]>;
+type CollectableScratchRemoval = Readonly<{
+    path: string;
+    action: "removed" | "unchanged";
+    retained: boolean;
+}>;
+/** Remove only abandoned Verification scratch worktrees whose ownership locks are held. */
+export declare function removeCollectableScratchWorktrees(repository: GitRepository, paths: Set<string>): Promise<readonly CollectableScratchRemoval[]>;
 /** Materialize a disposable candidate worktree and own only its removal. */
 export declare function materializeScratchCandidate(repository: GitRepository, candidate: SnapshotId): Promise<MaterializedScratchCandidate>;
+export {};

package/build/src/git/scratch.js

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { realpath } from "node:fs/promises";
+import { access, realpath } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { tryAcquireSqliteTransactionLock, } from "../coordination/sqlite-transaction-lock.js";
@@ -17,7 +17,7 @@ function ownershipLockPath(path) {
     const match = SCRATCH_PATTERN.exec(basename(path));
     return match === null ? null : join(SCRATCH_ROOT, `.${SCRATCH_PREFIX}${match[1]}.owner.sqlite`);
 }
-export async function collectableScratchWorktrees(paths) {
+async function collectableScratchWorktrees(paths) {
     const collectable = [];
     for (const path of paths) {
         const lockPath = ownershipLockPath(path);
@@ -29,6 +29,33 @@ export async function collectableScratchWorktrees(paths) {
     }
     return collectable;
 }
+const pathExists = (path) => access(path).then(() => true, () => false);
+/** Remove only abandoned Verification scratch worktrees whose ownership locks are held. */
+export async function removeCollectableScratchWorktrees(repository, paths) {
+    const removals = [];
+    for (const scratch of await collectableScratchWorktrees(paths)) {
+        try {
+            if (!(await pathExists(scratch.path))) {
+                await runGit(repository, ["worktree", "remove", scratch.path]);
+                paths.delete(scratch.path);
+                removals.push({ path: scratch.path, action: "removed", retained: false });
+                continue;
+            }
+            try {
+                await runGit(repository, ["worktree", "remove", "--force", scratch.path]);
+                paths.delete(scratch.path);
+                removals.push({ path: scratch.path, action: "removed", retained: false });
+            }
+            catch {
+                removals.push({ path: scratch.path, action: "unchanged", retained: true });
+            }
+        }
+        finally {
+            scratch.release();
+        }
+    }
+    return removals;
+}
 /** Materialize a disposable candidate worktree and own only its removal. */
 export async function materializeScratchCandidate(repository, candidate) {
     const cwd = scratchPath();

package/build/src/git/target-placement.d.ts

@@ -2,12 +2,6 @@ import { type HeldSqliteTransactionLock } from "../coordination/sqlite-transacti
 import type { ContractId, ContractState, SnapshotId } from "../core/facts/types.js";
 import type { RefOperation } from "../core/facts/offer.js";
 import { type GitRepository } from "./process.js";
-export type WorkspaceNotOnTargetRefusal = Readonly<{
-    kind: "workspace-not-on-target";
-    contractId: ContractId;
-    target: string;
-    branch: string | null;
-}>;
 export type CheckoutNotFollowableRefusal = Readonly<{
     kind: "checkout-not-followable";
     contractId: ContractId;
@@ -16,7 +10,7 @@ export type CheckoutNotFollowableRefusal = Readonly<{
     reason: "staged" | "conflict" | "untracked";
     paths: readonly string[];
 }>;
-export type TargetPlacementRefusal = CheckoutNotFollowableRefusal | WorkspaceNotOnTargetRefusal;
+export type TargetPlacementRefusal = CheckoutNotFollowableRefusal;
 export type TargetCheckoutEffect = Readonly<{
     kind: "target-checkout";
     path: string;
@@ -34,7 +28,7 @@ export type TargetPlacementPhysicalResult = Readonly<{
     lag: readonly TargetCheckoutLag[];
 }>;
 type FollowArm = Readonly<{
-    kind: "ordinary" | "here";
+    kind: "ordinary";
     path: string;
 }>;
 export type PreparedTargetPlacement = Readonly<{
@@ -58,7 +52,6 @@ export type TargetPlacementObservationInput = Readonly<{
     coordinates: TargetedContractCoordinates;
     predecessor: SnapshotId;
     candidate: SnapshotId;
-    hereWorkspacePath?: string;
 }>;
 export type TargetPlacementObservation = Readonly<{
     kind: "ready";
@@ -87,7 +80,13 @@ export type AuditTargetAnswer = Readonly<{
 }>;
 /** Adjudicate the complete post-Verification audit target answer without placing. */
 export declare function adjudicateAuditTarget(repository: GitRepository, input: TargetPlacementObservationInput): Promise<AuditTargetAnswer>;
-export declare function prepareTargetPlacement(repository: GitRepository, state: ContractState, target: RefOperation, hereWorkspacePath?: string): Promise<TargetPlacementPreparation>;
+export declare function prepareTargetPlacement(repository: GitRepository, state: ContractState, target: RefOperation): Promise<TargetPlacementPreparation>;
 export declare function followTargetPlacement(repository: GitRepository, prepared: PreparedTargetPlacement): Promise<TargetPlacementPhysicalResult>;
+/** Judge the target-checkout shape without mutating refs, worktrees, or indexes. */
+export declare function observeTargetCheckoutShape(repository: GitRepository, input: Readonly<{
+    path: string;
+    predecessor: SnapshotId;
+    candidate: SnapshotId;
+}>): Promise<"complete" | "recoverable" | "retained">;
 export declare function recoverTargetPlacement(repository: GitRepository, state: ContractState): Promise<TargetPlacementPhysicalResult>;
 export {};

package/build/src/git/target-placement.js

@@ -1,10 +1,9 @@
 import { lstat } from "node:fs/promises";
 import { resolve } from "node:path";
-import { acquireSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
+import { acquireSqliteTransactionLock, } from "../coordination/sqlite-transaction-lock.js";
 import { gitObjectId, gitObjectIdForSnapshot, gitRefLocator, mintSnapshotId } from "./identity.js";
-import { currentBranch } from "./observe.js";
-import { commonGitDirectory, readRef, registeredWorktrees, } from "./repository.js";
-import { consumeGitStdout, GitPlumbingError, runGit, } from "./process.js";
+import { commonGitDirectory, readRef, registeredWorktrees } from "./repository.js";
+import { consumeGitStdout, GitPlumbingError, runGit } from "./process.js";
 import { captureWorkspaceTree } from "./workspace.js";
 export async function observeTargetHead(repository, target) {
     const value = await readRef(repository, target);
@@ -26,9 +25,7 @@ function literalPath(path) {
     return `:(literal)${path}`;
 }
 async function commitTree(repository, snapshot) {
-    return gitObjectId((await runGit(repository, ["show", "-s", "--format=%T", gitObjectIdForSnapshot(snapshot)]))
-        .toString("utf8")
-        .trim(), "commit tree");
+    return gitObjectId((await runGit(repository, ["show", "-s", "--format=%T", gitObjectIdForSnapshot(snapshot)])).toString("utf8").trim(), "commit tree");
 }
 function checkoutRefusal(contractId, target, path, reason, paths) {
     return { kind: "checkout-not-followable", contractId, target: target.target, path, reason, paths };
@@ -64,11 +61,18 @@ async function dryRunRefusal(input, scopes) {
     const dirty = await gitPaths(repository, path, ["diff-files", "--name-only", "-z", "--", ...pathspecs]);
     if (dirty.length > 0)
         return checkoutRefusal(contractId, target, path, "conflict", dirty);
-    const unmerged = await gitPaths(repository, path, ["diff", "--name-only", "--diff-filter=U", "-z", "--", ...pathspecs]);
+    const unmerged = await gitPaths(repository, path, [
+        "diff",
+        "--name-only",
+        "--diff-filter=U",
+        "-z",
+        "--",
+        ...pathspecs,
+    ]);
     if (unmerged.length > 0)
         return checkoutRefusal(contractId, target, path, "conflict", unmerged);
-    return await untrackedRefusalWithinScopes(input, scopes, false)
-        ?? checkoutRefusal(contractId, target, path, "conflict", []);
+    return ((await untrackedRefusalWithinScopes(input, scopes, false)) ??
+        checkoutRefusal(contractId, target, path, "conflict", []));
 }
 async function physicalScope(worktree, candidatePath) {
     const components = candidatePath.split("/");
@@ -93,7 +97,10 @@ async function physicalScope(worktree, candidatePath) {
 }
 async function candidateEntryIsBlob(repository, path, candidate, candidatePath) {
     const output = await runGit(repository, ["-C", path, "ls-tree", "-z", candidate, "--", literalPath(candidatePath)]);
-    const records = output.toString("utf8").split("\0").filter((record) => record.length > 0);
+    const records = output
+        .toString("utf8")
+        .split("\0")
+        .filter((record) => record.length > 0);
     if (records.length !== 1)
         throw new Error(`candidate path has no unique Git entry: ${candidatePath}`);
     const separator = records[0].indexOf("\t");
@@ -142,13 +149,7 @@ async function untrackedRefusalWithinScopes(input, scopes, ignored) {
         if (scope.kind !== "directory")
             continue;
         let found = false;
-        await consumeGitStdout(repository, [
-            "-C",
-            path,
-            ...args,
-            "--",
-            literalPath(scope.path),
-        ], (chunk) => {
+        await consumeGitStdout(repository, ["-C", path, ...args, "--", literalPath(scope.path)], (chunk) => {
             if (chunk.length > 0)
                 found = true;
         });
@@ -158,10 +159,11 @@ async function untrackedRefusalWithinScopes(input, scopes, ignored) {
     return null;
 }
 async function indexMatchesTreeOnPaths(repository, path, tree, paths) {
-    return (await gitPaths(repository, path, ["diff-index", "--cached", "--name-only", "-z", tree, "--", ...paths])).length === 0;
+    return ((await gitPaths(repository, path, ["diff-index", "--cached", "--name-only", "-z", tree, "--", ...paths])).length ===
+        0);
 }
 async function workspaceMatchesTreeOnPaths(repository, path, tree, workspaceTree, paths) {
-    return (await gitPaths(repository, path, ["diff", "--name-only", "-z", tree, workspaceTree, "--", ...paths])).length === 0;
+    return ((await gitPaths(repository, path, ["diff", "--name-only", "-z", tree, workspaceTree, "--", ...paths])).length === 0);
 }
 async function ordinaryPrecheck(repository, contractId, target, path) {
     const predecessor = gitObjectIdForSnapshot(target.expectedOid);
@@ -199,35 +201,13 @@ export async function observeTargetPlacement(repository, input) {
     const worktrees = (await registeredWorktrees(repository))
         .filter((worktree) => worktree.branch === target.target)
         .sort((left, right) => left.path.localeCompare(right.path));
-    const hereSource = input.coordinates.workspace === "here" ? input.hereWorkspacePath ?? null : null;
-    if (hereSource !== null) {
-        const branch = await currentBranch(repository, hereSource);
-        if (branch !== target.target) {
-            return {
-                kind: "refused",
-                refusal: {
-                    kind: "workspace-not-on-target",
-                    contractId: input.contractId,
-                    target: target.target,
-                    branch,
-                },
-            };
-        }
-    }
     const arms = [];
     for (const worktree of worktrees) {
-        const kind = hereSource !== null && resolve(worktree.path) === hereSource ? "here" : "ordinary";
-        if (kind === "ordinary") {
-            const refusal = await ordinaryPrecheck(repository, input.contractId, target, worktree.path);
-            if (refusal !== null)
-                return { kind: "refused", refusal };
-        }
-        arms.push({ kind, path: worktree.path });
+        const refusal = await ordinaryPrecheck(repository, input.contractId, target, worktree.path);
+        if (refusal !== null)
+            return { kind: "refused", refusal };
+        arms.push({ kind: "ordinary", path: worktree.path });
     }
-    if (input.coordinates.workspace === "here" && hereSource === null)
-        throw new Error("targeted here workspace is unappointed");
-    if (hereSource !== null && !arms.some((arm) => arm.kind === "here"))
-        throw new Error("targeted here workspace is not a registered checkout of its target");
     return { kind: "ready", arms };
 }
 /** Adjudicate the complete post-Verification audit target answer without placing. */
@@ -252,7 +232,7 @@ export async function adjudicateAuditTarget(repository, input) {
         return { kind: "failed", diagnostic: error.message };
     }
 }
-export async function prepareTargetPlacement(repository, state, target, hereWorkspacePath) {
+export async function prepareTargetPlacement(repository, state, target) {
     if (state.coordinates.target !== target.target || state.currentIntegration?.snapshot !== target.newOid) {
         throw new Error("placement state does not match its offered target movement");
     }
@@ -261,7 +241,6 @@ export async function prepareTargetPlacement(repository, state, target, hereWork
         coordinates: { ...state.coordinates, target: target.target },
         predecessor: target.expectedOid,
         candidate: target.newOid,
-        ...(hereWorkspacePath === undefined ? {} : { hereWorkspacePath }),
     });
     return observation.kind === "refused"
         ? observation
@@ -274,10 +253,7 @@ export async function followTargetPlacement(repository, prepared) {
     const candidate = gitObjectIdForSnapshot(prepared.target.newOid);
     for (const arm of prepared.arms) {
         try {
-            if (arm.kind === "here")
-                await runGit(repository, ["-C", arm.path, "read-tree", candidate]);
-            else
-                await runGit(repository, ["-C", arm.path, "read-tree", "-m", "-u", predecessor, candidate]);
+            await runGit(repository, ["-C", arm.path, "read-tree", "-m", "-u", predecessor, candidate]);
             effects.push({ kind: "target-checkout", path: arm.path, target: prepared.target.target, action: "followed" });
         }
         catch (error) {
@@ -294,22 +270,46 @@ export async function followTargetPlacement(repository, prepared) {
 function recoveryLag(path, target, detail) {
     return { kind: "target-checkout-retained", path, target, diagnostic: detail };
 }
-async function recoverCheckout(input) {
-    const { repository, path, predecessor, candidate, predecessorTree, candidateTree } = input;
+async function classifyCheckout(input) {
+    const { repository, path, predecessorTree, candidateTree } = input;
     const changedPaths = await gitPaths(repository, path, ["diff", "--name-only", "-z", predecessorTree, candidateTree]);
     if (changedPaths.length === 0)
-        return "complete";
+        return { kind: "complete" };
     const workspaceTree = (await captureWorkspaceTree(repository, path)).tree;
     const candidateIndex = await indexMatchesTreeOnPaths(repository, path, candidateTree, changedPaths);
     const candidateWorkspace = await workspaceMatchesTreeOnPaths(repository, path, candidateTree, workspaceTree, changedPaths);
     if (candidateIndex && candidateWorkspace)
+        return { kind: "complete" };
+    if (workspaceTree === candidateTree)
+        return { kind: "recoverable", action: "candidate-index" };
+    const predecessorIndex = await indexMatchesTreeOnPaths(repository, path, predecessorTree, changedPaths);
+    if (predecessorIndex && candidateWorkspace)
+        return { kind: "recoverable", action: "index-merge" };
+    return !predecessorIndex ||
+        !(await workspaceMatchesTreeOnPaths(repository, path, predecessorTree, workspaceTree, changedPaths))
+        ? { kind: "retained" }
+        : { kind: "recoverable", action: "worktree-merge" };
+}
+/** Judge the target-checkout shape without mutating refs, worktrees, or indexes. */
+export async function observeTargetCheckoutShape(repository, input) {
+    const [predecessorTree, candidateTree] = await Promise.all([
+        commitTree(repository, input.predecessor),
+        commitTree(repository, input.candidate),
+    ]);
+    return (await classifyCheckout({ repository, ...input, predecessorTree, candidateTree })).kind;
+}
+async function recoverCheckout(input) {
+    const classified = await classifyCheckout(input);
+    if (classified.kind === "complete")
         return "complete";
-    if (workspaceTree === candidateTree) {
+    if (classified.kind === "retained")
+        return "retained";
+    const { repository, path, predecessor, candidate } = input;
+    if (classified.action === "candidate-index") {
         await runGit(repository, ["-C", path, "read-tree", gitObjectIdForSnapshot(candidate)]);
         return "recovered";
     }
-    const predecessorIndex = await indexMatchesTreeOnPaths(repository, path, predecessorTree, changedPaths);
-    if (predecessorIndex && candidateWorkspace) {
+    if (classified.action === "index-merge") {
         await runGit(repository, [
             "-C",
             path,
@@ -321,9 +321,6 @@ async function recoverCheckout(input) {
         ]);
         return "recovered";
     }
-    const predecessorWorkspace = await workspaceMatchesTreeOnPaths(repository, path, predecessorTree, workspaceTree, changedPaths);
-    if (!predecessorIndex || !predecessorWorkspace)
-        return "retained";
     await runGit(repository, [
         "-C",
         path,
@@ -341,7 +338,7 @@ export async function recoverTargetPlacement(repository, state) {
     if (state.terminal?.kind !== "claimed" || target === undefined || delivery === null)
         return { effects: [], lag: [] };
     const integration = state.currentIntegration;
-    if (integration === null || await readRef(repository, target) !== integration.snapshot)
+    if (integration === null || (await readRef(repository, target)) !== integration.snapshot)
         return { effects: [], lag: [] };
     const candidateTree = await commitTree(repository, integration.snapshot);
     const predecessorTree = await commitTree(repository, integration.predecessor);

package/build/src/git/tender.js

@@ -1,46 +1,20 @@
 import { access } from "node:fs/promises";
 import { gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
-import { decodeGitNumstat, registeredWorktreePaths, } from "./repository.js";
-import { GitPlumbingError, runGit, runGitWithEnvironment, } from "./process.js";
-import { captureWorkspaceTree, worktreePath } from "./workspace.js";
-async function workspaceExists(repository, workspace, path) {
+import { decodeGitNumstat, registeredWorktreePaths } from "./repository.js";
+import { GitPlumbingError, runGit, runGitWithEnvironment } from "./process.js";
+import { captureWorkspaceTree, unmergedWorkspacePaths, workspaceMergeHead, worktreePath } from "./workspace.js";
+async function workspaceExists(repository, path) {
     const exists = await access(path).then(() => true, () => false);
-    return workspace === "here"
-        || (exists && (await registeredWorktreePaths(repository)).includes(path));
+    return exists && (await registeredWorktreePaths(repository)).includes(path);
 }
 function workspaceFor(repository, input) {
     if (input.workspacePath !== undefined)
         return input.workspacePath;
     return input.place === undefined ? undefined : worktreePath(repository, input.place);
 }
-async function workspaceMergeHead(repository, workspace) {
-    try {
-        return mintSnapshotId((await runGit(repository, ["-C", workspace, "rev-parse", "-q", "--verify", "MERGE_HEAD"]))
-            .toString("utf8")
-            .trim());
-    }
-    catch (error) {
-        if (error instanceof GitPlumbingError && error.status === 1)
-            return undefined;
-        throw error;
-    }
-}
-async function unmergedWorkspacePaths(repository, workspace) {
-    const records = (await runGit(repository, ["-C", workspace, "ls-files", "--unmerged", "-z"]))
-        .toString("utf8")
-        .split("\0");
-    const paths = new Set();
-    for (const record of records.slice(0, -1)) {
-        const separator = record.indexOf("\t");
-        if (separator < 0)
-            throw new Error(`malformed unmerged index record: ${record}`);
-        paths.add(record.slice(separator + 1));
-    }
-    return [...paths].sort();
-}
 export async function captureTender(repository, input) {
     const workspace = workspaceFor(repository, input);
-    if (workspace === undefined || !(await workspaceExists(repository, input.coordinates.workspace, workspace))) {
+    if (workspace === undefined || !(await workspaceExists(repository, workspace))) {
         return { kind: "refused", refusal: { kind: "worktree-missing", contractId: input.contractId } };
     }
     if (input.rejectUnmerged === true) {
@@ -49,22 +23,14 @@ export async function captureTender(repository, input) {
             return { kind: "refused", refusal: { kind: "unmerged-paths", contractId: input.contractId, paths } };
     }
     const captured = await captureWorkspaceTree(repository, workspace);
-    const mergeHead = input.captureMergeState === true
-        ? await workspaceMergeHead(repository, workspace)
-        : undefined;
+    const mergeHead = input.captureMergeState === true ? await workspaceMergeHead(repository, workspace) : undefined;
     return {
         kind: "prepared",
         data: { ...captured, ...(mergeHead === undefined ? {} : { mergeHead }) },
     };
 }
 async function dirtyShortStat(repository, tender) {
-    return decodeGitNumstat(await runGit(repository, [
-        "diff",
-        "--numstat",
-        "-z",
-        gitObjectIdForSnapshot(tender.head),
-        tender.tree,
-    ]));
+    return decodeGitNumstat(await runGit(repository, ["diff", "--numstat", "-z", gitObjectIdForSnapshot(tender.head), tender.tree]));
 }
 export async function dirtyTenderRefusal(repository, contractId, tender) {
     return {
@@ -104,9 +70,8 @@ export async function prepareDeliveryCommitMetadata(repository, input) {
             effectiveConfig(repository, "user.name"),
             effectiveConfig(repository, "user.email"),
         ]);
-        identity = name !== undefined && email !== undefined
-            ? { name, email }
-            : { name: "Keiyaku", email: "keiyaku@localhost" };
+        identity =
+            name !== undefined && email !== undefined ? { name, email } : { name: "Keiyaku", email: "keiyaku@localhost" };
     }
     const subject = input.message ?? `${input.contractId}: ${input.title}`;
     return {
@@ -129,6 +94,8 @@ export async function materializeTenderSnapshot(repository, tender, commit) {
         GIT_COMMITTER_EMAIL: commit.identity.email,
         GIT_AUTHOR_DATE: commit.at,
         GIT_COMMITTER_DATE: commit.at,
-    })).toString("utf8").trim();
+    }))
+        .toString("utf8")
+        .trim();
     return mintSnapshotId(oid);
 }

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

@@ -0,0 +1,21 @@
+import type { ContractState, SnapshotId } from "../core/facts/types.js";
+import type { GitDecodeChannel } from "./read-observation.js";
+import { type WorktreeHooks } from "./hooks.js";
+import { type GitRepository } from "./process.js";
+import type { Effect, ReconcileAccumulation, ReconcileResult, WorktreeTopology } from "./reconcile.js";
+type TerminalReconcileInput = Readonly<{
+    repository: GitRepository;
+    channel: GitDecodeChannel;
+    hooks: WorktreeHooks;
+    retryHooks: boolean;
+    retainTerminalWorktree?: boolean;
+    place?: string;
+}>;
+type TerminalCustodyRefs = Readonly<{
+    ref: string;
+    pin: string;
+}>;
+export declare function updateRef(repository: GitRepository, ref: string, desired: SnapshotId): Promise<Effect>;
+export declare function removeRef(repository: GitRepository, ref: string): Promise<Effect>;
+export declare function reconcileTerminalManagedWorktree({ repository, channel, hooks, retryHooks, retainTerminalWorktree, place }: TerminalReconcileInput, state: ContractState, topology: WorktreeTopology, acc: ReconcileAccumulation, { ref, pin }: TerminalCustodyRefs): Promise<ReconcileResult>;
+export {};