@sooneocean/agw 1.4.0

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

@@ -0,0 +1,71 @@
+import type { UnifiedAgent, AgentDescriptor, AppConfig } from '../../types.js';
+import { AgentRepo } from '../../store/agent-repo.js';
+import { AuditRepo } from '../../store/audit-repo.js';
+import { ClaudeAdapter } from '../../agents/claude-adapter.js';
+import { CodexAdapter } from '../../agents/codex-adapter.js';
+import { GeminiAdapter } from '../../agents/gemini-adapter.js';
+
+export class AgentManager {
+  private adapters: Map<string, UnifiedAgent> = new Map();
+
+  constructor(
+    private agentRepo: AgentRepo,
+    private auditRepo: AuditRepo,
+    private config: AppConfig,
+  ) {
+    this.initAdapters();
+  }
+
+  private initAdapters(): void {
+    const timeout = this.config.defaultTimeout;
+    const maxBuffer = 10 * 1024 * 1024; // 10 MB
+
+    const agentConfigs = this.config.agents;
+
+    if (agentConfigs.claude?.enabled !== false) {
+      this.adapters.set('claude', new ClaudeAdapter(timeout, maxBuffer, agentConfigs.claude?.args, agentConfigs.claude?.command));
+    }
+    if (agentConfigs.codex?.enabled !== false) {
+      this.adapters.set('codex', new CodexAdapter(timeout, maxBuffer, agentConfigs.codex?.args, agentConfigs.codex?.command));
+    }
+    if (agentConfigs.gemini?.enabled !== false) {
+      this.adapters.set('gemini', new GeminiAdapter(timeout, maxBuffer, agentConfigs.gemini?.args, agentConfigs.gemini?.command));
+    }
+
+    // Sync enabled state to DB
+    for (const [id, conf] of Object.entries(agentConfigs)) {
+      this.agentRepo.setEnabled(id, conf.enabled);
+    }
+  }
+
+  async runHealthChecks(): Promise<void> {
+    // M5: Run all health checks in parallel instead of serial
+    const checks = Array.from(this.adapters.entries()).map(async ([id, adapter]) => {
+      const available = await adapter.healthCheck();
+      this.agentRepo.setAvailability(id, available);
+      this.auditRepo.log(null, 'agent.health', { agentId: id, available });
+    });
+    await Promise.allSettled(checks);
+  }
+
+  async checkAgent(id: string): Promise<boolean> {
+    const adapter = this.adapters.get(id);
+    if (!adapter) return false;
+    const available = await adapter.healthCheck();
+    this.agentRepo.setAvailability(id, available);
+    this.auditRepo.log(null, 'agent.health', { agentId: id, available });
+    return available;
+  }
+
+  getAdapter(id: string): UnifiedAgent | undefined {
+    return this.adapters.get(id);
+  }
+
+  listAgents(): AgentDescriptor[] {
+    return this.agentRepo.listAll();
+  }
+
+  getAvailableAgents(): AgentDescriptor[] {
+    return this.agentRepo.listAvailable();
+  }
+}

package/src/daemon/services/auto-scaler.ts

