nexus-agents 2.29.0 → 2.29.2

package/dist/chunk-GX436VRU.js

@@ -0,0 +1,931 @@
+import {
+  ParseError,
+  SecurityError,
+  getErrorMessage
+} from "./chunk-HSOPD265.js";
+
+// src/cli/research-helpers-io.ts
+import * as fs from "fs/promises";
+import { join, resolve as resolve2 } from "path";
+
+// src/security/safe-path.ts
+import { resolve, sep } from "path";
+function resolveInsideRoot(filePath, root = process.cwd()) {
+  const resolvedRoot = resolve(root);
+  const resolved = resolve(resolvedRoot, filePath);
+  if (resolved === resolvedRoot) return resolved;
+  if (resolved.startsWith(resolvedRoot + sep)) return resolved;
+  return null;
+}
+
+// src/cli/research-helpers-io.ts
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var REGISTRY_PATH = "docs/research/registry";
+var TECHNIQUES_FILE = "techniques.yaml";
+var PAPERS_FILE = "papers.yaml";
+function getProjectRoot() {
+  return process.cwd();
+}
+function validatePath(constructedPath, allowedRoot) {
+  const resolved = resolveInsideRoot(constructedPath, allowedRoot);
+  if (resolved === null) {
+    return {
+      ok: false,
+      error: new SecurityError("Path traversal detected: path escapes allowed root directory", {
+        context: { constructedPath, allowedRoot: resolve2(allowedRoot) }
+      })
+    };
+  }
+  return { ok: true, value: resolved };
+}
+async function loadTechniquesRegistry(rootDir) {
+  const root = rootDir ?? process.cwd();
+  const filePath = join(root, REGISTRY_PATH, TECHNIQUES_FILE);
+  const pathValidation = validatePath(filePath, root);
+  if (!pathValidation.ok) {
+    return pathValidation;
+  }
+  try {
+    const content = await fs.readFile(pathValidation.value, "utf-8");
+    return { ok: true, value: parseYaml(content) };
+  } catch (error) {
+    const message = getErrorMessage(error);
+    return { ok: false, error: new ParseError(`Failed to load techniques registry: ${message}`) };
+  }
+}
+async function loadPapersRegistry(rootDir) {
+  const root = rootDir ?? process.cwd();
+  const filePath = join(root, REGISTRY_PATH, PAPERS_FILE);
+  const pathValidation = validatePath(filePath, root);
+  if (!pathValidation.ok) {
+    return pathValidation;
+  }
+  try {
+    const content = await fs.readFile(pathValidation.value, "utf-8");
+    return { ok: true, value: parseYaml(content) };
+  } catch (error) {
+    const message = getErrorMessage(error);
+    return { ok: false, error: new ParseError(`Failed to load papers registry: ${message}`) };
+  }
+}
+async function savePapersRegistry(registry, rootDir) {
+  const root = rootDir ?? process.cwd();
+  const filePath = join(root, REGISTRY_PATH, PAPERS_FILE);
+  const pathValidation = validatePath(filePath, root);
+  if (!pathValidation.ok) {
+    return pathValidation;
+  }
+  try {
+    const content = stringifyYaml(registry, { lineWidth: 100 });
+    await fs.writeFile(pathValidation.value, content, "utf-8");
+    return { ok: true, value: void 0 };
+  } catch (error) {
+    const message = getErrorMessage(error);
+    return { ok: false, error: new ParseError(`Failed to save papers registry: ${message}`) };
+  }
+}
+
+// src/cli/research-alignment-map.ts
+var TECHNIQUE_IMPLEMENTATION_MAP = /* @__PURE__ */ new Map([
+  // Routing techniques
+  ["linucb-routing", { status: "implemented", path: "cli-adapters/linucb-bandit.ts" }],
+  ["topsis-routing", { status: "implemented", path: "cli-adapters/topsis-router.ts" }],
+  [
+    "cascade-routing",
+    { status: "implemented", path: "routing/stages/confidence-cascade-stage.ts" }
+  ],
+  [
+    "complexity-based-routing",
+    { status: "implemented", path: "routing/stages/confidence-cascade-stage.ts" }
+  ],
+  [
+    "moe-routing",
+    {
+      status: "implemented",
+      path: "cli-adapters/composite-router.ts",
+      hint: "5-stage composite routing selects among specialized CLI experts based on task features"
+    }
+  ],
+  ["two-stage-routing", { status: "implemented", path: "cli-adapters/composite-router-stages.ts" }],
+  [
+    "capability-instruction-tuning",
+    {
+      status: "partial",
+      path: "routing/stages/capability-match-stage.ts",
+      hint: "Static capability profiles, not instruction-tuned"
+    }
+  ],
+  [
+    "knn-routing",
+    {
+      status: "implemented",
+      path: "routing/stages/knn-routing-stage.ts",
+      hint: "KnnRoutingStage: cosine similarity over keyword vectors, K-nearest experience patterns, weighted by success rate"
+    }
+  ],
+  ["pilot-budget-routing", { status: "implemented", path: "cli-adapters/budget-router.ts" }],
+  [
+    "tolerance-routing",
+    {
+      status: "implemented",
+      path: "cli-adapters/composite-router-helpers.ts",
+      hint: "TOPSIS_TOLERANCE_BAND_PERCENT (5%) identifies quality-equivalent candidates after TOPSIS ranking"
+    }
+  ],
+  [
+    "sater-routing",
+    {
+      status: "implemented",
+      path: "routing/stages/quality-constraint-stage.ts",
+      hint: "QualityConstraintStage filters models by min quality (0.7), max cost, max latency before selection"
+    }
+  ],
+  [
+    "preference-trained-routing",
+    { status: "implemented", path: "cli-adapters/preference-router.ts" }
+  ],
+  [
+    "strmac-state-routing",
+    {
+      status: "implemented",
+      path: "context/routing-memory.ts",
+      hint: "RoutingMemory maintains state across calls (profile, experience, action cache) feeding LinUCB + weather bonus stages"
+    }
+  ],
+  [
+    "cross-attention-routing",
+    {
+      status: "implemented",
+      path: "routing/stages/capability-match-stage.ts",
+      hint: "AttentionMatrix maps task features to capability weights (configurable cross-attention)"
+    }
+  ],
+  // Consensus techniques
+  ["consensus-protocol", { status: "implemented", path: "consensus/engine.ts" }],
+  ["majority-voting", { status: "implemented", path: "consensus/engine.ts" }],
+  ["higher-order-voting", { status: "implemented", path: "consensus/higher-order-strategy.ts" }],
+  [
+    "anti-conformity-weighting",
+    { status: "implemented", path: "consensus/higher-order-strategy.ts" }
+  ],
+  [
+    "agreement-based-cascading",
+    {
+      status: "implemented",
+      path: "consensus/engine.ts",
+      hint: "canCascadeEarly() closes proposals when outcome is mathematically determined"
+    }
+  ],
+  [
+    "incremental-quorum",
+    {
+      status: "implemented",
+      path: "consensus/incremental-quorum.ts",
+      hint: "Ambiguity detection + voter expansion via VoterExpansionCallback (#1408)"
+    }
+  ],
+  [
+    "aegean-consensus",
+    { status: "partial", path: "consensus/engine.ts", hint: "Byzantine tolerance not implemented" }
+  ],
+  [
+    "cp-wbft-consensus",
+    {
+      status: "partial",
+      path: "consensus/engine.ts",
+      hint: "No weighted Byzantine fault tolerance"
+    }
+  ],
+  // Memory techniques
+  ["adaptive-memory", { status: "implemented", path: "memory/adaptive/" }],
+  ["mirix-six-type-memory", { status: "implemented", path: "memory/typed/" }],
+  [
+    "mem0-memory-architecture",
+    { status: "partial", path: "memory/", hint: "Multi-backend memory but not mem0 pattern" }
+  ],
+  [
+    "graph-based-memory",
+    {
+      status: "partial",
+      path: "memory/belief/",
+      hint: "Belief triples are graph-like but not full graph DB"
+    }
+  ],
+  ["experience-memory", { status: "implemented", path: "memory/session/" }],
+  ["hindsight-belief-memory", { status: "implemented", path: "memory/belief/" }],
+  [
+    "profile-memory",
+    {
+      status: "implemented",
+      path: "context/routing-memory.ts",
+      hint: "RoutingMemory stores model preferences per task type and feeds recommendations into composite router via PERSISTENCE_AWARE_FLAGS"
+    }
+  ],
+  [
+    "action-memory",
+    {
+      status: "implemented",
+      path: "orchestration/outcomes/",
+      hint: "OutcomeStore records actions+results+context with query-by-category/CLI/time and cross-session persistence"
+    }
+  ],
+  ["reflection-memory", { status: "implemented", path: "mcp/tools/orchestrate-reflection.ts" }],
+  [
+    "history-encoding",
+    {
+      status: "partial",
+      path: "context/token-counter.ts",
+      hint: "Token counting exists but no learned history encoding"
+    }
+  ],
+  // Orchestration techniques
+  [
+    "aflow-mcts-workflows",
+    {
+      status: "partial",
+      path: "workflows/aflow/",
+      hint: "AFlow scaffolding exists but MCTS not implemented"
+    }
+  ],
+  [
+    "dynamic-agent-selection",
+    { status: "implemented", path: "orchestration/aorchestra/agent-planner.ts" }
+  ],
+  ["dynamic-subagent-creation", { status: "implemented", path: "mcp/tools/create-expert.ts" }],
+  ["role-based-protocols", { status: "implemented", path: "agents/expert-roles.ts" }],
+  [
+    "rule-based-coordination",
+    { status: "implemented", path: "orchestration/aorchestra/worker-dispatcher.ts" }
+  ],
+  [
+    "temporal-graph-orchestration",
+    {
+      status: "partial",
+      path: "orchestration/graph/",
+      hint: "Graph workflows exist but not temporal-aware"
+    }
+  ],
+  [
+    "model-based-coordination",
+    {
+      status: "partial",
+      path: "orchestration/aorchestra/",
+      hint: "Worker dispatch but not model-based coordination theory"
+    }
+  ],
+  [
+    "trinity-roles",
+    {
+      status: "partial",
+      path: "agents/expert-roles.ts",
+      hint: "10 expert roles, not trinity pattern"
+    }
+  ],
+  [
+    "sew-self-evolving-workflows",
+    {
+      status: "partial",
+      path: "workflows/aflow/",
+      hint: "AFlow framework but no self-evolution loop"
+    }
+  ],
+  [
+    "scaling-coordination-predictor",
+    {
+      status: "partial",
+      path: "orchestration/aorchestra/agent-planner.ts",
+      hint: "Wave sizing but no scaling prediction"
+    }
+  ],
+  // Learning techniques
+  [
+    "self-refine-loop",
+    {
+      status: "implemented",
+      path: "mcp/tools/orchestrate-dispatch.ts"
+    }
+  ],
+  [
+    "recursive-improvement",
+    {
+      status: "implemented",
+      path: "mcp/tools/orchestrate-dispatch.ts"
+    }
+  ],
+  [
+    "rl-orchestrator",
+    {
+      status: "implemented",
+      path: "cli-adapters/linucb-bandit.ts",
+      hint: "LinUCB contextual bandit actively selects models via explore-exploit in routing pipeline"
+    }
+  ],
+  ["reflexion-verbal-rl", { status: "implemented", path: "mcp/tools/orchestrate-reflection.ts" }],
+  // Source-derived techniques (Wave 6 — from open-source project analysis)
+  ["failure-lesson-injection", { status: "implemented", path: "orchestration/failure-lessons.ts" }],
+  [
+    "skill-relevance-matching",
+    {
+      status: "implemented",
+      path: "agents/experts/skill-matcher.ts",
+      hint: "Matches task keywords to agent skill descriptions for optimal routing"
+    }
+  ],
+  [
+    "context-rot-prevention",
+    {
+      status: "implemented",
+      path: "agents/context-pruner.ts",
+      hint: "Token-efficient context pruning prevents quality degradation in long sessions"
+    }
+  ],
+  [
+    "wave-based-parallel-execution",
+    {
+      status: "implemented",
+      path: "orchestration/aorchestra/worker-dispatcher.ts",
+      hint: "AOrchestra worker dispatch with cross-wave context sharing"
+    }
+  ],
+  [
+    "write-time-deduplication",
+    {
+      status: "implemented",
+      path: "mcp/tools/memory-write.ts",
+      hint: "Semantic dedup at write time prevents memory bloat"
+    }
+  ]
+]);
+var FEATURE_GATE_INVENTORY = [
+  {
+    envVar: "NEXUS_V2_MODE",
+    defaultValue: "full",
+    description: "V2 pipeline mode (off/partial/full)",
+    techniques: ["two-stage-routing", "cascade-routing"]
+  },
+  {
+    envVar: "NEXUS_AORCHESTRA",
+    defaultValue: "true",
+    description: "AOrchestra dynamic agent planning",
+    techniques: ["dynamic-agent-selection", "model-based-coordination"]
+  },
+  {
+    envVar: "NEXUS_AORCHESTRA_DISPATCH",
+    defaultValue: "true",
+    description: "AOrchestra worker dispatch",
+    techniques: ["rule-based-coordination", "self-refine-loop"]
+  },
+  {
+    envVar: "NEXUS_PERSIST_LEARNING",
+    defaultValue: "true",
+    description: "Cross-session routing persistence",
+    techniques: ["linucb-routing", "preference-trained-routing", "experience-memory"]
+  },
+  {
+    envVar: "NEXUS_REFLECTIVE_MEMORY",
+    defaultValue: "shadow",
+    description: "Reflective memory retrieval (shadow=default, true=full, false=off)",
+    techniques: ["reflection-memory", "adaptive-memory", "reflexion-verbal-rl"]
+  },
+  {
+    envVar: "NEXUS_BILLING_MODE",
+    defaultValue: "plan",
+    description: "Cost mode (plan=strongest, api=cost-aware)",
+    techniques: ["pilot-budget-routing", "topsis-routing"]
+  },
+  {
+    envVar: "NEXUS_WORKER_MAX_CALLS",
+    defaultValue: "6",
+    description: "Max model calls per orchestrate",
+    techniques: ["self-refine-loop", "recursive-improvement"]
+  },
+  { envVar: "NEXUS_AUTH_ENABLED", defaultValue: "true", description: "Server authentication" },
+  { envVar: "NEXUS_EVENTBUS_ENABLED", defaultValue: "true", description: "EventBus A2A bridge" },
+  {
+    envVar: "NEXUS_RATE_LIMIT_ENABLED",
+    defaultValue: "true",
+    description: "Token-bucket rate limiter"
+  },
+  {
+    envVar: "NEXUS_CIRCUIT_BREAKER_THRESHOLD",
+    defaultValue: "5",
+    description: "Circuit breaker failure threshold"
+  },
+  {
+    envVar: "NEXUS_V2_POLICY_MODE",
+    defaultValue: "block",
+    description: "Policy enforcement (off/warn/block)"
+  },
+  { envVar: "NEXUS_LOG_LEVEL", defaultValue: "info", description: "Logging verbosity" },
+  {
+    envVar: "NEXUS_DISABLE_SESSIONS",
+    defaultValue: "false",
+    description: "Disable session tracking"
+  },
+  {
+    envVar: "NEXUS_DISABLE_METRICS",
+    defaultValue: "false",
+    description: "Disable metrics tracking"
+  },
+  {
+    envVar: "NEXUS_ALLOW_MOCK_ORCHESTRATION",
+    defaultValue: "false",
+    description: "Allow mock orchestration (test/CI)"
+  },
+  {
+    envVar: "NEXUS_MAX_CONCURRENT_EXPERTS",
+    defaultValue: "6",
+    description: "Expert pool semaphore capacity"
+  },
+  {
+    envVar: "NEXUS_VOTE_TIMEOUT_MS",
+    defaultValue: "60000",
+    description: "Consensus vote timeout override"
+  },
+  {
+    envVar: "NEXUS_EXPERT_TIMEOUT_MS",
+    defaultValue: "120000",
+    description: "Expert handler timeout override"
+  },
+  {
+    envVar: "NEXUS_WORKER_TIMEOUT_MS",
+    defaultValue: "60000",
+    description: "Worker subprocess timeout override"
+  }
+];
+
+// src/research/topic-aliases.ts
+var TOPIC_ALIASES = {
+  // → consensus
+  voting: "consensus",
+  "consensus-voting": "consensus",
+  debate: "consensus",
+  quorum: "consensus",
+  byzantine: "consensus",
+  "anti-conformity": "consensus",
+  "agreement-based": "consensus",
+  "correlation-aware": "consensus",
+  "LLM consensus and multi-agent voting mechanisms": "consensus",
+  "tolerance-parameter": "consensus",
+  // → routing
+  "model-routing": "routing",
+  "model routing": "routing",
+  "llm-routing": "routing",
+  cascade: "routing",
+  "cascade-routing": "routing",
+  "cost-optimization": "routing",
+  "cost-reduction": "routing",
+  "model-selection": "routing",
+  topsis: "routing",
+  linucb: "routing",
+  "contextual-bandit": "routing",
+  "quality-constrained": "routing",
+  "budget-constraints": "routing",
+  "unified-routing": "routing",
+  "query-model-matching": "routing",
+  "adaptive model routing and selection optimization": "routing",
+  "multi-model routing optimization": "routing",
+  "Single-head cross-attention for query-model matching": "routing",
+  "performance-cost-tradeoff": "routing",
+  "task-routing": "routing",
+  "difficulty-estimation": "routing",
+  "score-based": "routing",
+  "optimal-weighting": "routing",
+  "hierarchical-filtering": "routing",
+  "preference-optimization": "routing",
+  "preference-data": "routing",
+  dpo: "routing",
+  "cross-attention": "routing",
+  "cma-es": "routing",
+  profile: "routing",
+  prediction: "routing",
+  lightweight: "routing",
+  bayesian: "routing",
+  "quality-diversity": "routing",
+  "resource-optimization": "routing",
+  "routing-latency": "routing",
+  optimization: "routing",
+  "model-merging": "routing",
+  "model-zoo": "routing",
+  // → memory
+  "context-management": "memory",
+  "context-compression": "memory",
+  "context-control": "memory",
+  compression: "memory",
+  "kv-cache": "memory",
+  "long-context": "memory",
+  "long-term-memory": "memory",
+  "episodic-memory": "memory",
+  "graph-memory": "memory",
+  "hierarchical-memory": "memory",
+  "agentic-memory": "memory",
+  "lifelong-learning": "memory",
+  "cross-session-learning": "memory",
+  "continual-learning": "memory",
+  "self-editing-memory": "memory",
+  "six-type-memory": "memory",
+  "belief-memory": "memory",
+  "belief-state": "memory",
+  "action-memory": "memory",
+  "memory-evolution": "memory",
+  "virtual-context": "memory",
+  paging: "memory",
+  "prompt-compression": "memory",
+  "learned-compression": "memory",
+  zettelkasten: "memory",
+  "knowledge-distillation": "memory",
+  "history-encoding": "memory",
+  "ictm-tuple": "memory",
+  "latent-space": "memory",
+  "vector-db": "memory",
+  embedding: "memory",
+  "Taxonomy of context management strategies": "memory",
+  "Task-specific context compression": "memory",
+  "Learned compression modules": "memory",
+  rag: "memory",
+  "retrieval augmented generation": "memory",
+  svd: "memory",
+  "svd-mutation": "memory",
+  vae: "memory",
+  knn: "memory",
+  experience: "memory",
+  "state-aware": "memory",
+  "temporal-graph": "memory",
+  versioning: "memory",
+  // → code-generation
+  "code-repair": "code-generation",
+  "code-agent": "code-generation",
+  "code-review": "code-generation",
+  "software-engineering": "code-generation",
+  "swe-bench": "code-generation",
+  "self-improvement": "code-generation",
+  "self-evolving": "code-generation",
+  "self-debug": "code-generation",
+  "self-modification": "code-generation",
+  "skill-library": "code-generation",
+  "skill-discovery": "code-generation",
+  "code review benchmarks": "code-generation",
+  "code generation evaluation": "code-generation",
+  "execution-feedback": "code-generation",
+  // → cli-tools
+  mcp: "cli-tools",
+  "MCP protocol": "cli-tools",
+  "MCP security": "cli-tools",
+  "MCP Security": "cli-tools",
+  "mcp-applications": "cli-tools",
+  "model-context-protocol": "cli-tools",
+  puppeteer: "cli-tools",
+  streaming: "cli-tools",
+  integration: "cli-tools",
+  // → orchestration
+  "multi-agent": "orchestration",
+  "multi-agent-systems": "orchestration",
+  "multi-agent orchestration": "orchestration",
+  "Multi-Agent Orchestration": "orchestration",
+  "multi-agent-orchestration": "orchestration",
+  "multi-agent coordination": "orchestration",
+  "multi-agent-coordination": "orchestration",
+  "multi-agent-worker-dispatch": "orchestration",
+  "multi-agent reliability": "orchestration",
+  "multi-agent-rl": "orchestration",
+  coordination: "orchestration",
+  coordinator: "orchestration",
+  collaboration: "orchestration",
+  "graph-orchestration": "orchestration",
+  "agent architecture": "orchestration",
+  "dynamic-agent-creation": "orchestration",
+  "specialized-agents": "orchestration",
+  "thinker-worker-verifier": "orchestration",
+  "two-agent": "orchestration",
+  "meta-agent": "orchestration",
+  agents: "orchestration",
+  "workflow-optimization": "orchestration",
+  "workflow-generation": "orchestration",
+  "agent-communication": "orchestration",
+  "inter-agent": "orchestration",
+  "gvu-operator": "orchestration",
+  "rubber-duck": "orchestration",
+  "parallel-exploration": "orchestration",
+  kubernetes: "orchestration",
+  "scale-to-zero": "orchestration",
+  edge: "orchestration",
+  llm: "orchestration",
+  multimodal: "orchestration",
+  production: "orchestration",
+  hybrid: "orchestration",
+  "automatic-discovery": "orchestration",
+  roadmap: "orchestration",
+  // → security
+  "prompt injection defense": "security",
+  "inter-agent-security": "security",
+  "agent security": "security",
+  compliance: "security",
+  "formal-verification": "security",
+  "formal-safety": "security",
+  // → evaluation
+  benchmark: "evaluation",
+  benchmarking: "evaluation",
+  survey: "evaluation",
+  "autonomous agent evaluation benchmarks": "evaluation",
+  "evaluation-methods": "evaluation",
+  "LLM evaluation": "evaluation",
+  "hallucination-detection": "evaluation",
+  "self-evaluation": "evaluation",
+  "confidence-probe": "evaluation",
+  "confidence-aware": "evaluation",
+  verifier: "evaluation",
+  observability: "evaluation",
+  theoretical: "evaluation",
+  "post-deployment": "evaluation",
+  capability: "evaluation",
+  "knowledge-gaps": "evaluation",
+  helm: "evaluation",
+  // → safety
+  "agentic-safety": "safety",
+  "agentic AI safety": "safety",
+  "safety-evaluation": "safety",
+  "reward-modeling": "safety",
+  "constitutional-ai": "safety",
+  "hazard-analysis": "safety",
+  stpa: "safety",
+  "risk-assessment": "safety",
+  "fault-tolerance": "safety",
+  "ai-feedback": "safety",
+  rlaif: "safety",
+  "human-in-the-loop": "safety",
+  feedback: "safety",
+  "feedback-loop": "safety",
+  "feedback-learning": "safety",
+  anthropic: "safety",
+  // → planning
+  "decision-making": "planning",
+  "tree-search": "planning",
+  "tree-structure": "planning",
+  "multi-tree": "planning",
+  mcts: "planning",
+  backtrack: "planning",
+  hindsight: "planning",
+  "task-specific": "planning",
+  // → tool-use
+  "tool use": "tool-use",
+  "tool-augmented reasoning and function calling": "tool-use",
+  "tool routing optimization": "tool-use",
+  "dynamic-linking": "tool-use",
+  "Sparse outcome rewards reduce tool calls by 72%": "tool-use",
+  // → reasoning
+  "test-time": "reasoning",
+  "test-time-scaling": "reasoning",
+  "inference-scaling": "reasoning",
+  "inference-optimization": "reasoning",
+  "self-critique": "reasoning",
+  "self-reflection": "reasoning",
+  "self-referential": "reasoning",
+  "self-play": "reasoning",
+  reflexion: "reasoning",
+  reflection: "reasoning",
+  "reasoning-optimization": "reasoning",
+  "meta-thinking": "reasoning",
+  scaling: "reasoning",
+  recursive: "reasoning",
+  "trajectory-abstraction": "reasoning",
+  "verbal-rl": "reasoning",
+  exploration: "reasoning",
+  "Reducible uncertainty modeling across agent trajectories": "reasoning",
+  "Environmental feedback reduces uncertainty at decision gates": "reasoning",
+  "reinforcement-learning": "reasoning",
+  transformer: "reasoning",
+  ssm: "reasoning",
+  "sparse-activation": "reasoning",
+  "behavior-distillation": "reasoning",
+  "training-free": "reasoning",
+  "transfer-learning": "reasoning",
+  "instruction-tuning": "reasoning",
+  "Dense process rewards improve performance by 22%": "reasoning",
+  "prompt-optimization": "reasoning"
+};
+function normalizeTopicToCanonical(topic) {
+  return TOPIC_ALIASES[topic] ?? topic;
+}
+
+// src/cli/research-helpers-synthesize.ts
+var MIN_CROSS_CUTTING_CLUSTER_SIZE = 2;
+var CROSS_CUTTING_TAG_THRESHOLD = 3;
+async function synthesizeResearch(topicFilter) {
+  const registryResult = await loadPapersRegistry();
+  if (!registryResult.ok) {
+    return {
+      ok: false,
+      error: {
+        code: "LOAD_ERROR",
+        message: `Failed to load papers: ${getErrorMessage(registryResult.error)}`
+      }
+    };
+  }
+  const papers = extractPapers(registryResult.value);
+  if (papers.length === 0) {
+    return {
+      ok: false,
+      error: { code: "NO_PAPERS", message: "No papers found in registry" }
+    };
+  }
+  const clusters = groupByTopic(papers);
+  const filtered = topicFilter !== void 0 ? clusters.filter((c) => c.topic === topicFilter) : clusters;
+  const syntheses = filtered.map(synthesizeCluster);
+  const crossCutting = findCrossCuttingThemes(filtered);
+  const alignmentSummary = buildAlignmentSummary(syntheses);
+  const featureGates = buildFeatureGateSummary();
+  return {
+    ok: true,
+    value: {
+      clusters: syntheses,
+      totalPapers: papers.length,
+      topicCount: filtered.length,
+      crossCuttingThemes: crossCutting,
+      alignmentSummary,
+      featureGates
+    }
+  };
+}
+function safeArray(value) {
+  if (value === null || value === void 0) return [];
+  return Array.from(value);
+}
+function extractPapers(registry) {
+  return Object.entries(registry.papers).map(([id, p]) => ({
+    id,
+    title: p.title,
+    topics: safeArray(p.topics),
+    tags: safeArray(p.tags),
+    summary: p.summary.trim(),
+    keyFindings: safeArray(p.key_findings),
+    relevance: p.relevance,
+    implementationStatus: p.implementation_status,
+    techniquesExtracted: safeArray(p.techniques_extracted),
+    qualityScore: p.quality_score ?? 0,
+    evidenceTier: p.evidence_tier ?? "low"
+  }));
+}
+function groupByTopic(papers) {
+  const topicMap = /* @__PURE__ */ new Map();
+  for (const paper of papers) {
+    for (const rawTopic of paper.topics) {
+      const topic = normalizeTopicToCanonical(rawTopic);
+      const existing = topicMap.get(topic);
+      if (existing !== void 0) {
+        existing.push(paper);
+      } else {
+        topicMap.set(topic, [paper]);
+      }
+    }
+  }
+  const clusters = [];
+  for (const [topic, unsortedPapers] of topicMap) {
+    const topicPapers = [...unsortedPapers].sort((a, b) => b.qualityScore - a.qualityScore);
+    clusters.push({
+      topic,
+      papers: topicPapers,
+      paperCount: topicPapers.length
+    });
+  }
+  return clusters.sort((a, b) => b.paperCount - a.paperCount);
+}
+function computeClusterQuality(papers) {
+  const scores = papers.map((p) => p.qualityScore);
+  const totalScore = scores.reduce((sum, s) => sum + s, 0);
+  return {
+    avgScore: scores.length > 0 ? Math.round(totalScore / scores.length * 10) / 10 : 0,
+    high: papers.filter((p) => p.evidenceTier === "high").length,
+    medium: papers.filter((p) => p.evidenceTier === "medium").length,
+    low: papers.filter((p) => p.evidenceTier === "low").length
+  };
+}
+function synthesizeCluster(cluster) {
+  const allTags = collectFrequencies(cluster.papers.flatMap((p) => [...p.tags]));
+  const allTechniques = collectFrequencies(
+    cluster.papers.flatMap((p) => [...p.techniquesExtracted])
+  );
+  const allFindings = cluster.papers.flatMap((p) => [...p.keyFindings]);
+  const commonThemes = [...allTags.entries()].filter(([, count]) => count >= MIN_CROSS_CUTTING_CLUSTER_SIZE).sort((a, b) => b[1] - a[1]).map(([tag]) => tag);
+  const techniques = [...allTechniques.entries()].sort((a, b) => b[1] - a[1]).map(([tech, count]) => count > 1 ? `${tech} (${String(count)} papers)` : tech);
+  const notStarted = cluster.papers.filter((p) => p.implementationStatus === "not-started").flatMap((p) => [...p.techniquesExtracted]);
+  const uniqueOpportunities = [...new Set(notStarted)];
+  const gaps = [];
+  if (cluster.paperCount === 1) {
+    gaps.push(`Only 1 paper \u2014 more research needed on ${cluster.topic}`);
+  }
+  const highRelevanceUnimplemented = cluster.papers.filter(
+    (p) => p.relevance === "high" && p.implementationStatus === "not-started"
+  );
+  if (highRelevanceUnimplemented.length > 0) {
+    gaps.push(
+      `${String(highRelevanceUnimplemented.length)} high-relevance paper(s) not yet implemented`
+    );
+  }
+  const allTechNames = [...allTechniques.keys()];
+  const alignedTechniques = analyzeClusterAlignment(allTechNames);
+  const qualityDistribution = computeClusterQuality(cluster.papers);
+  if (qualityDistribution.low > qualityDistribution.high + qualityDistribution.medium) {
+    gaps.push(
+      `Mostly low-evidence papers (${String(qualityDistribution.low)}/${String(cluster.paperCount)}) \u2014 findings need stronger validation`
+    );
+  }
+  return {
+    topic: cluster.topic,
+    paperCount: cluster.paperCount,
+    papers: cluster.papers.map((p) => p.title),
+    commonThemes,
+    keyInsights: deduplicateFindings(allFindings).slice(0, 10),
+    techniques,
+    implementationOpportunities: uniqueOpportunities,
+    gaps,
+    alignedTechniques,
+    qualityDistribution
+  };
+}
+function findCrossCuttingThemes(clusters) {
+  const tagToTopics = /* @__PURE__ */ new Map();
+  for (const cluster of clusters) {
+    for (const paper of cluster.papers) {
+      for (const tag of paper.tags) {
+        const existing = tagToTopics.get(tag);
+        if (existing !== void 0) {
+          existing.add(cluster.topic);
+        } else {
+          tagToTopics.set(tag, /* @__PURE__ */ new Set([cluster.topic]));
+        }
+      }
+    }
+  }
+  return [...tagToTopics.entries()].filter(([, topics]) => topics.size >= CROSS_CUTTING_TAG_THRESHOLD).sort((a, b) => b[1].size - a[1].size).map(([tag, topics]) => `${tag} (spans: ${[...topics].join(", ")})`);
+}
+function analyzeClusterAlignment(techniques) {
+  const alignments = [];
+  for (const tech of techniques) {
+    const baseTech = tech.replace(/\s*\(\d+\s*papers?\)$/, "");
+    const mapping = TECHNIQUE_IMPLEMENTATION_MAP.get(baseTech);
+    if (mapping !== void 0) {
+      alignments.push({
+        technique: baseTech,
+        status: mapping.status,
+        canonicalPath: mapping.path,
+        ...mapping.hint !== void 0 ? { improvementHint: mapping.hint } : {}
+      });
+    } else {
+      alignments.push({ technique: baseTech, status: "not-started" });
+    }
+  }
+  return alignments;
+}
+function buildAlignmentSummary(clusters) {
+  const allAlignments = clusters.flatMap((c) => c.alignedTechniques);
+  const implemented = allAlignments.filter((a) => a.status === "implemented").length;
+  const partial = allAlignments.filter((a) => a.status === "partial").length;
+  const notStarted = allAlignments.filter((a) => a.status === "not-started").length;
+  const opportunities = allAlignments.filter((a) => a.status === "partial" && a.improvementHint !== void 0).map((a) => `${a.technique}: ${a.improvementHint ?? ""}`).slice(0, 10);
+  return {
+    implemented,
+    partial,
+    notStarted,
+    total: allAlignments.length,
+    topOpportunities: opportunities
+  };
+}
+function buildFeatureGateSummary() {
+  return FEATURE_GATE_INVENTORY.map((g) => ({
+    envVar: g.envVar,
+    defaultValue: g.defaultValue,
+    description: g.description,
+    linkedTechniqueCount: g.techniques?.length ?? 0
+  }));
+}
+function collectFrequencies(items) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    counts.set(item, (counts.get(item) ?? 0) + 1);
+  }
+  return counts;
+}
+function deduplicateFindings(findings) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const finding of findings) {
+    const normalized = finding.toLowerCase().trim();
+    if (normalized.length === 0) continue;
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    result.push(finding);
+  }
+  return result;
+}
+
+export {
+  resolveInsideRoot,
+  REGISTRY_PATH,
+  getProjectRoot,
+  loadTechniquesRegistry,
+  loadPapersRegistry,
+  savePapersRegistry,
+  normalizeTopicToCanonical,
+  synthesizeResearch
+};
+//# sourceMappingURL=chunk-GX436VRU.js.map