@sooneocean/agw 1.4.0

package/src/daemon/services/metrics.ts

@@ -0,0 +1,35 @@
+export interface MetricsSnapshot {
+  uptime: number;
+  tasks: { total: number; completed: number; failed: number; running: number };
+  agents: { total: number; available: number };
+  costs: { daily: number; monthly: number };
+  performance: { avgDurationMs: number; p95DurationMs: number };
+  memory: { heapUsed: number; heapTotal: number; rss: number };
+}
+
+export class MetricsCollector {
+  private startTime = Date.now();
+  private durations: number[] = [];
+
+  recordDuration(ms: number): void {
+    if (this.durations.length >= 500) this.durations.shift();
+    this.durations.push(ms);
+  }
+
+  getPerformance(): { avgDurationMs: number; p95DurationMs: number } {
+    if (this.durations.length === 0) return { avgDurationMs: 0, p95DurationMs: 0 };
+    const sorted = [...this.durations].sort((a, b) => a - b);
+    const avg = sorted.reduce((a, b) => a + b, 0) / sorted.length;
+    const p95 = sorted[Math.floor(sorted.length * 0.95)] ?? 0;
+    return { avgDurationMs: Math.round(avg), p95DurationMs: p95 };
+  }
+
+  getUptime(): number {
+    return Date.now() - this.startTime;
+  }
+
+  getMemory(): { heapUsed: number; heapTotal: number; rss: number } {
+    const mem = process.memoryUsage();
+    return { heapUsed: mem.heapUsed, heapTotal: mem.heapTotal, rss: mem.rss };
+  }
+}

package/src/daemon/services/stream-aggregator.ts

@@ -0,0 +1,64 @@
+import { EventEmitter } from 'node:events';
+
+export interface StreamChunk {
+  taskId: string;
+  source: 'stdout' | 'stderr';
+  content: string;
+  timestamp: number;
+  agentId?: string;
+}
+
+/**
+ * Aggregates multiple task streams into a single ordered stream.
+ * Useful for combos and workflows where multiple agents run and
+ * the caller wants a unified stream of all output.
+ */
+export class StreamAggregator extends EventEmitter {
+  private chunks: StreamChunk[] = [];
+  private taskIds = new Set<string>();
+  private completedTasks = new Set<string>();
+
+  track(taskId: string, agentId?: string): void {
+    this.taskIds.add(taskId);
+  }
+
+  addChunk(taskId: string, source: 'stdout' | 'stderr', content: string, agentId?: string): void {
+    const chunk: StreamChunk = {
+      taskId, source, content, timestamp: Date.now(), agentId,
+    };
+    this.chunks.push(chunk);
+    this.emit('chunk', chunk);
+  }
+
+  markComplete(taskId: string): void {
+    this.completedTasks.add(taskId);
+    if (this.isAllComplete()) {
+      this.emit('complete', this.getFullOutput());
+    }
+  }
+
+  isAllComplete(): boolean {
+    return this.taskIds.size > 0 && this.completedTasks.size >= this.taskIds.size;
+  }
+
+  getChunks(): StreamChunk[] {
+    return [...this.chunks];
+  }
+
+  getFullOutput(): string {
+    return this.chunks
+      .filter(c => c.source === 'stdout')
+      .map(c => c.content)
+      .join('');
+  }
+
+  getOutputByTask(): Record<string, string> {
+    const result: Record<string, string> = {};
+    for (const chunk of this.chunks) {
+      if (chunk.source === 'stdout') {
+        result[chunk.taskId] = (result[chunk.taskId] ?? '') + chunk.content;
+      }
+    }
+    return result;
+  }
+}

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

