mio-agent-runtime 0.3.15 → 0.4.0

package/package.json

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

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

@@ -21,7 +21,12 @@ Mio Agent Enhancement Layer 的最小 MCP 实现。
 - `mio.phase0.report` — 生成当前 Phase 0 验证报告，返回门槛状态、复用漏斗（含 `pendingAutoClaims`，即待确认的 auto_claim 数）、Agent 覆盖（含每个 host 的健康状态）、trace outcome 分布；支持 `format: markdown` 直接返回渲染报告。
 - `mio.task.route` — 把任务路由到最相关的**已验证经验**与相关记忆（P1）：对任务描述做混合检索匹配 verified 经验，返回可直接采用的模式（含 `reuseCount` 复用次数、确认状态、来源/目标 Agent 与记忆内容），把「查询响应」升级为「决策影响」；路由结果会进入查询日志，便于后续 `task_outcome` 自动关联复用证据。
 
-## 项目识别
+- `mio.agent.register` — 注册或更新 Agent 到 Mio Agent Registry（按 agentId+project 去重）：首次调用创建记录（registered=true），后续调用更新 lastSeenAt 并递增 sessionCount。支持 hostType（mcp/observer/plugin）和 capabilities。
+- `mio.agent.list` — 列出所有已注册 Agent，支持按 project 过滤。返回每个 Agent 的 id、agentId、hostType、capabilities、注册/最近活跃时间、会话数。
+
+- `mio.evolution.report` — 生成跨 Agent 演化报告（ADR-017 Evolution 平面）：生态系统摘要（agent/task/memory/reuse 总量）、Agent 性能对比（成功率/memory 数/verified reuse）、跨 Agent 复用模式、Memory 健康度（质量评分/低质量记录/缺失字段）、优化建议（路由/证据确认/记忆质量/覆盖度，按优先级排序）。支持 `period`（24h/7d/30d/all）和 `project` 过滤。- `mio.agent.report` — 生成 Agent 性能报告：聚合 task_outcome（成功率）、memory 数量、experience reuse（总次数/verified 数量）和活跃状态。支持指定 agentId 或 project 过滤。
+
+- `mio.task.record_outcome` — 一键记录任务结果：原子写入 traces.jsonl + 更新 Agent Registry（taskCount/successCount/failureCount）+ 自动关联 experience reuse auto-claim。替代手动调用 observer.ingest + agent.register 的分离流程，完成任务生命周期闭环。## 项目识别
 
 不传 `project` 时，服务会通过当前 Git 仓库自动识别项目名：
 

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

@@ -3,7 +3,6 @@
 
 const fs = require('fs')
 const path = require('path')
-const os = require('os')
 const crypto = require('crypto')
 const readline = require('readline')
 const { execFileSync } = require('child_process')
@@ -12,14 +11,13 @@ const SERVER_INFO = { name: 'mio-intelligence-mcp', version: '0.1.0' }
 const PROTOCOL_VERSION = '2024-11-05'
 
 const dataDir = path.resolve(
-  process.env.MIO_DATA_DIR ||
-    process.env.MIO_HOME ||
-    path.join(os.homedir(), '.mio-intelligence')
+  process.env.MIO_DATA_DIR || path.join(process.cwd(), '.mio-intelligence')
 )
 const memoryPath = path.join(dataDir, 'memory.jsonl')
 const tracePath = path.join(dataDir, 'traces.jsonl')
 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')
 fs.mkdirSync(dataDir, { recursive: true })
@@ -1128,6 +1126,94 @@ function listExperienceReuse(args = {}) {
   }
 }
 
