@os-eco/overstory-cli 0.8.4 → 0.8.6

package/src/commands/coordinator.test.ts

@@ -17,13 +17,14 @@ import { join } from "node:path";
 import { AgentError, ValidationError } from "../errors.ts";
 import { createMailStore } from "../mail/store.ts";
 import { openSessionStore } from "../sessions/compat.ts";
-import { createRunStore } from "../sessions/store.ts";
+import { createRunStore, createSessionStore } from "../sessions/store.ts";
 import { cleanupTempDir, createTempGitRepo } from "../test-helpers.ts";
 import type { AgentSession } from "../types.ts";
 import {
 	askCoordinator,
 	buildCoordinatorBeacon,
 	type CoordinatorDeps,
+	checkComplete,
 	coordinatorCommand,
 	createCoordinatorCommand,
 	resolveAttach,
@@ -2104,3 +2105,421 @@ describe("askCoordinator", () => {
 		expect(subcommandNames).toContain("ask");
 	});
 });
+
+// ─── checkComplete ─────────────────────────────────────────────────────────
+
+describe("checkComplete", () => {
+	test("all triggers disabled → complete: false", async () => {
+		// Default config has no coordinator section → all triggers default to false
+		const result = await checkComplete({ json: false });
+		expect(result.complete).toBe(false);
+		expect(result.triggers.allAgentsDone.enabled).toBe(false);
+		expect(result.triggers.taskTrackerEmpty.enabled).toBe(false);
+		expect(result.triggers.onShutdownSignal.enabled).toBe(false);
+	});
+
+	test("allAgentsDone met when all non-coordinator agents completed", async () => {
+		// Enable allAgentsDone in config
+		await Bun.write(
+			join(overstoryDir, "config.yaml"),
+			[
+				"project:",
+				"  name: test-project",
+				`  root: ${tempDir}`,
+				"  canonicalBranch: main",
+				"coordinator:",
+				"  exitTriggers:",
+				"    allAgentsDone: true",
+				"    taskTrackerEmpty: false",
+				"    onShutdownSignal: false",
+			].join("\n"),
+		);
+
+		// Write current-run.txt
+		const runId = `run-${Date.now()}`;
+		await Bun.write(join(overstoryDir, "current-run.txt"), runId);
+
+		// Create sessions.db with two completed agents
+		const store = createSessionStore(join(overstoryDir, "sessions.db"));
+		try {
+			const base: AgentSession = {
+				id: "s1",
+				agentName: "builder-1",
+				capability: "builder",
+				worktreePath: tempDir,
+				branchName: "feat/x",
+				taskId: "t1",
+				tmuxSession: "tmux-1",
+				state: "completed",
+				pid: null,
+				parentAgent: "coordinator",
+				depth: 1,
+				runId,
+				startedAt: new Date().toISOString(),
+				lastActivity: new Date().toISOString(),
+				escalationLevel: 0,
+				stalledSince: null,
+				transcriptPath: null,
+			};
+			store.upsert(base);
+			store.upsert({ ...base, id: "s2", agentName: "builder-2" });
+		} finally {
+			store.close();
+		}
+
+		const result = await checkComplete({ json: false });
+		expect(result.triggers.allAgentsDone.enabled).toBe(true);
+		expect(result.triggers.allAgentsDone.met).toBe(true);
+		expect(result.complete).toBe(true);
+	});
+
+	test("allAgentsDone not met when agents still working", async () => {
+		await Bun.write(
+			join(overstoryDir, "config.yaml"),
+			[
+				"project:",
+				"  name: test-project",
+				`  root: ${tempDir}`,
+				"  canonicalBranch: main",
+				"coordinator:",
+				"  exitTriggers:",
+				"    allAgentsDone: true",
+				"    taskTrackerEmpty: false",
+				"    onShutdownSignal: false",
+			].join("\n"),
+		);
+
+		const runId = `run-${Date.now()}`;
+		await Bun.write(join(overstoryDir, "current-run.txt"), runId);
+
+		const store = createSessionStore(join(overstoryDir, "sessions.db"));
+		try {
+			const session: AgentSession = {
+				id: "s1",
+				agentName: "builder-1",
+				capability: "builder",
+				worktreePath: tempDir,
+				branchName: "feat/x",
+				taskId: "t1",
+				tmuxSession: "tmux-1",
+				state: "working",
+				pid: null,
+				parentAgent: "coordinator",
+				depth: 1,
+				runId,
+				startedAt: new Date().toISOString(),
+				lastActivity: new Date().toISOString(),
+				escalationLevel: 0,
+				stalledSince: null,
+				transcriptPath: null,
+			};
+			store.upsert(session);
+		} finally {
+			store.close();
+		}
+
+		const result = await checkComplete({ json: false });
+		expect(result.triggers.allAgentsDone.enabled).toBe(true);
+		expect(result.triggers.allAgentsDone.met).toBe(false);
+		expect(result.complete).toBe(false);
+	});
+
+	test("allAgentsDone filters out coordinator session", async () => {
+		await Bun.write(
+			join(overstoryDir, "config.yaml"),
+			[
+				"project:",
+				"  name: test-project",
+				`  root: ${tempDir}`,
+				"  canonicalBranch: main",
+				"coordinator:",
+				"  exitTriggers:",
+				"    allAgentsDone: true",
+				"    taskTrackerEmpty: false",
+				"    onShutdownSignal: false",
+			].join("\n"),
+		);
+
+		const runId = `run-${Date.now()}`;
+		await Bun.write(join(overstoryDir, "current-run.txt"), runId);
+
+		const store = createSessionStore(join(overstoryDir, "sessions.db"));
+		try {
+			// coordinator session (should be excluded)
+			store.upsert({
+				id: "coord",
+				agentName: "coordinator",
+				capability: "coordinator",
+				worktreePath: tempDir,
+				branchName: "main",
+				taskId: "",
+				tmuxSession: "tmux-coord",
+				state: "working",
+				pid: null,
+				parentAgent: null,
+				depth: 0,
+				runId,
+				startedAt: new Date().toISOString(),
+				lastActivity: new Date().toISOString(),
+				escalationLevel: 0,
+				stalledSince: null,
+				transcriptPath: null,
+			});
+			// worker session that is completed
+			store.upsert({
+				id: "worker",
+				agentName: "builder-1",
+				capability: "builder",
+				worktreePath: tempDir,
+				branchName: "feat/x",
+				taskId: "t1",
+				tmuxSession: "tmux-w",
+				state: "completed",
+				pid: null,
+				parentAgent: "coordinator",
+				depth: 1,
+				runId,
+				startedAt: new Date().toISOString(),
+				lastActivity: new Date().toISOString(),
+				escalationLevel: 0,
+				stalledSince: null,
+				transcriptPath: null,
+			});
+		} finally {
+			store.close();
+		}
+
+		const result = await checkComplete({ json: false });
+		expect(result.triggers.allAgentsDone.enabled).toBe(true);
+		// coordinator is filtered out; only the builder counts → all done
+		expect(result.triggers.allAgentsDone.met).toBe(true);
+		expect(result.complete).toBe(true);
+	});
+
+	test("onShutdownSignal met when shutdown mail exists", async () => {
+		await Bun.write(
+			join(overstoryDir, "config.yaml"),
+			[
+				"project:",
+				"  name: test-project",
+				`  root: ${tempDir}`,
+				"  canonicalBranch: main",
+				"coordinator:",
+				"  exitTriggers:",
+				"    allAgentsDone: false",
+				"    taskTrackerEmpty: false",
+				"    onShutdownSignal: true",
+			].join("\n"),
+		);
+
+		// Insert a shutdown message into mail.db
+		const mailStore = createMailStore(join(overstoryDir, "mail.db"));
+		try {
+			mailStore.insert({
+				id: "",
+				from: "greenhouse",
+				to: "coordinator",
+				subject: "shutdown",
+				body: "All work done, please shutdown",
+				type: "status",
+				priority: "normal",
+				threadId: null,
+				payload: null,
+			});
+		} finally {
+			mailStore.close();
+		}
+
+		const result = await checkComplete({ json: false });
+		expect(result.triggers.onShutdownSignal.enabled).toBe(true);
+		expect(result.triggers.onShutdownSignal.met).toBe(true);
+		expect(result.complete).toBe(true);
+	});
+
+	test("overall complete false when only one of two enabled triggers is met", async () => {
+		// Enable allAgentsDone + onShutdownSignal; satisfy only onShutdownSignal
+		await Bun.write(
+			join(overstoryDir, "config.yaml"),
+			[
+				"project:",
+				"  name: test-project",
+				`  root: ${tempDir}`,
+				"  canonicalBranch: main",
+				"coordinator:",
+				"  exitTriggers:",
+				"    allAgentsDone: true",
+				"    taskTrackerEmpty: false",
+				"    onShutdownSignal: true",
+			].join("\n"),
+		);
+
+		// Write current-run.txt but no sessions → allAgentsDone not met (empty run)
+		const runId = `run-${Date.now()}`;
+		await Bun.write(join(overstoryDir, "current-run.txt"), runId);
+		// Sessions DB will be created empty — no agents → allAgentsDone.met = false (length === 0)
+
+		// Insert shutdown mail so onShutdownSignal is met
+		const mailStore = createMailStore(join(overstoryDir, "mail.db"));
+		try {
+			mailStore.insert({
+				id: "",
+				from: "operator",
+				to: "coordinator",
+				subject: "shutdown now",
+				body: "Please shutdown",
+				type: "status",
+				priority: "normal",
+				threadId: null,
+				payload: null,
+			});
+		} finally {
+			mailStore.close();
+		}
+
+		const result = await checkComplete({ json: false });
+		expect(result.triggers.allAgentsDone.enabled).toBe(true);
+		expect(result.triggers.allAgentsDone.met).toBe(false);
+		expect(result.triggers.onShutdownSignal.enabled).toBe(true);
+		expect(result.triggers.onShutdownSignal.met).toBe(true);
+		// Both must be met → false
+		expect(result.complete).toBe(false);
+	});
+
+	test("allAgentsDone false when merge queue has pending branches", async () => {
+		await Bun.write(
+			join(overstoryDir, "config.yaml"),
+			[
+				"project:",
+				"  name: test-project",
+				`  root: ${tempDir}`,
+				"  canonicalBranch: main",
+				"coordinator:",
+				"  exitTriggers:",
+				"    allAgentsDone: true",
+				"    taskTrackerEmpty: false",
+				"    onShutdownSignal: false",
+			].join("\n"),
+		);
+
+		const runId = `run-${Date.now()}`;
+		await Bun.write(join(overstoryDir, "current-run.txt"), runId);
+
+		// All agent sessions completed
+		const store = createSessionStore(join(overstoryDir, "sessions.db"));
+		try {
+			store.upsert({
+				id: "s1",
+				agentName: "lead-1",
+				capability: "lead",
+				worktreePath: tempDir,
+				branchName: "overstory/lead-1/task-1",
+				taskId: "task-1",
+				tmuxSession: "tmux-1",
+				state: "completed",
+				pid: null,
+				parentAgent: "coordinator",
+				depth: 1,
+				runId,
+				startedAt: new Date().toISOString(),
+				lastActivity: new Date().toISOString(),
+				escalationLevel: 0,
+				stalledSince: null,
+				transcriptPath: null,
+			});
+		} finally {
+			store.close();
+		}
+
+		// Merge queue has a pending entry — lead branch not yet merged
+		const { createMergeQueue } = await import("../merge/queue.ts");
+		const queue = createMergeQueue(join(overstoryDir, "merge-queue.db"));
+		try {
+			queue.enqueue({
+				branchName: "overstory/lead-1/task-1",
+				taskId: "task-1",
+				agentName: "lead-1",
+				filesModified: ["src/foo.ts"],
+			});
+		} finally {
+			queue.close();
+		}
+
+		const result = await checkComplete({ json: false });
+		expect(result.triggers.allAgentsDone.enabled).toBe(true);
+		expect(result.triggers.allAgentsDone.met).toBe(false);
+		expect(result.triggers.allAgentsDone.detail).toInclude("pending merge");
+		expect(result.triggers.allAgentsDone.detail).toInclude("overstory/lead-1/task-1");
+		expect(result.complete).toBe(false);
+	});
+
+	test("allAgentsDone true when all agents completed and merge queue is empty", async () => {
+		await Bun.write(
+			join(overstoryDir, "config.yaml"),
+			[
+				"project:",
+				"  name: test-project",
+				`  root: ${tempDir}`,
+				"  canonicalBranch: main",
+				"coordinator:",
+				"  exitTriggers:",
+				"    allAgentsDone: true",
+				"    taskTrackerEmpty: false",
+				"    onShutdownSignal: false",
+			].join("\n"),
+		);
+
+		const runId = `run-${Date.now()}`;
+		await Bun.write(join(overstoryDir, "current-run.txt"), runId);
+
+		const store = createSessionStore(join(overstoryDir, "sessions.db"));
+		try {
+			store.upsert({
+				id: "s1",
+				agentName: "lead-1",
+				capability: "lead",
+				worktreePath: tempDir,
+				branchName: "overstory/lead-1/task-1",
+				taskId: "task-1",
+				tmuxSession: "tmux-1",
+				state: "completed",
+				pid: null,
+				parentAgent: "coordinator",
+				depth: 1,
+				runId,
+				startedAt: new Date().toISOString(),
+				lastActivity: new Date().toISOString(),
+				escalationLevel: 0,
+				stalledSince: null,
+				transcriptPath: null,
+			});
+		} finally {
+			store.close();
+		}
+
+		// Merge queue exists but all entries are already merged (no pending)
+		const { createMergeQueue } = await import("../merge/queue.ts");
+		const queue = createMergeQueue(join(overstoryDir, "merge-queue.db"));
+		try {
+			const entry = queue.enqueue({
+				branchName: "overstory/lead-1/task-1",
+				taskId: "task-1",
+				agentName: "lead-1",
+				filesModified: ["src/foo.ts"],
+			});
+			queue.updateStatus(entry.branchName, "merged", "clean-merge");
+		} finally {
+			queue.close();
+		}
+
+		const result = await checkComplete({ json: false });
+		expect(result.triggers.allAgentsDone.enabled).toBe(true);
+		expect(result.triggers.allAgentsDone.met).toBe(true);
+		expect(result.complete).toBe(true);
+	});
+
+	test("command registration — createCoordinatorCommand has check-complete subcommand", () => {
+		const cmd = createCoordinatorCommand({});
+		const subcommandNames = cmd.commands.map((c) => c.name());
+		expect(subcommandNames).toContain("check-complete");
+	});
+});

