@sooneocean/agw 1.5.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sooneocean/agw",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "Agent Gateway — multi-agent task router for Claude, Codex, Gemini with combos, DAG, DSL",
   "type": "module",
   "bin": {

package/src/cli/commands/dashboard.ts

@@ -0,0 +1,67 @@
+import type { Command } from 'commander';
+import { HttpClient } from '../http-client.js';
+
+export function registerDashboardCommand(program: Command): void {
+  program
+    .command('dashboard')
+    .alias('dash')
+    .description('Live terminal dashboard — refresh every 3 seconds')
+    .option('--once', 'Print once and exit')
+    .action(async (options: { once?: boolean }) => {
+      const client = new HttpClient();
+
+      const render = async () => {
+        try {
+          const [metrics, agents, costs] = await Promise.all([
+            client.get<any>('/metrics').catch(() => null),
+            client.get<any[]>('/agents').catch(() => []),
+            client.get<any>('/costs').catch(() => null),
+          ]);
+
+          console.clear();
+          console.log('\x1b[36m╔══════════════════════════════════════════════╗\x1b[0m');
+          console.log('\x1b[36m║\x1b[0m        \x1b[1mAGW Dashboard\x1b[0m                         \x1b[36m║\x1b[0m');
+          console.log('\x1b[36m╚══════════════════════════════════════════════╝\x1b[0m');
+
+          if (metrics) {
+            const up = Math.floor(metrics.uptime / 1000);
+            const h = Math.floor(up / 3600);
+            const m = Math.floor((up % 3600) / 60);
+            const s = up % 60;
+            console.log(`\n  Uptime: ${h}h ${m}m ${s}s    Memory: ${metrics.memory?.heapMB ?? '?'}MB`);
+            console.log(`\n  \x1b[1mTasks\x1b[0m`);
+            console.log(`    Total: ${metrics.tasks.total}  ✓ ${metrics.tasks.completed}  ✗ ${metrics.tasks.failed}  ⟳ ${metrics.tasks.running}  ⏳ ${metrics.tasks.pending ?? 0}`);
+            if (metrics.performance.avgDurationMs > 0) {
+              console.log(`    Avg: ${(metrics.performance.avgDurationMs / 1000).toFixed(1)}s  P95: ${(metrics.performance.p95DurationMs / 1000).toFixed(1)}s`);
+            }
+          } else {
+            console.log('\n  \x1b[31mDaemon not running\x1b[0m');
+          }
+
+          console.log(`\n  \x1b[1mAgents\x1b[0m`);
+          for (const a of agents) {
+            const icon = a.available ? '\x1b[32m●\x1b[0m' : '\x1b[31m●\x1b[0m';
+            console.log(`    ${icon} ${a.name.padEnd(12)} ${a.available ? 'Ready' : 'Down'}`);
+          }
+
+          if (costs) {
+            console.log(`\n  \x1b[1mCosts\x1b[0m`);
+            console.log(`    Daily:  $${costs.daily.toFixed(2)}${costs.dailyLimit ? ` / $${costs.dailyLimit.toFixed(2)}` : ''}`);
+            console.log(`    Monthly: $${costs.monthly.toFixed(2)}${costs.monthlyLimit ? ` / $${costs.monthlyLimit.toFixed(2)}` : ''}`);
+          }
+
+          if (!options.once) {
+            console.log(`\n  \x1b[2mRefreshing every 3s... (Ctrl+C to quit)\x1b[0m`);
+          }
+        } catch {
+          console.log('\x1b[31m  Cannot connect to daemon\x1b[0m');
+        }
+      };
+
+      await render();
+      if (options.once) return;
+
+      const interval = setInterval(render, 3000);
+      process.on('SIGINT', () => { clearInterval(interval); process.exit(0); });
+    });
+}

package/src/cli/index.ts

@@ -7,13 +7,14 @@ import { registerDaemonCommand } from './commands/daemon.js';
 import { registerCostsCommand } from './commands/costs.js';
 import { registerWorkflowCommand } from './commands/workflow.js';
 import { registerComboCommand } from './commands/combo.js';
+import { registerDashboardCommand } from './commands/dashboard.js';
 
 export function createCli(): Command {
   const program = new Command();
   program
     .name('agw')
     .description('Agent Gateway — route tasks to the best AI agent')
-    .version('0.3.0');
+    .version('1.7.0');
 
   registerRunCommand(program);
   registerStatusCommand(program);
@@ -23,6 +24,7 @@ export function createCli(): Command {
   registerCostsCommand(program);
   registerWorkflowCommand(program);
   registerComboCommand(program);
+  registerDashboardCommand(program);
 
   return program;
 }

package/src/daemon/routes/batch.ts

@@ -0,0 +1,45 @@
+import type { FastifyInstance } from 'fastify';
+import type { TaskExecutor } from '../services/task-executor.js';
+import type { LlmRouter } from '../../router/llm-router.js';
+import type { AgentManager } from '../services/agent-manager.js';
+import { BatchExecutor } from '../services/batch.js';
+import type { BatchItem } from '../services/batch.js';
+
+export function registerBatchRoutes(
+  app: FastifyInstance,
+  executor: TaskExecutor,
+  router: LlmRouter,
+  agentManager: AgentManager,
+): void {
+  const batchExecutor = new BatchExecutor();
+
+  app.post<{ Body: { items: BatchItem[]; concurrency?: number } }>('/batch', async (request, reply) => {
+    const { items, concurrency } = request.body;
+    if (!items || !Array.isArray(items) || items.length === 0) {
+      return reply.status(400).send({ error: 'items array is required' });
+    }
+    if (items.length > 50) {
+      return reply.status(400).send({ error: 'Maximum 50 items per batch' });
+    }
+
+    const result = await batchExecutor.execute(
+      items,
+      async (prompt, agent, priority) => {
+        const availableAgents = agentManager.getAvailableAgents();
+        const task = await executor.execute(
+          { prompt, preferredAgent: agent, priority },
+          async (p) => router.route(p, availableAgents, agent),
+        );
+        return {
+          taskId: task.taskId,
+          status: task.status,
+          stdout: task.result?.stdout,
+          error: task.status === 'failed' ? task.result?.stderr : undefined,
+        };
+      },
+      concurrency ?? 5,
+    );
+
+    return reply.status(200).send(result);
+  });
+}

package/src/daemon/routes/capabilities.ts

@@ -0,0 +1,17 @@
+import type { FastifyInstance } from 'fastify';
+import type { CapabilityDiscovery } from '../services/capability-discovery.js';
+
+export function registerCapabilityRoutes(app: FastifyInstance, discovery: CapabilityDiscovery): void {
+  app.get('/capabilities', async () => discovery.getAll());
+
+  app.get<{ Params: { agentId: string } }>('/capabilities/:agentId', async (request, reply) => {
+    const cap = discovery.get(request.params.agentId);
+    if (!cap) return reply.status(404).send({ error: 'Agent not found' });
+    return cap;
+  });
+
+  app.post<{ Body: { prompt: string; availableAgents?: string[] } }>('/capabilities/match', async (request) => {
+    const agents = request.body.availableAgents ?? ['claude', 'codex', 'gemini'];
+    return discovery.findBestMatch(request.body.prompt, agents) ?? { agentId: agents[0], score: 0, reason: 'Fallback' };
+  });
+}

package/src/daemon/routes/export-import.ts

@@ -0,0 +1,54 @@
+import type { FastifyInstance } from 'fastify';
+import type { TemplateEngine } from '../services/template-engine.js';
+import type { WebhookManager } from '../services/webhook-manager.js';
+import type { Scheduler } from '../services/scheduler.js';
+import type { MemoryRepo } from '../../store/memory-repo.js';
+import { COMBO_PRESETS } from '../services/combo-executor.js';
+import { createExport, validateImport } from '../services/export-import.js';
+
+export function registerExportImportRoutes(
+  app: FastifyInstance,
+  templateEngine: TemplateEngine,
+  webhookManager: WebhookManager,
+  scheduler: Scheduler,
+  memoryRepo: MemoryRepo,
+): void {
+  app.get('/export', async () => {
+    return createExport({
+      templates: templateEngine.list(),
+      comboPresets: COMBO_PRESETS,
+      webhooks: webhookManager.getWebhooks(),
+      memory: memoryRepo.list(1000),
+      scheduledJobs: scheduler.listJobs(),
+      version: '1.6.0',
+    });
+  });
+
+  app.post('/import', async (request, reply) => {
+    const data = request.body;
+    if (!validateImport(data)) {
+      return reply.status(400).send({ error: 'Invalid import format' });
+    }
+
+    let imported = { templates: 0, memory: 0, jobs: 0 };
+
+    for (const t of data.templates) {
+      templateEngine.register(t);
+      imported.templates++;
+    }
+
+    for (const m of data.memory) {
+      memoryRepo.set(m.key, m.value, m.scope);
+      imported.memory++;
+    }
+
+    for (const j of data.scheduledJobs) {
+      try {
+        scheduler.addJob(j);
+        imported.jobs++;
+      } catch { /* skip invalid */ }
+    }
+
+    return { imported };
+  });
+}

package/src/daemon/routes/replay.ts

@@ -0,0 +1,22 @@
+import type { FastifyInstance } from 'fastify';
+import type { ReplayManager } from '../services/replay.js';
+
+export function registerReplayRoutes(app: FastifyInstance, replayManager: ReplayManager): void {
+  app.post<{ Params: { id: string } }>('/tasks/:id/replay', async (request, reply) => {
+    try {
+      const task = await replayManager.replayTask(request.params.id);
+      return reply.status(201).send(task);
+    } catch (err) {
+      return reply.status(404).send({ error: (err as Error).message });
+    }
+  });
+
+  app.post<{ Params: { id: string } }>('/combos/:id/replay', async (request, reply) => {
+    try {
+      const comboId = replayManager.replayCombo(request.params.id);
+      return reply.status(202).send({ comboId, status: 'replaying' });
+    } catch (err) {
+      return reply.status(404).send({ error: (err as Error).message });
+    }
+  });
+}

package/src/daemon/routes/scheduler.ts

@@ -0,0 +1,38 @@
+import type { FastifyInstance } from 'fastify';
+import type { Scheduler } from '../services/scheduler.js';
+
+export function registerSchedulerRoutes(app: FastifyInstance, scheduler: Scheduler): void {
+  app.get('/scheduler/jobs', async () => scheduler.listJobs());
+
+  app.get<{ Params: { id: string } }>('/scheduler/jobs/:id', async (request, reply) => {
+    const job = scheduler.getJob(request.params.id);
+    if (!job) return reply.status(404).send({ error: 'Job not found' });
+    return job;
+  });
+
+  app.post('/scheduler/jobs', async (request, reply) => {
+    const body = request.body as any;
+    try {
+      const job = scheduler.addJob(body);
+      return reply.status(201).send(job);
+    } catch (err) {
+      return reply.status(400).send({ error: (err as Error).message });
+    }
+  });
+
+  app.delete<{ Params: { id: string } }>('/scheduler/jobs/:id', async (request, reply) => {
+    const removed = scheduler.removeJob(request.params.id);
+    if (!removed) return reply.status(404).send({ error: 'Job not found' });
+    return { removed: true };
+  });
+
+  app.post<{ Params: { id: string } }>('/scheduler/jobs/:id/enable', async (request, reply) => {
+    if (!scheduler.enableJob(request.params.id)) return reply.status(404).send({ error: 'Job not found' });
+    return { enabled: true };
+  });
+
+  app.post<{ Params: { id: string } }>('/scheduler/jobs/:id/disable', async (request, reply) => {
+    if (!scheduler.disableJob(request.params.id)) return reply.status(404).send({ error: 'Job not found' });
+    return { disabled: true };
+  });
+}

package/src/daemon/routes/snapshots.ts

@@ -0,0 +1,23 @@
+import type { FastifyInstance } from 'fastify';
+import type { SnapshotManager } from '../services/snapshot.js';
+
+export function registerSnapshotRoutes(app: FastifyInstance, snapshotManager: SnapshotManager): void {
+  app.get('/snapshots', async () => snapshotManager.list());
+
+  app.post<{ Body: { label?: string } }>('/snapshots', async (request, reply) => {
+    const info = snapshotManager.create(request.body?.label);
+    return reply.status(201).send(info);
+  });
+
+  app.post<{ Params: { id: string } }>('/snapshots/:id/restore', async (request, reply) => {
+    const ok = snapshotManager.restore(request.params.id);
+    if (!ok) return reply.status(404).send({ error: 'Snapshot not found' });
+    return { restored: true, note: 'Restart daemon to use restored data' };
+  });
+
+  app.delete<{ Params: { id: string } }>('/snapshots/:id', async (request, reply) => {
+    const ok = snapshotManager.delete(request.params.id);
+    if (!ok) return reply.status(404).send({ error: 'Snapshot not found' });
+    return { deleted: true };
+  });
+}

package/src/daemon/server.ts

@@ -30,6 +30,16 @@ import { registerMemoryRoutes } from './routes/memory.js';
 import { registerHealthRoutes } from './routes/health.js';
 import { registerTemplateRoutes } from './routes/templates.js';
 import { registerWebhookRoutes } from './routes/webhooks.js';
+import { Scheduler } from './services/scheduler.js';
+import { ReplayManager } from './services/replay.js';
+import { registerSchedulerRoutes } from './routes/scheduler.js';
+import { registerReplayRoutes } from './routes/replay.js';
+import { registerExportImportRoutes } from './routes/export-import.js';
+import { CapabilityDiscovery } from './services/capability-discovery.js';
+import { SnapshotManager } from './services/snapshot.js';
+import { registerCapabilityRoutes } from './routes/capabilities.js';
+import { registerBatchRoutes } from './routes/batch.js';
+import { registerSnapshotRoutes } from './routes/snapshots.js';
 
 interface ServerOptions {
   dbPath?: string;
@@ -65,6 +75,10 @@ export async function buildServer(options: ServerOptions = {}): Promise<FastifyI
   const templateEngine = new TemplateEngine();
   templateEngine.seedDefaults();
   const webhookManager = new WebhookManager();
+  const scheduler = new Scheduler();
+  const replayManager = new ReplayManager(taskRepo, comboRepo, executor, comboExecutor, router, agentManager);
+  const capDiscovery = new CapabilityDiscovery();
+  const snapshotManager = new SnapshotManager(dbPath);
 
   const app = Fastify({
     logger: false,
@@ -82,6 +96,12 @@ export async function buildServer(options: ServerOptions = {}): Promise<FastifyI
   registerHealthRoutes(app, metrics, agentManager, cbRegistry, taskRepo, costRepo, config);
   registerTemplateRoutes(app, templateEngine, executor, router, agentManager);
   registerWebhookRoutes(app, webhookManager);
+  registerSchedulerRoutes(app, scheduler);
+  registerReplayRoutes(app, replayManager);
+  registerExportImportRoutes(app, templateEngine, webhookManager, scheduler, memoryRepo);
+  registerCapabilityRoutes(app, capDiscovery);
+  registerBatchRoutes(app, executor, router, agentManager);
+  registerSnapshotRoutes(app, snapshotManager);
 
   app.register(import('./routes/ui.js'));
 
@@ -93,6 +113,7 @@ export async function buildServer(options: ServerOptions = {}): Promise<FastifyI
       taskRepo.updateStatus(t.taskId, 'failed');
       auditRepo.log(t.taskId, 'task.failed', { reason: 'daemon shutdown' });
     }
+    scheduler.stopAll();
     db.close();
   });
 

package/src/daemon/services/batch.ts

@@ -0,0 +1,69 @@
+/**
+ * Batch Execution — submit multiple tasks at once, get unified results.
+ */
+
+import { nanoid } from 'nanoid';
+
+export interface BatchItem {
+  prompt: string;
+  agent?: string;
+  priority?: number;
+}
+
+export interface BatchResult {
+  batchId: string;
+  total: number;
+  completed: number;
+  failed: number;
+  results: { index: number; taskId: string; status: string; output?: string; error?: string }[];
+  totalDurationMs: number;
+}
+
+type ExecuteFn = (prompt: string, agent?: string, priority?: number) => Promise<{ taskId: string; status: string; stdout?: string; error?: string }>;
+
+export class BatchExecutor {
+  async execute(items: BatchItem[], executeFn: ExecuteFn, concurrency: number = 5): Promise<BatchResult> {
+    const batchId = nanoid(8);
+    const start = Date.now();
+    const results: BatchResult['results'] = [];
+
+    // Process in chunks for concurrency control
+    for (let i = 0; i < items.length; i += concurrency) {
+      const chunk = items.slice(i, i + concurrency);
+      const chunkResults = await Promise.allSettled(
+        chunk.map(async (item, offset) => {
+          const result = await executeFn(item.prompt, item.agent, item.priority);
+          return {
+            index: i + offset,
+            taskId: result.taskId,
+            status: result.status,
+            output: result.stdout,
+            error: result.error,
+          };
+        })
+      );
+
+      for (const r of chunkResults) {
+        if (r.status === 'fulfilled') {
+          results.push(r.value);
+        } else {
+          results.push({
+            index: results.length,
+            taskId: '',
+            status: 'failed',
+            error: r.reason?.message ?? 'Unknown error',
+          });
+        }
+      }
+    }
+
+    return {
+      batchId,
+      total: items.length,
+      completed: results.filter(r => r.status === 'completed').length,
+      failed: results.filter(r => r.status === 'failed').length,
+      results,
+      totalDurationMs: Date.now() - start,
+    };
+  }
+}

package/src/daemon/services/capability-discovery.ts

@@ -0,0 +1,130 @@
+/**
+ * Capability Discovery — probes agents to determine what they can do.
+ * Each agent is asked to self-describe its capabilities.
+ * Results are cached and used for smarter routing.
+ */
+
+export interface AgentCapability {
+  agentId: string;
+  strengths: string[];
+  weaknesses: string[];
+  maxContextLength?: number;
+  supportsStreaming: boolean;
+  supportsImages: boolean;
+  languages: string[];
+  specializations: string[];
+  discoveredAt: string;
+}
+
+const KNOWN_CAPABILITIES: Record<string, AgentCapability> = {
+  claude: {
+    agentId: 'claude',
+    strengths: ['complex reasoning', 'code review', 'architecture', 'refactoring', 'explanation', 'security analysis', 'long context'],
+    weaknesses: ['real-time data', 'running arbitrary shell commands autonomously'],
+    maxContextLength: 1_000_000,
+    supportsStreaming: true,
+    supportsImages: true,
+    languages: ['typescript', 'python', 'rust', 'go', 'java', 'c++', 'sql', 'bash'],
+    specializations: ['code-review', 'architecture', 'debugging', 'documentation', 'security-audit'],
+    discoveredAt: new Date().toISOString(),
+  },
+  codex: {
+    agentId: 'codex',
+    strengths: ['code generation', 'file operations', 'shell commands', 'quick edits', 'scripting', 'automation'],
+    weaknesses: ['long context reasoning', 'multi-file architecture decisions'],
+    maxContextLength: 200_000,
+    supportsStreaming: true,
+    supportsImages: false,
+    languages: ['typescript', 'python', 'rust', 'go', 'bash', 'sql'],
+    specializations: ['implementation', 'scripting', 'file-ops', 'testing', 'automation'],
+    discoveredAt: new Date().toISOString(),
+  },
+  gemini: {
+    agentId: 'gemini',
+    strengths: ['research', 'web search', 'multimodal', 'summarization', 'comparison', 'broad knowledge'],
+    weaknesses: ['precise code editing', 'complex refactoring'],
+    maxContextLength: 1_000_000,
+    supportsStreaming: true,
+    supportsImages: true,
+    languages: ['typescript', 'python', 'java', 'go', 'kotlin'],
+    specializations: ['research', 'summarization', 'comparison', 'multimodal-analysis'],
+    discoveredAt: new Date().toISOString(),
+  },
+};
+
+export class CapabilityDiscovery {
+  private capabilities = new Map<string, AgentCapability>();
+
+  constructor() {
+    // Seed known capabilities
+    for (const [id, cap] of Object.entries(KNOWN_CAPABILITIES)) {
+      this.capabilities.set(id, cap);
+    }
+  }
+
+  get(agentId: string): AgentCapability | undefined {
+    return this.capabilities.get(agentId);
+  }
+
+  getAll(): AgentCapability[] {
+    return Array.from(this.capabilities.values());
+  }
+
+  /** Find the best agent for a given task description */
+  findBestMatch(taskDescription: string, availableAgentIds: string[]): { agentId: string; score: number; reason: string } | undefined {
+    const lower = taskDescription.toLowerCase();
+    let bestMatch: { agentId: string; score: number; reason: string } | undefined;
+
+    for (const agentId of availableAgentIds) {
+      const cap = this.capabilities.get(agentId);
+      if (!cap) continue;
+
+      let score = 0;
+      const matchedStrengths: string[] = [];
+
+      for (const strength of cap.strengths) {
+        const words = strength.toLowerCase().split(/\s+/);
+        for (const word of words) {
+          if (word.length > 3 && lower.includes(word)) {
+            score += 2;
+            matchedStrengths.push(strength);
+            break;
+          }
+        }
+      }
+
+      for (const spec of cap.specializations) {
+        if (lower.includes(spec.replace('-', ' ')) || lower.includes(spec)) {
+          score += 3;
+          matchedStrengths.push(`specialization: ${spec}`);
+        }
+      }
+
+      // Penalty for weaknesses
+      for (const weakness of cap.weaknesses) {
+        const words = weakness.toLowerCase().split(/\s+/);
+        for (const word of words) {
+          if (word.length > 4 && lower.includes(word)) {
+            score -= 1;
+          }
+        }
+      }
+
+      if (!bestMatch || score > bestMatch.score) {
+        bestMatch = {
+          agentId,
+          score,
+          reason: matchedStrengths.length > 0
+            ? `Matched: ${matchedStrengths.slice(0, 3).join(', ')}`
+            : 'Default selection',
+        };
+      }
+    }
+
+    return bestMatch;
+  }
+
+  register(cap: AgentCapability): void {
+    this.capabilities.set(cap.agentId, cap);
+  }
+}

package/src/daemon/services/export-import.ts

@@ -0,0 +1,62 @@
+/**
+ * Export/Import — serialize AGW configuration and data for sharing/backup.
+ *
+ * Exports: templates, combo presets, webhooks, memory entries, scheduled jobs.
+ * Does NOT export: tasks, audit logs, cost records (runtime data).
+ */
+
+import type { TaskTemplate } from './template-engine.js';
+import type { WebhookConfig } from './webhook-manager.js';
+import type { ScheduledJob } from './scheduler.js';
+import type { MemoryEntry } from '../../store/memory-repo.js';
+import type { ComboPreset } from '../../types.js';
+
+export interface AgwExport {
+  version: string;
+  exportedAt: string;
+  templates: TaskTemplate[];
+  comboPresets: ComboPreset[];
+  webhooks: WebhookConfig[];
+  memory: MemoryEntry[];
+  scheduledJobs: Omit<ScheduledJob, 'id' | 'intervalMs' | 'nextRun' | 'runCount' | 'lastRun'>[];
+}
+
+export function createExport(data: {
+  templates: TaskTemplate[];
+  comboPresets: ComboPreset[];
+  webhooks: WebhookConfig[];
+  memory: MemoryEntry[];
+  scheduledJobs: ScheduledJob[];
+  version: string;
+}): AgwExport {
+  return {
+    version: data.version,
+    exportedAt: new Date().toISOString(),
+    templates: data.templates,
+    comboPresets: data.comboPresets,
+    webhooks: data.webhooks.map(w => ({ ...w, secret: undefined })), // Strip secrets
+    memory: data.memory,
+    scheduledJobs: data.scheduledJobs.map(j => ({
+      name: j.name,
+      type: j.type,
+      target: j.target,
+      params: j.params,
+      interval: j.interval,
+      agent: j.agent,
+      priority: j.priority,
+      workingDirectory: j.workingDirectory,
+      enabled: j.enabled,
+    })),
+  };
+}
+
+export function validateImport(data: unknown): data is AgwExport {
+  if (!data || typeof data !== 'object') return false;
+  const d = data as Record<string, unknown>;
+  return (
+    typeof d.version === 'string' &&
+    typeof d.exportedAt === 'string' &&
+    Array.isArray(d.templates) &&
+    Array.isArray(d.memory)
+  );
+}

package/src/daemon/services/replay.ts

@@ -0,0 +1,53 @@
+/**
+ * Replay — re-run a completed/failed task or combo with the same parameters.
+ */
+
+import type { TaskDescriptor, ComboDescriptor, CreateComboRequest } from '../../types.js';
+import type { TaskExecutor } from './task-executor.js';
+import type { ComboExecutor } from './combo-executor.js';
+import type { TaskRepo } from '../../store/task-repo.js';
+import type { ComboRepo } from '../../store/combo-repo.js';
+import type { LlmRouter } from '../../router/llm-router.js';
+import type { AgentManager } from './agent-manager.js';
+
+export class ReplayManager {
+  constructor(
+    private taskRepo: TaskRepo,
+    private comboRepo: ComboRepo,
+    private taskExecutor: TaskExecutor,
+    private comboExecutor: ComboExecutor,
+    private router: LlmRouter,
+    private agentManager: AgentManager,
+  ) {}
+
+  async replayTask(taskId: string): Promise<TaskDescriptor> {
+    const original = this.taskRepo.getById(taskId);
+    if (!original) throw new Error(`Task ${taskId} not found`);
+
+    const availableAgents = this.agentManager.getAvailableAgents();
+    return this.taskExecutor.execute(
+      {
+        prompt: original.prompt,
+        preferredAgent: original.assignedAgent,
+        workingDirectory: original.workingDirectory,
+        priority: original.priority,
+      },
+      async (p) => this.router.route(p, availableAgents, original.assignedAgent),
+    );
+  }
+
+  replayCombo(comboId: string): string {
+    const original = this.comboRepo.getById(comboId);
+    if (!original) throw new Error(`Combo ${comboId} not found`);
+
+    const request: CreateComboRequest = {
+      name: `${original.name} (replay)`,
+      pattern: original.pattern,
+      steps: original.steps,
+      input: original.input,
+      maxIterations: original.maxIterations,
+    };
+
+    return this.comboExecutor.start(request);
+  }
+}

package/src/daemon/services/scheduler.ts

@@ -0,0 +1,115 @@
+/**
+ * Scheduler — run tasks, combos, or templates on cron-like intervals.
+ *
+ * Supports: interval-based scheduling (every N minutes/hours).
+ * Cron expressions are parsed as simple patterns: "every 5m", "every 1h", "every 30s".
+ */
+
+import { nanoid } from 'nanoid';
+import { EventEmitter } from 'node:events';
+
+export interface ScheduledJob {
+  id: string;
+  name: string;
+  type: 'task' | 'combo-preset' | 'template';
+  target: string;           // prompt for task, presetId for combo, templateId for template
+  params?: Record<string, string>;  // for templates
+  interval: string;         // "every 5m", "every 1h"
+  intervalMs: number;       // parsed interval in ms
+  agent?: string;
+  priority?: number;
+  workingDirectory?: string;
+  enabled: boolean;
+  lastRun?: string;
+  nextRun: string;
+  runCount: number;
+}
+
+export function parseInterval(expr: string): number {
+  const match = expr.match(/^every\s+(\d+)\s*(s|m|h|d)$/i);
+  if (!match) throw new Error(`Invalid interval: "${expr}". Use "every Ns/m/h/d"`);
+
+  const value = parseInt(match[1], 10);
+  const unit = match[2].toLowerCase();
+  const multipliers: Record<string, number> = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+  return value * multipliers[unit];
+}
+
+export class Scheduler extends EventEmitter {
+  private jobs = new Map<string, ScheduledJob>();
+  private timers = new Map<string, NodeJS.Timeout>();
+
+  addJob(job: Omit<ScheduledJob, 'id' | 'intervalMs' | 'nextRun' | 'runCount'>): ScheduledJob {
+    const id = nanoid(8);
+    const intervalMs = parseInterval(job.interval);
+    const scheduled: ScheduledJob = {
+      ...job,
+      id,
+      intervalMs,
+      nextRun: new Date(Date.now() + intervalMs).toISOString(),
+      runCount: 0,
+    };
+
+    this.jobs.set(id, scheduled);
+
+    if (scheduled.enabled) {
+      this.startTimer(scheduled);
+    }
+
+    return scheduled;
+  }
+
+  removeJob(id: string): boolean {
+    const timer = this.timers.get(id);
+    if (timer) { clearInterval(timer); this.timers.delete(id); }
+    return this.jobs.delete(id);
+  }
+
+  enableJob(id: string): boolean {
+    const job = this.jobs.get(id);
+    if (!job) return false;
+    job.enabled = true;
+    this.startTimer(job);
+    return true;
+  }
+
+  disableJob(id: string): boolean {
+    const job = this.jobs.get(id);
+    if (!job) return false;
+    job.enabled = false;
+    const timer = this.timers.get(id);
+    if (timer) { clearInterval(timer); this.timers.delete(id); }
+    return true;
+  }
+
+  getJob(id: string): ScheduledJob | undefined {
+    return this.jobs.get(id);
+  }
+
+  listJobs(): ScheduledJob[] {
+    return Array.from(this.jobs.values());
+  }
+
+  private startTimer(job: ScheduledJob): void {
+    const existing = this.timers.get(job.id);
+    if (existing) clearInterval(existing);
+
+    const timer = setInterval(() => {
+      job.runCount++;
+      job.lastRun = new Date().toISOString();
+      job.nextRun = new Date(Date.now() + job.intervalMs).toISOString();
+      this.emit('job:trigger', job);
+    }, job.intervalMs);
+
+    // Don't keep process alive just for scheduling
+    timer.unref();
+    this.timers.set(job.id, timer);
+  }
+
+  stopAll(): void {
+    for (const [id, timer] of this.timers) {
+      clearInterval(timer);
+    }
+    this.timers.clear();
+  }
+}

package/src/daemon/services/snapshot.ts

@@ -0,0 +1,82 @@
+/**
+ * Snapshot — full system state backup and restore.
+ * Copies the entire SQLite database file.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const SNAPSHOT_DIR = path.join(os.homedir(), '.agw', 'snapshots');
+
+export interface SnapshotInfo {
+  id: string;
+  filename: string;
+  createdAt: string;
+  sizeBytes: number;
+}
+
+export class SnapshotManager {
+  private dbPath: string;
+
+  constructor(dbPath: string) {
+    this.dbPath = dbPath;
+    if (!fs.existsSync(SNAPSHOT_DIR)) {
+      fs.mkdirSync(SNAPSHOT_DIR, { recursive: true });
+    }
+  }
+
+  create(label?: string): SnapshotInfo {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const id = label ? `${label}-${timestamp}` : timestamp;
+    const filename = `snapshot-${id}.db`;
+    const destPath = path.join(SNAPSHOT_DIR, filename);
+
+    fs.copyFileSync(this.dbPath, destPath);
+
+    const stat = fs.statSync(destPath);
+    return {
+      id,
+      filename,
+      createdAt: new Date().toISOString(),
+      sizeBytes: stat.size,
+    };
+  }
+
+  restore(id: string): boolean {
+    const filename = `snapshot-${id}.db`;
+    const srcPath = path.join(SNAPSHOT_DIR, filename);
+    if (!fs.existsSync(srcPath)) return false;
+
+    // Backup current before overwriting
+    const backupPath = `${this.dbPath}.pre-restore`;
+    fs.copyFileSync(this.dbPath, backupPath);
+    fs.copyFileSync(srcPath, this.dbPath);
+    return true;
+  }
+
+  list(): SnapshotInfo[] {
+    if (!fs.existsSync(SNAPSHOT_DIR)) return [];
+    return fs.readdirSync(SNAPSHOT_DIR)
+      .filter(f => f.startsWith('snapshot-') && f.endsWith('.db'))
+      .map(f => {
+        const stat = fs.statSync(path.join(SNAPSHOT_DIR, f));
+        const id = f.replace(/^snapshot-/, '').replace(/\.db$/, '');
+        return {
+          id,
+          filename: f,
+          createdAt: stat.mtime.toISOString(),
+          sizeBytes: stat.size,
+        };
+      })
+      .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  }
+
+  delete(id: string): boolean {
+    const filename = `snapshot-${id}.db`;
+    const filePath = path.join(SNAPSHOT_DIR, filename);
+    if (!fs.existsSync(filePath)) return false;
+    fs.unlinkSync(filePath);
+    return true;
+  }
+}

package/src/daemon/services/task-chain.ts

@@ -0,0 +1,93 @@
+/**
+ * Task Chain — linked tasks with automatic rollback on failure.
+ * Each step can define a rollback action that runs if a later step fails.
+ */
+
+import { nanoid } from 'nanoid';
+import { EventEmitter } from 'node:events';
+
+export interface ChainStep {
+  prompt: string;
+  agent?: string;
+  rollbackPrompt?: string;  // prompt to execute if this step needs rollback
+}
+
+export interface ChainResult {
+  chainId: string;
+  status: 'completed' | 'failed' | 'rolled-back';
+  completedSteps: number;
+  failedAtStep?: number;
+  rolledBackSteps: number;
+  stepResults: { stepIndex: number; output: string; exitCode: number }[];
+}
+
+type ExecuteFn = (prompt: string, agent?: string) => Promise<{ stdout: string; exitCode: number }>;
+
+export class TaskChain extends EventEmitter {
+  async execute(steps: ChainStep[], executeFn: ExecuteFn): Promise<ChainResult> {
+    const chainId = nanoid(12);
+    const stepResults: ChainResult['stepResults'] = [];
+    let failedAtStep: number | undefined;
+
+    this.emit('chain:start', chainId, steps.length);
+
+    // Execute forward
+    for (let i = 0; i < steps.length; i++) {
+      this.emit('chain:step', chainId, i, 'executing');
+      try {
+        const result = await executeFn(steps[i].prompt, steps[i].agent);
+        stepResults.push({ stepIndex: i, output: result.stdout, exitCode: result.exitCode });
+
+        if (result.exitCode !== 0) {
+          failedAtStep = i;
+          this.emit('chain:step', chainId, i, 'failed');
+          break;
+        }
+        this.emit('chain:step', chainId, i, 'completed');
+      } catch (err) {
+        stepResults.push({ stepIndex: i, output: (err as Error).message, exitCode: 1 });
+        failedAtStep = i;
+        this.emit('chain:step', chainId, i, 'failed');
+        break;
+      }
+    }
+
+    // If all succeeded
+    if (failedAtStep === undefined) {
+      this.emit('chain:done', chainId, 'completed');
+      return {
+        chainId,
+        status: 'completed',
+        completedSteps: steps.length,
+        rolledBackSteps: 0,
+        stepResults,
+      };
+    }
+
+    // Rollback: execute rollback prompts in reverse order for completed steps
+    let rolledBack = 0;
+    for (let i = failedAtStep - 1; i >= 0; i--) {
+      if (!steps[i].rollbackPrompt) continue;
+      this.emit('chain:rollback', chainId, i);
+      try {
+        await executeFn(steps[i].rollbackPrompt!, steps[i].agent);
+        rolledBack++;
+      } catch {
+        // Rollback failure is logged but doesn't stop the rollback process
+        this.emit('chain:rollback-failed', chainId, i);
+      }
+    }
+
+    const status = rolledBack > 0 ? 'rolled-back' : 'failed';
+    this.emit('chain:done', chainId, status);
+
+    return {
+      chainId,
+      status,
+      completedSteps: failedAtStep,
+      failedAtStep,
+      rolledBackSteps: rolledBack,
+      stepResults,
+    };
+  }
+}