@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/dispatch/index.js

@@ -41,8 +41,9 @@ function decode(path, bytes) {
     if (keys.length !== 3 || keys.some((key) => !["akuId", "contractId", "dispatchedAt"].includes(key))) {
         corruption(`Dispatch has invalid fields: ${path}`);
     }
-    if (typeof record.akuId !== "string" || typeof record.contractId !== "string"
-        || typeof record.dispatchedAt !== "string") {
+    if (typeof record.akuId !== "string" ||
+        typeof record.contractId !== "string" ||
+        typeof record.dispatchedAt !== "string") {
         corruption(`Dispatch has invalid values: ${path}`);
     }
     let akuId;
@@ -81,8 +82,7 @@ export async function readDispatch(repository, value) {
     return await dispatchFromSnapshot(repository, await readGitPaths(repository, [path]), akuId);
 }
 export async function readDispatchesAt(observation) {
-    const entries = [...observation.snapshot.paths]
-        .filter(([path, entry]) => path.startsWith(DISPATCH_PREFIX) && entry.type === "blob");
+    const entries = [...observation.snapshot.paths].filter(([path, entry]) => path.startsWith(DISPATCH_PREFIX) && entry.type === "blob");
     const blobs = await observation.readBlobs(entries.map(([, entry]) => entry.oid));
     const dispatches = [];
     const seen = new Set();
@@ -151,11 +151,13 @@ export async function publishDispatch(input) {
                 message: `dispatch ${akuId}`,
                 at: intended.dispatchedAt,
             });
-            const publication = await updateRefsAtomically(input.repository, [{
+            const publication = await updateRefsAtomically(input.repository, [
+                {
                     ref: GIT_REF,
                     newOid: commit,
                     expectedOid: snapshot.commit,
-                }]);
+                },
+            ]);
             if (publication.kind === "published")
                 return { kind: "dispatched", dispatch: intended };
             const observed = await observedPublication(input.repository, akuId, owner);

package/build/src/duration.js

@@ -14,7 +14,11 @@ export function parseDuration(value) {
     return { kind: "parsed", milliseconds: Number(milliseconds) };
 }
 export function formatDuration(milliseconds) {
-    for (const [unit, multiplier] of [["h", 3_600_000], ["m", 60_000], ["s", 1_000]]) {
+    for (const [unit, multiplier] of [
+        ["h", 3_600_000],
+        ["m", 60_000],
+        ["s", 1_000],
+    ]) {
         if (milliseconds >= multiplier && milliseconds % multiplier === 0)
             return `${milliseconds / multiplier}${unit}`;
     }

package/build/src/git/admission.js

@@ -1,4 +1,4 @@
-import { decodeJournal, encodeEntry, } from "../core/facts/codec.js";
+import { decodeJournal, encodeEntry } from "../core/facts/codec.js";
 import { GIT_FORMAT_BYTES, GIT_FORMAT_PATH, GIT_REF, updateGitTreeFromFrozenDirectories, updateRefsAtomically, writeBlob, writeCommit, } from "./repository.js";
 import { contractJournalPath, contractJournalPaths, gitObjectIdForSnapshot, mintContractHead, mintSnapshotId, } from "./identity.js";
 import { validPath } from "./tree.js";
@@ -95,11 +95,13 @@ async function publishOffer(repository, admission, target, changes, assertions)
         { ref: GIT_REF, newOid: gitObjectIdForSnapshot(gitCommit), expectedOid: snapshot.commit },
         ...(target === null
             ? []
-            : [{
+            : [
+                {
                     ref: target.target,
                     newOid: gitObjectIdForSnapshot(target.newOid),
                     expectedOid: gitObjectIdForSnapshot(target.expectedOid),
-                }]),
+                },
+            ]),
     ], assertions);
 }
 export async function admit(repository, offer, admission, assertions = []) {

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

@@ -29,6 +29,14 @@ export type WorktreeHookLag = Readonly<{
 }>;
 type HookPhase = "create" | "destroy";
 export declare function hookMarkerPath(administrationDirectory: string): string;
+export type WorktreeHookMarkerObservation = Readonly<{
+    kind: "absent" | "pending" | "ok";
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+}>;
+/** Read the durable hook marker without executing commands or taking locks. */
+export declare function observeWorktreeHookMarker(administrationDirectory: string): Promise<WorktreeHookMarkerObservation>;
 export type HookCommandRun = Readonly<{
     kind: "ok";
 }> | Readonly<{

package/build/src/git/hooks.js

@@ -24,7 +24,9 @@ function decodeCommand(value, coordinate) {
     }
     if (value.argv[0].trim().length === 0)
         throw new Error(`${coordinate}.argv[0] must be nonblank`);
-    if (!Number.isSafeInteger(value.timeoutMs) || value.timeoutMs < 1 || value.timeoutMs > 2_147_483_647) {
+    if (!Number.isSafeInteger(value.timeoutMs) ||
+        value.timeoutMs < 1 ||
+        value.timeoutMs > 2_147_483_647) {
         throw new Error(`${coordinate}.timeoutMs is invalid`);
     }
     return { argv: value.argv, timeoutMs: value.timeoutMs };
@@ -40,10 +42,19 @@ function decodeFailure(value, coordinate) {
     switch (value.kind) {
         case "exit":
             exactKeys(value, ["kind", "code", "stdout", "stderr", "truncated"], coordinate);
-            if (!Number.isInteger(value.code) || typeof value.stdout !== "string" || typeof value.stderr !== "string" || typeof value.truncated !== "boolean") {
+            if (!Number.isInteger(value.code) ||
+                typeof value.stdout !== "string" ||
+                typeof value.stderr !== "string" ||
+                typeof value.truncated !== "boolean") {
                 throw new Error(`${coordinate} is invalid`);
             }
-            return { kind: "exit", code: value.code, stdout: value.stdout, stderr: value.stderr, truncated: value.truncated };
+            return {
+                kind: "exit",
+                code: value.code,
+                stdout: value.stdout,
+                stderr: value.stderr,
+                truncated: value.truncated,
+            };
         case "timeout":
         case "unknown-exit":
             exactKeys(value, ["kind"], coordinate);
@@ -76,7 +87,11 @@ function decodeProgress(value, commands, coordinate) {
         if (!Number.isInteger(value.command) || value.command < 0 || value.command >= commands) {
             throw new Error(`${coordinate}.command is invalid`);
         }
-        return { status: "failed", command: value.command, failure: decodeFailure(value.failure, `${coordinate}.failure`) };
+        return {
+            status: "failed",
+            command: value.command,
+            failure: decodeFailure(value.failure, `${coordinate}.failure`),
+        };
     }
     throw new Error(`${coordinate}.status is invalid`);
 }
@@ -114,6 +129,28 @@ async function readMarker(administrationDirectory) {
         throw error;
     }
 }
+function hookFailureDiagnostic(phase, progress) {
+    const failure = progress.failure;
+    const detail = failure.kind === "exit"
+        ? `exit=${failure.code}`
+        : failure.kind === "spawn-error"
+            ? failure.diagnostic
+            : failure.kind;
+    return `worktree-hook-failed ${phase} command=${progress.command} ${detail}`;
+}
+/** Read the durable hook marker without executing commands or taking locks. */
+export async function observeWorktreeHookMarker(administrationDirectory) {
+    const marker = await readMarker(administrationDirectory);
+    if (marker === null)
+        return { kind: "absent" };
+    if (marker.create.status === "failed")
+        return { kind: "failed", diagnostic: hookFailureDiagnostic("create", marker.create) };
+    if (marker.destroy.status === "failed")
+        return { kind: "failed", diagnostic: hookFailureDiagnostic("destroy", marker.destroy) };
+    if (marker.create.status === "pending" || marker.destroy.status === "pending")
+        return { kind: "pending" };
+    return { kind: "ok" };
+}
 async function writeMarker(administrationDirectory, marker) {
     const path = hookMarkerPath(administrationDirectory);
     await mkdir(dirname(path), { recursive: true });
@@ -129,13 +166,15 @@ function freshMarker(commands, createPending) {
 }
 function failedOutcome(outcome) {
     if (outcome.kind === "terminal") {
-        return outcome.code === 0 ? null : {
-            kind: "exit",
-            code: outcome.code,
-            stdout: outcome.stdout,
-            stderr: outcome.stderr,
-            truncated: outcome.truncated,
-        };
+        return outcome.code === 0
+            ? null
+            : {
+                kind: "exit",
+                code: outcome.code,
+                stdout: outcome.stdout,
+                stderr: outcome.stderr,
+                truncated: outcome.truncated,
+            };
     }
     return outcome;
 }
@@ -239,7 +278,9 @@ async function executePendingCommand(input) {
         const failure = result.kind === "failed" ? result.failure : null;
         const next = input.command + 1;
         await writeMarker(input.administrationDirectory, withProgress(marker, input.phase, failure === null
-            ? next === marker.commands[input.phase].length ? { status: "ok" } : { status: "pending", next }
+            ? next === marker.commands[input.phase].length
+                ? { status: "ok" }
+                : { status: "pending", next }
             : { status: "failed", command: input.command, failure }));
     }
     finally {
@@ -280,7 +321,13 @@ async function runPhase(worktree, administrationDirectory, hooks, phase, retryHo
             return null;
         if (progress.status === "failed") {
             if (!retryFailure) {
-                return { kind: "worktree-hook-failed", phase, path: worktree, command: progress.command, failure: progress.failure };
+                return {
+                    kind: "worktree-hook-failed",
+                    phase,
+                    path: worktree,
+                    command: progress.command,
+                    failure: progress.failure,
+                };
             }
             retryFailure = false;
             await writeMarker(administrationDirectory, withProgress(marker, phase, { status: "pending", next: progress.command }));
@@ -299,7 +346,9 @@ export function runCreateHooks(worktree, administrationDirectory, hooks, retryHo
 export function runDestroyHooks(worktree, administrationDirectory, hooks, retryHooks) {
     return runPhase(worktree, administrationDirectory, hooks, "destroy", retryHooks);
 }
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1] && process.argv[2] === "--run-hook") {
+if (process.argv[1] !== undefined &&
+    fileURLToPath(import.meta.url) === process.argv[1] &&
+    process.argv[2] === "--run-hook") {
     const encoded = process.argv[3];
     if (encoded === undefined)
         throw new Error("Hook runner input is missing");

package/build/src/git/identity.js

@@ -23,10 +23,7 @@ export function contractJournalPath(contract, journalClass = "active") {
     return `contracts/${journalClass}/${contractJournalSuffix(contract)}`;
 }
 export function contractJournalPaths(contract) {
-    return [
-        contractJournalPath(contract, "active"),
-        contractJournalPath(contract, "terminal"),
-    ];
+    return [contractJournalPath(contract, "active"), contractJournalPath(contract, "terminal")];
 }
 export function gitObjectId(value, label = "Git object ID") {
     if (!GIT_OBJECT_ID.test(value))

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

@@ -3,6 +3,8 @@ import type { ChangeId, ContractCoordinates, ContractId, SnapshotId } from "../c
 import { type GitObjectId } from "./identity.js";
 import { type GitRepository } from "./process.js";
 import type { DeliveryCommitMetadata, TenderCapture } from "./tender.js";
+import { workspaceMergeStatePresent } from "./workspace.js";
+export { workspaceMergeStatePresent };
 type IntegrationTender = Pick<TenderCapture, "head" | "tree">;
 declare const REQUIRED_GIT: "2.38";
 export type IntegrationPreparationRefusal = Readonly<{
@@ -30,8 +32,6 @@ export declare function worktreeChangeId(repository: GitRepository, input: Integ
 export declare function materializeIntegrationSnapshot(repository: GitRepository, tree: GitObjectId, parent: SnapshotId, metadata: DeliveryCommitMetadata): Promise<SnapshotId>;
 export declare function persistedTender(repository: GitRepository, snapshot: SnapshotId): Promise<IntegrationTender>;
 export declare function materializeReintegrationSnapshot(repository: GitRepository, tree: GitObjectId, parent: SnapshotId, template: SnapshotId): Promise<SnapshotId>;
-/** True when the appointed workspace already has Git MERGE_HEAD. */
-export declare function workspaceMergeStatePresent(repository: GitRepository, workspace: string): Promise<boolean>;
 /** Project the already-judged conflict as `git merge --no-commit <targetHead>`. */
 export declare function materializeJudgedConflict(repository: GitRepository, workspace: string, targetHead: SnapshotId): Promise<void>;
 export declare function planIntegration(repository: GitRepository, input: IntegrationCoordinates, tender: IntegrationTender, requireBranchesToBeUpToDate: boolean): Promise<Preparation<IntegrationPlan, Readonly<{
@@ -48,4 +48,3 @@ export type DeliveryDiffScope = Readonly<{
 export declare function readDeliveryScope(repository: GitRepository, predecessor: SnapshotId, candidate: SnapshotId, includePaths: boolean): Promise<DeliveryDiffScope>;
 /** Read a recorded integration pair's patch, or null when Git no longer has it. */
 export declare function readDeliveryDiff(repository: GitRepository, predecessor: SnapshotId, candidate: SnapshotId): Promise<string | null>;
-export {};

package/build/src/git/integration.js

@@ -1,7 +1,9 @@
 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, runGitWithEnvironment, } from "./process.js";
+import { decodeGitNameOnly, decodeGitNumstat, readRef } from "./repository.js";
+import { GitPlumbingError, runGit, runGitWithEnvironment } from "./process.js";
+import { workspaceMergeStatePresent } from "./workspace.js";
+export { workspaceMergeStatePresent };
 const REQUIRED_GIT = "2.38";
 async function runAllowingNonzero(repository, args, input) {
     try {
@@ -16,12 +18,18 @@ async function runAllowingNonzero(repository, args, input) {
 /** Mint the one worktree-content identity shared by review and delivery. */
 export async function worktreeChangeId(repository, input, tender) {
     const patch = await runGit(repository, [
-        "-c", "core.quotePath=false",
-        "-c", "core.abbrev=40",
-        "-c", "diff.algorithm=myers",
-        "-c", "diff.renames=false",
-        "-c", "diff.indentHeuristic=false",
-        "-c", "diff.suppressBlankEmpty=false",
+        "-c",
+        "core.quotePath=false",
+        "-c",
+        "core.abbrev=40",
+        "-c",
+        "diff.algorithm=myers",
+        "-c",
+        "diff.renames=false",
+        "-c",
+        "diff.indentHeuristic=false",
+        "-c",
+        "diff.suppressBlankEmpty=false",
         "diff",
         "--no-ext-diff",
         "--no-textconv",
@@ -53,7 +61,9 @@ export async function materializeIntegrationSnapshot(repository, tree, parent, m
         GIT_COMMITTER_EMAIL: metadata.identity.email,
         GIT_AUTHOR_DATE: metadata.at,
         GIT_COMMITTER_DATE: metadata.at,
-    })).toString("utf8").trim();
+    }))
+        .toString("utf8")
+        .trim();
     return mintSnapshotId(commit);
 }
 export async function persistedTender(repository, snapshot) {
@@ -80,12 +90,9 @@ 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,
-        ])).toString("utf8").replace(/\n$/u, "");
+        const formatted = (await runGit(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");
     }
     catch (error) {
@@ -105,7 +112,9 @@ export async function materializeReintegrationSnapshot(repository, tree, parent,
         GIT_COMMITTER_NAME: committerName,
         GIT_COMMITTER_EMAIL: committerEmail,
         GIT_COMMITTER_DATE: committerDate,
-    })).toString("utf8").trim();
+    }))
+        .toString("utf8")
+        .trim();
     return mintSnapshotId(commit);
 }
 async function isAncestor(repository, ancestor, descendant) {
@@ -192,26 +201,6 @@ async function mergedTree(repository, contractId, base, targetHead, tenderTree)
         message: "git merge-tree --write-tree failed",
     });
 }
-/** True when the appointed workspace already has Git MERGE_HEAD. */
-export async function workspaceMergeStatePresent(repository, workspace) {
-    const result = await runAllowingNonzero(repository, [
-        "-C",
-        workspace,
-        "rev-parse",
-        "-q",
-        "--verify",
-        "MERGE_HEAD",
-    ]);
-    if (result.status === 0)
-        return true;
-    if (result.status === 1)
-        return false;
-    throw new GitPlumbingError({
-        stderr: result.stderr,
-        status: result.status,
-        message: "git rev-parse --verify MERGE_HEAD failed",
-    });
-}
 /** Project the already-judged conflict as `git merge --no-commit <targetHead>`. */
 export async function materializeJudgedConflict(repository, workspace, targetHead) {
     const result = await runAllowingNonzero(repository, [
@@ -289,7 +278,11 @@ 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`)).toString("ascii").trimEnd().split("\n").map((record) => record.split(" ")[1]);
+    const types = (await runGit(repository, ["cat-file", "--batch-check=%(objectname) %(objecttype)"], `${objects.join("\n")}\n`))
+        .toString("ascii")
+        .trimEnd()
+        .split("\n")
+        .map((record) => record.split(" ")[1]);
     if (types.includes("missing"))
         return "unavailable";
     if (types.some((type) => type !== "commit")) {
@@ -322,7 +315,7 @@ export async function readDeliveryScope(repository, predecessor, candidate, incl
 }
 /** Read a recorded integration pair's patch, or null when Git no longer has it. */
 export async function readDeliveryDiff(repository, predecessor, candidate) {
-    if (await deliverySnapshotAvailability(repository, predecessor, candidate) === "unavailable")
+    if ((await deliverySnapshotAvailability(repository, predecessor, candidate)) === "unavailable")
         return null;
     try {
         return (await runGit(repository, [
@@ -334,7 +327,7 @@ export async function readDeliveryDiff(repository, predecessor, candidate) {
         ])).toString("utf8");
     }
     catch (error) {
-        if (await deliverySnapshotAvailability(repository, predecessor, candidate) === "unavailable")
+        if ((await deliverySnapshotAvailability(repository, predecessor, candidate)) === "unavailable")
             return null;
         throw error;
     }

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

@@ -1,2 +1,2 @@
 import type { WorldRoot } from "../world.js";
-export declare function nukeGit(world: WorldRoot): Promise<void>;
+export declare function nukeGit(world: WorldRoot, gitPath?: string): Promise<void>;

package/build/src/git/nuke.js

@@ -1,52 +1,90 @@
-import { access } from "node:fs/promises";
-import { nukeHereAppointments } from "../contract-worktree.js";
-import { nukeEmptyPlaceAuthority, readPlaceRegister, releaseManagedWorktrees, } from "../workspace-place.js";
+import { access, lstat, realpath, rm } from "node:fs/promises";
+import { isAbsolute, relative, sep } from "node:path";
+import { nukeEmptyPlaceAuthority, readPlaceRegister, releaseManagedWorktrees } from "../workspace-place.js";
 import { nukeWorktreeHookResidue } from "./hooks.js";
 import { runGit } from "./process.js";
-import { NoGitWorldError, registeredWorktrees, repositoryAt, worktreeGitDirectory } from "./repository.js";
+import { CANDIDATE_PIN_REF_NAMESPACE, DELIVERY_REF_NAMESPACE, GIT_REF, MIGRATION_CANDIDATE_PIN_REF_NAMESPACE, MIGRATION_DELIVERY_REF_NAMESPACE, NoGitWorldError, readRef, registeredWorktrees, repositoryAt, worktreeGitDirectory, } from "./repository.js";
 import { worktreePath } from "./workspace.js";
 async function managedCustody(repository) {
     const register = await readPlaceRegister(repository);
-    const topology = new Map((await registeredWorktrees(repository)).map((entry) => [entry.path, entry]));
-    const entries = [];
-    for (const appointment of register.appointments) {
-        const path = worktreePath(repository, appointment.place);
-        const registered = topology.get(path);
-        if (registered === undefined) {
-            try {
-                await access(path);
-            }
-            catch {
-                entries.push({ contract: appointment.contract, path });
-                continue;
-            }
-            throw new Error(`managed Place path has foreign custody: ${path}`);
-        }
-        if (registered.branch !== null)
-            throw new Error(`managed Place path has a branch: ${path}`);
-        entries.push({ contract: appointment.contract, path });
-    }
-    const refs = (await runGit(repository, [
-        "for-each-ref", "--format=%(refname)", "refs/heads/keiyaku-delivery", "refs/heads/keiyaku-candidate",
-    ])).toString("utf8").split("\n").filter((ref) => ref.length > 0);
-    const state = await runGit(repository, ["show-ref", "--verify", "--quiet", "refs/heads/keiyaku-state"])
-        .then(() => true, () => false);
-    return { entries, refs, state };
+    return {
+        entries: register.appointments.map((appointment) => ({
+            contract: appointment.contract,
+            path: worktreePath(repository, appointment.place),
+        })),
+    };
 }
-async function removeManagedWorktree(repository, entry) {
-    const topology = await registeredWorktrees(repository);
-    const registered = topology.find((candidate) => candidate.path === entry.path);
-    if (registered === undefined) {
-        try {
-            await access(entry.path);
-        }
-        catch {
-            return;
-        }
+function underCommonDirectory(commonDirectory, administrationDirectory) {
+    const suffix = relative(commonDirectory, administrationDirectory);
+    return suffix.length > 0 && suffix !== ".." && !suffix.startsWith(`..${sep}`) && !isAbsolute(suffix);
+}
+async function unregisteredResidueBelongsToRepository(repository, path) {
+    let physical;
+    try {
+        physical = await lstat(path);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+    if (!physical.isDirectory() || physical.isSymbolicLink())
+        return false;
+    let administrationDirectory;
+    try {
+        administrationDirectory = await worktreeGitDirectory(repository, path);
+    }
+    catch {
+        return false;
+    }
+    try {
+        const [common, administration] = await Promise.all([
+            realpath(repository.commonDirectory),
+            realpath(administrationDirectory),
+        ]);
+        return underCommonDirectory(common, administration);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function removeUnregisteredResidue(repository, entry) {
+    let present = true;
+    try {
+        await access(entry.path);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            present = false;
+        else
+            throw error;
+    }
+    if (!present)
+        return true;
+    if (!(await unregisteredResidueBelongsToRepository(repository, entry.path))) {
         throw new Error(`managed Place path has foreign custody: ${entry.path}`);
     }
+    const administrationDirectory = await worktreeGitDirectory(repository, entry.path);
+    await nukeWorktreeHookResidue(administrationDirectory);
+    await rm(entry.path, { recursive: true, force: true });
+    try {
+        await access(entry.path);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+    throw new Error(`managed Place worktree remains present: ${entry.path}`);
+}
+async function removeManagedWorktree(repository, entry) {
+    const registered = (await registeredWorktrees(repository)).find((candidate) => candidate.path === entry.path);
+    if (registered === undefined)
+        return await removeUnregisteredResidue(repository, entry);
     if (registered.branch !== null)
-        throw new Error(`managed Place path has a branch: ${entry.path}`);
+        return false;
     await nukeWorktreeHookResidue(await worktreeGitDirectory(repository, entry.path));
     await runGit(repository, ["worktree", "remove", "--force", entry.path]);
     if ((await registeredWorktrees(repository)).some((candidate) => candidate.path === entry.path)) {
@@ -55,38 +93,53 @@ async function removeManagedWorktree(repository, entry) {
     try {
         await access(entry.path);
     }
-    catch {
-        return;
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
     }
     throw new Error(`managed Place worktree remains present: ${entry.path}`);
 }
-async function removeOwnedRefs(repository, refs) {
-    for (const ref of refs) {
-        const oid = (await runGit(repository, ["rev-parse", "--verify", "--quiet", ref])).toString("utf8").trim();
-        if (oid.length > 0)
-            await runGit(repository, ["update-ref", "--no-deref", "-d", ref, oid]);
+async function deleteRefAt(repository, ref, expectedOid) {
+    await runGit(repository, ["update-ref", "--no-deref", "-d", ref, expectedOid]);
+}
+async function removeOwnedRefs(repository) {
+    const roots = [
+        DELIVERY_REF_NAMESPACE,
+        CANDIDATE_PIN_REF_NAMESPACE,
+        MIGRATION_DELIVERY_REF_NAMESPACE,
+        MIGRATION_CANDIDATE_PIN_REF_NAMESPACE,
+    ];
+    for (const root of roots) {
+        const refs = (await runGit(repository, ["for-each-ref", "--format=%(refname)", root]))
+            .toString("utf8")
+            .split("\n")
+            .filter((ref) => ref.length > root.length && ref.startsWith(`${root}/`));
+        for (const ref of refs) {
+            const oid = await readRef(repository, ref);
+            if (oid !== null)
+                await deleteRefAt(repository, ref, oid);
+        }
     }
 }
-export async function nukeGit(world) {
+export async function nukeGit(world, gitPath = "git") {
     let repository;
     try {
-        repository = await repositoryAt(world);
+        repository = await repositoryAt(world, gitPath);
     }
     catch (error) {
         if (error instanceof NoGitWorldError)
             return;
         throw error;
     }
+    const state = await readRef(repository, GIT_REF);
+    if (state !== null)
+        await deleteRefAt(repository, GIT_REF, state);
     const custody = await managedCustody(repository);
     for (const entry of custody.entries) {
-        await removeManagedWorktree(repository, entry);
-        await releaseManagedWorktrees(repository, [entry.contract]);
+        if (await removeManagedWorktree(repository, entry))
+            await releaseManagedWorktrees(repository, [entry.contract]);
     }
-    await nukeHereAppointments(repository);
     await nukeEmptyPlaceAuthority(repository);
-    await removeOwnedRefs(repository, custody.refs);
-    if (custody.state) {
-        const oid = (await runGit(repository, ["rev-parse", "--verify", "refs/heads/keiyaku-state"])).toString("utf8").trim();
-        await runGit(repository, ["update-ref", "--no-deref", "-d", "refs/heads/keiyaku-state", oid]);
-    }
+    await removeOwnedRefs(repository);
 }

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

@@ -34,11 +34,23 @@ export type BindCoordinatesObservation = Readonly<{
     target?: string;
     branch: string | null;
 }>;
+export type UnbornHeadObservation = Readonly<{
+    kind: "unborn-head";
+    branch: string | null;
+}>;
+export type BindTargetSelection = Readonly<{
+    kind: "explicit";
+    target: string;
+}> | Readonly<{
+    kind: "current-branch";
+}> | Readonly<{
+    kind: "targetless";
+}>;
 export declare function normalizeTargetBranch(repository: GitRepository, input: string): Promise<string | null>;
 /** Read one worktree's attached branch, or null for detached HEAD. */
 export declare function currentBranch(repository: GitRepository, path?: string): Promise<string | null>;
 /** Observe bind's tender start and optional reward target without creating persistent state. */
-export declare function observeBindCoordinates(repository: GitRepository, requestedTarget?: string): Promise<BindCoordinatesObservation | null>;
+export declare function observeBindCoordinates(repository: GitRepository, selection?: BindTargetSelection): Promise<BindCoordinatesObservation | UnbornHeadObservation | null>;
 export declare function observeActiveContractWorld(observation: GitReadObservation): Promise<ActiveContractWorldObservation>;
 export declare function observeContractWorld(observation: GitReadObservation, requested?: readonly ContractId[]): Promise<ContractWorldObservation>;
 export declare function observeContractsForAdmissionAt(repository: GitRepository, channel: GitDecodeChannel, ids: readonly ContractId[], selection?: GitTreeSelection): Promise<GitDecisionObservation>;