@memory-river/core 0.2.0

package/dist/api.d.ts

@@ -0,0 +1,100 @@
+import { type StorageMode } from './storage.js';
+import type { EmbeddingProvider, LlmClient, Logger, Notifier, SessionFileAccess } from './ports.js';
+import { type TranscriptEntry } from './transcript/rehydrate.js';
+import { type ArchiveSnapshotResult } from './transcript/transcript-archive.js';
+import { type ContextMessage, type EnumerationPlan, type MemoryEntry, type MemorySearchResult, type PluginConfig, type SkillCapsuleV2, type SkillDef, type SkillIndexEntry, type StatusChangeRequest, type StatusChangeResult } from './types.js';
+export type { EnumerationPlan } from './types.js';
+export interface MemoryRiverConfig {
+    dataDir: string;
+    ramDir: string;
+    storageMode?: StorageMode;
+    embedding?: Partial<PluginConfig['embedding']>;
+    retrieval?: PluginConfig['retrieval'];
+    cleanup?: PluginConfig['cleanup'];
+    cleanupEngine?: PluginConfig['cleanupEngine'];
+    autoRecall?: boolean;
+    driftThreshold?: number;
+    health?: PluginConfig['health'];
+    hooks?: PluginConfig['hooks'];
+    causalEngine?: PluginConfig['causalEngine'];
+    concentration?: PluginConfig['concentration'];
+}
+export interface MemoryRiverDeps {
+    embedder: EmbeddingProvider;
+    llm?: LlmClient;
+    logger?: Logger;
+    notifier?: Notifier;
+    sessionFiles?: SessionFileAccess;
+}
+export interface SessionHint {
+    sessionKey?: string;
+    sessionId?: string;
+}
+export interface AssembleContextOptions {
+    onAutoRecallResults?(event: {
+        query: string;
+        results: MemorySearchResult[];
+    }): void;
+}
+export type RehydrateRequest = {
+    mode: 'entry_ids';
+    sessionKey: string;
+    entryIds: number[];
+    bleed?: number;
+    limit?: number;
+} | {
+    mode: 'time_range';
+    sessionKey: string;
+    timestamp: string;
+    windowMinutes?: number;
+    limit?: number;
+} | {
+    mode: 'keyword';
+    keyword: string;
+    sessionKey?: string;
+    limit?: number;
+    offset?: number;
+};
+export type MemoryUpdate = Partial<Pick<MemoryEntry, 'text' | 'category' | 'importance' | 'metadata'>>;
+export interface MemoryRiver {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    remember(text: string, opts?: {
+        category?: string;
+        importance?: number;
+        metadata?: object;
+    }): Promise<void>;
+    updateMemory(id: string, updates: MemoryUpdate): Promise<boolean>;
+    setMemoryStatus(req: StatusChangeRequest): Promise<StatusChangeResult>;
+    recall(query: string, limit?: number): Promise<MemorySearchResult[]>;
+    enumerate(plan: EnumerationPlan, limit?: number): Promise<MemorySearchResult[]>;
+    searchMemory(query: string, limit?: number): Promise<MemorySearchResult[]>;
+    skills: {
+        save(def: SkillDef): Promise<{
+            id: string;
+        }>;
+        search(query: string, limit?: number): Promise<SkillIndexEntry[]>;
+        load(name: string): Promise<SkillCapsuleV2 | null>;
+        list(): Promise<SkillIndexEntry[]>;
+    };
+    rehydrate(req: RehydrateRequest): Promise<TranscriptEntry[]>;
+    assembleContext(messages: ContextMessage[], session?: SessionHint, options?: AssembleContextOptions): Promise<{
+        messages: ContextMessage[];
+    }>;
+    archiveTranscript(session: SessionHint, messages: ContextMessage[]): Promise<ArchiveSnapshotResult>;
+    compactSessionFile(session: SessionHint, opts?: object): Promise<{
+        ok: boolean;
+        compacted: boolean;
+    }>;
+    gwm: {
+        on(name: string, desc: string, kw?: string[]): Promise<string>;
+        off(): Promise<string>;
+        status(): string;
+        update(update: object): Promise<string>;
+    };
+    maintenance: {
+        runCleanup(): Promise<object>;
+        runNightConsolidation(): Promise<object>;
+    };
+}
+export declare function createMemoryRiver(config: MemoryRiverConfig, deps: MemoryRiverDeps): MemoryRiver;

