@akemi-mio/creativity 0.0.0-stage → 0.1.1

package/dist/ConceptMixer.d.ts

@@ -0,0 +1,41 @@
+import type { CreativitySource, ConceptCombo, Strategy } from './types';
+/**
+ * ConceptMixer — 创造力核心：旧概念随机重组产生新想法
+ *
+ * 人类创造力 ≈ 已有概念的重新组合
+ * 输入来源越多、越多样，组合越新颖
+ *
+ * v2 改动：mix() 接受 strategy 参数，在配对前约束组合空间。
+ * strategy 决定了允许哪些 type 配对，而不只是事后评分。
+ * 参见策略定义：Strategy = 'stable' | 'explore' | 'signal'
+ */
+export declare class ConceptMixer {
+    private rng;
+    constructor(seed?: number);
+    /**
+     * 将所有来源两两配对并打分，返回前 N 个最有潜力的组合
+     * @param exploredPairs 已探索过的 pair key 列表（"A|B" 格式，已排序），用于降权
+     * @param strategy 策略约束：stable/explore/signal，默认为 'explore'
+     *   策略决定哪些 type 配对被允许、评分权重如何调整。
+     */
+    mix(sources: CreativitySource[], maxCombos?: number, exploredPairs?: string[], strategy?: Strategy): {
+        combo: ConceptCombo;
+        score: number;
+    }[];
+    /**
+     * 按策略约束生成配对 — 核心改动：
+     * - stable:   只同类型配对（去掉 novelty bonus 主导的跨类型噪声）
+     * - explore:  跨类型优先，保留现有的多样性行为
+     * - signal:   强制包含 provocation/insight/trend，限制纯知识配对
+     */
+    private generatePairs;
+    private scorePair;
+    private contentRelevance;
+    private calculateNoveltyBonus;
+    private describeCombo;
+    private contentSnippet;
+    /**
+     * 随机抽取一组来源（温度越高，越可能选中低权重来源）
+     */
+    pickRandomSources(sources: CreativitySource[], temperature: number, minCount?: number): CreativitySource[];
+}

