mio-agent-runtime 0.5.2 → 0.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",

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

@@ -19,7 +19,9 @@ const experienceReusePath = path.join(dataDir, 'experience_reuse.jsonl')
 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 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')
@@ -1635,8 +1637,52 @@ const TOOLS = [
       additionalProperties: false
     },
   },
+  {
+    name: 'mio.idea.list',
+    description: 'List previously generated ideas, optionally filtered by keyword, strategy, or time window.',
+    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).' }
+      }
+    },
+  },
+  {
+    name: 'mio.evolution.suggest',
+    description: 'Analyze ecosystem data and produce prioritized improvement suggestions with next actions and expected impact.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        project: { type: 'string', description: 'Project name filter. Defaults to current repository.' }
+      }
+    },
+  },
 ]
 
+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 }
+}
+
 async function callTool(name, args = {}) {
   switch (name) {
     case 'mio.memory.query':
@@ -1679,6 +1725,10 @@ async function callTool(name, args = {}) {
       return recordTaskOutcome(args)
     case 'mio.idea.generate':
       return handleIdeaGenerate(args)
+    case 'mio.idea.list':
+      return listIdeas(args)
+    case 'mio.evolution.suggest':
+      return evolutionSuggest(args)
     default:
       throw new Error(`Unknown tool: ${name}`)
   }
@@ -1999,60 +2049,64 @@ function recordTaskOutcome(args = {}) {
 }
 
 
-async function handleIdeaGenerate(args = {}) {
-  const { goal, context = '', constraints = [], numIdeas = 3 } = args
-  // Memory-grounding: reuse related prior decisions/problems from Mio so ideas
-  // are informed by the Agent Control Plane's accumulated experience.
-  let related = []
-  try {
-    const mem = await queryMemory({ query: goal, limit: 3 })
-    if (mem && Array.isArray(mem.results)) related = mem.results
-  } catch (e) {
-    related = []
-  }
-  const relatedIds = related.map((r) => r.id).filter(Boolean)
-  const grounding = related
-    .filter((r) => r && (r.content || r.kind))
-    .map((r) => '- [' + (r.kind || 'note') + '] ' + String(r.content || '').slice(0, 240))
-    .join('\n')
-
-  // Generation strategies give diversity without exposing the mechanism to callers.
-  const strategies = [
-    'SCAMPER',
-    'Analogy',
-    'First-Principles',
-    'Random-Stimulus',
-    'Constraint-Inversion'
-  ]
+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 = []
 
-  const ideas = []
-  for (let i = 0; i < numIdeas; i++) {
-    const strategy = strategies[i % strategies.length]
-    const blocks = [
-      'Goal: ' + goal,
-      'Strategy: ' + strategy,
-      context ? 'Context: ' + context : '',
-      constraints.length ? 'Constraints: ' + constraints.join(', ') : '',
-      related.length
-        ? 'Related Mio memory:\n' + grounding
-        : 'No related Mio memory found yet; record outcomes to grow the experience base.',
-      'Suggestion: Consider prototyping the idea and measuring its impact against prior decisions.'
-    ].filter(Boolean)
-    ideas.push({
-      id: 'idea_' + Date.now() + '_' + i,
-      title: 'Idea #' + (i + 1) + ' (' + strategy + '): ' + goal,
-      description: blocks.join('\n\n'),
-      provenance: {
-        strategy: strategy,
-        relatedMemoryIds: relatedIds
-      }
-    })
+  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' })
   }
-  return {
-    ideas: ideas,
-    generatedAt: new Date().toISOString(),
-    groundedWith: related.length
+  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 }