@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/git/observe.js

@@ -2,7 +2,7 @@ import { decodeJournal } from "../core/facts/codec.js";
 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 { isKeiyakuOwnedRef } from "./repository.js";
 import { GitPlumbingError, runGit } from "./process.js";
 import { readGitTreeSelection, withGitTargetedReadObservation, } from "./read-observation.js";
 export async function observeDeliveryTargetAt(observation, state) {
@@ -14,9 +14,7 @@ export async function observeDeliveryTargetAt(observation, state) {
     const integration = state.currentIntegration;
     if (integration === null)
         return { head, drift: false };
-    const expected = state.terminal?.kind === "claimed"
-        ? integration.snapshot
-        : integration.predecessor;
+    const expected = state.terminal?.kind === "claimed" ? integration.snapshot : integration.predecessor;
     return { head, drift: head !== expected };
 }
 const TARGET_COORDINATES_FORMAT = "%(refname)%00%(objectname)%00";
@@ -43,12 +41,9 @@ 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",
-        ])).toString("utf8").trim();
+        const ref = (await runGit(repository, [...(path === undefined ? [] : ["-C", path]), "symbolic-ref", "--quiet", "HEAD"]))
+            .toString("utf8")
+            .trim();
         return ref.startsWith("refs/heads/") ? ref : null;
     }
     catch (error) {
@@ -66,39 +61,54 @@ function structuredFields(output, fieldCount) {
         malformedBindCoordinatesOutput();
     return fields.slice(0, -1);
 }
+async function observeHeadCoordinates(repository) {
+    try {
+        return {
+            start: mintSnapshotId((await runGit(repository, ["rev-parse", "--verify", "HEAD"])).toString("utf8").trim()),
+            branch: await currentBranch(repository),
+        };
+    }
+    catch (error) {
+        if (error instanceof GitPlumbingError &&
+            error.status === 128 &&
+            error.stderr.toString("utf8").includes("Needed a single revision")) {
+            return { kind: "unborn-head", branch: await currentBranch(repository) };
+        }
+        throw error;
+    }
+}
 /** Observe bind's tender start and optional reward target without creating persistent state. */
-export async function observeBindCoordinates(repository, requestedTarget) {
-    if (requestedTarget === undefined) {
+export async function observeBindCoordinates(repository, selection = { kind: "targetless" }) {
+    if (selection.kind === "explicit") {
+        const requestedTarget = selection.target;
+        if (isKeiyakuOwnedRef(requestedTarget)) {
+            throw new Error(`bind target names a Keiyaku-owned ref: ${requestedTarget}`);
+        }
+        const output = await runGit(repository, [
+            "for-each-ref",
+            `--format=${TARGET_COORDINATES_FORMAT}`,
+            "--",
+            requestedTarget,
+        ]);
+        if (output.length === 0)
+            return null;
+        const [target, start] = structuredFields(output, 2);
+        if (target !== requestedTarget || start === undefined)
+            malformedBindCoordinatesOutput();
         try {
-            return {
-                start: mintSnapshotId((await runGit(repository, ["rev-parse", "--verify", "HEAD"])).toString("utf8").trim()),
-                branch: await currentBranch(repository),
-            };
+            return { target, start: mintSnapshotId(start), branch: await currentBranch(repository) };
         }
         catch {
             malformedBindCoordinatesOutput();
         }
     }
-    if (isKeiyakuOwnedRef(requestedTarget)) {
-        throw new Error(`bind target names a Keiyaku-owned ref: ${requestedTarget}`);
-    }
-    const output = await runGit(repository, [
-        "for-each-ref",
-        `--format=${TARGET_COORDINATES_FORMAT}`,
-        "--",
-        requestedTarget,
-    ]);
-    if (output.length === 0)
-        return null;
-    const [target, start] = structuredFields(output, 2);
-    if (target !== requestedTarget || start === undefined)
-        malformedBindCoordinatesOutput();
-    try {
-        return { target, start: mintSnapshotId(start), branch: await currentBranch(repository) };
-    }
-    catch {
-        malformedBindCoordinatesOutput();
+    const observed = await observeHeadCoordinates(repository);
+    if ("kind" in observed)
+        return observed;
+    if (selection.kind === "current-branch" && observed.branch !== null) {
+        return { start: observed.start, target: observed.branch, branch: observed.branch };
     }
+    return observed;
 }
 function decodeGitJournal(path, git, bytes, expectedId) {
     const journal = git.paths.get(path);
@@ -108,9 +118,9 @@ function decodeGitJournal(path, git, bytes, expectedId) {
         throw new AuthorityCorruptionError(`journal path is not a blob: ${path}`);
     const entries = decodeJournal(bytes.toString("utf8"));
     const first = entries[0];
-    if (first === undefined
-        || (expectedId !== undefined && first.contract !== expectedId)
-        || entries.some((entry) => entry.contract !== (expectedId ?? first.contract))) {
+    if (first === undefined ||
+        (expectedId !== undefined && first.contract !== expectedId) ||
+        entries.some((entry) => entry.contract !== (expectedId ?? first.contract))) {
         if (expectedId !== undefined) {
             throw new AuthorityCorruptionError(`journal content does not canonically identify ${expectedId}: ${path}`);
         }
@@ -136,8 +146,7 @@ function observeDecodedJournal(id, decoded, path) {
     };
 }
 function observeFromGit(git, id, blobs) {
-    const matches = contractJournalPaths(id)
-        .flatMap((path) => git.paths.has(path) ? [path] : []);
+    const matches = contractJournalPaths(id).flatMap((path) => (git.paths.has(path) ? [path] : []));
     if (matches.length > 1)
         throw new AuthorityCorruptionError(`duplicate contract journal identity: ${id}`);
     const path = matches[0];
@@ -175,8 +184,7 @@ function enumerateContractObservations(git, blobs, journalClass) {
 }
 export async function observeActiveContractWorld(observation) {
     const git = observation.snapshot;
-    const journals = [...git.paths]
-        .filter(([path, entry]) => path.startsWith("contracts/active/") && path.endsWith(".jsonl") && entry.type === "blob");
+    const journals = [...git.paths].filter(([path, entry]) => path.startsWith("contracts/active/") && path.endsWith(".jsonl") && entry.type === "blob");
     const results = await observation.readBlobs(journals.map(([, entry]) => entry.oid));
     const blobs = new Map();
     for (const [path, entry] of journals) {
@@ -198,8 +206,7 @@ export async function observeActiveContractWorld(observation) {
 }
 export async function observeContractWorld(observation, requested = []) {
     const git = observation.snapshot;
-    const journals = [...git.paths]
-        .filter(([path, entry]) => /^contracts\/(?:active|terminal)\//u.test(path) && path.endsWith(".jsonl") && entry.type === "blob");
+    const journals = [...git.paths].filter(([path, entry]) => /^contracts\/(?:active|terminal)\//u.test(path) && path.endsWith(".jsonl") && entry.type === "blob");
     const results = await observation.readBlobs(journals.map(([, entry]) => entry.oid));
     const blobs = new Map();
     for (const [path, entry] of journals) {

package/build/src/git/process.js

@@ -19,7 +19,7 @@ function commandError(command, error) {
     const candidate = error;
     const stderr = candidate.stderr === undefined ? Buffer.alloc(0) : Buffer.from(candidate.stderr);
     const stdout = candidate.stdout === undefined ? Buffer.alloc(0) : Buffer.from(candidate.stdout);
-    const detail = stderr.length === 0 ? candidate.message ?? "git command failed" : stderr.toString("utf8");
+    const detail = stderr.length === 0 ? (candidate.message ?? "git command failed") : stderr.toString("utf8");
     return new GitPlumbingError({
         stdout,
         stderr,
@@ -47,7 +47,9 @@ async function executeGit(repository, args, input, environment) {
         stderr.push(retained);
         stderrBytes += retained.length;
     });
-    child.stdin.on("error", (error) => { inputError = error; });
+    child.stdin.on("error", (error) => {
+        inputError = error;
+    });
     child.stdin.end(input);
     const terminal = await new Promise((resolveTerminal) => {
         child.once("error", (error) => resolveTerminal({ code: null, error }));

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

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { gitObjectId } from "./identity.js";
 import { parseTreeObject, validPath } from "./tree.js";
-import { GIT_FORMAT_BYTES, GIT_FORMAT_PATH, GIT_REF, readRef, } from "./repository.js";
+import { GIT_FORMAT_BYTES, GIT_FORMAT_PATH, GIT_REF, readRef } from "./repository.js";
 import { GitPlumbingError } from "./process.js";
 const gitReadObservationBrand = Symbol("GitReadObservation");
 const gitDecodeChannelBrand = Symbol("GitDecodeChannel");
@@ -52,8 +52,12 @@ function batchObjectReader(repository) {
     let spawnError = null;
     let failure = null;
     child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
-    child.on("error", (error) => { spawnError = error; });
-    child.stdin.on("error", (error) => { spawnError ??= error; });
+    child.on("error", (error) => {
+        spawnError = error;
+    });
+    child.stdin.on("error", (error) => {
+        spawnError ??= error;
+    });
     const plumbingError = (message, status) => new GitPlumbingError({
         stderr: Buffer.concat(stderr),
         status,
@@ -64,7 +68,7 @@ function batchObjectReader(repository) {
         if (spawnError !== null)
             throw spawnError;
         await new Promise((resolve, reject) => {
-            child.stdin.write(value, (error) => error === null || error === undefined ? resolve() : reject(error));
+            child.stdin.write(value, (error) => (error === null || error === undefined ? resolve() : reject(error)));
         });
     };
     const read = async (oid) => {
@@ -252,7 +256,7 @@ async function readFormat(observation) {
 export async function withGitDecodeChannel(repository, consume) {
     const transport = { reader: null };
     let active = true;
-    const objectReader = () => transport.reader ??= batchObjectReader(repository);
+    const objectReader = () => (transport.reader ??= batchObjectReader(repository));
     const channel = {
         [gitDecodeChannelBrand]: true,
         readObjects: (oids) => {
@@ -329,9 +333,7 @@ async function observeEpoch(repository, channel, selection, consume) {
             if (commitObject === undefined)
                 throw new Error(`missing state commit result: ${commit}`);
             const tree = await commitTree(commitObject, commit);
-            const observed = selection === null
-                ? await completeTree(channel, tree)
-                : await readGitTreeSelection(channel, tree, selection);
+            const observed = selection === null ? await completeTree(channel, tree) : await readGitTreeSelection(channel, tree, selection);
             snapshot = { commit, tree, paths: observed.paths };
             treeDirectories = observed.directories;
         }

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

@@ -4,11 +4,17 @@ import type { ContractId, ContractState, SnapshotId } from "../core/facts/types.
 import type { GitDecodeChannel } from "./read-observation.js";
 import { type TargetCheckoutEffect, type TargetCheckoutLag } from "./target-placement.js";
 import { type WorktreeHookLag, type WorktreeHooks } from "./hooks.js";
-import { type UnsealedBytes } from "./terminal-seal.js";
+import type { UnsealedBytes } from "./terminal-seal.js";
 export type Effect = Readonly<{
     kind: "worktree";
     path: string;
     action: "created" | "removed" | "unchanged";
+}> | Readonly<{
+    kind: "worktree";
+    path: string;
+    action: "followed";
+    before: SnapshotId;
+    after: SnapshotId;
 }> | Readonly<{
     kind: "recovery-snapshot";
     action: "created";
@@ -34,12 +40,19 @@ type WorktreeRetained = Readonly<{
     kind: "worktree-retained";
     path: string;
 }>;
+type WorktreeFollowRetained = Readonly<{
+    kind: "worktree-follow-retained";
+    path: string;
+    tender: SnapshotId;
+    head: SnapshotId;
+    reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
+}>;
 export type ReconcileFailure = Readonly<{
     kind: "reconcile-failed";
     stage: "observation" | "effect";
     diagnostic: string;
 }>;
-export type ReconcileLag = WorktreeRetained | UnsealedBytes | TargetCheckoutLag | WorktreeHookLag | ReconcileFailure;
+export type ReconcileLag = WorktreeRetained | WorktreeFollowRetained | UnsealedBytes | TargetCheckoutLag | WorktreeHookLag | ReconcileFailure;
 export type ReconcileResult = Readonly<{
     effects: readonly Effect[];
     lag: readonly ReconcileLag[];
@@ -53,6 +66,13 @@ export type GitReconcileObservation = Readonly<{
     state: ContractState | null;
     result: ReconcileResult;
 }>;
+export type WorktreeTopology = Readonly<{
+    paths: Set<string>;
+}>;
+export type ReconcileAccumulation = Readonly<{
+    effects: Effect[];
+    lag: ReconcileLag[];
+}>;
 export declare function reconcile(input: ReconcileInput): Promise<GitReconcileObservation>;
 export declare function reconcileObservationFailure(error: unknown): ReconcileResult;
 export declare function reconcileEffectFailure(error: unknown, prior?: ReconcileResult): ReconcileResult;

package/build/src/git/reconcile.js

@@ -1,16 +1,16 @@
 import { access, mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { acquireSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
+import { acquireSqliteTransactionLock, } from "../coordination/sqlite-transaction-lock.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { CANDIDATE_PIN_REF_NAMESPACE, commonGitDirectory, DELIVERY_REF_NAMESPACE, isKeiyakuOwnedRef, readRef, registeredWorktreePaths, writeCommit, worktreeGitDirectory, } from "./repository.js";
-import { GitPlumbingError, runGit } from "./process.js";
-import { contractLocator, contractPhysicalName, gitObjectIdForSnapshot, mintSnapshotId, } from "./identity.js";
+import { CANDIDATE_PIN_REF_NAMESPACE, commonGitDirectory, DELIVERY_REF_NAMESPACE, registeredWorktreePaths, worktreeGitDirectory, } from "./repository.js";
+import { runGit } from "./process.js";
+import { contractLocator, contractPhysicalName, gitObjectIdForSnapshot } from "./identity.js";
 import { observeContractAt } from "./observe.js";
 import { acquireTargetPlacementFence, recoverTargetPlacement, } from "./target-placement.js";
-import { runCreateHooks, runDestroyHooks, } from "./hooks.js";
-import { worktreePath } from "./workspace.js";
-import { collectableScratchWorktrees } from "./scratch.js";
-import { terminalSealExpectations as decodeTerminalSealExpectations, terminalSealSnapshots, observeTerminalWorkspace, } from "./terminal-seal.js";
+import { runCreateHooks } from "./hooks.js";
+import { followManagedWorktree, worktreePath } from "./workspace.js";
+import { removeCollectableScratchWorktrees } from "./scratch.js";
+import { reconcileTerminalManagedWorktree, removeRef, updateRef } from "./terminal-reconcile.js";
 const pathExists = (path) => access(path).then(() => true, () => false);
 function deliveryRefFor(contract) {
     return `${DELIVERY_REF_NAMESPACE}/${contractPhysicalName(contract)}`;
@@ -25,49 +25,9 @@ function missingPlaceLag(repository) {
         diagnostic: `managed Contract is unappointed: ${join(repository.commonDirectory, "keiyaku", "places.json")}`,
     };
 }
-async function updateRef(repository, ref, desired) {
-    const before = await readRef(repository, ref);
-    if (before === desired)
-        return { kind: "ref", name: ref, action: "unchanged", before, after: desired };
-    await runGit(repository, [
-        "update-ref",
-        "--no-deref",
-        ref,
-        gitObjectIdForSnapshot(desired),
-        before ?? "0".repeat(desired.length),
-    ]);
-    return { kind: "ref", name: ref, action: before === null ? "created" : "updated", before, after: desired };
-}
-async function removeRef(repository, ref) {
-    const before = await readRef(repository, ref);
-    if (before === null)
-        return { kind: "ref", name: ref, action: "unchanged", before: null, after: null };
-    await runGit(repository, ["update-ref", "--no-deref", "-d", ref, before]);
-    return { kind: "ref", name: ref, action: "removed", before, after: null };
-}
-async function removeRefWithCustody(repository, ref, custodian, expectedCustodian) {
-    const before = await readRef(repository, ref);
-    if (before === null)
-        return { kind: "ref", name: ref, action: "unchanged", before: null, after: null };
-    if (await readRef(repository, custodian) !== expectedCustodian) {
-        return { kind: "ref", name: ref, action: "unchanged", before, after: before };
-    }
-    await runGit(repository, ["update-ref", "--stdin", "--no-deref"], [
-        "start",
-        `verify ${custodian} ${gitObjectIdForSnapshot(expectedCustodian)}`,
-        `delete ${ref} ${before}`,
-        "prepare",
-        "commit",
-        "",
-    ].join("\n"));
-    return { kind: "ref", name: ref, action: "removed", before, after: null };
-}
 async function acquireWorktreeTopology(repository) {
     return { paths: new Set(await registeredWorktreePaths(repository)) };
 }
-function fromPrimaryWorktree(repository) {
-    return { ...repository, effectiveCwd: repository.primaryWorktree };
-}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -85,7 +45,7 @@ function reconcileLockPath(repository, contract) {
 }
 async function worktree(repository, topology, path, desired) {
     const registered = topology.paths.has(path);
-    if (registered && await pathExists(path))
+    if (registered && (await pathExists(path)))
         return { kind: "worktree", path, action: "unchanged" };
     if (registered) {
         await runGit(repository, ["worktree", "remove", path]);
@@ -98,70 +58,12 @@ async function worktree(repository, topology, path, desired) {
     topology.paths.add(path);
     return { kind: "worktree", path, action: "created" };
 }
-async function removeWorktree(repository, topology, path, force = false) {
-    const registered = topology.paths.has(path);
-    if (!registered) {
-        return {
-            effect: { kind: "worktree", path, action: "unchanged" },
-            retained: await pathExists(path),
-        };
-    }
-    if (!await pathExists(path)) {
-        await runGit(repository, ["worktree", "remove", path]);
-        topology.paths.delete(path);
-        return { effect: { kind: "worktree", path, action: "removed" }, retained: false };
-    }
-    try {
-        await runGit(repository, ["worktree", "remove", ...(force ? ["--force"] : []), path]);
-    }
-    catch {
-        return { effect: { kind: "worktree", path, action: "unchanged" }, retained: true };
-    }
-    topology.paths.delete(path);
-    return { effect: { kind: "worktree", path, action: "removed" }, retained: false };
-}
 async function removeCollectableScratch(repository, topology, effects, lag) {
-    for (const scratch of await collectableScratchWorktrees(topology.paths)) {
-        try {
-            const removal = await removeWorktree(repository, topology, scratch.path, true);
-            effects.push(removal.effect);
-            if (removal.retained)
-                lag.push({ kind: "worktree-retained", path: scratch.path });
-        }
-        finally {
-            scratch.release();
-        }
-    }
-}
-async function refRows(repository) {
-    const output = (await runGit(repository, [
-        "for-each-ref",
-        "--format=%(refname)%00%(objectname)",
-    ])).toString("utf8");
-    if (output.length === 0)
-        return [];
-    return output.trimEnd().split("\n").map((row) => {
-        const [ref, oid, extra] = row.split("\0");
-        if (ref === undefined || oid === undefined || extra !== undefined)
-            throw new Error("Git ref row is malformed");
-        return { ref, oid };
-    });
-}
-async function snapshotCustodian(repository, snapshot) {
-    for (const row of await refRows(repository)) {
-        if (isKeiyakuOwnedRef(row.ref))
-            continue;
-        try {
-            await runGit(repository, ["merge-base", "--is-ancestor", gitObjectIdForSnapshot(snapshot), row.oid]);
-            return { ref: row.ref, oid: mintSnapshotId(row.oid) };
-        }
-        catch (error) {
-            if (error instanceof GitPlumbingError && error.status === 1)
-                continue;
-            throw error;
-        }
+    for (const removal of await removeCollectableScratchWorktrees(repository, topology.paths)) {
+        effects.push({ kind: "worktree", path: removal.path, action: removal.action });
+        if (removal.retained)
+            lag.push({ kind: "worktree-retained", path: removal.path });
     }
-    return null;
 }
 async function reconcileTargetCheckouts(repository, state) {
     if (state.terminal?.kind !== "claimed" || state.coordinates.target === undefined || state.delivery === null) {
@@ -201,171 +103,34 @@ async function reconcileTargetCheckouts(repository, state) {
         result = failed("effect", releaseFailure, result.effects, result.lag);
     return result;
 }
-async function reconcileHereWorkspaceRefs({ repository }, state, { effects, lag }) {
-    const pin = candidatePinRefFor(state.id);
-    if (state.terminal) {
-        if (state.delivery === null)
-            effects.push(await removeRef(repository, pin));
-        else {
-            const integration = state.currentIntegration?.snapshot;
-            if (integration === undefined)
-                return complete();
-            const custodian = await snapshotCustodian(repository, integration);
-            effects.push(await (custodian === null
-                ? await updateRef(repository, pin, integration)
-                : await removeRefWithCustody(repository, pin, custodian.ref, custodian.oid)));
-        }
-    }
-    else if (state.bound) {
-        effects.push(await (state.delivery === null
-            ? await removeRef(repository, pin)
-            : await updateRef(repository, pin, state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot)));
-    }
-    return complete(effects, lag);
-}
-function retainTerminalWorktree(path, retainedLag, { effects, lag }) {
-    effects.push({ kind: "worktree", path, action: "unchanged" });
-    lag.push(retainedLag);
-    return complete(effects, lag);
-}
-async function terminalSealExpectations(channel, state) {
-    const snapshots = terminalSealSnapshots(state);
-    const objects = await channel.readObjects(snapshots.map(gitObjectIdForSnapshot));
-    return decodeTerminalSealExpectations(state, objects);
-}
-async function removeSealedTerminalWorktree({ repository, topology, path, state, expected, hooks, retryHooks, acc }) {
-    if (topology.paths.has(path) && await pathExists(path)) {
-        const terminal = state.terminal;
-        if (terminal === null)
-            throw new Error(`terminal worktree cleanup received active Contract ${state.id}`);
-        const canRecover = terminal.kind === "abandoned";
-        let recovery = null;
-        const recordRecovery = async (workspace) => {
-            const snapshot = mintSnapshotId(await writeCommit({
-                repository,
-                tree: workspace.tree,
-                parent: gitObjectIdForSnapshot(recovery?.snapshot ?? workspace.head),
-                message: `${state.id}: ephemeral abandoned-workspace recovery\n\nKeiyaku-Contract: ${state.id}`,
-                actor: "Keiyaku Recovery",
-                at: terminal.at,
-            }));
-            const effect = {
-                kind: "recovery-snapshot",
-                action: "created",
-                snapshot,
-                retention: "ephemeral",
-            };
-            const existing = acc.effects.findIndex((item) => item.kind === "recovery-snapshot");
-            if (existing < 0)
-                acc.effects.push(effect);
-            else
-                acc.effects[existing] = effect;
-            return { snapshot, workspace };
-        };
-        const before = await observeTerminalWorkspace(repository, path, expected);
-        const beforeWorkspace = before.workspace;
-        const beforeHooks = before.unsealed;
-        if (beforeHooks !== null) {
-            if (!canRecover || beforeWorkspace.submodules.length > 0) {
-                return retainTerminalWorktree(path, beforeHooks, acc);
-            }
-            recovery = await recordRecovery(beforeWorkspace);
-        }
-        const hookLag = await runDestroyHooks(path, await worktreeGitDirectory(repository, path), hooks, retryHooks);
-        if (hookLag !== null)
-            return retainTerminalWorktree(path, hookLag, acc);
-        const after = await observeTerminalWorkspace(repository, path, expected);
-        const afterWorkspace = after.workspace;
-        const afterHooks = after.unsealed;
-        if (afterHooks !== null) {
-            if (!canRecover || afterWorkspace.submodules.length > 0) {
-                return retainTerminalWorktree(path, afterHooks, acc);
-            }
-        }
-        if (canRecover
-            && (recovery === null
-                || recovery.workspace.head !== afterWorkspace.head
-                || recovery.workspace.tree !== afterWorkspace.tree)
-            && (recovery !== null || beforeWorkspace.head !== afterWorkspace.head || beforeWorkspace.tree !== afterWorkspace.tree)) {
-            recovery = await recordRecovery(afterWorkspace);
-        }
-    }
-    const removal = await removeWorktree(repository, topology, path, true);
-    if (removal.retained)
-        return retainTerminalWorktree(path, { kind: "worktree-retained", path }, acc);
-    acc.effects.push(removal.effect);
-    return null;
-}
-async function targetCustodyForClaimedIntegration(repository, state, integration) {
-    return state.terminal?.kind === "claimed" && state.coordinates.target !== undefined
-        && await readRef(repository, state.coordinates.target) === integration
-        ? { ref: state.coordinates.target, oid: integration }
-        : null;
-}
-function sealedTree(expected, snapshot) {
-    const tree = expected.treeBySnapshot.get(snapshot);
-    if (tree === undefined)
-        throw new Error(`terminal seal tree was not resolved: ${snapshot}`);
-    return tree;
-}
-async function releaseTerminalCustody({ repository, state, expected, ref, pin, acc: { effects } }) {
-    if (state.delivery === null) {
-        const custodian = await snapshotCustodian(repository, state.coordinates.start);
-        if (custodian !== null)
-            effects.push(await removeRefWithCustody(repository, ref, custodian.ref, custodian.oid));
-        effects.push(await removeRef(repository, pin));
-        return;
-    }
-    const tender = state.delivery.data.tenderSnapshot;
-    const integration = state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot;
-    const target = await targetCustodyForClaimedIntegration(repository, state, integration);
-    if (sealedTree(expected, tender) === sealedTree(expected, integration) && target !== null) {
-        effects.push(await removeRefWithCustody(repository, ref, target.ref, target.oid));
-        effects.push(await removeRefWithCustody(repository, pin, target.ref, target.oid));
-    }
-    else if (tender === integration) {
-        effects.push(await removeRefWithCustody(repository, pin, ref, tender));
-    }
-    else if (target !== null) {
-        effects.push(await removeRefWithCustody(repository, pin, target.ref, target.oid));
-    }
-}
-async function reconcileTerminalManagedWorktree({ repository, channel, hooks, retryHooks, retainTerminalWorktree, place }, state, topology, acc) {
-    const primary = fromPrimaryWorktree(repository);
-    const ref = deliveryRefFor(state.id);
-    const pin = candidatePinRefFor(state.id);
-    const path = place === undefined ? undefined : worktreePath(repository, place);
-    if (path === undefined)
-        return complete(acc.effects, acc.lag);
-    const expected = await terminalSealExpectations(channel, state);
-    acc.effects.push(await updateRef(primary, ref, state.delivery?.data.tenderSnapshot ?? state.coordinates.start));
-    if (state.delivery !== null) {
-        acc.effects.push(await updateRef(primary, pin, state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot));
-    }
-    if (retainTerminalWorktree === true)
-        return complete(acc.effects, acc.lag);
-    const retained = await removeSealedTerminalWorktree({
-        repository: primary,
-        topology,
-        path,
-        state,
-        expected,
-        hooks,
-        retryHooks,
-        acc,
-    });
-    if (retained !== null)
-        return retained;
-    await releaseTerminalCustody({ repository: primary, state, expected, ref, pin, acc });
-    return complete(acc.effects, acc.lag);
-}
 async function reconcileActiveManagedWorktree({ repository, hooks, retryHooks, place }, state, topology, { effects, lag }) {
     if (place === undefined)
         return complete(effects, [...lag, missingPlaceLag(repository)]);
     const path = worktreePath(repository, place);
     const desired = state.delivery?.data.tenderSnapshot ?? state.coordinates.start;
     effects.push(await updateRef(repository, deliveryRefFor(state.id), desired));
-    effects.push(await worktree(repository, topology, path, desired));
+    const projection = await worktree(repository, topology, path, desired);
+    if (projection.kind === "worktree" && projection.action === "unchanged" && state.delivery !== null) {
+        const follow = await followManagedWorktree(repository, path, state.delivery.data.tenderSnapshot);
+        if (follow.kind === "followed") {
+            effects.push({ kind: "worktree", path, action: "followed", before: follow.before, after: follow.after });
+        }
+        else {
+            effects.push(projection);
+            if (follow.kind === "retained") {
+                lag.push({
+                    kind: "worktree-follow-retained",
+                    path,
+                    tender: state.delivery.data.tenderSnapshot,
+                    head: follow.head,
+                    reason: follow.reason,
+                });
+            }
+        }
+    }
+    else {
+        effects.push(projection);
+    }
     const hookLag = await runCreateHooks(path, await worktreeGitDirectory(repository, path), hooks, retryHooks);
     if (hookLag !== null)
         lag.push(hookLag);
@@ -385,10 +150,9 @@ async function reconcileWithTopology(input, state, topology) {
         const targetCheckouts = await reconcileTargetCheckouts(repository, state);
         effects.push(...targetCheckouts.effects);
         lag.push(...targetCheckouts.lag);
-        if (state.coordinates.workspace === "here")
-            return await reconcileHereWorkspaceRefs(input, state, { effects, lag });
-        if (state.terminal)
-            return await reconcileTerminalManagedWorktree(input, state, topology, { effects, lag });
+        if (state.terminal) {
+            return await reconcileTerminalManagedWorktree(input, state, topology, { effects, lag }, { ref: deliveryRefFor(state.id), pin: candidatePinRefFor(state.id) });
+        }
         return await reconcileActiveManagedWorktree(input, state, topology, { effects, lag });
     }
     catch (error) {

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

@@ -4,6 +4,8 @@ export type { TreeChange } from "./tree.js";
 export declare const GIT_REF = "refs/heads/keiyaku-state";
 export declare const DELIVERY_REF_NAMESPACE = "refs/heads/keiyaku-delivery";
 export declare const CANDIDATE_PIN_REF_NAMESPACE = "refs/heads/keiyaku-candidate";
+export declare const MIGRATION_DELIVERY_REF_NAMESPACE = "refs/keiyaku/delivery";
+export declare const MIGRATION_CANDIDATE_PIN_REF_NAMESPACE = "refs/keiyaku/candidate";
 export declare const GIT_FORMAT_PATH = "meta/format.json";
 export declare const GIT_FORMAT_BYTES = "{\"version\":4}\n";
 export declare function isKeiyakuOwnedRef(ref: string): boolean;