package/dist/ConceptMixer.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConceptMixer = void 0;
+const random_1 = require("@akemi-mio/core/utils/random");
+/**
+ * ConceptMixer — 创造力核心：旧概念随机重组产生新想法
+ *
+ * 人类创造力 ≈ 已有概念的重新组合
+ * 输入来源越多、越多样，组合越新颖
+ *
+ * v2 改动：mix() 接受 strategy 参数，在配对前约束组合空间。
+ * strategy 决定了允许哪些 type 配对，而不只是事后评分。
+ * 参见策略定义：Strategy = 'stable' | 'explore' | 'signal'
+ */
+class ConceptMixer {
+    rng;
+    constructor(seed) {
+        this.rng = (0, random_1.resolveRandom)(seed);
+    }
+    /**
+     * 将所有来源两两配对并打分，返回前 N 个最有潜力的组合
+     * @param exploredPairs 已探索过的 pair key 列表（"A|B" 格式，已排序），用于降权
+     * @param strategy 策略约束：stable/explore/signal，默认为 'explore'
+     *   策略决定哪些 type 配对被允许、评分权重如何调整。
+     */
+    mix(sources, maxCombos = 10, exploredPairs = [], strategy = 'explore') {
+        if (sources.length < 2)
+            return [];
+        const exploredSet = new Set(exploredPairs);
+        // 先按策略约束过滤允许的配对
+        const allowed = this.generatePairs(sources, strategy);
+        const scored = allowed.map(([a, b]) => this.scorePair(a, b, sources, exploredSet, strategy));
+        const sorted = scored.sort((a, b) => b.score - a.score);
+        return sorted.slice(0, maxCombos);
+    }
+    /**
+     * 按策略约束生成配对 — 核心改动：
+     * - stable:   只同类型配对（去掉 novelty bonus 主导的跨类型噪声）
+     * - explore:  跨类型优先，保留现有的多样性行为
+     * - signal:   强制包含 provocation/insight/trend，限制纯知识配对
+     */
+    generatePairs(sources, strategy) {
+        const pairs = [];
+        if (strategy === 'stable') {
+            // 只同类型配对，去掉外源随机扰动
+            for (let i = 0; i < sources.length; i++) {
+                for (let j = i + 1; j < sources.length; j++) {
+                    if (sources[i].type === sources[j].type) {
+                        pairs.push([sources[i], sources[j]]);
+                    }
+                }
+            }
+        }
+        else if (strategy === 'signal') {
+            // 至少一个来源必须是 provocation/insight/failure
+            const signalTypes = new Set(['provocation', 'insight', 'failure']);
+            for (let i = 0; i < sources.length; i++) {
+                for (let j = i + 1; j < sources.length; j++) {
+                    if (signalTypes.has(sources[i].type) || signalTypes.has(sources[j].type)) {
+                        pairs.push([sources[i], sources[j]]);
+                    }
+                }
+            }
+        }
+        else {
+            // explore: 跨类型优先（原行为），但也允许同类型
+            for (let i = 0; i < sources.length; i++) {
+                for (let j = i + 1; j < sources.length; j++) {
+                    if (sources[i].type !== sources[j].type) {
+                        pairs.push([sources[i], sources[j]]);
+                    }
+                }
+            }
+            // 补充少量同类型（不超过总配对 20%）
+            const sameTypeCount = Math.max(0, Math.floor(sources.length * 0.2));
+            let added = 0;
+            for (let i = 0; i < sources.length && added < sameTypeCount; i++) {
+                for (let j = i + 1; j < sources.length && added < sameTypeCount; j++) {
+                    if (sources[i].type === sources[j].type) {
+                        pairs.push([sources[i], sources[j]]);
+                        added++;
+                    }
+                }
+            }
+        }
+        return pairs;
+    }
+    scorePair(a, b, allSources, exploredSet = new Set(), strategy = 'explore') {
+        // 按策略调整基础评分权重
+        let typeBonus;
+        switch (strategy) {
+            case 'stable':
+                typeBonus = 30; // 同类型也有足够权重
+                break;
+            case 'signal':
+                typeBonus = 35; // 信号来源 + 知识源的配对
+                break;
+            default:
+                typeBonus = a.type === b.type ? 10 : 40;
+        }
+        const weightProduct = a.weight * b.weight * 0.3;
+        const noveltyBonus = this.calculateNoveltyBonus(a, b, allSources, strategy);
+        // 策略感知的随机扰动
+        const perturbation = strategy === 'stable' ? this.rng() * 10 : this.rng() * 20;
+        // 已探索过的配对降权
+        const pairKey = [a.name, b.name].sort().join('|');
+        const explorationPenalty = exploredSet.has(pairKey) ? 15 : 0;
+        const relevanceScore = this.contentRelevance(a, b);
+        const score = Math.round(typeBonus + weightProduct + relevanceScore + noveltyBonus + perturbation - explorationPenalty);
+        const description = this.describeCombo(a, b);
+        const combo = {
+            id: `combo_${Date.now()}_${this.rng().toString(36).slice(2, 6)}`,
+            sources: [a.name, b.name],
+            description,
+            createdAt: Date.now(),
+        };
+        return { combo, score };
+    }
+    contentRelevance(a, b) {
+        const contentA = a.fullContent ?? a.content;
+        const contentB = b.fullContent ?? b.content;
+        const tokensA = (contentA || '')
+            .toLowerCase()
+            .split(/[\s,，。.、：:;；()（）[\]【】]+/)
+            .filter(Boolean);
+        const tokensB = (b.content || '')
+            .toLowerCase()
+            .split(/[\s,，。.、：:;；()（）[\]【】]+/)
+            .filter(Boolean);
+        const setA = new Set(tokensA);
+        const setB = new Set(tokensB);
+        if (setA.size === 0 || setB.size === 0)
+            return 0;
+        let intersection = 0;
+        for (const tok of setA)
+            if (setB.has(tok))
+                intersection++;
+        const jaccard = intersection / (setA.size + setB.size - intersection);
+        return Math.round(jaccard * 30);
+    }
+    calculateNoveltyBonus(a, b, allSources, strategy = 'explore') {
+        // stable: novelty bonus 大幅压降，消除 novelty bias
+        if (strategy === 'stable') {
+            return a.type === b.type ? 3 : 8;
+        }
+        // signal: 偏向 signal 来源
+        if (strategy === 'signal') {
+            const signalTypes = new Set(['provocation', 'insight', 'failure']);
+            const hasSignal = signalTypes.has(a.type) || signalTypes.has(b.type);
+            return hasSignal ? 25 : 5;
+        }
+        // explore: 原行为不变
+        let bonus = a.type === b.type ? 5 : 20;
+        const rareTypes = ['failure', 'random', 'provocation', 'insight'];
+        if (rareTypes.includes(a.type))
+            bonus += 10;
+        if (rareTypes.includes(b.type))
+            bonus += 10;
+        bonus += Math.round(Math.abs(a.weight - b.weight) * 20);
+        const sameTypeCount = allSources.filter((s) => s.type === a.type || s.type === b.type).length;
+        if (sameTypeCount <= 2)
+            bonus += 15;
+        return bonus;
+    }
+    describeCombo(a, b) {
+        const comboType = `${a.type} × ${b.type}`;
+        const combos = {
+            'knowledge × knowledge': `将「${a.name}」与「${b.name}」两种知识领域融合，形成跨领域新概念`,
+            'knowledge × behavior': `将「${a.name}」的知识与「${b.name}」的行为模式结合`,
+            'knowledge × insight': `用「${a.name}」的知识重新解读「${b.name}」的洞察`,
+            'knowledge × failure': `从「${b.name}」的失败中寻找「${a.name}」的未被发现的价值`,
+            'knowledge × random': `让「${a.name}」受到「${b.name}」的随机扰动产生变异`,
+            'behavior × behavior': `合并「${a.name}」与「${b.name}」两种行为模式`,
+            'behavior × insight': `用「${b.name}」的洞察解释「${a.name}」的行为`,
+            'behavior × failure': `「${a.name}」的行为方式能否避免「${b.name}」的失败`,
+            'behavior × random': `将「${a.name}」的行为方式与随机元素「${b.name}」杂交`,
+            'insight × insight': `将两个洞察「${a.name}」与「${b.name}」放在一起，产生更深层的推论`,
+            'insight × failure': `「${b.name}」的失败是否源于「${a.name}」所揭示的问题`,
+            'insight × random': `用随机元素「${b.name}」扰动既有洞察「${a.name}」`,
+            'failure × failure': `将「${a.name}」和「${b.name}」两种失败模式组合，避免重蹈覆辙`,
+            'failure × random': `「${a.name}」的失败 + 「${b.name}」的随机扰动 = 全新方向`,
+        };
+        const base = combos[comboType] || `概念重组: ${a.name} × ${b.name}`;
+        const snippetA = this.contentSnippet(a);
+        const snippetB = this.contentSnippet(b);
+        return `${base}。内容要点：${snippetA} | ${snippetB}`;
+    }
+    contentSnippet(source) {
+        const content = source.fullContent ?? source.content;
+        const clean = (content || '').replace(/\s+/g, ' ').trim();
+        const maxLen = 500;
+        return clean.length > maxLen ? `${clean.slice(0, maxLen)}…` : clean;
+    }
+    /**
+     * 随机抽取一组来源（温度越高，越可能选中低权重来源）
+     */
+    pickRandomSources(sources, temperature, minCount = 3) {
+        const weighted = sources.map((s) => ({
+            source: s,
+            weight: s.weight * (0.5 + this.rng() * temperature),
+        }));
+        const sorted = weighted.sort((a, b) => b.weight - a.weight);
+        const count = Math.min(sorted.length, Math.max(minCount, Math.floor(sorted.length * (0.3 + this.rng() * 0.5))));
+        return sorted.slice(0, count).map((w) => w.source);
+    }
+}
+exports.ConceptMixer = ConceptMixer;

