@akemi-mio/creativity 0.0.0-stage → 0.1.1

package/dist/MechanismGraph.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveMechanismGraph = deriveMechanismGraph;
+exports.relationsToEdges = relationsToEdges;
+exports.isMechanismHypothesis = isMechanismHypothesis;
+function asString(v, fallback = '') {
+    return typeof v === 'string' && v.length > 0 ? v : fallback;
+}
+/**
+ * 从 traces.jsonl 行事件聚合机制边。
+ *
+ * 规则：
+ * - 仅计入 payload.capabilityId 存在的事件（能力绑定相关）。
+ * - 每条边键 = `${agent}|${capabilityId}|${outcome}`，count 累加。
+ * - inference：payload.inference === 'identity' 或 event_type 含 identity
+ *   时记 identity；否则记 inferred。
+ * - confidence：边内出现过任一 identity → high，否则 low。
+ */
+function deriveMechanismGraph(events) {
+    const edgeMap = new Map();
+    let eventCount = 0;
+    for (const ev of events) {
+        const capabilityId = asString(ev.payload?.capabilityId);
+        if (!capabilityId)
+            continue;
+        const agent = asString(ev.agent, 'unknown');
+        const outcome = asString(ev.outcome, 'unknown');
+        eventCount++;
+        const key = `${agent}|${capabilityId}|${outcome}`;
+        let edge = edgeMap.get(key);
+        if (!edge) {
+            edge = {
+                agent,
+                capabilityId,
+                outcome,
+                count: 0,
+                confidence: 'low',
+                inferences: [],
+            };
+            edgeMap.set(key, edge);
+        }
+        edge.count++;
+        const rawInference = ev.payload?.inference;
+        const inference = rawInference === 'identity' || (typeof ev.event_type === 'string' && ev.event_type.includes('identity')) ? 'identity' : 'inferred';
+        if (!edge.inferences.includes(inference))
+            edge.inferences.push(inference);
+        if (inference === 'identity')
+            edge.confidence = 'high';
+    }
+    const edges = [...edgeMap.values()].sort((a, b) => {
+        const c = b.count - a.count;
+        if (c !== 0)
+            return c;
+        const k = `${a.agent}|${a.capabilityId}|${a.outcome}`.localeCompare(`${b.agent}|${b.capabilityId}|${b.outcome}`);
+        return k;
+    });
+    return { edges, eventCount };
+}
+/** 把机制假设的 proposedRelations 投影为与派生图同形状的边（供对照，confidence 走 inference 字段）。 */
+function relationsToEdges(agent, relations) {
+    return relations.map((r) => {
+        const inference = r.inference ?? 'inferred';
+        return {
+            agent,
+            capabilityId: r.from,
+            outcome: r.to,
+            count: 1,
+            confidence: inference === 'identity' ? 'high' : 'low',
+            inferences: [inference],
+        };
+    });
+}
+/** 是否为机制假设：带非空 proposedRelations 即机制假设，否则普通创意（一个 store 两种粒度）。 */
+function isMechanismHypothesis(h) {
+    return Array.isArray(h.proposedRelations) && h.proposedRelations.length > 0;
+}

package/dist/MechanismRegistry.d.ts

