@akemi-mio/creativity 0.1.0 → 0.2.0

package/dist/WhenThenRunner.d.ts

@@ -0,0 +1,135 @@
+/**
+ * WhenThenRunner — 声明式 WHEN/THEN 受限 DSL 运行器（机制涌现 P2a，定案 D5/R5/A2）
+ *
+ * 候选执行不写任意代码：DSL 查表求值（阈值比较 + 字段存在性 + 枚举匹配，禁 JS eval）。
+ * 步骤依赖执行 + 显式 named outputs（无隐式上下文注入）。
+ * resourceBudget 编译为 CapabilityToken.constraints。
+ * 求值器输入输出全白名单序列化（JSON number/boolean/string）。
+ * 条件字符串长度上限，解析失败 = fail-closed（步骤跳过 + 记 guardrail 事件，不中断实验、不泄漏沙箱内部）。
+ */
+/**
+ * Token constraints — structural alias for CapabilityToken['constraints'].
+ * Defined locally to avoid a cross-package type dependency in the build (tsconfig.build.json is allowlist-based).
+ */
+export interface TokenConstraints {
+    maxCalls?: number;
+    maxTokens?: number;
+    expiryMs?: number;
+    allowedValues?: Record<string, string[]>;
+}
+/** 比较操作符（白名单，禁自由表达式） */
+export type CompareOp = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'exists' | 'notExists';
+/** WHEN 条件（查表求值，无 JS eval） */
+export interface WhenCondition {
+    /** 数据源路径（点分，如 `metrics.latency` 或 `capabilities.publishing.outcome`） */
+    field: string;
+    op: CompareOp;
+    /** 比较值（number/boolean/string 白名单；in/nin 时为 string[]） */
+    value?: number | boolean | string | string[];
+}
+/** THEN 动作 */
+export interface ThenAction {
+    /** 步骤 id（图内唯一） */
+    id: string;
+    /** capability id（执行时 resolve） */
+    capabilityId: string;
+    /** 显式 named inputs：来自上游 named outputs 或初始 context 的白名单路径 */
+    inputs?: Record<string, string>;
+    /** 显式 named outputs：本步骤产出名（下游可引用） */
+    outputs?: string[];
+    /** 资源预算（编译为 CapabilityToken.constraints） */
+    resourceBudget?: ResourceBudgetSpec;
+    /** 依赖的上游步骤 id（显式 DAG，无隐式顺序） */
+    dependsOn?: string[];
+    /** WHEN 条件为空则无条件执行；条件不满足 = 本步骤跳过 */
+    when?: WhenCondition[];
+}
+/** 单步资源预算 */
+export interface ResourceBudgetSpec {
+    maxCalls?: number;
+    maxTokens?: number;
+    expiryMs?: number;
+    allowedValues?: Record<string, string[]>;
+}
+/** 完整 WHEN/THEN 规则（一个候选实验的声明式执行计划） */
+export interface WhenThenRule {
+    id: string;
+    /** 假设 id（回溯） */
+    hypothesisId?: string;
+    /** 规则描述 */
+    description?: string;
+    /** 步骤列表（依赖 DAG） */
+    steps: ThenAction[];
+    /** 规则级资源预算（步骤级覆盖规则级） */
+    resourceBudget?: ResourceBudgetSpec;
+}
+/** 条件字符串长度上限（防超长注入） */
+export declare const MAX_CONDITION_FIELD_LEN = 128;
+export declare const MAX_CONDITION_STRING_VALUE_LEN = 512;
+export declare const MAX_CONDITION_LIST_LEN = 32;
+/** 按点分路径从 context 取值；中间路径不存在返回 undefined。不深入数组索引（防原型链）。 */
+export declare function lookupField(context: Record<string, unknown>, field: string): unknown;
+/** 求值单个 WHEN 条件；解析失败（非法字段/值/操作符）返回 null（调用方 fail-closed）。 */
+export declare function evaluateCondition(context: Record<string, unknown>, cond: WhenCondition): boolean | null;
+/** 求值全部 WHEN 条件（AND）；任一解析失败返回 null（fail-closed）。 */
+export declare function evaluateWhen(context: Record<string, unknown>, when: WhenCondition[] | undefined): boolean | null;
+/** 把 ResourceBudgetSpec 编译为 CapabilityToken.constraints（白名单字段）。 */
+export declare function compileBudgetToConstraints(budget: ResourceBudgetSpec | undefined, ruleBudget?: ResourceBudgetSpec): TokenConstraints | undefined;
+/** 单步执行输入（全白名单序列化） */
+export interface StepExecInput {
+    stepId: string;
+    capabilityId: string;
+    /** 显式 named inputs（路径解析后的值） */
+    inputs: Record<string, unknown>;
+    /** 编译后的 token constraints */
+    constraints?: TokenConstraints;
+}
+/** 单步执行结果 */
+export interface StepExecResult {
+    success: boolean;
+    /** 显式 named outputs（本步骤产出） */
+    outputs?: Record<string, unknown>;
+    error?: string;
+}
+/** 步骤执行器接口（由 CreativityExecutor / CapabilityService 实现） */
+export type StepExecutor = (input: StepExecInput) => Promise<StepExecResult>;
+/** 运行器事件（guardrail 事件 sink） */
+export interface RunnerEvent {
+    event_type: 'whenthen.step.skipped' | 'whenthen.step.failed' | 'whenthen.rule.complete' | 'whenthen.rule.failed';
+    rule_id: string;
+    step_id?: string;
+    /** 公开原因（不泄漏沙箱内部） */
+    reason?: string;
+    outcome?: string;
+    timestamp: number;
+}
+export type RunnerEventSink = (ev: RunnerEvent) => void;
+/** 拓扑排序步骤；环路/未知依赖返回 null（fail-closed）。 */
+export declare function topologicalOrder(steps: readonly ThenAction[]): ThenAction[] | null;
+export interface RunRuleResult {
+    success: boolean;
+    /** 各步骤 named outputs 汇总（key = stepId.outputName 或 outputName） */
+    namedOutputs: Record<string, unknown>;
+    /** 各步骤状态 */
+    steps: Array<{
+        id: string;
+        status: 'ok' | 'skipped' | 'failed' | 'blocked';
+        reason?: string;
+        outputs?: Record<string, unknown>;
+    }>;
+    events: RunnerEvent[];
+}
+/**
+ * 执行一条 WHEN/THEN 规则。
+ *
+ * - 按 DAG 拓扑顺序调度
+ * - 每步先求值 WHEN（解析失败 → fail-closed skip + guardrail 事件）
+ * - 输入从初始 context + 上游 named outputs 显式解析（无隐式注入）
+ * - 预算编译为 CapabilityToken.constraints 传给 executor
+ * - 任一步失败不中断实验：后续依赖步骤 blocked，独立步骤继续
+ */
+export declare function runWhenThenRule(rule: WhenThenRule, context: Record<string, unknown>, executeStep: StepExecutor, options?: {
+    /** 初始 named outputs（可选）；与 context 不同：context 只用于 WHEN 求值 */
+    initialOutputs?: Record<string, unknown>;
+    onEvent?: RunnerEventSink;
+}): Promise<RunRuleResult>;