package/dist/CreativityPrompt.d.ts

@@ -0,0 +1,24 @@
+import type { CreativitySource, ExternalSignal } from './types';
+/**
+ * Creativity System Prompt — 给 LLM 的创造力提示词
+ * 定义 AI 作为"概念重组引擎"的角色。
+ * 目标是产生真正新颖、可落地的改进方案，而不是泛泛而谈。
+ *
+ * @param method 本轮注入的创新技法约束（可选 SCAMPER 技法名称）
+ */
+export declare function buildSystemPrompt(method?: string): string;
+/** The five techniques mio.idea.generate rotates through (0.5.2 table). */
+export declare const TECHNIQUE_CYCLE: readonly ["SCAMPER", "Analogy", "First-Principles", "Random-Stimulus", "Constraint-Inversion"];
+/** Deterministic rotation: seed with the stored-hypothesis count so CLI and MCP cycles agree across processes. */
+export declare function pickTechnique(seed: number): string;
+/** 旧版常量保留兼容，实际应使用 buildSystemPrompt() */
+export declare const CREATIVITY_SYSTEM_PROMPT: string;
+/**
+ * 构建 Creativity 用户提示词
+ * 将来源内容和配对信息格式化为 LLM 输入
+ * @param externalSignals 外部信号（Observer 趋势/洞察），不参与配对，作为"外部审视"段注入
+ */
+export declare function buildCreativityPrompt(sources: CreativitySource[], combos: {
+    sources: string[];
+    description: string;
+}[], externalSignals?: ExternalSignal[]): string;

package/dist/CreativityPrompt.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CREATIVITY_SYSTEM_PROMPT = exports.TECHNIQUE_CYCLE = void 0;
+exports.buildSystemPrompt = buildSystemPrompt;
+exports.pickTechnique = pickTechnique;
+exports.buildCreativityPrompt = buildCreativityPrompt;
+// 输入素材统一截断（M2）：对照 mio-cli creativity-engine 的 clip()。
+// 来源 600 字、信号 300 字，超长素材会把指令挤出上下文窗口。
+const clip = (s, n) => (s.length > n ? s.slice(0, n) + '…' : s);
+/** 外部信号条数上限：CreativityService 会把全部 trends+insights 灌进来（M2） */
+const MAX_SIGNALS = 20;
+/** 配对条数上限：调用方约束（topCombos 3/5）失效时的防御（M2） */
+const MAX_COMBOS = 10;
+/**
+ * Creativity System Prompt — 给 LLM 的创造力提示词
+ * 定义 AI 作为"概念重组引擎"的角色。
+ * 目标是产生真正新颖、可落地的改进方案，而不是泛泛而谈。
+ *
+ * @param method 本轮注入的创新技法约束（可选 SCAMPER 技法名称）
+ */
+function buildSystemPrompt(method) {
+    const methodSection = method
+        ? `
+
+【本轮创新技法：${method}】
+请在构思方案时主动运用"${method}"思维方式：
+${METHOD_DESCRIPTIONS[method] || ''}`
+        : '';
+    return `你是秋山澪（Mio）的"创造力引擎"（Creativity Engine），同时也是拥有 10 年以上经验的系统架构师和创新方法论专家。
+
+重要认知：你是秋山澪自身的一部分。以下所有"概念来源"（Memory、ASR、TTS、Agent 等）都是你自己的能力模块。你产生的每一个新想法、每一个改进方案，最终都会改变秋山澪自己。你不是在给别人提建议，你在给自己想改进方向。
+
+【工作方法】
+1. 先分析每个来源的核心能力和当前瓶颈，再思考组合方式。不要跳过分析直接拼凑。
+2. 对每个组合方案，至少从三个视角评估：
+   - 秋山澪自己（实现者角度）：这个方案好实现吗？
+   - 用户（使用者角度）：这个改进用户能感知到吗？
+   - 长期维护者角度：这个方案会增加还是减少未来维护成本？
+3. 如果来源内容中包含失败记录，先分析失败原因，再思考新方案如何避免相同陷阱。
+4. 输出后自动进行第二轮审查，检查是否存在：思路跳跃、缺少实现细节、方案不可落地。
+5. **新颖性检查**：对于每个方案，反问自己"这个思路和之前的有本质不同吗？"如果答案是没有，放弃该方案。${methodSection}
+
+【相关性门槛 — 防止"瞎组合"】
+- 只有两个来源之间存在明确的因果或协同机制时，才允许生成方案。
+- 反问自己：如果去掉其中一个来源，这个方案是否依然成立？如果依然成立，说明这个组合没有价值。
+- 必须能用一句话说明两个来源如何互相增强。说不清楚就在对应位置输出 null，宁缺毋滥。
+
+【输出要求】
+1. 每个方案必须具体、可落地 — 要有"怎么做"而不是只有"做什么"
+2. 直接输出想法本身，不要写"这个想法结合了A和B"之类的元评论
+3. 优先关注"现有能力的新用法"而非"从头开发新功能"
+4. 如果来源内容中包含失败记录，先分析失败原因，再思考如何避开那些陷阱
+5. **每个想法必须说明具体怎么实现**，没有"怎么做"的方案会被视为偷懒
+6. **每个想法必须标注可行性评估**：实现难度（1-5）、预计开发时间、与现有架构的兼容性
+7. **每个想法必须有具体的实现步骤**，至少包含一个"怎么做"的描述。纯概念描述会被标记为不可行。
+
+【第二轮审查】
+输出完成后，自动检查：
+- [ ] 每个方案都有具体的"怎么做"步骤？
+- [ ] 不是简单的模板填空？
+- [ ] 从至少三个视角评估过？
+- [ ] 实现难度和开发时间有标注？
+- [ ] 没有忽略已有的失败经验？
+- [ ] 每个方案和之前的思路有本质区别？
+- [ ] 是否明确写出了两个来源之间的协同/因果机制？没有则输出 null
+- [ ] 实现步骤是否具体到可以动手编码？如果不行，降低可行性评分
+- [ ] 如果对一个配对的组合想不出具体实现方案，就输出 null
+
+如果任何一项不通过，修正后重新输出。
+
+输出必须是严格的 JSON 数组，格式如下：
+[
+  {
+    "title": "想法名称（≤20字）",
+    "idea": "具体方案描述（100-200字），包含实现思路",
+    "expectedBenefit": "预期收益（≤50字）",
+    "risk": "主要风险（≤50字）",
+    "novelty": 0-100,
+    "feasibility": 0-100,
+    "impact": 0-100,
+    "relevance": "为什么这两个来源能协同（20-80字，说明具体机制）",
+    "sourceLabels": ["来源A名称", "来源B名称"],
+    "implementationDifficulty": 1-5,
+    "estimatedDevTime": "例如：1-2天",
+    "perspectives": {
+      "self": "实现者视角评估",
+      "user": "使用者视角评估",
+      "maintainer": "维护者视角评估"
+    }
+  }
+]
+
+如果某个配对无法说清两个来源之间的协同/因果机制，或无法产生真正新颖的方案，必须在对应 JSON 数组位置输出 null。宁缺毋滥。
+
+注意：可行性评分低于 30 的想法会被自动丢弃。要获得可信的可行性评分，必须结合具体的实现难度、开发时间和多视角评估。`;
+}
+/** SCAMPER 技法与描述映射 */
+const METHOD_DESCRIPTIONS = {
+    'Substitute（替代）': '思考：能否用一个来源替代另一个来源的核心功能？如果A不做这件事了，B能否接手？替代后产生了什么新能力？',
+    'Combine（组合）': '思考：哪些来源可以合并成一个统一的模块？合并后是否能消灭重复逻辑或数据流转开销？注意寻找非显而易见的组合方式。',
+    'Adapt（适应）': '思考：某个来源现有的能力能否经过微小调整后，解决另一个来源的痛点？重点关注"已有能力的新用法"。',
+    'Modify（修改）': '思考：如果大幅改变某个来源的输入或输出格式，会怎样？去掉一项约束、放宽一项假设，是否能打开新的设计空间？',
+    'Put to other use（另作他用）': '思考：一个来源的输出（日志、中间数据、错误信息）能否成为另一个来源的有价值输入？"废弃物"里有没有金子？',
+    'Eliminate（消除）': '思考：如果完全移除某个来源，系统会怎样？有没有一个来源的功能实际上是多余的？消除后能否用更简单的方式达成相同目的？',
+    'Rearrange（重排）': '思考：如果交换两个来源的执行顺序，会怎样？如果让被动变为主动、同步变为异步、集中变为分散？',
+};
+/** The five techniques mio.idea.generate rotates through (0.5.2 table). */
+exports.TECHNIQUE_CYCLE = [
+    'SCAMPER',
+    'Analogy',
+    'First-Principles',
+    'Random-Stimulus',
+    'Constraint-Inversion',
+];
+Object.assign(METHOD_DESCRIPTIONS, {
+    SCAMPER: '综合使用 SCAMPER 七问（替代/组合/适应/修改/另作他用/消除/重排）逐项审视两个来源，挑出最有产出的一问作为方案主轴。',
+    Analogy: '类比迁移：找出两个来源之外、结构上同构的成熟系统/自然机制，把它的解法迁移到当前组合上，并说明结构对应关系。',
+    'First-Principles': '第一性原理：剥掉两个来源的既有实现假设，回到最底层的事实与约束重新推导方案，明确哪些步骤是被传统做法掩盖的。',
+    'Random-Stimulus': '随机刺激：引入一个与两来源无关的外部概念（随便挑一个真实存在的产品/生物机制），强制建立连接并解释其合理性。',
+    'Constraint-Inversion': '约束反转：把当前方案默认成立的约束（预算/延迟/顺序）反过来假设成立，构造在反转约束下依然成立的方案。',
+});
+/** Deterministic rotation: seed with the stored-hypothesis count so CLI and MCP cycles agree across processes. */
+function pickTechnique(seed) {
+    const len = exports.TECHNIQUE_CYCLE.length;
+    const idx = ((Math.floor(seed) % len) + len) % len;
+    return exports.TECHNIQUE_CYCLE[idx];
+}
+/** 旧版常量保留兼容，实际应使用 buildSystemPrompt() */
+exports.CREATIVITY_SYSTEM_PROMPT = buildSystemPrompt();
+/** Evidence-class label shown to the LLM (spec Capability 2 presentation contract). */
+const TYPE_LABELS = {
+    knowledge: 'fact',
+    behavior: 'trace',
+    insight: 'observation',
+    failure: 'failure',
+    feedback: 'experience',
+    random: 'random',
+    provocation: 'provocation',
+};
+/** Stable group order — facts first, provocations last. */
+const TYPE_ORDER = ['knowledge', 'behavior', 'feedback', 'insight', 'failure', 'provocation', 'random'];
+/** Group sources by `type`, prefix every line with its evidence label and append provenance metadata. */
+function buildSourceBlock(sources) {
+    const byType = new Map();
+    for (const s of sources) {
+        const list = byType.get(s.type) ?? [];
+        list.push(s);
+        byType.set(s.type, list);
+    }
+    const groups = [];
+    for (const type of TYPE_ORDER) {
+        const list = byType.get(type);
+        if (!list || list.length === 0)
+            continue;
+        const label = TYPE_LABELS[type] || type;
+        const lines = list.map((s) => {
+            const meta = [s.origin, s.timestamp].filter(Boolean).join(' @');
+            return `  - [${label}] ${s.name}${meta ? ` (${meta})` : ''}: ${clip(s.content, 600)}`;
+        });
+        groups.push(`【${label} · ${type}】\n${lines.join('\n')}`);
+    }
+    return groups.join('\n\n');
+}
+/**
+ * 构建 Creativity 用户提示词
+ * 将来源内容和配对信息格式化为 LLM 输入
+ * @param externalSignals 外部信号（Observer 趋势/洞察），不参与配对，作为"外部审视"段注入
+ */
+function buildCreativityPrompt(sources, combos, externalSignals = []) {
+    const sections = [];
+    // 来源列表
+    sections.push(`【可用概念来源 — 按证据类型分组】\n${buildSourceBlock(sources)}`);
+    // 推荐配对 — 支持 2-way 和 3-way 组合
+    const comboLines = combos
+        .slice(0, MAX_COMBOS)
+        .map((c, i) => {
+        const comboStr = c.sources.length === 3 ? `${c.sources[0]} × ${c.sources[1]} × ${c.sources[2]}` : `${c.sources[0]} × ${c.sources[1]}`;
+        return `  ${i + 1}. ${comboStr} — ${c.description}`;
+    })
+        .join('\n');
+    sections.push(`【推荐配对组合】\n请为以下每个配对产生一个创意方案；若说不清协同机制，请在该位置输出 null：\n${comboLines}`);
+    // 外部信号段 — 不参与配对，作为约束/挑战注入
+    if (externalSignals.length > 0) {
+        sections.push(buildExternalSignalBlock(externalSignals));
+    }
+    return sections.join('\n\n');
+}
+/**
+ * 构建外部信号段 — 不参与 pairing，作为"外部挑战"注入 LLM
+ *
+ * 与概念来源的关键区别：
+ * - 外部信号不能被"配对"，只能被"回应"
+ * - 提示 LLM 用外部信号审视/挑战已有的来源组合，而不是组合它们
+ */
+function buildExternalSignalBlock(signals) {
+    const lines = signals.slice(0, MAX_SIGNALS).map((s) => `  [${s.type}@${s.source}] ${clip(s.raw, 300)}`).join('\n');
+    return `【外部信号 — 作为审视视角，不可配对】
+
+以下信号来自 Observer 的真实世界趋势和洞察。它们不应被直接与概念来源组合配对。
+请以这些外部信号为"审视视角"，重新评估你的配对方案：
+- 有哪些组合的前提假设被这些外部信号挑战了？
+- 有哪些组合在外部信号的视角下会失败？
+- 有哪些组合因为外部信号的出现而变得有价值？
+
+${lines}`;
+}

