mio-agent-runtime 0.5.16 → 0.5.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.5.16",
+  "version": "0.5.17",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",
@@ -9,28 +9,30 @@
   },
   "files": [
     "bin/",
-    "server/",
-    "adapters/",
-    "observe/",
-    "scripts/",
-    "README.md",
+    "server/",
+    "adapters/",
+    "observe/",
+    "scripts/",
+    "README.md",
     "!server/mio-intelligence-mcp/__tests__"
   ],
-  "scripts": {
-    "check": "node --check bin/mio.js && node --check adapters/host-utils.js && node --check adapters/codex.js && node --check adapters/opencode.js && node --check adapters/workbuddy.js && node --check adapters/hermes.js && node --check server/runtime-modules.js && node --check server/host-capabilities.js && node --check server/evolution-cutover.js && node --check server/mio-intelligence-mcp/index.js && node --check server/mio-intelligence-mcp/phase0.js && node --check observe/observer.js && node --check scripts/verify-packed-runtime.js",
-    "prepack": "npm run check",
-    "verify:pack-install": "node scripts/verify-packed-runtime.js"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@akemi-mio/runtime-contracts": "^0.1.0",
-    "@akemi-mio/runtime-foundation": "^0.1.0",
-    "@akemi-mio/experience-memory": "^0.1.0",
-    "@akemi-mio/evolution-learning": "^0.1.0",
-    "@akemi-mio/evolution-strategy": "^0.1.0",
-    "@akemi-mio/evolution-safety": "^0.1.0",
-    "@akemi-mio/evolution-scheduler": "^0.1.0"
-  }
-}
+  "scripts": {
+    "check": "node --check bin/mio.js && node --check adapters/host-utils.js && node --check adapters/codex.js && node --check adapters/opencode.js && node --check adapters/workbuddy.js && node --check adapters/hermes.js && node --check server/runtime-modules.js && node --check server/host-capabilities.js && node --check server/evolution-cutover.js && node --check server/mio-intelligence-mcp/index.js && node --check server/mio-intelligence-mcp/phase0.js && node --check observe/observer.js && node --check scripts/verify-packed-runtime.js",
+    "prepack": "npm run check",
+    "verify:pack-install": "node scripts/verify-packed-runtime.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@akemi-mio/runtime-contracts": "^0.1.0",
+    "@akemi-mio/runtime-foundation": "^0.1.0",
+    "@akemi-mio/experience-memory": "^0.1.0",
+    "@akemi-mio/evolution-learning": "^0.1.0",
+    "@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.0",
+    "@akemi-mio/insight": "^0.1.0"
+  }
+}

package/server/creativity-engine.js

