mio-agent-runtime 0.5.16 → 0.5.22

package/server/creativity-engine.js

@@ -0,0 +1,397 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const crypto = require('crypto')
+
+// ═══════════════════════════════════════════════
+//  JSONL Store — ideas, combos, experiments
+// ═══════════════════════════════════════════════
+
+class CreativityStore {
+  constructor(dataDir) {
+    this.dataDir = dataDir
+    this.hypothesesPath = path.join(dataDir, 'creativity-hypotheses.jsonl')
+    this.combosPath = path.join(dataDir, 'creativity-combos.jsonl')
+    this.experimentsPath = path.join(dataDir, 'creativity-experiments.jsonl')
+    this._hypotheses = null
+    this._combos = null
+    this._experiments = null
+  }
+
+  _ensureDir() {
+    if (!fs.existsSync(this.dataDir)) {
+      fs.mkdirSync(this.dataDir, { recursive: true })
+    }
+  }
+
+  _readJsonl(filePath) {
+    if (!fs.existsSync(filePath)) return []
+    return fs.readFileSync(filePath, 'utf-8')
+      .split('\n')
+      .filter(Boolean)
+      .map(line => {
+        try { return JSON.parse(line) } catch { return null }
+      })
+      .filter(Boolean)
+  }
+
+  _appendJsonl(filePath, record) {
+    this._ensureDir()
+    fs.appendFileSync(filePath, JSON.stringify(record) + '\n')
+  }
+
+  getHypotheses(opts = {}) {
+    if (this._hypotheses === null) {
+      this._hypotheses = this._readJsonl(this.hypothesesPath)
+    }
+    let list = this._hypotheses
+    if (opts.status) list = list.filter(h => h.status === opts.status)
+    if (opts.limit) list = list.slice(-opts.limit)
+    return list
+  }
+
+  addHypothesis(h) {
+    this._appendJsonl(this.hypothesesPath, h)
+    if (this._hypotheses) this._hypotheses.push(h)
+  }
+
+  updateHypothesis(id, patch) {
+    const all = this.getHypotheses()
+    const idx = all.findIndex(h => h.id === id)
+    if (idx === -1) return false
+    Object.assign(all[idx], patch)
+    this._hypotheses = all
+    this._rewriteFile(this.hypothesesPath, all)
+    return true
+  }
+
+  getCombos(limit) {
+    if (this._combos === null) {
+      this._combos = this._readJsonl(this.combosPath)
+    }
+    return limit ? this._combos.slice(-limit) : this._combos
+  }
+
+  addCombo(c) {
+    this._appendJsonl(this.combosPath, c)
+    if (this._combos) this._combos.push(c)
+  }
+
+  getExperiments() {
+    if (this._experiments === null) {
+      this._experiments = this._readJsonl(this.experimentsPath)
+    }
+    return this._experiments
+  }
+
+  addExperiment(e) {
+    this._appendJsonl(this.experimentsPath, e)
+    if (this._experiments) this._experiments.push(e)
+  }
+
+  count() {
+    return {
+      hypotheses: this.getHypotheses().length,
+      combos: this.getCombos().length,
+      experiments: this.getExperiments().length,
+    }
+  }
+
+  _rewriteFile(filePath, records) {
+    this._ensureDir()
+    fs.writeFileSync(filePath, records.map(r => JSON.stringify(r)).join('\n') + '\n')
+  }
+}
+
+// ═══════════════════════════════════════════════
+//  Concept Mixer — pair sources for novel combos
+// ═══════════════════════════════════════════════
+
+function mulberry32(seed) {
+  let t = seed | 0
+  return () => {
+    t = (t + 0x6D2B79F5) | 0
+    let x = Math.imul(t ^ (t >>> 15), 1 | t)
+    x ^= x + Math.imul(x ^ (x >>> 7), 61 | x)
+    return ((x ^ (x >>> 14)) >>> 0) / 4294967296
+  }
+}
+
+function mixConcepts(sources, exploredPairs, rng) {
+  if (sources.length < 2) return []
+  const pairs = []
+  for (let i = 0; i < sources.length; i++) {
+    for (let j = i + 1; j < sources.length; j++) {
+      const key = `${sources[i].name}||${sources[j].name}`
+      const reverseKey = `${sources[j].name}||${sources[i].name}`
+      if (exploredPairs.has(key) || exploredPairs.has(reverseKey)) continue
+      pairs.push([sources[i], sources[j]])
+    }
+  }
+  // Shuffle and take top pairs
+  for (let i = pairs.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1))
+    ;[pairs[i], pairs[j]] = [pairs[j], pairs[i]]
+  }
+  return pairs.slice(0, Math.min(5, pairs.length))
+}
+
+// ═══════════════════════════════════════════════
+//  Novelty Scorer — reject duplicates
+// ═══════════════════════════════════════════════
+
+function bigramSet(text) {
+  const s = new Set()
+  const lower = text.toLowerCase()
+  for (let i = 0; i < lower.length - 1; i++) {
+    s.add(lower.slice(i, i + 2))
+  }
+  return s
+}
+
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 1
+  let inter = 0
+  for (const x of a) if (b.has(x)) inter++
+  return inter / (a.size + b.size - inter)
+}
+
+function evaluateNovelty(idea, recent, rejected) {
+  const ideaBigrams = bigramSet(idea.title + ' ' + idea.idea)
+  for (const r of recent) {
+    const sim = jaccard(ideaBigrams, bigramSet(r.title + ' ' + r.idea))
+    if (sim > 0.7) {
+      return { shouldReject: true, rejectReason: `too similar to recent: "${r.title}" (sim=${sim.toFixed(2)})`, adjustedNovelty: idea.novelty }
+    }
+  }
+  for (const r of rejected) {
+    const sim = jaccard(ideaBigrams, bigramSet(r.title + ' ' + r.idea))
+    if (sim > 0.6) {
+      return { shouldReject: true, rejectReason: `matches rejected: "${r.title}" (sim=${sim.toFixed(2)})`, adjustedNovelty: idea.novelty }
+    }
+  }
+  return { shouldReject: false, adjustedNovelty: Math.min(100, idea.novelty + 5) }
+}
+
+// ═══════════════════════════════════════════════
+//  Creativity Engine — main orchestrator
+// ═══════════════════════════════════════════════
+
+const STRATEGY_CYCLE = ['explore', 'signal', 'stable']
+
+class CreativityEngine {
+  constructor(dataDir, chatJson) {
+    this.store = new CreativityStore(dataDir)
+    this.chatJson = chatJson
+    this.strategyIndex = 0
+    this.exploredPairs = new Set()
+    this.rng = mulberry32(Date.now())
+  }
+
+  async generate(sourceLabels, strategy) {
+    const sources = sourceLabels.map(s => ({
+      name: s.name || 'unnamed',
+      content: s.content || '',
+      type: s.type || 'knowledge',
+      weight: s.weight || 0.5,
+    }))
+
+    if (sources.length < 2) {
+      return { ideas: [], reason: 'need at least 2 sources' }
+    }
+
+    const strat = strategy || STRATEGY_CYCLE[this.strategyIndex % STRATEGY_CYCLE.length]
+    this.strategyIndex++
+
+    // Mix concepts
+    const recent = this.store.getHypotheses({ limit: 30 })
+    const rejected = this.store.getHypotheses({ status: 'rejected', limit: 50 })
+    const exploredPairs = new Set(recent.flatMap(h => (h.sourceLabels || []).map((l, i, a) => i > 0 ? `${a[i-1]}||${l}` : '')).filter(Boolean))
+    const pairs = mixConcepts(sources, exploredPairs, this.rng.bind(this))
+
+    if (pairs.length === 0) {
+      return { ideas: [], reason: 'all pairs already explored' }
+    }
+
+    // Generate hypotheses via LLM
+    const ideas = []
+    for (const [a, b] of pairs) {
+      const prompt = this._buildGenerationPrompt(a, b, strat, recent.slice(-10), rejected.slice(-5))
+      try {
+        const result = await this.chatJson(prompt, {
+          system: `You are a creative hypothesis generator. Output JSON with fields: title, idea, expectedBenefit, risk, novelty (0-100), feasibility (0-100), impact (0-100). Generate ONE novel hypothesis by combining the given concepts.`,
+          temperature: strat === 'explore' ? 0.8 : 0.4,
+        })
+
+        if (result.data) {
+          const h = {
+            id: crypto.randomUUID(),
+            title: result.data.title || 'Untitled',
+            idea: result.data.idea || '',
+            expectedBenefit: result.data.expectedBenefit || '',
+            risk: result.data.risk || '',
+            novelty: Math.min(100, Math.max(0, result.data.novelty || 50)),
+            feasibility: Math.min(100, Math.max(0, result.data.feasibility || 50)),
+            impact: Math.min(100, Math.max(0, result.data.impact || 50)),
+            sourceLabels: [a.name, b.name],
+            status: 'active',
+            createdAt: Date.now(),
+            strategy: strat,
+          }
+
+          // Novelty check
+          const verdict = evaluateNovelty(h, recent, rejected)
+          if (verdict.shouldReject) {
+            h.status = 'rejected'
+            h.rejectionReason = verdict.rejectReason
+          } else {
+            h.novelty = verdict.adjustedNovelty
+          }
+
+          this.store.addHypothesis(h)
+          ideas.push(h)
+
+          // Record combo
+          this.store.addCombo({
+            id: crypto.randomUUID(),
+            sources: [a.name, b.name],
+            description: h.title,
+            createdAt: Date.now(),
+          })
+        }
+      } catch (err) {
+        // LLM call failed, skip this pair
+      }
+    }
+
+    return { ideas, strategy: strat, pairsAttempted: pairs.length }
+  }
+
+  async ferment(limit = 5) {
+    const fermentable = this.store.getHypotheses({ status: 'active' })
+      .concat(this.store.getHypotheses({ status: 'draft' }))
+      .slice(-limit)
+
+    if (fermentable.length === 0) {
+      return { fermented: 0, reason: 'no fermentable hypotheses' }
+    }
+
+    const results = []
+    for (const h of fermentable) {
+      const prompt = `Review and refine this hypothesis. Current state:
+Title: ${h.title}
+Idea: ${h.idea}
+Novelty: ${h.novelty}, Feasibility: ${h.feasibility}, Impact: ${h.impact}
+
+Output JSON with: title, idea, expectedBenefit, risk, novelty, feasibility, impact, verdict (promote/keep/reject/merge), reason.`
+
+      try {
+        const result = await this.chatJson(prompt, {
+          system: 'You are a creative hypothesis reviewer. Output JSON with refined scores and a verdict.',
+          temperature: 0.3,
+        })
+
+        if (result.data) {
+          const patch = {
+            title: result.data.title || h.title,
+            idea: result.data.idea || h.idea,
+            expectedBenefit: result.data.expectedBenefit || h.expectedBenefit,
+            risk: result.data.risk || h.risk,
+            novelty: Math.min(100, Math.max(0, result.data.novelty || h.novelty)),
+            feasibility: Math.min(100, Math.max(0, result.data.feasibility || h.feasibility)),
+            impact: Math.min(100, Math.max(0, result.data.impact || h.impact)),
+            fermentedAt: Date.now(),
+            fermentCount: (h.fermentCount || 0) + 1,
+          }
+
+          if (result.data.verdict === 'reject') {
+            patch.status = 'rejected'
+          } else if (result.data.verdict === 'promote' && (h.novelty + h.feasibility + h.impact) > 200) {
+            patch.status = 'validated'
+          }
+
+          this.store.updateHypothesis(h.id, patch)
+          results.push({ id: h.id, title: h.title, verdict: result.data.verdict, reason: result.data.reason })
+        }
+      } catch (err) {
+        // skip
+      }
+    }
+
+    return { fermented: results.length, results }
+  }
+
+  status() {
+    const count = this.store.count()
+    const active = this.store.getHypotheses({ status: 'active' })
+    const validated = this.store.getHypotheses({ status: 'validated' })
+    const rejected = this.store.getHypotheses({ status: 'rejected' })
+
+    return {
+      ...count,
+      active: active.length,
+      validated: validated.length,
+      rejected: rejected.length,
+      recentIdeas: active.slice(-5).map(h => ({
+        id: h.id,
+        title: h.title,
+        novelty: h.novelty,
+        feasibility: h.feasibility,
+        impact: h.impact,
+        score: h.novelty + h.feasibility + h.impact,
+      })),
+    }
+  }
+
+  list(opts = {}) {
+    return this.store.getHypotheses(opts).map(h => ({
+      id: h.id,
+      title: h.title,
+      idea: h.idea,
+      status: h.status,
+      novelty: h.novelty,
+      feasibility: h.feasibility,
+      impact: h.impact,
+      score: h.novelty + h.feasibility + h.impact,
+      sourceLabels: h.sourceLabels,
+      createdAt: h.createdAt,
+      fermentedAt: h.fermentedAt,
+      fermentCount: h.fermentCount,
+    }))
+  }
+
+  _buildGenerationPrompt(a, b, strategy, recentHypotheses, rejectedHypotheses) {
+    let prompt = `Combine these two concepts into ONE novel hypothesis:\n\n`
+    prompt += `Concept A: "${a.name}" — ${a.content}\n`
+    prompt += `Concept B: "${b.name}" — ${b.content}\n\n`
+    prompt += `Strategy: ${strategy}\n`
+
+    if (strategy === 'explore') {
+      prompt += `Cross-domain combination. Emphasize structural differences and unexpected connections.\n`
+    } else if (strategy === 'signal') {
+      prompt += `Inject external signals. Be provocative and challenge assumptions.\n`
+    } else {
+      prompt += `Stable combination. Conservative refinement of existing ideas.\n`
+    }
+
+    if (recentHypotheses.length > 0) {
+      prompt += `\nRecent ideas (avoid duplicates):\n`
+      for (const h of recentHypotheses) {
+        prompt += `- "${h.title}" (novelty=${h.novelty})\n`
+      }
+    }
+
+    if (rejectedHypotheses.length > 0) {
+      prompt += `\nRejected ideas (learn from failures):\n`
+      for (const h of rejectedHypotheses) {
+        prompt += `- "${h.title}" — ${h.risk}\n`
+      }
+    }
+
+    prompt += `\nOutput JSON: {"title": "...", "idea": "...", "expectedBenefit": "...", "risk": "...", "novelty": 0-100, "feasibility": 0-100, "impact": 0-100}`
+    return prompt
+  }
+}
+
+module.exports = { CreativityEngine, CreativityStore }

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) {