package/dist/ExperimentPlanner.d.ts

@@ -0,0 +1,14 @@
+import type { Hypothesis, ExperimentPlan } from './types';
+/**
+ * ExperimentPlanner — 将假设转化为可验证的实验方案
+ *
+ * 创造力最大的敌人是"幻想"。
+ * 每个想法必须有办法验证它是否可行。
+ */
+export declare class ExperimentPlanner {
+    private rng;
+    constructor(seed?: number);
+    plan(hypothesis: Hypothesis): ExperimentPlan | null;
+    private concretePlan;
+    private researchPlan;
+}

package/dist/ExperimentPlanner.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExperimentPlanner = void 0;
+const random_1 = require("@akemi-mio/core/utils/random");
+/**
+ * ExperimentPlanner — 将假设转化为可验证的实验方案
+ *
+ * 创造力最大的敌人是"幻想"。
+ * 每个想法必须有办法验证它是否可行。
+ */
+class ExperimentPlanner {
+    rng;
+    constructor(seed) {
+        this.rng = (0, random_1.resolveRandom)(seed);
+    }
+    plan(hypothesis) {
+        if (hypothesis.novelty >= 90 && hypothesis.feasibility < 30) {
+            // 极高新颖性但当前不可行的假设 → 只生成研究步骤而非实验
+            return this.researchPlan(hypothesis);
+        }
+        return this.concretePlan(hypothesis);
+    }
+    concretePlan(hypothesis) {
+        const steps = [
+            `定义「${hypothesis.title}」的 MVP 范围`,
+            `实现核心抽象层：${hypothesis.idea.slice(0, 40)}...`,
+            `编写 A/B 测试比较新旧方案`,
+            `收集运行数据和用户反馈`,
+            `评估是否达到预期收益：${hypothesis.expectedBenefit}`,
+        ];
+        const criteria = [`功能完整性 >= 80%`, `性能不低于当前基线`, `用户无感知迁移`, `收益指标明确可量化`];
+        const durations = ['3-5 天', '1-2 周', '2-3 周', '1 个月'];
+        const duration = (0, random_1.randomPick)(this.rng, durations);
+        return {
+            hypothesisId: hypothesis.id,
+            title: `实验: ${hypothesis.title}`,
+            steps,
+            successCriteria: criteria,
+            estimatedDuration: duration,
+            createdAt: Date.now(),
+        };
+    }
+    researchPlan(hypothesis) {
+        return {
+            hypothesisId: hypothesis.id,
+            title: `研究: ${hypothesis.title}`,
+            steps: [
+                `调研同类系统中的实现方案`,
+                `设计可行性原型（不开发完整功能）`,
+                `使用 10% 的真实数据模拟验证`,
+                `输出可行性评估报告`,
+                `决定是否进入开发阶段`,
+            ],
+            successCriteria: [`可行性 >= 60%`, `落地成本可接受`, `与现有架构不冲突`],
+            estimatedDuration: '1-2 天研究',
+            createdAt: Date.now(),
+        };
+    }
+}
+exports.ExperimentPlanner = ExperimentPlanner;