@@ -0,0 +1,397 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const crypto = require('crypto')
+
+// ═══════════════════════════════════════════════
+//  JSONL Store — ideas, combos, experiments
+// ═══════════════════════════════════════════════
+
+class CreativityStore {
+  constructor(dataDir) {
+    this.dataDir = dataDir
+    this.hypothesesPath = path.join(dataDir, 'creativity-hypotheses.jsonl')
+    this.combosPath = path.join(dataDir, 'creativity-combos.jsonl')
+    this.experimentsPath = path.join(dataDir, 'creativity-experiments.jsonl')
+    this._hypotheses = null
+    this._combos = null
+    this._experiments = null
+  }
+
+  _ensureDir() {
+    if (!fs.existsSync(this.dataDir)) {
+      fs.mkdirSync(this.dataDir, { recursive: true })
+    }
+  }
+
+  _readJsonl(filePath) {
+    if (!fs.existsSync(filePath)) return []
+    return fs.readFileSync(filePath, 'utf-8')
+      .split('\n')
+      .filter(Boolean)
+      .map(line => {
+        try { return JSON.parse(line) } catch { return null }
+      })
+      .filter(Boolean)
+  }
+
+  _appendJsonl(filePath, record) {
+    this._ensureDir()
+    fs.appendFileSync(filePath, JSON.stringify(record) + '\n')
+  }
+
+  getHypotheses(opts = {}) {
+    if (this._hypotheses === null) {
+      this._hypotheses = this._readJsonl(this.hypothesesPath)
+    }
+    let list = this._hypotheses
+    if (opts.status) list = list.filter(h => h.status === opts.status)
+    if (opts.limit) list = list.slice(-opts.limit)
+    return list
+  }
+
+  addHypothesis(h) {
+    this._appendJsonl(this.hypothesesPath, h)
+    if (this._hypotheses) this._hypotheses.push(h)
+  }
+
+  updateHypothesis(id, patch) {
+    const all = this.getHypotheses()
+    const idx = all.findIndex(h => h.id === id)
+    if (idx === -1) return false
+    Object.assign(all[idx], patch)
+    this._hypotheses = all
+    this._rewriteFile(this.hypothesesPath, all)
+    return true
+  }
+
+  getCombos(limit) {
+    if (this._combos === null) {
+      this._combos = this._readJsonl(this.combosPath)
+    }
+    return limit ? this._combos.slice(-limit) : this._combos
+  }
+
+  addCombo(c) {
+    this._appendJsonl(this.combosPath, c)
+    if (this._combos) this._combos.push(c)
+  }
+
+  getExperiments() {
+    if (this._experiments === null) {
+      this._experiments = this._readJsonl(this.experimentsPath)
+    }
+    return this._experiments
+  }
+
+  addExperiment(e) {
+    this._appendJsonl(this.experimentsPath, e)
+    if (this._experiments) this._experiments.push(e)
+  }
+
+  count() {
+    return {
+      hypotheses: this.getHypotheses().length,
+      combos: this.getCombos().length,
+      experiments: this.getExperiments().length,
+    }
+  }
+
+  _rewriteFile(filePath, records) {
+    this._ensureDir()
+    fs.writeFileSync(filePath, records.map(r => JSON.stringify(r)).join('\n') + '\n')
+  }
+}
+
+// ═══════════════════════════════════════════════
+//  Concept Mixer — pair sources for novel combos
+// ═══════════════════════════════════════════════
+
+function mulberry32(seed) {
+  let t = seed | 0
+  return () => {
+    t = (t + 0x6D2B79F5) | 0
+    let x = Math.imul(t ^ (t >>> 15), 1 | t)
+    x ^= x + Math.imul(x ^ (x >>> 7), 61 | x)
+    return ((x ^ (x >>> 14)) >>> 0) / 4294967296
+  }
+}
+
+function mixConcepts(sources, exploredPairs, rng) {
+  if (sources.length < 2) return []
+  const pairs = []
+  for (let i = 0; i < sources.length; i++) {
+    for (let j = i + 1; j < sources.length; j++) {
+      const key = `${sources[i].name}||${sources[j].name}`
+      const reverseKey = `${sources[j].name}||${sources[i].name}`
+      if (exploredPairs.has(key) || exploredPairs.has(reverseKey)) continue
+      pairs.push([sources[i], sources[j]])
+    }
+  }
+  // Shuffle and take top pairs
+  for (let i = pairs.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1))
+    ;[pairs[i], pairs[j]] = [pairs[j], pairs[i]]
+  }
+  return pairs.slice(0, Math.min(5, pairs.length))
+}
+
+// ═══════════════════════════════════════════════
+//  Novelty Scorer — reject duplicates
+// ═══════════════════════════════════════════════
+
+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
+}
+
+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)
+}
+
+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 }
+    }
+  }
+  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)
+    this.chatJson = chatJson
+    this.strategyIndex = 0
+    this.exploredPairs = new Set()
+    this.rng = mulberry32(Date.now())
+  }
+
+  async generate(sourceLabels, strategy) {
+    const sources = sourceLabels.map(s => ({
+      name: s.name || 'unnamed',
+      content: s.content || '',
+      type: s.type || 'knowledge',
+      weight: s.weight || 0.5,
+    }))
+
+    if (sources.length < 2) {
+      return { ideas: [], reason: 'need at least 2 sources' }
+    }
+
+    const strat = strategy || STRATEGY_CYCLE[this.strategyIndex % STRATEGY_CYCLE.length]
+    this.strategyIndex++
+
+    // Mix concepts
+    const recent = this.store.getHypotheses({ limit: 30 })
+    const rejected = this.store.getHypotheses({ status: 'rejected', limit: 50 })
+    const exploredPairs = new Set(recent.flatMap(h => (h.sourceLabels || []).map((l, i, a) => i > 0 ? `${a[i-1]}||${l}` : '')).filter(Boolean))
+    const pairs = mixConcepts(sources, exploredPairs, this.rng.bind(this))
+
+    if (pairs.length === 0) {
+      return { ideas: [], reason: 'all pairs already explored' }
+    }
+
+    // Generate hypotheses via LLM
+    const ideas = []
+    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.`,
+          temperature: strat === 'explore' ? 0.8 : 0.4,
+        })
+
+        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
+          }
+
+          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
+      }
+    }
+
+    return { ideas, strategy: strat, pairsAttempted: pairs.length }
+  }
+
+  async ferment(limit = 5) {
+    const fermentable = this.store.getHypotheses({ status: 'active' })
+      .concat(this.store.getHypotheses({ status: 'draft' }))
+      .slice(-limit)
+
+    if (fermentable.length === 0) {
+      return { fermented: 0, reason: 'no fermentable hypotheses' }
+    }
+
+    const results = []
+    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}
+
+Output JSON with: title, idea, expectedBenefit, risk, novelty, feasibility, impact, verdict (promote/keep/reject/merge), reason.`
+
+      try {
+        const result = await this.chatJson(prompt, {
+          system: 'You are a creative hypothesis reviewer. Output JSON with refined scores and a verdict.',
+          temperature: 0.3,
+        })
+
+        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.data.verdict === 'reject') {
+            patch.status = 'rejected'
+          } else if (result.data.verdict === 'promote' && (h.novelty + h.feasibility + h.impact) > 200) {
+            patch.status = 'validated'
+          }
+
+          this.store.updateHypothesis(h.id, patch)
+          results.push({ id: h.id, title: h.title, verdict: result.data.verdict, reason: result.data.reason })
+        }
+      } catch (err) {
+        // skip
+      }
+    }
+
+    return { fermented: results.length, results }
+  }
+
+  status() {
+    const count = this.store.count()
+    const active = this.store.getHypotheses({ status: 'active' })
+    const validated = this.store.getHypotheses({ status: 'validated' })
+    const rejected = this.store.getHypotheses({ status: 'rejected' })
+
+    return {
+      ...count,
+      active: active.length,
+      validated: validated.length,
+      rejected: rejected.length,
+      recentIdeas: active.slice(-5).map(h => ({
+        id: h.id,
+        title: h.title,
+        novelty: h.novelty,
+        feasibility: h.feasibility,
+        impact: h.impact,
+        score: h.novelty + h.feasibility + h.impact,
+      })),
+    }
+  }
+
+  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,
+    }))
+  }
+
+  _buildGenerationPrompt(a, b, strategy, recentHypotheses, rejectedHypotheses) {
+    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 += `Strategy: ${strategy}\n`
+
+    if (strategy === 'explore') {
+      prompt += `Cross-domain combination. Emphasize structural differences and unexpected connections.\n`
+    } else if (strategy === 'signal') {
+      prompt += `Inject external signals. Be provocative and challenge assumptions.\n`
+    } else {
+      prompt += `Stable combination. Conservative refinement of existing ideas.\n`
+    }
+
+    if (recentHypotheses.length > 0) {
+      prompt += `\nRecent ideas (avoid duplicates):\n`
+      for (const h of recentHypotheses) {
+        prompt += `- "${h.title}" (novelty=${h.novelty})\n`
+      }
+    }
+
+    if (rejectedHypotheses.length > 0) {
+      prompt += `\nRejected ideas (learn from failures):\n`
+      for (const h of rejectedHypotheses) {
+        prompt += `- "${h.title}" — ${h.risk}\n`
+      }
+    }
+
+    prompt += `\nOutput JSON: {"title": "...", "idea": "...", "expectedBenefit": "...", "risk": "...", "novelty": 0-100, "feasibility": 0-100, "impact": 0-100}`
+    return prompt
+  }
+}
+
+module.exports = { CreativityEngine, CreativityStore }

