@os-eco/overstory-cli 0.8.5 → 0.8.7

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

@@ -39,6 +39,19 @@ export type TaskTrackerBackend = "auto" | "seeds" | "beads";
 
 // === Project Configuration ===
 
+/**
+ * Conditions that trigger automatic coordinator shutdown.
+ * All triggers default to false for backward compatibility.
+ */
+export interface CoordinatorExitTriggers {
+	/** Exit when all spawned agents have completed and their branches have been merged. */
+	allAgentsDone: boolean;
+	/** Exit when the task tracker reports no unblocked work (sd/bd ready returns empty). */
+	taskTrackerEmpty: boolean;
+	/** Exit when a typed shutdown mail is received from an external caller (e.g., greenhouse). */
+	onShutdownSignal: boolean;
+}
+
 /** A single quality gate command that agents must pass before reporting completion. */
 export interface QualityGate {
 	/** Display name shown in the overlay (e.g., "Tests"). */
@@ -96,6 +109,10 @@ export interface OverstoryConfig {
 		verbose: boolean;
 		redactSecrets: boolean;
 	};
+	coordinator?: {
+		/** Conditions that trigger automatic coordinator shutdown. */
+		exitTriggers: CoordinatorExitTriggers;
+	};
 	runtime?: {
 		/** Default runtime adapter name (default: "claude"). */
 		default: string;
@@ -374,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. */
@@ -569,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. */
@@ -585,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/watchdog/daemon.test.ts

@@ -1977,3 +1977,260 @@ describe("buildCompletionMessage", () => {
 		expect(msg).toContain("3");
 	});
 });
