@akemi-mio/creativity 0.0.0-stage → 0.1.1

package/dist/ExperimentRunStore.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * 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。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_STOPPING_RULE = void 0;
+exports.parseStoppingRule = parseStoppingRule;
+exports.assignExperimentMode = assignExperimentMode;
+exports.evaluateStoppingRule = evaluateStoppingRule;
+exports.checkPromotionGate = checkPromotionGate;
+exports.routeExperimentMemoryPath = routeExperimentMemoryPath;
+exports.isExperimentMode = isExperimentMode;
+/** 默认停止规则：minSamples=30（硬门槛） */
+exports.DEFAULT_STOPPING_RULE = { minSamples: 30 };
+/**
+ * 解析并校验停止规则 JSON 配置。
+ * 失败返回 null（fail-closed）；未知字段忽略。
+ */
+function parseStoppingRule(raw) {
+    if (raw === null || typeof raw !== 'object')
+        return null;
+    const obj = raw;
+    const minSamples = obj.minSamples;
+    if (typeof minSamples !== 'number' || !Number.isFinite(minSamples) || minSamples < 1)
+        return null;
+    const config = { minSamples: Math.floor(minSamples) };
+    if (typeof obj.maxSamples === 'number' && Number.isFinite(obj.maxSamples) && obj.maxSamples >= config.minSamples) {
+        config.maxSamples = Math.floor(obj.maxSamples);
+    }
+    if (typeof obj.minSuccessRate === 'number' && Number.isFinite(obj.minSuccessRate) && obj.minSuccessRate >= 0 && obj.minSuccessRate <= 1) {
+        config.minSuccessRate = obj.minSuccessRate;
+    }
+    if (typeof obj.maxFailureRate === 'number' && Number.isFinite(obj.maxFailureRate) && obj.maxFailureRate >= 0 && obj.maxFailureRate <= 1) {
+        config.maxFailureRate = obj.maxFailureRate;
+    }
+    if (typeof obj.maxDurationMs === 'number' && Number.isFinite(obj.maxDurationMs) && obj.maxDurationMs > 0) {
+        config.maxDurationMs = Math.floor(obj.maxDurationMs);
+    }
+    return config;
+}
+/**
+ * 根据可用侧分配三模式。
+ * - 有 candidate + baseline → candidate（对照）
+ * - 只有 baseline → baseline
+ * - 消融：需要 candidate + baseline + ablation 标识；缺任一侧 → inconclusive
+ */
+function assignExperimentMode(input) {
+    const { candidateId, baselineId, ablationId } = input;
+    if (ablationId) {
+        // 消融需要双侧对照
+        if (!candidateId || !baselineId) {
+            return { assignment: 'ablation', reason: 'inconclusive_missing_side' };
+        }
+        return { assignment: 'ablation' };
+    }
+    if (candidateId && baselineId)
+        return { assignment: 'candidate' };
+    if (baselineId)
+        return { assignment: 'baseline' };
+    return { assignment: 'baseline', reason: 'no_baseline' };
+}
+/**
+ * 基于样本评估停止规则。
+ *
+ * - n < minSamples → 只能产出 inconclusive（A3 硬门槛）
+ * - n >= minSamples 且有 maxFailureRate/minSuccessRate → 可提前停止
+ * - maxSamples / maxDurationMs 达到 → 停止
+ */
+function evaluateStoppingRule(config, runs, now = Date.now()) {
+    const n = runs.length;
+    const successCount = runs.filter((r) => r.outcome === 'success').length;
+    const failureCount = runs.filter((r) => r.outcome === 'failure').length;
+    const inconclusiveCount = runs.filter((r) => r.outcome === 'inconclusive').length;
+    const successRate = n > 0 ? successCount / n : 0;
+    const failureRate = n > 0 ? failureCount / n : 0;
+    // 硬门槛：n < minSamples → inconclusive（A3）
+    if (n < config.minSamples) {
+        return {
+            shouldStop: false,
+            recommended: null,
+            reason: 'below_min_samples',
+        };
+    }
+    // maxSamples
+    if (config.maxSamples !== undefined && n >= config.maxSamples) {
+        return { shouldStop: true, recommended: majorityOutcome(successCount, failureCount, inconclusiveCount), reason: 'max_samples' };
+    }
+    // maxFailureRate 超过 → 停止 + reject
+    if (config.maxFailureRate !== undefined && failureRate > config.maxFailureRate) {
+        return { shouldStop: true, recommended: 'failure', reason: 'failure_rate_exceeded' };
+    }
+    // minSuccessRate 达到 → 停止 + success
+    if (config.minSuccessRate !== undefined && successRate >= config.minSuccessRate) {
+        return { shouldStop: true, recommended: 'success', reason: 'success_rate_met' };
+    }
+    // maxDurationMs
+    if (config.maxDurationMs !== undefined) {
+        const oldest = Math.min(...runs.map((r) => r.createdAt));
+        if (now - oldest >= config.maxDurationMs) {
+            return { shouldStop: true, recommended: majorityOutcome(successCount, failureCount, inconclusiveCount), reason: 'max_duration' };
+        }
+    }
+    return { shouldStop: false, recommended: null, reason: 'continue' };
+}
+function majorityOutcome(s, f, i) {
+    if (s > f && s > i)
+        return 'success';
+    if (f > s && f > i)
+        return 'failure';
+    return 'inconclusive';
+}
+/**
+ * 检查是否允许进入 PromotionRequest。
+ * A3：n < minSamples 禁晋级。
+ * A4：stale 禁晋级。
+ */
+function checkPromotionGate(config, runs, currentSnapshotId) {
+    // A4: stale 检查
+    const anyStale = runs.some((r) => r.stale === true);
+    if (anyStale) {
+        return { allowed: false, reason: 'stale_snapshot' };
+    }
+    // A4: baseSnapshotId 与当前 runtime 不匹配
+    if (currentSnapshotId) {
+        const mismatched = runs.some((r) => r.baseSnapshotId !== undefined && r.baseSnapshotId !== currentSnapshotId);
+        if (mismatched) {
+            return { allowed: false, reason: 'snapshot_mismatch' };
+        }
+    }
+    // A3: minSamples 硬门槛
+    const n = runs.length;
+    if (n < config.minSamples) {
+        return { allowed: false, reason: 'below_min_samples' };
+    }
+    return { allowed: true, reason: 'ok' };
+}
+// ══════════════════════════════════════════
+// Memory 机制性隔离（A1）
+// ══════════════════════════════════════════
+/**
+ * 实验 Memory 路由：MIO EXPERIMENT 标志 → experiment-memory.jsonl。
+ * 服务端 memory-record 检测此标志并强制路由。
+ */
+function routeExperimentMemoryPath(baseMemoryPath, isExperiment) {
+    if (!isExperiment)
+        return baseMemoryPath;
+    // 替换扩展名为 experiment-memory.jsonl
+    const dir = baseMemoryPath.includes('/') ? baseMemoryPath.slice(0, baseMemoryPath.lastIndexOf('/') + 1) : '';
+    return `${dir}experiment-memory.jsonl`;
+}
+/** MIO EXPERIMENT 环境标志检测 */
+function isExperimentMode(env = process.env) {
+    return env.MIO_EXPERIMENT === '1' || env.MIO_EXPERIMENT === 'true';
+}