@@ -0,0 +1,118 @@
+/**
+ * MechanismRegistry — 机制版本注册表 + PromotionRequest 薄实现（机制涌现 P4，定案 D5/A5）
+ *
+ * 生产轴：mechanisms.jsonl 存 MechanismVersion（mechanismId/version/status active|rolled_back/
+ * rollbackTo/approvedBy/submittedBy）。A5 代码级校验：Registry 写入时断言批准者≠提交者。
+ * PromotionRequest：提交前硬闸复用 checkPromotionGate（stale / n<minSamples 禁止提交），
+ * 批准走 pending → approved|rejected，批准时激活新版本并标旧版本 rolled_back。
+ * 回滚：rolled_back 路径——当前 active 标 rolled_back（rollbackTo=目标版本），目标版本重新激活。
+ */
+import { type StoppingRuleConfig, type ExperimentRun } from './ExperimentRunStore';
+export type MechanismStatus = 'active' | 'rolled_back';
+export interface MechanismVersion {
+    mechanismId: string;
+    /** 单调递增版本号，从 1 开始 */
+    version: number;
+    status: MechanismStatus;
+    /** 回滚目标版本（仅 status=rolled_back 时可设，指回滚后应激活的版本） */
+    rollbackTo?: number;
+    /** A5：批准者 agent id（≠submittedBy） */
+    approvedBy: string;
+    /** 提交者 agent id */
+    submittedBy: string;
+    hypothesisId?: string;
+    experimentRunIds?: string[];
+    createdAt: number;
+}
+export type ApprovalStatus = 'pending' | 'approved' | 'rejected';
+export interface PromotionRequest {
+    id: string;
+    mechanismId: string;
+    version: number;
+    hypothesisId?: string;
+    experimentRunIds: string[];
+    submittedBy: string;
+    approvalStatus: ApprovalStatus;
+    approvedBy?: string;
+    /** 拒绝/批准的公开原因 */
+    reason?: string;
+    createdAt: number;
+    decidedAt?: number;
+}
+/** A5：批准者必须与提交者不同，且双方非空。 */
+export declare function canIndependentlyApprove(submittedBy: string, approvedBy: string): boolean;
+export interface SubmitGateResult {
+    allowed: boolean;
+    reason: string;
+}
+/** 提交 PromotionRequest 前的硬闸检查。stale 或 n<minSamples 一律禁止提交。 */
+export declare function checkSubmitGate(config: StoppingRuleConfig, runs: readonly ExperimentRun[], currentSnapshotId?: string): SubmitGateResult;
+export interface SubmitPromotionInput {
+    mechanismId: string;
+    version: number;
+    hypothesisId?: string;
+    experimentRunIds?: string[];
+    submittedBy: string;
+}
+export type SubmitResult = {
+    ok: true;
+    request: PromotionRequest;
+} | {
+    ok: false;
+    reason: string;
+};
+export type DecideResult = {
+    ok: true;
+    request: PromotionRequest;
+    activated?: MechanismVersion;
+} | {
+    ok: false;
+    reason: string;
+};
+export type RollbackResult = {
+    ok: true;
+    rolledBack: MechanismVersion;
+    restored: MechanismVersion;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * 薄 Registry：文件级 jsonl 存储（机制设计定稿 P4 首版，不必上数据库）。
+ * 状态机：
+ * - PromotionRequest: pending → approved | rejected（批准时激活版本）
+ * - MechanismVersion: active | rolled_back（rolled_back 可带 rollbackTo）
+ */
+export declare class MechanismRegistryStore {
+    private readonly versionsPath;
+    private readonly requestsPath?;
+    private versions;
+    private requests;
+    private requestSeq;
+    constructor(versionsPath: string, requestsPath?: string | undefined);
+    listVersions(mechanismId?: string): MechanismVersion[];
+    getActive(mechanismId: string): MechanismVersion | null;
+    getHistory(mechanismId: string): MechanismVersion[];
+    listRequests(status?: ApprovalStatus): PromotionRequest[];
+    getRequest(id: string): PromotionRequest | null;
+    /**
+     * 提交 PromotionRequest。
+     * 硬闸：stale / snapshot_mismatch / below_min_samples 一律拒绝（复用 checkSubmitGate）。
+     * A5 双人：提交时不做批准校验（批准时校验）。
+     */
+    submit(input: SubmitPromotionInput, gate: SubmitGateResult): SubmitResult;
+    /**
+     * 批准 PromotionRequest。
+     * A5 代码级校验：批准者必须≠提交者（写进代码不是文档）。
+     * 批准成功：写入 MechanismVersion active，旧 active 标 rolled_back。
+     */
+    approve(requestId: string, approvedBy: string, now?: number): DecideResult;
+    reject(requestId: string, approvedBy: string, reason: string, now?: number): DecideResult;
+    /**
+     * 回滚：当前 active 标 rolled_back（rollbackTo=目标版本），目标版本重新激活。
+     * 生产观察恶化触发重评估 → 调用本方法回到 rollbackTo 指定的历史版本。
+     */
+    rollback(mechanismId: string, now?: number): RollbackResult;
+    private persistVersions;
+    private persistRequests;
+}

package/dist/MechanismRegistry.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * MechanismRegistry — 机制版本注册表 + PromotionRequest 薄实现（机制涌现 P4，定案 D5/A5）
+ *
+ * 生产轴：mechanisms.jsonl 存 MechanismVersion（mechanismId/version/status active|rolled_back/
+ * rollbackTo/approvedBy/submittedBy）。A5 代码级校验：Registry 写入时断言批准者≠提交者。
+ * PromotionRequest：提交前硬闸复用 checkPromotionGate（stale / n<minSamples 禁止提交），
+ * 批准走 pending → approved|rejected，批准时激活新版本并标旧版本 rolled_back。
+ * 回滚：rolled_back 路径——当前 active 标 rolled_back（rollbackTo=目标版本），目标版本重新激活。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MechanismRegistryStore = void 0;
+exports.canIndependentlyApprove = canIndependentlyApprove;
+exports.checkSubmitGate = checkSubmitGate;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const ExperimentRunStore_1 = require("./ExperimentRunStore");
+// ══════════════════════════════════════════
+// A5 代码级校验（批准者≠提交者，写进代码不是文档）
+// ══════════════════════════════════════════
+/** A5：批准者必须与提交者不同，且双方非空。 */
+function canIndependentlyApprove(submittedBy, approvedBy) {
+    if (!submittedBy || !approvedBy)
+        return false;
+    return submittedBy !== approvedBy;
+}
+/** 提交 PromotionRequest 前的硬闸检查。stale 或 n<minSamples 一律禁止提交。 */
+function checkSubmitGate(config, runs, currentSnapshotId) {
+    const gate = (0, ExperimentRunStore_1.checkPromotionGate)(config, runs, currentSnapshotId);
+    if (!gate.allowed) {
+        return { allowed: false, reason: gate.reason };
+    }
+    return { allowed: true, reason: 'ok' };
+}
+// ══════════════════════════════════════════
+// 文件持久化（jsonl，append-only 语义，整文件重写）
+// ══════════════════════════════════════════
+function readJsonl(path) {
+    if (!(0, node_fs_1.existsSync)(path))
+        return [];
+    const raw = (0, node_fs_1.readFileSync)(path, 'utf8').trim();
+    if (!raw)
+        return [];
+    return raw
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+function writeJsonl(path, entries) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+    const body = entries.map((e) => JSON.stringify(e)).join('\n');
+    (0, node_fs_1.writeFileSync)(path, body ? `${body}\n` : '', 'utf8');
+}
+/**
+ * 薄 Registry：文件级 jsonl 存储（机制设计定稿 P4 首版，不必上数据库）。
+ * 状态机：
+ * - PromotionRequest: pending → approved | rejected（批准时激活版本）
+ * - MechanismVersion: active | rolled_back（rolled_back 可带 rollbackTo）
+ */
+class MechanismRegistryStore {
+    versionsPath;
+    requestsPath;
+    versions = [];
+    requests = [];
+    requestSeq = 0;
+    constructor(versionsPath, requestsPath) {
+        this.versionsPath = versionsPath;
+        this.requestsPath = requestsPath;
+        this.versions = readJsonl(versionsPath);
+        const reqPath = requestsPath ?? versionsPath.replace(/mechanisms\.jsonl$/, 'promotion-requests.jsonl');
+        this.requests = readJsonl(reqPath);
+        // 恢复 requestSeq（幂等续号）
+        for (const r of this.requests) {
+            const m = /^pr-(\d+)$/.exec(r.id);
+            if (m)
+                this.requestSeq = Math.max(this.requestSeq, Number(m[1]));
+        }
+    }
+    // ── 查询 ──
+    listVersions(mechanismId) {
+        if (!mechanismId)
+            return [...this.versions];
+        return this.versions.filter((v) => v.mechanismId === mechanismId);
+    }
+    getActive(mechanismId) {
+        const actives = this.versions.filter((v) => v.mechanismId === mechanismId && v.status === 'active');
+        // 防御：多 active 取最高版本
+        if (actives.length === 0)
+            return null;
+        return actives.reduce((a, b) => (b.version > a.version ? b : a));
+    }
+    getHistory(mechanismId) {
+        return this.versions.filter((v) => v.mechanismId === mechanismId).sort((a, b) => a.version - b.version);
+    }
+    listRequests(status) {
+        if (!status)
+            return [...this.requests];
+        return this.requests.filter((r) => r.approvalStatus === status);
+    }
+    getRequest(id) {
+        return this.requests.find((r) => r.id === id) ?? null;
+    }
+    // ── 提交（Pending） ──
+    /**
+     * 提交 PromotionRequest。
+     * 硬闸：stale / snapshot_mismatch / below_min_samples 一律拒绝（复用 checkSubmitGate）。
+     * A5 双人：提交时不做批准校验（批准时校验）。
+     */
+    submit(input, gate) {
+        if (!gate.allowed) {
+            return { ok: false, reason: gate.reason };
+        }
+        if (!input.mechanismId || !input.submittedBy) {
+            return { ok: false, reason: 'invalid_input' };
+        }
+        if (!Number.isInteger(input.version) || input.version < 1) {
+            return { ok: false, reason: 'invalid_version' };
+        }
+        // 拒绝重复 pending（同 mechanismId+version）
+        const dup = this.requests.find((r) => r.mechanismId === input.mechanismId && r.version === input.version && r.approvalStatus === 'pending');
+        if (dup) {
+            return { ok: false, reason: 'duplicate_pending' };
+        }
+        this.requestSeq += 1;
+        const request = {
+            id: `pr-${this.requestSeq}`,
+            mechanismId: input.mechanismId,
+            version: input.version,
+            hypothesisId: input.hypothesisId,
+            experimentRunIds: input.experimentRunIds ?? [],
+            submittedBy: input.submittedBy,
+            approvalStatus: 'pending',
+            createdAt: Date.now(),
+        };
+        this.requests.push(request);
+        this.persistRequests();
+        return { ok: true, request };
+    }
+    // ── 批准（A5 双人校验 + 激活版本） ──
+    /**
+     * 批准 PromotionRequest。
+     * A5 代码级校验：批准者必须≠提交者（写进代码不是文档）。
+     * 批准成功：写入 MechanismVersion active，旧 active 标 rolled_back。
+     */
+    approve(requestId, approvedBy, now = Date.now()) {
+        const req = this.requests.find((r) => r.id === requestId);
+        if (!req)
+            return { ok: false, reason: 'request_not_found' };
+        if (req.approvalStatus !== 'pending') {
+            return { ok: false, reason: 'not_pending' };
+        }
+        // A5：批准者≠提交者（代码级）
+        if (!canIndependentlyApprove(req.submittedBy, approvedBy)) {
+            return { ok: false, reason: 'self_approval_forbidden' };
+        }
+        // 标记旧 active → rolled_back（回滚目标=本版本）
+        const previous = this.getActive(req.mechanismId);
+        if (previous) {
+            previous.status = 'rolled_back';
+            previous.rollbackTo = req.version;
+        }
+        // 写入新 active 版本
+        const version = {
+            mechanismId: req.mechanismId,
+            version: req.version,
+            status: 'active',
+            approvedBy,
+            submittedBy: req.submittedBy,
+            hypothesisId: req.hypothesisId,
+            experimentRunIds: req.experimentRunIds,
+            createdAt: now,
+        };
+        this.versions.push(version);
+        req.approvalStatus = 'approved';
+        req.approvedBy = approvedBy;
+        req.decidedAt = now;
+        this.persistVersions();
+        this.persistRequests();
+        return { ok: true, request: req, activated: version };
+    }
+    // ── 拒绝 ──
+    reject(requestId, approvedBy, reason, now = Date.now()) {
+        const req = this.requests.find((r) => r.id === requestId);
+        if (!req)
+            return { ok: false, reason: 'request_not_found' };
+        if (req.approvalStatus !== 'pending') {
+            return { ok: false, reason: 'not_pending' };
+        }
+        req.approvalStatus = 'rejected';
+        req.approvedBy = approvedBy;
+        req.reason = reason;
+        req.decidedAt = now;
+        this.persistRequests();
+        return { ok: true, request: req };
+    }
+    // ── 回滚 ──
+    /**
+     * 回滚：当前 active 标 rolled_back（rollbackTo=目标版本），目标版本重新激活。
+     * 生产观察恶化触发重评估 → 调用本方法回到 rollbackTo 指定的历史版本。
+     */
+    rollback(mechanismId, now = Date.now()) {
+        const current = this.getActive(mechanismId);
+        if (!current) {
+            return { ok: false, reason: 'no_active_version' };
+        }
+        const history = this.getHistory(mechanismId);
+        // 找目标：当前版本之前最高的历史版本
+        const target = history
+            .filter((v) => v.version < current.version)
+            .reduce((acc, v) => (!acc || v.version > acc.version ? v : acc), null);
+        if (!target) {
+            return { ok: false, reason: 'no_rollback_target' };
+        }
+        // 当前 → rolled_back
+        current.status = 'rolled_back';
+        current.rollbackTo = target.version;
+        // 目标 → 重新激活（更新 status；不动 createdAt 保留审计）
+        target.status = 'active';
+        target.approvedBy = current.approvedBy; // 沿用原批准者（审计不改）
+        this.persistVersions();
+        return { ok: true, rolledBack: current, restored: target };
+    }
+    // ── 持久化 ──
+    persistVersions() {
+        writeJsonl(this.versionsPath, this.versions);
+    }
+    persistRequests() {
+        const reqPath = this.requestsPath ?? this.versionsPath.replace(/mechanisms\.jsonl$/, 'promotion-requests.jsonl');
+        writeJsonl(reqPath, this.requests);
+    }
+}
+exports.MechanismRegistryStore = MechanismRegistryStore;

package/dist/NoveltyScorer.d.ts

@@ -0,0 +1,40 @@
+/**
+ * NoveltyScorer — 代码层新颖度评估
+ *
+ * 在 LLM 自评 novelty 之外，通过文本相似度对输入假设进行再评估：
+ * 1. 与近期假设（past 30）的 idea 文本对比，Jaccard 相似度 > 0.5 → 扣 15 分
+ * 2. 与已拒绝假设的 idea 文本对比，Jaccard 相似度 > 0.6 → 标记为 rejected
+ */
+/** Jaccard 相似度：|A ∩ B| / |A ∪ B| */
+export declare function jaccardSimilarity(a: string, b: string): number;
+export interface NoveltyVerdict {
+    /** 调整后的新颖度（0-100），可能被扣分 */
+    adjustedNovelty: number;
+    /** 是否应被自动拒绝（与已拒绝假设高度相似） */
+    shouldReject: boolean;
+    /** 为什么拒绝 */
+    rejectReason?: string;
+    /** 与最相似假设的信息 */
+    mostSimilarTitle?: string;
+    mostSimilarScore: number;
+}
+/**
+ * 对一条新假设进行代码层新颖度评估
+ *
+ * @param candidate 新假设
+ * @param recentHypotheses 近期假设（用于扣分）
+ * @param rejectedHypotheses 已拒绝假设（用于自动拒绝）
+ * @returns NoveltyVerdict
+ */
+export declare function evaluateNovelty(candidate: {
+    title: string;
+    idea: string;
+    novelty: number;
+}, recentHypotheses: {
+    title: string;
+    idea: string;
+    novelty: number;
+}[], rejectedHypotheses: {
+    title: string;
+    idea: string;
+}[]): NoveltyVerdict;

package/dist/NoveltyScorer.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * NoveltyScorer — 代码层新颖度评估
+ *
+ * 在 LLM 自评 novelty 之外，通过文本相似度对输入假设进行再评估：
+ * 1. 与近期假设（past 30）的 idea 文本对比，Jaccard 相似度 > 0.5 → 扣 15 分
+ * 2. 与已拒绝假设的 idea 文本对比，Jaccard 相似度 > 0.6 → 标记为 rejected
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jaccardSimilarity = jaccardSimilarity;
+exports.evaluateNovelty = evaluateNovelty;
+// ==================== Tokenizer ====================
+/**
+ * 简易 tokenizer：将文本拆分为 token 集合
+ * - 英文词按空格/标点分割、转小写
+ * - 中文按二元组（bigram）拆分（中文分词需要词典，这里用 bigram 近似）
+ * - 去重、去空
+ */
+function tokenize(text) {
+    const tokens = new Set();
+    // 英文/数字 token
+    const enTokens = text
+        .toLowerCase()
+        .split(/[^a-z0-9一-鿿]+/g)
+        .filter((t) => t.length > 1 && /[a-z0-9]/.test(t));
+    for (const t of enTokens)
+        tokens.add(t);
+    // 中文 bigram
+    const chChars = text.replace(/[^一-鿿]/g, '');
+    for (let i = 0; i < chChars.length - 1; i++) {
+        tokens.add(chChars.slice(i, i + 2));
+    }
+    return tokens;
+}
+// ==================== Similarity ====================
+/** Jaccard 相似度：|A ∩ B| / |A ∪ B| */
+function jaccardSimilarity(a, b) {
+    const setA = tokenize(a);
+    const setB = tokenize(b);
+    const union = new Set([...setA, ...setB]);
+    if (union.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const t of setA) {
+        if (setB.has(t))
+            intersection++;
+    }
+    return intersection / union.size;
+}
+/**
+ * 对一条新假设进行代码层新颖度评估
+ *
+ * @param candidate 新假设
+ * @param recentHypotheses 近期假设（用于扣分）
+ * @param rejectedHypotheses 已拒绝假设（用于自动拒绝）
+ * @returns NoveltyVerdict
+ */
+function evaluateNovelty(candidate, recentHypotheses, rejectedHypotheses) {
+    const candidateText = `${candidate.title} ${candidate.idea}`;
+    let adjustedNovelty = candidate.novelty;
+    let mostSimilarTitle = '';
+    let mostSimilarScore = 0;
+    // 1. 与近期假设对比
+    for (const h of recentHypotheses) {
+        const sim = jaccardSimilarity(candidateText, `${h.title} ${h.idea}`);
+        if (sim > mostSimilarScore) {
+            mostSimilarScore = sim;
+            mostSimilarTitle = h.title;
+        }
+    }
+    if (mostSimilarScore > 0.5) {
+        adjustedNovelty = Math.max(0, adjustedNovelty - 15);
+    }
+    // 2. 与已拒绝假设对比 — 高度相似则自动拒绝
+    for (const h of rejectedHypotheses) {
+        const sim = jaccardSimilarity(candidateText, `${h.title} ${h.idea}`);
+        if (sim > 0.6) {
+            return {
+                adjustedNovelty,
+                shouldReject: true,
+                rejectReason: `与已拒绝假设"${h.title}"内容高度相似 (Jaccard=${sim.toFixed(2)})`,
+                mostSimilarTitle: h.title,
+                mostSimilarScore: sim,
+            };
+        }
+    }
+    return {
+        adjustedNovelty,
+        shouldReject: false,
+        mostSimilarTitle,
+        mostSimilarScore,
+    };
+}

package/dist/SourceAggregator.d.ts

@@ -0,0 +1,21 @@
+import type { CreativitySource } from './types';
+export type SourceDomain = 'module' | 'behavior' | 'observation' | 'external' | 'failure' | 'feedback';
+export interface SourceProvider {
+    domain: SourceDomain;
+    name: string;
+    collect: () => CreativitySource[];
+}
+/**
+ * SourceAggregator — 来源总线
+ *
+ * 统一收集多域来源，做去重、每域限流与失败降级，
+ * 供创意产生与发酵两端共用同一份信号。
+ */
+export declare class SourceAggregator {
+    private providers;
+    private maxPerDomain;
+    private minDomains;
+    constructor(maxPerDomain?: number, minDomains?: number);
+    addProvider(provider: SourceProvider): void;
+    build(): CreativitySource[];
+}

package/dist/SourceAggregator.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceAggregator = void 0;
+const Logger_1 = require("@akemi-mio/core/logger/Logger");
+/**
+ * SourceAggregator — 来源总线
+ *
+ * 统一收集多域来源，做去重、每域限流与失败降级，
+ * 供创意产生与发酵两端共用同一份信号。
+ */
+class SourceAggregator {
+    providers = [];
+    maxPerDomain;
+    minDomains;
+    constructor(maxPerDomain = 4, minDomains = 3) {
+        this.maxPerDomain = maxPerDomain;
+        this.minDomains = minDomains;
+    }
+    addProvider(provider) {
+        this.providers.push(provider);
+    }
+    build() {
+        const byDomain = new Map();
+        const seen = new Set();
+        for (const provider of this.providers) {
+            let collected = [];
+            try {
+                collected = provider.collect() ?? [];
+            }
+            catch (err) {
+                (0, Logger_1.log)('WARN', 'source_provider_failed', { provider: provider.name, error: String(err?.message ?? err) });
+                continue;
+            }
+            const unique = collected.filter((s) => {
+                const key = `${provider.domain}:${s.name}`;
+                if (seen.has(key))
+                    return false;
+                seen.add(key);
+                return true;
+            });
+            const list = byDomain.get(provider.domain) ?? [];
+            byDomain.set(provider.domain, [...list, ...unique]);
+        }
+        const output = [];
+        let domainsWithData = 0;
+        for (const [domain, sources] of byDomain) {
+            if (sources.length > 0)
+                domainsWithData++;
+            const sorted = [...sources].sort((a, b) => b.weight - a.weight);
+            output.push(...sorted.slice(0, this.maxPerDomain));
+        }
+        if (domainsWithData < this.minDomains) {
+            (0, Logger_1.log)('WARN', 'source_aggregator_low_diversity', { domains: domainsWithData, min: this.minDomains });
+        }
+        (0, Logger_1.log)('INFO', 'source_aggregator_build', { total: output.length, domains: domainsWithData });
+        return output;
+    }
+}
+exports.SourceAggregator = SourceAggregator;

package/dist/TemplateLibrary.d.ts

@@ -0,0 +1,29 @@
+import type { CreativitySource, ConceptCombo, Hypothesis } from './types';
+/**
+ * TemplateLibrary — 本地假设生成引擎
+ *
+ * 使用方式：
+ *   1. selectBest(combo, sources) 根据来源类型选择 2-3 个最佳模板
+ *   2. fill(template, sourceA, sourceB) 填充模板内容
+ *   3. 直接 generate(combo, sources) 一站式生成 Hypothesis
+ */
+export declare class TemplateLibrary {
+    private rng;
+    constructor(seed?: number);
+    /**
+     * 为一个 ConceptCombo 生成一条假设
+     * @returns 生成的 Hypothesis，如果无适用模板则返回 null
+     */
+    generate(combo: ConceptCombo, sources: CreativitySource[]): Hypothesis | null;
+    /**
+     * 返回适用于某个类型组合的所有模板列表
+     * @param nameKey 对 source name 排序后的组合键，用于 nameFit 二次路由
+     */
+    private selectForType;
+    private typeKey;
+    /** 对 source name 排序生成 nameFit 查询键 */
+    private nameKey;
+    private stableHash;
+    /** 评分的小幅随机扰动（0-15），保持一定多样性 */
+    private scoreNoise;
+}