@sooneocean/agw 1.4.0

package/src/daemon/routes/agents.ts

@@ -0,0 +1,13 @@
+import type { FastifyInstance } from 'fastify';
+import type { AgentManager } from '../services/agent-manager.js';
+
+export function registerAgentRoutes(app: FastifyInstance, agentManager: AgentManager): void {
+  app.get('/agents', async () => {
+    return agentManager.listAgents();
+  });
+
+  app.post<{ Params: { id: string } }>('/agents/:id/health', async (request, reply) => {
+    const available = await agentManager.checkAgent(request.params.id);
+    return { id: request.params.id, available };
+  });
+}

package/src/daemon/routes/combos.ts

@@ -0,0 +1,103 @@
+import type { FastifyInstance } from 'fastify';
+import type { ComboExecutor } from '../services/combo-executor.js';
+import type { AppConfig, CreateComboRequest } from '../../types.js';
+import { validateWorkspace } from '../middleware/workspace.js';
+
+export function registerComboRoutes(
+  app: FastifyInstance,
+  comboExecutor: ComboExecutor,
+  config: AppConfig,
+): void {
+  const createComboSchema = {
+    body: {
+      type: 'object',
+      required: ['name', 'pattern', 'steps', 'input'],
+      properties: {
+        name: { type: 'string', minLength: 1, maxLength: 200 },
+        pattern: { type: 'string', enum: ['pipeline', 'map-reduce', 'review-loop', 'debate'] },
+        steps: {
+          type: 'array',
+          minItems: 2,
+          maxItems: config.maxWorkflowSteps,
+          items: {
+            type: 'object',
+            required: ['agent', 'prompt'],
+            properties: {
+              agent: { type: 'string' },
+              prompt: { type: 'string', minLength: 1, maxLength: config.maxPromptLength },
+              role: { type: 'string' },
+            },
+            additionalProperties: false,
+          },
+        },
+        input: { type: 'string', minLength: 1, maxLength: config.maxPromptLength },
+        workingDirectory: { type: 'string' },
+        priority: { type: 'integer', minimum: 1, maximum: 5, default: 3 },
+        maxIterations: { type: 'integer', minimum: 1, maximum: 10, default: 3 },
+      },
+      additionalProperties: false,
+    },
+  };
+
+  // Create and start a combo
+  app.post('/combos', { schema: createComboSchema }, async (request, reply) => {
+    const body = request.body as CreateComboRequest;
+    if (body.workingDirectory) {
+      try {
+        body.workingDirectory = validateWorkspace(body.workingDirectory, config.allowedWorkspaces);
+      } catch (err) {
+        return reply.status(400).send({ error: (err as Error).message });
+      }
+    }
+    const comboId = comboExecutor.start(body);
+    const combo = comboExecutor.getCombo(comboId);
+    return reply.status(202).send(combo);
+  });
+
+  // Start a combo from a preset
+  app.post<{ Params: { presetId: string }; Body: { input: string; workingDirectory?: string; priority?: number } }>(
+    '/combos/preset/:presetId',
+    async (request, reply) => {
+      const preset = comboExecutor.getPresets().find(p => p.id === request.params.presetId);
+      if (!preset) {
+        return reply.status(404).send({ error: `Preset not found: ${request.params.presetId}` });
+      }
+
+      const { input, workingDirectory, priority } = request.body;
+      if (!input || typeof input !== 'string') {
+        return reply.status(400).send({ error: 'input is required' });
+      }
+
+      const comboId = comboExecutor.start({
+        name: preset.name,
+        pattern: preset.pattern,
+        steps: preset.steps,
+        input,
+        workingDirectory,
+        priority,
+        maxIterations: preset.maxIterations,
+      });
+      const combo = comboExecutor.getCombo(comboId);
+      return reply.status(202).send(combo);
+    },
+  );
+
+  // List presets
+  app.get('/combos/presets', async () => {
+    return comboExecutor.getPresets();
+  });
+
+  // Get combo by ID
+  app.get<{ Params: { id: string } }>('/combos/:id', async (request, reply) => {
+    const combo = comboExecutor.getCombo(request.params.id);
+    if (!combo) return reply.status(404).send({ error: 'Combo not found' });
+    return combo;
+  });
+
+  // List combos
+  app.get<{ Querystring: { limit?: string; offset?: string } }>('/combos', async (request) => {
+    const limit = parseInt(request.query.limit ?? '20', 10);
+    const offset = parseInt(request.query.offset ?? '0', 10);
+    return comboExecutor.listCombos(limit, offset);
+  });
+}

