@akemi-mio/creativity 0.0.0-stage → 0.1.1

package/dist/InsightSamplingExperiment.d.ts

@@ -0,0 +1,82 @@
+/**
+ * InsightSamplingExperiment — insight 抽样策略 dogfood 实验（机制涌现 P3，定案 D4/R4）
+ *
+ * 首域 = insight 抽样策略（issue-6 P4 sourceQuota 有现成 before/after + 历史 observations 可重放）。
+ * 三组对照：现有 quota 抽样 / 变体 A / 变体 B + 消融（移除配额/移除时间序保持）+ 未见任务泛化。
+ * 产出 CapabilityDelta 报告；允许 inconclusive（不逼结论）。
+ * 硬前置 A1：MIO EXPERIMENT 标志路由 experiment-memory.jsonl（由 ExperimentRunStore 提供）。
+ */
+import type { ExperimentRun } from './ExperimentRunStore';
+/** Observation 最小形状（内联，避免跨包依赖） */
+interface ObservationLike {
+    id: string;
+    timestamp: string;
+    source: string;
+    content: string;
+}
+export type SamplingVariant = 'baseline' | 'variant_a' | 'variant_b' | 'ablation_no_quota' | 'ablation_no_time_order';
+/**
+ * baseline: 现有 quota 抽样（issue-6 P4 sampleBySourceQuota）。
+ * variant_a: 更高 minPerSource（保底提升，家族优先更强）。
+ * variant_b: 只用 Phase A 保底，不做 Phase B 余量补齐（纯家族公平）。
+ * ablation_no_quota: 移除配额 → 退化为 slice(0, limit)（issue-6 修复前）。
+ * ablation_no_time_order: 移除时间序保持 → 输出按 weight 降序。
+ */
+export declare function sampleVariant(observations: readonly ObservationLike[], variant: SamplingVariant, limit?: number): ObservationLike[];
+export interface SamplingMetrics {
+    /** 家族覆盖数（sourceFamily 去重） */
+    familyCoverage: number;
+    /** 最大家族占比（0-1；越低越公平） */
+    maxFamilyShare: number;
+    /** 时间序保持度：spearman 相关（0-1；1=完全保持） */
+    timeOrderPreservation: number;
+    /** 小源（len<quota）是否全部入选 */
+    smallSourceIncluded: boolean;
+    /** 样本量 */
+    sampleSize: number;
+}
+/** 计算抽样指标 */
+export declare function computeSamplingMetrics(original: readonly ObservationLike[], sampled: readonly ObservationLike[]): SamplingMetrics;
+export interface VariantResult {
+    variant: SamplingVariant;
+    metrics: SamplingMetrics;
+    runIds: string[];
+}
+export interface CapabilityDeltaReport {
+    experimentId: string;
+    hypothesisId?: string;
+    baselineVariant: SamplingVariant;
+    variants: VariantResult[];
+    /** 相对 baseline 的 delta（每指标：variant - baseline） */
+    deltas: Array<{
+        variant: SamplingVariant;
+        familyCoverageDelta: number;
+        maxFamilyShareDelta: number;
+        timeOrderPreservationDelta: number;
+        smallSourceIncludedDelta: number;
+    }>;
+    /** 泛化：在未见任务（held-out observations）上的表现 */
+    generalization?: {
+        heldOutSize: number;
+        baselineMetrics: SamplingMetrics;
+        bestVariant: SamplingVariant;
+        bestMetrics: SamplingMetrics;
+    };
+    /** 结论（允许 inconclusive） */
+    conclusion: 'variant_a_wins' | 'variant_b_wins' | 'baseline_wins' | 'inconclusive';
+    reason: string;
+    createdAt: number;
+}
+/**
+ * 运行 dogfood 实验：三组对照 + 消融，产出 CapabilityDelta 报告。
+ * observations 从历史重放；splitTrainTest 按时间切分（前 70% train，后 30% held-out）。
+ */
+export declare function runInsightSamplingExperiment(experimentId: string, observations: readonly ObservationLike[], options?: {
+    hypothesisId?: string;
+    limit?: number;
+    /** 每变体重复次数（取指标均值，降噪） */
+    repeats?: number;
+}): CapabilityDeltaReport;
+/** 把 CapabilityDelta 报告转成 ExperimentRun 列表（供 ExperimentRunStore.checkPromotionGate 使用） */
+export declare function reportToExperimentRuns(report: CapabilityDeltaReport): ExperimentRun[];
+export {};