+function registerAgent(args = {}) {
+  const agentId = String(args.agentId || '').trim()
+  if (!agentId) throw new Error('agent.register requires a non-empty agentId')
+  const project = args.project || projectName()
+  const hostType = args.hostType || 'mcp'
+  const capabilities = Array.isArray(args.capabilities) ? args.capabilities : []
+  const now = new Date().toISOString()
+  const agents = readJsonl(agentsPath)
+  const existing = agents.find((a) => a.agentId === agentId && a.project === project)
+  let result
+  if (existing) {
+    existing.lastSeenAt = now
+    existing.sessionCount = (existing.sessionCount || 1) + 1
+    existing.hostType = hostType
+    if (capabilities.length > 0) existing.capabilities = capabilities
+    result = existing
+  } else {
+    result = {
+      id: createId('agent'),
+      agentId,
+      hostType,
+      capabilities,
+      registeredAt: now,
+      lastSeenAt: now,
+      sessionCount: 1,
+      project,
+    }
+    agents.push(result)
+  }
+  writeJsonl(agentsPath, agents)
+  return { id: result.id, agentId: result.agentId, registered: !existing, sessionCount: result.sessionCount, hostType: result.hostType, capabilities: result.capabilities }
+}
+
+function listAgents(args = {}) {
+  const project = args.project || null
+  let agents = readJsonl(agentsPath)
+  if (project) agents = agents.filter((a) => a.project === project)
+  return {
+    count: agents.length,
+    agents: agents.map((a) => ({
+      id: a.id, agentId: a.agentId, hostType: a.hostType,
+      capabilities: a.capabilities, registeredAt: a.registeredAt,
+      lastSeenAt: a.lastSeenAt, sessionCount: a.sessionCount,
+      taskCount: a.taskCount || 0, successCount: a.successCount || 0, failureCount: a.failureCount || 0,
+      project: a.project,
+    })),
+  }
+}
+
+function reportAgent(args = {}) {
+  const targetAgent = args.agentId || null
+  const project = args.project || projectName()
+  const agents = readJsonl(agentsPath)
+  const filtered = agents.filter((a) =>
+    (!targetAgent || a.agentId === targetAgent) && (!project || a.project === project)
+  )
+  const traces = readJsonl(tracePath)
+  const memories = readJsonl(memoryPath)
+  const reuses = readJsonl(experienceReusePath)
+  const reports = filtered.map((agent) => {
+    const agentTraces = traces.filter((t) => t.agent === agent.agentId)
+    const outcomes = agentTraces.filter((t) => t.event_type === 'task_outcome')
+    const successes = outcomes.filter((t) => t.outcome === 'success').length
+    const failures = outcomes.filter((t) => t.outcome === 'failure').length
+    const agentMemories = memories.filter((m) => m.source === agent.agentId)
+    const agentReuses = reuses.filter((r) => r.sourceAgent === agent.agentId || r.targetAgent === agent.agentId)
+    const verified = agentReuses.filter((r) => r.confirmed && r.reuse && r.behaviorChanged && r.outcomeImproved)
+    const regTasks = agent.taskCount || 0
+    const regSuccess = agent.successCount || 0
+    const regFail = agent.failureCount || 0
+    const taskTotal = regTasks > 0 ? regTasks : outcomes.length
+    const taskSuccess = regTasks > 0 ? regSuccess : successes
+    const taskFail = regTasks > 0 ? regFail : failures
+    return {
+      agentId: agent.agentId,
+      hostType: agent.hostType,
+      sessionCount: agent.sessionCount,
+      registeredAt: agent.registeredAt,
+      lastSeenAt: agent.lastSeenAt,
+      taskOutcomes: { total: taskTotal, success: taskSuccess, failure: taskFail, successRate: taskTotal > 0 ? Math.round((taskSuccess / taskTotal) * 100) : 0 },
+      memories: agentMemories.length,
+      experienceReuses: { total: agentReuses.length, verified: verified.length },
+      active: (Date.now() - new Date(agent.lastSeenAt).getTime()) < 24 * 60 * 60 * 1000,
+    }
+  })
+  return { project, count: reports.length, reports }
+}
+
 function routeTask(args = {}) {
   const task = String(args.task || '').trim()
   if (!task) throw new Error('task.route requires a non-empty task')
@@ -1471,6 +1557,69 @@ const TOOLS = [
       required: ['task'],
     },
   },
