mio-agent-runtime 0.14.0 → 0.15.0

package/README.md

@@ -53,10 +53,11 @@ mio memory forget --ids a,b     PERMANENTLY delete records (--yes required; writ
 mio memory merge --ids a,b  Merge duplicate records into one survivor (--keep/--allow-divergent; --yes required)
 mio memory migrate --ids a,b --scope global|project   Move records between the project and global layers
 mio policy check "<action>" Check the historical risk of an action before running it (--project; reads global MIO_HOME)
-mio creativity status        Show creativity hypothesis counts and recent top ideas (reads global MIO_HOME)
+mio creativity status        Show creativity hypothesis counts, recent top ideas, adoption join (reads global MIO_HOME)
 mio creativity list          List creativity hypotheses (--status active|validated|rejected|draft, --limit N)
 mio creativity generate      Generate hypotheses from 2+ --source "name|content" (or --from-insights; calls an LLM)
 mio creativity ferment       Review and refine active hypotheses (calls an LLM)
+mio creativity adopt         Record an adoption event for a stored hypothesis (writes traces only)
 mio idea generate --goal "..."   Grounded idea pipeline: auto sources + novelty gate, persisted (calls an LLM)
 mio insight status           Insight counts: total, reported, unreported, high-value (needs @akemi-mio/insight)
 mio insight list             List insights (--unreported, --min-score N, --detector X, --limit N)
@@ -102,7 +103,7 @@ mio --version                Print the version and exit (-V)
 
 ## MCP 工具
 
-MCP 服务端在 5 大域共暴露 51 个工具：
+MCP 服务端在 5 大域共暴露 52 个工具：
 
 ### 记忆（11）
 `mio.memory.query` · `mio.memory.record` · `mio.memory.archive` · `mio.memory.merge` · `mio.memory.migrate` · `mio.memory.analyze` · `mio.memory.forget` · `mio.experience.list` · `mio.experience.confirm` · `mio.experience.reuse` · `mio.policy.check`
@@ -115,8 +116,8 @@ MCP 服务端在 5 大域共暴露 51 个工具：
 ### 洞察自省（4）
 `mio.insight.status` · `mio.insight.list` · `mio.insight.mark_reported` · `mio.insight.generate`
 
-### 创意引擎（5）
-`mio.creativity.generate` · `mio.creativity.ferment` · `mio.creativity.list` · `mio.creativity.status` · `mio.idea.generate`
+### 创意引擎（6）
+`mio.creativity.generate` · `mio.creativity.ferment` · `mio.creativity.adopt` · `mio.creativity.list` · `mio.creativity.status` · `mio.idea.generate`
 
 ### 任务、Agent 与演化（16）
 `mio.task.route` · `mio.task.record_outcome` · `mio.agent.register` · `mio.agent.list` · `mio.agent.report` · `mio.agent.evaluation` · `mio.host.capabilities` · `mio.evolution.status` · `mio.evolution.report` · `mio.evolution.shadow.record` · `mio.evolution.dual_write.record` · `mio.evolution.cutover.readiness` · `mio.evolution.cutover.apply` · `mio.evolution.migration.plan` · `mio.evolution.authority.plan` · `mio.phase0.report`
@@ -389,6 +390,7 @@ mio creativity list --json
 Creativity engine:
   hypotheses: 5  combos: 3  experiments: 1
   active: 2  validated: 1  rejected: 1  draft: 1
+  adoption: 2 adopted (events=2, tags=2) — derived join, not a metric
 
 Recent top ideas:
 - Plugin architecture  (novelty=80 feasibility=70 impact=90 score=240)
@@ -403,6 +405,32 @@ Recent top ideas:
 - **空存储是正常状态。** 引擎运行之前，`status` 报告全零计数，`list` 显示 "No hypotheses match." 两者都是有效输出，不是错误。
 - **缓存会在文件变化时失效。** 三个 JSONL 的读取按 `(size, mtime)` 校验，因此另一个进程写入后长驻的 MCP 服务端无需重启就能看到——与 `server/insight-store.js` 同一套守卫。
 
+### 采用证据链（adopt / status / list）
+
+假设的「采用」**不在存储里**，而是三轴分离的证据链——store 只管评审，采用是假设与外部世界的关系：
+
+- **评审轴（`creativity-hypotheses.jsonl`）**：`draft → active → validated / rejected`，假说自身的生命周期，由 `generate` / `ferment` 推进。
+- **声称轴（`traces.jsonl`）**：`mio.creativity.adopt`（MCP `mio.creativity.adopt`）追加 `creativity.adopt` 事件，`payload.hypothesisId` 即声称；只写事件、绝不碰 memory，校验失败零写入。
+- **证据轴（`memory.jsonl`）**：`mio memory record ... --hypothesis-id <uuid>`（MCP 参数 `hypothesisId`）把 `hypothesis:<uuid>` 注入记录 tags；`mio memory query --tags hypothesis:<uuid>` 即按标签召回。`AGENTS.md` 规范：**采用假设做决策时 `memory.record` 必带 `hypothesisId`**——这是把决策与假设挂上钩的唯一写入口。
+
+`status` / `list` 在**读侧**把两轴 join 成派生计数（`mio.creativity.status` 返回）：
+
+```json
+"adoption": {
+  "adopted": 2, "claimed": 3, "evidenced": 2,
+  "metric": false,
+  "note": "derived join of creativity.adopt events and hypothesis:<id> memory tags — informational; no rate or threshold by design",
+  "sources": {
+    "events": { "file": "traces.jsonl", "durable": true },
+    "memory": { "file": "memory.jsonl", "durable": true }
+  }
+}
+```
+
+- `claimed` / `evidenced` 是两轴各自的 **distinct id 原始计数**（可以含已不在存储中的悬空 id）；`adopted` = 两集合并集与存储假设 id 的交集——只有它回答「**存下来的**假设里哪些被采用过」。原始与 join 并报，悬空证据因此可见而不是被静默吞掉。
+- **`metric: false` 是承重字段**：这是信息性派生 join，**不是** ADR-017 评估指标——没有 adoption rate、没有阈值。`sources` 照 `routeAdoption` 的模式注明每个轴的背书文件与 durable 性，于是「0 adopted（真没人用）」与「证据文件没留存（不可测）」能区分开。
+- `list` 每行带 `adopted: boolean`，文本模式在状态后显示 `[adopted]` 标记；JSON 输出即引擎结果，MCP 与 CLI 两侧天然一致。
+
 ### 生成与发酵（`generate` / `ferment`）
 
 这两个子命令会调用 LLM，`mio creativity` 同样支持它们——用的是**共享的 LLM 客户端**
@@ -423,6 +451,13 @@ mio creativity ferment --limit 3
   `@akemi-mio/insight` 已安装且至少存有一条洞察时有意义，否则明确报错而不是
   静默当作「没有来源」。因为来源可由它提供，`mio.creativity.generate` 的
   `sources` 不再是 schema 必填项。
+- **判重粒度是（素材对 × `--strategy`）。** 同一对素材在 `explore` / `signal` /
+  `stable` 下各算一次实验——「409 就换 strategy 重试」是有效的降级而不是空转；
+  三种 strategy 都试过、且没有新素材时才真正耗尽，此时返回的 `reason` 会带上
+  strategy、来源数与候选对数（外加 `strategy` 与 `pairsAvailable: 0` 字段），
+  调用方可以据此区分「换个 strategy 有用」与「该补新素材了」。素材身份取名称
+  去空白后的**前 120 个字符**（`--source` 省略 `|` 时 name 会退化成整段描述，
+  描述尾部微调不得绕过判重）；没有 `strategy` 字段的旧记录仍挡住所有 strategy。
 - `ferment` 会复核 `active` / `draft` 假设并更新分数；`verdict=promote` 且总分 > 200 时
   升为 `validated`，`verdict=reject` 则标记为 `rejected`。
 - **失败的 LLM 调用会出现在结果里，不再被吞掉。** 返回值带 `errors`

package/bin/mio.js

@@ -23,7 +23,7 @@ const { createEvolutionCutoverTools } = require('../server/evolution-cutover.js'
 const { createMemoryStore } = require('../server/memory-store.js')
 const { createExperienceStore } = require('../server/experience-store.js')
 const { createPolicyStore } = require('../server/policy-store.js')
-const { CreativityEngine, sourcesFromInsights } = require('../server/creativity-engine.js')
+const { CreativityEngine, sourcesFromInsights, adoptHypothesis } = require('../server/creativity-engine.js')
 const { buildAutoSources, topUpSources } = require('../server/creativity-sources.js')
 const { runIdeaGenerate, groundingFrom } = require('../server/idea-generate.js')
 const { createAgentStore } = require('../server/agent-store.js')
@@ -678,18 +678,22 @@ function pruneCommand(args, useJson) {
 function rememberCommand(args, useJson) {
   const content = args[1]
   if (!content) {
-    console.error('Usage: mio remember "<content>" [--kind decision|context|problem|note] [--tags a,b] [--scope project|global] [--project name] [--json]')
+    console.error('Usage: mio remember "<content>" [--kind decision|context|problem|note] [--tags a,b] [--hypothesis-id id] [--scope project|global] [--project name] [--json]')
     process.exitCode = 1
     return
   }
   const flags = args.slice(2)
   const store = cliMemoryStore()
+  // optionValue returns the next token even if it is another flag; a bare
+  // trailing `--hypothesis-id` must not swallow `--json` as a "uuid".
+  const hypothesisId = optionValue(flags, '--hypothesis-id')
   let record
   try {
     record = store.recordMemory({
       content,
       kind: optionValue(flags, '--kind'),
       tags: splitTagsOption(flags, '--tags'),
+      hypothesisId: hypothesisId && !hypothesisId.startsWith('--') ? hypothesisId : undefined,
       scope: optionValue(flags, '--scope'),
       project: optionValue(flags, '--project'),
       source: 'cli',
@@ -2066,11 +2070,12 @@ function observerCommand(args, useJson) {
 
 function creativityUsage(write = console.log) {
   write(`Usage:
-  mio creativity status              Show hypothesis counts and recent top ideas
+  mio creativity status              Show hypothesis counts, recent top ideas, adoption join
   mio creativity list                List hypotheses (--status active|validated|rejected|draft, --sort novelty, --limit N)
 
   mio creativity generate        Generate hypotheses by combining sources (needs 2+ --source, calls an LLM)
   mio creativity ferment         Review/refine active hypotheses (calls an LLM)
+  mio creativity adopt           Record an adoption event for a stored hypothesis (writes traces only)
 
 Options:
   --status name      Filter list by status
@@ -2098,6 +2103,8 @@ function printCreativityStatus(result) {
   console.log('Creativity engine:')
   console.log(`  hypotheses: ${result.hypotheses}  combos: ${result.combos}  experiments: ${result.experiments}`)
   console.log(`  active: ${result.active}  validated: ${result.validated}  rejected: ${result.rejected}  draft: ${result.draft}`)
+  const adoption = result.adoption || { adopted: 0, claimed: 0, evidenced: 0 }
+  console.log(`  adoption: ${adoption.adopted} adopted (events=${adoption.claimed} tags=${adoption.evidenced}) — derived join, not a metric`)
   if (result.recentIdeas.length === 0) {
     console.log('No hypotheses yet.')
     return
@@ -2118,7 +2125,7 @@ function printCreativityList(items) {
   items.forEach((h, index) => {
     const when = h.createdAt ? new Date(h.createdAt).toISOString().slice(0, 19).replace('T', ' ') : ''
     const labels = Array.isArray(h.sourceLabels) && h.sourceLabels.length > 0 ? h.sourceLabels.join(' + ') : '—'
-    console.log(`${index + 1}. [${h.status}] ${h.title}  (N=${h.novelty} F=${h.feasibility} I=${h.impact} score=${h.score}${h.noveltyScore !== undefined ? ` noveltyScore=${h.noveltyScore}` : ''})`)
+    console.log(`${index + 1}. [${h.status}]${h.adopted ? ' [adopted]' : ''} ${h.title}  (N=${h.novelty} F=${h.feasibility} I=${h.impact} score=${h.score}${h.noveltyScore !== undefined ? ` noveltyScore=${h.noveltyScore}` : ''})`)
     console.log(`   ${labels} | ${when} | ${h.id}`)
     if (h.fermentCount) console.log(`   fermented ${h.fermentCount}x`)
   })
@@ -2296,10 +2303,45 @@ function creativityFermentCommand(args, useJson) {
   })
 }
 
+// mio.creativity.adopt from the terminal: same shared adoptHypothesis the MCP
+// server calls, same enforcement (id must exist; --memory-id must already
+// carry the hypothesis:<id> tag), event written to MIO_HOME/traces.jsonl.
+function creativityAdoptCommand(args, useJson) {
+  const flags = args.slice(2)
+  const hypothesisId = flags[0] && !flags[0].startsWith('--') ? String(flags[0]).trim() : ''
+  if (!hypothesisId) {
+    console.error('mio creativity adopt requires <hypothesisId>')
+    console.error('Usage: mio creativity adopt <hypothesisId> [--memory-id id] [--task-id id] [--note text] [--json]')
+    process.exitCode = 1
+    return
+  }
+
+  let result
+  try {
+    result = adoptHypothesis(
+      cliCreativityEngine(),
+      {
+        hypothesisId,
+        memoryId: optionValue(flags, '--memory-id'),
+        taskId: optionValue(flags, '--task-id'),
+        note: optionValue(flags, '--note'),
+      },
+      cliTaskStore().ingestObservation,
+      MIO_HOME
+    )
+  } catch (error) {
+    console.error(error.message || error)
+    process.exitCode = 1
+    return
+  }
+  if (useJson) return jsonOrText(result, true)
+  console.log(`Adopted hypothesis ${result.hypothesisId}`)
+  console.log(`  event: ${result.event && result.event.trace_id ? result.event.trace_id : 'creativity.adopt'}`)
+}
+
 function ideaUsage() {
   console.error('usage: mio idea generate --goal "one line" [--context "..."] [--constraint "..."] [--num N] [--json]')
 }
-
 async function ideaGenerateCommand(args, useJson) {
   const flags = args.slice(2)
   const goal = (optionValue(flags, '--goal') || '').trim()
@@ -2390,6 +2432,7 @@ function creativityCommand(args, useJson) {
   }
   if (sub === 'generate') return creativityGenerateCommand(args, useJson)
   if (sub === 'ferment') return creativityFermentCommand(args, useJson)
+  if (sub === 'adopt') return creativityAdoptCommand(args, useJson)
 
   if (!['status', 'list'].includes(sub)) {
     console.error(`Unknown creativity subcommand: ${sub}`)
@@ -3492,10 +3535,11 @@ Usage:
   mio experience list        List experience reuse (--status pending|confirmed|verified)
   mio experience confirm --ids a,b   Confirm auto-claimed reuse (bulk supported)
   mio experience reuse --source-agent A --target-agent B --experience-id X   Record a reuse
-  mio creativity status        Show creativity hypothesis counts and recent top ideas
+  mio creativity status        Show creativity hypothesis counts, recent top ideas, adoption join
   mio creativity list          List creativity hypotheses (--status active|validated|rejected|draft, --sort novelty, --limit N)
   mio creativity generate      Generate hypotheses from 2+ --source "name|content" (or --from-insights; calls an LLM)
   mio creativity ferment       Review and refine active hypotheses (calls an LLM)
+  mio creativity adopt         Record an adoption event for a stored hypothesis (writes traces only)
   mio idea generate --goal "..."   Grounded idea pipeline: auto sources, novelty gate, persisted (calls an LLM)
   mio insight status           Insight counts: total, reported, unreported, high-value
   mio insight list             List insights (--unreported, --min-score N, --detector X, --limit N)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",
@@ -34,7 +34,7 @@
     "@akemi-mio/evolution-strategy": "^0.1.0",
     "@akemi-mio/evolution-safety": "^0.1.0",
     "@akemi-mio/evolution-scheduler": "^0.1.0",
-    "@akemi-mio/observer": "^0.1.4",
+    "@akemi-mio/observer": "^0.1.5",
     "@akemi-mio/insight": "^0.1.1",
     "@akemi-mio/creativity": "^0.1.0"
   },

package/server/creativity-engine.js

@@ -3,6 +3,7 @@
 const fs = require('fs')
 const path = require('path')
 const crypto = require('crypto')
+const { readJsonl } = require('./memory-store.js')
 const { evaluateNovelty } = require('@akemi-mio/creativity/NoveltyScorer')
 
 // Cache validity key for a JSONL file: a (size, mtimeMs) pair, the same
@@ -162,14 +163,34 @@ function mulberry32(seed) {
   }
 }
 
-function mixConcepts(sources, exploredPairs, rng) {
+// One concept-pair identity. `--source "name|content"` allows omitting the
+// pipe, so `name` can degrade into the entire description (often >1k chars):
+// with the raw name as identity, a tail edit mints a brand-new pair and
+// silently bypasses dedup. Trim + first 120 chars is short enough to read in
+// a key and long enough that genuine sources do not collide.
+function pairSourceKey(name) {
+  return String(name == null ? '' : name).trim().slice(0, 120)
+}
+
+function mixConcepts(sources, exploredPairs, rng, strategy) {
   if (sources.length < 2) return []
+  // Dedup identity is (pair, strategy): `strategy` picks the prompt and the
+  // temperature, so the documented fallback "hit 409, retry with another
+  // strategy" is a genuinely different experiment. Without the suffix every
+  // retry recomputed the same key and returned the same deterministic
+  // `all pairs already explored` — three LLM-less no-ops in a row.
+  const strat = String(strategy || '')
   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}`
+      const a = pairSourceKey(sources[i].name)
+      const b = pairSourceKey(sources[j].name)
+      const key = strat ? `${a}||${b}||${strat}` : `${a}||${b}`
+      const reverseKey = strat ? `${b}||${a}||${strat}` : `${b}||${a}`
       if (exploredPairs.has(key) || exploredPairs.has(reverseKey)) continue
+      // Records written without a strategy field carry the unsuffixed key;
+      // they must keep blocking every strategy (the old semantics).
+      if (strat && (exploredPairs.has(`${a}||${b}`) || exploredPairs.has(`${b}||${a}`))) continue
       pairs.push([sources[i], sources[j]])
     }
   }
@@ -237,8 +258,55 @@ function listRow(h) {
   }
 }
 
+// --- read-side adoption join (idea b19bada4, design discussion 1d2e22e4 D3) ---
+// The store never gains an `adopted` status (D1/D4, see adoptHypothesis at the
+// bottom of this file): adoption is joined at READ time from the two evidence
+// axes the write side owns -- an append-only `creativity.adopt` trace event
+// (payload.hypothesisId = the CLAIM, written by mio.creativity.adopt) and a
+// `hypothesis:<id>` tag on a memory record (the EVIDENCE, injected by
+// mio.memory.record's hypothesisId parameter). The engine sits in
+// <dataRoot>/creativity on both hosts (MCP: path.join(dataDir, 'creativity');
+// CLI: path.join(MIO_HOME, 'creativity')), so the two evidence files are one
+// dirname up -- the same dataRoot convention adoptHypothesis documents.
+// Missing files are fine: readJsonl returns [] for them.
+//
+// The counts are informational joins, NOT ADR-017 metrics: no rate and no
+// threshold by design (D3 -- adoption rate was explicitly out of scope).
+// `sources` follows the routeAdoption pattern (evaluation-store.js): names
+// each axis' backing file and that it is durable, so a reader can tell
+// "0 adopted" apart from "evidence not kept". claimed/evidenced are raw
+// distinct ids (they can include ids no longer in the store); adopted is the
+// inner join against stored hypotheses, the only count that answers "which
+// surviving hypotheses were adopted".
+const ADOPTION_TAG_PREFIX = 'hypothesis:'
+
+const ADOPTION_SOURCES = Object.freeze({
+  events: { file: 'traces.jsonl', durable: true },
+  memory: { file: 'memory.jsonl', durable: true },
+})
+
+function readAdoptionEvidence(rootDir) {
+  const claimed = new Set()
+  for (const record of readJsonl(path.join(rootDir, 'traces.jsonl'))) {
+    if (!record || record.event_type !== 'creativity.adopt') continue
+    const id = record.payload && record.payload.hypothesisId
+    if (id) claimed.add(String(id))
+  }
+  const evidenced = new Set()
+  for (const record of readJsonl(path.join(rootDir, 'memory.jsonl'))) {
+    if (!record || !Array.isArray(record.tags)) continue
+    for (const tag of record.tags) {
+      if (typeof tag !== 'string' || !tag.startsWith(ADOPTION_TAG_PREFIX)) continue
+      const id = tag.slice(ADOPTION_TAG_PREFIX.length).trim()
+      if (id) evidenced.add(id)
+    }
+  }
+  return { claimed, evidenced }
+}
+
 class CreativityEngine {
   constructor(dataDir, chatJson) {
+    this.dataDir = dataDir
     this.store = new CreativityStore(dataDir)
     this.chatJson = chatJson
     this.strategyIndex = 0
@@ -266,14 +334,35 @@ class CreativityEngine {
     const strat = strategy || STRATEGY_CYCLE[this.strategyIndex % STRATEGY_CYCLE.length]
     this.strategyIndex++
 
-    // Mix concepts
+    // Mix concepts. Keys carry the strategy each record was written with, so
+    // explore -> signal -> stable retries each get their own attempt while a
+    // record without a strategy stays unsuffixed and blocks every strategy.
     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))
+    const exploredPairs = new Set(
+      recent.flatMap((h) =>
+        (h.sourceLabels || []).flatMap((l, i, a) => {
+          if (i === 0) return []
+          const x = pairSourceKey(a[i - 1])
+          const y = pairSourceKey(l)
+          return h.strategy ? [`${x}||${y}||${h.strategy}`] : [`${x}||${y}`]
+        })
+      )
+    )
+    const pairs = mixConcepts(sources, exploredPairs, this.rng.bind(this), strat)
 
     if (pairs.length === 0) {
-      return { ideas: [], reason: 'all pairs already explored' }
+      // The bare string made a deterministic failure look like "this strategy
+      // did not work, maybe the next one will" — callers that degrade by
+      // switching strategy burned two LLM-less retries before learning the
+      // material pool itself was exhausted.
+      const candidatePairs = (sources.length * (sources.length - 1)) / 2
+      return {
+        ideas: [],
+        reason: `all pairs already explored for strategy "${strat}" (${sources.length} sources, ${candidatePairs} candidate pairs)`,
+        strategy: strat,
+        pairsAvailable: 0,
+      }
     }
 
     // Generate hypotheses via LLM
@@ -469,6 +558,20 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibili
     return { fermented: results.length, results, errors }
   }
 
+  // Fresh per call: both evidence files are append-only and a long-lived MCP
+  // server must see new adopt events / memory tags without a restart (same
+  // rationale as the insight-store mtime cache -- minus the cache, since this
+  // is two small file reads on a read-only report path).
+  _adoption() {
+    const { claimed, evidenced } = readAdoptionEvidence(path.dirname(this.dataDir))
+    const storedIds = new Set(this.store.getHypotheses().map((h) => h.id))
+    const adoptedIds = new Set()
+    for (const id of [...claimed, ...evidenced]) {
+      if (storedIds.has(id)) adoptedIds.add(id)
+    }
+    return { claimed, evidenced, adoptedIds }
+  }
+
   status() {
     const count = this.store.count()
     const active = this.store.getHypotheses({ status: 'active' })
@@ -477,6 +580,7 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibili
     // draft is a real state -- ferment() reviews draft + active -- so hiding it
     // here made `status` and `list --status draft` disagree.
     const draft = this.store.getHypotheses({ status: 'draft' })
+    const adoption = this._adoption()
 
     return {
       ...count,
@@ -484,6 +588,19 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibili
       validated: validated.length,
       rejected: rejected.length,
       draft: draft.length,
+      // Derived join of the two evidence axes (see readAdoptionEvidence).
+      // metric:false is load-bearing: this is NOT an ADR-017 evaluation metric,
+      // so no rate and no threshold are reported -- adoption rate was explicitly
+      // out of scope (D3). sources names the backing files, routeAdoption style.
+      adoption: {
+        adopted: adoption.adoptedIds.size,
+        claimed: adoption.claimed.size,
+        evidenced: adoption.evidenced.size,
+        metric: false,
+        note:
+          'derived join of creativity.adopt events and hypothesis:<id> memory tags — informational; no rate or threshold by design',
+        sources: ADOPTION_SOURCES,
+      },
       recentIdeas: active.slice(-5).map(h => ({
         id: h.id,
         title: h.title,
@@ -503,6 +620,11 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibili
   // result. `limit: 0` (and only 0) opts back into "everything".
   list(opts = {}) {
     const limit = opts.limit === undefined ? 20 : opts.limit
+    // Same read-side join as status(): every row carries `adopted` so the two
+    // surfaces cannot disagree (the CLI/MCP entry points already share this
+    // engine). listRow() stays the pure store-row shape; decoration is here.
+    const adoption = this._adoption()
+    const decorate = (row) => ({ ...row, adopted: adoption.adoptedIds.has(row.id) })
     if (opts.sort === 'novelty') {
       // Relative novelty ranking (read-only, nothing written back). Pairwise
       // Jaccard is O(n²) — bound candidates to the newest 200 (spec Risk 3).
@@ -513,9 +635,13 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibili
         return { ...listRow(h), noveltyScore: verdict.adjustedNovelty }
       })
       rows.sort((a, b) => b.noveltyScore - a.noveltyScore || (b.createdAt || 0) - (a.createdAt || 0))
-      return limit === 0 ? rows : rows.slice(0, limit)
+      const decorated = rows.map(decorate)
+      return limit === 0 ? decorated : decorated.slice(0, limit)
     }
-    return this.store.getHypotheses({ status: opts.status, limit }).map(listRow)
+    return this.store
+      .getHypotheses({ status: opts.status, limit })
+      .map(listRow)
+      .map(decorate)
   }
 
   _buildGenerationPrompt(a, b, strategy, recentHypotheses, rejectedHypotheses) {
@@ -564,4 +690,69 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibili
   }
 }
 
-module.exports = { CreativityEngine, CreativityStore, sourcesFromInsights, isoOf }
+// Adoption evidence (idea b19bada4, design discussion 1d2e22e4 D1/D4): the
+// store never gains an `adopted` status -- adoption is a relation between a
+// stored hypothesis and the outside world, not an attribute of the hypothesis,
+// so it lives as an append-only `creativity.adopt` trace event, optionally
+// cross-checked against a memory record carrying the `hypothesis:<id>` tag.
+// The host (MCP or CLI) passes its own ingestObservation so both entry points
+// write byte-identical events; dataRoot is the directory holding memory.jsonl
+// and traces.jsonl -- the engine sits in <dataRoot>/creativity on both hosts
+// (see cliCreativityEngine in bin/mio.js). Every validation failure happens
+// before ingest, so a rejected call never pollutes the event stream. This
+// function writes traces only: it never touches memory.jsonl (the
+// generate/ferment write nothing to Memory boundary extends here).
+function adoptHypothesis(engine, args = {}, ingest, dataRoot) {
+  const hypothesisId = String(args.hypothesisId || '').trim()
+  if (!hypothesisId) {
+    throw new Error('mio.creativity.adopt requires hypothesisId: a stored hypothesis UUID')
+  }
+  if (!engine.store.getHypotheses().some((h) => h.id === hypothesisId)) {
+    throw new Error(`mio.creativity.adopt: no stored hypothesis with id "${hypothesisId}"`)
+  }
+  const memoryId = String(args.memoryId || '').trim()
+  if (memoryId) {
+    const memoryPath = path.join(dataRoot, 'memory.jsonl')
+    const records = fs.existsSync(memoryPath)
+      ? fs
+          .readFileSync(memoryPath, 'utf-8')
+          .split('\n')
+          .filter(Boolean)
+          .map((line) => {
+            try { return JSON.parse(line) } catch { return null }
+          })
+          .filter(Boolean)
+      : []
+    const record = records.find((r) => r && r.id === memoryId)
+    if (!record) {
+      throw new Error(`mio.creativity.adopt: no memory record with id "${memoryId}"`)
+    }
+    const tag = `hypothesis:${hypothesisId}`
+    if (!Array.isArray(record.tags) || !record.tags.includes(tag)) {
+      throw new Error(`mio.creativity.adopt: memory record "${memoryId}" is missing tag "${tag}"`)
+    }
+  }
+  if (typeof ingest !== 'function') {
+    throw new Error('mio.creativity.adopt: ingest is not available on this host')
+  }
+  const taskId = String(args.taskId || '').trim()
+  const note = String(args.note || '').trim()
+  const result = ingest({
+    trace_id: `creativity-adopt:${hypothesisId}:${Date.now()}`,
+    event_type: 'creativity.adopt',
+    outcome: 'success',
+    payload: {
+      hypothesisId,
+      ...(memoryId ? { memoryId } : {}),
+      ...(taskId ? { taskId } : {}),
+      ...(note ? { note } : {}),
+    },
+  })
+  return {
+    recorded: true,
+    hypothesisId,
+    event: (result && result.event) || result,
+  }
+}
+
+module.exports = { CreativityEngine, CreativityStore, sourcesFromInsights, isoOf, adoptHypothesis }

package/server/memory-store.js

@@ -518,12 +518,23 @@ function createMemoryStore(options = {}) {
     const content = String(args.content || '').trim()
     if (!content) throw new Error('memory.record requires a non-empty content')
     const scope = normalizeScope(args.scope)
+    // Adoption evidence (idea b19bada4, task 2261a5f4): hypothesisId is pure
+    // sugar for the exact tag `mio.creativity.adopt` enforces — the record
+    // joins the creativity hypothesis through the same `hypothesis:<uuid>`
+    // tag the tags AND-filter already searches. Omitted, the record keeps
+    // the exact legacy shape: no extra field, tags byte-identical.
+    const hypothesisId = String(args.hypothesisId || '').trim()
+    const tags = normalizeTags(args.tags)
+    if (hypothesisId) {
+      const tag = `hypothesis:${hypothesisId}`
+      if (!tags.includes(tag)) tags.push(tag)
+    }
     const record = {
       id: createId('mem'),
       timestamp: new Date().toISOString(),
       kind: args.kind || 'note',
       content,
-      tags: normalizeTags(args.tags),
+      tags,
       project: scope === 'global' ? null : args.project || projectName(),
       scope,
       source: args.source || agentId() || 'mcp',

package/server/mio-intelligence-mcp/index.js

@@ -20,7 +20,7 @@ const { createSubscriptionStore } = require('../subscription-store.js')
 const { createDigest } = require('../digest.js')
 const { createEvolutionReport } = require('../evolution-report.js')
 
-const { CreativityEngine, sourcesFromInsights } = require('../creativity-engine.js')
+const { CreativityEngine, sourcesFromInsights, adoptHypothesis } = require('../creativity-engine.js')
 const { buildAutoSources, topUpSources } = require('../creativity-sources.js')
 const { runIdeaGenerate, groundingFrom } = require('../idea-generate.js')
 // The observer and insight engines are optional dependencies. Their stores own
@@ -351,6 +351,11 @@ const TOOLS = [
         content: { type: 'string', description: 'Memory content.' },
         kind: { type: 'string', description: 'Memory kind, such as decision, context, or problem.' },
         tags: { type: 'array', items: { type: 'string' }, description: 'Optional tags.' },
+        hypothesisId: {
+          type: 'string',
+          description:
+            'Optional creativity hypothesis UUID. Injects the tag "hypothesis:<id>" so this record joins that hypothesis (the tag mio.creativity.adopt enforces); search it back via memory.query tags.',
+        },
         project: { type: 'string', description: 'Project name. Defaults to current directory name.' },
         scope: { type: 'string', description: 'Record scope: project (default) or global.' },
         source: { type: 'string', description: 'Recording source. Defaults to mcp.' },
@@ -696,12 +701,12 @@ const TOOLS = [
   },
   {
     name: 'mio.creativity.status',
-    description: 'Show creativity engine status: hypothesis counts, active/validated/rejected/draft, recent top ideas.',
+    description: 'Show creativity engine status: hypothesis counts, active/validated/rejected/draft, recent top ideas, plus the adoption evidence join — adopted/claimed/evidenced counts with sources (informational, NOT a metric; derived from creativity.adopt trace events and hypothesis:<id> memory tags).',
     inputSchema: { type: 'object', properties: {} },
   },
   {
     name: 'mio.creativity.list',
-    description: 'List creativity hypotheses with optional status filter. Newest 20 by default; pass limit: 0 for everything.',
+    description: 'List creativity hypotheses with optional status filter. Newest 20 by default; pass limit: 0 for everything. Each row carries adopted: true when a creativity.adopt event or a hypothesis:<id> memory tag exists for its id (read-side evidence join, informational).',
     inputSchema: {
       type: 'object',
       properties: {
@@ -735,7 +740,7 @@ const TOOLS = [
           type: 'boolean',
           description: 'Seed concept sources from stored insights (highest score first), merged with any explicit sources. Needs @akemi-mio/insight and at least one stored insight.',
         },
-        strategy: { type: 'string', description: 'Generation strategy: explore (cross-domain), signal (provocative), stable (conservative). Auto-selected if omitted.' },
+        strategy: { type: 'string', description: 'Generation strategy: explore (cross-domain), signal (provocative), stable (conservative). Auto-selected if omitted. Pair dedup is per strategy: the same source pair may be tried once under each strategy.' },
       },
     },
   },
@@ -749,6 +754,21 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'mio.creativity.adopt',
+    description:
+      'Record that a stored creativity hypothesis was adopted: validates the hypothesis id, then appends a creativity.adopt trace event (who/when/what). Optionally enforces that the referenced memory record carries the hypothesis:<id> tag. Writes traces only — never Mio memory, never hypothesis status.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        hypothesisId: { type: 'string', description: 'UUID of a stored hypothesis (creativity-hypotheses.jsonl). Must exist or the call fails.' },
+        memoryId: { type: 'string', description: 'Optional memory record id. If given, the record must exist and carry the tag "hypothesis:<hypothesisId>" or the call fails.' },
+        taskId: { type: 'string', description: 'Optional task id this adoption feeds.' },
+        note: { type: 'string', description: 'Optional short rationale for the adoption.' },
+      },
+      required: ['hypothesisId'],
+    },
+  },
   {
     name: 'mio.idea.generate',
     description:
@@ -1116,6 +1136,8 @@ async function callTool(name, args = {}) {
       return creativityEngine.generate(generationSources(args), args.strategy)
     case 'mio.creativity.ferment':
       return creativityEngine.ferment(args.limit)
+    case 'mio.creativity.adopt':
+      return adoptHypothesis(creativityEngine, args, ingestObservation, dataDir)
     case 'mio.idea.generate': {
       const goal = typeof args.goal === 'string' ? args.goal.trim() : ''
       if (!goal) throw new Error('mio.idea.generate requires goal: a non-empty string')