package/src/daemon/routes/costs.ts

@@ -0,0 +1,9 @@
+import type { FastifyInstance } from 'fastify';
+import type { CostRepo } from '../../store/cost-repo.js';
+import type { AppConfig } from '../../types.js';
+
+export function registerCostRoutes(app: FastifyInstance, costRepo: CostRepo, config: AppConfig): void {
+  app.get('/costs', async () => {
+    return costRepo.getSummary(config.dailyCostLimit, config.monthlyCostLimit);
+  });
+}

package/src/daemon/routes/health.ts

@@ -0,0 +1,62 @@
+import type { FastifyInstance } from 'fastify';
+import type { MetricsCollector } from '../services/metrics.js';
+import type { AgentManager } from '../services/agent-manager.js';
+import type { CircuitBreakerRegistry } from '../services/circuit-breaker.js';
+import type { TaskRepo } from '../../store/task-repo.js';
+import type { CostRepo } from '../../store/cost-repo.js';
+import type { AppConfig } from '../../types.js';
+
+export function registerHealthRoutes(
+  app: FastifyInstance,
+  metrics: MetricsCollector,
+  agentManager: AgentManager,
+  cbRegistry: CircuitBreakerRegistry,
+  taskRepo: TaskRepo,
+  costRepo: CostRepo | null,
+  config: AppConfig,
+): void {
+  app.get('/health', async () => {
+    return { status: 'ok', uptime: metrics.getUptime(), version: config.version ?? '1.4.0' };
+  });
+
+  app.get('/health/ready', async (_request, reply) => {
+    const agents = agentManager.getAvailableAgents();
+    if (agents.length === 0) {
+      return reply.status(503).send({ status: 'not_ready', reason: 'No agents available' });
+    }
+    return { status: 'ready', availableAgents: agents.length };
+  });
+
+  app.get('/metrics', async () => {
+    const agents = agentManager.listAgents();
+    const counts = taskRepo.countByStatus();
+    const total = Object.values(counts).reduce((a, b) => a + b, 0);
+    const perf = metrics.getPerformance();
+    const mem = metrics.getMemory();
+
+    return {
+      uptime: metrics.getUptime(),
+      tasks: {
+        total,
+        completed: counts.completed ?? 0,
+        failed: counts.failed ?? 0,
+        running: counts.running ?? 0,
+        pending: counts.pending ?? 0,
+      },
+      agents: {
+        total: agents.length,
+        available: agents.filter(a => a.available).length,
+        list: agents.map(a => ({ id: a.id, available: a.available })),
+      },
+      circuitBreakers: cbRegistry.getAll().map(cb => cb.toJSON()),
+      costs: costRepo ? { daily: costRepo.getDailyCost(), monthly: costRepo.getMonthlyCost() } : null,
+      performance: perf,
+      memory: { heapMB: Math.round(mem.heapUsed / 1048576), rssMB: Math.round(mem.rss / 1048576) },
+      limits: {
+        dailyCostLimit: config.dailyCostLimit,
+        monthlyCostLimit: config.monthlyCostLimit,
+        maxConcurrencyPerAgent: config.maxConcurrencyPerAgent,
+      },
+    };
+  });
+}

package/src/daemon/routes/memory.ts

