mio-agent-runtime 0.13.5 → 0.14.1

package/README.md

@@ -57,6 +57,7 @@ mio creativity status        Show creativity hypothesis counts and recent top id
 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 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)
 mio insight generate         Generate insights from context (--memory "kind|content"/--summary "text"; calls an LLM)
@@ -101,7 +102,7 @@ mio --version                Print the version and exit (-V)
 
 ## MCP 工具
 
-MCP 服务端在 5 大域共暴露 50 个工具：
+MCP 服务端在 5 大域共暴露 51 个工具：
 
 ### 记忆（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`
@@ -114,15 +115,15 @@ MCP 服务端在 5 大域共暴露 50 个工具：
 ### 洞察自省（4）
 `mio.insight.status` · `mio.insight.list` · `mio.insight.mark_reported` · `mio.insight.generate`
 
-### 创意引擎（4）
-`mio.creativity.generate` · `mio.creativity.ferment` · `mio.creativity.list` · `mio.creativity.status`
+### 创意引擎（5）
+`mio.creativity.generate` · `mio.creativity.ferment` · `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`
 
 ## 包
 
-`mio-agent-runtime` 依赖发布在 `@akemi-mio` scope 下的 **9** 个包（声明于 `package.json`，均为 `0.1.0`）。它们仅在源码变更时才发布，所以普通的 CLI 发布不会重新发布这些包。
+`mio-agent-runtime` 依赖发布在 `@akemi-mio` scope 下的 **10** 个包（声明于 `package.json`，均为 `0.1.0`）。它们仅在源码变更时才发布，所以普通的 CLI 发布不会重新发布这些包。
 
 | 依赖 | 说明 |
 |---|---|
@@ -135,6 +136,7 @@ MCP 服务端在 5 大域共暴露 50 个工具：
 | `@akemi-mio/evolution-scheduler` | 演化调度器 |
 | `@akemi-mio/observer` | ObserverService —— 多源数据采集、趋势分析、深度研究、世界模型、发酵、DAG 状态机、自演化引擎（唯一运行时依赖 `undici`，只用于走代理采集） |
 | `@akemi-mio/insight` | InsightService —— 基于 LLM 的洞察生成、冲突/漂移/重复/停滞目标/摩擦检测器、在场服务、洞察打分（零 npm 依赖） |
+| `@akemi-mio/creativity` | IdeaGenerator / NoveltyScorer / SourceAggregator —— `mio idea generate` 与创意引擎的生成算法（依赖 `@akemi-mio/core`） |
 
 以下 `@akemi-mio` 包同样位于本 monorepo 中并独立发布，但**不是**本 CLI 的依赖——其源码从不 import 它们，因此未声明在 `package.json` 里：
 
@@ -146,9 +148,9 @@ MCP 服务端在 5 大域共暴露 50 个工具：
 
 它们可直接被其它 Node 项目消费。`mio-agent-runtime` 自身是 CLI + MCP server 包。
 
-### 与宿主耦合的包（不发布）
+### 曾经不发布的两个包（现已发布）
 
-`@akemi-mio/core` 与 `@akemi-mio/creativity` 通过 `workspace:*` 链接在本 monorepo 内部消费，因此从源码构建，**不**发布到 npm。`packages/cli/` 已不存在。不要把这两个包加进下游 `package.json`——安装会失败。
+`@akemi-mio/core` 与 `@akemi-mio/creativity` 自 `mio-agent-runtime@0.14.0` 起发布到 npm（`0.1.0`）。`@akemi-mio/creativity` 是本 CLI 的直接依赖，`@akemi-mio/core` 经由它传递引入；其它 Node 项目可直接安装这两个包。
 
 ## 宿主说明
 
@@ -414,13 +416,20 @@ mio creativity ferment --limit 3
 
 - `--source "名称|内容"` **至少两个**：引擎是把概念两两配对来产生新假设的，
   一个来源在构造上就不可能产出组合（此时**不会**调用 LLM，直接返回
-  `need at least 2 sources`）。
+  `need at least 2 sources`）。显式来源不足 2 个时，本地自动来源（memory / traces / 已存假设；MCP 侧还含 insight 与 observer 趋势）会先把列表补齐到 2——显式 `--source` 永远排在前面且不被替换；补齐后仍不足 2 个才报上面的错。
 - **`--from-insights`（MCP 侧为 `fromInsights: true`）用已存洞察补足概念来源**：
   读取 `mio insight list` 能看到的同一份存储，按分数取前 10 条映射成
   `{ name, content, type: 'insight' }`，再与显式的 `--source` 合并。它只在
   `@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`
@@ -428,10 +437,24 @@ mio creativity ferment --limit 3
   打印 `N pair(s) failed:`。此前 `catch {}` 让「端点挂了」与「这一对确实没有
   新意」长得一模一样——`ideas: []` / `Nothing fermented` 两种输出都无法区分。
 
