mio-agent-runtime 0.3.5 → 0.3.6

package/README.md

@@ -10,9 +10,9 @@ Mio Agent Runtime 的可发布 CLI 包。
 npm install -g mio-agent-runtime
 ```
 
-> 新机器 / 升级：请安装 `>=0.3.4`（Codex 被动观察）或 `>=0.3.5`
-> （Codex + OpenCode 被动观察）。旧版本只有主动 MCP 规则注入，
-> 没有「无感存/取」。安装后执行一次 `mio init && mio install <host>`。
+> 新机器 / 升级：请安装 `>=0.3.6`（Codex + OpenCode + Hermes 被动观察）。
+> 旧版本只有主动 MCP 规则注入，没有「无感存/取」。安装后执行一次
+> `mio init && mio install <host>`。
 
 ## Commands
 
@@ -37,6 +37,9 @@ mio --json agents           Machine-readable agents
   running, restart it once so it reloads both files. `mio observe` also
   passively tails the OpenCode session database (`opencode db`) without
   requiring the model to call Mio tools.
+- Hermes uses `hermes mcp add mio-intelligence --command node --args <server>`
+  to register the Mio MCP server. Hermes has native memory and reads
+  AGENTS.md Context Files, so retrieval works without Mio rule injection.
 - WorkBuddy uses `~/.workbuddy/mcp.json` and requires each custom MCP server to
   be approved in `~/.workbuddy/mcp-approvals.json`. `mio install workbuddy`
   writes both files and injects Mio usage rules into
@@ -72,6 +75,12 @@ OpenCode 会话不依赖模型自觉：`mio observe` 通过 `opencode db` 增量
 把摘要写回 `<workspace>/AGENTS.md` 的 `MIO_CONTEXT` 块，供 OpenCode 下一会话
 被动取用。首次启动只回填最近 24h 的 part，避免历史会话灌入记忆库。
 
+Hermes（Nous hermes-agent）同理：`mio observe` 以只读方式增量读取
+`<LocalAppData>/hermes/state.db`（`messages.id` 自增游标，无需调用 hermes CLI），
+把每个用户回合的 `task_outcome` 写入 `MIO_HOME`（`source=hermes-observer`）。
+Hermes 本身有原生记忆，Mio 只负责让 Hermes 经验进入跨 Agent 生态；仅当会话
+发生在真实 git 仓库时才写回该仓库的 `AGENTS.md`，避免污染用户主目录。
+
 ## MIO_HOME
 
 默认 `~/.mio-intelligence`，可通过环境变量 `MIO_HOME` 覆盖。

package/adapters/hermes.js

@@ -0,0 +1,90 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const { spawnSync } = require('child_process')
+
+const SERVER_NAME = 'mio-intelligence'
+
+function hermesBin() {
+  if (process.env.HERMES_BIN && fs.existsSync(process.env.HERMES_BIN)) return process.env.HERMES_BIN
+  const candidates = [
+    path.join(os.homedir(), 'AppData', 'Local', 'hermes', 'hermes-agent', 'bin', 'hermes.exe'),
+    path.join(os.homedir(), '.hermes', 'bin', 'hermes.exe'),
+  ]
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c
+  }
+  return null
+}
+
+function runHermes(args) {
+  const bin = hermesBin()
+  // `hermes mcp add` asks to confirm tool enablement interactively; pre-answer
+  // it so the install is non-interactive.
+  const input = args[0] === 'mcp' && args[1] === 'add' ? 'Y\n' : undefined
+  let res
+  try {
+    res = bin
+      ? spawnSync(bin, args, { encoding: 'utf8', timeout: 60000, windowsHide: true, input: input })
+      : spawnSync('hermes', args, { encoding: 'utf8', timeout: 60000, shell: true, windowsHide: true, input: input })
+  } catch (_) {
+    return null
+  }
+  if (res.error || res.status !== 0) return null
+  return (res.stdout || '') + (res.stderr || '')
+}
+
+function isInstalled() {
+  const out = runHermes(['mcp', 'list'])
+  return Boolean(out && out.indexOf(SERVER_NAME) !== -1)
+}
+
+function install({ node, serverScript, home, workspace, project }) {
+  if (!hermesBin() && !isHermesOnPath()) {
+    return {
+      changed: false,
+      message: 'Hermes binary not found. Install hermes-agent first.',
+      configPath: null,
+    }
+  }
+  if (isInstalled()) {
+    return { changed: false, message: 'Hermes Mio MCP already installed.', configPath: null }
+  }
+
+  const context = JSON.stringify({
+    agentId: 'hermes',
+    project: project || path.basename(workspace || process.cwd()),
+    workspace: workspace || process.cwd(),
+    sessionId: 'hermes-session',
+  })
+
+  const args = [
+    'mcp', 'add', SERVER_NAME,
+    '--command', node,
+    '--args', serverScript,
+    '--env', 'MIO_DATA_DIR=' + home, 'MIO_CONTEXT=' + context,
+  ]
+  const out = runHermes(args)
+  const installed = isInstalled()
+
+  let message
+  if (installed) {
+    message = 'Hermes Mio MCP installed (config: <LocalAppData>/hermes/config.yaml). Start a new Hermes session to load it.'
+  } else {
+    message = 'Hermes mcp add returned but Mio was not detected. Run `hermes mcp add ' + SERVER_NAME + ' --command ' + node + ' --args ' + serverScript + '` manually and answer Y to the prompt.'
+  }
+  return { changed: installed, configPath: null, message }
+}
+
+function isHermesOnPath() {
+  try {
+    const res = spawnSync('where', ['hermes'], { encoding: 'utf8', shell: true })
+    return res.status === 0 && /hermes/.test(res.stdout || '')
+  } catch (_) {
+    return false
+  }
+}
+
+module.exports = { hermesBin, isInstalled, install }

package/bin/mio.js

@@ -1,249 +1,255 @@
-#!/usr/bin/env node
-'use strict'
-
-const fs = require('fs')
-const path = require('path')
-const os = require('os')
-
-const SERVER_SCRIPT = path.resolve(__dirname, '..', 'server', 'mio-intelligence-mcp', 'index.js')
-const MIO_HOME = process.env.MIO_HOME || path.join(os.homedir(), '.mio-intelligence')
-const CONFIG_FILE = path.join(MIO_HOME, 'config.json')
-
-const adapters = {
-  codex: require('../adapters/codex.js'),
-  opencode: require('../adapters/opencode.js'),
-  workbuddy: require('../adapters/workbuddy.js'),
-}
-const observer = require('../observe/observer.js')
-
-function ensureHome() {
-  fs.mkdirSync(MIO_HOME, { recursive: true })
-  fs.mkdirSync(path.join(MIO_HOME, 'logs'), { recursive: true })
-}
-
-function readConfig() {
-  const fallback = { version: 1, home: MIO_HOME, agents: {} }
-  if (!fs.existsSync(CONFIG_FILE)) return fallback
-  try {
-    return { ...fallback, ...JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')) }
-  } catch (_) {
-    return fallback
-  }
-}
-
-function writeConfig(config) {
-  ensureHome()
-  fs.writeFileSync(CONFIG_FILE, `${JSON.stringify(config, null, 2)}\n`, 'utf8')
-}
-
-function jsonOrText(payload, useJson) {
-  if (useJson) {
-    console.log(JSON.stringify(payload, null, 2))
-    return
-  }
-  return payload
-}
-
-function initCommand() {
-  ensureHome()
-  const config = readConfig()
-  if (!config.createdAt) config.createdAt = new Date().toISOString()
-  writeConfig(config)
-  console.log(`MIO_HOME ready: ${MIO_HOME}`)
-}
-
-function statusCommand(useJson) {
-  const config = readConfig()
-  const installed = {
-    codex: adapters.codex.isInstalled(),
-    opencode: adapters.opencode.isInstalled(),
-    workbuddy: adapters.workbuddy.isInstalled(),
-  }
-  const payload = {
-    version: config.version,
-    home: MIO_HOME,
-    serverScript: SERVER_SCRIPT,
-    serverScriptExists: fs.existsSync(SERVER_SCRIPT),
-    agents: config.agents || {},
-    codexInstalled: installed.codex,
-    opencodeInstalled: installed.opencode,
-    workbuddyInstalled: installed.workbuddy,
+#!/usr/bin/env node
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+
+const SERVER_SCRIPT = path.resolve(__dirname, '..', 'server', 'mio-intelligence-mcp', 'index.js')
+const MIO_HOME = process.env.MIO_HOME || path.join(os.homedir(), '.mio-intelligence')
+const CONFIG_FILE = path.join(MIO_HOME, 'config.json')
+
+const adapters = {
+  codex: require('../adapters/codex.js'),
+  opencode: require('../adapters/opencode.js'),
+  workbuddy: require('../adapters/workbuddy.js'),
+  hermes: require('../adapters/hermes.js'),
+}
+const observer = require('../observe/observer.js')
+
+function ensureHome() {
+  fs.mkdirSync(MIO_HOME, { recursive: true })
+  fs.mkdirSync(path.join(MIO_HOME, 'logs'), { recursive: true })
+}
+
+function readConfig() {
+  const fallback = { version: 1, home: MIO_HOME, agents: {} }
+  if (!fs.existsSync(CONFIG_FILE)) return fallback
+  try {
+    return { ...fallback, ...JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')) }
+  } catch (_) {
+    return fallback
+  }
+}
+
+function writeConfig(config) {
+  ensureHome()
+  fs.writeFileSync(CONFIG_FILE, `${JSON.stringify(config, null, 2)}\n`, 'utf8')
+}
+
+function jsonOrText(payload, useJson) {
+  if (useJson) {
+    console.log(JSON.stringify(payload, null, 2))
+    return
+  }
+  return payload
+}
+
+function initCommand() {
+  ensureHome()
+  const config = readConfig()
+  if (!config.createdAt) config.createdAt = new Date().toISOString()
+  writeConfig(config)
+  console.log(`MIO_HOME ready: ${MIO_HOME}`)
+}
+
+function statusCommand(useJson) {
+  const config = readConfig()
+  const installed = {
+    codex: adapters.codex.isInstalled(),
+    opencode: adapters.opencode.isInstalled(),
+    workbuddy: adapters.workbuddy.isInstalled(),
+    hermes: adapters.hermes.isInstalled(),
+  }
+  const payload = {
+    version: config.version,
+    home: MIO_HOME,
+    serverScript: SERVER_SCRIPT,
+    serverScriptExists: fs.existsSync(SERVER_SCRIPT),
+    agents: config.agents || {},
+    codexInstalled: installed.codex,
+    opencodeInstalled: installed.opencode,
+    workbuddyInstalled: installed.workbuddy,
+    hermesInstalled: installed.hermes,
+    hermesObserverReady: fs.existsSync(observer.hermesDbPath()),
     opencodeObserverReady: fs.existsSync(observer.opencodeDbPath()),
-    observerRunning: observer.isRunning(MIO_HOME),
-    observerPid: observer.isRunning(MIO_HOME) ? observer.readPid(MIO_HOME) : null,
-  }
-  if (useJson) {
-    jsonOrText(payload, true)
-    return
-  }
-  console.log(`MIO_HOME: ${MIO_HOME}`)
-  console.log(`MCP Server: ${SERVER_SCRIPT}`)
-  console.log(`Codex MCP: ${installed.codex ? 'installed' : 'not installed'}`)
+    observerRunning: observer.isRunning(MIO_HOME),
+    observerPid: observer.isRunning(MIO_HOME) ? observer.readPid(MIO_HOME) : null,
+  }
+  if (useJson) {
+    jsonOrText(payload, true)
+    return
+  }
+  console.log(`MIO_HOME: ${MIO_HOME}`)
+  console.log(`MCP Server: ${SERVER_SCRIPT}`)
+  console.log(`Codex MCP: ${installed.codex ? 'installed' : 'not installed'}`)
   console.log(`OpenCode MCP: ${installed.opencode ? 'installed' : 'not installed'}`)
-  console.log(`OpenCode observer: ${fs.existsSync(observer.opencodeDbPath()) ? 'ready' : 'no database'}`)
-  console.log(`WorkBuddy MCP: ${installed.workbuddy ? 'installed' : 'not installed'}`)
-  console.log(`Observer: ${observer.isRunning(MIO_HOME) ? 'running (pid ' + observer.readPid(MIO_HOME) + ')' : 'not running'}`)
-}
-
-function agentsCommand(useJson) {
-  const config = readConfig()
-  const agents = config.agents || {}
-  if (useJson) {
-    jsonOrText(agents, true)
-    return
-  }
-  const names = Object.keys(agents)
-  if (names.length === 0) {
-    console.log('No agents installed.')
-    return
-  }
-  for (const name of names) {
-    console.log(`${name}\t${agents[name].installedAt || ''}`)
-  }
-}
-
-function installCommand(host, useJson) {
-  if (!host) {
-    console.error('Usage: mio install <codex|opencode|workbuddy>')
-    process.exitCode = 1
-    return
-  }
-  const adapter = adapters[host]
-  if (!adapter) {
-    console.error(`Unknown host: ${host}`)
-    process.exitCode = 1
-    return
-  }
-  ensureHome()
-  const config = readConfig()
-  let result
-  try {
-    result = adapter.install({
-      node: process.execPath,
-      serverScript: SERVER_SCRIPT,
-      home: MIO_HOME,
-      workspace: process.cwd(),
-    })
-  } catch (error) {
-    console.error(`Failed to install ${host}: ${error.message || error}`)
-    process.exitCode = 1
-    return
-  }
-  if (result.changed) {
-    config.agents = config.agents || {}
-    config.agents[host] = {
-      installedAt: new Date().toISOString(),
-      configPath: result.configPath || null,
-    }
-    writeConfig(config)
-  }
-  try {
-    observer.runCycle(MIO_HOME, observer.loadState(MIO_HOME), observer.createSinks(MIO_HOME))
-  } catch (_) {}
-  let observerStarted = false
-  try {
-    observerStarted = observer.startBackground(MIO_HOME).started
-  } catch (_) {}
-  if (useJson) {
-    result.observer = {
-      running: observer.isRunning(MIO_HOME),
-      started: observerStarted,
-    }
-    jsonOrText(result, true)
-    return
-  }
-  console.log(result.message || `${host} adapter completed.`)
-  console.log(
-    observer.isRunning(MIO_HOME)
-      ? 'Observer daemon running.'
-      : 'Observer daemon not running. Run `mio observe --start`.'
-  )
-}
-
-function mcpCommand() {
-  require(SERVER_SCRIPT)
-}
-
-function observeCommand(args) {
-  const flags = args.slice(1)
-  const useJson = flags.includes('--json')
-  if (flags.includes('--start')) {
-    const result = observer.startBackground(MIO_HOME)
-    if (useJson) return jsonOrText(result, true)
-    console.log(result.started ? 'Observer started.' : 'Observer already running.')
-    return
-  }
-  if (flags.includes('--stop')) {
-    const result = observer.stopBackground(MIO_HOME)
-    if (useJson) return jsonOrText(result, true)
-    console.log(result.stopped ? 'Observer stopped.' : 'Observer was not running.')
-    return
-  }
-  if (flags.includes('--status')) {
-    const running = observer.isRunning(MIO_HOME)
-    const pid = observer.readPid(MIO_HOME)
-    if (useJson) return jsonOrText({ running, pid }, true)
-    console.log(running ? 'Observer: running (pid ' + pid + ')' : 'Observer: not running')
-    return
-  }
-  if (flags.includes('--once')) {
-    const res = observer.runCycle(
-      MIO_HOME,
-      observer.loadState(MIO_HOME),
-      observer.createSinks(MIO_HOME)
-    )
-    if (useJson) return jsonOrText(res, true)
-    console.log('Observed files=' + res.files + ' lines=' + res.lines + ' outcomes=' + res.outcomes)
-    return
-  }
-  console.log('Observing WorkBuddy transcripts into ' + MIO_HOME + ' (Ctrl+C to stop)...')
-  observer.startForeground(MIO_HOME)
-}
-
-function help() {
-  console.log(`Mio Agent Runtime CLI
-
-Usage:
-  mio init                    Initialize MIO_HOME
-  mio mcp                     Start Mio MCP server (stdio)
-  mio install <host>          Install Mio into a host (codex|opencode|workbuddy)
-  mio status                  Show runtime and adapter status
-  mio agents                  List installed agents
-  mio observe                 Watch WorkBuddy transcripts and auto-ingest task outcomes
-  mio observe --start|--stop|--status|--once   Manage the background observer daemon
-  mio --json status           Machine-readable status
-  mio --json agents           Machine-readable agents
-`)
-}
-
-function main() {
-  const args = process.argv.slice(2)
-  const jsonIndex = args.indexOf('--json')
-  const useJson = jsonIndex !== -1
-  if (useJson) args.splice(jsonIndex, 1)
-  const command = args[0] || 'help'
-
-  switch (command) {
-    case 'init':
-      return initCommand()
-    case 'mcp':
-      return mcpCommand()
-    case 'install':
-      return installCommand(args[1], useJson)
-    case 'status':
-      return statusCommand(useJson)
-    case 'agents':
-      return agentsCommand(useJson)
-    case 'observe':
-      return observeCommand(args)
-    case 'help':
-    case '--help':
-      return help()
-    default:
-      console.error(`Unknown command: ${command}`)
-      help()
-      process.exitCode = 1
-  }
-}
-
-main()
+  console.log(`OpenCode observer: ${fs.existsSync(observer.opencodeDbPath()) ? 'ready' : 'no database'}`)
+  console.log(`WorkBuddy MCP: ${installed.workbuddy ? 'installed' : 'not installed'}`)
+  console.log(`Hermes MCP: ${installed.hermes ? 'installed' : 'not installed'}`)
+  console.log(`Hermes observer: ${fs.existsSync(observer.hermesDbPath()) ? 'ready' : 'no database'}`)
+  console.log(`Observer: ${observer.isRunning(MIO_HOME) ? 'running (pid ' + observer.readPid(MIO_HOME) + ')' : 'not running'}`)
+}
+
+function agentsCommand(useJson) {
+  const config = readConfig()
+  const agents = config.agents || {}
+  if (useJson) {
+    jsonOrText(agents, true)
+    return
+  }
+  const names = Object.keys(agents)
+  if (names.length === 0) {
+    console.log('No agents installed.')
+    return
+  }
+  for (const name of names) {
+    console.log(`${name}\t${agents[name].installedAt || ''}`)
+  }
+}
+
+function installCommand(host, useJson) {
+  if (!host) {
+    console.error('Usage: mio install <codex|opencode|workbuddy|hermes>')
+    process.exitCode = 1
+    return
+  }
+  const adapter = adapters[host]
+  if (!adapter) {
+    console.error(`Unknown host: ${host}`)
+    process.exitCode = 1
+    return
+  }
+  ensureHome()
+  const config = readConfig()
+  let result
+  try {
+    result = adapter.install({
+      node: process.execPath,
+      serverScript: SERVER_SCRIPT,
+      home: MIO_HOME,
+      workspace: process.cwd(),
+    })
+  } catch (error) {
+    console.error(`Failed to install ${host}: ${error.message || error}`)
+    process.exitCode = 1
+    return
+  }
+  if (result.changed) {
+    config.agents = config.agents || {}
+    config.agents[host] = {
+      installedAt: new Date().toISOString(),
+      configPath: result.configPath || null,
+    }
+    writeConfig(config)
+  }
+  try {
+    observer.runCycle(MIO_HOME, observer.loadState(MIO_HOME), observer.createSinks(MIO_HOME))
+  } catch (_) {}
+  let observerStarted = false
+  try {
+    observerStarted = observer.startBackground(MIO_HOME).started
+  } catch (_) {}
+  if (useJson) {
+    result.observer = {
+      running: observer.isRunning(MIO_HOME),
+      started: observerStarted,
+    }
+    jsonOrText(result, true)
+    return
+  }
+  console.log(result.message || `${host} adapter completed.`)
+  console.log(
+    observer.isRunning(MIO_HOME)
+      ? 'Observer daemon running.'
+      : 'Observer daemon not running. Run `mio observe --start`.'
+  )
+}
+
+function mcpCommand() {
+  require(SERVER_SCRIPT)
+}
+
+function observeCommand(args) {
+  const flags = args.slice(1)
+  const useJson = flags.includes('--json')
+  if (flags.includes('--start')) {
+    const result = observer.startBackground(MIO_HOME)
+    if (useJson) return jsonOrText(result, true)
+    console.log(result.started ? 'Observer started.' : 'Observer already running.')
+    return
+  }
+  if (flags.includes('--stop')) {
+    const result = observer.stopBackground(MIO_HOME)
+    if (useJson) return jsonOrText(result, true)
+    console.log(result.stopped ? 'Observer stopped.' : 'Observer was not running.')
+    return
+  }
+  if (flags.includes('--status')) {
+    const running = observer.isRunning(MIO_HOME)
+    const pid = observer.readPid(MIO_HOME)
+    if (useJson) return jsonOrText({ running, pid }, true)
+    console.log(running ? 'Observer: running (pid ' + pid + ')' : 'Observer: not running')
+    return
+  }
+  if (flags.includes('--once')) {
+    const res = observer.runCycle(
+      MIO_HOME,
+      observer.loadState(MIO_HOME),
+      observer.createSinks(MIO_HOME)
+    )
+    if (useJson) return jsonOrText(res, true)
+    console.log('Observed files=' + res.files + ' lines=' + res.lines + ' outcomes=' + res.outcomes)
+    return
+  }
+  console.log('Observing WorkBuddy transcripts into ' + MIO_HOME + ' (Ctrl+C to stop)...')
+  observer.startForeground(MIO_HOME)
+}
+
+function help() {
+  console.log(`Mio Agent Runtime CLI
+
+Usage:
+  mio init                    Initialize MIO_HOME
+  mio mcp                     Start Mio MCP server (stdio)
+  mio install <host>          Install Mio into a host (codex|opencode|workbuddy|hermes)
+  mio status                  Show runtime and adapter status
+  mio agents                  List installed agents
+  mio observe                 Watch WorkBuddy transcripts and auto-ingest task outcomes
+  mio observe --start|--stop|--status|--once   Manage the background observer daemon
+  mio --json status           Machine-readable status
+  mio --json agents           Machine-readable agents
+`)
+}
+
+function main() {
+  const args = process.argv.slice(2)
+  const jsonIndex = args.indexOf('--json')
+  const useJson = jsonIndex !== -1
+  if (useJson) args.splice(jsonIndex, 1)
+  const command = args[0] || 'help'
+
+  switch (command) {
+    case 'init':
+      return initCommand()
+    case 'mcp':
+      return mcpCommand()
+    case 'install':
+      return installCommand(args[1], useJson)
+    case 'status':
+      return statusCommand(useJson)
+    case 'agents':
+      return agentsCommand(useJson)
+    case 'observe':
+      return observeCommand(args)
+    case 'help':
+    case '--help':
+      return help()
+    default:
+      console.error(`Unknown command: ${command}`)
+      help()
+      process.exitCode = 1
+  }
+}
+
+main()

package/observe/observer.js

@@ -83,6 +83,9 @@ function loadState(home) {
         ocDbMtime: parsed.ocDbMtime || null,
         ocPending: parsed.ocPending || false,
         ocTurns: parsed.ocTurns || {},
+        hmSeeded: parsed.hmSeeded || false,
+        hmLastMsgId: parsed.hmLastMsgId || 0,
+        hmTurns: parsed.hmTurns || {},
       }
     }
   } catch (_) {}
@@ -100,6 +103,9 @@ function loadState(home) {
     ocDbMtime: null,
     ocPending: false,
     ocTurns: {},
+    hmSeeded: false,
+    hmLastMsgId: 0,
+    hmTurns: {},
   }
 }
 
@@ -883,6 +889,230 @@ function runOpencodeCycle(home, state, sinks, opts) {
   return out
 }
 
+// ---------------------------------------------------------------------------
+// Hermes session observation (passive, via its own SQLite state.db)
+// ---------------------------------------------------------------------------
+
+// Hermes (Nous Research hermes-agent) keeps every conversation in
+// <LocalAppData>/hermes/state.db. Unlike OpenCode the file is not exclusively
+// locked, and `messages.id` is a monotonic AUTOINCREMENT cursor, so we can tail
+// it read-only with node:sqlite (Node 22+). Each message is one row carrying
+// role / content / finish_reason, so a user row opens a turn and an assistant
+// row with a terminal finish_reason closes it immediately. Hermes already has
+// native memory, so this observer only imports Hermes experience into the Mio
+// ecosystem (traces + memory + AGENTS.md context when a git repo is present).
+
+let _hermesSqlite = null
+let _hermesSqliteTried = false
+
+function hermesSqliteModule() {
+  if (_hermesSqliteTried) return _hermesSqlite
+  _hermesSqliteTried = true
+  try {
+    _hermesSqlite = require('node:sqlite')
+  } catch (_) {
+    _hermesSqlite = null
+  }
+  return _hermesSqlite
+}
+
+function hermesDbPath() {
+  return (
+    process.env.HERMES_DATA_DIR ||
+    path.join(os.homedir(), 'AppData', 'Local', 'hermes', 'state.db')
+  )
+}
+
+function hermesProjectName(meta) {
+  if (meta.git) return path.basename(meta.git)
+  if (meta.cwd && meta.cwd !== os.homedir()) return path.basename(meta.cwd)
+  return 'hermes'
+}
+
+function createHermesTurn(meta) {
+  meta = meta || {}
+  return {
+    id: null,
+    ts: null,
+    sessionId: meta.sessionId || null,
+    cwd: meta.git || null,
+    project: hermesProjectName({ git: meta.git, cwd: meta.projectHint }),
+    title: meta.title || null,
+    agent: meta.agent || null,
+    lastText: null,
+    toolCount: 0,
+    lastMid: null,
+  }
+}
+
+function hermesOutcomeFor(finish) {
+  if (finish === 'error' || finish === 'failure') return 'failure'
+  if (finish === 'cancel' || finish === 'aborted' || finish === 'interrupted') return 'aborted'
+  return 'success'
+}
+
+function finalizeHermesTurn(turn, outcome) {
+  if (!turn.id) return null
+  const finalized = {
+    id: turn.id,
+    ts: turn.ts,
+    sessionId: turn.sessionId,
+    cwd: turn.cwd,
+    project: turn.project,
+    agent: turn.agent,
+    title: turn.title,
+    lastText: turn.lastText,
+    toolCount: turn.toolCount,
+    errors: [],
+    outcome: outcome,
+  }
+  return finalized
+}
+
+function feedHermesRow(turn, row) {
+  const meta = { sessionId: row.sid, title: row.stitle, git: row.sgit, agent: row.ssource, projectHint: row.scwd }
+
+  if (row.role === 'user') {
+    let finalized = null
+    if (turn.id) finalized = finalizeHermesTurn(turn, 'aborted')
+    const next = createHermesTurn(meta)
+    next.id = Number(row.id)
+    next.ts = Math.floor(Number(row.t) * 1000) || Date.now()
+    next.lastMid = Number(row.id)
+    return { finalized, next }
+  }
+
+  if (row.role === 'assistant') {
+    if (!turn.id) return { next: turn }
+    if (typeof row.content === 'string' && row.content.trim()) {
+      turn.lastText = row.content
+    }
+    if (row.tool_calls) {
+      try {
+        const calls = JSON.parse(row.tool_calls)
+        if (Array.isArray(calls)) turn.toolCount += calls.length
+      } catch (_) {}
+    }
+    if (row.finish_reason && row.finish_reason !== 'tool_calls') {
+      const finalized = finalizeHermesTurn(turn, hermesOutcomeFor(row.finish_reason))
+      return { finalized, next: createHermesTurn(meta) }
+    }
+    turn.lastMid = Number(row.id)
+    return { next: turn }
+  }
+
+  return { next: turn }
+}
+
+function emitHermesOutcome(turn, sinks, state) {
+  if (!turn.id) return false
+  const summary = cleanText(turn.lastText)
+  if (!summary) return false
+  const outcome = turn.outcome
+  const tsToken = turn.ts ? Math.floor(turn.ts / 1000) : Math.floor(Date.now() / 1000)
+
+  sinks.trace({
+    trace_id: 'hermes:' + (turn.sessionId || 'unknown') + ':' + String(turn.id) + ':' + tsToken,
+    event_type: 'task_outcome',
+    outcome: outcome,
+    payload: {
+      host: 'hermes',
+      project: turn.project,
+      sessionId: turn.sessionId,
+      turnId: turn.id,
+      title: turn.title,
+      agent: turn.agent,
+      toolCalls: turn.toolCount,
+      errors: 0,
+      summary: summary.slice(0, 300),
+      source: 'hermes-observer',
+    },
+    agent: 'hermes',
+    host: 'hermes',
+    project: turn.project,
+  })
+
+  if (outcome === 'success' && summary.length >= 10) {
+    sinks.memory({
+      kind: 'note',
+      content: '[hermes] 任务完成: ' + summary.slice(0, 160),
+      tags: ['task-outcome', 'hermes', turn.project],
+      project: turn.project,
+      source: 'hermes-observer',
+    })
+    // Hermes reads AGENTS.md Context Files; write back only into a real repo
+    // workspace so we never pollute the user's home directory.
+    if (turn.cwd) {
+      var ctxTime = new Date(Number(turn.ts) || Date.now()).toLocaleString('zh-CN', { hour12: false })
+      updateProjectContext(state, turn.cwd, ctxTime + ' | ' + outcome + ' | ' + summary.slice(0, 80))
+    }
+  }
+  return true
+}
+
+function runHermesCycle(home, state, sinks, opts) {
+  const out = { files: 0, lines: 0, outcomes: 0 }
+  const dbPath = hermesDbPath()
+  if (!fs.existsSync(dbPath)) return out
+  const sqlite = hermesSqliteModule()
+  if (!sqlite) return out
+  let db
+  try {
+    db = new sqlite.DatabaseSync(dbPath, { readOnly: true })
+  } catch (_) {
+    return out
+  }
+  out.files = 1
+  const maxAgeMs = (opts && opts.maxAgeMs) || 24 * 60 * 60 * 1000
+  try {
+    if (!state.hmSeeded) {
+      const cutoff = (Date.now() - maxAgeMs) / 1000
+      const first = db.prepare('SELECT id FROM messages WHERE active = 1 AND timestamp >= ? ORDER BY id LIMIT 1').get(cutoff)
+      if (first) {
+        state.hmLastMsgId = first.id
+      } else {
+        const maxRow = db.prepare('SELECT COALESCE(MAX(id), 0) AS id FROM messages').get()
+        state.hmLastMsgId = maxRow.id
+      }
+      state.hmSeeded = true
+    }
+
+    const limit = 2000
+    const stmt = db.prepare(
+      'SELECT m.id AS id, m.session_id AS sid, m.role AS role, m.content AS content, ' +
+      'm.tool_name AS tool_name, m.tool_calls AS tool_calls, m.timestamp AS t, m.finish_reason AS finish_reason, ' +
+      's.title AS stitle, s.cwd AS scwd, s.git_repo_root AS sgit, s.source AS ssource ' +
+      'FROM messages m LEFT JOIN sessions s ON s.id = m.session_id ' +
+      'WHERE m.id > ? AND m.active = 1 ORDER BY m.id LIMIT ' + limit
+    )
+    const rows = stmt.all(state.hmLastMsgId)
+    if (rows.length === 0) return out
+
+    let lastId = state.hmLastMsgId
+    for (const row of rows) {
+      const rid = Number(row.id)
+      if (rid > lastId) lastId = rid
+      out.lines += 1
+      const sid = row.sid
+      let turn = state.hmTurns[sid]
+      if (!turn) {
+        turn = createHermesTurn({ sessionId: sid, title: row.stitle, git: row.sgit, agent: row.ssource, projectHint: row.scwd })
+        state.hmTurns[sid] = turn
+      }
+      const result = feedHermesRow(turn, row)
+      if (result.finalized) {
+        if (emitHermesOutcome(result.finalized, sinks, state)) out.outcomes += 1
+      }
+      state.hmTurns[sid] = result.next
+    }
+    state.hmLastMsgId = lastId
+  } finally {
+    db.close()
+  }
+  return out
+}
+
+
 // ---------------------------------------------------------------------------
 // cycle
 // ---------------------------------------------------------------------------
@@ -970,6 +1200,11 @@ function runCycle(home, state, sinks, opts) {
   out.lines += ocRes.lines
   out.outcomes += ocRes.outcomes
 
+  const hmRes = runHermesCycle(home, state, sinks, opts)
+  out.files += hmRes.files
+  out.lines += hmRes.lines
+  out.outcomes += hmRes.outcomes
+
   saveState(home, state)
   return out
 }
@@ -1059,6 +1294,8 @@ module.exports = {
   runCycle,
   opencodeDbPath,
   runOpencodeCycle,
+  runHermesCycle,
+  hermesDbPath,
   createSinks,
   startForeground,
   startBackground,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",
@@ -15,7 +15,7 @@
     "README.md"
   ],
   "scripts": {
-    "check": "node --check bin/mio.js && node --check adapters/codex.js && node --check adapters/opencode.js && node --check adapters/workbuddy.js && node --check server/mio-intelligence-mcp/index.js && node --check observe/observer.js",
+    "check": "node --check bin/mio.js && node --check adapters/codex.js && node --check adapters/opencode.js && node --check adapters/workbuddy.js && node --check adapters/hermes.js && node --check server/mio-intelligence-mcp/index.js && node --check observe/observer.js",
     "prepack": "npm run check"
   },
   "engines": {