@@ -0,0 +1,32 @@
+import type { FastifyInstance } from 'fastify';
+import type { MemoryRepo } from '../../store/memory-repo.js';
+
+export function registerMemoryRoutes(app: FastifyInstance, memoryRepo: MemoryRepo): void {
+  app.get('/memory', async (request) => {
+    const { scope, q } = request.query as { scope?: string; q?: string };
+    if (q) return memoryRepo.search(q);
+    if (scope) return memoryRepo.getByScope(scope);
+    return memoryRepo.list();
+  });
+
+  app.get<{ Params: { key: string } }>('/memory/:key', async (request, reply) => {
+    const value = memoryRepo.get(request.params.key);
+    if (value === undefined) return reply.status(404).send({ error: 'Key not found' });
+    return { key: request.params.key, value };
+  });
+
+  app.put<{ Params: { key: string }; Body: { value: string; scope?: string } }>(
+    '/memory/:key',
+    async (request) => {
+      const { value, scope } = request.body;
+      memoryRepo.set(request.params.key, value, scope);
+      return { key: request.params.key, value, scope: scope ?? 'global' };
+    },
+  );
+
+  app.delete<{ Params: { key: string } }>('/memory/:key', async (request, reply) => {
+    const deleted = memoryRepo.delete(request.params.key);
+    if (!deleted) return reply.status(404).send({ error: 'Key not found' });
+    return { deleted: true };
+  });
+}

package/src/daemon/routes/tasks.ts

@@ -0,0 +1,157 @@
+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 type { AppConfig } from '../../types.js';
+import { validateWorkspace } from '../middleware/workspace.js';
+
+export function registerTaskRoutes(
+  app: FastifyInstance,
+  executor: TaskExecutor,
+  router: LlmRouter,
+  agentManager: AgentManager,
+  config: AppConfig,
+): void {
+  const createTaskSchema = {
+    body: {
+      type: 'object',
+      required: ['prompt'],
+      properties: {
+        prompt: { type: 'string', minLength: 1, maxLength: config.maxPromptLength },
+        preferredAgent: { type: 'string' },
+        workingDirectory: { type: 'string' },
+        priority: { type: 'integer', minimum: 1, maximum: 5, default: 3 },
+      },
+      additionalProperties: false,
+    },
+  };
+
+  app.post<{ Body: { prompt: string; preferredAgent?: string; workingDirectory?: string; priority?: number } }>(
+    '/tasks',
+    { schema: createTaskSchema },
+    async (request, reply) => {
+      const { prompt, preferredAgent, priority } = request.body;
+
+      // Validate workspace (H2: path traversal protection)
+      let workingDirectory: string;
+      try {
+        workingDirectory = validateWorkspace(request.body.workingDirectory, config.allowedWorkspaces);
+      } catch (err) {
+        return reply.status(400).send({ error: (err as Error).message });
+      }
+
+      const availableAgents = agentManager.getAvailableAgents();
+      if (availableAgents.length === 0 && !preferredAgent) {
+        return reply.status(503).send({ error: 'No agents available. Check CLI installations.' });
+      }
+
+      let lowConfidence = false;
+      const task = await executor.execute(
+        { prompt, preferredAgent, workingDirectory, priority },
+        async (p) => {
+          const decision = await router.route(p, availableAgents, preferredAgent);
+          if (decision.confidence < 0.5) lowConfidence = true;
+          return decision;
+        },
+      );
+
+      return reply.status(201).send({ ...task, lowConfidence });
+    },
+  );
+
+  app.get<{ Params: { id: string } }>('/tasks/:id', async (request, reply) => {
+    const task = executor.getTask(request.params.id);
+    if (!task) return reply.status(404).send({ error: 'Task not found' });
+    return task;
+  });
+
+  // H4: SSE with task existence check, completed-task replay, idle timeout
+  app.get<{ Params: { id: string } }>('/tasks/:id/stream', async (request, reply) => {
+    const taskId = request.params.id;
+
+    // Check task exists
+    const existing = executor.getTask(taskId);
+    if (!existing) {
+      return reply.status(404).send({ error: 'Task not found' });
+    }
+
+    // If already completed/failed, replay result immediately
+    if (existing.status === 'completed' || existing.status === 'failed') {
+      reply.raw.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      });
+      reply.raw.write(`event: status\ndata: ${JSON.stringify({ status: existing.status })}\n\n`);
+      if (existing.result) {
+        reply.raw.write(`event: done\ndata: ${JSON.stringify(existing.result)}\n\n`);
+      }
+      reply.raw.end();
+      return;
+    }
+
+    reply.raw.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+    });
+
+    const sendEvent = (event: string, data: unknown) => {
+      reply.raw.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+    };
+
+    // Idle timeout — close stream if no events after 5 minutes
+    let idleTimer = setTimeout(() => {
+      sendEvent('timeout', { reason: 'idle timeout' });
+      cleanup();
+      reply.raw.end();
+    }, 300_000);
+
+    const resetIdle = () => {
+      clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        sendEvent('timeout', { reason: 'idle timeout' });
+        cleanup();
+        reply.raw.end();
+      }, 300_000);
+    };
+
+    const onStatus = (id: string, info: unknown) => {
+      if (id === taskId) { sendEvent('status', info); resetIdle(); }
+    };
+    const onStdout = (id: string, chunk: string) => {
+      if (id === taskId) { sendEvent('stdout', { chunk }); resetIdle(); }
+    };
+    const onStderr = (id: string, chunk: string) => {
+      if (id === taskId) { sendEvent('stderr', { chunk }); resetIdle(); }
+    };
+    const onDone = (id: string, result: unknown) => {
+      if (id === taskId) {
+        sendEvent('done', result);
+        cleanup();
+        reply.raw.end();
+      }
+    };
+
+    const cleanup = () => {
+      clearTimeout(idleTimer);
+      executor.removeListener('task:status', onStatus);
+      executor.removeListener('task:stdout', onStdout);
+      executor.removeListener('task:stderr', onStderr);
+      executor.removeListener('task:done', onDone);
+    };
+
+    executor.on('task:status', onStatus);
+    executor.on('task:stdout', onStdout);
+    executor.on('task:stderr', onStderr);
+    executor.on('task:done', onDone);
+
+    request.raw.on('close', cleanup);
+  });
+
+  app.get<{ Querystring: { limit?: string; offset?: string } }>('/tasks', async (request) => {
+    const limit = parseInt(request.query.limit ?? '20', 10);
+    const offset = parseInt(request.query.offset ?? '0', 10);
+    return executor.listTasks(limit, offset);
+  });
+}

