@os-eco/overstory-cli 0.10.3 → 0.11.0

package/src/agents/turn-runner.ts

@@ -23,6 +23,7 @@ import { Database } from "bun:sqlite";
 import { appendFileSync, existsSync } from "node:fs";
 import { mkdir, unlink } from "node:fs/promises";
 import { join } from "node:path";
+import { extractFileScope } from "../commands/agents.ts";
 import { AgentError } from "../errors.ts";
 import { createEventStore } from "../events/store.ts";
 import { filterToolArgs } from "../events/tool-filter.ts";
@@ -37,6 +38,13 @@ import type {
 	WorkerDiedPayload,
 } from "../types.ts";
 import { terminalMailTypesFor } from "./capabilities.ts";
+import { detectMailPollPattern } from "./mail-poll-detect.ts";
+import {
+	type DetectScopeViolationOpts,
+	detectScopeViolation as defaultDetectScopeViolation,
+	IMPLEMENTATION_CAPABILITIES,
+	type ScopeViolationResult,
+} from "./scope-detect.ts";
 import { acquireTurnLock } from "./turn-lock.ts";
 
 /** Subprocess shape required by `runTurn`. Compatible with `Bun.spawn`. */
@@ -125,6 +133,32 @@ export interface RunTurnOpts {
 	 * Set to `0` to disable (test injection / explicit opt-out only).
 	 */
 	eventStallTimeoutMs?: number;
+	/**
+	 * Throttle (ms) for refreshing `session.lastActivity` while events stream
+	 * from the parser loop. Default `2000` (every 2s). The watchdog at
+	 * `src/watchdog/health.ts:242-243` documents its design as: "the
+	 * turn-runner updates [lastActivity] on every parser event during a turn,
+	 * and the watchdog refreshes it from events.db between turns" — so the
+	 * runner must drive lastActivity itself or a long turn looks stalled and
+	 * gets zombified mid-flight (overstory-8e61).
+	 *
+	 * Set to `0` to refresh on every event (test injection / explicit opt-out).
+	 */
+	lastActivityRefreshIntervalMs?: number;
+	/**
+	 * Test injection: invoked each time the parser loop fires a mid-turn
+	 * `lastActivity` refresh (after the throttle gate, before/after the
+	 * SessionStore write). Used by tests to count refresh attempts directly
+	 * rather than inferring from observable timestamps (overstory-8e61).
+	 */
+	_onLastActivityRefresh?: () => void;
+	/**
+	 * Test injection: replaces the real `detectScopeViolation` from
+	 * `scope-detect.ts`. Tests pass a stubbed runner via the wrapper so they
+	 * can drive the scope-violation observability path without spawning git
+	 * (overstory-9f4d). Defaults to the real implementation.
+	 */
+	_scopeDetect?: (opts: DetectScopeViolationOpts) => ScopeViolationResult;
 }
 
 export interface TurnResult {
@@ -288,6 +322,38 @@ function checkTerminalMailSince(
 	}
 }
 
