mio-agent-runtime 0.13.4 → 0.13.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.13.4",
+  "version": "0.13.5",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",
@@ -33,8 +33,8 @@
     "@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"
   },
   "main": "index.js",
   "directories": {

package/server/creativity-engine.js

@@ -4,6 +4,29 @@ const fs = require('fs')
 const path = require('path')
 const crypto = require('crypto')
 
+// 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))
+}
+
 // ═══════════════════════════════════════════════
 //  JSONL Store — ideas, combos, experiments
 // ═══════════════════════════════════════════════
@@ -17,6 +40,9 @@ class CreativityStore {
     this._hypotheses = null
     this._combos = null
     this._experiments = null
+    this._hypothesesSig = null
+    this._combosSig = null
+    this._experimentsSig = null
   }
 
   _ensureDir() {
@@ -42,8 +68,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 +81,7 @@ class CreativityStore {
 
   addHypothesis(h) {
     this._appendJsonl(this.hypothesesPath, h)
+    this._hypothesesSig = fileSignature(this.hypothesesPath)
     if (this._hypotheses) this._hypotheses.push(h)
   }
 
@@ -63,30 +92,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)
   }
 
@@ -178,6 +214,30 @@ function evaluateNovelty(idea, recent, rejected) {
 //  Creativity Engine — main orchestrator
 // ═══════════════════════════════════════════════
 
+// 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',
+      weight: 0.7,
+    }))
+}
+
 const STRATEGY_CYCLE = ['explore', 'signal', 'stable']
 
 class CreativityEngine {
@@ -221,56 +281,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 +371,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,25 +477,36 @@ 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 => ({
+    const limit = opts.limit === undefined ? 20 : opts.limit
+    return this.store.getHypotheses({ ...opts, limit }).map(h => ({
       id: h.id,
       title: h.title,
       idea: h.idea,
@@ -358,18 +514,24 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty, feasibility, impa
       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 } : {}),
     }))
   }
 
   _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 +542,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 +565,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 }

package/server/evolution-cutover.js

@@ -72,13 +72,16 @@ function createEvolutionCutoverTools({ dataDir, appendJsonl, readJsonl, projectN
     const project = projectFromArgs(args)
     const shadowRuns = readJsonl(shadowPath).filter((record) => record.project === project)
     const dualWriteRuns = readJsonl(dualWritePath).filter((record) => record.project === project)
+    // Apply documented defaults (schema says minShadowRuns: 5, maxMismatchRate: 0)
+    const minShadowRuns = Number.isFinite(args.minShadowRuns) ? args.minShadowRuns : 5
+    const maxMismatchRate = Number.isFinite(args.maxMismatchRate) ? args.maxMismatchRate : 0
     return {
       project,
       ...assessCutoverReadiness({
         shadowRuns,
         dualWriteRuns,
-        minShadowRuns: Number.isFinite(args.minShadowRuns) ? args.minShadowRuns : undefined,
-        maxMismatchRate: Number.isFinite(args.maxMismatchRate) ? args.maxMismatchRate : undefined,
+        minShadowRuns,
+        maxMismatchRate,
       }),
     }
   }

package/server/insight-store.js

@@ -52,10 +52,12 @@ function isInsightAvailable() {
   return Boolean(InsightStore)
 }
 
-// Score at or above which an unreported insight is counted as high-value in the
-// status summary.
-const INSIGHT_HIGH_VALUE_SCORE = 0.7
-const INSIGHT_HIGH_VALUE_LIMIT = 50
+// "High value" means score >= 50 (0-100 scale) AND confidence >= 0.7 (0-1).
+// These used to be named INSIGHT_HIGH_VALUE_SCORE = 0.7 / ..._LIMIT = 50 and
+// were passed in (LIMIT, SCORE) order -- correct only because the constants
+// happened to occupy each other's slots. Named for what they are now.
+const INSIGHT_HIGH_VALUE_SCORE_THRESHOLD = 50
+const INSIGHT_HIGH_VALUE_CONFIDENCE_THRESHOLD = 0.7
 
 function createInsightStore(options = {}) {
   const dataDir = options.dataDir
@@ -94,7 +96,10 @@ function createInsightStore(options = {}) {
       total: all.length,
       unreported: unreported.length,
       reported: all.length - unreported.length,
-      highValue: s.getHighValueUnreported(INSIGHT_HIGH_VALUE_LIMIT, INSIGHT_HIGH_VALUE_SCORE).length,
+      highValue: s.getHighValueUnreported(
+        INSIGHT_HIGH_VALUE_SCORE_THRESHOLD,
+        INSIGHT_HIGH_VALUE_CONFIDENCE_THRESHOLD,
+      ).length,
     }
   }
 
@@ -125,7 +130,11 @@ function createInsightStore(options = {}) {
         createdAt: m.createdAt || m.timestamp || Date.now(),
       })),
       summaries: args.summaries || [],