package/src/daemon/routes/ui.ts

@@ -0,0 +1,18 @@
+import type { FastifyInstance } from 'fastify';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const UI_DIR = path.join(__dirname, '..', '..', '..', 'ui');
+
+export default async function uiPlugin(app: FastifyInstance): Promise<void> {
+  app.get('/ui', async (_request, reply) => {
+    const htmlPath = path.join(UI_DIR, 'index.html');
+    if (!fs.existsSync(htmlPath)) {
+      return reply.status(404).send({ error: 'Web UI not found' });
+    }
+    const html = fs.readFileSync(htmlPath, 'utf-8');
+    return reply.type('text/html').send(html);
+  });
+}

package/src/daemon/routes/workflows.ts

@@ -0,0 +1,73 @@
+import type { FastifyInstance } from 'fastify';
+import type { WorkflowExecutor } from '../services/workflow-executor.js';
+import type { AppConfig } from '../../types.js';
+import { validateWorkspace } from '../middleware/workspace.js';
+
+export function registerWorkflowRoutes(
+  app: FastifyInstance,
+  workflowExecutor: WorkflowExecutor,
+  config: AppConfig,
+): void {
+  const createWorkflowSchema = {
+    body: {
+      type: 'object',
+      required: ['name', 'steps'],
+      properties: {
+        name: { type: 'string', minLength: 1, maxLength: 200 },
+        steps: {
+          type: 'array',
+          minItems: 1,
+          maxItems: config.maxWorkflowSteps,
+          items: {
+            type: 'object',
+            required: ['prompt'],
+            properties: {
+              prompt: { type: 'string', minLength: 1, maxLength: config.maxPromptLength },
+              preferredAgent: { type: 'string' },
+            },
+            additionalProperties: false,
+          },
+        },
+        mode: { type: 'string', enum: ['sequential', 'parallel'], default: 'sequential' },
+        workingDirectory: { type: 'string' },
+        priority: { type: 'integer', minimum: 1, maximum: 5, default: 3 },
+      },
+      additionalProperties: false,
+    },
+  };
+
+  app.post('/workflows', { schema: createWorkflowSchema }, async (request, reply) => {
+    const body = request.body as {
+      name: string;
+      steps: { prompt: string; preferredAgent?: string }[];
+      mode?: 'sequential' | 'parallel';
+      workingDirectory?: string;
+      priority?: number;
+    };
+
+    // Validate workspace
+    if (body.workingDirectory) {
+      try {
+        body.workingDirectory = validateWorkspace(body.workingDirectory, config.allowedWorkspaces);
+      } catch (err) {
+        return reply.status(400).send({ error: (err as Error).message });
+      }
+    }
+
+    const workflowId = workflowExecutor.start(body);
+    const wf = workflowExecutor.getWorkflow(workflowId);
+    return reply.status(202).send(wf);
+  });
+
+  app.get<{ Params: { id: string } }>('/workflows/:id', async (request, reply) => {
+    const wf = workflowExecutor.getWorkflow(request.params.id);
+    if (!wf) return reply.status(404).send({ error: 'Workflow not found' });
+    return wf;
+  });
+
+  app.get<{ Querystring: { limit?: string; offset?: string } }>('/workflows', async (request) => {
+    const limit = parseInt(request.query.limit ?? '20', 10);
+    const offset = parseInt(request.query.offset ?? '0', 10);
+    return workflowExecutor.listWorkflows(limit, offset);
+  });
+}

