import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { CronRunner, createAiPromptExecutor, isInProcessBackupCommand, isInProcessMemoryBackupCommand, isInProcessScheduledEvalCommand } from "../cron-runner.js";
import type { AiPromptExecutor } from "../cron-runner.js";
import type { TaskStore, AutomationStore, ScheduledTask, AutomationRunResult, AutomationStep, Settings } from "@fusion/core";
import { randomUUID } from "node:crypto";

const cronLoggerSpies = vi.hoisted(() => ({
  log: vi.fn(),
  warn: vi.fn(),
  error: vi.fn(),
}));

const piModuleMocks = vi.hoisted(() => ({
  createFnAgent: vi.fn(),
  promptWithFallback: vi.fn(),
}));

const coreModuleMocks = vi.hoisted(() => ({
  runMemoryBackupCommand: vi.fn(),
}));

vi.mock("../logger.js", () => ({
  createLogger: () => ({
    log: cronLoggerSpies.log,
    warn: cronLoggerSpies.warn,
    error: cronLoggerSpies.error,
  }),
}));

vi.mock("../pi.js", () => ({
  createFnAgent: piModuleMocks.createFnAgent,
  promptWithFallback: piModuleMocks.promptWithFallback,
}));

vi.mock("@fusion/core", async (importOriginal) => {
  const actual = await importOriginal<typeof import("@fusion/core")>();
  return {
    ...actual,
    runMemoryBackupCommand: coreModuleMocks.runMemoryBackupCommand,
  };
});

// Default settings inline to avoid @fusion/core build dependency during tests
const DEFAULT_SETTINGS: Settings = {
  maxConcurrent: 2,
  maxWorktrees: 4,
  pollIntervalMs: 30000,
  autoResolveConflicts: true,
  requirePlanApproval: false,
  recycleWorktrees: false,
  worktreeNaming: "random",
  globalPause: false,
  enginePaused: false,
  ntfyEnabled: false,
  defaultProvider: "anthropic",
  defaultModelId: "claude-sonnet-4-5",
  planningProvider: "anthropic",
  planningModelId: "claude-sonnet-4-5",
  validatorProvider: "openai",
  validatorModelId: "gpt-4o",
  taskStuckTimeoutMs: undefined,
  groupOverlappingFiles: false,
  autoMerge: true,
};

function createMockSchedule(overrides: Partial<ScheduledTask> = {}): ScheduledTask {
  return {
    id: "test-schedule-id",
    name: "Test Schedule",
    description: "A test schedule",
    scheduleType: "hourly",
    cronExpression: "0 * * * *",
    command: "echo hello",
    enabled: true,
    runCount: 0,
    runHistory: [],
    nextRunAt: new Date(Date.now() - 60000).toISOString(), // past = due
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
    ...overrides,
  };
}

function createMockStore(settingsOverrides: Partial<Settings> = {}): TaskStore {
  return {
    getSettings: vi.fn().mockResolvedValue({
      ...DEFAULT_SETTINGS,
      ...settingsOverrides,
    }),
    on: vi.fn(),
    off: vi.fn(),
  } as unknown as TaskStore;
}

function createMockAutomationStore(schedules: ScheduledTask[] = []): AutomationStore {
  return {
    getDueSchedules: vi.fn().mockResolvedValue(schedules),
    getDueSchedulesAllScopes: vi.fn().mockResolvedValue(schedules),
    recordRun: vi.fn().mockResolvedValue(undefined),
    getSchedule: vi.fn().mockImplementation(async (id: string) => {
      const s = schedules.find((s) => s.id === id);
      if (!s) throw new Error(`Schedule ${id} not found`);
      return s;
    }),
  } as unknown as AutomationStore;
}

