@herdctl/core 0.0.1

package/src/scheduler/__tests__/schedule-runner.test.ts

@@ -0,0 +1,798 @@
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  vi,
+} from "vitest";
+import { mkdir, rm, realpath } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  runSchedule,
+  buildSchedulePrompt,
+  type RunScheduleOptions,
+  type ScheduleRunnerLogger,
+} from "../schedule-runner.js";
+import type { ResolvedAgent, Schedule } from "../../config/index.js";
+import type { ScheduleState } from "../../state/schemas/fleet-state.js";
+import type { SDKQueryFunction, SDKMessage } from "../../runner/index.js";
+import type {
+  WorkSourceManager,
+  WorkItem,
+  GetNextWorkItemResult,
+  WorkResult,
+} from "../../work-sources/index.js";
+import { readFleetState } from "../../state/fleet-state.js";
+
+// Helper to create a temp directory
+async function createTempDir(): Promise<string> {
+  const baseDir = join(
+    tmpdir(),
+    `herdctl-schedule-runner-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
+  );
+  await mkdir(baseDir, { recursive: true });
+  return await realpath(baseDir);
+}
+
+// Helper to create a mock logger
+function createMockLogger(): ScheduleRunnerLogger & {
+  debugs: string[];
+  infos: string[];
+  warnings: string[];
+  errors: string[];
+} {
+  const debugs: string[] = [];
+  const infos: string[] = [];
+  const warnings: string[] = [];
+  const errors: string[] = [];
+  return {
+    debugs,
+    infos,
+    warnings,
+    errors,
+    debug: (message: string) => debugs.push(message),
+    info: (message: string) => infos.push(message),
+    warn: (message: string) => warnings.push(message),
+    error: (message: string) => errors.push(message),
+  };
+}
+
+// Helper to create a test agent
+function createTestAgent(
+  name: string,
+  overrides?: Partial<ResolvedAgent>
+): ResolvedAgent {
+  return {
+    name,
+    configPath: `/fake/path/${name}.yaml`,
+    ...overrides,
+  } as ResolvedAgent;
+}
+
+// Helper to create a test schedule
+function createTestSchedule(overrides?: Partial<Schedule>): Schedule {
+  return {
+    type: "interval",
+    interval: "1h",
+    prompt: "Default test prompt",
+    ...overrides,
+  } as Schedule;
+}
+
+// Helper to create a test schedule state
+function createTestScheduleState(overrides?: Partial<ScheduleState>): ScheduleState {
+  return {
+    status: "idle",
+    last_run_at: null,
+    next_run_at: null,
+    last_error: null,
+    ...overrides,
+  };
+}
+
+// Helper to create a test work item
+function createTestWorkItem(overrides?: Partial<WorkItem>): WorkItem {
+  return {
+    id: "github:123",
+    source: "github",
+    externalId: "123",
+    title: "Fix authentication bug",
+    description: "Users are getting logged out unexpectedly",
+    priority: "high",
+    labels: ["bug", "auth"],
+    metadata: {},
+    url: "https://github.com/org/repo/issues/123",
+    createdAt: new Date("2024-01-01"),
+    updatedAt: new Date("2024-01-02"),
+    ...overrides,
+  };
+}
+
+// Helper to create a mock SDK query function
+function createMockSDKQuery(
+  messages: SDKMessage[] = []
+): SDKQueryFunction {
+  return async function* mockQuery() {
+    // Emit init message with session_id
+    yield {
+      type: "system" as const,
+      subtype: "init",
+      session_id: "test-session-123",
+    };
+
+    // Emit any provided messages
+    for (const message of messages) {
+      yield message;
+    }
+
+    // Emit result message
+    yield {
+      type: "assistant" as const,
+      content: "Task completed successfully",
+    };
+  };
+}
+
+// Helper to create a mock work source manager
+function createMockWorkSourceManager(
+  nextWorkResult?: GetNextWorkItemResult
+): WorkSourceManager & {
+  getNextWorkItemCalls: Array<{ agent: ResolvedAgent }>;
+  reportOutcomeCalls: Array<{ taskId: string; result: WorkResult }>;
+  releaseWorkItemCalls: Array<{ taskId: string; reason?: string }>;
+} {
+  const getNextWorkItemCalls: Array<{ agent: ResolvedAgent }> = [];
+  const reportOutcomeCalls: Array<{ taskId: string; result: WorkResult }> = [];
+  const releaseWorkItemCalls: Array<{ taskId: string; reason?: string }> = [];
+
+  return {
+    getNextWorkItemCalls,
+    reportOutcomeCalls,
+    releaseWorkItemCalls,
+    getNextWorkItem: vi.fn(async (agent) => {
+      getNextWorkItemCalls.push({ agent });
+      return nextWorkResult ?? { item: null, claimed: false };
+    }),
+    reportOutcome: vi.fn(async (taskId, result) => {
+      reportOutcomeCalls.push({ taskId, result });
+    }),
+    releaseWorkItem: vi.fn(async (taskId, options) => {
+      releaseWorkItemCalls.push({ taskId, reason: options?.reason });
+      return { success: true };
+    }),
+    getAdapter: vi.fn(async () => null),
+    clearCache: vi.fn(),
+  };
+}
+
+describe("buildSchedulePrompt", () => {
+  describe("without work item", () => {
+    it("returns schedule prompt when configured", () => {
+      const schedule = createTestSchedule({ prompt: "Check for updates" });
+      const result = buildSchedulePrompt(schedule);
+      expect(result).toBe("Check for updates");
+    });
+
+    it("returns default prompt when no schedule prompt", () => {
+      const schedule = createTestSchedule({ prompt: undefined });
+      const result = buildSchedulePrompt(schedule);
+      expect(result).toBe("Execute scheduled task.");
+    });
+  });
+
+  describe("with work item", () => {
+    it("combines schedule prompt and work item", () => {
+      const schedule = createTestSchedule({ prompt: "Process this issue:" });
+      const workItem = createTestWorkItem();
+
+      const result = buildSchedulePrompt(schedule, workItem);
+
+      expect(result).toContain("Process this issue:");
+      expect(result).toContain("## Work Item: Fix authentication bug");
+      expect(result).toContain("Users are getting logged out unexpectedly");
+      expect(result).toContain("**Source:** github");
+      expect(result).toContain("**Priority:** high");
+      expect(result).toContain("**Labels:** bug, auth");
+    });
+
+    it("works with work item alone (no schedule prompt)", () => {
+      const schedule = createTestSchedule({ prompt: undefined });
+      const workItem = createTestWorkItem({
+        title: "Add new feature",
+        description: "Implement the widget",
+      });
+
+      const result = buildSchedulePrompt(schedule, workItem);
+
+      expect(result).toContain("## Work Item: Add new feature");
+      expect(result).toContain("Implement the widget");
+      expect(result).not.toContain("undefined");
+    });
+
+    it("includes work item URL", () => {
+      const schedule = createTestSchedule();
+      const workItem = createTestWorkItem({
+        url: "https://github.com/org/repo/issues/456",
+      });
+
+      const result = buildSchedulePrompt(schedule, workItem);
+
+      expect(result).toContain("**URL:** https://github.com/org/repo/issues/456");
+    });
+
+    it("handles work item without labels", () => {
+      const schedule = createTestSchedule();
+      const workItem = createTestWorkItem({ labels: [] });
+
+      const result = buildSchedulePrompt(schedule, workItem);
+
+      expect(result).not.toContain("**Labels:**");
+    });
+  });
+});
+
+describe("runSchedule", () => {
+  let tempDir: string;
+  let mockLogger: ReturnType<typeof createMockLogger>;
+
+  beforeEach(async () => {
+    tempDir = await createTempDir();
+    // Create jobs and sessions directories for job executor
+    await mkdir(join(tempDir, "jobs"), { recursive: true });
+    await mkdir(join(tempDir, "sessions"), { recursive: true });
+    mockLogger = createMockLogger();
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe("basic execution", () => {
+    it("executes a schedule successfully", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({ prompt: "Do the thing" });
+      const sdkQuery = createMockSDKQuery();
+
+      const result = await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        logger: mockLogger,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.jobId).toBeDefined();
+      expect(result.sessionId).toBe("test-session-123");
+      expect(result.processedWorkItem).toBe(false);
+      expect(result.workItem).toBeUndefined();
+    });
+
+    it("updates schedule state to running during execution", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule();
+
+      // Track state during execution
+      let stateWhileRunning: ScheduleState | undefined;
+
+      const sdkQuery: SDKQueryFunction = async function* () {
+        // Read state during execution
+        const fleetState = await readFleetState(join(tempDir, "state.yaml"));
+        stateWhileRunning = fleetState.agents["test-agent"]?.schedules?.hourly;
+
+        yield { type: "system" as const, subtype: "init", session_id: "test" };
+        yield { type: "assistant" as const, content: "Done" };
+      };
+
+      await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        logger: mockLogger,
+      });
+
+      expect(stateWhileRunning?.status).toBe("running");
+    });
+
+    it("updates schedule state with last_run_at after completion", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({ interval: "1h" });
+      const sdkQuery = createMockSDKQuery();
+
+      const beforeRun = new Date();
+
+      await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        logger: mockLogger,
+      });
+
+      const fleetState = await readFleetState(join(tempDir, "state.yaml"));
+      const scheduleState = fleetState.agents["test-agent"]?.schedules?.hourly;
+
+      expect(scheduleState?.status).toBe("idle");
+      expect(scheduleState?.last_run_at).toBeDefined();
+      expect(new Date(scheduleState!.last_run_at!).getTime()).toBeGreaterThanOrEqual(
+        beforeRun.getTime()
+      );
+    });
+
+    it("calculates next_run_at based on interval", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({ interval: "1h" });
+      const sdkQuery = createMockSDKQuery();
+
+      await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        logger: mockLogger,
+      });
+
+      const fleetState = await readFleetState(join(tempDir, "state.yaml"));
+      const scheduleState = fleetState.agents["test-agent"]?.schedules?.hourly;
+
+      expect(scheduleState?.next_run_at).toBeDefined();
+
+      // Next run should be approximately 1 hour from now
+      const nextRun = new Date(scheduleState!.next_run_at!);
+      const now = new Date();
+      const diffMs = nextRun.getTime() - now.getTime();
+      const diffHours = diffMs / (1000 * 60 * 60);
+
+      expect(diffHours).toBeGreaterThan(0.9);
+      expect(diffHours).toBeLessThan(1.1);
+    });
+
+    it("passes correct trigger type and schedule name to executor", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule();
+
+      // We can't easily inspect what was passed to the executor,
+      // but we can verify the job was created correctly by checking logs
+      const sdkQuery = createMockSDKQuery();
+
+      const result = await runSchedule({
+        agent,
+        scheduleName: "my-schedule",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        logger: mockLogger,
+      });
+
+      expect(result.success).toBe(true);
+      expect(mockLogger.infos.some((m) => m.includes("my-schedule"))).toBe(true);
+    });
+  });
+
+  describe("with work source", () => {
+    it("fetches work item when schedule has work_source", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({
+        prompt: "Process issue:",
+        work_source: { type: "github", repo: "org/repo" } as const,
+      });
+      const workItem = createTestWorkItem();
+      const workSourceManager = createMockWorkSourceManager({
+        item: workItem,
+        claimed: true,
+        claimResult: { success: true, workItem },
+      });
+      const sdkQuery = createMockSDKQuery();
+
+      const result = await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        workSourceManager,
+        logger: mockLogger,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.processedWorkItem).toBe(true);
+      expect(result.workItem).toBe(workItem);
+      expect(workSourceManager.getNextWorkItemCalls).toHaveLength(1);
+    });
+
+    it("reports outcome to work source after successful execution", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({
+        work_source: { type: "github", repo: "org/repo" } as const,
+      });
+      const workItem = createTestWorkItem();
+      const workSourceManager = createMockWorkSourceManager({
+        item: workItem,
+        claimed: true,
+        claimResult: { success: true, workItem },
+      });
+      const sdkQuery = createMockSDKQuery();
+
+      await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        workSourceManager,
+        logger: mockLogger,
+      });
+
+      expect(workSourceManager.reportOutcomeCalls).toHaveLength(1);
+      expect(workSourceManager.reportOutcomeCalls[0].taskId).toBe(workItem.id);
+      expect(workSourceManager.reportOutcomeCalls[0].result.outcome).toBe("success");
+    });
+
+    it("reports failure outcome when job fails", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({
+        work_source: { type: "github", repo: "org/repo" } as const,
+      });
+      const workItem = createTestWorkItem();
+      const workSourceManager = createMockWorkSourceManager({
+        item: workItem,
+        claimed: true,
+        claimResult: { success: true, workItem },
+      });
+
+      // Create SDK query that produces an error
+      const sdkQuery: SDKQueryFunction = async function* () {
+        yield { type: "system" as const, subtype: "init", session_id: "test" };
+        yield { type: "error" as const, message: "API error", code: "API_ERROR" };
+      };
+
+      await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        workSourceManager,
+        logger: mockLogger,
+      });
+
+      expect(workSourceManager.reportOutcomeCalls).toHaveLength(1);
+      expect(workSourceManager.reportOutcomeCalls[0].result.outcome).toBe("failure");
+    });
+
+    it("continues when no work is available", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({
+        work_source: { type: "github", repo: "org/repo" } as const,
+      });
+      const workSourceManager = createMockWorkSourceManager({
+        item: null,
+        claimed: false,
+      });
+      const sdkQuery = createMockSDKQuery();
+
+      const result = await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        workSourceManager,
+        logger: mockLogger,
+      });
+
+      // Still runs with schedule prompt, just no work item
+      expect(result.success).toBe(true);
+      expect(result.processedWorkItem).toBe(false);
+      expect(result.workItem).toBeUndefined();
+      expect(workSourceManager.reportOutcomeCalls).toHaveLength(0);
+    });
+
+    it("handles claim failure gracefully", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({
+        work_source: { type: "github", repo: "org/repo" } as const,
+      });
+      const workItem = createTestWorkItem();
+      const workSourceManager = createMockWorkSourceManager({
+        item: workItem,
+        claimed: false,
+        claimResult: { success: false, reason: "already_claimed" },
+      });
+      const sdkQuery = createMockSDKQuery();
+
+      const result = await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        workSourceManager,
+        logger: mockLogger,
+      });
+
+      // Should still run, just without work item
+      expect(result.success).toBe(true);
+      expect(result.processedWorkItem).toBe(false);
+      expect(mockLogger.warnings.some((m) => m.includes("claim failed"))).toBe(true);
+    });
+
+    it("skips work source when no manager provided", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({
+        prompt: "Test",
+        work_source: { type: "github", repo: "org/repo" } as const,
+      });
+      const sdkQuery = createMockSDKQuery();
+
+      const result = await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        // No workSourceManager provided
+        logger: mockLogger,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.processedWorkItem).toBe(false);
+    });
+  });
+
+  describe("error handling", () => {
+    it("reports failure outcome when SDK throws", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({
+        work_source: { type: "github", repo: "org/repo" } as const,
+      });
+      const workItem = createTestWorkItem();
+      const workSourceManager = createMockWorkSourceManager({
+        item: workItem,
+        claimed: true,
+        claimResult: { success: true, workItem },
+      });
+
+      // Create SDK query that throws - JobExecutor catches this and returns failed result
+      const sdkQuery: SDKQueryFunction = async function* () {
+        throw new Error("Unexpected SDK failure");
+      };
+
+      const result = await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        workSourceManager,
+        logger: mockLogger,
+      });
+
+      // JobExecutor catches SDK errors and returns failed result
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+
+      // Work outcome should still be reported as failure
+      expect(workSourceManager.reportOutcomeCalls).toHaveLength(1);
+      expect(workSourceManager.reportOutcomeCalls[0].result.outcome).toBe("failure");
+    });
+
+    it("records error in schedule state on SDK failure", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule();
+
+      // Create SDK query that throws - JobExecutor catches this
+      const sdkQuery: SDKQueryFunction = async function* () {
+        throw new Error("Execution failed");
+      };
+
+      const result = await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        logger: mockLogger,
+      });
+
+      expect(result.success).toBe(false);
+
+      const fleetState = await readFleetState(join(tempDir, "state.yaml"));
+      const scheduleState = fleetState.agents["test-agent"]?.schedules?.hourly;
+
+      expect(scheduleState?.status).toBe("idle");
+      // Error message contains the original error but may be wrapped
+      expect(scheduleState?.last_error).toContain("Execution failed");
+    });
+
+    it("still calculates next_run_at on SDK failure", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({ interval: "30m" });
+
+      const sdkQuery: SDKQueryFunction = async function* () {
+        throw new Error("Execution failed");
+      };
+
+      const result = await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        logger: mockLogger,
+      });
+
+      expect(result.success).toBe(false);
+
+      const fleetState = await readFleetState(join(tempDir, "state.yaml"));
+      const scheduleState = fleetState.agents["test-agent"]?.schedules?.hourly;
+
+      // Should still have calculated next_run_at
+      expect(scheduleState?.next_run_at).toBeDefined();
+    });
+
+    it("continues if reporting outcome fails", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({
+        work_source: { type: "github", repo: "org/repo" } as const,
+      });
+      const workItem = createTestWorkItem();
+      const workSourceManager = createMockWorkSourceManager({
+        item: workItem,
+        claimed: true,
+        claimResult: { success: true, workItem },
+      });
+
+      // Make reportOutcome throw
+      (workSourceManager.reportOutcome as ReturnType<typeof vi.fn>).mockRejectedValue(
+        new Error("Report failed")
+      );
+
+      const sdkQuery = createMockSDKQuery();
+
+      const result = await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        workSourceManager,
+        logger: mockLogger,
+      });
+
+      // Should still succeed overall
+      expect(result.success).toBe(true);
+      expect(mockLogger.errors.some((m) => m.includes("Report failed"))).toBe(true);
+    });
+  });
+
+  describe("logging", () => {
+    it("logs schedule start", async () => {
+      const agent = createTestAgent("my-agent");
+      const schedule = createTestSchedule();
+      const sdkQuery = createMockSDKQuery();
+
+      await runSchedule({
+        agent,
+        scheduleName: "my-schedule",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        logger: mockLogger,
+      });
+
+      expect(
+        mockLogger.infos.some(
+          (m) => m.includes("Running") && m.includes("my-agent/my-schedule")
+        )
+      ).toBe(true);
+    });
+
+    it("logs schedule completion", async () => {
+      const agent = createTestAgent("my-agent");
+      const schedule = createTestSchedule();
+      const sdkQuery = createMockSDKQuery();
+
+      await runSchedule({
+        agent,
+        scheduleName: "my-schedule",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        logger: mockLogger,
+      });
+
+      expect(
+        mockLogger.infos.some(
+          (m) => m.includes("Completed") && m.includes("my-agent/my-schedule")
+        )
+      ).toBe(true);
+    });
+
+    it("logs work item claim", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({
+        work_source: { type: "github", repo: "org/repo" } as const,
+      });
+      const workItem = createTestWorkItem({ title: "Important task" });
+      const workSourceManager = createMockWorkSourceManager({
+        item: workItem,
+        claimed: true,
+        claimResult: { success: true, workItem },
+      });
+      const sdkQuery = createMockSDKQuery();
+
+      await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        workSourceManager,
+        logger: mockLogger,
+      });
+
+      expect(
+        mockLogger.infos.some(
+          (m) => m.includes("Claimed") && m.includes("Important task")
+        )
+      ).toBe(true);
+    });
+
+    it("logs outcome reporting", async () => {
+      const agent = createTestAgent("test-agent");
+      const schedule = createTestSchedule({
+        work_source: { type: "github", repo: "org/repo" } as const,
+      });
+      const workItem = createTestWorkItem();
+      const workSourceManager = createMockWorkSourceManager({
+        item: workItem,
+        claimed: true,
+        claimResult: { success: true, workItem },
+      });
+      const sdkQuery = createMockSDKQuery();
+
+      await runSchedule({
+        agent,
+        scheduleName: "hourly",
+        schedule,
+        scheduleState: createTestScheduleState(),
+        stateDir: tempDir,
+        sdkQuery,
+        workSourceManager,
+        logger: mockLogger,
+      });
+
+      expect(
+        mockLogger.infos.some(
+          (m) => m.includes("Reported outcome") && m.includes(workItem.id)
+        )
+      ).toBe(true);
+    });
+  });
+});