@akemi-mio/creativity 0.1.1 → 0.2.0

package/dist/FeedbackRollout.d.ts

@@ -0,0 +1,72 @@
+/**
+ * FeedbackRollout — 正向反馈闭环放量决策（设计 v1.0，P3 收尾）
+ *
+ * "离线回放 → 影子运行 → 小流量 → 正式启用，每阶段预固定基线、指标、回滚条件"（spec §八 P3）。
+ * 本模块把那张表落成可执行判定：
+ *   - rollback：安全不变量破坏（Duplicate Application Rate > 0）→ 立即建议回滚 off。
+ *   - advance：当前阶段的预固定门槛全部满足 → 建议进入下一阶段。
+ *   - hold：证据不足 → 保持当前阶段。
+ *
+ * 纯函数：不读写文件、不查 DB。阈值进配置 + 解析校验（R6 纪律）。
+ * 反馈永不进入 checkPromotionGate/checkSubmitGate；放量判定只决定"生成端消费档位"。
+ */
+import type { FeedbackSnapshot } from './FeedbackLearning';
+import { type FeedbackMode } from './FeedbackRuntime';
+export interface FeedbackRolloutThresholds {
+    /** 每阶段所需的最少运行观测数（shadow 或 canary） */
+    minStageRuns: number;
+    /** 升档所需的最小归因覆盖率（有 provenance 的正向事件占比） */
+    minAttributionCoverage: number;
+    /** canary → full 所允许的最大负向事件率（负向证据 / 全部证据） */
+    maxNegativeEventRate: number;
+}
+export declare const DEFAULT_FEEDBACK_ROLLOUT_THRESHOLDS: FeedbackRolloutThresholds;
+/** 解析并校验放量阈值；失败返回 null（fail-closed，调用方回退默认）。 */
+export declare function parseFeedbackRolloutThresholds(raw: unknown): FeedbackRolloutThresholds | null;
+/** 从环境变量解析（缺省全默认）。 */
+export declare function resolveFeedbackRolloutThresholds(env?: Record<string, string | undefined>): FeedbackRolloutThresholds;
+/** 一次观测模式下的生成运行摘要（shadow/canary/full；off 不观测不记录）。 */
+export interface FeedbackRuntimeRun {
+    at: number;
+    mode: Exclude<FeedbackMode, 'off'>;
+    snapshotVersion: string | null;
+    pairCount: number;
+    applied: boolean;
+}
+/** 阶梯：off → shadow → canary → full。 */
+export declare const FEEDBACK_MODE_LADDER: readonly FeedbackMode[];
+export declare function nextFeedbackMode(current: FeedbackMode): FeedbackMode | null;
+export interface FeedbackRolloutMetrics {
+    snapshotVersion: string | null;
+    shadowRuns: number;
+    canaryRuns: number;
+    attributionCoverage: number;
+    duplicateApplicationRate: number;
+    negativeEventRate: number;
+    eventCount: number;
+}
+export type FeedbackRolloutDecision = 'rollback' | 'advance' | 'hold';
+export interface FeedbackRolloutReport {
+    decision: FeedbackRolloutDecision;
+    from: FeedbackMode;
+    /** rollback → 'off'；advance → 下一阶段；hold → null */
+    to: FeedbackMode | null;
+    reasons: string[];
+    metrics: FeedbackRolloutMetrics;
+}
+/** 快照内负向事件率：负向证据 / 全部证据（无证据 → 0）。 */
+export declare function negativeEventRateOf(snapshot: FeedbackSnapshot | null): number;
+export interface BuildFeedbackRolloutReportArgs {
+    snapshot: FeedbackSnapshot | null;
+    runs: readonly FeedbackRuntimeRun[];
+    currentMode: FeedbackMode;
+    thresholds?: FeedbackRolloutThresholds;
+}
+/**
+ * 放量判定。判定顺序：
+ *   1. 安全不变量破坏（重复加权）→ rollback（无条件，压过一切）。
+ *   2. off → shadow：观测零风险，无条件 advance。
+ *   3. shadow → canary / canary → full：预固定门槛全部满足才 advance，否则 hold。
+ *   4. full：已到顶，hold。
+ */
+export declare function buildFeedbackRolloutReport(args: BuildFeedbackRolloutReportArgs): FeedbackRolloutReport;