package/dist/api.js

@@ -0,0 +1,156 @@
+import { resolvePaths } from './paths.js';
+import { resolveRamDbPath } from './storage.js';
+import { MemoryRiverEngine } from './engine.js';
+import { rehydrate as rehydrateByIds, rehydrateByTime } from './transcript/rehydrate.js';
+import { rehydrateByKeyword } from './transcript/rehydrate-keyword.js';
+import { createTranscriptArchive } from './transcript/transcript-archive.js';
+import { DEFAULT_CONFIG, } from './types.js';
+const consoleLogger = {
+    info: (msg, meta) => meta === undefined ? console.info(msg) : console.info(msg, meta),
+    warn: (msg, meta) => meta === undefined ? console.warn(msg) : console.warn(msg, meta),
+    error: (msg, meta) => meta === undefined ? console.error(msg) : console.error(msg, meta),
+};
+const noopNotifier = { async notify() { } };
+function mergeConfig(config, dimensions) {
+    const paths = resolvePaths(config);
+    const storage = resolveRamDbPath({
+        dbPath: paths.dbDir,
+        ramDbPath: paths.ramDbDir,
+        storageMode: config.storageMode,
+    });
+    return {
+        ...DEFAULT_CONFIG,
+        ...config,
+        embedding: { ...DEFAULT_CONFIG.embedding, ...config.embedding, dimensions },
+        retrieval: { ...DEFAULT_CONFIG.retrieval, ...config.retrieval },
+        cleanup: { ...DEFAULT_CONFIG.cleanup, ...config.cleanup },
+        cleanupEngine: { ...DEFAULT_CONFIG.cleanupEngine, ...config.cleanupEngine },
+        health: { ...DEFAULT_CONFIG.health, ...config.health },
+        hooks: { ...DEFAULT_CONFIG.hooks, ...config.hooks },
+        causalEngine: { ...DEFAULT_CONFIG.causalEngine, ...config.causalEngine },
+        concentration: { ...DEFAULT_CONFIG.concentration, ...config.concentration },
+        dbPath: paths.dbDir,
+        ramDbPath: storage.ramDbPath,
+        storageMode: config.storageMode ?? 'auto',
+        inboxPath: paths.inboxDir,
+    };
+}
+function textFromToolResult(result) {
+    return result?.content?.find?.((part) => part?.type === 'text')?.text ?? '';
+}
+export function createMemoryRiver(config, deps) {
+    const paths = resolvePaths(config);
+    const transcriptArchive = createTranscriptArchive(paths.transcriptsDir);
+    const sessionFiles = deps.sessionFiles ?? null;
+    const engineDeps = {
+        paths,
+        transcriptArchive,
+        embedder: deps.embedder,
+        llm: deps.llm,
+        logger: deps.logger ?? consoleLogger,
+        notifier: deps.notifier ?? noopNotifier,
+        deriveSessionFile: identity => sessionFiles?.resolveSessionFile(identity) ?? null,
+        ollamaUrl: '',
+        geminiApiKey: '',
+        deepseekApiKey: '',
+    };
+    const engineConfig = mergeConfig(config, deps.embedder.getDimensions());
+    const engine = new MemoryRiverEngine(engineConfig, engineDeps);
+    engine.configure(engineConfig, engineDeps);
+    return {
+        async start() {
+            engine.start();
+            await engine.init();
+        },
+        async stop() {
+            await engine.stop();
+        },
+        async remember(text, opts) {
+            await engine.remember(text, opts);
+        },
+        updateMemory(id, updates) {
+            return engine.updateMemory(id, updates);
+        },
+        setMemoryStatus(req) {
+            return engine.setMemoryStatus(req);
+        },
+        recall(query, limit) {
+            return engine.recall(query, limit);
+        },
+        enumerate(plan, limit) {
+            return engine.enumerate(plan, limit);
+        },
+        searchMemory(query, limit) {
+            return engine.searchMemory(query, limit);
+        },
+        skills: {
+            save(def) {
+                return engine.saveSkill(def);
+            },
+            search(query, limit) {
+                return engine.searchSkills(query, limit);
+            },
+            load(name) {
+                return engine.loadSkill(name);
+            },
+            list() {
+                return engine.listSkills();
+            },
+        },
+        async rehydrate(req) {
+            if (req.mode === 'entry_ids') {
+                return (await rehydrateByIds(transcriptArchive.getTranscriptPath(req.sessionKey), req.entryIds, req.bleed)).slice(0, req.limit);
+            }
+            if (req.mode === 'time_range') {
+                return (await rehydrateByTime(transcriptArchive.getTranscriptPath(req.sessionKey), req.timestamp, req.windowMinutes)).slice(0, req.limit);
+            }
+            return rehydrateByKeyword(paths.transcriptsDir, req.keyword, {
+                sessionKey: req.sessionKey,
+                limit: req.limit,
+                offset: req.offset,
+            });
+        },
+        assembleContext(messages, session, options) {
+            return engine.assemble({ messages, ...session, ...options });
+        },
+        async archiveTranscript(session, messages) {
+            return await engine.archiveTranscript(session, messages);
+        },
+        async compactSessionFile(session, opts = {}) {
+            const sessionFile = sessionFiles?.resolveSessionFile(session) ?? null;
+            if (!sessionFile)
+                return { ok: true, compacted: false };
+            return engine.compact({ ...session, ...opts, sessionFile });
+        },
+        gwm: {
+            async on(name, desc, kw) {
+                return textFromToolResult(await engine.executeGwmOn({
+                    taskName: name,
+                    taskDescription: desc,
+                    keywords: kw,
+                }));
+            },
+            async off() {
+                return textFromToolResult(await engine.executeGwmOff());
+            },
+            status() {
+                return textFromToolResult(engine.executeGwmStatus());
+            },
+            async update(update) {
+                return textFromToolResult(await engine.executeGwmUpdate(update));
+            },
+        },
+        maintenance: {
+            async runCleanup() {
+                await engine.init();
+                await engine.runCleanupEngineNow('session-end');
+                return { ok: true };
+            },
+            async runNightConsolidation() {
+                await engine.init();
+                await engine.runNightConsolidatorNow();
+                return { ok: true };
+            },
+        },
+    };
+}

