@herdctl/core 0.0.1 → 0.1.0

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

@@ -1,869 +0,0 @@
-/**
- * Tests for JobManager (US-4)
- *
- * Tests job history queries, output streaming, and retention management.
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { mkdtemp, rm, mkdir, writeFile, appendFile } from "fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
-import { JobManager } from "../job-manager.js";
-import { JobNotFoundError } from "../errors.js";
-import { createJob, updateJob } from "../../state/job-metadata.js";
-import { appendJobOutput } from "../../state/job-output.js";
-import type { JobMetadata } from "../../state/schemas/job-metadata.js";
-
-describe("JobManager", () => {
-  let tempDir: string;
-  let jobsDir: string;
-
-  beforeEach(async () => {
-    // Create temp directory for test
-    tempDir = await mkdtemp(join(tmpdir(), "job-manager-test-"));
-    jobsDir = join(tempDir, ".herdctl", "jobs");
-    await mkdir(jobsDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    // Cleanup
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  // Helper to create a test job
-  async function createTestJob(options: {
-    agent: string;
-    status?: "pending" | "running" | "completed" | "failed" | "cancelled";
-    startedAt?: Date;
-    prompt?: string;
-  }): Promise<JobMetadata> {
-    const job = await createJob(jobsDir, {
-      agent: options.agent,
-      trigger_type: "manual",
-      prompt: options.prompt ?? "Test prompt",
-    });
-
-    if (options.status && options.status !== "pending") {
-      return await updateJob(jobsDir, job.id, {
-        status: options.status,
-        finished_at:
-          options.status === "running" ? undefined : new Date().toISOString(),
-        exit_reason:
-          options.status === "completed"
-            ? "success"
-            : options.status === "failed"
-              ? "error"
-              : options.status === "cancelled"
-                ? "cancelled"
-                : undefined,
-      });
-    }
-
-    return job;
-  }
-
-  describe("getJobs()", () => {
-    it("returns empty list when no jobs exist", async () => {
-      const manager = new JobManager({ jobsDir });
-      const result = await manager.getJobs();
-
-      expect(result.jobs).toEqual([]);
-      expect(result.total).toBe(0);
-      expect(result.errors).toBe(0);
-    });
-
-    it("returns all jobs when no filter specified", async () => {
-      const manager = new JobManager({ jobsDir });
-
-      await createTestJob({ agent: "agent-1" });
-      await createTestJob({ agent: "agent-2" });
-      await createTestJob({ agent: "agent-1" });
-
-      const result = await manager.getJobs();
-
-      expect(result.jobs).toHaveLength(3);
-      expect(result.total).toBe(3);
-    });
-
-    it("filters by agent name", async () => {
-      const manager = new JobManager({ jobsDir });
-
-      await createTestJob({ agent: "agent-1" });
-      await createTestJob({ agent: "agent-2" });
-      await createTestJob({ agent: "agent-1" });
-
-      const result = await manager.getJobs({ agent: "agent-1" });
-
-      expect(result.jobs).toHaveLength(2);
-      expect(result.total).toBe(2);
-      expect(result.jobs.every((j) => j.agent === "agent-1")).toBe(true);
-    });
-
-    it("filters by status", async () => {
-      const manager = new JobManager({ jobsDir });
-
-      await createTestJob({ agent: "agent-1", status: "completed" });
-      await createTestJob({ agent: "agent-1", status: "failed" });
-      await createTestJob({ agent: "agent-1", status: "completed" });
-
-      const result = await manager.getJobs({ status: "completed" });
-
-      expect(result.jobs).toHaveLength(2);
-      expect(result.total).toBe(2);
-      expect(result.jobs.every((j) => j.status === "completed")).toBe(true);
-    });
-
-    it("filters by date range", async () => {
-      const manager = new JobManager({ jobsDir });
-
-      // Create jobs (they will all have "now" as started_at)
-      await createTestJob({ agent: "agent-1" });
-      await createTestJob({ agent: "agent-1" });
-
-      // Filter for jobs after a past date
-      const pastDate = new Date(Date.now() - 60000); // 1 minute ago
-      const result = await manager.getJobs({ startedAfter: pastDate });
-
-      expect(result.jobs).toHaveLength(2);
-    });
-
-    it("applies limit correctly", async () => {
-      const manager = new JobManager({ jobsDir });
-
-      await createTestJob({ agent: "agent-1" });
-      await createTestJob({ agent: "agent-1" });
-      await createTestJob({ agent: "agent-1" });
-
-      const result = await manager.getJobs({ limit: 2 });
-
-      expect(result.jobs).toHaveLength(2);
-      expect(result.total).toBe(3); // Total still shows all matching
-    });
-
-    it("applies offset correctly", async () => {
-      const manager = new JobManager({ jobsDir });
-
-      await createTestJob({ agent: "agent-1" });
-      await createTestJob({ agent: "agent-1" });
-      await createTestJob({ agent: "agent-1" });
-
-      const result = await manager.getJobs({ offset: 1 });
-
-      expect(result.jobs).toHaveLength(2);
-      expect(result.total).toBe(3);
-    });
-
-    it("applies limit and offset together", async () => {
-      const manager = new JobManager({ jobsDir });
-
-      await createTestJob({ agent: "agent-1" });
-      await createTestJob({ agent: "agent-1" });
-      await createTestJob({ agent: "agent-1" });
-      await createTestJob({ agent: "agent-1" });
-
-      const result = await manager.getJobs({ limit: 2, offset: 1 });
-
-      expect(result.jobs).toHaveLength(2);
-      expect(result.total).toBe(4);
-    });
-
-    it("combines multiple filters", async () => {
-      const manager = new JobManager({ jobsDir });
-
-      await createTestJob({ agent: "agent-1", status: "completed" });
-      await createTestJob({ agent: "agent-1", status: "failed" });
-      await createTestJob({ agent: "agent-2", status: "completed" });
-      await createTestJob({ agent: "agent-1", status: "completed" });
-
-      const result = await manager.getJobs({
-        agent: "agent-1",
-        status: "completed",
-      });
-
-      expect(result.jobs).toHaveLength(2);
-      expect(result.total).toBe(2);
-      expect(
-        result.jobs.every(
-          (j) => j.agent === "agent-1" && j.status === "completed"
-        )
-      ).toBe(true);
-    });
-
-    it("returns jobs sorted by started_at descending", async () => {
-      const manager = new JobManager({ jobsDir });
-
-      // Create jobs with small delays to ensure different timestamps
-      const job1 = await createTestJob({ agent: "agent-1" });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      const job2 = await createTestJob({ agent: "agent-1" });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      const job3 = await createTestJob({ agent: "agent-1" });
-
-      const result = await manager.getJobs();
-
-      // Most recent (job3) should be first
-      expect(result.jobs[0].id).toBe(job3.id);
-      expect(result.jobs[1].id).toBe(job2.id);
-      expect(result.jobs[2].id).toBe(job1.id);
-    });
-  });
-
-  describe("getJob()", () => {
-    it("returns job by ID", async () => {
-      const manager = new JobManager({ jobsDir });
-      const created = await createTestJob({ agent: "test-agent" });
-
-      const job = await manager.getJob(created.id);
-
-      expect(job.id).toBe(created.id);
-      expect(job.agent).toBe("test-agent");
-    });
-
-    it("throws JobNotFoundError for unknown ID", async () => {
-      const manager = new JobManager({ jobsDir });
-
-      await expect(manager.getJob("job-2099-01-01-xxxxxx")).rejects.toThrow(
-        JobNotFoundError
-      );
-
-      await expect(manager.getJob("job-2099-01-01-xxxxxx")).rejects.toMatchObject(
-        {
-          name: "JobNotFoundError",
-          jobId: "job-2099-01-01-xxxxxx",
-        }
-      );
-    });
-
-    it("returns job without output by default", async () => {
-      const manager = new JobManager({ jobsDir });
-      const created = await createTestJob({ agent: "test-agent" });
-
-      // Add some output
-      await appendJobOutput(jobsDir, created.id, {
-        type: "assistant",
-        content: "Hello",
-      });
-
-      const job = await manager.getJob(created.id);
-
-      expect(job.output).toBeUndefined();
-    });
-
-    it("includes output when requested", async () => {
-      const manager = new JobManager({ jobsDir });
-      const created = await createTestJob({ agent: "test-agent" });
-
-      // Add some output
-      await appendJobOutput(jobsDir, created.id, {
-        type: "assistant",
-        content: "Hello",
-      });
-      await appendJobOutput(jobsDir, created.id, {
-        type: "assistant",
-        content: "World",
-      });
-
-      const job = await manager.getJob(created.id, { includeOutput: true });
-
-      expect(job.output).toBeDefined();
-      expect(job.output).toHaveLength(2);
-      expect(job.output![0].type).toBe("assistant");
-      expect((job.output![0] as { content?: string }).content).toBe("Hello");
-    });
-  });
-
-  describe("streamJobOutput()", () => {
-    it("throws JobNotFoundError for unknown job", async () => {
-      const manager = new JobManager({ jobsDir });
-
-      await expect(
-        manager.streamJobOutput("job-2099-01-01-xxxxxx")
-      ).rejects.toThrow(JobNotFoundError);
-    });
-
-    it("emits existing messages immediately", async () => {
-      const manager = new JobManager({ jobsDir });
-      const created = await createTestJob({
-        agent: "test-agent",
-        status: "completed",
-      });
-
-      // Add some output before streaming
-      await appendJobOutput(jobsDir, created.id, {
-        type: "assistant",
-        content: "Message 1",
-      });
-      await appendJobOutput(jobsDir, created.id, {
-        type: "assistant",
-        content: "Message 2",
-      });
-
-      const messages: unknown[] = [];
-      const stream = await manager.streamJobOutput(created.id);
-
-      stream.on("message", (msg) => {
-        messages.push(msg);
-      });
-
-      // Wait a bit for messages to be emitted
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      stream.stop();
-
-      expect(messages.length).toBeGreaterThanOrEqual(2);
-    });
-
-    it("emits end event for completed jobs", async () => {
-      const manager = new JobManager({ jobsDir });
-      const created = await createTestJob({
-        agent: "test-agent",
-        status: "completed",
-      });
-
-      const stream = await manager.streamJobOutput(created.id);
-      let ended = false;
-
-      stream.on("end", () => {
-        ended = true;
-      });
-
-      // Wait for end event
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      stream.stop();
-
-      expect(ended).toBe(true);
-    });
-
-    it("can be stopped", async () => {
-      const manager = new JobManager({ jobsDir });
-      const created = await createTestJob({
-        agent: "test-agent",
-        status: "running",
-      });
-
-      const stream = await manager.streamJobOutput(created.id);
-
-      // Should not throw
-      stream.stop();
-    });
-  });
-
-  describe("applyRetention()", () => {
-    it("keeps jobs within per-agent limit", async () => {
-      const manager = new JobManager({
-        jobsDir,
-        retention: { maxJobsPerAgent: 2 },
-      });
-
-      // Create 3 jobs for same agent
-      await createTestJob({ agent: "agent-1", status: "completed" });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      await createTestJob({ agent: "agent-1", status: "completed" });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      await createTestJob({ agent: "agent-1", status: "completed" });
-
-      // Apply retention
-      const deleted = await manager.applyRetention();
-
-      expect(deleted).toBe(1);
-
-      // Verify only 2 remain
-      const result = await manager.getJobs({ agent: "agent-1" });
-      expect(result.total).toBe(2);
-    });
-
-    it("respects per-agent limit independently", async () => {
-      const manager = new JobManager({
-        jobsDir,
-        retention: { maxJobsPerAgent: 2 },
-      });
-
-      // Create 3 jobs for agent-1
-      await createTestJob({ agent: "agent-1", status: "completed" });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      await createTestJob({ agent: "agent-1", status: "completed" });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      await createTestJob({ agent: "agent-1", status: "completed" });
-
-      // Create 2 jobs for agent-2
-      await createTestJob({ agent: "agent-2", status: "completed" });
-      await createTestJob({ agent: "agent-2", status: "completed" });
-
-      // Apply retention
-      const deleted = await manager.applyRetention();
-
-      expect(deleted).toBe(1); // Only 1 from agent-1
-
-      // Verify counts
-      const agent1Result = await manager.getJobs({ agent: "agent-1" });
-      const agent2Result = await manager.getJobs({ agent: "agent-2" });
-
-      expect(agent1Result.total).toBe(2);
-      expect(agent2Result.total).toBe(2);
-    });
-
-    it("applies fleet-wide limit", async () => {
-      const manager = new JobManager({
-        jobsDir,
-        retention: { maxJobsPerAgent: 100, maxTotalJobs: 3 },
-      });
-
-      // Create 5 jobs across different agents
-      await createTestJob({ agent: "agent-1", status: "completed" });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      await createTestJob({ agent: "agent-2", status: "completed" });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      await createTestJob({ agent: "agent-3", status: "completed" });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      await createTestJob({ agent: "agent-4", status: "completed" });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      await createTestJob({ agent: "agent-5", status: "completed" });
-
-      // Apply retention
-      const deleted = await manager.applyRetention();
-
-      expect(deleted).toBe(2);
-
-      // Verify total count
-      const result = await manager.getJobs();
-      expect(result.total).toBe(3);
-    });
-
-    it("deletes oldest jobs first", async () => {
-      const manager = new JobManager({
-        jobsDir,
-        retention: { maxJobsPerAgent: 2 },
-      });
-
-      // Create jobs with increasing timestamps
-      const oldest = await createTestJob({
-        agent: "agent-1",
-        status: "completed",
-      });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      const middle = await createTestJob({
-        agent: "agent-1",
-        status: "completed",
-      });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      const newest = await createTestJob({
-        agent: "agent-1",
-        status: "completed",
-      });
-
-      // Apply retention
-      await manager.applyRetention();
-
-      // Verify oldest was deleted
-      const result = await manager.getJobs({ agent: "agent-1" });
-      const ids = result.jobs.map((j) => j.id);
-
-      expect(ids).toContain(newest.id);
-      expect(ids).toContain(middle.id);
-      expect(ids).not.toContain(oldest.id);
-    });
-
-    it("uses default per-agent limit of 100", async () => {
-      const manager = new JobManager({ jobsDir });
-      const config = manager.getRetentionConfig();
-
-      expect(config.maxJobsPerAgent).toBe(100);
-      expect(config.maxTotalJobs).toBe(0); // 0 means no limit
-    });
-  });
-
-  describe("getRetentionConfig()", () => {
-    it("returns configured retention settings", async () => {
-      const manager = new JobManager({
-        jobsDir,
-        retention: { maxJobsPerAgent: 50, maxTotalJobs: 500 },
-      });
-
-      const config = manager.getRetentionConfig();
-
-      expect(config.maxJobsPerAgent).toBe(50);
-      expect(config.maxTotalJobs).toBe(500);
-    });
-
-    it("returns copy of config", async () => {
-      const manager = new JobManager({
-        jobsDir,
-        retention: { maxJobsPerAgent: 50 },
-      });
-
-      const config1 = manager.getRetentionConfig();
-      const config2 = manager.getRetentionConfig();
-
-      expect(config1).toEqual(config2);
-      expect(config1).not.toBe(config2); // Different object instances
-    });
-  });
-
-  describe("job persistence survives restarts", () => {
-    it("jobs persist after creating new JobManager instance", async () => {
-      // Create first manager and add jobs
-      const manager1 = new JobManager({ jobsDir });
-      const created = await createTestJob({ agent: "test-agent" });
-
-      // Create new manager instance (simulating restart)
-      const manager2 = new JobManager({ jobsDir });
-
-      // Job should still be accessible
-      const job = await manager2.getJob(created.id);
-      expect(job.id).toBe(created.id);
-      expect(job.agent).toBe("test-agent");
-    });
-
-    it("job output persists after creating new JobManager instance", async () => {
-      // Create first manager and add job with output
-      const manager1 = new JobManager({ jobsDir });
-      const created = await createTestJob({ agent: "test-agent" });
-
-      await appendJobOutput(jobsDir, created.id, {
-        type: "assistant",
-        content: "Persistent message",
-      });
-
-      // Create new manager instance (simulating restart)
-      const manager2 = new JobManager({ jobsDir });
-
-      // Output should still be accessible
-      const job = await manager2.getJob(created.id, { includeOutput: true });
-      expect(job.output).toBeDefined();
-      expect(job.output).toHaveLength(1);
-      expect((job.output![0] as { content?: string }).content).toBe(
-        "Persistent message"
-      );
-    });
-  });
-
-  describe("streamJobOutput() edge cases", () => {
-    it("streams messages from a running job", async () => {
-      const manager = new JobManager({ jobsDir });
-      const created = await createTestJob({
-        agent: "test-agent",
-        status: "running",
-      });
-
-      // Add output before starting stream
-      await appendJobOutput(jobsDir, created.id, {
-        type: "assistant",
-        content: "Initial message",
-      });
-
-      const messages: unknown[] = [];
-      const stream = await manager.streamJobOutput(created.id);
-
-      stream.on("message", (msg) => {
-        messages.push(msg);
-      });
-
-      // Wait for messages to be processed
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      // Add more output while streaming
-      await appendJobOutput(jobsDir, created.id, {
-        type: "assistant",
-        content: "New message",
-      });
-
-      // Wait a bit more
-      await new Promise((resolve) => setTimeout(resolve, 200));
-
-      stream.stop();
-
-      expect(messages.length).toBeGreaterThanOrEqual(1);
-    });
-
-    it("handles error event", async () => {
-      const manager = new JobManager({ jobsDir });
-      const created = await createTestJob({
-        agent: "test-agent",
-        status: "completed",
-      });
-
-      const stream = await manager.streamJobOutput(created.id);
-      let errorReceived = false;
-
-      stream.on("error", () => {
-        errorReceived = true;
-      });
-
-      // Give time for processing
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      stream.stop();
-
-      // Error might not be received for normal completed jobs
-      // This just tests the event listener is properly attached
-      expect(typeof errorReceived).toBe("boolean");
-    });
-
-    it("can use off to unsubscribe from events", async () => {
-      const manager = new JobManager({ jobsDir });
-      const created = await createTestJob({
-        agent: "test-agent",
-        status: "completed",
-      });
-
-      const stream = await manager.streamJobOutput(created.id);
-      let messageCount = 0;
-      const handler = () => {
-        messageCount++;
-      };
-
-      stream.on("message", handler);
-      stream.off("message", handler);
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      stream.stop();
-
-      // Messages should not be counted after unsubscribing
-      expect(messageCount).toBe(0);
-    });
-
-    it("handles job that has no output file yet", async () => {
-      const manager = new JobManager({ jobsDir });
-      const created = await createTestJob({
-        agent: "test-agent",
-        status: "running",
-      });
-
-      // Don't add any output - output file doesn't exist yet
-      const stream = await manager.streamJobOutput(created.id);
-      const messages: unknown[] = [];
-
-      stream.on("message", (msg) => {
-        messages.push(msg);
-      });
-
-      // Wait a bit
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      stream.stop();
-
-      // Should not crash, just return no messages
-      expect(messages.length).toBe(0);
-    });
-
-    it("logs warning for malformed JSON in output file", async () => {
-      const warnMessages: string[] = [];
-      const manager = new JobManager({
-        jobsDir,
-        logger: {
-          warn: (msg) => warnMessages.push(msg),
-          debug: vi.fn(),
-        },
-      });
-
-      const created = await createTestJob({
-        agent: "test-agent",
-        status: "completed",
-      });
-
-      // Write invalid JSON directly to output file (correct path format)
-      const outputPath = join(jobsDir, `${created.id}.jsonl`);
-      await writeFile(
-        outputPath,
-        'not valid json\n{"type": "assistant", "content": "valid"}\n'
-      );
-
-      const messages: unknown[] = [];
-      const stream = await manager.streamJobOutput(created.id);
-
-      stream.on("message", (msg) => {
-        messages.push(msg);
-      });
-
-      // Wait for processing
-      await new Promise((resolve) => setTimeout(resolve, 150));
-
-      stream.stop();
-
-      // Should have logged a warning about malformed JSON
-      expect(warnMessages.some((m) => m.includes("malformed JSON"))).toBe(true);
-      // Should still have parsed the valid message
-      expect(messages.length).toBeGreaterThanOrEqual(1);
-    });
-
-    it("emits end when polling detects job completion", async () => {
-      const manager = new JobManager({ jobsDir });
-
-      // Create a running job
-      const created = await createTestJob({
-        agent: "test-agent",
-        status: "running",
-      });
-
-      const stream = await manager.streamJobOutput(created.id);
-      let endReceived = false;
-
-      stream.on("end", () => {
-        endReceived = true;
-      });
-
-      // Complete the job while streaming
-      await updateJob(jobsDir, created.id, {
-        status: "completed",
-        finished_at: new Date().toISOString(),
-        exit_reason: "success",
-      });
-
-      // Wait for polling to detect completion (poll interval is 1000ms)
-      await new Promise((resolve) => setTimeout(resolve, 1500));
-
-      stream.stop();
-
-      expect(endReceived).toBe(true);
-    });
-
-    it("handles stream stop during polling", async () => {
-      const manager = new JobManager({ jobsDir });
-
-      // Create a running job
-      const created = await createTestJob({
-        agent: "test-agent",
-        status: "running",
-      });
-
-      const stream = await manager.streamJobOutput(created.id);
-
-      // Immediately stop the stream
-      stream.stop();
-
-      // Wait to ensure polling would have run
-      await new Promise((resolve) => setTimeout(resolve, 150));
-
-      // Should not crash
-      expect(true).toBe(true);
-    });
-  });
-
-  describe("applyRetention() edge cases", () => {
-    it("handles empty jobs directory", async () => {
-      const manager = new JobManager({
-        jobsDir,
-        retention: { maxJobsPerAgent: 2 },
-      });
-
-      // No jobs created
-      const deleted = await manager.applyRetention();
-      expect(deleted).toBe(0);
-    });
-
-    it("handles jobs within retention limits", async () => {
-      const manager = new JobManager({
-        jobsDir,
-        retention: { maxJobsPerAgent: 10, maxTotalJobs: 100 },
-      });
-
-      // Create fewer jobs than limits
-      await createTestJob({ agent: "agent-1", status: "completed" });
-      await createTestJob({ agent: "agent-1", status: "completed" });
-
-      const deleted = await manager.applyRetention();
-      expect(deleted).toBe(0);
-
-      const result = await manager.getJobs();
-      expect(result.total).toBe(2);
-    });
-
-    it("deletes output files when applying retention", async () => {
-      const manager = new JobManager({
-        jobsDir,
-        retention: { maxJobsPerAgent: 1 },
-      });
-
-      // Create job with output
-      const job1 = await createTestJob({
-        agent: "agent-1",
-        status: "completed",
-      });
-      await appendJobOutput(jobsDir, job1.id, {
-        type: "assistant",
-        content: "Output to be deleted",
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 10));
-
-      // Create newer job
-      await createTestJob({ agent: "agent-1", status: "completed" });
-
-      // Apply retention
-      await manager.applyRetention();
-
-      // Old job and its output should be deleted
-      const result = await manager.getJobs();
-      expect(result.total).toBe(1);
-    });
-
-    it("logs warning when delete output file fails (non-ENOENT)", async () => {
-      const warnMessages: string[] = [];
-      const manager = new JobManager({
-        jobsDir,
-        retention: { maxJobsPerAgent: 1 },
-        logger: {
-          warn: (msg) => warnMessages.push(msg),
-          debug: vi.fn(),
-        },
-      });
-
-      // Create two jobs so one will be deleted
-      const job1 = await createTestJob({
-        agent: "agent-1",
-        status: "completed",
-      });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      await createTestJob({ agent: "agent-1", status: "completed" });
-
-      // Make the output path a directory so unlink will fail with EISDIR
-      // (correct path format without .output.)
-      const outputDir = join(jobsDir, `${job1.id}.jsonl`);
-      await mkdir(outputDir, { recursive: true });
-
-      // Apply retention
-      await manager.applyRetention();
-
-      // Should have logged a warning about failing to delete output file
-      expect(warnMessages.some((m) => m.includes("Failed to delete output file"))).toBe(true);
-    });
-  });
-
-  describe("logger functionality", () => {
-    it("uses provided logger", async () => {
-      const warnMessages: string[] = [];
-      const debugMessages: string[] = [];
-
-      const manager = new JobManager({
-        jobsDir,
-        retention: { maxJobsPerAgent: 1 },
-        logger: {
-          warn: (msg) => warnMessages.push(msg),
-          debug: (msg) => debugMessages.push(msg),
-        },
-      });
-
-      // Create jobs to trigger retention
-      await createTestJob({ agent: "agent-1", status: "completed" });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      await createTestJob({ agent: "agent-1", status: "completed" });
-
-      await manager.applyRetention();
-
-      // Debug message should have been logged
-      expect(debugMessages.some((m) => m.includes("retention"))).toBe(true);
-    });
-
-    it("uses default console logger when none provided", async () => {
-      // Just verify it doesn't crash
-      const manager = new JobManager({ jobsDir });
-      await createTestJob({ agent: "agent-1", status: "completed" });
-
-      const job = await manager.getJob(
-        (await manager.getJobs()).jobs[0].id
-      );
-      expect(job).toBeDefined();
-    });
-  });
-});