package/dist/FeedbackRollout.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * FeedbackRollout — 正向反馈闭环放量决策（设计 v1.0，P3 收尾）
+ *
+ * "离线回放 → 影子运行 → 小流量 → 正式启用，每阶段预固定基线、指标、回滚条件"（spec §八 P3）。
+ * 本模块把那张表落成可执行判定：
+ *   - rollback：安全不变量破坏（Duplicate Application Rate > 0）→ 立即建议回滚 off。
+ *   - advance：当前阶段的预固定门槛全部满足 → 建议进入下一阶段。
+ *   - hold：证据不足 → 保持当前阶段。
+ *
+ * 纯函数：不读写文件、不查 DB。阈值进配置 + 解析校验（R6 纪律）。
+ * 反馈永不进入 checkPromotionGate/checkSubmitGate；放量判定只决定"生成端消费档位"。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEEDBACK_MODE_LADDER = exports.DEFAULT_FEEDBACK_ROLLOUT_THRESHOLDS = void 0;
+exports.parseFeedbackRolloutThresholds = parseFeedbackRolloutThresholds;
+exports.resolveFeedbackRolloutThresholds = resolveFeedbackRolloutThresholds;
+exports.nextFeedbackMode = nextFeedbackMode;
+exports.negativeEventRateOf = negativeEventRateOf;
+exports.buildFeedbackRolloutReport = buildFeedbackRolloutReport;
+exports.DEFAULT_FEEDBACK_ROLLOUT_THRESHOLDS = {
+    minStageRuns: 5,
+    minAttributionCoverage: 0.3,
+    maxNegativeEventRate: 0.5,
+};
+function clampNumber(value, min, max, fallback) {
+    const num = typeof value === 'string' ? Number(value) : value;
+    if (typeof num !== 'number' || !Number.isFinite(num))
+        return fallback;
+    return Math.max(min, Math.min(max, num));
+}
+/** 解析并校验放量阈值；失败返回 null（fail-closed，调用方回退默认）。 */
+function parseFeedbackRolloutThresholds(raw) {
+    if (raw === null || typeof raw !== 'object')
+        return null;
+    const obj = raw;
+    const hasAny = ['minStageRuns', 'minAttributionCoverage', 'maxNegativeEventRate'].some((k) => obj[k] !== undefined);
+    if (!hasAny)
+        return null;
+    return {
+        minStageRuns: clampNumber(obj.minStageRuns, 1, 10_000, exports.DEFAULT_FEEDBACK_ROLLOUT_THRESHOLDS.minStageRuns),
+        minAttributionCoverage: clampNumber(obj.minAttributionCoverage, 0, 1, exports.DEFAULT_FEEDBACK_ROLLOUT_THRESHOLDS.minAttributionCoverage),
+        maxNegativeEventRate: clampNumber(obj.maxNegativeEventRate, 0, 1, exports.DEFAULT_FEEDBACK_ROLLOUT_THRESHOLDS.maxNegativeEventRate),
+    };
+}
+/** 从环境变量解析（缺省全默认）。 */
+function resolveFeedbackRolloutThresholds(env = process.env) {
+    return (parseFeedbackRolloutThresholds({
+        minStageRuns: env.MIO_FEEDBACK_MIN_STAGE_RUNS,
+        minAttributionCoverage: env.MIO_FEEDBACK_MIN_COVERAGE,
+        maxNegativeEventRate: env.MIO_FEEDBACK_MAX_NEGATIVE_RATE,
+    }) ?? exports.DEFAULT_FEEDBACK_ROLLOUT_THRESHOLDS);
+}
+// ══════════════════════════════════════════
+// 放量判定
+// ══════════════════════════════════════════
+/** 阶梯：off → shadow → canary → full。 */
+exports.FEEDBACK_MODE_LADDER = ['off', 'shadow', 'canary', 'full'];
+function nextFeedbackMode(current) {
+    const index = exports.FEEDBACK_MODE_LADDER.indexOf(current);
+    return index >= 0 && index < exports.FEEDBACK_MODE_LADDER.length - 1 ? exports.FEEDBACK_MODE_LADDER[index + 1] : null;
+}
+/** 快照内负向事件率：负向证据 / 全部证据（无证据 → 0）。 */
+function negativeEventRateOf(snapshot) {
+    if (!snapshot)
+        return 0;
+    let negative = 0;
+    let total = 0;
+    for (const pair of snapshot.pairs) {
+        for (const dimension of ['selection', 'quality', 'landing']) {
+            total += pair[dimension].evidenceCount;
+        }
+        negative += pair.negative.evidenceCount;
+        total += pair.negative.evidenceCount;
+    }
+    return total > 0 ? negative / total : 0;
+}
+function metricsOf(snapshot, runs) {
+    return {
+        snapshotVersion: snapshot?.version ?? null,
+        shadowRuns: runs.filter((r) => r.mode === 'shadow').length,
+        canaryRuns: runs.filter((r) => r.mode === 'canary').length,
+        attributionCoverage: snapshot?.attributionCoverage ?? 0,
+        duplicateApplicationRate: snapshot?.duplicateApplicationRate ?? 0,
+        negativeEventRate: negativeEventRateOf(snapshot),
+        eventCount: snapshot?.eventCount ?? 0,
+    };
+}
+/**
+ * 放量判定。判定顺序：
+ *   1. 安全不变量破坏（重复加权）→ rollback（无条件，压过一切）。
+ *   2. off → shadow：观测零风险，无条件 advance。
+ *   3. shadow → canary / canary → full：预固定门槛全部满足才 advance，否则 hold。
+ *   4. full：已到顶，hold。
+ */
+function buildFeedbackRolloutReport(args) {
+    const thresholds = args.thresholds ?? exports.DEFAULT_FEEDBACK_ROLLOUT_THRESHOLDS;
+    const metrics = metricsOf(args.snapshot, args.runs);
+    const reasons = [];
+    // 1) 安全不变量：重复加权率必须为 0（P1 验收不变量）
+    if (metrics.duplicateApplicationRate > 0) {
+        reasons.push(`duplicate_application_rate=${metrics.duplicateApplicationRate.toFixed(4)} > 0 (invariant broken)`);
+        return { decision: 'rollback', from: args.currentMode, to: 'off', reasons, metrics };
+    }
+    const next = nextFeedbackMode(args.currentMode);
+    if (args.currentMode === 'full' || next === null) {
+        reasons.push('already at full stage');
+        return { decision: 'hold', from: args.currentMode, to: null, reasons, metrics };
+    }
+    // 2) off → shadow：只增加观测，不改变生成行为
+    if (args.currentMode === 'off') {
+        reasons.push('observation adds no generation risk');
+        return { decision: 'advance', from: 'off', to: 'shadow', reasons, metrics };
+    }
+    // 3) shadow → canary / canary → full：预固定门槛
+    const stageRuns = args.currentMode === 'shadow' ? metrics.shadowRuns : metrics.canaryRuns;
+    const stageName = args.currentMode;
+    let ready = true;
+    if (stageRuns < thresholds.minStageRuns) {
+        ready = false;
+        reasons.push(`${stageName} runs ${stageRuns} < min ${thresholds.minStageRuns}`);
+    }
+    if (metrics.attributionCoverage < thresholds.minAttributionCoverage) {
+        ready = false;
+        reasons.push(`attribution coverage ${metrics.attributionCoverage.toFixed(4)} < min ${thresholds.minAttributionCoverage}`);
+    }
+    if (args.currentMode === 'canary' && metrics.negativeEventRate > thresholds.maxNegativeEventRate) {
+        ready = false;
+        reasons.push(`negative event rate ${metrics.negativeEventRate.toFixed(4)} > max ${thresholds.maxNegativeEventRate}`);
+    }
+    if (!ready) {
+        return { decision: 'hold', from: args.currentMode, to: null, reasons, metrics };
+    }
+    reasons.push(`all ${stageName} stage gates met`);
+    return { decision: 'advance', from: args.currentMode, to: next, reasons, metrics };
+}

