@jaimevalasek/aioson 1.5.1 → 1.7.0

package/src/runtime-store.js

@@ -590,6 +590,32 @@ async function openRuntimeDb(targetDir, options = {}) {
       created_at TEXT DEFAULT (datetime('now')),
       updated_at TEXT DEFAULT (datetime('now'))
     );
+
+    CREATE TABLE IF NOT EXISTS dynamic_squad_tools (
+      name TEXT NOT NULL,
+      squad_slug TEXT NOT NULL,
+      description TEXT NOT NULL,
+      input_schema TEXT NOT NULL DEFAULT '{}',
+      handler_type TEXT NOT NULL DEFAULT 'shell',
+      handler_code TEXT,
+      handler_path TEXT,
+      registered_at TEXT NOT NULL,
+      registered_by TEXT,
+      PRIMARY KEY (name, squad_slug)
+    );
+    CREATE INDEX IF NOT EXISTS idx_dynamic_squad_tools_squad ON dynamic_squad_tools(squad_slug);
+
+    CREATE TABLE IF NOT EXISTS inter_squad_events (
+      id TEXT PRIMARY KEY,
+      from_squad TEXT NOT NULL,
+      event TEXT NOT NULL,
+      payload TEXT,
+      created_at TEXT NOT NULL,
+      consumed_by TEXT NOT NULL DEFAULT '[]',
+      ttl_hours INTEGER NOT NULL DEFAULT 48
+    );
+    CREATE INDEX IF NOT EXISTS idx_inter_squad_events_from ON inter_squad_events(from_squad, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_inter_squad_events_event ON inter_squad_events(event, created_at DESC);
   `);
 
   ensureLegacyColumns(db);
@@ -693,6 +719,59 @@ function ensureLegacyColumns(db) {
   }
 
   try { db.exec('ALTER TABLE worker_runs ADD COLUMN conversation_id TEXT'); } catch { /* já existe */ }
+
+  // Event Enrichment (Plan 61) — new columns in execution_events
+  const execEventColumns = db.prepare('PRAGMA table_info(execution_events)').all();
+  const execEventColumnNames = new Set(execEventColumns.map((col) => col.name));
+
+  if (!execEventColumnNames.has('plan_step_id')) {
+    db.exec('ALTER TABLE execution_events ADD COLUMN plan_step_id TEXT');
+  }
+  if (!execEventColumnNames.has('worker_status')) {
+    db.exec('ALTER TABLE execution_events ADD COLUMN worker_status TEXT');
+  }
+  if (!execEventColumnNames.has('verdict')) {
+    db.exec('ALTER TABLE execution_events ADD COLUMN verdict TEXT');
+  }
+  if (!execEventColumnNames.has('token_count')) {
+    db.exec('ALTER TABLE execution_events ADD COLUMN token_count INTEGER');
+  }
+  if (!execEventColumnNames.has('progress_pct')) {
+    db.exec('ALTER TABLE execution_events ADD COLUMN progress_pct REAL');
+  }
+
+  db.exec('CREATE INDEX IF NOT EXISTS idx_execution_events_agent_type ON execution_events(agent_name, event_type, created_at DESC)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_execution_events_verdict ON execution_events(verdict, created_at DESC)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_plan_phases_status ON plan_phases(plan_id, status)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_artifacts_run ON artifacts(run_key, created_at DESC)');
+
+  // Dynamic Tools (Feature: Tool Registry)
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS dynamic_tools (
+      name TEXT PRIMARY KEY,
+      description TEXT NOT NULL,
+      input_schema TEXT NOT NULL DEFAULT '{}',
+      handler_type TEXT NOT NULL DEFAULT 'shell',
+      handler_code TEXT,
+      handler_path TEXT,
+      squad_slug TEXT,
+      registered_at TEXT NOT NULL DEFAULT (datetime('now')),
+      registered_by TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_dynamic_tools_squad ON dynamic_tools(squad_slug);
+  `);
+
+  // Evolution Log (Feature: Learning Evolution Pipeline)
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS evolution_log (
+      id TEXT PRIMARY KEY,
+      applied_at TEXT NOT NULL,
+      deltas_count INTEGER NOT NULL DEFAULT 0,
+      squad_slug TEXT,
+      files_json TEXT,
+      source_learning_ids_json TEXT
+    );
+  `);
 }
 
 function insertEvent(db, record) {
@@ -739,12 +818,14 @@ function insertExecutionEvent(db, record) {
       task_key, run_key, agent_name, agent_kind, squad_slug, session_key,
       source, workflow_id, workflow_stage, parent_run_key,
       event_type, phase, status, tool_name, message, payload_json,
-      sequence_no, parent_event_id, created_at
+      sequence_no, parent_event_id, created_at,
+      plan_step_id, worker_status, verdict, token_count, progress_pct
     ) VALUES (
       @task_key, @run_key, @agent_name, @agent_kind, @squad_slug, @session_key,
       @source, @workflow_id, @workflow_stage, @parent_run_key,
       @event_type, @phase, @status, @tool_name, @message, @payload_json,
-      @sequence_no, @parent_event_id, @created_at
+      @sequence_no, @parent_event_id, @created_at,
+      @plan_step_id, @worker_status, @verdict, @token_count, @progress_pct
     )
   `).run(record);
 }
