quantum-spherifier 1.0.0

package/src/modules/HierarchicalCommandInterpreter.js

@@ -0,0 +1,220 @@
+/**
+ * HierarchicalCommandInterpreter.js — quantum-spherifier (v1.0)
+ * Parses owner directives into a structured research plan.
+ *
+ * Owner directives can be:
+ *   - Free-form English: "Focus on surface code distance 11 with neutral atoms"
+ *   - Structured: { researchLine, topic, parameters, target_metric, max_iterations }
+ *   - Empty/null: autonomous mode (agent picks topic from under-explored KG regions)
+ *
+ * Output: a ResearchPlan object the QSpherifierAgent can execute.
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import { v4 as uuidv4 } from 'uuid';
+import { RESEARCH_LINES } from './QuantumKnowledgeGraph.js';
+
+const DEFAULT_PLAN = {
+  researchLine: null,
+  topic: null,
+  parameters: {},
+  targetMetric: 'logical_error_rate',
+  targetValue: null,
+  maxIterations: 10,
+  maxTokensPerIteration: 8000,
+  deliverables: ['hypothesis', 'design', 'patent_draft'],
+  safetyLevel: 'standard',
+  ownerDirective: null,
+  autonomous: false,
+};
+
+export class HierarchicalCommandInterpreter extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.llm = opts.llm ?? null;
+    this.kg = opts.kg ?? null;
+  }
+
+  /**
+   * Interpret an owner directive into a structured plan.
+   */
+  async interpret(directive) {
+    if (!directive || (typeof directive === 'string' && !directive.trim())) {
+      return this._autonomousPlan();
+    }
+
+    if (typeof directive === 'object') {
+      return { ...DEFAULT_PLAN, ...directive, id: uuidv4() };
+    }
+
+    // Try LLM parsing first
+    if (this.llm) {
+      const llmPlan = await this._llmParse(directive);
+      if (llmPlan) return { ...DEFAULT_PLAN, ...llmPlan, id: uuidv4(), ownerDirective: directive };
+    }
+
+    // Fallback: regex-based keyword extraction
+    return { ...DEFAULT_PLAN, ...this._regexParse(directive), id: uuidv4(), ownerDirective: directive };
+  }
+
+  _autonomousPlan() {
+    let researchLine = null;
+    let topic = null;
+    if (this.kg) {
+      // Pick the line with the most under-explored nodes
+      let bestLine = null;
+      let bestCount = -1;
+      for (const line of RESEARCH_LINES) {
+        const ue = this.kg.findUnderExplored(50, line);
+        if (ue.length > bestCount) {
+          bestCount = ue.length;
+          bestLine = line;
+        }
+      }
+      researchLine = bestLine;
+      const underExplored = bestLine ? this.kg.findUnderExplored(1, bestLine) : [];
+      if (underExplored.length > 0) topic = underExplored[0].node?.id;
+    }
+    return {
+      ...DEFAULT_PLAN,
+      id: uuidv4(),
+      researchLine,
+      topic,
+      ownerDirective: null,
+      autonomous: true,
+    };
+  }
+
+  _regexParse(text) {
+    const plan = { parameters: {} };
+    const lower = text.toLowerCase();
+
+    // Research line detection
+    if (/\b(qec|error[\s_-]?correction|surface[\s_-]?code|qldpc|color[\s_-]?code|magic[\s_-]?state|fault[\s_-]?toleran|logical[\s_-]?qubit|code[\s_-]?distance)\b/.test(lower)) {
+      plan.researchLine = 'quantum_error_correction';
+    } else if (/\b(qubit|transmon|fluxonium|cat[\s_-]?qubit|trapped[\s_-]?ion|neutral[\s_-]?atom|rydberg|photonic|topological|majorana|spin[\s_-]?qubit|silicon[\s_-]?spin|nv[\s_-]?center|coherence|gate[\s_-]?fidelity)\b/.test(lower)) {
+      plan.researchLine = 'new_qubit_modalities';
+    } else if (/\b(algorithm|shor|grover|vqe|qaoa|qft|hhl|phase[\s_-]?estimation|qsvt|quantum[\s_-]?machine[\s_-]?learning|qml|optimization)\b/.test(lower)) {
+      plan.researchLine = 'quantum_algorithms';
+    } else if (/\b(molecular|simulation|chemistry|femoco|catalyst|drug|fermionic|hamiltonian|trotter|qubitization|jordan[\s_-]?wigner|materials|battery|protein)\b/.test(lower)) {
+      plan.researchLine = 'molecular_simulation';
+    }
+
+    // Code distance
+    const dMatch = lower.match(/distance\s*(\d+)/);
+    if (dMatch) {
+      plan.parameters.codeDistance = parseInt(dMatch[1], 10);
+      plan.targetMetric = 'logical_error_rate';
+    }
+
+    // Physical qubits
+    const qMatch = lower.match(/(\d[\d,]*)\s*(?:physical[\s_-])?qubits?/);
+    if (qMatch) {
+      plan.parameters.physicalQubits = parseInt(qMatch[1].replace(/,/g, ''), 10);
+    }
+
+    // Logical qubits
+    const lqMatch = lower.match(/(\d[\d,]*)\s*logical[\s_-]?qubits?/);
+    if (lqMatch) {
+      plan.parameters.logicalQubits = parseInt(lqMatch[1].replace(/,/g, ''), 10);
+    }
+
+    // Gate fidelity
+    const fMatch = lower.match(/(\d{2}(?:\.\d+)?)\s*%\s*(?:2q|two[\s_-]?qubit|gate)?\s*fidelity/);
+    if (fMatch) {
+      plan.parameters.gate2qFidelity = parseFloat(fMatch[1]) / 100;
+    }
+
+    // T-gate count
+    const tMatch = lower.match(/(\d+(?:\.\d+)?e\d+|\d+)\s*t[\s_-]?gates?/i);
+    if (tMatch) {
+      plan.parameters.tgateCount = parseFloat(tMatch[1]);
+    }
+
+    // Qubit modality
+    const modalityMap = {
+      'transmon': 'superconducting_transmon',
+      'superconducting': 'superconducting_transmon',
+      'fluxonium': 'superconducting_fluxonium',
+      'cat qubit': 'cat_bosonic',
+      'trapped ion': 'trapped_ion',
+      'ionq': 'trapped_ion',
+      'neutral atom': 'neutral_atom',
+      'rydberg': 'neutral_atom',
+      'photonic': 'photonic',
+      'topological': 'topological_majorana',
+      'majorana': 'topological_majorana',
+      'silicon spin': 'silicon_spin_qubit',
+      'spin qubit': 'silicon_spin_qubit',
+    };
+    for (const [kw, modality] of Object.entries(modalityMap)) {
+      if (lower.includes(kw)) {
+        plan.parameters.modality = modality;
+        break;
+      }
+    }
+
+    // QEC code
+    const codeMap = {
+      'surface code': 'surface',
+      'qldpc': 'qLDPC',
+      'color code': 'color',
+      'bacon-shor': 'bacon_shor',
+      'concatenated': 'concatenated',
+    };
+    for (const [kw, code] of Object.entries(codeMap)) {
+      if (lower.includes(kw)) {
+        plan.parameters.code = code;
+        break;
+      }
+    }
+
+    // Topic KG node detection
+    if (this.kg) {
+      for (const node of this.kg.nodes.values()) {
+        const labelLower = node.label.toLowerCase();
+        if (lower.includes(labelLower) || lower.includes(node.id)) {
+          plan.topic = node.id;
+          if (!plan.researchLine) plan.researchLine = node.researchLine;
+          break;
+        }
+      }
+    }
+
+    // Safety level
+    if (lower.includes('strict')) plan.safetyLevel = 'strict';
+    else if (lower.includes('permissive')) plan.safetyLevel = 'permissive';
+
+    return plan;
+  }
+
+  async _llmParse(text) {
+    if (!this.llm) return null;
+    const system = [
+      'You are the Hierarchical Command Interpreter of quantum-spherifier.',
+      'Parse the user directive into a structured quantum-research plan.',
+      'Respond ONLY with a JSON object of shape:',
+      '{',
+      '  "researchLine": "quantum_error_correction|new_qubit_modalities|quantum_algorithms|molecular_simulation",',
+      '  "topic": "<KG node id, e.g. qec_surface_code>",',
+      '  "parameters": { "physicalQubits": 1000, "logicalQubits": 100, "codeDistance": 11, "modality": "neutral_atom", ... },',
+      '  "targetMetric": "logical_error_rate|gate_fidelity|T1|tgate_count|chemical_accuracy|...",',
+      '  "targetValue": "<value>",',
+      '  "maxIterations": <number>,',
+      '  "deliverables": ["hypothesis", "design", "patent_draft"],',
+      '  "safetyLevel": "standard|strict|permissive"',
+      '}',
+    ].join('\n');
+    try {
+      const r = await this.llm.chat(text, system, { task: 'hypothesis_generation' });
+      if (!r?.ok) return null;
+      const s = r.content ?? '';
+      const a = s.indexOf('{');
+      const b = s.lastIndexOf('}');
+      if (a >= 0 && b > a) return JSON.parse(s.slice(a, b + 1));
+    } catch (err) {
+      this.emit('parseError', err.message);
+    }
+    return null;
+  }
+}