+/**
+ * Check whether the agent has previously sent a `scope_expansion`-prefixed
+ * status mail (overstory-9f4d). When such a mail exists, the runner suppresses
+ * the soft scope-violation warning — the lead has already been informed.
+ *
+ * Soft signal — every failure (DB unavailable, missing table, etc.) returns
+ * false so observability never breaks the runner.
+ */
+function hasScopeExpansionMail(mailDbPath: string, agentName: string): boolean {
+	let db: Database;
+	try {
+		db = new Database(mailDbPath);
+	} catch {
+		return false;
+	}
+	try {
+		db.exec("PRAGMA busy_timeout = 5000");
+		const stmt = db.prepare<{ c: number }, { $a: string }>(
+			"SELECT 1 AS c FROM messages WHERE from_agent = $a AND subject LIKE 'scope_expansion%' LIMIT 1",
+		);
+		return stmt.get({ $a: agentName }) !== null;
+	} catch {
+		return false;
+	} finally {
+		try {
+			db.close();
+		} catch {
+			// best-effort
+		}
+	}
+}
+
 /**
  * Latest `created_at` timestamp of a terminal mail (`worker_done`/`result` for
  * task-scoped workers; `merged`/`merge_failed` for merger) sent by `agentName`.
@@ -850,7 +916,12 @@ export async function runTurn(opts: RunTurnOpts): Promise<TurnResult> {
 		let newSessionId: string | null = null;
 		let cleanResult = false;
 		let observedAnyEvent = false;
-		let bootedToWorking = false;
+		// True iff this turn fired the "first parser event" transition into
+		// `in_turn`. Replaces the legacy `bootedToWorking` flag; the trigger
+		// now fires from booting OR between_turns OR working (legacy migration)
+		// so a resumed spawn-per-turn agent flips back to `in_turn` at the
+		// start of every batch (overstory-3087).
+		let transitionedToInTurn = false;
 
 		// Stall watchdog (overstory-ddb3): if no parser event arrives for
 		// `eventStallTimeoutMs`, abort the turn via SIGTERM/SIGKILL. Otherwise a
@@ -945,21 +1016,52 @@ export async function runTurn(opts: RunTurnOpts): Promise<TurnResult> {
 				},
 			});
 
+			// Mid-turn `lastActivity` refresh (overstory-8e61). The watchdog at
+			// `src/watchdog/health.ts:242-243` documents that the runner advances
+			// lastActivity per parser event; without this the row stayed at
+			// `startedAt` for the whole turn and long turns got zombified live.
+			const lastActivityRefreshIntervalMs = opts.lastActivityRefreshIntervalMs ?? 2000;
+			let lastActivityRefreshMs = 0; // first event always refreshes
+
 			for await (const event of parser) {
 				armStallTimer();
 				observedAnyEvent = true;
 
-				if (!bootedToWorking && initialState === "booting") {
-					bootedToWorking = true;
+				// Keep `session.lastActivity` advancing while events flow so the
+				// watchdog does not zombify a live agent mid-turn — see
+				// `src/watchdog/health.ts:242-243` and overstory-8e61.
+				const nowMs = now().getTime();
+				if (nowMs - lastActivityRefreshMs >= lastActivityRefreshIntervalMs) {
+					lastActivityRefreshMs = nowMs;
+					updateSessionLastActivity(sessionsDbPath, agentName, (err) =>
+						runnerLog("warn", "failed to refresh lastActivity mid-turn", err),
+					);
+					opts._onLastActivityRefresh?.();
+				}
+
+				// First parser event of a turn → settle into `in_turn`. Allowed
+				// predecessors are `booting` (initial dispatch), `between_turns`
+				// (next mail batch on a healthy worker), or already-`in_turn`
+				// (idempotent — covers the case where a prior turn somehow left
+				// the row at in_turn). Legacy `working` rows are intentionally
+				// not in the matrix predecessor set (overstory-3087): spawn-
+				// per-turn workers should not flow through `working`, so the
+				// matrix keeps the substate path disjoint and a stale `working`
+				// row is left alone rather than silently coerced.
+				if (
+					!transitionedToInTurn &&
+					(initialState === "booting" || initialState === "between_turns")
+				) {
+					transitionedToInTurn = true;
 					updateSessionState(
 						sessionsDbPath,
 						agentName,
-						"working",
-						(err) => runnerLog("warn", "failed to transition booting → working", err),
+						"in_turn",
+						(err) => runnerLog("warn", `failed to transition ${initialState} → in_turn`, err),
 						(prev, attempted) =>
 							runnerLog(
 								"warn",
-								`booting → working rejected: state is now ${prev} (attempted ${attempted})`,
+								`${initialState} → in_turn rejected: state is now ${prev} (attempted ${attempted})`,
 							),
 					);
 				}
@@ -968,6 +1070,51 @@ export async function runTurn(opts: RunTurnOpts): Promise<TurnResult> {
 					cleanResult = event.isError !== true;
 				}
 
+				// Defense-in-depth (overstory-c92c): detect Bash mail-poll patterns
+				// the lead.md prompt forbids (overstory-fa84). Warn-only — emit a
+				// custom event before the original tool_use so observability tools
+				// see the warning ahead of the offending call. Wrapped in try/catch
+				// so detection failure cannot break the turn.
+				if (event.type === "tool_use" && event.name === "Bash") {
+					try {
+						const input =
+							typeof event.input === "object" && event.input !== null
+								? (event.input as Record<string, unknown>)
+								: null;
+						const command = input?.command;
+						const detection = detectMailPollPattern(command);
+						if (detection.matched) {
+							const cmdStr = typeof command === "string" ? command : "";
+							const truncated = cmdStr.length > 200 ? `${cmdStr.slice(0, 200)}…` : cmdStr;
+							runnerLog(
+								"warn",
+								`detected mail-poll pattern in Bash command (${detection.reason}): ${truncated}`,
+							);
+							try {
+								eventStore.insert({
+									runId,
+									agentName,
+									sessionId: newSessionId,
+									eventType: "custom",
+									toolName: null,
+									toolArgs: null,
+									toolDurationMs: null,
+									level: "warn",
+									data: JSON.stringify({
+										type: "mail_poll_detected",
+										reason: detection.reason,
+										command: cmdStr,
+									}),
+								});
+							} catch (insertErr) {
+								runnerLog("warn", "failed to insert mail_poll_detected event", insertErr);
+							}
+						}
+					} catch (detectErr) {
+						runnerLog("warn", "mail-poll detector threw", detectErr);
+					}
+				}
+
 				try {
 					recordAgentEvent(eventStore, agentName, runId, newSessionId, event);
 				} catch {
@@ -1032,6 +1179,70 @@ export async function runTurn(opts: RunTurnOpts): Promise<TurnResult> {
 			snapshotTs,
 		);
 
+		// Soft scope-violation observability (overstory-9f4d). Builders sometimes
+		// expand beyond their declared FILE_SCOPE; the lead needs a way to spot it
+		// during merge verification. Surface a warn-level event into events.db
+		// when the worker's modified files exceed FILE_SCOPE without an
+		// `expansion_reason:` justification (commit body OR prior scope_expansion
+		// mail). This is advisory — never aborts the turn, never blocks the
+		// completed transition. All errors are swallowed.
+		//
+		// TODO: baseRef is hard-coded to "main"; a future improvement could
+		// resolve the actual session-branch.txt for projects whose canonical
+		// branch differs.
+		if (terminalMailObserved && IMPLEMENTATION_CAPABILITIES.has(capability)) {
+			try {
+				const fileScope = await extractFileScope(worktreePath, runtime.instructionPath);
+				if (fileScope.length > 0) {
+					const detectFn = opts._scopeDetect ?? defaultDetectScopeViolation;
+					const { violations, expansionReasons } = detectFn({
+						worktreePath,
+						baseRef: "main",
+						fileScope,
+					});
+					if (violations.length > 0 && expansionReasons.length === 0) {
+						const justified = hasScopeExpansionMail(mailDbPath, agentName);
+						if (!justified) {
+							runnerLog(
+								"warn",
+								`agent modified ${violations.length} file(s) outside declared FILE_SCOPE without justification: ${violations.join(", ")}. To suppress, include 'expansion_reason: <why>' in your last commit message OR send a scope_expansion mail to your lead.`,
+							);
+							try {
+								const evStore = createEventStore(eventsDbPath);
+								try {
+									evStore.insert({
+										runId,
+										agentName,
+										sessionId: newSessionId,
+										eventType: "custom",
+										toolName: null,
+										toolArgs: null,
+										toolDurationMs: null,
+										level: "warn",
+										data: JSON.stringify({
+											type: "scope_violation",
+											violations,
+											fileScope,
+										}),
+									});
+								} finally {
+									try {
+										evStore.close();
+									} catch {
+										// best-effort
+									}
+								}
+							} catch {
+								// observability must never break the runner
+							}
+						}
+					}
+				}
+			} catch {
+				// scope detection is advisory — swallow all errors
+			}
+		}
+
 		const resumeMismatch =
 			priorSessionId !== null && newSessionId !== null && newSessionId !== priorSessionId;
 
@@ -1057,8 +1268,14 @@ export async function runTurn(opts: RunTurnOpts): Promise<TurnResult> {
 			finalState = "completed";
 		} else if (terminalMailMissing) {
 			finalState = "completed";
-		} else if (observedAnyEvent || bootedToWorking) {
-			finalState = "working";
+		} else if (observedAnyEvent || transitionedToInTurn) {
+			// Turn produced events but did not complete — settle to
+			// `between_turns`, NOT `working`, so the UI can distinguish a
+			// spawn-per-turn worker waiting for its next mail batch from one
+			// mid-execution. The watchdog will flip the row back to `in_turn`
+			// on the next batch when the parser fires its first event
+			// (overstory-3087).
+			finalState = "between_turns";
 		} else {
 			finalState = initialState;
 		}

package/src/commands/agents.ts

@@ -166,11 +166,20 @@ export async function discoverAgents(
 
 /**
  * Format the state icon for display.
+ *
+ * `in_turn` and `between_turns` (overstory-3087) render with the same cyan
+ * accent as `working` so a spawn-per-turn worker is visually grouped with
+ * other healthy/active agents in `ov agents` output. They use distinct
+ * glyphs ('>' vs '~') to mirror the dashboard / theme.ts mapping.
  */
 function getStateIcon(state: string): string {
 	switch (state) {
 		case "working":
 			return color.cyan(">");
+		case "in_turn":
+			return color.cyan(">");
+		case "between_turns":
+			return color.cyan("~");
 		case "booting":
 			return color.green("-");
 		case "stalled":

package/src/commands/coordinator.test.ts

@@ -1601,6 +1601,133 @@ describe("watchdog integration", () => {
 			expect(output).toContain("--watchdog");
 			expect(output).toContain("watchdog");
 		});
+
+		test("start help text includes --accept-existing-watchdog flag", async () => {
+			const cmd = createCoordinatorCommand({});
+			for (const sub of cmd.commands) {
+				sub.exitOverride();
+			}
+			const output = await captureStdout(async () => {
+				await cmd.parseAsync(["start", "--help"], { from: "user" }).catch(() => {});
+			});
+			expect(output).toContain("--accept-existing-watchdog");
+		});
+	});
+
+	// overstory-3f0c: detect leftover watchdog from a previous session before
+	// spawning, so operators do not get unexpected watchdog supervision.
+	describe("orphan watchdog detection (overstory-3f0c)", () => {
+		// (a) start (no --watchdog) + isRunning=true -> throws AgentError with PID
+		// and mention of --accept-existing-watchdog in the message
+		test("rejects start with AgentError when no flag passed and watchdog already running", async () => {
+			const { deps, watchdogCalls } = makeDeps({}, { running: true, startSuccess: true });
+			const originalSleep = Bun.sleep;
+			Bun.sleep = (() => Promise.resolve()) as typeof Bun.sleep;
+
+			try {
+				await coordinatorCommand(["start", "--json"], deps);
+				expect.unreachable("should have thrown AgentError");
+			} catch (err) {
+				expect(err).toBeInstanceOf(AgentError);
+				const ae = err as AgentError;
+				expect(ae.message).toContain("Watchdog daemon");
+				// PID is unavailable from the fake watchdog (no PID file written),
+				// so the message reports "unknown PID" — but it must reference the
+				// concept and the suppress flag explicitly.
+				expect(ae.message).toMatch(/PID/);
+				expect(ae.message).toContain("--accept-existing-watchdog");
+				expect(ae.message).toContain("--watchdog");
+				expect(ae.message).toContain("ov watch --kill-others");
+			} finally {
+				Bun.sleep = originalSleep;
+			}
+
+			// Detection ran but auto-start did NOT — the throw fired first.
+			expect(watchdogCalls?.isRunning).toBeGreaterThanOrEqual(1);
+			expect(watchdogCalls?.start).toBe(0);
+		});
+
+		// (b) start --watchdog + isRunning=true -> does NOT throw;
+		//     watchdog.start() is still called once
+		test("--watchdog with already-running daemon does NOT throw and still calls start()", async () => {
+			const { deps, watchdogCalls } = makeDeps(
+				{},
+				{ running: true, startSuccess: false }, // startSuccess:false simulates the no-op-when-already-running return
+			);
+			const originalSleep = Bun.sleep;
+			Bun.sleep = (() => Promise.resolve()) as typeof Bun.sleep;
+
+			let output: string;
+			try {
+				output = await captureStdout(() =>
+					coordinatorCommand(["start", "--watchdog", "--json"], deps),
+				);
+			} finally {
+				Bun.sleep = originalSleep;
+			}
+
+			expect(watchdogCalls?.start).toBe(1);
+			const parsed = JSON.parse(output) as Record<string, unknown>;
+			// reused-daemon sentinel keeps watchdog truthy in the JSON output
+			expect(parsed.watchdog).toBe(true);
+			expect(parsed.watchdogPreexisting).toBe(true);
+		});
+
+		// (c) start --accept-existing-watchdog + isRunning=true -> does NOT throw;
+		//     coordinator starts normally; watchdog.start() is NOT called
+		test("--accept-existing-watchdog allows start without calling watchdog.start()", async () => {
+			const { deps, watchdogCalls } = makeDeps({}, { running: true, startSuccess: true });
+			const originalSleep = Bun.sleep;
+			Bun.sleep = (() => Promise.resolve()) as typeof Bun.sleep;
+
+			let output: string;
+			try {
+				output = await captureStdout(() =>
+					coordinatorCommand(["start", "--accept-existing-watchdog", "--json"], deps),
+				);
+			} finally {
+				Bun.sleep = originalSleep;
+			}
+
+			expect(watchdogCalls?.start).toBe(0);
+			const parsed = JSON.parse(output) as Record<string, unknown>;
+			expect(parsed.watchdog).toBe(true);
+			expect(parsed.watchdogPreexisting).toBe(true);
+		});
+
+		// (d) start (no --watchdog) + isRunning=false -> no error, no start
+		// (regression — preserves the original "no flag, no daemon activity" path)
+		test("no flag + watchdog not running: starts normally without calling start()", async () => {
+			const { deps, watchdogCalls } = makeDeps({}, { running: false, startSuccess: true });
+			const originalSleep = Bun.sleep;
+			Bun.sleep = (() => Promise.resolve()) as typeof Bun.sleep;
+
+			let output: string;
+			try {
+				output = await captureStdout(() => coordinatorCommand(["start", "--json"], deps));
+			} finally {
+				Bun.sleep = originalSleep;
+			}
+
+			expect(watchdogCalls?.start).toBe(0);
+			const parsed = JSON.parse(output) as Record<string, unknown>;
+			expect(parsed.watchdog).toBe(false);
+			expect(parsed.watchdogPreexisting).toBe(false);
+		});
+
+		test("orchestrator inherits the same orphan-watchdog detection", async () => {
+			const { deps, watchdogCalls } = makeDeps({}, { running: true });
+			const originalSleep = Bun.sleep;
+			Bun.sleep = (() => Promise.resolve()) as typeof Bun.sleep;
+
+			try {
+				await expect(orchestratorCommand(["start", "--json"], deps)).rejects.toThrow(AgentError);
+			} finally {
+				Bun.sleep = originalSleep;
+			}
+
+			expect(watchdogCalls?.start).toBe(0);
+		});
 	});
 });
 

