@os-eco/overstory-cli 0.8.6 → 0.8.7

package/src/runtimes/gemini.ts

@@ -39,6 +39,9 @@ export class GeminiRuntime implements AgentRuntime {
 	/** Unique identifier for this runtime. */
 	readonly id = "gemini";
 
+	/** Stability level. Gemini adapter is experimental — not fully validated. */
+	readonly stability = "experimental" as const;
+
 	/** Relative path to the instruction file within a worktree. */
 	readonly instructionPath = "GEMINI.md";
 

package/src/runtimes/opencode.ts

@@ -41,6 +41,9 @@ export class OpenCodeRuntime implements AgentRuntime {
 	/** Unique identifier for this runtime. */
 	readonly id = "opencode";
 
+	/** Stability level. OpenCode adapter is experimental — not fully validated. */
+	readonly stability = "experimental" as const;
+
 	/**
 	 * Relative path to the instruction file within a worktree.
 	 *

package/src/runtimes/pi.test.ts

@@ -759,7 +759,7 @@ describe("PiRuntime integration: registry resolves 'pi'", () => {
 
 	test("getRuntime rejects truly unknown runtimes", async () => {
 		const { getRuntime } = await import("./registry.ts");
-		expect(() => getRuntime("cursor")).toThrow('Unknown runtime: "cursor"');
 		expect(() => getRuntime("nonexistent")).toThrow('Unknown runtime: "nonexistent"');
+		expect(() => getRuntime("does-not-exist")).toThrow('Unknown runtime: "does-not-exist"');
 	});
 });

package/src/runtimes/pi.ts

@@ -35,6 +35,9 @@ export class PiRuntime implements AgentRuntime {
 	/** Unique identifier for this runtime. */
 	readonly id = "pi";
 
+	/** Stability level. Pi adapter is experimental — not fully validated. */
+	readonly stability = "experimental" as const;
+
 	/** Relative path to the instruction file within a worktree. Pi reads .claude/CLAUDE.md natively. */
 	readonly instructionPath = ".claude/CLAUDE.md";
 

package/src/runtimes/registry.test.ts

@@ -3,6 +3,7 @@ import type { OverstoryConfig } from "../types.ts";
 import { ClaudeRuntime } from "./claude.ts";
 import { CodexRuntime } from "./codex.ts";
 import { CopilotRuntime } from "./copilot.ts";
+import { CursorRuntime } from "./cursor.ts";
 import { GeminiRuntime } from "./gemini.ts";
 import { OpenCodeRuntime } from "./opencode.ts";
 import { PiRuntime } from "./pi.ts";
@@ -23,7 +24,7 @@ describe("getRuntime", () => {
 
 	it("throws with a helpful message for an unknown runtime", () => {
 		expect(() => getRuntime("unknown-runtime")).toThrow(
-			'Unknown runtime: "unknown-runtime". Available: claude, codex, pi, copilot, gemini, sapling, opencode',
+			'Unknown runtime: "unknown-runtime". Available: claude, codex, pi, copilot, cursor, gemini, sapling, opencode',
 		);
 	});
 
@@ -106,6 +107,25 @@ describe("getRuntime", () => {
 		expect(a).not.toBe(b);
 	});
 
+	it("returns CursorRuntime when name is 'cursor'", () => {
+		const runtime = getRuntime("cursor");
+		expect(runtime).toBeInstanceOf(CursorRuntime);
+		expect(runtime.id).toBe("cursor");
+	});
+
+	it("uses config.runtime.default 'cursor' when name is omitted", () => {
+		const config = { runtime: { default: "cursor" } } as OverstoryConfig;
+		const runtime = getRuntime(undefined, config);
+		expect(runtime).toBeInstanceOf(CursorRuntime);
+		expect(runtime.id).toBe("cursor");
+	});
+
+	it("cursor runtime returns a new instance on each call", () => {
+		const a = getRuntime("cursor");
+		const b = getRuntime("cursor");
+		expect(a).not.toBe(b);
+	});
+
 	it("returns GeminiRuntime when name is 'gemini'", () => {
 		const runtime = getRuntime("gemini");
 		expect(runtime).toBeInstanceOf(GeminiRuntime);

package/src/runtimes/registry.ts

@@ -5,6 +5,7 @@ import type { OverstoryConfig } from "../types.ts";
 import { ClaudeRuntime } from "./claude.ts";
 import { CodexRuntime } from "./codex.ts";
 import { CopilotRuntime } from "./copilot.ts";
+import { CursorRuntime } from "./cursor.ts";
 import { GeminiRuntime } from "./gemini.ts";
 import { OpenCodeRuntime } from "./opencode.ts";
 import { PiRuntime } from "./pi.ts";
@@ -17,6 +18,7 @@ const runtimes = new Map<string, () => AgentRuntime>([
 	["codex", () => new CodexRuntime()],
 	["pi", () => new PiRuntime()],
 	["copilot", () => new CopilotRuntime()],
+	["cursor", () => new CursorRuntime()],
 	["gemini", () => new GeminiRuntime()],
 	["sapling", () => new SaplingRuntime()],
 	["opencode", () => new OpenCodeRuntime()],
@@ -37,6 +39,7 @@ export function getAllRuntimes(): AgentRuntime[] {
 		new CodexRuntime(),
 		new PiRuntime(),
 		new CopilotRuntime(),
+		new CursorRuntime(),
 		new GeminiRuntime(),
 		new SaplingRuntime(),
 		new OpenCodeRuntime(),

package/src/runtimes/sapling.ts

@@ -345,6 +345,9 @@ export class SaplingRuntime implements AgentRuntime {
 	/** Unique identifier for this runtime. */
 	readonly id = "sapling";
 
+	/** Stability level. Sapling is the primary headless runtime. */
+	readonly stability = "stable" as const;
+
 	/** Relative path to the instruction file within a worktree. */
 	readonly instructionPath = "SAPLING.md";
 

package/src/runtimes/types.ts

@@ -19,6 +19,8 @@ export interface SpawnOpts {
 	appendSystemPromptFile?: string;
 	/** Working directory for the spawned process. */
 	cwd: string;
+	/** Additional directories that the runtime may need to write outside cwd. */
+	sharedWritableDirs?: string[];
 	/** Additional environment variables to pass to the spawned process. */
 	env: Record<string, string>;
 }
@@ -147,6 +149,9 @@ export interface AgentRuntime {
 	/** Unique runtime identifier (e.g. "claude", "codex", "pi"). */
 	id: string;
 
+	/** Stability level of this runtime adapter. */
+	readonly stability: "stable" | "beta" | "experimental";
+
 	/** Relative path to the instruction file within a worktree (e.g. ".claude/CLAUDE.md"). */
 	readonly instructionPath: string;
 

package/src/schema-consistency.test.ts

@@ -87,6 +87,7 @@ describe("SQL schema consistency", () => {
 			const expected = [
 				"agent_count",
 				"completed_at",
+				"coordinator_name",
 				"coordinator_session_id",
 				"id",
 				"started_at",

package/src/sessions/store.test.ts

@@ -587,6 +587,48 @@ describe("edge cases", () => {
 	});
 });
 
+// ============================================================
+// SessionStore migration: coordinator_name in runs table
+// ============================================================
+
+describe("createSessionStore migrates runs table coordinator_name", () => {
+	test("opens successfully when existing runs table lacks coordinator_name", async () => {
+		// Close the store created by beforeEach so we can recreate the DB manually.
+		store.close();
+
+		const { Database: Db } = await import("bun:sqlite");
+		const legacyDb = new Db(dbPath);
+		// Drop runs table and recreate WITHOUT coordinator_name (simulates pre-migration DB).
+		legacyDb.exec("DROP TABLE IF EXISTS runs");
+		legacyDb.exec(`
+			CREATE TABLE runs (
+				id TEXT PRIMARY KEY,
+				started_at TEXT NOT NULL,
+				completed_at TEXT,
+				agent_count INTEGER NOT NULL DEFAULT 0,
+				coordinator_session_id TEXT,
+				status TEXT NOT NULL DEFAULT 'active'
+			)
+		`);
+		legacyDb.exec(
+			"INSERT INTO runs (id, started_at, status) VALUES ('legacy-run', '2026-01-01T00:00:00.000Z', 'active')",
+		);
+		legacyDb.close();
+
+		// createSessionStore should migrate the table and create indexes without error.
+		const migratedStore = createSessionStore(dbPath);
+		try {
+			// Verify the store works (no "no such column" error).
+			expect(migratedStore.getAll()).toBeArray();
+		} finally {
+			migratedStore.close();
+		}
+
+		// Re-assign so afterEach cleanup works.
+		store = createSessionStore(join(tempDir, "unused.db"));
+	});
+});
+
 // ============================================================
 // RunStore Tests
 // ============================================================
@@ -892,6 +934,142 @@ describe("RunStore", () => {
 		});
 	});
 
+	// === coordinatorName ===
+
+	describe("coordinatorName", () => {
+		test("creates run with coordinatorName and retrieves it", () => {
+			runStore.createRun(makeRun({ coordinatorName: "coordinator" }));
+			const result = runStore.getRun("run-2026-02-13T10:00:00.000Z");
+			expect(result?.coordinatorName).toBe("coordinator");
+		});
+
+		test("creates run with null coordinatorName", () => {
+			runStore.createRun(makeRun({ coordinatorName: null }));
+			const result = runStore.getRun("run-2026-02-13T10:00:00.000Z");
+			expect(result?.coordinatorName).toBeNull();
+		});
+
+		test("creates run without coordinatorName defaults to null", () => {
+			runStore.createRun(makeRun());
+			const result = runStore.getRun("run-2026-02-13T10:00:00.000Z");
+			expect(result?.coordinatorName).toBeNull();
+		});
+	});
+
+	// === getActiveRunForCoordinator ===
+
+	describe("getActiveRunForCoordinator", () => {
+		test("returns the active run for the given coordinator", () => {
+			runStore.createRun(
+				makeRun({
+					id: "run-coord-a",
+					coordinatorName: "coordinator-a",
+					startedAt: "2026-02-13T10:00:00.000Z",
+				}),
+			);
+			runStore.createRun(
+				makeRun({
+					id: "run-coord-b",
+					coordinatorName: "coordinator-b",
+					startedAt: "2026-02-13T11:00:00.000Z",
+				}),
+			);
+
+			const result = runStore.getActiveRunForCoordinator("coordinator-a");
+			expect(result?.id).toBe("run-coord-a");
+		});
+
+		test("returns null when no active run for coordinator", () => {
+			runStore.createRun(makeRun({ id: "run-coord-a", coordinatorName: "coordinator-a" }));
+			runStore.completeRun("run-coord-a", "completed");
+
+			const result = runStore.getActiveRunForCoordinator("coordinator-a");
+			expect(result).toBeNull();
+		});
+
+		test("returns null for unknown coordinator", () => {
+			runStore.createRun(makeRun({ id: "run-coord-a", coordinatorName: "coordinator-a" }));
+			const result = runStore.getActiveRunForCoordinator("other-coordinator");
+			expect(result).toBeNull();
+		});
+
+		test("returns most recent active run when coordinator has multiple", () => {
+			runStore.createRun(
+				makeRun({
+					id: "run-early",
+					coordinatorName: "coordinator",
+					startedAt: "2026-02-13T08:00:00.000Z",
+				}),
+			);
+			runStore.createRun(
+				makeRun({
+					id: "run-late",
+					coordinatorName: "coordinator",
+					startedAt: "2026-02-13T12:00:00.000Z",
+				}),
+			);
+
+			const result = runStore.getActiveRunForCoordinator("coordinator");
+			expect(result?.id).toBe("run-late");
+		});
+
+		test("ignores runs for other coordinators", () => {
+			runStore.createRun(makeRun({ id: "run-a", coordinatorName: "coordinator-a" }));
+			runStore.createRun(
+				makeRun({
+					id: "run-b",
+					coordinatorName: "coordinator-b",
+					startedAt: "2026-02-13T11:00:00.000Z",
+				}),
+			);
+
+			const result = runStore.getActiveRunForCoordinator("coordinator-a");
+			expect(result?.id).toBe("run-a");
+			expect(result?.coordinatorName).toBe("coordinator-a");
+		});
+	});
+
+	// === migration: coordinator_name column ===
+
+	describe("migration: coordinator_name column", () => {
+		test("adds coordinator_name column to existing runs table without it", async () => {
+			// Create a store, close it, then manually drop the coordinator_name column
+			// by creating a fresh DB without it, simulating a pre-migration schema.
+			runStore.close();
+
+			const { Database: Db } = await import("bun:sqlite");
+			const legacyDb = new Db(dbPath);
+			legacyDb.exec("DROP TABLE IF EXISTS runs");
+			legacyDb.exec(`
+				CREATE TABLE runs (
+					id TEXT PRIMARY KEY,
+					started_at TEXT NOT NULL,
+					completed_at TEXT,
+					agent_count INTEGER NOT NULL DEFAULT 0,
+					coordinator_session_id TEXT,
+					status TEXT NOT NULL DEFAULT 'active'
+				)
+			`);
+			legacyDb.exec(
+				"INSERT INTO runs (id, started_at, status) VALUES ('legacy-run', '2026-01-01T00:00:00.000Z', 'active')",
+			);
+			legacyDb.close();
+
+			// Opening a new RunStore should run the migration and add coordinator_name
+			const migratedStore = createRunStore(dbPath);
+			try {
+				const run = migratedStore.getRun("legacy-run");
+				expect(run).not.toBeNull();
+				expect(run?.coordinatorName).toBeNull();
+			} finally {
+				migratedStore.close();
+			}
+
+			// Re-assign store so afterEach cleanup doesn't double-close
+			runStore = createRunStore(join(tempDir, "unused-run.db"));
+		});
+	});
+
 	// === close ===
 
 	describe("close", () => {

package/src/sessions/store.ts

@@ -66,6 +66,7 @@ interface RunRow {
 	completed_at: string | null;
 	agent_count: number;
 	coordinator_session_id: string | null;
+	coordinator_name: string | null;
 	status: string;
 }
 
@@ -102,12 +103,14 @@ CREATE TABLE IF NOT EXISTS runs (
   completed_at TEXT,
   agent_count INTEGER NOT NULL DEFAULT 0,
   coordinator_session_id TEXT,
+  coordinator_name TEXT,
   status TEXT NOT NULL DEFAULT 'active'
     CHECK(status IN ('active','completed','failed'))
 )`;
 
 const CREATE_RUNS_INDEXES = `
-CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status)`;
+CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);
+CREATE INDEX IF NOT EXISTS idx_runs_coordinator ON runs(coordinator_name)`;
 
 /** Convert a database row (snake_case) to an AgentSession object (camelCase). */
 function rowToSession(row: SessionRow): AgentSession {
@@ -140,6 +143,7 @@ function rowToRun(row: RunRow): Run {
 		completedAt: row.completed_at,
 		agentCount: row.agent_count,
 		coordinatorSessionId: row.coordinator_session_id,
+		coordinatorName: row.coordinator_name,
 		status: row.status as RunStatus,
 	};
 }
@@ -182,16 +186,18 @@ export function createSessionStore(dbPath: string): SessionStore {
 	db.exec("PRAGMA synchronous = NORMAL");
 	db.exec("PRAGMA busy_timeout = 5000");
 
-	// Create schema
+	// Create schema (tables first, then migrations, then indexes)
 	db.exec(CREATE_TABLE);
-	db.exec(CREATE_INDEXES);
 	db.exec(CREATE_RUNS_TABLE);
-	db.exec(CREATE_RUNS_INDEXES);
 
-	// Migrate: rename bead_id → task_id on existing tables
+	// Migrate existing tables BEFORE creating indexes that reference new columns.
 	migrateBeadIdToTaskId(db);
-	// Migrate: add transcript_path column to existing tables
 	migrateAddTranscriptPath(db);
+	migrateAddCoordinatorName(db);
+
+	// Now safe to create indexes (all columns exist).
+	db.exec(CREATE_INDEXES);
+	db.exec(CREATE_RUNS_INDEXES);
 
 	// Prepare statements for frequent operations
 	const upsertStmt = db.prepare<
@@ -420,6 +426,18 @@ export function createSessionStore(dbPath: string): SessionStore {
 	};
 }
 
+/**
+ * Migrate an existing runs table to add the coordinator_name column.
+ * Safe to call multiple times — only adds the column if it does not exist.
+ */
+function migrateAddCoordinatorName(db: Database): void {
+	const rows = db.prepare("PRAGMA table_info(runs)").all() as Array<{ name: string }>;
+	const existingColumns = new Set(rows.map((r) => r.name));
+	if (!existingColumns.has("coordinator_name")) {
+		db.exec("ALTER TABLE runs ADD COLUMN coordinator_name TEXT");
+	}
+}
+
 /**
  * Create a new RunStore backed by a SQLite database at the given path.
  *
@@ -436,6 +454,11 @@ export function createRunStore(dbPath: string): RunStore {
 
 	// Create schema (idempotent — safe if SessionStore already created these)
 	db.exec(CREATE_RUNS_TABLE);
+
+	// Migrate: add coordinator_name column BEFORE creating indexes that reference it.
+	// The migration is a no-op on new databases (column already in CREATE_RUNS_TABLE).
+	migrateAddCoordinatorName(db);
+
 	db.exec(CREATE_RUNS_INDEXES);
 
 	// Prepare statements for frequent operations
@@ -447,11 +470,12 @@ export function createRunStore(dbPath: string): RunStore {
 			$completed_at: string | null;
 			$agent_count: number;
 			$coordinator_session_id: string | null;
+			$coordinator_name: string | null;
 			$status: string;
 		}
 	>(`
-		INSERT INTO runs (id, started_at, completed_at, agent_count, coordinator_session_id, status)
-		VALUES ($id, $started_at, $completed_at, $agent_count, $coordinator_session_id, $status)
+		INSERT INTO runs (id, started_at, completed_at, agent_count, coordinator_session_id, coordinator_name, status)
+		VALUES ($id, $started_at, $completed_at, $agent_count, $coordinator_session_id, $coordinator_name, $status)
 	`);
 
 	const getRunStmt = db.prepare<RunRow, { $id: string }>(`
@@ -464,6 +488,12 @@ export function createRunStore(dbPath: string): RunStore {
 		LIMIT 1
 	`);
 
+	const getActiveRunForCoordinatorStmt = db.prepare<RunRow, { $coordinator_name: string }>(`
+		SELECT * FROM runs WHERE status = 'active' AND coordinator_name = $coordinator_name
+		ORDER BY started_at DESC
+		LIMIT 1
+	`);
+
 	const incrementAgentCountStmt = db.prepare<void, { $id: string }>(`
 		UPDATE runs SET agent_count = agent_count + 1 WHERE id = $id
 	`);
@@ -483,6 +513,7 @@ export function createRunStore(dbPath: string): RunStore {
 				$completed_at: null,
 				$agent_count: run.agentCount ?? 0,
 				$coordinator_session_id: run.coordinatorSessionId,
+				$coordinator_name: run.coordinatorName ?? null,
 				$status: run.status,
 			});
 		},
@@ -497,6 +528,11 @@ export function createRunStore(dbPath: string): RunStore {
 			return row ? rowToRun(row) : null;
 		},
 
+		getActiveRunForCoordinator(coordinatorName: string): Run | null {
+			const row = getActiveRunForCoordinatorStmt.get({ $coordinator_name: coordinatorName });
+			return row ? rowToRun(row) : null;
+		},
+
 		listRuns(opts?: { limit?: number; status?: RunStatus }): Run[] {
 			const conditions: string[] = [];
 			const params: Record<string, string | number> = {};

package/src/types.ts

@@ -391,6 +391,8 @@ export interface MergeResult {
 	tier: ResolutionTier;
 	conflictFiles: string[];
 	errorMessage: string | null;
+	/** Warnings about files where auto-resolve was skipped to prevent content loss. */
+	warnings: string[];
 }
 
 /** Parsed conflict pattern from a single mulch record. */
@@ -586,12 +588,15 @@ export interface Run {
 	completedAt: string | null;
 	agentCount: number;
 	coordinatorSessionId: string | null;
+	coordinatorName: string | null; // which coordinator owns this run
 	status: RunStatus;
 }
 
 /** Input for creating a new run. */
-export type InsertRun = Omit<Run, "completedAt" | "agentCount"> & {
+export type InsertRun = Omit<Run, "completedAt" | "agentCount" | "coordinatorName"> & {
 	agentCount?: number;
+	/** Which coordinator owns this run. Defaults to null when not provided. */
+	coordinatorName?: string | null;
 };
 
 /** Interface for run management operations. */
@@ -602,6 +607,8 @@ export interface RunStore {
 	getRun(id: string): Run | null;
 	/** Get the most recently started active run. */
 	getActiveRun(): Run | null;
+	/** Get the most recently started active run for a specific coordinator. */
+	getActiveRunForCoordinator(coordinatorName: string): Run | null;
 	/** List runs, optionally limited. */
 	listRuns(opts?: { limit?: number; status?: RunStatus }): Run[];
 	/** Increment agent count for a run. */

package/src/worktree/tmux.test.ts

@@ -242,6 +242,53 @@ describe("createSession", () => {
 		const tmuxCmd = cmd[7] as string;
 		expect(tmuxCmd).toContain("echo test");
 	});
+
+	test("retries list-panes on transient failure", async () => {
+		let callCount = 0;
+		spawnSpy.mockImplementation(() => {
+			callCount++;
+			if (callCount === 1) {
+				// which overstory
+				return mockSpawnResult("/usr/local/bin/overstory\n", "", 0);
+			}
+			if (callCount === 2) {
+				// tmux new-session
+				return mockSpawnResult("", "", 0);
+			}
+			if (callCount === 3) {
+				// First list-panes fails (WSL2 race)
+				return mockSpawnResult("", "can't find pane\n", 1);
+			}
+			// Second list-panes succeeds
+			return mockSpawnResult("42\n", "", 0);
+		});
+
+		const pid = await createSession("retry-session", "/work/dir", "echo hello");
+		expect(pid).toBe(42);
+		// which + new-session + list-panes(fail) + list-panes(ok)
+		expect(spawnSpy).toHaveBeenCalledTimes(4);
+	});
+
+	test("throws after exhausting all list-panes retries", async () => {
+		let callCount = 0;
+		spawnSpy.mockImplementation(() => {
+			callCount++;
+			if (callCount === 1) {
+				// which overstory
+				return mockSpawnResult("/usr/local/bin/overstory\n", "", 0);
+			}
+			if (callCount === 2) {
+				// tmux new-session
+				return mockSpawnResult("", "", 0);
+			}
+			// All list-panes attempts fail
+			return mockSpawnResult("", "can't find pane\n", 1);
+		});
+
+		await expect(
+			createSession("retry-exhaust", "/work/dir", "echo hello", undefined, 2),
+		).rejects.toThrow(/failed to retrieve PID/);
+	});
 });
 
 describe("listSessions", () => {
@@ -932,6 +979,38 @@ describe("sendKeys", () => {
 		spawnSpy.mockImplementation(() => mockSpawnResult("", "some other error\n", 1));
 		await expect(sendKeys("overstory-agent-fake", "hello")).rejects.toThrow(/Failed to send keys/);
 	});
+
+	test("retries on transient 'can't find pane' error", async () => {
+		let callCount = 0;
+		spawnSpy.mockImplementation(() => {
+			callCount++;
+			if (callCount === 1) {
+				// First send-keys fails with transient pane error
+				return mockSpawnResult("", "can't find pane\n", 1);
+			}
+			// Second attempt succeeds
+			return mockSpawnResult("", "", 0);
+		});
+
+		await sendKeys("overstory-retry-agent", "hello world");
+		expect(spawnSpy).toHaveBeenCalledTimes(2);
+	});
+
+	test("does not retry on permanent 'session not found' error", async () => {
+		spawnSpy.mockImplementation(() => mockSpawnResult("", "cant find session: gone-agent\n", 1));
+
+		await expect(sendKeys("gone-agent", "hello", 3)).rejects.toThrow(/does not exist/);
+		// Only called once — no retries for permanent errors
+		expect(spawnSpy).toHaveBeenCalledTimes(1);
+	});
+
+	test("throws after exhausting retries on transient error", async () => {
+		spawnSpy.mockImplementation(() => mockSpawnResult("", "can't find pane\n", 1));
+
+		await expect(sendKeys("overstory-exhaust", "hello", 2)).rejects.toThrow(/not found after/);
+		// Initial + 2 retries = 3 calls
+		expect(spawnSpy).toHaveBeenCalledTimes(3);
+	});
 });
 
 describe("capturePaneContent", () => {
@@ -992,6 +1071,13 @@ describe("capturePaneContent", () => {
 
 /** Claude-like detectReady for tests — matches the existing hardcoded behavior. */
 function claudeDetectReady(paneContent: string): ReadyState {
+	if (
+		paneContent.includes("WARNING: Claude Code running in Bypass Permissions mode") &&
+		paneContent.includes("1. No, exit") &&
+		paneContent.includes("2. Yes, I accept")
+	) {
+		return { phase: "dialog", action: "type:2" };
+	}
 	if (paneContent.includes("trust this folder")) {
 		return { phase: "dialog", action: "Enter" };
 	}
@@ -1211,6 +1297,70 @@ describe("waitForTuiReady", () => {
 		expect(trustCall).toEqual(["tmux", "send-keys", "-t", "overstory-agent", "", "Enter"]);
 	});
 
+	test("detects bypass permissions dialog and types 2 before Enter", async () => {
+		const sendKeysCalls: string[][] = [];
+		let captureCallCount = 0;
+		spawnSpy.mockImplementation((...args: unknown[]) => {
+			const cmd = args[0] as string[];
+			if (cmd[1] === "capture-pane") {
+				captureCallCount++;
+				if (captureCallCount === 1) {
+					return mockSpawnResult(
+						"WARNING: Claude Code running in Bypass Permissions mode\n❯ 1. No, exit\n2. Yes, I accept",
+						"",
+						0,
+					);
+				}
+				return mockSpawnResult('Try "help"\nshift+tab', "", 0);
+			}
+			if (cmd[1] === "send-keys") {
+				sendKeysCalls.push(cmd);
+				return mockSpawnResult("", "", 0);
+			}
+			return mockSpawnResult("", "", 0);
+		});
+
+		const ready = await waitForTuiReady("overstory-agent", claudeDetectReady, 10_000, 500);
+
+		expect(ready).toBe(true);
+		expect(sendKeysCalls).toHaveLength(2);
+		expect(sendKeysCalls[0]).toEqual(["tmux", "send-keys", "-t", "overstory-agent", "2"]);
+		expect(sendKeysCalls[1]).toEqual(["tmux", "send-keys", "-t", "overstory-agent", "", "Enter"]);
+	});
+
+	test("retries typed bypass dialog action when the same dialog persists", async () => {
+		const sendKeysCalls: string[][] = [];
+		let captureCallCount = 0;
+		spawnSpy.mockImplementation((...args: unknown[]) => {
+			const cmd = args[0] as string[];
+			if (cmd[1] === "capture-pane") {
+				captureCallCount++;
+				if (captureCallCount <= 3) {
+					return mockSpawnResult(
+						"WARNING: Claude Code running in Bypass Permissions mode\n❯ 1. No, exit\n2. Yes, I accept",
+						"",
+						0,
+					);
+				}
+				return mockSpawnResult('Try "help"\nshift+tab', "", 0);
+			}
+			if (cmd[1] === "send-keys") {
+				sendKeysCalls.push(cmd);
+				return mockSpawnResult("", "", 0);
+			}
+			return mockSpawnResult("", "", 0);
+		});
+
+		const ready = await waitForTuiReady("overstory-agent", claudeDetectReady, 10_000, 500);
+
+		expect(ready).toBe(true);
+		expect(sendKeysCalls).toHaveLength(4);
+		expect(sendKeysCalls[0]).toEqual(["tmux", "send-keys", "-t", "overstory-agent", "2"]);
+		expect(sendKeysCalls[1]).toEqual(["tmux", "send-keys", "-t", "overstory-agent", "", "Enter"]);
+		expect(sendKeysCalls[2]).toEqual(["tmux", "send-keys", "-t", "overstory-agent", "2"]);
+		expect(sendKeysCalls[3]).toEqual(["tmux", "send-keys", "-t", "overstory-agent", "", "Enter"]);
+	});
+
 	test("handles trust dialog only once (trustHandled flag)", async () => {
 		const sendKeysCalls: string[][] = [];
 		let captureCallCount = 0;