mio-agent-runtime 0.2.2 → 0.2.3

package/README.md

@@ -1,49 +1,54 @@
-# 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 --json status           Machine-readable status
-mio --json agents           Machine-readable agents
-```
-
+# 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 --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/MEMORY.md`
   so WorkBuddy calls Mio memory/observer/policy automatically. If WorkBuddy is
-  already running, restart it once so it reloads the approval and memory files.
-
-## MIO_HOME
-
-默认 `~/.mio-intelligence`，可通过环境变量 `MIO_HOME` 覆盖。
-
-## Package layout
-
-```text
-packages/mio-cli
-├── bin/mio.js
-├── adapters/
-│   ├── codex.js
-│   ├── opencode.js
-│   └── workbuddy.js
-├── server/
-│   └── mio-intelligence-mcp/index.js
-└── package.json
-```
+  already running, restart it once so it reloads the approval and memory files.
+
+## MIO_HOME
+
+默认 `~/.mio-intelligence`，可通过环境变量 `MIO_HOME` 覆盖。
+
+## Package layout
+
+```text
+packages/mio-cli
+├── bin/mio.js
+├── adapters/
+│   ├── codex.js
+│   ├── opencode.js
+│   └── workbuddy.js
+├── server/
+│   └── mio-intelligence-mcp/index.js
+└── package.json
+```

package/adapters/codex.js

@@ -1,63 +1,62 @@
-'use strict'
-
-const fs = require('fs')
-const path = require('path')
-const os = require('os')
-
-function configPath() {
-  return path.join(os.homedir(), '.codex', 'config.toml')
-}
-
-function isInstalled() {
-  const target = configPath()
-  if (!fs.existsSync(target)) return false
-  return fs.readFileSync(target, 'utf8').includes('[mcp_servers.mio-intelligence]')
-}
-
-function install({ node, serverScript, home, workspace, project }) {
-  const target = configPath()
-  const backup = `${target}.bak-mio-${Date.now()}`
-  if (isInstalled()) {
-    return {
-      changed: false,
-      configPath: target,
-      message: 'Codex Mio MCP already installed.',
-    }
-  }
-
-  if (fs.existsSync(target)) {
-    fs.copyFileSync(target, backup)
-  }
-
-  const context = JSON.stringify({
-    agentId: 'codex',
-    project: project || path.basename(workspace || process.cwd()),
-    workspace: workspace || process.cwd(),
-    sessionId: 'codex-session',
-  })
-
-  fs.mkdirSync(path.dirname(target), { recursive: true })
-  let toml = fs.existsSync(target) ? fs.readFileSync(target, 'utf8') : ''
-  if (!toml.endsWith('\n')) toml += '\n'
-  const section = [
-    '[mcp_servers.mio-intelligence]',
-    `command = '${node}'`,
-    `args = ['${serverScript}']`,
-    'startup_timeout_sec = 30',
-    '',
-    '[mcp_servers.mio-intelligence.env]',
-    `MIO_DATA_DIR = '${home}'`,
-    `MIO_CONTEXT = '${context}'`,
-    '',
-  ].join('\n')
-  fs.writeFileSync(target, `${toml}${section}\n`, 'utf8')
-
-  return {
-    changed: true,
-    configPath: target,
-    backup,
-    message: 'Codex Mio MCP installed. Restart Codex to load it.',
-  }
-}
-
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+
+function configPath() {
+  return path.join(os.homedir(), '.codex', 'config.toml')
+}
+
+function isInstalled() {
+  const target = configPath()
+  if (!fs.existsSync(target)) return false
+  return fs.readFileSync(target, 'utf8').includes('[mcp_servers.mio-intelligence]')
+}
+
+function install({ node, serverScript, home, workspace }) {
+  const target = configPath()
+  const backup = `${target}.bak-mio-${Date.now()}`
+  if (isInstalled()) {
+    return {
+      changed: false,
+      configPath: target,
+      message: 'Codex Mio MCP already installed.',
+    }
+  }
+
+  if (fs.existsSync(target)) {
+    fs.copyFileSync(target, backup)
+  }
+
+  const context = JSON.stringify({
+    agentId: 'codex',
+    workspace: workspace || process.cwd(),
+    sessionId: 'codex-session',
+  })
+
+  fs.mkdirSync(path.dirname(target), { recursive: true })
+  let toml = fs.existsSync(target) ? fs.readFileSync(target, 'utf8') : ''
+  if (!toml.endsWith('\n')) toml += '\n'
+  const section = [
+    '[mcp_servers.mio-intelligence]',
+    `command = '${node}'`,
+    `args = ['${serverScript}']`,
+    'startup_timeout_sec = 30',
+    '',
+    '[mcp_servers.mio-intelligence.env]',
+    `MIO_DATA_DIR = '${home}'`,
+    `MIO_CONTEXT = '${context}'`,
+    '',
+  ].join('\n')
+  fs.writeFileSync(target, `${toml}${section}\n`, 'utf8')
+
+  return {
+    changed: true,
+    configPath: target,
+    backup,
+    message: 'Codex Mio MCP installed. Restart Codex to load it.',
+  }
+}
+
 module.exports = { configPath, isInstalled, install }

