@memory-river/core 0.2.0

package/dist/cognition/causal-engine.js

@@ -0,0 +1,150 @@
+/**
+ * Causal - 因果突觸判定
+ * memory-lance-v4
+ */
+export class CausalEngine {
+    store;
+    embedder;
+    updateThreshold;
+    causalThreshold;
+    overlapThreshold;
+    embeddingModel;
+    embeddingDim;
+    constructor(store, embedder, config = {}) {
+        this.store = store;
+        this.embedder = embedder;
+        // 儲存 embedding 維度（用於動態調整閾值）
+        this.embeddingDim = config.embeddingDim ?? 1024;
+        // 根據維度動態調整閾值
+        // Qwen3 1024d: 維度較低，向量更緊密，相似度普遍較高 → 需較高閾值
+        // Gemini 3072d: 維度較高，向量更稀疏，相似度普遍較低 → 需較低閾值
+        const isLowDim = this.embeddingDim <= 1280; // 1024d
+        const dimAdjustedUpdateThreshold = isLowDim ? 0.28 : 0.20;
+        const dimAdjustedCausalThreshold = isLowDim ? 0.32 : 0.23;
+        // 從 config 讀取，未提供時使用維度調整後的預設值
+        this.updateThreshold = config.updateThreshold ?? dimAdjustedUpdateThreshold;
+        this.causalThreshold = config.causalThreshold ?? dimAdjustedCausalThreshold;
+        this.overlapThreshold = config.overlapThreshold ?? 0.30;
+        this.embeddingModel = config.embeddingModel ?? "hf.co/Qwen/Qwen3-Embedding-0.6B-GGUF";
+    }
+    /**
+     * 判定新記憶與現有記憶的因果關係
+     * @param category - 新記憶的類別（可選，用於 Category-aware UPDATE 加速）
+     */
+    async determineRelation(text, excludeId, category) {
+        const vector = await this.embedder.embed(text);
+        // 搜尋最相似的記憶 (取前 5 筆就夠了)
+        const results = await this.store.vectorSearch(vector, 5);
+        // 🛡️ 過濾掉自己，以及系統初始化專用的 init_ 記憶
+        const filtered = results.filter(r => {
+            const isSelf = excludeId ? r.entry.id === excludeId : false;
+            const isInit = r.entry.id.startsWith("init_");
+            return !isSelf && !isInit;
+        });
+        if (filtered.length === 0) {
+            return { action: "INDEPENDENT", parentId: null };
+        }
+        const nearest = filtered[0];
+        const distance = nearest.rawDistance;
+        // ⚠️ 使用 configurable threshold（Gemini 3072d 預設值：0.15 / 0.45）
+        if (distance < this.causalThreshold) {
+            // 相似度高，判斷具體關係
+            const action = await this.judgeAction(text, nearest.entry.text, distance, category, nearest.entry.category);
+            return {
+                action,
+                parentId: action === "CAUSAL" || action === "UPDATE" ? nearest.entry.id : null,
+                distance,
+            };
+        }
+        return { action: "INDEPENDENT", parentId: null, distance };
+    }
+    /**
+     * 判斷具體因果關係（使用精準距離判斷 + 字面重疊二次確認 + Category 感知）
+     * ⚠️ threshold 來自 configurable 參數（Qwen3 1024d 預設：0.25 / 0.40）
+     *
+     * 🛡️ 距離漂移保護：當 distance < updateThreshold 時，
+     * 需同時通過字面重疊度檢查（Jaccard >= overlapThreshold）才判定 UPDATE，
+     * 否則降級為 CAUSAL，防止語意蒸餾後的向量飄移導致誤覆寫。
+     *
+     * 🆕 Category 同源加速：相同 category 的記憶，UPDATE 門檻放寬 50%，
+     * 且 distance 極低時即使字面重疊不達標也判定 UPDATE。
+     */
+    async judgeAction(newText, existingText, distance, newCategory, existingCategory) {
+        // 🆕 Category 同源加速：相同 category → UPDATE 門檻放寬 50%
+        const sameCategory = !!(newCategory && existingCategory && newCategory === existingCategory);
+        const effectiveUpdateThreshold = sameCategory
+            ? this.updateThreshold * 1.5
+            : this.updateThreshold;
+        // ⚠️ 第一分支：UPDATE threshold
+        if (distance <= effectiveUpdateThreshold) {
+            // 🛡️ 二次確認：distance 通過還不夠，字面也要有足夠重疊
+            const overlap = this.computeOverlap(newText, existingText);
+            if (overlap >= this.overlapThreshold) {
+                return "UPDATE";
+            }
+            // 🆕 即使字面重疊不夠，同 category 且 distance 極低 → 仍判定 UPDATE
+            if (sameCategory && distance < this.updateThreshold * 0.75) {
+                return "UPDATE";
+            }
+            // 重疊度不足，降級為 CAUSAL（不覆寫，只建立關聯）
+            return "CAUSAL";
+            // ⚠️ 第二分支：CAUSAL threshold
+        }
+        else if (distance <= this.causalThreshold) {
+            return "CAUSAL";
+        }
+        else {
+            return "INDEPENDENT";
+        }
+    }
+    /**
+     * 計算兩段文字的字面重疊度（Jaccard similarity）
+     * - 統一小寫、移除停用詞、比較 word-level set
+     * - lightweight，無需額外依賴
+     */
+    computeOverlap(textA, textB) {
+        const STOP_WORDS = new Set([
+            "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+            "have", "has", "had", "do", "does", "did", "will", "would", "could",
+            "should", "may", "might", "must", "can", "to", "of", "in", "for",
+            "on", "with", "at", "by", "from", "as", "into", "through", "during",
+            "and", "or", "but", "if", "then", "so", "than", "that", "this",
+            "it", "its", "i", "you", "he", "she", "we", "they", "what", "which",
+            "who", "whom", "whose", "where", "when", "why", "how",
+        ]);
+        const normalize = (t) => t.toLowerCase()
+            .replace(/[^\w\s]/g, " ")
+            .split(/\s+/)
+            .filter(w => w.length > 1 && !STOP_WORDS.has(w));
+        const setA = new Set(normalize(textA));
+        const setB = new Set(normalize(textB));
+        if (setA.size === 0 || setB.size === 0)
+            return 0;
+        // Jaccard = |A ∩ B| / |A ∪ B|
+        let intersection = 0;
+        for (const w of setA) {
+            if (setB.has(w))
+                intersection++;
+        }
+        const union = setA.size + setB.size - intersection;
+        return union === 0 ? 0 : intersection / union;
+    }
+    /**
+     * 回傳目前 embedding 模型建議的 threshold 組。
+     * 閾值會根據 embeddingDim 動態調整：
+     * - Qwen3 1024d（低維）：updateThreshold=0.28, causalThreshold=0.32
+     * - Gemini 3072d（高維）：updateThreshold=0.20, causalThreshold=0.23
+     */
+    getRecommendedThresholds() {
+        const isLowDim = this.embeddingDim <= 1280;
+        return {
+            updateThreshold: isLowDim ? 0.28 : 0.20,
+            causalThreshold: isLowDim ? 0.32 : 0.23,
+            overlapThreshold: 0.30,
+            embeddingDim: this.embeddingDim,
+            note: isLowDim
+                ? "Qwen3 1024d optimized (dense vectors, higher similarity)"
+                : "Gemini 3072d optimized (sparse vectors, lower similarity)",
+        };
+    }
+}