@@ -0,0 +1,77 @@
+/**
+ * Auto-Scaler — dynamically adjusts per-agent concurrency limits
+ * based on queue depth, error rates, and response times.
+ */
+
+export interface ScaleConfig {
+  minConcurrency: number;
+  maxConcurrency: number;
+  scaleUpThreshold: number;    // queue depth to trigger scale up
+  scaleDownThreshold: number;  // queue depth to trigger scale down
+  cooldownMs: number;          // minimum time between scale changes
+  errorRateThreshold: number;  // error rate (0-1) to trigger scale down
+}
+
+const DEFAULTS: ScaleConfig = {
+  minConcurrency: 1,
+  maxConcurrency: 10,
+  scaleUpThreshold: 3,
+  scaleDownThreshold: 0,
+  cooldownMs: 30_000,
+  errorRateThreshold: 0.5,
+};
+
+export interface ScaleDecision {
+  agentId: string;
+  action: 'scale-up' | 'scale-down' | 'hold';
+  currentConcurrency: number;
+  newConcurrency: number;
+  reason: string;
+}
+
+export class AutoScaler {
+  private config: ScaleConfig;
+  private lastScaleTime = new Map<string, number>();
+  private concurrencyMap = new Map<string, number>();
+
+  constructor(config?: Partial<ScaleConfig>) {
+    this.config = { ...DEFAULTS, ...config };
+  }
+
+  getConcurrency(agentId: string): number {
+    return this.concurrencyMap.get(agentId) ?? this.config.minConcurrency;
+  }
+
+  evaluate(agentId: string, queueDepth: number, errorRate: number): ScaleDecision {
+    const now = Date.now();
+    const current = this.getConcurrency(agentId);
+    const lastScale = this.lastScaleTime.get(agentId) ?? 0;
+    const inCooldown = (now - lastScale) < this.config.cooldownMs;
+
+    // Scale down on high error rate
+    if (errorRate >= this.config.errorRateThreshold && current > this.config.minConcurrency && !inCooldown) {
+      const newVal = Math.max(this.config.minConcurrency, current - 1);
+      this.concurrencyMap.set(agentId, newVal);
+      this.lastScaleTime.set(agentId, now);
+      return { agentId, action: 'scale-down', currentConcurrency: current, newConcurrency: newVal, reason: `error rate ${(errorRate * 100).toFixed(0)}% exceeds threshold` };
+    }
+
+    // Scale up on queue pressure
+    if (queueDepth >= this.config.scaleUpThreshold && current < this.config.maxConcurrency && !inCooldown) {
+      const newVal = Math.min(this.config.maxConcurrency, current + 1);
+      this.concurrencyMap.set(agentId, newVal);
+      this.lastScaleTime.set(agentId, now);
+      return { agentId, action: 'scale-up', currentConcurrency: current, newConcurrency: newVal, reason: `queue depth ${queueDepth} exceeds threshold` };
+    }
+
+    // Scale down when queue is empty
+    if (queueDepth <= this.config.scaleDownThreshold && current > this.config.minConcurrency && !inCooldown) {
+      const newVal = Math.max(this.config.minConcurrency, current - 1);
+      this.concurrencyMap.set(agentId, newVal);
+      this.lastScaleTime.set(agentId, now);
+      return { agentId, action: 'scale-down', currentConcurrency: current, newConcurrency: newVal, reason: 'queue empty' };
+    }
+
+    return { agentId, action: 'hold', currentConcurrency: current, newConcurrency: current, reason: inCooldown ? 'cooldown' : 'stable' };
+  }
+}

package/src/daemon/services/circuit-breaker.ts

