mio-agent-runtime 0.5.15 → 0.5.16

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

@@ -5,7 +5,10 @@ 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 SERVER_INFO = { name: 'mio-intelligence-mcp', version: '0.1.0' }
 const PROTOCOL_VERSION = '2024-11-05'
@@ -20,11 +23,10 @@ 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 })
-
-const { loadPhase0, summarizePhase0, renderPhase0Markdown } = require('./phase0')
+fs.mkdirSync(dataDir, { recursive: true })
+
+const { loadPhase0, summarizePhase0, renderPhase0Markdown } = require('./phase0')
+const evolutionCutover = createEvolutionCutoverTools({ dataDir, appendJsonl, readJsonl, projectName })
 
 let runtimeContext = {}
 try {
@@ -1594,209 +1596,132 @@ 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'],
+    },
+  },
+]
+
 async function callTool(name, args = {}) {
   switch (name) {
     case 'mio.memory.query':
@@ -1833,77 +1758,31 @@ async function callTool(name, args = {}) {
       return listAgents(args)
     case 'mio.agent.report':
       return reportAgent(args)
-    case 'mio.evolution.report':
-      return evolutionReport(args)
+    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.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:
       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 +2097,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 }

package/server/mio-intelligence-mcp/package.json

@@ -1,18 +1,18 @@
-{
-  "name": "@mio/mio-intelligence-mcp",
-  "version": "0.1.0",
-  "private": true,
-  "description": "Mio Agent Enhancement Layer - MCP-first intelligence core",
-  "type": "commonjs",
-  "main": "index.js",
-  "bin": {
-    "mio-intelligence-mcp": "index.js"
-  },
-  "scripts": {
-    "start": "node index.js",
-    "check": "node --check index.js"
-  },
-  "engines": {
-    "node": ">=18"
-  }
+{
+  "name": "@akemi-mio/mio-intelligence-mcp",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Mio Agent Enhancement Layer - MCP-first intelligence core",
+  "type": "commonjs",
+  "main": "index.js",
+  "bin": {
+    "mio-intelligence-mcp": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "check": "node --check index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  }
 }