+
+// === Bug fix tests: headless agent kill blast radius + stale detection ===
+
+describe("headless agent kill blast radius fix (Bug 1)", () => {
+	/**
+	 * Track PID kill calls without spawning real processes.
+	 * Also surfaces killTree calls so tests can assert on them.
+	 */
+	function processTracker(): {
+		isAlive: (pid: number) => boolean;
+		killTree: (pid: number) => Promise<void>;
+		killed: number[];
+	} {
+		const killed: number[] = [];
+		return {
+			isAlive: (pid: number) => {
+				try {
+					process.kill(pid, 0);
+					return true;
+				} catch {
+					return false;
+				}
+			},
+			killTree: async (pid: number) => {
+				killed.push(pid);
+			},
+			killed,
+		};
+	}
+
+	test("headless agent at escalation level 3 kills PID, not tmux session", async () => {
+		const nudgeIntervalMs = 60_000;
+		// stalledSince is 4 intervals ago — expectedLevel = floor(4) = 4, clamped to MAX (3)
+		const stalledSince = new Date(Date.now() - 4 * nudgeIntervalMs).toISOString();
+		const staleActivity = new Date(Date.now() - THRESHOLDS.staleThresholdMs * 2).toISOString();
+
+		const session = makeSession({
+			agentName: "headless-stalled",
+			tmuxSession: "", // headless
+			pid: process.pid, // alive PID — ZFC won't trigger direct terminate
+			state: "stalled",
+			lastActivity: staleActivity,
+			escalationLevel: 2,
+			stalledSince,
+		});
+
+		writeSessionsToStore(tempRoot, [session]);
+
+		const proc = processTracker();
+		// tmux mock: isSessionAlive("") returns true — simulates prefix-match bug scenario
+		const tmuxMock = tmuxWithLiveness({ "": true });
+
+		await runDaemonTick({
+			root: tempRoot,
+			...THRESHOLDS,
+			nudgeIntervalMs,
+			tier1Enabled: false,
+			_tmux: tmuxMock,
+			_triage: triageAlways("extend"),
+			_process: proc,
+			_eventStore: null,
+			_recordFailure: async () => {},
+			_getConnection: () => undefined,
+			_removeConnection: () => {},
+			_tailerRegistry: new Map(),
+			_findLatestStdoutLog: async () => null,
+		});
+
+		// PID was killed via killTree, NOT via tmux killSession("")
+		expect(proc.killed).toContain(process.pid);
+		expect(tmuxMock.killed).not.toContain("");
+	});
+
+	test("headless agent direct terminate kills PID, not tmux", async () => {
+		// PID 999999 is virtually guaranteed not to exist — health check sees it as dead
+		const deadPid = 999999;
+		const session = makeSession({
+			agentName: "headless-dead-pid",
+			tmuxSession: "", // headless
+			pid: deadPid,
+			state: "working",
+			lastActivity: new Date().toISOString(),
+		});
+
+		writeSessionsToStore(tempRoot, [session]);
+
+		const proc = processTracker();
+		// tmux mock: isSessionAlive("") returns true — would kill everything without the fix
+		const tmuxMock = tmuxWithLiveness({ "": true });
+
+		await runDaemonTick({
+			root: tempRoot,
+			...THRESHOLDS,
+			_tmux: tmuxMock,
+			_triage: triageAlways("extend"),
+			_process: proc,
+			_eventStore: null,
+			_recordFailure: async () => {},
+			_getConnection: () => undefined,
+			_removeConnection: () => {},
+			_tailerRegistry: new Map(),
+			_findLatestStdoutLog: async () => null,
+		});
+
+		// Should have attempted PID kill, NOT tmux killSession("")
+		expect(proc.killed).toContain(deadPid);
+		expect(tmuxMock.killed).not.toContain("");
+	});
+
+	test("triage terminate on headless agent kills PID, not tmux", async () => {
+		const nudgeIntervalMs = 60_000;
+		// stalledSince is 2.5 intervals ago — expectedLevel = floor(2.5) = 2 → triage fires
+		const stalledSince = new Date(Date.now() - 2.5 * nudgeIntervalMs).toISOString();
+		const staleActivity = new Date(Date.now() - THRESHOLDS.staleThresholdMs * 2).toISOString();
+
+		const session = makeSession({
+			agentName: "headless-triage-terminate",
+			tmuxSession: "", // headless
+			pid: process.pid, // alive
+			state: "stalled",
+			lastActivity: staleActivity,
+			escalationLevel: 1,
+			stalledSince,
+		});
+
+		writeSessionsToStore(tempRoot, [session]);
+
+		const proc = processTracker();
+		const tmuxMock = tmuxWithLiveness({ "": true });
+
+		await runDaemonTick({
+			root: tempRoot,
+			...THRESHOLDS,
+			nudgeIntervalMs,
+			tier1Enabled: true,
+			_tmux: tmuxMock,
+			_triage: triageAlways("terminate"), // AI triage says terminate
+			_nudge: nudgeTracker().nudge,
+			_process: proc,
+			_eventStore: null,
+			_recordFailure: async () => {},
+			_getConnection: () => undefined,
+			_removeConnection: () => {},
+			_tailerRegistry: new Map(),
+			_findLatestStdoutLog: async () => null,
+		});
+
+		// Should have killed the PID, not the tmux session
+		expect(proc.killed).toContain(process.pid);
+		expect(tmuxMock.killed).not.toContain("");
+	});
+});
+
+describe("headless agent stale detection via events.db (Bug 2)", () => {
+	test("headless agent with recent events in events.db is not flagged stale", async () => {
+		const staleActivity = new Date(Date.now() - THRESHOLDS.staleThresholdMs * 2).toISOString();
+
+		const session = makeSession({
+			agentName: "headless-active",
+			tmuxSession: "", // headless
+			pid: process.pid, // alive
+			state: "working",
+			lastActivity: staleActivity, // stale — would trigger escalate without event fallback
+		});
+
+		writeSessionsToStore(tempRoot, [session]);
+
+		const eventsDbPath = join(tempRoot, ".overstory", "events.db");
+		const eventStore = createEventStore(eventsDbPath);
+
+		try {
+			// Insert a recent event for this agent (within the stale threshold window)
+			eventStore.insert({
+				runId: null,
+				agentName: "headless-active",
+				sessionId: null,
+				eventType: "tool_end",
+				toolName: "Read",
+				toolArgs: null,
+				toolDurationMs: 100,
+				level: "info",
+				data: null,
+			});
+
+			const checks: HealthCheck[] = [];
+
+			await runDaemonTick({
+				root: tempRoot,
+				...THRESHOLDS,
+				onHealthCheck: (c) => checks.push(c),
+				_tmux: tmuxAllAlive(),
+				_triage: triageAlways("extend"),
+				_process: { isAlive: () => true, killTree: async () => {} },
+				_eventStore: eventStore,
+				_recordFailure: async () => {},
+				_getConnection: () => undefined,
+				_removeConnection: () => {},
+				_tailerRegistry: new Map(),
+				_findLatestStdoutLog: async () => null,
+			});
+
+			// Recent events found — lastActivity was refreshed, agent is NOT stalled
+			expect(checks).toHaveLength(1);
+			expect(checks[0]?.action).toBe("none");
+			expect(checks[0]?.state).toBe("working");
+
+			const reloaded = readSessionsFromStore(tempRoot);
+			expect(reloaded[0]?.state).toBe("working");
+		} finally {
+			eventStore.close();
+		}
+	});
+
+	test("headless agent with no recent events IS flagged stale", async () => {
+		const staleActivity = new Date(Date.now() - THRESHOLDS.staleThresholdMs * 2).toISOString();
+
+		const session = makeSession({
+			agentName: "headless-silent",
+			tmuxSession: "", // headless
+			pid: process.pid, // alive
+			state: "working",
+			lastActivity: staleActivity, // stale
+		});
+
+		writeSessionsToStore(tempRoot, [session]);
+
+		const eventsDbPath = join(tempRoot, ".overstory", "events.db");
+		const eventStore = createEventStore(eventsDbPath);
+
+		try {
+			// No events inserted for this agent — event fallback finds nothing
+
+			const checks: HealthCheck[] = [];
+
+			await runDaemonTick({
+				root: tempRoot,
+				...THRESHOLDS,
+				onHealthCheck: (c) => checks.push(c),
+				_tmux: tmuxAllAlive(),
+				_triage: triageAlways("extend"),
+				_process: { isAlive: () => true, killTree: async () => {} },
+				_eventStore: eventStore,
+				_recordFailure: async () => {},
+				_getConnection: () => undefined,
+				_removeConnection: () => {},
+				_tailerRegistry: new Map(),
+				_findLatestStdoutLog: async () => null,
+			});
+
+			// No recent events — lastActivity stays stale, agent IS flagged stalled
+			expect(checks).toHaveLength(1);
+			expect(checks[0]?.action).toBe("escalate");
+		} finally {
+			eventStore.close();
+		}
+	});
+});