mio-agent-runtime 0.5.17 → 0.5.22

package/observe/observer.js

@@ -86,6 +86,9 @@ function loadState(home) {
         hmSeeded: parsed.hmSeeded || false,
         hmLastMsgId: parsed.hmLastMsgId || 0,
         hmTurns: parsed.hmTurns || {},
+        clFiles: parsed.clFiles || {},
+        clBuffers: parsed.clBuffers || {},
+        clTurns: parsed.clTurns || {},
       }
     }
   } catch (_) {}
@@ -106,6 +109,9 @@ function loadState(home) {
     hmSeeded: false,
     hmLastMsgId: 0,
     hmTurns: {},
+    clFiles: {},
+    clBuffers: {},
+    clTurns: {},
   }
 }
 
@@ -282,9 +288,9 @@ const CONTEXT_MAX = 6
 // Maintain a compact 'recent Mio context' block inside <workspace>/AGENTS.md,
 // which WorkBuddy's MemoryLoader auto-injects into every session. This makes
 // retrieval guaranteed (not dependent on the model deciding to read memory).
-function updateProjectContext(state, cwd, line) {
+function updateProjectContext(state, cwd, line, targetFile) {
   if (!cwd || !line) return
-  const target = path.join(cwd, 'AGENTS.md')
+  const target = path.join(cwd, targetFile || 'AGENTS.md')
   const list = state.contexts[cwd] || []
   list.unshift(line)
   if (list.length > CONTEXT_MAX) list.pop()
@@ -1133,6 +1139,275 @@ function runHermesCycle(home, state, sinks, opts) {
 }
 
 
+// ---------------------------------------------------------------------------
+// Claude Code session observation (passive, transcript JSONL tailing)
+// ---------------------------------------------------------------------------
+
+// Claude Code writes append-only JSONL transcripts under
+// <configDir>/projects/<munged-cwd>/<sessionId>.jsonl. Each line carries
+// {type, message:{role, content}, cwd, sessionId, timestamp, uuid, ...}.
+// Assistant content items are text/thinking/tool_use; tool results come back
+// as user lines whose content array holds tool_result items with is_error.
+// A user prompt line (string content or a text item) closes the previous
+// turn; sidechain lines (subagent transcripts) are skipped as noise.
+
+function claudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude')
+}
+
+function claudeProjectsDir() {
+  return path.join(claudeConfigDir(), 'projects')
+}
+
+function listClaudeTranscripts() {
+  const root = claudeProjectsDir()
+  const out = []
+  if (!fs.existsSync(root)) return out
+  const walk = (dir) => {
+    let entries
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true })
+    } catch (_) {
+      return
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) walk(full)
+      else if (entry.isFile() && entry.name.endsWith('.jsonl')) out.push(full)
+    }
+  }
+  walk(root)
+  return out
+}
+
+function createClaudeTurn(meta) {
+  meta = meta || {}
+  return {
+    id: null,
+    ts: null,
+    sessionId: meta.sessionId || null,
+    cwd: meta.cwd || null,
+    project: meta.cwd ? path.basename(meta.cwd) : 'unknown',
+    lastText: null,
+    toolCount: 0,
+    errors: [],
+    apiError: false,
+  }
+}
+
+function claudeContentItems(obj) {
+  const content = obj && obj.message && obj.message.content
+  if (typeof content === 'string') return [{ type: 'text', text: content }]
+  return Array.isArray(content) ? content.filter(Boolean) : []
+}
+
+function finishClaudeTurn(turn, outcome) {
+  return {
+    id: turn.id,
+    ts: turn.ts,
+    sessionId: turn.sessionId,
+    cwd: turn.cwd,
+    project: turn.project,
+    lastText: turn.lastText,
+    toolCount: turn.toolCount,
+    errors: turn.errors.slice(),
+    apiError: turn.apiError,
+    outcome: outcome,
+  }
+}
+
+function feedClaudeLine(turn, obj) {
+  if (!obj || typeof obj !== 'object') return { next: turn }
+  // Subagent (sidechain) transcripts duplicate main-thread work; skip them.
+  if (obj.isSidechain === true) return { next: turn }
+  if (obj.sessionId) turn.sessionId = obj.sessionId
+  if (obj.cwd) {
+    turn.cwd = obj.cwd
+    turn.project = path.basename(obj.cwd)
+  }
+
+  if (obj.type === 'user') {
+    const items = claudeContentItems(obj)
+    let hasToolError = false
+    for (const item of items) {
+      if (item.type === 'tool_result' && item.is_error) {
+        turn.errors.push({ toolUseId: item.tool_use_id || 'unknown' })
+        hasToolError = true
+      }
+    }
+    if (turn.errors.length > 20) turn.errors.splice(0, turn.errors.length - 20)
+
+    // tool_result-only user lines continue the current turn; a string content
+    // or text item means a fresh prompt, which closes the previous turn.
+    const isPrompt =
+      typeof (obj.message && obj.message.content) === 'string' ||
+      items.some((item) => item.type === 'text')
+    if (isPrompt) {
+      let finalized = null
+      if (turn.id) {
+        finalized = finishClaudeTurn(turn, turn.apiError ? 'failure' : turn.lastText ? 'success' : 'aborted')
+      }
+      const next = createClaudeTurn({ sessionId: turn.sessionId, cwd: turn.cwd })
+      next.id = obj.uuid || null
+      next.ts = obj.timestamp ? Date.parse(obj.timestamp) || Date.now() : Date.now()
+      return { finalized, next }
+    }
+    return { next: turn }
+  }
+
+  if (obj.type === 'assistant') {
+    for (const item of claudeContentItems(obj)) {
+      if (item.type === 'text' && typeof item.text === 'string' && item.text.trim()) {
+        turn.lastText = item.text
+      } else if (item.type === 'tool_use') {
+        turn.toolCount += 1
+      }
+    }
+    if (obj.isApiErrorMessage === true || obj.error) turn.apiError = true
+    const ts = obj.timestamp ? Date.parse(obj.timestamp) : NaN
+    if (Number.isFinite(ts)) turn.ts = ts
+    return { next: turn }
+  }
+
+  return { next: turn }
+}
+
+function emitClaudeOutcome(turn, sinks, state) {
+  if (!turn.id) return false
+  const summary = cleanText(turn.lastText)
+  if (!summary && !turn.apiError) return false
+  const outcome = turn.apiError && turn.outcome !== 'failure' ? 'failure' : 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: 'claude:' + (turn.sessionId || 'unknown') + ':' + turnToken + ':' + tsToken,
+    event_type: 'task_outcome',
+    outcome: outcome,
+    payload: {
+      host: 'claude-code',
+      project: turn.project,
+      sessionId: turn.sessionId,
+      turnId: turn.id,
+      toolCalls: turn.toolCount,
+      errors: turn.errors.length,
+      summary: summary.slice(0, 300),
+      source: 'claude-observer',
+    },
+    agent: 'claude-code',
+    host: 'claude-code',
+    project: turn.project,
+  })
+
+  if (outcome === 'success' && summary.length >= 10) {
+    sinks.memory({
+      kind: 'note',
+      content: '[claude-code] 任务完成: ' + summary.slice(0, 160),
+      tags: ['task-outcome', 'claude-code', turn.project],
+      project: turn.project,
+      source: 'claude-observer',
+    })
+    // Claude Code auto-loads <workspace>/CLAUDE.md, so write the context
+    // block there instead of AGENTS.md.
+    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), 'CLAUDE.md')
+    }
+  }
+
+  for (const err of turn.errors) {
+    sinks.trace({
+      trace_id: 'claude:' + (turn.sessionId || 'unknown') + ':' + turnToken + ':' + String(err.toolUseId || 'err').slice(0, 12),
+      event_type: 'error',
+      outcome: 'error',
+      payload: {
+        host: 'claude-code',
+        project: turn.project,
+        sessionId: turn.sessionId,
+        turnId: turn.id,
+        toolUseId: err.toolUseId,
+      },
+      agent: 'claude-code',
+      host: 'claude-code',
+      project: turn.project,
+    })
+  }
+  return true
+}
+
+function runClaudeCycle(home, state, sinks, opts) {
+  const out = { files: 0, lines: 0, outcomes: 0 }
+  const files = listClaudeTranscripts()
+  const now = Date.now()
+  const maxAgeMs = (opts && opts.maxAgeMs) || 24 * 60 * 60 * 1000
+
+  for (const file of files) {
+    out.files += 1
+    let st
+    try {
+      st = fs.statSync(file)
+    } catch (_) {
+      continue
+    }
+    const info = state.clFiles[file] || { size: 0 }
+    if (!state.clFiles[file] && now - st.mtimeMs > maxAgeMs) continue
+    const size = st.size
+    if (size < info.size) {
+      info.size = 0
+      state.clBuffers[file] = ''
+    }
+
+    let turn = state.clTurns[file] || createClaudeTurn()
+
+    if (size > info.size) {
+      let chunk = ''
+      try {
+        const fd = fs.openSync(file, 'r')
+        const buf = Buffer.alloc(size - info.size)
+        fs.readSync(fd, buf, 0, buf.length, info.size)
+        fs.closeSync(fd)
+        chunk = buf.toString('utf8')
+      } catch (_) {
+        continue
+      }
+      const pending = (state.clBuffers[file] || '') + chunk
+      const lines = pending.split(/\r?\n/)
+      state.clBuffers[file] = lines.pop()
+      for (const line of lines) {
+        if (!line.trim()) continue
+        out.lines += 1
+        let obj
+        try {
+          obj = JSON.parse(line)
+        } catch (_) {
+          continue
+        }
+        const result = feedClaudeLine(turn, obj)
+        turn = result.next
+        if (result.finalized) {
+          if (emitClaudeOutcome(result.finalized, sinks, state)) out.outcomes += 1
+        }
+      }
+      state.clFiles[file] = { size: size, mtimeMs: st.mtimeMs }
+    }
+
+    // Idle finalize: the session has answered but no new prompt arrived yet.
+    if (turn.id && turn.lastText && now - st.mtimeMs > IDLE_MS) {
+      if (emitClaudeOutcome(finishClaudeTurn(turn, turn.apiError ? 'failure' : 'success'), sinks, state)) {
+        out.outcomes += 1
+      }
+      state.clTurns[file] = null
+    } else if (turn.id) {
+      state.clTurns[file] = turn
+    } else {
+      state.clTurns[file] = null
+    }
+  }
+
+  return out
+}
+
+
 // ---------------------------------------------------------------------------
 // cycle
 // ---------------------------------------------------------------------------
