@sooneocean/agw 1.4.0 → 1.6.0

package/package.json

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

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/templates.ts

@@ -0,0 +1,60 @@
+import type { FastifyInstance } from 'fastify';
+import type { TemplateEngine, TaskTemplate, InstantiateRequest } from '../services/template-engine.js';
+import type { TaskExecutor } from '../services/task-executor.js';
+import type { LlmRouter } from '../../router/llm-router.js';
+import type { AgentManager } from '../services/agent-manager.js';
+
+export function registerTemplateRoutes(
+  app: FastifyInstance,
+  templateEngine: TemplateEngine,
+  executor: TaskExecutor,
+  router: LlmRouter,
+  agentManager: AgentManager,
+): void {
+  // List templates
+  app.get<{ Querystring: { tag?: string } }>('/templates', async (request) => {
+    return templateEngine.list(request.query.tag);
+  });
+
+  // Get template
+  app.get<{ Params: { id: string } }>('/templates/:id', async (request, reply) => {
+    const t = templateEngine.get(request.params.id);
+    if (!t) return reply.status(404).send({ error: 'Template not found' });
+    return t;
+  });
+
+  // Register custom template
+  app.post<{ Body: TaskTemplate }>('/templates', async (request, reply) => {
+    templateEngine.register(request.body);
+    return reply.status(201).send(request.body);
+  });
+
+  // Delete template
+  app.delete<{ Params: { id: string } }>('/templates/:id', async (request, reply) => {
+    const deleted = templateEngine.unregister(request.params.id);
+    if (!deleted) return reply.status(404).send({ error: 'Template not found' });
+    return { deleted: true };
+  });
+
+  // Instantiate and execute a template
+  app.post<{ Body: InstantiateRequest }>('/templates/execute', async (request, reply) => {
+    try {
+      const { prompt, agent, priority } = templateEngine.instantiate(request.body);
+      const availableAgents = agentManager.getAvailableAgents();
+
+      const task = await executor.execute(
+        {
+          prompt,
+          preferredAgent: agent ?? request.body.overrides?.agent,
+          workingDirectory: request.body.overrides?.workingDirectory,
+          priority,
+        },
+        async (p) => router.route(p, availableAgents, agent),
+      );
+
+      return reply.status(201).send(task);
+    } catch (err) {
+      return reply.status(400).send({ error: (err as Error).message });
+    }
+  });
+}

package/src/daemon/routes/webhooks.ts

@@ -0,0 +1,18 @@
+import type { FastifyInstance } from 'fastify';
+import type { WebhookManager, WebhookConfig } from '../services/webhook-manager.js';
+
+export function registerWebhookRoutes(app: FastifyInstance, webhookManager: WebhookManager): void {
+  app.get('/webhooks', async () => {
+    return webhookManager.getWebhooks();
+  });
+
+  app.post<{ Body: WebhookConfig }>('/webhooks', async (request, reply) => {
+    webhookManager.addWebhook(request.body);
+    return reply.status(201).send({ registered: true, url: request.body.url });
+  });
+
+  app.delete<{ Body: { url: string } }>('/webhooks', async (request) => {
+    webhookManager.removeWebhook(request.body.url);
+    return { removed: true };
+  });
+}

package/src/daemon/server.ts

@@ -10,22 +10,31 @@ import { AuditRepo } from '../store/audit-repo.js';
 import { CostRepo } from '../store/cost-repo.js';
 import { WorkflowRepo } from '../store/workflow-repo.js';
 import { ComboRepo } from '../store/combo-repo.js';
+import { MemoryRepo } from '../store/memory-repo.js';
 import { AgentManager } from './services/agent-manager.js';
 import { TaskExecutor } from './services/task-executor.js';
 import { WorkflowExecutor } from './services/workflow-executor.js';
 import { ComboExecutor } from './services/combo-executor.js';
 import { LlmRouter } from '../router/llm-router.js';