package/dist/HypothesisGenerator.d.ts

@@ -0,0 +1,60 @@
+import type { Hypothesis, ConceptCombo, CreativitySource, ExternalSignal } from './types';
+/**
+ * HypothesisGenerator — 将概念组合转化为可验证的假设
+ *
+ * 四级生成链（逐级降级）：
+ *   远程 LLM → 本地模型 (transformers.js) → TemplateLibrary (30+ 模式) → 原始模板兜底
+ */
+export declare class HypothesisGenerator {
+    private idCounter;
+    private rng;
+    private chatJson;
+    private templateLib;
+    private localModel;
+    private rotationSeed;
+    private callCount;
+    constructor(chatJson: (userText: string, options?: {
+        system?: string;
+        temperature?: number;
+        timeoutMs?: number;
+        requestId?: string;
+        maxTokens?: number;
+    }) => Promise<{
+        data?: any;
+        error?: string;
+    }>, seed?: number, rotationSeed?: number);
+    /**
+     * 从概念组合生成假设 — 远程 LLM → 本地模型 → TemplateLibrary → 模板兜底
+     *
+     * 四级 fallback 链：
+     *   1. 远程 LLM           (高质，但 30s 超时、网络依赖)
+     *   2. 本地 transformers.js (进程内，~1s，无网络依赖)
+     *   3. TemplateLibrary    (30+ 模式，类型感知，零延迟)
+     *   4. 原始模板           (5 个硬编码，终极兜底)
+     */
+    generate(combos: ConceptCombo[], sources: CreativitySource[], 
+    /** 梦境模式使用更高温度 */
+    dreamMode?: boolean, 
+    /** 外部信号 — 不参与配对，作为审视视角注入 LLM */
+    externalSignals?: ExternalSignal[], 
+    /** 显式技法；缺省走五技法轮换（rotationSeed + 调用次数） */
+    method?: string): Promise<Hypothesis[]>;
+    /**
+     * 调 LLM 生成创意
+     */
+    private tryLLM;
+    /**
+     * 调本地 transformers.js 模型生成创意
+     */
+    private tryLocalModel;
+    private hasRelevanceJustification;
+    /** 记录本轮使用的轮换技法（idea.generate 的 provenance.technique 字段写它）。 */
+    private tag;
+    /** 根据 sourceLabels 构建来源深度详情（默认 shallow） */
+    private buildSourceDetails;
+    /**
+     * 模板 fallback — 从旧实现保留
+     */
+    private templateFallback;
+    private stableHash;
+}