package/dist/FeedbackRuntime.d.ts

@@ -0,0 +1,37 @@
+/**
+ * FeedbackRuntime — 正向反馈闭环受控启用（设计 v1.0，P3）
+ *
+ * 把"是否/如何消费反馈"从代码常量提升为可配置、可校验的运行时状态（R6 纪律）：
+ *   - off     关闭：生成行为与无反馈时逐字节一致（默认）。
+ *   - shadow  影子运行：计算反馈调整并记录 delta，但不应用到排序/prompt。
+ *   - canary 小流量：按比例应用反馈（λ 与探索预算生效）。
+ *   - full    正式启用：全部应用。
+ *
+ * 每阶段预固定基线、指标与回滚条件；回滚 = 切回 off（配置热切换，无需发版）。
+ * 反馈永不进入 checkPromotionGate/checkSubmitGate 输入（spec §二.2）。
+ */
+export type FeedbackMode = 'off' | 'shadow' | 'canary' | 'full';
+export interface FeedbackRuntimeConfig {
+    mode: FeedbackMode;
+    /** λ clamp：单对调整占总评分范围的比例上限 */
+    lambdaClampPct: number;
+    /** 探索预算：保留给低频/新组合的槽位比例 */
+    explorationBudget: number;
+    /** 证据时间衰减半衰期（天） */
+    halfLifeDays: number;
+    /** canary 模式应用反馈的比例 0..1 */
+    canaryFraction: number;
+}
+export declare const DEFAULT_FEEDBACK_RUNTIME: FeedbackRuntimeConfig;
+export declare const FEEDBACK_MODES: readonly FeedbackMode[];
+/**
+ * 解析并校验运行时配置；失败返回 null（fail-closed，调用方回退默认 off）。
+ * 未知字段忽略。
+ */
+export declare function parseFeedbackRuntime(raw: unknown): FeedbackRuntimeConfig | null;
+/** 从环境变量解析（缺省全 off）。 */
+export declare function resolveFeedbackRuntime(env?: Record<string, string | undefined>): FeedbackRuntimeConfig;
+/** 该模式下是否实际应用反馈到生成（shadow 只观测）。 */
+export declare function isFeedbackApplied(mode: FeedbackMode): boolean;
+/** 该模式下是否观测（计算 delta 并记录）。 */
+export declare function isFeedbackObserved(mode: FeedbackMode): boolean;