package/dist/cognition/conflict-detector.d.ts

@@ -0,0 +1,39 @@
+/**
+ * ConflictDetector — 記憶衝突偵測與主動抑制
+ *
+ * 模擬人類大腦的「主動抑制」(Retrieval-Induced Forgetting)：
+ * 新記憶寫入後，掃描同 category 的高相似記憶，
+ * 用 LLM 判斷是否存在語意衝突，若有則標記舊記憶為 deprecated。
+ *
+ * 只對高衝突風險類別觸發：preference, constraint, identity, decision
+ */
+import { MemoryStore } from '../store/store-v4.js';
+import { StatusManager } from '../store/status-manager.js';
+import { Embedder } from '../providers/embedder-v5.js';
+import type { LlmClient } from '../ports.js';
+export interface ConflictResult {
+    hasConflict: boolean;
+    conflictingIds: string[];
+    resolution: string;
+}
+export declare class ConflictDetector {
+    private store;
+    private embedder;
+    private llm?;
+    private statusManager;
+    private lastJudgeErrorMessage;
+    constructor(store: MemoryStore, embedder: Embedder, llm?: LlmClient | undefined, statusManager?: StatusManager);
+    /**
+     * 在新記憶寫入後呼叫，掃描是否存在衝突記憶
+     */
+    detectAndResolve(newMemoryId: string, newText: string, category: string): Promise<ConflictResult>;
+    /**
+     * LLM 衝突判定：兩段記憶是否在描述同一件事但結論矛盾
+     */
+    private judgeConflict;
+    /**
+     * 主動抑制：標記舊記憶為 deprecated
+     */
+    private suppressMemory;
+    private recordEffectiveness;
+}