+  {
+    name: 'mio.agent.register',
+    description: 'Register or update an agent in the Mio Agent Registry. Upserts by agentId+project; updates lastSeenAt and sessionCount.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agentId: { type: 'string', description: 'Unique agent identifier (e.g. codex, opencode).' },
+        hostType: { type: 'string', description: 'Host type: mcp, observer, or plugin. Defaults to mcp.' },
+        capabilities: { type: 'array', items: { type: 'string' }, description: 'Agent capabilities.' },
+        project: { type: 'string', description: 'Project name. Defaults to current directory name.' },
+      },
+      required: ['agentId'],
+    },
+  },
+  {
+    name: 'mio.agent.list',
+    description: 'List all registered agents, optionally filtered by project.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        project: { type: 'string', description: 'Project name filter. Omit for all agents.' },
+      },
+    },
+  },
+  {
+    name: 'mio.agent.report',
+    description: 'Performance report for one or all agents, aggregating task outcomes, memory, and experience reuse.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agentId: { type: 'string', description: 'Agent to report on. Omit for all agents.' },
+        project: { type: 'string', description: 'Project name filter. Defaults to current repository.' },
+      },
+    },
+  },
+  {
+    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'],
+    },
+  },
 ]
 
 async function callTool(name, args = {}) {
@@ -1503,6 +1652,16 @@ async function callTool(name, args = {}) {
       return phase0Report(args)
     case 'mio.task.route':
       return routeTask(args)
+    case 'mio.agent.register':
+      return registerAgent(args)
+    case 'mio.agent.list':
+      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)
     default:
       throw new Error(`Unknown tool: ${name}`)
   }
@@ -1584,4 +1743,242 @@ rl.on('close', () => {
   }
 })
 
