@akemi-mio/creativity 0.1.1 → 0.3.0

package/dist/HypothesisGenerator.d.ts

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

package/dist/HypothesisGenerator.js

@@ -42,13 +42,15 @@ class HypothesisGenerator {
     /** 外部信号 — 不参与配对，作为审视视角注入 LLM */
     externalSignals = [], 
     /** 显式技法；缺省走五技法轮换（rotationSeed + 调用次数） */
-    method) {
+    method, 
+    /** 正向反馈闭环 P2：不可变快照的结构化提示块。缺省 = 提示词逐字节不变。 */
+    feedback) {
         if (combos.length === 0)
             return [];
         const technique = method ?? (0, CreativityPrompt_1.pickTechnique)(this.rotationSeed + this.callCount);
         this.callCount += 1;
         // 第一级：远程 LLM 驱动生成
-        const llmResults = await this.tryLLM(sources, combos, dreamMode, externalSignals, technique);
+        const llmResults = await this.tryLLM(sources, combos, dreamMode, externalSignals, technique, feedback);
         if (llmResults.length > 0) {
             return this.tag(llmResults.map((r) => ({
                 id: `hyp_${Date.now()}_${++this.idCounter}_${this.rng().toString(36).slice(2, 4)}`,
@@ -68,7 +70,7 @@ class HypothesisGenerator {
         // 第二级：本地 transformers.js 模型
         if (this.localModel.isEnabled) {
             (0, Logger_1.log)('INFO', 'hypothesis_fallback_local', { count: combos.length });
-            const localResults = await this.tryLocalModel(sources, combos, dreamMode, technique);
+            const localResults = await this.tryLocalModel(sources, combos, dreamMode, technique, feedback);
             if (localResults.length > 0) {
                 return this.tag(localResults.map((r) => ({
                     id: `hyp_local_${Date.now()}_${++this.idCounter}_${this.rng().toString(36).slice(2, 4)}`,
@@ -105,14 +107,14 @@ class HypothesisGenerator {
     /**
      * 调 LLM 生成创意
      */
-    async tryLLM(sources, combos, dreamMode, externalSignals = [], technique = '') {
+    async tryLLM(sources, combos, dreamMode, externalSignals = [], technique = '', feedback) {
         // 限制输入量，避免超 token
         const topCombos = combos.slice(0, dreamMode ? 5 : 3);
         const comboInfo = topCombos.map((c) => ({
             sources: c.sources,
             description: c.description,
         }));
-        const prompt = (0, CreativityPrompt_1.buildCreativityPrompt)(sources, comboInfo, externalSignals);
+        const prompt = (0, CreativityPrompt_1.buildCreativityPrompt)(sources, comboInfo, externalSignals, feedback);
         try {
             const result = await this.chatJson(prompt, {
                 system: (0, CreativityPrompt_1.buildSystemPrompt)(technique),
@@ -120,6 +122,12 @@ class HypothesisGenerator {
                 timeoutMs: 60000,
                 // 输出无界会顶满超时（M2）：生成上限 1200 tokens
                 maxTokens: 1200,
+                // 提示词要求顶层数组：json_object 模式下部分模型会包成
+                // {"ideas": [...]}，Array.isArray 判空后**静默**降级到模板
+                // （无 provenance.sources → 反馈事件不可归因，attribution
+                // coverage 恒 0）。声明 array 身份让 llm-client 省略
+                // response_format，与 InsightGenerator 同策略。
+                responseFormat: 'array',
             });
             if (result.error) {
                 (0, Logger_1.log)('WARN', 'hypothesis_llm_error', { error: result.error });
@@ -141,13 +149,13 @@ class HypothesisGenerator {
     /**
      * 调本地 transformers.js 模型生成创意
      */
-    async tryLocalModel(sources, combos, dreamMode, technique = '') {
+    async tryLocalModel(sources, combos, dreamMode, technique = '', feedback) {
         const topCombos = combos.slice(0, dreamMode ? 3 : 2);
         const comboInfo = topCombos.map((c) => ({
             sources: c.sources,
             description: c.description,
         }));
-        const prompt = (0, CreativityPrompt_1.buildCreativityPrompt)(sources, comboInfo);
+        const prompt = (0, CreativityPrompt_1.buildCreativityPrompt)(sources, comboInfo, [], feedback);
         const result = await this.localModel.generate(prompt, {
             system: (0, CreativityPrompt_1.buildSystemPrompt)(technique),
             temperature: dreamMode ? 0.8 : 0.6,

package/dist/IdeaGenerator.d.ts

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

package/dist/IdeaGenerator.js

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

package/dist/InsightSamplingExperiment.d.ts

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

package/dist/InsightSamplingExperiment.js

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

package/dist/JsonlFeedbackEventStore.d.ts

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

package/dist/JsonlFeedbackEventStore.js

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

package/dist/ingestFeedbackEvents.d.ts

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

package/dist/ingestFeedbackEvents.js

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

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;

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akemi-mio/creativity",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Creativity layer: ideas, writing, blog, image, inspiration",
   "main": "./dist/IdeaGenerator.js",
   "types": "./dist/IdeaGenerator.d.ts",
@@ -50,6 +50,51 @@
       "require": "./dist/InsightSamplingExperiment.js",
       "default": "./dist/InsightSamplingExperiment.js"
     },
+    "./FeedbackEvents": {
+      "types": "./dist/FeedbackEvents.d.ts",
+      "require": "./dist/FeedbackEvents.js",
+      "default": "./dist/FeedbackEvents.js"
+    },
+    "./JsonlFeedbackEventStore": {
+      "types": "./dist/JsonlFeedbackEventStore.d.ts",
+      "require": "./dist/JsonlFeedbackEventStore.js",
+      "default": "./dist/JsonlFeedbackEventStore.js"
+    },
+    "./FeedbackLearning": {
+      "types": "./dist/FeedbackLearning.d.ts",
+      "require": "./dist/FeedbackLearning.js",
+      "default": "./dist/FeedbackLearning.js"
+    },
+    "./CreativityPrompt": {
+      "types": "./dist/CreativityPrompt.d.ts",
+      "require": "./dist/CreativityPrompt.js",
+      "default": "./dist/CreativityPrompt.js"
+    },
+    "./ConceptMixer": {
+      "types": "./dist/ConceptMixer.d.ts",
+      "require": "./dist/ConceptMixer.js",
+      "default": "./dist/ConceptMixer.js"
+    },
+    "./FeedbackRuntime": {
+      "types": "./dist/FeedbackRuntime.d.ts",
+      "require": "./dist/FeedbackRuntime.js",
+      "default": "./dist/FeedbackRuntime.js"
+    },
+    "./FeedbackRollout": {
+      "types": "./dist/FeedbackRollout.d.ts",
+      "require": "./dist/FeedbackRollout.js",
+      "default": "./dist/FeedbackRollout.js"
+    },
+    "./FeedbackRuntimeRuns": {
+      "types": "./dist/FeedbackRuntimeRuns.d.ts",
+      "require": "./dist/FeedbackRuntimeRuns.js",
+      "default": "./dist/FeedbackRuntimeRuns.js"
+    },
+    "./FeedbackMetrics": {
+      "types": "./dist/FeedbackMetrics.d.ts",
+      "require": "./dist/FeedbackMetrics.js",
+      "default": "./dist/FeedbackMetrics.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [