@modusensus/dsh-mneme 0.8.16 → 0.9.1

package/src/config.js

@@ -91,7 +91,8 @@ export const Config = z.object({
   // feature_flags 的值永远优先于这里的默认值。
   injectGuidanceEnabled: z.boolean().default(true),
   // #249 N3（压缩边缘双落点）：上下文即将大幅精简前抢救「正在做什么」。默认关。
-  // 触发靠宿主自己的压缩事件（`compaction/start|summary|end`，都在事件白名单里），
+  // 触发只认「历史真的被折叠了」的压缩事件（summary / prune / 不带 error 的 end；
+  // 判定见 continuity.js 的 isCompactionEdge —— start 只是「试过」，带 error 的 end 是失败收尾），
   // 不自定一套阈值参数——「压缩边缘」由宿主定义，我们再校准一份只会与之漂移。
   // 为什么是「新时机 + 新表面」因而默认关：它往对话里**追加消息**（新的注入表面，
   // 参照实现里最容易累积成一堆历史的那类），并多写一张提案表。按 §10 判据，引入
@@ -414,6 +415,13 @@ export const Config = z.object({
   // in the background after a short delay, rate-limited in batches. On by
   // default; set false to keep the backfill manual only.
   autoReindexOnBoot: z.boolean().default(true),
+  // Backfill pacing (previously hardcoded 500 / 10 / 200 in semantic.js). A
+  // fixed 500-per-boot cap meant a 4k-row backlog needed nine restarts to
+  // clear, and nothing reported that the run had been capped.
+  // reindexMaxPerBoot = 0 means "no cap, drain the whole backlog this run".
+  reindexMaxPerBoot: z.natural().default(500),
+  reindexBatchSize: z.natural().min(1).max(64).default(10),
+  reindexRateLimitMs: z.natural().default(200),
   // Semantic-first injection (Bug4): when enabled, injectCandidates with a
   // non-empty query recalls via the vector index first and falls back to the
   // rule-based pick to fill/dedupe. Empty query / no vector → legacy behavior.
@@ -481,6 +489,13 @@ export const Config = z.object({
   reflectionFailureTracking: z.boolean().default(true),
   reflectionUpdateMaxPerRun: z.natural().min(0).max(5).default(2),
   reflectionUpdateMinAgeHours: z.natural().min(0).max(168).default(24),
+  // failure_memories 的启动期保留期（天）。此前在 index.js 里写死 90，是这一族
+  // 四张启动期清理表里唯一没有键可陈述的一条（#275 伞下的欠账）。形态对齐
+  // recallRetentionDays：顶层扁平键、只从配置文件改；暂不进 settings.js 白名单，
+  // 面板可调是后续的事（那要同时补 api.js 的 NESTED 表与 client.js 的面板行）。
+  // 下限取 1 而非 0：这张表的用途是「挖掘重复出现的纠正模式」，窗口太短就只剩
+  // 最近一次；要彻底停掉清理应当显式关掉 reflectionFailureTracking。
+  reflectionFailureRetentionDays: z.natural().min(1).max(3650).default(90),
 
   // --- conflict freeze: manual review for conflicting memories (v0.2.1) ---
   // Opt-in by default: when true, conflicting memories are not auto-merged
@@ -828,10 +843,15 @@ export const Config = z.object({
 
   // --- scope: v0.8.0 A1 存储层（issue #17）--------------------------------
   // 总开关默认关：关闭时写入不标注 scope、去重维持 (type, title) 现状，行为
-  // 逐字节不变。开启后 memory_save 写入 agent_scope（session header 的
-  // agentPreset）与 workspace_scope（registry 反查 canonical path，header.cwd
-  // 兜底，取不到 NULL——解析绝不阻塞写入），去重键扩展为 (type, title,
-  // agent_scope, workspace_scope, sensitivity)。检索侧加权/过滤在 A2/A3 落地。
+  // 逐字节不变。开启后**两条写入路径都自动盖章**（*_scope_source='auto'）：
+  // ① 工具调用（tools.js：memory_save / memory_update，显式参数改标 'explicit'）
+  // ② 机器提炼（summarize.js：会话蒸馏；合并进既有行时不盖章，作用域属于那一行
+  //    原来被提炼出来的语境——v0.9.0 补，此前只有工具路径盖章，于是「项目记忆」
+  //    在库里几乎不存在）。
+  // 两路的值同源：agent 维取 session header 的 agentPreset，workspace 维取
+  // registry 反查的 canonical path（header.cwd 兜底，取不到 NULL——解析绝不阻塞
+  // 写入），去重键扩展为 (type, title, agent_scope, workspace_scope, sensitivity)。
+  // 检索侧加权/过滤在 A2/A3 落地。
   // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
   scopeEnabled: z.boolean().default(false),
   // strictScope（A3）：硬过滤模式。关闭=A2 软隔离（他 scope 降权保留可见，
@@ -842,6 +862,39 @@ export const Config = z.object({
   // 打开才有意义（没有写入标注就无可过滤维度），但独立成键：可先开标注积累
   // 数据、观察 A2 加权质量后再切硬过滤。
   strictScope: z.boolean().default(false),
+
+  // --- v0.9.0 M.O.（Modus Operandi · 手法，beta）--------------------------
+  // 命名：M.O. = Modus Operandi，拉丁语「一个人一贯的做事方式」，缩写 M.O.；
+  // 也正是 org 词根 modus（modusensus）。界面主显示 M.O.，设置项 hint 第一句
+  // 给全名——缩写不靠注释解释，靠用户第一眼能看见全名。
+  // 这是客户端只读视图（做法图谱 + 对话行结算卡）的门控。API 的 effective 取值只认
+  // config 顶层/嵌套路径，schema 里没有这个键 → effective 静默少键 → 客户端读
+  // 不到就一个座位都不注册（#254 漏登记 NESTED_FLAG_PATHS 是同一个坑）。
+  // 默认关：beta 功能必须 opt-in，老用户行为逐字节不变。不进 LIGHT_MODE_OFF——
+  // 它只是只读视图、不引入任何重型后台路径，轻量档用户显式勾选仍然赢（预设
+  // 该关的是重型能力，不该替用户关掉一个纯 UI 入口）。
+  // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
+  actionPipelineEnabled: z.boolean().default(false),
+
+  // M.O. 执行记账（v0.9.0 第二批）：`/mo-run` 显式开一次执行窗口，窗口内的命令执行
+  // 才可能被记成一条 run。与上面那个键**分开**：上面管「看图的座位」，这个管
+  // 「往账本里写」——看图和写账是两件事，混成一个键会让「只想看图」的人不知不觉
+  // 获得写入能力。
+  //
+  // 默认关（beta 必须 opt-in）。它挂在热路径上（每个会话事件都过一次监听），
+  // 所以轻量档要关掉：`LIGHT_MODE_OFF` 里有它。
+  actionRunEnabled: z.boolean().default(false),
+
+  // --- 人格定义页（beta）---------------------------------------------------
+  // 注入器渲染人格段的顶层总闸（双闸门的 config 半边；user_settings "persona"
+  // 键内的 persona.enabled 是 per-agent 半边，两闸同真才渲染）。API 的 effective
+  // 必须含这个键——schema 里没有它 effective 就静默少键，面板开关形同虚设
+  // （#254 漏登记 NESTED_FLAG_PATHS 是同一个坑，计数锁 test/api.test.js 钉住）。
+  // 默认关：beta 功能必须 opt-in，老用户行为逐字节不变。不进 LIGHT_MODE_OFF——
+  // 人格段是用户自写的一小段轻量常驻文本，不引入任何重型后台路径，轻量档用户
+  // 显式勾选仍然赢（同 actionPipelineEnabled 的定性）。
+  // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
+  personaEnabled: z.boolean().default(false)
 });
 
 // Fields forced to false by the light-mode preset. Everything not listed here
@@ -888,7 +941,11 @@ const LIGHT_MODE_OFF = [
   // #399：轻量档不开蒸馏原文留存——它是一份对话原文副本（磁盘 + 暴露面），
   // 与轻量档「小模型 / 小上下文 / 少留痕」的取向相反。默认关，这里只是
   // 轻量预设再确认一次；用户显式勾选仍然赢（合并顺序同 continuityRescueEnabled）。
-  "distillRecords.enabled"
+  "distillRecords.enabled",
+  // M.O. 执行记账：它挂在**热路径**上（每个会话事件都过一次监听）。轻量档的取向
+  // 是「小模型 / 小上下文 / 少常驻路径」，这与一个每事件都过一遍的监听器相冲突。
+  // 默认关，这里只是轻量预设再确认一次；用户显式勾选仍然赢（合并顺序同上面两条）。
+  "actionRunEnabled"
 ];
 
 /**

package/src/continuity.js

@@ -15,9 +15,11 @@ import { createUserMessage } from "@deepseek-ai/dsh-llm";
 //    也只用本地字符串比较；门控成本为零。
 // 4. **触发器就是宿主真的压缩**，不自定一套阈值。宿主在 `agent/pre-step`（压力）与
 //    `agent/request-error`（溢出）两处触发压缩，我们只订阅压缩事件
-//    （`compaction/start|summary|end`，都在 @deepseek-ai/dsh-session 的事件白名单里
+//    （`compaction/*` 一族，都在 @deepseek-ai/dsh-session 的事件白名单里
 //     `lib/types/known-event-types.js:31-34`）。自定阈值会与宿主口径漂移，还多一份没
 //    人校准的参数；「压缩边缘」本来就有宿主自己下的定义。
+//    **但发过压缩事件不等于这段历史真的被折叠了** —— 压缩插件在每一步都会试一次，
+//    失败时没有任何东西需要抢救。记账口径见 isCompactionEdge。
 //
 // 落点顺序（为什么 pre-step 里挂得住）：宿主的压缩插件在它自己的 pre-step 监听器里先
 // `await compactIfNeeded(...)` 再 `return next()`，所以我们的监听器拿到 `next()` 结果
@@ -38,7 +40,34 @@ export const CONTINUITY_NOTICE_MAX = 900;
 /** 边缘表的兜底上限：只留序号、且有界——压缩完就没有下一次 pre-step 的会话不走消费路径。 */
 const MAX_TRACKED_EDGES = 50;
 
-const EDGE_EVENT_TYPES = new Set(["compaction/start", "compaction/summary", "compaction/end"]);
+/**
+ * 什么算「一个真的边缘」= 这段历史**真的被折叠了**。
+ *
+ * 这跟「有人发过压缩事件」不是同一个问题。压缩插件在**每一步**都会试一次压缩
+ * （`agent/pre-step` 里的 `compactIfNeeded`），所以 `compaction/start` 只在说
+ * 「有人试过」；尝试失败时没有任何东西需要抢救。按「试过就救」记账会得到一个
+ * **每步都触发**的触发器 —— 实测（2026-10-14，本机两个长会话、12,000+ 事件，
+ * 代理层把 dsh 原生压缩 100% 拒掉）：
+ *
+ *   · 按 `start|summary|end` 记账：1,287 次置位 / 359 次注入（4c28eaaa：2,895 / 625）
+ *   · 按「真落地」记账：  39 次置位 /  32 次注入（4c28eaaa：  161 /  74）→ 降 91% / 88%
+ *
+ * 三种「真落地」：
+ * - `compaction/summary`：宿主压缩成功才落（dsh-compaction-basic 的
+ *   `commitCompactionBody`，与成功路同步提交；失败路不落）。
+ * - `compaction/prune`：宿主把旧事件折叠出表面（dsh-compaction-tool-result-pruner），
+ *   是「表面真的变短了」最直接的证据。
+ * - `compaction/end`：**成败两条路都发**（同一份源码：失败路
+ *   `append("compaction/end", { ...lifecycle, error: errorChain(error) })`），
+ *   所以只有**不带 error** 的那条才算落地。
+ */
+function isCompactionEdge(event) {
+  const type = event?.type;
+  if (type === "compaction/summary" || type === "compaction/prune") return true;
+  if (type !== "compaction/end") return false;
+  const error = event?.data?.error;
+  return error === undefined || error === null || error === "";
+}
 
 // 与 summarize.js 的 collectMessages 同一个口径：只取公开文本块，reasoning 私有推理
 // 不进快照（快照可能被宿主重建进摘要）。刻意副本而不是导出——那边是会话蒸馏的内部
@@ -148,21 +177,21 @@ function noticeAlreadyInSurface(session, text) {
  * 保持"挂上就是开"的单一口径。
  */
 export function createContinuityRescue(ctx, store) {
-  // 待处理的边缘：sessionId → 压缩事件序号。压缩事件到达时置位，下一次 pre-step 消费后
+  // 待处理的边缘：sessionId → 压缩事件序号。**真落地**的压缩事件到达时置位，下一次 pre-step 消费后
   // 删除（同一个边缘绝不注入第二次）。只留序号、不留 Session：插件在宿主进程里只 apply
   // 一次、服务所有会话，握着 Session 就是握着它的全量日志不放——压缩完就收工、不再有
   // pre-step 是常见路径，这些条目永远走不到消费路径上。
   const edge = new Map();
 
   const unsubscribe = ctx.on("session/event", (session, event) => {
-    if (!EDGE_EVENT_TYPES.has(event?.type)) return;
+    if (!isCompactionEdge(event)) return;
     if (!session?.id) return;
     if (!edge.has(session.id) && edge.size >= MAX_TRACKED_EDGES) {
       // 兜底淘汰最旧的（Map 是插入序）：这里漏掉最坏也只少一次注入，不会无界增长。
       edge.delete(edge.keys().next().value);
     }
-    // 同一轮压缩会依次落 start/summary/end，后到的覆盖前一个：留着最后一个（更有
-    // 信息——summary 带摘要事件 seq），序号即触发证据。
+    // 同一轮可能出现多条落地事件（prune 与 end 并存），后到的覆盖前一个：留着最后一个，
+    // 序号即触发证据。
     edge.set(session.id, typeof event.seq === "number" ? event.seq : null);
   });
 

package/src/dream/decisions.js

@@ -395,6 +395,12 @@ function casGuard(service, snapshot, ids) {
  *   provided, every decision target is CAS-checked against it and a decision
  *   computed from stale state is skipped and reported as a conflict instead of
  *   overwriting concurrent writes (item ①).
+ * @param config - pipeline config; `config.mintSource` (optional string) is the
+ *   provenance stamped on memories minted by `create` decisions. It is
+ *   read from the CALLER, never from the decision object: the LLM authors
+ *   `create` payloads and validateDecisions does not strip unknown fields, so
+ *   trusting `d.source` would let a model label its own output as human-written.
+ *   Absent/blank → saveWithDedupe's existing "manual" fallback (unchanged).
  * @returns {{ applied: number, conflicts: Array, failures: Array, committed: Array }}
  *   applied    - number of decisions/memories actually committed (archive counts
  *                each archived memory as one, merge/conflict/update count one).
@@ -484,7 +490,17 @@ function applyCreate(d, service, config = {}) {
   const body = evidence.length > 0
     ? STR.evidenceSuffix[language](content, evidence)
     : content;
-  const created = service.saveWithDedupe({ type, title, content: body, importance });
+  // mint 来源由调用方（管道）给，不从决策对象取——LLM 能自己写 d.source，
+  // 信它就等于让模型给自造条目盖「人写的」戳（见 applyDecisions 的 @param config）。
+  // 取不到就一个字段都不传，落回 saveWithDedupe 原有的兜底，行为与改前一致。
+  const mintSource = typeof config?.mintSource === "string" ? config.mintSource.trim() : "";
+  const created = service.saveWithDedupe({
+    type,
+    title,
+    content: body,
+    importance,
+    ...(mintSource ? { source: mintSource } : {})
+  });
   const memory = created?.memory;
   if (!memory) return "skipped"; // deduped/subsumed: nothing minted, clean no-op
   return { applied: 1, committed: { action: "create", id: memory.id, type } };

package/src/dream/sleep.js

@@ -381,7 +381,11 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     allowedActions: actionSet === "full" ? null : LEGACY_ACTIONS
   });
   if (!ok) return { status: "failed", error: `invalid decisions: ${errors.join("; ")}`, skipped };
-  const { applied, failures, conflicts } = applyDecisions(decisions, service, logger, snapshot, config);
+  // 同 phasePatterns——本相位的 create 也落 source=sleep（默认档的
+  // LEGACY_ACTIONS 含 create，理论上可 mint）。
+  const { applied, failures, conflicts } = applyDecisions(
+    decisions, service, logger, snapshot, { ...config, mintSource: "sleep" }
+  );
   // Issue #126 review（Copilot）：事务内 service.update 会跳过 scheduleEmbed（txDepth>0），
   // 而 sleep 路径此前没有 dream 那样的 post-apply 索引维护——differentiate 的差异注记与
   // supersede 的归档都反映不到缓存向量，"注记进 embedding 防再判重复"就是空承诺。
@@ -525,7 +529,11 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     maxCreatePerRun: maxPatterns
   });
   if (!ok) return { status: "failed", error: `invalid decisions: ${errors.join("; ")}` };
-  const { applied, failures, conflicts } = applyDecisions(decisions, service, logger, snapshot, config);
+  // 本相位的 create 落 source=sleep。来源从管道给而非从决策对象取——见
+  // applyDecisions 的 @param config。
+  const { applied, failures, conflicts } = applyDecisions(
+    decisions, service, logger, snapshot, { ...config, mintSource: "sleep" }
+  );
   return {
     status: applied > 0 ? "ok" : "noop",
     scanned: memories.length,

package/src/dream.js

@@ -1309,7 +1309,11 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // a target changed during the LLM call is skipped and reported as a
     // conflict instead of being overwritten (item ①). Frozen conflicts are
     // excluded from this list (they are parked, not applied).
-    const { applied, conflicts, failures, committed } = applyDecisions(applyList, service, logger, snapshot, config);
+    // mint 来源：主链路的 create 落 source=dream。来源从管道给而非从决策对象取——
+    // 见 applyDecisions 的 @param config。
+    const { applied, conflicts, failures, committed } = applyDecisions(
+      applyList, service, logger, snapshot, { ...config, mintSource: "dream" }
+    );
     // Per-record receipt chain: one row per actually-committed merge/conflict/
     // update verdict, stamped with the decision-basis digest + idempotency
     // counters (count_before → count_after). Written here, before the run audit

package/src/embedding.js

@@ -69,9 +69,51 @@ export async function embedText({ baseUrl, apiKey, model }, text) {
  * successful embed the model that produced the vectors is recorded, so the
  * index can detect drift and the auto-reindex backfill knows what to rebuild.
  */
+/**
+ * Bounded receipt ring for embedding attempts.
+ *
+ * Why a ring instead of llm_audit_logs: a full backfill is thousands of
+ * attempts, and one audit row each would bury the LLM calls that table exists
+ * to trace. What the user actually needs in order to answer "is the vector
+ * layer silently dead right now?" is the recent window plus running totals —
+ * which costs nothing and cannot flood.
+ */
+const RECEIPT_LIMIT = 200;
+
+function createReceiptLedger() {
+  const recent = [];
+  const totals = { ok: 0, failed: 0, skipped: 0 };
+  let lastOkAt = null;
+  let lastFailAt = null;
+  let lastFailReason = null;
+  return {
+    record(entry) {
+      recent.push(entry);
+      if (recent.length > RECEIPT_LIMIT) recent.shift();
+      if (entry.status in totals) totals[entry.status]++;
+      if (entry.status === "ok") lastOkAt = entry.at;
+      else if (entry.status === "failed") {
+        lastFailAt = entry.at;
+        lastFailReason = entry.reason ?? null;
+      }
+    },
+    snapshot() {
+      return {
+        totals: { ...totals },
+        lastOkAt,
+        lastFailAt,
+        lastFailReason,
+        recent: recent.slice(-RECEIPT_LIMIT)
+      };
+    }
+  };
+}
+
 export function createEmbedder({ store, settings, logger, vectorIndex }) {
   // Dimension of the most recent successful embed, exposed for fingerprinting.
   let _dimension = 0;
+  // Per-write embed receipts (see createReceiptLedger above).
+  const ledger = createReceiptLedger();
 
   /** Record the producing model fingerprint in vector_meta (best-effort). */
   function markModel(cfg, dimension) {
@@ -85,19 +127,52 @@ export function createEmbedder({ store, settings, logger, vectorIndex }) {
   // ready/configured 两个 getter 共用，避免以后改一处漏一处。
   const configComplete = (cfg) => !!(cfg?.enabled && cfg.baseUrl && cfg.apiKey && cfg.model);
 
+  /**
+   * Embed one memory and store the vector. Never throws — a flaky endpoint
+   * must not break memory writes — but it now REPORTS what happened instead
+   * of returning undefined on both success and failure. Callers that ignore
+   * the result are unaffected; callers that care get a receipt.
+   *
+   * @returns {Promise<{status:"ok"|"failed"|"skipped", id:string,
+   *   at:string, reason?:string, dim?:number, model?:string}>}
+   */
   async function embedFor(id, title, content) {
+    const at = new Date().toISOString();
     const cfg = settings.getVectorConfig();
-    if (!configComplete(cfg)) return;
+    if (!configComplete(cfg)) {
+      const entry = { status: "skipped", id, at, reason: "vector-config-incomplete" };
+      ledger.record(entry);
+      return entry;
+    }
     const text = [title, content].filter(Boolean).join("\n");
-    const vector = await embedText(cfg, text);
-    if (vector) {
-      store.setEmbedding(id, vector);
-      _dimension = vector.length;
-      // Bug3: record which model produced the current vectors so the index can
-      // detect drift and skip a redundant backfill when nothing changed.
-      markModel(cfg, vector.length);
-      logger?.info?.(`[dsh-mneme] embedded memory ${id} (dim=${vector.length})`);
+    let vector = null;
+    try {
+      vector = await embedText(cfg, text);
+    } catch (error) {
+      const entry = { status: "failed", id, at, reason: String(error) };
+      ledger.record(entry);
+      logger?.warn?.(`[dsh-mneme] embed memory ${id} failed: ${String(error)}`);
+      return entry;
+    }
+    if (!vector) {
+      // embedText swallows the HTTP detail (404 / timeout / malformed body all
+      // resolve to null). The receipt still has to say "no vector", which is
+      // exactly the fact the write path never used to report.
+      const entry = { status: "failed", id, at, reason: "embedding-request-returned-no-vector" };
+      ledger.record(entry);
+      logger?.warn?.(`[dsh-mneme] embed memory ${id} produced no vector`);
+      return entry;
     }
+    const model = modelHashOf(cfg.model);
+    store.setEmbedding(id, vector, model);
+    _dimension = vector.length;
+    // Bug3: record which model produced the current vectors so the index can
+    // detect drift and skip a redundant backfill when nothing changed.
+    markModel(cfg, vector.length);
+    const entry = { status: "ok", id, at, dim: vector.length, model };
+    ledger.record(entry);
+    logger?.info?.(`[dsh-mneme] embedded memory ${id} (dim=${vector.length})`);
+    return entry;
   }
 
   return {
@@ -120,10 +195,26 @@ export function createEmbedder({ store, settings, logger, vectorIndex }) {
     get configured() {
       return configComplete(settings.getVectorConfig());
     },
-    /** Fire-and-forget re-embed of a memory after any write. */
+    /**
+     * Re-embed a memory after any write. Still non-blocking — the caller does
+     * not have to await it — but it now RETURNS the receipt promise so a
+     * caller that wants to know can. Previously this returned undefined and
+     * swallowed the rejection, so "did this write get a vector?" had no answer
+     * anywhere in the process. Swallowing still applies to the rejection
+     * itself: a vector failure must never break the memory write.
+     */
     schedule(memory) {
-      if (!memory?.id) return;
-      embedFor(memory.id, memory.title, memory.content).catch(() => {});
+      if (!memory?.id) {
+        return Promise.resolve({ status: "skipped", id: null, at: new Date().toISOString(), reason: "no-id" });
+      }
+      return embedFor(memory.id, memory.title, memory.content).catch((error) => ({
+        status: "failed", id: memory.id, at: new Date().toISOString(), reason: String(error)
+      }));
+    },
+
+    /** Recent embed receipts + running totals (see createReceiptLedger). */
+    embedReceipts() {
+      return ledger.snapshot();
     },
 
     /** Embed one text and return its vector (null on failure/disabled). */
@@ -155,17 +246,27 @@ export function createEmbedder({ store, settings, logger, vectorIndex }) {
       return _dimension || undefined;
     },
 
-    /** Batch re-index rows still missing an embedding. */
+    /**
+     * Batch re-index rows whose vector is missing OR came from another model.
+     * Uses needsEmbeddingFor (not needsEmbedding) so a model switch actually
+     * re-embeds the old vectors instead of leaving them eligible for "has a
+     * vector" forever while they poison similarity ranking.
+     */
     async reindexMissing(limit = 50) {
       const cfg = settings.getVectorConfig();
       if (!cfg?.enabled) return { indexed: 0, skipped: 0 };
-      const rows = store.needsEmbedding(limit);
+      const model = modelHashOf(cfg.model);
+      // Fall back to the plain selector for stores that predate the
+      // provenance column (older hosts, test doubles).
+      const rows = typeof store.needsEmbeddingFor === "function"
+        ? store.needsEmbeddingFor(model, limit)
+        : store.needsEmbedding(limit);
       let indexed = 0;
       for (const row of rows) {
         const text = [row.title, row.content].filter(Boolean).join("\n");
         const vector = await embedText(cfg, text);
         if (vector) {
-          store.setEmbedding(row.id, vector);
+          store.setEmbedding(row.id, vector, model);
           _dimension = vector.length;
           indexed++;
         }

package/src/entities/extractor.js

@@ -163,6 +163,10 @@ export async function extractEntities(memory, { store, config, callLLM, logger }
     if (config.entityExtractionModel) options.model = config.entityExtractionModel;
     const reasoning = config.entityExtractionReasoning;
     if (reasoning && reasoning !== "none") options.reasoningEffort = reasoning;
+    // #405: 审计行要能归因到具体记忆。extractor 只把 content 写进 prompt，id 这里顺
+    // options 交给 index.js 的 adapter（route 映射只认 provider/model，多余键不会进
+    // llm.stream）。拿不到 id 就不写这个键，adapter 侧照旧留空数组，不造虚账。
+    if (memory.id) options.memoryId = memory.id;
     const llmResponse = await callLLM(messages, options);
     
     if (!llmResponse) {

package/src/index.js

@@ -14,7 +14,7 @@ import { createInjector } from "./inject.js";
 import { createPreInjectGate } from "./pre-inject-gate.js";
 import { createContinuityRescue } from "./continuity.js";
 import { createSummarizer } from "./summarize.js";
-import { createDreamScheduler } from "./dream.js";
+import { createDreamScheduler, describeStreamFailure } from "./dream.js";
 import { createSleepScheduler, runSleep } from "./dream/sleep.js";
 import { createApi } from "./api.js";
 import { createStandaloneApi } from "./api-standalone.js";
@@ -22,6 +22,8 @@ import { createStandaloneApi } from "./api-standalone.js";
 import { createMaintenance } from "./maintenance.js";
 import { createSettings } from "./settings.js";
 import { createCommandManager } from "./commands.js";
+import { createExecutionRecorder } from "./pipeline-runner.js";
+import { registerMoRunCommand } from "./pipeline-command.js";
 import { createVectorIndex } from "./vector-index.js";
 // semantic(embedder/reranker/boot 回填)纯搬移至 src/semantic.js(PR2):宿主与
 // daemon(dsh-mneme-serve,#363)共用同一套装配,原文件保留 barrel 出口。
@@ -78,6 +80,11 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger, serv
       } catch { /* fall through to whatever route we already have */ }
     }
     const effort = options.reasoningEffort;
+    // #405: 审计行的 related_memory_ids 此前恒空、error_message 又被压成一句常量，
+    // 于是「哪条记忆没抽到实体、为什么」在库里查不出来（主库 735 条 error 行全是
+    // 同一句话）。id 由 extractor 顺 options 传下来——它只认 memory.content，不认
+    // id。口径同 write-admission:350：拿不到 id 就留空，绝不挂不存在的 id 造虚账。
+    const relatedMemoryIds = options.memoryId ? [options.memoryId] : [];
     // 没有解析出 provider/model 就没有可归属的模型——与 dream 的 resolveRoute
     // 无路由早退同口径，那种情况不写审计行。
     const modelId = route.provider && route.model ? `${route.provider}:${route.model}` : "";
@@ -89,7 +96,7 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger, serv
       const timestamp = new Date(startedAt).toISOString();
       // 记账是 best-effort：写审计行失败只 warn，绝不反噬抽取本身（CONTRIBUTING
       // 的 fail-safe 硬约定）。
-      const writeAudit = (status, errorMessage) => {
+      const writeAudit = (status, errorMessage, relatedMemoryIds = []) => {
         if (config?.llmAudit?.enabled === false || typeof service?.saveLlmAudit !== "function") return;
         // #372: modelId 为空 = 路由解析失败——此前整个 writeAudit 静默 return，
         // llm.stream 抛错也留不下任何行，正是 #108 要消灭的「零实体零日志」同款盲区。
@@ -111,7 +118,7 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger, serv
             duration_ms: Date.now() - startedAt,
             status,
             error_message: errorMessage,
-            related_memory_ids: []
+            related_memory_ids: relatedMemoryIds
           });
         } catch (auditError) {
           logger?.warn?.(`dsh-mneme: entity extraction llm audit write failed: ${String(auditError)}`);
@@ -136,7 +143,7 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger, serv
             if (Number.isFinite(o)) outputTokens = o;
           }
           if (chunk.type === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) {
-            writeAudit("error", "llm stream aborted or errored");
+            writeAudit("error", describeStreamFailure(chunk.reason) || "llm stream aborted or errored", relatedMemoryIds);
             return undefined;
           }
         }
@@ -144,7 +151,7 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger, serv
         return text;
       })().catch((err) => {
         logger?.warn?.(`[dsh-mneme] entity extraction llm stream failed: ${String(err)}`);
-        writeAudit("error", String(err?.message ?? err));
+        writeAudit("error", String(err?.message ?? err), relatedMemoryIds);
         return undefined;
       });
     };
@@ -183,11 +190,6 @@ export const apply = (ctx, config) => {
   }
 
   const store = createStore(join(memoryDir, "memory.db"));
-  // Prune reflection failure rows older than 90 days on boot (best-effort, so
-  // the failure table never grows unbounded).
-  try {
-    store.deleteOldFailures(new Date(Date.now() - 90 * 86400000).toISOString());
-  } catch { /* non-fatal */ }
 
   // User-configurable settings (profile, rules, panel mode, standalone API
   // token) share the same SQLite file in dedicated tables, isolated from
@@ -226,6 +228,21 @@ export const apply = (ctx, config) => {
     cfg[objKey] = { ...(cfg[objKey] ?? {}), ...sub };
   }
 
+  // 失败表的启动期清理也放在装配之后（此前它在 createStore 之后、装配之前，写死
+  // 90 天）。保留期现在是显式配置键 reflectionFailureRetentionDays；等它进面板
+  // 白名单的那天，这里读的就是装配后的值，不用再改第二处。best-effort 语义不变：
+  // 清理失败不挡启动，否则一次锁表就能让插件起不来——但「不挡启动」不等于「可以
+  // 悄悄失败」：这一族的 recall_runs 清理当年就是静默蒸发，表涨到两万余行无人
+  // 察觉，所以本处与 llm_audit / distill_records / recall_runs 三处一样出声。
+  try {
+    const failureRetentionDays = Number.isInteger(cfg.reflectionFailureRetentionDays)
+      ? cfg.reflectionFailureRetentionDays
+      : 90;
+    store.deleteOldFailures(new Date(Date.now() - failureRetentionDays * 86400000).toISOString());
+  } catch (err) {
+    ctx.logger?.warn?.(`[dsh-mneme] failure-table retention purge failed: ${String(err)}`);
+  }
+
   // Bug8 的启动期清理放在装配之后：面板把 llmAudit.* 写进 kv、经 nestedFlags 合进
   // cfg，而写入侧（dream / summarize / 写入准入）读的都是装配后的 cfg——清理若读
   // rawCfg，面板改了保留期它不认，更糟的是「开不开审计」与写入侧可能取到不同的值
@@ -236,7 +253,9 @@ export const apply = (ctx, config) => {
       const retentionMs = Number.isInteger(cfg.llmAudit?.retentionDays) ? cfg.llmAudit.retentionDays : 90;
       store.deleteOldLlmAudits(new Date(Date.now() - retentionMs * 86400000).toISOString());
     }
-  } catch { /* non-fatal */ }
+  } catch (err) {
+    ctx.logger?.warn?.(`[dsh-mneme] llm_audit retention purge failed: ${String(err)}`);
+  }
 
   // #399 的启动期裁剪：与上面同款（读装配后的 cfg，理由同上——面板写的保留期必须
   // 与写入侧取到同一个值）。不同的一点：蒸馏原文留存默认关，而「默认关」在写入侧
@@ -250,7 +269,27 @@ export const apply = (ctx, config) => {
         : 90;
       store.clearDistillRecords(new Date(Date.now() - retentionMs * 86400000).toISOString());
     }
-  } catch { /* non-fatal */ }
+  } catch (err) {
+    ctx.logger?.warn?.(`[dsh-mneme] distill_records retention purge failed: ${String(err)}`);
+  }
+
+  // recall_runs 的滚动清理（v0.7.0 原设计，2026-10-14 找回）：与 llm_audit 同策略，
+  // 按 cfg.recallRetentionDays（默认 90 天）启动时清一次。读装配后的 cfg，理由与上面
+  // 两处一致 —— 写入侧取的是 cfg，清理侧若取 rawCfg，面板改的保留期就不生效。
+  // 这一对曾在 dd0ed78（v0.7.12 发布提交）里被整块弄丢，配置键与文档却一直留着，
+  // 实测 2026-10-13 那天从 16,041 涨到 20,510 行（一天四千余行，只增不减；
+  // 单给一个静态行数会随表腐坏，故带日期的区间才是可核对的说法）。注入行开始写真实 query 之后，这条从「表膨胀」
+  // 升级为「原话无限期留存」，所以必须与那次改动同批交付。
+  // 保留期语义是「天」（函数内部乘 86400000），清理失败只 warn，绝不挡插件启动。
+  try {
+    const recallRetentionDays = Number.isInteger(cfg.recallRetentionDays) ? cfg.recallRetentionDays : 90;
+    store.purgeRecallRunsOlderThan(recallRetentionDays);
+  } catch (err) {
+    // 这里必须真的出声。这一对当初是**静默**蒸发的：函数与调用一起没了、没人发现，
+    // 表就这么涨到两万余行。清理再失败一次而仍然不出声，同样的回归照样看不见——
+    // 「只 warn」不是修辞，是这族清理唯一的事后线索。
+    ctx.logger?.warn?.(`[dsh-mneme] recall_runs retention purge failed: ${String(err)}`);
+  }
 
   // 记忆语言（memory.language）：本实例逐层传入 inject / summarize / dream /
   // sleep / mirror，多实例（如 agent preset 内挂载）互不影响。
@@ -351,11 +390,40 @@ export const apply = (ctx, config) => {
   // Custom commands: register persisted commands into the DSH command registry
   // on boot; add/remove re-register live through the API.
   let commands = null;
+  // M.O. 执行记账器：默认 null（旗标关），开了才装配。
+  let recorder = null;
   if (ctx.commands) {
     commands = createCommandManager({ ctx, settings, logger: ctx.logger, language: langOf(cfg) });
     commands.sync();
   }
 
+  // M.O. 执行记账（v0.9.0 第二批）：`/mo-run` 显式开一次执行窗口，窗口内的命令执行
+  // 才可能被记成一条 run。挂的是 `session/event`——本仓已有三处消费者（continuity /
+  // summarize / api），不是新引入的宿主依赖。
+  //
+  // 为什么必须显式开窗：工作流的 trigger 是人话，拿它去猜「用户这句话是不是要开始走
+  // 某条流程」只能猜错，而猜错会把一条从没跑过的流程记成跑过。所以窗口边界由人的
+  // 显式动作划，**没开窗时一个字都不记**。
+  //
+  // 门控：默认关（actionRunEnabled），并且它挂热路径，轻量档也关。
+  if (cfg.actionRunEnabled === true) {
+    recorder = createExecutionRecorder({ ctx, logger: ctx.logger });
+    const disposeMoRun = registerMoRunCommand({
+      ctx,
+      recorder,
+      enabled: true,
+      language: () => langOf(cfg)
+    });
+    if (disposeMoRun) {
+      disposers.push(disposeMoRun);
+    } else {
+      // 注册不上（宿主没有命令注册表）时别留一个只开着窗口却没人能操作的记录器。
+      recorder.dispose();
+      recorder = null;
+      ctx.logger?.warn?.("[dsh-mneme] actionRunEnabled=true 但宿主没有命令注册表，M.O. 记账未启用");
+    }
+  }
+
   // Dream scheduler: automatic consolidation + summary runs, triggered by
   // store growth. Writes through the service fire the dream hook, which asks
   // the scheduler to (re)schedule a run once absolute and since-last-run
@@ -545,6 +613,7 @@ export const apply = (ctx, config) => {
       if (typeof dispose === "function") dispose();
     }
     commands?.dispose();
+    recorder?.dispose();
     if (dream) await dream.dispose();
     if (sleep) sleep.dispose();
     store.close();