@katyella/legio 0.1.3 → 0.2.2

package/src/watchdog/health.test.ts

@@ -1,371 +0,0 @@
-import { describe, expect, test } from "vitest";
-import type { AgentSession } from "../types.ts";
-import { evaluateHealth, isProcessRunning, transitionState } from "./health.ts";
-
-/**
- * Tests for the ZFC-based health evaluation and state machine.
- *
- * evaluateHealth is a pure function that takes session state + tmux liveness +
- * thresholds and returns a HealthCheck. No mocks needed for the core logic.
- *
- * isProcessRunning uses process.kill(pid, 0) which is safe to test with real PIDs:
- * the current process PID (alive) and a known-dead PID (not alive).
- *
- * Note: evaluateHealth calls isProcessRunning internally. For tests that need
- * to control pid liveness independently of the actual OS process table, we set
- * session.pid to known-alive (current process) or known-dead PIDs.
- */
-
-const THRESHOLDS = { zombieMs: 120_000 };
-
-/** PID that is guaranteed to be alive during tests: our own process. */
-const ALIVE_PID = process.pid;
-
-/**
- * PID that is very likely dead. PID 2147483647 (max 32-bit signed int) is
- * almost never in use. If by some miracle it is, the test still works because
- * we use it only for the "pid dead" path and the test validates behavior, not
- * the exact PID value.
- */
-const DEAD_PID = 2147483647;
-
-function makeSession(overrides: Partial<AgentSession> = {}): AgentSession {
-	return {
-		id: "session-test",
-		agentName: "test-agent",
-		capability: "builder",
-		worktreePath: "/tmp/test",
-		branchName: "legio/test-agent/test-task",
-		beadId: "test-task",
-		tmuxSession: "legio-test-agent",
-		state: "booting",
-		pid: ALIVE_PID,
-		parentAgent: null,
-		depth: 0,
-		runId: null,
-		startedAt: new Date().toISOString(),
-		lastActivity: new Date().toISOString(),
-		escalationLevel: 0,
-		stalledSince: null,
-		...overrides,
-	};
-}
-
-// === isProcessRunning ===
-
-describe("isProcessRunning", () => {
-	test("returns true for the current process PID", () => {
-		expect(isProcessRunning(process.pid)).toBe(true);
-	});
-
-	test("returns false for a PID that does not exist", () => {
-		// PID 2147483647 is max 32-bit signed — extremely unlikely to be alive
-		expect(isProcessRunning(DEAD_PID)).toBe(false);
-	});
-});
-
-// === evaluateHealth ===
-
-describe("evaluateHealth", () => {
-	// --- ZFC Rule 1: tmux dead → zombie (observable state wins) ---
-
-	test("ZFC: tmux dead + sessions.json says working → zombie with reconciliation note", () => {
-		const session = makeSession({ state: "working" });
-		const check = evaluateHealth(session, false, THRESHOLDS);
-
-		expect(check.state).toBe("zombie");
-		expect(check.action).toBe("terminate");
-		expect(check.tmuxAlive).toBe(false);
-		expect(check.processAlive).toBe(false);
-		expect(check.reconciliationNote).toContain("ZFC");
-		expect(check.reconciliationNote).toContain("tmux dead");
-		expect(check.reconciliationNote).toContain('"working"');
-	});
-
-	test("ZFC: tmux dead + sessions.json says booting → zombie with reconciliation note", () => {
-		const session = makeSession({ state: "booting" });
-		const check = evaluateHealth(session, false, THRESHOLDS);
-
-		expect(check.state).toBe("zombie");
-		expect(check.action).toBe("terminate");
-		expect(check.reconciliationNote).toContain("ZFC");
-		expect(check.reconciliationNote).toContain('"booting"');
-	});
-
-	// --- ZFC Rule 2: tmux alive + sessions.json says zombie → investigate ---
-
-	test("ZFC: tmux alive + sessions.json says zombie → investigate (don't auto-kill)", () => {
-		const session = makeSession({ state: "zombie", pid: ALIVE_PID });
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.state).toBe("zombie");
-		expect(check.action).toBe("investigate");
-		expect(check.processAlive).toBe(true);
-		expect(check.reconciliationNote).toContain("ZFC");
-		expect(check.reconciliationNote).toContain("investigation needed");
-		expect(check.reconciliationNote).toContain("don't auto-kill");
-	});
-
-	// --- ZFC Rule 3: pid dead + tmux alive → zombie ---
-
-	test("ZFC: pid dead + tmux alive → zombie (agent process exited, shell survived)", () => {
-		const session = makeSession({ state: "working", pid: DEAD_PID });
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.state).toBe("zombie");
-		expect(check.action).toBe("terminate");
-		expect(check.processAlive).toBe(false);
-		expect(check.pidAlive).toBe(false);
-		expect(check.tmuxAlive).toBe(true);
-		expect(check.reconciliationNote).toContain("ZFC");
-		expect(check.reconciliationNote).toContain("pid");
-		expect(check.reconciliationNote).toContain("shell survived");
-	});
-
-	// --- pid null (unavailable) ---
-
-	test("pid null does not trigger pid-based zombie detection", () => {
-		const session = makeSession({ state: "working", pid: null });
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.state).toBe("working");
-		expect(check.action).toBe("none");
-		expect(check.pidAlive).toBeNull();
-	});
-
-	// --- Time-based checks (both tmux and pid alive) ---
-
-	test("activity older than zombieMs → zombie", () => {
-		const oldActivity = new Date(Date.now() - 200_000).toISOString();
-		const session = makeSession({ state: "working", lastActivity: oldActivity });
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.state).toBe("zombie");
-		expect(check.action).toBe("terminate");
-		expect(check.reconciliationNote).toBeNull();
-	});
-
-	// --- Normal state transitions ---
-
-	test("booting with recent activity → transitions to working", () => {
-		const recentActivity = new Date(Date.now() - 5_000).toISOString();
-		const session = makeSession({ state: "booting", lastActivity: recentActivity });
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.state).toBe("working");
-		expect(check.action).toBe("none");
-		expect(check.reconciliationNote).toBeNull();
-	});
-
-	test("working with recent activity → stays working", () => {
-		const recentActivity = new Date(Date.now() - 5_000).toISOString();
-		const session = makeSession({ state: "working", lastActivity: recentActivity });
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.state).toBe("working");
-		expect(check.action).toBe("none");
-	});
-
-	// --- Persistent capabilities (coordinator, monitor) ---
-
-	test("persistent capability: coordinator with stale activity → still working, no escalation", () => {
-		const staleActivity = new Date(Date.now() - 60_000).toISOString();
-		const session = makeSession({
-			capability: "coordinator",
-			state: "working",
-			lastActivity: staleActivity,
-		});
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.state).toBe("working");
-		expect(check.action).toBe("none");
-	});
-
-	test("persistent capability: coordinator with zombie-level staleness → still working", () => {
-		const oldActivity = new Date(Date.now() - 200_000).toISOString();
-		const session = makeSession({
-			capability: "coordinator",
-			state: "working",
-			lastActivity: oldActivity,
-		});
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.state).toBe("working");
-		expect(check.action).toBe("none");
-	});
-
-	test("persistent capability: monitor with stale activity → still working", () => {
-		const staleActivity = new Date(Date.now() - 60_000).toISOString();
-		const session = makeSession({
-			capability: "monitor",
-			state: "working",
-			lastActivity: staleActivity,
-		});
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.state).toBe("working");
-		expect(check.action).toBe("none");
-	});
-
-	test("persistent capability: gateway with stale activity → still working", () => {
-		const staleActivity = new Date(Date.now() - 60_000).toISOString();
-		const session = makeSession({
-			capability: "gateway",
-			state: "working",
-			lastActivity: staleActivity,
-		});
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.state).toBe("working");
-		expect(check.action).toBe("none");
-	});
-
-	test("persistent capability: coordinator booting → transitions to working", () => {
-		const session = makeSession({
-			capability: "coordinator",
-			state: "booting",
-		});
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.state).toBe("working");
-		expect(check.action).toBe("none");
-	});
-
-	test("persistent capability: coordinator with tmux dead → still zombie (ZFC Rule 1 applies)", () => {
-		const session = makeSession({
-			capability: "coordinator",
-			state: "working",
-		});
-		const check = evaluateHealth(session, false, THRESHOLDS);
-
-		expect(check.state).toBe("zombie");
-		expect(check.action).toBe("terminate");
-	});
-
-	test("persistent capability: coordinator with pid dead → still zombie (ZFC Rule 3 applies)", () => {
-		const session = makeSession({
-			capability: "coordinator",
-			state: "working",
-			pid: DEAD_PID,
-		});
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.state).toBe("zombie");
-		expect(check.action).toBe("terminate");
-	});
-
-	// --- Completed agents ---
-
-	test("completed agents skip monitoring", () => {
-		const session = makeSession({ state: "completed" });
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.state).toBe("completed");
-		expect(check.action).toBe("none");
-		expect(check.reconciliationNote).toBeNull();
-	});
-
-	// --- pidAlive field is populated ---
-
-	test("pidAlive reflects actual process state for alive PID", () => {
-		const session = makeSession({ pid: ALIVE_PID, state: "working" });
-		const check = evaluateHealth(session, true, THRESHOLDS);
-
-		expect(check.pidAlive).toBe(true);
-	});
-
-	test("pidAlive reflects actual process state for dead PID", () => {
-		// Use dead pid but also tmux dead to avoid pid-zombie path intercepting
-		const session = makeSession({ pid: DEAD_PID, state: "working" });
-		const check = evaluateHealth(session, false, THRESHOLDS);
-
-		// tmux dead takes priority, so state is zombie via ZFC Rule 1
-		expect(check.state).toBe("zombie");
-		expect(check.pidAlive).toBe(false);
-	});
-});
-
-// === transitionState ===
-
-describe("transitionState", () => {
-	test("advances from booting to working", () => {
-		const check = {
-			state: "working" as const,
-			agentName: "a",
-			timestamp: "",
-			tmuxAlive: true,
-			pidAlive: true as boolean | null,
-			lastActivity: "",
-			processAlive: true,
-			action: "none" as const,
-			reconciliationNote: null,
-		};
-		expect(transitionState("booting", check)).toBe("working");
-	});
-
-	test("never regresses from zombie to booting", () => {
-		const check = {
-			state: "booting" as const,
-			agentName: "a",
-			timestamp: "",
-			tmuxAlive: true,
-			pidAlive: true as boolean | null,
-			lastActivity: "",
-			processAlive: true,
-			action: "none" as const,
-			reconciliationNote: null,
-		};
-		expect(transitionState("zombie", check)).toBe("zombie");
-	});
-
-	test("same state stays the same", () => {
-		const check = {
-			state: "working" as const,
-			agentName: "a",
-			timestamp: "",
-			tmuxAlive: true,
-			pidAlive: true as boolean | null,
-			lastActivity: "",
-			processAlive: true,
-			action: "none" as const,
-			reconciliationNote: null,
-		};
-		expect(transitionState("working", check)).toBe("working");
-	});
-
-	// --- ZFC: investigate holds state ---
-
-	test("ZFC: investigate action holds current state (does not advance)", () => {
-		const check = {
-			state: "zombie" as const,
-			agentName: "a",
-			timestamp: "",
-			tmuxAlive: true,
-			pidAlive: true as boolean | null,
-			lastActivity: "",
-			processAlive: true,
-			action: "investigate" as const,
-			reconciliationNote: "ZFC: tmux alive but sessions.json says zombie",
-		};
-		// Even though check.state is zombie (order 4) and current is zombie (order 4),
-		// investigate should hold — not advance
-		expect(transitionState("zombie", check)).toBe("zombie");
-	});
-
-	test("ZFC: investigate prevents forward transition", () => {
-		const check = {
-			state: "zombie" as const,
-			agentName: "a",
-			timestamp: "",
-			tmuxAlive: true,
-			pidAlive: true as boolean | null,
-			lastActivity: "",
-			processAlive: true,
-			action: "investigate" as const,
-			reconciliationNote: "ZFC conflict",
-		};
-		// If something were at "working" and check says zombie with investigate,
-		// the state should NOT advance
-		expect(transitionState("working", check)).toBe("working");
-	});
-});

