mio-agent-runtime 0.5.22 → 0.6.0

package/observe/observer.js

@@ -65,6 +65,71 @@ function stateFile(home) {
   return path.join(home, 'observe-state.json')
 }
 
+// Canonical form for a workspace path used as a context key.
+//
+// Context keys are taken verbatim from the `cwd` field of host transcripts, and
+// hosts disagree on spelling: the same directory arrives as `D:\work\code\x`,
+// `d:\work\code\x`, or `D:/work/code/x`. Left alone, one project splits into
+// several buckets, each capped at CONTEXT_MAX, so its history is fragmented and
+// entries are dropped early. Windows paths are case-insensitive, so normalise
+// the drive letter to upper case and use backslashes consistently to match the
+// style the file-observation keys already use.
+function normalizeCwd(cwd) {
+  if (!cwd || typeof cwd !== 'string') return cwd
+  let out = cwd.replace(/\//g, '\\').replace(/\\+/g, '\\')
+  // Upper-case a single drive letter prefix ("c:\..." -> "C:\...").
+  if (/^[a-zA-Z]:\\/.test(out)) out = out[0].toUpperCase() + out.slice(1)
+  // Drop a trailing separator unless the path is just the drive root.
+  if (out.length > 3 && out.endsWith('\\')) out = out.slice(0, -1)
+  return out
+}
+
+// Parse the "YYYY/M/D HH:MM:SS | ..." stamp that context lines carry.
+// Returns null when the line has no recognisable leading timestamp, so
+// unparseable entries never get treated as the oldest by accident.
+function contextTimestamp(line) {
+  const m = /^\s*(\d{4})\/(\d{1,2})\/(\d{1,2})\s+(\d{1,2}):(\d{2}):(\d{2})/.exec(String(line || ''))
+  if (!m) return null
+  const ms = new Date(
+    Number(m[1]),
+    Number(m[2]) - 1,
+    Number(m[3]),
+    Number(m[4]),
+    Number(m[5]),
+    Number(m[6]),
+  ).getTime()
+  return Number.isFinite(ms) ? ms : null
+}
+
+// Drop repeated lines from stored context lists, preserving the most recent
+// occurrence order. Older builds could write the same line into every slot of
+// a workspace block (a generated digest headline broadcast to all projects),
+// so existing observe-state files still carry duplicates until they are
+// rewritten. Normalising on load heals that data without a migration step.
+//
+// Keys are also folded through normalizeCwd and merged, so buckets split by
+// spelling differences collapse back into one on the next load.
+function dedupeContexts(contexts) {
+  const out = {}
+  for (const [cwd, list] of Object.entries(contexts)) {
+    const key = normalizeCwd(cwd)
+    const existing = out[key] || []
+    if (!Array.isArray(list)) {
+      out[key] = existing
+      continue
+    }
+    const seen = new Set(existing)
+    const merged = existing.slice()
+    for (const line of list) {
+      if (seen.has(line)) continue
+      seen.add(line)
+      merged.push(line)
+    }
+    out[key] = merged
+  }
+  return out
+}
+
 function loadState(home) {
   try {
     const parsed = JSON.parse(fs.readFileSync(stateFile(home), 'utf8'))
@@ -74,7 +139,7 @@ function loadState(home) {
         files: parsed.files || {},
         buffers: parsed.buffers || {},
         openTurns: parsed.openTurns || {},
-        contexts: parsed.contexts || {},
+        contexts: dedupeContexts(parsed.contexts || {}),
         codexFiles: parsed.codexFiles || {},
         codexBuffers: parsed.codexBuffers || {},
         codexTurns: parsed.codexTurns || {},
@@ -290,11 +355,39 @@ const CONTEXT_MAX = 6
 // retrieval guaranteed (not dependent on the model deciding to read memory).
 function updateProjectContext(state, cwd, line, targetFile) {
   if (!cwd || !line) return
+  const key = normalizeCwd(cwd)
   const target = path.join(cwd, targetFile || 'AGENTS.md')
-  const list = state.contexts[cwd] || []
+  // Merge any buckets that differ only by spelling, so a project observed as
+  // both "D:\work\code\x" and "d:\work\code\x" converges into one list instead
+  // of two half-filled ones.
+  const list = []
+  const seen = new Set()
+  for (const [existingKey, items] of Object.entries(state.contexts || {})) {
+    if (normalizeCwd(existingKey) !== key) continue
+    for (const item of items || []) {
+      if (seen.has(item)) continue
+      seen.add(item)
+      list.push(item)
+    }
+    if (existingKey !== key) delete state.contexts[existingKey]
+  }
+  // Re-inserting an existing line moves it to the front instead of duplicating.
+  const existing = list.indexOf(line)
+  if (existing !== -1) list.splice(existing, 1)
   list.unshift(line)
-  if (list.length > CONTEXT_MAX) list.pop()
-  state.contexts[cwd] = list
+  // Once buckets merge, the list can exceed CONTEXT_MAX. Entries are stamped
+  // "YYYY/M/D HH:MM:SS | ...", so trim by that timestamp rather than by
+  // position -- merging appends whole buckets in object-key order, which says
+  // nothing about age, and popping blind could discard recent work.
+  if (list.length > CONTEXT_MAX) {
+    const stamped = list.filter((l) => contextTimestamp(l) !== null)
+    if (stamped.length > 1) {
+      list.sort((a, b) => contextTimestamp(b) - contextTimestamp(a))
+    }
+    list.length = CONTEXT_MAX
+  }
+  state.contexts = state.contexts || {}
+  state.contexts[key] = list
   try {
     let content = fs.existsSync(target) ? fs.readFileSync(target, 'utf8') : ''
     const block = CONTEXT_BEGIN + '\n## Mio 最近上下文（自动注入）\n' + list.map(function (l) { return '- ' + l }).join('\n') + '\n' + CONTEXT_END
@@ -1591,6 +1684,9 @@ module.exports = {
   workbuddyConfigDir,
   loadState,
   saveState,
+  dedupeContexts,
+  normalizeCwd,
+  contextTimestamp,
   updateProjectContext,
   runCycle,
   opencodeDbPath,

package/package.json

@@ -1,38 +1,45 @@
-{
-  "name": "mio-agent-runtime",
-  "version": "0.5.22",
-  "description": "Mio Agent Runtime installer and MCP intelligence layer",
-  "license": "MIT",
-  "type": "commonjs",
-  "bin": {
-    "mio": "bin/mio.js"
-  },
-  "files": [
-    "bin/",
-    "server/",
-    "adapters/",
-    "observe/",
-    "scripts/",
-    "README.md",
-    "!server/mio-intelligence-mcp/__tests__"
-  ],
-  "scripts": {
-    "check": "node --check bin/mio.js && node --check adapters/host-utils.js && node --check adapters/codex.js && node --check adapters/opencode.js && node --check adapters/workbuddy.js && node --check adapters/hermes.js && node --check adapters/claude-code.js && node --check server/runtime-modules.js && node --check server/memory-store.js && node --check server/retention.js && node --check server/digest.js && node --check server/host-capabilities.js && node --check server/evolution-cutover.js && node --check server/mio-intelligence-mcp/index.js && node --check server/mio-intelligence-mcp/phase0.js && node --check observe/observer.js && node --check scripts/verify-packed-runtime.js",
-    "prepack": "npm run check",
-    "verify:pack-install": "node scripts/verify-packed-runtime.js"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@akemi-mio/runtime-contracts": "^0.1.0",
-    "@akemi-mio/runtime-foundation": "^0.1.0",
-    "@akemi-mio/experience-memory": "^0.1.0",
-    "@akemi-mio/evolution-learning": "^0.1.0",
-    "@akemi-mio/evolution-strategy": "^0.1.0",
-    "@akemi-mio/evolution-safety": "^0.1.0",
-    "@akemi-mio/evolution-scheduler": "^0.1.0",
-    "@akemi-mio/observer": "^0.1.0",
-    "@akemi-mio/insight": "^0.1.0"
-  }
-}
+{
+  "name": "mio-agent-runtime",
+  "version": "0.6.0",
+  "description": "Mio Agent Runtime installer and MCP intelligence layer",
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": {
+    "mio": "bin/mio.js"
+  },
+  "files": [
+    "bin/",
+    "server/",
+    "adapters/",
+    "observe/",
+    "scripts/",
+    "README.md",
+    "!server/mio-intelligence-mcp/__tests__"
+  ],
+  "scripts": {
+    "check": "node scripts/check-syntax.cjs",
+    "test": "node --test \"__tests__/*.test.js\" \"server/mio-intelligence-mcp/__tests__/*.test.js\"",
+    "prepack": "npm run check",
+    "verify:pack-install": "node scripts/verify-packed-runtime.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@akemi-mio/runtime-contracts": "^0.1.0",
+    "@akemi-mio/runtime-foundation": "^0.1.0",
+    "@akemi-mio/experience-memory": "^0.1.0",
+    "@akemi-mio/evolution-learning": "^0.1.0",
+    "@akemi-mio/evolution-strategy": "^0.1.0",
+    "@akemi-mio/evolution-safety": "^0.1.0",
+    "@akemi-mio/evolution-scheduler": "^0.1.0",
+    "@akemi-mio/observer": "^0.1.0",
+    "@akemi-mio/insight": "^0.1.0"
+  },
+  "main": "index.js",
+  "directories": {
+    "doc": "docs"
+  },
+  "keywords": [],
+  "author": ""
+}

package/scripts/check-syntax.cjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+'use strict'
+
+// Syntax gate for mio-agent-runtime (`npm run check`, which prepack runs).
+//
+// This used to be a hand-written file list in package.json. That silently rotted:
+// nine server modules -- including every store added later (policy, agent, task,
+// query-log, llm-client, creativity-engine) -- were never syntax-checked, so a
+// typo in any of them would have survived `npm run check` and only exploded at
+// require time, i.e. inside the published package.
+//
+// So: discover files instead of listing them. New modules are covered
+// automatically, and the gate can no longer fall behind the codebase.
+
+const fs = require('fs')
+const path = require('path')
+const { spawnSync } = require('child_process')
+
+const ROOT = path.resolve(__dirname, '..')
+
+// Top-level dirs to walk. __tests__ is excluded: those are exercised by
+// `node --test`, and a broken test file should fail the test run, not the
+// package gate.
+const INCLUDE_DIRS = ['bin', 'adapters', 'observe', 'server', 'scripts']
+const EXCLUDE_DIRS = new Set(['node_modules', '__tests__', 'dist', 'out'])
+const EXTENSIONS = new Set(['.js', '.cjs'])
+
+function walk(dir, out = []) {
+  let entries
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true })
+  } catch (_) {
+    return out
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (EXCLUDE_DIRS.has(entry.name)) continue
+      walk(path.join(dir, entry.name), out)
+    } else if (entry.isFile() && EXTENSIONS.has(path.extname(entry.name))) {
+      out.push(path.join(dir, entry.name))
+    }
+  }
+  return out
+}
+
+const files = INCLUDE_DIRS.flatMap((dir) => walk(path.join(ROOT, dir))).sort()
+
+if (files.length === 0) {
+  console.error('check-syntax: no files discovered -- the gate is broken')
+  process.exit(1)
+}
+
+const failures = []
+for (const file of files) {
+  const result = spawnSync(process.execPath, ['--check', file], { encoding: 'utf8' })
+  if (result.status !== 0) {
+    failures.push({ file, message: (result.stderr || '').trim().split('\n')[0] })
+  }
+}
+
+const rel = (f) => path.relative(ROOT, f).replace(/\\/g, '/')
+console.log(`checked ${files.length} file(s)`)
+
+if (failures.length > 0) {
+  for (const failure of failures) {
+    console.error(`FAIL ${rel(failure.file)}: ${failure.message}`)
+  }
+  console.error(`\n${failures.length} file(s) failed syntax check`)
+  process.exit(1)
+}
+
+console.log('all files parse')

package/scripts/verify-packed-runtime.js

@@ -76,12 +76,13 @@ function npmCommand(platform = process.platform) {
 
 function npmInvocation(args, env = process.env, platform = process.platform, node = process.execPath) {
   if (env.npm_execpath) {
-    return { command: node, args: [env.npm_execpath, ...args] }
+    return { command: node, args: [env.npm_execpath, ...args], shell: false }
   }
-  if (platform === 'win32') {
-    return { command: 'cmd.exe', args: ['/d', '/s', '/c', 'npm', ...args] }
-  }
-  return { command: npmCommand(platform), args }
+  // Fall back to the npm shim on PATH instead of routing through cmd.exe.
+  // cmd.exe is unavailable in some sandboxes, and a bare .cmd/.bat shim cannot
+  // be spawned directly (Node requires shell:true for those on Windows), so
+  // signal the shell requirement to the runner instead of guessing there.
+  return { command: npmCommand(platform), args: [...args], shell: platform === 'win32' }
 }
 
 function packageDirName(name) {
@@ -95,9 +96,12 @@ function tarballFileName(name, version) {
 
 function readPackageJson(workspaceRoot, name) {
   const packageDir = path.join(workspaceRoot, 'packages', packageDirName(name))
+  // Windows editors may write package.json with a UTF-8 BOM; JSON.parse
+  // rejects the leading U+FEFF, so strip it before parsing.
+  const raw = fs.readFileSync(path.join(packageDir, 'package.json'), 'utf8').replace(/^\uFEFF/, '')
   return {
     packageDir,
-    manifest: JSON.parse(fs.readFileSync(path.join(packageDir, 'package.json'), 'utf8')),
+    manifest: JSON.parse(raw),
   }
 }
 
@@ -211,6 +215,11 @@ function run(command, args, options = {}) {
     env: options.env || process.env,
     encoding: 'utf8',
     stdio: options.stdio || ['ignore', 'pipe', 'pipe'],
+    // Windows .cmd/.bat shims (npm.cmd) cannot be spawned directly by
+    // execFileSync since Node's CVE-2024-27980 hardening; they need a shell.
+    // This only kicks in for the npm shim path — node-based invocations pass
+    // an absolute node executable and still run shell-free.
+    shell: options.shell === true,
   })
   return output ? output.trim() : ''
 }
@@ -296,14 +305,19 @@ function verifyPackedRuntimeInstall(input = {}) {
     run(pack.command, pack.args, {
       cwd: pkg.packageDir,
       stdio: ['ignore', 'pipe', 'pipe'],
+      shell: pack.shell,
     })
     packageArtifactEvidence(pkg)
   }
 
   const init = npmInvocation(['init', '-y'])
-  run(init.command, init.args, { cwd: plan.installDir, stdio: ['ignore', 'pipe', 'pipe'] })
+  run(init.command, init.args, { cwd: plan.installDir, stdio: ['ignore', 'pipe', 'pipe'], shell: init.shell })
   const install = npmInvocation(plan.install.args)
-  run(install.command, install.args, { cwd: plan.install.cwd, stdio: ['ignore', 'pipe', 'pipe'] })
+  run(install.command, install.args, {
+    cwd: plan.install.cwd,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: install.shell,
+  })
   const smokeEnv = {
     ...process.env,
     MIO_HOME: path.join(plan.installDir, '.mio-home'),
@@ -360,6 +374,7 @@ module.exports = {
   createVerifyPackedRuntimeOptions,
   createPackedRuntimeInstallPlan,
   packageArtifactEvidence,
+  readPackageJson,
   npmInvocation,
   npmCommand,
   parseVerifyPackedRuntimeArgs,

package/server/agent-store.js

@@ -0,0 +1,140 @@
+'use strict'
+
+// Shared agent store: the single implementation behind mio.agent.list /
+// register / report, consumed by both the MCP server and the CLI
+// (`mio agents list` / `mio agents report`). It owns agents.jsonl plus the
+// read-only cross-references the report needs (traces, memory, experience
+// reuse). Extracted from mio-intelligence-mcp/index.js so the terminal and the
+// MCP tool can never report different agent telemetry.
+//
+// Two distinct "agent" notions live in this repo and the CLI must not confuse
+// them: `mio agents` (no subcommand) lists installed host adapters from
+// config.json, while this store reports *observed* agents recorded in
+// agents.jsonl. `mio agents list` / `report` are about the latter.
+
+const path = require('path')
+const { createId, readJsonl, appendJsonl, writeJsonl } = require('./memory-store.js')
+
+function createAgentStore(options) {
+  const dataDir = options.dataDir
+  const projectName = options.projectName || (() => null)
+
+  const agentsPath = path.join(dataDir, 'agents.jsonl')
+  const tracePath = path.join(dataDir, 'traces.jsonl')
+  const memoryPath = path.join(dataDir, 'memory.jsonl')
+  const experienceReusePath = path.join(dataDir, 'experience_reuse.jsonl')
+
+  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 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,
+    }
+  }
+
+  return { listAgents, reportAgent, registerAgent }
+}
+
+module.exports = { createAgentStore }

package/server/digest.js

@@ -186,6 +186,18 @@ function createDigest(options = {}) {
       suggestions,
     }
     report.markdown = renderMarkdown(report)
+
+    // Persist a machine-readable snapshot for consumers that should not
+    // recompute the aggregation — notably mio.task.route's agent-health signal.
+    try {
+      const digestDir = path.join(home, 'digest')
+      fs.mkdirSync(digestDir, { recursive: true })
+      const snapshot = { ...report }
+      delete snapshot.markdown
+      fs.writeFileSync(path.join(digestDir, 'latest.json'), JSON.stringify(snapshot) + '\n', 'utf8')
+    } catch (_) {
+      // best-effort persistence; the in-memory report is still returned
+    }
     return report
   }