mio-agent-runtime 0.13.4 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.13.4",
+  "version": "0.14.0",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",
@@ -17,6 +17,7 @@
     "!server/mio-intelligence-mcp/__tests__"
   ],
   "scripts": {
+    "pretest": "node scripts/link-workspace.cjs",
     "check": "node scripts/check-syntax.cjs",
     "test": "node --test \"__tests__/*.test.js\" \"server/mio-intelligence-mcp/__tests__/*.test.js\"",
     "prepack": "npm run check",
@@ -33,8 +34,9 @@
     "@akemi-mio/evolution-strategy": "^0.1.0",
     "@akemi-mio/evolution-safety": "^0.1.0",
     "@akemi-mio/evolution-scheduler": "^0.1.0",
-    "@akemi-mio/observer": "^0.1.3",
-    "@akemi-mio/insight": "^0.1.0"
+    "@akemi-mio/observer": "^0.1.4",
+    "@akemi-mio/insight": "^0.1.1",
+    "@akemi-mio/creativity": "^0.1.0"
   },
   "main": "index.js",
   "directories": {

package/scripts/link-workspace.cjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+'use strict'
+
+// Creates the node_modules junctions mio-cli needs to require the workspace
+// packages it depends on at runtime (@akemi-mio/insight etc. already exist as
+// junctions in a normal checkout; a fresh clone has none). Idempotent: an
+// existing link (or directory) is left alone. Windows junctions, because this
+// checkout lives on NTFS and junctions need no admin rights.
+
+const fs = require('fs')
+const path = require('path')
+
+const REPO = path.resolve(__dirname, '..', '..', '..')
+const links = [
+  {
+    at: path.join(REPO, 'packages', 'mio-cli', 'node_modules', '@akemi-mio', 'creativity'),
+    target: path.join(REPO, 'packages', 'creativity'),
+  },
+  {
+    at: path.join(REPO, 'packages', 'creativity', 'node_modules', '@akemi-mio', 'core'),
+    target: path.join(REPO, 'packages', 'core'),
+  },
+  // Root-level links: the new tests under tests/main/creativity/ import
+  // '@akemi-mio/creativity/*' from the repo root, and the lockfile's
+  // link:true entries are not materialized on disk (ground rule 4 forbids
+  // the `npm install` that would create them).
+  {
+    at: path.join(REPO, 'node_modules', '@akemi-mio', 'creativity'),
+    target: path.join(REPO, 'packages', 'creativity'),
+  },
+  {
+    at: path.join(REPO, 'node_modules', '@akemi-mio', 'core'),
+    target: path.join(REPO, 'packages', 'core'),
+  },
+]
+
+for (const { at, target } of links) {
+  let exists = false
+  try {
+    fs.lstatSync(at)
+    exists = true
+  } catch (_) {
+    exists = false
+  }
+  if (exists) {
+    console.log(`exists  ${at}`)
+    continue
+  }
+  fs.mkdirSync(path.dirname(at), { recursive: true })
+  fs.symlinkSync(target, at, 'junction')
+  console.log(`linked  ${at} -> ${target}`)
+}

package/server/creativity-engine.js

@@ -3,6 +3,37 @@
 const fs = require('fs')
 const path = require('path')
 const crypto = require('crypto')
+const { evaluateNovelty } = require('@akemi-mio/creativity/NoveltyScorer')
+
+// Cache validity key for a JSONL file: a (size, mtimeMs) pair, the same
+// guard server/insight-store.js uses (commit 0ba7fa8). Every getter below used
+// to latch its parsed array forever, so a long-running MCP process answered
+// `mio.creativity.list` from the copy it loaded at startup and a
+// `mio creativity generate` in another process stayed invisible until restart.
+function fileSignature(filePath) {
+  try {
+    const st = fs.statSync(filePath)
+    return `${st.size}:${st.mtimeMs}`
+  } catch (_) {
+    return 'missing'
+  }
+}
+
+// One clamp for every LLM score: coerce, reject NaN/Infinity (a model that
+// returns "high" used to store NaN and poison the sum gate), then bound to
+// 0-100. Missing values fall back so old records keep a neutral score.
+function clamp100(value, fallback = 50) {
+  const n = Number(value)
+  if (!Number.isFinite(n)) return fallback
+  return Math.min(100, Math.max(0, n))
+}
+
+// ISO timestamp for provenance: accepts epoch ms or date strings, returns
+// undefined when the value is missing or unparsable.
+function isoOf(value) {
+  const t = typeof value === 'number' ? value : Date.parse(value || '')
+  return Number.isFinite(t) ? new Date(t).toISOString() : undefined
+}
 
 // ═══════════════════════════════════════════════
 //  JSONL Store — ideas, combos, experiments
@@ -17,6 +48,9 @@ class CreativityStore {
     this._hypotheses = null
     this._combos = null
     this._experiments = null
+    this._hypothesesSig = null
+    this._combosSig = null
+    this._experimentsSig = null
   }
 
   _ensureDir() {
@@ -42,8 +76,10 @@ class CreativityStore {
   }
 
   getHypotheses(opts = {}) {
-    if (this._hypotheses === null) {
+    const sig = fileSignature(this.hypothesesPath)
+    if (this._hypotheses === null || this._hypothesesSig !== sig) {
       this._hypotheses = this._readJsonl(this.hypothesesPath)
+      this._hypothesesSig = sig
     }
     let list = this._hypotheses
     if (opts.status) list = list.filter(h => h.status === opts.status)
@@ -53,6 +89,7 @@ class CreativityStore {
 
   addHypothesis(h) {
     this._appendJsonl(this.hypothesesPath, h)
+    this._hypothesesSig = fileSignature(this.hypothesesPath)
     if (this._hypotheses) this._hypotheses.push(h)
   }
 
@@ -63,30 +100,37 @@ class CreativityStore {
     Object.assign(all[idx], patch)
     this._hypotheses = all
     this._rewriteFile(this.hypothesesPath, all)
+    this._hypothesesSig = fileSignature(this.hypothesesPath)
     return true
   }
 
   getCombos(limit) {
-    if (this._combos === null) {
+    const sig = fileSignature(this.combosPath)
+    if (this._combos === null || this._combosSig !== sig) {
       this._combos = this._readJsonl(this.combosPath)
+      this._combosSig = sig
     }
     return limit ? this._combos.slice(-limit) : this._combos
   }
 
   addCombo(c) {
     this._appendJsonl(this.combosPath, c)
+    this._combosSig = fileSignature(this.combosPath)
     if (this._combos) this._combos.push(c)
   }
 
   getExperiments() {
-    if (this._experiments === null) {
+    const sig = fileSignature(this.experimentsPath)
+    if (this._experiments === null || this._experimentsSig !== sig) {
       this._experiments = this._readJsonl(this.experimentsPath)
+      this._experimentsSig = sig
     }
     return this._experiments
   }
 
   addExperiment(e) {
     this._appendJsonl(this.experimentsPath, e)
+    this._experimentsSig = fileSignature(this.experimentsPath)
     if (this._experiments) this._experiments.push(e)
   }
 
@@ -138,48 +182,61 @@ function mixConcepts(sources, exploredPairs, rng) {
 }
 
 // ═══════════════════════════════════════════════
-//  Novelty Scorer — reject duplicates
+//  Creativity Engine — main orchestrator
 // ═══════════════════════════════════════════════
 
-function bigramSet(text) {
-  const s = new Set()
-  const lower = text.toLowerCase()
-  for (let i = 0; i < lower.length - 1; i++) {
-    s.add(lower.slice(i, i + 2))
-  }
-  return s
+// Concept sources drawn from stored insights, backing
+// `mio.creativity.generate { fromInsights: true }` / `mio creativity generate
+// --from-insights`. The *caller* supplies the insight records because only the
+// entry point knows which store is authoritative (MIO_HOME for the CLI, the
+// MCP server's MIO_DATA_DIR); this only maps them onto the { name, content,
+// type, weight } shape the concept mixer pairs up. Highest score first, capped
+// so one busy insight run cannot turn into dozens of LLM calls.
+function sourcesFromInsights(insights, limit = 10) {
+  return (Array.isArray(insights) ? insights : [])
+    .filter(i => i && (i.title || i.description || i.content))
+    .slice()
+    .sort((a, b) => (b.score || 0) - (a.score || 0))
+    .slice(0, limit)
+    .map(i => ({
+      name: String(i.title || i.id || 'insight').replace(/\s+/g, ' ').slice(0, 60),
+      content: [
+        i.description || i.content || i.title || '',
+        Array.isArray(i.evidence) && i.evidence.length > 0 ? `Evidence: ${i.evidence.join('; ')}` : '',
+      ].filter(Boolean).join('\n'),
+      type: 'insight',
+      // > 0.7: IdeaGenerator.applyTemperature keeps any weight>0.7 source unconditionally.
+      weight: 0.78,
+      origin: `insight:${i.id || i.title || 'unknown'}`,
+      ...(i.id ? { originId: i.id } : {}),
+      ...(isoOf(i.createdAt) ? { timestamp: isoOf(i.createdAt) } : {}),
+    }))
 }
 
-function jaccard(a, b) {
-  if (a.size === 0 && b.size === 0) return 1
-  let inter = 0
-  for (const x of a) if (b.has(x)) inter++
-  return inter / (a.size + b.size - inter)
-}
+const STRATEGY_CYCLE = ['explore', 'signal', 'stable']
 
-function evaluateNovelty(idea, recent, rejected) {
-  const ideaBigrams = bigramSet(idea.title + ' ' + idea.idea)
-  for (const r of recent) {
-    const sim = jaccard(ideaBigrams, bigramSet(r.title + ' ' + r.idea))
-    if (sim > 0.7) {
-      return { shouldReject: true, rejectReason: `too similar to recent: "${r.title}" (sim=${sim.toFixed(2)})`, adjustedNovelty: idea.novelty }
-    }
+// One row shape for every list variant — the fields JSON/CLI consumers already
+// depend on. `noveltyScore` is added only by sort=novelty (relative ranking),
+// never confused with the quality sum `score`.
+function listRow(h) {
+  return {
+    id: h.id,
+    title: h.title,
+    idea: h.idea,
+    status: h.status,
+    novelty: h.novelty,
+    feasibility: h.feasibility,
+    impact: h.impact,
+    ...(h.logic !== undefined ? { logic: h.logic } : {}),
+    score: h.novelty + h.feasibility + h.impact,
+    sourceLabels: h.sourceLabels,
+    createdAt: h.createdAt,
+    fermentedAt: h.fermentedAt,
+    fermentCount: h.fermentCount,
+    ...(h.mergedInto !== undefined ? { mergedInto: h.mergedInto } : {}),
   }
-  for (const r of rejected) {
-    const sim = jaccard(ideaBigrams, bigramSet(r.title + ' ' + r.idea))
-    if (sim > 0.6) {
-      return { shouldReject: true, rejectReason: `matches rejected: "${r.title}" (sim=${sim.toFixed(2)})`, adjustedNovelty: idea.novelty }
-    }
-  }
-  return { shouldReject: false, adjustedNovelty: Math.min(100, idea.novelty + 5) }
 }
 
-// ═══════════════════════════════════════════════
-//  Creativity Engine — main orchestrator
-// ═══════════════════════════════════════════════
-
-const STRATEGY_CYCLE = ['explore', 'signal', 'stable']
-
 class CreativityEngine {
   constructor(dataDir, chatJson) {
     this.store = new CreativityStore(dataDir)
@@ -221,56 +278,84 @@ class CreativityEngine {
 
     // Generate hypotheses via LLM
     const ideas = []
+    // A failed pair used to vanish: `catch {}` swallowed the exception and a
+    // chatJson `{ error }` payload fell through the `if (result.data)` guard,
+    // so the caller saw `ideas: []` with no explanation of whether the LLM was
+    // down, the JSON was unparseable, or every pair really was a duplicate.
+    const errors = []
     for (const [a, b] of pairs) {
       const prompt = this._buildGenerationPrompt(a, b, strat, recent.slice(-10), rejected.slice(-5))
       try {
         const result = await this.chatJson(prompt, {
-          system: `You are a creative hypothesis generator. Output JSON with fields: title, idea, expectedBenefit, risk, novelty (0-100), feasibility (0-100), impact (0-100). Generate ONE novel hypothesis by combining the given concepts.`,
+          system: [
+            'You are a creative hypothesis generator. Generate ONE novel hypothesis by combining the given concepts.',
+            'Reasoning rules:',
+            '1. First state the synergy mechanism: WHY these two concepts combine (what shared structure or complementary gap), not just THAT they pair.',
+            '2. Then give a causal chain: premise -> mechanism -> outcome. Each step must follow from the previous one; no unexplained jumps.',
+            '3. Be concrete: name the component, the change, and the observable effect. Vague claims ("improve efficiency", "be better") score 0 on logic.',
+            '4. State the strongest counter-risk honestly; an idea with no real risk is not being analyzed.',
+            'Output JSON with fields: title (<=60 chars), idea (the full causal chain, 100-250 words), expectedBenefit, risk, novelty (0-100), feasibility (0-100), impact (0-100), logic (0-100: how tight and complete the causal chain is).',
+          ].join('\n'),
           temperature: strat === 'explore' ? 0.8 : 0.4,
+          maxTokens: 900,
         })
 
-        if (result.data) {
-          const h = {
-            id: crypto.randomUUID(),
-            title: result.data.title || 'Untitled',
-            idea: result.data.idea || '',
-            expectedBenefit: result.data.expectedBenefit || '',
-            risk: result.data.risk || '',
-            novelty: Math.min(100, Math.max(0, result.data.novelty || 50)),
-            feasibility: Math.min(100, Math.max(0, result.data.feasibility || 50)),
-            impact: Math.min(100, Math.max(0, result.data.impact || 50)),
-            sourceLabels: [a.name, b.name],
-            status: 'active',
-            createdAt: Date.now(),
-            strategy: strat,
-          }
-
-          // Novelty check
-          const verdict = evaluateNovelty(h, recent, rejected)
-          if (verdict.shouldReject) {
-            h.status = 'rejected'
-            h.rejectionReason = verdict.rejectReason
-          } else {
-            h.novelty = verdict.adjustedNovelty
-          }
+        if (!result || !result.data) {
+          errors.push({
+            pair: [a.name, b.name],
+            error: (result && result.error) || 'LLM returned no data',
+          })
+          continue
+        }
 
-          this.store.addHypothesis(h)
-          ideas.push(h)
+        const h = {
+          id: crypto.randomUUID(),
+          title: String(result.data.title || 'Untitled').slice(0, 60),
+          idea: result.data.idea || '',
+          expectedBenefit: result.data.expectedBenefit || '',
+          risk: result.data.risk || '',
+          novelty: clamp100(result.data.novelty || 50),
+          feasibility: clamp100(result.data.feasibility || 50),
+          impact: clamp100(result.data.impact || 50),
+          // logic is the fourth scoring dimension: a high-novelty idea with a
+          // broken causal chain must be visibly weaker than one that reasons
+          // cleanly. Defaults to 50 so records written before it existed keep
+          // a neutral value instead of NaN.
+          logic: clamp100(result.data.logic ?? 50),
+          sourceLabels: [a.name, b.name],
+          status: 'active',
+          createdAt: Date.now(),
+          strategy: strat,
+        }
 
-          // Record combo
-          this.store.addCombo({
-            id: crypto.randomUUID(),
-            sources: [a.name, b.name],
-            description: h.title,
-            createdAt: Date.now(),
-          })
+        // Novelty check
+        const verdict = evaluateNovelty(h, recent, rejected)
+        if (verdict.shouldReject) {
+          h.status = 'rejected'
+          h.rejectionReason = verdict.rejectReason
+        } else {
+          h.novelty = verdict.adjustedNovelty
         }
+
+        this.store.addHypothesis(h)
+        ideas.push(h)
+
+        // Record combo
+        this.store.addCombo({
+          id: crypto.randomUUID(),
+          sources: [a.name, b.name],
+          description: h.title,
+          createdAt: Date.now(),
+        })
       } catch (err) {
-        // LLM call failed, skip this pair
+        errors.push({
+          pair: [a.name, b.name],
+          error: String((err && err.message) || err),
+        })
       }
     }
 
-    return { ideas, strategy: strat, pairsAttempted: pairs.length }
+    return { ideas, strategy: strat, pairsAttempted: pairs.length, errors }
   }
 
   async ferment(limit = 5) {
@@ -283,48 +368,105 @@ class CreativityEngine {
     }
 
     const results = []
+    // Same reason as generate(): a failing review used to be indistinguishable
+    // from a hypothesis that simply had nothing new to say.
+    const errors = []
     for (const h of fermentable) {
       const prompt = `Review and refine this hypothesis. Current state:
 Title: ${h.title}
 Idea: ${h.idea}
-Novelty: ${h.novelty}, Feasibility: ${h.feasibility}, Impact: ${h.impact}
+Novelty: ${h.novelty}, Feasibility: ${h.feasibility}, Impact: ${h.impact}, Logic: ${h.logic ?? '(not scored)'}
 
-Output JSON with: title, idea, expectedBenefit, risk, novelty, feasibility, impact, verdict (promote/keep/reject/merge), reason.`
+Review checklist (apply in order):
+1. Causal chain: does the idea explain WHY A leads to B at each step? If a step is asserted without a mechanism, lower logic and rewrite the step.
+2. Evidence: is each claim traceable to the given idea text, or is it speculation presented as fact? Flag speculation.
+3. Falsifiability: can you state how this idea would prove wrong? If not, say so in reason.
+4. Concrete over vague: reject filler claims ("improve efficiency") by rewriting them with the specific component and effect.
+
+Verdict rules:
+- promote: the idea is mature AND the refined scores justify landing (novelty + feasibility + impact > 200 with logic >= 60).
+- merge: only when this idea is clearly complementary to another stored one; set mergeWithId to that hypothesis id.
+- reject: the causal chain cannot be repaired, or the premise lost its supporting signals.
+- keep: everything else.
+
+Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibility (0-100), impact (0-100), logic (0-100), verdict (promote/keep/reject/merge), reason, mergeWithId (only for merge).`
 
       try {
         const result = await this.chatJson(prompt, {
-          system: 'You are a creative hypothesis reviewer. Output JSON with refined scores and a verdict.',
+          system: 'You are a critical creative hypothesis reviewer. Reward tight causal reasoning, penalize vagueness. Output JSON only.',
           temperature: 0.3,
+          maxTokens: 900,
         })
 
-        if (result.data) {
-          const patch = {
-            title: result.data.title || h.title,
-            idea: result.data.idea || h.idea,
-            expectedBenefit: result.data.expectedBenefit || h.expectedBenefit,
-            risk: result.data.risk || h.risk,
-            novelty: Math.min(100, Math.max(0, result.data.novelty || h.novelty)),
-            feasibility: Math.min(100, Math.max(0, result.data.feasibility || h.feasibility)),
-            impact: Math.min(100, Math.max(0, result.data.impact || h.impact)),
-            fermentedAt: Date.now(),
-            fermentCount: (h.fermentCount || 0) + 1,
-          }
+        if (!result || !result.data) {
+          errors.push({
+            id: h.id,
+            title: h.title,
+            error: (result && result.error) || 'LLM returned no data',
+          })
+          continue
+        }
+
+        const patch = {
+          title: String(result.data.title || h.title).slice(0, 60),
+          idea: result.data.idea || h.idea,
+          expectedBenefit: result.data.expectedBenefit || h.expectedBenefit,
+          risk: result.data.risk || h.risk,
+          novelty: clamp100(result.data.novelty || h.novelty),
+          feasibility: clamp100(result.data.feasibility || h.feasibility),
+          impact: clamp100(result.data.impact || h.impact),
+          logic: clamp100(result.data.logic ?? h.logic ?? 50),
+          fermentedAt: Date.now(),
+          fermentCount: (h.fermentCount || 0) + 1,
+        }
 
-          if (result.data.verdict === 'reject') {
-            patch.status = 'rejected'
-          } else if (result.data.verdict === 'promote' && (h.novelty + h.feasibility + h.impact) > 200) {
-            patch.status = 'validated'
+        let verdict = result.data.verdict
+        if (verdict === 'reject') {
+          patch.status = 'rejected'
+        } else if (verdict === 'merge') {
+          // merge used to fall through silently: the verdict was echoed back
+          // in the results but nothing was merged. Now it behaves like
+          // IdeaFermentationEngine -- the reviewed idea is folded into the
+          // target and marked merged, or downgraded to keep when the target
+          // id is unknown (an unresolvable merge is not a merge).
+          const target = result.data.mergeWithId
+            ? this.store.getHypotheses().find((x) => x.id === result.data.mergeWithId)
+            : null
+          if (target && target.id !== h.id) {
+            target.idea = [target.idea, patch.idea].filter(Boolean).join('\n---\n')
+            target.fermentedAt = patch.fermentedAt
+            target.fermentCount = (target.fermentCount || 0) + 1
+            this.store.updateHypothesis(target.id, {
+              idea: target.idea,
+              fermentedAt: target.fermentedAt,
+              fermentCount: target.fermentCount,
+            })
+            patch.status = 'merged'
+            patch.mergedInto = target.id
+          } else {
+            // An unresolvable merge target is not a merge; report it honestly
+            // as keep so the caller never sees a merge that did not happen.
+            verdict = 'keep'
           }
+        }
 
-          this.store.updateHypothesis(h.id, patch)
-          results.push({ id: h.id, title: h.title, verdict: result.data.verdict, reason: result.data.reason })
+        // The gate is unconditional: patch.logic already folds in the
+        // review's score, the stored score, or 50. A reviewer that omits
+        // the field falls back to the stored/neutral value — omitting logic
+        // must not waive the gate it exists to enforce.
+        const logicOk = Number.isFinite(patch.logic) && patch.logic >= 60
+        if (verdict === 'promote' && (patch.novelty + patch.feasibility + patch.impact) > 200 && logicOk) {
+          patch.status = 'validated'
         }
+
+        this.store.updateHypothesis(h.id, patch)
+        results.push({ id: h.id, title: h.title, verdict, reason: result.data.reason })
       } catch (err) {
-        // skip
+        errors.push({ id: h.id, title: h.title, error: String((err && err.message) || err) })
       }
     }
 
-    return { fermented: results.length, results }
+    return { fermented: results.length, results, errors }
   }
 
   status() {
@@ -332,44 +474,58 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty, feasibility, impa
     const active = this.store.getHypotheses({ status: 'active' })
     const validated = this.store.getHypotheses({ status: 'validated' })
     const rejected = this.store.getHypotheses({ status: 'rejected' })
+    // draft is a real state -- ferment() reviews draft + active -- so hiding it
+    // here made `status` and `list --status draft` disagree.
+    const draft = this.store.getHypotheses({ status: 'draft' })
 
     return {
       ...count,
       active: active.length,
       validated: validated.length,
       rejected: rejected.length,
+      draft: draft.length,
       recentIdeas: active.slice(-5).map(h => ({
         id: h.id,
         title: h.title,
         novelty: h.novelty,
         feasibility: h.feasibility,
         impact: h.impact,
+        // Undefined keys vanish over JSON (the CLI path); keep them out here
+        // too so the engine and the CLI round-trip deep-equal.
+        ...(h.logic !== undefined ? { logic: h.logic } : {}),
         score: h.novelty + h.feasibility + h.impact,
       })),
     }
   }
 
+  // The MCP schema and the CLI usage text both promise a default of 20; the
+  // implementation returned the whole store, so a large one flooded the tool
+  // result. `limit: 0` (and only 0) opts back into "everything".
   list(opts = {}) {
-    return this.store.getHypotheses(opts).map(h => ({
-      id: h.id,
-      title: h.title,
-      idea: h.idea,
-      status: h.status,
-      novelty: h.novelty,
-      feasibility: h.feasibility,
-      impact: h.impact,
-      score: h.novelty + h.feasibility + h.impact,
-      sourceLabels: h.sourceLabels,
-      createdAt: h.createdAt,
-      fermentedAt: h.fermentedAt,
-      fermentCount: h.fermentCount,
-    }))
+    const limit = opts.limit === undefined ? 20 : opts.limit
+    if (opts.sort === 'novelty') {
+      // Relative novelty ranking (read-only, nothing written back). Pairwise
+      // Jaccard is O(n²) — bound candidates to the newest 200 (spec Risk 3).
+      const candidates = this.store.getHypotheses({ status: opts.status }).slice(-200)
+      const rows = candidates.map((h) => {
+        const others = candidates.filter((x) => x.id !== h.id)
+        const verdict = evaluateNovelty(h, others, [])
+        return { ...listRow(h), noveltyScore: verdict.adjustedNovelty }
+      })
+      rows.sort((a, b) => b.noveltyScore - a.noveltyScore || (b.createdAt || 0) - (a.createdAt || 0))
+      return limit === 0 ? rows : rows.slice(0, limit)
+    }
+    return this.store.getHypotheses({ status: opts.status, limit }).map(listRow)
   }
 
   _buildGenerationPrompt(a, b, strategy, recentHypotheses, rejectedHypotheses) {
+    // Long sources used to be pasted unbounded, crowding the instructions out
+    // of the context window; 600 chars keeps the pairing signal without the
+    // flood.
+    const clip = (s, n = 600) => (s.length > n ? s.slice(0, n) + '…' : s)
     let prompt = `Combine these two concepts into ONE novel hypothesis:\n\n`
-    prompt += `Concept A: "${a.name}" — ${a.content}\n`
-    prompt += `Concept B: "${b.name}" — ${b.content}\n\n`
+    prompt += `Concept A: "${a.name}" — ${clip(a.content)}\n`
+    prompt += `Concept B: "${b.name}" — ${clip(b.content)}\n\n`
     prompt += `Strategy: ${strategy}\n`
 
     if (strategy === 'explore') {
@@ -380,6 +536,15 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty, feasibility, impa
       prompt += `Stable combination. Conservative refinement of existing ideas.\n`
     }
 
+    // The logical-quality bar, stated where the model composes rather than
+    // only in the system prompt: synergy mechanism, explicit causal chain,
+    // and no claims that cannot name their mechanism.
+    prompt += `\nQuality requirements:\n`
+    prompt += `- The idea must explain the synergy mechanism: WHY these two concepts combine.\n`
+    prompt += `- Write the proposal as a causal chain (premise -> mechanism -> outcome), each step following from the last.\n`
+    prompt += `- Be specific: component, change, observable effect. No bare claims like "improve efficiency".\n`
+    prompt += `- The title must be self-contained (a reader sees only the title in lists).\n`
+
     if (recentHypotheses.length > 0) {
       prompt += `\nRecent ideas (avoid duplicates):\n`
       for (const h of recentHypotheses) {
@@ -394,9 +559,9 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty, feasibility, impa
       }
     }
 
-    prompt += `\nOutput JSON: {"title": "...", "idea": "...", "expectedBenefit": "...", "risk": "...", "novelty": 0-100, "feasibility": 0-100, "impact": 0-100}`
+    prompt += `\nOutput JSON: {"title": "...", "idea": "...", "expectedBenefit": "...", "risk": "...", "novelty": 0-100, "feasibility": 0-100, "impact": 0-100, "logic": 0-100}`
     return prompt
   }
 }
 
-module.exports = { CreativityEngine, CreativityStore }
+module.exports = { CreativityEngine, CreativityStore, sourcesFromInsights, isoOf }