package/dist/cognition/causal-attribution.d.ts

@@ -0,0 +1,36 @@
+import type { SubsystemEffectivenessEvent } from '../types.js';
+export interface InjectedMemory {
+    memoryId: string;
+    snippet: string;
+    source: 'autoRecall' | 'gwm_keyword' | 'manual_recall';
+    injectedAt: number;
+    viaHook?: boolean;
+    hookKeyword?: string;
+}
+export interface AttributionResult {
+    memoryId: string;
+    outcome: 'used' | 'partial' | 'unused';
+    score: number;
+    method: 'ngram' | 'embedding' | 'skipped' | 'ngram_fallback';
+    injectedSnippet: string;
+    outputSnippet: string;
+    fallbackReason?: string;
+}
+export interface SubsystemReporter {
+    recordEvent(event: Partial<SubsystemEffectivenessEvent>): Promise<void> | void;
+}
+export interface EmbeddingProvider {
+    embed(text: string, mode?: 'store' | 'query'): Promise<number[]>;
+}
+export declare class CausalAttributionEngine {
+    private subsystemReporter;
+    private embedder?;
+    constructor(subsystemReporter: SubsystemReporter, embedder?: EmbeddingProvider | undefined);
+    attributeMemoriesAsync(injected: InjectedMemory[], outputText: string, requestId: string): void;
+    private attributeMemories;
+    private scoreOne;
+    private ngramOverlap;
+    private cosineSim;
+    private classifyByEmbedding;
+    private findOutputSnippet;
+}

package/dist/cognition/causal-attribution.js