package/src/commands/coordinator.ts

@@ -25,7 +25,7 @@ import { createMailClient } from "../mail/client.ts";
 import { createMailStore } from "../mail/store.ts";
 import { getRuntime } from "../runtimes/registry.ts";
 import { openSessionStore } from "../sessions/compat.ts";
-import { createRunStore } from "../sessions/store.ts";
+import { createRunStore, createSessionStore } from "../sessions/store.ts";
 import { resolveBackend, trackerCliName } from "../tracker/factory.ts";
 import type { AgentSession } from "../types.ts";
 import { isProcessRunning } from "../watchdog/health.ts";
@@ -1054,6 +1054,170 @@ async function outputCoordinator(
 	}
 }
 
+/** Per-trigger evaluation result for checkComplete. */
+export interface TriggerResult {
+	enabled: boolean;
+	met: boolean;
+	detail: string;
+}
+
+/** Result of `ov coordinator check-complete`. */
+export interface CheckCompleteResult {
+	complete: boolean;
+	triggers: {
+		allAgentsDone: TriggerResult;
+		taskTrackerEmpty: TriggerResult;
+		onShutdownSignal: TriggerResult;
+	};
+}
+
+/**
+ * Evaluate configured exit triggers and return per-trigger status.
+ *
+ * Logic:
+ * - complete = true only if ALL enabled triggers are met
+ * - No enabled triggers → complete: false (safety default)
+ */
+export async function checkComplete(
+	opts: { json: boolean },
+	deps?: CoordinatorDeps,
+): Promise<CheckCompleteResult> {
+	void deps; // reserved for future DI
+
+	const config = await loadConfig(process.cwd());
+	const triggers = config.coordinator?.exitTriggers ?? {
+		allAgentsDone: false,
+		taskTrackerEmpty: false,
+		onShutdownSignal: false,
+	};
+
+	const result: CheckCompleteResult = {
+		complete: false,
+		triggers: {
+			allAgentsDone: { enabled: triggers.allAgentsDone, met: false, detail: "" },
+			taskTrackerEmpty: { enabled: triggers.taskTrackerEmpty, met: false, detail: "" },
+			onShutdownSignal: { enabled: triggers.onShutdownSignal, met: false, detail: "" },
+		},
+	};
+
+	// allAgentsDone: read current-run.txt, query SessionStore
+	if (triggers.allAgentsDone) {
+		const runIdPath = join(config.project.root, ".overstory", "current-run.txt");
+		const runIdFile = Bun.file(runIdPath);
+		if (await runIdFile.exists()) {
+			const runId = (await runIdFile.text()).trim();
+			const sessionsDb = join(config.project.root, ".overstory", "sessions.db");
+			const store = createSessionStore(sessionsDb);
+			try {
+				const sessions = store.getByRun(runId);
+				const agentSessions = sessions.filter((s) => s.capability !== "coordinator");
+				let allDone =
+					agentSessions.length > 0 && agentSessions.every((s) => s.state === "completed");
+				const states = agentSessions.map((s) => `${s.agentName}:${s.state}`);
+
+				// Also check the merge queue — agents may be "completed" but branches
+				// not yet merged. This prevents premature issue closure when a builder
+				// finishes but its lead hasn't merged yet (overstory-5c08).
+				if (allDone) {
+					const mergeQueuePath = join(config.project.root, ".overstory", "merge-queue.db");
+					const mergeQueueFile = Bun.file(mergeQueuePath);
+					if (await mergeQueueFile.exists()) {
+						const { createMergeQueue } = await import("../merge/queue.ts");
+						const queue = createMergeQueue(mergeQueuePath);
+						try {
+							const pending = queue.list("pending");
+							if (pending.length > 0) {
+								allDone = false;
+								result.triggers.allAgentsDone.detail = `${pending.length} branch(es) pending merge: ${pending.map((e) => e.branchName).join(", ")}`;
+							}
+						} finally {
+							queue.close();
+						}
+					}
+				}
+
+				result.triggers.allAgentsDone.met = allDone;
+				if (result.triggers.allAgentsDone.detail === "") {
+					result.triggers.allAgentsDone.detail = allDone
+						? `All ${agentSessions.length} agents completed`
+						: states.join(", ");
+				}
+			} finally {
+				store.close();
+			}
+		} else {
+			result.triggers.allAgentsDone.detail = "No current run found";
+		}
+	}
+
+	// taskTrackerEmpty: shell out to tracker CLI
+	if (triggers.taskTrackerEmpty) {
+		try {
+			const backend = await resolveBackend(config.taskTracker.backend, config.project.root);
+			const cliName = trackerCliName(backend);
+			const proc = Bun.spawn([cliName, "ready", "--json"], {
+				cwd: config.project.root,
+				stdout: "pipe",
+				stderr: "pipe",
+			});
+			const exitCode = await proc.exited;
+			const stdout = await new Response(proc.stdout).text();
+			if (exitCode === 0) {
+				try {
+					const issues = JSON.parse(stdout.trim()) as unknown;
+					const isEmpty = Array.isArray(issues) && issues.length === 0;
+					result.triggers.taskTrackerEmpty.met = isEmpty;
+					result.triggers.taskTrackerEmpty.detail = isEmpty
+						? "No unblocked issues"
+						: `${(issues as unknown[]).length} unblocked issue(s)`;
+				} catch {
+					const isEmpty = stdout.trim() === "" || stdout.trim() === "[]";
+					result.triggers.taskTrackerEmpty.met = isEmpty;
+					result.triggers.taskTrackerEmpty.detail = isEmpty
+						? "No unblocked issues"
+						: "Issues found";
+				}
+			} else {
+				result.triggers.taskTrackerEmpty.detail = `Tracker command failed (exit ${exitCode})`;
+			}
+		} catch (err) {
+			result.triggers.taskTrackerEmpty.detail = `Tracker error: ${err instanceof Error ? err.message : String(err)}`;
+		}
+	}
+
+	// onShutdownSignal: check mail for shutdown messages to coordinator
+	if (triggers.onShutdownSignal) {
+		const mailDb = join(config.project.root, ".overstory", "mail.db");
+		const mailStore = createMailStore(mailDb);
+		try {
+			const unread = mailStore.getUnread("coordinator");
+			const shutdownMsg = unread.find((m) => m.subject.toLowerCase().includes("shutdown"));
+			result.triggers.onShutdownSignal.met = shutdownMsg !== undefined;
+			result.triggers.onShutdownSignal.detail = shutdownMsg
+				? `Shutdown signal from ${shutdownMsg.from}: ${shutdownMsg.subject}`
+				: "No shutdown signal received";
+		} finally {
+			mailStore.close();
+		}
+	}
+
+	// Overall: complete only if ALL enabled triggers are met
+	const enabledTriggers = Object.values(result.triggers).filter((t) => t.enabled);
+	result.complete = enabledTriggers.length > 0 && enabledTriggers.every((t) => t.met);
+
+	if (opts.json) {
+		jsonOutput("coordinator check-complete", result as unknown as Record<string, unknown>);
+	} else {
+		for (const [name, trigger] of Object.entries(result.triggers)) {
+			const status = !trigger.enabled ? "disabled" : trigger.met ? "MET" : "NOT MET";
+			process.stdout.write(`  ${name}: ${status} — ${trigger.detail}\n`);
+		}
+		process.stdout.write(`\nComplete: ${result.complete ? "YES" : "NO"}\n`);
+	}
+
+	return result;
+}
+
 /**
  * Create the Commander command for `ov coordinator`.
  */
@@ -1150,6 +1314,14 @@ export function createCoordinatorCommand(deps: CoordinatorDeps = {}): Command {
 			},
 		);
 
+	cmd
+		.command("check-complete")
+		.description("Evaluate exit triggers and report completion status")
+		.option("--json", "Output as JSON")
+		.action(async (opts: { json?: boolean }) => {
+			await checkComplete({ json: opts.json ?? false }, deps);
+		});
+
 	return cmd;
 }