@@ -1225,6 +1500,11 @@ function runCycle(home, state, sinks, opts) {
   out.lines += hmRes.lines
   out.outcomes += hmRes.outcomes
 
+  const clRes = runClaudeCycle(home, state, sinks, opts)
+  out.files += clRes.files
+  out.lines += clRes.lines
+  out.outcomes += clRes.outcomes
+
   saveState(home, state)
   return out
 }
@@ -1317,6 +1597,10 @@ module.exports = {
   runOpencodeCycle,
   runHermesCycle,
   hermesDbPath,
+  claudeProjectsDir,
+  runClaudeCycle,
+  createClaudeTurn,
+  feedClaudeLine,
   createSinks,
   startForeground,
   startBackground,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.5.17",
+  "version": "0.5.22",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",
@@ -17,7 +17,7 @@
     "!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 server/runtime-modules.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",
+    "check": "node --check bin/mio.js && node --check adapters/host-utils.js && node --check adapters/codex.js && node --check adapters/opencode.js && node --check adapters/workbuddy.js && node --check adapters/hermes.js && node --check adapters/claude-code.js && node --check server/runtime-modules.js && node --check server/memory-store.js && node --check server/retention.js && node --check server/digest.js && node --check server/host-capabilities.js && node --check server/evolution-cutover.js && node --check server/mio-intelligence-mcp/index.js && node --check server/mio-intelligence-mcp/phase0.js && node --check observe/observer.js && node --check scripts/verify-packed-runtime.js",
     "prepack": "npm run check",
     "verify:pack-install": "node scripts/verify-packed-runtime.js"
   },