@@ -0,0 +1,239 @@
+const NGRAM_USED_THRESHOLD = 0.50;
+const EMBEDDING_USED_THRESHOLD = 0.75;
+const EMBEDDING_PARTIAL_THRESHOLD = 0.55;
+const MIN_OUTPUT_LEN = 50;
+function truncateText(text, max) {
+    return text.length <= max ? text : text.slice(0, max);
+}
+function normalizeForNgram(text) {
+    return text
+        .toLowerCase()
+        .replace(/\s+/g, '')
+        .replace(/[，。！？、；：,.!?;:"'`~()[\]{}<>《》「」『』【】]/g, '');
+}
+function makeNgrams(text, size) {
+    if (text.length < size)
+        return [];
+    const grams = [];
+    for (let i = 0; i <= text.length - size; i++) {
+        grams.push(text.slice(i, i + size));
+    }
+    return grams;
+}
+function cosine(a, b) {
+    const len = Math.min(a.length, b.length);
+    if (len === 0)
+        return 0;
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < len; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    if (normA === 0 || normB === 0)
+        return 0;
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+export class CausalAttributionEngine {
+    subsystemReporter;
+    embedder;
+    constructor(subsystemReporter, embedder) {
+        this.subsystemReporter = subsystemReporter;
+        this.embedder = embedder;
+        if (!embedder) {
+            console.warn('[causal-attribution] embedder not provided, ' +
+                'embedding fallback disabled — only ngram >= USED_THRESHOLD ' +
+                'will mark used, all others will be unused');
+        }
+    }
+    attributeMemoriesAsync(injected, outputText, requestId) {
+        setImmediate(() => {
+            void this.attributeMemories(injected, outputText, requestId).catch((err) => {
+                console.error('[causal-attribution] failed', err);
+            });
+        });
+    }
+    async attributeMemories(injected, outputText, requestId) {
+        if (!injected || injected.length === 0)
+            return;
+        if (!outputText || outputText.length < MIN_OUTPUT_LEN) {
+            for (const mem of injected) {
+                try {
+                    await this.subsystemReporter.recordEvent({
+                        subsystem: 'causal',
+                        event: 'memory_attributed',
+                        outcome: 'skipped',
+                        entityId: mem.memoryId,
+                        relatedId: mem.memoryId,
+                        score: 0,
+                        count: 1,
+                        durationMs: 0,
+                        metadata: {
+                            method: 'skipped',
+                            source: mem.source,
+                            requestId,
+                            reason: 'output_too_short',
+                            outputLen: outputText?.length ?? 0,
+                            viaHook: mem.viaHook ?? false,
+                            hookKeyword: mem.hookKeyword ?? null,
+                        },
+                    });
+                }
+                catch (err) {
+                    console.error('[causal-attribution] short-output skip write failed', {
+                        memoryId: mem.memoryId,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            return;
+        }
+        for (const mem of injected) {
+            try {
+                const result = await this.scoreOne(mem, outputText);
+                await this.subsystemReporter.recordEvent({
+                    subsystem: 'causal',
+                    event: 'memory_attributed',
+                    outcome: result.outcome,
+                    entityId: mem.memoryId,
+                    relatedId: mem.memoryId,
+                    score: result.score,
+                    count: 1,
+                    durationMs: 0,
+                    metadata: {
+                        method: result.method,
+                        source: mem.source,
+                        requestId,
+                        injectedSnippet: result.injectedSnippet,
+                        outputSnippet: result.outputSnippet,
+                        outputLen: outputText.length,
+                        fallbackReason: result.fallbackReason,
+                        viaHook: mem.viaHook ?? false,
+                        hookKeyword: mem.hookKeyword ?? null,
+                    },
+                });
+            }
+            catch (err) {
+                console.error('[causal-attribution] memory attribution failed', {
+                    memoryId: mem.memoryId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
+    async scoreOne(mem, outputText) {
+        const injectedSnippet = truncateText(mem.snippet, 80);
+        if (outputText.length < MIN_OUTPUT_LEN) {
+            return {
+                memoryId: mem.memoryId,
+                outcome: 'unused',
+                score: 0,
+                method: 'ngram',
+                injectedSnippet,
+                outputSnippet: '',
+            };
+        }
+        const ngramScore = this.ngramOverlap(mem.snippet, outputText);
+        if (ngramScore >= NGRAM_USED_THRESHOLD) {
+            return {
+                memoryId: mem.memoryId,
+                outcome: 'used',
+                score: ngramScore,
+                method: 'ngram',
+                injectedSnippet,
+                outputSnippet: this.findOutputSnippet(mem.snippet, outputText),
+            };
+        }
+        if (!this.embedder) {
+            return {
+                memoryId: mem.memoryId,
+                outcome: 'unused',
+                score: ngramScore,
+                method: 'ngram',
+                injectedSnippet,
+                outputSnippet: '',
+            };
+        }
+        try {
+            const embeddingScore = await this.cosineSim(mem.snippet, outputText);
+            return {
+                memoryId: mem.memoryId,
+                outcome: this.classifyByEmbedding(embeddingScore),
+                score: embeddingScore,
+                method: 'embedding',
+                injectedSnippet,
+                outputSnippet: embeddingScore >= EMBEDDING_PARTIAL_THRESHOLD
+                    ? truncateText(outputText, 80)
+                    : '',
+            };
+        }
+        catch (err) {
+            console.error('[causal-attribution] embedding fallback failed', {
+                memoryId: mem.memoryId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            const fallbackReason = err instanceof Error ? err.message : String(err);
+            return {
+                memoryId: mem.memoryId,
+                outcome: 'unused',
+                score: ngramScore,
+                method: 'ngram_fallback',
+                injectedSnippet,
+                outputSnippet: '',
+                fallbackReason,
+            };
+        }
+    }
+    ngramOverlap(a, b) {
+        const inj = normalizeForNgram(a);
+        const out = normalizeForNgram(b);
+        const injectedNgrams = new Set([
+            ...makeNgrams(inj, 2),
+            ...makeNgrams(inj, 3),
+            ...makeNgrams(inj, 4),
+        ]);
+        if (injectedNgrams.size === 0)
+            return 0;
+        const outputNgrams = new Set([
+            ...makeNgrams(out, 2),
+            ...makeNgrams(out, 3),
+            ...makeNgrams(out, 4),
+        ]);
+        let overlap = 0;
+        for (const gram of injectedNgrams) {
+            if (outputNgrams.has(gram))
+                overlap++;
+        }
+        return overlap / injectedNgrams.size;
+    }
+    async cosineSim(a, b) {
+        const injected = truncateText(a, 200);
+        const output = truncateText(b, 500);
+        const [aVec, bVec] = await Promise.all([
+            this.embedder.embed(injected, 'query'),
+            this.embedder.embed(output, 'query'),
+        ]);
+        return cosine(aVec, bVec);
+    }
+    classifyByEmbedding(score) {
+        if (score >= EMBEDDING_USED_THRESHOLD)
+            return 'used';
+        if (score >= EMBEDDING_PARTIAL_THRESHOLD)
+            return 'partial';
+        return 'unused';
+    }
+    findOutputSnippet(injected, output) {
+        const inj = normalizeForNgram(injected);
+        const out = normalizeForNgram(output);
+        const grams = [...makeNgrams(inj, 4), ...makeNgrams(inj, 3), ...makeNgrams(inj, 2)];
+        const hit = grams.find(gram => out.includes(gram));
+        if (!hit)
+            return '';
+        const rawIndex = output.toLowerCase().indexOf(hit.slice(0, Math.min(4, hit.length)));
+        if (rawIndex < 0)
+            return truncateText(output, 80);
+        return truncateText(output.slice(Math.max(0, rawIndex - 20), rawIndex + 60), 80);
+    }
+}

package/dist/cognition/causal-engine.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Causal - 因果突觸判定
+ * memory-lance-v4
+ */
+import { MemoryStore } from "../store/store-v4.js";
+import { Embedder } from "../providers/embedder-v5.js";
+export type CausalAction = "UPDATE" | "CAUSAL" | "INDEPENDENT";
+export interface CausalResult {
+    action: CausalAction;
+    parentId: string | null;
+    distance?: number;
+}
+/**
+ * ⚠️ 此參數為 Qwen3 1024d 向量空間優化（2026-04 實測預設值）。
+ * 更換 embedding 模型（如 OpenAI 1536d、Gemini 3072d）需自行重新校準。
+ * 建議值：先用目前設定跑 50 筆 query 觀察 distance 分布，再調參。
+ *
+ * @example
+ * // Qwen3 1024d（預設，Ollama 本地部署）
+ * causalEngine: { updateThreshold: 0.25, causalThreshold: 0.40, embeddingModel: "hf.co/Qwen/Qwen3-Embedding-0.6B-GGUF" }
+ *
+ * // Gemini 3072d（參考範圍，需重新觀察）
+ * causalEngine: { updateThreshold: 0.15, causalThreshold: 0.45, embeddingModel: "gemini-embedding-exp-0325" }
+ */
+export interface CausalEngineConfig {
+    /**
+     * 標記目前使用的 embedding 模型維度。
+     * Qwen3 1024d: 向量更緊密，相似度普遍較高，需較高閾值
+     * Gemini 3072d: 向量更稀疏，相似度普遍較低，需較低閾值
+     * 預設值：1024
+     */
+    embeddingDim?: number;
+    /**
+     * ⚠️ Qwen3 1024d 向量空間優化參數（維度調整後預設值）。
+     * UPDATE threshold：低於此值視為同一記憶的更新（覆寫）。
+     * 預設值：0.25
+     */
+    updateThreshold?: number;
+    /**
+     * ⚠️ Qwen3 1024d 向量空間優化參數（維度調整後預設值）。
+     * CAUSAL threshold：低於此值視為因果關聯（建立 parentId 鏈）。
+     * 預設值：0.40
+     */
+    causalThreshold?: number;
+    /**
+     * ⚠️ Qwen3 1024d 向量空間優化參數。
+     * UPDATE 的字面重疊閾值（用於防止 distance 漂移誤判）。
+     * 當 distance < updateThreshold 時，需同時滿足字面重疊度 >= 此值，才判定 UPDATE。
+     * 預設值：0.30（Jaccard overlap，0=完全無重疊，1=完全相同）
+     * ⚠️ 設太高會讓 UPDATE 幾乎失效，建議 0.25~0.35。
+     */
+    overlapThreshold?: number;
+    /**
+     * ⚠️ 標記目前使用的 embedding 模型。
+     * 更換模型後強烈建議重新校準 updateThreshold / causalThreshold。
+     * 預設值："hf.co/Qwen/Qwen3-Embedding-0.6B-GGUF"（Ollama 本地部署 Qwen3 1024d）
+     */
+    embeddingModel?: string;
+}
+export declare class CausalEngine {
+    private store;
+    private embedder;
+    private readonly updateThreshold;
+    private readonly causalThreshold;
+    private readonly overlapThreshold;
+    private readonly embeddingModel;
+    private readonly embeddingDim;
+    constructor(store: MemoryStore, embedder: Embedder, config?: CausalEngineConfig);
+    /**
+     * 判定新記憶與現有記憶的因果關係
+     * @param category - 新記憶的類別（可選，用於 Category-aware UPDATE 加速）
+     */
+    determineRelation(text: string, excludeId?: string, category?: string): Promise<CausalResult>;
+    /**
+     * 判斷具體因果關係（使用精準距離判斷 + 字面重疊二次確認 + Category 感知）
+     * ⚠️ threshold 來自 configurable 參數（Qwen3 1024d 預設：0.25 / 0.40）
+     *
+     * 🛡️ 距離漂移保護：當 distance < updateThreshold 時，
+     * 需同時通過字面重疊度檢查（Jaccard >= overlapThreshold）才判定 UPDATE，
+     * 否則降級為 CAUSAL，防止語意蒸餾後的向量飄移導致誤覆寫。
+     *
+     * 🆕 Category 同源加速：相同 category 的記憶，UPDATE 門檻放寬 50%，
+     * 且 distance 極低時即使字面重疊不達標也判定 UPDATE。
+     */
+    private judgeAction;
+    /**
+     * 計算兩段文字的字面重疊度（Jaccard similarity）
+     * - 統一小寫、移除停用詞、比較 word-level set
+     * - lightweight，無需額外依賴
+     */
+    private computeOverlap;
+    /**
+     * 回傳目前 embedding 模型建議的 threshold 組。
+     * 閾值會根據 embeddingDim 動態調整：
+     * - Qwen3 1024d（低維）：updateThreshold=0.28, causalThreshold=0.32
+     * - Gemini 3072d（高維）：updateThreshold=0.20, causalThreshold=0.23
+     */
+    getRecommendedThresholds(): {
+        updateThreshold: number;
+        causalThreshold: number;
+        overlapThreshold: number;
+        embeddingDim: number;
+        note: string;
+    };
+}