@nerviq/cli 0.0.1 → 0.9.0-beta.2

package/src/harmony/watch.js

@@ -0,0 +1,336 @@
+/**
+ * H6. Harmony Watch - Continuous Adaptation Loop
+ *
+ * Monitors repo for changes across ALL platform config files and triggers
+ * cross-platform drift detection when changes occur.
+ *
+ * Extends the watch pattern from src/watch.js to cover all supported platforms.
+ * Zero external dependencies.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const COLORS = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  green: '\x1b[32m', yellow: '\x1b[33m', blue: '\x1b[36m', red: '\x1b[31m',
+};
+const c = (text, color) => `${COLORS[color] || ''}${text}${COLORS.reset}`;
+
+// ─── Platform config file paths to watch ──────────────────────────────────────
+
+const PLATFORM_WATCH_FILES = [
+  // Claude
+  'CLAUDE.md',
+  '.claude/settings.json',
+  '.claude/settings.local.json',
+  // Codex
+  'AGENTS.md',
+  'codex.toml',
+  '.codex/config.toml',
+  // Gemini
+  'GEMINI.md',
+  '.gemini/settings.json',
+  // Copilot
+  '.github/copilot-instructions.md',
+  '.github/copilot-review-instructions.md',
+  // Cursor
+  '.cursorrules',
+  // Shared
+  '.gitignore',
+  'package.json',
+  'tsconfig.json',
+];
+
+const PLATFORM_WATCH_DIRS = [
+  '.claude',
+  '.claude/commands',
+  '.claude/rules',
+  '.claude/agents',
+  '.claude/skills',
+  '.codex',
+  '.gemini',
+  '.github',
+  '.cursor',
+  '.cursor/rules',
+];
+
+// ─── fs.watch helpers (mirror pattern from src/watch.js) ──────────────────────
+
+function supportsNativeRecursiveWatch(platform) {
+  return (platform || process.platform) === 'win32' || (platform || process.platform) === 'darwin';
+}
+
+function statIfExists(fullPath) {
+  try {
+    return fs.statSync(fullPath);
+  } catch (_e) {
+    return null;
+  }
+}
+
+function listRecursiveDirectories(dir) {
+  const directories = [dir];
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (_e) {
+    return directories;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      directories.push(...listRecursiveDirectories(path.join(dir, entry.name)));
+    }
+  }
+  return directories;
+}
+
+/**
+ * Build a watch plan that covers all platform config files and directories.
+ */
+function buildHarmonyWatchPlan(rootDir, platform) {
+  const plan = [];
+  const seen = new Set();
+  const recursiveSupported = supportsNativeRecursiveWatch(platform);
+
+  const addTarget = (fullPath, recursive, source) => {
+    const resolved = path.resolve(fullPath);
+    const key = `${resolved}|${recursive}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    plan.push({ path: resolved, recursive, source });
+  };
+
+  // Watch repo root for top-level file creations
+  addTarget(rootDir, false, 'repo-root');
+
+  // Watch individual platform config files
+  for (const watchPath of PLATFORM_WATCH_FILES) {
+    const fullPath = path.join(rootDir, watchPath);
+    const stat = statIfExists(fullPath);
+    if (stat && stat.isFile()) {
+      addTarget(fullPath, false, watchPath);
+    }
+  }
+
+  // Watch platform config directories
+  for (const watchPath of PLATFORM_WATCH_DIRS) {
+    const fullPath = path.join(rootDir, watchPath);
+    const stat = statIfExists(fullPath);
+    if (!stat || !stat.isDirectory()) continue;
+
+    if (recursiveSupported) {
+      addTarget(fullPath, true, watchPath);
+    } else {
+      for (const dir of listRecursiveDirectories(fullPath)) {
+        addTarget(dir, false, watchPath);
+      }
+    }
+  }
+
+  return plan;
+}
+
+// ─── Watcher registration ─────────────────────────────────────────────────────
+
+function registerWatchers(rootDir, watchers, onChange, platform) {
+  const plan = buildHarmonyWatchPlan(rootDir, platform);
+
+  for (const item of plan) {
+    const key = `${item.path}|${item.recursive}`;
+    if (watchers.has(key)) continue;
+
+    try {
+      const watcher = fs.watch(item.path, { recursive: item.recursive }, (eventType, filename) => {
+        onChange(item, eventType, filename);
+      });
+      watchers.set(key, watcher);
+    } catch (_e) {
+      // Ignore unsupported or transient watch registration failures
+    }
+  }
+
+  return watchers.size;
+}
+
+function closeWatchers(watchers) {
+  for (const watcher of watchers.values()) {
+    try {
+      watcher.close();
+    } catch (_e) {
+      // Ignore close errors during shutdown
+    }
+  }
+  watchers.clear();
+}
+
+/**
+ * Identify which platform a changed file belongs to.
+ */
+function identifyPlatform(filePath) {
+  const normalized = filePath.replace(/\\/g, '/').toLowerCase();
+  if (normalized.includes('.claude') || normalized.includes('claude.md')) return 'claude';
+  if (normalized.includes('.codex') || normalized.includes('agents.md') || normalized.includes('codex.toml')) return 'codex';
+  if (normalized.includes('.gemini') || normalized.includes('gemini.md')) return 'gemini';
+  if (normalized.includes('copilot') || normalized.includes('.github')) return 'copilot';
+  if (normalized.includes('.cursor') || normalized.includes('cursorrules')) return 'cursor';
+  return 'unknown';
+}
+
+// ─── Main watch loop ──────────────────────────────────────────────────────────
+
+/**
+ * Start the harmony watch loop.
+ *
+ * @param {Object} options
+ * @param {string} options.dir - Root directory to watch
+ * @param {Function} [options.onDriftDetected] - Callback when drift increases: (platform, details) => void
+ * @param {Function} [options.onPlatformChange] - Callback on any platform config change: (platform, file) => void
+ * @param {Function} [options.runAudit] - Optional audit function to re-run on changes
+ * @param {number} [options.debounceMs=800] - Debounce interval in ms
+ */
+async function startHarmonyWatch(options) {
+  const {
+    dir,
+    onDriftDetected,
+    onPlatformChange,
+    runAudit,
+    debounceMs = 800,
+  } = options;
+
+  const recursiveSupported = supportsNativeRecursiveWatch();
+
+  console.log('');
+  console.log(c('  nerviq harmony watch', 'bold'));
+  console.log(c('  ═══════════════════════════════════════', 'dim'));
+  console.log(c(`  Watching: ${dir}`, 'dim'));
+  console.log(c(`  Platforms: Claude, Codex, Gemini, Copilot, Cursor`, 'dim'));
+  console.log(c(`  Mode: ${recursiveSupported ? 'native recursive' : 'expanded directory fallback'}`, 'dim'));
+  console.log(c('  Press Ctrl+C to stop', 'dim'));
+  console.log('');
+
+  // Initial audit if provided
+  let lastScores = {};
+  if (runAudit) {
+    try {
+      const results = await runAudit(dir);
+      if (results && typeof results === 'object') {
+        for (const [platform, result] of Object.entries(results)) {
+          lastScores[platform] = result.score || 0;
+        }
+      }
+      console.log(c('  Initial scores:', 'bold'));
+      for (const [platform, score] of Object.entries(lastScores)) {
+        console.log(`    ${platform}: ${scoreColor(score)}`);
+      }
+      console.log('');
+    } catch (e) {
+      console.log(c(`  Initial audit skipped: ${e.message}`, 'dim'));
+    }
+  }
+
+  const watchers = new Map();
+  let debounceTimer = null;
+  let shuttingDown = false;
+
+  const cleanupAndExit = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    clearTimeout(debounceTimer);
+    closeWatchers(watchers);
+    console.log('');
+    console.log(c('  Harmony watch stopped.', 'dim'));
+    process.exit(0);
+  };
+
+  const handleChange = (item, _eventType, filename) => {
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      const changedLabel = filename
+        ? String(filename)
+        : path.relative(dir, item.path) || path.basename(item.path);
+
+      const platform = identifyPlatform(changedLabel);
+      const timestamp = new Date().toLocaleTimeString();
+
+      console.log(c(`  [${timestamp}] Change: ${changedLabel} (${platform})`, 'dim'));
+
+      // Notify callback
+      if (onPlatformChange) {
+        try {
+          onPlatformChange(platform, changedLabel);
+        } catch (_e) {
+          // Ignore callback errors
+        }
+      }
+
+      // Re-register to pick up new dirs/files
+      registerWatchers(dir, watchers, handleChange);
+
+      // Re-audit if possible
+      if (runAudit) {
+        try {
+          const results = await runAudit(dir);
+          if (results && typeof results === 'object') {
+            for (const [p, result] of Object.entries(results)) {
+              const newScore = result.score || 0;
+              const oldScore = lastScores[p] || 0;
+              const delta = newScore - oldScore;
+
+              if (delta !== 0) {
+                const arrow = delta > 0
+                  ? c(`+${delta}`, 'green')
+                  : c(String(delta), 'yellow');
+                console.log(`    ${p}: ${scoreColor(newScore)} ${arrow}`);
+              }
+
+              // Drift detection
+              if (delta < 0 && onDriftDetected) {
+                try {
+                  onDriftDetected(p, { oldScore, newScore, delta, changedFile: changedLabel });
+                } catch (_e) {
+                  // Ignore callback errors
+                }
+              }
+
+              lastScores[p] = newScore;
+            }
+          }
+        } catch (_e) {
+          // Ignore transient errors during file saves
+        }
+      }
+
+      console.log('');
+    }, debounceMs);
+  };
+
+  registerWatchers(dir, watchers, handleChange);
+
+  if (watchers.size === 0) {
+    console.log(c('  Could not register any filesystem watchers.', 'yellow'));
+    return { watchers, close: () => {} };
+  }
+
+  process.once('SIGINT', cleanupAndExit);
+  process.once('SIGTERM', cleanupAndExit);
+
+  console.log(c(`  Watching ${watchers.size} targets for changes...`, 'dim'));
+  console.log('');
+
+  // Keep alive
+  await new Promise(() => {});
+}
+
+function scoreColor(score) {
+  const color = score >= 70 ? 'green' : score >= 40 ? 'yellow' : 'dim';
+  return c(`${score}/100`, color);
+}
+
+module.exports = {
+  startHarmonyWatch,
+  buildHarmonyWatchPlan,
+  PLATFORM_WATCH_FILES,
+  PLATFORM_WATCH_DIRS,
+  identifyPlatform,
+};

package/src/index.js

@@ -0,0 +1,256 @@
+const { audit } = require('./audit');
+const { setup } = require('./setup');
+const { analyzeProject } = require('./analyze');
+const { buildProposalBundle, applyProposalBundle } = require('./plans');
+const { getGovernanceSummary } = require('./governance');
+const { runBenchmark } = require('./benchmark');
+const { DOMAIN_PACKS, detectDomainPacks } = require('./domain-packs');
+const { MCP_PACKS, getMcpPack, mergeMcpServers, getMcpPackPreflight, recommendMcpPacks } = require('./mcp-packs');
+const { recordRecommendationOutcome, getRecommendationOutcomeSummary, formatRecommendationOutcomeSummary } = require('./activity');
+const { CodexProjectContext, detectCodexVersion } = require('./codex/context');
+const { formatSarif } = require('./formatters/sarif');
+const { CODEX_MCP_PACKS, recommendCodexMcpPacks, getCodexMcpPreflight, mergeCodexMcpToml } = require('./codex/mcp-packs');
+const { buildCodexProposalBundle } = require('./codex/plans');
+const { setupCodex } = require('./codex/setup');
+const {
+  getCodexHistory, formatCodexHistory, compareCodexLatest,
+  exportCodexTrendReport, recordCodexFeedback, formatCodexFeedback,
+  generateCodexInsights, formatCodexInsights,
+} = require('./codex/activity');
+const { getCodexGovernanceSummary } = require('./codex/governance');
+const {
+  patchAgentsMd, patchConfigToml, detectMixedAgentRepo, applyPatch,
+} = require('./codex/patch');
+const { checkReleaseGate, formatReleaseGate, getPropagationTargets } = require('./codex/freshness');
+const { runCodexDeepReview, collectCodexConfig, buildCodexReviewPayload } = require('./codex/deep-review');
+const { codexInteractive } = require('./codex/interactive');
+const { composePacks, getCiTemplate, CI_TEMPLATES, checkAdoptionGate } = require('./codex/premium');
+// Gemini CLI modules
+const { GeminiProjectContext, detectGeminiVersion } = require('./gemini/context');
+const { GEMINI_MCP_PACKS, recommendGeminiMcpPacks, getGeminiMcpPreflight, mergeGeminiMcpJson } = require('./gemini/mcp-packs');
+const { GEMINI_DOMAIN_PACKS, detectGeminiDomainPacks } = require('./gemini/domain-packs');
+const { buildGeminiProposalBundle } = require('./gemini/plans');
+const { setupGemini } = require('./gemini/setup');
+const { getGeminiGovernanceSummary } = require('./gemini/governance');
+const {
+  getGeminiHistory, formatGeminiHistory, compareGeminiLatest,
+  exportGeminiTrendReport, recordGeminiFeedback, formatGeminiFeedback,
+  generateGeminiInsights, formatGeminiInsights,
+} = require('./gemini/activity');
+const { patchGeminiMd, patchSettingsJson, detectMixedAgentRepo: detectMixedAgentRepoGemini } = require('./gemini/patch');
+const { checkReleaseGate: checkGeminiReleaseGate, formatReleaseGate: formatGeminiReleaseGate } = require('./gemini/freshness');
+const { runGeminiDeepReview, collectGeminiConfig } = require('./gemini/deep-review');
+const { geminiInteractive } = require('./gemini/interactive');
+const { composePacks: composeGeminiPacks, getCiTemplate: getGeminiCiTemplate, CI_TEMPLATES: GEMINI_CI_TEMPLATES, checkAdoptionGate: checkGeminiAdoptionGate } = require('./gemini/premium');
+// Copilot modules
+const { CopilotProjectContext } = require('./copilot/context');
+const { COPILOT_MCP_PACKS, recommendCopilotMcpPacks, getCopilotMcpPreflight } = require('./copilot/mcp-packs');
+const { COPILOT_DOMAIN_PACKS, detectCopilotDomainPacks } = require('./copilot/domain-packs');
+const { buildCopilotProposalBundle } = require('./copilot/plans');
+const { setupCopilot } = require('./copilot/setup');
+const { getCopilotGovernanceSummary } = require('./copilot/governance');
+const { getCopilotHistory, formatCopilotHistory, compareCopilotLatest, exportCopilotTrendReport, generateCopilotInsights } = require('./copilot/activity');
+const { runCopilotDeepReview } = require('./copilot/deep-review');
+const { copilotInteractive } = require('./copilot/interactive');
+const { composePacks: composeCopilotPacks, getCiTemplate: getCopilotCiTemplate, CI_TEMPLATES: COPILOT_CI_TEMPLATES, checkAdoptionGate: checkCopilotAdoptionGate } = require('./copilot/premium');
+// Cursor modules
+const { CursorProjectContext } = require('./cursor/context');
+const { CURSOR_MCP_PACKS, recommendCursorMcpPacks } = require('./cursor/mcp-packs');
+const { CURSOR_DOMAIN_PACKS, detectCursorDomainPacks } = require('./cursor/domain-packs');
+const { buildCursorProposalBundle } = require('./cursor/plans');
+const { setupCursor } = require('./cursor/setup');
+const { getCursorGovernanceSummary } = require('./cursor/governance');
+const { getCursorHistory, compareCursorLatest, generateCursorInsights } = require('./cursor/activity');
+const { runCursorDeepReview } = require('./cursor/deep-review');
+const { cursorInteractive } = require('./cursor/interactive');
+const { composePacks: composeCursorPacks, CI_TEMPLATES: CURSOR_CI_TEMPLATES, checkAdoptionGate: checkCursorAdoptionGate } = require('./cursor/premium');
+// Windsurf
+const { WindsurfProjectContext } = require('./windsurf/context');
+const { WINDSURF_DOMAIN_PACKS, detectWindsurfDomainPacks } = require('./windsurf/domain-packs');
+const { WINDSURF_MCP_PACKS } = require('./windsurf/mcp-packs');
+const { setupWindsurf } = require('./windsurf/setup');
+const { getWindsurfGovernanceSummary } = require('./windsurf/governance');
+const { runWindsurfDeepReview } = require('./windsurf/deep-review');
+const { windsurfInteractive } = require('./windsurf/interactive');
+// Aider
+const { AiderProjectContext } = require('./aider/context');
+const { AIDER_DOMAIN_PACKS, detectAiderDomainPacks } = require('./aider/domain-packs');
+const { setupAider } = require('./aider/setup');
+const { getAiderGovernanceSummary } = require('./aider/governance');
+const { runAiderDeepReview } = require('./aider/deep-review');
+const { aiderInteractive } = require('./aider/interactive');
+// OpenCode
+const { OpenCodeProjectContext } = require('./opencode/context');
+const { OPENCODE_DOMAIN_PACKS, detectOpenCodeDomainPacks } = require('./opencode/domain-packs');
+const { OPENCODE_MCP_PACKS } = require('./opencode/mcp-packs');
+const { setupOpenCode } = require('./opencode/setup');
+const { getOpenCodeGovernanceSummary } = require('./opencode/governance');
+const { runOpenCodeDeepReview } = require('./opencode/deep-review');
+const { opencodeInteractive } = require('./opencode/interactive');
+
+module.exports = {
+  audit,
+  setup,
+  analyzeProject,
+  buildProposalBundle,
+  applyProposalBundle,
+  getGovernanceSummary,
+  runBenchmark,
+  DOMAIN_PACKS,
+  detectDomainPacks,
+  MCP_PACKS,
+  getMcpPack,
+  mergeMcpServers,
+  getMcpPackPreflight,
+  recommendMcpPacks,
+  recordRecommendationOutcome,
+  getRecommendationOutcomeSummary,
+  formatRecommendationOutcomeSummary,
+  CodexProjectContext,
+  detectCodexVersion,
+  formatSarif,
+  // Codex CP-03: MCP Packs
+  CODEX_MCP_PACKS,
+  recommendCodexMcpPacks,
+  getCodexMcpPreflight,
+  mergeCodexMcpToml,
+  // Codex CP-05: Proposal Families
+  buildCodexProposalBundle,
+  // Codex CP-04: Setup Breadth
+  setupCodex,
+  // Codex CP-06: Repeat-Usage
+  getCodexHistory,
+  formatCodexHistory,
+  compareCodexLatest,
+  exportCodexTrendReport,
+  recordCodexFeedback,
+  formatCodexFeedback,
+  generateCodexInsights,
+  formatCodexInsights,
+  // Codex CP-09: Patch Intelligence
+  patchAgentsMd,
+  patchConfigToml,
+  detectMixedAgentRepo,
+  applyPatch,
+  // Codex CP-10: Governance
+  getCodexGovernanceSummary,
+  // Codex CP-12: Freshness
+  checkReleaseGate,
+  formatReleaseGate,
+  getPropagationTargets,
+  // Codex CP-13: Deep Review
+  runCodexDeepReview,
+  collectCodexConfig,
+  buildCodexReviewPayload,
+  // Codex CP-14: Interactive
+  codexInteractive,
+  // Codex CP-15: Premium
+  composePacks,
+  getCiTemplate,
+  CI_TEMPLATES,
+  checkAdoptionGate,
+  // Gemini CLI
+  GeminiProjectContext,
+  detectGeminiVersion,
+  GEMINI_MCP_PACKS,
+  recommendGeminiMcpPacks,
+  getGeminiMcpPreflight,
+  mergeGeminiMcpJson,
+  GEMINI_DOMAIN_PACKS,
+  detectGeminiDomainPacks,
+  buildGeminiProposalBundle,
+  setupGemini,
+  getGeminiGovernanceSummary,
+  getGeminiHistory,
+  formatGeminiHistory,
+  compareGeminiLatest,
+  exportGeminiTrendReport,
+  recordGeminiFeedback,
+  formatGeminiFeedback,
+  generateGeminiInsights,
+  formatGeminiInsights,
+  patchGeminiMd,
+  patchSettingsJson,
+  detectMixedAgentRepoGemini,
+  checkGeminiReleaseGate,
+  formatGeminiReleaseGate,
+  runGeminiDeepReview,
+  collectGeminiConfig,
+  geminiInteractive,
+  composeGeminiPacks,
+  getGeminiCiTemplate,
+  GEMINI_CI_TEMPLATES,
+  checkGeminiAdoptionGate,
+  // Copilot
+  CopilotProjectContext,
+  COPILOT_MCP_PACKS,
+  recommendCopilotMcpPacks,
+  getCopilotMcpPreflight,
+  COPILOT_DOMAIN_PACKS,
+  detectCopilotDomainPacks,
+  buildCopilotProposalBundle,
+  setupCopilot,
+  getCopilotGovernanceSummary,
+  getCopilotHistory,
+  formatCopilotHistory,
+  compareCopilotLatest,
+  exportCopilotTrendReport,
+  generateCopilotInsights,
+  runCopilotDeepReview,
+  copilotInteractive,
+  composeCopilotPacks,
+  getCopilotCiTemplate,
+  COPILOT_CI_TEMPLATES,
+  checkCopilotAdoptionGate,
+  // Cursor
+  CursorProjectContext, CURSOR_MCP_PACKS, recommendCursorMcpPacks,
+  CURSOR_DOMAIN_PACKS, detectCursorDomainPacks, buildCursorProposalBundle,
+  setupCursor, getCursorGovernanceSummary, getCursorHistory,
+  compareCursorLatest, generateCursorInsights, runCursorDeepReview,
+  cursorInteractive, composeCursorPacks, CURSOR_CI_TEMPLATES, checkCursorAdoptionGate,
+  // Windsurf
+  WindsurfProjectContext, WINDSURF_DOMAIN_PACKS, detectWindsurfDomainPacks, WINDSURF_MCP_PACKS,
+  setupWindsurf, getWindsurfGovernanceSummary, runWindsurfDeepReview, windsurfInteractive,
+  // Aider
+  AiderProjectContext, AIDER_DOMAIN_PACKS, detectAiderDomainPacks,
+  setupAider, getAiderGovernanceSummary, runAiderDeepReview, aiderInteractive,
+  // OpenCode
+  OpenCodeProjectContext, OPENCODE_DOMAIN_PACKS, detectOpenCodeDomainPacks, OPENCODE_MCP_PACKS,
+  setupOpenCode, getOpenCodeGovernanceSummary, runOpenCodeDeepReview, opencodeInteractive,
+  // Harmony (cross-platform)
+  ...(() => {
+    const { buildCanonicalModel, detectActivePlatforms } = require('./harmony/canon');
+    const { detectDrift, formatDriftReport } = require('./harmony/drift');
+    const { harmonyAudit, formatHarmonyAuditReport } = require('./harmony/audit');
+    const { generateHarmonySync, applyHarmonySync, previewHarmonySync } = require('./harmony/sync');
+    const { generateStrategicAdvice, PLATFORM_STRENGTHS } = require('./harmony/advisor');
+    const { startHarmonyWatch } = require('./harmony/watch');
+    const { saveHarmonyState, loadHarmonyState, getHarmonyHistory } = require('./harmony/memory');
+    const { getHarmonyGovernanceSummary, formatHarmonyGovernanceReport } = require('./harmony/governance');
+    return {
+      buildCanonicalModel, detectActivePlatforms, detectDrift, formatDriftReport,
+      harmonyAudit, formatHarmonyAuditReport,
+      generateHarmonySync, applyHarmonySync, previewHarmonySync,
+      generateStrategicAdvice, PLATFORM_STRENGTHS,
+      startHarmonyWatch, saveHarmonyState, loadHarmonyState, getHarmonyHistory,
+      getHarmonyGovernanceSummary, formatHarmonyGovernanceReport,
+    };
+  })(),
+  // Synergy (cross-platform amplification)
+  ...(() => {
+    const { propagateInsight, getCrossLearnings } = require('./synergy/learning');
+    const { routeTask, classifyTaskType, PLATFORM_CAPABILITIES } = require('./synergy/routing');
+    const { compoundAudit, calculateAmplification } = require('./synergy/evidence');
+    const { analyzeCompensation, getUncoveredGaps } = require('./synergy/compensation');
+    const { discoverPatterns } = require('./synergy/patterns');
+    const { rankRecommendations, calculateSynergyScore } = require('./synergy/ranking');
+    const { generateSynergyReport } = require('./synergy/report');
+    const { detectProjectChanges, generateAdaptiveUpdates } = require('./synergy/adaptive');
+    return {
+      propagateInsight, getCrossLearnings, routeTask, classifyTaskType, PLATFORM_CAPABILITIES,
+      compoundAudit, calculateAmplification, analyzeCompensation, getUncoveredGaps,
+      discoverPatterns, rankRecommendations, calculateSynergyScore,
+      generateSynergyReport, detectProjectChanges, generateAdaptiveUpdates,
+    };
+  })(),
+};