package/dist/FeedbackRuntime.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * FeedbackRuntime — 正向反馈闭环受控启用（设计 v1.0，P3）
+ *
+ * 把"是否/如何消费反馈"从代码常量提升为可配置、可校验的运行时状态（R6 纪律）：
+ *   - off     关闭：生成行为与无反馈时逐字节一致（默认）。
+ *   - shadow  影子运行：计算反馈调整并记录 delta，但不应用到排序/prompt。
+ *   - canary 小流量：按比例应用反馈（λ 与探索预算生效）。
+ *   - full    正式启用：全部应用。
+ *
+ * 每阶段预固定基线、指标与回滚条件；回滚 = 切回 off（配置热切换，无需发版）。
+ * 反馈永不进入 checkPromotionGate/checkSubmitGate 输入（spec §二.2）。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEEDBACK_MODES = exports.DEFAULT_FEEDBACK_RUNTIME = void 0;
+exports.parseFeedbackRuntime = parseFeedbackRuntime;
+exports.resolveFeedbackRuntime = resolveFeedbackRuntime;
+exports.isFeedbackApplied = isFeedbackApplied;
+exports.isFeedbackObserved = isFeedbackObserved;
+exports.DEFAULT_FEEDBACK_RUNTIME = {
+    mode: 'off',
+    lambdaClampPct: 0.1,
+    explorationBudget: 0.2,
+    halfLifeDays: 30,
+    canaryFraction: 0.1,
+};
+exports.FEEDBACK_MODES = ['off', 'shadow', 'canary', 'full'];
+function clampNumber(value, min, max, fallback) {
+    const num = typeof value === 'string' ? Number(value) : value;
+    if (typeof num !== 'number' || !Number.isFinite(num))
+        return fallback;
+    return Math.max(min, Math.min(max, num));
+}
+/**
+ * 解析并校验运行时配置；失败返回 null（fail-closed，调用方回退默认 off）。
+ * 未知字段忽略。
+ */
+function parseFeedbackRuntime(raw) {
+    if (raw === null || typeof raw !== 'object')
+        return null;
+    const obj = raw;
+    const mode = obj.mode;
+    if (!exports.FEEDBACK_MODES.includes(mode))
+        return null;
+    return {
+        mode: mode,
+        lambdaClampPct: clampNumber(obj.lambdaClampPct, 0, 0.5, exports.DEFAULT_FEEDBACK_RUNTIME.lambdaClampPct),
+        explorationBudget: clampNumber(obj.explorationBudget, 0, 1, exports.DEFAULT_FEEDBACK_RUNTIME.explorationBudget),
+        halfLifeDays: clampNumber(obj.halfLifeDays, 1, 3650, exports.DEFAULT_FEEDBACK_RUNTIME.halfLifeDays),
+        canaryFraction: clampNumber(obj.canaryFraction, 0, 1, exports.DEFAULT_FEEDBACK_RUNTIME.canaryFraction),
+    };
+}
+/** 从环境变量解析（缺省全 off）。 */
+function resolveFeedbackRuntime(env = process.env) {
+    const parsed = parseFeedbackRuntime({
+        mode: env.MIO_FEEDBACK_MODE,
+        lambdaClampPct: env.MIO_FEEDBACK_LAMBDA_PCT,
+        explorationBudget: env.MIO_FEEDBACK_EXPLORATION,
+        halfLifeDays: env.MIO_FEEDBACK_HALF_LIFE_DAYS,
+        canaryFraction: env.MIO_FEEDBACK_CANARY_FRACTION,
+    });
+    // env 全缺省时 parse 返回 null（mode undefined）→ 回退默认 off
+    return parsed ?? exports.DEFAULT_FEEDBACK_RUNTIME;
+}
+/** 该模式下是否实际应用反馈到生成（shadow 只观测）。 */
+function isFeedbackApplied(mode) {
+    return mode === 'canary' || mode === 'full';
+}
+/** 该模式下是否观测（计算 delta 并记录）。 */
+function isFeedbackObserved(mode) {
+    return mode === 'shadow' || mode === 'canary' || mode === 'full';
+}

