@os-eco/overstory-cli 0.8.0 → 0.8.3

package/src/commands/sling.test.ts

@@ -20,6 +20,7 @@ import {
 	checkRunSessionLimit,
 	checkTaskLock,
 	extractMulchRecordIds,
+	generateAgentName,
 	getCurrentBranch,
 	inferDomainsFromFiles,
 	isRunningAsRoot,
@@ -342,6 +343,31 @@ describe("shouldShowScoutWarning", () => {
 	});
 });
 
+describe("generateAgentName", () => {
+	test("returns capability-taskId when no collision", () => {
+		expect(generateAgentName("builder", "overstory-2f10", [])).toBe("builder-overstory-2f10");
+	});
+
+	test("returns capability-taskId when takenNames is empty", () => {
+		expect(generateAgentName("scout", "task-123", [])).toBe("scout-task-123");
+	});
+
+	test("appends -2 when base name is taken", () => {
+		expect(generateAgentName("builder", "overstory-2f10", ["builder-overstory-2f10"])).toBe(
+			"builder-overstory-2f10-2",
+		);
+	});
+
+	test("skips taken suffixes and returns -3 when -2 is also taken", () => {
+		expect(
+			generateAgentName("builder", "overstory-2f10", [
+				"builder-overstory-2f10",
+				"builder-overstory-2f10-2",
+			]),
+		).toBe("builder-overstory-2f10-3");
+	});
+});
+
 /**
  * Tests for hierarchy validation in sling.
  *
@@ -352,14 +378,12 @@ describe("shouldShowScoutWarning", () => {
  */
 
 describe("validateHierarchy", () => {
-	test("rejects builder when parentAgent is null", () => {
-		expect(() => validateHierarchy(null, "builder", "test-builder", 0, false)).toThrow(
-			HierarchyError,
-		);
+	test("allows builder when parentAgent is null", () => {
+		expect(() => validateHierarchy(null, "builder", "test-builder", 0, false)).not.toThrow();
 	});
 
-	test("rejects scout when parentAgent is null", () => {
-		expect(() => validateHierarchy(null, "scout", "test-scout", 0, false)).toThrow(HierarchyError);
+	test("allows scout when parentAgent is null", () => {
+		expect(() => validateHierarchy(null, "scout", "test-scout", 0, false)).not.toThrow();
 	});
 
 	test("rejects reviewer when parentAgent is null", () => {
@@ -404,15 +428,15 @@ describe("validateHierarchy", () => {
 
 	test("error has correct fields and code", () => {
 		try {
-			validateHierarchy(null, "builder", "my-builder", 0, false);
+			validateHierarchy(null, "reviewer", "my-reviewer", 0, false);
 			expect.unreachable("should have thrown");
 		} catch (err) {
 			expect(err).toBeInstanceOf(HierarchyError);
 			const he = err as HierarchyError;
 			expect(he.code).toBe("HIERARCHY_VIOLATION");
-			expect(he.agentName).toBe("my-builder");
-			expect(he.requestedCapability).toBe("builder");
-			expect(he.message).toContain("builder");
+			expect(he.agentName).toBe("my-reviewer");
+			expect(he.requestedCapability).toBe("reviewer");
+			expect(he.message).toContain("reviewer");
 			expect(he.message).toContain("lead");
 		}
 	});

package/src/commands/sling.ts

@@ -18,6 +18,7 @@
  * 14. Return AgentSession
  */
 
+import { mkdirSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { createIdentity, loadIdentity } from "../agents/identity.ts";
@@ -38,6 +39,7 @@ 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 { spawnHeadlessAgent } from "../worktree/process.ts";
 import {
 	capturePaneContent,
 	createSession,
@@ -75,6 +77,29 @@ export function calculateStaggerDelay(
 	return remaining > 0 ? remaining : 0;
 }
 
+/**
+ * Generate a unique agent name from capability and taskId.
+ * Base: capability-taskId. If that collides with takenNames,
+ * appends -2, -3, etc. up to 100. Falls back to -Date.now() for guaranteed uniqueness.
+ */
+export function generateAgentName(
+	capability: string,
+	taskId: string,
+	takenNames: readonly string[],
+): string {
+	const base = `${capability}-${taskId}`;
+	if (!takenNames.includes(base)) {
+		return base;
+	}
+	for (let i = 2; i <= 100; i++) {
+		const candidate = `${base}-${i}`;
+		if (!takenNames.includes(candidate)) {
+			return candidate;
+		}
+	}
+	return `${base}-${Date.now()}`;
+}
+
 /**
  * Check if the current process is running as root (UID 0).
  * Returns true if running as root, false otherwise.
@@ -345,9 +370,10 @@ export function validateHierarchy(
 		return;
 	}
 
-	if (parentAgent === null && capability !== "lead") {
+	const directSpawnCapabilities = ["lead", "scout", "builder"];
+	if (parentAgent === null && !directSpawnCapabilities.includes(capability)) {
 		throw new HierarchyError(
-			`Coordinator cannot spawn "${capability}" directly. Only "lead" is allowed without --parent. Use a lead as intermediary, or pass --force-hierarchy to bypass.`,
+			`Coordinator cannot spawn "${capability}" directly. Only lead, scout, and builder are allowed without --parent. Use a lead as intermediary, or pass --force-hierarchy to bypass.`,
 			{ agentName: name, requestedCapability: capability },
 		);
 	}
@@ -426,7 +452,9 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 	}
 
 	const capability = opts.capability ?? "builder";
-	const name = opts.name;
+	const rawName = opts.name?.trim() ?? "";
+	const nameWasAutoGenerated = rawName.length === 0;
+	let name = nameWasAutoGenerated ? `${capability}-${taskId}` : rawName;
 	const specPath = opts.spec ?? null;
 	const filesRaw = opts.files;
 	const parentAgent = opts.parent ?? null;
@@ -436,10 +464,6 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 	const skipScout = opts.skipScout ?? false;
 	const skipTaskCheck = opts.skipTaskCheck ?? false;
 
-	if (!name || name.trim().length === 0) {
-		throw new ValidationError("--name is required for sling", { field: "name" });
-	}
-
 	if (Number.isNaN(depth) || depth < 0) {
 		throw new ValidationError("--depth must be a non-negative integer", {
 			field: "depth",
@@ -594,11 +618,16 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 			);
 		}
 
-		const existing = store.getByName(name);
-		if (existing && existing.state !== "zombie" && existing.state !== "completed") {
-			throw new AgentError(`Agent name "${name}" is already in use (state: ${existing.state})`, {
-				agentName: name,
-			});
+		if (nameWasAutoGenerated) {
+			const takenNames = activeSessions.map((s) => s.agentName);
+			name = generateAgentName(capability, taskId, takenNames);
+		} else {
+			const existing = store.getByName(name);
+			if (existing && existing.state !== "zombie" && existing.state !== "completed") {
+				throw new AgentError(`Agent name "${name}" is already in use (state: ${existing.state})`, {
+					agentName: name,
+				});
+			}
 		}
 
 		// 5d. Task-level locking: prevent concurrent agents on the same task ID.
@@ -714,6 +743,9 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 			}
 		}
 
+		// Resolve runtime before overlayConfig so we can pass runtime.instructionPath
+		const runtime = getRuntime(opts.runtime, config);
+
 		const overlayConfig: OverlayConfig = {
 			agentName: name,
 			taskId: taskId,
@@ -739,11 +771,9 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 			qualityGates: config.project.qualityGates,
 			trackerCli: trackerCliName(resolvedBackend),
 			trackerName: resolvedBackend,
+			instructionPath: runtime.instructionPath,
 		};
 
-		// Resolve runtime before writeOverlay so we can pass runtime.instructionPath
-		const runtime = getRuntime(opts.runtime, config);
-
 		try {
 			await writeOverlay(worktreePath, overlayConfig, config.project.root, runtime.instructionPath);
 		} catch (err) {
@@ -836,142 +866,225 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 			}
 		}
 
-		// 11c. Preflight: verify tmux is available before attempting session creation
-		await ensureTmuxAvailable();
+		// 11c. Spawn: headless runtimes bypass tmux entirely; tmux path is unchanged.
+		if (runtime.headless === true && runtime.buildDirectSpawn) {
+			const directEnv = {
+				...runtime.buildEnv(resolvedModel),
+				OVERSTORY_AGENT_NAME: name,
+				OVERSTORY_WORKTREE_PATH: worktreePath,
+			};
+			const argv = runtime.buildDirectSpawn({
+				cwd: worktreePath,
+				env: directEnv,
+				model: resolvedModel.model,
+				instructionPath: runtime.instructionPath,
+			});
+
+			// Create a timestamped log dir for this headless agent session.
+			// Always redirect stdout to a file. This prevents SIGPIPE death:
+			// ov sling exits after spawning, closing the pipe's read end.
+			// If stdout is a pipe, the agent dies on the next write (SIGPIPE).
+			// File writes have no such limit, and the agent survives the CLI exit.
+			//
+			// Note: RPC connection wiring is intentionally omitted here. The RPC pipe
+			// is only useful when the spawner stays alive to consume it. ov sling is
+			// a short-lived CLI — any connection created here dies with the process.
+			const logTimestamp = new Date().toISOString().replace(/[:.]/g, "-");
+			const agentLogDir = join(overstoryDir, "logs", name, logTimestamp);
+			mkdirSync(agentLogDir, { recursive: true });
+
+			const headlessProc = await spawnHeadlessAgent(argv, {
+				cwd: worktreePath,
+				env: { ...(process.env as Record<string, string>), ...directEnv },
+				stdoutFile: join(agentLogDir, "stdout.log"),
+				stderrFile: join(agentLogDir, "stderr.log"),
+			});
 
-		// 12. Create tmux session running claude in interactive mode
-		const tmuxSessionName = `overstory-${config.project.name}-${name}`;
-		const spawnCmd = runtime.buildSpawnCommand({
-			model: resolvedModel.model,
-			permissionMode: "bypass",
-			cwd: worktreePath,
-			env: {
+			// 13. Record session with empty tmuxSession (no tmux pane for headless agents).
+			const session: AgentSession = {
+				id: `session-${Date.now()}-${name}`,
+				agentName: name,
+				capability,
+				worktreePath,
+				branchName,
+				taskId: taskId,
+				tmuxSession: "",
+				state: "booting",
+				pid: headlessProc.pid,
+				parentAgent: parentAgent,
+				depth,
+				runId,
+				startedAt: new Date().toISOString(),
+				lastActivity: new Date().toISOString(),
+				escalationLevel: 0,
+				stalledSince: null,
+				transcriptPath: null,
+			};
+			store.upsert(session);
+
+			const runStore = createRunStore(join(overstoryDir, "sessions.db"));
+			try {
+				runStore.incrementAgentCount(runId);
+			} finally {
+				runStore.close();
+			}
+
+			// 14. Output result (headless)
+			if (opts.json ?? false) {
+				jsonOutput("sling", {
+					agentName: name,
+					capability,
+					taskId,
+					branch: branchName,
+					worktree: worktreePath,
+					tmuxSession: "",
+					pid: headlessProc.pid,
+				});
+			} else {
+				printSuccess("Agent launched (headless)", name);
+				process.stdout.write(`   Task:     ${taskId}\n`);
+				process.stdout.write(`   Branch:   ${branchName}\n`);
+				process.stdout.write(`   Worktree: ${worktreePath}\n`);
+				process.stdout.write(`   PID:      ${headlessProc.pid}\n`);
+			}
+		} else {
+			// 11c. 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 spawnCmd = runtime.buildSpawnCommand({
+				model: resolvedModel.model,
+				permissionMode: "bypass",
+				cwd: worktreePath,
+				env: {
+					...runtime.buildEnv(resolvedModel),
+					OVERSTORY_AGENT_NAME: name,
+					OVERSTORY_WORKTREE_PATH: worktreePath,
+				},
+			});
+			const pid = await createSession(tmuxSessionName, worktreePath, spawnCmd, {
 				...runtime.buildEnv(resolvedModel),
 				OVERSTORY_AGENT_NAME: name,
 				OVERSTORY_WORKTREE_PATH: worktreePath,
-			},
-		});
-		const pid = await createSession(tmuxSessionName, worktreePath, spawnCmd, {
-			...runtime.buildEnv(resolvedModel),
-			OVERSTORY_AGENT_NAME: name,
-			OVERSTORY_WORKTREE_PATH: worktreePath,
-		});
+			});
 
-		// 13. Record session BEFORE sending the beacon so that hook-triggered
-		// updateLastActivity() can find the entry and transition booting->working.
-		// Without this, a race exists: hooks fire before the session is persisted,
-		// leaving the agent stuck in "booting" (overstory-036f).
-		const session: AgentSession = {
-			id: `session-${Date.now()}-${name}`,
-			agentName: name,
-			capability,
-			worktreePath,
-			branchName,
-			taskId: taskId,
-			tmuxSession: tmuxSessionName,
-			state: "booting",
-			pid,
-			parentAgent: parentAgent,
-			depth,
-			runId,
-			startedAt: new Date().toISOString(),
-			lastActivity: new Date().toISOString(),
-			escalationLevel: 0,
-			stalledSince: null,
-			transcriptPath: null,
-		};
+			// 13. Record session BEFORE sending the beacon so that hook-triggered
+			// updateLastActivity() can find the entry and transition booting->working.
+			// Without this, a race exists: hooks fire before the session is persisted,
+			// leaving the agent stuck in "booting" (overstory-036f).
+			const session: AgentSession = {
+				id: `session-${Date.now()}-${name}`,
+				agentName: name,
+				capability,
+				worktreePath,
+				branchName,
+				taskId: taskId,
+				tmuxSession: tmuxSessionName,
+				state: "booting",
+				pid,
+				parentAgent: parentAgent,
+				depth,
+				runId,
+				startedAt: new Date().toISOString(),
+				lastActivity: new Date().toISOString(),
+				escalationLevel: 0,
+				stalledSince: null,
+				transcriptPath: null,
+			};
 
-		store.upsert(session);
+			store.upsert(session);
 
-		// Increment agent count for the run
-		const runStore = createRunStore(join(overstoryDir, "sessions.db"));
-		try {
-			runStore.incrementAgentCount(runId);
-		} finally {
-			runStore.close();
-		}
+			// Increment agent count for the run
+			const runStore = createRunStore(join(overstoryDir, "sessions.db"));
+			try {
+				runStore.incrementAgentCount(runId);
+			} finally {
+				runStore.close();
+			}
 
-		// 13b. Give slow shells time to finish initializing before polling for TUI readiness.
-		const shellDelay = config.runtime?.shellInitDelayMs ?? 0;
-		if (shellDelay > 0) {
-			await Bun.sleep(shellDelay);
-		}
+			// 13b. Give slow shells time to finish initializing before polling for TUI readiness.
+			const shellDelay = config.runtime?.shellInitDelayMs ?? 0;
+			if (shellDelay > 0) {
+				await Bun.sleep(shellDelay);
+			}
 
-		// Wait for Claude Code TUI to render before sending input.
-		// Polling capture-pane is more reliable than a fixed sleep because
-		// TUI init time varies by machine load and model state.
-		await waitForTuiReady(tmuxSessionName, (content) => runtime.detectReady(content));
-		// Buffer for the input handler to attach after initial render
-		await Bun.sleep(1_000);
+			// Wait for Claude Code TUI to render before sending input.
+			// Polling capture-pane is more reliable than a fixed sleep because
+			// TUI init time varies by machine load and model state.
+			await waitForTuiReady(tmuxSessionName, (content) => runtime.detectReady(content));
+			// Buffer for the input handler to attach after initial render
+			await Bun.sleep(1_000);
 
-		const beacon = buildBeacon({
-			agentName: name,
-			capability,
-			taskId,
-			parentAgent,
-			depth,
-			instructionPath: runtime.instructionPath,
-		});
-		await sendKeys(tmuxSessionName, beacon);
-
-		// 13c. Follow-up Enters with increasing delays to ensure submission.
-		// Claude Code's TUI may consume early Enters during late initialization
-		// (overstory-yhv6). An Enter on an empty input line is harmless.
-		for (const delay of [1_000, 2_000, 3_000, 5_000]) {
-			await Bun.sleep(delay);
-			await sendKeys(tmuxSessionName, "");
-		}
+			const beacon = buildBeacon({
+				agentName: name,
+				capability,
+				taskId,
+				parentAgent,
+				depth,
+				instructionPath: runtime.instructionPath,
+			});
+			await sendKeys(tmuxSessionName, beacon);
+
+			// 13c. Follow-up Enters with increasing delays to ensure submission.
+			// Claude Code's TUI may consume early Enters during late initialization
+			// (overstory-yhv6). An Enter on an empty input line is harmless.
+			for (const delay of [1_000, 2_000, 3_000, 5_000]) {
+				await Bun.sleep(delay);
+				await sendKeys(tmuxSessionName, "");
+			}
 
-		// 13d. Verify beacon was received — if pane still shows the welcome
-		// screen (detectReady returns "ready"), resend the beacon. Claude Code's TUI
-		// sometimes consumes the Enter keystroke during late initialization, swallowing
-		// the beacon text entirely (overstory-3271).
-		//
-		// Skipped for runtimes that return false from requiresBeaconVerification().
-		// Pi's TUI idle and processing states are indistinguishable via detectReady
-		// (both show "pi v..." header and the token-usage status bar), so the loop
-		// would incorrectly conclude the beacon was not received and spam duplicate
-		// startup messages.
-		const needsVerification =
-			!runtime.requiresBeaconVerification || runtime.requiresBeaconVerification();
-		if (needsVerification) {
-			const verifyAttempts = 5;
-			for (let v = 0; v < verifyAttempts; v++) {
-				await Bun.sleep(2_000);
-				const paneContent = await capturePaneContent(tmuxSessionName);
-				if (paneContent) {
-					const readyState = runtime.detectReady(paneContent);
-					if (readyState.phase !== "ready") {
-						break; // Agent is processing — beacon was received
+			// 13d. Verify beacon was received — if pane still shows the welcome
+			// screen (detectReady returns "ready"), resend the beacon. Claude Code's TUI
+			// sometimes consumes the Enter keystroke during late initialization, swallowing
+			// the beacon text entirely (overstory-3271).
+			//
+			// Skipped for runtimes that return false from requiresBeaconVerification().
+			// Pi's TUI idle and processing states are indistinguishable via detectReady
+			// (both show "pi v..." header and the token-usage status bar), so the loop
+			// would incorrectly conclude the beacon was not received and spam duplicate
+			// startup messages.
+			const needsVerification =
+				!runtime.requiresBeaconVerification || runtime.requiresBeaconVerification();
+			if (needsVerification) {
+				const verifyAttempts = 5;
+				for (let v = 0; v < verifyAttempts; v++) {
+					await Bun.sleep(2_000);
+					const paneContent = await capturePaneContent(tmuxSessionName);
+					if (paneContent) {
+						const readyState = runtime.detectReady(paneContent);
+						if (readyState.phase !== "ready") {
+							break; // Agent is processing — beacon was received
+						}
 					}
+					// Still at welcome/idle screen — resend beacon
+					await sendKeys(tmuxSessionName, beacon);
+					await Bun.sleep(1_000);
+					await sendKeys(tmuxSessionName, ""); // Follow-up Enter
 				}
-				// Still at welcome/idle 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,
-			capability,
-			taskId,
-			branch: branchName,
-			worktree: worktreePath,
-			tmuxSession: tmuxSessionName,
-			pid,
-		};
 
-		if (opts.json ?? false) {
-			jsonOutput("sling", output);
-		} else {
-			printSuccess("Agent launched", name);
-			process.stdout.write(`   Task:     ${taskId}\n`);
-			process.stdout.write(`   Branch:   ${branchName}\n`);
-			process.stdout.write(`   Worktree: ${worktreePath}\n`);
-			process.stdout.write(`   Tmux:     ${tmuxSessionName}\n`);
-			process.stdout.write(`   PID:      ${pid}\n`);
+			// 14. Output result
+			const output = {
+				agentName: name,
+				capability,
+				taskId,
+				branch: branchName,
+				worktree: worktreePath,
+				tmuxSession: tmuxSessionName,
+				pid,
+			};
+
+			if (opts.json ?? false) {
+				jsonOutput("sling", output);
+			} else {
+				printSuccess("Agent launched", name);
+				process.stdout.write(`   Task:     ${taskId}\n`);
+				process.stdout.write(`   Branch:   ${branchName}\n`);
+				process.stdout.write(`   Worktree: ${worktreePath}\n`);
+				process.stdout.write(`   Tmux:     ${tmuxSessionName}\n`);
+				process.stdout.write(`   PID:      ${pid}\n`);
+			}
 		}
 	} finally {
 		store.close();

package/src/commands/status.test.ts

@@ -349,6 +349,83 @@ describe("run scoping", () => {
 	});
 });
 
+describe("headless agent alive markers", () => {
+	let chunks: string[];
+	let originalWrite: typeof process.stdout.write;
+
+	beforeEach(() => {
+		chunks = [];
+		originalWrite = process.stdout.write;
+		process.stdout.write = ((chunk: string) => {
+			chunks.push(chunk);
+			return true;
+		}) as typeof process.stdout.write;
+	});
+
+	afterEach(() => {
+		process.stdout.write = originalWrite;
+	});
+
+	function output(): string {
+		return chunks.join("");
+	}
+
+	test("printStatus shows green marker for headless agent with alive PID", () => {
+		// Use own process PID — guaranteed alive
+		const alivePid = process.pid;
+		const agent = makeAgent({
+			agentName: "headless-builder",
+			tmuxSession: "", // headless: no tmux
+			pid: alivePid,
+			state: "working",
+		});
+		const data = makeStatusData({
+			agents: [agent],
+			tmuxSessions: [], // no tmux sessions
+		});
+		printStatus(data);
+		const out = output();
+		// Green marker is ">" — check it appears in the output
+		expect(out).toContain("headless-builder");
+		expect(out).toContain(">");
+	});
+
+	test("printStatus shows red marker for headless agent with dead PID", () => {
+		const deadPid = 2_147_483_647; // max int, virtually guaranteed non-existent
+		const agent = makeAgent({
+			agentName: "dead-headless-builder",
+			tmuxSession: "", // headless: no tmux
+			pid: deadPid,
+			state: "working",
+		});
+		const data = makeStatusData({
+			agents: [agent],
+			tmuxSessions: [],
+		});
+		printStatus(data);
+		const out = output();
+		expect(out).toContain("dead-headless-builder");
+		expect(out).toContain("x");
+	});
+
+	test("printStatus uses tmux check (not PID) for tmux-based agents", () => {
+		const agent = makeAgent({
+			agentName: "tmux-builder",
+			tmuxSession: "overstory-test-builder",
+			pid: process.pid, // alive PID, but should use tmux check
+			state: "working",
+		});
+		// tmuxSessions empty → tmux dead → red marker
+		const data = makeStatusData({
+			agents: [agent],
+			tmuxSessions: [],
+		});
+		printStatus(data);
+		const out = output();
+		expect(out).toContain("x");
+	});
+});
+
 describe("--watch deprecation", () => {
 	test("help text marks --watch as deprecated", async () => {
 		const chunks: string[] = [];

package/src/commands/status.ts

@@ -20,7 +20,7 @@ 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";
+import { isProcessAlive, listSessions } from "../worktree/tmux.ts";
 
 // ---------------------------------------------------------------------------
 // Subprocess result cache (TTL-based, module-level)
@@ -260,8 +260,11 @@ export function printStatus(data: StatusData): void {
 					? new Date(agent.lastActivity).getTime()
 					: now;
 			const duration = formatDuration(endTime - new Date(agent.startedAt).getTime());
-			const tmuxAlive = tmuxSessionNames.has(agent.tmuxSession);
-			const aliveMarker = tmuxAlive ? color.green(">") : color.red("x");
+			const isHeadless = agent.tmuxSession === "" && agent.pid !== null;
+			const alive = isHeadless
+				? agent.pid !== null && isProcessAlive(agent.pid)
+				: tmuxSessionNames.has(agent.tmuxSession);
+			const aliveMarker = alive ? color.green(">") : color.red("x");
 			w(`   ${aliveMarker} ${accent(agent.agentName)} [${agent.capability}] `);
 			w(`${agent.state} | ${accent(agent.taskId)} | ${duration}\n`);