package/dist/InsightSamplingExperiment.js

@@ -0,0 +1,308 @@
+"use strict";
+/**
+ * InsightSamplingExperiment — insight 抽样策略 dogfood 实验（机制涌现 P3，定案 D4/R4）
+ *
+ * 首域 = insight 抽样策略（issue-6 P4 sourceQuota 有现成 before/after + 历史 observations 可重放）。
+ * 三组对照：现有 quota 抽样 / 变体 A / 变体 B + 消融（移除配额/移除时间序保持）+ 未见任务泛化。
+ * 产出 CapabilityDelta 报告；允许 inconclusive（不逼结论）。
+ * 硬前置 A1：MIO EXPERIMENT 标志路由 experiment-memory.jsonl（由 ExperimentRunStore 提供）。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sampleVariant = sampleVariant;
+exports.computeSamplingMetrics = computeSamplingMetrics;
+exports.runInsightSamplingExperiment = runInsightSamplingExperiment;
+exports.reportToExperimentRuns = reportToExperimentRuns;
+/** RSS feedUrl 折叠（与 observer sourceQuota.sourceFamily 同语义） */
+function sourceFamily(source) {
+    return /^https?:\/\//.test(source) ? 'rss' : source;
+}
+/**
+ * baseline: 现有 quota 抽样（issue-6 P4 sampleBySourceQuota）。
+ * variant_a: 更高 minPerSource（保底提升，家族优先更强）。
+ * variant_b: 只用 Phase A 保底，不做 Phase B 余量补齐（纯家族公平）。
+ * ablation_no_quota: 移除配额 → 退化为 slice(0, limit)（issue-6 修复前）。
+ * ablation_no_time_order: 移除时间序保持 → 输出按 weight 降序。
+ */
+function sampleVariant(observations, variant, limit = 30) {
+    const obs = [...observations];
+    switch (variant) {
+        case 'baseline':
+            return sampleByQuota(obs, limit, 5);
+        case 'variant_a':
+            return sampleByQuota(obs, limit, 8);
+        case 'variant_b': {
+            // Phase A only: 每家族取 min(quota, len)，quota = floor(limit/家族数) 或 5
+            const byFamily = new Map();
+            for (const o of obs) {
+                const f = sourceFamily(o.source);
+                const g = byFamily.get(f) ?? [];
+                g.push(o);
+                byFamily.set(f, g);
+            }
+            const families = [...byFamily.keys()];
+            let quota = 5;
+            if (families.length * quota > limit)
+                quota = Math.max(1, Math.floor(limit / families.length));
+            const out = [];
+            for (const f of families)
+                out.push(...byFamily.get(f).slice(0, quota));
+            // 保持时间序
+            out.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+            return out.slice(0, limit);
+        }
+        case 'ablation_no_quota':
+            return obs.slice(0, limit);
+        case 'ablation_no_time_order': {
+            const sampled = sampleByQuota(obs, limit, 5);
+            return sampled.sort((a, b) => sourceFamily(a.source).localeCompare(sourceFamily(b.source)));
+        }
+    }
+}
+/**
+ * 本地 quota 抽样（与 observer sourceQuota.sampleBySourceQuota 同语义的精简版）。
+ * Phase A 每家族保底 + Phase B 余量最大余数法 + 时间序保持。
+ */
+function sampleByQuota(observations, limit, minPerSource) {
+    if (limit <= 0)
+        return [];
+    if (observations.length <= limit)
+        return observations.slice();
+    const groups = new Map();
+    observations.forEach((obs, idx) => {
+        const family = sourceFamily(obs.source);
+        let g = groups.get(family);
+        if (!g) {
+            g = [];
+            groups.set(family, g);
+        }
+        g.push({ idx, obs });
+    });
+    const families = [...groups.keys()];
+    let quota = minPerSource;
+    if (families.length * quota > limit)
+        quota = Math.max(1, Math.floor(limit / families.length));
+    const picked = new Set();
+    const taken = new Map();
+    for (const family of families) {
+        const g = groups.get(family);
+        const take = Math.min(quota, g.length);
+        for (let i = 0; i < take; i++)
+            picked.add(g[i].idx);
+        taken.set(family, take);
+    }
+    const remaining = limit - picked.size;
+    if (remaining > 0) {
+        const shares = families.map((family) => {
+            const group = groups.get(family);
+            return { family, group, pool: group.length - taken.get(family), base: 0, frac: 0 };
+        });
+        const totalPool = shares.reduce((s, x) => s + x.pool, 0);
+        if (totalPool > 0) {
+            for (const s of shares) {
+                const exact = (remaining * s.pool) / totalPool;
+                s.base = Math.floor(exact);
+                s.frac = exact - s.base;
+            }
+            let leftover = remaining - shares.reduce((s, x) => s + x.base, 0);
+            const byFrac = [...shares].sort((a, b) => b.frac - a.frac);
+            for (const s of byFrac) {
+                if (leftover <= 0)
+                    break;
+                if (s.pool > s.base) {
+                    s.base++;
+                    leftover--;
+                }
+            }
+            for (const s of shares) {
+                const start = taken.get(s.family);
+                for (let i = start; i < start + s.base; i++)
+                    picked.add(s.group[i].idx);
+            }
+        }
+    }
+    return observations.filter((_, i) => picked.has(i));
+}
+/** 计算抽样指标 */
+function computeSamplingMetrics(original, sampled) {
+    const families = new Set(original.map((o) => sourceFamily(o.source)));
+    const sampledFamilies = new Set(sampled.map((o) => sourceFamily(o.source)));
+    const byFamily = new Map();
+    for (const s of sampled) {
+        const f = sourceFamily(s.source);
+        byFamily.set(f, (byFamily.get(f) ?? 0) + 1);
+    }
+    const maxCount = Math.max(0, ...byFamily.values());
+    const maxFamilyShare = sampled.length > 0 ? maxCount / sampled.length : 0;
+    // 时间序保持度：采样序列在原序列中的排名相关（简化为顺序单调比）
+    const idxMap = new Map();
+    original.forEach((o, i) => idxMap.set(o.id, i));
+    const ranks = sampled.map((s) => idxMap.get(s.id) ?? -1);
+    let concordant = 0;
+    let total = 0;
+    for (let i = 0; i < ranks.length; i++) {
+        for (let j = i + 1; j < ranks.length; j++) {
+            if (ranks[i] < 0 || ranks[j] < 0)
+                continue;
+            total++;
+            if (ranks[i] < ranks[j])
+                concordant++;
+        }
+    }
+    const timeOrderPreservation = total > 0 ? concordant / total : 1;
+    // 小源：len < 5 的家族是否全部入选
+    const origByFamily = new Map();
+    for (const o of original) {
+        const f = sourceFamily(o.source);
+        const g = origByFamily.get(f) ?? [];
+        g.push(o);
+        origByFamily.set(f, g);
+    }
+    const smallSourceIncluded = [...origByFamily.entries()].every(([f, g]) => {
+        if (g.length >= 5)
+            return true;
+        const inSample = sampled.filter((s) => sourceFamily(s.source) === f);
+        return inSample.length >= g.length;
+    });
+    return {
+        familyCoverage: sampledFamilies.size,
+        maxFamilyShare,
+        timeOrderPreservation,
+        smallSourceIncluded,
+        sampleSize: sampled.length,
+    };
+}
+/**
+ * 运行 dogfood 实验：三组对照 + 消融，产出 CapabilityDelta 报告。
+ * observations 从历史重放；splitTrainTest 按时间切分（前 70% train，后 30% held-out）。
+ */
+function runInsightSamplingExperiment(experimentId, observations, options) {
+    const limit = options?.limit ?? 30;
+    const repeats = options?.repeats ?? 1;
+    const sorted = [...observations].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    const split = Math.max(1, Math.floor(sorted.length * 0.7));
+    const train = sorted.slice(0, split);
+    const heldOut = sorted.slice(split);
+    const variants = ['baseline', 'variant_a', 'variant_b', 'ablation_no_quota', 'ablation_no_time_order'];
+    const variantResults = [];
+    for (const v of variants) {
+        let metricsAcc = null;
+        const runIds = [];
+        for (let r = 0; r < repeats; r++) {
+            const sampled = sampleVariant(train, v, limit);
+            const m = computeSamplingMetrics(train, sampled);
+            metricsAcc = metricsAcc
+                ? {
+                    familyCoverage: metricsAcc.familyCoverage + m.familyCoverage,
+                    maxFamilyShare: metricsAcc.maxFamilyShare + m.maxFamilyShare,
+                    timeOrderPreservation: metricsAcc.timeOrderPreservation + m.timeOrderPreservation,
+                    smallSourceIncluded: metricsAcc.smallSourceIncluded && m.smallSourceIncluded,
+                    sampleSize: metricsAcc.sampleSize + m.sampleSize,
+                }
+                : m;
+            runIds.push(`${experimentId}:${v}:${r}`);
+        }
+        const avg = metricsAcc
+            ? {
+                familyCoverage: Math.round(metricsAcc.familyCoverage / repeats),
+                maxFamilyShare: metricsAcc.maxFamilyShare / repeats,
+                timeOrderPreservation: metricsAcc.timeOrderPreservation / repeats,
+                smallSourceIncluded: metricsAcc.smallSourceIncluded,
+                sampleSize: Math.round(metricsAcc.sampleSize / repeats),
+            }
+            : { familyCoverage: 0, maxFamilyShare: 1, timeOrderPreservation: 0, smallSourceIncluded: false, sampleSize: 0 };
+        variantResults.push({ variant: v, metrics: avg, runIds });
+    }
+    const baseline = variantResults.find((r) => r.variant === 'baseline');
+    const deltas = variantResults
+        .filter((r) => r.variant !== 'baseline')
+        .map((r) => ({
+        variant: r.variant,
+        familyCoverageDelta: r.metrics.familyCoverage - baseline.metrics.familyCoverage,
+        maxFamilyShareDelta: r.metrics.maxFamilyShare - baseline.metrics.maxFamilyShare,
+        timeOrderPreservationDelta: r.metrics.timeOrderPreservation - baseline.metrics.timeOrderPreservation,
+        smallSourceIncludedDelta: (r.metrics.smallSourceIncluded ? 1 : 0) - (baseline.metrics.smallSourceIncluded ? 1 : 0),
+    }));
+    // 泛化：held-out 上 baseline vs best variant（按 familyCoverage + smallSourceIncluded 排序）
+    let generalization;
+    if (heldOut.length > 0) {
+        const baseSampled = sampleVariant(heldOut, 'baseline', limit);
+        const baseMetrics = computeSamplingMetrics(heldOut, baseSampled);
+        const scored = ['variant_a', 'variant_b'].map((v) => {
+            const s = sampleVariant(heldOut, v, limit);
+            return { v, m: computeSamplingMetrics(heldOut, s) };
+        });
+        const best = scored.sort((a, b) => {
+            const sc = (m) => m.familyCoverage * 10 + (m.smallSourceIncluded ? 5 : 0) - m.maxFamilyShare;
+            return sc(b.m) - sc(a.m);
+        })[0];
+        generalization = {
+            heldOutSize: heldOut.length,
+            baselineMetrics: baseMetrics,
+            bestVariant: best?.v ?? 'baseline',
+            bestMetrics: best?.m ?? baseMetrics,
+        };
+    }
+    // 结论：variant_a / variant_b 优于 baseline → 对应 wins；否则 baseline_wins；样本太少 → inconclusive
+    const aDelta = deltas.find((d) => d.variant === 'variant_a');
+    const bDelta = deltas.find((d) => d.variant === 'variant_b');
+    const aBetter = aDelta && (aDelta.familyCoverageDelta > 0 || aDelta.smallSourceIncludedDelta > 0);
+    const bBetter = bDelta && (bDelta.familyCoverageDelta > 0 || bDelta.smallSourceIncludedDelta > 0);
+    let conclusion;
+    let reason;
+    if (train.length < 10) {
+        conclusion = 'inconclusive';
+        reason = 'too_few_observations';
+    }
+    else if (aBetter && bBetter) {
+        // 双优 → inconclusive（需人工判断）
+        conclusion = 'inconclusive';
+        reason = 'both_variants_improve';
+    }
+    else if (aBetter) {
+        conclusion = 'variant_a_wins';
+        reason = 'higher_family_coverage_or_small_source';
+    }
+    else if (bBetter) {
+        conclusion = 'variant_b_wins';
+        reason = 'higher_family_coverage_or_small_source';
+    }
+    else {
+        conclusion = 'baseline_wins';
+        reason = 'no_improvement_over_baseline';
+    }
+    return {
+        experimentId,
+        hypothesisId: options?.hypothesisId,
+        baselineVariant: 'baseline',
+        variants: variantResults,
+        deltas,
+        generalization,
+        conclusion,
+        reason,
+        createdAt: Date.now(),
+    };
+}
+/** 把 CapabilityDelta 报告转成 ExperimentRun 列表（供 ExperimentRunStore.checkPromotionGate 使用） */
+function reportToExperimentRuns(report) {
+    return report.variants.map((v) => ({
+        id: `${report.experimentId}:${v.variant}`,
+        hypothesisId: report.hypothesisId,
+        candidateId: v.variant,
+        baselineId: report.baselineVariant,
+        assignment: (v.variant === 'baseline'
+            ? 'baseline'
+            : v.variant.startsWith('ablation')
+                ? 'ablation'
+                : 'candidate'),
+        outcome: report.conclusion === 'inconclusive' ? 'inconclusive' : v.variant === report.conclusion.replace('_wins', '') ? 'success' : 'failure',
+        metrics: {
+            familyCoverage: v.metrics.familyCoverage,
+            maxFamilyShare: v.metrics.maxFamilyShare,
+            timeOrderPreservation: v.metrics.timeOrderPreservation,
+            smallSourceIncluded: v.metrics.smallSourceIncluded,
+            sampleSize: v.metrics.sampleSize,
+        },
+        evidenceIds: v.runIds,
+        createdAt: report.createdAt,
+    }));
+}

