onbuzz 5.1.0 → 5.4.0

package/src/services/__tests__/scheduleService.flow.test.js

@@ -0,0 +1,625 @@
+/**
+ * Flow-level tests for ScheduleService — the layers the missed-run suite
+ * doesn't reach: CRUD, execution (agent/flow dispatch + error handling),
+ * persistence, broadcasting, and OS-scheduler sync (crontab + schtasks).
+ *
+ * child_process.execSync and fs are mocked so the OS-sync and persistence
+ * paths are exercised without touching the real crontab/Task Scheduler or
+ * disk. process.platform is overridden per test to drive the win32 vs posix
+ * branches deterministically on any host.
+ */
+import { jest, describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+jest.unstable_mockModule('fs', () => ({
+  promises: {
+    readFile: jest.fn(),
+    writeFile: jest.fn(),
+    mkdir: jest.fn(),
+  },
+}));
+jest.unstable_mockModule('child_process', () => ({ execSync: jest.fn() }));
+jest.unstable_mockModule('../../utilities/userDataDir.js', () => ({
+  getUserDataDir: jest.fn().mockReturnValue('/tmp/test-loxia-data'),
+}));
+
+const { default: ScheduleService } = await import('../scheduleService.js');
+const { execSync } = await import('child_process');
+const { promises: fsp } = await import('fs');
+const { readFile, writeFile, mkdir } = fsp;
+
+const ORIG_PLATFORM = process.platform;
+function setPlatform(p) {
+  Object.defineProperty(process, 'platform', { value: p, configurable: true });
+}
+
+function newSvc() {
+  const svc = new ScheduleService(createMockLogger());
+  svc.setWebSocketManager({ broadcast: jest.fn() });
+  return svc;
+}
+
+const VALID = {
+  name: 'Test', prompt: 'do the thing', targetType: 'agent',
+  targetId: 'a1', cronExpression: '0 9 * * *',
+};
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  // Re-establish default mock behavior after clearAllMocks wiped call history.
+  execSync.mockReturnValue('');
+  readFile.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+  writeFile.mockResolvedValue(undefined);
+  mkdir.mockResolvedValue(undefined);
+});
+
+afterEach(() => setPlatform(ORIG_PLATFORM));
+
+// ───────────────────────── CRUD ─────────────────────────
+
+describe('createSchedule', () => {
+  test.each([
+    [{ ...VALID, name: '' }, /name is required/],
+    [{ ...VALID, prompt: '' }, /Prompt is required/],
+    [{ ...VALID, targetType: 'nonsense' }, /targetType must be/],
+    [{ ...VALID, targetId: '' }, /targetId is required/],
+    [{ ...VALID, cronExpression: '' }, /cronExpression is required/],
+  ])('rejects invalid config %#', async (config, re) => {
+    await expect(newSvc().createSchedule(config)).rejects.toThrow(re);
+  });
+
+  test('creates, persists, broadcasts, and computes nextRun', async () => {
+    const svc = newSvc();
+    const sched = await svc.createSchedule(VALID);
+
+    expect(sched.id).toMatch(/^schedule-/);
+    expect(sched.runCount).toBe(0);
+    expect(sched.nextRun).toBeTruthy();
+    expect(svc.schedules.get(sched.id)).toBe(sched);
+    expect(writeFile).toHaveBeenCalledTimes(1);              // _saveSchedules
+    expect(svc.webSocketManager.broadcast).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'schedule_created', id: sched.id }));
+  });
+
+  test('resolves a preset name into its cron + records the preset', async () => {
+    const sched = await newSvc().createSchedule({ ...VALID, cronExpression: 'daily' });
+    expect(sched.cronExpression).toBe('0 9 * * *');
+    expect(sched.cronPreset).toBe('daily');
+  });
+
+  test('throws on an unparseable cron', async () => {
+    await expect(newSvc().createSchedule({ ...VALID, cronExpression: 'not a cron' }))
+      .rejects.toThrow();
+  });
+});
+
+describe('updateSchedule', () => {
+  test('throws for an unknown id', async () => {
+    await expect(newSvc().updateSchedule('nope', {})).rejects.toThrow(/not found/i);
+  });
+
+  test('cron change revalidates, recomputes nextRun, and sets preset', async () => {
+    const svc = newSvc();
+    const s = await svc.createSchedule(VALID);
+    const updated = await svc.updateSchedule(s.id, { cronExpression: 'every-hour' });
+    expect(updated.cronExpression).toBe('0 * * * *');
+    expect(updated.cronPreset).toBe('every-hour');
+    expect(updated.nextRun).toBeTruthy();
+  });
+
+  test('an invalid cron in the update is rejected', async () => {
+    const svc = newSvc();
+    const s = await svc.createSchedule(VALID);
+    await expect(svc.updateSchedule(s.id, { cronExpression: 'bad cron x' })).rejects.toThrow();
+  });
+
+  test('re-enabling a disabled schedule recomputes nextRun', async () => {
+    const svc = newSvc();
+    const s = await svc.createSchedule({ ...VALID, enabled: false });
+    s.nextRun = null;
+    const updated = await svc.updateSchedule(s.id, { enabled: true });
+    expect(updated.enabled).toBe(true);
+    expect(updated.nextRun).toBeTruthy();
+  });
+
+  test('ignores fields not on the allow-list', async () => {
+    const svc = newSvc();
+    const s = await svc.createSchedule(VALID);
+    const updated = await svc.updateSchedule(s.id, { runCount: 999, name: 'Renamed' });
+    expect(updated.name).toBe('Renamed');
+    expect(updated.runCount).toBe(0); // runCount is not user-updatable
+  });
+});
+
+describe('deleteSchedule / getters', () => {
+  test('delete throws for an unknown id', async () => {
+    await expect(newSvc().deleteSchedule('nope')).rejects.toThrow(/not found/i);
+  });
+
+  test('delete removes, persists, and broadcasts', async () => {
+    const svc = newSvc();
+    const s = await svc.createSchedule(VALID);
+    await svc.deleteSchedule(s.id);
+    expect(svc.getSchedule(s.id)).toBeNull();
+    expect(svc.webSocketManager.broadcast).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'schedule_deleted', id: s.id }));
+  });
+
+  test('listSchedules returns newest-first; getPresets returns a copy', async () => {
+    const svc = newSvc();
+    const a = await svc.createSchedule({ ...VALID, name: 'A' });
+    a.createdAt = '2026-01-01T00:00:00Z';
+    const b = await svc.createSchedule({ ...VALID, name: 'B' });
+    b.createdAt = '2026-02-01T00:00:00Z';
+    expect(svc.listSchedules().map((x) => x.name)).toEqual(['B', 'A']);
+
+    const presets = svc.getPresets();
+    presets['hacked'] = 'x';
+    expect(svc.getPresets().hacked).toBeUndefined(); // returned object is a copy
+  });
+});
+
+// ─────────────────────── Execution ───────────────────────
+
+describe('_executeSchedule', () => {
+  test('agent target: success sets lastRunStatus and broadcasts triggered', async () => {
+    const svc = newSvc();
+    svc.setAgentPool({
+      getAgent: jest.fn().mockResolvedValue({ name: 'Agent' }),
+      updateAgent: jest.fn().mockResolvedValue(undefined),
+      addUserMessage: jest.fn().mockResolvedValue(undefined),
+    });
+    const sched = { id: 's1', name: 'S', targetType: 'agent', targetId: 'a1', prompt: 'go' };
+    await svc._executeSchedule(sched);
+    expect(sched.lastRunStatus).toBe('success');
+    expect(svc.webSocketManager.broadcast).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'schedule_triggered', id: 's1' }));
+  });
+
+  test('flow target: success sets lastRunStatus', async () => {
+    const svc = newSvc();
+    svc.setFlowExecutor({ executeFlow: jest.fn().mockResolvedValue(undefined) });
+    const sched = { id: 's2', name: 'F', targetType: 'flow', targetId: 'f1', prompt: 'go' };
+    await svc._executeSchedule(sched);
+    expect(sched.lastRunStatus).toBe('success');
+  });
+
+  test('failure is caught: marks error and broadcasts schedule_error', async () => {
+    const svc = newSvc(); // no agentPool → _executeAgentSchedule throws
+    const sched = { id: 's3', name: 'S', targetType: 'agent', targetId: 'a1', prompt: 'go' };
+    await svc._executeSchedule(sched); // must not throw
+    expect(sched.lastRunStatus).toBe('error');
+    expect(sched.lastRunError).toMatch(/AgentPool not available/);
+    expect(svc.webSocketManager.broadcast).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'schedule_error', id: 's3' }));
+  });
+});
+
+describe('_executeAgentSchedule', () => {
+  test('throws when no agentPool is wired', async () => {
+    await expect(newSvc()._executeAgentSchedule({ id: 'x', targetId: 'a' }))
+      .rejects.toThrow(/AgentPool not available/);
+  });
+
+  test('throws when the target agent is missing', async () => {
+    const svc = newSvc();
+    svc.setAgentPool({ getAgent: jest.fn().mockResolvedValue(null) });
+    await expect(svc._executeAgentSchedule({ id: 'x', targetId: 'gone' }))
+      .rejects.toThrow(/Target agent not found/);
+  });
+
+  test('load-on-fire: restores an on-disk target then dispatches', async () => {
+    const svc = newSvc();
+    const updateAgent = jest.fn().mockResolvedValue(undefined);
+    const addUserMessage = jest.fn().mockResolvedValue(undefined);
+    const importArchivedAgent = jest.fn().mockResolvedValue({ id: 'a1', name: 'Restored' });
+    svc.setAgentPool({ getAgent: jest.fn().mockResolvedValue(null), updateAgent, addUserMessage });
+    svc.setOrchestrator({ stateManager: { importArchivedAgent }, config: { project: { directory: '/proj' } } });
+
+    await svc._executeAgentSchedule({ id: 's', name: 'Nightly', targetId: 'a1', prompt: 'go' });
+
+    expect(importArchivedAgent).toHaveBeenCalledWith('a1', '/proj', expect.anything());
+    expect(addUserMessage).toHaveBeenCalledWith('a1', expect.objectContaining({ source: 'schedule' }));
+  });
+
+  test('load-on-fire: falls back to getAgent when import returns nothing but the agent is now resident', async () => {
+    const svc = newSvc();
+    const getAgent = jest.fn()
+      .mockResolvedValueOnce(null)              // first check: not resident
+      .mockResolvedValueOnce({ id: 'a1', name: 'NowHere' }); // after import: resident
+    const importArchivedAgent = jest.fn().mockResolvedValue(null);
+    svc.setAgentPool({ getAgent, updateAgent: jest.fn(), addUserMessage: jest.fn() });
+    svc.setOrchestrator({ stateManager: { importArchivedAgent }, config: {} });
+
+    await svc._executeAgentSchedule({ id: 's', name: 'N', targetId: 'a1', prompt: 'go' });
+    expect(importArchivedAgent).toHaveBeenCalled();
+  });
+
+  test('load-on-fire: still throws when the agent cannot be restored', async () => {
+    const svc = newSvc();
+    svc.setAgentPool({ getAgent: jest.fn().mockResolvedValue(null) });
+    svc.setOrchestrator({ stateManager: { importArchivedAgent: jest.fn().mockResolvedValue(null) }, config: {} });
+    await expect(svc._executeAgentSchedule({ id: 'x', targetId: 'gone' }))
+      .rejects.toThrow(/Target agent not found/);
+  });
+
+  test('load-on-fire: a restore error is swallowed (falls through to not-found)', async () => {
+    const svc = newSvc();
+    svc.setAgentPool({ getAgent: jest.fn().mockResolvedValue(null) });
+    svc.setOrchestrator({ stateManager: { importArchivedAgent: jest.fn().mockRejectedValue(new Error('disk')) }, config: {} });
+    await expect(svc._executeAgentSchedule({ id: 'x', targetId: 'gone' }))
+      .rejects.toThrow(/Target agent not found/);
+  });
+
+  test('load-on-fire: no-op when no orchestrator/stateManager is wired', async () => {
+    const svc = newSvc();
+    svc.setAgentPool({ getAgent: jest.fn().mockResolvedValue(null) });
+    // no setOrchestrator → _loadAgentFromDisk returns null immediately
+    await expect(svc._executeAgentSchedule({ id: 'x', targetId: 'gone' }))
+      .rejects.toThrow(/Target agent not found/);
+  });
+
+  test('switches to agent mode and pushes the prompt, reusing a live session id', async () => {
+    const svc = newSvc();
+    const updateAgent = jest.fn().mockResolvedValue(undefined);
+    const addUserMessage = jest.fn().mockResolvedValue(undefined);
+    svc.setAgentPool({
+      getAgent: jest.fn().mockResolvedValue({ name: 'Agent' }),
+      updateAgent, addUserMessage,
+    });
+    svc.setWebSocketManager({
+      broadcast: jest.fn(),
+      connections: new Map([['c1', { sessionId: 'live-session' }]]),
+    });
+    await svc._executeAgentSchedule({ id: 's', name: 'Nightly', targetId: 'a1', prompt: 'run report' });
+
+    expect(updateAgent).toHaveBeenCalledWith('a1', expect.objectContaining({ sessionId: 'live-session', mode: 'agent' }));
+    expect(addUserMessage).toHaveBeenCalledWith('a1', expect.objectContaining({
+      content: expect.stringContaining('run report'),
+      source: 'schedule',
+    }));
+  });
+});
+
+describe('_executeFlowSchedule', () => {
+  test('throws when no flowExecutor is wired', async () => {
+    await expect(newSvc()._executeFlowSchedule({ id: 'x', targetId: 'f' }))
+      .rejects.toThrow(/FlowExecutor not available/);
+  });
+
+  test('executes the flow with input + source metadata', async () => {
+    const svc = newSvc();
+    const executeFlow = jest.fn().mockResolvedValue(undefined);
+    svc.setFlowExecutor({ executeFlow });
+    await svc._executeFlowSchedule({ id: 's', targetId: 'f1', prompt: 'kick' });
+    expect(executeFlow).toHaveBeenCalledWith(
+      'f1',
+      expect.objectContaining({ userInput: 'kick', source: 'schedule', scheduleId: 's' }),
+      expect.any(String),
+    );
+  });
+});
+
+// ─────────────────────── Persistence ───────────────────────
+
+describe('_loadSchedules', () => {
+  test('populates the map from disk', async () => {
+    readFile.mockResolvedValueOnce(JSON.stringify([
+      { id: 'a', name: 'A' }, { id: 'b', name: 'B' },
+    ]));
+    const svc = newSvc();
+    await svc._loadSchedules();
+    expect(svc.schedules.size).toBe(2);
+    expect(svc.getSchedule('a').name).toBe('A');
+  });
+
+  test('a missing file (ENOENT) is silent — no warning', async () => {
+    readFile.mockRejectedValueOnce(Object.assign(new Error('nope'), { code: 'ENOENT' }));
+    const svc = newSvc();
+    await svc._loadSchedules();
+    expect(svc.schedules.size).toBe(0);
+    expect(svc.logger.warn).not.toHaveBeenCalled();
+  });
+
+  test('a non-ENOENT read error is warned and swallowed', async () => {
+    readFile.mockRejectedValueOnce(Object.assign(new Error('EACCES'), { code: 'EACCES' }));
+    const svc = newSvc();
+    await svc._loadSchedules();
+    expect(svc.logger.warn).toHaveBeenCalled();
+  });
+});
+
+describe('_saveSchedules', () => {
+  test('mkdir + writeFile the serialized schedules', async () => {
+    const svc = newSvc();
+    svc.schedules.set('a', { id: 'a' });
+    await svc._saveSchedules();
+    expect(mkdir).toHaveBeenCalledWith(expect.any(String), { recursive: true });
+    expect(writeFile).toHaveBeenCalledWith(expect.any(String), expect.stringContaining('"id": "a"'), 'utf-8');
+  });
+
+  test('a write failure is caught and logged, not thrown', async () => {
+    writeFile.mockRejectedValueOnce(new Error('disk full'));
+    const svc = newSvc();
+    svc.schedules.set('a', { id: 'a' });
+    await expect(svc._saveSchedules()).resolves.toBeUndefined();
+    expect(svc.logger.error).toHaveBeenCalled();
+  });
+});
+
+describe('_broadcast', () => {
+  test('no-op when no WebSocket manager is wired', () => {
+    const svc = new ScheduleService(createMockLogger()); // no ws manager
+    expect(() => svc._broadcast('x', { a: 1 })).not.toThrow();
+  });
+
+  test('emits {type, ...data} when a broadcaster is present', () => {
+    const svc = newSvc();
+    svc._broadcast('hello', { a: 1 });
+    expect(svc.webSocketManager.broadcast).toHaveBeenCalledWith({ type: 'hello', a: 1 });
+  });
+});
+
+// ─────────────────────── OS-scheduler sync ───────────────────────
+
+describe('_findLoxiaBin', () => {
+  test('returns the path reported by which/where', () => {
+    execSync.mockReturnValueOnce('/usr/local/bin/loxia\n');
+    expect(newSvc()._findLoxiaBin()).toBe('/usr/local/bin/loxia');
+  });
+
+  test('falls back to the local cli.js when which/where fails', () => {
+    execSync.mockImplementationOnce(() => { throw new Error('not found'); });
+    expect(newSvc()._findLoxiaBin()).toMatch(/cli\.js/);
+  });
+});
+
+describe('_syncToOS routing', () => {
+  test('a disabled schedule is removed from the OS instead of synced', async () => {
+    const svc = newSvc();
+    const rm = jest.spyOn(svc, '_removeFromOS').mockResolvedValue(undefined);
+    await svc._syncToOS({ id: 's', enabled: false });
+    expect(rm).toHaveBeenCalledWith('s');
+  });
+
+  test('win32 routes to _syncToWindows', async () => {
+    setPlatform('win32');
+    const svc = newSvc();
+    const win = jest.spyOn(svc, '_syncToWindows').mockImplementation(() => {});
+    await svc._syncToOS({ id: 's', enabled: true, cronExpression: '0 9 * * *' });
+    expect(win).toHaveBeenCalled();
+  });
+
+  test('posix routes to _syncToCrontab', async () => {
+    setPlatform('linux');
+    const svc = newSvc();
+    const cron = jest.spyOn(svc, '_syncToCrontab').mockImplementation(() => {});
+    await svc._syncToOS({ id: 's', enabled: true, cronExpression: '0 9 * * *' });
+    expect(cron).toHaveBeenCalled();
+  });
+
+  test('a sync failure is caught and warned (internal scheduler still works)', async () => {
+    setPlatform('linux');
+    const svc = newSvc();
+    jest.spyOn(svc, '_syncToCrontab').mockImplementation(() => { throw new Error('crontab boom'); });
+    await svc._syncToOS({ id: 's', enabled: true, cronExpression: '0 9 * * *' });
+    expect(svc.logger.warn).toHaveBeenCalledWith(
+      'Failed to sync schedule to OS scheduler', expect.objectContaining({ id: 's' }));
+  });
+
+  test('syncAllToOS syncs every schedule', async () => {
+    const svc = newSvc();
+    svc.schedules.set('a', { id: 'a', enabled: true });
+    svc.schedules.set('b', { id: 'b', enabled: true });
+    const one = jest.spyOn(svc, '_syncToOS').mockResolvedValue(undefined);
+    await svc.syncAllToOS();
+    expect(one).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe('crontab sync (posix)', () => {
+  beforeEach(() => setPlatform('linux'));
+
+  test('replaces this schedule’s line, preserves unrelated lines', () => {
+    execSync.mockImplementation((cmd) => {
+      if (String(cmd).includes('crontab -l')) {
+        return '0 0 * * * /other/job # loxia-schedule:OTHER\n* * * * * old # loxia-schedule:s1\n';
+      }
+      return '';
+    });
+    const svc = newSvc();
+    svc._syncToCrontab({ id: 's1', cronExpression: '0 9 * * *' }, 'loxia trigger-schedule s1');
+
+    const writeCall = execSync.mock.calls.find((c) => c[0] === 'crontab -');
+    expect(writeCall).toBeTruthy();
+    const written = writeCall[1].input;
+    expect(written).toContain('loxia-schedule:OTHER');          // unrelated kept
+    expect(written).toContain('0 9 * * * loxia trigger-schedule s1 # loxia-schedule:s1'); // new entry
+    expect(written).not.toContain('old # loxia-schedule:s1');    // stale entry dropped
+  });
+
+  test('_removeFromCrontab with no existing crontab does not write', () => {
+    execSync.mockImplementation((cmd) => {
+      if (String(cmd).includes('crontab -l')) throw new Error('no crontab');
+      return '';
+    });
+    const svc = newSvc();
+    svc._removeFromCrontab('s1');
+    expect(execSync.mock.calls.some((c) => c[0] === 'crontab -')).toBe(false);
+  });
+
+  test('_removeFromCrontab strips this schedule’s line', () => {
+    execSync.mockImplementation((cmd) => {
+      if (String(cmd).includes('crontab -l')) {
+        return '* * * * * x # loxia-schedule:s1\n0 0 * * * y # loxia-schedule:keep\n';
+      }
+      return '';
+    });
+    const svc = newSvc();
+    svc._removeFromCrontab('s1');
+    const writeCall = execSync.mock.calls.find((c) => c[0] === 'crontab -');
+    expect(writeCall[1].input).toContain('loxia-schedule:keep');
+    expect(writeCall[1].input).not.toContain('loxia-schedule:s1');
+  });
+});
+
+describe('schtasks sync (win32)', () => {
+  beforeEach(() => setPlatform('win32'));
+
+  test('deletes then creates the task for a simple cron', () => {
+    const svc = newSvc();
+    svc._syncToWindows({ id: 's1', cronExpression: '0 9 * * *' }, 'loxia trigger-schedule s1');
+    const cmds = execSync.mock.calls.map((c) => String(c[0]));
+    expect(cmds.some((c) => c.includes('/Delete') && c.includes('LoxiaSchedule_s1'))).toBe(true);
+    expect(cmds.some((c) => c.includes('/Create') && c.includes('/TN "LoxiaSchedule_s1"'))).toBe(true);
+  });
+
+  test('a cron schtasks can’t express is skipped (delete only) with a warning', () => {
+    const svc = newSvc();
+    svc._syncToWindows({ id: 's2', cronExpression: '*/7 3 * * *' }, 'cmd');
+    const cmds = execSync.mock.calls.map((c) => String(c[0]));
+    expect(cmds.some((c) => c.includes('/Create'))).toBe(false);
+    expect(svc.logger.warn).toHaveBeenCalled();
+  });
+
+  test('_removeFromWindows deletes the task', () => {
+    const svc = newSvc();
+    svc._removeFromWindows('s3');
+    expect(execSync.mock.calls.some((c) => String(c[0]).includes('/Delete') && String(c[0]).includes('LoxiaSchedule_s3'))).toBe(true);
+  });
+});
+
+describe('_cronToSchtasksArgs', () => {
+  const svc = new ScheduleService(createMockLogger());
+  test.each([
+    ['*/5 * * * *', '/SC MINUTE /MO 5'],
+    ['15 * * * *', '/SC HOURLY /ST 00:15'],
+    ['30 9 * * *', '/SC DAILY /ST 09:30'],
+    ['0 9 * * 1-5', '/SC WEEKLY /D MON,TUE,WED,THU,FRI /ST 09:00'],
+    ['0 9 * * 1,3', '/SC WEEKLY /D MON,WED /ST 09:00'],
+    ['0 9 15 * *', '/SC MONTHLY /D 15 /ST 09:00'],
+  ])('%s → %s', (cron, expected) => {
+    expect(svc._cronToSchtasksArgs(cron)).toBe(expected);
+  });
+
+  test('returns null for a pattern schtasks cannot express', () => {
+    expect(svc._cronToSchtasksArgs('*/7 3 * * *')).toBeNull();
+  });
+});
+
+// ─────────────────────── _tick edge branches ───────────────────────
+
+const pastISO = () => new Date(Date.now() - 60 * 1000).toISOString();
+const futureISO = (ms) => new Date(Date.now() + ms).toISOString();
+
+function tickSvc() {
+  const svc = newSvc();
+  svc._executeSchedule = jest.fn().mockResolvedValue(undefined);
+  svc._saveSchedules = jest.fn().mockResolvedValue(undefined);
+  return svc;
+}
+
+describe('_tick lifecycle branches', () => {
+  test('a schedule past its endDate is disabled and cleared', async () => {
+    const svc = tickSvc();
+    const s = { id: 'e', name: 'End', enabled: true, nextRun: pastISO(),
+      endDate: new Date(Date.now() - 1000).toISOString() };
+    svc.schedules.set('e', s);
+    await svc._tick();
+    expect(s.enabled).toBe(false);
+    expect(s.nextRun).toBeNull();
+    expect(svc._executeSchedule).not.toHaveBeenCalled();
+    expect(svc.webSocketManager.broadcast).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'schedule_updated', id: 'e' }));
+  });
+
+  test('a schedule before its startDate is skipped', async () => {
+    const svc = tickSvc();
+    svc.schedules.set('s', { id: 's', enabled: true, nextRun: pastISO(),
+      startDate: futureISO(60 * 60 * 1000) });
+    await svc._tick();
+    expect(svc._executeSchedule).not.toHaveBeenCalled();
+  });
+
+  test('a runOnce schedule auto-disables after firing', async () => {
+    const svc = tickSvc();
+    const s = { id: 'o', name: 'Once', enabled: true, nextRun: pastISO(),
+      runOnce: true, cronExpression: '0 9 * * *', runCount: 0 };
+    svc.schedules.set('o', s);
+    await svc._tick();
+    expect(svc._executeSchedule).toHaveBeenCalledTimes(1);
+    expect(s.enabled).toBe(false);
+    expect(s.nextRun).toBeNull();
+  });
+});
+
+describe('misc dependency wiring + error paths', () => {
+  test('setOrchestrator stores the orchestrator', () => {
+    const svc = newSvc();
+    const orch = {};
+    svc.setOrchestrator(orch);
+    expect(svc.orchestrator).toBe(orch);
+  });
+
+  test('_executeFlowSchedule reuses a live WebSocket session id', async () => {
+    const svc = newSvc();
+    const executeFlow = jest.fn().mockResolvedValue(undefined);
+    svc.setFlowExecutor({ executeFlow });
+    svc.setWebSocketManager({ broadcast: jest.fn(), connections: new Map([['c', { sessionId: 'live' }]]) });
+    await svc._executeFlowSchedule({ id: 's', targetId: 'f1', prompt: 'go' });
+    expect(executeFlow).toHaveBeenCalledWith('f1', expect.any(Object), 'live');
+  });
+
+  test('_removeFromOS swallows + warns on failure', async () => {
+    setPlatform('linux');
+    const svc = newSvc();
+    jest.spyOn(svc, '_removeFromCrontab').mockImplementation(() => { throw new Error('boom'); });
+    await svc._removeFromOS('x');
+    expect(svc.logger.warn).toHaveBeenCalledWith(
+      'Failed to remove schedule from OS scheduler', expect.objectContaining({ id: 'x' }));
+  });
+});
+
+describe('start() lifecycle resilience', () => {
+  const ORIG_TRIGGER = process.env.LOXIA_TRIGGER_SCHEDULE;
+  afterEach(() => {
+    if (ORIG_TRIGGER === undefined) delete process.env.LOXIA_TRIGGER_SCHEDULE;
+    else process.env.LOXIA_TRIGGER_SCHEDULE = ORIG_TRIGGER;
+    jest.useRealTimers();
+  });
+
+  test('arms the interval and survives failing tick / sync / boot-trigger without throwing', async () => {
+    jest.useFakeTimers();
+    process.env.LOXIA_TRIGGER_SCHEDULE = 'boot-x';
+    const svc = newSvc();
+    svc._tick = jest.fn().mockRejectedValue(new Error('tick fail'));
+    svc.syncAllToOS = jest.fn().mockRejectedValue(new Error('sync fail'));
+    svc.triggerSchedule = jest.fn().mockRejectedValue(new Error('boot fail'));
+
+    expect(() => svc.start()).not.toThrow();
+    // Flush the immediate tick / syncAll / boot-trigger rejections.
+    await Promise.resolve(); await Promise.resolve(); await Promise.resolve();
+    // Fire the interval callback at least once.
+    jest.advanceTimersByTime(svc.checkIntervalMs);
+    await Promise.resolve();
+
+    expect(svc._tick).toHaveBeenCalled();
+    expect(svc.syncAllToOS).toHaveBeenCalled();
+    expect(svc.triggerSchedule).toHaveBeenCalledWith('boot-x');
+    expect(svc.logger.error).toHaveBeenCalled(); // tick/boot failures logged
+    svc.stop();
+    expect(svc.checkTimer).toBeNull();
+  });
+
+  test('start() is idempotent — a second call does not arm a second timer', () => {
+    jest.useFakeTimers();
+    const svc = newSvc();
+    svc._tick = jest.fn().mockResolvedValue(undefined);
+    svc.syncAllToOS = jest.fn().mockResolvedValue(undefined);
+    svc.start();
+    const timer = svc.checkTimer;
+    svc.start();
+    expect(svc.checkTimer).toBe(timer); // unchanged
+    svc.stop();
+  });
+});