package/adapters/opencode.js

@@ -4,10 +4,29 @@ const fs = require('fs')
 const path = require('path')
 const os = require('os')
 
+const INSTRUCTIONS_BEGIN = '<!-- MIO_INTELLIGENCE_BEGIN -->'
+const INSTRUCTIONS_END = '<!-- MIO_INTELLIGENCE_END -->'
+const INSTRUCTIONS_BLOCK = `${INSTRUCTIONS_BEGIN}
+## Mio Intelligence Layer
+
+Mio MCP tools are available. Treat these as mandatory runtime rules for every workspace.
+
+- Before designing or implementing a solution, or when unsure about prior decisions, call \`mio-intelligence_mio_memory_query\` first. Omit \`project\` unless a specific project is required; Mio derives it from the current Git repository.
+- After a decision affecting architecture, deployment, dependencies, or long-term behavior, call \`mio-intelligence_mio_memory_record\` with \`kind\`: \`decision\`, \`context\`, \`problem\`, or \`note\`.
+- When a tool call fails, retries, or returns an error, call \`mio-intelligence_mio_observer_ingest\` with a stable \`trace_id\`, relevant \`event_type\`, \`payload\`, and \`outcome\`.
+- Before a high-risk operation such as deletion, migration, credential change, or production change, call \`mio-intelligence_mio_policy_check\` and follow its suggestion when available.
+- If Mio MCP is unavailable, do not block the task. Continue normally and note the missed memory or observation.
+- Do not store secrets, credentials, or raw sensitive content in Mio memory.
+${INSTRUCTIONS_END}`
+
 function configPath() {
   return path.join(os.homedir(), '.config', 'opencode', 'opencode.json')
 }
 
+function globalInstructionsPath() {
+  return path.join(os.homedir(), '.config', 'opencode', 'AGENTS.md')
+}
+
 function readConfig() {
   const target = configPath()
   if (!fs.existsSync(target)) return null
@@ -18,59 +37,112 @@ function readConfig() {
   }
 }
 