package/dist/LocalModelService.d.ts

@@ -0,0 +1,38 @@
+/**
+ * LocalModelService — 用 transformers.js 在进程内跑小模型
+ *
+ * 零外部依赖，进程内运行，不需要 Ollama/Python/独立服务。
+ * 懒加载，优先加载项目目录下的模型文件（models/Xenova/...），
+ * 不存在则从 HuggingFace 下载。
+ *
+ * 已下载模型位置：
+ *   models/Xenova/Qwen2.5-0.5B-Instruct/
+ *
+ * 环境变量：
+ *   LOCAL_HYPOTHESIS_MODEL   — 模型 ID (默认 Xenova/Qwen2.5-0.5B-Instruct)
+ *   LOCAL_HYPOTHESIS_DISABLED — 设为 'true' 禁用本地模型
+ *   MODEL_CACHE_DIR           — 缓存目录，缺省自动探测
+ */
+export declare class LocalModelService {
+    private generator;
+    private loadAttempted;
+    private modelId;
+    constructor(modelId?: string);
+    get isEnabled(): boolean;
+    get isLoaded(): boolean;
+    /**
+     * 生成文本 — 兼容 chatJson 接口格式
+     */
+    generate(userText: string, options?: {
+        system?: string;
+        temperature?: number;
+        maxTokens?: number;
+    }): Promise<{
+        data?: any;
+        error?: string;
+    }>;
+    /**
+     * 尝试从生成文本中提取 JSON
+     */
+    private tryParse;
+}

