mio-agent-runtime 0.3.4 → 0.3.5

package/README.md

@@ -1,79 +1,93 @@
-# mio-agent-runtime
-
-Mio Agent Runtime 的可发布 CLI 包。
-
-安装一次，所有 Agent 自动接入 Mio。
-
-## Install
-
-```bash
-npm install -g mio-agent-runtime
-```
-
-## Commands
-
-```text
-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 (foreground)
-mio observe --start|--stop|--status|--once   Manage the background observer daemon
-mio --json status           Machine-readable status
-mio --json agents           Machine-readable agents
-```
-
-## Host notes
-
-- OpenCode uses `~/.config/opencode/opencode.json` for MCP registration and
-  `~/.config/opencode/AGENTS.md` for global instructions. `mio install opencode`
-  writes both files and injects Mio usage rules into `AGENTS.md` so OpenCode
-  calls Mio memory/observer/policy automatically. If OpenCode is already
-  running, restart it once so it reloads both files.
-- 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
-  `~/.workbuddy/CODEBUDDY.md` (user-level memory rules, auto-loaded by
-  WorkBuddy into every session; the CLI hardcodes the CodeBuddy product name, so the file is CODEBUDDY.md not WORKBUDDY.md) plus `<workspace>/AGENTS.md` (project-level).
-  If WorkBuddy is already running, restart it once so it reloads the approval
-  and memory rule files.
-
-## Passive observer (`mio observe`)
-
-WorkBuddy 的默认模型不一定会主动调用 Mio MCP 工具，即使规则已注入
-(`CODEBUDDY.md` / `AGENTS.md`)。`mio observe` 是一个不依赖模型自觉的
-兜底：它持续监听 `~/.workbuddy/projects/**/*.jsonl` 会话记录，把每个任务的
-结果（`task_outcome`）、工具调用错误（`error`）以及完成任务的摘要自动写入
-`MIO_HOME/traces.jsonl` 和 `MIO_HOME/memory.jsonl`（与 MCP 服务同一套
-schema，`source=workbuddy-observer`）。
-
-- `mio install <host>` 会自动执行一次回填并启动后台观察器。
-
-- 除了写入 `MIO_HOME`，观察器还会把任务摘要**写回 WorkBuddy 自己的记忆文件**
-  (`<workspace>/.workbuddy/memory/YYYY-MM-DD.md`，标为 `## Mio 自动摘要`)。
-  WorkBuddy 的系统提示要求模型每次会话维护并阅读这些文件，所以下一次会话
-  WorkBuddy 会**被动取到** Mio 记录的内容——单 Agent 的「存 + 取」闭环不依赖
-  模型调用 Mio 工具。
-- 已处理的文件偏移记录在 `MIO_HOME/observe-state.json`，不会重复写入。
-- 只回填最近 24h 内更新的会话，避免把历史记录灌入记忆库。
-
-## MIO_HOME
-
-默认 `~/.mio-intelligence`，可通过环境变量 `MIO_HOME` 覆盖。
-
-## Package layout
-
-```text
-packages/mio-cli
-├── bin/mio.js
-├── adapters/
-│   ├── codex.js
-│   ├── opencode.js
-│   └── workbuddy.js
-├── observe/
-│   └── observer.js
-├── server/
-│   └── mio-intelligence-mcp/index.js
-└── package.json
-```
+# mio-agent-runtime
+
+Mio Agent Runtime 的可发布 CLI 包。
+
+安装一次，所有 Agent 自动接入 Mio。
+
+## Install
+
+```bash
+npm install -g mio-agent-runtime
+```
+
+> 新机器 / 升级：请安装 `>=0.3.4`（Codex 被动观察）或 `>=0.3.5`
+> （Codex + OpenCode 被动观察）。旧版本只有主动 MCP 规则注入，
+> 没有「无感存/取」。安装后执行一次 `mio init && mio install <host>`。
+
+## Commands
+
+```text
+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 (foreground)
+mio observe --start|--stop|--status|--once   Manage the background observer daemon
+mio --json status           Machine-readable status
+mio --json agents           Machine-readable agents
+```
+
+## Host notes
+
+- OpenCode uses `~/.config/opencode/opencode.json` for MCP registration and
+  `~/.config/opencode/AGENTS.md` for global instructions. `mio install opencode`
+  writes both files and injects Mio usage rules into `AGENTS.md` so OpenCode
+  calls Mio memory/observer/policy automatically. If OpenCode is already
+  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.
+- 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
+  `~/.workbuddy/CODEBUDDY.md` (user-level memory rules, auto-loaded by
+  WorkBuddy into every session; the CLI hardcodes the CodeBuddy product name, so the file is CODEBUDDY.md not WORKBUDDY.md) plus `<workspace>/AGENTS.md` (project-level).
+  If WorkBuddy is already running, restart it once so it reloads the approval
+  and memory rule files.
+
+## Passive observer (`mio observe`)
+
+WorkBuddy 的默认模型不一定会主动调用 Mio MCP 工具，即使规则已注入
+(`CODEBUDDY.md` / `AGENTS.md`)。`mio observe` 是一个不依赖模型自觉的
+兜底：它持续监听 `~/.workbuddy/projects/**/*.jsonl` 会话记录，把每个任务的
+结果（`task_outcome`）、工具调用错误（`error`）以及完成任务的摘要自动写入
+`MIO_HOME/traces.jsonl` 和 `MIO_HOME/memory.jsonl`（与 MCP 服务同一套
+schema，`source=workbuddy-observer`）。
+
+- `mio install <host>` 会自动执行一次回填并启动后台观察器。
+
+- 除了写入 `MIO_HOME`，观察器还会把任务摘要**写回 WorkBuddy 自己的记忆文件**
+  (`<workspace>/.workbuddy/memory/YYYY-MM-DD.md`，标为 `## Mio 自动摘要`)。
+  WorkBuddy 的系统提示要求模型每次会话维护并阅读这些文件，所以下一次会话
+  WorkBuddy 会**被动取到** Mio 记录的内容——单 Agent 的「存 + 取」闭环不依赖
+  模型调用 Mio 工具。
+- 已处理的文件偏移记录在 `MIO_HOME/observe-state.json`，不会重复写入。
+- 只回填最近 24h 内更新的会话，避免把历史记录灌入记忆库。
+
+OpenCode 会话不依赖模型自觉：`mio observe` 通过 `opencode db` 增量读取
+`~/.local/share/opencode/opencode.db`（Windows 下该文件被 OpenCode 独占锁定，
+必须经 opencode 自带 CLI 读取），按 `part` 表的 rowid 做增量游标，只传输
+`text`/`tool` 两种 part，把每个用户回合的 `task_outcome` 与工具错误写入
+`MIO_HOME/traces.jsonl` / `memory.jsonl`（`source=opencode-observer`），并同样
+把摘要写回 `<workspace>/AGENTS.md` 的 `MIO_CONTEXT` 块，供 OpenCode 下一会话
+被动取用。首次启动只回填最近 24h 的 part，避免历史会话灌入记忆库。
+
+## MIO_HOME
+
+默认 `~/.mio-intelligence`，可通过环境变量 `MIO_HOME` 覆盖。
+
+## Package layout
+
+```text
+packages/mio-cli
+├── bin/mio.js
+├── adapters/
+│   ├── codex.js
+│   ├── opencode.js
+│   └── workbuddy.js
+├── observe/
+│   └── observer.js
+├── server/
+│   └── mio-intelligence-mcp/index.js
+└── package.json
+```