package/dist/cognition/conflict-detector.js

@@ -0,0 +1,193 @@
+/**
+ * ConflictDetector — 記憶衝突偵測與主動抑制
+ *
+ * 模擬人類大腦的「主動抑制」(Retrieval-Induced Forgetting)：
+ * 新記憶寫入後，掃描同 category 的高相似記憶，
+ * 用 LLM 判斷是否存在語意衝突，若有則標記舊記憶為 deprecated。
+ *
+ * 只對高衝突風險類別觸發：preference, constraint, identity, decision
+ */
+import { hashQuery } from '../util/util-hash.js';
+// 需要衝突偵測的高風險類別
+const CONFLICT_CATEGORIES = new Set([
+    'preference', 'constraint', 'identity', 'decision'
+]);
+export class ConflictDetector {
+    store;
+    embedder;
+    llm;
+    statusManager;
+    lastJudgeErrorMessage = null;
+    constructor(store, embedder, llm, statusManager = (() => { throw new Error('[ConflictDetector] statusManager is required'); })()) {
+        this.store = store;
+        this.embedder = embedder;
+        this.llm = llm;
+        this.statusManager = statusManager;
+    }
+    /**
+     * 在新記憶寫入後呼叫，掃描是否存在衝突記憶
+     */
+    async detectAndResolve(newMemoryId, newText, category) {
+        const attemptHash = hashQuery(`newMemoryId-${newMemoryId}-${Date.now()}`);
+        // 只對高風險類別觸發
+        if (!CONFLICT_CATEGORIES.has(category)) {
+            this.recordEffectiveness({
+                event: 'conflict_detect_attempted',
+                entityId: newMemoryId,
+                queryHash: attemptHash,
+                outcome: 'category_skipped',
+                metadata: { category },
+            });
+            return { hasConflict: false, conflictingIds: [], resolution: 'skip' };
+        }
+        this.recordEffectiveness({
+            event: 'conflict_detect_attempted',
+            entityId: newMemoryId,
+            queryHash: attemptHash,
+            outcome: 'entered',
+            metadata: { category },
+        });
+        // Step 1: 找同 category 的相似記憶
+        const candidates = await this.store.hybridVectorSearch(newText, 10);
+        const sameCategoryCandidates = candidates.filter(r => {
+            if (r.entry.id === newMemoryId)
+                return false;
+            if (r.entry.id.startsWith('init_'))
+                return false;
+            if (r.entry.category !== category)
+                return false;
+            // 只看 active 狀態的記憶
+            try {
+                const meta = typeof r.entry.metadata === 'string'
+                    ? JSON.parse(r.entry.metadata) : r.entry.metadata;
+                if (meta?.status === 'deprecated')
+                    return false;
+            }
+            catch { }
+            return true;
+        });
+        this.recordEffectiveness({
+            event: 'conflict_candidates_found',
+            entityId: newMemoryId,
+            queryHash: attemptHash,
+            outcome: sameCategoryCandidates.length > 0 ? 'has_candidates' : 'no_candidates',
+            count: sameCategoryCandidates.length,
+            metadata: { category },
+        });
+        if (sameCategoryCandidates.length === 0) {
+            return { hasConflict: false, conflictingIds: [], resolution: 'no_candidates' };
+        }
+        // Step 2: 對前 3 筆用 LLM 做衝突判定
+        const conflictingIds = [];
+        const judgeCandidates = sameCategoryCandidates.slice(0, 3);
+        const judgeStartedAt = Date.now();
+        let judgeErrorMessage = null;
+        for (const candidate of judgeCandidates) {
+            this.lastJudgeErrorMessage = null;
+            const isConflict = await this.judgeConflict(newText, candidate.entry.text, category);
+            if (this.lastJudgeErrorMessage)
+                judgeErrorMessage = this.lastJudgeErrorMessage;
+            if (isConflict) {
+                conflictingIds.push(candidate.entry.id);
+            }
+        }
+        this.recordEffectiveness({
+            event: 'conflict_llm_judged',
+            entityId: newMemoryId,
+            queryHash: attemptHash,
+            outcome: judgeErrorMessage
+                ? 'llm_failed'
+                : conflictingIds.length > 0
+                    ? 'conflict_found'
+                    : 'no_conflict',
+            count: judgeErrorMessage ? 0 : conflictingIds.length,
+            durationMs: Date.now() - judgeStartedAt,
+            metadata: {
+                category,
+                candidateCount: sameCategoryCandidates.length,
+                ...(judgeErrorMessage ? { errorMessage: judgeErrorMessage } : {}),
+            },
+        });
+        if (conflictingIds.length === 0) {
+            return { hasConflict: false, conflictingIds: [], resolution: 'no_conflict' };
+        }
+        // Step 3: 主動抑制 — 標記舊記憶為 deprecated
+        for (const oldId of conflictingIds) {
+            const ok = await this.suppressMemory(oldId, newMemoryId);
+            this.recordEffectiveness({
+                event: 'conflict_resolution_fired',
+                entityId: oldId,
+                relatedId: newMemoryId,
+                queryHash: attemptHash,
+                outcome: ok ? 'ok' : 'failed',
+                metadata: { category, reason: 'conflict_detected' },
+            });
+        }
+        console.log(`[ConflictDetector] Conflict resolution complete: ${conflictingIds.length} previous memories superseded by ${newMemoryId.slice(0, 8)}`);
+        return {
+            hasConflict: true,
+            conflictingIds,
+            resolution: `deprecated ${conflictingIds.length} conflicting memories`,
+        };
+    }
+    /**
+     * LLM 衝突判定：兩段記憶是否在描述同一件事但結論矛盾
+     */
+    async judgeConflict(newText, existingText, category) {
+        const prompt = `你是記憶衝突裁判。判斷以下兩段記憶是否存在「事實衝突」。
+
+衝突 = 兩段記憶描述的是同一個主題/主體，但給出了不同的結論、偏好或指令。
+共存 = 兩段記憶雖然相似，但描述的是不同面向、不同時間點的事實補充，可以同時成立。
+
+記憶 A（舊）：${existingText}
+記憶 B（新）：${newText}
+類別：${category}
+
+只回答一個字：「衝突」或「共存」`;
+        if (!this.llm) {
+            console.warn('[ConflictDetector] LLM provider not configured; skipping conflict evaluation and defaulting to coexistence');
+            return false;
+        }
+        try {
+            const result = await this.llm.generate(prompt, { purpose: 'conflict-detection' });
+            const answer = result.trim();
+            return answer.includes('衝突');
+        }
+        catch (err) {
+            console.warn('[ConflictDetector] LLM evaluation failed; defaulting to coexistence:', err);
+            this.lastJudgeErrorMessage = err instanceof Error ? err.message : String(err);
+            return false; // 判定失敗時保守處理，不誤刪
+        }
+    }
+    /**
+     * 主動抑制：標記舊記憶為 deprecated
+     */
+    async suppressMemory(oldId, newId) {
+        const result = await this.statusManager.changeStatus({
+            memoryId: oldId,
+            toStatus: 'deprecated',
+            reason: 'conflict_detected',
+            source: 'conflict-detector',
+            supersededBy: newId,
+        });
+        if (result.ok) {
+            console.log(`[ConflictDetector] Active suppression: ${oldId.slice(0, 8)} superseded by ${newId.slice(0, 8)}`);
+        }
+        else {
+            console.warn(`[ConflictDetector] Active suppression failed: ${oldId.slice(0, 8)} error=${result.error}`);
+        }
+        return result.ok;
+    }
+    recordEffectiveness(event) {
+        void this.store.recordSubsystemEffectiveness({
+            subsystem: 'conflict',
+            relatedId: '',
+            count: 0,
+            score: 0,
+            durationMs: 0,
+            ...event,
+        }).catch((err) => {
+            console.warn('[conflict-eff]', err?.message ?? err);
+        });
+    }
+}

