@akemi-mio/creativity 0.1.0 → 0.2.0

package/dist/ConceptMixer.d.ts

@@ -1,4 +1,16 @@
 import type { CreativitySource, ConceptCombo, Strategy } from './types';
+/**
+ * 正向反馈闭环 P2 有界消费输入（spec §六.2）。
+ * - `pairAdjustments`：conceptPairKey → λ clamp 后的调整量（调用方已按 λ 上限裁剪）。
+ * - `explorationBudget`：0..1，保留给低频/新组合的槽位比例（防自我复制）。
+ * 缺省 `undefined` → mix() 行为逐字节不变（回归钉保证）。
+ */
+export interface FeedbackMixerInput {
+    pairAdjustments: ReadonlyMap<string, number> | Record<string, number>;
+    explorationBudget?: number;
+    /** 单对调整上限（λ clamp，绝对分）。缺省 0.1（与 DEFAULT_FEEDBACK_LEARNING_CONFIG.lambdaClampPct 对齐）。 */
+    maxAdjustment?: number;
+}
 /**
  * ConceptMixer — 创造力核心：旧概念随机重组产生新想法
  *
@@ -8,6 +20,9 @@ import type { CreativitySource, ConceptCombo, Strategy } from './types';
  * v2 改动：mix() 接受 strategy 参数，在配对前约束组合空间。
  * strategy 决定了允许哪些 type 配对，而不只是事后评分。
  * 参见策略定义：Strategy = 'stable' | 'explore' | 'signal'
+ *
+ * P2 改动：mix() 接受可选 feedback，做有界排序修正 + 探索预算。
+ * 反馈只影响探索优先级，永不进入晋级门输入（spec §二.2）。
  */
 export declare class ConceptMixer {
     private rng;
@@ -17,8 +32,9 @@ export declare class ConceptMixer {
      * @param exploredPairs 已探索过的 pair key 列表（"A|B" 格式，已排序），用于降权
      * @param strategy 策略约束：stable/explore/signal，默认为 'explore'
      *   策略决定哪些 type 配对被允许、评分权重如何调整。
+     * @param feedback 可选：正向反馈有界修正 + 探索预算；缺省 = 行为不变。
      */
-    mix(sources: CreativitySource[], maxCombos?: number, exploredPairs?: string[], strategy?: Strategy): {
+    mix(sources: CreativitySource[], maxCombos?: number, exploredPairs?: string[], strategy?: Strategy, feedback?: FeedbackMixerInput): {
         combo: ConceptCombo;
         score: number;
     }[];

package/dist/ConceptMixer.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConceptMixer = void 0;
+const types_1 = require("./types");
 const random_1 = require("@akemi-mio/core/utils/random");
 /**
  * ConceptMixer — 创造力核心：旧概念随机重组产生新想法
@@ -11,6 +12,9 @@ const random_1 = require("@akemi-mio/core/utils/random");
  * v2 改动：mix() 接受 strategy 参数，在配对前约束组合空间。
  * strategy 决定了允许哪些 type 配对，而不只是事后评分。
  * 参见策略定义：Strategy = 'stable' | 'explore' | 'signal'
+ *
+ * P2 改动：mix() 接受可选 feedback，做有界排序修正 + 探索预算。
+ * 反馈只影响探索优先级，永不进入晋级门输入（spec §二.2）。
  */
 class ConceptMixer {
     rng;
@@ -22,16 +26,45 @@ class ConceptMixer {
      * @param exploredPairs 已探索过的 pair key 列表（"A|B" 格式，已排序），用于降权
      * @param strategy 策略约束：stable/explore/signal，默认为 'explore'
      *   策略决定哪些 type 配对被允许、评分权重如何调整。
+     * @param feedback 可选：正向反馈有界修正 + 探索预算；缺省 = 行为不变。
      */
-    mix(sources, maxCombos = 10, exploredPairs = [], strategy = 'explore') {
+    mix(sources, maxCombos = 10, exploredPairs = [], strategy = 'explore', feedback) {
         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);
+        if (!feedback) {
+            // 缺省路径：与原实现完全一致（含 RNG 调用序列），不得改动
+            const sorted = scored.sort((a, b) => b.score - a.score);
+            return sorted.slice(0, maxCombos);
+        }
+        const adjustments = feedback.pairAdjustments instanceof Map
+            ? feedback.pairAdjustments
+            : new Map(Object.entries(feedback.pairAdjustments));
+        const budget = Math.max(0, Math.min(1, feedback.explorationBudget ?? 0));
+        const exploreCount = Math.min(maxCombos, Math.round(maxCombos * budget));
+        const mainCount = maxCombos - exploreCount;
+        const maxAdj = feedback.maxAdjustment ?? 0.1;
+        const withAdjustment = scored.map((s, idx) => {
+            const [a, b] = allowed[idx];
+            const key = (0, types_1.conceptPairKey)((0, types_1.sourceConceptId)(a), (0, types_1.sourceConceptId)(b));
+            const raw = adjustments.get(key) ?? 0;
+            const adj = Math.max(-maxAdj, Math.min(maxAdj, raw));
+            return { ...s, feedbackKey: key, adjusted: s.score + adj };
+        });
+        const main = [...withAdjustment]
+            .sort((a, b) => (b.adjusted - a.adjusted) || (a.feedbackKey < b.feedbackKey ? -1 : 1))
+            .slice(0, mainCount);
+        const mainKeys = new Set(main.map((s) => s.feedbackKey));
+        const rest = withAdjustment
+            .filter((s) => !mainKeys.has(s.feedbackKey))
+            .sort((a, b) => (a.score - b.score) || (a.feedbackKey < b.feedbackKey ? -1 : 1))
+            .slice(0, exploreCount);
+        return [...main, ...rest]
+            .sort((a, b) => (b.adjusted - a.adjusted) || (a.feedbackKey < b.feedbackKey ? -1 : 1))
+            .map((s) => ({ combo: s.combo, score: s.adjusted }));
     }
     /**
      * 按策略约束生成配对 — 核心改动：

package/dist/CreativityPrompt.d.ts

@@ -1,4 +1,5 @@
 import type { CreativitySource, ExternalSignal } from './types';
+import type { FeedbackPromptBlock } from './FeedbackLearning';
 /**
  * Creativity System Prompt — 给 LLM 的创造力提示词
  * 定义 AI 作为"概念重组引擎"的角色。
@@ -21,4 +22,7 @@ export declare const CREATIVITY_SYSTEM_PROMPT: string;
 export declare function buildCreativityPrompt(sources: CreativitySource[], combos: {
     sources: string[];
     description: string;
-}[], externalSignals?: ExternalSignal[]): string;
+}[], externalSignals?: ExternalSignal[], 
+/** 正向反馈闭环 P2：不可变快照的结构化提示块。缺省 = 输出逐字节不变。 */
+feedback?: FeedbackPromptBlock): string;
+export declare function buildFeedbackBlockSection(feedback: FeedbackPromptBlock): string;

package/dist/CreativityPrompt.js

@@ -4,6 +4,8 @@ exports.CREATIVITY_SYSTEM_PROMPT = exports.TECHNIQUE_CYCLE = void 0;
 exports.buildSystemPrompt = buildSystemPrompt;
 exports.pickTechnique = pickTechnique;
 exports.buildCreativityPrompt = buildCreativityPrompt;
+exports.buildFeedbackBlockSection = buildFeedbackBlockSection;
+const FeedbackLearning_1 = require("./FeedbackLearning");
 // 输入素材统一截断（M2）：对照 mio-cli creativity-engine 的 clip()。
 // 来源 600 字、信号 300 字，超长素材会把指令挤出上下文窗口。
 const clip = (s, n) => (s.length > n ? s.slice(0, n) + '…' : s);
@@ -166,7 +168,9 @@ function buildSourceBlock(sources) {
  * 将来源内容和配对信息格式化为 LLM 输入
  * @param externalSignals 外部信号（Observer 趋势/洞察），不参与配对，作为"外部审视"段注入
  */
-function buildCreativityPrompt(sources, combos, externalSignals = []) {
+function buildCreativityPrompt(sources, combos, externalSignals = [], 
+/** 正向反馈闭环 P2：不可变快照的结构化提示块。缺省 = 输出逐字节不变。 */
+feedback) {
     const sections = [];
     // 来源列表
     sections.push(`【可用概念来源 — 按证据类型分组】\n${buildSourceBlock(sources)}`);
@@ -179,12 +183,43 @@ function buildCreativityPrompt(sources, combos, externalSignals = []) {
     })
         .join('\n');
     sections.push(`【推荐配对组合】\n请为以下每个配对产生一个创意方案；若说不清协同机制，请在该位置输出 null：\n${comboLines}`);
+    // 历史反馈段 — 只读结构化快照块，永不回灌 raw 事件正文
+    if (feedback) {
+        sections.push(buildFeedbackBlockSection(feedback));
+    }
     // 外部信号段 — 不参与配对，作为约束/挑战注入
     if (externalSignals.length > 0) {
         sections.push(buildExternalSignalBlock(externalSignals));
     }
     return sections.join('\n\n');
 }
+const FEEDBACK_DIMENSION_LABELS = {
+    selection: '选择',
+    quality: '质量',
+    landing: '落地',
+    negative: '负反馈',
+};
+function buildFeedbackBlockSection(feedback) {
+    const verifiedLines = feedback.verified.map((v) => `  - ${(0, FeedbackLearning_1.clipPromptText)(v.conceptA)} + ${(0, FeedbackLearning_1.clipPromptText)(v.conceptB)}\n` +
+        `    验证类型：${FEEDBACK_DIMENSION_LABELS[v.dimension] ?? v.dimension} · 独立批次：${v.evidenceCount}\n` +
+        `    估计置信度：${v.confidenceBand} / 适用范围：${v.scope}\n` +
+        `    已知限制：${v.limits}`);
+    const failureLines = feedback.failures.map((f) => `  - ${(0, FeedbackLearning_1.clipPromptText)(f.conceptA)} + ${(0, FeedbackLearning_1.clipPromptText)(f.conceptB)}\n` +
+        `    失败原因：${FEEDBACK_DIMENSION_LABELS[f.dimension] ?? f.dimension} · 批次：${f.evidenceCount}\n` +
+        `    适用范围：${f.scope} / 已知限制：${f.limits}`);
+    const parts = [
+        `【历史反馈 — 已验证来源与失败边界（快照 v${feedback.version}）】`,
+        '以下来自不可变反馈快照，仅作参考，不视为正确性保证：',
+    ];
+    if (verifiedLines.length > 0)
+        parts.push(`已验证的来源：\n${verifiedLines.join('\n')}`);
+    if (failureLines.length > 0)
+        parts.push(`失败边界：\n${failureLines.join('\n')}`);
+    parts.push('生成要求：\n' +
+        '  - 可提出与历史成功组合不同的新假设；成功记录仅作参考，不视为正确性保证\n' +
+        '  - 明确写出本次假设相对历史案例的差异；新假设仍须经过独立验证');
+    return parts.join('\n\n');
+}
 /**
  * 构建外部信号段 — 不参与 pairing，作为"外部挑战"注入 LLM
  *

package/dist/DrizzleFeedbackEventStore.d.ts

@@ -0,0 +1,22 @@
+import type { HypothesisFeedbackEvent } from './FeedbackEvents';
+export interface DrizzleAppendResult {
+    appended: boolean;
+    deduped: boolean;
+}
+/**
+ * DrizzleFeedbackEventStore — 主进程权威侧证据事件写入（P0）
+ *
+ * SQLite 表 `hypothesis_feedback_events`（migration v51）。
+ * INSERT OR IGNORE + UNIQUE(idempotency_key)：重复导入不增样本。
+ * 追加写入；纠错用更正事件，不 UPDATE 已有行。
+ */
+export declare class DrizzleFeedbackEventStore {
+    append(event: HypothesisFeedbackEvent): DrizzleAppendResult;
+    list(options?: {
+        hypothesisId?: string;
+        eventType?: string;
+        limit?: number;
+    }): HypothesisFeedbackEvent[];
+    count(): number;
+    hasKey(idempotencyKey: string): boolean;
+}

package/dist/DrizzleFeedbackEventStore.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrizzleFeedbackEventStore = void 0;
+const connection_1 = require("@akemi-mio/core/db/connection");
+function rowToEvent(obj) {
+    const event = {
+        id: obj.id,
+        hypothesisId: obj.hypothesis_id,
+        eventType: obj.event_type,
+        sourceType: obj.source_type,
+        sourceId: obj.source_id,
+        occurredAt: Number(obj.occurred_at),
+        ingestedAt: Number(obj.ingested_at),
+        idempotencyKey: obj.idempotency_key,
+        schemaVersion: Number(obj.schema_version ?? 1),
+    };
+    if (obj.source_version != null)
+        event.sourceVersion = String(obj.source_version);
+    if (obj.commit_sha != null)
+        event.commitSha = String(obj.commit_sha);
+    if (obj.experiment_run_id != null)
+        event.experimentRunId = String(obj.experiment_run_id);
+    if (obj.evidence_ref != null)
+        event.evidenceRef = String(obj.evidence_ref);
+    return event;
+}
+/**
+ * DrizzleFeedbackEventStore — 主进程权威侧证据事件写入（P0）
+ *
+ * SQLite 表 `hypothesis_feedback_events`（migration v51）。
+ * INSERT OR IGNORE + UNIQUE(idempotency_key)：重复导入不增样本。
+ * 追加写入；纠错用更正事件，不 UPDATE 已有行。
+ */
+class DrizzleFeedbackEventStore {
+    append(event) {
+        const db = (0, connection_1.getRawDb)();
+        const exists = db.exec(`SELECT 1 FROM hypothesis_feedback_events WHERE idempotency_key = ? LIMIT 1`, [event.idempotencyKey]);
+        if (exists && exists.length > 0 && exists[0].values.length > 0) {
+            return { appended: false, deduped: true };
+        }
+        db.run(`INSERT OR IGNORE INTO hypothesis_feedback_events
+        (id, hypothesis_id, event_type, source_type, source_id, source_version, commit_sha, experiment_run_id, evidence_ref, occurred_at, ingested_at, idempotency_key, schema_version)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            event.id,
+            event.hypothesisId,
+            event.eventType,
+            event.sourceType,
+            event.sourceId,
+            event.sourceVersion ?? null,
+            event.commitSha ?? null,
+            event.experimentRunId ?? null,
+            event.evidenceRef ?? null,
+            event.occurredAt,
+            event.ingestedAt,
+            event.idempotencyKey,
+            event.schemaVersion,
+        ]);
+        (0, connection_1.markDirty)();
+        return { appended: true, deduped: false };
+    }
+    list(options) {
+        const db = (0, connection_1.getRawDb)();
+        let sql = 'SELECT * FROM hypothesis_feedback_events';
+        const clauses = [];
+        const params = [];
+        if (options?.hypothesisId) {
+            clauses.push('hypothesis_id = ?');
+            params.push(options.hypothesisId);
+        }
+        if (options?.eventType) {
+            clauses.push('event_type = ?');
+            params.push(options.eventType);
+        }
+        if (clauses.length > 0)
+            sql += ' WHERE ' + clauses.join(' AND ');
+        sql += ' ORDER BY occurred_at ASC';
+        if (options?.limit)
+            sql += ` LIMIT ${options.limit}`;
+        const result = db.exec(sql, params);
+        if (!result || result.length === 0 || result[0].values.length === 0)
+            return [];
+        const columns = result[0].columns;
+        return result[0].values.map((values) => {
+            const obj = {};
+            for (let i = 0; i < columns.length; i++)
+                obj[columns[i]] = values[i];
+            return rowToEvent(obj);
+        });
+    }
+    count() {
+        const db = (0, connection_1.getRawDb)();
+        const r = db.exec('SELECT COUNT(*) FROM hypothesis_feedback_events');
+        return r && r.length > 0 && r[0].values.length > 0 ? Number(r[0].values[0][0]) : 0;
+    }
+    hasKey(idempotencyKey) {
+        const db = (0, connection_1.getRawDb)();
+        const r = db.exec('SELECT 1 FROM hypothesis_feedback_events WHERE idempotency_key = ? LIMIT 1', [idempencyKey]);
+        return !!(r && r.length > 0 && r[0].values.length > 0);
+    }
+}
+exports.DrizzleFeedbackEventStore = DrizzleFeedbackEventStore;

package/dist/ExperimentRunStore.d.ts

@@ -0,0 +1,106 @@
+/**
+ * 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;
+    /** 实验时使用的反馈快照版本（无反馈时为空）；回答"收益来自机制还是反馈权重" */
+    feedbackSnapshotVersion?: string;
+    baselineVersion?: string;
+    candidateVersion?: string;
+    /** 独立验证/测试结果（白名单标量） */
+    testResults?: Record<string, number | boolean | string>;
+    /** 回归验证结果（白名单标量） */
+    regressionResults?: Record<string, number | boolean | string>;
+    decision?: 'promote' | 'reject' | 'inconclusive' | 'rollback';
+}
+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;

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/FeedbackEvents.d.ts

@@ -0,0 +1,86 @@
+/**
+ * HypothesisFeedbackEvent — 正向反馈闭环证据层（设计 v1.0，P0）
+ *
+ * 只做三件事：类型契约、规范化校验、幂等键构建。
+ * 不做聚合/权重/快照（P1 的 FeedbackLearningService），
+ * 不写 Memory、不改 Hypothesis.status、不进晋级门输入。
+ *
+ * 双轴落点：
+ * - CLI/MCP 生产端 → JSONL `feedback-events.jsonl`（交换格式，见 JsonlFeedbackEventStore）
+ * - 主进程权威侧 → SQLite `hypothesis_feedback_events`（见 DrizzleFeedbackEventStore）
+ * 唯一真相源方向：CLI 只追加 JSONL，主进程 ingest 单向导入（spec §九 R3）。
+ */
+export declare const FEEDBACK_EVENT_SCHEMA_VERSION = 1;
+export type HypothesisFeedbackEventType = 'validated' | 'adopted' | 'implemented' | 'rejected' | 'regression_failed';
+export type HypothesisFeedbackSourceType = 'experiment' | 'memory' | 'adoption' | 'commit' | 'manual';
+export interface HypothesisFeedbackEvent {
+    /** 全局唯一事件 ID */
+    id: string;
+    /** 关联假设 UUID（必须指向真实假设，由调用方在入库前校验） */
+    hypothesisId: string;
+    eventType: HypothesisFeedbackEventType;
+    sourceType: HypothesisFeedbackSourceType;
+    /** 来源记录 ID（adopt 事件 trace id、memory id、experiment run id 等） */
+    sourceId: string;
+    /** 来源版本/契约版本，可选 */
+    sourceVersion?: string;
+    /** 实现关联 commit SHA（eventType=implemented 时必填） */
+    commitSha?: string;
+    /** 实验运行 ID，可选 */
+    experimentRunId?: string;
+    /** 验证报告/审计记录引用，可选 */
+    evidenceRef?: string;
+    /** 事件发生时间，epoch ms */
+    occurredAt: number;
+    /** 入库/规范化时间，epoch ms */
+    ingestedAt: number;
+    /** 幂等键：同键只允许生效一次（唯一约束） */
+    idempotencyKey: string;
+    schemaVersion: number;
+}
+export declare const FEEDBACK_EVENT_TYPES: readonly HypothesisFeedbackEventType[];
+export declare const FEEDBACK_SOURCE_TYPES: readonly HypothesisFeedbackSourceType[];
+/** 输入契约：调用方给出自然键字段，id/ingestedAt/idempotencyKey 由规范化器补齐。 */
+export interface HypothesisFeedbackEventInput {
+    hypothesisId: string;
+    eventType: HypothesisFeedbackEventType;
+    sourceType: HypothesisFeedbackSourceType;
+    sourceId: string;
+    sourceVersion?: string;
+    commitSha?: string;
+    experimentRunId?: string;
+    evidenceRef?: string;
+    /** epoch ms 或 ISO 8601 字符串 */
+    occurredAt?: number | string;
+    id?: string;
+    idempotencyKey?: string;
+}
+export type NormalizeQuarantineReason = 'missing_hypothesis_id' | 'invalid_event_type' | 'invalid_source_type' | 'missing_source_id' | 'missing_commit_sha_for_implemented' | 'invalid_occurred_at';
+export type NormalizeResult = {
+    ok: true;
+    event: HypothesisFeedbackEvent;
+} | {
+    ok: false;
+    reason: NormalizeQuarantineReason;
+    raw: unknown;
+};
+/**
+ * 幂等键 = 自然键拼接。同 hypothesisId+eventType+sourceType+sourceId(+commitSha/experimentRunId)
+ * 的重复提交会得到同键，存储层靠唯一约束去重。
+ */
+export declare function buildFeedbackIdempotencyKey(parts: {
+    hypothesisId: string;
+    eventType: string;
+    sourceType: string;
+    sourceId: string;
+    commitSha?: string;
+    experimentRunId?: string;
+}): string;
+/**
+ * 规范化 + 校验。不合格事件不丢弃、不生效——调用方写入隔离队列。
+ * 注意：本函数不校验 hypothesisId 是否指向真实假设（那需要 store 查询），
+ * 由生产者/ingest 在调用前或调用后单独把关（spec §五.1）。
+ */
+export declare function normalizeFeedbackEvent(raw: unknown, now?: number): NormalizeResult;
+/** 证据维度归类（spec §五.0）：选择 / 质量 / 落地。聚合时分维度累计，不合并成"成功次数"。 */
+export declare function feedbackEvidenceDimension(eventType: HypothesisFeedbackEventType): 'selection' | 'quality' | 'landing' | 'negative';