@os-eco/overstory-cli 0.9.2 → 0.9.3

package/src/runtimes/copilot.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { cleanupTempDir } from "../test-helpers.ts";
 import type { ResolvedModel } from "../types.ts";
-import { CopilotRuntime } from "./copilot.ts";
+import { CopilotRuntime, ensureCopilotTrustedFolders } from "./copilot.ts";
 import type { SpawnOpts } from "./types.ts";
 
 describe("CopilotRuntime", () => {
@@ -29,7 +29,7 @@ describe("CopilotRuntime", () => {
 				env: {},
 			};
 			const cmd = runtime.buildSpawnCommand(opts);
-			expect(cmd).toBe("copilot --model sonnet --allow-all-tools");
+			expect(cmd).toBe("copilot --model claude-sonnet-4-6 --allow-all-tools");
 		});
 
 		test("ask permission mode omits permission flag", () => {
@@ -40,7 +40,7 @@ describe("CopilotRuntime", () => {
 				env: {},
 			};
 			const cmd = runtime.buildSpawnCommand(opts);
-			expect(cmd).toBe("copilot --model opus");
+			expect(cmd).toBe("copilot --model claude-opus-4-6");
 			expect(cmd).not.toContain("--allow-all-tools");
 			expect(cmd).not.toContain("--permission-mode");
 		});
@@ -54,7 +54,7 @@ describe("CopilotRuntime", () => {
 				appendSystemPrompt: "You are a builder agent.",
 			};
 			const cmd = runtime.buildSpawnCommand(opts);
-			expect(cmd).toBe("copilot --model sonnet --allow-all-tools");
+			expect(cmd).toBe("copilot --model claude-sonnet-4-6 --allow-all-tools");
 			expect(cmd).not.toContain("append-system-prompt");
 			expect(cmd).not.toContain("You are a builder agent");
 		});
@@ -68,7 +68,7 @@ describe("CopilotRuntime", () => {
 				appendSystemPromptFile: "/project/.overstory/agent-defs/coordinator.md",
 			};
 			const cmd = runtime.buildSpawnCommand(opts);
-			expect(cmd).toBe("copilot --model opus --allow-all-tools");
+			expect(cmd).toBe("copilot --model claude-opus-4-6 --allow-all-tools");
 			expect(cmd).not.toContain("cat");
 			expect(cmd).not.toContain("coordinator.md");
 		});
@@ -86,16 +86,23 @@ describe("CopilotRuntime", () => {
 			expect(cmd).not.toContain("GITHUB_TOKEN");
 		});
 