package/bin/mio.js

@@ -68,6 +68,7 @@ function statusCommand(useJson) {
     codexInstalled: installed.codex,
     opencodeInstalled: installed.opencode,
     workbuddyInstalled: installed.workbuddy,
+    opencodeObserverReady: fs.existsSync(observer.opencodeDbPath()),
     observerRunning: observer.isRunning(MIO_HOME),
     observerPid: observer.isRunning(MIO_HOME) ? observer.readPid(MIO_HOME) : null,
   }
@@ -78,7 +79,8 @@ function statusCommand(useJson) {
   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 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'}`)
 }

package/observe/observer.js

@@ -5,7 +5,7 @@ const fs = require('fs')
 const path = require('path')
 const os = require('os')
 const crypto = require('crypto')
-const { spawn } = require('child_process')
+const { spawn, spawnSync } = require('child_process')
 
 const INTERVAL_MS = 3000
 // A WorkBuddy turn is considered finished when its transcript file has not
@@ -78,6 +78,11 @@ function loadState(home) {
         codexFiles: parsed.codexFiles || {},
         codexBuffers: parsed.codexBuffers || {},
         codexTurns: parsed.codexTurns || {},
+        ocSeeded: parsed.ocSeeded || false,
+        ocLastRowid: parsed.ocLastRowid || 0,
+        ocDbMtime: parsed.ocDbMtime || null,
+        ocPending: parsed.ocPending || false,
+        ocTurns: parsed.ocTurns || {},
       }
     }
   } catch (_) {}