package/dist/cognition/global-working-memory.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Global Working Memory (GWM) — 全局工作記憶引擎
+ *
+ * 功能：
+ * - 追蹤當前任務主題，計算 embedding drift
+ * - 當用戶對話偏離主題超過 5 輪，inject 工作記憶提醒
+ * - 支援 gwm_on/off/status/update 工具命令
+ */
+import { Embedder } from '../providers/embedder-v5.js';
+export interface GwmState {
+    active: boolean;
+    taskName: string;
+    taskDescription: string;
+    keywords: string[];
+    embedding: number[];
+    driftRoundCount: number;
+    createdAt: number;
+}
+export interface DriftResult {
+    isDrifting: boolean;
+    similarity: number;
+}
+export declare class GlobalWorkingMemory {
+    private readonly stateFile;
+    private lastDriftText;
+    private lastDriftVector;
+    private embedder;
+    private state;
+    private pendingInject;
+    private driftThreshold;
+    constructor(embedder: Embedder, stateFile: string, driftThreshold?: number);
+    private save;
+    load(): Promise<GwmState | null>;
+    gwmOn(taskName: string, taskDescription: string, keywords?: string[]): Promise<string>;
+    gwmOff(): Promise<string>;
+    gwmStatus(): string;
+    gwmUpdate(updates: {
+        taskName?: string;
+        taskDescription?: string;
+        keywords?: string[];
+    }): Promise<string>;
+    detectDrift(userMessages: {
+        role: string;
+        content: string | any[];
+    }[]): Promise<DriftResult>;
+    shouldInject(): boolean;
+    markInjected(): Promise<void>;
+    requestInject(): void;
+    getReminderMessage(): string;
+    isActive(): boolean;
+    getState(): GwmState | null;
+}
+export default GlobalWorkingMemory;