@@ -0,0 +1,95 @@
+type State = 'closed' | 'open' | 'half-open';
+
+export interface CircuitBreakerOptions {
+  failureThreshold: number;  // failures before opening
+  resetTimeout: number;      // ms before trying half-open
+  maxRetries: number;        // retries per execution
+  retryDelay: number;        // ms between retries
+}
+
+const DEFAULTS: CircuitBreakerOptions = {
+  failureThreshold: 3,
+  resetTimeout: 30_000,
+  maxRetries: 2,
+  retryDelay: 1_000,
+};
+
+export class CircuitBreaker {
+  private state: State = 'closed';
+  private failures = 0;
+  private lastFailure = 0;
+  private options: CircuitBreakerOptions;
+
+  constructor(public readonly name: string, options?: Partial<CircuitBreakerOptions>) {
+    this.options = { ...DEFAULTS, ...options };
+  }
+
+  getState(): State { return this.state; }
+  getFailures(): number { return this.failures; }
+
+  async execute<T>(fn: () => Promise<T>): Promise<T> {
+    if (this.state === 'open') {
+      if (Date.now() - this.lastFailure >= this.options.resetTimeout) {
+        this.state = 'half-open';
+      } else {
+        throw new Error(`Circuit breaker [${this.name}] is OPEN — agent temporarily unavailable`);
+      }
+    }
+
+    let lastError: Error | undefined;
+    for (let attempt = 0; attempt <= this.options.maxRetries; attempt++) {
+      try {
+        const result = await fn();
+        this.onSuccess();
+        return result;
+      } catch (err) {
+        lastError = err as Error;
+        if (attempt < this.options.maxRetries) {
+          await new Promise(r => setTimeout(r, this.options.retryDelay * (attempt + 1)));
+        }
+      }
+    }
+
+    this.onFailure();
+    throw lastError!;
+  }
+
+  private onSuccess(): void {
+    this.failures = 0;
+    this.state = 'closed';
+  }
+
+  private onFailure(): void {
+    this.failures++;
+    this.lastFailure = Date.now();
+    if (this.failures >= this.options.failureThreshold) {
+      this.state = 'open';
+    }
+  }
+
+  reset(): void {
+    this.state = 'closed';
+    this.failures = 0;
+  }
+
+  toJSON() {
+    return { name: this.name, state: this.state, failures: this.failures };
+  }
+}
+
+export class CircuitBreakerRegistry {
+  private breakers = new Map<string, CircuitBreaker>();
+
+  getOrCreate(name: string, options?: Partial<CircuitBreakerOptions>): CircuitBreaker {
+    let cb = this.breakers.get(name);
+    if (!cb) {
+      cb = new CircuitBreaker(name, options);
+      this.breakers.set(name, cb);
+    }
+    return cb;
+  }
+
+  getAll(): CircuitBreaker[] {
+    return Array.from(this.breakers.values());
+  }
+}

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