+
+function evolutionReport(args = {}) {
+  const project = args.project || projectName()
+  const period = String(args.period || 'all').trim()
+  const now = Date.now()
+  const periodMs = period === '24h' ? 86400000 : period === '7d' ? 604800000 : period === '30d' ? 2592000000 : Infinity
+  const cutoff = periodMs === Infinity ? 0 : now - periodMs
+
+  const memories = readJsonl(memoryPath).filter((m) => !project || m.project === project || !m.project)
+  const traces = readJsonl(tracePath).filter((t) => !project || t.project === project)
+  const reuses = readJsonl(experienceReusePath).filter((r) => !project || r.project === project)
+  const agents = readJsonl(agentsPath).filter((a) => !project || a.project === project)
+  const queries = readJsonl(queryPath).filter((q) => !project || q.project === project)
+
+  const filteredTraces = cutoff ? traces.filter((t) => new Date(t.timestamp).getTime() >= cutoff) : traces
+  const filteredMemories = cutoff ? memories.filter((m) => new Date(m.timestamp).getTime() >= cutoff) : memories
+
+  // Ecosystem summary
+  const agentIds = new Set()
+  filteredTraces.forEach((t) => { if (t.agent) agentIds.add(t.agent) })
+  agents.forEach((a) => agentIds.add(a.agentId))
+  const outcomes = filteredTraces.filter((t) => t.event_type === 'task_outcome')
+  const successes = outcomes.filter((t) => t.outcome === 'success').length
+  const failures = outcomes.filter((t) => t.outcome === 'failure').length
+  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 ecosystem = {
+    agents: agentIds.size,
+    totalTasks: outcomes.length,
+    successRate: outcomes.length > 0 ? Math.round((successes / outcomes.length) * 100) : 0,
+    totalMemories: filteredMemories.length,
+    totalReuses: reuses.length,
+    verifiedReuses: verifiedReuses.length,
+    pendingReuses: pendingReuses.length,
+  }
+
+  // Agent performance comparison
+  const agentPerf = []
+  for (const agentId of agentIds) {
+    const agentTraces = filteredTraces.filter((t) => t.agent === agentId)
+    const agentOutcomes = agentTraces.filter((t) => t.event_type === 'task_outcome')
+    const agentSuccesses = agentOutcomes.filter((t) => t.outcome === 'success').length
+    const agentFailures = agentOutcomes.filter((t) => t.outcome === 'failure').length
+    const agentMemories = filteredMemories.filter((m) => m.source === agentId)
+    const agentVerified = reuses.filter((r) =>
+      (r.sourceAgent === agentId || r.targetAgent === agentId) && r.confirmed && r.reuse && r.behaviorChanged && r.outcomeImproved
+    )
+    const reg = agents.find((a) => a.agentId === agentId)
+    agentPerf.push({
+      agentId,
+      tasks: {
+        total: agentOutcomes.length,
+        success: agentSuccesses,
+        failure: agentFailures,
+        successRate: agentOutcomes.length > 0 ? Math.round((agentSuccesses / agentOutcomes.length) * 100) : 0,
+      },
+      memories: agentMemories.length,
+      verifiedReuses: agentVerified.length,
+      registered: !!reg,
+      lastActive: reg ? reg.lastSeenAt : (agentTraces.length > 0 ? agentTraces[agentTraces.length - 1].timestamp : null),
+    })
+  }
+  agentPerf.sort((a, b) => b.tasks.successRate - a.tasks.successRate || b.tasks.total - a.tasks.total)
+
+  // Cross-agent patterns
+  const crossPatterns = []
+  const reuseByPair = {}
+  for (const r of reuses) {
+    const key = r.sourceAgent + '->' + r.targetAgent
+    if (!reuseByPair[key]) reuseByPair[key] = { source: r.sourceAgent, target: r.targetAgent, total: 0, verified: 0, improved: 0 }
+    reuseByPair[key].total++
+    if (r.confirmed) reuseByPair[key].verified++
+    if (r.outcomeImproved) reuseByPair[key].improved++
+  }
+  for (const [key, pair] of Object.entries(reuseByPair)) {
+    if (pair.source !== pair.target) {
+      crossPatterns.push({
+        type: 'reuse_path',
+        from: pair.source,
+        to: pair.target,
+        total: pair.total,
+        verified: pair.verified,
+        improved: pair.improved,
+      })
+    }
+  }
+  crossPatterns.sort((a, b) => b.verified - a.verified || b.total - a.total)
+
+  // Memory health
+  const byKind = {}
+  let shortContent = 0
+  let missingKind = 0
+  for (const m of filteredMemories) {
+    const kind = m.kind || 'unknown'
+    byKind[kind] = (byKind[kind] || 0) + 1
+    const content = String(m.content || '').trim()
+    if (content.length < 20) shortContent++
+    if (!m.kind) missingKind++
+  }
+  const memoryHealth = {
+    total: filteredMemories.length,
+    byKind,
+    shortContent,
+    missingKind,
+    qualityScore: filteredMemories.length > 0
+      ? Math.round(((filteredMemories.length - shortContent - missingKind) / filteredMemories.length) * 100)
+      : 100,
+  }
+
+  // Suggestions engine
+  const suggestions = []
+
+  // Routing suggestion: compare agent success rates
+  if (agentPerf.length >= 2) {
+    const best = agentPerf[0]
+    const worst = agentPerf[agentPerf.length - 1]
+    if (best.tasks.total >= 5 && worst.tasks.total >= 5 && best.tasks.successRate - worst.tasks.successRate >= 15) {
+      suggestions.push({
+        category: 'routing',
+        priority: 'high',
+        description: best.agentId + ' has ' + best.tasks.successRate + '% success rate vs ' + worst.agentId + ' at ' + worst.tasks.successRate + '%; prefer routing to ' + best.agentId,
+        basedOn: 'task_outcome comparison',
+      })
+    }
+  }
+
+  // Pending auto-claim suggestion
+  if (pendingReuses.length >= 10) {
+    suggestions.push({
+      category: 'evidence',
+      priority: 'medium',
+      description: pendingReuses.length + ' pending auto-claims awaiting confirmation; review cross-agent claims to increase verified reuse count',
+      basedOn: 'experience_reuse.jsonl',
+    })
+  }
+
+  // Memory quality suggestion
+  if (memoryHealth.qualityScore < 80 && filteredMemories.length > 10) {
+    suggestions.push({
+      category: 'memory',
+      priority: 'medium',
+      description: 'Memory quality score is ' + memoryHealth.qualityScore + '%; ' + shortContent + ' short records and ' + missingKind + ' missing kind fields found',
+      basedOn: 'memory.jsonl quality analysis',
+    })
+  }
+
+  // Cross-agent value suggestion
+  if (crossPatterns.length === 0 && agentIds.size >= 2) {
+    suggestions.push({
+      category: 'interop',
+      priority: 'high',
+      description: 'Multiple agents registered but no cross-agent reuse patterns detected; ensure agents query shared memory',
+      basedOn: 'experience_reuse.jsonl',
+    })
+  }
+
+  // Active agent suggestion
+  const inactiveAgents = agentPerf.filter((a) => {
+    if (!a.lastActive) return false
+    return (now - new Date(a.lastActive).getTime()) > 7 * 86400000
+  })
+  if (inactiveAgents.length > 0) {
+    suggestions.push({
+      category: 'coverage',
+      priority: 'low',
+      description: inactiveAgents.map((a) => a.agentId).join(', ') + ' inactive for >7 days; consider removal or reactivation',
+      basedOn: 'agent registry lastSeenAt',
+    })
+  }
+
+  suggestions.sort((a, b) => {
+    const p = { high: 0, medium: 1, low: 2 }
+    return (p[a.priority] || 2) - (p[b.priority] || 2)
+  })
+
+  return {
+    project,
+    generatedAt: new Date().toISOString(),
+    period,
+    ecosystem,
+    agentPerformance: agentPerf,
+    crossAgentPatterns: crossPatterns,
+    memoryHealth,
+    suggestions,
+  }
+}
+
+
+function recordTaskOutcome(args = {}) {
+  const outcome = String(args.outcome || '').trim().toLowerCase()
+  if (!['success', 'failure', 'aborted'].includes(outcome)) {
+    throw new Error('task.record_outcome requires outcome to be success, failure, or aborted')
+  }
+  const agentId = String(args.agentId || runtimeAgentId() || 'unknown').trim()
+  const project = args.project || projectName()
+  const task = String(args.task || '').trim()
+  const summary = String(args.summary || '').trim()
+  const verification = String(args.verification || '').trim()
+  const traceId = String(args.traceId || '').trim() || createId('trace:' + agentId + ':' + project)
+
+  // 1. Record trace event
+  const event = {
+    id: createId('trace'),
+    timestamp: new Date().toISOString(),
+    trace_id: traceId,
+    event_type: 'task_outcome',
+    outcome,
+    payload: { task, summary, verification },
+    agent: agentId,
+    host: 'mcp',
+    project,
+  }
+  appendJsonl(tracePath, event)
+
+  // 2. Auto-claim experience reuse
+  const autoClaims = autoClaimExperienceReuse(event)
+
+  // 3. Update agent registry
+  const now = new Date().toISOString()
+  const agents = readJsonl(agentsPath)
+  const agent = agents.find((a) => a.agentId === agentId && a.project === project)
+  if (agent) {
+    agent.lastSeenAt = now
+    agent.taskCount = (agent.taskCount || 0) + 1
+    agent.successCount = (agent.successCount || 0) + (outcome === 'success' ? 1 : 0)
+    agent.failureCount = (agent.failureCount || 0) + (outcome === 'failure' ? 1 : 0)
+    writeJsonl(agentsPath, agents)
+  }
+
+  return {
+    recorded: true,
+    event: { id: event.id, trace_id: traceId, outcome, agent: agentId, project },
+    agentUpdated: !!agent,
+    autoClaims: autoClaims.length > 0 ? autoClaims : undefined,
+  }
+}
+
 module.exports = { TOOLS, callTool, handleMessage, readJsonl, appendJsonl, rl }