package/server/mio-intelligence-mcp/README.md

@@ -103,7 +103,7 @@ task_outcome 数据经 auto-claim → confirm 后会自动升级后续同类动
 ```toml
 [mcp_servers.mio-intelligence]
 command = 'C:\nvm4w\nodejs\node.exe'
-args = ['D:\work\code\akemi-mio\.worktrees\mio-agent-enhancement-layer\server\mio-intelligence-mcp\index.js']
+args = ['/absolute/path/to/mio-agent-runtime/server/mio-intelligence-mcp/index.js']
 startup_timeout_sec = 30
 
 [mcp_servers.mio-intelligence.env]
@@ -136,7 +136,7 @@ OpenCode / WorkBuddy 的 MCP 配置只需保持同样语义：
     "mio": {
       "command": "node",
       "args": [
-        "D:/work/code/akemi-mio/.worktrees/mio-agent-enhancement-layer/server/mio-intelligence-mcp/index.js"
+        "/absolute/path/to/mio-agent-runtime/server/mio-intelligence-mcp/index.js"
       ],
       "env": {
         "MIO_DATA_DIR": "C:/Users/gf191/.mio-intelligence",

package/server/mio-intelligence-mcp/index.js

@@ -10,9 +10,74 @@ const { getEvolutionStatus } = require('../runtime-modules.js')
 const { listHostCapabilities } = require('../host-capabilities.js')
 const { createEvolutionCutoverTools } = require('../evolution-cutover.js')
 
+const { CreativityEngine } = require('../creativity-engine.js')
+
+// Observer research pipeline (optional — installed via @akemi-mio/observer)
+let ObserverStore = null
+let ObserverService = null
+try {
+  const obs = require('@akemi-mio/observer')
+  ObserverStore = obs.ObserverStore
+  ObserverService = obs.ObserverService
+} catch {}
+
+// Insight self-observation engine (optional — installed via @akemi-mio/insight)
+let InsightStore = null
+let InsightGenerator = null
+let PresenceService = null
+try {
+  const insight = require('@akemi-mio/insight')
+  InsightStore = insight.InsightStore
+  InsightGenerator = insight.InsightGenerator
+  PresenceService = insight.PresenceService
+} catch {}
+
 const SERVER_INFO = { name: 'mio-intelligence-mcp', version: '0.1.0' }
 const PROTOCOL_VERSION = '2024-11-05'
 
+// ═══════════════════════════════════════════════
+//  LLM chatJson — used by creativity engine
+// ═══════════════════════════════════════════════
+
+async function chatJson(userText, opts = {}) {
+  const apiUrl = process.env.LLM_API_URL || 'https://opencode.ai/zen/go/v1/chat/completions'
+  const apiKey = process.env.LLM_KEY || ''
+  const model = process.env.LLM_CHAT_MODEL || process.env.LLM_MODEL || 'deepseek-v4-flash'
+  const system = opts.system || 'You are a creative AI assistant. Output JSON.'
+  const temperature = opts.temperature ?? 0.3
+
+  try {
+    const resp = await fetch(apiUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+      },
+      body: JSON.stringify({
+        model,
+        temperature,
+        messages: [
+          { role: 'system', content: system },
+          { role: 'user', content: userText },
+        ],
+        response_format: { type: 'json_object' },
+      }),
+      signal: AbortSignal.timeout(opts.timeoutMs || 30000),
+    })
+
+    if (!resp.ok) return { error: `HTTP ${resp.status}` }
+    const json = await resp.json()
+    const text = json.choices?.[0]?.message?.content || ''
+    try {
+      return { data: JSON.parse(text) }
+    } catch {
+      return { data: text }
+    }
+  } catch (err) {
+    return { error: String(err) }
+  }
+}
+
 const dataDir = path.resolve(
   process.env.MIO_DATA_DIR || path.join(process.cwd(), '.mio-intelligence')
 )
@@ -25,8 +90,10 @@ const subscriptionPath = path.join(dataDir, 'subscriptions.jsonl')
 const digestStatePath = path.join(dataDir, 'digest_state.json')
 fs.mkdirSync(dataDir, { recursive: true })
 
-const { loadPhase0, summarizePhase0, renderPhase0Markdown } = require('./phase0')
-const evolutionCutover = createEvolutionCutoverTools({ dataDir, appendJsonl, readJsonl, projectName })
+const { loadPhase0, summarizePhase0, renderPhase0Markdown } = require('./phase0')
+const evolutionCutover = createEvolutionCutoverTools({ dataDir, appendJsonl, readJsonl, projectName })
+const creativityEngine = new CreativityEngine(path.join(dataDir, 'creativity'), chatJson)
+const insightStore = InsightStore ? new InsightStore(path.join(dataDir, 'insights', 'insights.json')) : null
 
 let runtimeContext = {}
 try {
@@ -1720,8 +1787,410 @@ const TOOLS = [
       required: ['outcome'],
     },
   },
+  {
+    name: 'mio.creativity.status',
+    description: 'Show creativity engine status: hypothesis counts, active/validated/rejected, recent top ideas.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'mio.creativity.list',
+    description: 'List creativity hypotheses with optional status filter.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        status: { type: 'string', description: 'Filter by status: active, validated, rejected, draft.' },
+        limit: { type: 'number', description: 'Max results. Default 20.' },
+      },
+    },
+  },
+  {
+    name: 'mio.creativity.generate',
+    description: 'Generate new creative hypotheses by combining concept sources via LLM. Returns ideas with novelty/feasibility/impact scores.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sources: {
+          type: 'array',
+          description: 'Concept sources to combine. Each has name, content, type (knowledge/behavior/insight/failure), weight.',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              content: { type: 'string' },
+              type: { type: 'string' },
+              weight: { type: 'number' },
+            },
+            required: ['name', 'content'],
+          },
+        },
+        strategy: { type: 'string', description: 'Generation strategy: explore (cross-domain), signal (provocative), stable (conservative). Auto-selected if omitted.' },
+      },
+      required: ['sources'],
+    },
+  },
+  {
+    name: 'mio.creativity.ferment',
+    description: 'Ferment (review and refine) active hypotheses. Updates scores, can promote/reject ideas.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max hypotheses to ferment. Default 5.' },
+      },
+    },
+  },
+
+  // ═══ Observer Research Pipeline ═══
+
+  // ═══ Insight Self-Observation ═══
+
+  ...(insightStore ? [{
+    name: 'mio.insight.status',
+    description: 'Get insight engine status: total insights, unreported count, cooldown.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'mio.insight.list',
+    description: 'List stored insights with optional filters.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        unreported: { type: 'boolean', description: 'Only unreported insights' },
+        minScore: { type: 'number', description: 'Minimum score filter' },
+        detector: { type: 'string', description: 'Filter by detector name' },
+        limit: { type: 'number', description: 'Max results (default 20)' },
+      },
+    },
+  },
+  {
+    name: 'mio.insight.mark_reported',
+    description: 'Mark insights as reported (acknowledged).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ids: { type: 'array', items: { type: 'string' }, description: 'Insight IDs to mark' },
+      },
+      required: ['ids'],
+    },
+  },
+  {
+    name: 'mio.insight.generate',
+    description: 'Run LLM-based insight generation from provided context data.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        memories: { type: 'array', items: { type: 'object' }, description: 'Memory entries to analyze' },
+        summaries: { type: 'array', items: { type: 'string' }, description: 'Recent summaries' },
+        plans: { type: 'array', items: { type: 'object' }, description: 'Active plans' },
+      },
+    },
+  }] : []),
+
+  // ═══ Observer Research Pipeline ═══
+
+  ...(ObserverStore ? [{
+    name: 'mio.observer.world_model',
+    description: 'Query the Observer world model: entities, events, trends, narratives, uncertainties, and relations.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        baseDir: { type: 'string', description: 'Observer data directory (default: .local/observer)' },
+      },
+    },
+  },
+  {
+    name: 'mio.observer.trends',
+    description: 'Get recent trend reports from the Observer pipeline.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        date: { type: 'string', description: 'Specific date (YYYY-MM-DD) or null for latest' },
+        limit: { type: 'number', description: 'Max reports to return (default 7)' },
+        baseDir: { type: 'string', description: 'Observer data directory' },
+      },
+    },
+  },
+  {
+    name: 'mio.observer.research',
+    description: 'List recent deep research results from the Observer pipeline.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max results (default 10)' },
+        baseDir: { type: 'string', description: 'Observer data directory' },
+      },
+    },
+  },
+  {
+    name: 'mio.observer.insights',
+    description: 'List Observer-generated insights (5-section structured articles).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max insights (default 20)' },
+        baseDir: { type: 'string', description: 'Observer data directory' },
+      },
+    },
+  },
+  {
+    name: 'mio.observer.status',
+    description: 'Get Observer pipeline status: counts of observations, trends, topics, research, insights, essays, and world model entities.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        baseDir: { type: 'string', description: 'Observer data directory' },
+      },
+    },
+  },
+  {
+    name: 'mio.observer.collect',
+    description: 'Force data collection from all configured sources (RSS, Bilibili, HackerNews, GitHub, Douyin). Returns collected observations.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sources: { type: 'array', items: { type: 'string' }, description: 'Specific sources to collect (default: all)' },
+        keywords: { type: 'array', items: { type: 'string' }, description: 'Keyword filter (OR match)' },
+        limit: { type: 'number', description: 'Max items per source (default 20)' },
+        baseDir: { type: 'string', description: 'Observer data directory' },
+      },
+    },
+  },
+  {
+    name: 'mio.observer.ferment',
+    description: 'Run fermentation engine: find recurring themes across recent observations and optionally write an essay.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        session: { type: 'string', description: 'Session label: morning/afternoon/night (default: afternoon)' },
+        baseDir: { type: 'string', description: 'Observer data directory' },
+      },
+    },
+  },
+  {
+    name: 'mio.observer.essays',
+    description: 'List published or draft essays from the Observer.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        type: { type: 'string', description: 'published or draft (default: published)' },
+        limit: { type: 'number', description: 'Max essays (default 10)' },
+        baseDir: { type: 'string', description: 'Observer data directory' },
+      },
+    },
+  },
+  {
+    name: 'mio.observer.dag',
+    description: 'Get DAG state machine status: today\'s task, recent summaries, retryable tasks.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        days: { type: 'number', description: 'Days to look back (default 7)' },
+        baseDir: { type: 'string', description: 'Observer data directory' },
+      },
+    },
+  }] : []),
 ]
 
+// ═══ Insight Self-Observation Handlers ═══
+
+function insightStatus() {
+  if (!insightStore) throw new Error('@akemi-mio/insight not installed')
+  const all = insightStore.getAll()
+  const unreported = insightStore.getUnreported()
+  return {
+    total: all.length,
+    unreported: unreported.length,
+    reported: all.length - unreported.length,
+    highValue: insightStore.getHighValueUnreported(50, 0.7).length,
+  }
+}
+
+function insightList(args = {}) {
+  if (!insightStore) throw new Error('@akemi-mio/insight not installed')
+  let insights = insightStore.getAll()
+  if (args.unreported) insights = insightStore.getUnreported()
+  if (args.minScore) insights = insights.filter(i => i.score >= args.minScore)
+  if (args.detector) insights = insights.filter(i => i.detector === args.detector)
+  if (args.limit) insights = insights.slice(-args.limit)
+  return insights
+}
+
+function insightMarkReported(args = {}) {
+  if (!insightStore) throw new Error('@akemi-mio/insight not installed')
+  if (!args.ids || !Array.isArray(args.ids)) throw new Error('ids array required')
+  for (const id of args.ids) insightStore.markReported(id)
+  return { marked: args.ids.length }
+}
+
+async function insightGenerate(args = {}) {
+  if (!InsightGenerator) throw new Error('@akemi-mio/insight not installed')
+  const generator = new InsightGenerator({ chatJson })
+  const ctx = {
+    memoryEntries: (args.memories || []).map(m => ({
+      type: m.kind || m.type || 'note',
+      content: m.content || '',
+      createdAt: m.createdAt || m.timestamp || Date.now(),
+    })),
+    summaries: args.summaries || [],
+    interactionCount: 0,
+    plans: (args.plans || []).map(p => ({
+      title: p.title || p.name || '',
+      status: p.status || 'unknown',
+      updatedAt: p.updatedAt || Date.now(),
+      steps: p.steps || [],
+      createdAt: p.createdAt || Date.now(),
+    })),
+    eventCount: 0,
+  }
+  const insights = await generator.generate(ctx)
+  if (insightStore) {
+    for (const i of insights) insightStore.addMany([i])
+  }
+  return { generated: insights.length, insights }
+}
+
+// ═══ Observer Research Pipeline Handlers ═══
+
+function getObserverStore(baseDir) {
+  if (!ObserverStore) throw new Error('@akemi-mio/observer not installed')
+  return new ObserverStore(baseDir || path.join(process.cwd(), '.local', 'observer'))
+}
+
+function getObserverBaseDir(args) {
+  return args.baseDir || path.join(process.cwd(), '.local', 'observer')
+}
+
+function readJsonSafe(filePath) {
+  if (!fs.existsSync(filePath)) return null
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')) } catch { return null }
+}
+
+function readJsonlSafe(filePath) {
+  if (!fs.existsSync(filePath)) return []
+  try {
+    return fs.readFileSync(filePath, 'utf8').trim().split('\n').filter(Boolean)
+      .map(l => { try { return JSON.parse(l) } catch { return null } }).filter(Boolean)
+  } catch { return [] }
+}
+
+function observerWorldModel(args = {}) {
+  const baseDir = getObserverBaseDir(args)
+  const wmDir = path.join(baseDir, 'world_model')
+  return {
+    entities: readJsonSafe(path.join(wmDir, 'entities.json')) || [],
+    events: readJsonSafe(path.join(wmDir, 'events.json')) || [],
+    trends: readJsonSafe(path.join(wmDir, 'trends.json')) || [],
+    narratives: readJsonSafe(path.join(wmDir, 'narratives.json')) || [],
+  }
+}
+
+function observerTrends(args = {}) {
+  const baseDir = getObserverBaseDir(args)
+  const trendsDir = path.join(baseDir, 'trends')
+  if (!fs.existsSync(trendsDir)) return []
+  if (args.date) {
+    const report = readJsonSafe(path.join(trendsDir, `${args.date}.json`))
+    return report ? [report] : []
+  }
+  const files = fs.readdirSync(trendsDir).filter(f => f.endsWith('.json')).sort().reverse()
+  return files.slice(0, args.limit || 7).map(f => readJsonSafe(path.join(trendsDir, f))).filter(Boolean)
+}
+
+function observerResearch(args = {}) {
+  const baseDir = getObserverBaseDir(args)
+  const researchDir = path.join(baseDir, 'research')
+  if (!fs.existsSync(researchDir)) return []
+  const files = fs.readdirSync(researchDir).filter(f => f.endsWith('.json')).sort().reverse()
+  return files.slice(0, args.limit || 10).map(f => readJsonSafe(path.join(researchDir, f))).filter(Boolean)
+}
+
+function observerInsights(args = {}) {
+  const baseDir = getObserverBaseDir(args)
+  const insightsDir = path.join(baseDir, 'insights')
+  if (!fs.existsSync(insightsDir)) return []
+  const files = fs.readdirSync(insightsDir).filter(f => f.endsWith('.json')).sort().reverse()
+  return files.slice(0, args.limit || 20).map(f => readJsonSafe(path.join(insightsDir, f))).filter(Boolean)
+}
+
+function observerStatus(args = {}) {
+  const baseDir = getObserverBaseDir(args)
+  const dirs = ['observations', 'trends', 'topics', 'research', 'insights', 'world_model', 'essays']
+  const status = {}
+  for (const d of dirs) {
+    const dir = path.join(baseDir, d)
+    if (fs.existsSync(dir)) {
+      status[d] = fs.readdirSync(dir).filter(f => !f.startsWith('.')).length
+    } else {
+      status[d] = 0
+    }
+  }
+  return status
+}
+
+function observerCollect(args = {}) {
+  if (!ObserverService) throw new Error('@akemi-mio/observer not installed')
+  const baseDir = getObserverBaseDir(args)
+  const service = new ObserverService({ baseDir, collectorConfig: {} })
+  const sources = args.sources || ['bilibili', 'hackernews', 'github', 'douyin', 'rss']
+  const allObs = []
+  for (const src of sources) {
+    try {
+      const collectFn = service.collectBySource ? service.collectBySource : service.collect
+      if (collectFn) {
+        const result = collectFn.call(service, [src], args.keywords || [], args.limit || 20)
+        if (Array.isArray(result)) allObs.push(...result)
+        else if (result && typeof result === 'object') {
+          for (const [key, items] of Object.entries(result)) allObs.push(...items)
+        }
+      }
+    } catch (e) {
+      allObs.push({ source: src, error: e.message })
+    }
+  }
+  return { collected: allObs.length, observations: allObs }
+}
+
+function observerFerment(args = {}) {
+  if (!ObserverService) throw new Error('@akemi-mio/observer not installed')
+  const baseDir = getObserverBaseDir(args)
+  const service = new ObserverService({ baseDir, collectorConfig: {} })
+  const session = args.session || 'afternoon'
+  try {
+    const fermentation = service.getFermentation()
+    if (fermentation && fermentation.ferment) return fermentation.ferment(session)
+    return { status: 'fermentation engine available but no ferment method' }
+  } catch (e) {
+    return { error: e.message }
+  }
+}
+
+function observerEssays(args = {}) {
+  const baseDir = getObserverBaseDir(args)
+  const type = args.type || 'published'
+  const essaysDir = path.join(baseDir, 'essays', type)
+  if (!fs.existsSync(essaysDir)) return []
+  const files = fs.readdirSync(essaysDir).filter(f => f.endsWith('.md')).sort().reverse()
+  return files.slice(0, args.limit || 10).map(f => {
+    const content = fs.readFileSync(path.join(essaysDir, f), 'utf8')
+    return { file: f, type, content, created: fs.statSync(path.join(essaysDir, f)).birthtime.toISOString() }
+  })
+}
+
+function observerDag(args = {}) {
+  const baseDir = getObserverBaseDir(args)
+  const days = args.days || 7
+  const summaries = []
+  const todayDate = new Date()
+  for (let i = 0; i < days; i++) {
+    const d = new Date(todayDate)
+    d.setDate(d.getDate() - i)
+    const dateStr = d.toISOString().slice(0, 10)
+    const filePath = path.join(baseDir, 'summaries', `${dateStr}.jsonl`)
+    const items = readJsonlSafe(filePath)
+    if (items.length) summaries.push({ date: dateStr, summaries: items })
+  }
+  return { summaries, summaryCount: summaries.reduce((a, s) => a + s.summaries.length, 0) }
+}
+
 async function callTool(name, args = {}) {
   switch (name) {
     case 'mio.memory.query':
@@ -1776,9 +2245,43 @@ async function callTool(name, args = {}) {
       return evolutionCutover.authorityPlan(args)
     case 'mio.evolution.cutover.apply':
       return evolutionCutover.applyCutover(args)
-    case 'mio.task.record_outcome':
-      return recordTaskOutcome(args)
-    default:
+    case 'mio.task.record_outcome':
+      return recordTaskOutcome(args)
+    case 'mio.creativity.status':
+      return creativityEngine.status()
+    case 'mio.creativity.list':
+      return creativityEngine.list(args)
+    case 'mio.creativity.generate':
+      return creativityEngine.generate(args.sources, args.strategy)
+    case 'mio.creativity.ferment':
+      return creativityEngine.ferment(args.limit)
+    case 'mio.insight.status':
+      return insightStatus()
+    case 'mio.insight.list':
+      return insightList(args)
+    case 'mio.insight.mark_reported':
+      return insightMarkReported(args)
+    case 'mio.insight.generate':
+      return insightGenerate(args)
+    case 'mio.observer.world_model':
+      return observerWorldModel(args)
+    case 'mio.observer.trends':
+      return observerTrends(args)
+    case 'mio.observer.research':
+      return observerResearch(args)
+    case 'mio.observer.insights':
+      return observerInsights(args)
+    case 'mio.observer.status':
+      return observerStatus(args)
+    case 'mio.observer.collect':
+      return observerCollect(args)
+    case 'mio.observer.ferment':
+      return observerFerment(args)
+    case 'mio.observer.essays':
+      return observerEssays(args)
+    case 'mio.observer.dag':
+      return observerDag(args)
+    default:
       throw new Error(`Unknown tool: ${name}`)
   }
 }