package/dist/LocalModelService.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalModelService = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const Logger_1 = require("@akemi-mio/core/logger/Logger");
+/**
+ * LocalModelService — 用 transformers.js 在进程内跑小模型
+ *
+ * 零外部依赖，进程内运行，不需要 Ollama/Python/独立服务。
+ * 懒加载，优先加载项目目录下的模型文件（models/Xenova/...），
+ * 不存在则从 HuggingFace 下载。
+ *
+ * 已下载模型位置：
+ *   models/Xenova/Qwen2.5-0.5B-Instruct/
+ *
+ * 环境变量：
+ *   LOCAL_HYPOTHESIS_MODEL   — 模型 ID (默认 Xenova/Qwen2.5-0.5B-Instruct)
+ *   LOCAL_HYPOTHESIS_DISABLED — 设为 'true' 禁用本地模型
+ *   MODEL_CACHE_DIR           — 缓存目录，缺省自动探测
+ */
+class LocalModelService {
+    generator = null;
+    loadAttempted = false;
+    modelId;
+    constructor(modelId) {
+        this.modelId = modelId || process.env.LOCAL_HYPOTHESIS_MODEL || 'Xenova/Qwen2.5-0.5B-Instruct';
+    }
+    get isEnabled() {
+        return process.env.LOCAL_HYPOTHESIS_DISABLED !== 'true';
+    }
+    get isLoaded() {
+        return this.generator !== null;
+    }
+    /**
+     * 生成文本 — 兼容 chatJson 接口格式
+     */
+    async generate(userText, options) {
+        if (!this.isEnabled) {
+            return { error: 'local model disabled by env' };
+        }
+        // 测试环境下跳过实际模型加载
+        if (process.env.VITEST || process.env.NODE_ENV === 'test') {
+            return { error: 'local model disabled in test environment' };
+        }
+        // 懒加载模型
+        if (!this.generator) {
+            if (this.loadAttempted)
+                return { error: 'model previously failed to load' };
+            this.loadAttempted = true;
+            try {
+                (0, Logger_1.log)('INFO', 'local_model_loading', { model: this.modelId });
+                const { pipeline, env } = await import('@xenova/transformers');
+                // 优先使用项目目录下的本地模型
+                const modelsDir = await resolveModelsDir();
+                const localModelPath = (0, path_1.resolve)(modelsDir, this.modelId);
+                const hasLocalFiles = (0, fs_1.existsSync)(localModelPath);
+                if (hasLocalFiles) {
+                    env.localModelPath = modelsDir;
+                    (0, Logger_1.log)('INFO', 'local_model_use_cache', { path: localModelPath });
+                }
+                else {
+                    (0, Logger_1.log)('INFO', 'local_model_no_cache', { path: localModelPath });
+                }
+                this.generator = await pipeline('text-generation', this.modelId, {
+                    cache_dir: process.env.MODEL_CACHE_DIR,
+                });
+                (0, Logger_1.log)('INFO', 'local_model_loaded', { model: this.modelId, local: hasLocalFiles });
+            }
+            catch (err) {
+                (0, Logger_1.log)('WARN', 'local_model_load_failed', { model: this.modelId, error: err.message });
+                this.generator = null;
+                return { error: `local model load failed: ${err.message}` };
+            }
+        }
+        // 构造 prompts
+        const systemMsg = options?.system || '';
+        const chatTemplate = systemMsg
+            ? `<|im_start|>system\n${systemMsg}<|im_end|>\n<|im_start|>user\n${userText}<|im_end|>\n<|im_start|>assistant\n`
+            : `<|im_start|>user\n${userText}<|im_end|>\n<|im_start|>assistant\n`;
+        try {
+            const result = await this.generator(chatTemplate, {
+                max_new_tokens: options?.maxTokens || 768,
+                temperature: options?.temperature ?? 0.7,
+                do_sample: true,
+            });
+            const rawText = Array.isArray(result) ? result[0]?.generated_text : result?.generated_text;
+            if (!rawText)
+                return { error: 'empty generation' };
+            // 去掉输入部分，只取生成的文本
+            const generated = rawText.slice(chatTemplate.length).trim();
+            // 尝试解析 JSON
+            const parsed = this.tryParse(generated);
+            if (parsed) {
+                return { data: parsed };
+            }
+            return { error: `generated non-JSON: ${generated.slice(0, 100)}` };
+        }
+        catch (err) {
+            (0, Logger_1.log)('WARN', 'local_model_generation_error', { error: err.message });
+            return { error: `generation failed: ${err.message}` };
+        }
+    }
+    /**
+     * 尝试从生成文本中提取 JSON
+     */
+    tryParse(text) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            const match = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+            if (match) {
+                try {
+                    return JSON.parse(match[1].trim());
+                }
+                catch {
+                    // ignore
+                }
+            }
+            const arrMatch = text.match(/\[[\s\S]*\]/);
+            if (arrMatch) {
+                try {
+                    return JSON.parse(arrMatch[0]);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        return null;
+    }
+}
+exports.LocalModelService = LocalModelService;
+/** 自动探测项目 models 目录 */
+async function resolveModelsDir() {
+    // Electron 环境
+    try {
+        const { app } = await import('electron');
+        // 优先项目目录（dev），回退到 userData/models（安装版）
+        if ((0, fs_1.existsSync)((0, path_1.resolve)(app.getAppPath(), 'models'))) {
+            return (0, path_1.resolve)(app.getAppPath(), 'models');
+        }
+        return (0, path_1.resolve)(app.getPath('userData'), 'models');
+    }
+    catch {
+        // not in Electron
+    }
+    // Node.js 开发环境：逐级向上找 models/
+    let dir = process.cwd();
+    for (let i = 0; i < 5; i++) {
+        const p = (0, path_1.resolve)(dir, 'models');
+        if ((0, fs_1.existsSync)(p))
+            return p;
+        const parent = (0, path_1.resolve)(dir, '@akemi-mio/main');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // fallback: CWD/models
+    return (0, path_1.resolve)(process.cwd(), 'models');
+}

package/dist/MechanismGraph.d.ts

@@ -0,0 +1,46 @@
+import type { ProposedRelation } from './types';
+/**
+ * Mechanism Graph v0 — traces.jsonl 派生读模型（非独立图存储）。
+ *
+ * 定案 A6：confidence 由边的推断来源映射——identity=verified → high，
+ * inferred → low。聚合键为 (agent, capabilityId, outcome)。
+ * 持久化图后置到 P3 验证有产出之后。
+ */
+export interface TraceEventLike {
+    event_type?: string;
+    outcome?: string;
+    agent?: string;
+    payload?: Record<string, unknown>;
+}
+export interface MechanismEdge {
+    agent: string;
+    capabilityId: string;
+    outcome: string;
+    count: number;
+    /** A6: identity=verified→high / inferred→low */
+    confidence: 'high' | 'low';
+    /** 聚合中出现过的 inference 种类（identity 优先） */
+    inferences: Array<'identity' | 'inferred'>;
+}
+export interface MechanismGraph {
+    edges: MechanismEdge[];
+    /** 参与聚合的事件总数（仅计入含 agent+capabilityId 的 tool_call/task 类事件） */
+    eventCount: number;
+}
+/**
+ * 从 traces.jsonl 行事件聚合机制边。
+ *
+ * 规则：
+ * - 仅计入 payload.capabilityId 存在的事件（能力绑定相关）。
+ * - 每条边键 = `${agent}|${capabilityId}|${outcome}`，count 累加。
+ * - inference：payload.inference === 'identity' 或 event_type 含 identity
+ *   时记 identity；否则记 inferred。
+ * - confidence：边内出现过任一 identity → high，否则 low。
+ */
+export declare function deriveMechanismGraph(events: readonly TraceEventLike[]): MechanismGraph;
+/** 把机制假设的 proposedRelations 投影为与派生图同形状的边（供对照，confidence 走 inference 字段）。 */
+export declare function relationsToEdges(agent: string, relations: readonly ProposedRelation[]): MechanismEdge[];
+/** 是否为机制假设：带非空 proposedRelations 即机制假设，否则普通创意（一个 store 两种粒度）。 */
+export declare function isMechanismHypothesis(h: {
+    proposedRelations?: ProposedRelation[];
+}): boolean;