package/dist/HypothesisGenerator.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HypothesisGenerator = void 0;
+const CreativityPrompt_1 = require("./CreativityPrompt");
+const TemplateLibrary_1 = require("./TemplateLibrary");
+const LocalModelService_1 = require("./LocalModelService");
+const random_1 = require("@akemi-mio/core/utils/random");
+const Logger_1 = require("@akemi-mio/core/logger/Logger");
+/**
+ * HypothesisGenerator — 将概念组合转化为可验证的假设
+ *
+ * 四级生成链（逐级降级）：
+ *   远程 LLM → 本地模型 (transformers.js) → TemplateLibrary (30+ 模式) → 原始模板兜底
+ */
+class HypothesisGenerator {
+    idCounter = 0;
+    rng;
+    chatJson;
+    templateLib;
+    localModel;
+    rotationSeed = 0;
+    callCount = 0;
+    constructor(chatJson, seed, rotationSeed = 0) {
+        this.chatJson = chatJson;
+        this.rng = (0, random_1.resolveRandom)(seed);
+        this.templateLib = new TemplateLibrary_1.TemplateLibrary(seed);
+        this.localModel = new LocalModelService_1.LocalModelService();
+        this.rotationSeed = rotationSeed;
+    }
+    /**
+     * 从概念组合生成假设 — 远程 LLM → 本地模型 → TemplateLibrary → 模板兜底
+     *
+     * 四级 fallback 链：
+     *   1. 远程 LLM           (高质，但 30s 超时、网络依赖)
+     *   2. 本地 transformers.js (进程内，~1s，无网络依赖)
+     *   3. TemplateLibrary    (30+ 模式，类型感知，零延迟)
+     *   4. 原始模板           (5 个硬编码，终极兜底)
+     */
+    async generate(combos, sources, 
+    /** 梦境模式使用更高温度 */
+    dreamMode = false, 
+    /** 外部信号 — 不参与配对，作为审视视角注入 LLM */
+    externalSignals = [], 
+    /** 显式技法；缺省走五技法轮换（rotationSeed + 调用次数） */
+    method) {
+        if (combos.length === 0)
+            return [];
+        const technique = method ?? (0, CreativityPrompt_1.pickTechnique)(this.rotationSeed + this.callCount);
+        this.callCount += 1;
+        // 第一级：远程 LLM 驱动生成
+        const llmResults = await this.tryLLM(sources, combos, dreamMode, externalSignals, technique);
+        if (llmResults.length > 0) {
+            return this.tag(llmResults.map((r) => ({
+                id: `hyp_${Date.now()}_${++this.idCounter}_${this.rng().toString(36).slice(2, 4)}`,
+                title: r.title,
+                idea: r.idea,
+                expectedBenefit: r.expectedBenefit,
+                risk: r.risk,
+                sourceLabels: r.sourceLabels,
+                sourceDetails: this.buildSourceDetails(r.sourceLabels, sources),
+                novelty: Math.max(10, Math.min(100, r.novelty)),
+                feasibility: Math.max(10, Math.min(100, r.feasibility)),
+                impact: Math.max(10, Math.min(100, r.impact)),
+                status: 'draft',
+                createdAt: Date.now(),
+            })), technique);
+        }
+        // 第二级：本地 transformers.js 模型
+        if (this.localModel.isEnabled) {
+            (0, Logger_1.log)('INFO', 'hypothesis_fallback_local', { count: combos.length });
+            const localResults = await this.tryLocalModel(sources, combos, dreamMode, technique);
+            if (localResults.length > 0) {
+                return this.tag(localResults.map((r) => ({
+                    id: `hyp_local_${Date.now()}_${++this.idCounter}_${this.rng().toString(36).slice(2, 4)}`,
+                    title: r.title,
+                    idea: r.idea,
+                    expectedBenefit: r.expectedBenefit,
+                    risk: r.risk,
+                    sourceLabels: r.sourceLabels,
+                    sourceDetails: this.buildSourceDetails(r.sourceLabels, sources),
+                    novelty: Math.max(10, Math.min(100, r.novelty)),
+                    feasibility: Math.max(10, Math.min(100, r.feasibility)),
+                    impact: Math.max(10, Math.min(100, r.impact)),
+                    status: 'draft',
+                    createdAt: Date.now(),
+                })), technique);
+            }
+        }
+        // 第二/三级失败 → 记录日志
+        (0, Logger_1.log)('INFO', 'hypothesis_fallback_templates', { count: combos.length });
+        // 第三级：TemplateLibrary (30+ 类型感知模板)
+        const tplResults = [];
+        for (const combo of combos) {
+            const h = this.templateLib.generate(combo, sources);
+            if (h)
+                tplResults.push(h);
+        }
+        if (tplResults.length > 0) {
+            return this.tag(tplResults, technique);
+        }
+        // 第四级：原始模板兜底
+        (0, Logger_1.log)('WARN', 'hypothesis_fallback_legacy', { count: combos.length });
+        return this.tag(combos.map((combo) => this.templateFallback(combo)), technique);
+    }
+    /**
+     * 调 LLM 生成创意
+     */
+    async tryLLM(sources, combos, dreamMode, externalSignals = [], technique = '') {
+        // 限制输入量，避免超 token
+        const topCombos = combos.slice(0, dreamMode ? 5 : 3);
+        const comboInfo = topCombos.map((c) => ({
+            sources: c.sources,
+            description: c.description,
+        }));
+        const prompt = (0, CreativityPrompt_1.buildCreativityPrompt)(sources, comboInfo, externalSignals);
+        try {
+            const result = await this.chatJson(prompt, {
+                system: (0, CreativityPrompt_1.buildSystemPrompt)(technique),
+                temperature: dreamMode ? 1.0 : 0.8,
+                timeoutMs: 60000,
+                // 输出无界会顶满超时（M2）：生成上限 1200 tokens
+                maxTokens: 1200,
+            });
+            if (result.error) {
+                (0, Logger_1.log)('WARN', 'hypothesis_llm_error', { error: result.error });
+                return [];
+            }
+            const ideas = Array.isArray(result.data) ? result.data : [];
+            // 验证基本格式
+            return ideas.filter((i) => typeof i.title === 'string' &&
+                typeof i.idea === 'string' &&
+                Array.isArray(i.sourceLabels) &&
+                typeof i.novelty === 'number' &&
+                this.hasRelevanceJustification(i));
+        }
+        catch (err) {
+            (0, Logger_1.log)('ERROR', 'hypothesis_llm_exception', { error: String(err) });
+            return [];
+        }
+    }
+    /**
+     * 调本地 transformers.js 模型生成创意
+     */
+    async tryLocalModel(sources, combos, dreamMode, technique = '') {
+        const topCombos = combos.slice(0, dreamMode ? 3 : 2);
+        const comboInfo = topCombos.map((c) => ({
+            sources: c.sources,
+            description: c.description,
+        }));
+        const prompt = (0, CreativityPrompt_1.buildCreativityPrompt)(sources, comboInfo);
+        const result = await this.localModel.generate(prompt, {
+            system: (0, CreativityPrompt_1.buildSystemPrompt)(technique),
+            temperature: dreamMode ? 0.8 : 0.6,
+            maxTokens: dreamMode ? 1024 : 768,
+        });
+        if (result.error) {
+            (0, Logger_1.log)('WARN', 'hypothesis_local_error', { error: result.error });
+            return [];
+        }
+        const ideas = Array.isArray(result.data) ? result.data : [];
+        return ideas.filter((i) => typeof i.title === 'string' &&
+            typeof i.idea === 'string' &&
+            Array.isArray(i.sourceLabels) &&
+            typeof i.novelty === 'number' &&
+            this.hasRelevanceJustification(i));
+    }
+    hasRelevanceJustification(i) {
+        const relevance = typeof i.relevance === 'string' ? i.relevance.trim() : '';
+        return relevance.length >= 10;
+    }
+    /** 记录本轮使用的轮换技法（idea.generate 的 provenance.technique 字段写它）。 */
+    tag(hypotheses, technique) {
+        return hypotheses.map((h) => ({ ...h, technique }));
+    }
+    /** 根据 sourceLabels 构建来源深度详情（默认 shallow） */
+    buildSourceDetails(labels, sources) {
+        const byName = new Map(sources.map((s) => [s.name, s.sourceDepth ?? 'shallow']));
+        return labels.map((name) => ({ name, depth: byName.get(name) ?? 'shallow' }));
+    }
+    /**
+     * 模板 fallback — 从旧实现保留
+     */
+    templateFallback(combo) {
+        const [a, b] = combo.sources;
+        const hash = this.stableHash(a, b);
+        const idx = hash % TEMPLATES.length;
+        const t = TEMPLATES[idx];
+        return {
+            id: `hyp_fb_${Date.now()}_${++this.idCounter}_${this.rng().toString(36).slice(2, 4)}`,
+            title: t.title(a, b),
+            idea: t.idea(a, b),
+            expectedBenefit: t.expectedBenefit,
+            risk: t.risk,
+            sourceLabels: [a, b],
+            sourceDetails: [a, b].map((name) => ({ name, depth: 'shallow' })),
+            novelty: 50 + Math.round(this.rng() * 30),
+            feasibility: 40 + Math.round(this.rng() * 30),
+            impact: 50 + Math.round(this.rng() * 25),
+            status: 'draft',
+            createdAt: Date.now(),
+        };
+    }
+    stableHash(a, b) {
+        let h = 0;
+        const s = a + '|' + b;
+        for (let i = 0; i < s.length; i++) {
+            h = (h << 5) - h + s.charCodeAt(i);
+            h = h & h;
+        }
+        return Math.abs(h);
+    }
+}
+exports.HypothesisGenerator = HypothesisGenerator;
+const TEMPLATES = [
+    {
+        title: (a, b) => `${a} 驱动的 ${b}`,
+        idea: (a, b) => `将「${a}」的核心机制作为「${b}」的新输入维度`,
+        expectedBenefit: '解锁之前被忽视的新能力组合',
+        risk: '组合可能引入不必要的复杂度',
+    },
+    {
+        title: (a, b) => `基于 ${a} 的 ${b} 增强`,
+        idea: (a, b) => `让「${a}」和「${b}」通过一个共享接口互相增强`,
+        expectedBenefit: '系统灵活性提升，涌现新的行为模式',
+        risk: '两个概念耦合后难以单独演进',
+    },
+    {
+        title: (a, b) => `${a} × ${b} 混合系统`,
+        idea: (a, b) => `借鉴「${a}」的设计哲学重新思考「${b}」的实现`,
+        expectedBenefit: '减少重复逻辑，提升模块间信息复用',
+        risk: '可能存在隐含的语义冲突',
+    },
+    {
+        title: (a, b) => `从 ${a} 到 ${b} 的抽象跳跃`,
+        idea: (a, b) => `在「${a}」的基础上构建「${b}」的新抽象层`,
+        expectedBenefit: '降低认知负载，统一概念模型',
+        risk: '抽象层过多影响 runtime 性能',
+    },
+    {
+        title: (a, b) => `${a} 视角下的 ${b} 重构`,
+        idea: (a, b) => `将「${a}」的某一种能力移植到「${b}」的上下文中`,
+        expectedBenefit: '架构更优雅，扩展点增加',
+        risk: '预期收益不确定，需要实验验证',
+    },
+];
+// 保留旧文件中的 PATTERN_LIBRARY 作为参考，但不再使用