package/dist/cognition/global-working-memory.js

@@ -0,0 +1,211 @@
+/**
+ * Global Working Memory (GWM) — 全局工作記憶引擎
+ *
+ * 功能：
+ * - 追蹤當前任務主題，計算 embedding drift
+ * - 當用戶對話偏離主題超過 5 輪，inject 工作記憶提醒
+ * - 支援 gwm_on/off/status/update 工具命令
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+// ─── Cosine Similarity ──────────────────────────────────────────────────────
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length || a.length === 0)
+        return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const d = Math.sqrt(normA) * Math.sqrt(normB);
+    return d === 0 ? 0 : dotProduct / d;
+}
+// ─── Keyword Extractor ───────────────────────────────────────────────────────
+function extractKeywords(text) {
+    const stopwords = new Set([
+        '的', '了', '是', '在', '我', '有', '和', '就', '不', '人', '都', '一', '一個', '上', '也', '很', '到', '說', '要', '去', '你',
+        '會', '著', '沒有', '看', '好', '自己', '這', '什麼', '還', '這個', '那個', '然後', '如果', '所以', '但是', '可以', '因為',
+        'the', 'a', 'an', 'is', 'are', 'was', 'were', 'of', 'in', 'to', 'for', 'with', 'on', 'at', 'by', 'from', 'as', 'or', 'and',
+        'it', 'that', 'this', 'i', 'you', 'we', 'they', 'he', 'she', 'my', 'your', 'our', 'their',
+    ]);
+    const raw = text
+        .split(/[\s,，、。.!！?？:：;；""''（）\(\)\[\]]+/)
+        .filter((w) => w.length > 1 && !stopwords.has(w.toLowerCase()));
+    // 去重
+    return Array.from(new Set(raw)).slice(0, 5);
+}
+// ─── GlobalWorkingMemory ────────────────────────────────────────────────────
+export class GlobalWorkingMemory {
+    stateFile;
+    lastDriftText = "";
+    lastDriftVector = null;
+    embedder;
+    state = null;
+    pendingInject = false; // injectOnce flag
+    driftThreshold;
+    constructor(embedder, stateFile, driftThreshold = 0.65) {
+        this.stateFile = stateFile;
+        this.embedder = embedder;
+        this.driftThreshold = driftThreshold;
+    }
+    // ── State I/O ──────────────────────────────────────────────────────────────
+    async save() {
+        if (!this.state)
+            return;
+        const dir = path.dirname(this.stateFile);
+        await fs.promises.mkdir(dir, { recursive: true });
+        await fs.promises.writeFile(this.stateFile, JSON.stringify(this.state, null, 2), 'utf-8');
+    }
+    async load() {
+        try {
+            const data = await fs.promises.readFile(this.stateFile, 'utf-8');
+            this.state = JSON.parse(data);
+            return this.state;
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── GWM Tools ──────────────────────────────────────────────────────────────
+    async gwmOn(taskName, taskDescription, keywords) {
+        const kw = keywords && keywords.length > 0
+            ? keywords
+            : extractKeywords(taskDescription);
+        const embedding = await this.embedder.embed(taskDescription, 'store');
+        this.state = {
+            active: true,
+            taskName,
+            taskDescription,
+            keywords: kw,
+            embedding,
+            driftRoundCount: 0,
+            createdAt: Date.now(),
+        };
+        await this.save();
+        return `[✅ GWM 啟動] 任務：${taskName}，關鍵字：${kw.join(', ')}`;
+    }
+    async gwmOff() {
+        this.state = null;
+        this.pendingInject = false;
+        try {
+            await fs.promises.unlink(this.stateFile);
+        }
+        catch { /* file may not exist */ }
+        return '[✅ GWM 已關閉]';
+    }
+    gwmStatus() {
+        if (!this.state || !this.state.active) {
+            return '[📋 GWM 狀態] 目前未啟動';
+        }
+        return [
+            '[📋 GWM 狀態]',
+            `任務：${this.state.taskName}`,
+            `描述：${this.state.taskDescription}`,
+            `關鍵字：${this.state.keywords.join(', ')}`,
+            `Drift 輪數：${this.state.driftRoundCount}/5`,
+            `啟動時間：${new Date(this.state.createdAt).toLocaleString('zh-TW')}`,
+        ].join('\n');
+    }
+    async gwmUpdate(updates) {
+        if (!this.state)
+            return '[❌ GWM 未啟動]';
+        if (updates.taskName)
+            this.state.taskName = updates.taskName;
+        if (updates.taskDescription) {
+            this.state.taskDescription = updates.taskDescription;
+            // re-embed if description changed
+            this.state.embedding = await this.embedder.embed(updates.taskDescription, 'store');
+        }
+        if (updates.keywords)
+            this.state.keywords = updates.keywords;
+        await this.save();
+        return '[✅ GWM 已更新]';
+    }
+    // ── Drift Detection ────────────────────────────────────────────────────────
+    async detectDrift(userMessages) {
+        if (!this.state || !this.state.active) {
+            return { isDrifting: false, similarity: 1 };
+        }
+        // 取出最近 1 筆 user message
+        let lastUserText = '';
+        for (let i = userMessages.length - 1; i >= 0; i--) {
+            const m = userMessages[i];
+            if (m.role === 'user') {
+                if (typeof m.content === 'string') {
+                    lastUserText = m.content;
+                }
+                else if (Array.isArray(m.content)) {
+                    lastUserText = m.content.map((c) => c.type === 'text' ? c.text : '').join(' ');
+                }
+                break;
+            }
+        }
+        if (!lastUserText)
+            return { isDrifting: false, similarity: 1 };
+        // 🛡️ 短句保護：< 10 字的回覆（如「好」「繼續」）不計入 drift
+        if (lastUserText.trim().length < 10) {
+            return { isDrifting: this.state.driftRoundCount >= 2, similarity: 1 };
+        }
+        // 🛠️ Embedding 快取：同一句話不重複呼叫 Ollama
+        let msgEmbedding;
+        if (lastUserText === this.lastDriftText && this.lastDriftVector) {
+            msgEmbedding = this.lastDriftVector;
+        }
+        else {
+            msgEmbedding = await this.embedder.embed(lastUserText, 'store');
+            this.lastDriftText = lastUserText;
+            this.lastDriftVector = msgEmbedding;
+        }
+        const similarity = cosineSimilarity(msgEmbedding, this.state.embedding);
+        if (similarity < this.driftThreshold) {
+            this.state.driftRoundCount += 1;
+        }
+        else {
+            this.state.driftRoundCount = Math.max(0, this.state.driftRoundCount - 1); // 慢慢恢復，不直接歸零
+        }
+        await this.save();
+        const isDrifting = this.state.driftRoundCount >= 2; // 2 輪就觸發（原本 5 輪太晚）
+        if (isDrifting) {
+            this.requestInject();
+        }
+        return { isDrifting, similarity };
+    }
+    // ── Check & consume inject (injectOnce 模式) ──────────────────────────────
+    shouldInject() {
+        return this.pendingInject && this.state?.active === true;
+    }
+    async markInjected() {
+        this.pendingInject = false;
+        if (this.state) {
+            // 不歸零，只減 1 — 持續施壓，如果下一輪還是漂移就會立刻再次提醒
+            this.state.driftRoundCount = Math.max(0, this.state.driftRoundCount - 1);
+            await this.save();
+        }
+    }
+    requestInject() {
+        this.pendingInject = true;
+    }
+    // ── Reminder Message ───────────────────────────────────────────────────────
+    getReminderMessage() {
+        if (!this.state)
+            return '';
+        return [
+            `⚠️【重要指令】你的當前任務是「${this.state.taskName}」。`,
+            `任務描述：${this.state.taskDescription}`,
+            `關鍵字：${this.state.keywords.join(', ')}`,
+            ``,
+            `❗ 如果你現在做的事情與上述任務無關，請立即停下並回到主線。`,
+            `如果你認為當前工作是完成任務的必要步驟，請在回覆中明確說明關聯性。`,
+        ].join('\n');
+    }
+    isActive() {
+        return this.state?.active === true;
+    }
+    getState() {
+        return this.state;
+    }
+}
+export default GlobalWorkingMemory;