-      interactionCount: 0,
+      // 桌面端有真实交互流；CLI 默认没有。调用方可显式传入
+      // interactionCount/eventCount（如 MCP 侧按 trace 统计），
+      // 不传时 Scorer 会按记忆新鲜度给 confidence 兜底（旧逻辑
+      // 恒 0.2 会把 highValue 永久压成 0）。
+      interactionCount: Number(args.interactionCount) || 0,
       plans: (args.plans || []).map((p) => ({
         title: p.title || p.name || '',
         status: p.status || 'unknown',
@@ -133,13 +142,30 @@ function createInsightStore(options = {}) {
         steps: p.steps || [],
         createdAt: p.createdAt || Date.now(),
       })),
-      eventCount: 0,
+      eventCount: Number(args.eventCount) || 0,
     }
     const insights = await generator.generate(ctx)
     if (InsightStore && storePath) {
-      requireStore().addMany(insights)
+      // addMany is a pure push: every `mio insight generate` run used to
+      // append another copy of the same detection. Drop titles the store
+      // already holds (reported or not) so re-running is idempotent.
+      const s = requireStore()
+      const seen = new Set(s.getAll().map((i) => String(i.title || '').trim().toLowerCase()))
+      // Dedup against the store AND within the batch -- a generator that emits
+      // the same detection twice in one run must not survive just because the
+      // second copy was not there when the set was built.
+      const fresh = []
+      for (const i of insights || []) {
+        if (!i) continue
+        const key = i.title ? String(i.title).trim().toLowerCase() : null
+        if (key !== null && seen.has(key)) continue
+        if (key !== null) seen.add(key)
+        fresh.push(i)
+      }
+      if (fresh.length > 0) s.addMany(fresh)
+      return { generated: fresh.length, duplicates: (insights || []).length - fresh.length, insights: fresh }
     }
-    return { generated: insights.length, insights }
+    return { generated: (insights || []).length, insights }
   }
 
   return {
@@ -154,6 +180,6 @@ function createInsightStore(options = {}) {
 module.exports = {
   createInsightStore,
   isInsightAvailable,
-  INSIGHT_HIGH_VALUE_SCORE,
-  INSIGHT_HIGH_VALUE_LIMIT,
+  INSIGHT_HIGH_VALUE_SCORE_THRESHOLD,
+  INSIGHT_HIGH_VALUE_CONFIDENCE_THRESHOLD,
 }

package/server/llm-client.js

@@ -27,14 +27,13 @@ const path = require('path')
 const DEFAULT_API_URL = 'https://opencode.ai/zen/go/v1/chat/completions'
 const DEFAULT_MODEL = 'deepseek-v4-flash'
 
-// Resolve the directory holding config.json. The CLI and the MCP server use
-// different data dirs by design (MIO_HOME vs MIO_DATA_DIR||cwd/.mio-intelligence),
-// so we honour whichever is set and fall back to the CLI default. No third
-// convention is introduced here on purpose.
+// Resolve the directory holding config.json. The CLI uses MIO_HOME
+// (~/.mio-intelligence by default). The MCP server uses MIO_DATA_DIR ||
+// cwd/.mio-intelligence. This module serves the CLI-facing `llm-config`/
+// `config llm` commands, so we follow the CLI convention: MIO_HOME first.
 function homeDir() {
   return (
     process.env.MIO_HOME ||
-    process.env.MIO_DATA_DIR ||
     path.join(os.homedir(), '.mio-intelligence')
   )
 }
@@ -118,6 +117,13 @@ async function chatJson(userText, opts = {}) {
   const system = opts.system || 'You are a creative AI assistant. Output JSON.'
   const temperature = opts.temperature ?? 0.3
 
+  // response_format must match the prompt's top-level shape. Prompts that
+  // demand a top-level JSON array (InsightPrompt) can be rejected outright
+  // (HTTP 400) by OpenAI-compatible gateways that enforce json_object, so
+  // array callers omit the field and rely on prompt + fence-stripping parse.
+  const wantsArray = opts.responseFormat === 'array'
+  const responseFormat = wantsArray ? undefined : { type: 'json_object' }
+
   try {
     const resp = await fetch(apiUrl, {
       method: 'POST',
@@ -128,11 +134,12 @@ async function chatJson(userText, opts = {}) {
       body: JSON.stringify({
         model,
         temperature,
+        ...(opts.maxTokens ? { max_tokens: opts.maxTokens } : {}),
         messages: [
           { role: 'system', content: system },
           { role: 'user', content: userText },
         ],
-        response_format: { type: 'json_object' },
+        ...(responseFormat ? { response_format: responseFormat } : {}),
       }),
       signal: AbortSignal.timeout(opts.timeoutMs || 30000),
     })
@@ -140,10 +147,24 @@ async function chatJson(userText, opts = {}) {
     if (!resp.ok) return { error: `HTTP ${resp.status}` }
     const json = await resp.json()
     const text = json.choices?.[0]?.message?.content || ''
+
+    // Parse failures used to return { data: rawText }, so a prose answer
+    // masqueraded as a parsed object: callers testing truthy `result.data`
+    // stored an untitled, score-less record (and polluted the novelty
+    // dedup pool). A model that answered with anything but JSON is an
+    // error, not a degraded success. One retry with a code fence stripped
+    // covers models that wrap JSON despite response_format.
     try {
       return { data: JSON.parse(text) }
-    } catch {
-      return { data: text }
+    } catch (_) {}
+    const stripped = text.replace(/^\s*```(?:json)?\s*/i, '').replace(/\s*```\s*$/, '')
+    try {
+      return { data: JSON.parse(stripped) }
+    } catch (_) {
+      return {
+        error: 'model returned unparseable JSON',
+        raw: String(text).slice(0, 300),
+      }
     }
   } catch (err) {
     return { error: String(err) }