package/server/digest.js

@@ -0,0 +1,266 @@
+'use strict'
+
+// Digest: turn the accumulated MIO_HOME data (traces, memory, reuse evidence)
+// into an actionable report. Deterministic aggregation only — no LLM. The
+// report answers: what got done, where the errors are, which agent performs
+// best, and what deserves attention next.
+
+const fs = require('fs')
+const path = require('path')
+
+function readJsonl(file) {
+  if (!fs.existsSync(file)) return []
+  return fs
+    .readFileSync(file, 'utf8')
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line)
+      } catch (_) {
+        return null
+      }
+    })
+    .filter(Boolean)
+}
+
+function isVerifiedReuse(record) {
+  return (
+    (record.reuse === true || record.reuse === 'true') &&
+    (record.behaviorChanged === true || record.behaviorChanged === 'true') &&
+    (record.outcomeImproved === true || record.outcomeImproved === 'true')
+  )
+}
+
+function createDigest(options = {}) {
+  const home = options.home
+  const now = options.now || (() => Date.now())
+
+  function generate(args = {}) {
+    const days = Math.max(1, Number(args.days) || 7)
+    const project = args.project ? String(args.project) : null
+    const atTime = now()
+    const cutoff = atTime - days * 86400000
+
+    const traces = readJsonl(path.join(home, 'traces.jsonl')).filter((trace) => {
+      if (!trace || typeof trace !== 'object') return false
+      const ts = Date.parse(trace.timestamp || '')
+      if (!(Number.isFinite(ts) && ts >= cutoff)) return false
+      if (project && trace.project !== project) return false
+      return true
+    })
+
+    const outcomes = traces.filter((t) => String(t.event_type || '').toLowerCase() === 'task_outcome')
+    const errors = traces.filter((t) => String(t.event_type || '').toLowerCase() === 'error')
+
+    // --- per-agent performance ---
+    const agentMap = new Map()
+    for (const outcome of outcomes) {
+      const agent = String(outcome.agent || 'unknown')
+      let entry = agentMap.get(agent)
+      if (!entry) {
+        entry = { agent, total: 0, success: 0, failure: 0, aborted: 0 }
+        agentMap.set(agent, entry)
+      }
+      entry.total += 1
+      const oc = String(outcome.outcome || 'none').toLowerCase()
+      if (oc === 'success') entry.success += 1
+      else if (oc === 'failure' || oc === 'error') entry.failure += 1
+      else entry.aborted += 1
+    }
+    const agents = [...agentMap.values()]
+      .map((entry) => ({
+        ...entry,
+        successRate: entry.total > 0 ? Math.round((entry.success / entry.total) * 100) : 0,
+      }))
+      .sort((a, b) => b.total - a.total)
+
+    // --- error hotspots ---
+    const errorByAgent = new Map()
+    const errorByTool = new Map()
+    for (const error of errors) {
+      const agent = String(error.agent || 'unknown')
+      errorByAgent.set(agent, (errorByAgent.get(agent) || 0) + 1)
+      const tool =
+        (error.payload && (error.payload.tool || error.payload.toolUseId || error.payload.status)) ||
+        'unknown'
+      const key = agent + ':' + String(tool)
+      errorByTool.set(key, (errorByTool.get(key) || 0) + 1)
+    }
+    const errorHotspots = {
+      total: errors.length,
+      byAgent: [...errorByAgent.entries()]
+        .map(([agent, count]) => ({ agent, count }))
+        .sort((a, b) => b.count - a.count),
+      byTool: [...errorByTool.entries()]
+        .map(([key, count]) => ({ key, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 10),
+    }
+
+    // --- project activity ---
+    const projectMap = new Map()
+    for (const outcome of outcomes) {
+      const name = String(outcome.project || 'unknown')
+      let entry = projectMap.get(name)
+      if (!entry) {
+        entry = { project: name, tasks: 0, success: 0, lastAt: null, recent: [] }
+        projectMap.set(name, entry)
+      }
+      entry.tasks += 1
+      if (String(outcome.outcome || '').toLowerCase() === 'success') entry.success += 1
+      const ts = Date.parse(outcome.timestamp || '')
+      if (Number.isFinite(ts) && (!entry.lastAt || ts > entry.lastAt)) entry.lastAt = ts
+      const summary = outcome.payload && outcome.payload.summary
+      if (summary && entry.recent.length < 3) {
+        entry.recent.push({
+          at: outcome.timestamp,
+          agent: outcome.agent,
+          outcome: outcome.outcome,
+          summary: String(summary).slice(0, 160),
+        })
+      }
+    }
+    const projects = [...projectMap.values()]
+      .map((entry) => ({ ...entry, lastAt: entry.lastAt ? new Date(entry.lastAt).toISOString() : null }))
+      .sort((a, b) => b.tasks - a.tasks)
+
+    // --- reuse evidence ---
+    const reuseRecords = readJsonl(path.join(home, 'experience_reuse.jsonl')).filter((record) => {
+      if (!record || typeof record !== 'object') return false
+      if (project && record.project !== project) return false
+      const ts = Date.parse(record.timestamp || '')
+      return Number.isFinite(ts) && ts >= cutoff
+    })
+    const reuse = {
+      verified: reuseRecords.filter(isVerifiedReuse).length,
+      pendingAutoClaims: reuseRecords.filter(
+        (record) => record.source === 'auto_claim' && record.confirmed !== true
+      ).length,
+      total: reuseRecords.length,
+    }
+
+    // --- rule-based suggestions (facts first, thresholds conservative) ---
+    const suggestions = []
+    const reliable = agents.filter((a) => a.total >= 5)
+    if (reliable.length >= 2) {
+      const best = reliable.reduce((a, b) => (b.successRate > a.successRate ? b : a))
+      const worst = reliable.reduce((a, b) => (b.successRate < a.successRate ? b : a))
+      if (best.successRate - worst.successRate >= 20) {
+        suggestions.push(
+          `路由信号: ${best.agent} 成功率 ${best.successRate}% vs ${worst.agent} ${worst.successRate}%（近 ${days} 天），同类任务优先路由给 ${best.agent}。`
+        )
+      }
+    }
+    if (errorHotspots.total >= 5 && errorHotspots.byAgent.length > 0) {
+      const top = errorHotspots.byAgent[0]
+      suggestions.push(
+        `错误热点: ${top.agent} 近 ${days} 天产生 ${top.count} 条 error trace${errorHotspots.byTool.length > 0 ? `（高发: ${errorHotspots.byTool[0].key} x${errorHotspots.byTool[0].count}）` : ''}，优先排查。`
+      )
+    }
+    if (reuse.pendingAutoClaims >= 10) {
+      suggestions.push(
+        `待确认: ${reuse.pendingAutoClaims} 条 auto-claim 经验复用未确认，运行 mio.experience.confirm 提升证据质量。`
+      )
+    }
+
+    const report = {
+      generatedAt: new Date(atTime).toISOString(),
+      periodDays: days,
+      project: project || 'all',
+      overview: {
+        tasks: outcomes.length,
+        byOutcome: outcomes.reduce((acc, t) => {
+          const oc = String(t.outcome || 'none').toLowerCase()
+          acc[oc] = (acc[oc] || 0) + 1
+          return acc
+        }, {}),
+        errorTraces: errors.length,
+        activeAgents: agents.length,
+        activeProjects: projects.length,
+      },
+      agents,
+      errorHotspots,
+      projects,
+      reuse,
+      suggestions,
+    }
+    report.markdown = renderMarkdown(report)
+    return report
+  }
+
+  function renderMarkdown(report) {
+    const lines = []
+    const from = new Date(Date.parse(report.generatedAt) - report.periodDays * 86400000)
+      .toISOString()
+      .slice(0, 10)
+    const to = report.generatedAt.slice(0, 10)
+    lines.push(`# Mio Digest (${from} ~ ${to}, project=${report.project})`)
+    lines.push('')
+    const ov = report.overview
+    const rate = ov.tasks > 0 ? Math.round(((ov.byOutcome.success || 0) / ov.tasks) * 100) : 0
+    lines.push(
+      `- 任务 ${ov.tasks} 条（success ${ov.byOutcome.success || 0} / failure ${ov.byOutcome.failure || 0} / aborted ${ov.byOutcome.aborted || 0}，成功率 ${rate}%），error trace ${ov.errorTraces} 条`
+    )
+    lines.push(`- 活跃 agent ${ov.activeAgents} 个，活跃项目 ${ov.activeProjects} 个`)
+    lines.push('')
+
+    if (report.agents.length > 0) {
+      lines.push('## Agent 表现')
+      lines.push('')
+      lines.push('| agent | 任务 | 成功 | 失败 | 中止 | 成功率 |')
+      lines.push('|---|---|---|---|---|---|')
+      for (const a of report.agents) {
+        lines.push(`| ${a.agent} | ${a.total} | ${a.success} | ${a.failure} | ${a.aborted} | ${a.successRate}% |`)
+      }
+      lines.push('')
+    }
+
+    if (report.projects.length > 0) {
+      lines.push('## 项目动态')
+      lines.push('')
+      for (const p of report.projects) {
+        const lastAt = p.lastAt ? p.lastAt.slice(0, 16).replace('T', ' ') : '-'
+        lines.push(`### ${p.project}（${p.tasks} 任务，最近 ${lastAt}）`)
+        for (const task of p.recent) {
+          const at = task.at ? task.at.slice(5, 16).replace('T', ' ') : ''
+          lines.push(`- [${task.outcome}] (${at} ${task.agent}) ${task.summary}`)
+        }
+        lines.push('')
+      }
+    }
+
+    if (report.errorHotspots.total > 0) {
+      lines.push('## 错误热点')
+      lines.push('')
+      for (const item of report.errorHotspots.byAgent) {
+        lines.push(`- ${item.agent}: ${item.count} 条`)
+      }
+      const tools = report.errorHotspots.byTool.slice(0, 5)
+      if (tools.length > 0) {
+        lines.push(`- 高发位置: ${tools.map((t) => `${t.key} x${t.count}`).join(', ')}`)
+      }
+      lines.push('')
+    }
+
+    lines.push('## 经验复用')
+    lines.push('')
+    lines.push(`- verified ${report.reuse.verified} / pending auto-claim ${report.reuse.pendingAutoClaims} / total ${report.reuse.total}`)
+    lines.push('')
+
+    if (report.suggestions.length > 0) {
+      lines.push('## 可行动建议')
+      lines.push('')
+      for (const suggestion of report.suggestions) {
+        lines.push(`- ${suggestion}`)
+      }
+      lines.push('')
+    }
+
+    return lines.join('\n')
+  }
+
+  return { generate, renderMarkdown }
+}
+
+module.exports = { createDigest }

package/server/host-capabilities.js

@@ -5,6 +5,7 @@ const adapters = {
   opencode: require('../adapters/opencode.js'),
   workbuddy: require('../adapters/workbuddy.js'),
   hermes: require('../adapters/hermes.js'),
+  claude: require('../adapters/claude-code.js'),
 }
 
 const HOST_CAPABILITIES = [
@@ -24,6 +25,10 @@ const HOST_CAPABILITIES = [
     name: 'hermes',
     capabilities: ['mcp-tools', 'memory', 'observer-ingest', 'observer-transcript', 'policy-check', 'experience-reuse', 'runtime-status'],
   },
+  {
+    name: 'claude',
+    capabilities: ['mcp-tools', 'memory', 'observer-ingest', 'observer-transcript', 'policy-check', 'experience-reuse', 'runtime-status'],
+  },
 ]
 
 function safeInstalled(adapter) {