web-agent-bridge 2.3.0 → 2.3.1

package/server/services/agent-symphony.js

@@ -1,19 +1,17 @@
 /**
- * Agent Symphony Orchestrator — Autonomous Multi-Agent Collaboration
+ * Symphony Orchestrator — Multi-Agent Composition Engine
  *
- * Coordinates specialized agents (Researcher, Negotiator, Analyst, Guardian)
- * to execute complex tasks WITHOUT any external LLM dependency.
- * Each agent has built-in rule engines and heuristics.
+ * Orchestrates complex workflows by composing multiple agent roles into
+ * coordinated multi-phase pipelines. Each role contributes specialized analysis,
+ * and the results are fused into a unified recommendation.
  *
- * Symphony Phases:
- *   1. COMPOSE  — Assign roles based on task type
- *   2. DISCOVER — Researcher gathers site data via WAB schema
- *   3. ANALYZE  — Analyst evaluates options using learned preferences
- *   4. NEGOTIATE — Negotiator pursues best deal terms
- *   5. GUARD    — Guardian validates safety & fairness
- *   6. DECIDE   — Final consensus assembly from all agent outputs
- *
- * All processing is local — no tokens consumed, no data shared externally.
+ * Architecture:
+ *   - 4 specialized role engines: Researcher, Analyst, Negotiator, Guardian
+ *   - 6-phase pipeline: analyze → research → negotiate → guard → synthesize → decide
+ *   - Templates define which phases execute and in what order
+ *   - Cross-service integration: Analyst consults learning engine for preferences
+ *   - All decisions are recorded back to the learning engine for future improvement
+ *   - No data leaves the WAB instance — everything runs locally
  */
 
 const crypto = require('crypto');
@@ -21,661 +19,693 @@ const { db } = require('../models/db');
 
 // ─── Schema ──────────────────────────────────────────────────────────
 
+// Drop legacy schema if columns are incompatible (v2.3.0 → v2.3.1 migration)
+try {
+  const cols = db.prepare("PRAGMA table_info(symphony_compositions)").all().map(c => c.name);
+  if (cols.length > 0 && !cols.includes('template')) {
+    db.exec('DROP TABLE IF EXISTS symphony_compositions');
+    db.exec('DROP TABLE IF EXISTS symphony_phase_logs');
+  }
+} catch (_) {}
+
 db.exec(`
   CREATE TABLE IF NOT EXISTS symphony_compositions (
     id TEXT PRIMARY KEY,
     site_id TEXT NOT NULL,
-    task TEXT NOT NULL,
-    task_type TEXT NOT NULL,
-    status TEXT DEFAULT 'composing',
+    template TEXT NOT NULL,
+    input_data TEXT DEFAULT '{}',
+    status TEXT DEFAULT 'pending',
     phases_completed TEXT DEFAULT '[]',
-    current_phase TEXT DEFAULT 'compose',
-    final_decision TEXT,
-    confidence REAL DEFAULT 0.0,
-    duration_ms INTEGER DEFAULT 0,
+    current_phase TEXT,
+    result TEXT,
+    error TEXT,
+    duration_ms INTEGER,
+    agent_count INTEGER DEFAULT 0,
     created_at TEXT DEFAULT (datetime('now')),
     completed_at TEXT
   );
 
-  CREATE TABLE IF NOT EXISTS symphony_roles (
+  CREATE TABLE IF NOT EXISTS symphony_phase_logs (
     id TEXT PRIMARY KEY,
     composition_id TEXT NOT NULL,
+    phase TEXT NOT NULL,
     role TEXT NOT NULL,
-    agent_id TEXT,
-    status TEXT DEFAULT 'waiting',
     input TEXT DEFAULT '{}',
     output TEXT DEFAULT '{}',
-    reasoning TEXT,
-    confidence REAL DEFAULT 0.0,
-    started_at TEXT,
-    completed_at TEXT,
-    FOREIGN KEY (composition_id) REFERENCES symphony_compositions(id) ON DELETE CASCADE
-  );
-
-  CREATE TABLE IF NOT EXISTS symphony_consensus (
-    id TEXT PRIMARY KEY,
-    composition_id TEXT NOT NULL,
-    votes TEXT DEFAULT '{}',
-    method TEXT DEFAULT 'weighted',
-    result TEXT DEFAULT '{}',
-    agreement_score REAL DEFAULT 0.0,
-    created_at TEXT DEFAULT (datetime('now')),
-    FOREIGN KEY (composition_id) REFERENCES symphony_compositions(id) ON DELETE CASCADE
-  );
-
-  CREATE TABLE IF NOT EXISTS symphony_templates (
-    id TEXT PRIMARY KEY,
-    name TEXT UNIQUE NOT NULL,
-    task_type TEXT NOT NULL,
-    roles TEXT NOT NULL,
-    phase_order TEXT NOT NULL,
-    description TEXT,
+    duration_ms INTEGER DEFAULT 0,
     created_at TEXT DEFAULT (datetime('now'))
   );
 
-  CREATE INDEX IF NOT EXISTS idx_symphony_comp_site ON symphony_compositions(site_id);
-  CREATE INDEX IF NOT EXISTS idx_symphony_comp_status ON symphony_compositions(status);
-  CREATE INDEX IF NOT EXISTS idx_symphony_roles_comp ON symphony_roles(composition_id);
-  CREATE INDEX IF NOT EXISTS idx_symphony_consensus_comp ON symphony_consensus(composition_id);
+  CREATE INDEX IF NOT EXISTS idx_sym_comp_site ON symphony_compositions(site_id);
+  CREATE INDEX IF NOT EXISTS idx_sym_comp_status ON symphony_compositions(status);
+  CREATE INDEX IF NOT EXISTS idx_sym_comp_template ON symphony_compositions(template);
+  CREATE INDEX IF NOT EXISTS idx_sym_phase_comp ON symphony_phase_logs(composition_id);
 `);
 