@@ -0,0 +1,184 @@
+import { nanoid } from 'nanoid';
+import { EventEmitter } from 'node:events';
+import type Database from 'better-sqlite3';
+import type { CreateTaskRequest, TaskDescriptor } from '../../types.js';
+import { TaskRepo } from '../../store/task-repo.js';
+import { AuditRepo } from '../../store/audit-repo.js';
+import { CostRepo } from '../../store/cost-repo.js';
+import { AgentManager } from './agent-manager.js';
+import { TaskQueue } from './task-queue.js';
+
+export class TaskExecutor extends EventEmitter {
+  private taskQueue: TaskQueue;
+  private costRepo: CostRepo;
+  private dailyCostLimit?: number;
+  private monthlyCostLimit?: number;
+
+  constructor(
+    private taskRepo: TaskRepo,
+    private auditRepo: AuditRepo,
+    private agentManager: AgentManager,
+    costRepo?: CostRepo | null,
+    maxConcurrencyPerAgent: number = 3,
+    dailyCostLimit?: number,
+    monthlyCostLimit?: number,
+    db?: Database.Database,
+  ) {
+    super();
+    this.costRepo = costRepo ?? (db ? new CostRepo(db) : null) as CostRepo;
+    this.dailyCostLimit = dailyCostLimit;
+    this.monthlyCostLimit = monthlyCostLimit;
+    this.taskQueue = new TaskQueue(taskRepo, maxConcurrencyPerAgent);
+
+    this.taskQueue.on('queued', (taskId: string) => {
+      this.auditRepo.log(taskId, 'task.queued', { reason: 'concurrency limit' });
+    });
+  }
+
+  private checkQuota(): void {
+    if (!this.costRepo) return;
+    if (this.dailyCostLimit) {
+      const daily = this.costRepo.getDailyCost();
+      if (daily >= this.dailyCostLimit) {
+        this.auditRepo.log(null, 'cost.quota_exceeded', { type: 'daily', current: daily, limit: this.dailyCostLimit });
+        throw new Error(`Daily cost limit exceeded ($${daily.toFixed(2)} / $${this.dailyCostLimit.toFixed(2)})`);
+      }
+    }
+    if (this.monthlyCostLimit) {
+      const monthly = this.costRepo.getMonthlyCost();
+      if (monthly >= this.monthlyCostLimit) {
+        this.auditRepo.log(null, 'cost.quota_exceeded', { type: 'monthly', current: monthly, limit: this.monthlyCostLimit });
+        throw new Error(`Monthly cost limit exceeded ($${monthly.toFixed(2)} / $${this.monthlyCostLimit.toFixed(2)})`);
+      }
+    }
+  }
+
+  async execute(request: CreateTaskRequest, routeFn?: (prompt: string) => Promise<{ agentId: string; reason: string; confidence: number }>): Promise<TaskDescriptor> {
+    this.checkQuota();
+
+    const taskId = nanoid(12);
+    const workingDirectory = request.workingDirectory ?? process.cwd();
+    const createdAt = new Date().toISOString();
+    const priority = request.priority ?? 3;
+
+    // Create task
+    this.taskRepo.create({
+      taskId,
+      prompt: request.prompt,
+      workingDirectory,
+      status: 'pending',
+      priority,
+      createdAt,
+      preferredAgent: request.preferredAgent,
+      workflowId: request.workflowId,
+      stepIndex: request.stepIndex,
+    });
+    this.auditRepo.log(taskId, 'task.created', { prompt: request.prompt, priority });
+    this.emit('task:status', taskId, { status: 'pending' });
+
+    // Route
+    this.taskRepo.updateStatus(taskId, 'routing');
+    this.emit('task:status', taskId, { status: 'routing' });
+
+    let agentId: string;
+    let routingReason: string;
+
+    if (request.preferredAgent) {
+      agentId = request.preferredAgent;
+      routingReason = 'User override';
+    } else if (routeFn) {
+      const decision = await routeFn(request.prompt);
+      agentId = decision.agentId;
+      routingReason = decision.reason;
+    } else {
+      throw new Error('No routing function provided and no preferred agent');
+    }
+
+    // Don't set 'running' yet — task may be queued (M1: status accuracy)
+    this.auditRepo.log(taskId, 'task.routed', { agentId, reason: routingReason });
+
+    const adapter = this.agentManager.getAdapter(agentId);
+    if (!adapter) {
+      this.taskRepo.updateStatus(taskId, 'failed');
+      this.auditRepo.log(taskId, 'task.failed', { error: `Agent ${agentId} not available` });
+      return this.taskRepo.getById(taskId)!;
+    }
+
+    // Execute through the concurrency queue
+    const executeTask = async (): Promise<void> => {
+      // NOW set 'running' — task is actually starting (M1)
+      this.taskRepo.updateStatus(taskId, 'running', agentId, routingReason);
+      this.auditRepo.log(taskId, 'task.started', { agentId });
+      this.emit('task:status', taskId, { status: 'running', agentId, reason: routingReason });
+      const onStdout = (...args: unknown[]) => this.emit('task:stdout', taskId, String(args[0]));
+      const onStderr = (...args: unknown[]) => this.emit('task:stderr', taskId, String(args[0]));
+      adapter.on('stdout', onStdout);
+      adapter.on('stderr', onStderr);
+
+      const task: TaskDescriptor = {
+        taskId,
+        prompt: request.prompt,
+        workingDirectory,
+        status: 'running',
+        priority,
+        assignedAgent: agentId,
+        createdAt,
+      };
+
+      try {
+        const result = await adapter.execute(task);
+        const finalStatus = result.exitCode === 0 ? 'completed' : 'failed';
+        this.taskRepo.updateResult(taskId, result);
+        this.taskRepo.updateStatus(taskId, finalStatus);
+        const eventType = result.exitCode === 0 ? 'task.completed' : 'task.failed';
+        this.auditRepo.log(taskId, eventType, { exitCode: result.exitCode, durationMs: result.durationMs });
+
+        if (result.costEstimate && this.costRepo) {
+          this.costRepo.record(taskId, agentId, result.costEstimate, result.tokenEstimate ?? 0);
+        }
+
+        this.emit('task:done', taskId, result);
+      } finally {
+        adapter.removeListener('stdout', onStdout);
+        adapter.removeListener('stderr', onStderr);
+      }
+    };
+
+    // Use queue for concurrency control (M2: reject on error to avoid hanging)
+    return new Promise<TaskDescriptor>((resolve, reject) => {
+      const wrappedExecute = async () => {
+        try {
+          await executeTask();
+          resolve(this.taskRepo.getById(taskId)!);
+        } catch (err) {
+          this.taskRepo.updateStatus(taskId, 'failed');
+          this.auditRepo.log(taskId, 'task.failed', { error: (err as Error).message });
+          resolve(this.taskRepo.getById(taskId)!);
+        }
+      };
+
+      const started = this.taskQueue.enqueue({
+        taskId,
+        agentId,
+        priority,
+        execute: wrappedExecute,
+      });
+
+      if (!started) {
+        this.emit('task:status', taskId, { status: 'queued' });
+      }
+    });
+  }
+
+  getTask(taskId: string): TaskDescriptor | undefined {
+    return this.taskRepo.getById(taskId);
+  }
+
+  listTasks(limit: number = 20, offset: number = 0): TaskDescriptor[] {
+    return this.taskRepo.list(limit, offset);
+  }
+
+  getCostRepo(): CostRepo {
+    return this.costRepo;
+  }
+}

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

