@modusensus/dsh-mneme 0.8.1 → 0.8.2

package/src/dream.js

@@ -910,8 +910,8 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       maxTokens: config.dreamMaxTokens ?? 4096,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
-        { role: "system", content: [{ type: "text", text: consolidationPrompt }] },
-        { role: "user", content: [{ type: "text", text: listText }] }
+        { role: "system", content: [{ type: "text", text: consolidationPrompt }], source: { kind: "plugin", plugin: "dsh-mneme" } },
+        { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
     };
@@ -933,8 +933,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       logger?.warn?.(`dsh-mneme dream: no json array in llm output (raw length ${decisionText?.length ?? 0}; head: ${head})`);
       return finish({ ok: false, error: "no json array in llm output", summary: false });
     }
-    const { ok, errors, skipped, resolvedShortIds } = validateDecisions(decisions, snapshot, {
+    const { ok, errors, skipped, resolvedShortIds, coverageShortfall } = validateDecisions(decisions, snapshot, {
       maxUpdatePerRun: config.reflectionUpdateMaxPerRun,
+      // Issue #104 方向 2：archive 批量上限（全局闸门，超限整单拒绝）。
+      maxArchivePerRun: config.dreamMaxArchivePerRun,
       minAgeHours: config.reflectionUpdateMinAgeHours,
       // v0.4.4 fix：显式透传，用户配 dreamImplicitKeep:false 时严格模式必须
       // 真正生效，dreamMinExplicitCoverage 决定隐式 keep 下的覆盖率下限。
@@ -972,6 +974,12 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     if (skippedInvalid) {
       logger?.warn?.(`dsh-mneme dream: ${skipped.length} invalid decision(s) skipped (run degrades): ${skipped.map((s) => s.error).join("; ")}`);
     }
+    // Issue #104 方向 1：覆盖率不足降级为 degraded（不再整单拒绝）——合法子集
+    // 照常应用、未提及条目隐式 keep，理由随 outcome.degradations 落库供离线定位。
+    const coverageDegraded = typeof coverageShortfall === "string" && coverageShortfall.length > 0;
+    if (coverageDegraded) {
+      logger?.warn?.(`dsh-mneme dream: ${coverageShortfall} (run degrades: valid subset applied, unclaimed ids kept implicitly)`);
+    }
 
     // Capture pre-update snapshots so the audit records what each update changed.
     const updateSnapshots = {};
@@ -1087,6 +1095,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // claim "merge-archived" (item ②). Conflicts/failures ride along so the
     // audit row records why the run diverged.
     const outcome = { ...buildOutcome(committed), conflicts, failures };
+    if (coverageDegraded) outcome.degradations = [coverageShortfall];
     // Frozen conflicts were not adjudicated: mark both sides pending in the
     // per-id outcome so the audit row shows they were parked, not skipped.
     if (frozenIds.length) {
@@ -1130,8 +1139,8 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       maxTokens: config.dreamMaxTokens ?? 2048,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
-        { role: "system", content: [{ type: "text", text: STR.prompts.dreamSummary[language] }] },
-        { role: "user", content: [{ type: "text", text: service.all().filter((m) => !m.archived && m.type !== "summary").map((m) => `- ${m.title}: ${m.content}`).join("\n") }] }
+        { role: "system", content: [{ type: "text", text: STR.prompts.dreamSummary[language] }], source: { kind: "plugin", plugin: "dsh-mneme" } },
+        { role: "user", content: [{ type: "text", text: service.all().filter((m) => !m.archived && m.type !== "summary").map((m) => `- ${m.title}: ${m.content}`).join("\n") }], source: { kind: "plugin", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { summaryStreamFailure = describeStreamFailure(reason); }));
     };
@@ -1171,7 +1180,9 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     //   degraded  — real consolidation landed but the run did not produce its
     //               full output: the summary came back empty/missing, or
     //               skipInvalid dropped individually-invalid decisions
-    //               (Issue #89 — marked, not faked). The valid subset was
+    //               (Issue #89 — marked, not faked), or the explicit-decision
+    //               coverage fell below dreamMinExplicitCoverage (Issue #104
+    //               方向 1 — degrade, don't reject). The valid subset was
     //               absorbed (ok for the baseline).
     let status;
     let okResult;
@@ -1182,7 +1193,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       status = summaryStored ? "ok" : "noop";
       okResult = summaryStored;
     } else {
-      status = summaryStored && !skippedInvalid ? "ok" : "degraded";
+      status = summaryStored && !skippedInvalid && !coverageDegraded ? "ok" : "degraded";
       okResult = true;
     }
     return finish({

package/src/entities/extractor.js

@@ -150,8 +150,8 @@ export async function extractEntities(memory, { store, config, callLLM, logger }
     const userText = buildUserMessage(memory.content);
 
     const messages = [
-      { role: "system", content: [{ type: "text", text: systemPrompt }] },
-      { role: "user", content: [{ type: "text", text: userText }] }
+      { role: "system", content: [{ type: "text", text: systemPrompt }], source: { kind: "plugin", plugin: "dsh-mneme" } },
+      { role: "user", content: [{ type: "text", text: userText }], source: { kind: "plugin", plugin: "dsh-mneme" } }
     ];
 
     // Issue #109: optional provider/model override + reasoning effort are

package/src/index.js

@@ -275,6 +275,8 @@ export const apply = (ctx, config) => {
         batchSize: cfg.localEmbedBatchSize,
         cacheDir: cfg.embedModelCacheDir,
         runtimeDir: cfg.runtimeDir,
+        // #188：embedModelMirror 接成 transformers 的下载镜像（此前死配置）。
+        remoteHost: cfg.embedModelMirror,
         baseUrl: cfg.ollamaBaseUrl,
         logger: ctx.logger
       });
@@ -327,6 +329,10 @@ export const apply = (ctx, config) => {
         device: cfg.localEmbedDevice,
         cacheDir: cfg.embedModelCacheDir,
         runtimeDir: cfg.runtimeDir,
+        // #188：量化档默认 q8（此前不传 dtype 会去要 1GB 级 fp32 模型）；
+        // embedModelMirror 此前是死配置，现接成 transformers 的下载镜像。
+        useDtype: cfg.rerankDtype,
+        remoteHost: cfg.embedModelMirror,
         logger: ctx.logger
       });
       service.setReranker(reranker);

package/src/lang.js

@@ -23,8 +23,8 @@ const PROMPTS = {
     "en": "You are the memory overview assistant. From the consolidated memories below, produce a 150-200 word memory-library overview covering: user preferences, active projects, key decisions. This will be injected as conversation context. Output only the summary text, nothing else."
   },
   "consolidation": {
-    "zh": "你是记忆库整理助手。下面是全部记忆条目（id、类型、标题、内容、重要性、更新时间）。\n请执行记忆巩固（consolidation），输出一个决策 JSON 数组。\n\n【决策格式（必须严格遵守）】\n每个决策必须是对象，字段固定：\n- \"action\"：必填。取值只能是 \"keep\" / \"merge\" / \"archive\" / \"update\" / \"conflict\" 之一（字段名必须是 action，严禁写成 type）\n- \"ids\"：必填，数组，本决策涉及的记忆 id 列表\n- \"reason\"：可选，字符串，决策理由\n- \"importance\"：可选，整数 1-5\n- merge 额外字段：\"keepSource\"（单个 id 字符串，必须是 ids 之一）+ 合并后的 \"title\"、\"content\"\n- conflict 额外字段：\"winner\" 与 \"loser\"，都是【单个 id 字符串，不是数组】\n- update 额外字段：修正后的 \"title\" 和/或 \"content\"；\"ids\" 只能包含一个 id\n\n【决策 JSON 示例】\n[\n  { \"action\": \"merge\", \"ids\": [\"m1\", \"m2\"], \"keepSource\": \"m1\", \"title\": \"合并标题\", \"content\": \"合并后的摘要内容\", \"importance\": 4, \"reason\": \"主题相近\" },\n  { \"action\": \"conflict\", \"winner\": \"m3\", \"loser\": \"m4\", \"reason\": \"内容矛盾，保留更新的信息\" },\n  { \"action\": \"update\", \"ids\": [\"m5\"], \"content\": \"修正后的内容\", \"reason\": \"信息过时\" },\n  { \"action\": \"archive\", \"ids\": [\"m6\"], \"reason\": \"重复或过时\" }\n]\n\n【任务】\n1. 识别主题相近的条目 → merge（合并为更精炼的摘要，保留信息最完整的 id 作为 keepSource）\n2. 识别重复/过时信息 → archive\n3. 识别内容矛盾的条目 → conflict（按时间新旧、来源完整性、信息具体程度判断 winner/loser）\n4. 发现单条记忆中的信息过时、错误或遗漏 → update（直接修正内容）\n   - update 的 ids 只能包含一个 id\n   - 必须提供修正后的 title 和/或 content\n   - 仅当内容确实需要修正时才使用，不要滥用\n   - 每次整理最多输出 2 个 update\n   - 24 小时内新建的记忆不可 update\n5. 无问题的条目无需输出（未提及的条目将自动保留 keep）\n\n【硬性规则】\n- 字段名必须精确为 \"action\"，严禁写成 \"type\"；字段名统一用双引号\n- conflict 的 winner/loser、merge 的 keepSource 都是【单个 id 字符串，绝不是数组】\n- 每条记忆最多被 claim 一次：同一个 id 不能出现在多个决策中（同一 id 不能被 merge 和 conflict/archive 等重复占用）\n- 未在决策中提及的记忆将自动保留（keep），无需为每条记忆输出 keep\n- merge 的 keepSource 必须是 ids 之一\n- 仅合并同类型条目（type 相同）\n- 不要编造 ids；只使用提供的 id\n- 重要性 1-5，合并后取最高\n- 只输出 JSON 数组，不要其他文字",
-    "en": "You are the memory consolidation assistant. Below are all memory entries (id, type, title, content, importance, updated time).\nPerform memory consolidation and output a JSON array of decisions.\n\n[Decision format (must be followed strictly)]\nEach decision must be an object with fixed fields:\n- \"action\": required. Value must be one of \"keep\" / \"merge\" / \"archive\" / \"update\" / \"conflict\" (the field name must be action, never type)\n- \"ids\": required, array, the list of memory ids involved in this decision\n- \"reason\": optional, string, rationale for the decision\n- \"importance\": optional, integer 1-5\n- merge extra fields: \"keepSource\" (a single id string, must be one of ids) plus the merged \"title\" and \"content\"\n- conflict extra fields: \"winner\" and \"loser\", each a [single id string, never an array]\n- update extra fields: the corrected \"title\" and/or \"content\"; \"ids\" may contain only one id\n\n[Decision JSON examples]\n[\n  { \"action\": \"merge\", \"ids\": [\"m1\", \"m2\"], \"keepSource\": \"m1\", \"title\": \"Merged title\", \"content\": \"Merged summary content\", \"importance\": 4, \"reason\": \"similar topics\" },\n  { \"action\": \"conflict\", \"winner\": \"m3\", \"loser\": \"m4\", \"reason\": \"content contradicts; keep the newer information\" },\n  { \"action\": \"update\", \"ids\": [\"m5\"], \"content\": \"corrected content\", \"reason\": \"information outdated\" },\n  { \"action\": \"archive\", \"ids\": [\"m6\"], \"reason\": \"duplicate or outdated\" }\n]\n\n[Task]\n1. Identify entries with similar topics -> merge (merge into a more refined summary; keep the id with the most complete information as keepSource)\n2. Identify duplicate/outdated information -> archive\n3. Identify entries with contradictory content -> conflict (judge winner/loser by recency, source completeness, and information specificity)\n4. Find outdated, wrong, or missing information in a single memory -> update (correct the content directly)\n   - update's ids may contain only one id\n   - must provide the corrected title and/or content\n   - use only when the content truly needs correction; do not abuse\n   - output at most 2 updates per consolidation run\n   - memories created within the last 24 hours must not be updated\n5. Entries without issues need no output (unmentioned entries are automatically kept)\n\n[Hard rules]\n- Field names must be exactly \"action\", never \"type\"; use double quotes for all field names\n- conflict winner/loser and merge keepSource are [single id strings, never arrays]\n- Each memory may be claimed at most once: the same id must not appear in multiple decisions (an id must not be claimed by both merge and conflict/archive, etc.)\n- Memories not mentioned in any decision are automatically kept (keep); no need to output keep for every memory\n- merge keepSource must be one of ids\n- Only merge entries of the same type (identical type)\n- Never invent ids; use only the provided ids\n- Importance is 1-5; after a merge take the highest\n- Write every title, content, and reason in English\n- Output only the JSON array, nothing else"
+    "zh": "你是记忆库整理助手。下面是全部记忆条目（id、类型、标题、内容、重要性、更新时间）。\n请执行记忆巩固（consolidation），输出一个决策 JSON 数组。\n\n【决策格式（必须严格遵守）】\n每个决策必须是对象，字段固定：\n- \"action\"：必填。取值只能是 \"keep\" / \"merge\" / \"archive\" / \"update\" / \"conflict\" 之一（字段名必须是 action，严禁写成 type）\n- \"ids\"：必填，数组，本决策涉及的记忆 id 列表\n- \"reason\"：可选，字符串，决策理由\n- \"importance\"：可选，整数 1-5\n- merge 额外字段：\"keepSource\"（单个 id 字符串，必须是 ids 之一）+ 合并后的 \"title\"、\"content\"\n- conflict 额外字段：\"winner\" 与 \"loser\"，都是【单个 id 字符串，不是数组】\n- update 额外字段：修正后的 \"title\" 和/或 \"content\"；\"ids\" 只能包含一个 id\n\n【决策 JSON 示例】\n[\n  { \"action\": \"merge\", \"ids\": [\"m1\", \"m2\"], \"keepSource\": \"m1\", \"title\": \"合并标题\", \"content\": \"合并后的摘要内容\", \"importance\": 4, \"reason\": \"主题相近\" },\n  { \"action\": \"conflict\", \"winner\": \"m3\", \"loser\": \"m4\", \"reason\": \"内容矛盾，保留更新的信息\" },\n  { \"action\": \"update\", \"ids\": [\"m5\"], \"content\": \"修正后的内容\", \"reason\": \"信息过时\" },\n  { \"action\": \"archive\", \"ids\": [\"m6\"], \"reason\": \"重复或过时\" }\n]\n\n【任务】\n1. 识别主题相近的条目 → merge（合并为更精炼的摘要，保留信息最完整的 id 作为 keepSource）\n2. 识别重复/过时信息 → archive\n3. 识别内容矛盾的条目 → conflict（按时间新旧、来源完整性、信息具体程度判断 winner/loser）\n4. 发现单条记忆中的信息过时、错误或遗漏 → update（直接修正内容）\n   - update 的 ids 只能包含一个 id\n   - 必须提供修正后的 title 和/或 content\n   - 仅当内容确实需要修正时才使用，不要滥用\n   - 每次整理最多输出 2 个 update\n   - 24 小时内新建的记忆不可 update\n5. 无问题的条目无需输出（未提及的条目将自动保留 keep）\n\n【硬性规则】\n- 字段名必须精确为 \"action\"，严禁写成 \"type\"；字段名统一用双引号\n- conflict 的 winner/loser、merge 的 keepSource 都是【单个 id 字符串，绝不是数组】\n- 每条记忆最多被 claim 一次：同一个 id 不能出现在多个决策中（同一 id 不能被 merge 和 conflict/archive 等重复占用）\n- 未在决策中提及的记忆将自动保留（keep），无需为每条记忆输出 keep\n- merge 的 keepSource 必须是 ids 之一\n- 仅合并同类型条目（type 相同）\n- 不要编造 ids；只使用提供的 id\n- 重要性 1-5，合并后取最高\n- archive 仅用于确属「重复或已过时」的条目；rejected_solution / constraint / pitfall / preference / pattern 属长保留类型，除非确属重复或过时，否则不要归档\n- 每次整理最多输出 8 个 archive\n- 只输出 JSON 数组，不要其他文字",
+    "en": "You are the memory consolidation assistant. Below are all memory entries (id, type, title, content, importance, updated time).\nPerform memory consolidation and output a JSON array of decisions.\n\n[Decision format (must be followed strictly)]\nEach decision must be an object with fixed fields:\n- \"action\": required. Value must be one of \"keep\" / \"merge\" / \"archive\" / \"update\" / \"conflict\" (the field name must be action, never type)\n- \"ids\": required, array, the list of memory ids involved in this decision\n- \"reason\": optional, string, rationale for the decision\n- \"importance\": optional, integer 1-5\n- merge extra fields: \"keepSource\" (a single id string, must be one of ids) plus the merged \"title\" and \"content\"\n- conflict extra fields: \"winner\" and \"loser\", each a [single id string, never an array]\n- update extra fields: the corrected \"title\" and/or \"content\"; \"ids\" may contain only one id\n\n[Decision JSON examples]\n[\n  { \"action\": \"merge\", \"ids\": [\"m1\", \"m2\"], \"keepSource\": \"m1\", \"title\": \"Merged title\", \"content\": \"Merged summary content\", \"importance\": 4, \"reason\": \"similar topics\" },\n  { \"action\": \"conflict\", \"winner\": \"m3\", \"loser\": \"m4\", \"reason\": \"content contradicts; keep the newer information\" },\n  { \"action\": \"update\", \"ids\": [\"m5\"], \"content\": \"corrected content\", \"reason\": \"information outdated\" },\n  { \"action\": \"archive\", \"ids\": [\"m6\"], \"reason\": \"duplicate or outdated\" }\n]\n\n[Task]\n1. Identify entries with similar topics -> merge (merge into a more refined summary; keep the id with the most complete information as keepSource)\n2. Identify duplicate/outdated information -> archive\n3. Identify entries with contradictory content -> conflict (judge winner/loser by recency, source completeness, and information specificity)\n4. Find outdated, wrong, or missing information in a single memory -> update (correct the content directly)\n   - update's ids may contain only one id\n   - must provide the corrected title and/or content\n   - use only when the content truly needs correction; do not abuse\n   - output at most 2 updates per consolidation run\n   - memories created within the last 24 hours must not be updated\n5. Entries without issues need no output (unmentioned entries are automatically kept)\n\n[Hard rules]\n- Field names must be exactly \"action\", never \"type\"; use double quotes for all field names\n- conflict winner/loser and merge keepSource are [single id strings, never arrays]\n- Each memory may be claimed at most once: the same id must not appear in multiple decisions (an id must not be claimed by both merge and conflict/archive, etc.)\n- Memories not mentioned in any decision are automatically kept (keep); no need to output keep for every memory\n- merge keepSource must be one of ids\n- Only merge entries of the same type (identical type)\n- Never invent ids; use only the provided ids\n- Importance is 1-5; after a merge take the highest\n- Write every title, content, and reason in English\n- archive is only for entries that are genuinely \"duplicate or outdated\"; rejected_solution / constraint / pitfall / preference / pattern are long-retention types — do not archive them unless they are truly duplicate or outdated\n- output at most 8 archives per consolidation run\n- Output only the JSON array, nothing else"
   },
   "conflict": {
     "zh": "你是记忆库冲突仲裁助手。下面是检测到的高相似度记忆对，可能内容矛盾或重复。\n对每一对输出一个 decision 对象：\n- 两条确实矛盾/重复 → { \"action\": \"conflict\", \"winner\": <保留的id>, \"loser\": <归档的id>, \"reason\": \"理由\" }\n- 两条只是主题相近、并无矛盾 → { \"action\": \"keep\", \"ids\": [<两个id>] }\n规则：\n- winner 应为信息更完整、更新或更可信的一条\n- 只使用提供的 id，不要编造\n- 每对必须输出一个 decision\n- 只输出 JSON 数组，不要其他文字",

package/src/local-embedder.js

@@ -30,7 +30,7 @@ function modelHash(model) {
  * transformers 的选项里。
  */
 async function defaultPipelineLoader(task, model, options) {
-  const { runtimeDir, ...pipelineOptions } = options ?? {};
+  const { runtimeDir, remoteHost, ...pipelineOptions } = options ?? {};
   const { module } = await loadTransformers({
     runtimeDir: runtimeDir || defaultRuntimeDir()
   });
@@ -41,6 +41,11 @@ async function defaultPipelineLoader(task, model, options) {
   // model is fully cached locally. Mirroring the cache_dir onto env.cacheDir
   // makes that pre-check resolve locally too — fully offline loading.
   if (pipelineOptions.cache_dir) env.cacheDir = pipelineOptions.cache_dir;
+  // issue #188 补充：embedModelMirror 此前是死配置（定义了但全仓无人读取）。
+  // transformers.js 不认 HF_ENDPOINT（那是 Python huggingface_hub 的变量），
+  // 模型下载源由 env.remoteHost 决定——把镜像接到真正的开关上，否则
+  // huggingface.co 不可达的网络连模型都下不下来。
+  if (remoteHost) env.remoteHost = remoteHost;
   return pipeline(task, model, pipelineOptions);
 }
 
@@ -72,6 +77,8 @@ export class LocalEmbedder {
     // 自管运行时根目录（issue #131）：空表示用默认位置，具体解析交给 loader。
     this.runtimeDir = String(opts.runtimeDir ?? "").trim();
     this.useDtype = opts.useDtype || "q8";
+    // 模型镜像下载源（embedModelMirror，#188 补充）：空 = transformers 默认。
+    this.remoteHost = String(opts.remoteHost ?? "").trim();
     this.logger = opts.logger ?? null;
     // Test hook: replace the pipeline factory without touching modules.
     this.engineFactory = opts.engineFactory || defaultPipelineLoader;
@@ -91,6 +98,7 @@ export class LocalEmbedder {
     if (this.cacheDir) options.cache_dir = this.cacheDir;
     // 传给注入的 engineFactory，由 defaultPipelineLoader 取走后交给三层解析。
     if (this.runtimeDir) options.runtimeDir = this.runtimeDir;
+    if (this.remoteHost) options.remoteHost = this.remoteHost;
     this.extractor = await this.engineFactory("feature-extraction", this.model, options);
     this.ready = true; // service reads this to flush queued re-embeds
     this.logger?.info?.(

package/src/reranker.js

@@ -27,7 +27,7 @@ function modelHash(model) {
  * runtimeDir 取走后不混进 transformers 的选项。
  */
 async function defaultPipelineLoader(task, model, options) {
-  const { runtimeDir, ...pipelineOptions } = options ?? {};
+  const { runtimeDir, remoteHost, ...pipelineOptions } = options ?? {};
   const { module } = await loadTransformers({
     runtimeDir: runtimeDir || defaultRuntimeDir()
   });
@@ -36,6 +36,10 @@ async function defaultPipelineLoader(task, model, options) {
   // 的 cache_dir，回退到 env.cacheDir —— 即使模型已完全缓存在本地也会去请求网络。
   // embedder 侧早就镜像了，reranker 侧一直漏着，于是「已缓存 + 离线」时重排初始化会失败。
   if (pipelineOptions.cache_dir) env.cacheDir = pipelineOptions.cache_dir;
+  // issue #188 补充：embedModelMirror 此前是死配置——transformers.js 不认
+  // HF_ENDPOINT（那是 Python huggingface_hub 的变量），下载源由 env.remoteHost
+  // 决定。把镜像接到真正的开关上，huggingface.co 不可达的网络才能自动下载。
+  if (remoteHost) env.remoteHost = remoteHost;
   return pipeline(task, model, pipelineOptions);
 }
 
@@ -85,6 +89,11 @@ export class LocalReranker {
     this.cacheDir = String(opts.cacheDir ?? "").trim() || defaultModelCacheDir();
     // 自管运行时根目录（issue #131）：空表示用默认位置，解析交给 loader。
     this.runtimeDir = String(opts.runtimeDir ?? "").trim();
+    // 与嵌入层同约定：默认 q8（4 倍小的 model_quantized.onnx），"fp32" 可关。
+    // 此前不传 dtype，即使缓存里有量化文件也会去要 1GB 级的 model.onnx（#188）。
+    this.useDtype = String(opts.useDtype ?? "q8").trim() || "q8";
+    // 模型镜像下载源（embedModelMirror，#188 补充）：空 = transformers 默认。
+    this.remoteHost = String(opts.remoteHost ?? "").trim();
     this.logger = opts.logger ?? null;
     this.engineFactory = opts.engineFactory || defaultPipelineLoader;
     // Injectable seam: async (query, passage) => number. When set, init()
@@ -94,6 +103,7 @@ export class LocalReranker {
     this._batchScorer = null;
     this._queryVec = null;
     this._queryKey = null;
+    this._constantScoreWarned = false;
   }
 
   /** Load the model; throws when no strategy can be bound. */
@@ -119,9 +129,10 @@ export class LocalReranker {
   }
 
   _engineOptions() {
-    const options = { device: this.device };
+    const options = { device: this.device, dtype: this.useDtype };
     if (this.cacheDir) options.cache_dir = this.cacheDir;
     if (this.runtimeDir) options.runtimeDir = this.runtimeDir;
+    if (this.remoteHost) options.remoteHost = this.remoteHost;
     return options;
   }
 
@@ -136,8 +147,14 @@ export class LocalReranker {
         return out.map((r) => clamp01(typeof r?.score === "number" ? r.score : 0));
       };
     } else if (strategy === "tc") {
-      // Classification head: tokenize (query, passage) pairs, score with
-      // sigmoid(l1 - l0) so relevance lands in [0, 1].
+      // Classification head: score so relevance lands in [0, 1]. Branch on the
+      // output width (issue #188): a dual-logit head (num_labels=2 exports,
+      // e.g. bge-reranker-v2-m3) gives the positive class as the softmax
+      // probability sigmoid(l1 - l0); a SINGLE-logit head (e.g.
+      // Xenova/bge-reranker-base) emits one raw relevance logit per pair, and
+      // the positive class is simply sigmoid(logit) — reading l1 as l0 there
+      // collapses every score to sigmoid(0) = 0.5 and silently disables
+      // reranking (no error, status still "ready").
       this._batchScorer = async (query, passages) => {
         const { tokenizer, model } = this.pipeline;
         const inputs = tokenizer(passages.map(() => query), {
@@ -151,10 +168,10 @@ export class LocalReranker {
         const rows = [];
         for (let i = 0; i < dims[0]; i++) {
           const base = i * cols;
-          const l0 = logits.data[base];
-          const l1 = cols > 1 ? logits.data[base + 1] : l0;
-          // sigmoid(l1 - l0) == softmax probability of the positive class.
-          rows.push(clamp01(1 / (1 + Math.exp(l0 - l1))));
+          const score = cols > 1
+            ? 1 / (1 + Math.exp(logits.data[base] - logits.data[base + 1]))
+            : 1 / (1 + Math.exp(-logits.data[base]));
+          rows.push(clamp01(score));
         }
         return rows;
       };
@@ -208,6 +225,19 @@ export class LocalReranker {
         results.push({ id: chunk[j].id, score: clamp01(Number(scores[j]) || 0) });
       }
     }
+    // Silent-failure tripwire (issue #188): a reranker whose every candidate
+    // scores identically is not ranking anything — e.g. a single-logit head
+    // read through the dual-logit formula. Warn once so the degradation is
+    // observable instead of a constant 0.5 column hiding behind a "ready"
+    // status forever.
+    if (results.length > 1 && results.every((r) => r.score === results[0].score)) {
+      if (!this._constantScoreWarned) {
+        this._constantScoreWarned = true;
+        this.logger?.warn?.(
+          `[dsh-mneme] reranker scores degenerated to a constant (${results[0].score}) — check the model's output dims (single vs dual logit head)`
+        );
+      }
+    }
     return results
       .filter((r) => r.score >= this.scoreThreshold)
       .sort((a, b) => b.score - a.score);

package/src/service.js

@@ -1292,6 +1292,22 @@ export function createService({ store, mirror, config, onWrite, logger }) {
           if (m && !m.archived && INJECT_TYPES.has(m.type) && !m.forgotten && codingGate(m)) semanticItems.push(m);
         }
       }
+      // Issue #198：首轮（无向量、无缓存召回）的同步兜底——BM25 词法召回领位。
+      // 注入渲染是同步的（宿主 systemPrompt 的 contexts 不支持异步 text），
+      // 查询向量只能异步 prefetch 给下一轮，首轮必 miss；此时纯静态排序会让
+      // 老的高重要性 summary/preference 占满槽位，当前话题的 decision/project
+      // 进不来。查询文本本身就在手上，BM25 是纯进程内同步计算，词法相关性
+      // 足以把当前话题顶到前排；门控与向量路径一致（含 importance 阈值）。
+      // 语义向量命中时本分支不参与，行为不变。
+      if (!semanticItems.length) {
+        for (const hit of bm25Recall(q, maxItems * 2)) {
+          if (hit && !hit.archived && INJECT_TYPES.has(hit.type) && !hit.forgotten &&
+            codingGate(hit) &&
+            (hit.type === "summary" || hit.type === "preference" || hit.importance >= threshold)) {
+            semanticItems.push(hit);
+          }
+        }
+      }
       if (semanticItems.length) {
         const seen = new Set();
         const merged = [];

package/src/store.js

@@ -22,6 +22,9 @@ CREATE TABLE IF NOT EXISTS memories (
 );
 CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
 CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
+-- Issue #202：all()/list() 按 updated_at 排序，无索引时走临时 B 树全表排序
+-- （5k 行实测 all() 231ms → 135ms）。IF NOT EXISTS 幂等，存量库启动即建。
+CREATE INDEX IF NOT EXISTS idx_memories_updated ON memories(updated_at);
 
 -- autoDream audit trail: one row per consolidation run, capturing the exact
 -- input snapshot digest + the LLM decision list + per-id outcome + a compact
@@ -717,11 +720,51 @@ export function createStore(path) {
     }
   }
 
+  // Issue #202：embedding 解析缓存。检索路径此前每次调用都对全部带向量行
+  // JSON.parse（993 × 512 维 ≈ 48 ms/次，且 SQL 拖着 10 MB 的 TEXT），余弦本身
+  // 只占 3%。向量只经 setEmbedding 写入（单一失效点），把解析结果按 id 缓存，
+  // 命中即零解析；上限 FIFO 驱逐防大库内存无界（4000 × 512 维 double ≈ 16 MB）。
+  const embeddingCache = new Map();
+  const EMBEDDING_CACHE_MAX = 4000;
+
+  function cacheEmbedding(id, vector) {
+    if (embeddingCache.size >= EMBEDDING_CACHE_MAX && !embeddingCache.has(id)) {
+      const oldest = embeddingCache.keys().next().value;
+      embeddingCache.delete(oldest);
+    }
+    embeddingCache.set(id, vector);
+  }
+
+  /** Parsed embedding for one id (cache-first); undefined when none/parse
+   *  failure. Single read path shared by searchVector / getEmbedding(s). */
+  function getParsedEmbedding(id) {
+    const cached = embeddingCache.get(id);
+    if (cached) return cached;
+    const row = db.prepare("SELECT embedding FROM memories WHERE id = ?").get(id);
+    if (!row?.embedding) return undefined;
+    try {
+      const v = JSON.parse(row.embedding);
+      if (Array.isArray(v) && v.length) {
+        cacheEmbedding(id, v);
+        return v;
+      }
+    } catch { /* corrupt embedding text: treated as absent */ }
+    return undefined;
+  }
+
+  // all()/list() 的显式列清单：从实际 schema 派生（迁移后），只排除 embedding
+  // 列——consolidation/sleep/inject 的消费方都不读向量，而它是全表里最重的一列
+  // （5k 行库 ≈ 9.4 MB TEXT），每次全表调用都白搬。经 PRAGMA 派生而非硬编码，
+  // schema 演进时自动跟随。
+  const memoryColumns = db.prepare("PRAGMA table_info(memories)").all()
+    .map((c) => c.name)
+    .filter((n) => n !== "embedding");
+  const memoryColumnList = memoryColumns.join(", ");
+
   // Per-instance monotonic timestamp guard: consecutive writes within the same
   // millisecond must still produce strictly increasing timestamps (test asserts
   // updated_at != created_at). State lives in the store closure, not module scope.
-  let lastTs = "";
-  function nowIso() {
+  let lastTs = "";  function nowIso() {
     let ts = new Date().toISOString();
     if (lastTs && ts <= lastTs) {
       const d = new Date(lastTs);
@@ -925,6 +968,10 @@ export function createStore(path) {
         now,
         id
       );
+      // Issue #202：update 可直写 embedding（patch.embedding），缓存条目失效，
+      // 下次读取按库值重解析。宁滥勿缺——即便本 patch 未含 embedding，丢一条
+      // 缓存只多一次点查重解析。
+      embeddingCache.delete(id);
       // Desired generation bumped in the same transaction as the update (peer
       // blocker 1: crash between write and sync must still be recoverable).
       incrementGeneration();
@@ -995,6 +1042,8 @@ export function createStore(path) {
         expectedUpdatedAt
       );
       if (result.changes === 0) return; // CAS miss: a concurrent write won
+      // Issue #202：同 update——CAS 命中即可能改写 embedding，失效缓存条目。
+      embeddingCache.delete(id);
       // Only bump desired generation on a successful CAS — a miss writes nothing.
       incrementGeneration();
       applied = true;
@@ -1177,7 +1226,9 @@ export function createStore(path) {
   }
 
   function all() {
-    const rows = db.prepare("SELECT * FROM memories ORDER BY updated_at DESC").all();
+    // Issue #202：显式列清单排除 embedding——toRow 本就不输出向量，SELECT *
+    // 纯属把全表最重的列（9.4 MB TEXT/5k 行）拖进内存再丢弃。
+    const rows = db.prepare(`SELECT ${memoryColumnList} FROM memories ORDER BY updated_at DESC`).all();
     return rows.map(toRow);
   }
 
@@ -1185,6 +1236,17 @@ export function createStore(path) {
   function setEmbedding(id, vector) {
     const json = Array.isArray(vector) && vector.length ? JSON.stringify(vector) : null;
     db.prepare("UPDATE memories SET embedding = ? WHERE id = ?").run(json, id);
+    // Issue #202：单一写入口即单一失效点——重写缓存条目（向量在手上不必重解析），
+    // 清空则移除，删除过的 id 不会被下一次 searchVector 的 id 集合选中。
+    if (json) {
+      try {
+        const parsed = JSON.parse(json);
+        if (Array.isArray(parsed) && parsed.length) cacheEmbedding(id, parsed);
+        else embeddingCache.delete(id);
+      } catch { embeddingCache.delete(id); }
+    } else {
+      embeddingCache.delete(id);
+    }
   }
 
   /** Batch fetch stored embeddings by id (v0.5.0 search-time semantic dedup).
@@ -1193,19 +1255,10 @@ export function createStore(path) {
   function getEmbeddings(ids) {
     const out = new Map();
     const list = (Array.isArray(ids) ? ids : []).filter(Boolean);
-    for (let i = 0; i < list.length; i += 100) {
-      const chunk = list.slice(i, i + 100);
-      const rows = db.prepare(
-        `SELECT id, embedding FROM memories
-         WHERE embedding IS NOT NULL AND embedding != ''
-           AND id IN (${chunk.map(() => "?").join(",")})`
-      ).all(...chunk);
-      for (const row of rows) {
-        try {
-          const vec = JSON.parse(row.embedding);
-          if (Array.isArray(vec) && vec.length) out.set(row.id, vec);
-        } catch { /* corrupt row: skip */ }
-      }
+    for (const id of list) {
+      // Issue #202：走同一解析缓存（语义去重的批量读也免重复 parse）。
+      const vec = getParsedEmbedding(id);
+      if (vec) out.set(id, vec);
     }
     return out;
   }
@@ -1280,24 +1333,30 @@ export function createStore(path) {
   function searchVector(vector, { limit = 20, includeArchived = false, threshold = 0 } = {}) {
     if (!Array.isArray(vector) || !vector.length) return [];
     const archivedFilter = includeArchived ? "" : "archived = 0 AND ";
+    // Issue #202：只取 id 列（~40 KB）而非 SELECT *（~11 MB）——向量从缓存取，
+    // 缓存未命中时按 id 点查 embedding 再解析回填。SQL 里保留 embedding 的
+    // IS NOT NULL 过滤，保证「有向量的行」集合始终以库为准（删除/清空即时生效）。
     const rows = db.prepare(
-      `SELECT * FROM memories
+      `SELECT id FROM memories
        WHERE ${archivedFilter}forgotten = 0 AND embedding IS NOT NULL AND embedding != ''`
     ).all();
     const scored = [];
     for (const row of rows) {
-      let v;
-      try {
-        v = JSON.parse(row.embedding);
-      } catch {
-        continue;
-      }
+      const v = getParsedEmbedding(row.id);
+      if (!v) continue;
       const score = cosine(vector, v);
-      if (score >= threshold) scored.push({ row, score });
+      if (score >= threshold) scored.push({ row: { id: row.id }, score });
     }
     scored.sort((a, b) => b.score - a.score);
     const { limit: lim } = sanitizePage(limit, 0, 20);
-    return scored.slice(0, lim).map(({ row, score }) => ({ ...toRow(row), score }));
+    // Top-N 回表：只对入选行取完整字段（主键点查 ≤ lim 行），评分别拖着正文走。
+    const getFull = db.prepare("SELECT * FROM memories WHERE id = ?");
+    const out = [];
+    for (const { row, score } of scored.slice(0, lim)) {
+      const full = getFull.get(row.id);
+      if (full) out.push({ ...toRow(full), score });
+    }
+    return out;
   }
 
   // --- autoDream audit trail ----------------------------------------------
@@ -2245,6 +2304,7 @@ export function createStore(path) {
     search,
     setEmbedding,
     getEmbeddings,
+    getParsedEmbedding,
     embeddedCount,
     needsEmbedding,
     searchVector,

package/src/summarize.js

@@ -144,7 +144,7 @@ function collectMessages(session, maxChars = 8000, language = "zh") {
         break;
     }
   }
-  return lines.length ? [createUserMessage({ content: [{ type: "text", text: trim(lines.join("\n"), maxChars) }] })] : [];
+  return lines.length ? [createUserMessage({ content: [{ type: "text", text: trim(lines.join("\n"), maxChars) }], source: { kind: "plugin", plugin: "dsh-mneme" } })] : [];
 }
 
 // ── 智能调速器（429 保护）─────────────────────────────────────────────
@@ -265,7 +265,7 @@ export function createSummarizer(ctx, service, config) {
         model: route.model,
         purpose: "summarization",
         messages: [
-          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)] }] },
+          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)] }], source: { kind: "plugin", plugin: "dsh-mneme" } },
           ...messages
         ],
         signal: controller.signal

package/src/tools.js

@@ -39,6 +39,8 @@ const MEMORY_ITEM_SCHEMA = {
     updated_at: { type: "string", required: true }
   }
 };
+// 导出供回归测试断言 memory_get 与共享 schema 同源（#184 防漂移护栏）。
+export { MEMORY_ITEM_SCHEMA };
 
 // v0.8.0 A2：occurred 时间窗参数 → store 过滤选项（list/count 同口径）；
 // 未传参返回空对象，既有调用方不受影响。（A3 复核：此处入参仅含 occurred 边界。）
@@ -277,25 +279,10 @@ export function createTools(ctx, service, config, embedder) {
           type: "object",
           additionalProperties: false,
           properties: {
-            memory: {
-              type: "object",
-              additionalProperties: false,
-              properties: {
-                id: { type: "string", required: true },
-                title: { type: "string", required: true },
-                type: { type: "string", required: true },
-                importance: { type: "integer", required: true },
-                tags: { type: "array", items: { type: "string" } },
-                content: { type: "string", required: true },
-                source: { type: "string" },
-                agent_scope: { type: "string" },
-                workspace_scope: { type: "string" },
-                sensitivity: { type: "string" },
-                occurred_at: { type: "string" },
-                created_at: { type: "string" },
-                updated_at: { type: "string" }
-              }
-            }
+            // 与 memory_search / memory_list 共用同一份 item schema——DTO 由
+            // toApiList 统一产出，内联副本曾漏掉 v0.8.1 的 scope 来源三键，
+            // 任何被标注过的行都过不了 in-process 校验（#184）。
+            memory: MEMORY_ITEM_SCHEMA
           }
         },
         render: (_args, value) => {

package/src/vector-index.js

@@ -56,14 +56,8 @@ export function createVectorIndex({ store, logger }) {
 
     /** Read one memory's cached vector; undefined when none/parse failure. */
     getEmbedding(id) {
-      const row = db.prepare("SELECT embedding FROM memories WHERE id = ?").get(id);
-      if (!row?.embedding) return undefined;
-      try {
-        const v = JSON.parse(row.embedding);
-        return Array.isArray(v) && v.length ? v : undefined;
-      } catch {
-        return undefined;
-      }
+      // Issue #202：走 store 的解析缓存（与 searchVector/getEmbeddings 同源）。
+      return store.getParsedEmbedding(id);
     },
 
     /** Cosine search over embedded rows; results carry a 0..1 score. */

package/test/api.test.js

@@ -1394,6 +1394,11 @@ test("POST /api/dsh-mneme/test-model succeeds and reports reply + latency", asyn
   assert.equal(data.modelId, "deepseek:deepseek-chat", "modelId reports the probed route");
   assert.equal(MOCK_LLM.lastOptions.provider, "deepseek");
   assert.equal(MOCK_LLM.lastOptions.purpose, "dsh-mneme-connectivity-test");
+  // 回归：探测必须是一条 user 消息（带 source）。system-only 对话自
+  // 0.1.6-alpha.1 起被官方 API 整单拒绝（「messages: at least one message
+  // is required」），探测按钮会 502。
+  assert.equal(MOCK_LLM.lastOptions.messages[0].role, "user");
+  assert.equal(MOCK_LLM.lastOptions.messages[0].source?.kind, "plugin");
   assert.equal("reasoningEffort" in MOCK_LLM.lastOptions, false, "no effort configured -> field omitted");
 });