-// ─── Default Templates ──────────────────────────────────────────────
-
-const TEMPLATES = [
-  {
-    name: 'purchase_advisor',
-    task_type: 'purchase',
-    roles: ['researcher', 'analyst', 'negotiator', 'guardian'],
-    phase_order: ['discover', 'analyze', 'negotiate', 'guard', 'decide'],
-    description: 'End-to-end purchase advisory: discover products, analyze value, negotiate price, verify safety',
-  },
-  {
-    name: 'price_hunter',
-    task_type: 'price_comparison',
-    roles: ['researcher', 'analyst', 'guardian'],
-    phase_order: ['discover', 'analyze', 'guard', 'decide'],
-    description: 'Cross-site price comparison and best-deal identification',
-  },
-  {
-    name: 'deal_negotiator',
-    task_type: 'negotiation',
-    roles: ['researcher', 'negotiator', 'guardian'],
-    phase_order: ['discover', 'negotiate', 'guard', 'decide'],
-    description: 'Aggressive deal-seeking with safety verification',
-  },
-  {
-    name: 'site_scout',
-    task_type: 'exploration',
-    roles: ['researcher', 'analyst'],
-    phase_order: ['discover', 'analyze', 'decide'],
-    description: 'Explore and catalog site capabilities',
-  },
-  {
-    name: 'trust_auditor',
-    task_type: 'verification',
-    roles: ['researcher', 'guardian', 'analyst'],
-    phase_order: ['discover', 'guard', 'analyze', 'decide'],
-    description: 'Comprehensive trust and safety audit of a site',
-  },
-];
-
-const _ensureTemplates = db.transaction(() => {
-  const insert = db.prepare(`INSERT OR IGNORE INTO symphony_templates (id, name, task_type, roles, phase_order, description) VALUES (?, ?, ?, ?, ?, ?)`);
-  for (const t of TEMPLATES) {
-    insert.run(crypto.randomUUID(), t.name, t.task_type, JSON.stringify(t.roles), JSON.stringify(t.phase_order), t.description);
-  }
-});
-_ensureTemplates();
-
 // ─── Prepared Statements ─────────────────────────────────────────────
 
 const stmts = {
-  insertComposition: db.prepare(`INSERT INTO symphony_compositions (id, site_id, task, task_type) VALUES (?, ?, ?, ?)`),
-  getComposition: db.prepare(`SELECT * FROM symphony_compositions WHERE id = ?`),
-  updateComposition: db.prepare(`UPDATE symphony_compositions SET status = ?, current_phase = ?, phases_completed = ?, final_decision = ?, confidence = ?, duration_ms = ?, completed_at = ? WHERE id = ?`),
-  getCompositionsBySite: db.prepare(`SELECT * FROM symphony_compositions WHERE site_id = ? ORDER BY created_at DESC LIMIT ?`),
-  getActiveCompositions: db.prepare(`SELECT * FROM symphony_compositions WHERE status IN ('composing', 'executing') ORDER BY created_at DESC`),
+  insertComposition: db.prepare('INSERT INTO symphony_compositions (id, site_id, template, input_data, status, current_phase, agent_count) VALUES (?, ?, ?, ?, ?, ?, ?)'),
+  updateComposition: db.prepare("UPDATE symphony_compositions SET status = ?, phases_completed = ?, current_phase = ?, result = ?, error = ?, duration_ms = ?, completed_at = datetime('now') WHERE id = ?"),
+  updatePhase: db.prepare('UPDATE symphony_compositions SET current_phase = ?, phases_completed = ? WHERE id = ?'),
+  getComposition: db.prepare('SELECT * FROM symphony_compositions WHERE id = ?'),
+  getCompositions: db.prepare('SELECT * FROM symphony_compositions WHERE site_id = ? ORDER BY created_at DESC LIMIT ?'),
+  getRecentByTemplate: db.prepare('SELECT * FROM symphony_compositions WHERE site_id = ? AND template = ? ORDER BY created_at DESC LIMIT ?'),
 
-  insertRole: db.prepare(`INSERT INTO symphony_roles (id, composition_id, role, agent_id) VALUES (?, ?, ?, ?)`),
-  getRoles: db.prepare(`SELECT * FROM symphony_roles WHERE composition_id = ? ORDER BY started_at ASC`),
-  getRole: db.prepare(`SELECT * FROM symphony_roles WHERE composition_id = ? AND role = ?`),
-  updateRole: db.prepare(`UPDATE symphony_roles SET status = ?, input = ?, output = ?, reasoning = ?, confidence = ?, started_at = COALESCE(started_at, datetime('now')), completed_at = ? WHERE id = ?`),
+  insertPhaseLog: db.prepare('INSERT INTO symphony_phase_logs (id, composition_id, phase, role, input, output, duration_ms) VALUES (?, ?, ?, ?, ?, ?, ?)'),
+  getPhaseLogs: db.prepare('SELECT * FROM symphony_phase_logs WHERE composition_id = ? ORDER BY created_at ASC'),
 
-  insertConsensus: db.prepare(`INSERT INTO symphony_consensus (id, composition_id, votes, method, result, agreement_score) VALUES (?, ?, ?, ?, ?, ?)`),
-  getConsensus: db.prepare(`SELECT * FROM symphony_consensus WHERE composition_id = ?`),
+  getStats: db.prepare(`SELECT
+    COUNT(*) as total,
+    SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed,
+    SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed,
+    AVG(CASE WHEN duration_ms IS NOT NULL THEN duration_ms END) as avg_duration,
+    COUNT(DISTINCT template) as templates_used
+    FROM symphony_compositions WHERE site_id = ?`),
+};
 
-  getTemplate: db.prepare(`SELECT * FROM symphony_templates WHERE name = ?`),
-  getTemplateByType: db.prepare(`SELECT * FROM symphony_templates WHERE task_type = ?`),
-  getAllTemplates: db.prepare(`SELECT * FROM symphony_templates ORDER BY name`),
+// ─── Templates ───────────────────────────────────────────────────────
 
-  getStats: db.prepare(`SELECT
-    (SELECT COUNT(*) FROM symphony_compositions WHERE site_id = ?) as total_compositions,
-    (SELECT COUNT(*) FROM symphony_compositions WHERE site_id = ? AND status = 'completed') as completed,
-    (SELECT AVG(confidence) FROM symphony_compositions WHERE site_id = ? AND status = 'completed') as avg_confidence,
-    (SELECT AVG(duration_ms) FROM symphony_compositions WHERE site_id = ? AND status = 'completed') as avg_duration_ms`),
+const TEMPLATES = {
+  'product-purchase': {
+    name: 'Smart Product Purchase',
+    description: 'Full analysis pipeline for purchase decisions',
+    phases: ['analyze', 'research', 'negotiate', 'guard', 'synthesize'],
+    roles: ['analyst', 'researcher', 'negotiator', 'guardian'],
+  },
+  'content-discovery': {
+    name: 'Content Discovery',
+    description: 'Find and evaluate content across sources',
+    phases: ['research', 'analyze', 'synthesize'],
+    roles: ['researcher', 'analyst'],
+  },
+  'security-audit': {
+    name: 'Security Audit',
+    description: 'Comprehensive security and privacy evaluation',
+    phases: ['research', 'guard', 'analyze', 'synthesize'],
+    roles: ['researcher', 'guardian', 'analyst'],
+  },
+  'price-optimization': {
+    name: 'Price Optimization',
+    description: 'Find the best price through research and negotiation',
+    phases: ['research', 'negotiate', 'guard', 'synthesize'],
+    roles: ['researcher', 'negotiator', 'guardian'],
+  },
+  'comparison-analysis': {
+    name: 'Comparison Analysis',
+    description: 'Compare multiple options with weighted criteria',
+    phases: ['research', 'analyze', 'synthesize'],
+    roles: ['researcher', 'analyst'],
+  },
 };
 