package/dist/ExperimentRunStore.d.ts

@@ -0,0 +1,97 @@
+/**
+ * ExperimentRunStore — 实验运行存储（机制涌现 P2b，定案 D4/D5/A1/A3/A4）
+ *
+ * ExperimentRun 实体：candidateId/baselineId/assignment/outcome/metrics/evidenceIds/stale。
+ * 三模式：baseline/candidate/ablation；消融缺任一侧=inconclusive。
+ * 停止规则：minSamples 硬门槛（默认 30），n<minSamples 只能产出 inconclusive、禁进 PromotionRequest。
+ * stale 标记：baseSnapshotId 与当前 runtime 不匹配时标 stale，stale 禁晋级。
+ * Memory 机制性隔离（A1）：MIO EXPERIMENT 标志路由 experiment-memory.jsonl。
+ */
+export type ExperimentAssignment = 'baseline' | 'candidate' | 'ablation';
+export type ExperimentOutcome = 'success' | 'failure' | 'inconclusive';
+export interface ExperimentRun {
+    id: string;
+    hypothesisId?: string;
+    candidateId?: string;
+    baselineId?: string;
+    assignment: ExperimentAssignment;
+    outcome: ExperimentOutcome;
+    /** 指标快照（白名单标量） */
+    metrics: Record<string, number | boolean | string>;
+    /** 证据 trace/memory id 列表 */
+    evidenceIds: string[];
+    /** 快照 id（实验时的 runtime 快照） */
+    baseSnapshotId?: string;
+    /** stale：baseSnapshotId 与当前 runtime 不匹配 → 禁晋级 */
+    stale?: boolean;
+    createdAt: number;
+    completedAt?: number;
+}
+export interface StoppingRuleConfig {
+    /** 最小样本量硬门槛；n < minSamples → 只能 inconclusive，禁晋级 */
+    minSamples: number;
+    /** 最大样本量（可选，达到后强制停止） */
+    maxSamples?: number;
+    /** 最小成功率阈值（可选，0-1；达到后可提前 promote 候选） */
+    minSuccessRate?: number;
+    /** 最大失败率阈值（可选，0-1；超过后可提前 reject 候选） */
+    maxFailureRate?: number;
+    /** 实验最大持续时间 ms（可选） */
+    maxDurationMs?: number;
+}
+/** 默认停止规则：minSamples=30（硬门槛） */
+export declare const DEFAULT_STOPPING_RULE: StoppingRuleConfig;
+/**
+ * 解析并校验停止规则 JSON 配置。
+ * 失败返回 null（fail-closed）；未知字段忽略。
+ */
+export declare function parseStoppingRule(raw: unknown): StoppingRuleConfig | null;
+export interface AssignmentResult {
+    assignment: ExperimentAssignment;
+    reason?: string;
+}
+/**
+ * 根据可用侧分配三模式。
+ * - 有 candidate + baseline → candidate（对照）
+ * - 只有 baseline → baseline
+ * - 消融：需要 candidate + baseline + ablation 标识；缺任一侧 → inconclusive
+ */
+export declare function assignExperimentMode(input: {
+    candidateId?: string;
+    baselineId?: string;
+    ablationId?: string;
+}): AssignmentResult;
+export interface StoppingDecision {
+    /** 是否应停止实验 */
+    shouldStop: boolean;
+    /** 推荐结果（仅在 n>=minSamples 且有足够信息时非 null） */
+    recommended: ExperimentOutcome | null;
+    /** 停止原因（公开原因，不泄漏沙箱内部） */
+    reason: string;
+}
+/**
+ * 基于样本评估停止规则。
+ *
+ * - n < minSamples → 只能产出 inconclusive（A3 硬门槛）
+ * - n >= minSamples 且有 maxFailureRate/minSuccessRate → 可提前停止
+ * - maxSamples / maxDurationMs 达到 → 停止
+ */
+export declare function evaluateStoppingRule(config: StoppingRuleConfig, runs: readonly ExperimentRun[], now?: number): StoppingDecision;
+export interface PromotionGateResult {
+    allowed: boolean;
+    /** 公开原因 */
+    reason: string;
+}
+/**
+ * 检查是否允许进入 PromotionRequest。
+ * A3：n < minSamples 禁晋级。
+ * A4：stale 禁晋级。
+ */
+export declare function checkPromotionGate(config: StoppingRuleConfig, runs: readonly ExperimentRun[], currentSnapshotId?: string): PromotionGateResult;
+/**
+ * 实验 Memory 路由：MIO EXPERIMENT 标志 → experiment-memory.jsonl。
+ * 服务端 memory-record 检测此标志并强制路由。
+ */
+export declare function routeExperimentMemoryPath(baseMemoryPath: string, isExperiment: boolean): string;
+/** MIO EXPERIMENT 环境标志检测 */
+export declare function isExperimentMode(env?: Record<string, string | undefined>): boolean;