@shiyuphan/follow-me 0.1.0 → 0.1.1

package/README.md

@@ -81,6 +81,17 @@ SHAs and re-running `apply` is a no-op.
 - `apply` refuses to move a branch it did not create unless `--force`.
 - The review server binds `127.0.0.1` only and rejects cross-origin requests.
 - Everything under `.follow-me/` is ignored by git.
+- Outside the repo, follow-me writes only its state dir (`~/.local/state/follow-me`, or
+  `$XDG_STATE_HOME/follow-me`), which holds the review server's `server.json` and `server.log`.
+- One review server per user hosts every session. `follow-me server stop` signals it only after
+  it answers as follow-me on its recorded port, so a reused pid is never killed.
+
+Three guarantees hold across sessions. The original branch is never written. `apply` puts the
+split on `<branch>-split` or `--name`, and refuses the branch being split and any branch checked
+out in a worktree, even with `--force`. Sessions are isolated per worktree. Each worktree keeps
+its own `.follow-me/`, each branch its own directory, and a lock stops two agents from applying or
+reviewing one session at once. `follow-me clean` removes leftovers: sessions of deleted branches,
+review drafts no review can resume, and files of processes that died.
 
 ## Development
 

package/dist/src/cli.js

@@ -1,12 +1,15 @@
 import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { join, relative } from "node:path";
 import { PlanRequestError, requestPlan } from "./anthropic.js";
 import { DiffParseError, formatUnitRef } from "./diff.js";
 import { BranchRefusedError, GitError, treeOf, writeBranch } from "./git.js";
+import { findServer, idleMs, listSessions, openBrowser, portFallbackMessage, probeHealth, registerWith, sessionUrl, spawnDetached, startOrAttach, stateDir, stopServer, } from "./host.js";
+import { runInstall, runUninstall } from "./install.js";
 import { serializePlanFile, validatePlan } from "./plan.js";
 import { renderFeedback, renderPrompt } from "./prompt.js";
-import { loadDraftComments, serveReview } from "./server.js";
-import { BranchMovedError, extractSession, openSession, SessionFileError, } from "./session.js";
+import { RegistrationError, sessionIdOf } from "./server.js";
+import { BranchMovedError, cleanSessions, extractSession, openSession, SessionFileError, SessionLockedError, } from "./session.js";
 class UsageError extends Error {
     name = "UsageError";
 }