package/dist/IdeaGenerator.d.ts

@@ -0,0 +1,51 @@
+import type { CreativitySource, ConceptCombo, Hypothesis, CreativeIdea, Strategy, ExternalSignal } from './types';
+/**
+ * IdeaGenerator — 创造力引擎的核心编排器
+ *
+ * 流程：
+ * 1. Source Gathering — 从多个来源收集"概念"
+ * 2. Concept Mixing — 随机配对重组（规则引擎，保留）
+ * 3. Hypothesis Generation — 将组合转化为假设（LLM 驱动，new）
+ * 4. Experiment Planning — 为假设生成验证方案（规则引擎，保留）
+ */
+export declare class IdeaGenerator {
+    private mixer;
+    private hypothesisGen;
+    private experimentPlanner;
+    private rng;
+    private temperature;
+    /** 已探索过的配对 key 列表，传给 ConceptMixer 以降权 */
+    private exploredPairs;
+    constructor(chatJson: (userText: string, options?: {
+        system?: string;
+        temperature?: number;
+        timeoutMs?: number;
+        requestId?: string;
+    }) => Promise<{
+        data?: any;
+        error?: string;
+    }>, temperature?: number, seed?: number, rotationSeed?: number);
+    /**
+     * 完整一轮"灵感涌现"流程
+     * @param strategy 生成策略，约束 ConceptMixer 配对空间
+     */
+    generateIdeas(sources: CreativitySource[], maxIdeas?: number, strategy?: Strategy, externalSignals?: ExternalSignal[], method?: string): Promise<CreativeIdea[]>;
+    /**
+     * Dream Mode — 高随机性、跨时间跨度的"梦境"模式
+     */
+    dreamIdeas(recentSources: CreativitySource[], historicalCombos: ConceptCombo[], failedHypotheses: Hypothesis[], maxIdeas?: number, strategy?: Strategy): Promise<CreativeIdea[]>;
+    setTemperature(t: number): void;
+    /** 设置已探索过的配对，用于 ConceptMixer 降权 */
+    setExploredPairs(pairs: string[]): void;
+    /**
+     * 可行性/质量门禁 — 过滤明显不靠谱的想法
+     * - 可行性评分 >= 30 才保留
+     * - 想法描述至少 20 个字符（排除模板填空）
+     * - novelty > 80 但 feasibility < 40 的"可疑高新颖性"需要额外检查描述长度
+     */
+    private feasibilityGate;
+    /**
+     * 温度影响来源选择权重
+     */
+    private applyTemperature;
+}