@@ -90,6 +95,11 @@ function loadState(home) {
     codexFiles: {},
     codexBuffers: {},
     codexTurns: {},
+    ocSeeded: false,
+    ocLastRowid: 0,
+    ocDbMtime: null,
+    ocPending: false,
+    ocTurns: {},
   }
 }
 
@@ -552,6 +562,327 @@ function runCodexCycle(home, state, sinks, opts) {
   return out
 }
 
+// ---------------------------------------------------------------------------
+// OpenCode session observation (passive, via `opencode db`)
+// ---------------------------------------------------------------------------
+
+// OpenCode stores everything in ~/.local/share/opencode/opencode.db (SQLite).
+// On Windows the db file is held with an exclusive lock while OpenCode runs,
+// so we cannot open it with node:sqlite directly. Instead we shell out to the
+// `opencode db` CLI, which opens the same database through the app itself and
+// works even while OpenCode is running. We tail `part` rows by rowid so each
+// session is scanned incrementally and only text/tool parts are transferred.
+
+function opencodeDataDir() {
+  return (
+    process.env.OPENCODE_DATA_DIR ||
+    path.join(os.homedir(), '.local', 'share', 'opencode')
+  )
+}
+
+function opencodeDbPath() {
+  return path.join(opencodeDataDir(), 'opencode.db')
+}
+
+function findOpencodeBin() {
+  if (process.env.OPENCODE_BIN && fs.existsSync(process.env.OPENCODE_BIN)) {
+    return process.env.OPENCODE_BIN
+  }
+  const exeDir = path.dirname(process.execPath)
+  const candidates = [
+    path.join(exeDir, 'node_modules', 'opencode-ai', 'bin', 'opencode.exe'),
+    path.join(exeDir, '..', 'node_modules', 'opencode-ai', 'bin', 'opencode.exe'),
+    path.join(exeDir, '..', '..', 'node_modules', 'opencode-ai', 'bin', 'opencode.exe'),
+  ]
+  for (const c of candidates) {
+    const resolved = path.resolve(c)
+    if (fs.existsSync(resolved)) return resolved
+  }
+  return null
+}
+
+function runOpencodeQuery(sql) {
+  const bin = findOpencodeBin()
+  const args = ['db', sql, '--format', 'json']
+  let res
+  try {
+    res = bin
+      ? spawnSync(bin, args, { encoding: 'utf8', timeout: 90000, windowsHide: true, maxBuffer: 256 * 1024 * 1024 })
+      : spawnSync('opencode', args, { encoding: 'utf8', timeout: 90000, shell: true, maxBuffer: 256 * 1024 * 1024 })
+  } catch (_) {
+    return null
+  }
+  if (res.error || res.status !== 0 || !res.stdout) return null
+  try {
+    return JSON.parse(res.stdout)
+  } catch (_) {
+    return null
+  }
+}
+
+// Only transfer text and tool parts; skip reasoning/step bookkeeping rows to
+// keep the transferred payload small.
+const OPENCODE_PART_FILTER = " AND (p.data LIKE '%\"type\":\"text\"%' OR p.data LIKE '%\"type\":\"tool\"%')"
+
+function createOpencodeTurn(meta) {
+  meta = meta || {}
+  return {
+    id: null,
+    ts: null,
+    sessionId: meta.sessionId || null,
+    cwd: meta.directory || null,
+    project: meta.directory ? path.basename(meta.directory) : 'unknown',
+    agent: meta.agent || null,
+    title: meta.title || null,
+    lastMid: null,
+    lastText: null,
+    toolCount: 0,
+    errors: [],
+    pendingTerminal: null,
+    done: false,
+  }
+}
+
+function opencodeOutcomeFor(finish) {
+  if (finish === 'error') return 'failure'
+  if (finish === 'cancel' || finish === 'aborted' || finish === 'interrupted') return 'aborted'
+  return 'success'
+}
+
+function finalizeOpencodeTurn(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: turn.errors.slice(),
+    outcome: outcome,
+  }
+  turn.done = true
+  return finalized
+}
+
+function applyOpencodeAssistantPart(turn, pd, md, row) {
+  if (pd.type === 'text' && typeof pd.text === 'string' && pd.text.trim()) {
+    turn.lastText = pd.text
+  } else if (pd.type === 'tool') {
+    turn.toolCount += 1
+    const status = pd.state && pd.state.status
+    if (status && status !== 'completed' && status !== 'ok' && status !== 'success' && status !== 'running') {
+      turn.errors.push({ tool: pd.tool || 'unknown', status: status })
+      if (turn.errors.length > 20) turn.errors.shift()
+    }
+  }
+  if (md.finish && md.finish !== 'tool-calls') {
+    turn.pendingTerminal = md.finish
+  }
+  turn.lastMid = row.mid
+}
+
+function feedOpencodePart(turn, row) {
+  let pd
+  let md
+  try {
+    pd = JSON.parse(row.pd)
+  } catch (_) {
+    pd = null
+  }
+  try {
+    md = JSON.parse(row.md)
+  } catch (_) {
+    md = null
+  }
+  if (!pd || !md) return { next: turn }
+
+  // A user message starts a new turn; any unfinished previous turn is aborted.
+  if (md.role === 'user') {
+    let finalized = null
+    if (turn.id && !turn.done) {
+      finalized = finalizeOpencodeTurn(turn, turn.pendingTerminal ? opencodeOutcomeFor(turn.pendingTerminal) : 'aborted')
+    }
+    const next = createOpencodeTurn({
+      sessionId: row.sid,
+      directory: row.sdir,
+      title: row.stitle,
+      agent: row.sagent,
+    })
+    next.id = row.mid
+    next.ts = Number(row.t) || Date.now()
+    next.lastMid = row.mid
+    return { finalized, next }
+  }
+
+  if (turn.done) return { next: turn }
+
+  // Message boundary after a terminal finish closes the previous turn.
+  if (turn.lastMid && row.mid !== turn.lastMid && turn.pendingTerminal) {
+    const finalized = finalizeOpencodeTurn(turn, opencodeOutcomeFor(turn.pendingTerminal))
+    const next = createOpencodeTurn({
+      sessionId: row.sid,
+      directory: row.sdir,
+      title: row.stitle,
+      agent: row.sagent,
+    })
+    applyOpencodeAssistantPart(next, pd, md, row)
+    return { finalized, next }
+  }
+
+  applyOpencodeAssistantPart(turn, pd, md, row)
+  return { next: turn }
+}
+
+function emitOpencodeOutcome(turn, sinks, state) {
+  if (!turn.id) return false
+  const summary = cleanText(turn.lastText)
+  if (!summary) return false
+  const outcome = turn.outcome
+  const turnToken = String(turn.id).slice(0, 8)
+  const tsToken = turn.ts ? Math.floor(turn.ts / 1000) : Math.floor(Date.now() / 1000)
+
+  sinks.trace({
+    trace_id: 'opencode:' + (turn.sessionId || 'unknown') + ':' + turnToken + ':' + tsToken,
+    event_type: 'task_outcome',
+    outcome: outcome,
+    payload: {
+      host: 'opencode',
+      project: turn.project,
+      sessionId: turn.sessionId,
+      turnId: turn.id,
+      title: turn.title,
+      agent: turn.agent,
+      toolCalls: turn.toolCount,
+      errors: turn.errors.length,
+      summary: summary.slice(0, 300),
+      source: 'opencode-observer',
+    },
+    agent: 'opencode',
+    host: 'opencode',
+    project: turn.project,
+  })
+
+  if (outcome === 'success' && summary.length >= 10) {
+    sinks.memory({
+      kind: 'note',
+      content: '[opencode] 任务完成: ' + summary.slice(0, 160),
+      tags: ['task-outcome', 'opencode', turn.project],
+      project: turn.project,
+      source: 'opencode-observer',
+    })
+    var ctxTime = new Date(Number(turn.ts) || Date.now()).toLocaleString('zh-CN', { hour12: false })
+    updateProjectContext(state, turn.cwd, ctxTime + ' | ' + outcome + ' | ' + summary.slice(0, 80))
+  }
+
+  for (const err of turn.errors) {
+    sinks.trace({
+      trace_id: 'opencode:' + (turn.sessionId || 'unknown') + ':' + turnToken + ':' + String(err.tool || 'err').slice(0, 12),
+      event_type: 'error',
+      outcome: 'error',
+      payload: {
+        host: 'opencode',
+        project: turn.project,
+        sessionId: turn.sessionId,
+        turnId: turn.id,
+        tool: err.tool,
+        status: err.status,
+      },
+      agent: 'opencode',
+      host: 'opencode',
+      project: turn.project,
+    })
+  }
+  return true
+}
+
+function runOpencodeCycle(home, state, sinks, opts) {
+  const out = { files: 0, lines: 0, outcomes: 0 }
+  const db = opencodeDbPath()
+  if (!fs.existsSync(db)) return out
+  let st
+  try {
+    st = fs.statSync(db)
+  } catch (_) {
+    return out
+  }
+  out.files = 1
+  const maxAgeMs = (opts && opts.maxAgeMs) || 24 * 60 * 60 * 1000
+
+  // First run: seed the rowid cursor to the first part written within the
+  // backfill window so ancient history never floods MIO_HOME.
+  if (!state.ocSeeded) {
+    const ts = Date.now() - maxAgeMs
+    const first = runOpencodeQuery('SELECT rowid FROM part WHERE time_created >= ' + ts + ' ORDER BY rowid LIMIT 1')
+    let rid = 0
+    if (Array.isArray(first) && first.length > 0) {
+      rid = Number(first[0].rowid) || 0
+    } else {
+      const maxRow = runOpencodeQuery('SELECT COALESCE(MAX(rowid), 0) AS rid FROM part')
+      if (Array.isArray(maxRow) && maxRow.length > 0) rid = Number(maxRow[0].rid) || 0
+    }
+    state.ocLastRowid = rid
+    state.ocSeeded = true
+    state.ocDbMtime = st.mtimeMs
+    state.ocPending = true
+    return out
+  }
+
+  const changed = state.ocDbMtime === null || state.ocDbMtime !== st.mtimeMs
+  if (!changed && !state.ocPending) return out
+
+  const limit = 1500
+  const sql =
+    'SELECT p.rowid AS rid, p.session_id AS sid, p.message_id AS mid, p.time_created AS t, ' +
+    'p.data AS pd, m.data AS md, s.directory AS sdir, s.title AS stitle, s.agent AS sagent ' +
+    'FROM part p JOIN message m ON m.id = p.message_id JOIN session s ON s.id = p.session_id ' +
+    'WHERE p.rowid > ' + state.ocLastRowid + OPENCODE_PART_FILTER +
+    ' ORDER BY p.rowid LIMIT ' + limit
+  const rows = runOpencodeQuery(sql)
+  if (!Array.isArray(rows)) return out
+  state.ocDbMtime = st.mtimeMs
+  if (rows.length === 0) {
+    state.ocPending = false
+    return out
+  }
+
+  let lastRid = state.ocLastRowid
+  for (const row of rows) {
+    const rid = Number(row.rid)
+    if (rid > lastRid) lastRid = rid
+    out.lines += 1
+    const sid = row.sid
+    let turn = state.ocTurns[sid]
+    if (!turn) {
+      turn = createOpencodeTurn({ sessionId: sid, directory: row.sdir, title: row.stitle, agent: row.sagent })
+      state.ocTurns[sid] = turn
+    }
+    const result = feedOpencodePart(turn, row)
+    if (result.finalized) {
+      if (emitOpencodeOutcome(result.finalized, sinks, state)) out.outcomes += 1
+    }
+    state.ocTurns[sid] = result.next
+  }
+  state.ocLastRowid = lastRid
+  state.ocPending = rows.length >= limit
+
+  // Caught up: any turn holding a terminal finish is complete.
+  if (!state.ocPending) {
+    for (const sid of Object.keys(state.ocTurns)) {
+      const turn = state.ocTurns[sid]
+      if (turn && turn.id && turn.pendingTerminal && !turn.done) {
+        const finalized = finalizeOpencodeTurn(turn, opencodeOutcomeFor(turn.pendingTerminal))
+        if (finalized && emitOpencodeOutcome(finalized, sinks, state)) out.outcomes += 1
+        state.ocTurns[sid] = createOpencodeTurn({ sessionId: sid, directory: turn.cwd, title: turn.title, agent: turn.agent })
+      }
+    }
+  }
+  return out
+}
+
 // ---------------------------------------------------------------------------
 // cycle
 // ---------------------------------------------------------------------------
@@ -634,6 +965,11 @@ function runCycle(home, state, sinks, opts) {
   out.lines += codexRes.lines
   out.outcomes += codexRes.outcomes
 
+  const ocRes = runOpencodeCycle(home, state, sinks, opts)
+  out.files += ocRes.files
+  out.lines += ocRes.lines
+  out.outcomes += ocRes.outcomes
+
   saveState(home, state)
   return out
 }
@@ -721,6 +1057,8 @@ module.exports = {
   saveState,
   updateProjectContext,
   runCycle,
+  opencodeDbPath,
+  runOpencodeCycle,
   createSinks,
   startForeground,
   startBackground,

package/package.json

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