@@ -14,18 +17,34 @@ const USAGE = `usage: follow-me <command>
 
   extract [--base <ref>] [--branch <name>]  anchor a session and list the units
   check [path] [--branch <name>]            validate draft.json or the given plan file
-  apply [--name <branch>] [--force]         write the draft as a branch of commits
-  status                                    show the session's plans, reviews and branch
+  apply [--name <branch>] [--force]         write the draft as commits on <branch>-split or
+                                            --name; never on <branch> or a checked-out branch
+  status                                    show the session's plans, reviews, lock and the
+                                            branch apply writes
   prompt [--walk] [--branch <name>]         print the planner prompt for a coding agent
   plan [--walk] [--model <id>] [--branch <name>]
                                             ask the Anthropic API to write draft.json
-  review [--port <n>] [--no-open]           review the latest plan commit by commit
-  walk [--base <ref>] [--branch <name>] [--model <id>] [--port <n>] [--no-open]
+  review [--port <n>] [--detach] [--no-open] review the latest plan commit by commit
+  walk [--base <ref>] [--branch <name>] [--model <id>] [--port <n>] [--detach] [--no-open]
                                             watch a branch being written, narrated, and
                                             review its code; nothing is applied
+  server status                             show the review server and the sessions it hosts
+  server stop                               stop the review server; drafts are kept
   feedback [--branch <name>]                print the latest review as markdown
+  clean [--all] [--dry-run]                 remove sessions of deleted branches, finished
+                                            review drafts and leftovers of dead processes;
+                                            --all removes .follow-me/ entirely
+  install [--harness <ids>|--all] [--user] [--dry-run]
+                                            copy the skill into coding agents' skill dirs
+  install --list                            show each harness, its skill dirs and docs
+  uninstall [--harness <ids>|--all] [--user] [--dry-run]
+                                            remove the skill files install writes
 
---walk writes the prompt for a reviewer: a story with narration instead of a split.`;
+--walk writes the prompt for a reviewer: a story with narration instead of a split.
+review and walk share one server per user: a running one hosts the session and the command
+prints its URL; otherwise the command serves until its review ends, or with --detach starts the
+server in the background. --port taken by another program falls back to a free port.
+--force lets apply move a branch follow-me did not create; it never allows <branch> itself.`;
 function parseArgs(argv, spec) {
     const positionals = [];
     const values = new Map();
@@ -159,12 +178,12 @@ function branchFlag(args) {
 function portOf(args) {
     const raw = args.values.get("port");
     if (raw === undefined)
-        return {};
+        return undefined;
     const port = Number(raw);
     if (!Number.isInteger(port) || port < 0 || port > 65535) {
         throw new UsageError(`--port ${raw} is not a port number`);
     }
-    return { port };
+    return port === 0 ? undefined : port;
 }
 function modeOf(args) {
     return args.flags.has("walk") ? "walk" : "split";
@@ -197,16 +216,33 @@ async function check(cwd, args) {
         say(formatWarning(w));
     return 0;
 }
+/** Runs one command under the session's lock, so two agents never apply or review it at once. */
+async function locked(session, command, run) {
+    const held = session.lock(command);
+    try {
+        return await run(held);
+    }
+    finally {
+        held.release();
+    }
+}
+function splitBranch(session) {
+    return `${session.anchor.branch}-split`;
+}
 async function apply(cwd, args) {
     const session = await openSession(cwd);
+    return locked(session, "apply", () => applyLocked(session, args));
+}
+async function applyLocked(session, args) {
     const verdict = validate(session, session.readDraft());
     if (!verdict.ok)
         return 1;
     const version = session.freeze(verdict.plan);
-    const name = args.values.get("name") ?? `${session.anchor.branch}-split`;
+    const name = args.values.get("name") ?? splitBranch(session);
     const last = session.applied();
     const result = await writeBranch(session.root, session.diff, verdict.plan, {
         name,
+        source: session.anchor.branch,
         expectedOld: last?.branch === name ? last.head : null,
         force: args.flags.has("force"),
     });
@@ -269,18 +305,87 @@ function latestPlan(session) {
         return null;
     return { version: session.freeze(verdict.plan), plan: verdict.plan };
 }
-async function serve(session, mode, latest, args) {
-    const { version, plan } = latest;
-    const reviewsDir = join(session.dir, "reviews");
-    return serveReview({
-        mode,
-        anchor: session.anchor,
-        version,
-        planHash: plan.hash,
-        commits: plan.commits,
-        units: [...session.diff.units.values()],
-        comments: await loadDraftComments(reviewsDir, version),
-    }, { reviewsDir, open: !args.flags.has("no-open"), ...portOf(args) });
+function announce(mode, url, args) {
+    say(`follow-me ${mode === "walk" ? "code review" : "review"}: ${url}`);
+    if (!args.flags.has("no-open"))
+        openBrowser(url);
+}
+/** The server that already runs for this user, or one on --port that answers as ours. */
+async function runningServer(home, port) {
+    const live = await findServer(home);
+    if (live !== null)
+        return live.port;
+    if (port !== undefined && (await probeHealth(port)) !== null)
+        return port;
+    return null;
+}
+/**
+ * Hosts the session on the user's one review server. A running server gets the session and the
+ * CLI exits; otherwise this process becomes the server, in the foreground or, with --detach, as
+ * a background process. The CLI prepares the plan under the session lock and hands the lock to
+ * whichever process hosts it. report runs when a foreground review ends.
+ */
+async function hostReview(session, mode, args, prepare, report) {
+    const home = stateDir();
+    const lock = session.lockState();
+    const live = await findServer(home);
+    if (live !== null && lock.kind === "held" && lock.pid === live.pid) {
+        const id = sessionIdOf(session.dir);
+        const open = (await listSessions(live.port)).find((s) => s.id === id && s.mode === mode);
+        if (open !== undefined) {
+            announce(mode, sessionUrl(live.port, open), args);
+            return { kind: "elsewhere" };
+        }
+    }
+    return locked(session, mode === "walk" ? "walk" : "review", async (held) => {
+        const prepared = await prepare();
+        if (prepared === null)
+            return { kind: "refused" };
+        const registration = {
+            dir: session.dir,
+            mode,
+            version: prepared.version,
+            hash: prepared.plan.hash,
+            lockToken: held.token,
+        };
+        const port = portOf(args);
+        let started;
+        const running = await runningServer(home, port);
+        if (running !== null)
+            started = { kind: "attached", port: running };
+        else if (args.flags.has("detach")) {
+            const server = await spawnDetached(home, port);
+            if (port !== undefined && server.port !== port)
+                say(portFallbackMessage(port, server.port));
+            started = { kind: "attached", port: server.port };
+        }
+        else
+            started = await startOrAttach(home, port, say);
+        if (started.kind === "attached") {
+            const summary = await registerWith(started.port, registration);
+            announce(mode, sessionUrl(started.port, summary), args);
+            return { kind: "elsewhere" };
+        }
+        const { host } = started;
+        const { summary, done } = await host.register(registration);
+        announce(mode, sessionUrl(host.port, summary), args);
+        const review = await done;
+        if (review === null)
+            return { kind: "stopped" };
+        report(review);
+        const others = host.sessions().length;
+        say(others > 0
+            ? `still serving ${plural(others, "other session")} at ${host.url}; this process exits after they end`
+            : `the server exits in ${Math.ceil(idleMs() / 1000)}s unless another review starts; ctrl-c stops it now`);
+        await host.closed;
+        return { kind: "ended" };
+    });
+}
+function exitCode(hosted) {
+    if (hosted.kind === "stopped") {
+        console.error("follow-me: the server stopped before the review ended; its comments are kept");
+    }
+    return hosted.kind === "refused" || hosted.kind === "stopped" ? 1 : 0;
 }
 function alreadyReviewed(session, version, args) {
     if (!session.reviews().some((r) => r.version === version))
@@ -290,14 +395,14 @@ function alreadyReviewed(session, version, args) {
 }
 async function review(cwd, args) {
     const session = await openSession(cwd);
-    const latest = latestPlan(session);
-    if (latest === null)
-        return 1;
-    if (alreadyReviewed(session, latest.version, args))
-        return 1;
-    const review = await serve(session, "split", latest, args);
-    say(`review v${latest.version} saved with ${plural(review.comments.length, "comment")}`);
-    return 0;
+    const prepare = async () => {
+        const latest = latestPlan(session);
+        if (latest === null || alreadyReviewed(session, latest.version, args))
+            return null;
+        return latest;
+    };
+    const report = (review) => say(`review v${review.planVersion} saved with ${plural(review.comments.length, "comment")}`);
+    return exitCode(await hostReview(session, "split", args, prepare, report));
 }
 /** Opens the reviewer's session, re-extracting instead of failing when the branch moved. */
 async function openForWalk(cwd, args) {
@@ -341,6 +446,15 @@ function hasApiCredentials() {
 }
 async function walk(cwd, args) {
     const session = await openForWalk(cwd, args);
+    const report = (review) => {
+        const saved = join(session.dir, "reviews", `v${review.planVersion}.json`);
+        say(`code review saved to ${relative(cwd, saved)} with ${plural(review.comments.length, "comment")}`);
+        say(`\`follow-me feedback${branchFlag(args)}\` prints it as a code review for the author`);
+    };
+    const hosted = await hostReview(session, "walk", args, () => walkPlan(session, cwd, args), report);
+    return exitCode(hosted);
+}
+async function walkPlan(session, cwd, args) {
     let latest = walkablePlan(session);
     if (latest === null) {
         if (!hasApiCredentials()) {
@@ -348,20 +462,14 @@ async function walk(cwd, args) {
             say("Have a coding agent follow the prompt, then walk again:");
             say(`  follow-me prompt --walk${branchFlag(args)}`);
             say(`  follow-me walk${branchFlag(args)}`);
-            return 1;
+            return null;
         }
         const drafted = await draftWithApi(session, cwd, "walk", args);
         if (drafted === null)
-            return 1;
+            return null;
         latest = { version: session.freeze(drafted), plan: drafted };
     }
-    if (alreadyReviewed(session, latest.version, args))
-        return 1;
-    const review = await serve(session, "walk", latest, args);
-    const saved = join(session.dir, "reviews", `v${latest.version}.json`);
-    say(`code review saved to ${relative(cwd, saved)} with ${plural(review.comments.length, "comment")}`);
-    say(`\`follow-me feedback${branchFlag(args)}\` prints it as a code review for the author`);
-    return 0;
+    return alreadyReviewed(session, latest.version, args) ? null : latest;
 }
 async function feedback(cwd, args) {
     const session = await openSession(cwd, sessionOpts(args));
@@ -378,12 +486,77 @@ async function feedback(cwd, args) {
     process.stdout.write(renderFeedback(stored.review, plan.file, session.diff.units));
     return 0;
 }
+function describeLock(lock) {
+    if (lock.kind === "free")
+        return "free";
+    const who = `pid ${lock.pid} (follow-me ${lock.command})`;
+    return lock.kind === "held"
+        ? `held by ${who}`
+        : `stale, ${who} is gone; follow-me clean removes it`;
+}
+/** The URL of this session on the user's server, when that server is what holds its lock. */
+async function hostedPage(session, holder) {
+    const live = await findServer(stateDir());
+    if (live === null || live.pid !== holder)
+        return null;
+    const id = sessionIdOf(session.dir);
+    const open = (await listSessions(live.port)).find((s) => s.id === id);
+    return open === undefined ? null : sessionUrl(live.port, open);
+}
+async function serverCommand(argv) {
+    const [verb, ...rest] = argv;
+    const home = stateDir();
+    switch (verb) {
+        case "status": {
+            parseArgs(rest, {});
+            const live = await findServer(home);
+            if (live === null) {
+                say("no server running");
+                return 0;
+            }
+            say(`server pid ${live.pid} at http://127.0.0.1:${live.port}/ since ${live.startedAt}`);
+            const sessions = await listSessions(live.port);
+            if (sessions.length === 0)
+                say("  no sessions");
+            for (const s of sessions) {
+                const what = s.mode === "walk" ? "walk" : "review";
+                say(`  ${sessionUrl(live.port, s)}  ${s.branch} ${what} of plan v${s.version}, ${plural(s.comments, "comment")}  ${s.repo}`);
+            }
+            return 0;
+        }
+        case "stop": {
+            parseArgs(rest, {});
+            const stopped = await stopServer(home);
+            say(stopped === null ? "no server running" : `stopped server pid ${stopped.pid}`);
+            return 0;
+        }
+        // What `--detach` runs in the background; not meant to be typed.
+        case "run": {
+            const started = await startOrAttach(home, portOf(parseArgs(rest, { values: ["port"] })), say);
+            if (started.kind === "attached") {
+                say(`a follow-me server already runs on port ${started.port}`);
+                return 0;
+            }
+            say(`follow-me server: ${started.host.url}`);
+            await started.host.closed;
+            return 0;
+        }
+        default:
+            throw new UsageError("usage: follow-me server status|stop");
+    }
+}
 async function status(cwd) {
     const session = await openSession(cwd);
     const { anchor, diff } = session;
     const plans = session.plans();
     const reviews = session.reviews();
     say(`${anchor.branch} ${short(anchor.tip)} onto ${anchor.baseRef} ${short(anchor.base)}`);
+    say(`writes to: ${splitBranch(session)}`);
+    const lock = session.lockState();
+    say(`lock: ${describeLock(lock)}`);
+    const page = lock.kind === "held" ? await hostedPage(session, lock.pid) : null;
+    if (page !== null)
+        say(`review page: ${page}`);
     say(`units: ${plural(diff.units.size, "unit")}`);
     let hasDraft = true;
     try {
@@ -412,6 +585,14 @@ async function status(cwd) {
         : `applied: plan v${applied.version} as ${applied.branch} at ${short(applied.head)}`);
     return 0;
 }
+function skillTargets(args) {
+    return {
+        harness: args.values.get("harness"),
+        all: args.flags.has("all"),
+        user: args.flags.has("user"),
+        dryRun: args.flags.has("dry-run"),
+    };
+}
 export async function main(argv, cwd) {
     const [command, ...rest] = argv;
     try {
@@ -437,13 +618,33 @@ export async function main(argv, cwd) {
             case "plan":
                 return await plan(cwd, parseArgs(rest, { values: ["model", "branch"], flags: ["walk"] }));
             case "review":
-                return await review(cwd, parseArgs(rest, { values: ["port"], flags: ["no-open"] }));
+                return await review(cwd, parseArgs(rest, { values: ["port"], flags: ["no-open", "detach"] }));
             case "walk": {
-                const spec = { values: ["base", "branch", "model", "port"], flags: ["no-open"] };
+                const spec = { values: ["base", "branch", "model", "port"], flags: ["no-open", "detach"] };
                 return await walk(cwd, parseArgs(rest, spec));
             }
+            case "server":
+                return await serverCommand(rest);
             case "feedback":
                 return await feedback(cwd, parseArgs(rest, { values: ["branch"] }));
+            case "clean": {
+                const args = parseArgs(rest, { flags: ["all", "dry-run"] });
+                const opts = { all: args.flags.has("all"), dryRun: args.flags.has("dry-run") };
+                for (const path of await cleanSessions(cwd, opts))
+                    say(relative(cwd, path));
+                return 0;
+            }
+            case "install": {
+                const args = parseArgs(rest, {
+                    values: ["harness"],
+                    flags: ["all", "user", "dry-run", "list"],
+                });
+                return runInstall({ ...skillTargets(args), list: args.flags.has("list") }, homedir(), cwd, say);
+            }
+            case "uninstall": {
+                const args = parseArgs(rest, { values: ["harness"], flags: ["all", "user", "dry-run"] });
+                return runUninstall(skillTargets(args), homedir(), cwd, say);
+            }
             case undefined:
             case "help":
             case "--help":
@@ -459,6 +660,8 @@ export async function main(argv, cwd) {
             BranchMovedError,
             BranchRefusedError,
             SessionFileError,
+            SessionLockedError,
+            RegistrationError,
             GitError,
             PlanRequestError,
         ];

package/dist/src/git.js

@@ -1,6 +1,5 @@
 import { execFile } from "node:child_process";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { link, mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { isSha, neededBlobs, parseDiff } from "./diff.js";
 export class GitError extends Error {
@@ -24,6 +23,13 @@ function git(repo, args, opts = {}) {
             else
                 resolve(stdout);
         });
+        // git can exit before reading its input (a bad ref, a missing repo). On Linux the
+        // pending write then fails with EPIPE; the callback above already carries git's
+        // real error, so that write failure is noise.
+        child.stdin?.on("error", (error) => {
+            if (error.code !== "EPIPE")
+                reject(error);
+        });
         child.stdin?.end(opts.input ?? "");
     });
 }
@@ -64,6 +70,22 @@ export async function currentBranch(repo) {
         throw error;
     }
 }
+/** Each branch checked out in some worktree of the repo, mapped to that worktree's path. */
+export async function checkedOutBranches(repo) {
+    const out = (await git(repo, ["worktree", "list", "--porcelain", "-z"])).toString("utf8");
+    const found = new Map();
+    let path = "";
+    for (const field of out.split("\0")) {
+        if (field.startsWith("worktree "))
+            path = field.slice("worktree ".length);
+        if (field.startsWith("branch refs/heads/"))
+            found.set(field.slice("branch refs/heads/".length), path);
+    }
+    return found;
+}
+export async function branchExists(repo, name) {
+    return (await resolveOptional(repo, `refs/heads/${name}`)) !== null;
+}
 export async function defaultBaseRef(repo) {
     for (const name of ["main", "master"]) {
         if ((await resolveOptional(repo, `refs/heads/${name}`)) !== null)
@@ -132,7 +154,7 @@ function identityEnv(who, back) {
         GIT_COMMITTER_DATE: date(who.committer),
     };
 }
-async function indexLine(repo, change, zero) {
+async function indexLine(repo, change, zero, env) {
     const entry = async () => {
         if (change.op === "delete")
             return `0 ${zero}`;
@@ -140,6 +162,7 @@ async function indexLine(repo, change, zero) {
             return `${change.entry.mode} ${change.entry.blob}`;
         const blob = await gitText(repo, ["hash-object", "-w", "--stdin"], {
             input: Buffer.from(change.bytes, "latin1"),
+            env,
         });
         return `${change.mode} ${toSha(blob, change.path)}`;
     };
@@ -149,9 +172,35 @@ async function indexLine(repo, change, zero) {
         Buffer.from([0]),
     ]);
 }
+/** Prefix of the quarantine directories writeBranch creates inside the object store. */
+export const QUARANTINE_PREFIX = "follow-me-incoming-";
+export async function objectsDir(repo) {
+    return gitText(repo, ["rev-parse", "--path-format=absolute", "--git-path", "objects"]);
+}
+/** Hard-links the quarantined loose objects into the store; an object already there stays. */
+async function adoptObjects(quarantine, objects) {
+    for (const fanout of await readdir(quarantine)) {
+        if (!/^[0-9a-f]{2}$/.test(fanout))
+            continue;
+        await mkdir(join(objects, fanout), { recursive: true });
+        for (const name of await readdir(join(quarantine, fanout))) {
+            if (name.startsWith("tmp_"))
+                continue;
+            try {
+                await link(join(quarantine, fanout, name), join(objects, fanout, name));
+            }
+            catch (error) {
+                if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
+                    throw error;
+            }
+        }
+    }
+}
 /**
  * Writes the plan as commits on top of the merge-base through a temporary index, so the
  * user's index and worktree are never touched, then moves refs/heads/<name> by compare-and-swap.
+ * New objects go to a quarantine inside the object store and are adopted only right before the
+ * ref moves, so a refused or failed write leaves neither refs nor objects behind.
  */
 export async function writeBranch(repo, diff, plan, opts) {
     const ref = `refs/heads/${opts.name}`;
@@ -161,15 +210,27 @@ export async function writeBranch(repo, diff, plan, opts) {
     catch {
         throw new BranchRefusedError(`"${opts.name}" is not a valid branch name`);
     }
+    if (opts.name === opts.source) {
+        throw new BranchRefusedError(`${opts.name} is the branch being split; the split always lands on a separate branch, so pick another --name (--force does not change this)`);
+    }
+    const worktree = (await checkedOutBranches(repo)).get(opts.name);
+    if (worktree !== undefined) {
+        throw new BranchRefusedError(`branch ${opts.name} is checked out in ${worktree}; moving it would leave that worktree out of sync, so pick another --name (--force does not change this)`);
+    }
     const who = await identities(repo, diff.tip);
     const zero = "0".repeat(diff.base.length);
     const n = plan.commits.length;
-    const dir = await mkdtemp(join(tmpdir(), "follow-me-index-"));
+    const objects = await objectsDir(repo);
+    const dir = await mkdtemp(join(objects, `${QUARANTINE_PREFIX}${process.pid}-`));
     const commits = [];
     let head = diff.base;
     let tree = diff.baseTree;
     try {
-        const env = { GIT_INDEX_FILE: join(dir, "index") };
+        const env = {
+            GIT_INDEX_FILE: join(dir, "index"),
+            GIT_OBJECT_DIRECTORY: dir,
+            GIT_ALTERNATE_OBJECT_DIRECTORIES: objects,
+        };
         await git(repo, ["read-tree", diff.baseTree], { env });
         for (const commit of plan.commits) {
             // Deletes go first so a file can give way to a directory of the same name.
@@ -177,34 +238,35 @@ export async function writeBranch(repo, diff, plan, opts) {
                 ...commit.changes.filter((c) => c.op === "delete"),
                 ...commit.changes.filter((c) => c.op !== "delete"),
             ];
-            const lines = await Promise.all(ordered.map((c) => indexLine(repo, c, zero)));
+            const lines = await Promise.all(ordered.map((c) => indexLine(repo, c, zero, env)));
             await git(repo, ["update-index", "-z", "--index-info"], { env, input: Buffer.concat(lines) });
             tree = toSha(await gitText(repo, ["write-tree"], { env }), "write-tree");
             const message = commit.message.endsWith("\n") ? commit.message : `${commit.message}\n`;
             head = toSha(await gitText(repo, ["commit-tree", "--no-gpg-sign", tree, "-p", head, "-F", "-"], {
                 input: message,
-                env: identityEnv(who, n - 1 - commit.index),
+                env: { ...env, ...identityEnv(who, n - 1 - commit.index) },
             }), "commit-tree");
             commits.push(head);
         }
+        if (tree !== diff.tipTree) {
+            throw new Error(`the last commit's tree ${tree} differs from the tip tree ${diff.tipTree}`);
+        }
+        const current = await resolveOptional(repo, ref);
+        if (current === head)
+            return { kind: "unchanged", branch: opts.name, head, commits };
+        if (current !== null && !opts.force) {
+            if (opts.expectedOld === null) {
+                throw new BranchRefusedError(`branch ${opts.name} already exists and follow-me did not write it; pass --force to overwrite`);
+            }
+            if (current !== opts.expectedOld) {
+                throw new BranchRefusedError(`branch ${opts.name} moved since the last apply (expected ${opts.expectedOld}, found ${current}); pass --force to overwrite`);
+            }
+        }
+        await adoptObjects(dir, objects);
+        await git(repo, ["update-ref", "-m", "follow-me apply", ref, head, current ?? zero]);
+        return { kind: current === null ? "created" : "updated", branch: opts.name, head, commits };
     }
     finally {
         await rm(dir, { recursive: true, force: true });
     }
-    if (tree !== diff.tipTree) {
-        throw new Error(`the last commit's tree ${tree} differs from the tip tree ${diff.tipTree}`);
-    }
-    const current = await resolveOptional(repo, ref);
-    if (current === head)
-        return { kind: "unchanged", branch: opts.name, head, commits };
-    if (current !== null && !opts.force) {
-        if (opts.expectedOld === null) {
-            throw new BranchRefusedError(`branch ${opts.name} already exists and follow-me did not write it; pass --force to overwrite`);
-        }
-        if (current !== opts.expectedOld) {
-            throw new BranchRefusedError(`branch ${opts.name} moved since the last apply (expected ${opts.expectedOld}, found ${current}); pass --force to overwrite`);
-        }
-    }
-    await git(repo, ["update-ref", "-m", "follow-me apply", ref, head, current ?? zero]);
-    return { kind: current === null ? "created" : "updated", branch: opts.name, head, commits };
 }