mio-agent-runtime 0.5.23 → 0.7.0

package/observe/observer.js

@@ -65,26 +65,67 @@ 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[cwd] = []
+      out[key] = existing
       continue
     }
-    const seen = new Set()
-    const deduped = []
+    const seen = new Set(existing)
+    const merged = existing.slice()
     for (const line of list) {
       if (seen.has(line)) continue
       seen.add(line)
-      deduped.push(line)
+      merged.push(line)
     }
-    out[cwd] = deduped
+    out[key] = merged
   }
   return out
 }
@@ -314,24 +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')
-  // Normalise the whole list before inserting, not just the incoming line.
-  // Callers may load state without going through loadState (the digest
-  // write-back reads the file directly), so stale duplicates have to be
-  // cleared here or they keep consuming slots and push real history out.
+  // 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 item of state.contexts[cwd] || []) {
-    if (seen.has(item)) continue
-    seen.add(item)
-    list.push(item)
+  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
@@ -1629,6 +1685,8 @@ module.exports = {
   loadState,
   saveState,
   dedupeContexts,
+  normalizeCwd,
+  contextTimestamp,
   updateProjectContext,
   runCycle,
   opencodeDbPath,

package/package.json

@@ -1,45 +1,45 @@
-{
-  "name": "mio-agent-runtime",
-  "version": "0.5.23",
-  "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",
-    "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": ""
-}
+{
+  "name": "mio-agent-runtime",
+  "version": "0.7.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/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 }