@a-company/paradigm 5.10.0 → 5.21.0

package/dist/chunk-45MUDW6E.js

@@ -1,804 +0,0 @@
-#!/usr/bin/env node
-import {
-  loadAgentsManifest
-} from "./chunk-PMXRGPRQ.js";
-import {
-  AuditLogger
-} from "./chunk-PBHIFAL4.js";
-import {
-  getProvider,
-  initializeProviders
-} from "./chunk-TXESEO7Y.js";
-import {
-  calculateCost,
-  formatCost,
-  formatTokens
-} from "./chunk-5JGJACDU.js";
-
-// src/core/agent-spawner.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-import * as yaml3 from "js-yaml";
-
-// src/core/context-builder.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
-import { glob } from "glob";
-var SYMBOL_PATTERN = /[#$^!~][a-zA-Z0-9_-]+/g;
-function extractSymbols(text) {
-  const matches = text.match(SYMBOL_PATTERN) || [];
-  return [...new Set(matches)];
-}
-function getSymbolType(symbol) {
-  const prefix = symbol.charAt(0);
-  const types = {
-    "#": "component",
-    "$": "flow",
-    "^": "gate",
-    "!": "signal",
-    "~": "aspect"
-  };
-  return types[prefix] || "unknown";
-}
-async function buildAgentContext(agent, task, rootDir, facetConfig) {
-  const paradigmDir = path.join(rootDir, ".paradigm");
-  const taskSymbols = extractSymbols(task);
-  const contextConfig = getContextPatterns(agent, facetConfig);
-  const expandedInclude = expandPatterns(contextConfig.include || [], taskSymbols);
-  const exclude = contextConfig.exclude || [];
-  const files = await gatherFiles(rootDir, expandedInclude, exclude);
-  const systemPrompt = await buildRoleSpecificPrompt(agent, paradigmDir, taskSymbols);
-  return {
-    systemPrompt,
-    files,
-    symbols: taskSymbols
-  };
-}
-function getContextPatterns(agent, facetConfig) {
-  if (facetConfig?.contextInclude || facetConfig?.contextExclude) {
-    return {
-      include: facetConfig.contextInclude,
-      exclude: facetConfig.contextExclude
-    };
-  }
-  const defaults = {
-    architect: {
-      include: [
-        "specs/*.md",
-        ".purpose",
-        "**/.purpose",
-        "portal.yaml",
-        ".paradigm/config.yaml"
-      ],
-      exclude: [
-        "src/**",
-        "tests/**",
-        "node_modules/**",
-        "dist/**"
-      ]
-    },
-    builder: {
-      include: [
-        "src/**",
-        "tests/**",
-        "{feature}.purpose",
-        "specs/{feature}.md"
-      ],
-      exclude: [
-        "specs/*.md",
-        "node_modules/**",
-        "dist/**"
-      ]
-    },
-    reviewer: {
-      include: [
-        "src/**",
-        "specs/*.md",
-        "portal.yaml",
-        ".purpose"
-      ],
-      exclude: [
-        "tests/**",
-        "node_modules/**",
-        "dist/**"
-      ]
-    },
-    tester: {
-      include: [
-        "tests/**",
-        "health.yaml",
-        "{feature}.purpose"
-      ],
-      exclude: [
-        "src/**",
-        "specs/**",
-        "node_modules/**",
-        "dist/**"
-      ]
-    },
-    security: {
-      include: [
-        "portal.yaml",
-        "src/middleware/**",
-        "src/auth/**",
-        ".paradigm/wisdom/antipatterns.yaml"
-      ],
-      exclude: [
-        "src/routes/**",
-        "tests/**",
-        "node_modules/**",
-        "dist/**"
-      ]
-    }
-  };
-  return defaults[agent.name] || {
-    include: [".purpose", "portal.yaml"],
-    exclude: ["node_modules/**", "dist/**"]
-  };
-}
-function expandPatterns(patterns, symbols) {
-  const expanded = [];
-  for (const pattern of patterns) {
-    if (pattern.includes("{feature}") || pattern.includes("{symbol}")) {
-      for (const symbol of symbols) {
-        const name = symbol.substring(1);
-        expanded.push(
-          pattern.replace(/\{feature\}/g, name).replace(/\{symbol\}/g, name)
-        );
-      }
-    } else {
-      expanded.push(pattern);
-    }
-  }
-  return expanded;
-}
-async function gatherFiles(rootDir, include, exclude) {
-  const files = /* @__PURE__ */ new Set();
-  for (const pattern of include) {
-    try {
-      const matches = await glob(pattern, {
-        cwd: rootDir,
-        ignore: exclude,
-        nodir: true,
-        absolute: false
-      });
-      for (const match of matches) {
-        files.add(match);
-      }
-    } catch {
-    }
-  }
-  return Array.from(files);
-}
-async function buildRoleSpecificPrompt(agent, paradigmDir, symbols) {
-  const parts = [];
-  const configPath = path.join(paradigmDir, "config.yaml");
-  let config = null;
-  if (fs.existsSync(configPath)) {
-    try {
-      config = yaml.load(fs.readFileSync(configPath, "utf-8"));
-    } catch {
-    }
-  }
-  parts.push(`# ${agent.name.charAt(0).toUpperCase() + agent.name.slice(1)} Agent Context
-`);
-  if (config?.project) {
-    parts.push(`> Project: ${config.project}`);
-    if (config.discipline && config.discipline !== "auto") {
-      parts.push(`> Discipline: ${config.discipline}`);
-    }
-    parts.push("");
-  }
-  if (config?.["agent-guidelines"]?.overview) {
-    parts.push("## Project Overview\n");
-    parts.push(config["agent-guidelines"].overview);
-    parts.push("");
-  }
-  if (config?.["symbol-system"]) {
-    parts.push("## Symbol System\n");
-    parts.push("| Symbol | Meaning | Description |");
-    parts.push("|--------|---------|-------------|");
-    for (const [prefix, info] of Object.entries(config["symbol-system"])) {
-      parts.push(`| \`${prefix}\` | ${info.name} | ${info.description} |`);
-    }
-    parts.push("");
-  }
-  if (config?.conventions) {
-    const roleConventions = filterConventionsForRole(config.conventions, agent.name);
-    if (roleConventions.length > 0) {
-      parts.push("## Conventions\n");
-      for (const conv of roleConventions) {
-        parts.push(`- ${conv}`);
-      }
-      parts.push("");
-    }
-  }
-  if (symbols.length > 0) {
-    parts.push("## Symbols in Scope\n");
-    for (const symbol of symbols) {
-      const type = getSymbolType(symbol);
-      parts.push(`- \`${symbol}\` (${type})`);
-    }
-    parts.push("");
-  }
-  const tips = getRoleTips(agent.name);
-  if (tips.length > 0) {
-    parts.push("## Tips for This Role\n");
-    for (const tip of tips) {
-      parts.push(`- ${tip}`);
-    }
-    parts.push("");
-  }
-  return parts.join("\n");
-}
-function filterConventionsForRole(conventions, role) {
-  const roleKeywords = {
-    architect: ["design", "spec", "document", "flow", "symbol", "reference"],
-    builder: ["code", "implement", "component", "logger", "test"],
-    reviewer: ["review", "portal", "gate", "check", "validate"],
-    tester: ["test", "verify", "health", "validate"],
-    security: ["portal", "gate", "auth", "security", "vulnerability"]
-  };
-  const keywords = roleKeywords[role] || [];
-  return conventions.filter(
-    (conv) => keywords.some((kw) => conv.toLowerCase().includes(kw))
-  );
-}
-function getRoleTips(role) {
-  const tips = {
-    architect: [
-      "Focus on design decisions, not implementation details",
-      "Use paradigm symbols to reference features and components",
-      "Document flows that span 3+ components",
-      "Hand off to builder when spec is ready"
-    ],
-    builder: [
-      "Follow the spec from architect exactly",
-      "If spec is unclear, ask for clarification or hand back",
-      "Use the Paradigm logger, not raw console.log",
-      "Hand off to reviewer when implementation is ready"
-    ],
-    reviewer: [
-      "Check that all ^gate requirements are met",
-      "Verify adherence to specs",
-      "Do NOT implement fixes - hand back to builder",
-      "Approve or request changes with clear feedback"
-    ],
-    tester: [
-      "Run tests and verify health status",
-      "Check portal validations",
-      "Update health.yaml when verified",
-      "Report issues with reproduction steps"
-    ],
-    security: [
-      "Focus on ^gate implementations",
-      "Check for OWASP top 10 vulnerabilities",
-      "Flag issues but do NOT implement fixes",
-      "Review auth flows and session handling"
-    ]
-  };
-  return tips[role] || [];
-}
-
-// src/core/budget-tracker.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as yaml2 from "js-yaml";
-import { EventEmitter } from "events";
-var BudgetTracker = class extends EventEmitter {
-  config;
-  usage;
-  records = [];
-  configPath;
-  constructor(_rootDir) {
-    super();
-    this.configPath = path2.join(_rootDir, ".paradigm", "config.yaml");
-    this.config = this.loadConfig();
-    this.usage = this.initializeUsage();
-  }
-  // ==========================================================================
-  // Public API
-  // ==========================================================================
-  /**
-   * Check if a request is within budget
-   */
-  checkBudget(agent, requestedTokens) {
-    const estimatedCost = this.estimateCost(requestedTokens, "sonnet");
-    if (this.config.maxTokens) {
-      const projectedTokens = this.usage.tokens.total + requestedTokens;
-      if (projectedTokens > this.config.maxTokens) {
-        return {
-          allowed: false,
-          reason: `Global token limit exceeded: ${formatTokens(projectedTokens)} > ${formatTokens(this.config.maxTokens)}`,
-          usage: this.usage,
-          warningLevel: "exceeded"
-        };
-      }
-    }
-    if (this.config.maxCostUsd) {
-      const projectedCost = this.usage.cost + estimatedCost;
-      if (projectedCost > this.config.maxCostUsd) {
-        return {
-          allowed: false,
-          reason: `Cost ceiling exceeded: ${formatCost(projectedCost)} > ${formatCost(this.config.maxCostUsd)}`,
-          usage: this.usage,
-          warningLevel: "exceeded"
-        };
-      }
-    }
-    const agentLimit = this.config.agentLimits?.[agent];
-    if (agentLimit) {
-      const agentUsage = this.usage.byAgent[agent] || { tokens: { input: 0, output: 0, total: 0 }, cost: 0 };
-      if (agentLimit.maxTokens) {
-        const projectedAgentTokens = agentUsage.tokens.total + requestedTokens;
-        if (projectedAgentTokens > agentLimit.maxTokens) {
-          return {
-            allowed: false,
-            reason: `Agent '${agent}' token limit exceeded: ${formatTokens(projectedAgentTokens)} > ${formatTokens(agentLimit.maxTokens)}`,
-            usage: this.usage,
-            warningLevel: "exceeded"
-          };
-        }
-      }
-      if (agentLimit.maxCostUsd) {
-        const projectedAgentCost = agentUsage.cost + estimatedCost;
-        if (projectedAgentCost > agentLimit.maxCostUsd) {
-          return {
-            allowed: false,
-            reason: `Agent '${agent}' cost limit exceeded: ${formatCost(projectedAgentCost)} > ${formatCost(agentLimit.maxCostUsd)}`,
-            usage: this.usage,
-            warningLevel: "exceeded"
-          };
-        }
-      }
-    }
-    let warningLevel = "none";
-    if (this.config.warnAtPercent && this.config.maxTokens) {
-      const projectedTokens = this.usage.tokens.total + requestedTokens;
-      const percentage = projectedTokens / this.config.maxTokens * 100;
-      if (percentage >= this.config.warnAtPercent) {
-        warningLevel = "approaching";
-      }
-    }
-    return {
-      allowed: true,
-      usage: this.usage,
-      warningLevel
-    };
-  }
-  /**
-   * Record usage after an agent completes
-   */
-  recordUsage(agent, tokens, model, orchestrationId) {
-    const cost = calculateCost(tokens, model);
-    this.usage.tokens.input += tokens.input;
-    this.usage.tokens.output += tokens.output;
-    this.usage.tokens.total += tokens.total;
-    this.usage.cost += cost;
-    if (this.config.maxTokens) {
-      this.usage.percentage = this.usage.tokens.total / this.config.maxTokens * 100;
-    }
-    if (!this.usage.byAgent[agent]) {
-      this.usage.byAgent[agent] = {
-        tokens: { input: 0, output: 0, total: 0 },
-        cost: 0
-      };
-    }
-    this.usage.byAgent[agent].tokens.input += tokens.input;
-    this.usage.byAgent[agent].tokens.output += tokens.output;
-    this.usage.byAgent[agent].tokens.total += tokens.total;
-    this.usage.byAgent[agent].cost += cost;
-    const record = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      agent,
-      model,
-      tokens,
-      cost,
-      orchestrationId
-    };
-    this.records.push(record);
-    this.emit("usage", { agent, tokens, cost, total: this.usage });
-    if (this.config.warnAtPercent && this.usage.percentage >= this.config.warnAtPercent) {
-      this.emit("warning", {
-        type: "budget_approaching",
-        percentage: this.usage.percentage,
-        usage: this.usage
-      });
-    }
-  }
-  /**
-   * Get current usage
-   */
-  getUsage() {
-    return { ...this.usage };
-  }
-  /**
-   * Get usage records
-   */
-  getRecords() {
-    return [...this.records];
-  }
-  /**
-   * Get remaining budget
-   */
-  getRemaining() {
-    return {
-      tokens: this.config.maxTokens ? this.config.maxTokens - this.usage.tokens.total : null,
-      cost: this.config.maxCostUsd ? this.config.maxCostUsd - this.usage.cost : null
-    };
-  }
-  /**
-   * Reset usage (for new orchestration)
-   */
-  reset() {
-    this.usage = this.initializeUsage();
-    this.records = [];
-  }
-  /**
-   * Estimate cost for tokens
-   */
-  estimateCost(tokens, model) {
-    const usage = {
-      input: Math.floor(tokens / 2),
-      output: Math.ceil(tokens / 2),
-      total: tokens
-    };
-    return calculateCost(usage, model);
-  }
-  /**
-   * Estimate time for tokens (rough approximation)
-   */
-  estimateTime(tokens, model) {
-    const tps = {
-      opus: 50,
-      sonnet: 100,
-      haiku: 200
-    };
-    return Math.ceil(tokens / tps[model]) * 1e3;
-  }
-  /**
-   * Get summary for display
-   */
-  getSummary() {
-    const lines = [];
-    lines.push("Budget Summary:");
-    lines.push(`  Tokens: ${formatTokens(this.usage.tokens.total)}`);
-    lines.push(`  Cost: ${formatCost(this.usage.cost)}`);
-    if (this.config.maxTokens) {
-      lines.push(`  Token limit: ${formatTokens(this.config.maxTokens)} (${this.usage.percentage.toFixed(1)}% used)`);
-    }
-    if (this.config.maxCostUsd) {
-      const costPercent = this.usage.cost / this.config.maxCostUsd * 100;
-      lines.push(`  Cost limit: ${formatCost(this.config.maxCostUsd)} (${costPercent.toFixed(1)}% used)`);
-    }
-    if (Object.keys(this.usage.byAgent).length > 0) {
-      lines.push("  By agent:");
-      for (const [agent, agentUsage] of Object.entries(this.usage.byAgent)) {
-        lines.push(`    ${agent}: ${formatTokens(agentUsage.tokens.total)} (${formatCost(agentUsage.cost)})`);
-      }
-    }
-    return lines.join("\n");
-  }
-  // ==========================================================================
-  // Private Methods
-  // ==========================================================================
-  loadConfig() {
-    const defaultConfig = {
-      maxTokens: 5e5,
-      maxCostUsd: 5,
-      warnAtPercent: 80
-    };
-    if (!fs2.existsSync(this.configPath)) {
-      return defaultConfig;
-    }
-    try {
-      const content = fs2.readFileSync(this.configPath, "utf-8");
-      const config = yaml2.load(content);
-      const orchestration = config.orchestration;
-      if (orchestration?.budget) {
-        const budget = orchestration.budget;
-        return {
-          maxTokens: budget.max_tokens,
-          maxCostUsd: budget.max_cost_usd,
-          warnAtPercent: budget.warn_at_percent,
-          agentLimits: orchestration.agent_limits
-        };
-      }
-      return defaultConfig;
-    } catch {
-      return defaultConfig;
-    }
-  }
-  initializeUsage() {
-    return {
-      tokens: { input: 0, output: 0, total: 0 },
-      cost: 0,
-      percentage: 0,
-      byAgent: {}
-    };
-  }
-};
-
-// src/core/agent-spawner.ts
-var AgentSpawner = class {
-  provider = null;
-  budgetTracker = null;
-  auditLogger = null;
-  rootDir;
-  constructor(rootDir) {
-    this.rootDir = rootDir;
-  }
-  /**
-   * Initialize the spawner
-   */
-  async initialize() {
-    await initializeProviders();
-    this.provider = getProvider();
-    this.budgetTracker = new BudgetTracker(this.rootDir);
-    this.auditLogger = new AuditLogger(this.rootDir);
-  }
-  /**
-   * Check if spawner is ready
-   */
-  isReady() {
-    return this.provider !== null;
-  }
-  /**
-   * Get the current provider
-   */
-  getProvider() {
-    return this.provider;
-  }
-  /**
-   * Spawn a single agent
-   */
-  async spawn(agentName, task, options = {}) {
-    if (!this.provider) {
-      return {
-        success: false,
-        error: "Spawner not initialized",
-        sessionId: ""
-      };
-    }
-    const manifest = loadAgentsManifest(this.rootDir);
-    if (!manifest) {
-      return {
-        success: false,
-        error: "Team not configured. Run `paradigm team init` first.",
-        sessionId: ""
-      };
-    }
-    const agent = manifest.agents[agentName];
-    if (!agent) {
-      return {
-        success: false,
-        error: `Unknown agent: ${agentName}. Available: ${Object.keys(manifest.agents).join(", ")}`,
-        sessionId: ""
-      };
-    }
-    const providerName = options.provider || this.provider.name;
-    const provider = getProvider(providerName);
-    if (!provider) {
-      return {
-        success: false,
-        error: `Provider '${providerName}' not available`,
-        sessionId: ""
-      };
-    }
-    const isAvailable = await provider.isAvailable();
-    if (!isAvailable) {
-      return {
-        success: false,
-        error: `Provider '${providerName}' not configured (missing API key?)`,
-        sessionId: ""
-      };
-    }
-    const sessionId = this.generateSessionId(agentName);
-    const facetConfig = this.loadFacetConfig(agentName);
-    const context = await buildAgentContext(agent, task, this.rootDir, facetConfig);
-    const model = options.model || facetConfig?.defaultModel || "sonnet";
-    const spawnOptions = {
-      model,
-      task,
-      context,
-      budget: options.budget,
-      mcpServerPath: options.mcpServerPath,
-      workingDirectory: options.workingDirectory || this.rootDir,
-      checkpoints: options.checkpoints,
-      timeout: options.timeout
-    };
-    const startTime = Date.now();
-    const startTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const relay = {
-      agent: agentName,
-      task,
-      status: "success",
-      completionVerified: false,
-      outputs: {
-        artifacts: [],
-        symbols: context.symbols,
-        decisions: []
-      },
-      metrics: {
-        tokens_used: { input: 0, output: 0, total: 0 },
-        duration_ms: 0,
-        files_read: 0,
-        files_written: 0
-      }
-    };
-    try {
-      for await (const message of provider.spawn(agent, spawnOptions)) {
-        if (message.usage) {
-          relay.metrics.tokens_used = message.usage;
-        }
-        if (message.type === "tool_use") {
-          if (message.toolName === "read_file") {
-            relay.metrics.files_read++;
-          } else if (message.toolName === "write_file") {
-            relay.metrics.files_written++;
-            const filePath = message.toolInput?.path;
-            if (filePath) {
-              relay.outputs.artifacts.push({
-                path: filePath,
-                action: "modified"
-              });
-            }
-          }
-        }
-        if (options.checkpoints && message.type === "tool_use") {
-          const shouldPause = this.shouldPauseForCheckpoint(
-            message,
-            options.checkpoints
-          );
-          if (shouldPause && options.onCheckpoint) {
-            const approved = await options.onCheckpoint(
-              `Agent wants to ${message.toolName}: ${JSON.stringify(message.toolInput)}`
-            );
-            if (!approved) {
-              relay.status = "blocked";
-              break;
-            }
-          }
-        }
-        if (options.onMessage) {
-          options.onMessage(message);
-        }
-        if (message.type === "error") {
-          relay.status = "failed";
-        }
-        if (this.budgetTracker && message.usage) {
-          const budgetResult = this.budgetTracker.checkBudget(
-            agentName,
-            message.usage.total
-          );
-          if (!budgetResult.allowed) {
-            relay.status = "failed";
-            break;
-          }
-        }
-      }
-      relay.metrics.duration_ms = Date.now() - startTime;
-      if (this.budgetTracker) {
-        this.budgetTracker.recordUsage(agentName, relay.metrics.tokens_used, model);
-      }
-      if (relay.status === "success") {
-        const hasArtifacts = relay.outputs.artifacts.length > 0;
-        const hasDecisions = relay.outputs.decisions.length > 0;
-        const hasHandoff = !!relay.handoff;
-        const didFileWork = relay.metrics.files_written > 0;
-        const isArchitect = agentName === "architect";
-        const isBuilder = agentName === "builder";
-        if (isBuilder && !didFileWork && !hasHandoff) {
-          relay.status = "partial";
-        } else if (!hasArtifacts && !hasDecisions && !hasHandoff && !didFileWork) {
-          relay.status = "partial";
-        }
-        relay.completionVerified = true;
-        if (relay.status === "partial" && !isArchitect) {
-          if (options.onMessage) {
-            options.onMessage({
-              type: "text",
-              content: `[completion-check] Agent "${agentName}" downgraded from success \u2192 partial: no meaningful output detected.`,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          }
-        }
-      }
-      if (this.auditLogger) {
-        const agentLog = {
-          name: agentName,
-          model,
-          started: startTimestamp,
-          completed: (/* @__PURE__ */ new Date()).toISOString(),
-          duration_ms: relay.metrics.duration_ms,
-          tokens: relay.metrics.tokens_used,
-          cost_usd: calculateCost(relay.metrics.tokens_used, model),
-          status: relay.status,
-          artifacts: relay.outputs.artifacts,
-          symbols: relay.outputs.symbols
-        };
-        this.auditLogger.logAgentCompletion(sessionId, agentLog);
-      }
-      return {
-        success: relay.status === "success" || relay.status === "partial",
-        relay,
-        sessionId
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        sessionId,
-        relay: {
-          ...relay,
-          status: "failed",
-          metrics: {
-            ...relay.metrics,
-            duration_ms: Date.now() - startTime
-          }
-        }
-      };
-    }
-  }
-  /**
-   * Spawn multiple agents in parallel
-   */
-  async spawnParallel(agents) {
-    const promises = agents.map(
-      ({ name, task, options }) => this.spawn(name, task, options)
-    );
-    return Promise.all(promises);
-  }
-  // ==========================================================================
-  // Private Methods
-  // ==========================================================================
-  generateSessionId(agentName) {
-    const timestamp = Date.now();
-    const random = Math.random().toString(36).substring(2, 8);
-    return `${agentName}-${timestamp}-${random}`;
-  }
-  loadFacetConfig(agentName) {
-    const facetsPath = path3.join(this.rootDir, ".paradigm", "facets.yaml");
-    if (!fs3.existsSync(facetsPath)) {
-      const defaults = {
-        architect: { defaultModel: "opus" },
-        security: { defaultModel: "opus" },
-        reviewer: { defaultModel: "sonnet" },
-        builder: { defaultModel: "haiku" },
-        tester: { defaultModel: "haiku" }
-      };
-      return defaults[agentName];
-    }
-    try {
-      const content = fs3.readFileSync(facetsPath, "utf-8");
-      const facets = yaml3.load(content);
-      return facets[agentName];
-    } catch {
-      return void 0;
-    }
-  }
-  shouldPauseForCheckpoint(message, config) {
-    if (!config.beforeActions || message.type !== "tool_use") {
-      return false;
-    }
-    const actionMap = {
-      write: ["write_file", "edit_file"],
-      delete: ["delete_file", "rm"],
-      execute: ["run_command", "bash"],
-      external_api: ["mcp_call", "http_request"]
-    };
-    for (const action of config.beforeActions) {
-      const tools = actionMap[action] || [];
-      if (message.toolName && tools.includes(message.toolName)) {
-        return true;
-      }
-    }
-    return false;
-  }
-};
-
-export {
-  extractSymbols,
-  AgentSpawner
-};