@@ -0,0 +1,300 @@
+import { nanoid } from 'nanoid';
+import { EventEmitter } from 'node:events';
+import type { CreateComboRequest, ComboDescriptor, CreateTaskRequest, ComboPreset } from '../../types.js';
+import { ComboRepo } from '../../store/combo-repo.js';
+import { AuditRepo } from '../../store/audit-repo.js';
+import type { TaskExecutor } from './task-executor.js';
+import type { AgentManager } from './agent-manager.js';
+
+// Interpolate template variables: {{input}}, {{prev}}, {{step.N}}, {{all}}
+function interpolate(template: string, context: { input: string; prev?: string; stepResults: Record<number, string> }): string {
+  let result = template.replace(/\{\{input\}\}/g, context.input);
+  if (context.prev !== undefined) {
+    result = result.replace(/\{\{prev\}\}/g, context.prev);
+  }
+  // {{step.0}}, {{step.1}}, etc.
+  result = result.replace(/\{\{step\.(\d+)\}\}/g, (_match, idx) => {
+    return context.stepResults[parseInt(idx, 10)] ?? `[step ${idx} not yet available]`;
+  });
+  // {{all}} — all step results concatenated
+  result = result.replace(/\{\{all\}\}/g, () => {
+    return Object.entries(context.stepResults)
+      .sort(([a], [b]) => parseInt(a) - parseInt(b))
+      .map(([idx, out]) => `--- Step ${idx} ---\n${out}`)
+      .join('\n\n');
+  });
+  return result;
+}
+
+// Built-in presets
+export const COMBO_PRESETS: ComboPreset[] = [
+  {
+    id: 'analyze-implement-review',
+    name: 'Analyze → Implement → Review',
+    description: 'Claude analyzes the problem, Codex implements, Claude reviews the result',
+    pattern: 'pipeline',
+    steps: [
+      { agent: 'claude', role: 'analyzer', prompt: 'Analyze this task and produce a clear technical plan:\n\n{{input}}' },
+      { agent: 'codex', role: 'implementer', prompt: 'Implement the following plan:\n\n{{prev}}' },
+      { agent: 'claude', role: 'reviewer', prompt: 'Review this implementation for correctness, security, and quality. The original request was:\n\n{{input}}\n\nThe implementation output:\n\n{{prev}}' },
+    ],
+  },
+  {
+    id: 'multi-perspective',
+    name: 'Multi-Perspective Analysis',
+    description: 'All agents analyze independently, Claude synthesizes',
+    pattern: 'map-reduce',
+    steps: [
+      { agent: 'claude', role: 'analyst-1', prompt: 'Analyze this from an architecture and security perspective:\n\n{{input}}' },
+      { agent: 'codex', role: 'analyst-2', prompt: 'Analyze this from an implementation and performance perspective:\n\n{{input}}' },
+      { agent: 'claude', role: 'synthesizer', prompt: 'Synthesize these independent analyses into a unified recommendation:\n\nAnalysis 1 (Architecture/Security):\n{{step.0}}\n\nAnalysis 2 (Implementation/Performance):\n{{step.1}}\n\nOriginal question:\n{{input}}' },
+    ],
+  },
+  {
+    id: 'code-review-loop',
+    name: 'Implement + Review Loop',
+    description: 'Codex implements, Claude reviews, iterates until approved',
+    pattern: 'review-loop',
+    steps: [
+      { agent: 'codex', role: 'implementer', prompt: '{{input}}\n\n{{prev}}' },
+      { agent: 'claude', role: 'reviewer', prompt: 'Review this code. If it\'s acceptable, respond with exactly "APPROVED". If not, explain what needs to change.\n\nOriginal request: {{input}}\n\nImplementation:\n{{prev}}' },
+    ],
+    maxIterations: 3,
+  },
+  {
+    id: 'debate',
+    name: 'Agent Debate',
+    description: 'Two agents debate, then a judge synthesizes the best answer',
+    pattern: 'debate',
+    steps: [
+      { agent: 'claude', role: 'debater-1', prompt: 'Take a strong position on this topic and argue for it:\n\n{{input}}' },
+      { agent: 'codex', role: 'debater-2', prompt: 'Take the opposite position from this argument and counter it:\n\nOriginal topic: {{input}}\n\nFirst position:\n{{step.0}}' },
+      { agent: 'claude', role: 'judge', prompt: 'You are a neutral judge. Evaluate both positions and synthesize the strongest answer:\n\nOriginal question: {{input}}\n\nPosition A:\n{{step.0}}\n\nPosition B:\n{{step.1}}' },
+    ],
+  },
+];
+
+export class ComboExecutor extends EventEmitter {
+  constructor(
+    private comboRepo: ComboRepo,
+    private auditRepo: AuditRepo,
+    private taskExecutor: TaskExecutor,
+    private agentManager: AgentManager,
+  ) {
+    super();
+  }
+
+  getPresets(): ComboPreset[] {
+    return COMBO_PRESETS;
+  }
+
+  start(request: CreateComboRequest): string {
+    const comboId = nanoid(12);
+    const createdAt = new Date().toISOString();
+
+    this.comboRepo.create({
+      comboId,
+      name: request.name,
+      pattern: request.pattern,
+      steps: request.steps,
+      input: request.input,
+      status: 'pending',
+      maxIterations: request.maxIterations,
+      workingDirectory: request.workingDirectory,
+      priority: request.priority,
+      createdAt,
+    });
+    this.auditRepo.log(null, 'combo.created', {
+      comboId, name: request.name, pattern: request.pattern, stepCount: request.steps.length,
+    });
+
+    this.runCombo(comboId, request).catch((err) => {
+      this.emit('combo:error', comboId, err);
+    });
+
+    return comboId;
+  }
+
+  private async runCombo(comboId: string, request: CreateComboRequest): Promise<void> {
+    this.comboRepo.updateStatus(comboId, 'running');
+
+    try {
+      switch (request.pattern) {
+        case 'pipeline':
+          await this.executePipeline(comboId, request);
+          break;
+        case 'map-reduce':
+          await this.executeMapReduce(comboId, request);
+          break;
+        case 'review-loop':
+          await this.executeReviewLoop(comboId, request);
+          break;
+        case 'debate':
+          await this.executeDebate(comboId, request);
+          break;
+      }
+      this.comboRepo.updateStatus(comboId, 'completed');
+      this.auditRepo.log(null, 'combo.completed', { comboId });
+      this.emit('combo:done', comboId);
+    } catch (err) {
+      this.comboRepo.updateStatus(comboId, 'failed');
+      this.auditRepo.log(null, 'combo.failed', { comboId, error: (err as Error).message });
+      this.emit('combo:done', comboId);
+    }
+  }
+
+  /** Pipeline: each step's output feeds into the next step's prompt */
+  private async executePipeline(comboId: string, request: CreateComboRequest): Promise<void> {
+    const stepResults: Record<number, string> = {};
+    let prev = '';
+
+    for (let i = 0; i < request.steps.length; i++) {
+      const step = request.steps[i];
+      const prompt = interpolate(step.prompt, { input: request.input, prev, stepResults });
+
+      this.auditRepo.log(null, 'combo.step', { comboId, stepIndex: i, agent: step.agent, role: step.role });
+
+      const task = await this.executeStep(comboId, step.agent, prompt, request);
+      const output = task.result?.stdout ?? '';
+      stepResults[i] = output;
+      prev = output;
+
+      this.comboRepo.addTaskId(comboId, task.taskId);
+      this.comboRepo.setStepResult(comboId, i, output);
+
+      if (task.status === 'failed') {
+        throw new Error(`Pipeline step ${i} (${step.role ?? step.agent}) failed`);
+      }
+    }
+
+    this.comboRepo.setFinalOutput(comboId, prev);
+  }
+
+  /** Map-Reduce: all steps except last run in parallel, last step gets all results */
+  private async executeMapReduce(comboId: string, request: CreateComboRequest): Promise<void> {
+    const mapSteps = request.steps.slice(0, -1);
+    const reduceStep = request.steps[request.steps.length - 1];
+    const stepResults: Record<number, string> = {};
+
+    // Map phase: run all map steps in parallel
+    this.auditRepo.log(null, 'combo.step', { comboId, phase: 'map', count: mapSteps.length });
+
+    const mapPromises = mapSteps.map(async (step, i) => {
+      const prompt = interpolate(step.prompt, { input: request.input, stepResults });
+      const task = await this.executeStep(comboId, step.agent, prompt, request);
+      const output = task.result?.stdout ?? '';
+      stepResults[i] = output;
+      this.comboRepo.addTaskId(comboId, task.taskId);
+      this.comboRepo.setStepResult(comboId, i, output);
+      return task;
+    });
+
+    const mapResults = await Promise.all(mapPromises);
+    const failed = mapResults.filter(t => t.status === 'failed');
+    if (failed.length > 0) {
+      throw new Error(`Map phase: ${failed.length} step(s) failed`);
+    }
+
+    // Reduce phase: synthesize all map results
+    this.auditRepo.log(null, 'combo.step', { comboId, phase: 'reduce', agent: reduceStep.agent });
+
+    const reducePrompt = interpolate(reduceStep.prompt, { input: request.input, stepResults });
+    const reduceTask = await this.executeStep(comboId, reduceStep.agent, reducePrompt, request);
+    const reduceIdx = request.steps.length - 1;
+    const finalOutput = reduceTask.result?.stdout ?? '';
+
+    stepResults[reduceIdx] = finalOutput;
+    this.comboRepo.addTaskId(comboId, reduceTask.taskId);
+    this.comboRepo.setStepResult(comboId, reduceIdx, finalOutput);
+    this.comboRepo.setFinalOutput(comboId, finalOutput);
+
+    if (reduceTask.status === 'failed') {
+      throw new Error('Reduce step failed');
+    }
+  }
+
+  /** Review Loop: step[0] implements, step[1] reviews, iterate until APPROVED or max iterations */
+  private async executeReviewLoop(comboId: string, request: CreateComboRequest): Promise<void> {
+    const implStep = request.steps[0];
+    const reviewStep = request.steps[1];
+    const maxIter = request.maxIterations ?? 3;
+    const stepResults: Record<number, string> = {};
+    let prev = '';
+    let approved = false;
+
+    for (let iter = 0; iter < maxIter; iter++) {
+      this.comboRepo.incrementIterations(comboId);
+      this.auditRepo.log(null, 'combo.iteration', { comboId, iteration: iter + 1, maxIterations: maxIter });
+
+      // Implementation step
+      const implPrompt = interpolate(implStep.prompt, { input: request.input, prev, stepResults });
+      const implTask = await this.executeStep(comboId, implStep.agent, implPrompt, request);
+      const implOutput = implTask.result?.stdout ?? '';
+      this.comboRepo.addTaskId(comboId, implTask.taskId);
+
+      if (implTask.status === 'failed') {
+        throw new Error(`Implementation failed on iteration ${iter + 1}`);
+      }
+
+      // Review step
+      const reviewPrompt = interpolate(reviewStep.prompt, { input: request.input, prev: implOutput, stepResults });
+      const reviewTask = await this.executeStep(comboId, reviewStep.agent, reviewPrompt, request);
+      const reviewOutput = reviewTask.result?.stdout ?? '';
+      this.comboRepo.addTaskId(comboId, reviewTask.taskId);
+
+      if (reviewTask.status === 'failed') {
+        throw new Error(`Review failed on iteration ${iter + 1}`);
+      }
+
+      // Check for approval
+      if (reviewOutput.toUpperCase().includes('APPROVED')) {
+        approved = true;
+        stepResults[0] = implOutput;
+        stepResults[1] = reviewOutput;
+        this.comboRepo.setStepResult(comboId, 0, implOutput);
+        this.comboRepo.setStepResult(comboId, 1, reviewOutput);
+        this.comboRepo.setFinalOutput(comboId, implOutput);
+        break;
+      }
+
+      // Not approved — feed review feedback as prev for next iteration
+      prev = `Previous review feedback:\n${reviewOutput}\n\nPlease address the above issues.`;
+    }
+
+    if (!approved) {
+      // Max iterations reached without approval — use last implementation
+      const combo = this.comboRepo.getById(comboId);
+      this.comboRepo.setFinalOutput(comboId, `[Max iterations (${maxIter}) reached without approval]\n\n${stepResults[0] ?? ''}`);
+    }
+  }
+
+  /** Debate: step[0] argues, step[1] counters, step[2] judges */
+  private async executeDebate(comboId: string, request: CreateComboRequest): Promise<void> {
+    // Same as pipeline but with semantic labeling
+    await this.executePipeline(comboId, request);
+  }
+
+  private async executeStep(
+    comboId: string,
+    agentId: string,
+    prompt: string,
+    request: CreateComboRequest,
+  ) {
+    const taskRequest: CreateTaskRequest = {
+      prompt,
+      preferredAgent: agentId,
+      workingDirectory: request.workingDirectory,
+      priority: request.priority,
+    };
+
+    return this.taskExecutor.execute(taskRequest);
+  }
+
+  getCombo(comboId: string): ComboDescriptor | undefined {
+    return this.comboRepo.getById(comboId);
+  }
+
+  listCombos(limit: number = 20, offset: number = 0): ComboDescriptor[] {
+    return this.comboRepo.list(limit, offset);
+  }
+}

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