+import { MetricsCollector } from './services/metrics.js';
+import { CircuitBreakerRegistry } from './services/circuit-breaker.js';
+import { TemplateEngine } from './services/template-engine.js';
+import { WebhookManager } from './services/webhook-manager.js';
 import { registerAuthMiddleware } from './middleware/auth.js';
 import { registerAgentRoutes } from './routes/agents.js';
 import { registerTaskRoutes } from './routes/tasks.js';
 import { registerWorkflowRoutes } from './routes/workflows.js';
 import { registerCostRoutes } from './routes/costs.js';
 import { registerComboRoutes } from './routes/combos.js';
-import { MemoryRepo } from '../store/memory-repo.js';
 import { registerMemoryRoutes } from './routes/memory.js';
 import { registerHealthRoutes } from './routes/health.js';
-import { MetricsCollector } from './services/metrics.js';
-import { CircuitBreakerRegistry } from './services/circuit-breaker.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';
 
 interface ServerOptions {
   dbPath?: string;
@@ -58,6 +67,11 @@ export async function buildServer(options: ServerOptions = {}): Promise<FastifyI
   const comboExecutor = new ComboExecutor(comboRepo, auditRepo, executor, agentManager);
   const metrics = new MetricsCollector();
   const cbRegistry = new CircuitBreakerRegistry();
+  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 app = Fastify({
     logger: false,
@@ -73,6 +87,11 @@ export async function buildServer(options: ServerOptions = {}): Promise<FastifyI
   registerComboRoutes(app, comboExecutor, config);
   registerMemoryRoutes(app, memoryRepo);
   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);
 
   app.register(import('./routes/ui.js'));
 
@@ -84,6 +103,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/condition-engine.ts

@@ -0,0 +1,75 @@
+/**
+ * Condition Engine — evaluates conditions on agent output to control combo flow.
+ *
+ * Conditions:
+ *   contains:"APPROVED"     — output contains string
+ *   !contains:"ERROR"       — output does NOT contain string
+ *   exitCode:0              — task exit code equals value
+ *   length>100              — output length greater than threshold
+ *   matches:/pattern/i      — output matches regex
+ *   always                  — always true (default)
+ */
+
+export interface Condition {
+  type: 'contains' | 'not-contains' | 'exitCode' | 'length-gt' | 'length-lt' | 'matches' | 'always';
+  value?: string | number;
+}
+
+export interface ConditionalBranch {
+  condition: Condition;
+  thenStep: number;  // step index to jump to
+  elseStep?: number; // step index if condition is false
+}
+
+export function parseCondition(expr: string): Condition {
+  if (expr === 'always') return { type: 'always' };
+
+  const containsMatch = expr.match(/^contains:"(.+)"$/);
+  if (containsMatch) return { type: 'contains', value: containsMatch[1] };
+
+  const notContainsMatch = expr.match(/^!contains:"(.+)"$/);
+  if (notContainsMatch) return { type: 'not-contains', value: notContainsMatch[1] };
+
+  const exitCodeMatch = expr.match(/^exitCode:(\d+)$/);
+  if (exitCodeMatch) return { type: 'exitCode', value: parseInt(exitCodeMatch[1], 10) };
+
+  const lengthGtMatch = expr.match(/^length>(\d+)$/);
+  if (lengthGtMatch) return { type: 'length-gt', value: parseInt(lengthGtMatch[1], 10) };
+
+  const lengthLtMatch = expr.match(/^length<(\d+)$/);
+  if (lengthLtMatch) return { type: 'length-lt', value: parseInt(lengthLtMatch[1], 10) };
+
+  const matchesMatch = expr.match(/^matches:\/(.+)\/([gimsuy]*)$/);
+  if (matchesMatch) return { type: 'matches', value: matchesMatch[1] + (matchesMatch[2] ? `/${matchesMatch[2]}` : '') };
+
+  throw new Error(`Invalid condition: ${expr}`);
+}
+
+export function evaluateCondition(condition: Condition, output: string, exitCode: number = 0): boolean {
+  switch (condition.type) {
+    case 'always':
+      return true;
+
+    case 'contains':
+      return output.includes(String(condition.value));
+
+    case 'not-contains':
+      return !output.includes(String(condition.value));
+
+    case 'exitCode':
+      return exitCode === condition.value;
+
+    case 'length-gt':
+      return output.length > (condition.value as number);
+
+    case 'length-lt':
+      return output.length < (condition.value as number);
+
+    case 'matches': {
+      const parts = String(condition.value).split('/');
+      const pattern = parts[0];
+      const flags = parts[1] ?? '';
+      return new RegExp(pattern, flags).test(output);
+    }
+  }
+}

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/template-engine.ts

@@ -0,0 +1,145 @@
+/**
+ * Task Template Engine — reusable parameterized task definitions.
+ *
+ * Templates use {{param.name}} syntax for user-supplied values.
+ * Templates can be stored, listed, and instantiated.
+ *
+ * Example:
+ *   { id: "code-review", prompt: "Review {{param.file}} for {{param.criteria}}", agent: "claude" }
+ *   Instantiate with: { templateId: "code-review", params: { file: "auth.ts", criteria: "security" } }
+ */
+
+export interface TaskTemplate {
+  id: string;
+  name: string;
+  description: string;
+  prompt: string;           // template with {{param.name}} placeholders
+  agent?: string;           // default agent
+  priority?: number;
+  params: TemplateParam[];  // parameter definitions
+  tags?: string[];
+}
+
+export interface TemplateParam {
+  name: string;
+  description: string;
+  required: boolean;
+  default?: string;
+}
+
+export interface InstantiateRequest {
+  templateId: string;
+  params: Record<string, string>;
+  overrides?: {
+    agent?: string;
+    priority?: number;
+    workingDirectory?: string;
+  };
+}
+
+export class TemplateEngine {
+  private templates = new Map<string, TaskTemplate>();
+
+  register(template: TaskTemplate): void {
+    this.templates.set(template.id, template);
+  }
+
+  unregister(id: string): boolean {
+    return this.templates.delete(id);
+  }
+
+  get(id: string): TaskTemplate | undefined {
+    return this.templates.get(id);
+  }
+
+  list(tag?: string): TaskTemplate[] {
+    const all = Array.from(this.templates.values());
+    if (tag) return all.filter(t => t.tags?.includes(tag));
+    return all;
+  }
+
+  instantiate(request: InstantiateRequest): { prompt: string; agent?: string; priority?: number } {
+    const template = this.templates.get(request.templateId);
+    if (!template) throw new Error(`Template not found: ${request.templateId}`);
+
+    // Validate required params
+    for (const param of template.params) {
+      if (param.required && !(request.params[param.name] ?? param.default)) {
+        throw new Error(`Missing required parameter: ${param.name}`);
+      }
+    }
+
+    // Interpolate {{param.name}} with provided values
+    let prompt = template.prompt;
+    for (const param of template.params) {
+      const value = request.params[param.name] ?? param.default ?? '';
+      prompt = prompt.replace(new RegExp(`\\{\\{param\\.${param.name}\\}\\}`, 'g'), value);
+    }
+
+    return {
+      prompt,
+      agent: request.overrides?.agent ?? template.agent,
+      priority: request.overrides?.priority ?? template.priority,
+    };
+  }
+
+  /** Seed built-in templates */
+  seedDefaults(): void {
+    this.register({
+      id: 'code-review',
+      name: 'Code Review',
+      description: 'Review a file for quality, security, and correctness',
+      prompt: 'Review {{param.file}} for {{param.criteria}}. Focus on actionable issues.',
+      agent: 'claude',
+      priority: 4,
+      params: [
+        { name: 'file', description: 'File path to review', required: true },
+        { name: 'criteria', description: 'Review criteria', required: false, default: 'quality, security, correctness' },
+      ],
+      tags: ['review', 'quality'],
+    });
+
+    this.register({
+      id: 'implement-feature',
+      name: 'Implement Feature',
+      description: 'Implement a new feature with tests',
+      prompt: 'Implement the following feature: {{param.description}}\n\nRequirements:\n{{param.requirements}}\n\nInclude unit tests.',
+      agent: 'codex',
+      priority: 3,
+      params: [
+        { name: 'description', description: 'Feature description', required: true },
+        { name: 'requirements', description: 'Detailed requirements', required: false, default: 'Follow existing patterns' },
+      ],
+      tags: ['implementation', 'feature'],
+    });
+
+    this.register({
+      id: 'explain-code',
+      name: 'Explain Code',
+      description: 'Explain what a piece of code does',
+      prompt: 'Explain this code in {{param.detail_level}} detail:\n\n{{param.code}}',
+      agent: 'claude',
+      priority: 2,
+      params: [
+        { name: 'code', description: 'Code to explain', required: true },
+        { name: 'detail_level', description: 'Detail level (brief/moderate/deep)', required: false, default: 'moderate' },
+      ],
+      tags: ['explanation', 'documentation'],
+    });
+
+    this.register({
+      id: 'debug-issue',
+      name: 'Debug Issue',
+      description: 'Diagnose and fix a bug',
+      prompt: 'Debug this issue: {{param.issue}}\n\nError message: {{param.error}}\n\nRelevant file: {{param.file}}',
+      agent: 'claude',
+      priority: 5,
+      params: [
+        { name: 'issue', description: 'Description of the issue', required: true },
+        { name: 'error', description: 'Error message or stack trace', required: false, default: 'N/A' },
+        { name: 'file', description: 'Relevant file path', required: false, default: 'N/A' },
+      ],
+      tags: ['debugging', 'fix'],
+    });
+  }
+}

package/src/daemon/services/webhook-manager.ts

@@ -0,0 +1,98 @@
+/**
+ * Webhook Manager — sends HTTP POST notifications on AGW events.
+ *
+ * Config example:
+ *   webhooks: [
+ *     { url: "https://slack.com/...", events: ["task.completed", "combo.completed"], secret: "hmac-key" }
+ *   ]
+ */
+
+import { createHmac } from 'node:crypto';
+
+export interface WebhookConfig {
+  url: string;
+  events: string[];      // event types to subscribe to, or ["*"] for all
+  secret?: string;       // HMAC-SHA256 signing key
+  headers?: Record<string, string>;
+  retries?: number;
+  timeoutMs?: number;
+}
+
+export interface WebhookPayload {
+  event: string;
+  timestamp: string;
+  data: Record<string, unknown>;
+}
+
+export class WebhookManager {
+  private hooks: WebhookConfig[] = [];
+
+  addWebhook(config: WebhookConfig): void {
+    this.hooks.push(config);
+  }
+
+  removeWebhook(url: string): void {
+    this.hooks = this.hooks.filter(h => h.url !== url);
+  }
+
+  getWebhooks(): WebhookConfig[] {
+    return this.hooks.map(h => ({ ...h, secret: h.secret ? '***' : undefined }));
+  }
+
+  async emit(event: string, data: Record<string, unknown>): Promise<void> {
+    const payload: WebhookPayload = {
+      event,
+      timestamp: new Date().toISOString(),
+      data,
+    };
+    const body = JSON.stringify(payload);
+
+    const matching = this.hooks.filter(h =>
+      h.events.includes('*') || h.events.includes(event)
+    );
+
+    const deliveries = matching.map(hook => this.deliver(hook, body));
+    await Promise.allSettled(deliveries);
+  }
+
+  private async deliver(hook: WebhookConfig, body: string): Promise<void> {
+    const maxRetries = hook.retries ?? 2;
+    const timeout = hook.timeoutMs ?? 10_000;
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'User-Agent': 'AGW-Webhook/1.5',
+      ...hook.headers,
+    };
+
+    if (hook.secret) {
+      const signature = createHmac('sha256', hook.secret).update(body).digest('hex');
+      headers['X-AGW-Signature'] = `sha256=${signature}`;
+    }
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+
+        const res = await fetch(hook.url, {
+          method: 'POST',
+          headers,
+          body,
+          signal: controller.signal,
+        });
+
+        clearTimeout(timer);
+
+        if (res.ok) return;
+        if (res.status >= 400 && res.status < 500) return; // Don't retry client errors
+      } catch {
+        // Retry on network errors
+      }
+
+      if (attempt < maxRetries) {
+        await new Promise(r => setTimeout(r, 1000 * (attempt + 1)));
+      }
+    }
+  }
+}