@os-eco/overstory-cli 0.6.4 → 0.6.6

package/src/commands/sling.test.ts

@@ -3,7 +3,9 @@ import { resolveModel, resolveProviderEnv } from "../agents/manifest.ts";
 import { HierarchyError } from "../errors.ts";
 import type { AgentManifest, OverstoryConfig } from "../types.ts";
 import {
+	type AutoDispatchOptions,
 	type BeaconOptions,
+	buildAutoDispatch,
 	buildBeacon,
 	calculateStaggerDelay,
 	checkBeadLock,
@@ -405,14 +407,14 @@ describe("buildBeacon", () => {
 
 		expect(beacon).toContain("read .claude/CLAUDE.md");
 		expect(beacon).toContain("mulch prime");
-		expect(beacon).toContain("overstory mail check --agent scout-1");
+		expect(beacon).toContain("ov mail check --agent scout-1");
 		expect(beacon).toContain("begin task overstory-xyz");
 	});
 
 	test("uses agent name in mail check command", () => {
 		const beacon = buildBeacon(makeBeaconOpts({ agentName: "reviewer-beta" }));
 
-		expect(beacon).toContain("overstory mail check --agent reviewer-beta");
+		expect(beacon).toContain("ov mail check --agent reviewer-beta");
 	});
 
 	test("reflects capability in header", () => {
@@ -554,13 +556,13 @@ describe("isRunningAsRoot", () => {
 /**
  * Tests for checkBeadLock.
  *
- * checkBeadLock prevents concurrent agents from working the same bead ID.
+ * checkBeadLock prevents concurrent agents from working the same task ID.
  * It checks the active session list and returns the agent name that holds
  * the lock (i.e., is already working on the bead), or null if the bead is free.
  */
 
-function makeBeadSession(agentName: string, beadId: string): { agentName: string; beadId: string } {
-	return { agentName, beadId };
+function makeBeadSession(agentName: string, taskId: string): { agentName: string; taskId: string } {
+	return { agentName, taskId };
 }
 
 describe("checkBeadLock", () => {
@@ -568,7 +570,7 @@ describe("checkBeadLock", () => {
 		expect(checkBeadLock([], "overstory-abc")).toBeNull();
 	});
 
-	test("returns null when no session matches the bead ID", () => {
+	test("returns null when no session matches the task ID", () => {
 		const sessions = [
 			makeBeadSession("builder-1", "overstory-xyz"),
 			makeBeadSession("builder-2", "overstory-def"),
@@ -587,7 +589,7 @@ describe("checkBeadLock", () => {
 	});
 
 	test("returns the first matching agent when multiple sessions match", () => {
-		// Multiple sessions can have the same beadId (e.g., retried agent)
+		// Multiple sessions can have the same taskId (e.g., retried agent)
 		// checkBeadLock returns the first match
 		const sessions = [
 			makeBeadSession("builder-1", "overstory-abc"),
@@ -851,3 +853,83 @@ describe("sling provider env injection building blocks", () => {
 		expect(builderResult.env?.ANTHROPIC_DEFAULT_SONNET_MODEL).toBe("anthropic/claude-3-5-haiku");
 	});
 });
+
+/**
+ * Tests for buildAutoDispatch.
+ *
+ * buildAutoDispatch constructs a pre-spawn dispatch mail message that is
+ * inserted into the mail DB before the tmux session is created. This ensures
+ * the agent's SessionStart hook can immediately deliver context without
+ * waiting for the coordinator to send a separate dispatch message.
+ */
+
+function makeAutoDispatchOpts(overrides?: Partial<AutoDispatchOptions>): AutoDispatchOptions {
+	return {
+		agentName: "builder-1",
+		taskId: "overstory-abc",
+		capability: "builder",
+		specPath: "/path/to/spec.md",
+		parentAgent: "lead-alpha",
+		...overrides,
+	};
+}
+
+describe("buildAutoDispatch", () => {
+	test("uses parent agent as sender when provided", () => {
+		const dispatch = buildAutoDispatch({
+			agentName: "builder-1",
+			taskId: "overstory-abc",
+			capability: "builder",
+			specPath: "/path/to/spec.md",
+			parentAgent: "lead-alpha",
+		});
+		expect(dispatch.from).toBe("lead-alpha");
+		expect(dispatch.to).toBe("builder-1");
+		expect(dispatch.subject).toContain("overstory-abc");
+		expect(dispatch.body).toContain("spec.md");
+	});
+
+	test("uses orchestrator as sender when no parent", () => {
+		const dispatch = buildAutoDispatch({
+			agentName: "lead-1",
+			taskId: "overstory-xyz",
+			capability: "lead",
+			specPath: null,
+			parentAgent: null,
+		});
+		expect(dispatch.from).toBe("orchestrator");
+		expect(dispatch.body).toContain("No spec file");
+	});
+
+	test("includes capability in body", () => {
+		const dispatch = buildAutoDispatch({
+			agentName: "scout-1",
+			taskId: "overstory-abc",
+			capability: "scout",
+			specPath: null,
+			parentAgent: "lead-alpha",
+		});
+		expect(dispatch.body).toContain("scout");
+	});
+
+	test("includes spec path when provided", () => {
+		const dispatch = buildAutoDispatch({
+			agentName: "builder-1",
+			taskId: "overstory-abc",
+			capability: "builder",
+			specPath: "/abs/path/to/spec.md",
+			parentAgent: "lead-alpha",
+		});
+		expect(dispatch.body).toContain("/abs/path/to/spec.md");
+	});
+
+	test("subject contains task ID", () => {
+		const dispatch = buildAutoDispatch(makeAutoDispatchOpts({ taskId: "overstory-zz99" }));
+		expect(dispatch.subject).toContain("overstory-zz99");
+	});
+
+	test("to is the agent name", () => {
+		const dispatch = buildAutoDispatch(makeAutoDispatchOpts({ agentName: "my-builder" }));
+		expect(dispatch.to).toBe("my-builder");
+	});
+});

package/src/commands/sling.ts

@@ -1,5 +1,5 @@
 /**
- * CLI command: overstory sling <task-id>
+ * CLI command: ov sling <task-id>
  *
  * CRITICAL PATH. Orchestrates a full agent spawn:
  * 1. Load config + manifest
@@ -27,6 +27,8 @@ import { writeOverlay } from "../agents/overlay.ts";
 import { loadConfig } from "../config.ts";
 import { AgentError, HierarchyError, ValidationError } from "../errors.ts";
 import { inferDomain } from "../insights/analyzer.ts";
+import { createMailClient } from "../mail/client.ts";
+import { createMailStore } from "../mail/store.ts";
 import { createMulchClient } from "../mulch/client.ts";
 import { openSessionStore } from "../sessions/compat.ts";
 import { createRunStore } from "../sessions/store.ts";
@@ -34,7 +36,13 @@ import type { TrackerIssue } from "../tracker/factory.ts";
 import { createTrackerClient, resolveBackend, trackerCliName } from "../tracker/factory.ts";
 import type { AgentSession, OverlayConfig } from "../types.ts";
 import { createWorktree } from "../worktree/manager.ts";
-import { createSession, sendKeys, waitForTuiReady } from "../worktree/tmux.ts";
+import {
+	capturePaneContent,
+	createSession,
+	ensureTmuxAvailable,
+	sendKeys,
+	waitForTuiReady,
+} from "../worktree/tmux.ts";
 
 /**
  * Calculate how many milliseconds to sleep before spawning a new agent,
@@ -111,6 +119,45 @@ export interface SlingOptions {
 	json?: boolean;
 }
 
+export interface AutoDispatchOptions {
+	agentName: string;
+	taskId: string;
+	capability: string;
+	specPath: string | null;
+	parentAgent: string | null;
+}
+
+/**
+ * Build a structured auto-dispatch mail message for a newly slung agent.
+ *
+ * Sending this mail before creating the tmux session ensures it exists
+ * in the DB when SessionStart fires, eliminating the race where dispatch
+ * mail arrives after the agent boots and sits idle forever.
+ */
+export function buildAutoDispatch(opts: AutoDispatchOptions): {
+	from: string;
+	to: string;
+	subject: string;
+	body: string;
+} {
+	const from = opts.parentAgent ?? "orchestrator";
+	const specLine = opts.specPath
+		? `Spec file: ${opts.specPath}`
+		: "No spec file provided. Check your overlay for task details.";
+	const body = [
+		`You have been assigned task ${opts.taskId} as a ${opts.capability} agent.`,
+		specLine,
+		`Read your overlay at .claude/CLAUDE.md and begin immediately.`,
+	].join(" ");
+
+	return {
+		from,
+		to: opts.agentName,
+		subject: `Dispatch: ${opts.taskId}`,
+		body,
+	};
+}
+
 /**
  * Options for building the structured startup beacon.
  */
@@ -135,7 +182,7 @@ export interface BeaconOptions {
  *   Startup protocol:
  *   1. Read your assignment in .claude/CLAUDE.md
  *   2. Load expertise: mulch prime
- *   3. Check mail: overstory mail check --agent <name>
+ *   3. Check mail: ov mail check --agent <name>
  *   4. Begin working on task <bead-id>
  */
 export function buildBeacon(opts: BeaconOptions): string {
@@ -144,7 +191,7 @@ export function buildBeacon(opts: BeaconOptions): string {
 	const parts = [
 		`[OVERSTORY] ${opts.agentName} (${opts.capability}) ${timestamp} task:${opts.taskId}`,
 		`Depth: ${opts.depth} | Parent: ${parent}`,
-		`Startup: read .claude/CLAUDE.md, run mulch prime, check mail (overstory mail check --agent ${opts.agentName}), then begin task ${opts.taskId}`,
+		`Startup: read .claude/CLAUDE.md, run mulch prime, check mail (ov mail check --agent ${opts.agentName}), then begin task ${opts.taskId}`,
 	];
 	return parts.join(" — ");
 }
@@ -161,17 +208,17 @@ export function parentHasScouts(
 }
 
 /**
- * Check if any active agent is already working on the given bead ID.
+ * Check if any active agent is already working on the given task ID.
  * Returns the agent name if locked, or null if the bead is free.
  *
  * @param activeSessions - Currently active (non-zombie) sessions
- * @param beadId - The bead task ID to check for concurrent work
+ * @param taskId - The bead task ID to check for concurrent work
  */
 export function checkBeadLock(
-	activeSessions: ReadonlyArray<{ agentName: string; beadId: string }>,
-	beadId: string,
+	activeSessions: ReadonlyArray<{ agentName: string; taskId: string }>,
+	taskId: string,
 ): string | null {
-	const existing = activeSessions.find((s) => s.beadId === beadId);
+	const existing = activeSessions.find((s) => s.taskId === taskId);
 	return existing?.agentName ?? null;
 }
 
@@ -225,14 +272,14 @@ export function validateHierarchy(
 }
 
 /**
- * Entry point for `overstory sling <task-id> [flags]`.
+ * Entry point for `ov sling <task-id> [flags]`.
  *
  * @param taskId - The task ID to assign to the agent
  * @param opts - Command options
  */
 export async function slingCommand(taskId: string, opts: SlingOptions): Promise<void> {
 	if (!taskId) {
-		throw new ValidationError("Task ID is required: overstory sling <task-id>", {
+		throw new ValidationError("Task ID is required: ov sling <task-id>", {
 			field: "taskId",
 		});
 	}
@@ -269,7 +316,7 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 	// Warn if --skip-scout is used for a non-lead capability (harmless but confusing)
 	if (skipScout && capability !== "lead") {
 		process.stderr.write(
-			`⚠️  Warning: --skip-scout is only meaningful for leads. Ignoring for "${capability}" agent "${name}".\n`,
+			`Warning: --skip-scout is only meaningful for leads. Ignoring for "${capability}" agent "${name}".\n`,
 		);
 	}
 
@@ -393,7 +440,7 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 			});
 		}
 
-		// 5d. Bead-level locking: prevent concurrent agents on the same bead ID.
+		// 5d. Bead-level locking: prevent concurrent agents on the same task ID.
 		// Exception: the parent agent may delegate its own task to a child.
 		const lockHolder = checkBeadLock(activeSessions, taskId);
 		if (lockHolder !== null && lockHolder !== parentAgent) {
@@ -415,7 +462,7 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 		// the scout-skip pattern so agents and operators can see it happening.
 		if (capability === "builder" && parentAgent && !parentHasScouts(store.getAll(), parentAgent)) {
 			process.stderr.write(
-				`⚠️  Warning: "${parentAgent}" is spawning builder "${name}" without having spawned any scouts.\n`,
+				`Warning: "${parentAgent}" is spawning builder "${name}" without having spawned any scouts.\n`,
 			);
 			process.stderr.write(
 				"   Leads should spawn scouts in Phase 1 before building. See agents/lead.md.\n",
@@ -453,7 +500,7 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 			baseDir: worktreeBaseDir,
 			agentName: name,
 			baseBranch: config.project.canonicalBranch,
-			beadId: taskId,
+			taskId: taskId,
 		});
 
 		// 8. Generate + write overlay CLAUDE.md
@@ -474,7 +521,7 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 
 		const overlayConfig: OverlayConfig = {
 			agentName: name,
-			beadId: taskId,
+			taskId: taskId,
 			specPath: absoluteSpecPath,
 			branchName,
 			worktreePath,
@@ -514,6 +561,30 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 		// 9. Deploy hooks config (capability-specific guards)
 		await deployHooks(worktreePath, name, capability);
 
+		// 9b. Send auto-dispatch mail so it exists when SessionStart hook fires.
+		// This eliminates the race where coordinator sends dispatch AFTER agent boots.
+		const dispatch = buildAutoDispatch({
+			agentName: name,
+			taskId,
+			capability,
+			specPath: absoluteSpecPath,
+			parentAgent,
+		});
+		const mailStore = createMailStore(join(overstoryDir, "mail.db"));
+		try {
+			const mailClient = createMailClient(mailStore);
+			mailClient.send({
+				from: dispatch.from,
+				to: dispatch.to,
+				subject: dispatch.subject,
+				body: dispatch.body,
+				type: "dispatch",
+				priority: "normal",
+			});
+		} finally {
+			mailStore.close();
+		}
+
 		// 10. Claim tracker issue
 		if (config.taskTracker.enabled && !skipTaskCheck) {
 			try {
@@ -537,6 +608,9 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 			});
 		}
 
+		// 11b. Preflight: verify tmux is available before attempting session creation
+		await ensureTmuxAvailable();
+
 		// 12. Create tmux session running claude in interactive mode
 		const tmuxSessionName = `overstory-${config.project.name}-${name}`;
 		const { model, env } = resolveModel(config, manifest, capability, agentDef.model);
@@ -557,7 +631,7 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 			capability,
 			worktreePath,
 			branchName,
-			beadId: taskId,
+			taskId: taskId,
 			tmuxSession: tmuxSessionName,
 			state: "booting",
 			pid,
@@ -604,6 +678,23 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 			await sendKeys(tmuxSessionName, "");
 		}
 
+		// 13d. Verify beacon was received — if pane still shows the welcome
+		// screen ("Try "), resend the beacon. Claude Code's TUI sometimes
+		// consumes the Enter keystroke during late initialization, swallowing
+		// the beacon text entirely (overstory-3271).
+		const verifyAttempts = 5;
+		for (let v = 0; v < verifyAttempts; v++) {
+			await Bun.sleep(2_000);
+			const paneContent = await capturePaneContent(tmuxSessionName);
+			if (paneContent && !paneContent.includes('Try "')) {
+				break; // Agent is processing — beacon was received
+			}
+			// Still at welcome screen — resend beacon
+			await sendKeys(tmuxSessionName, beacon);
+			await Bun.sleep(1_000);
+			await sendKeys(tmuxSessionName, ""); // Follow-up Enter
+		}
+
 		// 14. Output result
 		const output = {
 			agentName: name,
@@ -618,7 +709,7 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 		if (opts.json ?? false) {
 			process.stdout.write(`${JSON.stringify(output)}\n`);
 		} else {
-			process.stdout.write(`🚀 Agent "${name}" launched!\n`);
+			process.stdout.write(`Agent "${name}" launched!\n`);
 			process.stdout.write(`   Task:     ${taskId}\n`);
 			process.stdout.write(`   Branch:   ${branchName}\n`);
 			process.stdout.write(`   Worktree: ${worktreePath}\n`);

package/src/commands/spec.test.ts

@@ -58,8 +58,8 @@ afterEach(async () => {
 // === validation ===
 
 describe("validation", () => {
-	test("write without bead-id throws ValidationError", async () => {
-		await expect(specWriteCommand("", {})).rejects.toThrow("Bead ID is required");
+	test("write without task-id throws ValidationError", async () => {
+		await expect(specWriteCommand("", {})).rejects.toThrow("Task ID is required");
 	});
 
 	test("write without body throws ValidationError", async () => {

package/src/commands/spec.ts

@@ -1,7 +1,7 @@
 /**
- * CLI command: overstory spec write <bead-id> --body <content>
+ * CLI command: ov spec write <bead-id> --body <content>
  *
- * Writes a task specification to `.overstory/specs/<bead-id>.md`.
+ * Writes a task specification to `.overstory/specs/<task-id>.md`.
  * Scouts use this to persist spec documents as files instead of
  * sending entire specs via mail messages.
  *
@@ -30,13 +30,13 @@ async function readStdin(): Promise<string> {
 }
 
 /**
- * Write a spec file to .overstory/specs/<bead-id>.md.
+ * Write a spec file to .overstory/specs/<task-id>.md.
  *
  * Exported for direct use in tests.
  */
 export async function writeSpec(
 	projectRoot: string,
-	beadId: string,
+	taskId: string,
 	body: string,
 	agent?: string,
 ): Promise<string> {
@@ -55,24 +55,23 @@ export async function writeSpec(
 		content += "\n";
 	}
 
-	const specPath = join(specsDir, `${beadId}.md`);
+	const specPath = join(specsDir, `${taskId}.md`);
 	await Bun.write(specPath, content);
 
 	return specPath;
 }
 
 /**
- * Entry point for `overstory spec write <bead-id> [flags]`.
+ * Entry point for `ov spec write <bead-id> [flags]`.
  *
- * @param beadId - The bead/task ID for the spec file
+ * @param taskId - The task ID for the spec file
  * @param opts - Command options
  */
-export async function specWriteCommand(beadId: string, opts: SpecWriteOptions): Promise<void> {
-	if (!beadId || beadId.trim().length === 0) {
-		throw new ValidationError(
-			"Bead ID is required: overstory spec write <bead-id> --body <content>",
-			{ field: "beadId" },
-		);
+export async function specWriteCommand(taskId: string, opts: SpecWriteOptions): Promise<void> {
+	if (!taskId || taskId.trim().length === 0) {
+		throw new ValidationError("Task ID is required: ov spec write <task-id> --body <content>", {
+			field: "taskId",
+		});
 	}
 
 	let body = opts.body;
@@ -94,6 +93,6 @@ export async function specWriteCommand(beadId: string, opts: SpecWriteOptions):
 	const { resolveProjectRoot } = await import("../config.ts");
 	const projectRoot = await resolveProjectRoot(process.cwd());
 
-	const specPath = await writeSpec(projectRoot, beadId, body, opts.agent);
+	const specPath = await writeSpec(projectRoot, taskId, body, opts.agent);
 	process.stdout.write(`${specPath}\n`);
 }

package/src/commands/status.test.ts

@@ -28,7 +28,7 @@ function makeAgent(overrides: Partial<AgentSession> = {}): AgentSession {
 		capability: "builder",
 		worktreePath: "/tmp/worktrees/test-builder",
 		branchName: "overstory/test-builder/task-1",
-		beadId: "task-1",
+		taskId: "task-1",
 		tmuxSession: "overstory-test-builder",
 		state: "working",
 		pid: 12345,
@@ -364,7 +364,7 @@ describe("--watch deprecation", () => {
 
 		const out = chunks.join("");
 		expect(out).toContain("deprecated");
-		expect(out).toContain("overstory dashboard");
+		expect(out).toContain("ov dashboard");
 	});
 
 	test("--watch writes deprecation notice to stderr", async () => {
@@ -394,7 +394,103 @@ describe("--watch deprecation", () => {
 
 		const err = stderrChunks.join("");
 		expect(err).toContain("--watch is deprecated");
-		expect(err).toContain("overstory dashboard");
+		expect(err).toContain("ov dashboard");
+	});
+});
+
+describe("gatherStatus reconciliation", () => {
+	afterEach(() => {
+		invalidateStatusCache();
+	});
+
+	test("booting agent with dead tmux becomes zombie", async () => {
+		const tempDir = await createTempGitRepo();
+		const overstoryDir = join(tempDir, ".overstory");
+		await mkdir(overstoryDir, { recursive: true });
+
+		const store = createSessionStore(join(overstoryDir, "sessions.db"));
+		const now = new Date().toISOString();
+		const session = makeAgent({
+			agentName: "boot-builder",
+			capability: "builder",
+			state: "booting",
+			tmuxSession: "overstory-boot-builder",
+			runId: null,
+		});
+		session.startedAt = now;
+		session.lastActivity = now;
+		store.upsert(session);
+		store.close();
+
+		try {
+			// No real tmux running, so getCachedTmuxSessions() returns empty array
+			// evaluateHealth ZFC Rule 1: tmux dead → zombie
+			const result = await gatherStatus(tempDir, "orchestrator", false, undefined);
+			const agent = result.agents.find((a) => a.agentName === "boot-builder");
+			expect(agent).toBeDefined();
+			expect(agent?.state).toBe("zombie");
+		} finally {
+			await rm(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	test("completed agents skip reconciliation", async () => {
+		const tempDir = await createTempGitRepo();
+		const overstoryDir = join(tempDir, ".overstory");
+		await mkdir(overstoryDir, { recursive: true });
+
+		const store = createSessionStore(join(overstoryDir, "sessions.db"));
+		const now = new Date().toISOString();
+		const session = makeAgent({
+			agentName: "done-builder",
+			capability: "builder",
+			state: "completed",
+			tmuxSession: "overstory-done-builder",
+			runId: null,
+		});
+		session.startedAt = now;
+		session.lastActivity = now;
+		store.upsert(session);
+		store.close();
+
+		try {
+			const result = await gatherStatus(tempDir, "orchestrator", false, undefined);
+			const agent = result.agents.find((a) => a.agentName === "done-builder");
+			expect(agent).toBeDefined();
+			expect(agent?.state).toBe("completed");
+		} finally {
+			await rm(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	test("working agent with dead tmux becomes zombie", async () => {
+		const tempDir = await createTempGitRepo();
+		const overstoryDir = join(tempDir, ".overstory");
+		await mkdir(overstoryDir, { recursive: true });
+
+		const store = createSessionStore(join(overstoryDir, "sessions.db"));
+		const now = new Date().toISOString();
+		const session = makeAgent({
+			agentName: "working-builder",
+			capability: "builder",
+			state: "working",
+			tmuxSession: "overstory-working-builder",
+			runId: null,
+		});
+		session.startedAt = now;
+		session.lastActivity = now;
+		store.upsert(session);
+		store.close();
+
+		try {
+			// No real tmux session → tmux dead → zombie via evaluateHealth ZFC Rule 1
+			const result = await gatherStatus(tempDir, "orchestrator", false, undefined);
+			const agent = result.agents.find((a) => a.agentName === "working-builder");
+			expect(agent).toBeDefined();
+			expect(agent?.state).toBe("zombie");
+		} finally {
+			await rm(tempDir, { recursive: true, force: true });
+		}
 	});
 });
 

package/src/commands/status.ts

@@ -14,6 +14,7 @@ import { createMergeQueue } from "../merge/queue.ts";
 import { createMetricsStore } from "../metrics/store.ts";
 import { openSessionStore } from "../sessions/compat.ts";
 import type { AgentSession } from "../types.ts";
+import { evaluateHealth } from "../watchdog/health.ts";
 import { listWorktrees } from "../worktree/manager.ts";
 import { listSessions } from "../worktree/tmux.ts";
 
@@ -136,23 +137,23 @@ export async function gatherStatus(
 
 		const tmuxSessions = await getCachedTmuxSessions();
 
-		// Reconcile agent states: if tmux session is dead but agent state
-		// indicates it should be alive, mark it as zombie
+		// Reconcile agent states using the same health evaluation as the
+		// dashboard and watchdog. This handles:
+		//   1. tmux dead -> zombie (regardless of recorded state)
+		//   2. persistent capabilities (coordinator, monitor) booting -> working when tmux alive
+		//   3. time-based stale/zombie detection for non-persistent agents
 		const tmuxSessionNames = new Set(tmuxSessions.map((s) => s.name));
+		const healthThresholds = { staleMs: 300_000, zombieMs: 600_000 };
 		for (const session of sessions) {
-			if (
-				session.state === "booting" ||
-				session.state === "working" ||
-				session.state === "stalled"
-			) {
-				const tmuxAlive = tmuxSessionNames.has(session.tmuxSession);
-				if (!tmuxAlive) {
-					try {
-						store.updateState(session.agentName, "zombie");
-						session.state = "zombie";
-					} catch {
-						// Best effort: don't fail status display if update fails
-					}
+			if (session.state === "completed") continue;
+			const tmuxAlive = tmuxSessionNames.has(session.tmuxSession);
+			const check = evaluateHealth(session, tmuxAlive, healthThresholds);
+			if (check.state !== session.state) {
+				try {
+					store.updateState(session.agentName, check.state);
+					session.state = check.state;
+				} catch {
+					// Best effort: don't fail status display if update fails
 				}
 			}
 		}
@@ -273,7 +274,7 @@ export function printStatus(data: StatusData): void {
 			const tmuxAlive = tmuxSessionNames.has(agent.tmuxSession);
 			const aliveMarker = tmuxAlive ? "●" : "○";
 			w(`   ${aliveMarker} ${agent.agentName} [${agent.capability}] `);
-			w(`${agent.state} | ${agent.beadId} | ${duration}\n`);
+			w(`${agent.state} | ${agent.taskId} | ${duration}\n`);
 
 			const detail = data.verboseDetails?.[agent.agentName];
 			if (detail) {
@@ -346,9 +347,7 @@ async function executeStatus(opts: StatusOpts): Promise<void> {
 	}
 
 	if (watch) {
-		process.stderr.write(
-			"⚠️  --watch is deprecated. Use 'overstory dashboard' for live monitoring.\n\n",
-		);
+		process.stderr.write("⚠️  --watch is deprecated. Use 'ov dashboard' for live monitoring.\n\n");
 		// Polling loop (kept for one release cycle)
 		while (true) {
 			// Clear screen
@@ -378,7 +377,7 @@ export function createStatusCommand(): Command {
 		.option("--verbose", "Show extra detail per agent (worktree, logs, mail timestamps)")
 		.option("--agent <name>", "Show unread mail for this agent (default: orchestrator)")
 		.option("--all", "Show sessions from all runs (default: current run only)")
-		.option("--watch", "(deprecated) Use 'overstory dashboard' for live monitoring")
+		.option("--watch", "(deprecated) Use 'ov dashboard' for live monitoring")
 		.option("--interval <ms>", "Poll interval for --watch in milliseconds (default: 3000)")
 		.action(async (opts: StatusOpts) => {
 			await executeStatus(opts);