@a-company/paradigm 5.10.0 → 5.21.0

package/dist/chunk-YRZ5RPEB.js

@@ -1,1561 +0,0 @@
-#!/usr/bin/env node
-import {
-  suggestAgentsForTask
-} from "./chunk-6QC3YGB6.js";
-import {
-  AgentSpawner,
-  extractSymbols
-} from "./chunk-45MUDW6E.js";
-import {
-  loadAgentsManifest
-} from "./chunk-PMXRGPRQ.js";
-import {
-  AuditLogger
-} from "./chunk-PBHIFAL4.js";
-import {
-  calculateCost
-} from "./chunk-5JGJACDU.js";
-import {
-  buildSymbolIndex,
-  getReferencesTo,
-  searchSymbols
-} from "./chunk-ZGUAAVMA.js";
-import {
-  extractDeclaredGates,
-  loadPortalConfig
-} from "./chunk-YMDLDELF.js";
-
-// src/core/orchestrator.ts
-import { minimatch } from "minimatch";
-
-// src/core/task-classifier.ts
-var ANALYSIS_KEYWORDS = [
-  "should",
-  "what",
-  "how",
-  "why",
-  "recommend",
-  "analyze",
-  "compare",
-  "evaluate",
-  "assess",
-  "review",
-  "explain",
-  "describe",
-  "investigate",
-  "which",
-  "best practice",
-  "trade-off",
-  "tradeoff",
-  "pros and cons",
-  "decision"
-];
-var DOCUMENTATION_KEYWORDS = [
-  "document",
-  "write docs",
-  "readme",
-  ".purpose",
-  "purpose file",
-  "jsdoc",
-  "tsdoc",
-  "comments",
-  "docstring",
-  "api docs",
-  "changelog",
-  "architecture doc"
-];
-var BUGFIX_KEYWORDS = [
-  "bug",
-  "fix",
-  "broken",
-  "not working",
-  "issue",
-  "error",
-  "crash",
-  "fails",
-  "failing",
-  "wrong",
-  "incorrect",
-  "doesn't work",
-  "doesn't",
-  "cant",
-  "can't",
-  "regression",
-  "patch"
-];
-var REFACTOR_KEYWORDS = [
-  "rename",
-  "refactor",
-  "migrate",
-  "restructure",
-  "move",
-  "reorganize",
-  "clean up",
-  "cleanup",
-  "consolidate",
-  "extract",
-  "inline",
-  "simplify",
-  "modularize",
-  "decouple",
-  "split",
-  "merge"
-];
-var SECURITY_KEYWORDS = [
-  "auth",
-  "authentication",
-  "authorization",
-  "permission",
-  "admin",
-  "delete",
-  "purge",
-  "password",
-  "credential",
-  "token",
-  "secret",
-  "key",
-  "encrypt",
-  "decrypt",
-  "hash",
-  "session",
-  "oauth",
-  "jwt",
-  "api key",
-  "role",
-  "access",
-  "gate",
-  "portal",
-  "sensitive",
-  "private",
-  "security",
-  "vulnerability",
-  "xss",
-  "sql injection",
-  "csrf"
-];
-var SYMBOL_PATTERN = /[@#$%^!?&~][a-zA-Z0-9_-]+/g;
-var TASK_AGENT_MAPPING = {
-  analysis: {
-    agents: ["architect"],
-    models: { architect: "opus" },
-    costMultiplier: { min: 0.3, max: 0.5 }
-  },
-  documentation: {
-    agents: ["architect"],
-    models: { architect: "sonnet" },
-    costMultiplier: { min: 0.25, max: 0.45 }
-  },
-  bugfix: {
-    agents: ["security", "builder"],
-    models: { security: "opus", builder: "haiku" },
-    costMultiplier: { min: 0.5, max: 0.8 }
-  },
-  refactor: {
-    agents: ["architect", "builder"],
-    models: { architect: "opus", builder: "haiku" },
-    costMultiplier: { min: 0.6, max: 0.85 }
-  },
-  feature: {
-    agents: ["architect", "security", "builder", "tester"],
-    models: { architect: "opus", security: "opus", builder: "haiku", tester: "haiku" },
-    costMultiplier: { min: 0.8, max: 1.2 }
-  }
-};
-function extractSymbols2(text) {
-  const matches = text.match(SYMBOL_PATTERN) || [];
-  return [...new Set(matches)];
-}
-function matchesKeywords(text, keywords) {
-  const textLower = text.toLowerCase();
-  return keywords.filter((keyword) => textLower.includes(keyword.toLowerCase()));
-}
-function determineComplexity(task, type, symbols, context) {
-  let score = 0;
-  if (symbols.length >= 5) score += 2;
-  else if (symbols.length >= 2) score += 1;
-  const wordCount = task.split(/\s+/).length;
-  if (wordCount >= 100) score += 2;
-  else if (wordCount >= 50) score += 1;
-  const prefixes = new Set(symbols.map((s) => s[0]));
-  if (prefixes.size >= 4) score += 2;
-  else if (prefixes.size >= 2) score += 1;
-  if (symbols.some((s) => s.startsWith("^"))) score += 1;
-  if (symbols.some((s) => s.startsWith("$"))) score += 1;
-  if (type === "feature") score += 1;
-  if (type === "refactor") score += 1;
-  if (context?.affectedFiles && context.affectedFiles.length > 10) score += 2;
-  else if (context?.affectedFiles && context.affectedFiles.length > 5) score += 1;
-  if (score >= 5) return "high";
-  if (score >= 2) return "medium";
-  return "low";
-}
-function shouldInvolveSecurity(task, symbols, context) {
-  const securityMatches = matchesKeywords(task, SECURITY_KEYWORDS);
-  if (securityMatches.length > 0) return true;
-  if (symbols.some((s) => s.startsWith("^"))) return true;
-  if (context?.affectedFiles) {
-    const sensitivePathPatterns = [
-      /auth/i,
-      /middleware/i,
-      /security/i,
-      /gate/i,
-      /permission/i,
-      /admin/i
-    ];
-    for (const file of context.affectedFiles) {
-      if (sensitivePathPatterns.some((pattern) => pattern.test(file))) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function classifyTask(task, context) {
-  const symbols = extractSymbols2(task);
-  const analysisMatches = matchesKeywords(task, ANALYSIS_KEYWORDS);
-  const documentationMatches = matchesKeywords(task, DOCUMENTATION_KEYWORDS);
-  const bugfixMatches = matchesKeywords(task, BUGFIX_KEYWORDS);
-  const refactorMatches = matchesKeywords(task, REFACTOR_KEYWORDS);
-  let type;
-  let matchedKeywords;
-  if (analysisMatches.length > 0 && bugfixMatches.length === 0 && refactorMatches.length === 0) {
-    type = "analysis";
-    matchedKeywords = analysisMatches;
-  } else if (documentationMatches.length > 0 && bugfixMatches.length === 0) {
-    type = "documentation";
-    matchedKeywords = documentationMatches;
-  } else if (bugfixMatches.length > 0) {
-    type = "bugfix";
-    matchedKeywords = bugfixMatches;
-  } else if (refactorMatches.length > 0) {
-    type = "refactor";
-    matchedKeywords = refactorMatches;
-  } else {
-    type = "feature";
-    matchedKeywords = [];
-  }
-  const mapping = TASK_AGENT_MAPPING[type];
-  const securityRequired = shouldInvolveSecurity(task, symbols, context);
-  let recommendedAgents = [...mapping.agents];
-  if (securityRequired && !recommendedAgents.includes("security")) {
-    recommendedAgents = ["security", ...recommendedAgents];
-  }
-  const complexity = determineComplexity(task, type, symbols, context);
-  let costMultiplier = { ...mapping.costMultiplier };
-  if (complexity === "high") {
-    costMultiplier.min *= 1.2;
-    costMultiplier.max *= 1.3;
-  } else if (complexity === "low") {
-    costMultiplier.min *= 0.8;
-    costMultiplier.max *= 0.9;
-  }
-  if (securityRequired && !mapping.agents.includes("security")) {
-    costMultiplier.min += 0.15;
-    costMultiplier.max += 0.2;
-  }
-  return {
-    type,
-    complexity,
-    recommendedAgents,
-    securityRequired,
-    costMultiplier,
-    matchedKeywords,
-    symbols
-  };
-}
-function getRecommendedModel(agentName, classification) {
-  const mapping = TASK_AGENT_MAPPING[classification.type];
-  if (agentName === "security" && classification.securityRequired) {
-    return "opus";
-  }
-  return mapping.models[agentName] || "sonnet";
-}
-
-// src/core/pm-compliance.ts
-import * as fs from "fs";
-import * as path from "path";
-var SYMBOL_PATTERN2 = /[@#$%^!?&~][a-zA-Z][a-zA-Z0-9_-]*/g;
-var ROUTE_PATTERNS = [
-  // Express/Fastify
-  /\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
-  // SvelteKit
-  /export\s+(async\s+)?function\s+(GET|POST|PUT|PATCH|DELETE)/gi,
-  // Next.js
-  /export\s+(async\s+)?function\s+(GET|POST|PUT|PATCH|DELETE)/gi,
-  // Hono
-  /\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/gi
-];
-var ROUTE_KEYWORDS = [
-  "endpoint",
-  "route",
-  "api",
-  "handler",
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete",
-  "rest",
-  "crud",
-  "controller"
-];
-function runPreflight(task, rootDir, index) {
-  const taskLower = task.toLowerCase();
-  const symbolMatches = task.match(SYMBOL_PATTERN2) || [];
-  const uniqueSymbols = [...new Set(symbolMatches)];
-  const affectedSymbols = uniqueSymbols.map((sym) => {
-    const results = searchSymbols(index, sym);
-    const found = results.length > 0 ? results[0] : null;
-    return {
-      symbol: sym,
-      exists: !!found,
-      type: found?.type,
-      description: found?.description
-    };
-  });
-  const rippleAnalysis = affectedSymbols.filter((s) => s.exists).map((s) => {
-    const directDeps = getReferencesTo(index, s.symbol);
-    const indirectSet = /* @__PURE__ */ new Set();
-    for (const dep of directDeps) {
-      const indirect = getReferencesTo(index, dep.symbol);
-      for (const ind of indirect) {
-        if (ind.symbol !== s.symbol && !directDeps.find((d) => d.symbol === ind.symbol)) {
-          indirectSet.add(ind.symbol);
-        }
-      }
-    }
-    const total = directDeps.length + indirectSet.size;
-    let impact = "low";
-    if (total > 10) impact = "high";
-    else if (total > 3) impact = "medium";
-    return {
-      symbol: s.symbol,
-      directDependents: directDeps.length,
-      indirectDependents: indirectSet.size,
-      impact
-    };
-  });
-  const portalConfig = loadPortalConfig(rootDir);
-  const portalStatus = {
-    exists: !!portalConfig,
-    gateCount: portalConfig ? extractDeclaredGates(portalConfig).length : 0,
-    gates: portalConfig ? extractDeclaredGates(portalConfig).map((g) => `^${g}`) : [],
-    routeCount: portalConfig?.routes ? Object.keys(portalConfig.routes).length : 0
-  };
-  const taskAddsRoutes = ROUTE_KEYWORDS.some((k) => taskLower.includes(k));
-  const manifest = loadAgentsManifest(rootDir);
-  const suggestedAgents = manifest ? suggestAgentsForTask(task, manifest.agents).map((s) => ({
-    name: s.name,
-    confidence: s.confidence,
-    reason: s.reason
-  })) : [];
-  const requiredChecks = [];
-  if (affectedSymbols.some((s) => s.exists)) {
-    requiredChecks.push("ripple-analysis");
-  }
-  if (taskAddsRoutes) {
-    requiredChecks.push("portal-compliance");
-  }
-  if (uniqueSymbols.some((s) => s.startsWith("^"))) {
-    requiredChecks.push("gate-validation");
-  }
-  if (uniqueSymbols.some((s) => s.startsWith("!"))) {
-    requiredChecks.push("signal-registration");
-  }
-  requiredChecks.push("purpose-coverage");
-  return {
-    affectedSymbols,
-    rippleAnalysis,
-    portalStatus,
-    taskAddsRoutes,
-    suggestedAgents,
-    requiredChecks
-  };
-}
-function runPostflight(filesModified, symbolsTouched, rootDir, index) {
-  const violations = [];
-  const portalConfig = loadPortalConfig(rootDir);
-  const declaredGates = portalConfig ? extractDeclaredGates(portalConfig) : [];
-  const declaredRoutes = portalConfig?.routes ? Object.keys(portalConfig.routes) : [];
-  for (const file of filesModified) {
-    const absPath = path.isAbsolute(file) ? file : path.join(rootDir, file);
-    if (!fs.existsSync(absPath)) continue;
-    let content;
-    try {
-      content = fs.readFileSync(absPath, "utf-8");
-    } catch {
-      continue;
-    }
-    for (const pattern of ROUTE_PATTERNS) {
-      pattern.lastIndex = 0;
-      let match;
-      while ((match = pattern.exec(content)) !== null) {
-        const routePath = match[2] || match[0];
-        if (routePath && routePath.startsWith("/")) {
-          const isKnown = declaredRoutes.some((r) => {
-            const normalizedDeclared = r.replace(/\s+(GET|POST|PUT|PATCH|DELETE)\s*$/, "").trim();
-            return normalizedDeclared === routePath;
-          });
-          if (!isKnown && portalConfig) {
-            violations.push({
-              type: "missing-portal-gate",
-              severity: "warning",
-              message: `Route "${routePath}" found in ${path.relative(rootDir, absPath)} but not declared in portal.yaml`,
-              file: path.relative(rootDir, absPath),
-              suggestion: `Add this route to portal.yaml with appropriate ^gates. Run paradigm_gates_for_route to get suggestions.`
-            });
-          } else if (!portalConfig && routePath.startsWith("/api/")) {
-            violations.push({
-              type: "missing-portal-gate",
-              severity: "warning",
-              message: `API route "${routePath}" found but no portal.yaml exists`,
-              file: path.relative(rootDir, absPath),
-              suggestion: `Create portal.yaml to declare gates for API routes. Run: paradigm portal init`
-            });
-          }
-        }
-      }
-    }
-  }
-  for (const symbol of symbolsTouched) {
-    const results = searchSymbols(index, symbol);
-    if (results.length === 0) {
-      violations.push({
-        type: "unregistered-symbol",
-        severity: "error",
-        message: `Symbol "${symbol}" was touched but is not registered in any .purpose file`,
-        suggestion: `Add "${symbol}" to the nearest .purpose file. Use paradigm_purpose_add_component or paradigm_purpose_add_signal.`
-      });
-    }
-  }
-  for (const symbol of symbolsTouched) {
-    if (symbol.startsWith("^")) {
-      const gateName = symbol.slice(1);
-      if (!declaredGates.includes(gateName)) {
-        violations.push({
-          type: "missing-portal-gate",
-          severity: "error",
-          message: `Gate "${symbol}" is referenced but not declared in portal.yaml`,
-          suggestion: `Add ${symbol} to portal.yaml with description and check expression.`
-        });
-      }
-    }
-  }
-  if (filesModified.length >= 5 && symbolsTouched.length >= 3) {
-    violations.push({
-      type: "uncaptured-wisdom",
-      severity: "warning",
-      message: `Large change (${filesModified.length} files, ${symbolsTouched.length} symbols) \u2014 consider recording architectural decisions`,
-      suggestion: `Use paradigm_wisdom_record to capture any decisions or antipatterns discovered during this task.`
-    });
-  }
-  const errors = violations.filter((v) => v.severity === "error").length;
-  const warnings = violations.filter((v) => v.severity === "warning").length;
-  const totalChecks = 4;
-  let status = "pass";
-  if (errors > 0) status = "violations";
-  else if (warnings > 0) status = "warnings";
-  return {
-    status,
-    violations,
-    summary: {
-      totalChecks,
-      passed: totalChecks - (errors > 0 ? 1 : 0) - (warnings > 0 ? 1 : 0),
-      warnings,
-      errors
-    },
-    blocksCompletion: errors > 0
-  };
-}
-
-// src/core/orchestrator.ts
-var DEFAULT_AGENT_MODELS = {
-  architect: "opus",
-  security: "opus",
-  reviewer: "sonnet",
-  builder: "haiku",
-  tester: "haiku"
-};
-var SECURITY_ESCALATION_KEYWORDS = [
-  "auth",
-  "permission",
-  "admin",
-  "delete",
-  "purge",
-  "password",
-  "credential",
-  "token",
-  "secret",
-  "key",
-  "encrypt",
-  "decrypt",
-  "hash",
-  "session",
-  "oauth",
-  "jwt",
-  "role",
-  "access control",
-  "vulnerability",
-  "injection",
-  "xss",
-  "csrf"
-];
-var SECURITY_ESCALATION_PATHS = [
-  "**/auth/**",
-  "**/middleware/**",
-  "**/security/**",
-  "**/gates/**",
-  "**/guards/**",
-  "**/policies/**",
-  "**/permissions/**",
-  "**/admin/**"
-];
-function shouldEscalateSecurity(task, affectedFiles) {
-  const taskLower = task.toLowerCase();
-  const hasKeyword = SECURITY_ESCALATION_KEYWORDS.some(
-    (k) => taskLower.includes(k.toLowerCase())
-  );
-  const hasGateSymbol = task.includes("^");
-  let hasSensitivePath = false;
-  if (affectedFiles) {
-    hasSensitivePath = affectedFiles.some(
-      (file) => SECURITY_ESCALATION_PATHS.some((pattern) => minimatch(file, pattern))
-    );
-  }
-  return hasKeyword || hasGateSymbol || hasSensitivePath;
-}
-var REFACTOR_KEYWORDS2 = ["rename", "refactor", "migrate", "restructure", "move", "reorganize"];
-function isRefactoringTask(task) {
-  const taskLower = task.toLowerCase();
-  return REFACTOR_KEYWORDS2.some((k) => taskLower.includes(k));
-}
-var Orchestrator = class {
-  spawner;
-  auditLogger;
-  rootDir;
-  constructor(rootDir) {
-    this.rootDir = rootDir;
-    this.spawner = new AgentSpawner(rootDir);
-    this.auditLogger = new AuditLogger(rootDir);
-  }
-  /**
-   * Initialize the orchestrator
-   */
-  async initialize() {
-    await this.spawner.initialize();
-  }
-  /**
-   * Orchestrate a task
-   */
-  async orchestrate(task, options = {}) {
-    const mode = options.mode || "faceted";
-    const startTime = Date.now();
-    const orchestrationId = this.generateOrchestrationId();
-    const result = {
-      success: false,
-      mode,
-      orchestrationId,
-      task,
-      agentsSpawned: 0,
-      totalTokens: { input: 0, output: 0, total: 0 },
-      totalCost: 0,
-      duration_ms: 0,
-      agentResults: []
-    };
-    try {
-      let preflightResult;
-      if (options.pmGovernance?.enabled) {
-        try {
-          const { aggregateFromDirectory } = await import("./dist-34NA5RS5.js");
-          const aggregation = await aggregateFromDirectory(this.rootDir);
-          const index = buildSymbolIndex(aggregation);
-          preflightResult = runPreflight(task, this.rootDir, index);
-        } catch {
-        }
-      }
-      if (mode === "solo") {
-        const soloResult = await this.runSoloMode(task, options);
-        result.agentsSpawned = 1;
-        result.agentResults = [soloResult];
-        result.success = soloResult.success;
-        if (soloResult.relay) {
-          result.totalTokens = soloResult.relay.metrics.tokens_used;
-          result.totalCost = calculateCost(result.totalTokens, options.orchestratorModel || "opus");
-        }
-      } else {
-        const facetedResult = await this.runFacetedMode(task, options);
-        result.agentsSpawned = facetedResult.results.length;
-        result.agentResults = facetedResult.results;
-        result.totalTokens = facetedResult.totalTokens;
-        result.totalCost = facetedResult.totalCost;
-        result.success = facetedResult.success;
-        result.parallelBuilderStats = facetedResult.parallelBuilderStats;
-      }
-      if (options.pmGovernance?.enabled && preflightResult) {
-        try {
-          const { aggregateFromDirectory } = await import("./dist-34NA5RS5.js");
-          const aggregation = await aggregateFromDirectory(this.rootDir);
-          const index = buildSymbolIndex(aggregation);
-          const filesModified = [];
-          const symbolsTouched = [];
-          for (const agentResult of result.agentResults) {
-            if (agentResult.relay?.outputs?.artifacts) {
-              filesModified.push(...agentResult.relay.outputs.artifacts.map((a) => a.path));
-            }
-          }
-          for (const sym of preflightResult.affectedSymbols) {
-            symbolsTouched.push(sym.symbol);
-          }
-          const postflightResult = runPostflight(filesModified, symbolsTouched, this.rootDir, index);
-          result.complianceReport = {
-            preflight: preflightResult,
-            postflight: postflightResult
-          };
-          if (options.pmGovernance.blockOnViolations && postflightResult.blocksCompletion) {
-            result.success = false;
-          }
-        } catch {
-          result.complianceReport = { preflight: preflightResult };
-        }
-      }
-      result.duration_ms = Date.now() - startTime;
-      const log = this.auditLogger.startOrchestration(orchestrationId, task, mode);
-      log.completed = (/* @__PURE__ */ new Date()).toISOString();
-      log.status = result.success ? "success" : "failed";
-      log.totals = {
-        duration_ms: result.duration_ms,
-        tokens: result.totalTokens.total,
-        cost_usd: result.totalCost,
-        agents_spawned: result.agentsSpawned,
-        files_created: 0,
-        files_modified: 0
-      };
-      this.auditLogger.saveOrchestration(log);
-      result.log = log;
-      return result;
-    } catch (error) {
-      result.error = error instanceof Error ? error.message : String(error);
-      result.duration_ms = Date.now() - startTime;
-      return result;
-    }
-  }
-  /**
-   * Compare solo vs faceted mode for A/B testing
-   */
-  async compare(task, options = {}) {
-    const soloResult = await this.orchestrate(task, { ...options, mode: "solo" });
-    const facetedResult = await this.orchestrate(task, { ...options, mode: "faceted" });
-    const tokensSaved = soloResult.totalTokens.total - facetedResult.totalTokens.total;
-    const costDiff = soloResult.totalCost - facetedResult.totalCost;
-    const timeDiff = soloResult.duration_ms - facetedResult.duration_ms;
-    let winner = "tie";
-    if (facetedResult.success && !soloResult.success) {
-      winner = "faceted";
-    } else if (soloResult.success && !facetedResult.success) {
-      winner = "solo";
-    } else if (facetedResult.totalCost < soloResult.totalCost * 0.8) {
-      winner = "faceted";
-    } else if (soloResult.totalCost < facetedResult.totalCost * 0.8) {
-      winner = "solo";
-    }
-    return {
-      solo: soloResult,
-      faceted: facetedResult,
-      comparison: {
-        winner,
-        tokensSaved,
-        costDiff,
-        timeDiff,
-        soloSucceeded: soloResult.success,
-        facetedSucceeded: facetedResult.success
-      }
-    };
-  }
-  // ==========================================================================
-  // Private: Solo Mode
-  // ==========================================================================
-  async runSoloMode(task, options) {
-    const manifest = loadAgentsManifest(this.rootDir);
-    const agentName = manifest?.team.default_agent || "architect";
-    const model = options.orchestratorModel || "opus";
-    const spawnerOptions = {
-      model,
-      workingDirectory: options.workingDirectory || this.rootDir,
-      mcpServerPath: options.mcpServerPath,
-      budget: options.budget,
-      onMessage: options.onMessage ? (msg) => options.onMessage("solo", msg) : void 0,
-      onCheckpoint: options.onCheckpoint
-    };
-    if (options.onAgentStart) {
-      options.onAgentStart("solo", task, model);
-    }
-    const result = await this.spawner.spawn(agentName, task, spawnerOptions);
-    if (options.onAgentComplete) {
-      options.onAgentComplete("solo", result, model);
-    }
-    return result;
-  }
-  // ==========================================================================
-  // Private: Faceted Mode
-  // ==========================================================================
-  async runFacetedMode(task, options) {
-    const manifest = loadAgentsManifest(this.rootDir);
-    if (!manifest) {
-      return {
-        success: false,
-        results: [],
-        totalTokens: { input: 0, output: 0, total: 0 },
-        totalCost: 0
-      };
-    }
-    let rippleContext = "";
-    if (isRefactoringTask(task)) {
-      const symbols = extractSymbols(task);
-      if (symbols.length > 0) {
-        const rippleResults = [];
-        rippleResults.push("## Auto-Ripple Analysis\n");
-        rippleResults.push("The following symbols are affected by this refactoring:");
-        rippleResults.push("");
-        for (const symbol of symbols.slice(0, 5)) {
-          rippleResults.push(`- **${symbol}**: Check dependencies before renaming/moving`);
-        }
-        rippleResults.push("");
-        rippleResults.push("**Recommendation:** Run `paradigm_ripple` for each symbol before making changes.");
-        rippleContext = rippleResults.join("\n");
-      }
-    }
-    const agentPlan = this.planAgentSequence(task, manifest.agents);
-    const stages = this.groupByStage(agentPlan);
-    const results = [];
-    let totalTokens = { input: 0, output: 0, total: 0 };
-    let totalCost = 0;
-    let handoffContexts = /* @__PURE__ */ new Map();
-    let success = true;
-    let parallelBuilderStats;
-    const sortedStages = Array.from(stages.keys()).sort((a, b) => a - b);
-    for (const stageNum of sortedStages) {
-      const stageAgents = stages.get(stageNum) || [];
-      if (stageAgents.length === 0) continue;
-      if (options.checkpoints?.beforeAgentSpawn && options.onCheckpoint) {
-        const agentNames = stageAgents.map((s) => s.agent).join(", ");
-        const approved = await options.onCheckpoint(
-          `Stage ${stageNum}: Spawn ${agentNames}${stageAgents.length > 1 ? " (parallel)" : ""}`
-        );
-        if (!approved) {
-          success = false;
-          break;
-        }
-      }
-      const spawnPromises = stageAgents.map(async (step) => {
-        const model = options.agentBudgets?.[step.agent]?.maxTokens ? "haiku" : step.model || DEFAULT_AGENT_MODELS[step.agent] || "sonnet";
-        let handoffContext = "";
-        if (step.dependsOn.length > 0) {
-          const contexts = step.dependsOn.map((dep) => handoffContexts.get(dep)).filter(Boolean);
-          if (contexts.length > 0) {
-            handoffContext = contexts.join("\n\n---\n\n");
-          }
-        }
-        let additionalContext = handoffContext;
-        if (step.agent === "architect" && rippleContext) {
-          additionalContext = rippleContext + (handoffContext ? "\n\n---\n\n" + handoffContext : "");
-        }
-        const taskWithContext = additionalContext ? `${step.subtask}
-
-## Context from previous agents:
-${additionalContext}` : step.subtask;
-        const spawnerOptions = {
-          model,
-          workingDirectory: options.workingDirectory || this.rootDir,
-          mcpServerPath: options.mcpServerPath,
-          budget: options.agentBudgets?.[step.agent] || options.budget,
-          onMessage: options.onMessage ? (msg) => options.onMessage(step.agent, msg) : void 0,
-          onCheckpoint: options.onCheckpoint
-        };
-        if (options.onAgentStart) {
-          options.onAgentStart(step.agent, step.subtask, model);
-        }
-        const result = await this.spawner.spawn(step.agent, taskWithContext, spawnerOptions);
-        if (options.onAgentComplete) {
-          options.onAgentComplete(step.agent, result, model);
-        }
-        return { step, result, model };
-      });
-      const stageResults = await Promise.all(spawnPromises);
-      for (const { step, result, model } of stageResults) {
-        results.push(result);
-        if (result.relay) {
-          totalTokens.input += result.relay.metrics.tokens_used.input;
-          totalTokens.output += result.relay.metrics.tokens_used.output;
-          totalTokens.total += result.relay.metrics.tokens_used.total;
-          totalCost += calculateCost(result.relay.metrics.tokens_used, model);
-          const context = result.relay.handoff?.context || `${step.agent} completed: ${result.relay.outputs.decisions.join(", ") || "task done"}`;
-          handoffContexts.set(step.agent, context);
-          if (step.agent === "architect" && result.relay) {
-            const filePlan = this.extractFilePlanFromRelay(result);
-            if (filePlan && filePlan.length > 0) {
-              const builderPlan = this.planBuilderStages(filePlan);
-              if (builderPlan.hasFilePlan && builderPlan.totalBuilders > 1) {
-                const parallelResult = await this.runParallelBuilders(
-                  builderPlan,
-                  handoffContexts.get("architect") || "",
-                  options
-                );
-                results.push(...parallelResult.results);
-                totalTokens.input += parallelResult.totalTokens.input;
-                totalTokens.output += parallelResult.totalTokens.output;
-                totalTokens.total += parallelResult.totalTokens.total;
-                totalCost += parallelResult.totalCost;
-                if (!parallelResult.success) {
-                  success = false;
-                }
-                parallelBuilderStats = {
-                  usedFilePlan: true,
-                  totalSubPhases: builderPlan.stages.length,
-                  totalParallelBuilders: builderPlan.totalBuilders,
-                  filesCreated: builderPlan.totalFiles
-                };
-                for (const [stageKey, stageValue] of stages) {
-                  const filtered = stageValue.filter((s) => s.agent !== "builder");
-                  stages.set(stageKey, filtered);
-                }
-              }
-            }
-          }
-        }
-        if (!result.success && step.required) {
-          success = false;
-        }
-      }
-      if (!success) break;
-      if (options.checkpoints?.afterAgentComplete && options.onCheckpoint) {
-        const approved = await options.onCheckpoint(
-          `Stage ${stageNum} completed. Continue to next stage?`
-        );
-        if (!approved) {
-          break;
-        }
-      }
-    }
-    return { success, results, totalTokens, totalCost, parallelBuilderStats };
-  }
-  /**
-   * Extract file plan from architect's relay result
-   */
-  extractFilePlanFromRelay(result) {
-    if (!result.relay) return void 0;
-    const handoffContext = result.relay.handoff?.context || "";
-    if (handoffContext.includes("filePlan:")) {
-      return this.parseFilePlanFromText(handoffContext);
-    }
-    return void 0;
-  }
-  /**
-   * Parse file plan from text (simplified YAML parsing)
-   */
-  parseFilePlanFromText(text) {
-    const filePlan = [];
-    const filePlanMatch = text.match(/filePlan:\s*\n([\s\S]*?)(?=\n[a-z_]+:|$)/);
-    if (!filePlanMatch) {
-      return void 0;
-    }
-    const filePlanContent = filePlanMatch[1];
-    const lines = filePlanContent.split("\n");
-    let currentGroup = null;
-    let inFiles = false;
-    let currentFile = {};
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      if (trimmed.startsWith("- group:")) {
-        if (currentGroup) {
-          if (currentFile.path) {
-            currentGroup.files.push({
-              path: currentFile.path,
-              description: currentFile.description || ""
-            });
-            currentFile = {};
-          }
-          filePlan.push(currentGroup);
-        }
-        currentGroup = {
-          group: trimmed.split(":")[1].trim(),
-          subPhase: 0,
-          files: []
-        };
-        inFiles = false;
-        continue;
-      }
-      if (!currentGroup) continue;
-      if (trimmed.startsWith("subPhase:")) {
-        currentGroup.subPhase = parseInt(trimmed.split(":")[1].trim(), 10) || 0;
-        continue;
-      }
-      if (trimmed === "files:") {
-        inFiles = true;
-        continue;
-      }
-      if (inFiles) {
-        if (trimmed.startsWith("- path:")) {
-          if (currentFile.path) {
-            currentGroup.files.push({
-              path: currentFile.path,
-              description: currentFile.description || ""
-            });
-          }
-          currentFile = {
-            path: trimmed.split(":").slice(1).join(":").trim().replace(/^["']|["']$/g, "")
-          };
-          continue;
-        }
-        if (trimmed.startsWith("description:")) {
-          currentFile.description = trimmed.split(":").slice(1).join(":").trim().replace(/^["']|["']$/g, "");
-          continue;
-        }
-      }
-    }
-    if (currentFile.path && currentGroup) {
-      currentGroup.files.push({
-        path: currentFile.path,
-        description: currentFile.description || ""
-      });
-    }
-    if (currentGroup) {
-      filePlan.push(currentGroup);
-    }
-    return filePlan.length > 0 ? filePlan : void 0;
-  }
-  // ==========================================================================
-  // Private: Agent Planning
-  // ==========================================================================
-  /**
-   * Plan agent sequence with parallel execution support
-   *
-   * Returns execution stages where agents within a stage can run in parallel,
-   * but stages execute sequentially (stage N+1 waits for stage N to complete).
-   *
-   * Uses task classification for intelligent agent selection:
-   * - Analysis tasks: Architect only
-   * - Documentation tasks: Architect only
-   * - Bug fixes: Security + Builder
-   * - Refactoring: Architect + Builder (with auto-ripple)
-   * - Features: Full team as needed
-   */
-  planAgentSequence(task, agents) {
-    const symbols = extractSymbols(task);
-    const taskLower = task.toLowerCase();
-    const classification = classifyTask(task);
-    const plan = [];
-    const securityEscalated = shouldEscalateSecurity(task);
-    if (classification.type === "analysis") {
-      if (agents["architect"]) {
-        plan.push({
-          agent: "architect",
-          subtask: `Analyze and recommend: ${task}`,
-          required: true,
-          stage: 0,
-          dependsOn: [],
-          model: "opus"
-        });
-      }
-      return plan;
-    }
-    if (classification.type === "documentation") {
-      if (agents["architect"]) {
-        plan.push({
-          agent: "architect",
-          subtask: `Document: ${task}`,
-          required: true,
-          stage: 0,
-          dependsOn: [],
-          model: "sonnet"
-          // Sonnet is sufficient for documentation
-        });
-      }
-      return plan;
-    }
-    const hasDesign = taskLower.includes("design") || taskLower.includes("architect") || taskLower.includes("plan") || taskLower.includes("spec");
-    const hasSecurity = securityEscalated || taskLower.includes("auth") || taskLower.includes("security") || taskLower.includes("gate") || symbols.some((s) => s.startsWith("^"));
-    if (hasDesign && agents["architect"]) {
-      plan.push({
-        agent: "architect",
-        subtask: `Design and specify: ${task}`,
-        required: true,
-        stage: 0,
-        dependsOn: [],
-        model: "opus"
-      });
-    }
-    if (hasSecurity && agents["security"]) {
-      plan.push({
-        agent: "security",
-        subtask: `Review security aspects of: ${task}`,
-        // Security is REQUIRED when escalated, optional otherwise
-        required: securityEscalated,
-        stage: 0,
-        // Can run parallel with architect
-        dependsOn: [],
-        // Use opus for escalated security reviews
-        model: securityEscalated ? "opus" : "opus"
-      });
-    }
-    const hasImplementation = taskLower.includes("build") || taskLower.includes("implement") || taskLower.includes("create") || taskLower.includes("add") || taskLower.includes("fix");
-    if (hasImplementation && agents["builder"]) {
-      const dependsOn = hasDesign && agents["architect"] ? ["architect"] : [];
-      plan.push({
-        agent: "builder",
-        subtask: `Implement: ${task}`,
-        required: true,
-        stage: dependsOn.length > 0 ? 1 : 0,
-        dependsOn,
-        model: "haiku"
-      });
-    }
-    const hasReview = taskLower.includes("review") || taskLower.includes("check");
-    const hasTest = taskLower.includes("test") || taskLower.includes("verify") || taskLower.includes("validate");
-    const builderInPlan = plan.some((p) => p.agent === "builder");
-    const reviewStage = builderInPlan ? 2 : hasDesign ? 1 : 0;
-    if (hasReview && agents["reviewer"]) {
-      plan.push({
-        agent: "reviewer",
-        subtask: `Review: ${task}`,
-        required: false,
-        stage: reviewStage,
-        dependsOn: builderInPlan ? ["builder"] : [],
-        model: "sonnet"
-      });
-    }
-    if (hasTest && agents["tester"]) {
-      plan.push({
-        agent: "tester",
-        subtask: `Test and validate: ${task}`,
-        required: false,
-        stage: reviewStage,
-        // Can run parallel with reviewer
-        dependsOn: builderInPlan ? ["builder"] : [],
-        model: "haiku"
-      });
-    }
-    if (plan.length === 0) {
-      const recommendedAgents = classification.recommendedAgents;
-      if (recommendedAgents.includes("architect") && agents["architect"]) {
-        plan.push({
-          agent: "architect",
-          subtask: `Design: ${task}`,
-          required: true,
-          stage: 0,
-          dependsOn: [],
-          model: getRecommendedModel("architect", classification)
-        });
-      }
-      if ((recommendedAgents.includes("security") || securityEscalated) && agents["security"]) {
-        plan.push({
-          agent: "security",
-          subtask: `Security review: ${task}`,
-          required: securityEscalated,
-          stage: 0,
-          dependsOn: [],
-          model: "opus"
-        });
-      }
-      if (recommendedAgents.includes("builder") && agents["builder"]) {
-        const hasPreviousStage = plan.length > 0;
-        plan.push({
-          agent: "builder",
-          subtask: `Implement: ${task}`,
-          required: true,
-          stage: hasPreviousStage ? 1 : 0,
-          dependsOn: plan.filter((p) => p.stage === 0).map((p) => p.agent),
-          model: getRecommendedModel("builder", classification)
-        });
-      }
-      if (recommendedAgents.includes("tester") && agents["tester"]) {
-        const builderStage = plan.find((p) => p.agent === "builder")?.stage ?? 0;
-        plan.push({
-          agent: "tester",
-          subtask: `Test: ${task}`,
-          required: false,
-          stage: builderStage + 1,
-          dependsOn: agents["builder"] ? ["builder"] : [],
-          model: getRecommendedModel("tester", classification)
-        });
-      }
-    }
-    return plan.sort((a, b) => a.stage - b.stage);
-  }
-  /**
-   * Group plan steps by stage for parallel execution
-   */
-  groupByStage(plan) {
-    const stages = /* @__PURE__ */ new Map();
-    for (const step of plan) {
-      const existing = stages.get(step.stage) || [];
-      existing.push({ agent: step.agent, subtask: step.subtask, required: step.required, dependsOn: step.dependsOn });
-      stages.set(step.stage, existing);
-    }
-    return stages;
-  }
-  // ==========================================================================
-  // Private: Utilities
-  // ==========================================================================
-  generateOrchestrationId() {
-    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const random = Math.random().toString(36).substring(2, 8);
-    return `orch-${date}-${random}`;
-  }
-  // ==========================================================================
-  // Private: Parallel Builder Planning
-  // ==========================================================================
-  /**
-   * Plan parallel builder stages from architect's file plan
-   */
-  planBuilderStages(filePlan) {
-    if (!filePlan || filePlan.length === 0) {
-      return {
-        hasFilePlan: false,
-        stages: [{
-          subPhase: 0,
-          builders: [{
-            agent: "builder",
-            group: "all",
-            files: [],
-            availableFiles: []
-          }]
-        }],
-        totalFiles: 0,
-        totalBuilders: 1
-      };
-    }
-    const subPhases = /* @__PURE__ */ new Map();
-    for (const group of filePlan) {
-      const existing = subPhases.get(group.subPhase) || [];
-      existing.push(group);
-      subPhases.set(group.subPhase, existing);
-    }
-    const stages = [];
-    const sortedPhases = [...subPhases.keys()].sort((a, b) => a - b);
-    let availableFiles = [];
-    let totalBuilders = 0;
-    let totalFiles = 0;
-    for (const phase of sortedPhases) {
-      const groups = subPhases.get(phase);
-      const builders = [];
-      for (let i = 0; i < groups.length; i++) {
-        const group = groups[i];
-        totalFiles += group.files.length;
-        totalBuilders++;
-        builders.push({
-          agent: `builder-${phase}-${i}`,
-          group: group.group,
-          files: group.files,
-          availableFiles: [...availableFiles]
-        });
-      }
-      stages.push({
-        subPhase: phase,
-        builders
-      });
-      for (const group of groups) {
-        for (const file of group.files) {
-          availableFiles.push(file.path);
-        }
-      }
-    }
-    return {
-      hasFilePlan: true,
-      stages,
-      totalFiles,
-      totalBuilders
-    };
-  }
-  /**
-   * Build narrowed prompt for a parallel builder
-   */
-  buildParallelBuilderPrompt(assignedFiles, availableFiles, architectContext, groupName) {
-    const parts = [];
-    parts.push(`You are a BUILDER agent responsible for implementing the **${groupName}** group.`);
-    parts.push("");
-    parts.push("## Your Assignment");
-    parts.push("");
-    parts.push("### Files to Create:");
-    for (const file of assignedFiles) {
-      parts.push(`- \`${file.path}\`: ${file.description}`);
-    }
-    parts.push("");
-    if (availableFiles.length > 0) {
-      parts.push("### Available Files (already created):");
-      parts.push("These files exist and you can import from them:");
-      for (const file of availableFiles) {
-        parts.push(`- \`${file}\``);
-      }
-      parts.push("");
-    }
-    if (architectContext) {
-      parts.push("### Context from Architect:");
-      parts.push(architectContext);
-      parts.push("");
-    }
-    parts.push("### Instructions:");
-    parts.push("1. Create ONLY the files assigned to you");
-    parts.push("2. You can import from available files (already created)");
-    parts.push("3. Follow existing patterns in the codebase");
-    parts.push("4. Use the Paradigm logger (not console.log)");
-    parts.push("5. End with the standard Agent Relay block");
-    return parts.join("\n");
-  }
-  /**
-   * Execute parallel builder stages
-   * Sub-phases execute sequentially, builders within each sub-phase execute in parallel
-   */
-  async runParallelBuilders(builderPlan, architectContext, options) {
-    const results = [];
-    let totalTokens = { input: 0, output: 0, total: 0 };
-    let totalCost = 0;
-    let success = true;
-    for (const stage of builderPlan.stages) {
-      if (options.checkpoints?.beforeAgentSpawn && options.onCheckpoint) {
-        const builderNames = stage.builders.map((b) => b.group).join(", ");
-        const approved = await options.onCheckpoint(
-          `Builder Sub-phase ${stage.subPhase}: ${builderNames}${stage.builders.length > 1 ? " (parallel)" : ""}`
-        );
-        if (!approved) {
-          success = false;
-          break;
-        }
-      }
-      const spawnPromises = stage.builders.map(async (builder) => {
-        const taskPrompt = this.buildParallelBuilderPrompt(
-          builder.files,
-          builder.availableFiles,
-          architectContext,
-          builder.group
-        );
-        const spawnerOptions = {
-          model: "haiku",
-          // Builders always use haiku
-          workingDirectory: options.workingDirectory || this.rootDir,
-          mcpServerPath: options.mcpServerPath,
-          budget: options.budget,
-          onMessage: options.onMessage ? (msg) => options.onMessage(builder.agent, msg) : void 0,
-          onCheckpoint: options.onCheckpoint
-        };
-        if (options.onAgentStart) {
-          options.onAgentStart(builder.agent, `Implement ${builder.group}`, "haiku");
-        }
-        const result = await this.spawner.spawn("builder", taskPrompt, spawnerOptions);
-        if (options.onAgentComplete) {
-          options.onAgentComplete(builder.agent, result, "haiku");
-        }
-        return { builder, result };
-      });
-      const stageResults = await Promise.all(spawnPromises);
-      for (const { result } of stageResults) {
-        results.push(result);
-        if (result.relay) {
-          totalTokens.input += result.relay.metrics.tokens_used.input;
-          totalTokens.output += result.relay.metrics.tokens_used.output;
-          totalTokens.total += result.relay.metrics.tokens_used.total;
-          totalCost += calculateCost(result.relay.metrics.tokens_used, "haiku");
-        }
-        if (!result.success) {
-          success = false;
-        }
-      }
-      if (!success) break;
-      if (options.checkpoints?.afterAgentComplete && options.onCheckpoint) {
-        const approved = await options.onCheckpoint(
-          `Sub-phase ${stage.subPhase} complete. Continue to next sub-phase?`
-        );
-        if (!approved) {
-          break;
-        }
-      }
-    }
-    return { success, results, totalTokens, totalCost };
-  }
-};
-
-// src/core/background-orchestrator.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as yaml from "js-yaml";
-import { spawn } from "child_process";
-var BackgroundOrchestrator = class {
-  rootDir;
-  orchestrationsDir;
-  constructor(rootDir) {
-    this.rootDir = rootDir;
-    this.orchestrationsDir = path2.join(rootDir, ".paradigm", "orchestrations");
-    this.ensureOrchestrationDir();
-  }
-  /**
-   * Start an orchestration in background mode
-   */
-  async startBackground(task, options = {}) {
-    const id = this.generateId();
-    const outputFile = path2.join(this.orchestrationsDir, `${id}.output`);
-    const logFile = path2.join(this.orchestrationsDir, `${id}.log`);
-    const orchestration = {
-      id,
-      task,
-      status: "pending",
-      mode: options.mode || "faceted",
-      created: (/* @__PURE__ */ new Date()).toISOString(),
-      outputFile,
-      logFile,
-      artifacts: []
-    };
-    this.saveOrchestration(orchestration);
-    this.spawnOrchestration(id, task, options);
-    return orchestration;
-  }
-  /**
-   * Get orchestration by ID
-   */
-  getOrchestration(id) {
-    const metaFile = path2.join(this.orchestrationsDir, `${id}.yaml`);
-    if (!fs2.existsSync(metaFile)) {
-      return null;
-    }
-    try {
-      const content = fs2.readFileSync(metaFile, "utf-8");
-      return yaml.load(content);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * List all orchestrations
-   */
-  listOrchestrations(options = {}) {
-    const files = fs2.readdirSync(this.orchestrationsDir).filter((f) => f.endsWith(".yaml") && !f.includes("output") && !f.includes("log")).sort().reverse();
-    const orchestrations = [];
-    for (const file of files) {
-      if (options.limit && orchestrations.length >= options.limit) break;
-      const metaFile = path2.join(this.orchestrationsDir, file);
-      try {
-        const content = fs2.readFileSync(metaFile, "utf-8");
-        const orch = yaml.load(content);
-        if (options.status) {
-          const statuses = Array.isArray(options.status) ? options.status : [options.status];
-          if (!statuses.includes(orch.status)) continue;
-        }
-        orchestrations.push(orch);
-      } catch {
-      }
-    }
-    return orchestrations;
-  }
-  /**
-   * Get running orchestrations
-   */
-  getRunning() {
-    return this.listOrchestrations({ status: "running" });
-  }
-  /**
-   * Get orchestration output (streaming)
-   */
-  getOutput(id, options = {}) {
-    const orch = this.getOrchestration(id);
-    if (!orch) return "";
-    if (!fs2.existsSync(orch.outputFile)) {
-      return "";
-    }
-    const content = fs2.readFileSync(orch.outputFile, "utf-8");
-    if (options.lines) {
-      const lines = content.split("\n");
-      return lines.slice(-options.lines).join("\n");
-    }
-    return content;
-  }
-  /**
-   * Accept orchestration changes
-   */
-  async accept(id, _options = {}) {
-    const orch = this.getOrchestration(id);
-    if (!orch) return false;
-    if (orch.status !== "completed") {
-      throw new Error(`Cannot accept orchestration in '${orch.status}' status`);
-    }
-    orch.status = "accepted";
-    this.saveOrchestration(orch);
-    return true;
-  }
-  /**
-   * Reject orchestration changes
-   */
-  async reject(id, options = {}) {
-    const orch = this.getOrchestration(id);
-    if (!orch) return false;
-    if (orch.status !== "completed") {
-      throw new Error(`Cannot reject orchestration in '${orch.status}' status`);
-    }
-    orch.status = "rejected";
-    orch.error = options.reason;
-    this.saveOrchestration(orch);
-    if (options.cleanup && orch.artifacts.length > 0) {
-      for (const artifact of orch.artifacts) {
-        if (artifact.action === "created") {
-          const filePath = path2.join(this.rootDir, artifact.path);
-          if (fs2.existsSync(filePath)) {
-            fs2.unlinkSync(filePath);
-          }
-        }
-      }
-    }
-    return true;
-  }
-  /**
-   * Get diff of orchestration changes
-   */
-  async getDiff(id) {
-    const orch = this.getOrchestration(id);
-    if (!orch) return "";
-    if (orch.artifacts.length === 0) {
-      return "No file changes in this orchestration.";
-    }
-    const diffParts = [];
-    diffParts.push(`Orchestration: ${id}`);
-    diffParts.push(`Task: ${orch.task}`);
-    diffParts.push(`Status: ${orch.status}`);
-    diffParts.push("");
-    diffParts.push("Files:");
-    for (const artifact of orch.artifacts) {
-      const icon = artifact.action === "created" ? "+" : artifact.action === "modified" ? "~" : "-";
-      diffParts.push(`  ${icon} ${artifact.path}`);
-    }
-    return diffParts.join("\n");
-  }
-  /**
-   * Mark orchestration as complete
-   */
-  markComplete(id, result) {
-    const orch = this.getOrchestration(id);
-    if (!orch) return;
-    orch.status = result.success ? "completed" : "failed";
-    orch.completed = (/* @__PURE__ */ new Date()).toISOString();
-    orch.result = result;
-    orch.parallelBuilderStats = result.parallelBuilderStats;
-    for (const agentResult of result.agentResults) {
-      if (agentResult.relay?.outputs.artifacts) {
-        for (const artifact of agentResult.relay.outputs.artifacts) {
-          orch.artifacts.push(artifact);
-        }
-      }
-    }
-    this.saveOrchestration(orch);
-  }
-  /**
-   * Send completion notification
-   */
-  async notify(id, methods = ["bell"]) {
-    const orch = this.getOrchestration(id);
-    if (!orch) return;
-    for (const method of methods) {
-      switch (method) {
-        case "bell":
-          process.stdout.write("\x07");
-          break;
-        case "desktop":
-          try {
-            if (process.platform === "darwin") {
-              spawn("osascript", [
-                "-e",
-                `display notification "Orchestration ${orch.status}: ${orch.task.slice(0, 50)}" with title "Paradigm"`
-              ]);
-            } else {
-              spawn("notify-send", [
-                "Paradigm",
-                `Orchestration ${orch.status}: ${orch.task.slice(0, 50)}`
-              ]);
-            }
-          } catch {
-          }
-          break;
-        case "file":
-          const statusFile = path2.join(this.orchestrationsDir, `${id}.status`);
-          fs2.writeFileSync(statusFile, JSON.stringify({
-            id,
-            status: orch.status,
-            completed: orch.completed,
-            task: orch.task
-          }));
-          break;
-        case "webhook":
-          break;
-      }
-    }
-  }
-  // ==========================================================================
-  // Private Methods
-  // ==========================================================================
-  ensureOrchestrationDir() {
-    if (!fs2.existsSync(this.orchestrationsDir)) {
-      fs2.mkdirSync(this.orchestrationsDir, { recursive: true });
-    }
-  }
-  generateId() {
-    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const time = Date.now().toString(36);
-    const random = Math.random().toString(36).substring(2, 6);
-    return `orch-${date}-${time}-${random}`;
-  }
-  saveOrchestration(orch) {
-    const metaFile = path2.join(this.orchestrationsDir, `${orch.id}.yaml`);
-    fs2.writeFileSync(metaFile, yaml.dump(orch));
-  }
-  spawnOrchestration(id, task, options) {
-    const orch = this.getOrchestration(id);
-    if (orch) {
-      orch.status = "running";
-      orch.started = (/* @__PURE__ */ new Date()).toISOString();
-      this.saveOrchestration(orch);
-    }
-    (async () => {
-      try {
-        const orchestrator = new Orchestrator(this.rootDir);
-        await orchestrator.initialize();
-        const outputStream = fs2.createWriteStream(orch.outputFile, { flags: "a" });
-        const result = await orchestrator.orchestrate(task, {
-          ...options,
-          onMessage: (source, message) => {
-            if (message.type === "text") {
-              outputStream.write(`[${source}] ${message.content}
-`);
-            }
-            options.onMessage?.(source, message);
-          },
-          onAgentStart: (agent, agentTask, model) => {
-            outputStream.write(`
-\u25B6 ${agent}: ${agentTask}
-`);
-            options.onAgentStart?.(agent, agentTask, model);
-          },
-          onAgentComplete: (agent, agentResult, model) => {
-            const status = agentResult.success ? "\u2713" : "\u2717";
-            outputStream.write(`${status} ${agent} completed
-`);
-            options.onAgentComplete?.(agent, agentResult, model);
-          }
-        });
-        outputStream.end();
-        this.markComplete(id, result);
-        if (options.notify) {
-          await this.notify(id, options.notifyMethods || ["bell"]);
-        }
-      } catch (error) {
-        const failedOrch = this.getOrchestration(id);
-        if (failedOrch) {
-          failedOrch.status = "failed";
-          failedOrch.error = error instanceof Error ? error.message : String(error);
-          failedOrch.completed = (/* @__PURE__ */ new Date()).toISOString();
-          this.saveOrchestration(failedOrch);
-        }
-      }
-    })();
-  }
-};
-
-export {
-  Orchestrator,
-  BackgroundOrchestrator
-};