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 } from 'vitest';
import { calculateBackoff, generateTaskFromFeatureAgent } from './featureAgents.js';
/**
* Tests for feature agents pure logic.
*/
const _MIN_BACKOFF_MS = 60 * 60 * 1000;
const MAX_BACKOFF_MS = 24 * 60 * 60 * 1000;
describe('Feature Agent Backoff Calculation', () => {
it('should start at 1 hour for first idle', () => {
expect(calculateBackoff(1)).toBe(60 * 60 * 1000);
});
it('should double for each consecutive idle', () => {
expect(calculateBackoff(2)).toBe(2 * 60 * 60 * 1000);
expect(calculateBackoff(3)).toBe(4 * 60 * 60 * 1000);
});
it('should cap at 24 hours', () => {
expect(calculateBackoff(10)).toBe(MAX_BACKOFF_MS);
expect(calculateBackoff(100)).toBe(MAX_BACKOFF_MS);
});
});
describe('Feature Agent Scheduling Logic', () => {
function isDue(agent, now) {
if (agent.status !== 'active') return false;
if (agent.currentAgentId) return false;
if (agent.backoff?.currentDelayMs) {
const nextAllowed = new Date(agent.backoff.lastIdleAt).getTime() + agent.backoff.currentDelayMs;
if (now < nextAllowed) return false;
}
const lastRun = agent.lastRunAt ? new Date(agent.lastRunAt).getTime() : 0;
const mode = agent.schedule?.mode || 'continuous';
if (mode === 'continuous') {
const pause = agent.schedule?.pauseBetweenRunsMs || 60000;
return now - lastRun >= pause;
} else if (mode === 'interval') {
const interval = agent.schedule?.intervalMs || 3600000;
return now - lastRun >= interval;
}
return false;
}
const baseAgent = {
status: 'active',
currentAgentId: null,
backoff: null,
lastRunAt: null,
schedule: { mode: 'continuous', pauseBetweenRunsMs: 60000 }
};
it('should be due when never run before', () => {
expect(isDue(baseAgent, Date.now())).toBe(true);
});
it('should not be due when recently run (continuous)', () => {
const agent = { ...baseAgent, lastRunAt: new Date().toISOString() };
expect(isDue(agent, Date.now())).toBe(false);
});
it('should be due when pause elapsed (continuous)', () => {
const agent = {
...baseAgent,
lastRunAt: new Date(Date.now() - 120000).toISOString()
};
expect(isDue(agent, Date.now())).toBe(true);
});
it('should respect interval mode', () => {
const agent = {
...baseAgent,
schedule: { mode: 'interval', intervalMs: 3600000 },
lastRunAt: new Date(Date.now() - 1800000).toISOString() // 30min ago
};
expect(isDue(agent, Date.now())).toBe(false);
const oldAgent = {
...agent,
lastRunAt: new Date(Date.now() - 7200000).toISOString() // 2h ago
};
expect(isDue(oldAgent, Date.now())).toBe(true);
});
it('should skip non-active agents', () => {
expect(isDue({ ...baseAgent, status: 'draft' }, Date.now())).toBe(false);
expect(isDue({ ...baseAgent, status: 'paused' }, Date.now())).toBe(false);
});
it('should skip agents already running', () => {
const agent = { ...baseAgent, currentAgentId: 'agent-123' };
expect(isDue(agent, Date.now())).toBe(false);
});
it('should skip agents in backoff', () => {
const agent = {
...baseAgent,
backoff: {
currentDelayMs: 3600000,
lastIdleAt: new Date().toISOString(),
consecutiveIdles: 1
}
};
expect(isDue(agent, Date.now())).toBe(false);
});
it('should allow agents past backoff window', () => {
const agent = {
...baseAgent,
backoff: {
currentDelayMs: 3600000,
lastIdleAt: new Date(Date.now() - 7200000).toISOString(),
consecutiveIdles: 1
}
};
expect(isDue(agent, Date.now())).toBe(true);
});
});
describe('Feature Agent State Transitions', () => {
function canResume(status) {
return status === 'paused';
}
function canActivate(status) {
return status !== 'active';
}
it('should only resume from paused', () => {
expect(canResume('paused')).toBe(true);
expect(canResume('active')).toBe(false);
expect(canResume('draft')).toBe(false);
expect(canResume('error')).toBe(false);
});
it('should activate from any non-active state', () => {
expect(canActivate('draft')).toBe(true);
expect(canActivate('paused')).toBe(true);
expect(canActivate('active')).toBe(false);
});
});
describe('Feature Agent Task Generation', () => {
const agent = {
id: 'fa-abc123',
name: 'UI Agent',
description: 'Polish UI',
priority: 'HIGH',
appId: 'app-001',
providerId: 'prov-1',
model: 'opus',
effort: 'high'
};
it('should generate task with correct metadata', () => {
const task = generateTaskFromFeatureAgent(agent);
expect(task.metadata.featureAgentId).toBe('fa-abc123');
expect(task.metadata.featureAgentRun).toBe(true);
expect(task.metadata.app).toBe('app-001');
expect(task.metadata.effort).toBe('high');
});
it('should use agent priority', () => {
const task = generateTaskFromFeatureAgent(agent);
expect(task.priority).toBe('HIGH');
});
it('should default to MEDIUM priority', () => {
const task = generateTaskFromFeatureAgent({ ...agent, priority: undefined });
expect(task.priority).toBe('MEDIUM');
});
it('should be an internal pending task', () => {
const task = generateTaskFromFeatureAgent(agent);
expect(task.taskType).toBe('internal');
expect(task.status).toBe('pending');
expect(task.approvalRequired).toBe(false);
});
it('should include feature agent description', () => {
const task = generateTaskFromFeatureAgent(agent);
expect(task.description).toContain('UI Agent');
expect(task.description).toContain('Polish UI');
});
});