@@ -0,0 +1,136 @@
+import { nanoid } from 'nanoid';
+import { EventEmitter } from 'node:events';
+
+export interface DagNode {
+  id: string;
+  prompt: string;
+  agent?: string;
+  dependsOn: string[];  // node IDs this node depends on
+}
+
+export interface DagResult {
+  dagId: string;
+  status: 'completed' | 'failed';
+  nodeResults: Record<string, { output: string; exitCode: number; durationMs: number }>;
+  executionOrder: string[];
+  totalDurationMs: number;
+}
+
+type ExecuteFn = (nodeId: string, prompt: string, agent?: string) => Promise<{ stdout: string; exitCode: number; durationMs: number }>;
+
+export class DagExecutor extends EventEmitter {
+  /**
+   * Execute a DAG of tasks respecting dependencies.
+   * Nodes without dependencies run in parallel.
+   * Node prompts can reference {{node.ID}} for dependency outputs.
+   */
+  async execute(nodes: DagNode[], executeFn: ExecuteFn): Promise<DagResult> {
+    const dagId = nanoid(12);
+    const start = Date.now();
+    const nodeResults: Record<string, { output: string; exitCode: number; durationMs: number }> = {};
+    const executionOrder: string[] = [];
+
+    // Validate: no cycles, all dependencies exist
+    const nodeMap = new Map(nodes.map(n => [n.id, n]));
+    for (const node of nodes) {
+      for (const dep of node.dependsOn) {
+        if (!nodeMap.has(dep)) throw new Error(`Node ${node.id} depends on unknown node ${dep}`);
+      }
+    }
+    if (this.hasCycle(nodes)) throw new Error('DAG contains a cycle');
+
+    const completed = new Set<string>();
+    const failed = new Set<string>();
+    const pending = new Set(nodes.map(n => n.id));
+
+    while (pending.size > 0) {
+      // Find all nodes whose dependencies are satisfied
+      const ready = nodes.filter(n =>
+        pending.has(n.id) &&
+        n.dependsOn.every(d => completed.has(d)) &&
+        !n.dependsOn.some(d => failed.has(d))
+      );
+
+      // Check for nodes blocked by failed dependencies
+      const blocked = nodes.filter(n =>
+        pending.has(n.id) &&
+        n.dependsOn.some(d => failed.has(d))
+      );
+      for (const b of blocked) {
+        pending.delete(b.id);
+        failed.add(b.id);
+        nodeResults[b.id] = { output: 'Skipped: dependency failed', exitCode: 1, durationMs: 0 };
+      }
+
+      if (ready.length === 0 && pending.size > 0 && blocked.length === 0) {
+        throw new Error('DAG execution deadlocked');
+      }
+      if (ready.length === 0) break;
+
+      // Execute ready nodes in parallel
+      const results = await Promise.allSettled(
+        ready.map(async (node) => {
+          const prompt = this.interpolateNodePrompt(node.prompt, nodeResults);
+          this.emit('dag:node:start', dagId, node.id);
+          const result = await executeFn(node.id, prompt, node.agent);
+          return { nodeId: node.id, ...result };
+        })
+      );
+
+      for (const r of results) {
+        if (r.status === 'fulfilled') {
+          const { nodeId, stdout, exitCode, durationMs } = r.value;
+          nodeResults[nodeId] = { output: stdout, exitCode, durationMs };
+          executionOrder.push(nodeId);
+          pending.delete(nodeId);
+          if (exitCode === 0) completed.add(nodeId);
+          else failed.add(nodeId);
+          this.emit('dag:node:done', dagId, nodeId, exitCode);
+        } else {
+          // Should not happen since executeFn catches errors, but handle anyway
+          const nodeId = ready[results.indexOf(r)].id;
+          nodeResults[nodeId] = { output: r.reason?.message ?? 'Unknown error', exitCode: 1, durationMs: 0 };
+          pending.delete(nodeId);
+          failed.add(nodeId);
+        }
+      }
+    }
+
+    return {
+      dagId,
+      status: failed.size === 0 ? 'completed' : 'failed',
+      nodeResults,
+      executionOrder,
+      totalDurationMs: Date.now() - start,
+    };
+  }
+
+  private interpolateNodePrompt(prompt: string, nodeResults: Record<string, { output: string }>): string {
+    return prompt.replace(/\{\{node\.([a-zA-Z0-9_-]+)\}\}/g, (_match, nodeId) => {
+      return nodeResults[nodeId]?.output ?? `[node ${nodeId} not available]`;
+    });
+  }
+
+  private hasCycle(nodes: DagNode[]): boolean {
+    const visited = new Set<string>();
+    const recStack = new Set<string>();
+    const adj = new Map<string, string[]>();
+    for (const n of nodes) adj.set(n.id, n.dependsOn);
+
+    const dfs = (id: string): boolean => {
+      visited.add(id);
+      recStack.add(id);
+      for (const dep of adj.get(id) ?? []) {
+        if (!visited.has(dep) && dfs(dep)) return true;
+        if (recStack.has(dep)) return true;
+      }
+      recStack.delete(id);
+      return false;
+    };
+
+    for (const n of nodes) {
+      if (!visited.has(n.id) && dfs(n.id)) return true;
+    }
+    return false;
+  }
+}