package/dist/HypothesisGenerator.d.ts

@@ -1,4 +1,5 @@
 import type { Hypothesis, ConceptCombo, CreativitySource, ExternalSignal } from './types';
+import type { FeedbackPromptBlock } from './FeedbackLearning';
 /**
  * HypothesisGenerator — 将概念组合转化为可验证的假设
  *
@@ -38,7 +39,9 @@ export declare class HypothesisGenerator {
     /** 外部信号 — 不参与配对，作为审视视角注入 LLM */
     externalSignals?: ExternalSignal[], 
     /** 显式技法；缺省走五技法轮换（rotationSeed + 调用次数） */
-    method?: string): Promise<Hypothesis[]>;
+    method?: string, 
+    /** 正向反馈闭环 P2：不可变快照的结构化提示块。缺省 = 提示词逐字节不变。 */
+    feedback?: FeedbackPromptBlock): Promise<Hypothesis[]>;
     /**
      * 调 LLM 生成创意
      */

package/dist/HypothesisGenerator.js

@@ -42,13 +42,15 @@ class HypothesisGenerator {
     /** 外部信号 — 不参与配对，作为审视视角注入 LLM */
     externalSignals = [], 
     /** 显式技法；缺省走五技法轮换（rotationSeed + 调用次数） */
-    method) {
+    method, 
+    /** 正向反馈闭环 P2：不可变快照的结构化提示块。缺省 = 提示词逐字节不变。 */
+    feedback) {
         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);