-// ─── Role Engines (Rule-Based AI) ────────────────────────────────────
+// ─── Role Engines ────────────────────────────────────────────────────
 
-const RoleEngines = {
+const ROLE_ENGINES = {
   /**
-   * Researcher — Discovers and catalogs site information
+   * Researcher — gathers structured data from the schema and context.
    */
   researcher: {
-    execute(input) {
-      const { siteData, task } = input;
-      const findings = [];
-      const capabilities = [];
-
-      // Analyze schema if available
-      if (siteData?.schema) {
-        const schema = typeof siteData.schema === 'string' ? JSON.parse(siteData.schema) : siteData.schema;
-        if (schema.actions) {
-          for (const [name, def] of Object.entries(schema.actions)) {
-            capabilities.push({ name, type: 'action', params: Object.keys(def.params || {}) });
-          }
-          findings.push(`Found ${Object.keys(schema.actions).length} available actions`);
-        }
-        if (schema.products) {
-          findings.push(`Catalog: ${schema.products.length || 'unknown'} products available`);
+    execute(schema, context, priorOutputs) {
+      const result = { sources: [], findings: [], dataQuality: 'unknown' };
+
+      // Collect available actions from schema
+      if (schema && schema.actions && Array.isArray(schema.actions)) {
+        for (const action of schema.actions) {
+          result.sources.push({
+            type: 'action',
+            name: action.name || action.id || 'unnamed',
+            available: true,
+            fields: Array.isArray(action.fields) ? action.fields.length : 0,
+          });
         }
       }
 
-      // Extract relevant data points from site data
-      if (siteData?.products) {
-        const products = Array.isArray(siteData.products) ? siteData.products : [];
-        const prices = products.filter((p) => p.price).map((p) => ({ name: p.name, price: p.price }));
-        if (prices.length > 0) {
-          findings.push(`Price range: ${Math.min(...prices.map((p) => p.price))} - ${Math.max(...prices.map((p) => p.price))}`);
+      // Analyze context data
+      if (context.items && Array.isArray(context.items)) {
+        for (const item of context.items) {
+          const finding = { type: 'item', name: item.name || item.title || 'Unknown' };
+          if (item.price !== undefined) finding.price = item.price;
+          if (item.rating !== undefined) finding.rating = item.rating;
+          if (item.availability !== undefined) finding.availability = item.availability;
+          if (item.category) finding.category = item.category;
+          result.findings.push(finding);
         }
       }
 
-      if (siteData?.categories) findings.push(`Categories: ${siteData.categories.join(', ')}`);
-      if (siteData?.policies) {
-        if (siteData.policies.returns) findings.push(`Return policy: ${siteData.policies.returns}`);
-        if (siteData.policies.shipping) findings.push(`Shipping: ${siteData.policies.shipping}`);
+      // Pull context fields directly
+      if (context.url) result.researchedUrl = context.url;
+      if (context.query) result.researchQuery = context.query;
+      if (context.budget) result.budgetConstraint = context.budget;
+
+      // Factor in prior research if present
+      if (priorOutputs.research) {
+        result.priorResearch = priorOutputs.research.findings?.length || 0;
       }
 
-      return {
-        findings,
-        capabilities,
-        dataQuality: findings.length > 3 ? 'rich' : findings.length > 0 ? 'moderate' : 'sparse',
-        confidence: Math.min(0.95, 0.3 + findings.length * 0.1),
-        reasoning: `Discovered ${findings.length} data points and ${capabilities.length} capabilities`,
-      };
+      result.dataQuality = result.findings.length > 3 ? 'high' : result.findings.length > 0 ? 'medium' : 'low';
+      result.sourcesCount = result.sources.length;
+      result.findingsCount = result.findings.length;
+
+      return result;
     },
   },
 
   /**
-   * Analyst — Evaluates options using scoring heuristics
+   * Analyst — evaluates data using scoring criteria AND learned preferences.
    */
   analyst: {
-    execute(input) {
-      const { findings, products, preferences, task } = input;
-      const analyses = [];
-
-      // Score products if available
-      if (products && Array.isArray(products)) {
-        const scored = products.map((product) => {
-          let score = 50; // base score
-          const reasons = [];
-
-          // Price scoring
-          if (product.price !== undefined && preferences?.maxPrice) {
-            const priceRatio = product.price / preferences.maxPrice;
-            if (priceRatio <= 0.5) { score += 25; reasons.push('well under budget'); }
-            else if (priceRatio <= 0.8) { score += 15; reasons.push('within budget'); }
-            else if (priceRatio <= 1.0) { score += 5; reasons.push('near budget limit'); }
-            else { score -= 20; reasons.push('over budget'); }
-          }
+    execute(schema, context, priorOutputs) {
+      const research = priorOutputs.research || {};
+      const findings = research.findings || context.items || [];
+
+      // Build criteria from context or defaults
+      const criteria = context.criteria || this._defaultCriteria(context);
+
+      // Load learned preferences if learning engine is available
+      let preferences = null;
+      try {
+        const learning = require('./agent-learning');
+        const siteId = context.siteId || context.site_id || 'default';
+        const agentId = context.agentId || 'symphony-analyst';
+        const domain = context.domain || 'purchase';
+        preferences = learning.getPreferences(siteId, agentId, domain);
+      } catch (_) {
+        // Learning engine not available — continue without preferences
+      }
 
-          // Rating scoring
-          if (product.rating !== undefined) {
-            score += (product.rating - 3) * 10;
-            if (product.rating >= 4.5) reasons.push('highly rated');
-            if (product.rating < 3) reasons.push('poorly rated');
+      // Score items
+      const scored = findings.map((item) => {
+        let score = 0;
+        let weights = 0;
+        const breakdown = {};
+
+        for (const [criterion, weight] of Object.entries(criteria)) {
+          let val = 0;
+
+          if (criterion === 'price' && item.price !== undefined) {
+            const budget = context.budget || 100;
+            val = Math.max(0, 1 - item.price / budget); // lower price = higher score
+          } else if (criterion === 'rating' && item.rating !== undefined) {
+            val = item.rating / 5; // normalize to [0,1]
+          } else if (criterion === 'availability' && item.availability !== undefined) {
+            val = item.availability ? 1 : 0;
+          } else if (criterion === 'quality' && item.quality !== undefined) {
+            val = Math.min(1, item.quality / 10);
+          } else if (criterion === 'popularity' && item.reviews !== undefined) {
+            val = Math.min(1, item.reviews / 1000); // 1000+ reviews = max
+          } else {
+            continue; // Skip criteria with no matching data
           }
 
-          // Availability
-          if (product.inStock === false) { score -= 30; reasons.push('out of stock'); }
-
-          // Discount scoring
-          if (product.discount) {
-            score += Math.min(20, product.discount);
-            reasons.push(`${product.discount}% discount`);
+          // Apply preference modifier: if user historically prefers this criterion, boost it
+          let prefModifier = 1;
+          if (preferences && preferences.profile) {
+            const prefEntry = preferences.profile[criterion] || preferences.profile[`category:${criterion}`];
+            if (prefEntry) {
+              prefModifier = prefEntry.direction === 'preferred' ? 1.2 : 0.8;
+            }
           }
 
-          // Preference matching
-          if (preferences?.preferredCategory && product.category === preferences.preferredCategory) {
-            score += 10;
-            reasons.push('matches preferred category');
-          }
+          const adjustedWeight = weight * prefModifier;
+          breakdown[criterion] = { value: Math.round(val * 100) / 100, weight: adjustedWeight };
+          score += val * adjustedWeight;
+          weights += adjustedWeight;
+        }
 
-          return { ...product, score: Math.max(0, Math.min(100, score)), reasons };
-        });
+        return {
+          item: item.name || item.title || 'Unknown',
+          score: weights > 0 ? Math.round((score / weights) * 1000) / 1000 : 0,
+          breakdown,
+          raw: item,
+        };
+      });
 
-        scored.sort((a, b) => b.score - a.score);
-        analyses.push({
-          type: 'product_ranking',
-          items: scored.slice(0, 10),
-          bestOption: scored[0],
-          worstOption: scored[scored.length - 1],
-        });
-      }
-
-      // Value analysis from findings
-      const valueInsights = [];
-      if (findings) {
-        for (const f of findings) {
-          if (typeof f === 'string' && f.includes('Price range')) valueInsights.push(f);
-          if (typeof f === 'string' && f.includes('discount')) valueInsights.push(f);
-          if (typeof f === 'string' && f.includes('Return policy')) valueInsights.push(f);
-        }
-      }
+      scored.sort((a, b) => b.score - a.score);
 
       return {
-        analyses,
-        valueInsights,
-        recommendation: analyses[0]?.items?.[0] || null,
-        confidence: analyses.length > 0 ? 0.7 + analyses[0].items.length * 0.02 : 0.3,
-        reasoning: `Analyzed ${analyses.length > 0 ? analyses[0].items.length : 0} options with ${valueInsights.length} value insights`,
+        rankings: scored,
+        topPick: scored[0] || null,
+        criteriaUsed: criteria,
+        preferencesApplied: preferences !== null,
+        preferenceSummary: preferences
+          ? { confidence: preferences.confidence, topActions: preferences.topActions }
+          : null,
+        itemsEvaluated: scored.length,
       };
     },
+
+    _defaultCriteria(context) {
+      const c = { price: 0.3, rating: 0.3 };
+      if (context.budget) c.price = 0.4;
+      c.availability = 0.2;
+      c.quality = 0.15;
+      c.popularity = 0.05;
+      return c;
+    },
   },
 
   /**
-   * Negotiator — Pursues optimal deal terms
+   * Negotiator — identifies deals, calculates savings potential, suggests tactics.
    */
   negotiator: {
-    execute(input) {
-      const { product, siteCapabilities, preferences, marketData } = input;
-      const strategies = [];
-      const terms = {};
-
-      if (!product) {
-        return { strategies: [], terms: {}, confidence: 0, reasoning: 'No product to negotiate' };
+    execute(schema, context, priorOutputs) {
+      const analysis = priorOutputs.analyze || {};
+      const topPick = analysis.topPick || {};
+      const item = topPick.raw || context.items?.[0] || {};
+      const price = item.price || context.price || 0;
+      const budget = context.budget || price * 1.2;
+
+      // Calculate negotiation position
+      const marketData = this._estimateMarketData(price, context);
+      const savingsTarget = Math.round(price * 0.15); // Target 15% savings
+
+      const tactics = [];
+
+      // Bundle discount
+      if (context.items && context.items.length > 1) {
+        tactics.push({
+          tactic: 'bundle_discount',
+          description: 'Request bundle pricing for multiple items',
+          potentialSavings: Math.round(price * 0.1),
+          applicability: 'high',
+        });
       }
 
-      const price = product.price || 0;
-
-      // Strategy: Volume discount
-      if (siteCapabilities?.some((c) => c.name === 'bulk_order' || c.name === 'quantity_discount')) {
-        strategies.push({ type: 'volume', description: 'Request bulk/quantity discount', priority: 2 });
-        terms.quantity_discount = true;
+      // Timing-based discount
+      if (marketData.priceVolatility > 0.1) {
+        tactics.push({
+          tactic: 'price_timing',
+          description: 'Price shows volatility — waiting may yield lower price',
+          potentialSavings: Math.round(price * marketData.priceVolatility),
+          applicability: 'medium',
+        });
       }
 
-      // Strategy: Competitor price matching
-      if (marketData?.competitorPrices) {
-        const lowest = Math.min(...marketData.competitorPrices);
-        if (lowest < price) {
-          strategies.push({ type: 'price_match', description: `Competitor offers ${lowest} (${Math.round((1 - lowest / price) * 100)}% less)`, priority: 3 });
-          terms.target_price = lowest;
+      // Coupon/promo
+      if (schema && schema.actions) {
+        const hasPromo = schema.actions.some((a) =>
+          (a.name || '').toLowerCase().includes('coupon') ||
+          (a.name || '').toLowerCase().includes('promo') ||
+          (a.name || '').toLowerCase().includes('discount')
+        );
+        if (hasPromo) {
+          tactics.push({
+            tactic: 'promo_code',
+            description: 'Promotional actions detected in schema',
+            potentialSavings: Math.round(price * 0.2),
+            applicability: 'high',
+          });
         }
       }
 
-      // Strategy: Loyalty/repeat customer
-      if (preferences?.visitCount > 3) {
-        strategies.push({ type: 'loyalty', description: 'Leverage repeat customer status', priority: 1 });
-        terms.loyalty = true;
-      }
+      // Loyalty / repeat customer
+      tactics.push({
+        tactic: 'loyalty_inquiry',
+        description: 'Check for loyalty program or returning customer discounts',
+        potentialSavings: Math.round(price * 0.05),
+        applicability: 'low',
+      });
 
-      // Strategy: Bundle deal
-      if (siteCapabilities?.some((c) => c.name === 'bundle' || c.name === 'add_to_cart')) {
-        strategies.push({ type: 'bundle', description: 'Explore bundle pricing', priority: 1 });
-        terms.bundle = true;
-      }
+      // Compute position strength
+      const withinBudget = price <= budget;
+      const bestSavings = tactics.reduce((max, t) => Math.max(max, t.potentialSavings), 0);
 
-      // Calculate target price
-      let targetDiscount = 0;
-      if (strategies.length > 0) targetDiscount = Math.min(35, strategies.length * 8 + 5);
-      terms.target_price = terms.target_price || price * (1 - targetDiscount / 100);
-      terms.max_acceptable = price * 0.95; // worst case: 5% off
-      terms.ideal_price = price * (1 - targetDiscount / 100);
+      return {
+        originalPrice: price,
+        targetPrice: price - savingsTarget,
+        budget,
+        withinBudget,
+        maxPotentialSavings: bestSavings,
+        tactics,
+        marketEstimate: marketData,
+        recommendation: withinBudget
+          ? (bestSavings > price * 0.1 ? 'negotiate' : 'proceed')
+          : 'reconsider',
+      };
+    },
 
-      strategies.sort((a, b) => b.priority - a.priority);
+    _estimateMarketData(price, context) {
+      // Estimate market position from available signals
+      const priceVolatility = context.priceHistory
+        ? Math.min(1, context.priceHistory.stddev / price)
+        : 0.1;
+      const supplyLevel = context.availability === false ? 'low' : 'normal';
+      const demandSignal = context.reviews && context.reviews > 500 ? 'high' : 'moderate';
 
       return {
-        strategies,
-        terms,
-        confidence: Math.min(0.9, 0.3 + strategies.length * 0.15),
-        reasoning: `${strategies.length} negotiation strategies identified, target ${targetDiscount}% discount`,
+        estimatedFairValue: Math.round(price * 0.9),
+        priceVolatility: Math.round(priceVolatility * 100) / 100,
+        supplyLevel,
+        demandSignal,
       };
     },
   },
 
   /**
-   * Guardian — Validates safety, fairness, and trust
+   * Guardian — security, privacy, and trust evaluation.
    */
   guardian: {
-    execute(input) {
-      const { product, siteData, negotiationTerms, reputationData } = input;
-      const warnings = [];
-      const approvals = [];
+    execute(schema, context, priorOutputs) {
+      const risks = [];
       let riskScore = 0;
 
-      // Price manipulation check
-      if (product?.price && product?.originalPrice) {
-        const realDiscount = (1 - product.price / product.originalPrice) * 100;
-        if (product.discount && Math.abs(product.discount - realDiscount) > 5) {
-          warnings.push({ type: 'price_manipulation', severity: 'high', detail: `Claimed discount (${product.discount}%) doesn't match actual (${Math.round(realDiscount)}%)` });
-          riskScore += 30;
-        }
+      // Trust level assessment
+      const trustLevel = context.trustLevel || context.trust_level || 'unknown';
+      if (trustLevel === 'unknown' || trustLevel === 'emerging') {
+        risks.push({
+          category: 'trust',
+          severity: trustLevel === 'unknown' ? 'high' : 'medium',
+          description: `Site has ${trustLevel} trust level`,
+          mitigation: 'Verify site reputation before providing sensitive data',
+        });
+        riskScore += trustLevel === 'unknown' ? 30 : 15;
       }
 
-      // Reputation check
-      if (reputationData) {
-        if (reputationData.trustLevel === 'emerging') {
-          warnings.push({ type: 'low_trust', severity: 'medium', detail: 'Site has low trust level' });
-          riskScore += 15;
-        }
-        if (reputationData.attestationCount < 3) {
-          warnings.push({ type: 'few_attestations', severity: 'low', detail: 'Limited reputation data' });
-          riskScore += 10;
-        }
-        if (reputationData.trustLevel === 'verified' || reputationData.trustLevel === 'exemplary') {
-          approvals.push('trusted_site');
+      // Schema field sensitivity check
+      if (schema && schema.actions) {
+        for (const action of schema.actions) {
+          if (!Array.isArray(action.fields)) continue;
+          for (const field of action.fields) {
+            const name = (field.name || field.label || '').toLowerCase();
+            if (/password|credit.?card|cvv|ssn|social.?security/i.test(name)) {
+              risks.push({
+                category: 'data_sensitivity',
+                severity: 'high',
+                description: `Sensitive field detected: ${field.name || field.label}`,
+                mitigation: 'Ensure HTTPS and validate site certificate',
+              });
+              riskScore += 25;
+            } else if (/email|phone|address|zip|birth/i.test(name)) {
+              risks.push({
+                category: 'data_sensitivity',
+                severity: 'medium',
+                description: `PII field detected: ${field.name || field.label}`,
+                mitigation: 'Review privacy policy before sharing',
+              });
+              riskScore += 10;
+            }
+          }
         }
       }
 
-      // Negotiation terms safety
-      if (negotiationTerms?.target_price && product?.price) {
-        if (negotiationTerms.target_price < product.price * 0.3) {
-          warnings.push({ type: 'unrealistic_price', severity: 'medium', detail: 'Target price seems unrealistically low' });
-          riskScore += 10;
+      // URL safety
+      if (context.url) {
+        const urlLower = context.url.toLowerCase();
+        if (!urlLower.startsWith('https://')) {
+          risks.push({
+            category: 'connection_security',
+            severity: 'high',
+            description: 'Connection is not encrypted (no HTTPS)',
+            mitigation: 'Avoid entering sensitive data on insecure connections',
+          });
+          riskScore += 30;
         }
       }
 
-      // Data quality check
-      if (siteData) {
-        if (!siteData.policies?.returns) {
-          warnings.push({ type: 'no_return_policy', severity: 'medium', detail: 'No return policy found' });
-          riskScore += 10;
-        }
-        if (!siteData.policies?.privacy) {
-          warnings.push({ type: 'no_privacy_policy', severity: 'low', detail: 'No privacy policy found' });
-          riskScore += 5;
+      // Price anomaly check
+      if (priorOutputs.negotiate) {
+        const neg = priorOutputs.negotiate;
+        if (neg.originalPrice && neg.marketEstimate) {
+          const priceDelta = Math.abs(neg.originalPrice - neg.marketEstimate.estimatedFairValue) / neg.originalPrice;
+          if (priceDelta > 0.4) {
+            risks.push({
+              category: 'price_anomaly',
+              severity: 'medium',
+              description: `Price deviates ${Math.round(priceDelta * 100)}% from estimated fair value`,
+              mitigation: 'Cross-reference price with other sources',
+            });
+            riskScore += 15;
+          }
         }
       }
 
-      const safe = riskScore < 40;
-      if (safe) approvals.push('risk_acceptable');
+      riskScore = Math.min(100, riskScore);
+      const verdict = riskScore > 50 ? 'block' : riskScore > 25 ? 'caution' : 'safe';
 
       return {
-        safe,
-        riskScore: Math.min(100, riskScore),
-        warnings,
-        approvals,
-        confidence: warnings.length === 0 ? 0.9 : Math.max(0.3, 0.9 - warnings.length * 0.1),
-        reasoning: `Risk score: ${riskScore}/100, ${warnings.length} warnings, ${approvals.length} approvals`,
+        riskScore,
+        verdict,
+        risks,
+        riskCount: risks.length,
+        trustLevel,
+        recommendation: verdict === 'block'
+          ? 'Do not proceed — significant risks detected'
+          : verdict === 'caution'
+            ? 'Proceed with caution — review risks'
+            : 'Safe to proceed',
       };
     },
   },
 };
 
-// ─── Core API ────────────────────────────────────────────────────────
+// ─── Synthesis Engine ────────────────────────────────────────────────
 
-/**
- * Compose a new symphony — select template and assign roles.
- */
-function compose(siteId, task, taskType, agentIds = {}) {
-  const template = stmts.getTemplateByType.get(taskType) || stmts.getTemplateByType.get('exploration');
-  if (!template) throw new Error(`No template for task type: ${taskType}`);
-
-  const roles = JSON.parse(template.roles);
-  const id = crypto.randomUUID();
-  stmts.insertComposition.run(id, siteId, task, taskType);
-
-  // Assign roles
-  const roleAssignments = [];
-  for (const role of roles) {
-    const roleId = crypto.randomUUID();
-    const agentId = agentIds[role] || null;
-    stmts.insertRole.run(roleId, id, role, agentId);
-    roleAssignments.push({ id: roleId, role, agentId });
-  }
-
-  return {
-    compositionId: id,
-    template: template.name,
-    roles: roleAssignments,
-    phases: JSON.parse(template.phase_order),
-    status: 'composing',
+function _synthesize(phaseOutputs, context) {
+  const synthesis = {
+    summary: {},
+    recommendation: 'proceed',
+    confidence: 0,
+    factors: [],
   };
-}
 
-/**
- * Execute a single phase of the symphony.
- */
-function executePhase(compositionId, phaseName, phaseInput = {}) {
-  const comp = stmts.getComposition.get(compositionId);
-  if (!comp) throw new Error('Composition not found');
-
-  const roles = stmts.getRoles.all(compositionId);
-  const phasesCompleted = JSON.parse(comp.phases_completed || '[]');
-
-  // Determine which role handles this phase
-  const phaseRoleMap = {
-    discover: 'researcher',
-    analyze: 'analyst',
-    negotiate: 'negotiator',
-    guard: 'guardian',
-  };
+  // Merge research
+  if (phaseOutputs.research) {
+    synthesis.summary.dataQuality = phaseOutputs.research.dataQuality;
+    synthesis.summary.sourcesFound = phaseOutputs.research.sourcesCount || 0;
+    synthesis.summary.findingsCount = phaseOutputs.research.findingsCount || 0;
+  }
 
-  const roleName = phaseRoleMap[phaseName];
-  if (!roleName) {
-    // 'decide' phase — run consensus
-    return _runConsensus(compositionId, roles);
+  // Merge analysis
+  if (phaseOutputs.analyze) {
+    const analysis = phaseOutputs.analyze;
+    synthesis.summary.topPick = analysis.topPick?.item || null;
+    synthesis.summary.topScore = analysis.topPick?.score || 0;
+    synthesis.summary.itemsEvaluated = analysis.itemsEvaluated || 0;
+    synthesis.summary.preferencesApplied = analysis.preferencesApplied || false;
+    synthesis.factors.push({
+      factor: 'analysis',
+      impact: analysis.topPick?.score > 0.7 ? 'positive' : 'neutral',
+      detail: `Top pick scored ${analysis.topPick?.score || 0}`,
+    });
   }
 
-  const role = roles.find((r) => r.role === roleName);
-  if (!role) {
-    return { phase: phaseName, skipped: true, reason: `No ${roleName} assigned` };
+  // Merge negotiation
+  if (phaseOutputs.negotiate) {
+    const neg = phaseOutputs.negotiate;
+    synthesis.summary.originalPrice = neg.originalPrice;
+    synthesis.summary.targetPrice = neg.targetPrice;
+    synthesis.summary.maxSavings = neg.maxPotentialSavings;
+    synthesis.summary.withinBudget = neg.withinBudget;
+    synthesis.summary.tacticsAvailable = neg.tactics?.length || 0;
+    synthesis.factors.push({
+      factor: 'negotiation',
+      impact: neg.recommendation === 'negotiate' ? 'opportunity' : neg.recommendation === 'proceed' ? 'positive' : 'negative',
+      detail: `${neg.recommendation} — potential savings $${neg.maxPotentialSavings || 0}`,
+    });
   }
 
-  // Gather input from previous phases
-  const previousOutputs = {};
-  for (const r of roles) {
-    if (r.output && r.output !== '{}') {
-      previousOutputs[r.role] = JSON.parse(r.output);
+  // Merge guardian
+  if (phaseOutputs.guard) {
+    const guard = phaseOutputs.guard;
+    synthesis.summary.riskScore = guard.riskScore;
+    synthesis.summary.risks = guard.riskCount;
+    synthesis.summary.securityVerdict = guard.verdict;
+    synthesis.factors.push({
+      factor: 'security',
+      impact: guard.verdict === 'safe' ? 'positive' : guard.verdict === 'caution' ? 'neutral' : 'negative',
+      detail: `Risk score ${guard.riskScore}/100 — ${guard.verdict}`,
+    });
+
+    // Guardian can override recommendation
+    if (guard.verdict === 'block') {
+      synthesis.recommendation = 'block';
     }
   }
 
-  const fullInput = { ...previousOutputs, ...phaseInput };
+  // Confidence: average of positive/neutral factor count ratio
+  const pos = synthesis.factors.filter((f) => f.impact === 'positive' || f.impact === 'opportunity').length;
+  synthesis.confidence = synthesis.factors.length > 0
+    ? Math.round((pos / synthesis.factors.length) * 1000) / 1000
+    : 0.5;
 
-  // Execute the role engine
-  const engine = RoleEngines[roleName];
-  if (!engine) throw new Error(`No engine for role: ${roleName}`);
+  if (synthesis.recommendation !== 'block') {
+    synthesis.recommendation = synthesis.confidence >= 0.5 ? 'proceed' : 'reconsider';
+  }
 
-  const output = engine.execute(fullInput);
+  return synthesis;
+}
 
-  // Save role result
-  stmts.updateRole.run(
-    'completed', JSON.stringify(fullInput), JSON.stringify(output),
-    output.reasoning || '', output.confidence || 0,
-    new Date().toISOString(), role.id
-  );
+// ─── Phase To Role Mapping ───────────────────────────────────────────
 
-  // Update composition
-  phasesCompleted.push(phaseName);
-  stmts.updateComposition.run(
-    'executing', phaseName, JSON.stringify(phasesCompleted),
-    null, 0, 0, null, compositionId
-  );
+const PHASE_ROLE_MAP = {
+  analyze: 'analyst',
+  research: 'researcher',
+  negotiate: 'negotiator',
+  guard: 'guardian',
+  synthesize: null, // Handled by _synthesize
+};
 
-  return { phase: phaseName, role: roleName, output, phasesCompleted };
-}
+// ─── Orchestration ───────────────────────────────────────────────────
 
 /**
- * Execute the entire symphony end-to-end.
+ * Execute a full symphony composition.
+ *
+ * @param {string} siteId - Site identifier
+ * @param {string} templateName - Template to use
+ * @param {object} inputData - User-provided context (cloned to prevent mutation)
+ * @param {object} [schema] - Site WAB schema
+ * @returns {{ compositionId, status, result, phaseLogs, durationMs }}
  */
-function perform(siteId, task, taskType, inputData = {}, agentIds = {}) {
-  const startTime = Date.now();
-  const composition = compose(siteId, task, taskType, agentIds);
+function perform(siteId, templateName, inputData = {}, schema = null) {
+  const template = TEMPLATES[templateName];
+  if (!template) {
+    throw new Error(`Unknown template: ${templateName}. Available: ${Object.keys(TEMPLATES).join(', ')}`);
+  }
 
-  // Get template phase order
-  const template = stmts.getTemplateByType.get(taskType);
-  const phases = template ? JSON.parse(template.phase_order) : ['discover', 'decide'];
+  const compositionId = crypto.randomUUID();
+  const startTime = Date.now();
 
-  const phaseResults = {};
+  // Clone inputData to prevent mutation of caller's object
+  const context = JSON.parse(JSON.stringify(inputData));
+  context.siteId = siteId;
 
-  // Execute phases sequentially, piping outputs
-  for (const phase of phases) {
-    const phaseInput = { ...inputData };
+  stmts.insertComposition.run(
+    compositionId, siteId, templateName,
+    JSON.stringify(context), 'running',
+    template.phases[0], template.roles.length
+  );
 
-    // Pipe previous phase outputs
-    for (const [prevPhase, prevResult] of Object.entries(phaseResults)) {
-      if (prevResult.output) {
-        Object.assign(phaseInput, prevResult.output);
+  const phaseOutputs = {};
+  const phaseLogs = [];
+  const completedPhases = [];
+
+  try {
+    for (const phase of template.phases) {
+      const phaseStart = Date.now();
+
+      stmts.updatePhase.run(phase, JSON.stringify(completedPhases), compositionId);
+
+      let output;
+      if (phase === 'synthesize') {
+        output = _synthesize(phaseOutputs, context);
+      } else {
+        const roleName = PHASE_ROLE_MAP[phase];
+        const engine = ROLE_ENGINES[roleName];
+        if (!engine) {
+          output = { skipped: true, reason: `No engine for role: ${roleName}` };
+        } else {
+          output = engine.execute(schema, context, phaseOutputs);
+        }
       }
-    }
-
-    const result = executePhase(composition.compositionId, phase, phaseInput);
-    phaseResults[phase] = result;
-  }
 
-  const duration = Date.now() - startTime;
+      phaseOutputs[phase] = output;
+      completedPhases.push(phase);
+
+      const phaseDuration = Date.now() - phaseStart;
+      const logId = crypto.randomUUID();
+      stmts.insertPhaseLog.run(
+        logId, compositionId, phase, PHASE_ROLE_MAP[phase] || 'orchestrator',
+        JSON.stringify(phase === 'synthesize' ? {} : context),
+        JSON.stringify(output), phaseDuration
+      );
+      phaseLogs.push({ phase, role: PHASE_ROLE_MAP[phase] || 'orchestrator', output, durationMs: phaseDuration });
+    }
 
-  // Get final decision
-  const consensus = stmts.getConsensus.get(composition.compositionId);
-  const finalDecision = consensus ? JSON.parse(consensus.result) : phaseResults;
+    const durationMs = Date.now() - startTime;
+    const finalResult = phaseOutputs.synthesize || phaseOutputs[completedPhases[completedPhases.length - 1]];
 
-  // Calculate overall confidence
-  const roleOutputs = Object.values(phaseResults).filter((r) => r.output?.confidence);
-  const avgConfidence = roleOutputs.length > 0
-    ? roleOutputs.reduce((s, r) => s + r.output.confidence, 0) / roleOutputs.length
-    : 0;
+    stmts.updateComposition.run(
+      'completed', JSON.stringify(completedPhases), null,
+      JSON.stringify(finalResult), null, durationMs, compositionId
+    );
 
-  // Finalize composition
-  stmts.updateComposition.run(
-    'completed', 'decide', JSON.stringify(Object.keys(phaseResults)),
-    JSON.stringify(finalDecision), avgConfidence, duration,
-    new Date().toISOString(), composition.compositionId
-  );
+    // Record decision to learning engine for future improvements
+    _recordToLearning(siteId, templateName, context, finalResult);
 
-  return {
-    compositionId: composition.compositionId,
-    template: composition.template,
-    phases: phaseResults,
-    decision: finalDecision,
-    confidence: avgConfidence,
-    duration_ms: duration,
-    status: 'completed',
-  };
-}
+    return { compositionId, status: 'completed', result: finalResult, phaseLogs, durationMs };
 
-// ─── Consensus Engine ────────────────────────────────────────────────
-
-function _runConsensus(compositionId, roles) {
-  const completedRoles = roles.filter((r) => r.output && r.output !== '{}');
-  const votes = {};
-  let totalConfidence = 0;
-
-  for (const role of completedRoles) {
-    const output = JSON.parse(role.output);
-    votes[role.role] = {
-      confidence: output.confidence || 0,
-      recommendation: output.recommendation || output.strategies?.[0] || null,
-      reasoning: output.reasoning || '',
-      safe: output.safe !== undefined ? output.safe : true,
-      riskScore: output.riskScore || 0,
-    };
-    totalConfidence += output.confidence || 0;
+  } catch (err) {
+    const durationMs = Date.now() - startTime;
+    stmts.updateComposition.run(
+      'failed', JSON.stringify(completedPhases), null,
+      null, err.message, durationMs, compositionId
+    );
+    return { compositionId, status: 'failed', error: err.message, phaseLogs, durationMs };
   }
+}
 
-  // Weighted consensus
-  const result = {
-    recommendation: null,
-    reasoning: [],
-    overallConfidence: completedRoles.length > 0 ? totalConfidence / completedRoles.length : 0,
-    safe: true,
-    participatingRoles: completedRoles.map((r) => r.role),
-  };
-
-  // Guardian veto check
-  if (votes.guardian && !votes.guardian.safe) {
-    result.safe = false;
-    result.recommendation = { action: 'abort', reason: 'Guardian flagged safety concerns', riskScore: votes.guardian.riskScore };
-    result.reasoning.push(`GUARDIAN VETO: ${votes.guardian.reasoning}`);
-  } else {
-    // Take analyst recommendation if available, otherwise researcher findings
-    if (votes.analyst?.recommendation) {
-      result.recommendation = votes.analyst.recommendation;
-      result.reasoning.push(`Analyst: ${votes.analyst.reasoning}`);
-    }
-    if (votes.negotiator) {
-      result.negotiation = votes.negotiator;
-      result.reasoning.push(`Negotiator: ${votes.negotiator.reasoning}`);
-    }
-    if (votes.researcher) {
-      result.reasoning.push(`Researcher: ${votes.researcher.reasoning}`);
-    }
-    if (votes.guardian) {
-      result.reasoning.push(`Guardian: ${votes.guardian.reasoning}`);
-    }
+/**
+ * Record composition result to the learning engine so future runs improve.
+ */
+function _recordToLearning(siteId, templateName, context, result) {
+  try {
+    const learning = require('./agent-learning');
+    const domain = context.domain || templateName;
+    const action = result?.recommendation || 'unknown';
+
+    learning.recordDecision(siteId, 'symphony', domain, action, {
+      template: templateName,
+      confidence: result?.confidence,
+      riskScore: result?.summary?.riskScore,
+      topScore: result?.summary?.topScore,
+    });
+  } catch (_) {
+    // Learning engine unavailable — silently continue
   }
-
-  const consensusId = crypto.randomUUID();
-  const agreementScore = _calculateAgreement(votes);
-
-  stmts.insertConsensus.run(
-    consensusId, compositionId, JSON.stringify(votes),
-    'weighted', JSON.stringify(result), agreementScore
-  );
-
-  return {
-    phase: 'decide',
-    consensus: result,
-    votes,
-    agreementScore,
-  };
 }
 
-function _calculateAgreement(votes) {
-  const confidences = Object.values(votes).map((v) => v.confidence);
-  if (confidences.length < 2) return 1.0;
+// ─── Query API ───────────────────────────────────────────────────────
 
-  // Agreement = inverse of confidence variance
-  const mean = confidences.reduce((s, c) => s + c, 0) / confidences.length;
-  const variance = confidences.reduce((s, c) => s + (c - mean) ** 2, 0) / confidences.length;
-  return Math.max(0, 1 - variance);
+function getComposition(id) {
+  const row = stmts.getComposition.get(id);
+  if (!row) return null;
+  return _deserializeComposition(row);
 }
 
-// ─── Query API ───────────────────────────────────────────────────────
+function getCompositions(siteId, limit = 20) {
+  return stmts.getCompositions.all(siteId, limit).map(_deserializeComposition);
+}
 
-function getComposition(compositionId) {
-  const comp = stmts.getComposition.get(compositionId);
-  if (!comp) return null;
-  const roles = stmts.getRoles.all(compositionId);
-  const consensus = stmts.getConsensus.get(compositionId);
-  return {
-    ...comp,
-    phases_completed: JSON.parse(comp.phases_completed || '[]'),
-    final_decision: comp.final_decision ? JSON.parse(comp.final_decision) : null,
-    roles: roles.map((r) => ({ ...r, input: JSON.parse(r.input || '{}'), output: JSON.parse(r.output || '{}') })),
-    consensus: consensus ? { ...consensus, votes: JSON.parse(consensus.votes), result: JSON.parse(consensus.result) } : null,
-  };
+function getCompositionsByTemplate(siteId, template, limit = 10) {
+  return stmts.getRecentByTemplate.all(siteId, template, limit).map(_deserializeComposition);
 }
 
-function getCompositions(siteId, limit = 20) {
-  return stmts.getCompositionsBySite.all(siteId, limit).map((c) => ({
-    ...c,
-    phases_completed: JSON.parse(c.phases_completed || '[]'),
-    final_decision: c.final_decision ? JSON.parse(c.final_decision) : null,
+function getPhaseLogs(compositionId) {
+  const rows = stmts.getPhaseLogs.all(compositionId);
+  return rows.map((r) => ({
+    ...r,
+    input: JSON.parse(r.input || '{}'),
+    output: JSON.parse(r.output || '{}'),
   }));
 }
 
 function getTemplates() {
-  return stmts.getAllTemplates.all().map((t) => ({
-    ...t, roles: JSON.parse(t.roles), phase_order: JSON.parse(t.phase_order),
-  }));
+  return TEMPLATES;
 }
 
 function getStats(siteId) {
-  return stmts.getStats.get(siteId, siteId, siteId, siteId);
+  const row = stmts.getStats.get(siteId);
+  return {
+    total: row.total || 0,
+    completed: row.completed || 0,
+    failed: row.failed || 0,
+    successRate: row.total > 0 ? Math.round(((row.completed || 0) / row.total) * 1000) / 1000 : 0,
+    avgDuration: row.avg_duration ? Math.round(row.avg_duration) : 0,
+    templatesUsed: row.templates_used || 0,
+  };
+}
+
+function _deserializeComposition(row) {
+  return {
+    ...row,
+    input_data: JSON.parse(row.input_data || '{}'),
+    phases_completed: JSON.parse(row.phases_completed || '[]'),
+    result: row.result ? JSON.parse(row.result) : null,
+  };
 }
 
 module.exports = {
-  compose, executePhase, perform,
-  getComposition, getCompositions, getTemplates, getStats,
-  RoleEngines,
+  perform, getComposition, getCompositions, getCompositionsByTemplate,
+  getPhaseLogs, getTemplates, getStats,
 };