+### 目标驱动的 idea 流水线（`mio idea generate`）
+
+一个 goal 直接产出可实验的假设（MCP 面为 `mio.idea.generate`），来源全程本地优先组装：
+
+```bash
+mio idea generate --goal "降低 MCP 调用延迟" --context "近三天 p95 上升" --constraint "不引入新依赖"
+mio idea generate --goal "扩大命令覆盖" --json
+```
+
+- **来源顺序**：goal → context → constraints → 记忆 grounding（取前 3 条，`scope: all`）→ 本地自动来源（memory / traces / 已存假设，MCP 侧还含 insight 与 observer 趋势），按 `origin` 去重；凑不足 2 个时返回 `reason` 文案而不是报错。
+- **每条 idea 都持久化**到 `<MIO_HOME>/creativity/creativity-hypotheses.jsonl`（`draft`，带 `provenance`：strategy / technique / relatedMemoryIds / 命中来源 / generatedAt），**绝不写入 Mio memory**。
+- **novelty 门禁**：与已 `rejected` 假设近似重复的候选落盘为 `rejected` 并带 `rejectionReason`；与近期假设相似的只降分。拒绝的假设同样入库，供后续去重。
+- `--num` 钳制在 1..3（默认 3）；`--json` 返回完整结构 `{ ideas, generatedAt, groundedWith, persistedIds }`。
+
 #### LLM 配置
 
-只有 4 条命令会调用大模型：`mio creativity generate` / `ferment`、
-`mio insight generate`、`mio observer ferment`。它们共用
+只有 5 条命令会调用大模型：`mio creativity generate` / `ferment`、
+`mio idea generate`、`mio insight generate`、`mio observer ferment`。它们共用
 `server/llm-client.js` 这一份实现，配置也共用同一套解析顺序：
 
 ```

package/bin/mio.js

@@ -24,6 +24,8 @@ 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 { buildAutoSources, topUpSources } = require('../server/creativity-sources.js')
+const { runIdeaGenerate, groundingFrom } = require('../server/idea-generate.js')
 const { createAgentStore } = require('../server/agent-store.js')
 const { createEvaluationStore } = require('../server/evaluation-store.js')
 const { createInsightStore, isInsightAvailable } = require('../server/insight-store.js')
@@ -2065,7 +2067,7 @@ function observerCommand(args, useJson) {
 function creativityUsage(write = console.log) {
   write(`Usage:
   mio creativity status              Show hypothesis counts and recent top ideas