@@ -0,0 +1,75 @@
+import { EventEmitter } from 'node:events';
+import type { TaskRepo } from '../../store/task-repo.js';
+
+interface QueuedTask {
+  taskId: string;
+  agentId: string;
+  priority: number;
+  execute: () => Promise<void>;
+}
+
+export class TaskQueue extends EventEmitter {
+  private queue: QueuedTask[] = [];
+  private runningCount: Map<string, number> = new Map();
+
+  constructor(
+    private taskRepo: TaskRepo,
+    private maxConcurrencyPerAgent: number,
+  ) {
+    super();
+  }
+
+  getRunningCount(agentId: string): number {
+    return this.runningCount.get(agentId) ?? 0;
+  }
+
+  canRun(agentId: string): boolean {
+    return this.getRunningCount(agentId) < this.maxConcurrencyPerAgent;
+  }
+
+  enqueue(item: QueuedTask): boolean {
+    if (this.canRun(item.agentId)) {
+      this.startTask(item);
+      return true; // started immediately
+    }
+    // Insert sorted by priority DESC
+    const idx = this.queue.findIndex(q => q.priority < item.priority);
+    if (idx === -1) this.queue.push(item);
+    else this.queue.splice(idx, 0, item);
+    this.emit('queued', item.taskId, item.agentId);
+    return false; // queued
+  }
+
+  private startTask(item: QueuedTask): void {
+    const current = this.runningCount.get(item.agentId) ?? 0;
+    this.runningCount.set(item.agentId, current + 1);
+
+    item.execute()
+      .catch((err) => {
+        this.emit('task:error', item.taskId, err);
+      })
+      .finally(() => {
+        const count = this.runningCount.get(item.agentId) ?? 1;
+        this.runningCount.set(item.agentId, count - 1);
+        this.processQueue(item.agentId);
+      });
+  }
+
+  private processQueue(agentId: string): void {
+    const idx = this.queue.findIndex(q => q.agentId === agentId);
+    if (idx === -1) return;
+    if (!this.canRun(agentId)) return;
+
+    const next = this.queue.splice(idx, 1)[0];
+    this.startTask(next);
+    this.emit('dequeued', next.taskId, next.agentId);
+  }
+
+  getQueueLength(): number {
+    return this.queue.length;
+  }
+
+  getQueuedTasks(): QueuedTask[] {
+    return [...this.queue];
+  }
+}