package/src/watchdog/triage.test.ts

@@ -1,162 +0,0 @@
-/**
- * Tests for Tier 1 AI-assisted triage.
- * classifyResponse and buildTriagePrompt are pure functions — tested directly.
- * triageAgent uses real filesystem (temp dirs). Claude spawn is expected to
- * fail in test environments, exercising the fallback-to-extend path.
- * spawnClaude is NOT mocked — we rely on it failing naturally in tests.
- */
-
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import { buildTriagePrompt, classifyResponse, triageAgent } from "./triage.ts";
-
-describe("classifyResponse", () => {
-	test("returns 'retry' when response contains 'retry'", () => {
-		const result = classifyResponse("The operation should retry.");
-		expect(result).toBe("retry");
-	});
-
-	test("returns 'retry' when response contains 'recoverable'", () => {
-		const result = classifyResponse("This error is recoverable.");
-		expect(result).toBe("retry");
-	});
-
-	test("returns 'terminate' when response contains 'terminate'", () => {
-		const result = classifyResponse("You should terminate the agent.");
-		expect(result).toBe("terminate");
-	});
-
-	test("returns 'terminate' when response contains 'fatal'", () => {
-		const result = classifyResponse("This is a fatal error.");
-		expect(result).toBe("terminate");
-	});
-
-	test("returns 'terminate' when response contains 'failed'", () => {
-		const result = classifyResponse("The operation has failed.");
-		expect(result).toBe("terminate");
-	});
-
-	test("handles mixed case (e.g., 'RETRY', 'Fatal')", () => {
-		expect(classifyResponse("RETRY this operation")).toBe("retry");
-		expect(classifyResponse("Fatal error occurred")).toBe("terminate");
-		expect(classifyResponse("RecOverAble issue")).toBe("retry");
-	});
-
-	test("returns 'extend' when response contains none of the keywords", () => {
-		const result = classifyResponse("The agent is processing data.");
-		expect(result).toBe("extend");
-	});
-
-	test("returns 'extend' for empty string", () => {
-		const result = classifyResponse("");
-		expect(result).toBe("extend");
-	});
-
-	test("first match wins when response has multiple keywords", () => {
-		// 'retry' is checked before 'terminate'
-		const result = classifyResponse("retry this but it may terminate later");
-		expect(result).toBe("retry");
-	});
-});
-
-describe("buildTriagePrompt", () => {
-	test("contains agent name in output", () => {
-		const prompt = buildTriagePrompt("test-agent", "2026-02-13T10:00:00Z", "log content");
-		expect(prompt).toContain("test-agent");
-	});
-
-	test("contains lastActivity timestamp in output", () => {
-		const timestamp = "2026-02-13T10:00:00Z";
-		const prompt = buildTriagePrompt("test-agent", timestamp, "log content");
-		expect(prompt).toContain(timestamp);
-	});
-
-	test("contains log content wrapped in code fences", () => {
-		const logContent = "Error: something went wrong\nat line 42";
-		const prompt = buildTriagePrompt("test-agent", "2026-02-13T10:00:00Z", logContent);
-		expect(prompt).toContain("```");
-		expect(prompt).toContain(logContent);
-		expect(prompt.split("```").length).toBeGreaterThanOrEqual(3); // Opening and closing fences
-	});
-
-	test("contains classification instructions (retry/terminate/extend)", () => {
-		const prompt = buildTriagePrompt("test-agent", "2026-02-13T10:00:00Z", "log content");
-		expect(prompt).toContain("retry");
-		expect(prompt).toContain("terminate");
-		expect(prompt).toContain("extend");
-	});
-});
-
-describe("triageAgent", () => {
-	let tempRoot: string;
-
-	beforeEach(async () => {
-		tempRoot = await mkdtemp(join(tmpdir(), "triage-test-"));
-	});
-
-	afterEach(async () => {
-		await rm(tempRoot, { recursive: true, force: true });
-	});
-
-	test("returns 'extend' when no logs directory exists", async () => {
-		const result = await triageAgent({
-			agentName: "test-agent",
-			root: tempRoot,
-			lastActivity: "2026-02-13T10:00:00Z",
-		});
-		expect(result).toBe("extend");
-	});
-
-	test("returns 'extend' when logs directory exists but is empty", async () => {
-		const logsDir = join(tempRoot, ".legio", "logs", "test-agent");
-		await mkdir(logsDir, { recursive: true });
-
-		const result = await triageAgent({
-			agentName: "test-agent",
-			root: tempRoot,
-			lastActivity: "2026-02-13T10:00:00Z",
-		});
-		expect(result).toBe("extend");
-	});
-
-	test("returns 'extend' when logs directory has session dir but no session.log", async () => {
-		const logsDir = join(tempRoot, ".legio", "logs", "test-agent", "2026-02-13T10-00-00");
-		await mkdir(logsDir, { recursive: true });
-		await writeFile(join(logsDir, ".gitkeep"), "", "utf-8");
-
-		const result = await triageAgent({
-			agentName: "test-agent",
-			root: tempRoot,
-			lastActivity: "2026-02-13T10:00:00Z",
-		});
-		expect(result).toBe("extend");
-	});
-
-	test("returns 'extend' when session.log exists but claude binary fails", async () => {
-		const timestamp = "2026-02-13T10-00-00";
-		const sessionLogDir = join(tempRoot, ".legio", "logs", "test-agent", timestamp);
-		const sessionLogPath = join(sessionLogDir, "session.log");
-
-		await mkdir(sessionLogDir, { recursive: true });
-
-		// Create session.log with some content
-		await writeFile(
-			sessionLogPath,
-			"Agent started\nProcessing data\nError: something went wrong\n",
-			"utf-8",
-		);
-
-		// triageAgent will try to spawn claude which should fail or be killed by timeout.
-		// Short timeout ensures the test doesn't hang even if the claude binary
-		// exists on the system (e.g., inside a Claude Code session).
-		const result = await triageAgent({
-			agentName: "test-agent",
-			root: tempRoot,
-			lastActivity: "2026-02-13T10:00:00Z",
-			timeoutMs: 500,
-		});
-		expect(result).toBe("extend");
-	});
-});