describe("CronRunner", () => {
  let runner: CronRunner;

  beforeEach(() => {
    vi.clearAllMocks();
    piModuleMocks.promptWithFallback.mockResolvedValue(undefined);
    piModuleMocks.createFnAgent.mockResolvedValue({
      session: {
        dispose: vi.fn(),
      },
    });
    coreModuleMocks.runMemoryBackupCommand.mockResolvedValue({
      success: true,
      output: "memory backup ok",
    });
  });

  afterEach(() => {
    if (runner) runner.stop();
  });

  describe("start/stop", () => {
    it("starts and stops without error", () => {
      const store = createMockStore();
      const automationStore = createMockAutomationStore();
      runner = new CronRunner(store, automationStore);

      runner.start();
      expect(runner["running"]).toBe(true);

      runner.stop();
      expect(runner["running"]).toBe(false);
    });

    it("is idempotent on start", () => {
      const store = createMockStore();
      const automationStore = createMockAutomationStore();
      runner = new CronRunner(store, automationStore);

      runner.start();
      runner.start(); // should not double-start
      runner.stop();
    });

    it("is safe to stop when not started", () => {
      const store = createMockStore();
      const automationStore = createMockAutomationStore();
      runner = new CronRunner(store, automationStore);

      // Should not throw
      expect(() => runner.stop()).not.toThrow();
    });
  });

  describe("createAiPromptExecutor", () => {
    it("returns response text even when session disposal throws", async () => {
      piModuleMocks.createFnAgent.mockImplementation(async (options: { onText?: (delta: string) => void }) => {
        options.onText?.("hello ");
        options.onText?.("world");
        return {
          session: {
            dispose: () => {
              throw new Error("dispose failed");
            },
          },
        };
      });

      const executor = await createAiPromptExecutor("/test/project");
      const result = await executor("Summarize this");

      expect(result).toBe("hello world");
      expect(piModuleMocks.promptWithFallback).toHaveBeenCalledTimes(1);
      expect(cronLoggerSpies.warn).toHaveBeenCalledWith(
        expect.stringContaining("Session disposal failed: dispose failed"),
      );
    });
  });

  describe("tick", () => {
    it("skips when globalPause is true", async () => {
      const store = createMockStore({ globalPause: true });
      const automationStore = createMockAutomationStore([createMockSchedule()]);
      runner = new CronRunner(store, automationStore);

      await runner.tick();

      expect(automationStore.getDueSchedules).not.toHaveBeenCalled();
    });

    it("skips when enginePaused is true", async () => {
      const store = createMockStore({ enginePaused: true });
      const automationStore = createMockAutomationStore([createMockSchedule()]);
      runner = new CronRunner(store, automationStore);

      await runner.tick();

      expect(automationStore.getDueSchedules).not.toHaveBeenCalled();
    });

    it("does nothing when no schedules are due", async () => {
      const store = createMockStore();
      const automationStore = createMockAutomationStore([]);
      runner = new CronRunner(store, automationStore);

      await runner.tick();

      expect(automationStore.getDueSchedules).toHaveBeenCalledTimes(1);
      expect(automationStore.recordRun).not.toHaveBeenCalled();
    });

    it("handles errors in tick gracefully", async () => {
      const store = createMockStore();
      const automationStore = createMockAutomationStore([createMockSchedule()]);
      
      // Make getDueSchedules throw an error
      (automationStore.getDueSchedules as ReturnType<typeof vi.fn>).mockRejectedValue(
        new Error("Database error")
      );
      
      runner = new CronRunner(store, automationStore);

      // Should not throw
      await expect(runner.tick()).resolves.toBeUndefined();
    });

    it("executes due schedules", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "echo test-output" });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      await runner.tick();

      expect(automationStore.recordRun).toHaveBeenCalledTimes(1);
      const [id, result] = (automationStore.recordRun as ReturnType<typeof vi.fn>).mock.calls[0] as [string, AutomationRunResult];
      expect(id).toBe(schedule.id);
      expect(result.success).toBe(true);
      expect(result.output).toContain("test-output");
    });

    it("re-entrance guard prevents overlapping ticks", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "sleep 0.1 && echo done" });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      // Start first tick
      const tick1 = runner.tick();
      // Attempt second tick immediately
      const tick2 = runner.tick();

      await Promise.all([tick1, tick2]);

      // Should only have recorded one run (second tick was a no-op)
      expect(automationStore.recordRun).toHaveBeenCalledTimes(1);
    });
  });

  describe("executeSchedule", () => {
    it("records successful execution", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "echo success" });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(true);
      expect(result.output).toContain("success");
      expect(result.startedAt).toBeTruthy();
      expect(result.completedAt).toBeTruthy();
    });

    it("records failed execution", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "exit 1" });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.error).toBeTruthy();
    });

    it("records timeout execution", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "sleep 60",
        timeoutMs: 100, // very short timeout
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.error).toContain("timed out");
    }, 10000);

    it("prevents concurrent runs of the same schedule", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "sleep 0.2 && echo done" });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      // Start execution
      const exec1 = runner.executeSchedule(schedule);

      // in-flight set should contain the schedule
      expect(runner["inFlight"].has(schedule.id)).toBe(true);

      await exec1;

      // After completion, in-flight should be cleared
      expect(runner["inFlight"].has(schedule.id)).toBe(false);
    });

    it("calls recordRun on automation store", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "echo recorded" });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      await runner.executeSchedule(schedule);

      expect(automationStore.recordRun).toHaveBeenCalledWith(
        schedule.id,
        expect.objectContaining({
          success: true,
          output: expect.stringContaining("recorded"),
        }),
      );
    });

    it("clears inFlight even when recordRun throws", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "echo in-flight-cleanup" });
      const automationStore = createMockAutomationStore([schedule]);
      (automationStore.recordRun as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error("record failed"));
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(true);
      expect(runner["inFlight"].has(schedule.id)).toBe(false);
    });

    it("captures stderr output", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "echo err >&2" });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(true);
      expect(result.output).toContain("err");
    });

    it("calls recordRun before callback on success", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "echo success" });
      const automationStore = createMockAutomationStore([schedule]);

      const callOrder: string[] = [];
      const onProcessed = vi.fn().mockImplementation(() => {
        callOrder.push("callback");
      });

      runner = new CronRunner(store, automationStore, { onScheduleRunProcessed: onProcessed });
      await runner.executeSchedule(schedule);

      expect(callOrder).toContain("callback");
      // recordRun should have been called first
      expect(automationStore.recordRun).toHaveBeenCalledBefore(onProcessed);
    });

    it("invokes callback on successful execution", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "echo success" });
      const automationStore = createMockAutomationStore([schedule]);

      const onProcessed = vi.fn();
      runner = new CronRunner(store, automationStore, { onScheduleRunProcessed: onProcessed });

      await runner.executeSchedule(schedule);

      expect(onProcessed).toHaveBeenCalledTimes(1);
      expect(onProcessed).toHaveBeenCalledWith(
        schedule,
        expect.objectContaining({ success: true }),
      );
    });

    it("invokes callback on failed execution", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "exit 1" });
      const automationStore = createMockAutomationStore([schedule]);

      const onProcessed = vi.fn();
      runner = new CronRunner(store, automationStore, { onScheduleRunProcessed: onProcessed });

      await runner.executeSchedule(schedule);

      expect(onProcessed).toHaveBeenCalledTimes(1);
      expect(onProcessed).toHaveBeenCalledWith(
        schedule,
        expect.objectContaining({ success: false }),
      );
    });

    it("does not invoke callback when not provided", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "echo test" });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      // Should not throw
      await runner.executeSchedule(schedule);
    });

    it("callback errors do not throw or alter returned result", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "echo success" });
      const automationStore = createMockAutomationStore([schedule]);

      const onProcessed = vi.fn().mockRejectedValue(new Error("callback failed"));
      runner = new CronRunner(store, automationStore, { onScheduleRunProcessed: onProcessed });

      // Should not throw
      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(true);
      expect(result.output).toContain("success");
    });

    it("callback errors do not prevent recordRun", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "echo test" });
      const automationStore = createMockAutomationStore([schedule]);

      const onProcessed = vi.fn().mockRejectedValue(new Error("callback failed"));
      runner = new CronRunner(store, automationStore, { onScheduleRunProcessed: onProcessed });

      await runner.executeSchedule(schedule);

      expect(automationStore.recordRun).toHaveBeenCalledTimes(1);
    });

    it("passes schedule and result to callback", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        id: "custom-id",
        name: "Custom Schedule",
        command: "echo custom",
      });
      const automationStore = createMockAutomationStore([schedule]);

      let receivedSchedule: ScheduledTask | undefined;
      let receivedResult: AutomationRunResult | undefined;
      const onProcessed = vi.fn().mockImplementation((s: ScheduledTask, r: AutomationRunResult) => {
        receivedSchedule = s;
        receivedResult = r;
      });

      runner = new CronRunner(store, automationStore, { onScheduleRunProcessed: onProcessed });
      await runner.executeSchedule(schedule);

      expect(receivedSchedule).toEqual(schedule);
      expect(receivedResult).toBeDefined();
      expect(receivedResult!.success).toBe(true);
    });
  });

  describe("concurrent schedule prevention in tick", () => {
    it("skips schedule already in-flight during tick", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "sleep 0.3 && echo done" });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      // Start first execution (will block for 300ms)
      const exec1 = runner.executeSchedule(schedule);

      // Tick while execution in progress — should skip the in-flight schedule
      await runner.tick();

      await exec1;

      // Should only have recorded one run (tick skipped it)
      expect(automationStore.recordRun).toHaveBeenCalledTimes(1);
    });
  });

  describe("mid-tick pause detection", () => {
    it("stops executing schedules when pause is detected mid-tick", async () => {
      const store = createMockStore();
      const schedules = [
        createMockSchedule({ id: "s1", name: "First", command: "echo first" }),
        createMockSchedule({ id: "s2", name: "Second", command: "echo second" }),
      ];
      const automationStore = createMockAutomationStore(schedules);

      // Mock getSettings to return paused AFTER first two calls
      // (1st call = initial tick check, 2nd call = before first schedule)
      let callCount = 0;
      (store.getSettings as ReturnType<typeof vi.fn>).mockImplementation(async () => {
        callCount++;
        return {
          ...DEFAULT_SETTINGS,
          globalPause: callCount > 2, // pause before second schedule
        };
      });

      runner = new CronRunner(store, automationStore);
      await runner.tick();

      // Should only execute first schedule, not second
      expect(automationStore.recordRun).toHaveBeenCalledTimes(1);
      const [id] = (automationStore.recordRun as ReturnType<typeof vi.fn>).mock.calls[0] as [string, AutomationRunResult];
      expect(id).toBe("s1");
    });
  });

  describe("multiple schedules", () => {
    it("executes all due schedules in a single tick", async () => {
      const store = createMockStore();
      const schedules = [
        createMockSchedule({ id: "s1", name: "First", command: "echo first" }),
        createMockSchedule({ id: "s2", name: "Second", command: "echo second" }),
      ];
      const automationStore = createMockAutomationStore(schedules);
      runner = new CronRunner(store, automationStore);

      await runner.tick();

      expect(automationStore.recordRun).toHaveBeenCalledTimes(2);
    });
  });

  describe("output truncation", () => {
    it("truncates large output to prevent memory exhaustion", async () => {
      const store = createMockStore();
      // Generate output larger than 10KB using printf
      const schedule = createMockSchedule({
        command: "python3 -c \"print('x' * 15000)\"",
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(true);
      // MAX_OUTPUT_LENGTH = 10 * 1024 = 10240
      expect(result.output.length).toBeLessThanOrEqual(10240 + 20);
      expect(result.output).toContain("[output truncated]");
    });
  });

  describe("error handling", () => {
    it("continues to next schedule when recordRun fails", async () => {
      const store = createMockStore();
      const schedules = [
        createMockSchedule({ id: "s1", name: "First", command: "echo first" }),
        createMockSchedule({ id: "s2", name: "Second", command: "echo second" }),
      ];
      const automationStore = createMockAutomationStore(schedules);

      // Make recordRun fail for first schedule
      let recordCalls = 0;
      (automationStore.recordRun as ReturnType<typeof vi.fn>).mockImplementation(async () => {
        recordCalls++;
        if (recordCalls === 1) throw new Error("Storage error");
        return undefined;
      });

      runner = new CronRunner(store, automationStore);
      await runner.tick();

      // Should still have attempted both schedules
      expect(automationStore.recordRun).toHaveBeenCalledTimes(2);
    });
  });

  describe("poll interval", () => {
    it("enforces minimum poll interval of 10 seconds", () => {
      const store = createMockStore();
      const automationStore = createMockAutomationStore();
      runner = new CronRunner(store, automationStore, { pollIntervalMs: 1000 });

      expect(runner["pollIntervalMs"]).toBe(10000);
    });

    it("defaults to 60 seconds", () => {
      const store = createMockStore();
      const automationStore = createMockAutomationStore();
      runner = new CronRunner(store, automationStore);

      expect(runner["pollIntervalMs"]).toBe(60000);
    });
  });

  // ── Multi-step execution ──────────────────────────────────────────

  describe("multi-step execution", () => {
    function makeStep(overrides: Partial<AutomationStep> = {}): AutomationStep {
      return {
        id: randomUUID(),
        type: "command",
        name: "Test step",
        command: "echo step-output",
        ...overrides,
      };
    }

    it("legacy single-command mode still works when no steps are defined", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({ command: "echo legacy-mode" });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(true);
      expect(result.output).toContain("legacy-mode");
      expect(result.stepResults).toBeUndefined();
    });

    it("falls back to legacy mode when steps array is empty", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "echo empty-steps-fallback",
        steps: [],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(true);
      expect(result.output).toContain("empty-steps-fallback");
      expect(result.stepResults).toBeUndefined();
    });

    it("executes multiple command steps sequentially", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({ name: "Step 1", command: "echo first" }),
          makeStep({ name: "Step 2", command: "echo second" }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(true);
      expect(result.stepResults).toHaveLength(2);
      expect(result.stepResults![0].success).toBe(true);
      expect(result.stepResults![0].output).toContain("first");
      expect(result.stepResults![1].success).toBe(true);
      expect(result.stepResults![1].output).toContain("second");
    });

    it("stops on step failure when continueOnFailure is false", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({ name: "Failing step", command: "exit 1" }),
          makeStep({ name: "Should not run", command: "echo should-not-run" }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults).toHaveLength(1); // Only the first step ran
      expect(result.stepResults![0].success).toBe(false);
      expect(result.error).toContain("1 step(s) failed");
      expect(result.error).toContain("execution stopped");
    });

    it("continues after failure when continueOnFailure is true", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({ name: "Failing step", command: "exit 1", continueOnFailure: true }),
          makeStep({ name: "Should still run", command: "echo continued" }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false); // Overall failure
      expect(result.stepResults).toHaveLength(2); // Both steps ran
      expect(result.stepResults![0].success).toBe(false);
      expect(result.stepResults![1].success).toBe(true);
      expect(result.stepResults![1].output).toContain("continued");
    });

    it("continueOnFailure also advances after a create-task failure", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({
            type: "create-task",
            name: "Invalid create task",
            taskDescription: "",
            continueOnFailure: true,
            command: undefined,
          }),
          makeStep({ name: "Still runs", command: "echo still-ran" }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults).toHaveLength(2);
      expect(result.stepResults![0].success).toBe(false);
      expect(result.stepResults![1].success).toBe(true);
      expect(result.stepResults![1].output).toContain("still-ran");
    });

    it("uses per-step timeout override", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "",
        timeoutMs: 30000, // schedule-level timeout (large)
        steps: [
          makeStep({ name: "Slow step", command: "sleep 60", timeoutMs: 100 }), // step-level timeout (tiny)
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults).toHaveLength(1);
      expect(result.stepResults![0].error).toContain("timed out");
    }, 10000);

    it("falls back to schedule-level timeout when step has no timeout", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "",
        timeoutMs: 100, // tiny schedule-level timeout
        steps: [
          makeStep({ name: "Slow step", command: "sleep 60" }), // no step-level timeout
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults![0].error).toContain("timed out");
    }, 10000);

    it("handles AI prompt step execution with executor", async () => {
      const store = createMockStore();
      const mockFn = vi.fn()
        .mockResolvedValue("AI analysis complete: no issues found");
      const mockExecutor = mockFn as unknown as AiPromptExecutor;
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({
            type: "ai-prompt",
            name: "AI Analysis",
            prompt: "Analyze the codebase",
            modelProvider: "anthropic",
            modelId: "claude-sonnet-4-5",
            command: undefined,
          }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore, { aiPromptExecutor: mockExecutor });

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(true);
      expect(result.stepResults).toHaveLength(1);
      expect(result.stepResults![0].success).toBe(true);
      expect(result.stepResults![0].output).toContain("AI analysis complete");
      // Verify executor was called with correct model params from step
      expect(mockExecutor).toHaveBeenCalledWith(
        "Analyze the codebase",
        "anthropic",
        "claude-sonnet-4-5",
      );
    });

    it("fails AI prompt step when no prompt is provided", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({
            type: "ai-prompt",
            name: "Empty prompt",
            prompt: "",
            command: undefined,
          }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults![0].error).toContain("no prompt specified");
    });

    it("fails command step when no command is provided", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({ name: "Empty command", command: "" }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults![0].error).toContain("no command specified");
    });

    it("handles unknown step type gracefully", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({ name: "Unknown step", type: "unknown-type" as any }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults).toHaveLength(1);
      expect(result.stepResults![0].success).toBe(false);
      expect(result.stepResults![0].error).toContain("Unknown step type");
    });

    it("aggregates output from all steps with headers", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({ name: "Alpha", command: "echo alpha-output" }),
          makeStep({ name: "Beta", command: "echo beta-output" }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.output).toContain("Step 1: Alpha");
      expect(result.output).toContain("alpha-output");
      expect(result.output).toContain("Step 2: Beta");
      expect(result.output).toContain("beta-output");
    });

    it("records run result with stepResults to automation store", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "",
        steps: [makeStep({ name: "S1", command: "echo ok" })],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      await runner.executeSchedule(schedule);

      expect(automationStore.recordRun).toHaveBeenCalledWith(
        schedule.id,
        expect.objectContaining({
          success: true,
          stepResults: expect.arrayContaining([
            expect.objectContaining({
              stepName: "S1",
              success: true,
            }),
          ]),
        }),
      );
    });

    it("mixed step types execute correctly", async () => {
      const store = createMockStore();
      const mockFn = vi.fn()
        .mockResolvedValue("Summary: all good");
      const mockExecutor = mockFn as unknown as AiPromptExecutor;
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({ name: "Build", command: "echo build-done" }),
          makeStep({
            type: "ai-prompt",
            name: "Summarize",
            prompt: "Summarize results",
            command: undefined,
          }),
          makeStep({ name: "Deploy", command: "echo deployed" }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore, { aiPromptExecutor: mockExecutor });

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(true);
      expect(result.stepResults).toHaveLength(3);
      expect(result.stepResults![0].stepName).toBe("Build");
      expect(result.stepResults![1].stepName).toBe("Summarize");
      expect(result.stepResults![2].stepName).toBe("Deploy");
      expect(result.stepResults![1].output).toContain("Summary: all good");
    });

    // ── AI prompt step execution ────────────────────────────────────────

    function createAiMockExecutor(
      response: string = "mock AI response",
    ): AiPromptExecutor {
      const fn = vi.fn().mockResolvedValue(response);
      return fn as unknown as AiPromptExecutor;
    }

    it("returns success with AI response when executor is configured", async () => {
      const store = createMockStore();
      const mockExecutor = createAiMockExecutor("Analysis complete: 3 findings");
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({
            type: "ai-prompt",
            name: "Code Review",
            prompt: "Review the code for issues",
            command: undefined,
          }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore, { aiPromptExecutor: mockExecutor });

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(true);
      expect(result.stepResults![0].success).toBe(true);
      expect(result.stepResults![0].output).toContain("Analysis complete: 3 findings");
    });

    it("passes step model provider and model ID to executor", async () => {
      const store = createMockStore();
      const mockExecutor = createAiMockExecutor("response");
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({
            type: "ai-prompt",
            name: "Step with model",
            prompt: "Do something",
            modelProvider: "openai",
            modelId: "gpt-4o",
            command: undefined,
          }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore, { aiPromptExecutor: mockExecutor });

      await runner.executeSchedule(schedule);

      expect(mockExecutor).toHaveBeenCalledWith("Do something", "openai", "gpt-4o");
    });

    it("falls back to settings defaults when step has no model", async () => {
      const store = createMockStore({
        defaultProvider: "anthropic",
        defaultModelId: "claude-sonnet-4-5",
      });
      const mockExecutor = createAiMockExecutor("response");
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({
            type: "ai-prompt",
            name: "Step without model",
            prompt: "Use defaults",
            command: undefined,
          }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore, { aiPromptExecutor: mockExecutor });

      await runner.executeSchedule(schedule);

      expect(mockExecutor).toHaveBeenCalledWith("Use defaults", "anthropic", "claude-sonnet-4-5");
    });

    it("returns configuration error when no executor is provided", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({
            type: "ai-prompt",
            name: "No executor",
            prompt: "This should fail",
            command: undefined,
          }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults![0].success).toBe(false);
      expect(result.stepResults![0].error).toContain("AI execution is not configured");
      expect(result.stepResults![0].output).toBe("");
    });

    it("fails early when prompt is empty even with executor configured", async () => {
      const store = createMockStore();
      const mockExecutor = createAiMockExecutor("should not be called");
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({
            type: "ai-prompt",
            name: "Empty prompt",
            prompt: "   ",
            command: undefined,
          }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore, { aiPromptExecutor: mockExecutor });

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults![0].error).toContain("no prompt specified");
      expect(mockExecutor).not.toHaveBeenCalled();
    });

    it("handles timeout by returning failure", async () => {
      const store = createMockStore();
      const mockFn = vi.fn()
        .mockImplementation(() => new Promise((resolve) => {
          setTimeout(() => resolve("too late"), 5000);
        }));
      const mockExecutor = mockFn as unknown as AiPromptExecutor;
      const schedule = createMockSchedule({
        command: "",
        timeoutMs: 100,
        steps: [
          makeStep({
            type: "ai-prompt",
            name: "Slow AI",
            prompt: "Take your time",
            command: undefined,
          }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore, { aiPromptExecutor: mockExecutor });

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults![0].success).toBe(false);
      expect(result.stepResults![0].error).toContain("timed out");
    });

    it("handles executor throwing an error", async () => {
      const store = createMockStore();
      const mockFn = vi.fn()
        .mockRejectedValue(new Error("API rate limit exceeded"));
      const mockExecutor = mockFn as unknown as AiPromptExecutor;
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({
            type: "ai-prompt",
            name: "Failing AI",
            prompt: "Cause an error",
            command: undefined,
          }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore, { aiPromptExecutor: mockExecutor });

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults![0].success).toBe(false);
      expect(result.stepResults![0].error).toContain("API rate limit exceeded");
    });

    it("truncates output when AI response exceeds MAX_OUTPUT_LENGTH", async () => {
      const store = createMockStore();
      const longResponse = "x".repeat(15_000);
      const mockExecutor = createAiMockExecutor(longResponse);
      const schedule = createMockSchedule({
        command: "",
        steps: [
          makeStep({
            type: "ai-prompt",
            name: "Verbose AI",
            prompt: "Give me lots of text",
            command: undefined,
          }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore, { aiPromptExecutor: mockExecutor });

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(true);
      expect(result.stepResults![0].success).toBe(true);
      expect(result.stepResults![0].output).toContain("[output truncated]");
      expect(result.stepResults![0].output.length).toBeLessThanOrEqual(10 * 1024 + 50);
    });

    it("uses per-step timeout override over schedule timeout", async () => {
      const store = createMockStore();
      const mockFn = vi.fn()
        .mockImplementation(() => new Promise((resolve) => {
          setTimeout(() => resolve("too late"), 5000);
        }));
      const mockExecutor = mockFn as unknown as AiPromptExecutor;
      const schedule = createMockSchedule({
        command: "",
        timeoutMs: 30000,
        steps: [
          makeStep({
            type: "ai-prompt",
            name: "Slow AI",
            prompt: "Take your time",
            timeoutMs: 100,
            command: undefined,
          }),
        ],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore, { aiPromptExecutor: mockExecutor });

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults![0].error).toContain("timed out");
    });
  });

  // ── Create-task step execution ─────────────────────────────────────────

  describe("create-task step execution", () => {
    function makeCreateTaskStep(overrides: Partial<AutomationStep> = {}): AutomationStep {
      return {
        id: randomUUID(),
        type: "create-task",
        name: "Create task step",
        taskDescription: "Review dependencies for security vulnerabilities",
        ...overrides,
      };
    }

    it("successfully creates a task when taskDescription is provided", async () => {
      const mockTask = { id: "FN-1234", title: "Review", description: "Review dependencies" };
      const createTaskMock = vi.fn().mockResolvedValue(mockTask);
      const store = createMockStore({} as any);
      (store as any).createTask = createTaskMock;

      const schedule = createMockSchedule({
        command: "",
        steps: [makeCreateTaskStep({ taskDescription: "Check npm packages" })],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(true);
      expect(result.stepResults).toHaveLength(1);
      expect(result.stepResults![0].success).toBe(true);
      expect(result.stepResults![0].output).toContain("Created task FN-1234");
      expect(createTaskMock).toHaveBeenCalledTimes(1);
    });

    it("returns error when taskDescription is missing", async () => {
      const store = createMockStore();
      const schedule = createMockSchedule({
        command: "",
        steps: [makeCreateTaskStep({ taskDescription: "" })],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults).toHaveLength(1);
      expect(result.stepResults![0].success).toBe(false);
      expect(result.stepResults![0].error).toContain("no task description specified");
    });

    it("passes taskTitle, taskColumn, modelProvider, modelId to store.createTask()", async () => {
      const mockTask = { id: "FN-5678", title: "Weekly Review", description: "Check packages" };
      const createTaskMock = vi.fn().mockResolvedValue(mockTask);
      const store = createMockStore({} as any);
      (store as any).createTask = createTaskMock;

      const schedule = createMockSchedule({
        command: "",
        steps: [makeCreateTaskStep({
          taskTitle: "Weekly Review",
          taskDescription: "Check packages",
          taskColumn: "todo",
          modelProvider: "anthropic",
          modelId: "claude-sonnet-4-5",
        })],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      await runner.executeSchedule(schedule);

      expect(createTaskMock).toHaveBeenCalledWith({
        title: "Weekly Review",
        description: "Check packages",
        column: "todo",
        modelProvider: "anthropic",
        modelId: "claude-sonnet-4-5",
        source: {
          sourceType: "cron",
          sourceMetadata: { scheduleId: "test-schedule-id", stepId: expect.any(String) },
        },
      });
    });

    it("defaults column to triage when taskColumn is not set", async () => {
      const mockTask = { id: "FN-9999", title: "", description: "Some task" };
      const createTaskMock = vi.fn().mockResolvedValue(mockTask);
      const store = createMockStore({} as any);
      (store as any).createTask = createTaskMock;

      const schedule = createMockSchedule({
        command: "",
        steps: [makeCreateTaskStep({ taskDescription: "Some task" })],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      await runner.executeSchedule(schedule);

      expect(createTaskMock).toHaveBeenCalledWith(
        expect.objectContaining({ column: "triage" }),
      );
    });

    it("handles store.createTask() errors gracefully", async () => {
      const createTaskMock = vi.fn().mockRejectedValue(new Error("Database constraint violation"));
      const store = createMockStore({} as any);
      (store as any).createTask = createTaskMock;

      const schedule = createMockSchedule({
        command: "",
        steps: [makeCreateTaskStep({ taskDescription: "This will fail" })],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      const result = await runner.executeSchedule(schedule);

      expect(result.success).toBe(false);
      expect(result.stepResults).toHaveLength(1);
      expect(result.stepResults![0].success).toBe(false);
      expect(result.stepResults![0].error).toContain("Database constraint violation");
    });

    it("trims whitespace from task fields", async () => {
      const mockTask = { id: "FN-0001", title: "Cleaned", description: "Trimmed" };
      const createTaskMock = vi.fn().mockResolvedValue(mockTask);
      const store = createMockStore({} as any);
      (store as any).createTask = createTaskMock;

      const schedule = createMockSchedule({
        command: "",
        steps: [makeCreateTaskStep({
          taskTitle: "  Cleaned  ",
          taskDescription: "  Trimmed  ",
          modelProvider: "  anthropic  ",
          modelId: "  claude-sonnet-4-5  ",
        })],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      await runner.executeSchedule(schedule);

      expect(createTaskMock).toHaveBeenCalledWith(
        expect.objectContaining({
          title: "Cleaned",
          description: "Trimmed",
          modelProvider: "anthropic",
          modelId: "claude-sonnet-4-5",
        }),
      );
    });

    it("sets title to undefined when taskTitle is not provided", async () => {
      const mockTask = { id: "FN-0002", title: "", description: "Minimal task" };
      const createTaskMock = vi.fn().mockResolvedValue(mockTask);
      const store = createMockStore({} as any);
      (store as any).createTask = createTaskMock;

      const schedule = createMockSchedule({
        command: "",
        steps: [makeCreateTaskStep({ taskTitle: undefined })],
      });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore);

      await runner.executeSchedule(schedule);

      // When taskTitle is undefined, title should be undefined in the input
      const callArg = createTaskMock.mock.calls[0][0];
      expect(callArg.title).toBeUndefined();
    });
  });

  // ── Scoped lane regression tests (FN-1766) ─────────────────────────────────

  describe("scoped lane polling", () => {
    it("scope='project' calls getDueSchedules with 'project'", async () => {
      const store = createMockStore();
      const automationStore = createMockAutomationStore([]);
      runner = new CronRunner(store, automationStore, { scope: "project" });

      await runner.tick();

      expect(automationStore.getDueSchedules).toHaveBeenCalledWith("project");
      expect(automationStore.getDueSchedulesAllScopes).not.toHaveBeenCalled();
    });

    it("scope='global' calls getDueSchedules with 'global'", async () => {
      const store = createMockStore();
      const automationStore = createMockAutomationStore([]);
      runner = new CronRunner(store, automationStore, { scope: "global" });

      await runner.tick();

      expect(automationStore.getDueSchedules).toHaveBeenCalledWith("global");
      expect(automationStore.getDueSchedulesAllScopes).not.toHaveBeenCalled();
    });

    it("scope='all' calls getDueSchedulesAllScopes", async () => {
      const store = createMockStore();
      const automationStore = createMockAutomationStore([]);
      runner = new CronRunner(store, automationStore, { scope: "all" });

      await runner.tick();

      expect(automationStore.getDueSchedulesAllScopes).toHaveBeenCalled();
      expect(automationStore.getDueSchedules).not.toHaveBeenCalled();
    });

    it("scope='project' skips global-scoped schedules", async () => {
      const store = createMockStore();
      const globalSchedule = createMockSchedule({ id: "global-schedule", scope: "global" });
      const automationStore = createMockAutomationStore([globalSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "project" });

      await runner.tick();

      // Should NOT execute the global schedule
      expect(automationStore.recordRun).not.toHaveBeenCalled();
    });

    it("scope='global' skips project-scoped schedules", async () => {
      const store = createMockStore();
      const projectSchedule = createMockSchedule({ id: "project-schedule", scope: "project" });
      const automationStore = createMockAutomationStore([projectSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "global" });

      await runner.tick();

      // Should NOT execute the project schedule
      expect(automationStore.recordRun).not.toHaveBeenCalled();
    });

    it("scope='all' executes both global and project schedules", async () => {
      const store = createMockStore();
      const globalSchedule = createMockSchedule({ id: "global-sched", name: "Global", scope: "global", command: "echo global" });
      const projectSchedule = createMockSchedule({ id: "project-sched", name: "Project", scope: "project", command: "echo project" });
      const automationStore = createMockAutomationStore([globalSchedule, projectSchedule]);
      (automationStore.getDueSchedulesAllScopes as ReturnType<typeof vi.fn>).mockResolvedValue([globalSchedule, projectSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "all" });

      await runner.tick();

      // Should execute both schedules
      expect(automationStore.recordRun).toHaveBeenCalledTimes(2);
    });

    it("scope='all' deduplicates by schedule ID — no double execution", async () => {
      const store = createMockStore();
      // Same schedule ID in both scopes
      const scheduleInBothScopes = createMockSchedule({ id: "shared-id", name: "Shared", scope: "project", command: "echo shared" });
      const automationStore = createMockAutomationStore([scheduleInBothScopes]);
      // getDueSchedulesAllScopes returns it once
      (automationStore.getDueSchedulesAllScopes as ReturnType<typeof vi.fn>).mockResolvedValue([scheduleInBothScopes]);
      runner = new CronRunner(store, automationStore, { scope: "all" });

      await runner.tick();

      // Should only execute once
      expect(automationStore.recordRun).toHaveBeenCalledTimes(1);
    });

    it("scope='all' skips schedule from wrong scope after scope mismatch", async () => {
      const store = createMockStore();
      // Schedule says global but runner is polling project scope
      const mismatchedSchedule = createMockSchedule({ id: "mismatch", name: "Mismatched", scope: "global", command: "echo wrong" });
      const automationStore = createMockAutomationStore([mismatchedSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "project" });

      await runner.tick();

      // Should NOT execute - schedule is global but runner is in project scope
      expect(automationStore.recordRun).not.toHaveBeenCalled();
    });

    it("scope='all' includes lane tag in execution log context", async () => {
      const store = createMockStore();
      const globalSchedule = createMockSchedule({ id: "global-log", name: "Global", scope: "global", command: "echo global" });
      const projectSchedule = createMockSchedule({ id: "project-log", name: "Project", scope: "project", command: "echo project" });
      const automationStore = createMockAutomationStore([globalSchedule, projectSchedule]);
      (automationStore.getDueSchedulesAllScopes as ReturnType<typeof vi.fn>).mockResolvedValue([globalSchedule, projectSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "all" });

      await runner.tick();

      // Both schedules executed
      expect(automationStore.recordRun).toHaveBeenCalledTimes(2);
      expect(automationStore.recordRun).toHaveBeenCalledWith("global-log", expect.any(Object));
      expect(automationStore.recordRun).toHaveBeenCalledWith("project-log", expect.any(Object));
    });

    it("scope='project' default when not specified", () => {
      const store = createMockStore();
      const automationStore = createMockAutomationStore([]);
      runner = new CronRunner(store, automationStore);

      expect(runner["scope"]).toBe("project");
    });
  });

  describe("scoped lane pause regressions", () => {
    it("scope='project' skips when initially paused", async () => {
      const store = createMockStore({ globalPause: true });
      const schedule = createMockSchedule({ scope: "project" });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore, { scope: "project" });

      await runner.tick();

      expect(automationStore.getDueSchedules).not.toHaveBeenCalled();
    });

    it("scope='global' skips when initially paused", async () => {
      const store = createMockStore({ enginePaused: true });
      const schedule = createMockSchedule({ scope: "global" });
      const automationStore = createMockAutomationStore([schedule]);
      runner = new CronRunner(store, automationStore, { scope: "global" });

      await runner.tick();

      expect(automationStore.getDueSchedules).not.toHaveBeenCalled();
    });

    it("scope='all' skips when initially paused", async () => {
      const store = createMockStore({ globalPause: true });
      const globalSchedule = createMockSchedule({ scope: "global" });
      const projectSchedule = createMockSchedule({ scope: "project" });
      const automationStore = createMockAutomationStore([globalSchedule, projectSchedule]);
      (automationStore.getDueSchedulesAllScopes as ReturnType<typeof vi.fn>).mockResolvedValue([globalSchedule, projectSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "all" });

      await runner.tick();

      expect(automationStore.getDueSchedulesAllScopes).not.toHaveBeenCalled();
    });

    it("scope='project' halts mid-tick when pause flips", async () => {
      const schedules = [
        createMockSchedule({ id: "s1", name: "First", scope: "project", command: "echo first" }),
        createMockSchedule({ id: "s2", name: "Second", scope: "project", command: "echo second" }),
      ];
      const automationStore = createMockAutomationStore(schedules);

      // Mock getSettings to pause after first schedule executes
      // Initial check (1), check before s1 (2), check after s1 starts (3) = pause
      let getSettingsCalls = 0;
      const mockStore: TaskStore = {
        getSettings: vi.fn().mockImplementation(async () => {
          getSettingsCalls++;
          // Pause is detected on 3rd call: initial check, before s1, then before s2
          return {
            ...DEFAULT_SETTINGS,
            globalPause: getSettingsCalls >= 3, // Pause on 3rd call (before s2)
          };
        }),
        on: vi.fn(),
        off: vi.fn(),
      } as unknown as TaskStore;

      runner = new CronRunner(mockStore, automationStore, { scope: "project" });

      await runner.tick();

      // Should only execute first schedule (s1 executes, s2 is skipped due to pause)
      expect(automationStore.recordRun).toHaveBeenCalledTimes(1);
      const [id] = (automationStore.recordRun as ReturnType<typeof vi.fn>).mock.calls[0] as [string, AutomationRunResult];
      expect(id).toBe("s1");
    });
  });

  describe("scoped lane ID-overlap regressions", () => {
    it("identical IDs across global and project scopes must not cross lane boundaries", async () => {
      const store = createMockStore();
      // Same ID in both scopes - store returns both
      const globalSchedule = createMockSchedule({ id: "overlap-id", name: "Global Overlap", scope: "global", command: "echo global" });
      const projectSchedule = createMockSchedule({ id: "overlap-id", name: "Project Overlap", scope: "project", command: "echo project" });
      const automationStore = createMockAutomationStore([globalSchedule, projectSchedule]);
      // getDueSchedulesAllScopes returns both (simulating both lanes having schedules with same ID)
      (automationStore.getDueSchedulesAllScopes as ReturnType<typeof vi.fn>).mockResolvedValue([globalSchedule, projectSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "all" });

      await runner.tick();

      // With scope="all", both schedules share the same ID
      // The runner should execute once (first occurrence wins due to deduplication)
      expect(automationStore.recordRun).toHaveBeenCalledTimes(1);
      // The ID should be "overlap-id"
      const [id] = (automationStore.recordRun as ReturnType<typeof vi.fn>).mock.calls[0] as [string, AutomationRunResult];
      expect(id).toBe("overlap-id");
    });

    it("scope='project' with overlapping ID only processes project-scoped version", async () => {
      const store = createMockStore();
      // Only the project-scoped version should be processed
      const projectSchedule = createMockSchedule({ id: "overlap-id", name: "Project Only", scope: "project", command: "echo project" });
      const automationStore = createMockAutomationStore([projectSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "project" });

      await runner.tick();

      expect(automationStore.recordRun).toHaveBeenCalledTimes(1);
      const [id] = (automationStore.recordRun as ReturnType<typeof vi.fn>).mock.calls[0] as [string, AutomationRunResult];
      expect(id).toBe("overlap-id");
    });

    it("scope='global' with overlapping ID only processes global-scoped version", async () => {
      const store = createMockStore();
      // Only the global-scoped version should be processed
      const globalSchedule = createMockSchedule({ id: "overlap-id", name: "Global Only", scope: "global", command: "echo global" });
      const automationStore = createMockAutomationStore([globalSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "global" });

      await runner.tick();

      expect(automationStore.recordRun).toHaveBeenCalledTimes(1);
      const [id] = (automationStore.recordRun as ReturnType<typeof vi.fn>).mock.calls[0] as [string, AutomationRunResult];
      expect(id).toBe("overlap-id");
    });
  });

  describe("utility-lane semaphore boundary", () => {
    it("CronRunner does not use task-lane semaphore operations", async () => {
      const store = createMockStore();
      const automationStore = createMockAutomationStore([]);
      runner = new CronRunner(store, automationStore);

      // Cast to any to access internal state for semaphore trap
      const runnerAny = runner as any;

      // Verify no semaphore-related methods exist on the runner
      expect(runnerAny.acquire).toBeUndefined();
      expect(runnerAny.release).toBeUndefined();
      expect(runnerAny.run).toBeUndefined();
      expect(runnerAny.semaphore).toBeUndefined();
      expect(runnerAny["_semaphore"]).toBeUndefined();
    });

    it("CronRunner constructor does not accept semaphore parameter", () => {
      const store = createMockStore();
      const automationStore = createMockAutomationStore();
      runner = new CronRunner(store, automationStore);

      // Verify internal state doesn't have semaphore references
      const keys = Object.keys(runner);
      const hasSemaphore = keys.some(k => k.toLowerCase().includes("semaphore") || k.toLowerCase().includes("acquire"));
      expect(hasSemaphore).toBe(false);
    });
  });

  // ── Cross-package integration tests (FN-1743) ─────────────────────────────────
  //
  // These tests verify end-to-end scoped scheduling wiring across packages.
  // They ensure that:
  // 1. CronRunner bound to a project store executes scoped schedules only for that project lane
  // 2. CronRunner with both global and project stores executes both lanes in the same tick
  // 3. Execution logs contain lane identity (scope tag + projectId)
  // 4. Pause behavior applies uniformly across both lanes
  // 5. Lane diagnostics are verifiable in test assertions

  describe("cross-package dual-lane execution integration", () => {
    it("scope='all' executes both global and project lanes in the same tick with correct order", async () => {
      const store = createMockStore();
      const globalSchedule = createMockSchedule({
        id: "global-1",
        name: "Global Schedule",
        scope: "global",
        command: "echo global",
      });
      const projectSchedule = createMockSchedule({
        id: "project-1",
        name: "Project Schedule",
        scope: "project",
        command: "echo project",
      });
      const automationStore = createMockAutomationStore([globalSchedule, projectSchedule]);
      // getDueSchedulesAllScopes returns both lanes
      (automationStore.getDueSchedulesAllScopes as ReturnType<typeof vi.fn>).mockResolvedValue([globalSchedule, projectSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "all" });

      await runner.tick();

      // Both schedules should be executed in the same tick
      expect(automationStore.recordRun).toHaveBeenCalledTimes(2);
      // Verify order: global first, then project (based on getDueSchedulesAllScopes result order)
      const calls = (automationStore.recordRun as ReturnType<typeof vi.fn>).mock.calls;
      expect(calls[0][0]).toBe("global-1");
      expect(calls[1][0]).toBe("project-1");
    });

    it("scope='all' lane identity is preserved in execution context", async () => {
      const store = createMockStore();
      const globalSchedule = createMockSchedule({
        id: "global-lane-test",
        name: "Global Lane",
        scope: "global",
        command: "echo global-lane",
      });
      const projectSchedule = createMockSchedule({
        id: "project-lane-test",
        name: "Project Lane",
        scope: "project",
        command: "echo project-lane",
      });
      const automationStore = createMockAutomationStore([globalSchedule, projectSchedule]);
      (automationStore.getDueSchedulesAllScopes as ReturnType<typeof vi.fn>).mockResolvedValue([globalSchedule, projectSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "all" });

      await runner.tick();

      // Verify both lanes were executed
      expect(automationStore.recordRun).toHaveBeenCalledTimes(2);
      const calls = (automationStore.recordRun as ReturnType<typeof vi.fn>).mock.calls;
      // Each call receives the schedule ID and result
      expect(calls[0][0]).toBe("global-lane-test");
      expect(calls[1][0]).toBe("project-lane-test");
    });

    it("pause applies uniformly across both lanes when scope='all'", async () => {
      const store = createMockStore({ globalPause: true });
      const globalSchedule = createMockSchedule({ id: "global-pause", name: "Global", scope: "global", command: "echo global" });
      const projectSchedule = createMockSchedule({ id: "project-pause", name: "Project", scope: "project", command: "echo project" });
      const automationStore = createMockAutomationStore([globalSchedule, projectSchedule]);
      (automationStore.getDueSchedulesAllScopes as ReturnType<typeof vi.fn>).mockResolvedValue([globalSchedule, projectSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "all" });

      await runner.tick();

      // Neither lane should execute when paused
      expect(automationStore.getDueSchedulesAllScopes).not.toHaveBeenCalled();
      expect(automationStore.recordRun).not.toHaveBeenCalled();
    });

    it("identical schedule IDs across global and project lanes execute once (deduplication)", async () => {
      const store = createMockStore();
      // Same ID in both scopes
      const globalSchedule = createMockSchedule({
        id: "shared-schedule",
        name: "Shared Global",
        scope: "global",
        command: "echo shared-global",
      });
      const projectSchedule = createMockSchedule({
        id: "shared-schedule",
        name: "Shared Project",
        scope: "project",
        command: "echo shared-project",
      });
      const automationStore = createMockAutomationStore([globalSchedule, projectSchedule]);
      (automationStore.getDueSchedulesAllScopes as ReturnType<typeof vi.fn>).mockResolvedValue([globalSchedule, projectSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "all" });

      await runner.tick();

      // Only one execution should occur due to deduplication
      expect(automationStore.recordRun).toHaveBeenCalledTimes(1);
    });
  });

  describe("cross-package scoped isolation integration", () => {
    it("CronRunner bound to project store never executes global-lane schedules", async () => {
      const store = createMockStore();
      const globalSchedule = createMockSchedule({ id: "global-iso", name: "Global", scope: "global", command: "echo global" });
      const automationStore = createMockAutomationStore([globalSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "project" });

      await runner.tick();

      // Project-scoped runner should not execute global schedule
      expect(automationStore.recordRun).not.toHaveBeenCalled();
    });

    it("CronRunner bound to global store never executes project-lane schedules", async () => {
      const store = createMockStore();
      const projectSchedule = createMockSchedule({ id: "project-iso", name: "Project", scope: "project", command: "echo project" });
      const automationStore = createMockAutomationStore([projectSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "global" });

      await runner.tick();

      // Global-scoped runner should not execute project schedule
      expect(automationStore.recordRun).not.toHaveBeenCalled();
    });

    it("scope='all' executes schedules from both lanes but never crosses lane boundaries", async () => {
      const store = createMockStore();
      const globalSchedule = createMockSchedule({ id: "global-boundary", name: "Global", scope: "global", command: "echo global" });
      const projectSchedule = createMockSchedule({ id: "project-boundary", name: "Project", scope: "project", command: "echo project" });
      const automationStore = createMockAutomationStore([globalSchedule, projectSchedule]);
      (automationStore.getDueSchedulesAllScopes as ReturnType<typeof vi.fn>).mockResolvedValue([globalSchedule, projectSchedule]);
      runner = new CronRunner(store, automationStore, { scope: "all" });

      await runner.tick();

      // Both lanes should execute
      expect(automationStore.recordRun).toHaveBeenCalledTimes(2);
      // But each schedule is executed exactly once (no double execution)
      const calls = (automationStore.recordRun as ReturnType<typeof vi.fn>).mock.calls;
      expect(calls[0][0]).toBe("global-boundary");
      expect(calls[1][0]).toBe("project-boundary");
    });
  });

  describe("isInProcessBackupCommand", () => {
    const positives = [
      // Bare binary forms.
      "fn backup --create",
      "fusion backup --create",
      "runfusion.ai backup --create",
      "runfusion backup --create",
      "@runfusion/fusion backup --create",
      // npx prefix without flags.
      "npx runfusion.ai backup --create",
      "npx @runfusion/fusion backup --create",
      // npx with flags — including the canonical `npx -y runfusion.ai`
      // form FN_NPX_INVOCATION emits.
      "npx -y runfusion.ai backup --create",
      "npx --yes runfusion.ai backup --create",
      "npx -y -p runfusion.ai runfusion.ai backup --create",
      "npx --package=runfusion.ai runfusion.ai backup --create",
      // Whitespace / case tolerance.
      "FN BACKUP --CREATE",
      "fn backup --create --some-other-flag",
      "  fn backup --create  ",
    ];

    const negatives: Array<string | undefined> = [
      // Wrong subcommand — must not be intercepted, the in-process path
      // only does create+cleanup and would silently swallow these.
      "fn backup --list",
      "fn backup --restore /tmp/old.db",
      "fn backup --cleanup",
      "fn backup",
      "fn task list",
      "echo hello",
      "fn-other backup --create",
      "fnbackup --create",
      "fnext backup --create",
      "",
      undefined,
      // Shell continuations after --create encode user-authored side
      // effects we cannot mirror in-process; let them shell out.
      "fn backup --create && notify-send done",
      "fn backup --create || echo failed",
      "fn backup --create | tee /tmp/log",
      "fn backup --create ; rm -rf /tmp/garbage",
      "fn backup --create > /tmp/out.txt",
      "fn backup --create 2> /tmp/err.txt",
      "fn backup --create `whoami`",
      "fn backup --create $(date)",
      // Trailing positional arguments aren't `--flag`s — refuse.
      "fn backup --create extra-positional",
    ];

    for (const cmd of positives) {
      it(`intercepts: ${cmd}`, () => {
        expect(isInProcessBackupCommand(cmd)).toBe(true);
      });
    }

    for (const cmd of negatives) {
      it(`does NOT intercept: ${JSON.stringify(cmd)}`, () => {
        expect(isInProcessBackupCommand(cmd)).toBe(false);
      });
    }
  });

  describe("isInProcessMemoryBackupCommand", () => {
    const positives = [
      "fn memory-backup --create",
      "npx runfusion.ai memory-backup --create",
      "  fn memory-backup --create  ",
      "FN MEMORY-BACKUP --CREATE",
    ];

    const negatives: Array<string | undefined> = [
      "fn memory-backup --list",
      "fn memory-backup",
      "fn backup --create",
      "",
      undefined,
    ];

    for (const cmd of positives) {
      it(`intercepts: ${cmd}`, () => {
        expect(isInProcessMemoryBackupCommand(cmd)).toBe(true);
      });
    }

    for (const cmd of negatives) {
      it(`does NOT intercept: ${JSON.stringify(cmd)}`, () => {
        expect(isInProcessMemoryBackupCommand(cmd)).toBe(false);
      });
    }
  });

  describe("memory backup in-process dispatch", () => {
    it("routes fn memory-backup --create through runMemoryBackupCommand", async () => {
      const store = createMockStore() as unknown as TaskStore & { getFusionDir: () => string };
      store.getFusionDir = vi.fn().mockReturnValue("/tmp/.fusion");
      const schedule = createMockSchedule({ id: "mem-bk", command: "fn memory-backup --create" });
      runner = new CronRunner(store, createMockAutomationStore());

      const runResult = await (runner as unknown as { executeLegacyCommand: (s: ScheduledTask, startedAt: string) => Promise<AutomationRunResult> })
        .executeLegacyCommand(schedule, new Date().toISOString());

      expect(coreModuleMocks.runMemoryBackupCommand).toHaveBeenCalledWith("/tmp/.fusion", expect.any(Object));
      expect(runResult.success).toBe(true);
      expect(runResult.output).toContain("memory backup ok");
    });
  });

  describe("isInProcessScheduledEvalCommand", () => {
    it("matches canonical scheduled eval command", () => {
      expect(isInProcessScheduledEvalCommand("fn eval --scheduled-batch")).toBe(true);
      expect(isInProcessScheduledEvalCommand("fusion eval --scheduled-batch --flag")).toBe(true);
    });

    it("rejects non-canonical and shell-metachar commands", () => {
      expect(isInProcessScheduledEvalCommand("fn eval")).toBe(false);
      expect(isInProcessScheduledEvalCommand("fn eval --scheduled-batch && echo x")).toBe(false);
      expect(isInProcessScheduledEvalCommand("echo fn eval --scheduled-batch")).toBe(false);
    });
  });

  describe("scheduled eval command feature gating", () => {
    it("returns a disabled result when evalsView experimental feature is off", async () => {
      const store = createMockStore({ experimentalFeatures: { evalsView: false } as Settings["experimentalFeatures"] });
      const schedule = createMockSchedule({ id: "eval-off", command: "fn eval --scheduled-batch" });
      runner = new CronRunner(store, createMockAutomationStore());

      const runResult = await (runner as unknown as { executeLegacyCommand: (s: ScheduledTask, startedAt: string) => Promise<AutomationRunResult> })
        .executeLegacyCommand(schedule, new Date().toISOString());
      expect(runResult.success).toBe(false);
      expect(runResult.output).toBe("evals-experimental-disabled");
      expect(runResult.error).toBe("Evals experimental feature is disabled");
    });

    it("does not return the disabled sentinel when evalsView experimental feature is on", async () => {
      const store = createMockStore({ experimentalFeatures: { evalsView: true } as Settings["experimentalFeatures"] }) as unknown as {
        getEvalStore: () => {
          listRuns: () => Array<{ id: string; status: string; metadata?: Record<string, unknown>; window: { until?: string } }>;
          createRun: (input: { projectId: string; trigger: string; scope: string; window: { since?: string; until: string }; metadata: Record<string, unknown> }) => { id: string; startedAt?: string; window: { until: string } };
          appendRunEvent: (runId: string, event: Record<string, unknown>) => void;
          updateRun: (runId: string, patch: Record<string, unknown>) => void;
        };
        listTasks: (opts: { column: string }) => Promise<Array<{ id: string; column: string; createdAt: string; updatedAt: string; executionCompletedAt?: string; title: string; summary?: string }>>;
      };

      store.getEvalStore = () => ({
        listRuns: () => [],
        createRun: () => ({ id: "run-1", window: { until: new Date().toISOString() } }),
        appendRunEvent: () => {},
        updateRun: () => {},
      });
      store.listTasks = async () => [];

      const schedule = createMockSchedule({ id: "eval-on", command: "fn eval --scheduled-batch" });
      runner = new CronRunner(store as unknown as TaskStore, createMockAutomationStore());

      const runResult = await (runner as unknown as { executeLegacyCommand: (s: ScheduledTask, startedAt: string) => Promise<AutomationRunResult> })
        .executeLegacyCommand(schedule, new Date().toISOString());
      expect(runResult.output).not.toBe("evals-experimental-disabled");
    });
  });
});