@herdctl/core 0.0.1 → 0.0.2

package/src/fleet-manager/__tests__/integration.test.ts

@@ -1,1209 +0,0 @@
-/**
- * Integration tests for FleetManager (US-13)
- *
- * Comprehensive integration tests covering:
- * - Full flow: initialize → start → trigger → complete → stop
- * - Scheduler integration: schedules trigger jobs correctly
- * - State persistence: survives restart with correct state
- * - Edge cases: start when running, stop when stopped, etc.
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { mkdtemp, rm, mkdir, writeFile, readFile } from "fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
-import { FleetManager } from "../fleet-manager.js";
-import {
-  InvalidStateError,
-  AgentNotFoundError,
-  ScheduleNotFoundError,
-} from "../errors.js";
-import type {
-  FleetManagerLogger,
-  JobCreatedPayload,
-  JobCompletedPayload,
-  ScheduleTriggeredPayload,
-} from "../types.js";
-
-describe("FleetManager Integration Tests (US-13)", () => {
-  let tempDir: string;
-  let configDir: string;
-  let stateDir: string;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), "fleet-integration-test-"));
-    configDir = join(tempDir, "config");
-    stateDir = join(tempDir, ".herdctl");
-    await mkdir(configDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  // Helper to create a test config file
-  async function createConfig(config: object) {
-    const configPath = join(configDir, "herdctl.yaml");
-    const yaml = await import("yaml");
-    await writeFile(configPath, yaml.stringify(config));
-    return configPath;
-  }
-
-  // Helper to create an agent config file
-  async function createAgentConfig(name: string, config: object) {
-    const agentDir = join(configDir, "agents");
-    await mkdir(agentDir, { recursive: true });
-    const agentPath = join(agentDir, `${name}.yaml`);
-    const yaml = await import("yaml");
-    await writeFile(agentPath, yaml.stringify(config));
-    return agentPath;
-  }
-
-  // Create a silent logger for tests
-  function createSilentLogger(): FleetManagerLogger {
-    return {
-      debug: vi.fn(),
-      info: vi.fn(),
-      warn: vi.fn(),
-      error: vi.fn(),
-    };
-  }
-
-  // Create a test manager with common options
-  function createTestManager(
-    configPath: string,
-    options: { checkInterval?: number } = {}
-  ) {
-    return new FleetManager({
-      configPath,
-      stateDir,
-      checkInterval: options.checkInterval ?? 10000, // Long interval by default to avoid unexpected triggers
-      logger: createSilentLogger(),
-    });
-  }
-
-  // ==========================================================================
-  // Full Flow Integration Tests
-  // ==========================================================================
-
-  describe("Full Flow: initialize → start → trigger → complete → stop", () => {
-    it("completes a full lifecycle with manual trigger", async () => {
-      // Setup: Create agent config
-      await createAgentConfig("workflow-agent", {
-        name: "workflow-agent",
-        description: "Agent for testing full workflow",
-        schedules: {
-          hourly: {
-            type: "interval",
-            interval: "1h",
-            prompt: "Check hourly tasks",
-          },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/workflow-agent.yaml" }],
-      });
-
-      // Create manager
-      const manager = createTestManager(configPath);
-      const events: string[] = [];
-
-      // Track all events
-      manager.on("initialized", () => events.push("initialized"));
-      manager.on("started", () => events.push("started"));
-      manager.on("stopped", () => events.push("stopped"));
-      manager.on("job:created", () => events.push("job:created"));
-
-      // 1. Verify initial state
-      expect(manager.state.status).toBe("uninitialized");
-
-      // 2. Initialize
-      await manager.initialize();
-      expect(manager.state.status).toBe("initialized");
-      expect(manager.state.agentCount).toBe(1);
-      expect(events).toContain("initialized");
-
-      // 3. Start
-      await manager.start();
-      await new Promise((resolve) => setTimeout(resolve, 50)); // Wait for async start
-      expect(manager.state.status).toBe("running");
-      expect(events).toContain("started");
-
-      // 4. Trigger agent
-      const result = await manager.trigger("workflow-agent", "hourly");
-      expect(result.agentName).toBe("workflow-agent");
-      expect(result.scheduleName).toBe("hourly");
-      expect(result.prompt).toBe("Check hourly tasks");
-      expect(result.jobId).toMatch(/^job-\d{4}-\d{2}-\d{2}-[a-z0-9]{6}$/);
-      expect(events).toContain("job:created");
-
-      // 5. Verify fleet status while running
-      const fleetStatus = await manager.getFleetStatus();
-      expect(fleetStatus.state).toBe("running");
-      expect(fleetStatus.counts.totalAgents).toBe(1);
-      expect(fleetStatus.scheduler.status).toBe("running");
-
-      // 6. Stop
-      await manager.stop();
-      expect(manager.state.status).toBe("stopped");
-      expect(events).toContain("stopped");
-
-      // 7. Verify final state
-      const finalStatus = await manager.getFleetStatus();
-      expect(finalStatus.state).toBe("stopped");
-      expect(finalStatus.stoppedAt).not.toBeNull();
-    });
-
-    it("emits events in correct order during lifecycle", async () => {
-      await createAgentConfig("event-order-agent", {
-        name: "event-order-agent",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/event-order-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      const eventOrder: string[] = [];
-
-      manager.on("initialized", () => eventOrder.push("initialized"));
-      manager.on("started", () => eventOrder.push("started"));
-      manager.on("job:created", () => eventOrder.push("job:created"));
-      manager.on("stopped", () => eventOrder.push("stopped"));
-
-      await manager.initialize();
-      await manager.start();
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      await manager.trigger("event-order-agent");
-      await manager.stop();
-
-      expect(eventOrder).toEqual([
-        "initialized",
-        "started",
-        "job:created",
-        "stopped",
-      ]);
-    });
-
-    it("handles multiple agents in full workflow", async () => {
-      await createAgentConfig("agent-alpha", {
-        name: "agent-alpha",
-        description: "First agent",
-      });
-
-      await createAgentConfig("agent-beta", {
-        name: "agent-beta",
-        description: "Second agent",
-      });
-
-      await createAgentConfig("agent-gamma", {
-        name: "agent-gamma",
-        description: "Third agent",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [
-          { path: "./agents/agent-alpha.yaml" },
-          { path: "./agents/agent-beta.yaml" },
-          { path: "./agents/agent-gamma.yaml" },
-        ],
-      });
-
-      const manager = createTestManager(configPath);
-
-      await manager.initialize();
-      expect(manager.state.agentCount).toBe(3);
-
-      await manager.start();
-      await new Promise((resolve) => setTimeout(resolve, 50));
-
-      // Trigger all agents
-      const results = await Promise.all([
-        manager.trigger("agent-alpha"),
-        manager.trigger("agent-beta"),
-        manager.trigger("agent-gamma"),
-      ]);
-
-      expect(results).toHaveLength(3);
-      expect(results.map((r) => r.agentName).sort()).toEqual([
-        "agent-alpha",
-        "agent-beta",
-        "agent-gamma",
-      ]);
-
-      // Verify all have unique job IDs
-      const jobIds = results.map((r) => r.jobId);
-      expect(new Set(jobIds).size).toBe(3);
-
-      // Verify fleet status
-      const status = await manager.getFleetStatus();
-      expect(status.counts.totalAgents).toBe(3);
-
-      await manager.stop();
-    });
-
-    it("correctly tracks timing through lifecycle", async () => {
-      await createAgentConfig("timing-agent", {
-        name: "timing-agent",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/timing-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-
-      // Before init
-      const beforeInit = new Date().toISOString();
-      expect(manager.state.initializedAt).toBeNull();
-      expect(manager.state.startedAt).toBeNull();
-      expect(manager.state.stoppedAt).toBeNull();
-
-      await manager.initialize();
-      const afterInit = new Date().toISOString();
-
-      expect(manager.state.initializedAt).not.toBeNull();
-      expect(manager.state.initializedAt! >= beforeInit).toBe(true);
-      expect(manager.state.initializedAt! <= afterInit).toBe(true);
-
-      const beforeStart = new Date().toISOString();
-      await manager.start();
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      const afterStart = new Date().toISOString();
-
-      expect(manager.state.startedAt).not.toBeNull();
-      expect(manager.state.startedAt! >= beforeStart).toBe(true);
-      expect(manager.state.startedAt! <= afterStart).toBe(true);
-
-      // Check uptime
-      const status = await manager.getFleetStatus();
-      expect(status.uptimeSeconds).toBeGreaterThanOrEqual(0);
-
-      const beforeStop = new Date().toISOString();
-      await manager.stop();
-      const afterStop = new Date().toISOString();
-
-      expect(manager.state.stoppedAt).not.toBeNull();
-      expect(manager.state.stoppedAt! >= beforeStop).toBe(true);
-      expect(manager.state.stoppedAt! <= afterStop).toBe(true);
-    });
-  });
-
-  // ==========================================================================
-  // Scheduler Integration Tests
-  // ==========================================================================
-
-  describe("Scheduler Integration", () => {
-    it("scheduler triggers jobs on schedule", async () => {
-      await createAgentConfig("scheduled-agent", {
-        name: "scheduled-agent",
-        schedules: {
-          frequent: {
-            type: "interval",
-            interval: "100ms", // Very short for testing
-            prompt: "Scheduled prompt",
-          },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/scheduled-agent.yaml" }],
-      });
-
-      const manager = new FleetManager({
-        configPath,
-        stateDir,
-        checkInterval: 50, // Check frequently for testing
-        logger: createSilentLogger(),
-      });
-
-      const scheduleTriggers: ScheduleTriggeredPayload[] = [];
-      manager.on("schedule:triggered", (payload) => {
-        scheduleTriggers.push(payload);
-      });
-
-      await manager.initialize();
-      await manager.start();
-
-      // Wait for at least one scheduled trigger
-      await new Promise((resolve) => setTimeout(resolve, 300));
-
-      await manager.stop();
-
-      // Scheduler should have triggered at least once
-      expect(scheduleTriggers.length).toBeGreaterThanOrEqual(1);
-      expect(scheduleTriggers[0].agentName).toBe("scheduled-agent");
-      expect(scheduleTriggers[0].scheduleName).toBe("frequent");
-    });
-
-    it("scheduler respects disabled schedules", async () => {
-      await createAgentConfig("disabled-schedule-agent", {
-        name: "disabled-schedule-agent",
-        schedules: {
-          active: {
-            type: "interval",
-            interval: "5s", // Longer interval to avoid race conditions
-          },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/disabled-schedule-agent.yaml" }],
-      });
-
-      const manager = new FleetManager({
-        configPath,
-        stateDir,
-        checkInterval: 50,
-        logger: createSilentLogger(),
-      });
-
-      await manager.initialize();
-
-      // Disable the schedule BEFORE starting
-      await manager.disableSchedule("disabled-schedule-agent", "active");
-
-      // Track all triggers
-      const triggers: string[] = [];
-      manager.on("schedule:triggered", () => {
-        triggers.push("triggered");
-      });
-
-      await manager.start();
-
-      // Wait a bit - disabled schedule should not trigger
-      await new Promise((resolve) => setTimeout(resolve, 150));
-
-      await manager.stop();
-
-      // No triggers should have occurred since schedule was disabled
-      expect(triggers.length).toBe(0);
-    });
-
-    it("getSchedules returns correct schedule information", async () => {
-      await createAgentConfig("multi-schedule-agent", {
-        name: "multi-schedule-agent",
-        schedules: {
-          hourly: {
-            type: "interval",
-            interval: "1h",
-          },
-          daily: {
-            type: "interval",
-            interval: "24h",
-          },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/multi-schedule-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      const schedules = await manager.getSchedules();
-
-      expect(schedules).toHaveLength(2);
-      expect(schedules.map((s) => s.name).sort()).toEqual(["daily", "hourly"]);
-      expect(schedules.every((s) => s.agentName === "multi-schedule-agent")).toBe(
-        true
-      );
-      expect(schedules.every((s) => s.status === "idle")).toBe(true);
-    });
-
-    it("getSchedule returns specific schedule", async () => {
-      await createAgentConfig("specific-schedule-agent", {
-        name: "specific-schedule-agent",
-        schedules: {
-          target: {
-            type: "interval",
-            interval: "30m",
-          },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/specific-schedule-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      const schedule = await manager.getSchedule(
-        "specific-schedule-agent",
-        "target"
-      );
-
-      expect(schedule.name).toBe("target");
-      expect(schedule.agentName).toBe("specific-schedule-agent");
-      expect(schedule.type).toBe("interval");
-      expect(schedule.interval).toBe("30m");
-    });
-
-    it("enableSchedule and disableSchedule toggle schedule status", async () => {
-      await createAgentConfig("toggle-agent", {
-        name: "toggle-agent",
-        schedules: {
-          toggleable: {
-            type: "interval",
-            interval: "1h",
-          },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/toggle-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      // Initially idle
-      let schedule = await manager.getSchedule("toggle-agent", "toggleable");
-      expect(schedule.status).toBe("idle");
-
-      // Disable
-      await manager.disableSchedule("toggle-agent", "toggleable");
-      schedule = await manager.getSchedule("toggle-agent", "toggleable");
-      expect(schedule.status).toBe("disabled");
-
-      // Re-enable
-      await manager.enableSchedule("toggle-agent", "toggleable");
-      schedule = await manager.getSchedule("toggle-agent", "toggleable");
-      expect(schedule.status).toBe("idle");
-    });
-  });
-
-  // ==========================================================================
-  // State Persistence Tests
-  // ==========================================================================
-
-  describe("State Persistence", () => {
-    it("persists fleet state across restart", async () => {
-      await createAgentConfig("persistent-agent", {
-        name: "persistent-agent",
-        schedules: {
-          check: {
-            type: "interval",
-            interval: "1h",
-          },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/persistent-agent.yaml" }],
-      });
-
-      // First manager instance - trigger a job
-      const manager1 = createTestManager(configPath);
-      await manager1.initialize();
-      await manager1.start();
-      await new Promise((resolve) => setTimeout(resolve, 50));
-
-      const triggerResult = await manager1.trigger("persistent-agent", "check");
-      const jobId = triggerResult.jobId;
-
-      await manager1.stop();
-
-      // Second manager instance - verify state was persisted
-      const manager2 = createTestManager(configPath);
-      await manager2.initialize();
-
-      // State should show agent info correctly
-      const agentInfo = await manager2.getAgentInfoByName("persistent-agent");
-      expect(agentInfo.name).toBe("persistent-agent");
-
-      // Verify the job was created with metadata (stored as YAML)
-      const yaml = await import("yaml");
-      const jobFilePath = join(stateDir, "jobs", `${jobId}.yaml`);
-      const jobContent = await readFile(jobFilePath, "utf-8");
-      const metadata = yaml.parse(jobContent);
-
-      expect(metadata.id).toBe(jobId);
-      expect(metadata.agent).toBe("persistent-agent");
-    });
-
-    it("schedule state survives restart", async () => {
-      await createAgentConfig("schedule-persist-agent", {
-        name: "schedule-persist-agent",
-        schedules: {
-          persist: {
-            type: "interval",
-            interval: "1h",
-          },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/schedule-persist-agent.yaml" }],
-      });
-
-      // First instance - disable schedule
-      const manager1 = createTestManager(configPath);
-      await manager1.initialize();
-      await manager1.disableSchedule("schedule-persist-agent", "persist");
-
-      let schedule = await manager1.getSchedule(
-        "schedule-persist-agent",
-        "persist"
-      );
-      expect(schedule.status).toBe("disabled");
-
-      // Note: The current implementation may or may not persist schedule disabled state
-      // This test documents the expected behavior
-
-      await manager1.stop();
-
-      // Second instance - check if schedule state was preserved
-      const manager2 = createTestManager(configPath);
-      await manager2.initialize();
-
-      // Get schedule state
-      schedule = await manager2.getSchedule("schedule-persist-agent", "persist");
-      // Schedule status after restart - depends on implementation
-      // Currently schedules start fresh as "idle" on restart
-      expect(["idle", "disabled"]).toContain(schedule.status);
-    });
-
-    it("job metadata persists to disk", async () => {
-      await createAgentConfig("job-persist-agent", {
-        name: "job-persist-agent",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/job-persist-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-      await manager.start();
-      await new Promise((resolve) => setTimeout(resolve, 50));
-
-      const result = await manager.trigger("job-persist-agent", undefined, {
-        prompt: "Persisted prompt",
-      });
-
-      // Verify job metadata was written to disk (stored as YAML)
-      const yaml = await import("yaml");
-      const jobFilePath = join(stateDir, "jobs", `${result.jobId}.yaml`);
-
-      const metadataContent = await readFile(jobFilePath, "utf-8");
-      const metadata = yaml.parse(metadataContent);
-
-      expect(metadata.id).toBe(result.jobId);
-      expect(metadata.agent).toBe("job-persist-agent");
-      expect(metadata.prompt).toBe("Persisted prompt");
-      expect(metadata.trigger_type).toBe("manual");
-
-      await manager.stop();
-    });
-
-    it("state directory is created if it does not exist", async () => {
-      await createAgentConfig("state-dir-agent", {
-        name: "state-dir-agent",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/state-dir-agent.yaml" }],
-      });
-
-      // Use a new state directory that doesn't exist
-      const newStateDir = join(tempDir, "new-state-dir");
-
-      const manager = new FleetManager({
-        configPath,
-        stateDir: newStateDir,
-        logger: createSilentLogger(),
-      });
-
-      await manager.initialize();
-      await manager.start();
-      await new Promise((resolve) => setTimeout(resolve, 50));
-
-      // Trigger a job to ensure state is persisted
-      const result = await manager.trigger("state-dir-agent");
-
-      // Verify job file was created in state directory (stored as YAML)
-      const yaml = await import("yaml");
-      const jobFilePath = join(newStateDir, "jobs", `${result.jobId}.yaml`);
-      const content = await readFile(jobFilePath, "utf-8");
-      expect(yaml.parse(content)).toHaveProperty("id", result.jobId);
-
-      await manager.stop();
-    });
-  });
-
-  // ==========================================================================
-  // Edge Case Tests
-  // ==========================================================================
-
-  describe("Edge Cases", () => {
-    describe("start() edge cases", () => {
-      it("throws InvalidStateError when calling start before initialize", async () => {
-        const configPath = await createConfig({
-          version: 1,
-          agents: [],
-        });
-
-        const manager = createTestManager(configPath);
-
-        await expect(manager.start()).rejects.toThrow(InvalidStateError);
-        await expect(manager.start()).rejects.toMatchObject({
-          operation: "start",
-          currentState: "uninitialized",
-        });
-      });
-
-      it("handles start when already running (idempotent)", async () => {
-        await createAgentConfig("idempotent-start", {
-          name: "idempotent-start",
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/idempotent-start.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-        await manager.start();
-        await new Promise((resolve) => setTimeout(resolve, 50));
-
-        expect(manager.state.status).toBe("running");
-
-        // Second start should be safe (idempotent or throw)
-        // Based on implementation, may throw InvalidStateError or be no-op
-        try {
-          await manager.start();
-          // If no error, should still be running
-          expect(manager.state.status).toBe("running");
-        } catch (error) {
-          expect(error).toBeInstanceOf(InvalidStateError);
-        }
-
-        await manager.stop();
-      });
-
-      it("requires re-initialization to restart after stop", async () => {
-        await createAgentConfig("restart-agent", {
-          name: "restart-agent",
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/restart-agent.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-
-        // First start/stop cycle
-        await manager.start();
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        expect(manager.state.status).toBe("running");
-        await manager.stop();
-        expect(manager.state.status).toBe("stopped");
-
-        // Cannot restart without re-initialization
-        // This documents the current behavior - must create new manager instance
-        await expect(manager.start()).rejects.toThrow();
-      });
-    });
-
-    describe("stop() edge cases", () => {
-      it("handles stop when already stopped (idempotent)", async () => {
-        await createAgentConfig("idempotent-stop", {
-          name: "idempotent-stop",
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/idempotent-stop.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-        await manager.start();
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        await manager.stop();
-
-        expect(manager.state.status).toBe("stopped");
-
-        // Second stop should be safe
-        await manager.stop();
-        expect(manager.state.status).toBe("stopped");
-      });
-
-      it("handles stop when never started (no-op)", async () => {
-        await createAgentConfig("never-started", {
-          name: "never-started",
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/never-started.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-
-        // Stop without ever starting is a no-op - stays in initialized state
-        await manager.stop();
-        expect(manager.state.status).toBe("initialized");
-      });
-
-      it("stop respects timeout option", async () => {
-        await createAgentConfig("timeout-agent", {
-          name: "timeout-agent",
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/timeout-agent.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-        await manager.start();
-        await new Promise((resolve) => setTimeout(resolve, 50));
-
-        // Stop with short timeout
-        const beforeStop = Date.now();
-        await manager.stop({ timeout: 100 });
-        const afterStop = Date.now();
-
-        expect(manager.state.status).toBe("stopped");
-        // Stop should complete quickly
-        expect(afterStop - beforeStop).toBeLessThan(1000);
-      });
-    });
-
-    describe("initialize() edge cases", () => {
-      it("throws error for invalid config", async () => {
-        const configPath = join(configDir, "herdctl.yaml");
-        await writeFile(configPath, "invalid: yaml: content:");
-
-        const manager = new FleetManager({
-          configPath,
-          stateDir,
-          logger: createSilentLogger(),
-        });
-
-        await expect(manager.initialize()).rejects.toThrow();
-      });
-
-      it("throws error for non-existent config", async () => {
-        const manager = new FleetManager({
-          configPath: "/nonexistent/path/config.yaml",
-          stateDir,
-          logger: createSilentLogger(),
-        });
-
-        await expect(manager.initialize()).rejects.toThrow();
-      });
-
-      it("handles re-initialization (idempotent or error)", async () => {
-        await createAgentConfig("reinit-agent", {
-          name: "reinit-agent",
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/reinit-agent.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-
-        // Second initialize - should be idempotent or throw
-        try {
-          await manager.initialize();
-          expect(manager.state.status).toBe("initialized");
-        } catch (error) {
-          expect(error).toBeInstanceOf(InvalidStateError);
-        }
-      });
-    });
-
-    describe("trigger() edge cases", () => {
-      it("throws AgentNotFoundError for non-existent agent", async () => {
-        await createAgentConfig("existing-agent", {
-          name: "existing-agent",
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/existing-agent.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-
-        await expect(manager.trigger("nonexistent-agent")).rejects.toThrow(
-          AgentNotFoundError
-        );
-        await expect(manager.trigger("nonexistent-agent")).rejects.toMatchObject({
-          agentName: "nonexistent-agent",
-          availableAgents: ["existing-agent"],
-        });
-      });
-
-      it("throws ScheduleNotFoundError for non-existent schedule", async () => {
-        await createAgentConfig("schedule-edge-agent", {
-          name: "schedule-edge-agent",
-          schedules: {
-            existing: {
-              type: "interval",
-              interval: "1h",
-            },
-          },
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/schedule-edge-agent.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-
-        await expect(
-          manager.trigger("schedule-edge-agent", "nonexistent")
-        ).rejects.toThrow(ScheduleNotFoundError);
-        await expect(
-          manager.trigger("schedule-edge-agent", "nonexistent")
-        ).rejects.toMatchObject({
-          scheduleName: "nonexistent",
-          availableSchedules: ["existing"],
-        });
-      });
-
-      it("throws InvalidStateError before initialize", async () => {
-        const configPath = await createConfig({
-          version: 1,
-          agents: [],
-        });
-
-        const manager = createTestManager(configPath);
-
-        await expect(manager.trigger("any-agent")).rejects.toThrow(
-          InvalidStateError
-        );
-      });
-
-      it("trigger works after stop", async () => {
-        await createAgentConfig("trigger-after-stop", {
-          name: "trigger-after-stop",
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/trigger-after-stop.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-        await manager.start();
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        await manager.stop();
-
-        // Should still be able to trigger after stop
-        const result = await manager.trigger("trigger-after-stop");
-        expect(result.agentName).toBe("trigger-after-stop");
-      });
-    });
-
-    describe("getAgentInfoByName() edge cases", () => {
-      it("throws AgentNotFoundError before initialize", async () => {
-        const configPath = await createConfig({
-          version: 1,
-          agents: [],
-        });
-
-        const manager = createTestManager(configPath);
-
-        await expect(manager.getAgentInfoByName("any")).rejects.toThrow(
-          AgentNotFoundError
-        );
-      });
-
-      it("throws AgentNotFoundError for unknown agent", async () => {
-        await createAgentConfig("known", {
-          name: "known",
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/known.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-
-        await expect(manager.getAgentInfoByName("unknown")).rejects.toThrow(
-          AgentNotFoundError
-        );
-      });
-    });
-
-    describe("reload() edge cases", () => {
-      it("throws InvalidStateError before initialize", async () => {
-        const configPath = await createConfig({
-          version: 1,
-          agents: [],
-        });
-
-        const manager = createTestManager(configPath);
-
-        await expect(manager.reload()).rejects.toThrow(InvalidStateError);
-      });
-
-      it("reload works in all valid states", async () => {
-        await createAgentConfig("reload-states", {
-          name: "reload-states",
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/reload-states.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-
-        // Test in initialized state
-        await manager.initialize();
-        let result = await manager.reload();
-        expect(result.agentCount).toBe(1);
-
-        // Test in running state
-        await manager.start();
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        result = await manager.reload();
-        expect(result.agentCount).toBe(1);
-
-        // Test in stopped state
-        await manager.stop();
-        result = await manager.reload();
-        expect(result.agentCount).toBe(1);
-      });
-    });
-
-    describe("getSchedule() edge cases", () => {
-      it("throws AgentNotFoundError for unknown agent", async () => {
-        await createAgentConfig("schedule-agent", {
-          name: "schedule-agent",
-          schedules: {
-            test: { type: "interval", interval: "1h" },
-          },
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/schedule-agent.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-
-        await expect(
-          manager.getSchedule("unknown-agent", "test")
-        ).rejects.toThrow(AgentNotFoundError);
-      });
-
-      it("throws ScheduleNotFoundError for unknown schedule", async () => {
-        await createAgentConfig("schedule-not-found", {
-          name: "schedule-not-found",
-          schedules: {
-            exists: { type: "interval", interval: "1h" },
-          },
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/schedule-not-found.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-
-        await expect(
-          manager.getSchedule("schedule-not-found", "does-not-exist")
-        ).rejects.toThrow(ScheduleNotFoundError);
-      });
-    });
-
-    describe("empty fleet edge cases", () => {
-      it("handles fleet with no agents", async () => {
-        const configPath = await createConfig({
-          version: 1,
-          agents: [],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-
-        expect(manager.state.agentCount).toBe(0);
-
-        const status = await manager.getFleetStatus();
-        expect(status.counts.totalAgents).toBe(0);
-        expect(status.counts.totalSchedules).toBe(0);
-
-        const agents = await manager.getAgentInfo();
-        expect(agents).toEqual([]);
-
-        const schedules = await manager.getSchedules();
-        expect(schedules).toEqual([]);
-
-        await manager.start();
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        expect(manager.state.status).toBe("running");
-
-        await manager.stop();
-        expect(manager.state.status).toBe("stopped");
-      });
-
-      it("handles agent with no schedules", async () => {
-        await createAgentConfig("no-schedules", {
-          name: "no-schedules",
-          description: "Agent without schedules",
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/no-schedules.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-
-        const agentInfo = await manager.getAgentInfoByName("no-schedules");
-        expect(agentInfo.scheduleCount).toBe(0);
-        expect(agentInfo.schedules).toEqual([]);
-
-        // Trigger should still work
-        const result = await manager.trigger("no-schedules");
-        expect(result.agentName).toBe("no-schedules");
-        expect(result.scheduleName).toBeNull();
-      });
-    });
-
-    describe("concurrency edge cases", () => {
-      it("single start/stop cycle completes correctly", async () => {
-        await createAgentConfig("rapid-cycle", {
-          name: "rapid-cycle",
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/rapid-cycle.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-
-        // Single start/stop cycle
-        await manager.start();
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        await manager.stop();
-
-        expect(manager.state.status).toBe("stopped");
-      });
-
-      it("concurrent triggers to same agent", async () => {
-        await createAgentConfig("concurrent-agent", {
-          name: "concurrent-agent",
-          instances: { max_concurrent: 5 },
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/concurrent-agent.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-
-        // Trigger multiple jobs concurrently
-        const triggers = await Promise.all([
-          manager.trigger("concurrent-agent", undefined, { prompt: "Job 1" }),
-          manager.trigger("concurrent-agent", undefined, { prompt: "Job 2" }),
-          manager.trigger("concurrent-agent", undefined, { prompt: "Job 3" }),
-        ]);
-
-        expect(triggers).toHaveLength(3);
-        const jobIds = triggers.map((t) => t.jobId);
-        expect(new Set(jobIds).size).toBe(3); // All unique IDs
-      });
-    });
-
-    describe("stop with cancelOnTimeout", () => {
-      it("stops with cancelOnTimeout option", async () => {
-        await createAgentConfig("cancel-agent", {
-          name: "cancel-agent",
-        });
-
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/cancel-agent.yaml" }],
-        });
-
-        const manager = createTestManager(configPath);
-        await manager.initialize();
-        await manager.start();
-        await new Promise((resolve) => setTimeout(resolve, 50));
-
-        // Stop with cancelOnTimeout enabled (doesn't matter here since no running jobs)
-        await manager.stop({
-          timeout: 100,
-          cancelOnTimeout: true,
-          cancelTimeout: 50,
-        });
-
-        expect(manager.state.status).toBe("stopped");
-      });
-    });
-
-    describe("error state handling", () => {
-      it("tracks errors during initialization", async () => {
-        // Create invalid config with missing agent file
-        const configPath = await createConfig({
-          version: 1,
-          agents: [{ path: "./agents/nonexistent.yaml" }],
-        });
-
-        const logger = createSilentLogger();
-        const manager = new FleetManager({
-          configPath,
-          stateDir,
-          logger,
-        });
-
-        // Initialize should fail
-        try {
-          await manager.initialize();
-        } catch {
-          // Expected
-        }
-
-        // Status should be error
-        expect(manager.state.status).toBe("error");
-        expect(manager.state.lastError).toBeDefined();
-      });
-    });
-  });
-});