-function isInstalled() {
-  const config = readConfig()
-  return Boolean(config && config.mcp && config.mcp['mio-intelligence'])
+function readGlobalInstructions() {
+  const target = globalInstructionsPath()
+  if (!fs.existsSync(target)) return ''
+  try {
+    return fs.readFileSync(target, 'utf8')
+  } catch (_) {
+    return ''
+  }
 }
 
-function install({ node, serverScript, home, workspace, project }) {
-  const target = configPath()
-  if (isInstalled()) {
-    return {
-      changed: false,
-      configPath: target,
-      message: 'OpenCode Mio MCP already installed.',
-    }
+function ensureGlobalInstructions() {
+  const target = globalInstructionsPath()
+  let content = readGlobalInstructions()
+  const original = content
+  const start = content.indexOf(INSTRUCTIONS_BEGIN)
+  if (start !== -1) {
+    const end = content.indexOf(INSTRUCTIONS_END, start)
+    content = end === -1 ? content.slice(0, start) : content.slice(0, start) + content.slice(end + INSTRUCTIONS_END.length)
+    content = content.trimEnd()
+  }
+  if (content) content += '\n\n'
+  content += INSTRUCTIONS_BLOCK + '\n'
+  if (content === original) {
+    return { changed: false, target, backup: null }
   }
 
   const backup = `${target}.bak-mio-${Date.now()}`
   if (fs.existsSync(target)) {
     fs.copyFileSync(target, backup)
   }
+  fs.mkdirSync(path.dirname(target), { recursive: true })
+  fs.writeFileSync(target, content, 'utf8')
+  return { changed: true, target, backup }
+}
 
+function isInstalled() {
+  const config = readConfig()
+  if (!config || !config.mcp || !config.mcp['mio-intelligence']) return false
+  const instructions = readGlobalInstructions()
+  return instructions.includes(INSTRUCTIONS_BEGIN) && instructions.includes(INSTRUCTIONS_END)
+}
+
+function install({ node, serverScript, home, workspace, project }) {
+  const target = configPath()
   const config = readConfig() || {}
-  const existingMcp = config.mcp && typeof config.mcp === 'object' ? config.mcp : {}
-  const context = JSON.stringify({
-    agentId: 'opencode',
-    project: project || path.basename(workspace || process.cwd()),
-    workspace: workspace || process.cwd(),
-    sessionId: 'opencode-session',
-  })
-  const next = {
-    ...config,
-    mcp: {
-      ...existingMcp,
-      'mio-intelligence': {
-        enabled: true,
-        type: 'local',
-        command: [node, serverScript],
-        environment: {
-          MIO_DATA_DIR: home,
-          MIO_CONTEXT: context,
+  const configInstalled = Boolean(config.mcp && config.mcp['mio-intelligence'])
+
+  let configChanged = false
+  let backup = null
+
+  if (!configInstalled) {
+    backup = `${target}.bak-mio-${Date.now()}`
+    if (fs.existsSync(target)) {
+      fs.copyFileSync(target, backup)
+    }
+
+    const existingMcp = config.mcp && typeof config.mcp === 'object' ? config.mcp : {}
+    const context = JSON.stringify({
+      agentId: 'opencode',
+      project: project || path.basename(workspace || process.cwd()),
+      workspace: workspace || process.cwd(),
+      sessionId: 'opencode-session',
+    })
+    const next = {
+      ...config,
+      mcp: {
+        ...existingMcp,
+        'mio-intelligence': {
+          enabled: true,
+          type: 'local',
+          command: [node, serverScript],
+          environment: {
+            MIO_DATA_DIR: home,
+            MIO_CONTEXT: context,
+          },
         },
       },
-    },
+    }
+
+    fs.mkdirSync(path.dirname(target), { recursive: true })
+    fs.writeFileSync(target, `${JSON.stringify(next, null, 2)}\n`, 'utf8')
+    configChanged = true
   }
 
-  fs.mkdirSync(path.dirname(target), { recursive: true })
-  fs.writeFileSync(target, `${JSON.stringify(next, null, 2)}\n`, 'utf8')
+  const instructionsResult = ensureGlobalInstructions()
+  const changed = configChanged || instructionsResult.changed
+
+  let message
+  if (configChanged && instructionsResult.changed) {
+    message = 'OpenCode Mio MCP installed and global Mio rules injected into AGENTS.md. Restart OpenCode to load them.'
+  } else if (instructionsResult.changed) {
+    message = 'OpenCode Mio MCP already installed. Injected global Mio rules into AGENTS.md. Restart OpenCode to load them.'
+  } else {
+    message = 'OpenCode Mio MCP already installed.'
+  }
 
   return {
-    changed: true,
+    changed,
     configPath: target,
+    globalInstructionsPath: instructionsResult.target,
+    configChanged,
+    instructionsChanged: instructionsResult.changed,
     backup,
-    message: 'OpenCode Mio MCP installed. Restart OpenCode to load it.',
+    backupInstructions: instructionsResult.backup,
+    message,
   }
 }
 
-module.exports = { configPath, isInstalled, install }
+module.exports = { configPath, globalInstructionsPath, isInstalled, install }

package/adapters/workbuddy.js

@@ -1,174 +1,14 @@
-'use strict'
-
-const fs = require('fs')
-const path = require('path')
-const os = require('os')
-const crypto = require('crypto')
-
-function configDir() {
-  return (
-    process.env.WORKBUDDY_CONFIG_DIR ||
-    process.env.CODEBUDDY_CONFIG_DIR ||
-    path.join(os.homedir(), '.workbuddy')
-  )
-}
-
-function configPath() {
-  return path.join(configDir(), 'mcp.json')
-}
-
-function legacyConfigPath() {
-  return path.join(configDir(), '.mcp.json')
-}
-
-function approvalsPath() {
-  return path.join(configDir(), 'mcp-approvals.json')
-}
-
-function memoryPath() {
-  return path.join(configDir(), 'MEMORY.md')
-}
-
-function readJson(file) {
-  if (!fs.existsSync(file)) return null
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'))
-  } catch (_) {
-    return null
-  }
-}
-
-
-const MEMORY_BEGIN = '<!-- MIO_INTELLIGENCE_BEGIN -->'
-const MEMORY_END = '<!-- MIO_INTELLIGENCE_END -->'
-const MEMORY_BLOCK = `${MEMORY_BEGIN}
-## Mio Intelligence Layer
-
-Mio MCP tools are available. Treat these as mandatory runtime rules for every workspace.
-
-- Before designing or implementing a solution, or when unsure about prior decisions, call \`mcp__mio-intelligence__mio.memory.query\` first. Omit \`project\` unless a specific project is required; Mio derives it from the current Git repository.
-- After a decision affecting architecture, deployment, dependencies, or long-term behavior, call \`mcp__mio-intelligence__mio.memory.record\` with \`kind\`: \`decision\`, \`context\`, \`problem\`, or \`note\`.
-- When a tool call fails, retries, or returns an error, call \`mcp__mio-intelligence__mio.observer.ingest\` with a stable \`trace_id\`, relevant \`event_type\`, \`payload\`, and \`outcome\`.
-- Before a high-risk operation such as deletion, migration, credential change, or production change, call \`mcp__mio-intelligence__mio.policy.check\` and follow its suggestion when available.
-- If Mio MCP is unavailable, do not block the task. Continue normally and note the missed memory or observation.
-- Do not store secrets, credentials, or raw sensitive content in Mio memory.
-${MEMORY_END}`
-
-function ensureMemoryRules() {
-  const target = memoryPath()
-  let content = fs.existsSync(target) ? fs.readFileSync(target, 'utf8') : ''
-  const start = content.indexOf(MEMORY_BEGIN)
-  if (start !== -1) {
-    const end = content.indexOf(MEMORY_END, start)
-    content = end === -1 ? content.slice(0, start) : content.slice(0, start) + content.slice(end + MEMORY_END.length)
-    content = content.trimEnd()
-  }
-  const before = content
-  if (content) content += '\n\n'
-  content += MEMORY_BLOCK + '\n'
-  if (content === before) return false
-  fs.mkdirSync(path.dirname(target), { recursive: true })
-  fs.writeFileSync(target, content, 'utf8')
-  return true
-}
-
-function isInstalled() {
-  const config = readJson(configPath())
-  const entry = config && config.mcpServers && config.mcpServers['mio-intelligence']
-  if (!entry) return false
-
-  const approvals = readJson(approvalsPath()) || {}
-  const memory = fs.existsSync(memoryPath()) ? fs.readFileSync(memoryPath(), 'utf8') : ''
-  return Boolean(
-    approvals[approvalKey('mio-intelligence', entry)] &&
-    memory.includes(MEMORY_BEGIN) &&
-    memory.includes(MEMORY_END)
-  )
-}
-
-function approvalKey(name, entry) {
-  let input
-  if (entry.command) {
-    input = `${entry.command || ''}|${(entry.args || []).map(String).sort().join(',')}|${Object.keys(entry.env || {}).sort().join(',')}`
-  } else if (entry.url) {
-    try {
-      input = new URL(entry.url).origin
-    } catch (_) {
-      input = entry.url
-    }
-  } else {
-    input = JSON.stringify(entry)
-  }
-
-  const hash = crypto.createHash('sha256').update(input).digest('hex')
-  return `${hash}::${name}`
-}
-
-function writeApproval(name, entry) {
-  const target = approvalsPath()
-  const approvals = readJson(target) || {}
-  approvals[approvalKey(name, entry)] = Date.now()
-  fs.mkdirSync(path.dirname(target), { recursive: true })
-  fs.writeFileSync(target, `${JSON.stringify(approvals, null, 2)}\n`, 'utf8')
-}
-
-function install({ node, serverScript, home, workspace, project }) {
-  const target = configPath()
-  const canonical = readJson(target) || {}
-  const legacy = readJson(legacyConfigPath()) || {}
-  const canonicalServers =
-    canonical.mcpServers && typeof canonical.mcpServers === 'object' ? canonical.mcpServers : {}
-  const legacyServers =
-    legacy.mcpServers && typeof legacy.mcpServers === 'object' ? legacy.mcpServers : {}
-
-  const config = {
-    ...legacy,
-    ...canonical,
-    mcpServers: {
-      ...legacyServers,
-      ...canonicalServers,
-    },
-  }
-
-  const context = JSON.stringify({
-    agentId: 'workbuddy',
-    project: project || path.basename(workspace || process.cwd()),
-    workspace: workspace || process.cwd(),
-    sessionId: 'workbuddy-session',
-  })
-
-  config.mcpServers = {
-    ...config.mcpServers,
-    'mio-intelligence': {
-      command: node,
-      args: [serverScript],
-      env: {
-        MIO_DATA_DIR: home,
-        MIO_CONTEXT: context,
-      },
-    },
-  }
-
-  writeApproval('mio-intelligence', config.mcpServers['mio-intelligence'])
-  const memoryChanged = ensureMemoryRules()
-
-  const backup = `${target}.bak-mio-${Date.now()}`
-  if (fs.existsSync(target)) {
-    fs.copyFileSync(target, backup)
-  }
-
-  fs.mkdirSync(path.dirname(target), { recursive: true })
-  fs.writeFileSync(target, `${JSON.stringify(config, null, 2)}\n`, 'utf8')
-
-  return {
-    changed: true,
-    configPath: target,
-    approvalsPath: approvalsPath(),
-    memoryPath: memoryPath(),
-    memoryChanged,
-    backup,
-    message: 'WorkBuddy Mio MCP installed, approved, and auto-memory rules injected. WorkBuddy should auto-load it; restart if it was already running.',
-  }
-}
-
-module.exports = { configDir, configPath, approvalsPath, memoryPath, approvalKey, isInstalled, install }
+'use strict'
+
+function isInstalled() {
+  return false
+}
+
+function install() {
+  return {
+    changed: false,
+    message: 'WorkBuddy adapter is not implemented yet.',
+  }
+}
+
+module.exports = { isInstalled, install }

package/bin/mio.js

@@ -1,74 +1,56 @@
-#!/usr/bin/env node
-'use strict'
-
-const fs = require('fs')
-const path = require('path')
-const os = require('os')
-const { execFileSync } = require('child_process')
-
-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'),
-}
-
-function projectFromWorkspace(workspace) {
-  try {
-    const commonDir = execFileSync(
-      'git',
-      ['-C', workspace, 'rev-parse', '--path-format=absolute', '--git-common-dir'],
-      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }
-    ).trim()
-    if (commonDir) {
-      const name = path.basename(path.dirname(commonDir))
-      if (name) return name
-    }
-  } catch (_) {
-    // fall through to workspace basename
-  }
-  return path.basename(workspace)
-}
-
-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}`)
-}
-
+#!/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'),
+}
+
+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 = {
@@ -86,121 +68,120 @@ function statusCommand(useJson) {
     opencodeInstalled: installed.opencode,
     workbuddyInstalled: installed.workbuddy,
   }
-  if (useJson) {
-    jsonOrText(payload, true)
-    return
-  }
+  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(`WorkBuddy MCP: ${installed.workbuddy ? 'installed' : 'not installed'}`)
 }
-
-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(),
-      project: projectFromWorkspace(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)
-  }
-  if (useJson) {
-    jsonOrText(result, true)
-    return
-  }
-  console.log(result.message || `${host} adapter completed.`)
-}
-
-function mcpCommand() {
-  require(SERVER_SCRIPT)
-}
-
-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 --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 'help':
-    case '--help':
-      return help()
-    default:
-      console.error(`Unknown command: ${command}`)
-      help()
-      process.exitCode = 1
-  }
-}
-
-main()
+
+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)
+  }
+  if (useJson) {
+    jsonOrText(result, true)
+    return
+  }
+  console.log(result.message || `${host} adapter completed.`)
+}
+
+function mcpCommand() {
+  require(SERVER_SCRIPT)
+}
+
+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 --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 'help':
+    case '--help':
+      return help()
+    default:
+      console.error(`Unknown command: ${command}`)
+      help()
+      process.exitCode = 1
+  }
+}
+
+main()

package/package.json

@@ -1,23 +1,23 @@
-{
-  "name": "mio-agent-runtime",
-  "version": "0.2.2",
-  "description": "Mio Agent Runtime installer and MCP intelligence layer",
-  "license": "MIT",
-  "type": "commonjs",
-  "bin": {
-    "mio": "bin/mio.js"
-  },
-  "files": [
-    "bin/",
-    "server/",
-    "adapters/",
-    "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",
-    "prepack": "npm run check"
-  },
-  "engines": {
-    "node": ">=18"
-  }
+{
+  "name": "mio-agent-runtime",
+  "version": "0.2.3",
+  "description": "Mio Agent Runtime installer and MCP intelligence layer",
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": {
+    "mio": "bin/mio.js"
+  },
+  "files": [
+    "bin/",
+    "server/",
+    "adapters/",
+    "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",
+    "prepack": "npm run check"
+  },
+  "engines": {
+    "node": ">=18"
+  }
 }