package/src/daemon/server.ts

@@ -0,0 +1,91 @@
+import Fastify from 'fastify';
+import type { FastifyInstance } from 'fastify';
+import path from 'node:path';
+import os from 'node:os';
+import { loadConfig } from '../config.js';
+import { createDatabase } from '../store/db.js';
+import { TaskRepo } from '../store/task-repo.js';
+import { AgentRepo } from '../store/agent-repo.js';
+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 { 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 { 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';
+
+interface ServerOptions {
+  dbPath?: string;
+  configPath?: string;
+}
+
+export async function buildServer(options: ServerOptions = {}): Promise<FastifyInstance> {
+  const agwDir = path.join(os.homedir(), '.agw');
+  const configPath = options.configPath ?? path.join(agwDir, 'config.json');
+  const dbPath = options.dbPath ?? path.join(agwDir, 'agw.db');
+
+  const config = loadConfig(configPath);
+  const db = createDatabase(dbPath);
+  const taskRepo = new TaskRepo(db);
+  const agentRepo = new AgentRepo(db);
+  const auditRepo = new AuditRepo(db);
+  const costRepo = new CostRepo(db);
+  const workflowRepo = new WorkflowRepo(db);
+  const comboRepo = new ComboRepo(db);
+  const memoryRepo = new MemoryRepo(db);
+
+  const agentManager = new AgentManager(agentRepo, auditRepo, config);
+  const executor = new TaskExecutor(
+    taskRepo, auditRepo, agentManager, costRepo,
+    config.maxConcurrencyPerAgent,
+    config.dailyCostLimit, config.monthlyCostLimit, db,
+  );
+  const router = new LlmRouter(config.anthropicApiKey, config.routerModel);
+  const workflowExecutor = new WorkflowExecutor(workflowRepo, auditRepo, executor, router, agentManager);
+  const comboExecutor = new ComboExecutor(comboRepo, auditRepo, executor, agentManager);
+  const metrics = new MetricsCollector();
+  const cbRegistry = new CircuitBreakerRegistry();
+
+  const app = Fastify({
+    logger: false,
+    bodyLimit: 1_048_576,
+  });
+
+  registerAuthMiddleware(app, config.authToken);
+
+  registerAgentRoutes(app, agentManager);
+  registerTaskRoutes(app, executor, router, agentManager, config);
+  registerWorkflowRoutes(app, workflowExecutor, config);
+  registerCostRoutes(app, costRepo, config);
+  registerComboRoutes(app, comboExecutor, config);
+  registerMemoryRoutes(app, memoryRepo);
+  registerHealthRoutes(app, metrics, agentManager, cbRegistry, taskRepo, costRepo, config);
+
+  app.register(import('./routes/ui.js'));
+
+  agentManager.runHealthChecks().catch(() => {});
+
+  app.addHook('onClose', async () => {
+    const runningTasks = taskRepo.list(100, 0).filter(t => t.status === 'running');
+    for (const t of runningTasks) {
+      taskRepo.updateStatus(t.taskId, 'failed');
+      auditRepo.log(t.taskId, 'task.failed', { reason: 'daemon shutdown' });
+    }
+    db.close();
+  });
+
+  return app;
+}

package/src/daemon/services/agent-learning.ts

@@ -0,0 +1,77 @@
+/**
+ * Agent Learning — tracks which agent performs best for different task categories.
+ * Over time, routing decisions improve based on historical success rates.
+ */
+
+export interface AgentScore {
+  agentId: string;
+  category: string;
+  successCount: number;
+  failCount: number;
+  avgDurationMs: number;
+  totalCost: number;
+  score: number;  // calculated: success_rate * (1 / normalized_duration)
+}
+
+export class AgentLearning {
+  private scores = new Map<string, AgentScore>(); // key: `agentId:category`
+
+  record(agentId: string, category: string, success: boolean, durationMs: number, cost: number): void {
+    const key = `${agentId}:${category}`;
+    let score = this.scores.get(key);
+    if (!score) {
+      score = { agentId, category, successCount: 0, failCount: 0, avgDurationMs: 0, totalCost: 0, score: 0 };
+      this.scores.set(key, score);
+    }
+
+    if (success) score.successCount++;
+    else score.failCount++;
+
+    const total = score.successCount + score.failCount;
+    score.avgDurationMs = ((score.avgDurationMs * (total - 1)) + durationMs) / total;
+    score.totalCost += cost;
+    score.score = this.calculateScore(score);
+  }
+
+  private calculateScore(s: AgentScore): number {
+    const total = s.successCount + s.failCount;
+    if (total === 0) return 0;
+    const successRate = s.successCount / total;
+    const speedFactor = 1 / Math.max(1, s.avgDurationMs / 1000);
+    return Math.round(successRate * speedFactor * 1000) / 1000;
+  }
+
+  /** Get the best agent for a category based on historical performance */
+  getBestAgent(category: string): string | undefined {
+    const candidates = Array.from(this.scores.values())
+      .filter(s => s.category === category && (s.successCount + s.failCount) >= 3);
+
+    if (candidates.length === 0) return undefined;
+    candidates.sort((a, b) => b.score - a.score);
+    return candidates[0].agentId;
+  }
+
+  /** Get all scores for an agent */
+  getAgentScores(agentId: string): AgentScore[] {
+    return Array.from(this.scores.values()).filter(s => s.agentId === agentId);
+  }
+
+  /** Get all scores */
+  getAllScores(): AgentScore[] {
+    return Array.from(this.scores.values());
+  }
+
+  /** Categorize a prompt into a rough category */
+  static categorize(prompt: string): string {
+    const lower = prompt.toLowerCase();
+    if (/refactor|restructure|reorganize/.test(lower)) return 'refactoring';
+    if (/test|spec|coverage/.test(lower)) return 'testing';
+    if (/bug|fix|error|crash/.test(lower)) return 'debugging';
+    if (/review|audit|check/.test(lower)) return 'review';
+    if (/build|deploy|ci|cd/.test(lower)) return 'devops';
+    if (/explain|document|summarize/.test(lower)) return 'documentation';
+    if (/create|new|add|implement/.test(lower)) return 'implementation';
+    if (/research|compare|analyze/.test(lower)) return 'analysis';
+    return 'general';
+  }
+}