@@ -786,7 +867,12 @@ function appendRunEvent(db, options) {
       payload_json: payloadJson,
       sequence_no: nextExecutionSequence(db, run.run_key),
       parent_event_id: options.parentEventId || null,
-      created_at: now
+      created_at: now,
+      plan_step_id: options.planStepId ? String(options.planStepId).trim() : null,
+      worker_status: options.workerStatus ? String(options.workerStatus).trim() : null,
+      verdict: options.verdict ? String(options.verdict).trim().toUpperCase() : null,
+      token_count: options.tokenCount != null ? Number(options.tokenCount) || null : null,
+      progress_pct: options.progressPct != null ? Number(options.progressPct) || null : null
     });
   });
 
@@ -2425,6 +2511,66 @@ function deleteROIConfig(db, squadSlug) {
   return db.prepare('DELETE FROM squad_roi_config WHERE squad_slug = ?').run(squadSlug);
 }
 
+// ─── Dynamic Tools CRUD ───────────────────────────────────────────────────────
+
+function registerDynamicTool(db, opts) {
+  const now = nowIso();
+  db.prepare(`
+    INSERT OR REPLACE INTO dynamic_tools
+      (name, description, input_schema, handler_type, handler_code, handler_path, squad_slug, registered_at, registered_by)
+    VALUES
+      (@name, @description, @inputSchema, @handlerType, @handlerCode, @handlerPath, @squadSlug, @registeredAt, @registeredBy)
+  `).run({
+    name: String(opts.name),
+    description: String(opts.description),
+    inputSchema: opts.inputSchema ? JSON.stringify(opts.inputSchema) : '{}',
+    handlerType: String(opts.handlerType || 'shell'),
+    handlerCode: opts.handlerCode || null,
+    handlerPath: opts.handlerPath || null,
+    squadSlug: opts.squadSlug || null,
+    registeredAt: now,
+    registeredBy: opts.registeredBy || null
+  });
+  return opts.name;
+}
+
+function unregisterDynamicTool(db, name) {
+  return db.prepare('DELETE FROM dynamic_tools WHERE name = ?').run(name);
+}
+
+function getDynamicTool(db, name) {
+  return db.prepare('SELECT * FROM dynamic_tools WHERE name = ?').get(name) || null;
+}
+
+function listDynamicTools(db, squadSlug = null) {
+  if (squadSlug) {
+    return db.prepare('SELECT * FROM dynamic_tools WHERE squad_slug = ? ORDER BY registered_at DESC').all(squadSlug);
+  }
+  return db.prepare('SELECT * FROM dynamic_tools ORDER BY registered_at DESC').all();
+}
+
+// ─── Evolution Log CRUD ───────────────────────────────────────────────────────
+
+function insertEvolutionLog(db, opts) {
+  const id = `evo-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+  db.prepare(`
+    INSERT INTO evolution_log (id, applied_at, deltas_count, squad_slug, files_json, source_learning_ids_json)
+    VALUES (@id, @appliedAt, @deltasCount, @squadSlug, @filesJson, @sourceIdsJson)
+  `).run({
+    id,
+    appliedAt: nowIso(),
+    deltasCount: Number(opts.deltasCount || 0),
+    squadSlug: opts.squadSlug || null,
+    filesJson: JSON.stringify(opts.files || []),
+    sourceIdsJson: JSON.stringify(opts.sourceLearningIds || [])
+  });
+  return id;
+}
+
+function listEvolutionLog(db, limit = 20) {
+  return db.prepare('SELECT * FROM evolution_log ORDER BY applied_at DESC LIMIT ?').all(limit);
+}
+
 module.exports = {
   resolveRuntimePaths,
   runtimeStoreExists,
@@ -2518,5 +2664,13 @@ module.exports = {
   // ROI Config CRUD
   upsertROIConfig,
   getROIConfig,
-  deleteROIConfig
+  deleteROIConfig,
+  // Dynamic Tools CRUD
+  registerDynamicTool,
+  unregisterDynamicTool,
+  getDynamicTool,
+  listDynamicTools,
+  // Evolution Log CRUD
+  insertEvolutionLog,
+  listEvolutionLog
 };

package/src/sandbox.js

@@ -0,0 +1,177 @@
+'use strict';
+
+const { spawn } = require('node:child_process');
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_OUTPUT_BYTES = 5 * 1024; // 5KB before summarization
+
+// Credential redaction patterns — covers the most common secret formats
+const REDACTION_PATTERNS = [
+  // GitHub tokens (classic and fine-grained)
+  { pattern: /ghp_[A-Za-z0-9]{36}/g, replacement: 'ghp_[REDACTED]' },
+  { pattern: /github_pat_[A-Za-z0-9_]{82}/g, replacement: 'github_pat_[REDACTED]' },
+  // AWS access keys
+  { pattern: /AKIA[0-9A-Z]{16}/g, replacement: 'AKIA[REDACTED]' },
+  // Google OAuth tokens
+  { pattern: /ya29\.[A-Za-z0-9_\-]{50,}/g, replacement: 'ya29.[REDACTED]' },
+  // Generic Bearer tokens in headers
+  { pattern: /Bearer\s+[A-Za-z0-9\-._~+\/]+=*/gi, replacement: 'Bearer [REDACTED]' },
+  // Password in URL (e.g. postgres://user:password@host)
+  { pattern: /:[^/:@\s]{4,}@[a-z0-9.\-]+(?::\d+)?/gi, replacement: ':[REDACTED]@host' },
+  // Generic password= key=value pairs
+  { pattern: /password\s*=\s*["']?[^\s"'&;,]{4,}["']?/gi, replacement: 'password=[REDACTED]' },
+  { pattern: /passwd\s*=\s*["']?[^\s"'&;,]{4,}["']?/gi, replacement: 'passwd=[REDACTED]' },
+  // secret= key=value pairs
+  { pattern: /secret\s*=\s*["']?[^\s"'&;,]{4,}["']?/gi, replacement: 'secret=[REDACTED]' },
+  // api_key= or apikey= patterns
+  { pattern: /api[_-]?key\s*=\s*["']?[^\s"'&;,]{4,}["']?/gi, replacement: 'api_key=[REDACTED]' },
+  // Private key blocks
+  { pattern: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g, replacement: '-----BEGIN PRIVATE KEY [REDACTED] END PRIVATE KEY-----' },
+];
+
+/**
+ * Redact known credential patterns from a string.
+ * @param {string} text
+ * @returns {string}
+ */
+function redactCredentials(text) {
+  if (!text) return text;
+  let result = text;
+  for (const { pattern, replacement } of REDACTION_PATTERNS) {
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+
+/**
+ * Summarize long output to stay within size budget.
+ * @param {string} output
+ * @param {string} intent — optional context about what was executed
+ * @param {number} maxSize — max bytes to return
+ * @returns {string}
+ */
+function summarizeOutput(output, intent = '', maxSize = MAX_OUTPUT_BYTES) {
+  if (!output || output.length <= maxSize) return output;
+
+  const half = Math.floor(maxSize / 2);
+  const head = output.slice(0, half);
+  const tail = output.slice(-half);
+  const omitted = output.length - maxSize;
+  const intentNote = intent ? ` (${intent})` : '';
+
+  return `${head}\n\n[... ${omitted} bytes omitted${intentNote} ...]\n\n${tail}`;
+}
+
+/**
+ * Execute a shell command in a sandboxed subprocess with timeout and redaction.
+ *
+ * @param {string} command  — shell command to run
+ * @param {object} opts     — { cwd?, timeout?, env?, maxOutput?, intent?, shell? }
+ * @returns {{ ok: boolean, stdout: string, stderr: string, exitCode: number|null, timedOut: boolean }}
+ */
+async function executeInSandbox(command, opts = {}) {
+  const timeout = opts.timeout || DEFAULT_TIMEOUT_MS;
+  const cwd = opts.cwd || process.cwd();
+  const maxOutput = opts.maxOutput || MAX_OUTPUT_BYTES;
+  const intent = opts.intent || command.slice(0, 60);
+  const shell = opts.shell !== false; // default true
+
+  return new Promise((resolve) => {
+    const controller = new AbortController();
+    let timedOut = false;
+    let killed = false;
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeout);
+
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutSize = 0;
+    let stderrSize = 0;
+
+    const baseOpts = {
+      cwd,
+      env: { ...process.env, ...(opts.env || {}) },
+      signal: controller.signal
+    };
+
+    let child;
+    try {
+      if (shell) {
+        // Use Node's built-in shell wrapping
+        child = spawn(command, [], { ...baseOpts, shell: true });
+      } else {
+        const parts = command.split(/\s+/);
+        child = spawn(parts[0], parts.slice(1), { ...baseOpts, shell: false });
+      }
+    } catch (err) {
+      clearTimeout(timer);
+      resolve({ ok: false, stdout: '', stderr: err.message, exitCode: null, timedOut: false, error: err.message });
+      return;
+    }
+
+    child.stdout.on('data', (chunk) => {
+      if (stdoutSize < maxOutput * 2) {
+        stdoutChunks.push(chunk);
+        stdoutSize += chunk.length;
+      }
+    });
+
+    child.stderr.on('data', (chunk) => {
+      if (stderrSize < maxOutput * 2) {
+        stderrChunks.push(chunk);
+        stderrSize += chunk.length;
+      }
+    });
+
+    child.on('close', (code, signal) => {
+      if (killed) return;
+      clearTimeout(timer);
+
+      const rawStdout = Buffer.concat(stdoutChunks).toString('utf8');
+      const rawStderr = Buffer.concat(stderrChunks).toString('utf8');
+
+      const stdout = redactCredentials(summarizeOutput(rawStdout, intent, maxOutput));
+      const stderr = redactCredentials(summarizeOutput(rawStderr, intent, maxOutput));
+
+      resolve({
+        ok: !timedOut && code === 0,
+        stdout,
+        stderr,
+        exitCode: code,
+        timedOut,
+        signal: signal || null
+      });
+    });
+
+    child.on('error', (err) => {
+      if (killed) return;
+      clearTimeout(timer);
+
+      if (err.code === 'ABORT_ERR' || timedOut) {
+        resolve({
+          ok: false,
+          stdout: '',
+          stderr: `Command timed out after ${timeout}ms`,
+          exitCode: null,
+          timedOut: true,
+          signal: null
+        });
+      } else {
+        resolve({
+          ok: false,
+          stdout: '',
+          stderr: err.message,
+          exitCode: null,
+          timedOut: false,
+          error: err.message
+        });
+      }
+      killed = true;
+    });
+  });
+}
+
+module.exports = { executeInSandbox, redactCredentials, summarizeOutput };

package/src/squad/agent-teams-adapter.js

@@ -0,0 +1,264 @@
+'use strict';
+
+/**
+ * Agent Teams Adapter — Plan 81, Phase 1.1
+ *
+ * Translates squad manifests into Claude Code Agent Teams configurations.
+ * Enables squads to execute via native Agent Teams parallelism instead of
+ * manual Promise.all of subprocesses.
+ *
+ * Mapping:
+ *   executors[].slug            → teammates[].name
+ *   executors[].type            → teammates[].subagent definition
+ *   tasks[].wave                → tasks[].dependencies
+ *   tasks[].must_haves          → tasks[].acceptance_criteria
+ *   budget.max_tokens_per_task  → per-teammate token limits
+ *   intra-bus messages          → shared mailbox messages
+ *
+ * Fallback: if Agent Teams is not available (Claude Code < v2.1.32),
+ * returns { available: false } and caller falls back to legacy engine.
+ */
+
+const { execSync } = require('node:child_process');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+// ─── Availability detection ──────────────────────────────────────────────────
+
+/**
+ * Detect if Claude Code Agent Teams is available.
+ * Checks for claude binary and version >= 2.1.32.
+ */
+function detectAgentTeams() {
+  try {
+    const versionOutput = execSync('claude --version 2>/dev/null', {
+      encoding: 'utf8',
+      timeout: 5000
+    }).trim();
+
+    const match = versionOutput.match(/(\d+)\.(\d+)\.(\d+)/);
+    if (!match) return { available: false, reason: 'version_parse_error', raw: versionOutput };
+
+    const [, major, minor, patch] = match.map(Number);
+    const version = `${major}.${minor}.${patch}`;
+
+    // Agent Teams requires v2.1.32+
+    const meetsMinimum =
+      major > 2 ||
+      (major === 2 && minor > 1) ||
+      (major === 2 && minor === 1 && patch >= 32);
+
+    return {
+      available: meetsMinimum,
+      version,
+      reason: meetsMinimum ? 'ok' : 'version_too_old'
+    };
+  } catch {
+    return { available: false, reason: 'claude_not_found' };
+  }
+}
+
+// ─── Manifest to Team Config translation ─────────────────────────────────────
+
+/**
+ * Build a teammate definition from a squad executor.
+ */
+function executorToTeammate(executor, squadSlug, projectDir) {
+  const agentFile = executor.file
+    ? path.join(projectDir, executor.file)
+    : path.join(projectDir, SQUADS_DIR, squadSlug, 'agents', `${executor.slug}.md`);
+
+  const teammate = {
+    name: executor.slug,
+    role: executor.role || executor.title || executor.slug,
+    type: mapExecutorType(executor.type),
+    agentFile: agentFile
+  };
+
+  // Model tier mapping
+  if (executor.modelTier) {
+    const tierMap = {
+      powerful: 'opus',
+      balanced: 'sonnet',
+      fast: 'haiku',
+      none: null
+    };
+    teammate.model = tierMap[executor.modelTier] || 'sonnet';
+  }
+
+  // Skills
+  if (executor.skills && executor.skills.length > 0) {
+    teammate.skills = executor.skills;
+  }
+
+  return teammate;
+}
+
+/**
+ * Map AIOSON executor type to Agent Teams teammate type.
+ */
+function mapExecutorType(type) {
+  const typeMap = {
+    agent: 'subagent',
+    worker: 'worker',
+    clone: 'subagent',
+    assistant: 'subagent',
+    'human-gate': 'gate',
+    research: 'research',
+    reviewer: 'subagent',
+    skill: 'skill'
+  };
+  return typeMap[type] || 'subagent';
+}
+
+/**
+ * Convert a task decomposition plan to Agent Teams task list.
+ */
+function planToTeamTasks(plan, executors) {
+  const tasks = [];
+
+  for (const task of plan.tasks) {
+    const teamTask = {
+      id: task.id,
+      title: task.title,
+      description: task.description,
+      assignTo: task.executor || null,
+      dependencies: task.dependencies || [],
+      acceptance_criteria: task.acceptance_criteria || [],
+      priority: task.priority || 0,
+      metadata: {}
+    };
+
+    // Map must_haves to structured acceptance criteria
+    if (task.must_haves) {
+      if (task.must_haves.artifacts) {
+        teamTask.acceptance_criteria.push(
+          ...task.must_haves.artifacts.map((a) => `Artifact exists: ${a}`)
+        );
+      }
+      if (task.must_haves.key_links) {
+        teamTask.acceptance_criteria.push(
+          ...task.must_haves.key_links.map((l) => `Wired: ${l}`)
+        );
+      }
+    }
+
+    // read_first_hints become context for the teammate
+    if (task.read_first_hints && task.read_first_hints.length > 0) {
+      teamTask.metadata.read_first = task.read_first_hints;
+    }
+
+    tasks.push(teamTask);
+  }
+
+  return tasks;
+}
+
+/**
+ * Translate a full squad manifest + plan into an Agent Teams configuration.
+ *
+ * @param {string} projectDir
+ * @param {object} manifest  — squad.manifest.json contents
+ * @param {object} plan  — decomposed task plan
+ * @param {object} [options]  — { budget, enableBus }
+ * @returns {object}  — Agent Teams config
+ */
+function translateToTeamConfig(projectDir, manifest, plan, options = {}) {
+  const { budget = {} } = options;
+  const executors = manifest.executors || [];
+
+  // Build teammates
+  const teammates = executors.map((e) =>
+    executorToTeammate(e, manifest.slug, projectDir)
+  );
+
+  // Build tasks
+  const tasks = planToTeamTasks(plan, executors);
+
+  // Team configuration
+  const teamConfig = {
+    name: `squad-${manifest.slug}`,
+    description: manifest.mission || manifest.goal || `Squad: ${manifest.name}`,
+    teammates,
+    tasks,
+    settings: {
+      parallel: true,
+      maxConcurrent: teammates.length,
+      taskTimeout: budget.max_tokens_per_task ? Math.ceil(budget.max_tokens_per_task / 100) : 300,
+      quality: {
+        verifyOnComplete: true,
+        blockOnFail: true
+      }
+    }
+  };
+
+  // Budget constraints
+  if (budget.max_tokens_per_session) {
+    teamConfig.settings.tokenBudget = budget.max_tokens_per_session;
+  }
+  if (budget.max_tokens_per_task) {
+    teamConfig.settings.perTaskTokenLimit = budget.max_tokens_per_task;
+  }
+
+  // Anti-loop settings
+  if (manifest.anti_loop) {
+    teamConfig.settings.antiLoop = {
+      threshold: manifest.anti_loop.threshold || 8,
+      action: manifest.anti_loop.action || 'feedback'
+    };
+  }
+
+  return teamConfig;
+}
+
+/**
+ * Write Agent Teams config to a JSON file for claude --team usage.
+ */
+async function writeTeamConfig(projectDir, squadSlug, teamConfig) {
+  const configDir = path.join(projectDir, '.aioson', 'squads', squadSlug, 'team-config');
+  await fs.mkdir(configDir, { recursive: true });
+
+  const configPath = path.join(configDir, 'team.json');
+  await fs.writeFile(configPath, JSON.stringify(teamConfig, null, 2), 'utf8');
+
+  return configPath;
+}
+
+/**
+ * Resolve the execution engine for a squad:autorun run.
+ * Returns 'agent-teams' if requested and available, otherwise 'legacy'.
+ */
+function resolveEngine(requestedEngine) {
+  if (requestedEngine === 'legacy') return { engine: 'legacy', reason: 'explicit' };
+
+  if (requestedEngine === 'agent-teams') {
+    const detection = detectAgentTeams();
+    if (detection.available) {
+      return { engine: 'agent-teams', version: detection.version, reason: 'explicit' };
+    }
+    return { engine: 'legacy', reason: `agent-teams requested but ${detection.reason}`, fallback: true };
+  }
+
+  // Auto-detect
+  if (requestedEngine === 'auto') {
+    const detection = detectAgentTeams();
+    if (detection.available) {
+      return { engine: 'agent-teams', version: detection.version, reason: 'auto-detected' };
+    }
+    return { engine: 'legacy', reason: 'auto-fallback' };
+  }
+
+  return { engine: 'legacy', reason: 'default' };
+}
+
+module.exports = {
+  detectAgentTeams,
+  translateToTeamConfig,
+  writeTeamConfig,
+  resolveEngine,
+  executorToTeammate,
+  planToTeamTasks,
+  mapExecutorType
+};