Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { describe, it, expect, beforeEach, vi } from 'vitest'
// This suite owns scheduler time, not settings or credential I/O.
vi.mock('./userTimezone.js', () => ({ getUserTimezone: vi.fn(async () => 'UTC') }))
// Mock modules before import
vi.mock('./cosEvents.js', () => ({
cosEvents: { emit: vi.fn() }
}))
vi.mock('../lib/fileUtils.js', () => ({
sleep: vi.fn().mockResolvedValue(),
tryReadFile: vi.fn().mockResolvedValue(null),
// Strict twin (#4115) — `services/settings.js#readSettingsStrict` reads through
// it, and this factory is exhaustive (no `importActual` spread), so an omitted
// export is a hard "not defined on the mock" throw. `ok: true, value: null` is
// the absent-file shape, matching `tryReadFile`'s null above.
tryReadFileStrict: vi.fn().mockResolvedValue({ ok: true, value: null }),
readJSONFile: vi.fn(),
// Strict twin of readJSONFile (#4115). Same exhaustive-factory constraint as
// tryReadFileStrict above. Left un-stubbed by default (undefined value) to
// match readJSONFile's bare vi.fn(); tests that need a value set it per case.
readJSONFileStrict: vi.fn().mockResolvedValue({ ok: true, value: undefined }),
ensureDir: vi.fn().mockResolvedValue(),
atomicWrite: vi.fn().mockResolvedValue(),
safeJSONParse: (raw, fallback) => { try { return JSON.parse(raw) } catch { return fallback } },
PATHS: { cos: '/mock/data/cos', digitalTwin: '/mock/data/digital-twin', data: '/mock/data', root: '/mock/root' },
HOUR: 60 * 60 * 1000,
DAY: 24 * 60 * 60 * 1000
}))
vi.mock('fs/promises', () => ({
writeFile: vi.fn().mockResolvedValue(),
readFile: vi.fn().mockResolvedValue('{}'),
rename: vi.fn().mockResolvedValue(),
readdir: vi.fn().mockResolvedValue([]),
stat: vi.fn().mockResolvedValue({ isDirectory: () => false, mtimeMs: 0 }),
rm: vi.fn().mockResolvedValue()
}))
vi.mock('fs', () => ({
existsSync: vi.fn().mockReturnValue(false)
}))
vi.mock('./retirementAppScope.js', () => ({ resolveRetirementApp: vi.fn(async () => ({ app: { id: 'app-1', repoPath: '/mock/root' } })) }))
vi.mock('./worktreeManager.js', () => ({
reapMergedWorktrees: vi.fn().mockResolvedValue({ reaped: [] }),
cleanupOrphanedWorktrees: vi.fn().mockResolvedValue(0)
}))
vi.mock('./cosAgentRepository.js', () => ({ listStoredAgentStatuses: vi.fn(async () => []) }))
vi.mock('./agentState.js', () => ({
getActiveAgentIds: vi.fn().mockReturnValue([])
}))
vi.mock('./autobiography.js', () => ({
checkAndPrompt: vi.fn().mockResolvedValue({ prompted: true, prompt: { id: 'test-1', text: 'test' } })
}))
// Import after mocks
import { computeNextJobRun } from './autonomousJobs/scheduler.js'
import { ON_DEMAND_INTERVAL, resolveIntervalMs } from '../lib/autonomousJobIntervals.js'
import {
agentDataCleanup,
getAllJobs,
getJob,
getDueJobs,
createJob,
updateJob,
deleteJob,
recordJobExecution,
toggleJob,
generateTaskFromJob,
getJobStats,
INTERVAL_OPTIONS,
isScriptJob,
executeScriptJob,
initJobs
} from './autonomousJobs.js'
import { readJSONFile, atomicWrite } from '../lib/fileUtils.js'
import { listStoredAgentStatuses } from './cosAgentRepository.js'
import { cosEvents } from './cosEvents.js'
import { checkAndPrompt } from './autobiography.js'
import { reapMergedWorktrees, cleanupOrphanedWorktrees } from './worktreeManager.js'
import { getActiveAgentIds } from './agentState.js'
describe('autonomousJobs', () => {
const mockJobsData = {
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [
{
id: 'job-test-1',
name: 'Test Job',
description: 'A test job',
category: 'test',
interval: 'daily',
intervalMs: 86400000,
enabled: true,
priority: 'MEDIUM',
autonomyLevel: 'manager',
promptTemplate: 'Do the test thing',
lastRun: null,
runCount: 0,
createdAt: '2025-01-01T00:00:00.000Z',
updatedAt: '2025-01-01T00:00:00.000Z'
}
]
}
beforeEach(() => {
vi.clearAllMocks()
readJSONFile.mockResolvedValue(JSON.parse(JSON.stringify(mockJobsData)))
})
describe('getDueJobs', () => {
it('never-run enabled job is always due', async () => {
const due = await getDueJobs()
const testJob = due.find(j => j.id === 'job-test-1')
expect(testJob).toBeDefined()
expect(testJob.reason).toBe('never-run')
expect(testJob.overdueBy).toBeGreaterThan(0)
})
it('recently-run job is NOT due', async () => {
const now = new Date()
const oneHourAgo = new Date(now - 60 * 60 * 1000).toISOString()
readJSONFile.mockResolvedValue({
...mockJobsData,
jobs: [{
...mockJobsData.jobs[0],
lastRun: oneHourAgo
}]
})
const due = await getDueJobs()
expect(due.find(j => j.id === 'job-test-1')).toBeUndefined()
})
it('jobs sort by most overdue first', async () => {
const now = new Date()
const twoDaysAgo = new Date(now - 2 * 24 * 60 * 60 * 1000).toISOString()
const fourDaysAgo = new Date(now - 4 * 24 * 60 * 60 * 1000).toISOString()
readJSONFile.mockResolvedValue({
...mockJobsData,
jobs: [
{
...mockJobsData.jobs[0],
id: 'job-1',
name: 'Less Overdue',
lastRun: twoDaysAgo,
intervalMs: 86400000
},
{
...mockJobsData.jobs[0],
id: 'job-2',
name: 'More Overdue',
lastRun: fourDaysAgo,
intervalMs: 86400000
}
]
})
const due = await getDueJobs()
// Verify relative ordering: more overdue jobs should come first
const job2Idx = due.findIndex(j => j.id === 'job-2')
const job1Idx = due.findIndex(j => j.id === 'job-1')
expect(job2Idx).toBeGreaterThanOrEqual(0)
expect(job1Idx).toBeGreaterThanOrEqual(0)
expect(job2Idx).toBeLessThan(job1Idx)
expect(due[job2Idx].overdueBy).toBeGreaterThan(due[job1Idx].overdueBy)
// Verify only expected test jobs plus any default jobs are present
const testJobIds = new Set(['job-test-1', 'job-1', 'job-2'])
const defaultJobPrefixes = ['job-github-', 'job-brain-', 'job-daily-', 'job-moltworld-', 'job-jira-', 'job-autobiography-', 'job-system-', 'job-agent-', 'job-datadog-']
const unexpectedJobs = due.filter(j => !testJobIds.has(j.id) && !defaultJobPrefixes.some(p => j.id.startsWith(p)))
expect(unexpectedJobs).toHaveLength(0)
})
})
describe('generateTaskFromJob', () => {
it('returns correct task structure with metadata', async () => {
const job = mockJobsData.jobs[0]
const task = await generateTaskFromJob(job)
expect(task).toMatchObject({
priority: job.priority,
metadata: {
autonomousJob: true,
jobId: job.id,
jobName: job.name,
jobCategory: job.category,
autonomyLevel: job.autonomyLevel
},
taskType: 'internal',
autoApprove: false
})
expect(task.id).toContain(job.id)
expect(task.description).toBeTruthy()
expect(task.metadata.prompt).toBe('Do the test thing')
})
it('stores a multiline generated body in metadata.prompt and keeps the row summary one-line', async () => {
const task = await generateTaskFromJob({
...mockJobsData.jobs[0],
promptTemplate: 'Review the app\n\n## Context\nUse the configured inputs.',
})
expect(task.description).toBe('Review the app')
expect(task.metadata.prompt).toBe('Review the app\n\n## Context\nUse the configured inputs.')
})
it('autoApprove true when autonomyLevel is yolo', async () => {
const yoloJob = {
...mockJobsData.jobs[0],
autonomyLevel: 'yolo'
}
const task = await generateTaskFromJob(yoloJob)
expect(task.autoApprove).toBe(true)
expect(task.metadata.autonomyLevel).toBe('yolo')
})
it('omits app + git options when job has no appId/taskMetadata', async () => {
const task = await generateTaskFromJob(mockJobsData.jobs[0])
expect(task.metadata.app).toBeUndefined()
expect(task.metadata.useWorktree).toBeUndefined()
expect(task.metadata.openPR).toBeUndefined()
expect(task.metadata.simplify).toBeUndefined()
})
it('app-scoped job sets metadata.app and forwards git options', async () => {
const appJob = {
...mockJobsData.jobs[0],
appId: 'app-xyz',
taskMetadata: { useWorktree: true, openPR: true, simplify: false }
}
const task = await generateTaskFromJob(appJob)
expect(task.metadata.app).toBe('app-xyz')
expect(task.metadata.useWorktree).toBe(true)
expect(task.metadata.openPR).toBe(true)
expect(task.metadata.simplify).toBe(false)
})
it('forwards providerId/model into metadata.provider/metadata.model', async () => {
const job = { ...mockJobsData.jobs[0], providerId: 'anthropic', model: 'claude-opus-4-8' }
const task = await generateTaskFromJob(job)
expect(task.metadata.provider).toBe('anthropic')
expect(task.metadata.model).toBe('claude-opus-4-8')
})
it('omits provider/model when job has no override', async () => {
const task = await generateTaskFromJob(mockJobsData.jobs[0])
expect(task.metadata.provider).toBeUndefined()
expect(task.metadata.model).toBeUndefined()
})
it('forwards effort into metadata.effort', async () => {
const job = { ...mockJobsData.jobs[0], providerId: 'claude-code', effort: 'max' }
const task = await generateTaskFromJob(job)
expect(task.metadata.effort).toBe('max')
})
it('omits effort when job has no override', async () => {
const task = await generateTaskFromJob(mockJobsData.jobs[0])
expect(task.metadata.effort).toBeUndefined()
})
it('appends the configuration form values to the dispatched prompt', async () => {
const task = await generateTaskFromJob({
...mockJobsData.jobs[0],
formFields: [
{ key: 'subject', label: 'Subject', type: 'text' },
{ key: 'skipped', label: 'Skipped', type: 'text' },
],
formValues: { subject: 'tides', skipped: '' },
})
expect(task.metadata.prompt).toContain('Do the test thing')
expect(task.metadata.prompt).toContain('## Run configuration')
expect(task.metadata.prompt).toContain('- Subject: tides')
// A blank field must not reach the agent as an empty parameter.
expect(task.metadata.prompt).not.toContain('Skipped')
// The row summary is still the prompt's first line, not the appended block.
expect(task.description).toBe('Do the test thing')
})
it('leaves the prompt untouched when the job declares no configuration form', async () => {
const task = await generateTaskFromJob(mockJobsData.jobs[0])
expect(task.metadata.prompt).toBe('Do the test thing')
})
})
describe('createJob with resolveIntervalMs', () => {
it('hourly interval produces correct intervalMs', async () => {
const jobData = {
name: 'Hourly Job',
interval: 'hourly',
promptTemplate: 'Do hourly thing'
}
const job = await createJob(jobData)
expect(job.intervalMs).toBe(60 * 60 * 1000)
expect(job.interval).toBe('hourly')
})
it('daily interval produces correct intervalMs', async () => {
const jobData = {
name: 'Daily Job',
interval: 'daily',
promptTemplate: 'Do daily thing'
}
const job = await createJob(jobData)
expect(job.intervalMs).toBe(24 * 60 * 60 * 1000)
expect(job.interval).toBe('daily')
})
it('weekly interval produces correct intervalMs', async () => {
const jobData = {
name: 'Weekly Job',
interval: 'weekly',
promptTemplate: 'Do weekly thing'
}
const job = await createJob(jobData)
expect(job.intervalMs).toBe(7 * 24 * 60 * 60 * 1000)
expect(job.interval).toBe('weekly')
})
it('every-2-hours interval produces correct intervalMs', async () => {
const jobData = {
name: 'Bi-Hourly Job',
interval: 'every-2-hours',
promptTemplate: 'Do bi-hourly thing'
}
const job = await createJob(jobData)
expect(job.intervalMs).toBe(2 * 60 * 60 * 1000)
expect(job.interval).toBe('every-2-hours')
})
})
// #6375 — the on-demand cadence. Its whole contract is negative (never fires
// on a clock) and it is enforced in three separate places, so each is pinned.
describe('on-demand cadence (#6375)', () => {
const onDemandJob = (overrides = {}) => ({
...mockJobsData.jobs[0],
id: 'job-on-demand',
interval: ON_DEMAND_INTERVAL,
intervalMs: null,
enabled: true,
...overrides
})
it('resolveIntervalMs returns the no-interval sentinel, not DAY and not NaN', () => {
const resolved = resolveIntervalMs(ON_DEMAND_INTERVAL)
expect(resolved).toBeNull()
expect(resolved).not.toBe(24 * 60 * 60 * 1000)
expect(Number.isNaN(resolved)).toBe(false)
})
it('does not fall through to DAY for a cadence outside the vocabulary', () => {
// The old `default: return DAY` silently rescheduled a typo'd cadence daily.
expect(resolveIntervalMs('dailyy')).toBeNull()
})
it('is never due — not when never run, and not after a week of elapsed time', async () => {
// loadJobs merges the shipped default jobs in, so assert on this job only.
readJSONFile.mockResolvedValue({ ...mockJobsData, jobs: [onDemandJob()] })
expect((await getDueJobs()).find(j => j.id === 'job-on-demand')).toBeUndefined()
const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString()
readJSONFile.mockResolvedValue({ ...mockJobsData, jobs: [onDemandJob({ lastRun: weekAgo })] })
expect((await getDueJobs()).find(j => j.id === 'job-on-demand')).toBeUndefined()
})
it('computeNextJobRun returns null rather than an Invalid Date', () => {
const next = computeNextJobRun(onDemandJob({ lastRun: '2025-01-01T00:00:00.000Z' }), 'UTC')
expect(next).toBeNull()
// The regression this closes: lastRun + null === lastRun, a finite past
// timestamp that reads as permanently overdue.
expect(next).not.toBe(Date.parse('2025-01-01T00:00:00.000Z'))
})
it('createJob stores the sentinel and drops a pinned time-of-day', async () => {
const job = await createJob({
name: 'Manual only',
interval: ON_DEMAND_INTERVAL,
scheduledTime: '09:00',
promptTemplate: 'Only when asked'
})
expect(job.interval).toBe(ON_DEMAND_INTERVAL)
expect(job.intervalMs).toBeNull()
expect(job.scheduledTime).toBeNull()
})
it('updateJob switching an existing recurring job to on-demand clears its interval', async () => {
const updated = await updateJob('job-test-1', { interval: ON_DEMAND_INTERVAL })
expect(updated.interval).toBe(ON_DEMAND_INTERVAL)
expect(updated.intervalMs).toBeNull()
})
it('every recurring cadence still round-trips to a finite interval', async () => {
for (const opt of INTERVAL_OPTIONS.filter(o => o.value !== ON_DEMAND_INTERVAL)) {
const job = await createJob({ name: opt.value, interval: opt.value, promptTemplate: 'x' })
expect(job.interval, opt.value).toBe(opt.value)
expect(job.intervalMs, opt.value).toBe(opt.ms)
}
const custom = await createJob({ name: 'custom', interval: 'custom', intervalMs: 90_000, promptTemplate: 'x' })
expect(custom.intervalMs).toBe(90_000)
})
})
describe('INTERVAL_OPTIONS', () => {
it('has expected options', () => {
expect(INTERVAL_OPTIONS).toContainEqual({
value: 'hourly',
label: 'Every Hour',
ms: 60 * 60 * 1000
})
expect(INTERVAL_OPTIONS).toContainEqual({
value: 'daily',
label: 'Daily',
ms: 24 * 60 * 60 * 1000
})
expect(INTERVAL_OPTIONS).toContainEqual({
value: 'weekly',
label: 'Weekly',
ms: 7 * 24 * 60 * 60 * 1000
})
expect(INTERVAL_OPTIONS.length).toBeGreaterThan(3)
})
})
describe('mergeWithDefaults (tested indirectly via loadJobs)', () => {
it('missing default jobs get added', async () => {
readJSONFile.mockResolvedValueOnce({
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [
{
id: 'job-custom-only',
name: 'Custom Job',
description: 'Only custom job',
category: 'custom',
interval: 'daily',
intervalMs: 86400000,
enabled: false,
priority: 'MEDIUM',
autonomyLevel: 'manager',
promptTemplate: 'Custom work',
lastRun: null,
runCount: 0,
createdAt: '2025-01-01T00:00:00.000Z',
updatedAt: '2025-01-01T00:00:00.000Z'
}
]
})
const jobs = await getAllJobs()
expect(jobs.length).toBeGreaterThan(1)
expect(jobs.find(j => j.id === 'job-custom-only')).toBeDefined()
expect(jobs.find(j => j.id === 'job-github-repo-maintenance')).toBeDefined()
expect(jobs.find(j => j.id === 'job-brain-review')).toBeDefined()
})
it('user-edited fields on a built-in job are NOT overwritten on restart', async () => {
readJSONFile.mockResolvedValue({
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [
{
id: 'job-datadog-error-monitor',
name: 'DataDog Error Monitor',
description: 'Old description',
category: 'datadog-error-monitor',
interval: 'weekly',
intervalMs: 7 * 24 * 60 * 60 * 1000,
scheduledTime: '09:00',
enabled: true,
priority: 'LOW',
autonomyLevel: 'manager',
promptTemplate: 'My custom Datadog prompt',
lastRun: '2025-01-02T00:00:00.000Z',
runCount: 7,
createdAt: '2025-01-01T00:00:00.000Z',
updatedAt: '2025-01-01T00:00:00.000Z'
}
]
})
const jobs = await getAllJobs()
const datadog = jobs.find(j => j.id === 'job-datadog-error-monitor')
// User-edited additive fields must be preserved
expect(datadog.scheduledTime).toBe('09:00')
expect(datadog.interval).toBe('weekly')
expect(datadog.priority).toBe('LOW')
expect(datadog.promptTemplate).toBe('My custom Datadog prompt')
// Runtime state not touched
expect(datadog.enabled).toBe(true)
expect(datadog.lastRun).toBe('2025-01-02T00:00:00.000Z')
expect(datadog.runCount).toBe(7)
})
it('a new field missing on an existing job IS populated from defaults', async () => {
readJSONFile.mockResolvedValue({
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [
{
id: 'job-datadog-error-monitor',
name: 'DataDog Error Monitor',
// intentionally omit scheduledTime to simulate an older stored record
category: 'datadog-error-monitor',
interval: 'daily',
intervalMs: 86400000,
enabled: false,
priority: 'MEDIUM',
autonomyLevel: 'manager',
promptTemplate: 'My custom Datadog prompt',
lastRun: null,
runCount: 0,
createdAt: '2025-01-01T00:00:00.000Z',
updatedAt: '2025-01-01T00:00:00.000Z'
}
]
})
const jobs = await getAllJobs()
const datadog = jobs.find(j => j.id === 'job-datadog-error-monitor')
// Missing field should be filled in from the default
expect(datadog.scheduledTime).toBe('08:00')
// Existing user-set fields remain untouched
expect(datadog.promptTemplate).toBe('My custom Datadog prompt')
})
it('structural field changes (type/scriptHandler) ARE synced regardless of stored value', async () => {
readJSONFile.mockResolvedValue({
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [
{
id: 'job-agent-data-cleanup',
name: 'Agent Data Cleanup',
description: 'Cleans up old agent data',
category: 'maintenance',
interval: 'daily',
intervalMs: 86400000,
enabled: false,
priority: 'LOW',
autonomyLevel: 'manager',
promptTemplate: 'Clean up agent data',
type: 'script',
scriptHandler: 'STALE_HANDLER', // stale value — should be overwritten
lastRun: null,
runCount: 0,
createdAt: '2025-01-01T00:00:00.000Z',
updatedAt: '2025-01-01T00:00:00.000Z'
}
]
})
const jobs = await getAllJobs()
const cleanup = jobs.find(j => j.id === 'job-agent-data-cleanup')
// Structural field must be corrected to the shipped value
expect(cleanup.scriptHandler).toBe('agent-data-cleanup')
expect(cleanup.type).toBe('script')
})
it('shipped default update reaches an untouched built-in job', async () => {
// Existing job has scheduledTime matching its shipped snapshot → untouched
readJSONFile.mockResolvedValue({
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [
{
id: 'job-datadog-error-monitor',
name: 'DataDog Error Monitor',
description: 'Monitors errors',
category: 'datadog-error-monitor',
interval: 'daily',
intervalMs: 86400000,
scheduledTime: '06:00',
enabled: false,
priority: 'MEDIUM',
autonomyLevel: 'manager',
promptTemplate: 'Default datadog prompt',
lastRun: null,
runCount: 0,
createdAt: '2025-01-01T00:00:00.000Z',
updatedAt: '2025-01-01T00:00:00.000Z',
// Snapshot says '06:00' was the previously shipped value
_shippedDefaults: { scheduledTime: '06:00' }
}
]
})
const jobs = await getAllJobs()
const datadog = jobs.find(j => j.id === 'job-datadog-error-monitor')
// The current DEFAULT_JOBS ships scheduledTime '08:00' for datadog-error-monitor.
// Since existing matches snapshot ('06:00' === '06:00') and differs from new default,
// the value should be updated to the new shipped default.
expect(datadog.scheduledTime).toBe('08:00')
expect(datadog._shippedDefaults.scheduledTime).toBe('08:00')
})
it('user customization is preserved when snapshot differs from stored value', async () => {
// User changed scheduledTime to '09:00' but snapshot records '06:00' as the shipped value
readJSONFile.mockResolvedValue({
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [
{
id: 'job-datadog-error-monitor',
name: 'DataDog Error Monitor',
description: 'Monitors errors',
category: 'datadog-error-monitor',
interval: 'daily',
intervalMs: 86400000,
scheduledTime: '09:00',
enabled: false,
priority: 'MEDIUM',
autonomyLevel: 'manager',
promptTemplate: 'Default datadog prompt',
lastRun: null,
runCount: 0,
createdAt: '2025-01-01T00:00:00.000Z',
updatedAt: '2025-01-01T00:00:00.000Z',
// Snapshot says '06:00' — user edited to '09:00'
_shippedDefaults: { scheduledTime: '06:00' }
}
]
})
const jobs = await getAllJobs()
const datadog = jobs.find(j => j.id === 'job-datadog-error-monitor')
// User's '09:00' must be preserved; snapshot stays '06:00'
expect(datadog.scheduledTime).toBe('09:00')
expect(datadog._shippedDefaults.scheduledTime).toBe('06:00')
})
it('pre-snapshot job bootstraps _shippedDefaults but preserves value', async () => {
// Existing job has scheduledTime but NO _shippedDefaults at all
readJSONFile.mockResolvedValue({
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [
{
id: 'job-datadog-error-monitor',
name: 'DataDog Error Monitor',
description: 'Monitors errors',
category: 'datadog-error-monitor',
interval: 'daily',
intervalMs: 86400000,
scheduledTime: '06:00',
enabled: false,
priority: 'MEDIUM',
autonomyLevel: 'manager',
promptTemplate: 'Default datadog prompt',
lastRun: null,
runCount: 0,
createdAt: '2025-01-01T00:00:00.000Z',
updatedAt: '2025-01-01T00:00:00.000Z'
// No _shippedDefaults — this job predates the mechanism
}
]
})
const jobs = await getAllJobs()
const datadog = jobs.find(j => j.id === 'job-datadog-error-monitor')
// Value is preserved (conservative — can't tell if user edited or if it's old shipped)
expect(datadog.scheduledTime).toBe('06:00')
// Snapshot is bootstrapped to the CURRENT shipped default so next release can compare
expect(datadog._shippedDefaults).toBeDefined()
expect(datadog._shippedDefaults.scheduledTime).toBe('08:00')
})
it('new additive field on existing job is populated and snapshot set', async () => {
// Existing job has no priority field (simulates an old record missing a new field)
readJSONFile.mockResolvedValue({
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [
{
id: 'job-datadog-error-monitor',
name: 'DataDog Error Monitor',
description: 'Monitors errors',
category: 'datadog-error-monitor',
interval: 'daily',
intervalMs: 86400000,
enabled: false,
autonomyLevel: 'manager',
promptTemplate: 'Default datadog prompt',
lastRun: null,
runCount: 0,
createdAt: '2025-01-01T00:00:00.000Z',
updatedAt: '2025-01-01T00:00:00.000Z',
_shippedDefaults: {}
// No priority field — should be added from default
}
]
})
const jobs = await getAllJobs()
const datadog = jobs.find(j => j.id === 'job-datadog-error-monitor')
// Missing field gets populated from default
expect(datadog.priority).toBe('MEDIUM')
// Snapshot is set so future changes can be detected
expect(datadog._shippedDefaults.priority).toBe('MEDIUM')
})
})
describe('initJobs save-gating', () => {
it('persists when shipped-default update reaches an untouched built-in job', async () => {
// Job has scheduledTime matching snapshot → untouched, default ships new value → dirty
readJSONFile.mockResolvedValue({
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [
{
id: 'job-datadog-error-monitor',
name: 'DataDog Error Monitor',
description: 'Monitors errors',
category: 'datadog-error-monitor',
interval: 'daily',
intervalMs: 86400000,
scheduledTime: '06:00',
enabled: false,
priority: 'MEDIUM',
autonomyLevel: 'manager',
promptTemplate: 'Default datadog prompt',
lastRun: null,
runCount: 0,
createdAt: '2025-01-01T00:00:00.000Z',
updatedAt: '2025-01-01T00:00:00.000Z',
_shippedDefaults: { scheduledTime: '06:00' }
}
]
})
atomicWrite.mockClear()
const data = await initJobs()
// The in-memory value is updated to the new shipped default
const datadog = data.jobs.find(j => j.id === 'job-datadog-error-monitor')
expect(datadog.scheduledTime).toBe('08:00')
expect(datadog._shippedDefaults.scheduledTime).toBe('08:00')
// The updated data was persisted to disk
expect(atomicWrite).toHaveBeenCalled()
const [, savedData] = atomicWrite.mock.calls[0]
const savedDatadog = savedData.jobs.find(j => j.id === 'job-datadog-error-monitor')
expect(savedDatadog.scheduledTime).toBe('08:00')
expect(savedDatadog._shippedDefaults.scheduledTime).toBe('08:00')
})
it('does not persist when no changes are needed', async () => {
// Construct a payload that exactly matches all shipped defaults so mergeWithDefaults is a no-op.
// Use an unrecognized ID so it gets added as a new job — but then use a second call
// to simulate a restart where nothing changed.
// Simplest approach: provide a data set where all existing jobs already match defaults exactly.
readJSONFile.mockResolvedValue({
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [] // no existing jobs; only new ones will be added (dirty = true on first call)
})
// First call seeds defaults → dirty, saves
atomicWrite.mockClear()
await initJobs()
const firstSaveCount = atomicWrite.mock.calls.length
expect(firstSaveCount).toBeGreaterThan(0)
// Second call with the same data that was just "saved" — nothing changed
// Simulate the re-read returning the exact same merged data (all snapshots bootstrapped)
const savedData = atomicWrite.mock.calls[0][1]
readJSONFile.mockResolvedValue(JSON.parse(JSON.stringify(savedData)))
atomicWrite.mockClear()
await initJobs()
// No further saves needed — data is already up to date
expect(atomicWrite).not.toHaveBeenCalled()
})
it('persists when user-edited field leaves snapshot intact on a different field', async () => {
// User changed scheduledTime (preserves '09:00'), but priority is missing entirely → dirty
readJSONFile.mockResolvedValue({
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [
{
id: 'job-datadog-error-monitor',
name: 'DataDog Error Monitor',
description: 'Monitors errors',
category: 'datadog-error-monitor',
interval: 'daily',
intervalMs: 86400000,
scheduledTime: '09:00',
enabled: false,
autonomyLevel: 'manager',
promptTemplate: 'Default datadog prompt',
lastRun: null,
runCount: 0,
createdAt: '2025-01-01T00:00:00.000Z',
updatedAt: '2025-01-01T00:00:00.000Z',
_shippedDefaults: { scheduledTime: '06:00' }
// No priority — brand-new field → dirty
}
]
})
atomicWrite.mockClear()
const data = await initJobs()
// User's scheduledTime must still be '09:00'
const datadog = data.jobs.find(j => j.id === 'job-datadog-error-monitor')
expect(datadog.scheduledTime).toBe('09:00')
// New priority field is populated
expect(datadog.priority).toBe('MEDIUM')
// Data was persisted because a new field was added
expect(atomicWrite).toHaveBeenCalled()
})
})
describe('getAllJobs', () => {
it('returns all jobs from storage', async () => {
const jobs = await getAllJobs()
expect(jobs.length).toBeGreaterThan(0)
expect(jobs.find(j => j.id === 'job-test-1')).toBeDefined()
})
})
describe('getJob', () => {
it('returns job by ID', async () => {
const job = await getJob('job-test-1')
expect(job).toBeDefined()
expect(job.id).toBe('job-test-1')
})
it('returns null for non-existent job', async () => {
const job = await getJob('nonexistent')
expect(job).toBeNull()
})
})
describe('createJob', () => {
it('creates job with defaults', async () => {
const newJob = {
name: 'New Job',
promptTemplate: 'Do new thing'
}
const job = await createJob(newJob)
expect(job.name).toBe('New Job')
expect(job.priority).toBe('MEDIUM')
expect(job.autonomyLevel).toBe('manager')
expect(job.enabled).toBe(false)
expect(job.interval).toBe('weekly')
expect(cosEvents.emit).toHaveBeenCalledWith('jobs:created', {
id: expect.any(String),
name: 'New Job'
})
})
it('defaults appId/taskMetadata to null when omitted', async () => {
const job = await createJob({ name: 'Global Job', promptTemplate: 'do it' })
expect(job.appId).toBeNull()
expect(job.taskMetadata).toBeNull()
})
it('persists appId + taskMetadata when provided', async () => {
const job = await createJob({
name: 'App Job',
promptTemplate: 'do it',
appId: 'app-xyz',
taskMetadata: { useWorktree: true, openPR: true, simplify: false }
})
expect(job.appId).toBe('app-xyz')
expect(job.taskMetadata).toEqual({ useWorktree: true, openPR: true, simplify: false })
})
it('defaults providerId/model to null when omitted', async () => {
const job = await createJob({ name: 'Default AI Job', promptTemplate: 'do it' })
expect(job.providerId).toBeNull()
expect(job.model).toBeNull()
})
it('persists providerId + model when provided', async () => {
const job = await createJob({
name: 'Pinned AI Job',
promptTemplate: 'do it',
providerId: 'anthropic',
model: 'claude-opus-4-8'
})
expect(job.providerId).toBe('anthropic')
expect(job.model).toBe('claude-opus-4-8')
})
it('defaults effort to null when omitted', async () => {
const job = await createJob({ name: 'No Effort Job', promptTemplate: 'do it' })
expect(job.effort).toBeNull()
})
it('persists effort when provided', async () => {
const job = await createJob({
name: 'Effort Job',
promptTemplate: 'do it',
providerId: 'claude-code',
effort: 'xhigh'
})
expect(job.effort).toBe('xhigh')
})
it('stores configured data input ids and defaults to an empty selection', async () => {
const configured = await createJob({
name: 'Context Job',
promptTemplate: 'do it',
dataInputs: ['project-goals', 'open-issues']
})
expect(configured.dataInputs).toEqual(['project-goals', 'open-issues'])
const plain = await createJob({ name: 'Plain Job', promptTemplate: 'do it' })
expect(plain.dataInputs).toEqual([])
})
})
describe('updateJob', () => {
it('updates existing job', async () => {
const updates = {
name: 'Updated Name',
enabled: true
}
const job = await updateJob('job-test-1', updates)
expect(job.name).toBe('Updated Name')
expect(job.enabled).toBe(true)
expect(cosEvents.emit).toHaveBeenCalledWith('jobs:updated', {
id: 'job-test-1',
updates
})
})
it('returns null for non-existent job', async () => {
const job = await updateJob('nonexistent', { name: 'Updated' })
expect(job).toBeNull()
})
it('updates appId + taskMetadata, and can clear appId', async () => {
const scoped = await updateJob('job-test-1', { appId: 'app-abc', taskMetadata: { openPR: true } })
expect(scoped.appId).toBe('app-abc')
expect(scoped.taskMetadata).toEqual({ openPR: true })
const cleared = await updateJob('job-test-1', { appId: null })
expect(cleared.appId).toBeNull()
})
it('updates providerId + model, and can clear them', async () => {
const pinned = await updateJob('job-test-1', { providerId: 'anthropic', model: 'claude-opus-4-8' })
expect(pinned.providerId).toBe('anthropic')
expect(pinned.model).toBe('claude-opus-4-8')
const cleared = await updateJob('job-test-1', { providerId: null, model: null })
expect(cleared.providerId).toBeNull()
expect(cleared.model).toBeNull()
})
})
describe('deleteJob', () => {
it('deletes existing job', async () => {
const result = await deleteJob('job-test-1')
expect(result).toBe(true)
expect(cosEvents.emit).toHaveBeenCalledWith('jobs:deleted', {
id: 'job-test-1'
})
})
it('returns false for non-existent job', async () => {
const result = await deleteJob('nonexistent')
expect(result).toBe(false)
})
})
describe('recordJobExecution', () => {
it('updates lastRun and increments runCount', async () => {
const job = await recordJobExecution('job-test-1')
expect(job.lastRun).toBeDefined()
expect(job.runCount).toBe(1)
expect(cosEvents.emit).toHaveBeenCalledWith('jobs:executed', {
id: 'job-test-1',
runCount: 1
})
})
it('returns null for non-existent job', async () => {
const job = await recordJobExecution('nonexistent')
expect(job).toBeNull()
})
})
describe('toggleJob', () => {
it('toggles enabled state from true to false', async () => {
const job = await toggleJob('job-test-1')
expect(job.enabled).toBe(false)
expect(cosEvents.emit).toHaveBeenCalledWith('jobs:toggled', {
id: 'job-test-1',
enabled: false
})
})
it('toggles enabled state from false to true', async () => {
readJSONFile.mockResolvedValue({
...mockJobsData,
jobs: [{
...mockJobsData.jobs[0],
enabled: false
}]
})
const job = await toggleJob('job-test-1')
expect(job.enabled).toBe(true)
})
it('returns null for non-existent job', async () => {
const job = await toggleJob('nonexistent')
expect(job).toBeNull()
})
})
describe('getJobStats', () => {
it('returns correct statistics', async () => {
readJSONFile.mockResolvedValueOnce({
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [
{
id: 'job-1',
name: 'Job 1',
description: '',
category: 'test',
interval: 'daily',
intervalMs: 86400000,
enabled: true,
priority: 'MEDIUM',
autonomyLevel: 'manager',
promptTemplate: '',
lastRun: null,
runCount: 5,
createdAt: '2025-01-01T00:00:00.000Z',
updatedAt: '2025-01-01T00:00:00.000Z'
},
{
id: 'job-2',
name: 'Job 2',
description: '',
category: 'brain-processing',
interval: 'daily',
intervalMs: 86400000,
enabled: false,
priority: 'MEDIUM',
autonomyLevel: 'manager',
promptTemplate: '',
lastRun: null,
runCount: 3,
createdAt: '2025-01-01T00:00:00.000Z',
updatedAt: '2025-01-01T00:00:00.000Z'
}
]
})
const stats = await getJobStats()
expect(stats.total).toBeGreaterThan(0)
expect(stats.enabled).toBeGreaterThanOrEqual(1)
expect(stats.disabled).toBeGreaterThanOrEqual(1)
expect(stats.byCategory.test).toBe(1)
expect(stats.totalRuns).toBeGreaterThanOrEqual(8)
})
})
describe('script jobs', () => {
it('isScriptJob returns true for script-type jobs', () => {
const scriptJob = {
id: 'job-test',
type: 'script',
scriptHandler: 'autobiography-prompt'
}
expect(isScriptJob(scriptJob)).toBe(true)
})
it('isScriptJob returns false for regular jobs', () => {
const regularJob = {
id: 'job-test',
name: 'Regular Job',
promptTemplate: 'Do something'
}
expect(isScriptJob(regularJob)).toBe(false)
})
it('isScriptJob returns false if handler not registered', () => {
const invalidJob = {
id: 'job-test',
type: 'script',
scriptHandler: 'nonexistent-handler'
}
expect(isScriptJob(invalidJob)).toBe(false)
})
it('executeScriptJob calls the handler and records execution', async () => {
readJSONFile.mockResolvedValueOnce({
version: 1,
lastUpdated: '2025-01-01T00:00:00.000Z',
jobs: [
{
id: 'job-autobiography-prompt',
name: 'Autobiography Story Prompt',
type: 'script',
scriptHandler: 'autobiography-prompt',
enabled: true,
intervalMs: 86400000,
lastRun: null,
runCount: 0
}
]
})
const scriptJob = {
id: 'job-autobiography-prompt',
name: 'Autobiography Story Prompt',
type: 'script',
scriptHandler: 'autobiography-prompt'
}
const result = await executeScriptJob(scriptJob)
expect(checkAndPrompt).toHaveBeenCalled()
expect(result).toEqual({ prompted: true, prompt: { id: 'test-1', text: 'test' } })
expect(cosEvents.emit).toHaveBeenCalledWith('jobs:script-executed', {
id: 'job-autobiography-prompt',
result: { prompted: true, prompt: { id: 'test-1', text: 'test' } }
})
})
it('executeScriptJob throws for non-script jobs', async () => {
const regularJob = {
id: 'job-test',
name: 'Regular Job',
promptTemplate: 'Do something'
}
await expect(executeScriptJob(regularJob)).rejects.toThrow('not a script job')
})
})
describe('agentDataCleanup — paused agent protection', () => {
beforeEach(() => {
vi.clearAllMocks()
reapMergedWorktrees.mockResolvedValue({ reaped: [] })
cleanupOrphanedWorktrees.mockResolvedValue(0)
// No active in-memory agents by default
getActiveAgentIds.mockReturnValue([])
})
it('paused agent id is in the activeAgentIds set passed to reapMergedWorktrees', async () => {
// agentDataCleanup reads the stored agent statuses once
listStoredAgentStatuses.mockResolvedValueOnce([{ id: 'paused-agent-1', status: 'paused' }, { id: 'running-agent-2', status: 'running' }])
await agentDataCleanup()
expect(reapMergedWorktrees).toHaveBeenCalledOnce()
const [, opts] = reapMergedWorktrees.mock.calls[0]
expect(opts.activeAgentIds().has('paused-agent-1')).toBe(true)
})
it('paused agent id is in the set passed to cleanupOrphanedWorktrees', async () => {
listStoredAgentStatuses.mockResolvedValueOnce([{ id: 'paused-agent-1', status: 'paused' }, { id: 'running-agent-2', status: 'running' }])
await agentDataCleanup()
expect(cleanupOrphanedWorktrees).toHaveBeenCalledOnce()
const [, getActiveIds] = cleanupOrphanedWorktrees.mock.calls[0]
expect(getActiveIds().has('paused-agent-1')).toBe(true)
})
it('both reap passes see an agent dispatched after the job took its snapshot', async () => {
listStoredAgentStatuses.mockResolvedValueOnce([{ id: 'paused-agent-1', status: 'paused' }])
// Empty when the job starts; agent-x registers while the earlier passes run.
getActiveAgentIds.mockReturnValueOnce([]).mockReturnValue(['agent-x'])
await agentDataCleanup()
const [, opts] = reapMergedWorktrees.mock.calls[0]
const [, getActiveIds] = cleanupOrphanedWorktrees.mock.calls[0]
for (const ids of [opts.activeAgentIds(), getActiveIds()]) {
expect(ids.has('agent-x')).toBe(true)
expect(ids.has('paused-agent-1')).toBe(true)
}
})
it('non-paused agent is NOT added to the protect set via the stored statuses', async () => {
listStoredAgentStatuses.mockResolvedValueOnce([{ id: 'paused-agent-1', status: 'paused' }, { id: 'running-agent-2', status: 'running' }])
await agentDataCleanup()
const [, opts] = reapMergedWorktrees.mock.calls[0]
// running-agent-2 is not paused and not in getActiveAgentIds() → NOT in protect set
expect(opts.activeAgentIds().has('running-agent-2')).toBe(false)
})
it('in-memory active agents are also protected alongside paused agents', async () => {
getActiveAgentIds.mockReturnValue(['live-agent-99'])
listStoredAgentStatuses.mockResolvedValueOnce([{ id: 'paused-agent-1', status: 'paused' }])
await agentDataCleanup()
const [, opts] = reapMergedWorktrees.mock.calls[0]
expect(opts.activeAgentIds().has('paused-agent-1')).toBe(true)
expect(opts.activeAgentIds().has('live-agent-99')).toBe(true)
})
it('skips every reap when the stored statuses cannot be read (a paused agent could look orphaned)', async () => {
listStoredAgentStatuses.mockRejectedValueOnce(new Error('database unavailable'))
await expect(agentDataCleanup()).resolves.toMatchObject({ cleaned: 0, mergedReaped: 0, worktreesReaped: 0 })
expect(reapMergedWorktrees).not.toHaveBeenCalled()
expect(cleanupOrphanedWorktrees).not.toHaveBeenCalled()
})
})
})