@akemi-mio/creativity 0.1.0 → 0.2.0

package/dist/FeedbackLearning.js

@@ -0,0 +1,456 @@
+"use strict";
+/**
+ * FeedbackLearning — 正向反馈闭环离线学习核心（设计 v1.0，P1）
+ *
+ * 纯计算，不碰 DB、不写 Memory、不改假设状态、不进晋级门输入。
+ * 输入规范化证据事件 + 假设 provenance，输出：
+ *   - ConceptPairWeight：概念对 × 三维度（选择/质量/落地）加权证据
+ *   - FeedbackSnapshot：不可变 + 版本号（sha256 前 12 位）
+ *   - 离线回放：原始 vs 反馈策略的逐对调整与证据追溯
+ *
+ * 评审决议（spec §十三）落地：
+ *   §13.2 带权 Beta 变体：衰减后计数为小数，不取整（取整顺序相关会破坏 reproducibility）。
+ *   §13.3 三维度归一分母 = 该维度 S_d + F_d，不跨维度、不用假设数；无事件维度取先验均值。
+ *   §13.1 batch 身份：experimentRunId 优先，否则 hypothesisId（或 implemented 的 commitSha）。
+ *   §13.4 快照只带结构化字段，禁止 raw 事件正文。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FEEDBACK_LEARNING_CONFIG = exports.POSITIVE_DIMENSIONS = void 0;
+exports.evidenceWeight = evidenceWeight;
+exports.isNegativeEvent = isNegativeEvent;
+exports.timeDecay = timeDecay;
+exports.conceptIdOf = conceptIdOf;
+exports.pairKeyOf = pairKeyOf;
+exports.canonicalJson = canonicalJson;
+exports.hashPrefix = hashPrefix;
+exports.aggregateConceptPairWeights = aggregateConceptPairWeights;
+exports.buildFeedbackSnapshot = buildFeedbackSnapshot;
+exports.replayFeedbackAdjustment = replayFeedbackAdjustment;
+exports.clipPromptText = clipPromptText;
+exports.buildFeedbackPromptBlock = buildFeedbackPromptBlock;
+exports.buildMixerInputFromSnapshot = buildMixerInputFromSnapshot;
+const crypto_1 = require("crypto");
+const FeedbackEvents_1 = require("./FeedbackEvents");
+const types_1 = require("./types");
+exports.POSITIVE_DIMENSIONS = ['selection', 'quality', 'landing'];
+exports.DEFAULT_FEEDBACK_LEARNING_CONFIG = {
+    halfLifeDays: 30,
+    alpha0: 1,
+    beta0: 1,
+    minSamples: 30,
+    weightCaps: {
+        validated: 0.5,
+        adopted: 0.2,
+        implemented: 0.3,
+        rejected: 1.0,
+        regression_failed: 1.0,
+    },
+    attributionMinCoverage: 0.3,
+    explorationBudget: 0.2,
+    lambdaClampPct: 0.1,
+};
+/** 单条事件对某维度的贡献权重（未衰减）。负向事件归 negative 维度。 */
+function evidenceWeight(eventType, caps) {
+    switch (eventType) {
+        case 'validated':
+            return caps.validated;
+        case 'adopted':
+            return caps.adopted;
+        case 'implemented':
+            return caps.implemented;
+        case 'rejected':
+            return caps.rejected;
+        case 'regression_failed':
+            return caps.regression_failed;
+        default:
+            return 1;
+    }
+}
+function isNegativeEvent(eventType) {
+    return eventType === 'rejected' || eventType === 'regression_failed';
+}
+/** 时间衰减 w(t) = 2^(-Δt/H)，Δt 以天为单位；未来事件不放大。 */
+function timeDecay(occurredAt, now, halfLifeDays) {
+    if (halfLifeDays <= 0)
+        return 1;
+    const dtDays = Math.max(0, (now - occurredAt) / 86_400_000);
+    return Math.pow(2, -dtDays / halfLifeDays);
+}
+/** 概念身份：取 origin（稳定字段），缺失时回退 name 并标记 hypothesis_only。 */
+function conceptIdOf(source) {
+    return (0, types_1.sourceConceptId)(source);
+}
+function pairKeyOf(a, b) {
+    return (0, types_1.conceptPairKey)(a, b);
+}
+/** 稳定序列化：对象键排序、数组保序，保证跨平台 hash 一致。 */
+function canonicalJson(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(obj[k])}`).join(',')}}`;
+}
+function hashPrefix(input, length = 12) {
+    return (0, crypto_1.createHash)('sha256').update(input, 'utf8').digest('hex').slice(0, length);
+}
+function emptyEstimate(alpha0, beta0) {
+    return {
+        positiveCount: 0,
+        negativeCount: 0,
+        evidenceCount: 0,
+        posteriorMean: alpha0 / (alpha0 + beta0),
+        confidence: 0,
+        lastEvidenceAt: 0,
+    };
+}
+function batchKeyOf(event) {
+    return event.experimentRunId || (event.commitSha ? `commit:${event.commitSha}` : event.hypothesisId);
+}
+/** 稳定排序（locale 不敏感、字段序固定）——reproducibility 前提。 */
+function sortEvents(events) {
+    return [...events].sort((a, b) => {
+        if (a.hypothesisId !== b.hypothesisId)
+            return a.hypothesisId < b.hypothesisId ? -1 : 1;
+        if (a.eventType !== b.eventType)
+            return a.eventType < b.eventType ? -1 : 1;
+        if (a.sourceId !== b.sourceId)
+            return a.sourceId < b.sourceId ? -1 : 1;
+        return a.occurredAt - b.occurredAt;
+    });
+}
+function isAttributable(sources) {
+    if (!sources || sources.length < 2)
+        return false;
+    return sources.filter((s) => s.origin && s.origin.trim()).length >= 2;
+}
+/**
+ * 聚合概念对权重。
+ *
+ * @param events 规范化后的证据事件（可乱序；内部稳定排序）
+ * @param hypotheses hypothesisId → provenance（用于概念对归因）
+ * @param config 学习配置
+ * @param now 评估时刻，epoch ms
+ */
+function aggregateConceptPairWeights(events, hypotheses, config = exports.DEFAULT_FEEDBACK_LEARNING_CONFIG, now = Date.now()) {
+    const sorted = sortEvents(events);
+    const pairMap = new Map();
+    // (pairKey, dimension, batchKey) → 衰减后最大权重；同源事件不伪造样本量
+    const slotMap = new Map();
+    const trace = [];
+    let positiveAttributed = 0;
+    let positiveTotal = 0;
+    let appliedCount = 0;
+    let dedupedEventCount = 0;
+    let naiveWeightApplied = 0;
+    let duplicateWeightApplied = 0;
+    const getPair = (pairKey, attribution) => {
+        let pair = pairMap.get(pairKey);
+        if (!pair) {
+            const [conceptAId, conceptBId] = pairKey.split('|');
+            pair = {
+                conceptAId,
+                conceptBId,
+                pairKey,
+                attribution,
+                selection: emptyEstimate(config.alpha0, config.beta0),
+                quality: emptyEstimate(config.alpha0, config.beta0),
+                landing: emptyEstimate(config.alpha0, config.beta0),
+                negative: emptyEstimate(config.alpha0, config.beta0),
+                lastEvidenceAt: 0,
+            };
+            pairMap.set(pairKey, pair);
+        }
+        return pair;
+    };
+    for (const event of sorted) {
+        const dimension = (0, FeedbackEvents_1.feedbackEvidenceDimension)(event.eventType);
+        const weight = evidenceWeight(event.eventType, config.weightCaps);
+        const batchKey = batchKeyOf(event);
+        const provenance = hypotheses[event.hypothesisId];
+        const sources = provenance?.sources;
+        const attributable = isAttributable(sources);
+        if (!isNegativeEvent(event.eventType)) {
+            positiveTotal++;
+            if (attributable)
+                positiveAttributed++;
+        }
+        if (!attributable) {
+            // 无 provenance：只记假设级，不归因到对（R5）
+            const pairKey = `hypothesis:${event.hypothesisId}`;
+            const pair = getPair(pairKey, 'hypothesis_only');
+            const est = pair[dimension];
+            est.evidenceCount += 1;
+            const decayed = weight * timeDecay(event.occurredAt, now, config.halfLifeDays);
+            if (isNegativeEvent(event.eventType))
+                est.negativeCount += decayed;
+            else
+                est.positiveCount += decayed;
+            if (event.occurredAt > pair.lastEvidenceAt)
+                pair.lastEvidenceAt = event.occurredAt;
+            appliedCount++;
+            naiveWeightApplied += decayed;
+            trace.push({
+                hypothesisId: event.hypothesisId,
+                eventType: event.eventType,
+                sourceId: event.sourceId,
+                pairKey,
+                dimension,
+                weight: decayed,
+                batchKey,
+                duplicate: false,
+            });
+            continue;
+        }
+        // 有 provenance：来源两两构成贡献概念对
+        const ids = sources.map(conceptIdOf);
+        for (let i = 0; i < ids.length; i++) {
+            for (let j = i + 1; j < ids.length; j++) {
+                const key = pairKeyOf(ids[i], ids[j]);
+                const slotKey = `${key}\u0000${dimension}\u0000${batchKey}`;
+                const decayed = weight * timeDecay(event.occurredAt, now, config.halfLifeDays);
+                const existing = slotMap.get(slotKey);
+                const duplicate = !!existing && existing.weight >= decayed;
+                if (duplicate) {
+                    dedupedEventCount++;
+                    duplicateWeightApplied += 0; // 去重后不重复加权
+                }
+                else {
+                    slotMap.set(slotKey, { weight: decayed, batchKey, dimension, lastEvidenceAt: event.occurredAt });
+                    appliedCount++;
+                    naiveWeightApplied += decayed;
+                }
+                trace.push({
+                    hypothesisId: event.hypothesisId,
+                    eventType: event.eventType,
+                    sourceId: event.sourceId,
+                    pairKey: key,
+                    dimension,
+                    weight: duplicate ? 0 : decayed,
+                    batchKey,
+                    duplicate,
+                });
+            }
+        }
+    }
+    // slot 汇总到 pair 的维度估计（跨 batch 求和，已按 batch 去重）
+    for (const [slotKey, slot] of slotMap) {
+        const [pairKey, dimension] = slotKey.split('\u0000');
+        const pair = getPair(pairKey, 'pair');
+        const est = pair[dimension];
+        if (isNegativeEventDimension(dimension))
+            est.negativeCount += slot.weight;
+        else
+            est.positiveCount += slot.weight;
+        if (slot.lastEvidenceAt > est.lastEvidenceAt)
+            est.lastEvidenceAt = slot.lastEvidenceAt;
+        if (slot.lastEvidenceAt > pair.lastEvidenceAt)
+            pair.lastEvidenceAt = slot.lastEvidenceAt;
+    }
+    // 回填每维度 evidenceCount（原始事件数）与后验/置信度
+    const rawCounts = countRawEvidence(sorted, hypotheses);
+    for (const pair of pairMap.values()) {
+        applyPosterior(pair, config);
+        const rc = rawCounts.get(pair.pairKey);
+        if (rc) {
+            pair.selection.evidenceCount = rc.selection;
+            pair.quality.evidenceCount = rc.quality;
+            pair.landing.evidenceCount = rc.landing;
+            pair.negative.evidenceCount = rc.negative;
+        }
+    }
+    const pairs = [...pairMap.values()].sort((a, b) => (a.pairKey < b.pairKey ? -1 : a.pairKey > b.pairKey ? 1 : 0));
+    return {
+        pairs,
+        attributionCoverage: positiveTotal === 0 ? 1 : positiveAttributed / positiveTotal,
+        duplicateApplicationRate: naiveWeightApplied === 0 ? 0 : duplicateWeightApplied / naiveWeightApplied,
+        appliedCount,
+        dedupedEventCount,
+        trace,
+    };
+}
+function isNegativeEventDimension(d) {
+    return d === 'negative';
+}
+function applyPosterior(pair, config) {
+    for (const d of [...exports.POSITIVE_DIMENSIONS, 'negative']) {
+        const est = pair[d];
+        const s = est.positiveCount;
+        const f = est.negativeCount;
+        est.posteriorMean = (config.alpha0 + s) / (config.alpha0 + config.beta0 + s + f);
+        est.confidence = (s + f) / (s + f + config.alpha0 + config.beta0);
+    }
+}
+function countRawEvidence(events, hypotheses) {
+    const counts = new Map();
+    const bump = (pairKey, d) => {
+        let c = counts.get(pairKey);
+        if (!c) {
+            c = { selection: 0, quality: 0, landing: 0, negative: 0 };
+            counts.set(pairKey, c);
+        }
+        c[d]++;
+    };
+    for (const event of events) {
+        const d = (0, FeedbackEvents_1.feedbackEvidenceDimension)(event.eventType);
+        const sources = hypotheses[event.hypothesisId]?.sources;
+        if (!isAttributable(sources)) {
+            bump(`hypothesis:${event.hypothesisId}`, d);
+            continue;
+        }
+        const ids = sources.map(conceptIdOf);
+        for (let i = 0; i < ids.length; i++) {
+            for (let j = i + 1; j < ids.length; j++) {
+                bump(pairKeyOf(ids[i], ids[j]), d);
+            }
+        }
+    }
+    return counts;
+}
+/**
+ * 构建不可变快照。同输入 + 同配置 + 同版本 → 同 hash（100% 可复现）。
+ */
+function buildFeedbackSnapshot(events, hypotheses, config = exports.DEFAULT_FEEDBACK_LEARNING_CONFIG, now = Date.now()) {
+    const aggregate = aggregateConceptPairWeights(events, hypotheses, config, now);
+    const configHash = hashPrefix(canonicalJson(config), 12);
+    const window = canonicalJson({
+        schemaVersion: FeedbackEvents_1.FEEDBACK_EVENT_SCHEMA_VERSION,
+        now,
+        events: sortEvents(events)
+            .map((e) => ({
+            hypothesisId: e.hypothesisId,
+            eventType: e.eventType,
+            sourceId: e.sourceId,
+            sourceType: e.sourceType,
+            commitSha: e.commitSha ?? null,
+            experimentRunId: e.experimentRunId ?? null,
+            occurredAt: e.occurredAt,
+            idempotencyKey: e.idempotencyKey,
+        })),
+        config,
+    });
+    const version = hashPrefix(window, 12);
+    const pairs = aggregate.pairs.map((p) => ({ ...p, feedbackSnapshotVersion: version }));
+    return {
+        version,
+        configHash,
+        generatedAt: now,
+        eventCount: events.length,
+        attributionCoverage: aggregate.attributionCoverage,
+        duplicateApplicationRate: aggregate.duplicateApplicationRate,
+        dedupedEventCount: aggregate.dedupedEventCount,
+        pairs,
+    };
+}
+/**
+ * 离线回放：给定概念对权重，计算有界反馈调整（λ clamp）。
+ * 不读 DB、不写任何状态；供 P2 接入 ConceptMixer 前做离线对比。
+ */
+function replayFeedbackAdjustment(weight, config = exports.DEFAULT_FEEDBACK_LEARNING_CONFIG) {
+    let pos = 0;
+    let conf = 0;
+    let evidence = 0;
+    for (const d of exports.POSITIVE_DIMENSIONS) {
+        const est = weight[d];
+        pos += est.posteriorMean * est.confidence;
+        conf += est.confidence;
+        evidence += est.evidenceCount;
+    }
+    const posMean = conf > 0 ? pos / conf : 0.5;
+    const negMean = weight.negative.posteriorMean;
+    // 正向证据把分数拉向 +1，负向证据拉向 -1；无正向证据时取先验中性 0.5
+    const adjustment = Math.max(-1, Math.min(1, (posMean - 0.5) * 2 - negMean));
+    const clamp = Math.max(0, config.lambdaClampPct);
+    return {
+        pairKey: weight.pairKey,
+        adjustment,
+        evidenceCount: evidence,
+        posteriorMean: posMean,
+        confidence: conf,
+        clampedAdjustment: adjustment * clamp,
+    };
+}
+const PROMPT_TEXT_LIMIT = 120;
+/** 确定性裁剪：字符串上限 120 字符（§13.4）。 */
+function clipPromptText(s, limit = PROMPT_TEXT_LIMIT) {
+    const clean = String(s ?? '').replace(/\s+/g, ' ').trim();
+    return clean.length > limit ? `${clean.slice(0, limit)}…` : clean;
+}
+function band(value) {
+    if (value < 0.5)
+        return 'low';
+    if (value < 0.8)
+        return 'medium';
+    return 'high';
+}
+function confidenceBand(value) {
+    if (value < 0.3)
+        return 'low';
+    if (value < 0.7)
+        return 'medium';
+    return 'high';
+}
+function scopeOf(evidenceCount) {
+    return evidenceCount >= 3 ? '多批次独立验证' : '限定任务类别';
+}
+const LIMITS = '尚未验证跨场景泛化';
+/**
+ * 从不可变快照构建结构化提示块。只带结构化字段，永不回灌 raw 事件正文
+ * 或 provenance.origin 自由文本（§13.4，红队注入面）。
+ */
+function buildFeedbackPromptBlock(snapshot) {
+    const verified = [];
+    const failures = [];
+    for (const pair of snapshot.pairs) {
+        if (pair.attribution === 'hypothesis_only')
+            continue;
+        for (const d of exports.POSITIVE_DIMENSIONS) {
+            const est = pair[d];
+            if (est.evidenceCount <= 0)
+                continue;
+            verified.push({
+                pairKey: pair.pairKey,
+                conceptA: pair.conceptAId,
+                conceptB: pair.conceptBId,
+                dimension: d,
+                evidenceCount: est.evidenceCount,
+                posteriorBand: band(est.posteriorMean),
+                confidenceBand: confidenceBand(est.confidence),
+                scope: scopeOf(est.evidenceCount),
+                limits: LIMITS,
+            });
+        }
+        if (pair.negative.evidenceCount > 0) {
+            failures.push({
+                pairKey: pair.pairKey,
+                conceptA: pair.conceptAId,
+                conceptB: pair.conceptBId,
+                dimension: 'negative',
+                evidenceCount: pair.negative.evidenceCount,
+                scope: '特定实验条件',
+                limits: LIMITS,
+            });
+        }
+    }
+    const byPair = (a, b) => a.pairKey < b.pairKey ? -1 : a.pairKey > b.pairKey ? 1 : a.dimension < b.dimension ? -1 : a.dimension > b.dimension ? 1 : 0;
+    verified.sort(byPair);
+    failures.sort(byPair);
+    return { version: snapshot.version, verified, failures };
+}
+/**
+ * 快照 → ConceptMixer 有界消费输入（spec §六.2）。
+ * pairAdjustments 用快照 pairKey（conceptId 对齐）；λ clamp 由 mixer 再兜底。
+ */
+function buildMixerInputFromSnapshot(snapshot, config = exports.DEFAULT_FEEDBACK_LEARNING_CONFIG) {
+    const pairAdjustments = {};
+    for (const pair of snapshot.pairs) {
+        pairAdjustments[pair.pairKey] = replayFeedbackAdjustment(pair, config).clampedAdjustment;
+    }
+    return {
+        pairAdjustments,
+        explorationBudget: config.explorationBudget,
+        maxAdjustment: config.lambdaClampPct,
+    };
+}

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 };
+}