convoke-agents 2.0.0

package/scripts/update/convoke-update.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+
+const readline = require('readline');
+const chalk = require('chalk');
+const versionDetector = require('./lib/version-detector');
+const migrationRunner = require('./lib/migration-runner');
+const registry = require('./migrations/registry');
+const { findProjectRoot } = require('./lib/utils');
+
+/**
+ * Convoke Update CLI
+ * Main update command for users
+ */
+
+/**
+ * Assess the current installation and determine what update action is needed.
+ * Pure logic — no I/O, no process.exit. Returns a structured decision object.
+ *
+ * @param {string|null} projectRoot - Project root path (null if not found)
+ * @returns {object} Assessment result with action, versions, migrations, breakingChanges
+ */
+function assessUpdate(projectRoot) {
+  if (!projectRoot) {
+    return { action: 'no-project' };
+  }
+
+  const currentVersion = versionDetector.getCurrentVersion(projectRoot);
+  const targetVersion = versionDetector.getTargetVersion();
+  const scenario = versionDetector.detectInstallationScenario(projectRoot);
+
+  if (scenario === 'fresh') {
+    return { action: 'fresh', scenario };
+  }
+
+  if (scenario === 'partial' || scenario === 'corrupted') {
+    return { action: 'broken', scenario };
+  }
+
+  if (!currentVersion) {
+    return { action: 'no-version', scenario };
+  }
+
+  const migrationPath = versionDetector.getMigrationPath(currentVersion, targetVersion);
+
+  if (migrationPath.type === 'up-to-date') {
+    return { action: 'up-to-date', currentVersion, targetVersion };
+  }
+
+  if (migrationPath.type === 'downgrade') {
+    return { action: 'downgrade', currentVersion, targetVersion };
+  }
+
+  const migrations = registry.getMigrationsFor(currentVersion);
+  const breakingChanges = registry.getBreakingChanges(currentVersion);
+
+  if (migrations.length === 0) {
+    return { action: 'no-migrations', currentVersion, targetVersion };
+  }
+
+  return {
+    action: 'upgrade',
+    currentVersion,
+    targetVersion,
+    migrations,
+    breakingChanges
+  };
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes('--dry-run');
+  const yes = args.includes('--yes') || args.includes('-y');
+  const verbose = args.includes('--verbose') || args.includes('-v');
+
+  // Header
+  console.log('');
+  console.log(chalk.bold.magenta('╔════════════════════════════════════════╗'));
+  console.log(chalk.bold.magenta('║   Convoke Update Manager               ║'));
+  console.log(chalk.bold.magenta('╚════════════════════════════════════════╝'));
+  console.log('');
+
+  const projectRoot = findProjectRoot();
+  const assessment = assessUpdate(projectRoot);
+
+  switch (assessment.action) {
+    case 'no-project':
+      console.log(chalk.red('Not in a Convoke project. Could not find _bmad/ directory.'));
+      console.log('');
+      console.log('Run: ' + chalk.cyan('npx convoke-install'));
+      console.log('');
+      process.exit(1);
+      break;
+
+    case 'fresh':
+      console.log(chalk.yellow('No previous installation detected.'));
+      console.log('');
+      console.log('Run: ' + chalk.cyan('npx convoke-install'));
+      console.log('');
+      process.exit(0);
+      break;
+
+    case 'broken':
+      console.log(chalk.red('Installation appears incomplete or corrupted.'));
+      console.log('');
+      console.log('Recommend running: ' + chalk.cyan('npx convoke-install'));
+      console.log('');
+      process.exit(1);
+      break;
+
+    case 'no-version':
+      console.log(chalk.yellow('Could not detect current version.'));
+      console.log('');
+      console.log('Run: ' + chalk.cyan('npx convoke-install'));
+      console.log('');
+      process.exit(0);
+      break;
+
+    case 'up-to-date':
+      console.log(chalk.green(`✓ Already up to date! (v${assessment.currentVersion})`));
+      console.log('');
+      console.log(chalk.gray('If you expected a newer version, npx may be serving a cached copy.'));
+      console.log(chalk.gray('Run: ') + chalk.cyan('npx -p convoke-agents@latest convoke-update'));
+      console.log('');
+      process.exit(0);
+      break;
+
+    case 'downgrade':
+      console.log(chalk.red.bold('⚠ DOWNGRADE DETECTED'));
+      console.log('');
+      console.log(`  Current version: ${assessment.currentVersion}`);
+      console.log(`  Package version: ${assessment.targetVersion}`);
+      console.log('');
+      console.log(chalk.gray('This usually means npx is serving a cached older package.'));
+      console.log(chalk.gray('Run: ') + chalk.cyan('npx -p convoke-agents@latest convoke-update'));
+      console.log('');
+      console.log(chalk.gray('If the issue persists, clear the cache and reinstall:'));
+      console.log(chalk.cyan('  npm cache clean --force && npm install convoke-agents@latest'));
+      console.log('');
+      console.log(chalk.yellow('If you intentionally want to downgrade:'));
+      console.log('  1. Backup your installation');
+      console.log('  2. Uninstall current version');
+      console.log('  3. Install desired version');
+      console.log('');
+      process.exit(1);
+      break;
+
+    case 'no-migrations':
+      console.log(chalk.yellow('No migrations needed (versions compatible)'));
+      console.log('');
+      process.exit(0);
+      break;
+
+    case 'upgrade':
+      break; // Continue below
+  }
+
+  // Show migration plan
+  console.log(chalk.cyan('Migration Plan:'));
+  console.log(`  From: ${chalk.red(assessment.currentVersion)}`);
+  console.log(`  To:   ${chalk.green(assessment.targetVersion)}`);
+  console.log('');
+
+  console.log(chalk.cyan('Migrations to apply:'));
+  assessment.migrations.forEach((m, i) => {
+    const icon = m.breaking ? chalk.red('⚠') : chalk.green('✓');
+    console.log(`  ${i + 1}. ${icon} ${m.description}`);
+  });
+  console.log('');
+
+  if (assessment.breakingChanges.length > 0) {
+    console.log(chalk.red.bold('⚠ BREAKING CHANGES:'));
+    assessment.breakingChanges.forEach(change => {
+      console.log(chalk.yellow(`  - ${change}`));
+    });
+    console.log('');
+  }
+
+  // Dry run - preview only
+  if (dryRun) {
+    console.log(chalk.yellow.bold('DRY RUN - Previewing changes'));
+    console.log('');
+
+    try {
+      await migrationRunner.runMigrations(assessment.currentVersion, { dryRun: true, verbose });
+    } catch (error) {
+      console.error(chalk.red('Error during preview:'), error.message);
+      process.exit(1);
+    }
+
+    process.exit(0);
+  }
+
+  // Confirm with user (unless --yes)
+  if (!yes) {
+    console.log(chalk.cyan('Your data will be backed up automatically before migration.'));
+    console.log('');
+
+    const confirmed = await confirm('Proceed with migration?');
+
+    if (!confirmed) {
+      console.log('');
+      console.log(chalk.yellow('Migration cancelled.'));
+      console.log('');
+      process.exit(0);
+    }
+  }
+
+  // Run migrations
+  console.log('');
+  console.log(chalk.cyan.bold('Starting migration...'));
+
+  try {
+    const result = await migrationRunner.runMigrations(assessment.currentVersion, { verbose });
+
+    console.log('');
+    console.log(chalk.green.bold('✓ Migration completed successfully!'));
+    console.log('');
+    console.log(chalk.cyan('Changes applied:'));
+    result.results.forEach(r => {
+      console.log(chalk.green(`  ✓ ${r.name}`));
+      if (verbose) {
+        r.changes.forEach(change => {
+          console.log(chalk.gray(`    - ${change}`));
+        });
+      }
+    });
+    console.log('');
+    console.log(chalk.gray(`Backup location: ${result.backupMetadata.backup_dir}`));
+    console.log('');
+
+  } catch (_error) {
+    // Error already logged by migration-runner
+    process.exit(1);
+  }
+}
+
+/**
+ * Confirm action with user
+ * @param {string} message - Confirmation message
+ * @returns {Promise<boolean>} True if user confirms
+ */
+async function confirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise(resolve => {
+    rl.question(chalk.yellow(`${message} [y/N]: `), answer => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+// Export assessUpdate for testing
+module.exports = { assessUpdate };
+
+// Run main when executed directly
+if (require.main === module) {
+  main().catch(error => {
+    console.error('');
+    console.error(chalk.red.bold('Unexpected error:'));
+    console.error(chalk.red(error.message));
+    console.error('');
+    if (error.stack) {
+      console.error(chalk.gray(error.stack));
+      console.error('');
+    }
+    process.exit(1);
+  });
+}

package/scripts/update/convoke-version.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const yaml = require('js-yaml');
+const versionDetector = require('./lib/version-detector');
+const { findProjectRoot, compareVersions } = require('./lib/utils');
+
+/**
+ * Convoke Version CLI
+ * Show version information and migration history
+ */
+
+async function main() {
+  const projectRoot = findProjectRoot();
+  const targetVersion = versionDetector.getTargetVersion();
+
+  console.log('');
+  console.log(chalk.bold('Convoke Version Information'));
+  console.log('');
+
+  // Not in a Convoke project
+  if (!projectRoot) {
+    console.log(chalk.yellow('Status:           Not in a Convoke project'));
+    console.log(`Package version:  ${chalk.cyan(targetVersion)}`);
+    console.log('');
+    console.log('Run: ' + chalk.cyan('npx convoke-install'));
+    console.log('');
+    return;
+  }
+
+  const currentVersion = versionDetector.getCurrentVersion(projectRoot);
+  const scenario = versionDetector.detectInstallationScenario(projectRoot);
+
+  // Fresh install - not installed yet
+  if (scenario === 'fresh') {
+    console.log(chalk.yellow('Status:           Not installed'));
+    console.log(`Package version:  ${chalk.cyan(targetVersion)}`);
+    console.log('');
+    console.log('Run: ' + chalk.cyan('npx convoke-install'));
+    console.log('');
+    return;
+  }
+
+  // Partial installation - config.yaml missing but some files exist
+  if (scenario === 'partial' || !currentVersion) {
+    console.log(chalk.red('Status:           Partial installation (config.yaml missing)'));
+    console.log(`Package version:  ${chalk.cyan(targetVersion)}`);
+    console.log('');
+    console.log(chalk.yellow('This indicates an installation error.'));
+    console.log('');
+    console.log('Try running: ' + chalk.cyan('npx convoke-install'));
+    console.log('');
+    console.log('If the problem persists, check the installation logs.');
+    console.log('');
+    return;
+  }
+
+  // Corrupted installation
+  if (scenario === 'corrupted') {
+    console.log(chalk.red('Status:           Corrupted installation (missing required files)'));
+    console.log(`Package version:  ${chalk.cyan(targetVersion)}`);
+    console.log('');
+    console.log(chalk.yellow('Some required files are missing.'));
+    console.log('');
+    console.log('Run: ' + chalk.cyan('npx convoke-install') + ' to reinstall');
+    console.log('');
+    return;
+  }
+
+  // Installed
+  console.log(`Installed version: ${chalk.cyan(currentVersion)}`);
+  console.log(`Package version:   ${chalk.cyan(targetVersion)}`);
+  console.log('');
+
+  // Status
+  if (currentVersion === targetVersion) {
+    console.log(chalk.green('Status: ✓ Up to date'));
+  } else if (compareVersions(currentVersion, targetVersion) < 0) {
+    console.log(chalk.yellow('Status: ⚠ Update available'));
+    console.log('');
+    console.log('Run: ' + chalk.cyan('npx -p convoke-agents@latest convoke-update --dry-run') + ' (to preview)');
+    console.log('     ' + chalk.cyan('npx -p convoke-agents@latest convoke-update') + ' (to apply)');
+  } else {
+    console.log(chalk.yellow(`Status: Package version (${targetVersion}) is older than installed (${currentVersion})`));
+  }
+
+  // Show migration history
+  const migrationHistory = await getMigrationHistory(projectRoot);
+  if (migrationHistory && migrationHistory.length > 0) {
+    console.log('');
+    console.log(chalk.cyan('Migration History:'));
+    migrationHistory.forEach((entry, index) => {
+      const timestamp = new Date(entry.timestamp).toLocaleDateString();
+      console.log(chalk.gray(`  ${index + 1}. ${entry.from_version} → ${entry.to_version} (${timestamp})`));
+      if (entry.migrations_applied && entry.migrations_applied.length > 0) {
+        entry.migrations_applied.forEach(m => {
+          console.log(chalk.gray(`     - ${m}`));
+        });
+      }
+    });
+  }
+
+  console.log('');
+}
+
+/**
+ * Get migration history from config.yaml
+ * @param {string} projectRoot - Project root
+ * @returns {Promise<Array|null>} Migration history or null
+ */
+async function getMigrationHistory(projectRoot) {
+  const configPath = path.join(projectRoot, '_bmad/bme/_vortex/config.yaml');
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const configContent = await fs.readFile(configPath, 'utf8');
+    const config = yaml.load(configContent);
+
+    return config.migration_history || null;
+  } catch (_error) {
+    return null;
+  }
+}
+
+// Run main
+main().catch(error => {
+  console.error('Error:', error.message);
+  process.exit(1);
+});

package/scripts/update/lib/agent-registry.js

@@ -0,0 +1,144 @@
+/**
+ * Canonical agent and workflow registry.
+ *
+ * Single source of truth consumed by refresh-installation, validator,
+ * convoke-doctor, installer, index.js, and migration-runner.
+ *
+ * To add a new agent:  push one entry to AGENTS + its workflows to WORKFLOWS.
+ * Every consumer picks up the change automatically.
+ */
+
+'use strict';
+
+const AGENTS = [
+  // Stream 1 — Contextualize
+  {
+    id: 'contextualization-expert', name: 'Emma', icon: '\u{1F3AF}',
+    title: 'Contextualization Expert', stream: 'Contextualize',
+    persona: {
+      role: 'Strategic Framing + Problem-Product Space Navigator',
+      identity: 'Expert in helping teams contextualize their product strategy by defining clear problem spaces and validating assumptions. Specializes in Lean Startup methodologies, persona creation, and product vision framing. Guides teams through the critical \'Contextualize\' stream of the Vortex pattern.',
+      communication_style: 'Strategic yet approachable - speaks in frameworks and validated learning. Like a product strategist who asks \'What are we really solving?\' and \'Who is this truly for?\' Uses Lean Startup language (hypotheses, assumptions, pivots) and focuses on clarity before action.',
+      expertise: '- Master of Lean Startup and strategic framing methodologies - Personas over demographics - focus on jobs-to-be-done and problem contexts - Vision before features - align team around the \'why\' before the \'what\' - Challenge assumptions - every belief is a hypothesis until validated - Problem-solution fit comes before product-market fit',
+    },
+  },
+  // Stream 2 — Empathize
+  {
+    id: 'discovery-empathy-expert', name: 'Isla', icon: '\u{1F50D}',
+    title: 'Discovery & Empathy Expert', stream: 'Empathize',
+    persona: {
+      role: 'Qualitative Research Expert + Empathy Mapping Specialist',
+      identity: 'Expert in helping teams deeply understand their users through structured discovery and empathy work. Specializes in qualitative research methods, user interviews, ethnographic observation, and empathy mapping. Guides teams through the \'Empathize\' stream of the Vortex pattern.',
+      communication_style: 'Warm and probing - asks follow-up questions others wouldn\'t think of. Speaks in user stories and observations. Celebrates messy, raw findings over polished assumptions. Says things like \'I noticed that...\' and \'What if we asked them WHY they do that?\'',
+      expertise: '- Listen before you define - Observe before you assume - Feelings are data - Talk to real people, not personas - Empathy is a practice, not a phase - The messier the research, the richer the insights',
+    },
+  },
+  // Stream 3 — Synthesize
+  {
+    id: 'research-convergence-specialist', name: 'Mila', icon: '\u{1F52C}',
+    title: 'Research Convergence Specialist', stream: 'Synthesize',
+    persona: {
+      role: 'Research Convergence + Problem Definition Specialist',
+      identity: 'Expert in converging divergent research streams into actionable problem definitions. Specializes in Jobs-to-be-Done framing, Pains & Gains analysis, and cross-source pattern synthesis. Guides teams through the \'Synthesize\' stream — transforming raw empathy data and contextual insights into clear, prioritized problem statements.',
+      communication_style: 'Warm but analytically precise — connects dots others miss while keeping teams grounded in evidence. Says things like \'Here\'s what the research is telling us...\' and \'Three patterns converge on this insight.\' Balances empathy with rigor, always linking findings back to user language.',
+      expertise: '- Convergence over collection - synthesize before you define - Jobs-to-be-Done framing turns observations into actionable problem statements - Pains & Gains analysis reveals what users value vs. what they tolerate - Cross-source triangulation - one data point is an anecdote, three are a pattern - Problem definition is the highest-leverage activity in product discovery',
+    },
+  },
+  // Stream 4 — Hypothesize
+  {
+    id: 'hypothesis-engineer', name: 'Liam', icon: '\u{1F4A1}',
+    title: 'Hypothesis Engineer', stream: 'Hypothesize',
+    persona: {
+      role: 'Creative Ideation + Hypothesis Engineering Specialist',
+      identity: 'Creative peer who ideates alongside the user rather than facilitating from a distance. Specializes in structured brainwriting, 4-field hypothesis contracts, and assumption mapping. Guides teams through the \'Hypothesize\' stream — turning validated problem definitions into testable solution hypotheses.',
+      communication_style: 'Energetic and challenging — pushes teams past obvious ideas with provocative \'What if?\' questions. Says things like \'That\'s a safe bet — what\'s the bold version?\' and \'Let\'s stress-test that assumption before we build anything.\' Treats ideation as craft, not chaos.',
+      expertise: '- Structured brainwriting produces better ideas than unstructured brainstorming - 4-field hypothesis contracts force clarity: belief, evidence needed, experiment, success criteria - Assumption mapping separates what we know from what we think we know - The riskiest assumption gets tested first, not the easiest one - Good hypotheses are falsifiable — if you can\'t prove it wrong, it\'s not a hypothesis',
+    },
+  },
+  // Stream 5 — Externalize
+  {
+    id: 'lean-experiments-specialist', name: 'Wade', icon: '\u{1F9EA}',
+    title: 'Lean Experiments Specialist', stream: 'Externalize',
+    persona: {
+      role: 'Lean Startup + Validated Learning Expert',
+      identity: 'Lean Startup practitioner specialized in running rapid experiments to validate product hypotheses. Helps teams move from assumptions to evidence through Build-Measure-Learn cycles. Guides teams through the \'Externalize\' stream - taking ideas into the real world to test with actual users.',
+      communication_style: 'Experimental and evidence-driven - speaks in hypotheses, metrics, and learning. Like a scientist who says \'Let\'s test that assumption\' and \'What would prove us wrong?\' Uses Lean language (MVPs, pivots, validated learning) and focuses on speed-to-insight over perfection.',
+      expertise: '- Master of Lean Startup and rapid experimentation - Build the smallest thing that tests the riskiest assumption - Measure what matters - focus on actionable metrics, not vanity metrics - Learn fast, pivot faster - every experiment teaches something - Proof-of-concept before proof-of-value - validate feasibility before business case - Fail fast is good, learn fast is better',
+    },
+  },
+  // Stream 6 — Sensitize
+  {
+    id: 'production-intelligence-specialist', name: 'Noah', icon: '\u{1F4E1}',
+    title: 'Production Intelligence Specialist', stream: 'Sensitize',
+    persona: {
+      role: 'Signal Interpretation + Production Intelligence Analyst',
+      identity: 'Intelligence analyst who interprets production signals through contextual lenses. Specializes in signal-context-trend analysis, behavioral pattern detection, and feedback loop interpretation. Guides teams through the \'Sensitize\' stream — reading what real-world usage reveals about product-market fit. Explicitly does NOT make strategic recommendations — that is Max\'s domain.',
+      communication_style: 'Calm and observational — reports what the data shows without jumping to conclusions. Says things like \'The signal indicates...\' and \'Here\'s what we\'re seeing in context.\' Presents findings in signal + context + trend format, leaving strategic interpretation to the decision-maker.',
+      expertise: '- Signal + context + trend — raw metrics mean nothing without interpretation frames - Behavioral patterns reveal intent that surveys miss - Production data is the most honest user feedback — it can\'t lie - Anomaly detection surfaces what dashboards hide - Observe and report, don\'t prescribe — strategic decisions belong downstream',
+    },
+  },
+  // Stream 7 — Systematize
+  {
+    id: 'learning-decision-expert', name: 'Max', icon: '\u{1F9ED}',
+    title: 'Learning & Decision Expert', stream: 'Systematize',
+    persona: {
+      role: 'Validated Learning Synthesizer + Strategic Decision Expert',
+      identity: 'Expert in synthesizing experiment results, capturing validated learnings, and guiding strategic pivot/patch/persevere decisions. Guides teams through the \'Systematize\' stream - turning data into decisions and learning into action.',
+      communication_style: 'Calm and decisive - cuts through noise to surface what the data actually says. Says things like \'The evidence suggests...\' and \'Based on what we\'ve learned, here are our three options.\' Focuses on evidence over opinion.',
+      expertise: '- Data tells a story - learn to read it - Every experiment has a lesson, even failed ones - Decide and move - analysis paralysis kills innovation - Pivot is not failure, it is intelligence - Systematize what you learn so the next team doesn\'t start from zero',
+    },
+  },
+];
+
+const WORKFLOWS = [
+  // Emma — Contextualize (Stream 1)
+  { name: 'lean-persona', agent: 'contextualization-expert' },
+  { name: 'product-vision', agent: 'contextualization-expert' },
+  { name: 'contextualize-scope', agent: 'contextualization-expert' },
+  // Isla — Empathize (Stream 2)
+  { name: 'empathy-map', agent: 'discovery-empathy-expert' },
+  { name: 'user-interview', agent: 'discovery-empathy-expert' },
+  { name: 'user-discovery', agent: 'discovery-empathy-expert' },
+  // Mila — Synthesize (Stream 3)
+  { name: 'research-convergence', agent: 'research-convergence-specialist' },
+  { name: 'pivot-resynthesis', agent: 'research-convergence-specialist' },
+  { name: 'pattern-mapping', agent: 'research-convergence-specialist' },
+  // Liam — Hypothesize (Stream 4)
+  { name: 'hypothesis-engineering', agent: 'hypothesis-engineer' },
+  { name: 'assumption-mapping', agent: 'hypothesis-engineer' },
+  { name: 'experiment-design', agent: 'hypothesis-engineer' },
+  // Wade — Externalize (Stream 5)
+  { name: 'mvp', agent: 'lean-experiments-specialist' },
+  { name: 'lean-experiment', agent: 'lean-experiments-specialist' },
+  { name: 'proof-of-concept', agent: 'lean-experiments-specialist' },
+  { name: 'proof-of-value', agent: 'lean-experiments-specialist' },
+  // Noah — Sensitize (Stream 6)
+  { name: 'signal-interpretation', agent: 'production-intelligence-specialist' },
+  { name: 'behavior-analysis', agent: 'production-intelligence-specialist' },
+  { name: 'production-monitoring', agent: 'production-intelligence-specialist' },
+  // Max — Systematize (Stream 7)
+  { name: 'learning-card', agent: 'learning-decision-expert' },
+  { name: 'pivot-patch-persevere', agent: 'learning-decision-expert' },
+  { name: 'vortex-navigation', agent: 'learning-decision-expert' },
+];
+
+// Derived lists — computed from the canonical arrays above
+const AGENT_FILES = AGENTS.map(a => `${a.id}.md`);
+const AGENT_IDS = AGENTS.map(a => a.id);
+const WORKFLOW_NAMES = WORKFLOWS.map(w => w.name);
+const USER_GUIDES = AGENTS.map(a => `${a.name.toUpperCase()}-USER-GUIDE.md`);
+
+// Wave 3 streams use standardized step filenames (P20)
+const WAVE3_STREAMS = new Set(['Synthesize', 'Hypothesize', 'Sensitize']);
+const _wave3AgentIds = new Set(AGENTS.filter(a => WAVE3_STREAMS.has(a.stream)).map(a => a.id));
+const WAVE3_WORKFLOW_NAMES = new Set(WORKFLOWS.filter(w => _wave3AgentIds.has(w.agent)).map(w => w.name));
+
+module.exports = {
+  AGENTS,
+  WORKFLOWS,
+  AGENT_FILES,
+  AGENT_IDS,
+  WORKFLOW_NAMES,
+  USER_GUIDES,
+  WAVE3_WORKFLOW_NAMES,
+};