package/src/commands/coordinator.ts

@@ -351,6 +351,14 @@ export interface CoordinatorSessionOptions {
 	 * the web UI's POST /api/coordinator/start endpoint.
 	 */
 	headless?: boolean;
+	/**
+	 * Acknowledge that a watchdog daemon from a previous session may already be
+	 * running and should be allowed to supervise this coordinator. Without this
+	 * (or `--watchdog`), the start command refuses to spawn when a leftover
+	 * daemon is detected, to surface the "watchdog persists across runs" trap
+	 * that overstory-3f0c was filed for.
+	 */
+	acceptExistingWatchdog?: boolean;
 }
 
 /**
@@ -385,6 +393,7 @@ export async function startCoordinatorSession(
 		displayName: displayNameOpt,
 		beaconBuilder: beaconBuilderOpt,
 		headless: headlessFlag,
+		acceptExistingWatchdog: acceptExistingWatchdogFlag,
 	} = opts;
 
 	const coordinatorName = agentNameOpt ?? coordinatorNameOpt ?? COORDINATOR_NAME;
@@ -406,6 +415,25 @@ export async function startCoordinatorSession(
 	const monitor = deps._monitor ?? createDefaultMonitor(projectRoot);
 	const tmuxSession = coordinatorTmuxSession(config.project.name, coordinatorName);
 
+	// Detect leftover watchdog daemon from a previous session (overstory-3f0c).
+	// If a watchdog is already running and the operator did not pass --watchdog
+	// or --accept-existing-watchdog, refuse to start: a persistent daemon will
+	// supervise this coordinator with policy decided by the original invocation,
+	// not the current one. This prevents "I didn't run --watchdog, why is the
+	// watchdog killing things?" surprises.
+	const watchdogAlreadyRunning = await watchdog.isRunning();
+	if (watchdogAlreadyRunning && !watchdogFlag && !acceptExistingWatchdogFlag) {
+		const existingPid = await readWatchdogPid(projectRoot);
+		const pidLabel = existingPid !== null ? `PID ${existingPid}` : "unknown PID";
+		throw new AgentError(
+			`Watchdog daemon (${pidLabel}) is already running from a previous session. ` +
+				`It will supervise this ${displayName.toLowerCase()} run and may take escalation actions you did not opt into. ` +
+				`To proceed: pass --watchdog to acknowledge, pass --accept-existing-watchdog to suppress this check, ` +
+				`or run 'ov watch --kill-others' (or remove .overstory/watchdog.pid) first.`,
+			{ agentName: coordinatorName },
+		);
+	}
+
 	// Check for existing coordinator session with the same name
 	const overstoryDir = join(projectRoot, ".overstory");
 	const { store } = openSessionStore(overstoryDir);
@@ -589,9 +617,21 @@ export async function startCoordinatorSession(
 				if (watchdogResult) {
 					watchdogPid = watchdogResult.pid;
 					if (!json) printHint("Watchdog started");
+				} else if (watchdogAlreadyRunning) {
+					// createDefaultWatchdog.start() returns null when an existing PID
+					// is alive — that's a no-op success, not a failure. Reuse the
+					// existing daemon. Sentinel value keeps `watchdogPid !== undefined`
+					// truthy in the JSON output.
+					watchdogPid = -1;
+					if (!json) printHint("Watchdog already running, reusing existing daemon");
 				} else {
 					if (!json) printWarning("Watchdog failed to start");
 				}
+			} else if (watchdogAlreadyRunning && acceptExistingWatchdogFlag) {
+				// --accept-existing-watchdog without --watchdog: surface that an
+				// existing daemon is supervising this run, but do not call start().
+				watchdogPid = -1;
+				if (!json) printHint("Watchdog already running, reusing existing daemon");
 			}
 			let monitorPid: number | undefined;
 			if (monitorFlag) {
@@ -615,7 +655,8 @@ export async function startCoordinatorSession(
 				projectRoot,
 				pid: headlessProc.pid,
 				headless: true,
-				watchdog: watchdogFlag ? watchdogPid !== undefined : false,
+				watchdog: watchdogPid !== undefined,
+				watchdogPreexisting: watchdogAlreadyRunning,
 				monitor: monitorFlag ? monitorPid !== undefined : false,
 			};
 
@@ -755,16 +796,28 @@ export async function startCoordinatorSession(
 			await tmux.sendKeys(tmuxSession, "");
 		}
 
-		// Auto-start watchdog if --watchdog flag is present
+		// Auto-start watchdog if --watchdog flag is present.
 		let watchdogPid: number | undefined;
 		if (watchdogFlag) {
 			const watchdogResult = await watchdog.start();
 			if (watchdogResult) {
 				watchdogPid = watchdogResult.pid;
 				if (!json) printHint("Watchdog started");
+			} else if (watchdogAlreadyRunning) {
+				// createDefaultWatchdog.start() returns null when an existing PID
+				// is alive — that's a no-op success, not a failure. Reuse the
+				// existing daemon. Sentinel value keeps `watchdogPid !== undefined`
+				// truthy in the JSON output.
+				watchdogPid = -1;
+				if (!json) printHint("Watchdog already running, reusing existing daemon");
 			} else {
 				if (!json) printWarning("Watchdog failed to start");
 			}
+		} else if (watchdogAlreadyRunning && acceptExistingWatchdogFlag) {
+			// --accept-existing-watchdog without --watchdog: surface that an
+			// existing daemon is supervising this run, but do not call start().
+			watchdogPid = -1;
+			if (!json) printHint("Watchdog already running, reusing existing daemon");
 		}
 
 		// Auto-start monitor if --monitor flag is present and tier2 is enabled
@@ -789,7 +842,8 @@ export async function startCoordinatorSession(
 			tmuxSession,
 			projectRoot,
 			pid,
-			watchdog: watchdogFlag ? watchdogPid !== undefined : false,
+			watchdog: watchdogPid !== undefined,
+			watchdogPreexisting: watchdogAlreadyRunning,
 			monitor: monitorFlag ? monitorPid !== undefined : false,
 		};
 
@@ -815,7 +869,14 @@ export async function startCoordinatorSession(
 
 async function startPersistentAgent(
 	spec: PersistentAgentSpec,
-	opts: { json: boolean; attach: boolean; watchdog: boolean; monitor: boolean; profile?: string },
+	opts: {
+		json: boolean;
+		attach: boolean;
+		watchdog: boolean;
+		monitor: boolean;
+		profile?: string;
+		acceptExistingWatchdog?: boolean;
+	},
 	deps: CoordinatorDeps = {},
 ): Promise<void> {
 	await startCoordinatorSession(
@@ -1557,6 +1618,10 @@ export function createPersistentAgentCommand(
 		.option("--attach", "Always attach to tmux session after start")
 		.option("--no-attach", "Never attach to tmux session after start")
 		.option("--watchdog", `Auto-start watchdog daemon with ${spec.commandName}`)
+		.option(
+			"--accept-existing-watchdog",
+			"Continue when a watchdog daemon from a previous session is already running (it will supervise this run)",
+		)
 		.option("--monitor", `Auto-start Tier 2 monitor agent with ${spec.commandName}`)
 		.option("--profile <name>", "Canopy profile to apply to spawned agents")
 		.option("--json", "Output as JSON")
@@ -1564,6 +1629,7 @@ export function createPersistentAgentCommand(
 			async (opts: {
 				attach?: boolean;
 				watchdog?: boolean;
+				acceptExistingWatchdog?: boolean;
 				monitor?: boolean;
 				json?: boolean;
 				profile?: string;
@@ -1576,6 +1642,7 @@ export function createPersistentAgentCommand(
 						json: opts.json ?? false,
 						attach: shouldAttach,
 						watchdog: opts.watchdog ?? false,
+						acceptExistingWatchdog: opts.acceptExistingWatchdog ?? false,
 						monitor: opts.monitor ?? false,
 						profile: opts.profile,
 					},

package/src/commands/dashboard.ts

@@ -615,7 +615,7 @@ export function renderAgentPanel(
 
 	// Sort agents: active first, then completed, then zombie
 	const agents = [...data.status.agents].sort((a, b) => {
-		const activeStates = ["working", "booting", "stalled"];
+		const activeStates = ["working", "in_turn", "between_turns", "booting", "stalled"];
 		const aActive = activeStates.includes(a.state);
 		const bActive = activeStates.includes(b.state);
 		if (aActive && !bActive) return -1;