package/src/daemon/services/workflow-executor.ts

@@ -0,0 +1,150 @@
+import { nanoid } from 'nanoid';
+import { EventEmitter } from 'node:events';
+import type { CreateWorkflowRequest, WorkflowDescriptor, CreateTaskRequest } from '../../types.js';
+import { WorkflowRepo } from '../../store/workflow-repo.js';
+import { AuditRepo } from '../../store/audit-repo.js';
+import type { TaskExecutor } from './task-executor.js';
+import type { LlmRouter } from '../../router/llm-router.js';
+import type { AgentManager } from './agent-manager.js';
+
+export class WorkflowExecutor extends EventEmitter {
+  constructor(
+    private workflowRepo: WorkflowRepo,
+    private auditRepo: AuditRepo,
+    private taskExecutor: TaskExecutor,
+    private router: LlmRouter,
+    private agentManager: AgentManager,
+  ) {
+    super();
+  }
+
+  /** Start a workflow in the background. Returns workflowId immediately. */
+  start(request: CreateWorkflowRequest): string {
+    const workflowId = nanoid(12);
+    const createdAt = new Date().toISOString();
+
+    this.workflowRepo.create({
+      workflowId,
+      name: request.name,
+      steps: request.steps,
+      mode: request.mode ?? 'sequential',
+      status: 'pending',
+      createdAt,
+      workingDirectory: request.workingDirectory,
+      priority: request.priority,
+    });
+    this.auditRepo.log(null, 'workflow.created', { workflowId, name: request.name, stepCount: request.steps.length });
+
+    // Execute in background — don't block the caller
+    this.runWorkflow(workflowId, request).catch((err) => {
+      this.emit('workflow:error', workflowId, err);
+    });
+
+    return workflowId;
+  }
+
+  /** Execute workflow synchronously (for testing or CLI). */
+  async execute(request: CreateWorkflowRequest): Promise<WorkflowDescriptor> {
+    const workflowId = nanoid(12);
+    const createdAt = new Date().toISOString();
+
+    this.workflowRepo.create({
+      workflowId,
+      name: request.name,
+      steps: request.steps,
+      mode: request.mode ?? 'sequential',
+      status: 'pending',
+      createdAt,
+      workingDirectory: request.workingDirectory,
+      priority: request.priority,
+    });
+    this.auditRepo.log(null, 'workflow.created', { workflowId, name: request.name, stepCount: request.steps.length });
+
+    await this.runWorkflow(workflowId, request);
+    return this.workflowRepo.getById(workflowId)!;
+  }
+
+  private async runWorkflow(workflowId: string, request: CreateWorkflowRequest): Promise<void> {
+    this.workflowRepo.updateStatus(workflowId, 'running');
+
+    try {
+      if (request.mode === 'parallel') {
+        await this.executeParallel(workflowId, request);
+      } else {
+        await this.executeSequential(workflowId, request);
+      }
+      this.workflowRepo.updateStatus(workflowId, 'completed');
+      this.auditRepo.log(null, 'workflow.completed', { workflowId });
+      this.emit('workflow:done', workflowId);
+    } catch (err) {
+      this.workflowRepo.updateStatus(workflowId, 'failed');
+      this.auditRepo.log(null, 'workflow.failed', { workflowId, error: (err as Error).message });
+      this.emit('workflow:done', workflowId);
+    }
+  }
+
+  private async executeSequential(workflowId: string, request: CreateWorkflowRequest): Promise<void> {
+    for (let i = 0; i < request.steps.length; i++) {
+      const step = request.steps[i];
+      this.workflowRepo.updateStep(workflowId, i);
+      this.auditRepo.log(null, 'workflow.step', { workflowId, stepIndex: i });
+
+      const taskRequest: CreateTaskRequest = {
+        prompt: step.prompt,
+        preferredAgent: step.preferredAgent,
+        workingDirectory: request.workingDirectory,
+        priority: request.priority,
+        workflowId,
+        stepIndex: i,
+      };
+
+      const availableAgents = this.agentManager.getAvailableAgents();
+      const task = await this.taskExecutor.execute(taskRequest, async (p) => {
+        return this.router.route(p, availableAgents, step.preferredAgent);
+      });
+
+      this.workflowRepo.addTaskId(workflowId, task.taskId);
+
+      if (task.status === 'failed') {
+        throw new Error(`Step ${i} failed (task ${task.taskId})`);
+      }
+    }
+  }
+
+  private async executeParallel(workflowId: string, request: CreateWorkflowRequest): Promise<void> {
+    this.auditRepo.log(null, 'workflow.step', { workflowId, mode: 'parallel', stepCount: request.steps.length });
+
+    const promises = request.steps.map(async (step, i) => {
+      const taskRequest: CreateTaskRequest = {
+        prompt: step.prompt,
+        preferredAgent: step.preferredAgent,
+        workingDirectory: request.workingDirectory,
+        priority: request.priority,
+        workflowId,
+        stepIndex: i,
+      };
+
+      const availableAgents = this.agentManager.getAvailableAgents();
+      const task = await this.taskExecutor.execute(taskRequest, async (p) => {
+        return this.router.route(p, availableAgents, step.preferredAgent);
+      });
+
+      this.workflowRepo.addTaskId(workflowId, task.taskId);
+      return task;
+    });
+
+    const results = await Promise.all(promises);
+    const failed = results.filter(t => t.status === 'failed');
+    if (failed.length > 0) {
+      throw new Error(`${failed.length} step(s) failed: ${failed.map(t => t.taskId).join(', ')}`);
+    }
+  }
+
+  getWorkflow(workflowId: string): WorkflowDescriptor | undefined {
+    return this.workflowRepo.getById(workflowId);
+  }
+
+  listWorkflows(limit: number = 20, offset: number = 0): WorkflowDescriptor[] {
+    return this.workflowRepo.list(limit, offset);
+  }
+}

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

