@katyella/legio 0.1.3 → 0.2.2

package/src/doctor/merge-queue.test.ts

@@ -24,16 +24,20 @@ describe("checkMergeQueue", () => {
 				maxDepth: 2,
 			},
 			worktrees: { baseDir: "" },
-			beads: { enabled: true },
+			taskTracker: { backend: "auto" as const, enabled: true },
 			mulch: { enabled: true, domains: [], primeFormat: "markdown" },
 			merge: { aiResolveEnabled: false, reimagineEnabled: false },
-			watchdog: {
+			watchman: {
 				tier0Enabled: true,
 				tier0IntervalMs: 30000,
 				tier1Enabled: false,
 				tier2Enabled: false,
 				zombieThresholdMs: 600000,
 				nudgeIntervalMs: 60000,
+				mailIntervalMs: 5_000,
+				reNudgeIntervalMs: 10_000,
+				warnAfterMs: 60_000,
+				beaconNudgeMs: 20_000,
 			},
 			models: {},
 			logging: { verbose: false, redactSecrets: true },

package/src/doctor/structure.test.ts

@@ -37,7 +37,8 @@ describe("checkStructure", () => {
 			worktrees: {
 				baseDir: ".legio/worktrees",
 			},
-			beads: {
+			taskTracker: {
+				backend: "auto" as const,
 				enabled: true,
 			},
 			mulch: {
@@ -49,13 +50,17 @@ describe("checkStructure", () => {
 				aiResolveEnabled: false,
 				reimagineEnabled: false,
 			},
-			watchdog: {
+			watchman: {
 				tier0Enabled: true,
 				tier0IntervalMs: 30000,
 				tier1Enabled: false,
 				tier2Enabled: false,
 				zombieThresholdMs: 600000,
 				nudgeIntervalMs: 60000,
+				mailIntervalMs: 5_000,
+				reNudgeIntervalMs: 10_000,
+				warnAfterMs: 60_000,
+				beaconNudgeMs: 20_000,
 			},
 			models: {},
 			logging: {

package/src/doctor/version.test.ts

@@ -19,7 +19,8 @@ const mockConfig: LegioConfig = {
 	worktrees: {
 		baseDir: "/tmp/.legio/worktrees",
 	},
-	beads: {
+	taskTracker: {
+		backend: "auto" as const,
 		enabled: false,
 	},
 	mulch: {
@@ -31,13 +32,17 @@ const mockConfig: LegioConfig = {
 		aiResolveEnabled: false,
 		reimagineEnabled: false,
 	},
-	watchdog: {
+	watchman: {
 		tier0Enabled: false,
 		tier0IntervalMs: 30000,
 		tier1Enabled: false,
 		tier2Enabled: false,
 		zombieThresholdMs: 600000,
 		nudgeIntervalMs: 60000,
+		mailIntervalMs: 5_000,
+		reNudgeIntervalMs: 10_000,
+		warnAfterMs: 60_000,
+		beaconNudgeMs: 20_000,
 	},
 	models: {},
 	logging: {

package/src/e2e/init-sling-lifecycle.test.ts

@@ -1,6 +1,6 @@
 import { access, readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 
 /** Test helper: check whether a file exists using Node.js fs/promises. */
 async function fileExists(path: string): Promise<boolean> {
@@ -48,13 +48,11 @@ const EXPECTED_AGENT_DEFS = [
 
 describe("E2E: init→sling lifecycle on external project", () => {
 	let tempDir: string;
-	let originalCwd: string;
 	let originalWrite: typeof process.stdout.write;
 
 	beforeEach(async () => {
 		tempDir = await createTempGitRepo();
-		originalCwd = process.cwd();
-		process.chdir(tempDir);
+		vi.spyOn(process, "cwd").mockReturnValue(tempDir);
 
 		// Suppress stdout noise from initCommand
 		originalWrite = process.stdout.write;
@@ -62,7 +60,6 @@ describe("E2E: init→sling lifecycle on external project", () => {
 	});
 
 	afterEach(async () => {
-		process.chdir(originalCwd);
 		process.stdout.write = originalWrite;
 		await cleanupTempDir(tempDir);
 	});

package/src/index.ts

@@ -40,12 +40,12 @@ import { stopCommand } from "./commands/stop.ts";
 import { supervisorCommand } from "./commands/supervisor.ts";
 import { traceCommand } from "./commands/trace.ts";
 import { upCommand } from "./commands/up.ts";
-import { watchCommand } from "./commands/watch.ts";
+import { watchmanCommand } from "./commands/watchman.ts";
 import { worktreeCommand } from "./commands/worktree.ts";
 import { LegioError, WorktreeError } from "./errors.ts";
 import { setQuiet } from "./logging/color.ts";
 
-const VERSION = "0.1.3";
+const VERSION = "0.2.2";
 
 const HELP = `legio v${VERSION} — Multi-agent orchestration for Claude Code
 
@@ -74,7 +74,7 @@ Commands:
   worktree <sub>          Manage worktrees (list/clean)
   log <event>             Log a hook event
   logs [options]          Query NDJSON logs across agents
-  watch                   Start watchdog daemon
+  watchman <sub>           Unified daemon — health + mail + beacon (start/stop/status)
   feed [options]          Unified real-time event stream across all agents
   trace <target>         Chronological event timeline for agent/bead
   errors [options]        Aggregated error view across agents
@@ -111,13 +111,13 @@ const COMMANDS = [
 	"hooks",
 	"monitor",
 	"mail",
+	"watchman",
 	"merge",
 	"nudge",
 	"group",
 	"worktree",
 	"log",
 	"logs",
-	"watch",
 	"trace",
 	"feed",
 	"errors",
@@ -251,6 +251,9 @@ async function main(): Promise<void> {
 		case "mail":
 			await mailCommand(commandArgs);
 			break;
+		case "watchman":
+			await watchmanCommand(commandArgs);
+			break;
 		case "merge":
 			await mergeCommand(commandArgs);
 			break;
@@ -269,9 +272,6 @@ async function main(): Promise<void> {
 		case "logs":
 			await logsCommand(commandArgs);
 			break;
-		case "watch":
-			await watchCommand(commandArgs);
-			break;
 		case "trace":
 			await traceCommand(commandArgs);
 			break;

package/src/mail/pending.ts

@@ -0,0 +1,120 @@
+/**
+ * Pending nudge marker utilities for inter-agent mail delivery.
+ *
+ * Instead of sending tmux keys (which corrupt tool I/O), auto-nudge writes
+ * a JSON marker file per agent. The `mail check --inject` flow reads and
+ * clears these markers, prepending a priority banner to the injected output.
+ *
+ * Extracted from src/commands/mail.ts for shared use by the watchman daemon.
+ */
+
+import { access, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+/** Shape of a pending nudge marker file. */
+export interface PendingNudge {
+	from: string;
+	reason: string;
+	subject: string;
+	messageId: string;
+	createdAt: string;
+}
+
+/** Directory where pending nudge markers are stored. */
+export function pendingNudgeDir(cwd: string): string {
+	return join(cwd, ".legio", "pending-nudges");
+}
+
+/**
+ * Write a pending nudge marker for an agent.
+ *
+ * Creates `.legio/pending-nudges/{agent}.json` so that the next
+ * `mail check --inject` call surfaces a priority banner for this message.
+ * Overwrites any existing marker (only the latest nudge matters).
+ */
+export async function writePendingNudge(
+	cwd: string,
+	agentName: string,
+	nudge: Omit<PendingNudge, "createdAt">,
+): Promise<void> {
+	const dir = pendingNudgeDir(cwd);
+	await mkdir(dir, { recursive: true });
+
+	const marker: PendingNudge = {
+		...nudge,
+		createdAt: new Date().toISOString(),
+	};
+	const filePath = join(dir, `${agentName}.json`);
+	const tmpPath = `${filePath}.tmp`;
+	await writeFile(tmpPath, `${JSON.stringify(marker, null, "\t")}\n`);
+	await rename(tmpPath, filePath);
+}
+
+/**
+ * Read and clear pending nudge markers for an agent.
+ *
+ * Returns the pending nudge (if any) and removes the marker file.
+ * Called by `mail check --inject` to prepend a priority banner.
+ */
+export async function readAndClearPendingNudge(
+	cwd: string,
+	agentName: string,
+): Promise<PendingNudge | null> {
+	const filePath = join(pendingNudgeDir(cwd), `${agentName}.json`);
+	try {
+		await access(filePath);
+	} catch {
+		return null;
+	}
+	try {
+		const text = await readFile(filePath, "utf-8");
+		const nudge = JSON.parse(text) as PendingNudge;
+		await unlink(filePath);
+		return nudge;
+	} catch {
+		// Corrupt or race condition — clear it and move on
+		try {
+			await unlink(filePath);
+		} catch {
+			// Already gone
+		}
+		return null;
+	}
+}
+
+/**
+ * Check if a pending nudge marker exists for an agent.
+ */
+export async function pendingNudgeExists(cwd: string, agentName: string): Promise<boolean> {
+	const filePath = join(pendingNudgeDir(cwd), `${agentName}.json`);
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Check if an agent is idle (not actively executing a tool).
+ *
+ * An agent is considered idle when `.legio/agent-busy/{agentName}` does NOT exist
+ * or when the marker is stale (older than 5 minutes, indicating a crashed agent).
+ * The busy marker contains an ISO timestamp written by hooks during active tool execution.
+ * Idle agents can receive a direct tmux nudge; busy agents only get the pending marker.
+ */
+export async function isAgentIdle(cwd: string, agentName: string): Promise<boolean> {
+	const busyPath = join(cwd, ".legio", "agent-busy", agentName);
+	try {
+		const timestamp = await readFile(busyPath, "utf-8");
+		const age = Date.now() - new Date(timestamp.trim()).getTime();
+		if (age > 5 * 60 * 1000) {
+			// Stale marker from crashed agent — clean up
+			await unlink(busyPath).catch(() => {});
+			return true;
+		}
+		return false; // busy marker present and fresh — agent is actively working
+	} catch {
+		return true; // no busy marker — agent is idle
+	}
+}

package/src/mail/store.test.ts

@@ -658,6 +658,95 @@ describe("createMailStore", () => {
 		});
 	});
 
+	describe("getAgentsWithUnread", () => {
+		test("returns empty array when no messages", () => {
+			const agents = store.getAgentsWithUnread();
+			expect(agents).toHaveLength(0);
+		});
+
+		test("returns empty array when all messages are read", () => {
+			const msg = store.insert({
+				id: "",
+				from: "agent-a",
+				to: "orchestrator",
+				subject: "test",
+				body: "body",
+				type: "status",
+				priority: "normal",
+				threadId: null,
+			});
+			store.markRead(msg.id);
+
+			const agents = store.getAgentsWithUnread();
+			expect(agents).toHaveLength(0);
+		});
+
+		test("returns distinct agent names with unread mail", () => {
+			store.insert({
+				id: "",
+				from: "agent-a",
+				to: "orchestrator",
+				subject: "msg1",
+				body: "body",
+				type: "status",
+				priority: "normal",
+				threadId: null,
+			});
+			store.insert({
+				id: "",
+				from: "agent-b",
+				to: "orchestrator",
+				subject: "msg2",
+				body: "body",
+				type: "status",
+				priority: "normal",
+				threadId: null,
+			});
+			store.insert({
+				id: "",
+				from: "agent-a",
+				to: "builder-1",
+				subject: "msg3",
+				body: "body",
+				type: "status",
+				priority: "normal",
+				threadId: null,
+			});
+
+			const agents = store.getAgentsWithUnread();
+			expect(agents).toHaveLength(2);
+			expect(agents.sort()).toEqual(["builder-1", "orchestrator"]);
+		});
+
+		test("does not include agents whose mail is all read", () => {
+			const msg1 = store.insert({
+				id: "",
+				from: "agent-a",
+				to: "orchestrator",
+				subject: "msg1",
+				body: "body",
+				type: "status",
+				priority: "normal",
+				threadId: null,
+			});
+			store.insert({
+				id: "",
+				from: "agent-a",
+				to: "builder-1",
+				subject: "msg2",
+				body: "body",
+				type: "status",
+				priority: "normal",
+				threadId: null,
+			});
+			store.markRead(msg1.id);
+
+			const agents = store.getAgentsWithUnread();
+			expect(agents).toHaveLength(1);
+			expect(agents[0]).toBe("builder-1");
+		});
+	});
+
 	describe("audience column", () => {
 		test("defaults audience to agent when not provided", () => {
 			const msg = store.insert({

package/src/mail/store.ts

@@ -28,6 +28,8 @@ export interface MailStore {
 	getById(id: string): MailMessage | null;
 	getByThread(threadId: string): MailMessage[];
 	markRead(id: string): void;
+	/** Get distinct agent names that have unread messages. */
+	getAgentsWithUnread(): string[];
 	/** Delete messages matching the given criteria. Returns the number of messages deleted. */
 	purge(options: { all?: boolean; olderThanMs?: number; agent?: string }): number;
 	close(): void;
@@ -243,6 +245,10 @@ export function createMailStore(dbPath: string): MailStore {
 		UPDATE messages SET read = 1 WHERE id = $id
 	`);
 
+	const getAgentsWithUnreadStmt = db.prepare(`
+		SELECT DISTINCT to_agent FROM messages WHERE read = 0
+	`);
+
 	// Dynamic filter queries are built at call time since the WHERE clause varies
 	function buildFilterQuery(filters?: {
 		from?: string;
@@ -348,6 +354,11 @@ export function createMailStore(dbPath: string): MailStore {
 			markReadStmt.run({ id });
 		},
 
+		getAgentsWithUnread(): string[] {
+			const rows = getAgentsWithUnreadStmt.all() as Array<{ to_agent: string }>;
+			return rows.map((r) => r.to_agent);
+		},
+
 		purge(options: { all?: boolean; olderThanMs?: number; agent?: string }): number {
 			// Count matching rows before deletion so we can report accurate numbers
 			if (options.all) {