package/src/modules/HypothesisGenerator.js

@@ -0,0 +1,421 @@
+/**
+ * HypothesisGenerator.js — quantum-spherifier (v1.0)
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Generates scientific hypotheses across the four quantum-computing research
+ * lines by combining concepts from the QuantumKnowledgeGraph with under-
+ * explored regions and current resource-feasibility gaps.
+ *
+ * Uses an LLM adapter (via task-routed LLMRouter) for natural-language
+ * hypothesis synthesis, but can also operate deterministically (template-based)
+ * when no LLM is configured.
+ *
+ * Output: structured hypothesis record with:
+ *   - statement
+ *   - rationale
+ *   - supporting concepts (KG node IDs) — ensures cross-linking
+ *   - predicted impact on logical error rate / qubit count / circuit depth / chemical accuracy
+ *   - feasibility tier
+ *   - patentability hint
+ *   - proposed experiments
+ *   - cross-link verification
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import { v4 as uuidv4 } from 'uuid';
+
+// Per-research-line hypothesis templates. Each template lists the KG concepts
+// it cross-links — this is how quantum-spherifier ensures nothing stays isolated.
+const HYPOTHESIS_TEMPLATES = {
+  quantum_error_correction: [
+    {
+      pattern: ['qec_surface_code', 'qubit_neutral_atom'],
+      template: 'A reconfigurable neutral-atom array implementing a distance-{d} surface code with long-range Rydberg-mediated syndrome extraction achieves a logical error rate of {pL} — a {factor}-fold reduction over fixed-lattice transmon implementations — by exploiting all-to-all connectivity to reduce hook-error pathways.',
+      parameters: { codeDistance: 11, logicalErrorRate: 1e-9, physicalQubits: 242, modality: 'neutral_atom' },
+      metric: 'logical_error_rate', direction: 'decrease', magnitude: '100x',
+    },
+    {
+      pattern: ['qec_qldpc', 'qubit_neutral_atom'],
+      template: 'A [[{n},{k},{d}]] qLDPC code implemented on a reconfigurable neutral-atom processor with non-local check measurements achieves a constant encoding rate of {rate}, reducing the physical-to-logical overhead from ~{old_overhead} (surface code) to ~{new_overhead} for the same target logical error rate.',
+      parameters: { physicalQubits: 1000, logicalQubits: 100, codeDistance: 10, modality: 'neutral_atom', overheadReduction: '10x' },
+      metric: 'physical_to_logical_overhead', direction: 'decrease', magnitude: '10x',
+    },
+    {
+      pattern: ['qec_bacon_shor', 'qubit_cat'],
+      template: 'A biased-noise Bacon-Shor code on cat qubits (phase-flip dominated) with a target bit-flip suppression of {bf_supp} achieves a logical error rate of {pL} with only {overhead} physical qubits per logical, a {factor}-x overhead reduction versus the surface code on depolarizing noise.',
+      parameters: { modality: 'cat_bosonic', physicalQubits: 400, logicalQubits: 10, codeDistance: 7, bias: 'dephasing' },
+      metric: 'physical_to_logical_overhead', direction: 'decrease', magnitude: '4x',
+    },
+    {
+      pattern: ['qec_magic_state_distillation', 'qec_color_code'],
+      template: 'A color-code architecture with transversal Clifford gates combined with a 15-to-1 T-state distillation protocol reduces the total T-gate overhead for a {app} computation from {old_T} to {new_T} T factories, enabling a {speedup}-fold end-to-end runtime reduction.',
+      parameters: { tgateCount: 1e7, logicalQubits: 100, application: 'molecular_simulation' },
+      metric: 'tgate_overhead', direction: 'decrease', magnitude: '2x',
+    },
+  ],
+
+  new_qubit_modalities: [
+    {
+      pattern: ['qubit_fluxonium', 'qubit_transmon'],
+      template: 'A fluxonium-on-sapphire qubit with T1 = {T1} ms and 2-qubit gate fidelity of {f2q} achieves a {factor}-fold coherence improvement over state-of-the-art transmons while retaining CMOS-compatible fabrication, enabling deeper circuits on {n}-qubit processors without QEC.',
+      parameters: { modality: 'superconducting_fluxonium', T1_s: 1.0, gate2qFidelity: 0.999, physicalQubits: 100 },
+      metric: 'T1', direction: 'increase', magnitude: '3x',
+    },
+    {
+      pattern: ['qubit_neutral_atom', 'qubit_silicon_spin'],
+      template: 'A hybrid architecture using {n} neutral-atom qubits for computation and {m} silicon-spin qubits for long-term quantum memory (T2 = {T2} ms) enables coherent interleaving of subroutines across a {factor}-times-longer effective circuit depth.',
+      parameters: { modality: 'hybrid_neutral_spin', physicalQubits: 1000, T2_s: 0.01 },
+      metric: 'effective_coherence', direction: 'increase', magnitude: '100x',
+    },
+    {
+      pattern: ['qubit_photonic', 'qubit_cat'],
+      template: 'A photonic-fusion-based architecture using Gottesman-Kitaev-Preskill (GKP) bosonic encoding achieves a {factor}-x reduction in resource overhead for fault-tolerant MBQC by combining intrinsic squeezing protection with fusion measurements at {rate} Hz.',
+      parameters: { modality: 'photonic_gkp', physicalQubits: 100000, gate2qFidelity: 0.995 },
+      metric: 'resource_overhead', direction: 'decrease', magnitude: '5x',
+    },
+    {
+      pattern: ['qubit_topological', 'qubit_transmon'],
+      template: 'A topological qubit prototype based on Majorana zero modes in an InAs/Al nanowire, once braiding is demonstrated at fidelity {f_braid}, would reduce the QEC overhead for logical qubits from ~{old_overhead} (surface code on transmons) to ~{new_overhead}, a {factor}-x improvement.',
+      parameters: { modality: 'topological_majorana', physicalQubits: 100, logicalQubits: 10, gate2qFidelity: 0.9999 },
+      metric: 'qec_overhead', direction: 'decrease', magnitude: '10x',
+    },
+    {
+      pattern: ['qubit_silicon_spin', 'qubit_transmon'],
+      template: 'A {n}-qubit silicon spin-qubit processor fabricated on Intel 3 CMOS nodes, with 2-qubit gate fidelity {f2q} and dot pitch of {pitch} nm, achieves {density} qubits/mm² — a {factor}-x density improvement over transmon processors — at cryogenic cost {cost}.',
+      parameters: { modality: 'silicon_spin_qubit', physicalQubits: 1000, gate2qFidelity: 0.999, fabNode: 'Intel_3' },
+      metric: 'qubit_density', direction: 'increase', magnitude: '1000x',
+    },
+  ],
+
+  quantum_algorithms: [
+    {
+      pattern: ['algo_qsvt', 'sim_qubitization'],
+      template: 'A QSVT-based algorithm for ground-state energy estimation of a {mol} molecule using {n_logical} logical qubits and {T} T-gates achieves {accuracy} chemical accuracy with a {factor}-x reduction in T-gate count versus Trotterization at the same target precision.',
+      parameters: { logicalQubits: 200, tgateCount: 1e8, application: 'chemistry', algorithm: 'QSVT_qubitization' },
+      metric: 'tgate_count', direction: 'decrease', magnitude: '100x',
+    },
+    {
+      pattern: ['algo_vqe', 'sim_transition_metal'],
+      template: 'A problem-tailored VQE ansatz with symmetry-adapted UCCSD and a measurement-frugal grouping strategy estimates the ground-state energy of a {mol} transition-metal catalyst to within {accuracy} Ha using {n_phys} physical qubits — a near-term target on {platform}.',
+      parameters: { physicalQubits: 150, algorithm: 'VQE_UCCSD', era: 'NISQ', application: 'catalysis' },
+      metric: 'chemical_accuracy', direction: 'decrease', magnitude: '1.6mHa',
+    },
+    {
+      pattern: ['algo_qpe', 'qec_surface_code'],
+      template: 'A robust phase-estimation algorithm for the FeMoco active site, requiring {n_logical} logical qubits and {T} T-gates, achieves chemical accuracy ({accuracy} Ha) in {runtime} days on a 1M-physical-qubit surface-code processor — a {factor}-x speedup over classical DMRG.',
+      parameters: { logicalQubits: 3000, tgateCount: 1e11, application: 'FeMoco', algorithm: 'QPE' },
+      metric: 'runtime', direction: 'decrease', magnitude: '1000x',
+    },
+    {
+      pattern: ['algo_qml', 'algo_qsvt'],
+      template: 'A quantum kernel method based on QSVT-projected feature maps achieves a {factor}-x training-speedup over classical Gaussian kernels on a {n_qubit} qubit processor for {task} classification, with provable separation on {dataset}.',
+      parameters: { physicalQubits: 100, algorithm: 'quantum_kernel_QSVT', application: 'classification' },
+      metric: 'training_speedup', direction: 'increase', magnitude: '10x',
+    },
+    {
+      pattern: ['algo_hhl', 'algo_qsvt'],
+      template: 'An HHL solver for sparse linear systems Ax=b, re-cast as a QSVT block-encoding with optimal query complexity {Q}, achieves an exponential speedup for {app} on {n_logical} logical qubits with T-gate count {T}.',
+      parameters: { logicalQubits: 500, tgateCount: 1e9, algorithm: 'HHL_QSVT', application: 'PDE_solver' },
+      metric: 'query_complexity', direction: 'decrease', magnitude: 'exponential',
+    },
+  ],
+
+  molecular_simulation: [
+    {
+      pattern: ['sim_femoco', 'sim_qubitization'],
+      template: 'A qubitized simulation of the FeMoco active site ({n_orb} active orbitals) on a fault-tolerant processor with {n_logical} logical qubits and {T} T-gates achieves chemical accuracy ({accuracy} Ha) in {runtime} days, enabling first-principles prediction of the nitrogenase mechanism.',
+      parameters: { logicalQubits: 3000, tgateCount: 1e11, molecule: 'FeMoco', activeOrbitals: 154, chemicalAccuracy_Ha: 0.0016 },
+      metric: 'chemical_accuracy', direction: 'achieve', magnitude: '1.6mHa',
+    },
+    {
+      pattern: ['sim_transition_metal', 'algo_vqe'],
+      template: 'A VQE calculation of a Ni-catalyzed C-H activation barrier ({n_orb} orbitals) on {n_phys} NISQ qubits with a problem-decomposed ansatz predicts the activation energy within {accuracy} kcal/mol of experiment — a practical near-term application in pharma process chemistry.',
+      parameters: { physicalQubits: 80, molecule: 'Ni_C_H_activation', activeOrbitals: 30, era: 'NISQ' },
+      metric: 'activation_energy_error', direction: 'decrease', magnitude: '1kcal/mol',
+    },
+    {
+      pattern: ['sim_drug_discovery', 'sim_fermionic'],
+      template: 'A hybrid quantum-classical pipeline for protein-ligand binding affinity, combining VQE for the QM region and molecular dynamics for the MM region, predicts ΔG within {accuracy} kcal/mol for {target} — matching FEP+ accuracy at {factor}-x lower compute for strongly-correlated metalloproteins.',
+      parameters: { physicalQubits: 200, application: 'binding_affinity', pipeline: 'QM_MM_hybrid' },
+      metric: 'binding_affinity_error', direction: 'decrease', magnitude: '1kcal/mol',
+    },
+    {
+      pattern: ['sim_materials', 'sim_qubitization'],
+      template: 'A qubitized simulation of the 2D Hubbard model on a {n_logical}-logical-qubit fault-tolerant processor resolves the pseudogap and stripe phases at {accuracy} energy resolution, providing microscopic insight into high-Tc cuprate superconductivity unreachable by QMC due to the sign problem.',
+      parameters: { logicalQubits: 500, tgateCount: 1e10, model: 'Hubbard_2D', application: 'high_Tc' },
+      metric: 'energy_resolution', direction: 'achieve', magnitude: '10meV',
+    },
+    {
+      pattern: ['sim_fermionic', 'sim_jordan_wigner'],
+      template: 'A Bravyi-Kitaev+ mapping with symmetry tapering reduces the qubit count for a {mol} simulation from {n_old} to {n_new} qubits ({factor}-x reduction) without loss of accuracy, enabling simulation of larger active spaces on near-term hardware.',
+      parameters: { physicalQubits: 50, molecule: 'organometallic', mapping: 'Bravyi_Kitaev_superfast' },
+      metric: 'qubit_count', direction: 'decrease', magnitude: '2x',
+    },
+  ],
+};
+
+// Cross-line templates — deliberately bridge two research lines
+const CROSS_LINE_TEMPLATES = [
+  {
+    pattern: ['qec_qldpc', 'qubit_neutral_atom', 'sim_femoco'],
+    template: 'A reconfigurable neutral-atom platform implementing a qLDPC code with constant-rate encoding provides the {n_logical} logical qubits needed for FeMoco simulation at {factor}-x lower physical-qubit overhead than surface-code architectures, bridging QEC, qubit-modality, and molecular-simulation advances into a single viable path to useful quantum chemistry.',
+    parameters: { physicalQubits: 50000, logicalQubits: 3000, modality: 'neutral_atom', code: 'qLDPC', application: 'FeMoco' },
+    metric: 'physical_qubit_overhead', direction: 'decrease', magnitude: '10x',
+  },
+  {
+    pattern: ['qec_bacon_shor', 'qubit_cat', 'algo_qpe'],
+    template: 'Cat-qubit Bacon-Shor logical qubits with biased-noise protection, combined with QPE for molecular energy estimation, reduce the T-gate factory footprint by {factor}-x, enabling FeMoco-scale chemistry on a {n_phys}-physical-qubit processor — a coherent integration of QEC, qubit-modality, and algorithm advances.',
+    parameters: { physicalQubits: 100000, logicalQubits: 3000, modality: 'cat_bosonic', algorithm: 'QPE' },
+    metric: 'factory_footprint', direction: 'decrease', magnitude: '4x',
+  },
+  {
+    pattern: ['algo_qsvt', 'qubit_fluxonium', 'sim_transition_metal'],
+    template: 'Fluxonium qubits with T1 = {T1} ms extend the effective circuit depth for NISQ-era VQE on transition-metal catalysts by {factor}-x, while a QSVT-structured ansatz reduces gate count by {factor2}-x — together enabling catalyst screening beyond classical DFT accuracy.',
+    parameters: { physicalQubits: 200, modality: 'fluxonium', algorithm: 'VQE_QSVT_ansatz', T1_s: 1.0 },
+    metric: 'effective_circuit_depth', direction: 'increase', magnitude: '10x',
+  },
+];
+
+export class HypothesisGenerator extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.kg = opts.kg ?? null;
+    this.llm = opts.llm ?? null;
+    this.feasibilityChecker = opts.feasibilityChecker ?? null;
+  }
+
+  /**
+   * Generate one or more hypotheses.
+   * @param {object} opts
+   * @param {string} opts.researchLine  – one of RESEARCH_LINES
+   * @param {number} [opts.count=1]
+   * @param {string} [opts.seedTopic]   – optional KG node id
+   * @param {string} [opts.ownerDirective]
+   * @param {boolean} [opts.crossLink]  – generate a cross-line hypothesis
+   * @param {string} [opts.pairedLine]  – paired line for cross-link
+   */
+  async generate(opts = {}) {
+    const count = opts.count ?? 1;
+    const results = [];
+    for (let i = 0; i < count; i++) {
+      const hyp = await this._generateOne(opts);
+      results.push(hyp);
+      this.emit('hypothesis', hyp);
+    }
+    return results;
+  }
+
+  async _generateOne(opts) {
+    const id = `hyp_${uuidv4().slice(0, 8)}`;
+    const line = opts.researchLine ?? 'quantum_error_correction';
+    const seedTopic = opts.seedTopic ?? this._pickSeedTopic(line);
+    const neighbourhood = this.kg ? this.kg.neighbourhood(seedTopic, 2) : [];
+    const underExplored = this.kg ? this.kg.findUnderExplored(5, line) : [];
+
+    let hypothesis;
+    if (this.llm && opts.ownerDirective) {
+      hypothesis = await this._llmGenerate({
+        id, line, seedTopic, neighbourhood, underExplored,
+        ownerDirective: opts.ownerDirective, crossLink: opts.crossLink, pairedLine: opts.pairedLine,
+      });
+    } else {
+      hypothesis = this._templateGenerate({
+        id, line, seedTopic, neighbourhood, underExplored,
+        ownerDirective: opts.ownerDirective, crossLink: opts.crossLink, pairedLine: opts.pairedLine,
+      });
+    }
+
+    // Ensure supportingConcepts always cross-link to the KG (nothing isolated)
+    if ((!hypothesis.supportingConcepts || hypothesis.supportingConcepts.length === 0) && seedTopic) {
+      hypothesis.supportingConcepts = [seedTopic, ...neighbourhood.slice(0, 3).map(n => n.node?.id).filter(Boolean)];
+    }
+
+    // Feasibility check
+    if (this.feasibilityChecker) {
+      hypothesis.feasibility = await this.feasibilityChecker.assess(hypothesis);
+    }
+
+    hypothesis.id = id;
+    hypothesis.researchLine = line;
+    hypothesis.crossLink = opts.crossLink ?? false;
+    hypothesis.pairedLine = opts.pairedLine ?? null;
+    hypothesis.createdAt = Date.now();
+    hypothesis.seedTopic = seedTopic;
+    return hypothesis;
+  }
+
+  _pickSeedTopic(line) {
+    if (!this.kg) return null;
+    const lineNodes = this.kg.byResearchLine(line);
+    if (lineNodes.length === 0) return null;
+    // Prefer under-explored
+    const underExplored = this.kg.findUnderExplored(20, line);
+    if (underExplored.length > 0 && underExplored[0].node) return underExplored[0].node.id;
+    return lineNodes[Math.floor(Math.random() * lineNodes.length)].id;
+  }
+
+  _templateGenerate(ctx) {
+    const pool = ctx.crossLink ? CROSS_LINE_TEMPLATES : (HYPOTHESIS_TEMPLATES[ctx.line] ?? []);
+    const tpl = pool[Math.floor(Math.random() * pool.length)] ?? HYPOTHESIS_TEMPLATES[ctx.line]?.[0];
+
+    // Fill template with realistic parameters
+    const fill = {
+      d: tpl?.parameters?.codeDistance ?? 11,
+      pL: '1e-9',
+      factor: tpl?.magnitude ?? '10',
+      n: tpl?.parameters?.physicalQubits ?? 1000,
+      m: 100,
+      n_phys: tpl?.parameters?.physicalQubits ?? 100,
+      n_logical: tpl?.parameters?.logicalQubits ?? 100,
+      n_orb: 50,
+      T: tpl?.parameters?.tgateCount?.toExponential(2) ?? '1e8',
+      T1: (tpl?.parameters?.T1_s ?? 0.3) * 1000, // ms
+      T2: 10, // ms
+      f2q: '99.9%',
+      f_braid: '99.99%',
+      rate: '1/10',
+      old_overhead: '1000',
+      new_overhead: '100',
+      overhead: '100',
+      bf_supp: '1e-8',
+      old_T: '1e9',
+      new_T: '5e8',
+      accuracy: '1.6',
+      runtime: '4',
+      Q: 'O(κ log(1/ε))',
+      mol: 'FeMoco',
+      app: 'chemistry',
+      platform: 'IBM Heron',
+      task: 'drug-target',
+      dataset: 'adversarial',
+      pitch: 100,
+      density: 1e6,
+      cost: '$1M',
+      target: 'metalloprotein',
+      speedup: '1000',
+      factor2: '5',
+    };
+
+    let statement = tpl?.template ?? 'Investigate an under-explored region of the quantum knowledge graph.';
+    for (const [k, v] of Object.entries(fill)) {
+      statement = statement.replace(new RegExp(`\\{${k}\\}`, 'g'), String(v));
+    }
+
+    const supportingConcepts = (tpl?.pattern ?? [])
+      .filter(p => this.kg?.nodes.has(p))
+      .concat(neighbourhood_safe(ctx).slice(0, 2).map(n => n.node?.id).filter(Boolean));
+
+    return {
+      statement,
+      rationale: `Synthesised by combining the ${(tpl?.pattern ?? []).join(' + ')} pattern within research line "${ctx.line}"${ctx.crossLink ? ` (cross-linking with "${ctx.pairedLine}")` : ''}. The hypothesis is anchored to ${supportingConcepts.length} knowledge-graph concepts to ensure no advance stays isolated.`,
+      supportingConcepts,
+      predictedImpact: {
+        metric: tpl?.metric ?? 'logical_error_rate',
+        direction: tpl?.direction ?? 'decrease',
+        magnitude: tpl?.magnitude ?? '10x',
+      },
+      parameters: { ...tpl?.parameters, researchLine: ctx.line },
+      feasibility: { tier: 'mid_term', confidence: 0.55 },
+      patentabilityHint: 'MAYBE',
+      proposedExperiments: this._proposeExperiments(ctx.line, tpl?.parameters),
+      source: 'template',
+      templatePattern: tpl?.pattern ?? [],
+    };
+  }
+
+  _proposeExperiments(line, params) {
+    const experiments = {
+      quantum_error_correction: [
+        `Implement a distance-${params?.codeDistance ?? 7} code on a ${params?.modality ?? 'superconducting'} processor and measure the logical error rate over ${1e4} cycles.`,
+        'Simulate the decoder (MWPM or neural) under realistic circuit-level noise to verify threshold crossing.',
+        'Benchmark syndrome extraction latency against the coherence budget to ensure real-time decoding feasibility.',
+      ],
+      new_qubit_modalities: [
+        `Fabricate a ${params?.modality ?? 'fluxonium'} test chip and measure T1, T2, and 2-qubit gate fidelity over 1000 randomized benchmarking sequences.`,
+        'Characterize the noise spectrum (1/f, quasiparticle, photon shot noise) to identify the dominant decoherence channel.',
+        'Scale to a 2x2 or 3x3 grid and verify cross-talk remains below the QEC threshold.',
+      ],
+      quantum_algorithms: [
+        `Resource-estimate the algorithm at target precision: count T-gates, logical qubits, and magic-state factories.`,
+        'Classically simulate a reduced version (8-16 qubits) to verify correctness and benchmark against classical alternatives.',
+        'Profile the circuit depth against expected hardware cycle times to confirm runtime feasibility.',
+      ],
+      molecular_simulation: [
+        'Prepare the molecular Hamiltonian (active space selection, integral computation) and map to qubits via Bravyi-Kitaev.',
+        'Classically verify the ground-state energy on a small basis set using CASCI/DMRG.',
+        'Run VQE (NISQ) or QPE (FTQC) resource estimation and compare to classical CCSD(T) benchmarks.',
+      ],
+    };
+    return experiments[line] ?? experiments.quantum_error_correction;
+  }
+
+  async _llmGenerate(ctx) {
+    const system = [
+      'You are quantum-spherifier (qSpherifier), an autonomous scientific researcher specialised in quantum computing.',
+      'Your mission: advance quantum hardware and algorithms toward solving problems impossible for classical computers,',
+      'within a short-to-medium-term horizon (1-10 years).',
+      '',
+      'Constraints — EVERY hypothesis must satisfy these:',
+      '1. Be anchored to technologies that exist today or are under active construction',
+      '   (IBM Condor/Heron, Google Willow, IonQ Forte, Quantinuum H2, QuEra Aquila, Atom Computing 1180, PsiQuantum, etc.).',
+      '2. Propose a measurable improvement in: logical error rate, qubit count, coherence time, gate fidelity,',
+      '   circuit depth, T-gate count, chemical accuracy, or algorithmic speedup.',
+      '3. Cross-link to at least 2 knowledge-graph concepts so nothing stays isolated.',
+      '4. Identify 2-4 candidate patent claims focused on the NOVEL hardware or algorithmic mechanism.',
+      '5. Avoid speculative physics — no faster-than-light, no macroscopic entanglement without decoherence control,',
+      '   no D-Wave-style quantum annealing claims of general advantage without evidence.',
+      '',
+      'Respond ONLY with a JSON object of the shape:',
+      '{',
+      '  "statement": "<one-paragraph hypothesis statement>",',
+      '  "rationale": "<why this is novel, feasible, and cross-linked>",',
+      '  "supportingConcepts": ["<KG node id>", ...],',
+      '  "predictedImpact": { "metric": "...", "direction": "increase|decrease|achieve", "magnitude": "..." },',
+      '  "parameters": { "physicalQubits": <n>, "logicalQubits": <n>, "modality": "...", ... },',
+      '  "feasibility": { "tier": "current|near_term|mid_term|long_term", "confidence": 0.0-1.0 },',
+      '  "patentabilityHint": "YES|MAYBE|NO",',
+      '  "proposedExperiments": ["...", ...],',
+      '  "candidatePatentClaims": ["<claim 1>", "<claim 2>", ...]',
+      '}',
+    ].join('\n');
+
+    const user = [
+      `Research line: ${ctx.line}`,
+      ctx.crossLink ? `Cross-linking with: ${ctx.pairedLine}` : '',
+      `Seed topic: ${ctx.seedTopic ?? 'random'}`,
+      `Owner directive: ${ctx.ownerDirective ?? '(none)'}`,
+      `Under-explored concepts: ${ctx.underExplored.map(u => u.node?.label).join(', ')}`,
+      `Neighbourhood concepts: ${ctx.neighbourhood.map(n => n.node?.label).slice(0, 8).join(', ')}`,
+      '',
+      'Generate ONE hypothesis now.',
+    ].join('\n');
+
+    const response = await this.llm.chat(user, system, { task: 'hypothesis_generation' });
+    if (!response?.ok) {
+      this.emit('llmError', response?.error ?? 'unknown');
+      return this._templateGenerate(ctx);
+    }
+    try {
+      const text = response.content ?? '';
+      const jsonStart = text.indexOf('{');
+      const jsonEnd = text.lastIndexOf('}');
+      if (jsonStart >= 0 && jsonEnd > jsonStart) {
+        const jsonStr = text.slice(jsonStart, jsonEnd + 1);
+        const parsed = JSON.parse(jsonStr);
+        return {
+          ...parsed,
+          source: 'llm',
+          rawLlmResponse: text,
+          llmAdapter: response.adapterUsed,
+        };
+      }
+    } catch (err) {
+      this.emit('parseError', err.message);
+    }
+    return this._templateGenerate(ctx);
+  }
+}
+
+function neighbourhood_safe(ctx) {
+  return Array.isArray(ctx.neighbourhood) ? ctx.neighbourhood : [];
+}