@webappwiz/arbor 0.0.30 → 0.0.32

package/merge.test.ts

@@ -1,332 +0,0 @@
-import { describe, expect, it, setDefaultTimeout } from "bun:test";
-import { join } from "node:path";
-import { FakePs } from "webappwiz/system/testing";
-import { add } from "./add";
-import { merge } from "./merge";
-import { PLAN_FILE } from "./plan";
-import { Shell } from "./shell";
-import { LIVE_PID, Testing } from "./testing";
-
-// Every test here drives real git in a repo of its own, dozens of processes
-// each: fast alone, but starved past bun's 5s default when the whole suite
-// runs in parallel on a busy machine.
-setDefaultTimeout(30_000);
-
-describe.concurrent("merge", () => {
-	it("rebases, tests, then fast-forwards trunk", async () => {
-		await using deps = await Testing.open();
-
-		await add(deps, "alpha");
-		const worktree = (await deps.service.find("alpha")).path;
-		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
-		// Trunk moved on underneath, so the rebase has real work to do.
-		await deps.commit(deps.root, "trunk.txt", "trunk\n", "add trunk");
-
-		await merge(deps, worktree);
-
-		expect(await deps.gitCli(deps.root, "log", "--oneline", "main")).toContain(
-			"add alpha",
-		);
-		expect(
-			await deps.gitCli(deps.root, "rev-list", "--count", "--merges", "main"),
-		).toBe("0");
-		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
-	});
-
-	it("lands on a clean rebase alone when no hook is configured", async () => {
-		await using deps = await Testing.open();
-
-		deps.config.postRewrite = null;
-		deps.config.preMerge = null;
-		await add(deps, "alpha");
-		const worktree = (await deps.service.find("alpha")).path;
-		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
-
-		await merge(deps, worktree);
-
-		expect(await deps.gitCli(deps.root, "log", "--oneline", "main")).toContain(
-			"add alpha",
-		);
-	});
-
-	it("lands a --base task on its base branch and leaves trunk alone", async () => {
-		await using deps = await Testing.open();
-
-		await deps.gitCli(deps.root, "branch", "feature", "main");
-		const trunkBefore = await deps.gitCli(deps.root, "rev-parse", "main");
-		await add(deps, "alpha", { base: "feature" });
-		const worktree = (await deps.service.find("alpha")).path;
-		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
-
-		await merge(deps, worktree);
-
-		expect(
-			await deps.gitCli(deps.root, "log", "--oneline", "feature"),
-		).toContain("add alpha");
-		expect(await deps.gitCli(deps.root, "rev-parse", "main")).toBe(trunkBefore);
-	});
-
-	it("lands into the worktree that holds the base, leaving trunk alone", async () => {
-		await using deps = await Testing.open();
-
-		await add(deps, "parent");
-		const parent = (await deps.service.find("parent")).path;
-		await deps.commit(parent, "parent.txt", "parent\n", "add parent");
-		const trunkBefore = await deps.gitCli(deps.root, "rev-parse", "main");
-
-		await add(deps, "child", { base: "task/parent" });
-		const child = (await deps.service.find("child")).path;
-		await deps.commit(child, "child.txt", "child\n", "add child");
-
-		await merge(deps, child);
-
-		// The parent's files move with its branch, not just the ref: a ref moved
-		// behind a worktree's back leaves it reading the landed files as deleted.
-		expect(await deps.fs.exists(join(parent, "child.txt"))).toBe(true);
-		expect(await deps.gitCli(parent, "log", "--oneline", "HEAD")).toContain(
-			"add child",
-		);
-		expect(await deps.gitCli(deps.root, "rev-parse", "main")).toBe(trunkBefore);
-	});
-
-	it("refuses to land into a base worktree whose changes collide", async () => {
-		await using deps = await Testing.open();
-
-		await add(deps, "parent");
-		const parent = (await deps.service.find("parent")).path;
-		await add(deps, "child", { base: "task/parent" });
-		const child = (await deps.service.find("child")).path;
-		await deps.commit(child, "shared.txt", "child\n", "add shared");
-		// The parent is mid-edit on the very file the child is about to land.
-		await deps.fs.write(join(parent, "shared.txt"), "parent still editing\n");
-
-		await expect(merge(deps, child)).toBail("merge_failed", {
-			message: parent,
-		});
-		expect((await deps.service.find("child")).state?.mergeAttempts).toBe(1);
-		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
-	});
-
-	it("discards the landed task, so it drops out of the listing", async () => {
-		await using deps = await Testing.open();
-
-		await add(deps, "alpha");
-		const worktree = (await deps.service.find("alpha")).path;
-		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
-
-		await merge(deps, worktree);
-
-		expect((await deps.service.find("alpha")).status).toBe("removed");
-		expect(await deps.fs.exists(worktree)).toBe(false);
-		expect(await deps.service.list()).toEqual([]);
-	});
-
-	it("refuses to run with uncommitted changes, before taking the lock", async () => {
-		await using deps = await Testing.open();
-
-		await add(deps, "alpha");
-		const worktree = (await deps.service.find("alpha")).path;
-		await deps.fs.write(join(worktree, "alpha.txt"), "not committed\n");
-
-		await expect(merge(deps, worktree)).toBail("dirty");
-		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
-	});
-
-	it("leaves a conflicting rebase in progress for the agent to resolve", async () => {
-		await using deps = await Testing.open();
-
-		await add(deps, "alpha");
-		const worktree = (await deps.service.find("alpha")).path;
-		await deps.commit(worktree, "README.md", "task side\n", "task edit");
-		await deps.commit(deps.root, "README.md", "trunk side\n", "trunk edit");
-
-		await expect(merge(deps, worktree)).toBail("conflict", {
-			message: "README.md",
-		});
-		expect(await deps.gitCli(worktree, "status", "--porcelain")).toContain(
-			"UU README.md",
-		);
-		expect((await deps.service.find("alpha")).state?.mergeAttempts).toBe(1);
-		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
-	});
-
-	it("rolls the branch back and leaves trunk alone when the gate fails", async () => {
-		await using deps = await Testing.open();
-
-		deps.config.preMerge = "echo boom-from-tests; exit 1";
-		await add(deps, "alpha");
-		const worktree = (await deps.service.find("alpha")).path;
-		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
-		await deps.commit(deps.root, "trunk.txt", "trunk\n", "add trunk");
-		const before = await deps.gitCli(worktree, "rev-parse", "HEAD");
-		const trunkBefore = await deps.gitCli(deps.root, "rev-parse", "main");
-
-		await expect(merge(deps, worktree)).toBail("tests_failed", {
-			message: "boom-from-tests",
-		});
-		expect(await deps.gitCli(worktree, "rev-parse", "HEAD")).toBe(before);
-		expect(await deps.gitCli(deps.root, "rev-parse", "main")).toBe(trunkBefore);
-		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
-	});
-
-	it("runs postRewrite before preMerge, and fails the gate when it does", async () => {
-		await using deps = await Testing.open();
-
-		// Only passes if the hook ran first, in the same tree, before preMerge.
-		deps.config.postRewrite = "echo hooked > hook.txt";
-		deps.config.preMerge = "grep -q hooked hook.txt";
-		await add(deps, "alpha");
-		const worktree = (await deps.service.find("alpha")).path;
-		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
-
-		await merge(deps, worktree);
-		expect(await deps.gitCli(deps.root, "log", "-1", "--format=%s")).toBe(
-			"add alpha",
-		);
-
-		deps.config.postRewrite = "echo boom-from-hook; exit 1";
-		await add(deps, "beta");
-		const beta = (await deps.service.find("beta")).path;
-		await deps.commit(beta, "beta.txt", "beta\n", "add beta");
-
-		await expect(merge(deps, beta)).toBail("tests_failed", {
-			message: "boom-from-hook",
-		});
-		expect((await deps.service.find("beta")).state?.mergeAttempts).toBe(1);
-	});
-
-	it("runs postMerge in the main tree after landing", async () => {
-		await using deps = await Testing.open();
-
-		deps.config.postMerge = 'echo "$ARBOR_TASK" > post-merge.txt';
-		await add(deps, "alpha");
-		const worktree = (await deps.service.find("alpha")).path;
-		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
-
-		await merge(deps, worktree);
-
-		expect(await deps.fs.read(join(deps.root, "post-merge.txt"))).toBe(
-			"alpha\n",
-		);
-	});
-
-	it("reports a failed postMerge without disturbing the landed branch", async () => {
-		await using deps = await Testing.open();
-
-		deps.config.postMerge = "echo boom-after-land; exit 1";
-		await add(deps, "alpha");
-		const worktree = (await deps.service.find("alpha")).path;
-		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
-
-		await expect(merge(deps, worktree)).toBail("hook_failed", {
-			message: "boom-after-land",
-		});
-		expect(await deps.gitCli(deps.root, "log", "--oneline", "main")).toContain(
-			"add alpha",
-		);
-		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
-	});
-
-	it("refuses to land while a question is open or an answer unchecked", async () => {
-		await using deps = await Testing.open();
-
-		await add(deps, "alpha");
-		const found = await deps.service.find("alpha");
-		const worktree = found.path;
-		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
-		const plan = `${worktree}/${PLAN_FILE}`;
-		await deps.fs.write(plan, "# alpha\n\n## Blocked\n\n- [ ] 1. Keep it?\n");
-
-		await expect(merge(deps, worktree)).toBail("blocked", {
-			message: "questions 1 unchecked",
-			data: { task: "alpha", blocked: ["1"] },
-		});
-
-		// Answered but not acted on: the agent checks it off once it has.
-		await deps.fs.write(
-			plan,
-			"# alpha\n\n## Blocked\n\n- [ ] 1. Keep it? → rename it first\n",
-		);
-		await expect(merge(deps, worktree)).toBail("blocked");
-		expect(
-			await deps.gitCli(deps.root, "log", "--oneline", "main"),
-		).not.toContain("add alpha");
-
-		const read = await deps.fs.read(plan);
-		await deps.fs.write(plan, read.replace("- [ ]", "- [x]"));
-		await merge(deps, worktree);
-		expect(await deps.gitCli(deps.root, "log", "--oneline", "main")).toContain(
-			"add alpha",
-		);
-	});
-
-	it("stops once the retry budget is spent", async () => {
-		await using deps = await Testing.open();
-
-		deps.config.mergeRetryCount = 2;
-		await add(deps, "alpha");
-		const worktree = await deps.service.find("alpha");
-		await worktree.save({ mergeAttempts: 2 });
-
-		await expect(merge(deps, worktree.path)).toBail("budget_exhausted", {
-			message: "arbor escalate",
-		});
-	});
-
-	it("refuses to land when the lease changed hands during the test run", async () => {
-		await using deps = await Testing.open();
-
-		await add(deps, "alpha");
-		const worktree = await deps.service.find("alpha");
-		await deps.commit(worktree.path, "alpha.txt", "alpha\n", "add alpha");
-		const trunkBefore = await deps.gitCli(deps.root, "rev-parse", "main");
-		// Another agent takes the tree while the tests are running: the one
-		// window merge cannot hold the record across, and the reason it re-reads
-		// it before landing.
-		const ps = new FakePs();
-		ps.simulate(async () => {
-			await worktree.save({
-				lease: {
-					pid: LIVE_PID,
-					hostname: deps.ps.hostname,
-					heartbeatAt: new Date().toISOString(),
-				},
-			});
-			return 0;
-		});
-
-		await expect(
-			merge({ ...deps, shell: new Shell({ ps }) }, worktree.path),
-		).toBail("lease_lost");
-		expect(await deps.gitCli(deps.root, "rev-parse", "main")).toBe(trunkBefore);
-		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
-	});
-
-	it("serializes: one merge runs its tests and lands before the next starts", async () => {
-		await using deps = await Testing.open();
-
-		const trace = join(deps.root, "trace.log");
-		deps.config.preMerge = `printf 'start-%s\\n' "$ARBOR_TASK" >> ${trace}; sleep 0.2; printf 'end-%s\\n' "$ARBOR_TASK" >> ${trace}`;
-
-		await add(deps, "alpha");
-		await add(deps, "beta");
-		const alpha = (await deps.service.find("alpha")).path;
-		const beta = (await deps.service.find("beta")).path;
-		await deps.commit(alpha, "alpha.txt", "alpha\n", "add alpha");
-		await deps.commit(beta, "beta.txt", "beta\n", "add beta");
-
-		await Promise.all([merge(deps, alpha), merge(deps, beta)]);
-
-		const lines = (await deps.fs.read(trace)).trim().split("\n");
-		expect(lines).toHaveLength(4);
-		// Merges hold the lock exclusively, so the second can't start until the first ends.
-		expect(lines[1]).toBe(`end-${lines[0]?.slice("start-".length)}`);
-		expect(lines[3]).toBe(`end-${lines[2]?.slice("start-".length)}`);
-		const log = await deps.gitCli(deps.root, "log", "--oneline", "main");
-		expect(log).toContain("add alpha");
-		expect(log).toContain("add beta");
-		expect(
-			await deps.gitCli(deps.root, "rev-list", "--count", "--merges", "main"),
-		).toBe("0");
-	}, 20_000);
-});