package/dist/WhenThenRunner.js

@@ -0,0 +1,358 @@
+"use strict";
+/**
+ * WhenThenRunner — 声明式 WHEN/THEN 受限 DSL 运行器（机制涌现 P2a，定案 D5/R5/A2）
+ *
+ * 候选执行不写任意代码：DSL 查表求值（阈值比较 + 字段存在性 + 枚举匹配，禁 JS eval）。
+ * 步骤依赖执行 + 显式 named outputs（无隐式上下文注入）。
+ * resourceBudget 编译为 CapabilityToken.constraints。
+ * 求值器输入输出全白名单序列化（JSON number/boolean/string）。
+ * 条件字符串长度上限，解析失败 = fail-closed（步骤跳过 + 记 guardrail 事件，不中断实验、不泄漏沙箱内部）。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CONDITION_LIST_LEN = exports.MAX_CONDITION_STRING_VALUE_LEN = exports.MAX_CONDITION_FIELD_LEN = void 0;
+exports.lookupField = lookupField;
+exports.evaluateCondition = evaluateCondition;
+exports.evaluateWhen = evaluateWhen;
+exports.compileBudgetToConstraints = compileBudgetToConstraints;
+exports.topologicalOrder = topologicalOrder;
+exports.runWhenThenRule = runWhenThenRule;
+// ══════════════════════════════════════════
+// 求值器（白名单查表，禁 eval）
+// ══════════════════════════════════════════
+/** 条件字符串长度上限（防超长注入） */
+exports.MAX_CONDITION_FIELD_LEN = 128;
+exports.MAX_CONDITION_STRING_VALUE_LEN = 512;
+exports.MAX_CONDITION_LIST_LEN = 32;
+function isScalar(v) {
+    return typeof v === 'number' || typeof v === 'boolean' || typeof v === 'string';
+}
+/** 按点分路径从 context 取值；中间路径不存在返回 undefined。不深入数组索引（防原型链）。 */
+function lookupField(context, field) {
+    if (typeof field !== 'string' || field.length === 0 || field.length > exports.MAX_CONDITION_FIELD_LEN)
+        return undefined;
+    // 禁原型链：字段不得含 `__proto__` / `constructor` / `prototype`
+    if (field.includes('__proto__') || field.includes('constructor') || field.includes('prototype'))
+        return undefined;
+    const parts = field.split('.');
+    let cur = context;
+    for (const p of parts) {
+        if (cur === null || typeof cur !== 'object' || Array.isArray(cur))
+            return undefined;
+        const obj = cur;
+        if (!Object.prototype.hasOwnProperty.call(obj, p))
+            return undefined;
+        cur = obj[p];
+    }
+    return cur;
+}
+/** 求值单个 WHEN 条件；解析失败（非法字段/值/操作符）返回 null（调用方 fail-closed）。 */
+function evaluateCondition(context, cond) {
+    if (!cond || typeof cond !== 'object')
+        return null;
+    const { field, op, value } = cond;
+    if (typeof field !== 'string' || field.length === 0 || field.length > exports.MAX_CONDITION_FIELD_LEN)
+        return null;
+    if (field.includes('__proto__') || field.includes('constructor') || field.includes('prototype'))
+        return null;
+    const actual = lookupField(context, field);
+    switch (op) {
+        case 'exists':
+            return actual !== undefined && actual !== null;
+        case 'notExists':
+            return actual === undefined || actual === null;
+        case 'eq':
+        case 'neq':
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte': {
+            if (!isScalar(value))
+                return null;
+            if (!isScalar(actual))
+                return false;
+            switch (op) {
+                case 'eq':
+                    return actual === value;
+                case 'neq':
+                    return actual !== value;
+                case 'gt':
+                    return typeof actual === 'number' && typeof value === 'number' && actual > value;
+                case 'gte':
+                    return typeof actual === 'number' && typeof value === 'number' && actual >= value;
+                case 'lt':
+                    return typeof actual === 'number' && typeof value === 'number' && actual < value;
+                case 'lte':
+                    return typeof actual === 'number' && typeof value === 'number' && actual <= value;
+                default:
+                    return null;
+            }
+        }
+        case 'in':
+        case 'nin': {
+            if (!Array.isArray(value) || value.length > exports.MAX_CONDITION_LIST_LEN)
+                return null;
+            if (!value.every((v) => typeof v === 'string' && v.length <= exports.MAX_CONDITION_STRING_VALUE_LEN))
+                return null;
+            if (!isScalar(actual))
+                return false;
+            const hit = value.includes(actual);
+            return op === 'in' ? hit : !hit;
+        }
+        default:
+            // 未知操作符 = 解析失败
+            return null;
+    }
+}
+/** 求值全部 WHEN 条件（AND）；任一解析失败返回 null（fail-closed）。 */
+function evaluateWhen(context, when) {
+    if (!when || when.length === 0)
+        return true;
+    for (const c of when) {
+        const r = evaluateCondition(context, c);
+        if (r === null)
+            return null;
+        if (r === false)
+            return false;
+    }
+    return true;
+}
+// ══════════════════════════════════════════
+// resourceBudget → CapabilityToken.constraints
+// ══════════════════════════════════════════
+/** 把 ResourceBudgetSpec 编译为 CapabilityToken.constraints（白名单字段）。 */
+function compileBudgetToConstraints(budget, ruleBudget) {
+    // 步骤级覆盖规则级
+    const b = budget ?? ruleBudget;
+    if (!b)
+        return undefined;
+    const constraints = {};
+    if (typeof b.maxCalls === 'number' && Number.isFinite(b.maxCalls) && b.maxCalls >= 0) {
+        constraints.maxCalls = Math.floor(b.maxCalls);
+    }
+    if (typeof b.maxTokens === 'number' && Number.isFinite(b.maxTokens) && b.maxTokens >= 0) {
+        constraints.maxTokens = Math.floor(b.maxTokens);
+    }
+    if (typeof b.expiryMs === 'number' && Number.isFinite(b.expiryMs) && b.expiryMs >= 0) {
+        constraints.expiryMs = Math.floor(b.expiryMs);
+    }
+    if (b.allowedValues && typeof b.allowedValues === 'object' && !Array.isArray(b.allowedValues)) {
+        const allowed = {};
+        for (const [k, arr] of Object.entries(b.allowedValues)) {
+            if (Array.isArray(arr) && arr.every((v) => typeof v === 'string' && v.length <= exports.MAX_CONDITION_STRING_VALUE_LEN)) {
+                if (arr.length <= exports.MAX_CONDITION_LIST_LEN)
+                    allowed[k] = arr;
+            }
+        }
+        if (Object.keys(allowed).length > 0)
+            constraints.allowedValues = allowed;
+    }
+    return Object.keys(constraints).length > 0 ? constraints : undefined;
+}
+// ══════════════════════════════════════════
+// 依赖调度（DAG 拓扑 + named outputs）
+// ══════════════════════════════════════════
+/** 拓扑排序步骤；环路/未知依赖返回 null（fail-closed）。 */
+function topologicalOrder(steps) {
+    const byId = new Map();
+    for (const s of steps) {
+        if (!s || typeof s.id !== 'string' || s.id.length === 0)
+            return null;
+        if (byId.has(s.id))
+            return null;
+        byId.set(s.id, s);
+    }
+    const indegree = new Map();
+    const children = new Map();
+    for (const s of steps) {
+        indegree.set(s.id, 0);
+    }
+    for (const s of steps) {
+        const deps = s.dependsOn ?? [];
+        for (const d of deps) {
+            if (!byId.has(d))
+                return null; // 未知依赖
+            indegree.set(s.id, (indegree.get(s.id) ?? 0) + 1);
+            const list = children.get(d) ?? [];
+            list.push(s.id);
+            children.set(d, list);
+        }
+    }
+    const queue = [];
+    for (const [id, deg] of indegree) {
+        if (deg === 0)
+            queue.push(id);
+    }
+    queue.sort();
+    const order = [];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        order.push(byId.get(id));
+        for (const child of children.get(id) ?? []) {
+            const nd = (indegree.get(child) ?? 1) - 1;
+            indegree.set(child, nd);
+            if (nd === 0)
+                queue.push(child);
+        }
+        queue.sort();
+    }
+    if (order.length !== steps.length)
+        return null; // 环
+    return order;
+}
+/**
+ * 执行一条 WHEN/THEN 规则。
+ *
+ * - 按 DAG 拓扑顺序调度
+ * - 每步先求值 WHEN（解析失败 → fail-closed skip + guardrail 事件）
+ * - 输入从初始 context + 上游 named outputs 显式解析（无隐式注入）
+ * - 预算编译为 CapabilityToken.constraints 传给 executor
+ * - 任一步失败不中断实验：后续依赖步骤 blocked，独立步骤继续
+ */
+async function runWhenThenRule(rule, context, executeStep, options) {
+    const events = [];
+    const namedOutputs = { ...(options?.initialOutputs ?? {}) };
+    const stepStatus = new Map();
+    const stepReason = new Map();
+    const stepOutputs = new Map();
+    const sink = (ev) => {
+        events.push(ev);
+        options?.onEvent?.(ev);
+    };
+    // 1. 拓扑排序（环/未知依赖 → 整规则 fail-closed）
+    const order = topologicalOrder(rule.steps ?? []);
+    if (!order) {
+        sink({
+            event_type: 'whenthen.rule.failed',
+            rule_id: rule.id,
+            reason: 'invalid_graph',
+            outcome: 'failed',
+            timestamp: Date.now(),
+        });
+        return { success: false, namedOutputs, steps: [], events };
+    }
+    // 2. 逐步骤
+    for (const step of order) {
+        const deps = step.dependsOn ?? [];
+        const depBlocked = deps.some((d) => {
+            const st = stepStatus.get(d);
+            return st === 'failed' || st === 'blocked' || st === 'skipped';
+        });
+        if (depBlocked) {
+            stepStatus.set(step.id, 'blocked');
+            stepReason.set(step.id, 'upstream_blocked');
+            sink({
+                event_type: 'whenthen.step.skipped',
+                rule_id: rule.id,
+                step_id: step.id,
+                reason: 'upstream_blocked',
+                outcome: 'skipped',
+                timestamp: Date.now(),
+            });
+            continue;
+        }
+        // 3. WHEN 求值（fail-closed）
+        const whenOk = evaluateWhen(context, step.when);
+        if (whenOk === null) {
+            stepStatus.set(step.id, 'skipped');
+            stepReason.set(step.id, 'when_parse_failed');
+            sink({
+                event_type: 'whenthen.step.skipped',
+                rule_id: rule.id,
+                step_id: step.id,
+                reason: 'when_parse_failed',
+                outcome: 'skipped',
+                timestamp: Date.now(),
+            });
+            continue;
+        }
+        if (whenOk === false) {
+            stepStatus.set(step.id, 'skipped');
+            stepReason.set(step.id, 'when_not_satisfied');
+            sink({
+                event_type: 'whenthen.step.skipped',
+                rule_id: rule.id,
+                step_id: step.id,
+                reason: 'when_not_satisfied',
+                outcome: 'skipped',
+                timestamp: Date.now(),
+            });
+            continue;
+        }
+        // 4. 显式 named inputs 解析（路径 = 初始 context 或 namedOutputs）
+        const inputs = {};
+        if (step.inputs) {
+            for (const [name, path] of Object.entries(step.inputs)) {
+                if (typeof path !== 'string' || path.length === 0 || path.length > exports.MAX_CONDITION_FIELD_LEN)
+                    continue;
+                if (path.includes('__proto__') || path.includes('constructor') || path.includes('prototype'))
+                    continue;
+                const v = lookupField(namedOutputs, path) ?? lookupField(context, path);
+                if (v !== undefined)
+                    inputs[name] = v;
+            }
+        }
+        // 5. 预算编译
+        const constraints = compileBudgetToConstraints(step.resourceBudget, rule.resourceBudget);
+        // 6. 执行
+        try {
+            const result = await executeStep({
+                stepId: step.id,
+                capabilityId: step.capabilityId,
+                inputs,
+                constraints,
+            });
+            if (result.success) {
+                stepStatus.set(step.id, 'ok');
+                const outs = result.outputs ?? {};
+                stepOutputs.set(step.id, outs);
+                for (const [k, v] of Object.entries(outs)) {
+                    namedOutputs[k] = v;
+                    namedOutputs[`${step.id}.${k}`] = v;
+                }
+            }
+            else {
+                stepStatus.set(step.id, 'failed');
+                stepReason.set(step.id, result.error ?? 'step_failed');
+                sink({
+                    event_type: 'whenthen.step.failed',
+                    rule_id: rule.id,
+                    step_id: step.id,
+                    reason: result.error ?? 'step_failed',
+                    outcome: 'failed',
+                    timestamp: Date.now(),
+                });
+            }
+        }
+        catch {
+            stepStatus.set(step.id, 'failed');
+            stepReason.set(step.id, 'step_exception');
+            sink({
+                event_type: 'whenthen.step.failed',
+                rule_id: rule.id,
+                step_id: step.id,
+                reason: 'step_exception',
+                outcome: 'failed',
+                timestamp: Date.now(),
+            });
+        }
+    }
+    const allOk = order.every((s) => stepStatus.get(s.id) === 'ok' || stepStatus.get(s.id) === 'skipped');
+    sink({
+        event_type: allOk ? 'whenthen.rule.complete' : 'whenthen.rule.failed',
+        rule_id: rule.id,
+        reason: allOk ? 'complete' : 'partial_failure',
+        outcome: allOk ? 'success' : 'partial',
+        timestamp: Date.now(),
+    });
+    return {
+        success: allOk,
+        namedOutputs,
+        steps: order.map((s) => ({
+            id: s.id,
+            status: stepStatus.get(s.id) ?? 'blocked',
+            reason: stepReason.get(s.id),
+            outputs: stepOutputs.get(s.id),
+        })),
+        events,
+    };
+}

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

