@memory-river/core 0.2.0 → 0.2.3

package/dist/distill/concentrator-adapter.d.ts

@@ -7,6 +7,7 @@
  * 3. 雙軌並行提煉：短期前情提要 (大膠囊, health: 30) + 長期精確記憶 (小紙條)
  * 4. 完美回注與幽靈清理：注入 Context 頂端，並自動拔除斷片的 Tool Result
  */
+import { type ChildProcess } from 'node:child_process';
 import { ContextMessage } from '../types.js';
 import type { RawTranscriptEntry, TranscriptArchive } from '../transcript/transcript-archive.js';
 import type { SessionIdentity } from '../util/session-identity.js';
@@ -87,7 +88,23 @@ export declare function findProbeTextMismatchDetail(summarizePairs: ComparableTr
 export declare function logProbeTextMismatchDetail(detail: ProbeTextMismatchDetail): void;
 export declare function buildDualTrackPrompt(conversationLog: string, capsuleLanguage?: string): string;
 export declare function buildGeneralConversationPrompt(conversationLog: string, capsuleLanguage?: string): string;
+export declare function buildImportanceScoringPrompt(noteTexts: string[]): string;
 export declare function buildSimplePrompt(conversationLog: string, capsuleLanguage?: string): string;
+export type CodexReasoningEffort = 'none' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+export interface CodexCliConfig {
+    model: string;
+    reasoningEffort: CodexReasoningEffort;
+    workdir: string;
+    timeoutMs: number;
+}
+type ExecFileCallback = (error: NodeJS.ErrnoException | null, stdout: string | Buffer, stderr: string | Buffer) => void;
+type ExecFileInvoker = (file: string, args: string[], options: {
+    cwd: string;
+    timeout: number;
+}, callback: ExecFileCallback) => Pick<ChildProcess, 'kill' | 'stdin'> | undefined;
+export declare function buildCodexExecArgs(prompt: string, config: CodexCliConfig): string[];
+export declare function parseCodexOutput(stdout: string): unknown;
+export declare function runCodexCli(prompt: string, config: CodexCliConfig, execFileImpl?: ExecFileInvoker): Promise<string>;
 export interface ConcentratorConfig {
     apiKey: string;
     model: string;
@@ -101,7 +118,11 @@ export interface ConcentratorConfig {
      */
     capsuleLanguage?: string;
     concentrationTarget?: number;
-    provider?: 'gemini' | 'deepseek';
+    provider?: 'codex' | 'gemini' | 'deepseek';
+    codexModel?: string;
+    codexReasoningEffort?: CodexReasoningEffort;
+    codexWorkdir?: string;
+    codexTimeoutMs?: number;
     maxTokens?: number;
     deepseekApiKey?: string;
     deepseekModel?: string;
@@ -109,6 +130,7 @@ export interface ConcentratorConfig {
     transcriptArchive: TranscriptArchive;
     sessionSummaryDir: string;
     llm?: LlmClient;
+    importanceScorer?: (prompt: string) => Promise<string>;
 }
 export interface CapsuleOutput {
     messages: ContextMessage[];
@@ -122,6 +144,7 @@ export declare class ConcentratorAdapter implements LlmClient {
     private statsStore?;
     private transcriptArchive;
     private llm?;
+    private importanceScorer?;
     private readonly MAX_CONTEXT_WINDOW;
     private static readonly WATERLINE_CODE;
     private static readonly WATERLINE_DEFAULT;
@@ -133,6 +156,7 @@ export declare class ConcentratorAdapter implements LlmClient {
      */
     private detectConversationMode;
     buildFallbackCapsule(messages: ContextMessage[]): string;
+    private scoreNoteImportance;
     concentrate(rawMessages: ContextMessage[], dryRun?: boolean, force?: boolean, context?: ConcentrateContext): Promise<CapsuleOutput>;
     estimateTokens(messages: ContextMessage[]): number;
     estimateTokenBreakdown(messages: ContextMessage[]): {
@@ -142,7 +166,7 @@ export declare class ConcentratorAdapter implements LlmClient {
     };
     /**
      * Provider 輪替 fallback 核心方法
-     * 依序嘗試 gemini → deepseek，任一成功即返回
+     * 依序嘗試 codex → gemini → deepseek，任一成功即返回
      * Gemini 若連續 3 次 503，冷卻 90 秒內直接跳過
      */
     private callWithFallback;

package/dist/distill/concentrator-adapter.js

@@ -9,6 +9,8 @@
  */
 import * as path from 'node:path';
 import * as fs from 'node:fs';
+import * as os from 'node:os';
+import { execFile } from 'node:child_process';
 import { CapsuleBridge } from '../pipeline/capsule-bridge.js';
 import { sharedLLMRateLimiter } from '../util/rate-limiter.js';
 const CONCRETE_FACT_NOTE_CATEGORIES = new Set([
@@ -794,7 +796,7 @@ ${conversationLog}
 【時間正規化】對話每個 turn 前綴有 [at=<ISO>] 絕對時間戳。當事實含「昨天/今天/明天/上週/下個月/剛才/之後」等相對時間，必須以該事實所在 turn 的 at 為錨，在 text 內寫出絕對日期（例：「在 2023-05-07（原文稱昨天）參加了…」），並填 when 欄位。若 at=unknown 或語意不足以唯一解析，保留原文相對詞、不可猜，when.precision 與 when.source 設為 "unknown"。明確日期、月份、年份、區間、期限、事件先後順序都要保留，不要只寫「最近」「之前」。
 
 每筆格式：
-{ "text": "...", "category": "fact|decision|entity|preference|constraint|identity|knowledge|history|business|other", "importance": 0.0-1.0, "tags": ["..."], "subject": "主體（選配）", "predicate": "關係/屬性/動作（選配）", "value": "值，字串/數字/布林（選配）", "unit": "數值單位（選配）", "when": { "start": "YYYY-MM-DD 或 ISO（選配）", "end": "（選配）", "precision": "datetime|date|month|year|range|unknown", "sourceText": "原文時間詞", "source": "explicit|relative_anchored|contextual|unknown", "anchor": "錨定用的 turn ISO 時間" } }
+{ "text": "...", "category": "fact|decision|entity|preference|constraint|identity|knowledge|history|business|other", "tags": ["..."], "subject": "主體（選配）", "predicate": "關係/屬性/動作（選配）", "value": "值，字串/數字/布林（選配）", "unit": "數值單位（選配）", "when": { "start": "YYYY-MM-DD 或 ISO（選配）", "end": "（選配）", "precision": "datetime|date|month|year|range|unknown", "sourceText": "原文時間詞", "source": "explicit|relative_anchored|contextual|unknown", "anchor": "錨定用的 turn ISO 時間" } }
 （subject/predicate/value/unit/entities/when 全為選配：有對應資訊才填，沒有就整個省略，不可填空字串或編造。text 仍是主要可讀、可檢索內容；日期、數值、人名、地名、檔案名、產品名、事件名也必須同時寫進 text，能正規化的日期同時寫入 text 與 when。）
 
 收錄：
@@ -814,7 +816,6 @@ ${conversationLog}
 - 一筆只表達一個可獨立更新的主張，必須自足：寫明主體、內容、作用域，以及必要的時間、狀態、條件或理由；不得使用「這個」「上述方案」「已處理」等脫離原文便無法理解的指涉。
 - 保留足以語意檢索與回查原始 transcript 的專案、元件、人物或事件名稱，但不要複製整段對話、長篇推理、日誌或操作過程（原文可由 rehydrate 取回）。
 - category 選最能代表該主張長期用途者；tags 用少量具辨識力的實體/專案/領域/狀態詞。
-- importance 依「跨時間耐久性 × 未來決策效用」評分，不依篇幅、情緒強度或主題是否熱門；較低分代表耐久性或決策效用較低，但不得因此省略可獨立檢索的具體事實。
 
 CRITICAL INSTRUCTION: Output ONLY valid, raw JSON. Do NOT wrap in markdown code blocks. Start with '{' and end with '}'.
 
@@ -841,7 +842,6 @@ confidence 評分標準（0.0–1.0）：
     {
       "text": "精確的顆粒化記憶（含足夠上下文，獨立可理解；日期/數值/人名要寫進 text）",
       "category": "fact|decision|entity|preference|constraint|identity|knowledge|history|business|other",
-      "importance": 0.0-1.0,
       "tags": [],
       "subject": "主體（選配，省略則整個不要出現）",
       "predicate": "關係/屬性/動作（選配）",
@@ -896,7 +896,7 @@ ${capsuleLanguageInstruction}寫一段「前情提要」（600–900 字），
 【時間正規化】對話每個 turn 前綴有 [at=<ISO>] 絕對時間戳。當事實含「昨天/今天/明天/上週/下個月/剛才/之後」等相對時間，必須以該事實所在 turn 的 at 為錨，在 text 內寫出絕對日期（例：「在 2023-05-07（原文稱昨天）參加了…」），並填 when 欄位。若 at=unknown 或語意不足以唯一解析，保留原文相對詞、不可猜，when.precision 與 when.source 設為 "unknown"。明確日期、月份、年份、區間、期限、事件先後順序都要保留，不要只寫「最近」「之前」。
 
 每筆格式：
-{ "text": "...", "category": "fact|decision|entity|preference|constraint|identity|knowledge|history|business|other", "importance": 0.0-1.0, "tags": ["..."], "subject": "主體（選配）", "predicate": "關係/屬性/動作（選配）", "value": "值，字串/數字/布林（選配）", "unit": "數值單位（選配）", "when": { "start": "YYYY-MM-DD 或 ISO（選配）", "end": "（選配）", "precision": "datetime|date|month|year|range|unknown", "sourceText": "原文時間詞", "source": "explicit|relative_anchored|contextual|unknown", "anchor": "錨定用的 turn ISO 時間" } }
+{ "text": "...", "category": "fact|decision|entity|preference|constraint|identity|knowledge|history|business|other", "tags": ["..."], "subject": "主體（選配）", "predicate": "關係/屬性/動作（選配）", "value": "值，字串/數字/布林（選配）", "unit": "數值單位（選配）", "when": { "start": "YYYY-MM-DD 或 ISO（選配）", "end": "（選配）", "precision": "datetime|date|month|year|range|unknown", "sourceText": "原文時間詞", "source": "explicit|relative_anchored|contextual|unknown", "anchor": "錨定用的 turn ISO 時間" } }
 （subject/predicate/value/unit/entities/when 全為選配：有對應資訊才填，沒有就整個省略，不可填空字串或編造。text 仍是主要可讀、可檢索內容；日期、數值、人名、地名、檔案名、產品名、事件名也必須同時寫進 text，能正規化的日期同時寫入 text 與 when。）
 
 收錄：
@@ -916,7 +916,6 @@ ${capsuleLanguageInstruction}寫一段「前情提要」（600–900 字），
 - 一筆只表達一個可獨立更新的主張，必須自足：寫明主體、內容、作用域，以及必要的時間、狀態、條件或理由；不得使用「這個」「上述方案」「已處理」等脫離原文便無法理解的指涉。
 - 保留足以語意檢索與回查原始 transcript 的專案、元件、人物或事件名稱，但不要複製整段對話、長篇推理、日誌或操作過程（原文可由 rehydrate 取回）。
 - category 選最能代表該主張長期用途者；tags 用少量具辨識力的實體/專案/領域/狀態詞。
-- importance 依「跨時間耐久性 × 未來決策效用」評分，不依篇幅、情緒強度或主題是否熱門；較低分代表耐久性或決策效用較低，但不得因此省略可獨立檢索的具體事實。
 
 CRITICAL INSTRUCTION: Output ONLY valid, raw JSON. Do NOT wrap in markdown code blocks. Start with '{' and end with '}'.
 
@@ -930,7 +929,7 @@ confidence 評分標準（0.0–1.0）：
   "confidence": 0.85,
   "capsule": "任務B的自然語言前情提要...",
   "notes": [
-    { "text": "精確的顆粒化記憶（含足夠上下文，獨立可理解；日期/數值/人名要寫進 text）", "category": "fact|decision|entity|preference|constraint|identity|knowledge|history|business|other", "importance": 0.0, "tags": [], "subject": "（選配，省略則不要出現）", "predicate": "（選配）", "value": "（選配）", "unit": "（選配）", "when": { "start": "YYYY-MM-DD（選配）", "precision": "date", "sourceText": "原文時間詞", "source": "relative_anchored", "anchor": "turn ISO 時間" } }
+    { "text": "精確的顆粒化記憶（含足夠上下文，獨立可理解；日期/數值/人名要寫進 text）", "category": "fact|decision|entity|preference|constraint|identity|knowledge|history|business|other", "tags": [], "subject": "（選配，省略則不要出現）", "predicate": "（選配）", "value": "（選配）", "unit": "（選配）", "when": { "start": "YYYY-MM-DD（選配）", "precision": "date", "sourceText": "原文時間詞", "source": "relative_anchored", "anchor": "turn ISO 時間" } }
   ]
 }
 
@@ -940,6 +939,70 @@ confidence 評分標準（0.0–1.0）：
 - 必須回傳可完整 JSON.parse 的有效 JSON，不可輸出半截 JSON`;
     return isSourceLanguage ? `${sourceLanguageRequirementTop}\n\n${prompt}\n\n${sourceLanguageRequirementBottom}` : prompt;
 }
+export function buildImportanceScoringPrompt(noteTexts) {
+    const numberedNotes = noteTexts
+        .map((text, index) => `${index + 1}. ${text}`)
+        .join('\n');
+    return `非互動模式,立即回答,不要提問、不要使用任何工具、不要讀檔。
+
+下面是即將存進 AI 長期記憶庫的記憶。請為每一則評 importance(0.0-1.0)。
+
+評分標準(照這個定義,不要自行更改):
+importance 依「跨時間耐久性 × 未來決策效用」評分,不依篇幅、情緒強度或主題是否熱門;
+較低分代表耐久性或決策效用較低。
+
+只輸出 JSON,不要任何其他文字、不要 markdown 圍欄。必須包含全部 <${noteTexts.length}> 筆:
+{"r":[{"n":<編號>,"i":<0.0-1.0>}]}
+
+${numberedNotes}`;
+}
+class ImportanceScoreParseError extends Error {
+    scores;
+    constructor(message, scores) {
+        super(message);
+        this.scores = scores;
+        this.name = 'ImportanceScoreParseError';
+    }
+}
+function parseImportanceScores(raw, expectedCount) {
+    const lines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    let response = null;
+    for (let index = lines.length - 1; index >= 0; index--) {
+        try {
+            const candidate = JSON.parse(lines[index]);
+            if (candidate && typeof candidate === 'object' && Array.isArray(candidate.r)) {
+                response = candidate;
+                break;
+            }
+        }
+        catch {
+            // Codex progress lines and other non-JSON output are expected here.
+        }
+    }
+    if (!response) {
+        throw new ImportanceScoreParseError('importance score response parse failed', new Map());
+    }
+    const scores = new Map();
+    for (const entry of response.r) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const item = entry;
+        if (typeof item.n === 'number'
+            && Number.isInteger(item.n)
+            && item.n >= 1
+            && item.n <= expectedCount
+            && typeof item.i === 'number'
+            && Number.isFinite(item.i)) {
+            scores.set(item.n, Math.max(0, Math.min(1, item.i)));
+        }
+    }
+    const missing = Array.from({ length: expectedCount }, (_, index) => index + 1)
+        .filter((number) => !scores.has(number));
+    if (missing.length > 0) {
+        throw new ImportanceScoreParseError(`importance score response missing notes: ${missing.join(',')}`, scores);
+    }
+    return scores;
+}
 // ─── 降級版 Prompt (專供本地小模型使用) ───
 export function buildSimplePrompt(conversationLog, capsuleLanguage = '繁體中文') {
     if (capsuleLanguage === 'source') {
@@ -1076,14 +1139,123 @@ function classifyConcentratorFailure(err) {
         return 'quota';
     return 'other';
 }
+const CODEX_FAILURE_BREAKER_THRESHOLD = 3;
+const CODEX_FAILURE_COOLDOWN_MS = 90_000;
 const GEMINI_503_BREAKER_THRESHOLD = 3;
 const GEMINI_503_COOLDOWN_MS = 90_000;
+let codexConsecutiveFailureCount = 0;
+let codexCooldownUntil = 0;
 let geminiConsecutive503Count = 0;
 let geminiCooldownUntil = 0;
 function isGemini503Error(err) {
     const message = String(err?.message ?? err ?? '').toLowerCase();
     return message.includes('gemini api error: 503');
 }
+export function buildCodexExecArgs(prompt, config) {
+    return [
+        'exec',
+        '-C', config.workdir,
+        '-c', `model=${config.model}`,
+        '-c', `model_reasoning_effort=${config.reasoningEffort}`,
+        prompt,
+    ];
+}
+function findBalancedJsonCandidates(text) {
+    const stack = [];
+    const candidates = [];
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (inString && ch === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (ch === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (ch === '[' || ch === '{') {
+            stack.push({ opener: ch, start: i });
+            continue;
+        }
+        if (ch !== ']' && ch !== '}')
+            continue;
+        const expected = ch === ']' ? '[' : '{';
+        const top = stack[stack.length - 1];
+        if (!top || top.opener !== expected)
+            continue;
+        stack.pop();
+        candidates.push(text.slice(top.start, i + 1));
+    }
+    return candidates;
+}
+export function parseCodexOutput(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        throw new Error('Codex CLI returned empty stdout');
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === 'object')
+            return parsed;
+    }
+    catch { }
+    const candidates = findBalancedJsonCandidates(stdout);
+    for (let i = candidates.length - 1; i >= 0; i--) {
+        try {
+            const parsed = JSON.parse(candidates[i]);
+            if (parsed && typeof parsed === 'object')
+                return parsed;
+        }
+        catch { }
+    }
+    throw new Error('Codex CLI stdout did not contain parseable JSON');
+}
+export function runCodexCli(prompt, config, execFileImpl = execFile) {
+    const args = buildCodexExecArgs(prompt, config);
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let timedOut = false;
+        let child;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child?.kill('SIGTERM');
+            reject(new Error(`Codex CLI timed out after ${config.timeoutMs}ms`));
+        }, config.timeoutMs);
+        const finish = (error, stdout, stderr) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (timedOut)
+                return;
+            if (error) {
+                const detail = String(stderr || error.message || error);
+                reject(new Error(`Codex CLI failed: ${detail}`));
+                return;
+            }
+            try {
+                resolve(JSON.stringify(parseCodexOutput(String(stdout))));
+            }
+            catch (parseError) {
+                reject(parseError);
+            }
+        };
+        child = execFileImpl('codex', args, {
+            cwd: config.workdir,
+            timeout: config.timeoutMs,
+        }, finish);
+        // execFile 不吃 stdio 選項,child 的 stdin 會是一個開著的 pipe,
+        // codex CLI 因此停在 "Reading additional input from stdin" 直到 timeout。
+        child?.stdin?.end();
+    });
+}
 function extractBalancedObjectForKey(text, key) {
     const keyIndex = text.indexOf(`"${key}"`);
     if (keyIndex === -1)
@@ -1285,6 +1457,7 @@ export class ConcentratorAdapter {
     statsStore;
     transcriptArchive;
     llm;
+    importanceScorer;
     MAX_CONTEXT_WINDOW = 200000;
     // ── 動態水位線常數 ──────────────────────────────────────
     static WATERLINE_CODE = 0.40; // 代碼/技術密集：40%
@@ -1298,6 +1471,10 @@ export class ConcentratorAdapter {
             capsuleLanguage: config.capsuleLanguage ?? '繁體中文',
             concentrationTarget: config.concentrationTarget ?? 0,
             provider: config.provider ?? 'gemini',
+            codexModel: config.codexModel ?? 'gpt-5.6-luna',
+            codexReasoningEffort: config.codexReasoningEffort ?? 'low',
+            codexWorkdir: config.codexWorkdir || os.homedir(),
+            codexTimeoutMs: config.codexTimeoutMs ?? 120000,
             maxTokens: config.maxTokens ?? 8192,
             deepseekApiKey: config.deepseekApiKey || '',
             deepseekModel: config.deepseekModel ?? 'deepseek-v4-flash',
@@ -1307,6 +1484,7 @@ export class ConcentratorAdapter {
         this.statsStore = config.statsStore;
         this.transcriptArchive = config.transcriptArchive;
         this.llm = config.llm;
+        this.importanceScorer = config.importanceScorer;
         this.capsuleBridge = new CapsuleBridge(this.config.inboxPath);
     }
     /**
@@ -1376,6 +1554,41 @@ export class ConcentratorAdapter {
             `## 9. Optional Next Step\n${latestAssistant === '無' ? '無' : latestAssistant}`,
         ].join('\n\n');
     }
+    async scoreNoteImportance(notes, metricContext) {
+        if (notes.length === 0)
+            return;
+        const prompt = buildImportanceScoringPrompt(notes.map((note) => typeof note.text === 'string' ? note.text : ''));
+        let scores = new Map();
+        try {
+            const raw = this.importanceScorer
+                ? await this.importanceScorer(prompt)
+                : await this.callWithFallback(prompt, 'scoreImportance', undefined, { sessionIdentity: metricContext?.sessionIdentity, inputTokens: estimatePromptTokens(prompt) }, 2048);
+            scores = parseImportanceScores(raw, notes.length);
+        }
+        catch (error) {
+            if (error instanceof ImportanceScoreParseError) {
+                scores = error.scores;
+            }
+            const message = String(error?.message ?? error).toLowerCase();
+            const reason = error instanceof ImportanceScoreParseError
+                ? (message.includes('missing') ? 'partial missing' : 'parse failed')
+                : (message.includes('timeout') || message.includes('timed out') || message.includes('abort')
+                    ? 'timeout'
+                    : 'call failed');
+            console.warn(`[ConcentratorAdapter] Importance scoring fallback: ${reason}; missing scores use 0.5`);
+        }
+        notes.forEach((note, index) => {
+            const importance = scores.get(index + 1);
+            if (importance === undefined) {
+                note.importance = 0.5;
+                note.importanceFallback = true;
+            }
+            else {
+                note.importance = importance;
+                delete note.importanceFallback;
+            }
+        });
+    }
     async concentrate(rawMessages, dryRun = false, force = false, context = {}) {
         const messages = rawMessages.map(msg => truncateGiantStrings(msg));
         const currentTokens = estimateTotalTokens(messages);
@@ -1388,7 +1601,7 @@ export class ConcentratorAdapter {
         if (!needsCut) {
             return { messages, wasConcentrated: false, processedThroughIndex: 0 };
         }
-        if (!this.llm && !this.config.apiKey && !this.config.deepseekApiKey) {
+        if (!this.llm && this.config.provider !== 'codex' && !this.config.apiKey && !this.config.deepseekApiKey) {
             console.warn('[ConcentratorAdapter] Concentration skipped: no LLM API key configured; raw transcripts and recall remain available.');
             return { messages, wasConcentrated: false, processedThroughIndex: 0 };
         }
@@ -1577,7 +1790,9 @@ export class ConcentratorAdapter {
                 const originalTokens = estimatePromptTokens(conversationLog);
                 const summaryTokens = estimatePromptTokens(capsuleText);
                 const compressionRatio = originalTokens / Math.max(1, summaryTokens);
-                const notes = parsedData.notes || [];
+                const notes = Array.isArray(parsedData.notes)
+                    ? parsedData.notes.map((item) => item && typeof item === 'object' ? item : {})
+                    : [];
                 const sourceEntryIds = sourceEntryIdsProbe?.matched ? sourceEntryIdsProbe.sourceEntryIds : [];
                 const sourceEntryRange = sourceEntryIds.length > 0
                     ? {
@@ -1605,6 +1820,9 @@ export class ConcentratorAdapter {
                     console.log(`[ConcentratorAdapter] sourceEntryIds metadata: length=${sourceEntryIds.length} firstEntryId=${sourceEntryRange?.firstEntryId ?? 'none'} lastEntryId=${sourceEntryRange?.lastEntryId ?? 'none'}`);
                     console.log(`[ConcentratorAdapter] Short-term capsule written (health: 30, confidence: ${confidence.toFixed(2)})`);
                 }
+                await this.scoreNoteImportance(notes, {
+                    sessionIdentity: context.sessionIdentity,
+                });
                 const acceptedNoteTexts = [];
                 for (const item of notes) {
                     const text = typeof item.text === 'string' ? item.text.trim() : '';
@@ -1629,6 +1847,7 @@ export class ConcentratorAdapter {
                                 confidence,
                                 firstTimestamp,
                                 lastTimestamp,
+                                ...(item.importanceFallback === true ? { importanceFallback: true } : {}),
                                 ...(sourceEntryIds.length > 0 ? { sourceEntryIds } : {}),
                                 ...(sourceEntryRange ? { sourceEntryRange } : {}),
                                 // Optional structured enrichment — additive, stored as-is (no schema change),
@@ -1655,7 +1874,7 @@ export class ConcentratorAdapter {
                     || rawMessages[0]?.sessionId
                     || 'unknown';
                 const concentratedAt = Date.now();
-                await this.writeSessionSummary({ sessionId, concentratedAt, capsule: capsuleText, notes: parsedData.notes || [], primaryRequest: summary?.primaryRequest || '', pendingTasks: summary?.pendingTasks || '', nextStep: summary?.nextStep || '' });
+                await this.writeSessionSummary({ sessionId, concentratedAt, capsule: capsuleText, notes: notes, primaryRequest: summary?.primaryRequest || '', pendingTasks: summary?.pendingTasks || '', nextStep: summary?.nextStep || '' });
             }
             catch (err) {
                 console.error("[ConcentratorAdapter] Compaction failed:", err);
@@ -1683,7 +1902,7 @@ export class ConcentratorAdapter {
     }
     /**
      * Provider 輪替 fallback 核心方法
-     * 依序嘗試 gemini → deepseek，任一成功即返回
+     * 依序嘗試 codex → gemini → deepseek，任一成功即返回
      * Gemini 若連續 3 次 503，冷卻 90 秒內直接跳過
      */
     async callWithFallback(prompt, fnName = 'generate', fallbackPrompt, // concentrate 失敗時由呼叫端接 deterministic capsule；此處不處理
@@ -1691,22 +1910,44 @@ export class ConcentratorAdapter {
         if (this.llm) {
             return this.llm.generate(prompt, { purpose: fnName, maxTokens });
         }
-        const providers = [];
+        const providers = this.config.provider === 'codex'
+            ? ['codex', 'gemini', 'deepseek']
+            : ['gemini', 'deepseek'];
         const now = Date.now();
+        if (providers.includes('codex')) {
+            if (now < codexCooldownUntil) {
+                console.warn(`[${fnName}] codex skipped: circuit breaker cooling down for ${Math.ceil((codexCooldownUntil - now) / 1000)}s`);
+            }
+            else {
+                // codex has no API key; authentication belongs to the local CLI.
+            }
+        }
+        const eligibleProviders = providers.filter((provider) => provider !== 'codex' || now >= codexCooldownUntil);
         if (now < geminiCooldownUntil) {
             console.warn(`[${fnName}] gemini skipped: circuit breaker cooling down for ${Math.ceil((geminiCooldownUntil - now) / 1000)}s`);
         }
-        else {
-            providers.push('gemini');
-        }
-        providers.push('deepseek');
+        const orderedProviders = eligibleProviders.filter((provider) => provider !== 'gemini' || now >= geminiCooldownUntil);
         const attemptedProviders = [];
         const startedAt = Date.now();
         const shouldRecordMetric = fnName === 'concentrate';
         let lastError = null;
-        for (const provider of providers) {
+        for (const provider of orderedProviders) {
             attemptedProviders.push(provider);
             try {
+                if (provider === 'codex') {
+                    const result = await this.callProvider(provider, prompt, maxTokens);
+                    codexConsecutiveFailureCount = 0;
+                    await this.recordConcentratorAttemptMetric({
+                        metricContext,
+                        provider,
+                        outcome: 'success',
+                        attemptedProviders,
+                        inputTokens: metricContext?.inputTokens ?? estimatePromptTokens(prompt),
+                        outputTokens: estimatePromptTokens(result),
+                        durationMs: Date.now() - startedAt,
+                    }, shouldRecordMetric);
+                    return result;
+                }
                 if (provider === 'gemini') {
                     if (this.config.apiKey) {
                         const result = await this.callProvider(provider, prompt, maxTokens);
@@ -1745,7 +1986,14 @@ export class ConcentratorAdapter {
             }
             catch (err) {
                 console.warn(`[${fnName}] ${provider} failed; trying next provider:`, err);
-                if (provider === 'gemini') {
+                if (provider === 'codex') {
+                    codexConsecutiveFailureCount += 1;
+                    if (codexConsecutiveFailureCount >= CODEX_FAILURE_BREAKER_THRESHOLD) {
+                        codexCooldownUntil = Date.now() + CODEX_FAILURE_COOLDOWN_MS;
+                        console.warn(`[${fnName}] codex circuit breaker opened for ${CODEX_FAILURE_COOLDOWN_MS / 1000}s after ${codexConsecutiveFailureCount} consecutive failures`);
+                    }
+                }
+                else if (provider === 'gemini') {
                     if (isGemini503Error(err)) {
                         geminiConsecutive503Count += 1;
                         if (geminiConsecutive503Count >= GEMINI_503_BREAKER_THRESHOLD) {
@@ -1776,6 +2024,14 @@ export class ConcentratorAdapter {
         if (provider === 'gemini') {
             return callGeminiAPI(this.config.apiKey, this.config.model, prompt, maxTokens);
         }
+        if (provider === 'codex') {
+            return runCodexCli(prompt, {
+                model: this.config.codexModel,
+                reasoningEffort: this.config.codexReasoningEffort,
+                workdir: this.config.codexWorkdir,
+                timeoutMs: this.config.codexTimeoutMs,
+            });
+        }
         if (provider === 'deepseek') {
             return callDeepSeekAPI(this.config.deepseekApiKey, this.config.deepseekModel, prompt, maxTokens);
         }

package/dist/engine.js

@@ -87,7 +87,11 @@ export class MemoryRiverEngine {
                 apiKey: config.concentration?.geminiApiKey || config.embedding.apiKey || deps.geminiApiKey,
                 model: config.concentration?.model || 'gemini-2.5-flash-lite',
                 inboxPath: config.inboxPath,
-                provider: config.concentration?.provider || 'gemini',
+                provider: config.concentration?.provider || 'codex',
+                codexModel: config.concentration?.codexModel,
+                codexReasoningEffort: config.concentration?.codexReasoningEffort,
+                codexWorkdir: config.concentration?.codexWorkdir,
+                codexTimeoutMs: config.concentration?.codexTimeoutMs,
                 maxTokens: config.concentration?.maxTokens ?? 8192,
                 deepseekApiKey: config.concentration?.deepseekApiKey || deps.deepseekApiKey,
                 deepseekModel: config.concentration?.deepseekModel || 'deepseek-v4-flash',

package/dist/store/store-v4.d.ts

@@ -27,6 +27,7 @@ export declare function normalizeLanceUpdateValues(values: Record<string, unknow
 type DecayOptions = {
     coreCategories?: string[];
     coreImportanceThreshold?: number;
+    capsuleBypassCore?: boolean;
     skillCapsuleProtection?: boolean;
     dryRun?: boolean;
     deleteWith?: (id: string) => Promise<boolean>;

package/dist/store/store-v4.js

@@ -18,11 +18,26 @@ import { Schema, Field, Int64, Utf8, Bool, Float64 } from "apache-arrow";
 import { optimizeAuxTablesInConnection, recordAuxTableWrite, } from "./aux-table-maintenance.js";
 // 動態載入 jieba
 let jieba = null;
+let jiebaUnavailable = false;
 const loadJieba = async () => {
     if (jieba)
         return jieba;
+    if (jiebaUnavailable)
+        return null;
     const module = await import("nodejieba");
-    jieba = module.default ?? module;
+    const candidate = module.default ?? module;
+    // nodejieba 的 index.js 在原生 binding 缺失時仍能 import 成功,只有第一次真正
+    // 呼叫才丟。這裡先探一次,讓失敗落在 tokenizeChinese 的 catch 裡走降級,
+    // 而不是逃出去把每一次 store/update/ftsSearch 都打掛。
+    try {
+        candidate.cut("測");
+    }
+    catch (error) {
+        jiebaUnavailable = true;
+        console.warn("[MemoryStore] nodejieba unavailable, falling back to per-character Chinese tokenization:", error?.message ?? error);
+        throw error;
+    }
+    jieba = candidate;
     return jieba;
 };
 let lancedbImportPromise = null;
@@ -56,10 +71,13 @@ export class SchemaViolationError extends Error {
     }
 }
 // 預設健康度配置
+// coreImportanceThreshold 必須與 types.ts 的 DEFAULT_CLEANUP_CONFIG 一致。
+// 兩處曾經分別是 0.85 / 0.75,同一個「記憶要多重要才不被淘汰」的問題會因為
+// 呼叫入口不同而得到差一倍的答案(0.85→41% 受保護、0.75→76%)。改一邊要改兩邊。
 const DEFAULT_HEALTH_CONFIG = {
     initialScore: 100,
-    coreCategories: ["identity", "constraint", "business", "core_rule"],
-    coreImportanceThreshold: 0.85,
+    coreCategories: ["identity", "preference", "constraint", "business", "decision", "core_rule"],
+    coreImportanceThreshold: 0.75,
     skillDecayFactor: 0.25,
 };
 const STRING_UPDATE_FIELDS = new Set([
@@ -2678,6 +2696,7 @@ export class MemoryStore {
         let deferredDecay = 0, deferredDelete = 0;
         const effectiveCoreCategories = options.coreCategories ?? this.healthConfig.coreCategories;
         const effectiveCoreImportanceThreshold = options.coreImportanceThreshold ?? this.healthConfig.coreImportanceThreshold;
+        const capsuleBypassCore = options.capsuleBypassCore ?? true;
         const protectSkillCapsules = options.skillCapsuleProtection ?? true;
         const isDryRun = options.dryRun ?? false;
         const maxDelete = options.maxDelete === undefined ? Infinity : Math.max(0, Math.floor(options.maxDelete));
@@ -2706,14 +2725,16 @@ export class MemoryStore {
             const id = memoryRow.id;
             if (id.startsWith("init_"))
                 continue;
-            const isCore = effectiveCoreCategories.includes(memoryRow.category) ||
-                memoryRow.importance >= effectiveCoreImportanceThreshold;
+            const metaObj = this.parseMetadata(memoryRow.metadata);
+            // dynamic capsule 出生就是短命設計(health 30),不該因為 importance 高而被當成核心記憶保護
+            const isDynamicCapsule = metaObj?.type === 'dynamic_capsule';
+            const isCore = (!capsuleBypassCore || !isDynamicCapsule) && (effectiveCoreCategories.includes(memoryRow.category) ||
+                memoryRow.importance >= effectiveCoreImportanceThreshold);
             if (isCore) {
                 coreProtected++;
                 continue;
             }
             // 技能膠囊不參與灰塵清理(只響應用戶明確刪除)
-            const metaObj = this.parseMetadata(memoryRow.metadata);
             if (protectSkillCapsules && metaObj?.capsuleType === 'skill_capsule') {
                 continue;
             }

package/dist/types.d.ts

@@ -1,7 +1,3 @@
-/**
- * Unified Types - memory-river
- * Merged from v4/types.ts + context-river/concentrator.ts
- */
 export type MemoryCategory = "preference" | "fact" | "decision" | "entity" | "constraint" | "identity" | "business" | "knowledge" | "skill" | "other";
 export declare const MEMORY_CATEGORIES: readonly ["preference", "fact", "decision", "entity", "constraint", "identity", "business", "knowledge", "skill", "other"];
 export declare const PROTECTED_CATEGORIES: MemoryCategory[];
@@ -171,7 +167,7 @@ export interface TranscriptWatermarkRow {
     lineCount: number;
     updatedAt: number;
 }
-export type ConcentratorProvider = "gemini" | "deepseek" | "all_failed";
+export type ConcentratorProvider = "codex" | "gemini" | "deepseek" | "all_failed";
 export type ConcentratorStatOutcome = "success" | "partial" | "failure";
 export type ConcentratorFailureReason = "broken_json" | "timeout" | "quota" | "other";
 export interface ConcentratorStat {
@@ -284,8 +280,9 @@ export interface InboxWriteOptions {
  *    實際 embedder-v5.ts 使用 Ollama，不受此欄位影響。
  *
  * Concentration（濃縮）Provider 順序：
- *   - 預設：Gemini → DeepSeek
+ *   - 預設：Codex CLI → Gemini → DeepSeek
  *   - Gemini 若連續 3 次 503：冷卻 90 秒，期間直接跳過 Gemini
+ *   - Codex CLI 若連續 3 次失敗：冷卻 90 秒，期間直接跳過 Codex CLI
  *   - concentrate() 全失敗時仍由 ConcentratorAdapter 走 deterministic fallback capsule
  *
  * =============================================================================
@@ -351,8 +348,12 @@ export interface PluginConfig {
     };
     concentration?: {
         model?: string;
-        provider?: 'gemini' | 'deepseek';
+        provider?: 'codex' | 'gemini' | 'deepseek';
         geminiApiKey?: string;
+        codexModel?: string;
+        codexReasoningEffort?: 'none' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+        codexWorkdir?: string;
+        codexTimeoutMs?: number;
         maxTokens?: number;
         deepseekApiKey?: string;
         deepseekModel?: string;

package/dist/types.js

@@ -1,3 +1,8 @@
+/**
+ * Unified Types - memory-river
+ * Merged from v4/types.ts + context-river/concentrator.ts
+ */
+import * as os from 'node:os';
 export const MEMORY_CATEGORIES = [
     "preference",
     "fact",
@@ -55,8 +60,11 @@ export const DEFAULT_CONFIG = {
         decayPerRun: 5,
         decayIntervalMs: 24 * 60 * 60 * 1000,
         deleteThreshold: 0,
-        coreCategories: ["identity", "preference", "constraint", "business", "core_rule"],
-        coreImportanceThreshold: 0.8,
+        // 與上面 cleanupEngine 及 store-v4 的 DEFAULT_HEALTH_CONFIG 保持一致。
+        // 這三處曾經各寫各的(0.75 / 0.8 / 0.85,category 也是 6 / 5 / 4 類),
+        // 「記憶要多重要才不被淘汰」會因為呼叫入口不同而得到不同答案。改一處要改三處。
+        coreCategories: ["identity", "preference", "constraint", "business", "decision", "core_rule"],
+        coreImportanceThreshold: 0.75,
         skillDecayFactor: 0.25,
     },
     hooks: {
@@ -73,13 +81,13 @@ export const DEFAULT_CONFIG = {
     },
     concentration: {
         model: 'gemini-2.5-flash-lite',
-        /**
-         * @deprecated 此欄位已失效。實際 fallback 順序由 concentrator-adapter.ts 內定
-         *             （Gemini → DeepSeek），不受 config 影響。
-         *             保留欄位以避免破壞既有宿主設定，請勿依賴其值。
-         */
-        provider: 'gemini',
+        /** Provider chain starts with Codex when this is 'codex'; old values retain their legacy chain. */
+        provider: 'codex',
         geminiApiKey: "",
+        codexModel: 'gpt-5.6-luna',
+        codexReasoningEffort: 'low',
+        codexWorkdir: os.homedir(),
+        codexTimeoutMs: 120000,
         maxTokens: 8192,
         deepseekApiKey: "",
         deepseekModel: 'deepseek-v4-flash',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memory-river/core",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "Framework-neutral long-term memory engine for Node.js agents.",
   "private": false,
   "license": "Apache-2.0",