mio-agent-runtime 0.5.15 → 0.5.17

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

@@ -5,11 +5,79 @@ const fs = require('fs')
 const path = require('path')
 const crypto = require('crypto')
 const readline = require('readline')
-const { execFileSync } = require('child_process')
+const { execFileSync } = require('child_process')
+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')
 )
@@ -20,11 +88,12 @@ const queryPath = path.join(dataDir, 'queries.jsonl')
 const agentsPath = path.join(dataDir, 'agents.jsonl')
 const subscriptionPath = path.join(dataDir, 'subscriptions.jsonl')
 const digestStatePath = path.join(dataDir, 'digest_state.json')
-const ideasPath = path.join(dataDir, 'ideas.jsonl')
-const suggestionsPath = path.join(dataDir, 'suggestions.jsonl')
-fs.mkdirSync(dataDir, { recursive: true })
-
+fs.mkdirSync(dataDir, { recursive: true })
+
 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 {
@@ -1594,209 +1663,534 @@ const TOOLS = [
       },
     },
   },
-  {
-    name: 'mio.evolution.report',
-    description: 'Generate cross-agent evolution report: ecosystem summary, agent performance comparison, cross-agent patterns, memory health, and optimization suggestions (ADR-017 Evolution plane).',
+  {
+    name: 'mio.evolution.report',
+    description: 'Generate cross-agent evolution report: ecosystem summary, agent performance comparison, cross-agent patterns, memory health, and optimization suggestions (ADR-017 Evolution plane).',
     inputSchema: {
       type: 'object',
       properties: {
         project: { type: 'string', description: 'Project name filter. Defaults to current repository.' },
         period: { type: 'string', description: 'Time window: 24h, 7d, 30d, or all (default).' },
       },
-    },
-  },
-  {
-    name: 'mio.task.record_outcome',
-    description: 'Record task outcome with agent registry update and auto-claim experience reuse in one atomic call. Combines observer.ingest + agent stats + auto-claim for a complete task lifecycle closure.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        outcome: { type: 'string', description: 'Task outcome: success, failure, or aborted.' },
-        task: { type: 'string', description: 'Brief task description.' },
-        summary: { type: 'string', description: 'Optional task summary.' },
-        verification: { type: 'string', description: 'Optional verification details.' },
-        agentId: { type: 'string', description: 'Agent identifier. Defaults to MIO_CONTEXT agentId.' },
-        project: { type: 'string', description: 'Project name. Defaults to current repository.' },
-        traceId: { type: 'string', description: 'Optional custom trace ID. Auto-generated if omitted.' },
-      },
-      required: ['outcome'],
-    },
+    },
   },
   {
-    name: 'mio.idea.generate',
-    description: 'Generate creative ideas or multiple candidate solutions based on a given goal, context, and constraints.',
+    name: 'mio.evolution.status',
+    description: 'Report composed mio-agent-runtime module health from the canonical runtime module registry.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'mio.host.capabilities',
+    description: 'List installed desktop host adapters and the safe capability surface they expose to runtime modules.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'mio.evolution.shadow.record',
+    description: 'Record a shadow comparison between legacy and modular runtime outputs without changing authority.',
     inputSchema: {
       type: 'object',
-      required: ['goal'],
       properties: {
-        goal: { type: 'string', description: 'The goal or problem description for which to generate ideas.' },
-        context: { type: 'string', description: '(Optional) Additional background information, such as prior decisions or known problems.' },
-        constraints: { type: 'array', items: { type: 'string' }, description: '(Optional) List of constraints, e.g. "no new dependencies", "must be implementable as a plugin".' },
-        numIdeas: { type: 'integer', description: '(Optional) Number of ideas to return, default 3.', default: 3, minimum: 1 }
+        label: { type: 'string', description: 'Human-readable comparison label.' },
+        project: { type: 'string', description: 'Project name. Defaults to current repository.' },
+        legacy: { type: 'object', description: 'Legacy path output snapshot.' },
+        modular: { type: 'object', description: 'Modular path output snapshot.' },
+        input: { type: 'object', description: 'Optional sanitized input snapshot.' },
       },
-      additionalProperties: false
+      required: ['legacy', 'modular'],
     },
   },
   {
-    name: 'mio.idea.list',
-    description: 'List previously generated ideas, optionally filtered by keyword, strategy, or time window.',
+    name: 'mio.evolution.dual_write.record',
+    description: 'Record a dual-write sample result for legacy and modular state paths without switching authority.',
     inputSchema: {
       type: 'object',
       properties: {
-        goal: { type: 'string', description: '(Optional) Filter ideas whose goal contains this keyword.' },
-        strategy: { type: 'string', description: '(Optional) Filter by generation strategy (e.g. SCAMPER, Analogy).' },
-        limit: { type: 'integer', description: '(Optional) Max results, default 10.', default: 10, minimum: 1 },
-        period: { type: 'string', description: '(Optional) Time window: 24h, 7d, 30d, or all (default).' }
-      }
+        label: { type: 'string', description: 'Human-readable dual-write label.' },
+        project: { type: 'string', description: 'Project name. Defaults to current repository.' },
+        authoritative: { type: 'string', description: 'Authoritative path: legacy or modular. Defaults to legacy.' },
+        legacyResult: { type: 'object', description: 'Legacy write result snapshot.' },
+        modularResult: { type: 'object', description: 'Modular write result snapshot.' },
+        record: { type: 'object', description: 'Optional sanitized record metadata.' },
+      },
+      required: ['legacyResult', 'modularResult'],
     },
   },
   {
-    name: 'mio.evolution.suggest',
-    description: 'Analyze ecosystem data and produce prioritized improvement suggestions with next actions and expected impact.',
+    name: 'mio.evolution.cutover.readiness',
+    description: 'Assess whether shadow and dual-write samples are sufficient to consider modular runtime cutover.',
     inputSchema: {
       type: 'object',
       properties: {
-        project: { type: 'string', description: 'Project name filter. Defaults to current repository.' }
-      }
+        project: { type: 'string', description: 'Project name. Defaults to current repository.' },
+        minShadowRuns: { type: 'number', description: 'Minimum shadow comparison samples required. Defaults to 5.' },
+        maxMismatchRate: { type: 'number', description: 'Allowed shadow mismatch rate. Defaults to 0.' },
+      },
     },
   },