package/dist/types.d.ts

@@ -5,6 +5,17 @@
  * - signal:   强制注入 trend/ provocation/insight 来源，限�?randomness
  */
 export type Strategy = 'stable' | 'explore' | 'signal';
+/**
+ * 规范化概念身份（正向反馈闭环 spec §五.2）：稳定字段 `origin` 优先，
+ * `name` 仅作展示，缺失时回退 `name:<name>` 以避免与 origin 碰撞。
+ * ConceptMixer 与 FeedbackLearning 共用此规则，防止双套身份漂移（R2）。
+ */
+export declare function sourceConceptId(s: {
+    name: string;
+    origin?: string;
+}): string;
+/** 规范化无序概念对键：(A,B) ≡ (B,A)。 */
+export declare function conceptPairKey(a: string, b: string): string;
 export interface CreativitySource {
     name: string;
     content: string;
@@ -85,7 +96,7 @@ export interface Hypothesis {
     impact: number;
     /** 逻辑一致性评分 0-100（第四维，评审/生成时打分，可缺省视为 50） */
     logic?: number;
-    status: 'draft' | 'active' | 'experimenting' | 'validated' | 'rejected';
+    status: 'draft' | 'active' | 'testing' | 'validated' | 'rejected';
     createdAt: number;
     /** The rotation technique this hypothesis was generated with (idea.generate provenance.technique). */
     technique?: string;
@@ -112,6 +123,20 @@ export interface Hypothesis {
     implementedCommitSha?: string;
     implementedAt?: number;
     implementationNote?: string;
+    /** 机制假设：提出的关系边（带 proposedRelations 即机制假设，否则普通创意） */
+    proposedRelations?: ProposedRelation[];
+    /** 证伪条件：命中任一条件则机制假设可被拒绝 */
+    falsificationConditions?: string[];
+    /** 触发本假设的 observation/trace id 溯源 */
+    sourceObservationIds?: string[];
+}
+/** 机制图的一条候选边：A --[effect]--> B */
+export interface ProposedRelation {
+    from: string;
+    to: string;
+    effect: string;
+    /** 推断来源：identity=verified | inferred（A6 confidence 映射） */
+    inference?: 'identity' | 'inferred';
 }
 export interface ExperimentPlan {
     hypothesisId: string;

package/dist/types.js

@@ -1,6 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FERMENT_PHASE_OFFSET_MS = exports.FERMENT_INTERVAL_MS = exports.NORMAL_CYCLE_INTERVAL_MS = exports.DREAM_CYCLE_INTERVAL_MS = exports.CREATIVITY_STORE_VERSION = void 0;
+exports.sourceConceptId = sourceConceptId;
+exports.conceptPairKey = conceptPairKey;
+/**
+ * 规范化概念身份（正向反馈闭环 spec §五.2）：稳定字段 `origin` 优先，
+ * `name` 仅作展示，缺失时回退 `name:<name>` 以避免与 origin 碰撞。
+ * ConceptMixer 与 FeedbackLearning 共用此规则，防止双套身份漂移（R2）。
+ */
+function sourceConceptId(s) {
+    const origin = s.origin ? s.origin.trim() : '';
+    return origin || `name:${s.name}`;
+}
+/** 规范化无序概念对键：(A,B) ≡ (B,A)。 */
+function conceptPairKey(a, b) {
+    return [a, b].sort().join('|');
+}
 exports.CREATIVITY_STORE_VERSION = 2;
 exports.DREAM_CYCLE_INTERVAL_MS = 30 * 60 * 1000; // 30min
 exports.NORMAL_CYCLE_INTERVAL_MS = 5 * 60 * 1000; // 5min