@@ -0,0 +1,90 @@
+import { EventEmitter } from 'node:events';
+
+export interface WsClient {
+  id: string;
+  subscriptions: Set<string>;  // taskIds being watched
+  send: (data: string) => void;
+  close: () => void;
+}
+
+/**
+ * WebSocket connection manager for bidirectional real-time communication.
+ * Clients can:
+ * - Subscribe to task events by taskId
+ * - Receive broadcast events (agent status, metrics)
+ * - Send commands (cancel task, update priority)
+ */
+export class WsManager extends EventEmitter {
+  private clients = new Map<string, WsClient>();
+  private nextId = 0;
+
+  addClient(send: (data: string) => void, close: () => void): string {
+    const id = `ws-${++this.nextId}`;
+    this.clients.set(id, { id, subscriptions: new Set(), send, close });
+    this.emit('client:connect', id);
+    return id;
+  }
+
+  removeClient(id: string): void {
+    this.clients.delete(id);
+    this.emit('client:disconnect', id);
+  }
+
+  subscribe(clientId: string, taskId: string): void {
+    const client = this.clients.get(clientId);
+    if (client) client.subscriptions.add(taskId);
+  }
+
+  unsubscribe(clientId: string, taskId: string): void {
+    const client = this.clients.get(clientId);
+    if (client) client.subscriptions.delete(taskId);
+  }
+
+  /** Send event to all clients subscribed to this taskId */
+  sendToSubscribers(taskId: string, event: string, data: unknown): void {
+    const message = JSON.stringify({ event, taskId, data, timestamp: Date.now() });
+    for (const client of this.clients.values()) {
+      if (client.subscriptions.has(taskId) || client.subscriptions.has('*')) {
+        try { client.send(message); } catch { /* ignore dead connections */ }
+      }
+    }
+  }
+
+  /** Broadcast to all connected clients */
+  broadcast(event: string, data: unknown): void {
+    const message = JSON.stringify({ event, data, timestamp: Date.now() });
+    for (const client of this.clients.values()) {
+      try { client.send(message); } catch { /* ignore */ }
+    }
+  }
+
+  /** Process incoming message from a client */
+  handleMessage(clientId: string, raw: string): void {
+    try {
+      const msg = JSON.parse(raw) as { action: string; taskId?: string; [key: string]: unknown };
+      switch (msg.action) {
+        case 'subscribe':
+          if (msg.taskId) this.subscribe(clientId, msg.taskId);
+          break;
+        case 'unsubscribe':
+          if (msg.taskId) this.unsubscribe(clientId, msg.taskId);
+          break;
+        case 'subscribe-all':
+          this.subscribe(clientId, '*');
+          break;
+        default:
+          this.emit('command', clientId, msg);
+      }
+    } catch {
+      // Ignore malformed messages
+    }
+  }
+
+  getClientCount(): number {
+    return this.clients.size;
+  }
+
+  getClient(id: string): WsClient | undefined {
+    return this.clients.get(id);
+  }
+}