package/dist/IdeaGenerator.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdeaGenerator = void 0;
+const ConceptMixer_1 = require("./ConceptMixer");
+const HypothesisGenerator_1 = require("./HypothesisGenerator");
+const ExperimentPlanner_1 = require("./ExperimentPlanner");
+const random_1 = require("@akemi-mio/core/utils/random");
+/**
+ * IdeaGenerator — 创造力引擎的核心编排器
+ *
+ * 流程：
+ * 1. Source Gathering — 从多个来源收集"概念"
+ * 2. Concept Mixing — 随机配对重组（规则引擎，保留）
+ * 3. Hypothesis Generation — 将组合转化为假设（LLM 驱动，new）
+ * 4. Experiment Planning — 为假设生成验证方案（规则引擎，保留）
+ */
+class IdeaGenerator {
+    mixer;
+    hypothesisGen;
+    experimentPlanner;
+    rng;
+    // 创造力温度：越高越随机，越低越保守
+    temperature = 0.3;
+    /** 已探索过的配对 key 列表，传给 ConceptMixer 以降权 */
+    exploredPairs = [];
+    constructor(chatJson, temperature = 0.3, seed, rotationSeed = 0) {
+        this.rng = (0, random_1.resolveRandom)(seed);
+        this.mixer = new ConceptMixer_1.ConceptMixer(seed);
+        this.hypothesisGen = new HypothesisGenerator_1.HypothesisGenerator(chatJson, seed, rotationSeed);
+        this.experimentPlanner = new ExperimentPlanner_1.ExperimentPlanner(seed);
+        this.temperature = temperature;
+    }
+    /**
+     * 完整一轮"灵感涌现"流程
+     * @param strategy 生成策略，约束 ConceptMixer 配对空间
+     */
+    async generateIdeas(sources, maxIdeas = 5, strategy = 'explore', externalSignals = [], method) {
+        if (sources.length < 2)
+            return [];
+        // 1. 随机扰动：温度越高，来源选择越随机
+        const activeSources = this.applyTemperature(sources);
+        // 2. 概念重组：按策略约束配对 + 打分
+        const scoredCombos = this.mixer.mix(activeSources, maxIdeas * 3, this.exploredPairs, strategy);
+        const combos = scoredCombos.map((c) => c.combo);
+        if (combos.length === 0)
+            return [];
+        // 3. 用 LLM 生成假设（外部信号作为审视视角注入，不参与配对）
+        const hypotheses = await this.hypothesisGen.generate(combos, activeSources, false, externalSignals, method);
+        // 4. 可行性/质量门禁（与 dream 模式同一套门槛）——此前只有梦境路径
+        //    过 feasibilityGate，主路径仅按 novelty 筛，可行性 0 分也能入库。
+        const feasible = this.feasibilityGate(hypotheses);
+        // 5. 策略感知的新颖性门禁 — stable 模式同类型配对新颖度天然偏低，
+        //    降低阈值避免误杀；signal 模式需要更高的新颖度才有价值
+        const noveltyThreshold = strategy === 'stable' ? 30 : strategy === 'signal' ? 40 : 35;
+        const novel = feasible.filter((h) => h.novelty >= noveltyThreshold);
+        // 6. 为每个假设生成实验方案
+        const ideas = novel.slice(0, maxIdeas).map((h) => ({
+            hypothesis: h,
+            experiment: this.experimentPlanner.plan(h),
+        }));
+        return ideas;
+    }
+    /**
+     * Dream Mode — 高随机性、跨时间跨度的"梦境"模式
+     */
+    async dreamIdeas(recentSources, historicalCombos, failedHypotheses, maxIdeas = 3, strategy = 'explore') {
+        // 梦境模式：提高温度，纳入失败历史，强制跨类型组合
+        const dreamTemperature = 0.8;
+        // 将失败方案转化为来源（高权重）
+        const failureSources = failedHypotheses.map((h) => ({
+            name: `失败:${h.title}`,
+            content: `${h.idea}\n风险:${h.risk}`,
+            type: 'failure',
+            weight: 0.8,
+        }));
+        const allSources = [
+            ...recentSources,
+            ...failureSources,
+            // 添加随机扰动源
+            {
+                name: `随机种子_${Date.now()}`,
+                content: this.rng().toString(36),
+                type: 'random',
+                weight: 0.3,
+            },
+        ];
+        // 用高温度混合
+        const activeSources = this.mixer.pickRandomSources(allSources, dreamTemperature, 4);
+        const scoredCombos = this.mixer.mix(activeSources, maxIdeas * 5, [], strategy);
+        const combos = scoredCombos.map((c) => c.combo);
+        if (combos.length === 0)
+            return [];
+        // 梦境模式：高温度 + dreamMode=true
+        const hypotheses = await this.hypothesisGen.generate(combos, activeSources, true);
+        const feasible = this.feasibilityGate(hypotheses);
+        const novel = feasible.filter((h) => h.novelty >= 50);
+        return novel.slice(0, maxIdeas).map((h) => ({
+            hypothesis: h,
+            experiment: this.experimentPlanner.plan(h),
+        }));
+    }
+    setTemperature(t) {
+        this.temperature = Math.max(0, Math.min(1, t));
+    }
+    /** 设置已探索过的配对，用于 ConceptMixer 降权 */
+    setExploredPairs(pairs) {
+        this.exploredPairs = pairs;
+    }
+    /**
+     * 可行性/质量门禁 — 过滤明显不靠谱的想法
+     * - 可行性评分 >= 30 才保留
+     * - 想法描述至少 20 个字符（排除模板填空）
+     * - novelty > 80 但 feasibility < 40 的"可疑高新颖性"需要额外检查描述长度
+     */
+    feasibilityGate(hypotheses) {
+        return hypotheses.filter((h) => {
+            if (h.feasibility < 30)
+                return false;
+            if (!h.idea || h.idea.length < 20)
+                return false;
+            if (h.novelty > 80 && h.feasibility < 40) {
+                if (!h.idea || h.idea.length < 60)
+                    return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * 温度影响来源选择权重
+     */
+    applyTemperature(sources) {
+        if (this.temperature < 0.2) {
+            return [...sources].sort((a, b) => b.weight - a.weight).slice(0, 4);
+        }
+        if (this.temperature > 0.7) {
+            return sources.filter(() => this.rng() > 0.2);
+        }
+        return sources.filter((s) => {
+            if (s.weight > 0.7)
+                return true;
+            return this.rng() < 0.85;
+        });
+    }
+}
+exports.IdeaGenerator = IdeaGenerator;