-,
   {
-    name: 'mio.dashboard.start',
-    description: 'Start the Mio live dashboard HTTP server and return its URL. Aggregates MIO_HOME data into a browser-viewable dashboard.',
+    name: 'mio.evolution.migration.plan',
+    description: 'Preview a state migration plan between legacy and modular records without writing state.',
     inputSchema: {
       type: 'object',
       properties: {
-        port: { type: 'integer', description: '(Optional) Port to bind, default 8787.', default: 8787, minimum: 1 },
-        open: { type: 'boolean', description: '(Optional) Open the dashboard in the default browser after starting.' }
-      }
+        legacyRecords: { type: 'array', items: { type: 'object' }, description: 'Legacy state records.' },
+        modularRecords: { type: 'array', items: { type: 'object' }, description: 'Existing modular state records.' },
+      },
     },
   },
   {
-    name: 'mio.dashboard.stop',
-    description: 'Stop the running Mio dashboard HTTP server.',
-    inputSchema: { type: 'object', properties: {} },
+    name: 'mio.evolution.authority.plan',
+    description: 'Create a gated authority switch plan from legacy to modular runtime without applying it.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        readiness: { type: 'object', description: 'Result from mio.evolution.cutover.readiness.' },
+        from: { type: 'string', description: 'Current authoritative path. Defaults to legacy.' },
+        to: { type: 'string', description: 'Target authoritative path. Defaults to modular.' },
+      },
+      required: ['readiness'],
+    },
   },
   {
-    name: 'mio.dashboard.status',
-    description: 'Check if the Mio dashboard HTTP server is running.',
-    inputSchema: { type: 'object', properties: {} },
-  }]
-
-function handleIdeaGenerate(args = {}) {
-  const goal = String(args.goal || '').trim()
-  if (!goal) throw new Error('idea.generate requires a goal')
-  const numIdeas = Math.min(Math.max(Number(args.numIdeas) || 3, 1), 10)
-  const context = args.context ? String(args.context).trim() : ''
-  const constraints = Array.isArray(args.constraints) ? args.constraints.map(String) : []
-
-  // Query Mio memory for related context
-  const relatedRecords = readJsonl(memoryPath)
-    .filter(r => r.archived !== true)
-    .filter(r => {
-      const text = (r.content || '').toLowerCase()
-      const goalLower = goal.toLowerCase()
-      // Support both space-separated (English) and continuous (Chinese) matching
-      const goalWords = goalLower.split(/\s+/).filter(w => w.length > 2)
-      // For Chinese: extract 2-char n-grams as search tokens
-      const ngrams = []
-      for (let i = 0; i < goalLower.length - 1; i++) {
-        const ng = goalLower.slice(i, i + 2)
-        if (ng.trim().length === 2) ngrams.push(ng)
-      }
-      const allTokens = [...new Set([...goalWords, ...ngrams])]
-      return allTokens.some(t => text.includes(t))
-    })
-    .slice(0, 8)
-
-  const relatedMemoryText = relatedRecords.length > 0
-    ? relatedRecords.map(r => '- [' + r.kind + '] ' + (r.content || '').slice(0, 200)).join('\n')
-    : '(no related memories found)'
-
-  const strategies = [
-    {
-      name: 'SCAMPER',
-      prompt: 'Apply SCAMPER: Substitute, Combine, Adapt, Modify, Put to another use, Eliminate, Reverse. ' +
-        'For goal: ' + goal + '. What novel combination or modification of existing elements could work?'
-    },
-    {
-      name: 'Analogy',
-      prompt: 'By analogy: What similar problem has been solved in a completely different domain? ' +
-        'For goal: ' + goal + '. What approach from another field (biology, economics, gaming, logistics) transfers here?'
-    },
-    {
-      name: 'First-Principles',
-      prompt: 'First principles: Strip away all assumptions. What are the absolute basics of ' + goal + '? ' +
-        'What would you build if you had no prior art, no constraints, no legacy?'
-    },
-    {
-      name: 'Random-Stimulus',
-      prompt: 'Random stimulus: Pick an unrelated concept (a relay race, a restaurant menu, a river delta, a beehive). ' +
-        'How does it relate to ' + goal + '? What structural or procedural parallel exists?'
-    },
-    {
-      name: 'Constraint-Inversion',
-      prompt: 'Constraint inversion: Instead of ' + goal + ', what is the OPPOSITE goal? ' +
-        'How would you deliberately make things worse? Now invert the inversion — what does that reveal about the real solution?'
-    }
-  ]
-
-  const selectedStrategies = strategies.slice(0, numIdeas)
-  const ideas = []
-
-  for (let i = 0; i < selectedStrategies.length; i++) {
-    const s = selectedStrategies[i]
-    const idea = {
-      id: createId('idea'),
-      title: 'Idea #' + (i + 1) + ' (' + s.name + '): ' + goal,
-      description: 'Goal: ' + goal + '\n\n' +
-        'Strategy: ' + s.name + '\n\n' +
-        'Related Mio memory:\n' + relatedMemoryText + '\n\n' +
-        (context ? 'Context: ' + context + '\n\n' : '') +
-        (constraints.length > 0 ? 'Constraints:\n' + constraints.map(c => '- ' + c).join('\n') + '\n\n' : '') +
-        'Strategy prompt: ' + s.prompt + '\n\n' +
-        'Suggestion: Consider prototyping the idea and measuring its impact against prior decisions.',
-      provenance: {
-        strategy: s.name,
-        relatedMemoryIds: relatedRecords.map(r => r.id).slice(0, 5),
+    name: 'mio.evolution.cutover.apply',
+    description: 'Dry-run an authority switch plan. This stage refuses real cutover and never mutates authority state.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        dryRun: { type: 'boolean', description: 'Must be true. Real cutover is intentionally gated.' },
+        project: { type: 'string', description: 'Project name. Defaults to current repository.' },
+        plan: { type: 'object', description: 'Authority switch plan from mio.evolution.authority.plan.' },
       },
-      generatedAt: new Date().toISOString(),
-      goal,
-      context: context || null,
-      constraints,
-    }
-    ideas.push(idea)
-  }
-
-  // Persist to ideas.jsonl
-  for (const idea of ideas) {
-    appendJsonl(ideasPath, idea)
-  }
-
-  return { ideas, count: ideas.length, goal, strategies: ideas.map(i => i.provenance.strategy) }
-}
-
-function listIdeas(args = {}) {
-  if (!fs.existsSync(ideasPath)) return { ideas: [], count: 0, total: 0 }
-  const now = Date.now()
-  const period = String(args.period || 'all').trim()
-  const periodMs = period === '24h' ? 86400000 : period === '7d' ? 604800000 : period === '30d' ? 2592000000 : Infinity
-  const cutoff = periodMs === Infinity ? 0 : now - periodMs
-  const goalFilter = args.goal ? String(args.goal).toLowerCase() : null
-  const strategyFilter = args.strategy ? String(args.strategy).trim().toLowerCase() : null
-  const limit = Math.min(Math.max(Number(args.limit) || 10, 1), 50)
-  const all = fs.readFileSync(ideasPath, 'utf8').split('\n').filter(Boolean).map(line => {
-    try { return JSON.parse(line) } catch (_) { return null }
-  }).filter(Boolean)
-  const filtered = all.filter(idea => {
-    if (cutoff && new Date(idea.generatedAt).getTime() < cutoff) return false
-    if (goalFilter && !String(idea.goal || '').toLowerCase().includes(goalFilter)) return false
-    if (strategyFilter && String(idea.provenance?.strategy || '').toLowerCase() !== strategyFilter) return false
-    return true
-  })
-  return { ideas: filtered.slice(-limit), count: filtered.length, total: all.length }
-}
-
+      required: ['dryRun', 'plan'],
+    },
+  },
+  {
+    name: 'mio.task.record_outcome',
+    description: 'Record task outcome with agent registry update and auto-claim experience reuse in one atomic call. Combines observer.ingest + agent stats + auto-claim for a complete task lifecycle closure.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        outcome: { type: 'string', description: 'Task outcome: success, failure, or aborted.' },
+        task: { type: 'string', description: 'Brief task description.' },
+        summary: { type: 'string', description: 'Optional task summary.' },
+        verification: { type: 'string', description: 'Optional verification details.' },
+        agentId: { type: 'string', description: 'Agent identifier. Defaults to MIO_CONTEXT agentId.' },
+        project: { type: 'string', description: 'Project name. Defaults to current repository.' },
+        traceId: { type: 'string', description: 'Optional custom trace ID. Auto-generated if omitted.' },
+      },
+      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':
@@ -1833,77 +2227,65 @@ async function callTool(name, args = {}) {
       return listAgents(args)
     case 'mio.agent.report':
       return reportAgent(args)
-    case 'mio.evolution.report':
-      return evolutionReport(args)
-    case 'mio.task.record_outcome':
-      return recordTaskOutcome(args)
-    case 'mio.idea.generate':
-      return handleIdeaGenerate(args)
-    case 'mio.idea.list':
-      return listIdeas(args)
-    case 'mio.evolution.suggest':
-      return evolutionSuggest(args)
-    case 'mio.dashboard.start':
-      return handleDashboardStart(args)
-    case 'mio.dashboard.stop':
-      return handleDashboardStop()
-    case 'mio.dashboard.status':
-      return handleDashboardStatus()
-    default:
+    case 'mio.evolution.report':
+      return evolutionReport(args)
+    case 'mio.evolution.status':
+      return getEvolutionStatus()
+    case 'mio.host.capabilities':
+      return listHostCapabilities()
+    case 'mio.evolution.shadow.record':
+      return evolutionCutover.recordShadowComparison(args)
+    case 'mio.evolution.dual_write.record':
+      return evolutionCutover.recordDualWrite(args)
+    case 'mio.evolution.cutover.readiness':
+      return evolutionCutover.cutoverReadiness(args)
+    case 'mio.evolution.migration.plan':
+      return evolutionCutover.migrationPlan(args)
+    case 'mio.evolution.authority.plan':
+      return evolutionCutover.authorityPlan(args)
+    case 'mio.evolution.cutover.apply':
+      return evolutionCutover.applyCutover(args)
+    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}`)
   }
 }
 
-const DASHBOARD_PORT = 8787
-const dashboardPidPath = () => path.join(dataDir, 'dashboard.pid')
-
-function isDashboardRunning() {
-  const pidFile = dashboardPidPath()
-  if (!fs.existsSync(pidFile)) return false
-  try {
-    const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10)
-    process.kill(pid, 0)
-    return true
-  } catch (_) {
-    return false
-  }
-}
-
-function handleDashboardStart(args = {}) {
-  const port = parseInt(args.port || process.env.MIO_DASHBOARD_PORT || DASHBOARD_PORT, 10)
-  const url = 'http://localhost:' + port
-  if (isDashboardRunning()) {
-    if (args.open) { try { require('child_process').exec('start ' + url) } catch (_) {} }
-    return { url: url, running: true, message: 'Dashboard already running at ' + url }
-  }
-  const serverScript = path.join(__dirname, 'dashboard-server.js')
-  const child = require('child_process').spawn(process.execPath, [serverScript, String(port)], {
-    env: Object.assign({}, process.env, { MIO_DATA_DIR: dataDir }),
-    detached: true,
-    stdio: 'ignore',
-  })
-  child.unref()
-  fs.writeFileSync(dashboardPidPath(), String(child.pid))
-  if (args.open) { try { require('child_process').exec('start ' + url) } catch (_) {} }
-  return { url: url, running: true, pid: child.pid, message: 'Dashboard started at ' + url }
-}
-
-function handleDashboardStop() {
-  const pidFile = dashboardPidPath()
-  if (!fs.existsSync(pidFile)) return { running: false, message: 'Dashboard not running.' }
-  try {
-    const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10)
-    process.kill(pid, 'SIGTERM')
-  } catch (_) {}
-  try { fs.unlinkSync(pidFile) } catch (_) {}
-  return { running: false, message: 'Dashboard stopped.' }
-}
-
-function handleDashboardStatus() {
-  const running = isDashboardRunning()
-  return { running: running, url: running ? 'http://localhost:' + DASHBOARD_PORT : null }
-}
-
 function jsonRpcResult(id, result) {
   return { jsonrpc: '2.0', id, result }
 }
@@ -2218,65 +2600,4 @@ function recordTaskOutcome(args = {}) {
   }
 }
 
-
-function evolutionSuggest(args = {}) {
-  const project = args.project || projectName()
-  const now = Date.now()
-  const memories = readJsonl(memoryPath)
-  const traces = readJsonl(tracePath)
-  const reuses = readJsonl(experienceReusePath)
-  const ideas = fs.existsSync(ideasPath)
-    ? fs.readFileSync(ideasPath, 'utf8').split('\n').filter(Boolean).map(l => { try { return JSON.parse(l) } catch (_) { return null } }).filter(Boolean)
-    : []
-  const agentIds = new Set()
-  traces.forEach((t) => { if (t.agent) agentIds.add(t.agent) })
-  const outcomes = traces.filter((t) => t.event_type === 'task_outcome')
-  const successes = outcomes.filter((t) => t.outcome === 'success').length
-  const successRate = outcomes.length > 0 ? Math.round((successes / outcomes.length) * 100) : 0
-  const verifiedReuses = reuses.filter((r) => r.confirmed && r.reuse && r.behaviorChanged && r.outcomeImproved)
-  const pendingReuses = reuses.filter((r) => r.source === 'auto_claim' && !r.confirmed)
-  const decisions = memories.filter((m) => m.kind === 'decision')
-  const problems = memories.filter((m) => m.kind === 'problem')
-  const shortMemories = memories.filter((m) => String(m.content || '').trim().length < 20)
-  const ideasWithoutMemory = ideas.filter((i) => !i.provenance?.relatedMemoryIds?.length)
-  const suggestions = []
-
-  if (agentIds.size >= 2) {
-    const agentStats = []
-    for (const id of agentIds) {
-      const ao = outcomes.filter((t) => t.agent === id)
-      const as = ao.filter((t) => t.outcome === 'success').length
-      agentStats.push({ id, total: ao.length, success: as, rate: ao.length > 0 ? Math.round(as / ao.length * 100) : 0 })
-    }
-    agentStats.sort((a, b) => b.rate - a.rate)
-    const best = agentStats[0], worst = agentStats[agentStats.length - 1]
-    if (best.total >= 5 && worst.total >= 5 && best.rate - worst.rate >= 15) {
-      suggestions.push({ category: 'routing', priority: 'high', title: 'Route tasks to ' + best.id, description: best.id + ' has ' + best.rate + '% success rate vs ' + worst.id + ' at ' + worst.rate + '%.', nextAction: 'Update task routing rules to prefer ' + best.id, impact: 'Could improve overall success rate by ~' + Math.round((best.rate - worst.rate) * 0.3) + '%', basedOn: 'task_outcome comparison' })
-    }
-  }
-  if (shortMemories.length > 5 && memories.length > 10) {
-    suggestions.push({ category: 'memory', priority: 'medium', title: 'Enrich ' + shortMemories.length + ' short memory records', description: Math.round(shortMemories.length / memories.length * 100) + '% of memories have content < 20 chars.', nextAction: 'Review and expand short memory records, or archive irrelevant ones.', impact: 'Improves memory.query recall precision', basedOn: 'memory.jsonl analysis' })
-  }
-  if (pendingReuses.length >= 5) {
-    suggestions.push({ category: 'evidence', priority: 'medium', title: 'Confirm ' + pendingReuses.length + ' pending auto-claims', description: pendingReuses.length + ' auto-claimed reuses await confirmation.', nextAction: 'Call mio.experience.confirm on each auto_claim id.', impact: 'Increases verified reuse count toward Phase 0 threshold', basedOn: 'experience_reuse.jsonl' })
-  }
-  const crossAgent = verifiedReuses.filter((r) => r.sourceAgent !== r.targetAgent)
-  if (agentIds.size >= 2 && crossAgent.length === 0) {
-    suggestions.push({ category: 'interop', priority: 'high', title: 'Enable cross-agent experience sharing', description: 'Multiple agents exist but no cross-agent reuse detected.', nextAction: 'Ensure all agents query shared memory before designing solutions.', impact: 'Unlocks core Agent Control Plane value', basedOn: 'experience_reuse.jsonl' })
-  }
-  if (ideas.length > 0 && ideasWithoutMemory.length > ideas.length * 0.5) {
-    suggestions.push({ category: 'creativity', priority: 'low', title: 'Improve idea grounding (' + ideasWithoutMemory.length + ' ungrounded)', description: Math.round(ideasWithoutMemory.length / ideas.length * 100) + '% of ideas lack related memory context.', nextAction: 'Record more decision/problem memories to enrich the idea pipeline.', impact: 'Higher-quality, more context-aware ideas', basedOn: 'ideas.jsonl provenance' })
-  }
-  if (problems.length >= 3) {
-    const recent = problems.filter((p) => (now - new Date(p.timestamp).getTime()) < 7 * 86400000)
-    if (recent.length >= 2) {
-      suggestions.push({ category: 'health', priority: 'high', title: recent.length + ' problems in last 7 days', description: 'Recurring problems may indicate systemic issues.', nextAction: 'Review recent problems, identify root causes, create decision records.', impact: 'Prevents problem accumulation', basedOn: 'memory.jsonl recent problems' })
-    }
-  }
-  suggestions.sort((a, b) => ({ high: 0, medium: 1, low: 2 }[a.priority] || 2) - ({ high: 0, medium: 1, low: 2 }[b.priority] || 2))
-  const record = { id: 'evo_' + Date.now(), timestamp: new Date().toISOString(), project, metrics: { agents: agentIds.size, tasks: outcomes.length, successRate, memories: memories.length, decisions: decisions.length, problems: problems.length, verifiedReuses: verifiedReuses.length, pendingReuses: pendingReuses.length, ideas: ideas.length }, suggestions }
-  try { fs.appendFileSync(suggestionsPath, JSON.stringify(record) + '\n') } catch (_) {}
-  return record
-}
-
 module.exports = { TOOLS, callTool, handleMessage, readJsonl, appendJsonl, rl }