-		test("all model names pass through unchanged", () => {
-			for (const model of ["sonnet", "opus", "haiku", "gpt-4o", "openrouter/gpt-5"]) {
+		test("known aliases expand to fully-qualified names, unknown models pass through", () => {
+			const cases: Array<[string, string]> = [
+				["sonnet", "claude-sonnet-4-6"],
+				["opus", "claude-opus-4-6"],
+				["haiku", "claude-haiku-4-5"],
+				["gpt-4o", "gpt-4o"],
+				["openrouter/gpt-5", "openrouter/gpt-5"],
+			];
+			for (const [alias, expected] of cases) {
 				const opts: SpawnOpts = {
-					model,
+					model: alias,
 					permissionMode: "bypass",
 					cwd: "/tmp",
 					env: {},
 				};
 				const cmd = runtime.buildSpawnCommand(opts);
-				expect(cmd).toContain(`--model ${model}`);
+				expect(cmd).toContain(`--model ${expected}`);
 			}
 		});
 
@@ -112,13 +119,37 @@ describe("CopilotRuntime", () => {
 		});
 	});
 
+	describe("expandModel", () => {
+		test("expands 'sonnet' to claude-sonnet-4-6", () => {
+			expect(runtime.expandModel("sonnet")).toBe("claude-sonnet-4-6");
+		});
+
+		test("expands 'opus' to claude-opus-4-6", () => {
+			expect(runtime.expandModel("opus")).toBe("claude-opus-4-6");
+		});
+
+		test("expands 'haiku' to claude-haiku-4-5", () => {
+			expect(runtime.expandModel("haiku")).toBe("claude-haiku-4-5");
+		});
+
+		test("passes through fully-qualified names unchanged", () => {
+			expect(runtime.expandModel("claude-sonnet-4-6")).toBe("claude-sonnet-4-6");
+			expect(runtime.expandModel("gpt-4o")).toBe("gpt-4o");
+			expect(runtime.expandModel("openrouter/gpt-5")).toBe("openrouter/gpt-5");
+		});
+
+		test("passes through unknown aliases unchanged", () => {
+			expect(runtime.expandModel("my-custom-model")).toBe("my-custom-model");
+		});
+	});
+
 	describe("buildPrintCommand", () => {
 		test("basic command without model includes --allow-all-tools", () => {
 			const argv = runtime.buildPrintCommand("Summarize this diff");
 			expect(argv).toEqual(["copilot", "-p", "Summarize this diff", "--allow-all-tools"]);
 		});
 
-		test("command with model override appends --model flag", () => {
+		test("command with model override appends --model flag (alias expanded)", () => {
 			const argv = runtime.buildPrintCommand("Classify this error", "haiku");
 			expect(argv).toEqual([
 				"copilot",
@@ -126,7 +157,19 @@ describe("CopilotRuntime", () => {
 				"Classify this error",
 				"--allow-all-tools",
 				"--model",
-				"haiku",
+				"claude-haiku-4-5",
+			]);
+		});
+
+		test("command with fully-qualified model passes through unchanged", () => {
+			const argv = runtime.buildPrintCommand("Summarize", "gpt-4o");
+			expect(argv).toEqual([
+				"copilot",
+				"-p",
+				"Summarize",
+				"--allow-all-tools",
+				"--model",
+				"gpt-4o",
 			]);
 		});
 
@@ -289,13 +332,13 @@ describe("CopilotRuntime", () => {
 				worktreePath,
 			});
 
-			// No overlay written — .github directory should not be created.
+			// No overlay written — copilot-instructions.md should not exist.
 			const overlayPath = join(worktreePath, ".github", "copilot-instructions.md");
 			const overlayExists = await Bun.file(overlayPath).exists();
 			expect(overlayExists).toBe(false);
 		});
 
-		test("does not write settings.local.json (no hook deployment)", async () => {
+		test("does not write settings.local.json (Copilot uses its own hooks format)", async () => {
 			const worktreePath = join(tempDir, "worktree");
 
 			await runtime.deployConfig(
@@ -309,6 +352,42 @@ describe("CopilotRuntime", () => {
 			const settingsExists = await Bun.file(settingsPath).exists();
 			expect(settingsExists).toBe(false);
 		});
+
+		test("writes .github/hooks/hooks.json with Copilot schema when deployConfig is called", async () => {
+			const worktreePath = join(tempDir, "worktree-hooks");
+
+			await runtime.deployConfig(
+				worktreePath,
+				{ content: "# Instructions" },
+				{ agentName: "test-builder", capability: "builder", worktreePath },
+			);
+
+			const hooksPath = join(worktreePath, ".github", "hooks", "hooks.json");
+			const hooksExists = await Bun.file(hooksPath).exists();
+			expect(hooksExists).toBe(true);
+
+			const hooksContent = JSON.parse(await Bun.file(hooksPath).text()) as Record<string, unknown>;
+			// Copilot schema: top-level "hooks" key with onSessionStart array
+			expect(hooksContent).toHaveProperty("hooks");
+			const hooks = hooksContent.hooks as Record<string, unknown>;
+			expect(hooks).toHaveProperty("onSessionStart");
+			expect(Array.isArray(hooks.onSessionStart)).toBe(true);
+		});
+
+		test("hooks.json contains agentName substituted in commands", async () => {
+			const worktreePath = join(tempDir, "worktree-agentname");
+
+			await runtime.deployConfig(worktreePath, undefined, {
+				agentName: "my-test-agent",
+				capability: "builder",
+				worktreePath,
+			});
+
+			const hooksPath = join(worktreePath, ".github", "hooks", "hooks.json");
+			const raw = await Bun.file(hooksPath).text();
+			expect(raw).toContain("my-test-agent");
+			expect(raw).not.toContain("{{AGENT_NAME}}");
+		});
 	});
 
 	describe("parseTranscript", () => {
@@ -496,6 +575,127 @@ describe("CopilotRuntime", () => {
 	});
 });
 
+describe("ensureCopilotTrustedFolders", () => {
+	let tempDir: string;
+
+	beforeEach(async () => {
+		tempDir = await mkdtemp(join(tmpdir(), "overstory-copilot-trust-test-"));
+	});
+
+	afterEach(async () => {
+		await cleanupTempDir(tempDir);
+	});
+
+	test("creates config.json with trustedFolders when file does not exist", async () => {
+		const configDir = join(tempDir, "github-copilot");
+		await ensureCopilotTrustedFolders("/some/worktree", configDir);
+
+		const configPath = join(configDir, "config.json");
+		const content = JSON.parse(await Bun.file(configPath).text()) as Record<string, unknown>;
+		expect(Array.isArray(content.trustedFolders)).toBe(true);
+		expect(content.trustedFolders).toContain("/some/worktree");
+	});
+
+	test("creates config directory if it does not exist", async () => {
+		const configDir = join(tempDir, "nested", "github-copilot");
+		await ensureCopilotTrustedFolders("/my/worktree", configDir);
+
+		const configPath = join(configDir, "config.json");
+		const exists = await Bun.file(configPath).exists();
+		expect(exists).toBe(true);
+	});
+
+	test("appends to existing trustedFolders without duplicates", async () => {
+		const configDir = join(tempDir, "github-copilot");
+		await ensureCopilotTrustedFolders("/first/path", configDir);
+		await ensureCopilotTrustedFolders("/second/path", configDir);
+
+		const configPath = join(configDir, "config.json");
+		const content = JSON.parse(await Bun.file(configPath).text()) as Record<string, unknown>;
+		expect(Array.isArray(content.trustedFolders)).toBe(true);
+		const trusted = content.trustedFolders as string[];
+		expect(trusted).toContain("/first/path");
+		expect(trusted).toContain("/second/path");
+		expect(trusted.length).toBe(2);
+	});
+
+	test("does not duplicate existing entries", async () => {
+		const configDir = join(tempDir, "github-copilot");
+		await ensureCopilotTrustedFolders("/some/worktree", configDir);
+		await ensureCopilotTrustedFolders("/some/worktree", configDir);
+
+		const configPath = join(configDir, "config.json");
+		const content = JSON.parse(await Bun.file(configPath).text()) as Record<string, unknown>;
+		const trusted = content.trustedFolders as string[];
+		expect(trusted.filter((p) => p === "/some/worktree").length).toBe(1);
+	});
+
+	test("preserves other config keys when updating trustedFolders", async () => {
+		const configDir = join(tempDir, "github-copilot");
+		const configPath = join(configDir, "config.json");
+		await Bun.write(
+			configPath,
+			`${JSON.stringify({ someOtherKey: "value", trustedFolders: [] }, null, "\t")}\n`,
+		);
+
+		await ensureCopilotTrustedFolders("/new/worktree", configDir);
+
+		const content = JSON.parse(await Bun.file(configPath).text()) as Record<string, unknown>;
+		expect(content.someOtherKey).toBe("value");
+		expect(content.trustedFolders as string[]).toContain("/new/worktree");
+	});
+
+	test("handles invalid JSON in existing config by starting fresh", async () => {
+		const configDir = join(tempDir, "github-copilot");
+		await Bun.write(join(configDir, "config.json"), "not valid json");
+		await ensureCopilotTrustedFolders("/new/worktree", configDir);
+
+		const configPath = join(configDir, "config.json");
+		const content = JSON.parse(await Bun.file(configPath).text()) as Record<string, unknown>;
+		expect(content.trustedFolders as string[]).toContain("/new/worktree");
+	});
+
+	test("treats non-array trustedFolders as empty and replaces it", async () => {
+		const configDir = join(tempDir, "github-copilot");
+		const configPath = join(configDir, "config.json");
+		await Bun.write(
+			configPath,
+			`${JSON.stringify({ trustedFolders: "not-an-array" }, null, "\t")}\n`,
+		);
+
+		await ensureCopilotTrustedFolders("/my/worktree", configDir);
+
+		const content = JSON.parse(await Bun.file(configPath).text()) as Record<string, unknown>;
+		expect(Array.isArray(content.trustedFolders)).toBe(true);
+		expect(content.trustedFolders as string[]).toContain("/my/worktree");
+	});
+});
+
+describe("CopilotRuntime.prepareWorktree", () => {
+	let tempDir: string;
+
+	beforeEach(async () => {
+		tempDir = await mkdtemp(join(tmpdir(), "overstory-copilot-prepworktree-test-"));
+	});
+
+	afterEach(async () => {
+		await cleanupTempDir(tempDir);
+	});
+
+	test("prepareWorktree is defined on CopilotRuntime", () => {
+		const runtime = new CopilotRuntime();
+		expect(typeof runtime.prepareWorktree).toBe("function");
+	});
+
+	test("calling prepareWorktree with a worktreePath does not throw", async () => {
+		// We can't inject configDir through the interface method, but we can verify
+		// it doesn't throw. The actual file write goes to real homedir, which is
+		// tested via ensureCopilotTrustedFolders directly.
+		const runtime = new CopilotRuntime();
+		await expect(runtime.prepareWorktree("/test/worktree")).resolves.toBeUndefined();
+	});
+});
+
 describe("CopilotRuntime integration: registry resolves 'copilot'", () => {
 	test("getRuntime('copilot') returns CopilotRuntime", async () => {
 		const { getRuntime } = await import("./registry.ts");

package/src/runtimes/copilot.ts

@@ -2,7 +2,9 @@
 // Implements the AgentRuntime contract for the `copilot` CLI (GitHub Copilot).
 
 import { mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
 import { join } from "node:path";
+import { deployCopilotHooks } from "../agents/copilot-hooks-deployer.ts";
 import type { ResolvedModel } from "../types.ts";
 import type {
 	AgentRuntime,
@@ -13,6 +15,54 @@ import type {
 	TranscriptSummary,
 } from "./types.ts";
 
+/**
+ * Map of overstory model aliases to fully-qualified Copilot model names.
+ *
+ * The copilot CLI rejects short aliases like "sonnet" and requires fully-qualified
+ * names like "claude-sonnet-4-6". Unknown names (e.g. "gpt-4o", "openrouter/gpt-5")
+ * are passed through unchanged.
+ */
+const MODEL_MAP: Record<string, string> = {
+	sonnet: "claude-sonnet-4-6",
+	opus: "claude-opus-4-6",
+	haiku: "claude-haiku-4-5",
+};
+
+/**
+ * Add a worktree path to the Copilot trusted folders list.
+ *
+ * Reads `~/.config/github-copilot/config.json`, appends the worktreePath to
+ * the `trustedFolders` array if not already present, and writes back atomically.
+ * Creates the config directory if it does not exist.
+ *
+ * Exported for testability — callers can inject a custom configDir to avoid
+ * touching the real home directory in tests.
+ *
+ * @param worktreePath - Absolute path to the worktree to pre-trust
+ * @param configDir - Override the config directory (default: ~/.config/github-copilot)
+ */
+export async function ensureCopilotTrustedFolders(
+	worktreePath: string,
+	configDir: string = join(homedir(), ".config", "github-copilot"),
+): Promise<void> {
+	const configPath = join(configDir, "config.json");
+	await mkdir(configDir, { recursive: true });
+
+	let config: Record<string, unknown> = {};
+	try {
+		config = JSON.parse(await Bun.file(configPath).text()) as Record<string, unknown>;
+	} catch {
+		// File doesn't exist or contains invalid JSON — start fresh.
+	}
+
+	const trusted = Array.isArray(config.trustedFolders) ? (config.trustedFolders as string[]) : [];
+	if (!trusted.includes(worktreePath)) {
+		trusted.push(worktreePath);
+		config.trustedFolders = trusted;
+		await Bun.write(configPath, `${JSON.stringify(config, null, "\t")}\n`);
+	}
+}
+
 /**
  * GitHub Copilot runtime adapter.
  *
@@ -34,11 +84,25 @@ export class CopilotRuntime implements AgentRuntime {
 	/** Relative path to the instruction file within a worktree. */
 	readonly instructionPath = ".github/copilot-instructions.md";
 
+	/**
+	 * Expand a model alias to a fully-qualified Copilot model name.
+	 *
+	 * Looks up the alias in MODEL_MAP. If not found, returns the model unchanged.
+	 * This allows known aliases (sonnet, opus, haiku) to be resolved while
+	 * passing through fully-qualified names (e.g. gpt-4o, openrouter/gpt-5).
+	 *
+	 * @param model - Short alias or fully-qualified model name
+	 * @returns Fully-qualified model name accepted by the copilot CLI
+	 */
+	expandModel(model: string): string {
+		return MODEL_MAP[model] ?? model;
+	}
+
 	/**
 	 * Build the shell command string to spawn an interactive Copilot agent.
 	 *
 	 * Maps SpawnOpts to `copilot` CLI flags:
-	 * - `model` → `--model <model>`
+	 * - `model` → `--model <model>` (aliases expanded via MODEL_MAP)
 	 * - `permissionMode === "bypass"` → `--allow-all-tools`
 	 * - `permissionMode === "ask"` → no permission flag added
 	 * - `appendSystemPrompt` and `appendSystemPromptFile` are IGNORED —
@@ -51,7 +115,7 @@ export class CopilotRuntime implements AgentRuntime {
 	 * @returns Shell command string suitable for tmux new-session -c
 	 */
 	buildSpawnCommand(opts: SpawnOpts): string {
-		let cmd = `copilot --model ${opts.model}`;
+		let cmd = `copilot --model ${this.expandModel(opts.model)}`;
 
 		if (opts.permissionMode === "bypass") {
 			cmd += " --allow-all-tools";
@@ -79,29 +143,27 @@ export class CopilotRuntime implements AgentRuntime {
 	buildPrintCommand(prompt: string, model?: string): string[] {
 		const cmd = ["copilot", "-p", prompt, "--allow-all-tools"];
 		if (model !== undefined) {
-			cmd.push("--model", model);
+			cmd.push("--model", this.expandModel(model));
 		}
 		return cmd;
 	}
 
 	/**
-	 * Deploy per-agent instructions to a worktree.
+	 * Deploy per-agent instructions and lifecycle hooks to a worktree.
 	 *
-	 * For Copilot this writes only the instruction file:
+	 * For Copilot this writes:
 	 * - `.github/copilot-instructions.md` — the agent's task-specific overlay.
 	 *   Skipped when overlay is undefined.
-	 *
-	 * The `hooks` parameter is unused — Copilot does not support Claude Code's
-	 * hook mechanism, so no settings file is deployed.
+	 * - `.github/hooks/hooks.json` — Copilot lifecycle hooks (onSessionStart).
 	 *
 	 * @param worktreePath - Absolute path to the agent's git worktree
 	 * @param overlay - Overlay content to write as copilot-instructions.md, or undefined to skip
-	 * @param _hooks - Unused for Copilot runtime
+	 * @param hooks - Hook config providing agentName for hook command substitution
 	 */
 	async deployConfig(
 		worktreePath: string,
 		overlay: OverlayContent | undefined,
-		_hooks: HooksDef,
+		hooks: HooksDef,
 	): Promise<void> {
 		if (overlay) {
 			const githubDir = join(worktreePath, ".github");
@@ -109,7 +171,8 @@ export class CopilotRuntime implements AgentRuntime {
 			await Bun.write(join(githubDir, "copilot-instructions.md"), overlay.content);
 		}
 
-		// No hook deployment for Copilot — the runtime has no hook mechanism.
+		// Deploy Copilot lifecycle hooks (Phase 1: onSessionStart only).
+		await deployCopilotHooks(worktreePath, hooks.agentName);
 	}
 
 	/**
@@ -231,4 +294,23 @@ export class CopilotRuntime implements AgentRuntime {
 	getTranscriptDir(_projectRoot: string): string | null {
 		return null;
 	}
+
+	/**
+	 * Pre-trust the worktree path in the Copilot config.
+	 *
+	 * Copilot shows an interactive folder trust dialog when it encounters a new
+	 * worktree path. Pre-writing the path to ~/.config/github-copilot/config.json
+	 * before spawn prevents this dialog from blocking the agent session.
+	 *
+	 * Errors are non-fatal: a warning is emitted to stderr and spawn continues.
+	 *
+	 * @param worktreePath - Absolute path to the agent's worktree
+	 */
+	async prepareWorktree(worktreePath: string): Promise<void> {
+		try {
+			await ensureCopilotTrustedFolders(worktreePath);
+		} catch {
+			process.stderr.write(`Warning: Could not pre-trust Copilot folder: ${worktreePath}\n`);
+		}
+	}
 }

package/src/runtimes/pi.test.ts

@@ -313,6 +313,30 @@ describe("PiRuntime", () => {
 			const state = runtime.detectReady(pane);
 			expect(state).toEqual({ phase: "ready" });
 		});
+
+		test("returns ready for 1.0M context window (Opus/Sonnet large context)", () => {
+			const pane = [
+				" pi v0.55.1",
+				" escape to interrupt",
+				"",
+				"────────────────────────────────",
+				"~/Projects/os-eco/overstory (main)",
+				"0.0%/1.0M (auto)         (anthropic) claude-opus-4-6 • high",
+			].join("\n");
+			const state = runtime.detectReady(pane);
+			expect(state).toEqual({ phase: "ready" });
+		});
+
+		test("returns loading when only 1.0M status bar present (no header)", () => {
+			const state = runtime.detectReady("0.0%/1.0M (auto)         (anthropic) claude-opus-4-6");
+			expect(state).toEqual({ phase: "loading" });
+		});
+
+		test("returns ready for 2.0M context window", () => {
+			const pane = " pi v1.0\n\n0.0%/2.0M done";
+			const state = runtime.detectReady(pane);
+			expect(state).toEqual({ phase: "ready" });
+		});
 	});
 
 	describe("buildEnv", () => {

package/src/runtimes/pi.ts

@@ -168,10 +168,11 @@ export class PiRuntime implements AgentRuntime {
 	 */
 	detectReady(paneContent: string): ReadyState {
 		// Pi's TUI shows "pi v<version>" in the header and a status bar with
-		// a token usage indicator like "0.0%/200k" when fully rendered.
-		// Earlier detection checked for "model:" which Pi's TUI never contains.
+		// a token usage indicator like "0.0%/200k" or "0.0%/1.0M" when fully rendered.
+		// The context window size uses k-scale (e.g. 200k) for smaller models and
+		// M-scale (e.g. 1.0M) for Opus/Sonnet with 1M+ context windows.
 		const hasHeader = paneContent.includes("pi v");
-		const hasStatusBar = /\d+\.\d+%\/\d+k/.test(paneContent);
+		const hasStatusBar = /\d+\.\d+%\/[\d.]+[kKmM]/.test(paneContent);
 		if (hasHeader && hasStatusBar) {
 			return { phase: "ready" };
 		}

package/src/runtimes/types.ts

@@ -246,4 +246,11 @@ export interface AgentRuntime {
 	 * The caller provides the raw stdout ReadableStream from Bun.spawn().
 	 */
 	parseEvents?(stream: ReadableStream<Uint8Array>): AsyncIterable<AgentEvent>;
+
+	/**
+	 * Prepare a worktree path before spawning an agent.
+	 * Called by sling.ts after worktree creation but before agent spawn.
+	 * Used by runtimes that need environment setup (e.g., Copilot folder trust).
+	 */
+	prepareWorktree?(worktreePath: string): Promise<void>;
 }

package/src/tracker/factory.test.ts

@@ -68,6 +68,16 @@ describe("resolveBackend", () => {
 			await rm(tempDir, { recursive: true });
 		}
 	});
+	test("returns beads for auto when both .seeds/ and .beads/ exist", async () => {
+		const tempDir = await mkdtemp(join(tmpdir(), "tracker-test-"));
+		try {
+			await mkdir(join(tempDir, ".beads"));
+			await mkdir(join(tempDir, ".seeds"));
+			expect(await resolveBackend("auto", tempDir)).toBe("beads");
+		} finally {
+			await rm(tempDir, { recursive: true });
+		}
+	});
 });
 
 describe("trackerCliName", () => {

package/src/tracker/factory.ts

@@ -38,7 +38,8 @@ export async function resolveBackend(
 ): Promise<TrackerBackend> {
 	if (configBackend === "beads") return "beads";
 	if (configBackend === "seeds") return "seeds";
-	// "auto" detection: check for .seeds/ directory first (newer tool), then .beads/
+	// "auto" detection: check for .beads/ first (never auto-scaffolded by ov init,
+	// so its presence signals explicit user setup), then .seeds/.
 	const dirExists = async (path: string): Promise<boolean> => {
 		try {
 			const s = await stat(path);
@@ -47,8 +48,8 @@ export async function resolveBackend(
 			return false;
 		}
 	};
-	if (await dirExists(join(cwd, ".seeds"))) return "seeds";
 	if (await dirExists(join(cwd, ".beads"))) return "beads";
+	if (await dirExists(join(cwd, ".seeds"))) return "seeds";
 	// Default fallback — seeds is the preferred tracker
 	return "seeds";
 }