package/merge.ts

@@ -1,283 +0,0 @@
-import { color, type Logger } from "webappwiz/log";
-import type { Fs, Lock } from "webappwiz/system";
-import type { Config } from "./config";
-import { fail } from "./exit";
-import type { Git } from "./git";
-import { PLAN_FILE, questions } from "./plan";
-import type { Shell } from "./shell";
-import { recommend, recommendation, type Todos } from "./todo";
-import type { Worktree } from "./worktree";
-import type { WorktreeService } from "./worktree-service";
-
-const TAIL_LINES = 40;
-
-/**
- * Lands the current worktree's branch on its base branch, trunk unless the
- * task was created with `--base`. Never a merge commit: it rebases onto the
- * base, runs the gate there, and fast-forwards the base with
- * `git merge --ff-only`, in whichever worktree has the base checked out.
- * History stays linear.
- */
-export async function merge(
-	{
-		service,
-		git,
-		lock,
-		shell,
-		config,
-		log,
-		todos,
-		fs,
-	}: {
-		service: WorktreeService;
-		git: Git;
-		lock: Lock;
-		shell: Shell;
-		config: Config;
-		log: Logger;
-		todos: Todos;
-		fs: Fs;
-	},
-	cwd: string,
-): Promise<void> {
-	const branch = await git.currentBranch(cwd).catch(() => "");
-	const task = service.taskFor(branch);
-	if (!task) {
-		fail(
-			"not_found",
-			`not in a task worktree (branch '${branch}'): run merge from a worktree made by \`arbor add\``,
-			{ branch },
-		);
-	}
-	let worktree = await service.find(task);
-	if (!worktree.state) {
-		fail(
-			"not_found",
-			`no state file for '${task}': run \`arbor claim ${task}\` first`,
-			{ task },
-		);
-	}
-
-	const base = worktree.base;
-	const dirty = await worktree.uncommitted();
-	if (dirty.length > 0) {
-		fail(
-			"dirty",
-			`'${task}' has uncommitted changes: commit them before merging`,
-			{ task, paths: dirty },
-		);
-	}
-	if (worktree.mergeAttempts >= config.mergeRetryCount) {
-		fail(
-			"budget_exhausted",
-			`'${task}' has used its ${config.mergeRetryCount} merge attempts: run \`arbor escalate <reason>\`, and a human can grant another ${config.mergeRetryCount} with \`arbor retry ${task}\`; or \`arbor remove ${task}\` and start over against current ${base}`,
-			{ task, mergeAttempts: worktree.mergeAttempts },
-		);
-	}
-	if (worktree.leaseHeldByOther) {
-		fail(
-			"lease_held",
-			`'${task}' is held by pid ${worktree.lease?.pid} on ${worktree.lease?.hostname}: another agent is driving this tree`,
-			{ task, lease: worktree.lease },
-		);
-	}
-	// An unchecked question is one the user has yet to answer, or an answer
-	// the agent has yet to act on.
-	const plan = await fs.read(`${worktree.path}/${PLAN_FILE}`).catch(() => "");
-	const blocked = questions(plan)
-		.filter((asked) => !asked.done)
-		.map((asked) => asked.number);
-	if (blocked.length > 0) {
-		fail(
-			"blocked",
-			`'${task}' has questions ${blocked.join(", ")} unchecked under ## Blocked: act on each answer and check it off, or escalate and ask the user in chat, then merge again`,
-			{ task, blocked },
-		);
-	}
-	worktree = await worktree.take();
-
-	// Blocks until free: an agent told "busy, try later" goes and edits code in
-	// a branch that is supposed to be frozen.
-	await lock.acquire();
-	worktree = await worktree.take({ status: "merging" });
-
-	const before = await git.head(worktree.path);
-	const rebase = await git.rebase(worktree.path, base);
-	if (rebase.code !== 0) {
-		// Left in progress on purpose: the agent needs the conflict markers.
-		const paths = await git.conflictedPaths(worktree.path);
-		await lock.release();
-		await bump(worktree);
-		fail(
-			"conflict",
-			[
-				`rebase onto ${base} conflicted in ${paths.length || "?"} file(s):`,
-				...paths.map((file) => `  ${file}`),
-				"",
-				"The rebase is still in progress. Resolve the conflicts, `git add` them,",
-				"`git rebase --continue`, then run `arbor merge` again.",
-				"If both sides restructured the same logic, prefer `arbor escalate <reason>`",
-				`or \`arbor remove ${task}\` and redo the task against current ${base}.`,
-			].join("\n"),
-			{ task, paths },
-		);
-	}
-
-	// After the rebase, never before: a branch that passed against an older
-	// trunk tells you nothing about the combination. This is the only thing
-	// standing between semantic conflicts and a broken trunk, and a repo that
-	// configures neither hook has chosen to go without it.
-	//
-	// The two hooks share one shell rather than getting a run each: the recovery
-	// is the same either way, and one gate reports one failure however far down
-	// it got.
-	const gate = [config.postRewrite, config.preMerge]
-		.filter(Boolean)
-		.join(" && ");
-	const gated = gate
-		? await shell.run(gate, worktree.path, {
-				env: {
-					ARBOR_TASK: task,
-					ARBOR_WORKTREE: worktree.path,
-				},
-			})
-		: { exitCode: 0, stdout: "", stderr: "" };
-	if (gated.exitCode !== 0) {
-		// The rebase already finished, so there is nothing for `rebase --abort`
-		// to undo: resetting to the pre-rebase commit is what returns the branch
-		// to its previous state.
-		await git.resetHard(worktree.path, before);
-		await lock.release();
-		await bump(worktree);
-		fail(
-			"tests_failed",
-			[
-				`\`${gate}\` failed after rebasing onto ${base} (exit ${gated.exitCode}).`,
-				`${base} is untouched and ${branch} is back at ${before.slice(0, 8)}.`,
-				"",
-				tail(`${gated.stdout}\n${gated.stderr}`),
-			].join("\n"),
-			{ task, exitCode: gated.exitCode },
-		);
-	}
-
-	// Deliberately re-read from disk rather than trusting the copy in hand: a
-	// long test run can outlive the lease, and landing after someone else
-	// claimed the tree would land work that is no longer ours.
-	const current = await worktree.reload();
-	if (!current.leaseOurs) {
-		await lock.release();
-		fail(
-			"lease_lost",
-			`the lease on '${task}' was taken by pid ${current.lease?.pid} during the merge, stopping without landing. Do not retry; another agent owns this tree.`,
-			{ task, lease: current.lease },
-		);
-	}
-
-	// A branch can only be advanced where it is checked out: git allows one
-	// worktree per branch, and moving the ref behind that worktree's back would
-	// leave its index and files on the old commit. For trunk that tree is the
-	// main one; for a task created with `--base task/<other>` it is that task's
-	// worktree, and the work lands there rather than on trunk.
-	const holder = await git.worktreeFor(base);
-	const landing = holder ?? git.root;
-	const checkout = holder ? null : await git.checkout(base);
-	const merged =
-		checkout && checkout.code !== 0
-			? checkout
-			: await git.mergeFfOnly(landing, branch);
-	if (merged.code !== 0) {
-		await lock.release();
-		await bump(worktree);
-		fail(
-			"merge_failed",
-			[
-				`could not fast-forward ${base} in ${landing}: ${merged.stderr || merged.stdout}`,
-				...(landing === git.root
-					? []
-					: [
-							"",
-							`${base} is checked out there, which is the only place it can move.`,
-							"Whoever is working in that tree has to commit or stash what collides,",
-							"then merge again.",
-						]),
-			].join("\n"),
-			{ task, base, landing },
-		);
-	}
-
-	const head = await git.shortHead(landing);
-	// The work is on the base, so the tree has nothing left to hold. Discarding it
-	// here is what keeps `arbor list` a list of live work rather than a graveyard
-	// of landed tasks.
-	//
-	// Step out of it first: merge usually runs from inside the tree it is about
-	// to delete, and spawning git from a directory that no longer exists fails
-	// with ENOENT before git is even reached.
-	service.ps.cd(git.root);
-	const discarded = await current.discard();
-	await lock.release();
-	if (discarded.code !== 0) {
-		fail(
-			"usage",
-			`landed '${task}' on ${base} (${head}) but could not discard its worktree: ${discarded.stderr || discarded.stdout}\nRun \`arbor remove ${task}\` to clean up.`,
-			{ task },
-		);
-	}
-	// After the land, in the main tree: the merge can bring the main tree a
-	// dependency change the way a rebase brings the worktree one. The branch is
-	// already on the base, so a failure here reports and rolls nothing back.
-	if (config.postMerge) {
-		const ran = await shell.run(config.postMerge, landing, {
-			env: { ARBOR_TASK: task },
-		});
-		if (ran.exitCode !== 0) {
-			fail(
-				"hook_failed",
-				[
-					`landed '${task}' on ${base} (${head}) but the postMerge hook failed (exit ${ran.exitCode}).`,
-					"",
-					tail(`${ran.stdout}\n${ran.stderr}`),
-				].join("\n"),
-				{ task, exitCode: ran.exitCode },
-			);
-		}
-	}
-	// Done is done: the todos this task took up leave the list with it.
-	const done = await todos.takenBy(task);
-	for (const todo of done) {
-		await todo.remove();
-	}
-	const lines = [
-		`${color.green("merged")} ${task} onto ${base} (${head})${
-			landing === git.root ? "" : `\n  landed in: ${landing}`
-		}\n  worktree removed, cd ${git.root}`,
-		...done.map((todo) => `  done todo ${todo.id}: ${todo.subject}`),
-	];
-	// Only a landing on trunk ends a piece of work. A part landing on its
-	// parent's branch hands back to that parent, which is not done yet.
-	if (landing === git.root) {
-		lines.push(
-			...recommendation(
-				await recommend(
-					todos,
-					task,
-					config.todoStalenessMs,
-					done.flatMap((todo) => todo.tags),
-				),
-			),
-		);
-	}
-	log.info(lines.join("\n"));
-}
-
-async function bump(worktree: Worktree): Promise<void> {
-	await worktree.take({
-		status: "working",
-		mergeAttempts: worktree.mergeAttempts + 1,
-	});
-}
-
-function tail(output: string): string {
-	return output.trim().split("\n").slice(-TAIL_LINES).join("\n");
-}