+        const llmResults = await this.tryLLM(sources, combos, dreamMode, externalSignals, technique, feedback);
         if (llmResults.length > 0) {
             return this.tag(llmResults.map((r) => ({
                 id: `hyp_${Date.now()}_${++this.idCounter}_${this.rng().toString(36).slice(2, 4)}`,
@@ -68,7 +70,7 @@ class HypothesisGenerator {
         // 第二级：本地 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);
+            const localResults = await this.tryLocalModel(sources, combos, dreamMode, technique, feedback);
             if (localResults.length > 0) {
                 return this.tag(localResults.map((r) => ({
                     id: `hyp_local_${Date.now()}_${++this.idCounter}_${this.rng().toString(36).slice(2, 4)}`,
@@ -105,14 +107,14 @@ class HypothesisGenerator {
     /**
      * 调 LLM 生成创意
      */
-    async tryLLM(sources, combos, dreamMode, externalSignals = [], technique = '') {
+    async tryLLM(sources, combos, dreamMode, externalSignals = [], technique = '', feedback) {
         // 限制输入量，避免超 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);
+        const prompt = (0, CreativityPrompt_1.buildCreativityPrompt)(sources, comboInfo, externalSignals, feedback);
         try {
             const result = await this.chatJson(prompt, {
                 system: (0, CreativityPrompt_1.buildSystemPrompt)(technique),
@@ -141,13 +143,13 @@ class HypothesisGenerator {
     /**
      * 调本地 transformers.js 模型生成创意
      */
-    async tryLocalModel(sources, combos, dreamMode, technique = '') {
+    async tryLocalModel(sources, combos, dreamMode, technique = '', feedback) {
         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 prompt = (0, CreativityPrompt_1.buildCreativityPrompt)(sources, comboInfo, [], feedback);
         const result = await this.localModel.generate(prompt, {
             system: (0, CreativityPrompt_1.buildSystemPrompt)(technique),
             temperature: dreamMode ? 0.8 : 0.6,

package/dist/IdeaGenerator.d.ts

@@ -1,4 +1,6 @@
 import type { CreativitySource, ConceptCombo, Hypothesis, CreativeIdea, Strategy, ExternalSignal } from './types';
+import { type FeedbackMixerInput } from './ConceptMixer';
+import type { FeedbackPromptBlock } from './FeedbackLearning';
 /**
  * IdeaGenerator — 创造力引擎的核心编排器
  *
@@ -29,7 +31,11 @@ export declare class IdeaGenerator {
      * 完整一轮"灵感涌现"流程
      * @param strategy 生成策略，约束 ConceptMixer 配对空间
      */
-    generateIdeas(sources: CreativitySource[], maxIdeas?: number, strategy?: Strategy, externalSignals?: ExternalSignal[], method?: string): Promise<CreativeIdea[]>;
+    generateIdeas(sources: CreativitySource[], maxIdeas?: number, strategy?: Strategy, externalSignals?: ExternalSignal[], method?: string, 
+    /** 正向反馈闭环 P2：结构化提示块（缺省 = 提示词逐字节不变）。 */
+    feedbackPrompt?: FeedbackPromptBlock, 
+    /** 正向反馈闭环 P2：mixer 有界修正 + 探索预算（缺省 = 配对排序逐字节不变）。 */
+    mixerFeedback?: FeedbackMixerInput): Promise<CreativeIdea[]>;
     /**
      * Dream Mode — 高随机性、跨时间跨度的"梦境"模式
      */

package/dist/IdeaGenerator.js

@@ -34,18 +34,22 @@ class IdeaGenerator {
      * 完整一轮"灵感涌现"流程
      * @param strategy 生成策略，约束 ConceptMixer 配对空间
      */
-    async generateIdeas(sources, maxIdeas = 5, strategy = 'explore', externalSignals = [], method) {
+    async generateIdeas(sources, maxIdeas = 5, strategy = 'explore', externalSignals = [], method, 
+    /** 正向反馈闭环 P2：结构化提示块（缺省 = 提示词逐字节不变）。 */
+    feedbackPrompt, 
+    /** 正向反馈闭环 P2：mixer 有界修正 + 探索预算（缺省 = 配对排序逐字节不变）。 */
+    mixerFeedback) {
         if (sources.length < 2)
             return [];
         // 1. 随机扰动：温度越高，来源选择越随机
         const activeSources = this.applyTemperature(sources);
-        // 2. 概念重组：按策略约束配对 + 打分
-        const scoredCombos = this.mixer.mix(activeSources, maxIdeas * 3, this.exploredPairs, strategy);
+        // 2. 概念重组：按策略约束配对 + 打分（可选反馈有界修正）
+        const scoredCombos = this.mixer.mix(activeSources, maxIdeas * 3, this.exploredPairs, strategy, mixerFeedback);
         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);
+        const hypotheses = await this.hypothesisGen.generate(combos, activeSources, false, externalSignals, method, feedbackPrompt);
         // 4. 可行性/质量门禁（与 dream 模式同一套门槛）——此前只有梦境路径
         //    过 feasibilityGate，主路径仅按 novelty 筛，可行性 0 分也能入库。
         const feasible = this.feasibilityGate(hypotheses);

package/dist/InsightSamplingExperiment.d.ts

@@ -78,5 +78,5 @@ export declare function runInsightSamplingExperiment(experimentId: string, obser
     repeats?: number;
 }): CapabilityDeltaReport;
 /** 把 CapabilityDelta 报告转成 ExperimentRun 列表（供 ExperimentRunStore.checkPromotionGate 使用） */
-export declare function reportToExperimentRuns(report: CapabilityDeltaReport): ExperimentRun[];
+export declare function reportToExperimentRuns(report: CapabilityDeltaReport, feedbackSnapshotVersion?: string): ExperimentRun[];
 export {};

package/dist/InsightSamplingExperiment.js

@@ -283,12 +283,13 @@ function runInsightSamplingExperiment(experimentId, observations, options) {
     };
 }
 /** 把 CapabilityDelta 报告转成 ExperimentRun 列表（供 ExperimentRunStore.checkPromotionGate 使用） */
-function reportToExperimentRuns(report) {
+function reportToExperimentRuns(report, feedbackSnapshotVersion) {
     return report.variants.map((v) => ({
         id: `${report.experimentId}:${v.variant}`,
         hypothesisId: report.hypothesisId,
         candidateId: v.variant,
         baselineId: report.baselineVariant,
+        ...(feedbackSnapshotVersion ? { feedbackSnapshotVersion } : {}),
         assignment: (v.variant === 'baseline'
             ? 'baseline'
             : v.variant.startsWith('ablation')

package/dist/JsonlFeedbackEventStore.d.ts

@@ -0,0 +1,32 @@
+/**
+ * JsonlFeedbackEventStore — CLI/MCP 侧证据事件追加存储（P0）
+ *
+ * 落盘：`<dataDir>/feedback-events.jsonl`（append-only）。
+ * 幂等：加载时建 idempotencyKey 集合，同键追加直接跳过（不抛错、不重复生效）。
+ * 这是交换/重放格式，不是权威真相源——主进程 ingest 单向导入 SQLite。
+ */
+import { type HypothesisFeedbackEvent, type HypothesisFeedbackEventInput, type NormalizeQuarantineReason } from './FeedbackEvents';
+export interface JsonlAppendResult {
+    /** 事件已追加并生效 */
+    appended: boolean;
+    /** 因 idempotencyKey 已存在而跳过 */
+    deduped: boolean;
+    event?: HypothesisFeedbackEvent;
+    /** 规范化失败（进隔离队列由调用方处理） */
+    quarantine?: {
+        reason: NormalizeQuarantineReason;
+        raw: unknown;
+    };
+}
+export declare class JsonlFeedbackEventStore {
+    readonly eventsPath: string;
+    private seenKeys;
+    constructor(dataDir: string);
+    /** 重读文件（长活 MCP 进程需看到外部追加；幂等键集合整体重建，成本可接受）。 */
+    private ensureLoaded;
+    /** 供长活进程在外部写入后强制重读。 */
+    invalidate(): void;
+    append(input: HypothesisFeedbackEventInput, now?: number): JsonlAppendResult;
+    /** 读取全部可解析事件（损坏行跳过，供 ingest/回放使用）。 */
+    list(): HypothesisFeedbackEvent[];
+}

package/dist/JsonlFeedbackEventStore.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * JsonlFeedbackEventStore — CLI/MCP 侧证据事件追加存储（P0）
+ *
+ * 落盘：`<dataDir>/feedback-events.jsonl`（append-only）。
+ * 幂等：加载时建 idempotencyKey 集合，同键追加直接跳过（不抛错、不重复生效）。
+ * 这是交换/重放格式，不是权威真相源——主进程 ingest 单向导入 SQLite。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonlFeedbackEventStore = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const FeedbackEvents_1 = require("./FeedbackEvents");
+class JsonlFeedbackEventStore {
+    eventsPath;
+    seenKeys = null;
+    constructor(dataDir) {
+        this.eventsPath = (0, path_1.join)(dataDir, 'feedback-events.jsonl');
+    }
+    /** 重读文件（长活 MCP 进程需看到外部追加；幂等键集合整体重建，成本可接受）。 */
+    ensureLoaded() {
+        if (this.seenKeys)
+            return this.seenKeys;
+        this.seenKeys = new Set();
+        if ((0, fs_1.existsSync)(this.eventsPath)) {
+            const lines = (0, fs_1.readFileSync)(this.eventsPath, 'utf-8').split('\n').filter(Boolean);
+            for (const line of lines) {
+                try {
+                    const row = JSON.parse(line);
+                    if (row && typeof row.idempotencyKey === 'string')
+                        this.seenKeys.add(row.idempotencyKey);
+                }
+                catch {
+                    // 损坏行不参与幂等集合；ingest 时会进隔离
+                }
+            }
+        }
+        return this.seenKeys;
+    }
+    /** 供长活进程在外部写入后强制重读。 */
+    invalidate() {
+        this.seenKeys = null;
+    }
+    append(input, now = Date.now()) {
+        const normalized = (0, FeedbackEvents_1.normalizeFeedbackEvent)(input, now);
+        if (!normalized.ok) {
+            return { appended: false, deduped: false, quarantine: { reason: normalized.reason, raw: normalized.raw } };
+        }
+        const event = normalized.event;
+        const keys = this.ensureLoaded();
+        if (keys.has(event.idempotencyKey)) {
+            return { appended: false, deduped: true, event };
+        }
+        const dir = (0, path_1.dirname)(this.eventsPath);
+        if (!(0, fs_1.existsSync)(dir))
+            (0, fs_1.mkdirSync)(dir, { recursive: true });
+        (0, fs_1.appendFileSync)(this.eventsPath, JSON.stringify(event) + '\n', 'utf-8');
+        keys.add(event.idempotencyKey);
+        return { appended: true, deduped: false, event };
+    }
+    /** 读取全部可解析事件（损坏行跳过，供 ingest/回放使用）。 */
+    list() {
+        if (!(0, fs_1.existsSync)(this.eventsPath))
+            return [];
+        const out = [];
+        for (const line of (0, fs_1.readFileSync)(this.eventsPath, 'utf-8').split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                out.push(JSON.parse(line));
+            }
+            catch {
+                // skip corrupt
+            }
+        }
+        return out;
+    }
+}
+exports.JsonlFeedbackEventStore = JsonlFeedbackEventStore;

package/dist/ingestFeedbackEvents.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ingestFeedbackEvents — CLI JSONL → 主进程 SQLite 单向导入（P0）
+ *
+ * 方向固定：CLI/MCP 只追加 feedback-events.jsonl；主进程定期/按需 ingest。
+ * 不做反向同步（spec §九 R3：同步验证前禁止双端各自算权重）。
+ * 幂等：靠 idempotency_key 唯一约束，重复导入不增样本。
+ * 隔离：规范化失败或 hypothesisId 无对应假设的事件进 quarantine 返回值，不入库、不丢弃。
+ */
+import { type NormalizeQuarantineReason } from './FeedbackEvents';
+import type { DrizzleFeedbackEventStore } from './DrizzleFeedbackEventStore';
+import type { JsonlFeedbackEventStore } from './JsonlFeedbackEventStore';
+export interface IngestFeedbackResult {
+    /** 成功写入权威侧的事件数 */
+    ingested: number;
+    /** 因 idempotencyKey 已存在而跳过 */
+    deduped: number;
+    /** 规范化失败或假设不存在 */
+    quarantined: Array<{
+        reason: NormalizeQuarantineReason | 'unknown_hypothesis';
+        raw: unknown;
+    }>;
+}
+export interface IngestFeedbackOptions {
+    /** 校验 hypothesisId 是否指向真实假设；返回 false 的事件进隔离。 */
+    hypothesisExists?: (id: string) => boolean;
+    now?: number;
+}
+/**
+ * @param jsonlSource CLI 侧 JSONL store（或等价的 list() 数据源）
+ * @param target 主进程权威 SQLite store
+ */
+export declare function ingestFeedbackEvents(jsonlSource: Pick<JsonlFeedbackEventStore, 'list'>, target: Pick<DrizzleFeedbackEventStore, 'append' | 'hasKey'>, options?: IngestFeedbackOptions): IngestFeedbackResult;

package/dist/ingestFeedbackEvents.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * ingestFeedbackEvents — CLI JSONL → 主进程 SQLite 单向导入（P0）
+ *
+ * 方向固定：CLI/MCP 只追加 feedback-events.jsonl；主进程定期/按需 ingest。
+ * 不做反向同步（spec §九 R3：同步验证前禁止双端各自算权重）。
+ * 幂等：靠 idempotency_key 唯一约束，重复导入不增样本。
+ * 隔离：规范化失败或 hypothesisId 无对应假设的事件进 quarantine 返回值，不入库、不丢弃。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ingestFeedbackEvents = ingestFeedbackEvents;
+const FeedbackEvents_1 = require("./FeedbackEvents");
+/**
+ * @param jsonlSource CLI 侧 JSONL store（或等价的 list() 数据源）
+ * @param target 主进程权威 SQLite store
+ */
+function ingestFeedbackEvents(jsonlSource, target, options = {}) {
+    const now = options.now ?? Date.now();
+    const result = { ingested: 0, deduped: 0, quarantined: [] };
+    for (const raw of jsonlSource.list()) {
+        const normalized = (0, FeedbackEvents_1.normalizeFeedbackEvent)(raw, now);
+        if (!normalized.ok) {
+            result.quarantined.push({ reason: normalized.reason, raw });
+            continue;
+        }
+        const event = normalized.event;
+        if (options.hypothesisExists && !options.hypothesisExists(event.hypothesisId)) {
+            result.quarantined.push({ reason: 'unknown_hypothesis', raw });
+            continue;
+        }
+        if (target.hasKey(event.idempotencyKey)) {
+            result.deduped++;
+            continue;
+        }
+        const appendResult = target.append(event);
+        if (appendResult.appended)
+            result.ingested++;
+        else if (appendResult.deduped)
+            result.deduped++;
+    }
+    return result;
+}