@modusensus/dsh-mneme 0.8.16 → 0.9.1

package/lib/settings.js

@@ -31,6 +31,67 @@ function parseList(raw) {
   }
 }
 
+// persona 对象的字段白名单：写入时只挑这些键，未知字段丢弃（设计稿①：字段从简，
+// beta 收到真实反馈再加；provenance 是 v1.5 协作式人格的预留位，v1 不写管道）。
+// 读侧损坏即回空对象——同一容错口径照 parseList（坏值不抛错、面板显示为空可重写）。
+const PERSONA_FIELDS = ["name", "personality", "replyStyle", "enabled", "provenance"];
+
+function parsePersona(raw) {
+  try {
+    const value = JSON.parse(raw);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+    const out = {};
+    for (const key of PERSONA_FIELDS) {
+      if (value[key] !== undefined) out[key] = value[key];
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+// 多卡模型（v1.2）：存储形为 { default: <卡>, byAgent: { <agentId>: <卡>, … } }。
+// 兼容层：v1 存的是单对象（有 PERSONA_FIELDS 键、无 default/byAgent 键），读侧
+// 判形状——单对象原样落 default 位，旧数据零迁移。byAgent 的键是 agent 身份
+// id（注入时按会话身份寻址，取不到落 default）。default 卡不可删（兜底位）。
+function parsePersonaStore(raw) {
+  try {
+    const value = JSON.parse(raw);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return { default: {}, byAgent: {} };
+    }
+    // 新形：含 default 或 byAgent 键 → 按多卡解析
+    if ("default" in value || "byAgent" in value) {
+      const byAgent = {};
+      if (value.byAgent && typeof value.byAgent === "object" && !Array.isArray(value.byAgent)) {
+        for (const [agentId, card] of Object.entries(value.byAgent)) {
+          const parsed = parsePersona(JSON.stringify(card ?? {}));
+          if (Object.keys(parsed).length) byAgent[String(agentId)] = parsed;
+        }
+      }
+      return { default: parsePersona(JSON.stringify(value.default ?? {})), byAgent };
+    }
+    // 旧形：v1 单对象 → 整体作 default（字段白名单在 parsePersona 内裁）
+    return { default: parsePersona(raw), byAgent: {} };
+  } catch {
+    return { default: {}, byAgent: {} };
+  }
+}
+
+function serializePersonaStore(store) {
+  const out = {
+    default: parsePersona(JSON.stringify(store?.default ?? {})),
+    byAgent: {}
+  };
+  if (store?.byAgent && typeof store.byAgent === "object") {
+    for (const [agentId, card] of Object.entries(store.byAgent)) {
+      const parsed = parsePersona(JSON.stringify(card ?? {}));
+      if (Object.keys(parsed).length) out.byAgent[String(agentId)] = parsed;
+    }
+  }
+  return JSON.stringify(out);
+}
+
 // --- feature flags（功能开关）白名单 -----------------------------------------
 // 面板可逐项开关的后端能力。设计约束：
 // 1. 键名与类型必须和 config.js schema 同名同型，这份白名单是唯一校验源
@@ -140,7 +201,24 @@ const FEATURE_FLAG_BOOLEANS = [
   // 落盘（distill_records）并给记忆挂窗口链接（memory_provenance）；默认关。
   // 点号键平铺存、合并时展开回 distillRecords 对象（同 llmAudit.enabled）。
   // retentionDays 是 int，走下面的 INT_RANGES 表，不进开关白名单。
-  "distillRecords.enabled"
+  "distillRecords.enabled",
+  // v0.9.0：M.O.（Modus Operandi · 手法，beta）客户端视图开关。客户端读 /features
+  // 的 effective
+  // 决定是否注册座位（会话头图标 / 浮层 / 右栏 / 对话行卡片），服务端只负责把
+  // 这个键稳定暴露出来——键若不在 effective 里，客户端静默少键、一个座位都不注册。
+  // 默认关（beta、opt-in）；顶层扁平键，因此不需要 NESTED_FLAG_PATHS 条目。
+  "actionPipelineEnabled",
+  // v0.9.0 第二批：M.O. 执行记账（`/mo-run` 开窗 → 窗口内命令被记成一条 run）。
+  // 与上面那个键分开：那个管「看图的座位」，这个管「往账本里写」。默认关（beta、
+  // opt-in），顶层扁平键，不需要 NESTED_FLAG_PATHS 条目。
+  "actionRunEnabled",
+  // 人格定义页（beta）：注入器渲染人格段的顶层总闸（双闸门的 config 半边；对象内
+  // 的 persona.enabled 是 per-agent 半边，存 user_settings 的 "persona" 键，见
+  // getPersona/setPersona）。默认关（beta、opt-in，老用户行为逐字节不变）；不进
+  // LIGHT_MODE_OFF——人格段是用户自写的一小段轻量常驻文本，不引入任何重型后台
+  // 路径，轻量档用户显式勾选仍然赢（同 actionPipelineEnabled 的定性）。顶层扁平
+  // 键，不需要 NESTED_FLAG_PATHS 条目。
+  "personaEnabled"
 ];
 // 整数开关的闭区间，与 config.js 里 z.natural().min().max() 对齐。
 const FEATURE_FLAG_INT_RANGES = {
@@ -397,6 +475,65 @@ export function createSettings(db) {
       setSetting("rules", JSON.stringify(list));
     },
 
+    /**
+     * Agent persona (name / personality / replyStyle + enabled gate), stored as
+     * one JSON key. v1.2 多卡：存储形 { default, byAgent }，旧 v1 单对象读作
+     * default 兼容。getPersona 返回全量多卡形（面板用）；getPersonaFor 按 agent
+     * 身份取卡（注入用），身份缺失/无卡/卡 enabled=false 均落 default。
+     */
+    getPersona() {
+      return parsePersonaStore(getSetting("persona") ?? "{}");
+    },
+    setPersona(input) {
+      // 双形兼容：单对象形 = 只更新 default、byAgent 保留（旧面板/旧调用方合并语义）；
+      // 多卡形 = 全量替换。坏体（非对象）在此不落库不抛错，保值由调用方守卫。
+      if (typeof input !== "object" || input === null || Array.isArray(input)) return;
+      if ("default" in input || "byAgent" in input) {
+        setSetting("persona", serializePersonaStore(input));
+        return;
+      }
+      const current = parsePersonaStore(getSetting("persona") ?? "{}");
+      current.default = parsePersona(JSON.stringify(input));
+      setSetting("persona", serializePersonaStore(current));
+    },
+    /** Per-agent lookup for the injector: id card → default fallback. */
+    getPersonaFor(agentId) {
+      const store = parsePersonaStore(getSetting("persona") ?? "{}");
+      const id = typeof agentId === "string" && agentId.trim() ? agentId.trim() : "";
+      if (id) {
+        const card = store.byAgent[id];
+        if (card && card.enabled === true) return card;
+      }
+      return store.default;
+    },
+    /** Replace one byAgent card wholesale (panel save); default 不可经此改。 */
+    setPersonaFor(agentId, card) {
+      const id = typeof agentId === "string" && agentId.trim() ? agentId.trim() : "";
+      if (!id || id === "default") return false;
+      const store = parsePersonaStore(getSetting("persona") ?? "{}");
+      const clean = parsePersona(JSON.stringify(
+        typeof card === "object" && card !== null && !Array.isArray(card) ? card : {}
+      ));
+      if (Object.keys(clean).length) store.byAgent[id] = clean;
+      else delete store.byAgent[id];
+      setSetting("persona", serializePersonaStore(store));
+      return true;
+    },
+    /** byAgent 键列表（面板卡列表用，default 不在其中）。 */
+    listPersonas() {
+      return Object.keys(parsePersonaStore(getSetting("persona") ?? "{}").byAgent);
+    },
+    /** 删一张 byAgent 卡；default 不可删（返回 false）。 */
+    removePersona(agentId) {
+      const id = typeof agentId === "string" && agentId.trim() ? agentId.trim() : "";
+      if (!id || id === "default") return false;
+      const store = parsePersonaStore(getSetting("persona") ?? "{}");
+      if (!(id in store.byAgent)) return false;
+      delete store.byAgent[id];
+      setSetting("persona", serializePersonaStore(store));
+      return true;
+    },
+
     /** All custom commands, sorted by name. */
     listCommands() {
       const rows = db.prepare("SELECT * FROM custom_commands ORDER BY name ASC").all();

package/lib/store.js

@@ -835,6 +835,15 @@ export function createStore(path) {
   // 老库打开时 SCHEMA 的 CREATE TABLE 对既有表不生效，列还不存在，把索引写进 SCHEMA
   // 会直接报 no such column（与下方 llm_audit_logs.session_key 同理）。
   addColumn("memories", "content_hash", "ALTER TABLE memories ADD COLUMN content_hash TEXT");
+  // 每条向量的出身（行级 model hash，如 `qwen3.7-text-embedding-flash#17a6a0b1`）。
+  // 为什么必须行级：vector_meta 只有一个 model_hash，它记的是「最后一次成功写入
+  // 的模型」，换模型时被整表覆盖——于是上一代模型产出的向量在元数据上看起来完全
+  // 合规，实际与新模型的查询向量不可比。没有这一列，「这条向量是不是当前模型产
+  // 的」就无从判断（content_hash 是内容归一化哈希，与向量模型无关；dimension 在
+  // 同为 1024 维的模型间也区分不出来）。
+  // 存量行的值是 NULL，且**不推断**：按 updated_at 猜出的模型名会变成日后审计信
+  // 以为真的证据。NULL 一律读作「出身未知」，等价的补法是重算，不是猜。
+  addColumn("memories", "embedding_model", "ALTER TABLE memories ADD COLUMN embedding_model TEXT");
   // issue #24 块2（权重演化）：entity_relations 加 weight + source。存量关系
   // 行缺列 → 默认 manual 1.0（最保守：既有语义不因迁移而变弱）。
   addColumn("entity_relations", "weight", "ALTER TABLE entity_relations ADD COLUMN weight REAL NOT NULL DEFAULT 1.0");
@@ -1565,11 +1574,24 @@ export function createStore(path) {
     // "chrono" is pure newest-first — the stable order paged browsing (month
     // tree, infinite scroll) needs; importance ordering would interleave
     // months across pages.
-    const orderBy = order === "chrono" ? "updated_at DESC, id DESC" : "importance DESC, updated_at DESC, id";
+    // #430：chrono 的 **无界档** 不再追加 id 平局键。updated_at 上有 #202 建的
+    // 索引，而带 id 的第二项排序键用不上它——5k 行实测同一份 SQL 只差这一项：
+    // 100.6ms（带 id，EXPLAIN 多一个 USE TEMP B-TREE）对 23.4ms（纯 updated_at，
+    // 直接走 idx_memories_updated）。分页档位必须留平局键（跨页拼接要求稳定，
+    // 同刻两行在新旧页之间可能漏一条或重复一条）；无界档没有跨页拼接，今天唯一
+    // 的调用方 syncMirror 只用它算覆盖集，与顺序无关。
+    const orderBy = order === "chrono"
+      ? (unbounded ? "updated_at DESC" : "updated_at DESC, id DESC")
+      : "importance DESC, updated_at DESC, id";
+    // Issue #430：与 all() 共用同一份显式列清单（memoryColumns 由 PRAGMA 派生，
+    // 排除 embedding）。toRow 本就不输出向量，SELECT * 只是把全表最重的列拖进
+    // 内存再丢弃——无界档实测 5k 行 263ms → 117ms，窗口档 50ms → 41ms，本函数
+    // 的全部调用方（分页浏览、document 索引、sleep 池、注册器全量扫描）一起受益。
+    const projected = `SELECT ${memoryColumnList} FROM memories`;
     const rows = unbounded
-      ? db.prepare(`SELECT * FROM memories ${where} ORDER BY ${orderBy}`).all(...params)
+      ? db.prepare(`${projected} ${where} ORDER BY ${orderBy}`).all(...params)
       : db.prepare(
-          `SELECT * FROM memories ${where} ORDER BY ${orderBy} LIMIT ? OFFSET ?`
+          `${projected} ${where} ORDER BY ${orderBy} LIMIT ? OFFSET ?`
         ).all(...params, lim, off);
     return rows.map(toRow);
   }
@@ -1581,10 +1603,36 @@ export function createStore(path) {
     return rows.map(toRow);
   }
 
-  /** Set (or clear with null) the embedding vector of a memory. */
-  function setEmbedding(id, vector) {
+  // Issue #430：写路径要的「最近若干条正文」。质量过滤的近重复判定只读 content
+  // 这一列 + 前 20 行，此前写成 all().slice(0, 20) —— 全表逐行 toRow（27 字段、
+  // 三次 JSON 解析）之后只截前 20 条正文；5k 行实测 100ms 级 → 0.06ms 级。
+  // 口径与 all() 的前 N 条严格一致：不加 WHERE（archived/forgotten 仍参与近重复
+  // 判定）、updated_at DESC、同刻顺序未定义。limit 走 sanitizePage，非正整数
+  // 落回 20，调用方不必自己防 0/undefined。
+  function recentContents(limit = 20) {
+    const { limit: lim } = sanitizePage(limit, 0, 20);
+    const rows = db.prepare("SELECT content FROM memories ORDER BY updated_at DESC LIMIT ?").all(lim);
+    return rows.map((row) => row.content ?? "");
+  }
+
+  /** Set (or clear with null) the embedding vector of a memory.
+   *  `modelHash` records which model produced THIS vector (see the
+   *  embedding_model migration note). Clearing the vector clears the
+   *  provenance with it, so a NULL vector is never paired with a stale model
+   *  name; omitting modelHash leaves the column untouched (callers that
+   *  predate the column still work, their rows simply read as unknown). */
+  function setEmbedding(id, vector, modelHash) {
     const json = Array.isArray(vector) && vector.length ? JSON.stringify(vector) : null;
-    db.prepare("UPDATE memories SET embedding = ? WHERE id = ?").run(json, id);
+    if (json) {
+      if (modelHash !== undefined) {
+        db.prepare("UPDATE memories SET embedding = ?, embedding_model = ? WHERE id = ?")
+          .run(json, modelHash === null ? null : String(modelHash), id);
+      } else {
+        db.prepare("UPDATE memories SET embedding = ? WHERE id = ?").run(json, id);
+      }
+    } else {
+      db.prepare("UPDATE memories SET embedding = NULL, embedding_model = NULL WHERE id = ?").run(id);
+    }
     // Issue #202：单一写入口即单一失效点——重写缓存条目（向量在手上不必重解析），
     // 清空则移除，删除过的 id 不会被下一次 searchVector 的 id 集合选中。
     if (json) {
@@ -1637,6 +1685,54 @@ export function createStore(path) {
     ).all(limit);
   }
 
+  /**
+   * Rows whose vector is missing OR was produced by a different model than
+   * `modelHash` — the selector the backfill should use whenever the caller
+   * knows which model the vectors are supposed to come from.
+   *
+   * Why `needsEmbedding` alone is not enough: it only matches empty vectors,
+   * so after a model switch every vector written by the previous model stays
+   * eligible for "has a vector" forever, while its similarity to the current
+   * query embedding is meaningless. Those rows keep inflating the status
+   * card's coverage while semantic recall silently degrades.
+   *
+   * `embedding_model IS NULL` counts as stale on purpose: NULL means "written
+   * before per-row provenance existed, producing model unknown", and an
+   * unknown origin cannot be proven to match. Those rows get re-embedded
+   * rather than assumed correct.
+   *
+   * When `modelHash` is falsy (embedder unconfigured / no fingerprint yet)
+   * this degrades to the plain missing-only selector instead of re-embedding
+   * the whole table against nothing.
+   */
+  function needsEmbeddingFor(modelHash, limit = 50) {
+    if (!modelHash) return needsEmbedding(limit);
+    return db.prepare(
+      `SELECT id, title, content, embedding_model FROM memories
+       WHERE ((embedding IS NULL OR embedding = '')
+              OR embedding_model IS NULL
+              OR embedding_model != ?)
+         AND forgotten = 0 AND archived = 0
+       ORDER BY updated_at DESC LIMIT ?`
+    ).all(String(modelHash), limit);
+  }
+
+  /** True when any active row would be picked by needsEmbeddingFor(). */
+  function hasStaleEmbedding(modelHash) {
+    return needsEmbeddingFor(modelHash, 1).length > 0;
+  }
+
+  /** Per-model provenance counts over active rows ('' = unknown origin). */
+  function embeddingModelBreakdown() {
+    return db.prepare(
+      `SELECT COALESCE(embedding_model, '') AS model, count(*) AS c
+         FROM memories
+        WHERE embedding IS NOT NULL AND embedding != ''
+          AND forgotten = 0 AND archived = 0
+        GROUP BY COALESCE(embedding_model, '')`
+    ).all();
+  }
+
   function search(query, { limit = 20, includeArchived = false } = {}) {
     const q = String(query).trim();
     if (!q) return [];
@@ -1968,6 +2064,30 @@ export function createStore(path) {
 
   // --- recall evaluation trail (方案 B: separate from the production audit) -
 
+  /**
+   * Rolling purge of the recall_runs production audit (v0.7.0): with recordRecall
+   * defaulting ON, the table would otherwise grow unboundedly on a busy store.
+   * Drop rows older than `days` (config.recallRetentionDays, default 90).
+   * created_at is an ISO TEXT string, so the ISO bound compares lexicographically.
+   * Returns the number of rows deleted (bookkeeping — never throws on empty).
+   *
+   * 2026-10-14 找回：这一对（本函数 + index.js 的启动调用）在 dd0ed78「release:
+   * v0.7.12 + 编码记忆(codingRetrospect)蒸馏/…（合并 #73 与 #74）」里被整块弄丢。
+   * 该提交不是 merge（单亲 cb5ec63），store.js 是从一个没有这段的版本重建的，
+   * 于是函数与调用一起蒸发，而配置键 recallRetentionDays、README.md 与
+   * docs/CONFIGURATION.md 的「recall_runs 滚动清理保留天数」一直留到今天。
+   * 实测后果（2026-10-14 快照）：本机 recall_runs 18,442 行、跨度 2026-09-08 →
+   * 2026-10-13，即从那一天起只增不减。注意这张表是**活的、只增的**：同一个 10-13
+   * 当天 14:43Z 是 18,442 行、20:47Z 已是 20,029 行，几小时就差一千五——所以任何
+   * 行数只在测它的那一刻成立，引用时必须带时刻，否则日后对不上会被误读成出了错。
+   * 这份审计里现在装的是用户原话，不是无信息的空串。
+   */
+  function purgeRecallRunsOlderThan(days) {
+    const cutoff = new Date(Date.now() - days * 86400000).toISOString();
+    const result = db.prepare("DELETE FROM recall_runs WHERE created_at < ?").run(cutoff);
+    return result.changes;
+  }
+
   /**
    * Persist one retrieval-evaluation snapshot into recall_evals — the test/eval
    * sibling of recall_runs, deliberately stored apart so eval snapshots never
@@ -3102,12 +3222,17 @@ export function createStore(path) {
     getUnrecalledSince,
     list,
     all,
+    // #430：有界单列读，写路径（质量过滤）用。
+    recentContents,
     search,
     setEmbedding,
     getEmbeddings,
     getParsedEmbedding,
     embeddedCount,
     needsEmbedding,
+    needsEmbeddingFor,
+    hasStaleEmbedding,
+    embeddingModelBreakdown,
     searchVector,
     saveDreamRun,
     lastDreamRunAt,
@@ -3122,6 +3247,7 @@ export function createStore(path) {
     getRecallRun,
     listRecallRuns,
     listRecallRunsSince,
+    purgeRecallRunsOlderThan,
     saveRecallEval,
     getRecallEval,
     listRecallEvals,

package/lib/summarize.js

@@ -4,6 +4,8 @@ import { STR, langOf } from "./lang.js";
 // 重试一次不带 effort 字段）与 describeStreamFailure（流失败原因归一）——
 // 三条链路同一降级语义，不另造第二份实现。
 import { withEffortFallback, describeStreamFailure, EFFORT_REJECT_RE } from "./dream.js";
+// v0.9.0（M.O. 项目记忆）：蒸馏写入复用工具路径那把作用域解析器，见 createSummarizer。
+import { createScopeResolver } from "./scope.js";
 
 // 编码记忆蒸馏 prompt（codingRetrospect 开启时启用）：在通用记忆之外，额外提取
 // 三类编码专属记忆，专治重复踩坑 / 遗忘被否决方案 / 丢失工程约束。字段仍沿用
@@ -511,6 +513,15 @@ export function createSummarizer(ctx, service, config, deps = {}) {
   const setTimer = typeof deps.setTimeoutFn === "function" ? deps.setTimeoutFn : setTimeout;
   const clearTimer = typeof deps.clearTimeoutFn === "function" ? deps.clearTimeoutFn : clearTimeout;
 
+  // v0.9.0（M.O. 项目记忆）：蒸馏写入也要盖作用域章。此前只有 memory_save 那条工具
+  // 路径盖章（tools.js 的 resolveSessionScope 盖章块，2026-10-14 在 :174-181），而机器提炼是写入量的绝大多数——于是「项目记忆」
+  // 在库里根本不存在（全库带 scope 的行不足 3%，且带 scope 的全部来自工具路径）。
+  // 这里不另造口径：同一把解析器（scope.js 的 createScopeResolver，2026-10-13 在 :24）、同一把闸门
+  // （config.scopeEnabled === true）、同一对列（*_scope + *_scope_source='auto'），
+  // 与工具路径逐字对齐。解析器的入参形状是「工具 exec」（内部读 exec.agent.session），
+  // 蒸馏路径手里直接有会话对象，所以包一层壳喂进去——不改解析器的公共契约。
+  const resolveSessionScope = createScopeResolver({ ctx, config, logger: ctx.logger });
+
   const inFlight = new Map();
   // Issue #127：per-session 上一次实际开跑时刻（最小间隔闸门用）。与 inFlight
   // 同生命周期，dispose 时一并清空。
@@ -873,6 +884,13 @@ export function createSummarizer(ctx, service, config, deps = {}) {
       const dedupeMode = config.summarizeDedupeMode ?? "off";
       let deduped = 0;
       let dedupeMaxSim = 0;
+      // v0.9.0（M.O. 项目记忆）：一次窗口解析一次——同一蒸馏窗口里所有条目同属一个
+      // 工作区、一个 agent 身份，逐条解析是白花钱。解析不到就落 NULL（NULL = 未标注 =
+      // 全局可见），且解析器绝不抛错（scope.js 的硬约束：记忆写入不该被作用域拖挂）。
+      // 闸门与 tools.js 的 autoStamping（2026-10-14 在 :175）同一把：关着就一个字段都不加，老行为不变。
+      const writeScope = config?.scopeEnabled === true
+        ? resolveSessionScope({ agent: { session } })
+        : null;
       const writes = [];
       for (const entry of entries) {
         // Provenance: the summarizer runs on a real session (turn/end hook), so
@@ -917,6 +935,18 @@ export function createSummarizer(ctx, service, config, deps = {}) {
           const outcome = service.saveWithDedupe({
             ...entry,
             source,
+            // 合并进既有行时不盖章，但这件事由 saveWithDedupe 的合并分支自己保证
+            // （它只认 explicit 来源升级，从不采纳这里传的 auto 字段）——调用方不能
+            // 靠「省略字段」来表达这个意图，因为省略会反向把合并也挡掉：
+            // findSessionDuplicate 只按 type+source+时间窗找候选，不看 scope；找到
+            // 候选后由 saveWithDedupe 的 scopeMatches 门决定并或不并。这里一省略，
+            // 新条目的 scope 就是 null，与已盖过章的候选不等，门必拒 → 回落新建，
+            // 而那一行同样是新行、同样该带章，却没有章可带。实测两轮蒸馏正是如此：
+            // 第二轮命中第一轮、门拒后新建，留下同题两行一行 auto 一行 NULL——
+            // 作用域隔离没做成，重复倒留下了。传字段、让合并分支按自己的口径处理，
+            // 才是「不重贴」与「新行必贴」两个要求的唯一相容解。
+            ...(writeScope ? { agent_scope: writeScope.agent_scope, agent_scope_source: "auto" } : {}),
+            ...(writeScope ? { workspace_scope: writeScope.workspace_scope, workspace_scope_source: "auto" } : {}),
             ...(dup ? { _mergeInto: dup.memory.id } : {})
           });
           // created 与 merged 两条成功分支都返回 memory（含 id）；merged 时 id 是

package/lib/tools.js

@@ -7,6 +7,7 @@ import { matchesPlatform } from "./runtime/closure.js";
 import { verifyPayload } from "./runtime/verify.js";
 import { TOOL_GUIDE, CONTINUITY_TOOL_RULE } from "./guide.js";
 import { injectChildEnabled } from "./config.js";
+import { lastUserQuery } from "./inject.js";
 
 const TEXT_OUTPUT = (text) => [{ type: "text", text }];
 // Per-registry tool-name registry: guards against duplicate registration on
@@ -381,6 +382,14 @@ export function createTools(ctx, service, config, embedder) {
         render: (_args, value) => TEXT_OUTPUT(`Updated memory ${value.memory.id}: ${value.memory.title}`)
       },
       async execute(args) {
+        // v0.9.0：失败表的 query 是「当时到底想干什么」唯一的落点，而 service
+        // 层看不到会话（它只认 ctx.query，见 src/service.js 的 saveFailure 注释）。
+        // 工具层是唯一同时握着改写动作与本轮会话的入口：没给 reason 就退回当轮用户
+        // 原话，取法与注入侧共用同一份实现（src/inject.js 的 lastUserQuery），不复制
+        // 第二份。两边都取不到时仍然写 NULL——空串会假装「有意图」，NULL 才说实话。
+        const exec = arguments[1];
+        const reason = typeof args.reason === "string" ? args.reason.trim() : "";
+        const query = reason || lastUserQuery(exec) || undefined;
         const memory = service.update(args.id, {
           title: args.title,
           content: args.content,
@@ -389,10 +398,10 @@ export function createTools(ctx, service, config, embedder) {
           importance: args.importance,
           // 复核项 4（#170）：strictScope 下他 scope 的行按「不存在」处理（与 get 对齐），
           // 展开恒为 undefined，仅承担写入前校验。
-          ...(assertVisibleForTool(args.id, arguments[1])),
+          ...(assertVisibleForTool(args.id, exec)),
           ...(args.agent_scope !== undefined ? { agent_scope: args.agent_scope } : {}),
           ...(args.workspace_scope !== undefined ? { workspace_scope: args.workspace_scope } : {})
-        }, { query: args.reason });
+        }, { query });
         return { memory: { id: memory.id, title: memory.title, content: memory.content } };
       }
     }),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
-  "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 9 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.8.16",
+  "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 10 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
+  "version": "0.9.1",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -64,7 +64,7 @@
     "@deepseek-ai/dsh-tools": ">=0.1.0-rc.6 <0.2.0 || >=0.1.5-rc.0 <0.3.0 || >=0.2.0-rc.0 <0.3.0",
     "@deepseek-ai/schemastery": "^3.18.1",
     "@huggingface/transformers": ">=4.2.0 <5",
-    "dsh-better-sidebar": "^0.18.0"
+    "dsh-better-sidebar": ">=0.18.0 <1"
   },
   "peerDependenciesMeta": {
     "dsh-better-sidebar": {

package/scripts/changelog-prep.mjs

@@ -14,23 +14,78 @@ export function detectEol(text) {
 }
 
 /**
- * 在 `# Changelog` 标题之后插入 `## [version] - date` 占位节（幂等：已含该版本则不改）。
+ * 只剥掉整段两端的空行，保留每行自己的缩进（正文原样搬走的前提）。
+ * 重新拼回时用原文的行尾：CRLF 的 CHANGELOG 若在这里退化成 LF，整份文件就成了混合行尾。
+ */
+function stripBlankEdges(text, eol) {
+  const lines = text.split(/\r?\n/);
+  let from = 0;
+  let to = lines.length;
+  while (from < to && lines[from].trim() === "") from += 1;
+  while (to > from && lines[to - 1].trim() === "") to -= 1;
+  return lines.slice(from, to).join(eol);
+}
+
+/**
+ * 插入 `## [version] - date` 节（幂等：已含该版本则不改）。
+ *
+ * **两个位置约定，都是被真实发版逼出来的**：
+ *
+ * 1. 新版本节排在 `## [Unreleased]` **下面**，不是 `# Changelog` 下面。Keep a Changelog
+ *    的约定是未发布区永远在最上；插反了会写出「[0.9.1] 在 [Unreleased] 之上」的顺序颠倒。
+ *    v0.9.0 那次就是靠事后一笔人工提交（77df0fb）掰回来的——机器算得对的事不该留给人补。
+ *
+ * 2. `[Unreleased]` 里攒着的条目**整段搬进新版本节**，Unreleased 留空。原先只插一个
+ *    「🐛 修复 / （待填）」空占位，攒着的条目原地不动，于是发版后文件里同时存在
+ *    「新版本节是空的」和「旧条目还挂在 Unreleased 名下」——搬运这一步照样是人工补的
+ *    （同一个 77df0fb）。搬的是位置不是内容：原样移动、一个字不改，所以「新版本节里
+ *    该写什么」这个判断仍然只由往 Unreleased 里写条目的人做。
  *
  * 返回 `{ok:false, reason}` 而不是静默返回原文——调用方必须能区分「没什么可做」与
  * 「该做但没做成」，后者要报错退出。`reason` 取值：`already-present` / `header-not-found`。
+ * 成功时带两个字段，**必须分开用**：
+ * - `movedContent`：是否真的从 [Unreleased] 搬了非空正文（决定「搬了」还是「插了空占位」）；
+ * - `moved`：其中以 `- ` 开头的条目数，只用于把日志说得更具体。
+ * 用 `moved` 当「有没有搬」的判据是错的：正文非空但一条 `-` 都没有（例如全是正文段落或
+ * 缩进代码块）时 `moved` 是 0，日志会说「[Unreleased] 本来是空的」——而它是非空的。
  *
  * @param {string} text CHANGELOG 全文
  * @param {string} version 如 "0.8.13"
  * @param {string} date 如 "2026-10-03"
- * @returns {{ok: true, text: string} | {ok: false, reason: "already-present" | "header-not-found"}}
+ * @returns {{ok: true, text: string, moved: number, movedContent: boolean} | {ok: false, reason: "already-present" | "header-not-found"}}
  */
 export function insertReleaseSection(text, version, date) {
   if (text.includes(`## [${version}]`)) return { ok: false, reason: "already-present" };
   const eol = detectEol(text);
-  const head = `## [${version}] - ${date}${eol}${eol}## 🐛 修复${eol}${eol}- （待填）${eol}${eol}`;
-  // BOM 可选：带 BOM 的检出上 `^#` 同样匹配不到，属于同一类「形状变了就静默失败」。
-  // 行尾 `\r?\n` 两种都吃——这就是本模块存在的首要理由。
-  const out = text.replace(/^(\uFEFF?# Changelog\r?\n\r?\n)/, `$1${head}`);
+  const placeholder = `## 🐛 修复${eol}${eol}- （待填）${eol}`;
+
+  const m = /^## \[Unreleased\][^\r\n]*\r?\n/m.exec(text);
+  if (m) {
+    const start = m.index + m[0].length;
+    const rest = text.slice(start);
+    const nextRel = rest.search(/^## \[/m);
+    const body = nextRel === -1 ? rest : rest.slice(0, nextRel);
+    const tail = nextRel === -1 ? "" : rest.slice(nextRel);
+    // 只剥节边界上的空行，**不 trim 正文**：正文首行若是缩进代码块（Markdown 的四空格），
+    // trim 会把前导空格吃掉，代码块降级成普通段落——那就不是「原样搬」了。
+    const pending = stripBlankEdges(body, eol);
+    const head = `## [${version}] - ${date}${eol}${eol}`;
+
+    // Unreleased 里攒着东西：整段搬进新版本节，Unreleased 留空。
+    // 搬的是位置不是内容——原样移动，一个字不改。这样「新版本节里有什么」这个判断
+    // 仍然只由往 Unreleased 里写条目的人做，脚本只负责把攒好的东西挪对地方。
+    if (pending) {
+      const moved = pending.split(/\r?\n/).filter((l) => l.startsWith("- ")).length;
+      return { ok: true, moved, movedContent: true, text: text.slice(0, start) + eol + head + pending + eol + eol + tail };
+    }
+
+    // Unreleased 是空的：插占位节，等人写内容。
+    return { ok: true, moved: 0, movedContent: false, text: text.slice(0, start) + eol + head + placeholder + eol + tail };
+  }
+
+  // 没有 [Unreleased] 的旧文件：退回标题之后。BOM 可选——带 BOM 的检出上 `^#` 同样匹配不到。
+  const section = `## [${version}] - ${date}${eol}${eol}${placeholder}${eol}`;
+  const out = text.replace(/^(\uFEFF?# Changelog\r?\n\r?\n)/, "$1" + section);
   if (out === text) return { ok: false, reason: "header-not-found" };
-  return { ok: true, text: out };
+  return { ok: true, moved: 0, movedContent: false, text: out };
 }

package/scripts/check-sync.js

@@ -1,11 +1,13 @@
-// 发布前校验 src/ 与 lib/ 一致性。
+// 断言 src/ 与 lib/ 一致——发布前的平价闸门。
 //
-// npm 包实际加载 lib/（package main → lib/index.js），而 root 层 `npm publish`
-// 不触发 dsh-mneme/ 的 prepack → sync 同步。历史教训：PR #60 只改了 src 忘了同步
-// lib，v0.7.8 发出去的 npm 包跑的还是旧代码（issue #65）。此脚本让这类漂移在发布时
-// 直接 fail，而不是带着旧产物上线。
+// npm 包实际加载 lib/（package main → lib/index.js）。历史教训：PR #60 只改了 src
+// 忘了同步 lib，v0.7.8 发出去的 npm 包跑的还是旧代码，用户侧静默失效（issue #65）。
 //
-// 用法：node scripts/check-sync.js （root package.json 的 prepack 钩子自动调用）
+// 注意这里**只校验、不同步**：prepack 钩子跑的是 `npm run sync`（把 src 覆盖到
+// lib），同步后必然一致，所以它永远不会因漂移失败。真正的闸门是这道脚本，跑在
+// CI 每个 PR 与 release.yml 的 test job 里——让漂移在合并前就红，而不是等到发布。
+//
+// 用法：node scripts/check-sync.js （CI 与 release.yml 调用，非 prepack）
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, relative } from "node:path";
 import { fileURLToPath } from "node:url";