package/path.test.ts

@@ -1,35 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { add } from "./add";
-import { path } from "./path";
-import { Testing } from "./testing";
-
-describe("path", () => {
-	let deps: Testing;
-
-	beforeEach(async () => {
-		deps = await Testing.open();
-	});
-
-	afterEach(() => deps.disposeAsync());
-
-	it("prints the main tree bare, so `cd $(arbor path)` works", async () => {
-		await path(deps);
-
-		// Bare: no label, no decoration, nothing a shell would have to strip.
-		expect(deps.out()).toBe(deps.root);
-	});
-
-	it("prints a task's worktree, and refuses one that is not there", async () => {
-		await add(deps, "alpha");
-		const worktree = (await deps.service.find("alpha")).path;
-		deps.log.clear();
-
-		await path(deps, "alpha");
-		expect(deps.out()).toBe(worktree);
-
-		await expect(path(deps, "nope")).toBail("not_found");
-
-		await deps.fs.rm(worktree, { recursive: true, force: true });
-		await expect(path(deps, "alpha")).toBail("orphaned");
-	});
-});

package/path.ts

@@ -1,38 +0,0 @@
-import type { Logger } from "webappwiz/log";
-import { fail } from "./exit";
-import type { WorktreeService } from "./worktree-service";
-
-/**
- * Where a task lives, or (with no task) the main tree. Nothing but the path
- * on stdout, so it composes: `cd "$(arbor path)"`, `zed -a "$(arbor path x)"`.
- * Moving between trees is `cd` and nothing else, and the main tree is the one
- * path a process standing in a worktree cannot otherwise name: git's
- * `--show-toplevel` hands back the worktree it is already in.
- */
-export async function path(
-	{ service, log }: { service: WorktreeService; log: Logger },
-	task?: string,
-): Promise<void> {
-	if (!task) {
-		log.info(service.git.root);
-		return;
-	}
-
-	const worktree = await service.find(task);
-	if (worktree.gone) {
-		fail(
-			"not_found",
-			`no task '${task}': run \`arbor list\` to see what there is`,
-			{ task },
-		);
-	}
-	// A path you cannot cd into is worse than no answer: say so on stderr and
-	// leave stdout empty rather than handing back a directory that is not there.
-	if (!worktree.exists) {
-		fail("orphaned", `'${task}' has no worktree at ${worktree.path}`, {
-			task,
-			worktree: worktree.path,
-		});
-	}
-	log.info(worktree.path);
-}