-  mio creativity list                List hypotheses (--status active|validated|rejected|draft, --limit N)
+  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)
@@ -2073,6 +2075,7 @@ function creativityUsage(write = console.log) {
 Options:
   --status name      Filter list by status
   --limit N          Max results for list / ferment (default 20 / 5); --limit 0 lists everything
+  --sort novelty     Rank list by relative noveltyScore (a dedup signal, not a quality score)
   --source "name|content"   A concept source for generate; repeat 2+ times
   --from-insights    Seed generate's sources from stored insights (needs @akemi-mio/insight)
   --strategy explore|signal|stable   Generation strategy (auto-selected if omitted)
@@ -2081,6 +2084,7 @@ Options:
 Examples:
   mio creativity status
   mio creativity list --status rejected --limit 10
+  mio creativity list --sort novelty
   mio creativity generate --source "auth|token rotation" --source "cache|write-through"
   mio creativity generate --from-insights --source "auth|token rotation"
 
@@ -2114,7 +2118,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})`)
+    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(`   ${labels} | ${when} | ${h.id}`)
     if (h.fermentCount) console.log(`   fermented ${h.fermentCount}x`)
   })
@@ -2162,6 +2166,26 @@ function printCreativityErrors(errors, label) {
   }
 }
 
+// Auto sources for generate's top-up: the same local providers the MCP server
+// uses, assembled from the CLI's global MIO_HOME (spec Capability 2). Every
+// layer degrades to [] — a missing optional package or an unreadable store
+// must never fail `mio creativity generate`.
+function cliAutoSources() {
+  let insights = []
+  let trends = []
+  try {
+    if (isInsightAvailable()) insights = cliInsightStore().list({}) || []
+  } catch (_) {}
+  try {
+    if (isObserverAvailable()) trends = cliObserverStore().trends({ limit: 3 }) || []
+  } catch (_) {}
+  try {
+    return buildAutoSources({ dataDir: MIO_HOME, insights, trends })
+  } catch (_) {
+    return []
+  }
+}
+
 function creativityGenerateCommand(args, useJson) {
   const flags = args.slice(2)
   let sources = parseSources(flags)
@@ -2191,6 +2215,15 @@ function creativityGenerateCommand(args, useJson) {
     sources = sources.concat(seeds)
   }
 
+  // Auto top-up (spec Capability 2, injection point 2): explicit --source
+  // entries win; when fewer than two remain, local memory/traces/stored
+  // hypotheses (plus insight/observer observations) fill the gap. If the
+  // topped-up set is still short, the errors below keep their old wording.
+  if (sources.length < 2) {
+    const topped = topUpSources(sources, cliAutoSources())
+    if (topped.length >= 2) sources = topped
+  }
+
   if (sources.length < 2) {
     if (flagPresent(flags, '--from-insights')) {
       console.error(`mio creativity generate needs at least 2 concept sources; --from-insights only supplied ${sources.length}.`)
@@ -2263,6 +2296,90 @@ function creativityFermentCommand(args, useJson) {
   })
 }
 
+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()
+  if (!goal) {
+    console.error('mio idea generate requires --goal "..."')
+    ideaUsage()
+    process.exitCode = 1
+    return
+  }
+  const context = optionValue(flags, '--context') || ''
+  const constraints = optionValues(flags, '--constraint')
+  let numIdeas
+  try {
+    numIdeas = parseNumberOption(flags, '--num')
+  } catch (error) {
+    console.error(error.message || error)
+    ideaUsage()
+    process.exitCode = 1
+    return
+  }
+
+  // Grounding from the CLI's global MIO_HOME. A failed query degrades to "no
+  // grounding" — never a hard error (spec Capability 1: local-first, tolerant).
+  // The core logger echoes every event to stdout; in --json mode that would
+  // corrupt the payload jsonOrText must own, so the echo is routed to stderr
+  // while the pipeline runs (executed deviation — the plan assumed pure JSON).
+  const echoLog = useJson ? console.log : null
+  if (useJson) console.log = (...params) => console.error(...params)
+
+  let result
+  try {
+    let grounding = { sources: [], relatedMemoryIds: [], groundedWith: 0 }
+    try {
+      const qr = await cliMemoryStore().queryMemory({ query: goal, limit: 3, scope: 'all' })
+      grounding = groundingFrom(qr)
+    } catch (_) {}
+
+    if (!useJson) warnIfLlmUnconfigured()
+
+    result = await runIdeaGenerate({
+      goal,
+      context,
+      constraints,
+      numIdeas,
+      chatJson,
+      store: cliCreativityEngine().store,
+      groundingSources: grounding.sources,
+      relatedMemoryIds: grounding.relatedMemoryIds,
+      autoSources: cliAutoSources(),
+    })
+  } catch (error) {
+    console.error(error.message || error)
+    process.exitCode = 1
+    return
+  } finally {
+    if (useJson) console.log = echoLog
+  }
+
+  if (useJson) return jsonOrText(result, true)
+  if (result.reason) {
+    console.log(`No ideas generated: ${result.reason}`)
+    return
+  }
+  console.log(`Generated ${result.ideas.length} idea(s) (grounded with ${result.groundedWith} memories)`)
+  result.ideas.forEach((idea) => {
+    console.log(`- [${idea.hypothesis.status}] ${idea.title}`)
+    console.log(`  novelty=${idea.hypothesis.novelty} feasibility=${idea.hypothesis.feasibility} impact=${idea.hypothesis.impact} | ${idea.hypothesis.id}`)
+    if (idea.provenance && idea.provenance.technique) console.log(`  technique=${idea.provenance.technique}`)
+    if (idea.hypothesis.rejectionReason) console.log(`  rejected: ${idea.hypothesis.rejectionReason}`)
+  })
+  console.log(`Persisted ${result.persistedIds.length} idea(s)`)
+}
+
+function ideaCommand(args, useJson) {
+  const sub = args[1]
+  if (sub === 'generate') return ideaGenerateCommand(args, useJson)
+  ideaUsage()
+  process.exitCode = 1
+}
+
 function creativityCommand(args, useJson) {
   const sub = args[1]
 
@@ -2289,9 +2406,16 @@ function creativityCommand(args, useJson) {
     if (sub === 'status') {
       result = engine.status()
     } else {
+      const sort = optionValue(flags, '--sort')
+      if (sort !== undefined && sort !== 'novelty') {
+        console.error(`mio creativity list: unknown --sort "${sort}" (supported: novelty)`)
+        process.exitCode = 1
+        return
+      }
       result = engine.list({
         status: optionValue(flags, '--status'),
         limit: parseNumberOption(flags, '--limit'),
+        sort,
       })
     }
   } catch (error) {
@@ -3369,9 +3493,10 @@ Usage:
   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 list          List creativity hypotheses (--status active|validated|rejected|draft, --limit N)
+  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 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)
   mio insight generate         Generate insights from context (--memory "kind|content"/--summary "text"; calls an LLM)
@@ -3435,6 +3560,8 @@ async function main() {
       return policyCommand(args, useJson)
     case 'creativity':
       return creativityCommand(args, useJson)
+    case 'idea':
+      return ideaCommand(args, useJson)
     case 'insight':
       return insightCommand(args, useJson)
     case 'observer':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.13.5",
+  "version": "0.14.1",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",
@@ -17,6 +17,7 @@
     "!server/mio-intelligence-mcp/__tests__"
   ],
   "scripts": {
+    "pretest": "node scripts/link-workspace.cjs",
     "check": "node scripts/check-syntax.cjs",
     "test": "node --test \"__tests__/*.test.js\" \"server/mio-intelligence-mcp/__tests__/*.test.js\"",
     "prepack": "npm run check",
@@ -34,7 +35,8 @@
     "@akemi-mio/evolution-safety": "^0.1.0",
     "@akemi-mio/evolution-scheduler": "^0.1.0",
     "@akemi-mio/observer": "^0.1.4",
-    "@akemi-mio/insight": "^0.1.1"
+    "@akemi-mio/insight": "^0.1.1",
+    "@akemi-mio/creativity": "^0.1.0"
   },
   "main": "index.js",
   "directories": {

package/scripts/link-workspace.cjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+'use strict'
+
+// Creates the node_modules junctions mio-cli needs to require the workspace
+// packages it depends on at runtime (@akemi-mio/insight etc. already exist as
+// junctions in a normal checkout; a fresh clone has none). Idempotent: an
+// existing link (or directory) is left alone. Windows junctions, because this
+// checkout lives on NTFS and junctions need no admin rights.
+
+const fs = require('fs')
+const path = require('path')
+
+const REPO = path.resolve(__dirname, '..', '..', '..')
+const links = [
+  {
+    at: path.join(REPO, 'packages', 'mio-cli', 'node_modules', '@akemi-mio', 'creativity'),
+    target: path.join(REPO, 'packages', 'creativity'),
+  },
+  {
+    at: path.join(REPO, 'packages', 'creativity', 'node_modules', '@akemi-mio', 'core'),
+    target: path.join(REPO, 'packages', 'core'),
+  },
+  // Root-level links: the new tests under tests/main/creativity/ import
+  // '@akemi-mio/creativity/*' from the repo root, and the lockfile's
+  // link:true entries are not materialized on disk (ground rule 4 forbids
+  // the `npm install` that would create them).
+  {
+    at: path.join(REPO, 'node_modules', '@akemi-mio', 'creativity'),
+    target: path.join(REPO, 'packages', 'creativity'),
+  },
+  {
+    at: path.join(REPO, 'node_modules', '@akemi-mio', 'core'),
+    target: path.join(REPO, 'packages', 'core'),
+  },
+]
+
+for (const { at, target } of links) {
+  let exists = false
+  try {
+    fs.lstatSync(at)
+    exists = true
+  } catch (_) {
+    exists = false
+  }
+  if (exists) {
+    console.log(`exists  ${at}`)
+    continue
+  }
+  fs.mkdirSync(path.dirname(at), { recursive: true })
+  fs.symlinkSync(target, at, 'junction')
+  console.log(`linked  ${at} -> ${target}`)
+}

package/server/creativity-engine.js

@@ -3,6 +3,7 @@
 const fs = require('fs')
 const path = require('path')
 const crypto = require('crypto')
+const { evaluateNovelty } = require('@akemi-mio/creativity/NoveltyScorer')
 
 // Cache validity key for a JSONL file: a (size, mtimeMs) pair, the same
 // guard server/insight-store.js uses (commit 0ba7fa8). Every getter below used
@@ -27,6 +28,13 @@ function clamp100(value, fallback = 50) {
   return Math.min(100, Math.max(0, n))
 }
 
+// ISO timestamp for provenance: accepts epoch ms or date strings, returns
+// undefined when the value is missing or unparsable.
+function isoOf(value) {
+  const t = typeof value === 'number' ? value : Date.parse(value || '')
+  return Number.isFinite(t) ? new Date(t).toISOString() : undefined
+}
+
 // ═══════════════════════════════════════════════
 //  JSONL Store — ideas, combos, experiments
 // ═══════════════════════════════════════════════
@@ -154,14 +162,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]])
     }
   }
@@ -173,43 +201,6 @@ function mixConcepts(sources, exploredPairs, rng) {
   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
 // ═══════════════════════════════════════════════
@@ -234,12 +225,38 @@ function sourcesFromInsights(insights, limit = 10) {
         Array.isArray(i.evidence) && i.evidence.length > 0 ? `Evidence: ${i.evidence.join('; ')}` : '',
       ].filter(Boolean).join('\n'),
       type: 'insight',
-      weight: 0.7,
+      // > 0.7: IdeaGenerator.applyTemperature keeps any weight>0.7 source unconditionally.
+      weight: 0.78,
+      origin: `insight:${i.id || i.title || 'unknown'}`,
+      ...(i.id ? { originId: i.id } : {}),
+      ...(isoOf(i.createdAt) ? { timestamp: isoOf(i.createdAt) } : {}),
     }))
 }
 
 const STRATEGY_CYCLE = ['explore', 'signal', 'stable']
 
+// One row shape for every list variant — the fields JSON/CLI consumers already
+// depend on. `noveltyScore` is added only by sort=novelty (relative ranking),
+// never confused with the quality sum `score`.
+function listRow(h) {
+  return {
+    id: h.id,
+    title: h.title,
+    idea: h.idea,
+    status: h.status,
+    novelty: h.novelty,
+    feasibility: h.feasibility,
+    impact: h.impact,
+    ...(h.logic !== undefined ? { logic: h.logic } : {}),
+    score: h.novelty + h.feasibility + h.impact,
+    sourceLabels: h.sourceLabels,
+    createdAt: h.createdAt,
+    fermentedAt: h.fermentedAt,
+    fermentCount: h.fermentCount,
+    ...(h.mergedInto !== undefined ? { mergedInto: h.mergedInto } : {}),
+  }
+}
+
 class CreativityEngine {
   constructor(dataDir, chatJson) {
     this.store = new CreativityStore(dataDir)
@@ -269,14 +286,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
@@ -506,22 +544,19 @@ 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
-    return this.store.getHypotheses({ ...opts, limit }).map(h => ({
-      id: h.id,
-      title: h.title,
-      idea: h.idea,
-      status: h.status,
-      novelty: h.novelty,
-      feasibility: h.feasibility,
-      impact: h.impact,
-      ...(h.logic !== undefined ? { logic: h.logic } : {}),
-      score: h.novelty + h.feasibility + h.impact,
-      sourceLabels: h.sourceLabels,
-      createdAt: h.createdAt,
-      fermentedAt: h.fermentedAt,
-      fermentCount: h.fermentCount,
-      ...(h.mergedInto !== undefined ? { mergedInto: h.mergedInto } : {}),
-    }))
+    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).
+      const candidates = this.store.getHypotheses({ status: opts.status }).slice(-200)
+      const rows = candidates.map((h) => {
+        const others = candidates.filter((x) => x.id !== h.id)
+        const verdict = evaluateNovelty(h, others, [])
+        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)
+    }
+    return this.store.getHypotheses({ status: opts.status, limit }).map(listRow)
   }
 
   _buildGenerationPrompt(a, b, strategy, recentHypotheses, rejectedHypotheses) {
@@ -570,4 +605,4 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibili
   }
 }
 
-module.exports = { CreativityEngine, CreativityStore, sourcesFromInsights }
+module.exports = { CreativityEngine, CreativityStore, sourcesFromInsights, isoOf }

package/server/creativity-sources.js

@@ -0,0 +1,186 @@
+'use strict'
+
+// Source auto-aggregation for the creativity engine (spec Capability 2).
+//
+// Default providers read ONLY local MIO_HOME data — zero network. Insight and
+// observer sources arrive as plain arrays from the caller, because only the
+// entry point knows which store is authoritative (MIO_HOME for the CLI, the
+// MCP server's MIO_DATA_DIR) and whether its optional package resolves.
+// SourceAggregator already tolerates a throwing provider (per-provider
+// try/catch with a WARN log), so providers here do not need extra guards.
+
+const fs = require('fs')
+const path = require('path')
+const { SourceAggregator } = require('@akemi-mio/creativity/SourceAggregator')
+const { sourcesFromInsights, isoOf } = require('./creativity-engine.js')
+
+function readJsonl(file) {
+  try {
+    return fs
+      .readFileSync(file, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        try { return JSON.parse(line) } catch { return null }
+      })
+      .filter(Boolean)
+  } catch (_) {
+    return []
+  }
+}
+
+// Every weight is > 0.7 on purpose: IdeaGenerator.applyTemperature keeps any
+// source with weight > 0.7 unconditionally (temperature 0.5 middle branch), so
+// the assembled set reaches the prompt intact — deterministic, no RNG survival.
+const WEIGHTS = {
+  memory: 0.75,
+  traceOk: 0.74,
+  traceFail: 0.73,
+  hypothesisActive: 0.72,
+  hypothesisRejected: 0.72,
+  trend: 0.76,
+}
+
+function memoryProvider(dataDir) {
+  return {
+    domain: 'feedback',
+    name: 'memory',
+    collect() {
+      return readJsonl(path.join(dataDir, 'memory.jsonl'))
+        .filter((r) => r && r.archived !== true && (r.kind === 'decision' || r.kind === 'note'))
+        .slice(-6)
+        .map((r) => ({
+          name: `${r.kind}: ${String(r.content || '').slice(0, 40)}`,
+          content: String(r.content || ''),
+          type: 'feedback',
+          weight: WEIGHTS.memory,
+          origin: `memory:${r.id}`,
+          originId: r.id,
+          timestamp: isoOf(r.timestamp),
+        }))
+    },
+  }
+}
+
+function traceProviders(dataDir) {
+  const events = () => readJsonl(path.join(dataDir, 'traces.jsonl')).slice(-40)
+  const fmt = (r) => `${r.event_type}${r.outcome ? `/${r.outcome}` : ''}: ${JSON.stringify(r.payload || {}).slice(0, 300)}`
+  const stamp = (r) => isoOf(r.timestamp ?? r.ts)
+  return [
+    {
+      domain: 'behavior',
+      name: 'traces-success',
+      collect() {
+        return events()
+          .filter((r) => r.event_type === 'task_outcome' && r.outcome === 'success')
+          .slice(-3)
+          .map((r) => ({
+            name: `success: ${String((r.payload && (r.payload.task || r.payload.summary)) || r.trace_id || 'task').slice(0, 40)}`,
+            content: fmt(r),
+            type: 'behavior',
+            weight: WEIGHTS.traceOk,
+            origin: `trace:${r.trace_id}`,
+            originId: r.trace_id,
+            timestamp: stamp(r),
+          }))
+      },
+    },
+    {
+      domain: 'failure',
+      name: 'traces-failure',
+      collect() {
+        return events()
+          .filter(
+            (r) =>
+              (r.event_type === 'error' || r.event_type === 'retry') ||
+              (r.event_type === 'task_outcome' && (r.outcome === 'failure' || r.outcome === 'error' || r.outcome === 'aborted')),
+          )
+          .slice(-3)
+          .map((r) => ({
+            name: `failure: ${String(r.event_type)}${r.trace_id ? ` ${String(r.trace_id).slice(0, 12)}` : ''}`,
+            content: fmt(r),
+            type: 'failure',
+            weight: WEIGHTS.traceFail,
+            origin: `trace:${r.trace_id || 'unknown'}`,
+            originId: r.trace_id,
+            timestamp: stamp(r),
+          }))
+      },
+    },
+  ]
+}
+
+function hypothesesProvider(dataDir) {
+  return {
+    domain: 'module',
+    name: 'hypotheses',
+    collect() {
+      return readJsonl(path.join(dataDir, 'creativity', 'creativity-hypotheses.jsonl'))
+        .filter((h) => h && (h.status === 'active' || h.status === 'rejected'))
+        .slice(-6)
+        .map((h) => ({
+          name: String(h.title || h.id).slice(0, 60),
+          content: `idea: ${h.idea}\nrisk: ${h.risk || '-'}`,
+          type: h.status === 'rejected' ? 'failure' : 'knowledge',
+          weight: h.status === 'rejected' ? WEIGHTS.hypothesisRejected : WEIGHTS.hypothesisActive,
+          origin: `hypothesis:${h.id}`,
+          originId: h.id,
+          timestamp: isoOf(h.createdAt),
+        }))
+    },
+  }
+}
+
+// Observer trend reports → provocation sources. The report schema has drifted
+// across observer versions, so fields are read defensively with fallbacks.
+function trendSources(trends) {
+  return (Array.isArray(trends) ? trends : []).slice(0, 4).map((t, i) => {
+    const title = (t && (t.title || t.name || t.date)) || `trend-${i}`
+    const body =
+      (t && t.summary) ||
+      (Array.isArray(t && t.themes) ? t.themes.join('; ') : '') ||
+      JSON.stringify(t || {}).slice(0, 400)
+    const key = (t && (t.date || t.id)) || String(i)
+    const stamp = isoOf(t && (t.generatedAt || t.date))
+    return {
+      name: String(title).slice(0, 60),
+      content: String(body),
+      type: 'provocation',
+      weight: WEIGHTS.trend,
+      origin: `observer-trends:${key}`,
+      ...(t && t.id ? { originId: t.id } : {}),
+      ...(stamp ? { timestamp: stamp } : {}),
+    }
+  })
+}
+
+// Assemble every local (+ optionally insight/observer) domain through the
+// package SourceAggregator so dedup, per-domain caps and failure tolerance
+// behave identically for idea.generate and the generate top-up.
+function buildAutoSources({ dataDir, insights = [], trends = [] }) {
+  const aggregator = new SourceAggregator(4, 1)
+  aggregator.addProvider(memoryProvider(dataDir))
+  for (const provider of traceProviders(dataDir)) aggregator.addProvider(provider)
+  aggregator.addProvider(hypothesesProvider(dataDir))
+  if (Array.isArray(insights) && insights.length > 0) {
+    aggregator.addProvider({ domain: 'observation', name: 'insight', collect: () => sourcesFromInsights(insights) })
+  }
+  const trendList = Array.isArray(trends) ? trends : []
+  if (trendList.length > 0) {
+    aggregator.addProvider({ domain: 'external', name: 'observer-trends', collect: () => trendSources(trendList) })
+  }
+  return aggregator.build()
+}
+
+// Explicit --source entries always win: auto sources only top a set up to the
+// two entries the concept mixer needs; they never replace or reorder explicit
+// ones (spec Capability 2, injection point 2).
+function topUpSources(explicit, auto) {
+  const list = Array.isArray(explicit) ? explicit.filter(Boolean) : []
+  if (list.length >= 2) return list
+  const seen = new Set(list.map((s) => s.name))
+  const extra = (Array.isArray(auto) ? auto : []).filter((s) => s && !seen.has(s.name))
+  return [...list, ...extra]
+}
+
+module.exports = { buildAutoSources, topUpSources, trendSources, memoryProvider, traceProviders, hypothesesProvider }

package/server/idea-generate.js

@@ -0,0 +1,136 @@
+'use strict'
+
+// `mio.idea.generate` — one-shot goal-driven idea pipeline (spec Capability 1).
+// Shared by the CLI (`mio idea generate`) and the MCP server (tool
+// `mio.idea.generate`): each entry point only assembles entry-specific inputs
+// (which store is authoritative, where local data lives) and renders the
+// response this module returns.
+//
+// Contract:
+//   - source order: goal → context → constraints → grounding → local auto,
+//     deduplicated by `origin` (fallback name), first occurrence wins — so a
+//     memory that arrives both as a grounding hit and through the local
+//     provider contributes exactly once, the grounding copy first;
+//   - pairing strategy: cross-type `explore` only when two types exist, else
+//     the `stable` fallback (an all-knowledge set explores into ZERO combos);
+//   - every candidate passes evaluateNovelty against stored hypotheses: a
+//     near-duplicate of a REJECTED one is persisted as rejected with a reason,
+//     a merely-similar recent one is down-scored; drafts AND rejects both land
+//     in the store so later runs can dedup against them;
+//   - ideas are never written to Mio memory — CreativityStore only.
+
+const { IdeaGenerator } = require('@akemi-mio/creativity/IdeaGenerator')
+const { evaluateNovelty } = require('@akemi-mio/creativity/NoveltyScorer')
+
+// All > 0.7: IdeaGenerator.applyTemperature keeps such sources unconditionally
+// (temperature 0.5 middle branch) — deterministic prompt, no RNG survival.
+const WEIGHTS = { goal: 0.95, context: 0.9, constraint: 0.88, grounding: 0.75 }
+
+// `queryMemory` result → grounding sources + ids. Tolerates null/empty
+// (a thrown query is the caller's problem to catch; a miss is not).
+function groundingFrom(queryResult) {
+  const results = Array.isArray(queryResult && queryResult.results) ? queryResult.results : []
+  const sources = results.map((r) => ({
+    name: `${r.kind || 'memory'}: ${String(r.content || '').slice(0, 40)}`,
+    content: String(r.content || ''),
+    type: 'feedback',
+    weight: WEIGHTS.grounding,
+    origin: `memory:${r.id}`,
+    originId: r.id,
+    ...(r.timestamp ? { timestamp: r.timestamp } : {}),
+  }))
+  return { sources, relatedMemoryIds: results.map((r) => r.id), groundedWith: results.length }
+}
+
+function namedSource(role, text, origin, weight) {
+  const body = String(text).trim()
+  return {
+    name: `${role}: ${body.slice(0, 40)}`,
+    content: body,
+    type: 'knowledge',
+    weight,
+    origin,
+  }
+}
+
+async function runIdeaGenerate(options) {
+  const {
+    goal,
+    context = '',
+    constraints = [],
+    numIdeas,
+    chatJson,
+    store,
+    groundingSources = [],
+    relatedMemoryIds = [],
+    autoSources = [],
+  } = options || {}
+
+  const ordered = []
+  if (typeof goal === 'string' && goal.trim()) ordered.push(namedSource('goal', goal, 'goal', WEIGHTS.goal))
+  if (typeof context === 'string' && context.trim()) ordered.push(namedSource('context', context, 'context', WEIGHTS.context))
+  if (Array.isArray(constraints)) {
+    constraints.forEach((c, i) => {
+      if (typeof c === 'string' && c.trim()) ordered.push(namedSource('constraint', c, `constraint:${i}`, WEIGHTS.constraint))
+    })
+  }
+  for (const s of [...groundingSources, ...autoSources]) {
+    if (s && typeof s === 'object' && s.name) ordered.push(s)
+  }
+
+  const seen = new Set()
+  const sources = []
+  for (const s of ordered) {
+    const key = s.origin || s.name
+    if (seen.has(key)) continue
+    seen.add(key)
+    sources.push(s)
+  }
+
+  if (sources.length < 2) {
+    return { reason: 'need at least 2 sources — add --context/--constraints, or run `mio remember` first' }
+  }
+
+  const pairingStrategy = new Set(sources.map((s) => s.type)).size >= 2 ? 'explore' : 'stable'
+  const requested = Number(numIdeas)
+  const maxIdeas = Number.isFinite(requested) ? Math.min(Math.max(Math.trunc(requested), 1), 3) : 3
+
+  const rotationSeed = store.getHypotheses().length
+  const generator = new IdeaGenerator(chatJson, 0.5, undefined, rotationSeed)
+  // method left undefined: HypothesisGenerator rotates techniques internally
+  // from rotationSeed; the chosen one comes back on hypothesis.technique.
+  const creativeIdeas = await generator.generateIdeas(sources, maxIdeas, pairingStrategy, [])
+
+  const generatedAt = new Date().toISOString()
+  const recent = store.getHypotheses().slice(-30)
+  const rejected = store.getHypotheses({ status: 'rejected' }).slice(-50)
+
+  const ideas = []
+  const persistedIds = []
+  for (const { hypothesis: h, experiment } of creativeIdeas) {
+    const verdict = evaluateNovelty(h, recent, rejected)
+    if (verdict.shouldReject) {
+      h.status = 'rejected'
+      h.rejectionReason = verdict.rejectReason
+    } else {
+      h.novelty = verdict.adjustedNovelty
+    }
+    const labels = new Set(Array.isArray(h.sourceLabels) ? h.sourceLabels : [])
+    h.provenance = {
+      strategy: pairingStrategy,
+      technique: h.technique,
+      relatedMemoryIds: [...relatedMemoryIds],
+      sources: sources
+        .filter((s) => labels.has(s.name))
+        .map((s) => ({ name: s.name, type: s.type, origin: s.origin, timestamp: s.timestamp })),
+      generatedAt,
+    }
+    store.addHypothesis(h)
+    persistedIds.push(h.id)
+    ideas.push({ title: h.title, hypothesis: h, experiment, novelty: h.novelty, provenance: h.provenance })
+  }
+
+  return { ideas, generatedAt, groundedWith: groundingSources.length, persistedIds }
+}
+
+module.exports = { runIdeaGenerate, groundingFrom }

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

@@ -21,6 +21,8 @@ const { createDigest } = require('../digest.js')
 const { createEvolutionReport } = require('../evolution-report.js')
 
 const { CreativityEngine, sourcesFromInsights } = 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
 // the require and expose isObserverAvailable() / isInsightAvailable() so tool
 // registration can be gated on them, and both the MCP server and the CLI share
@@ -178,6 +180,16 @@ const memoryStore = createMemoryStore({
   verifiedFilter: REUSE_STATUS_FILTERS.verified,
 })
 
+// Second memory-store instance WITHOUT the shared queryLog: idea.generate's
+// grounding recall is tool-side context gathering, not a user query — it must
+// not append to queries.jsonl (that log exists for recall-style queries).
+const groundingMemoryStore = createMemoryStore({
+  dataDir,
+  projectName,
+  agentId: runtimeAgentId,
+  verifiedFilter: REUSE_STATUS_FILTERS.verified,
+})
+
 const digestEngine = createDigest({ home: dataDir })
 
 const {
@@ -695,6 +707,7 @@ const TOOLS = [
       properties: {
         status: { type: 'string', description: 'Filter by status: active, validated, rejected, draft.' },
         limit: { type: 'number', description: 'Max results. Default 20.' },
+        sort: { type: 'string', description: "Sort order: 'novelty' ranks stored hypotheses by relative noveltyScore (a dedup signal, NOT a quality score), newest 200 candidates capped. Default: newest." },
       },
     },
   },
@@ -722,7 +735,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.' },
       },
     },
   },
@@ -736,6 +749,21 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'mio.idea.generate',
+    description:
+      'Generate up to 3 concrete, experiment-backed hypotheses from one goal. Sources are assembled locally (goal, context/constraints, Mio memory grounding, local memory/traces/stored hypotheses) and every idea is persisted to the CreativityStore with provenance — Mio memory is never written. Returns { ideas, generatedAt, groundedWith, persistedIds }, or { reason } when fewer than two sources are available.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        goal: { type: 'string', description: 'The one-line goal the ideas should pursue (required).' },
+        context: { type: 'string', description: 'Optional free-form background.' },
+        constraints: { type: 'array', items: { type: 'string' }, description: 'Optional hard constraints.' },
+        numIdeas: { type: 'number', description: 'How many ideas to return; clamped to 1..3, default 3.' },
+      },
+      required: ['goal'],
+    },
+  },
 
   // ═══ Observer Research Pipeline ═══
 
@@ -968,6 +996,25 @@ function observerDag(args = {}) {
   return observerStore.dag(args)
 }
 
+// Local auto sources shared by generate's top-up and idea.generate — the same
+// providers the CLI assembles (spec Capability 2). Every layer degrades to []
+// so a missing optional package or an unreadable store never fails a tool call.
+function autoSources() {
+  let insights = []
+  let trends = []
+  try {
+    if (isInsightAvailable()) insights = insightStore.list({}) || []
+  } catch (_) {}
+  try {
+    trends = observerStore.trends({ limit: 3 }) || []
+  } catch (_) {}
+  try {
+    return buildAutoSources({ dataDir, insights, trends })
+  } catch (_) {
+    return []
+  }
+}
+
 // `fromInsights` seeds generation from what the insight engine already noticed
 // instead of making the caller hand-write concept sources. Only this entry
 // point knows which store is authoritative, so the read happens here; the
@@ -975,15 +1022,24 @@ function observerDag(args = {}) {
 // so the CLI's `--from-insights` lands on the same shapes.
 function generationSources(args) {
   const supplied = args.sources
-  if (!args.fromInsights) return supplied
-  if (!isInsightAvailable()) {
-    throw new Error('mio.creativity.generate fromInsights requires the optional package @akemi-mio/insight')
-  }
-  const seeds = sourcesFromInsights(insightStore.list({}))
-  if (seeds.length === 0) {
-    throw new Error('mio.creativity.generate fromInsights: no stored insights yet (run `mio insight generate` first)')
+  // Nothing to top up and no fromInsights: return as-is so the engine keeps
+  // throwing its documented "requires sources" error for empty calls.
+  if (!args.fromInsights && !(Array.isArray(supplied) && supplied.length)) return supplied
+  let base = supplied
+  if (args.fromInsights) {
+    if (!isInsightAvailable()) {
+      throw new Error('mio.creativity.generate fromInsights requires the optional package @akemi-mio/insight')
+    }
+    const seeds = sourcesFromInsights(insightStore.list({}))
+    if (seeds.length === 0) {
+      throw new Error('mio.creativity.generate fromInsights: no stored insights yet (run `mio insight generate` first)')
+    }
+    base = Array.isArray(supplied) ? supplied.concat(seeds) : seeds
   }
-  return Array.isArray(supplied) ? supplied.concat(seeds) : seeds
+  // Explicit sources always win; local memory/traces/stored hypotheses only
+  // top a short list up to the two entries the mixer needs (spec Capability 2,
+  // injection point 2 — the MCP twin of `mio creativity generate`).
+  return topUpSources(Array.isArray(base) ? base : [], autoSources())
 }
 
 async function callTool(name, args = {}) {
@@ -1060,6 +1116,26 @@ async function callTool(name, args = {}) {
       return creativityEngine.generate(generationSources(args), args.strategy)
     case 'mio.creativity.ferment':
       return creativityEngine.ferment(args.limit)
+    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')
+      let grounding = { sources: [], relatedMemoryIds: [], groundedWith: 0 }
+      try {
+        const qr = await groundingMemoryStore.queryMemory({ query: goal, limit: 3, scope: 'all' })
+        grounding = groundingFrom(qr)
+      } catch (_) {}
+      return runIdeaGenerate({
+        goal,
+        context: typeof args.context === 'string' ? args.context : '',
+        constraints: Array.isArray(args.constraints) ? args.constraints.filter((c) => typeof c === 'string') : [],
+        numIdeas: args.numIdeas,
+        chatJson,
+        store: creativityEngine.store,
+        groundingSources: grounding.sources,
+        relatedMemoryIds: grounding.relatedMemoryIds,
+        autoSources: autoSources(),
+      })
+    }
     case 'mio.insight.status':
       return insightStatus()
     case 'mio.insight.list':