@modusensus/dsh-mneme 0.10.0 → 0.11.0

package/lib/config-keys.js

@@ -0,0 +1,144 @@
+// 配置键覆盖面的「唯一一份」描述（issue #386 第 7 条）。
+//
+// 为什么单独一个模块：面板上能改的键（settings.js 白名单）与 schema 里实际存在的
+// 键（config.js 的 Config）是两张表，它们从来没被摆在同一个地方对过。于是
+// 「用户能理解、但面板改不到」的键只能靠读源码 + 手数得到答案——issue #386 列了
+// 七组、维护者另外复述了一遍，每次都要重新数。
+//
+// 这里只做「算」：把 schema 声明的叶子键与白名单取交/差，回三份清单。它不读
+// 数据库、不碰 cfg 的实际值、**不返回任何键的值**——apiToken 这类敏感键的名字可以
+// 出现在「仅配置文件」清单里（那正是这条 issue 想让用户看见的东西），值一个字节
+// 都不出。判定口径住在 flagKeysFromSpec，api.js 的 featureSnapshot 用的也是它；
+// 谁要是另抄一份白名单，test/config-keys-routes.test.js 的静态锁直接转红。
+
+import { Config } from "./config.js";
+import { FEATURE_FLAG_SPEC } from "./settings.js";
+
+/**
+ * 白名单里的全部键（面板 PUT 能写、effective 会算的那些）。
+ *
+ * 顺序与 api.js 的 featureSnapshot 逐字对应：booleans → ints → numbers → strings
+ * → urls → enums。api.js 直接引这一份，不再自己拼一遍。
+ */
+export function flagKeysFromSpec() {
+  return [
+    ...FEATURE_FLAG_SPEC.booleans,
+    ...Object.keys(FEATURE_FLAG_SPEC.ints),
+    ...Object.keys(FEATURE_FLAG_SPEC.numbers),
+    ...FEATURE_FLAG_SPEC.strings,
+    ...FEATURE_FLAG_SPEC.urls,
+    ...Object.keys(FEATURE_FLAG_SPEC.enums)
+  ];
+}
+
+/**
+ * 把「已解析的配置对象」摊平成叶子键清单。
+ *
+ * 这份清单的含义是**「有默认值因此会出现在 effective 里的键」**，不是「schema 声明
+ * 了哪些键」——两者不等。`Config({})` 解析后 `apiToken` 根本不存在（`z.string()`
+ * 没有 `.default()`），若拿它当 schema 清单，最该被用户看见的那个键反而消失了
+ * （第一版就是这么错的，被 `config-keys returns key names but never the apiToken
+ * value` 那条用例抓住）。
+ *
+ * 数组当叶子（`sessionGateSessions` 是 `z.array`，面板没有编辑器，整条替换不算
+ * 「改一个值」）。
+ */
+export function defaultedLeafKeys(instance = Config({})) {
+  const out = [];
+  const walk = (node, prefix) => {
+    for (const key of Object.keys(node)) {
+      const value = node[key];
+      const path = prefix ? `${prefix}.${key}` : key;
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) walk(value, path);
+      else out.push(path);
+    }
+  };
+  walk(instance, "");
+  return out;
+}
+
+/**
+ * schema **声明**的全部叶子键（含没有默认值的那些，比如 apiToken）。
+ *
+ * 直接走 schema 的 ref 图而不是解析结果：`Config.dict` 里每一项都是
+ * `{ uid, refs }`，真实节点在 `refs[uid]`。三种形状要分开处理：
+ *   - `object`：有 `dict`，递归进去；
+ *   - `dict`：键是开放的（`heatTypeDecay` 就是），只能靠 `meta.default` 的对象键
+ *     把已知的那几个名字还原出来；没有默认值就整条当一个叶子；
+ *   - 其它：叶子。
+ *
+ * 探针实测：声明叶子 196 个、解析结果 191 个、白名单 113 个。两边差的那五个是
+ * `dreamProvider` / `dreamModel` / `dreamReasoningEffort` / `apiToken` /
+ * `sleepReasoningEffort`——都只声明、没给默认值。
+ */
+export function schemaLeafKeys(schema = Config) {
+  const out = [];
+  const resolve = (node) => (node && node.refs && node.uid in node.refs ? node.refs[node.uid] : node);
+  const walk = (node, prefix) => {
+    const real = resolve(node);
+    if (!real) return;
+    if (real.type === "object" && real.dict) {
+      for (const key of Object.keys(real.dict)) walk(real.dict[key], prefix ? `${prefix}.${key}` : key);
+      return;
+    }
+    if (real.type === "dict") {
+      const def = real.meta && real.meta.default;
+      if (def && typeof def === "object" && !Array.isArray(def)) {
+        for (const key of Object.keys(def)) out.push(`${prefix}.${key}`);
+        return;
+      }
+    }
+    out.push(prefix);
+  };
+  if (schema && schema.dict) {
+    for (const key of Object.keys(schema.dict)) walk(schema.dict[key], key);
+  }
+  return out;
+}
+
+/**
+ * 三份清单 + 计数。#386 第 7 条要的答案全在这里。
+ *
+ * - `panelEditable`：schema 声明了、且白名单也登记了的键（面板能改）。
+ * - `fileOnly`：schema 声明了、面板改不到的键——issue 正文点名的那七组都在里面，
+ *   连同 `apiToken`、`memoryDir` 这类「知道它存在就够了」的键。
+ * - `undefaulted`：白名单登记了、schema 也有，**但没有 `.default()`**，所以
+ *   `effective` 里根本不会出现它。**这是本轮读码发现的一处真实不对称**：
+ *   `dreamProvider` / `dreamModel` 在 settings.js 的 STRINGS 表里，config.js 那边
+ *   只有 `z.string().description(...)` 而没有 `.default()`，于是面板有输入框、保存
+ *   也能存，但 `featureSnapshot()` 的 `configFlagValue` 取到 undefined 就不写进
+ *   effective（api.js 的 `if (value !== undefined)`）。列出来而不擅自补默认值：
+ *   补默认值会改变「未配置时到底用哪个模型」的既有行为，那是另一个决定。
+ *
+ * 三份互不相交，并集 = 白名单 ∪（声明里不在白名单的那批）——探针实测白名单
+ * 113 个全部都在声明里，所以并集就是声明的 196 个，一个不漏也不重复。
+ */
+export function describeConfigKeys() {
+  const declared = schemaLeafKeys();
+  const declaredSet = new Set(declared);
+  const defaulted = new Set(defaultedLeafKeys());
+  const flags = flagKeysFromSpec();
+  const flagSet = new Set(flags);
+
+  const panelEditable = [];
+  const undefaulted = [];
+  for (const key of flags) {
+    if (!declaredSet.has(key)) continue;
+    if (defaulted.has(key)) panelEditable.push(key);
+    else undefaulted.push(key);
+  }
+  const fileOnly = declared.filter((key) => !flagSet.has(key));
+
+  return {
+    counts: {
+      schemaLeaf: declared.length,
+      flag: flags.length,
+      panelEditable: panelEditable.length,
+      fileOnly: fileOnly.length,
+      undefaulted: undefaulted.length
+    },
+    panelEditable,
+    fileOnly,
+    undefaulted
+  };
+}

package/lib/config.js

@@ -696,6 +696,10 @@ export const Config = z.object({
   //       injection sort re-ranks by importance * quality_score/100 (degraded)
   //   score < 30 → archived + tagged low_quality (still explicitly searchable)
   // Meta-memory markers, near-duplicates and repetitive filler lose points.
+  // "Repetitive" is trigram repetition > 0.7 (this change). The shipped v0.7.12
+  // measure was unique-chars/total, which decays with length: it flagged 94% of
+  // 800-2000 char memories and 100% of longer ones, i.e. long Chinese prose was
+  // punished for being long. Threshold rationale lives in quality-filter.js.
   memoryQualityFilter: z.object({
     enabled: z.boolean().default(true),
     archiveThreshold: z.natural().min(1).max(100).default(30),
@@ -888,6 +892,30 @@ export const Config = z.object({
   // 「用户开关 > 轻量预设 > bundle」，同 continuityRescueEnabled / distillRecords.enabled）。
   organizeEnabled: z.boolean().default(false),
 
+  // chorography（仓库地志，spec: docs/specs/2026-11-04-chorography-design.md）的
+  // 暴露闸（opt-in，默认关）：管模型侧三个只读工具（choro_search / read_page /
+  // module_map）、面板浏览页，以及 M3 的开局注入。工具描述常驻模型上下文 = 新增
+  // 成本，按仓库纪律 opt-in；默认关=工具不存在、面板页空态、注入块不渲染，行为与
+  // 0.10.1 逐字节一致。
+  //
+  // 本键仍**不进 LIGHT_MODE_OFF**，但理由收窄成一句：它是「是否启用这个子系统」，
+  // 不是「每轮付多少」。轻量档要付的是下面那条 chorographyInject（把档位压成
+  // off）——两层分开，用户才能在轻量档里保留工具、只关掉每轮那块文本。
+  chorographyEnabled: z.boolean().default(false),
+
+  // 开局注入档位（M3，spec §7）：off / light / full，默认 light。
+  // light ≤8 行（模块名 + 文件数 + 页状态 + 页路径，按「还有 N 个」明说截断）；
+  // full 列全部模块；off 不注入但工具照旧可用。
+  // 为什么是枚举而不是布尔：spec 原文就是三档，「开了但只给 6 行」与「全给」是两种
+  // 用法，布尔键表达不了；跟随 chorographyEnabled 隐式开又会丢掉「留工具、去文本」
+  // 这个组合。
+  // 为什么写作 z.union([z.const(...)]) 而不是 z.enum：与 summarizeDedupeMode 同款，
+  // 全仓枚举键统一这一种写法（z.enum 的报错文案与既有键不一致）。
+  // 轻量档**不进 LIGHT_MODE_OFF**：那张表对平铺键一律赋 false，枚举键进去会得到与
+  // schema 不符的 false，而 false !== "off" 时注入照样渲染——静默失效比不关更糟。
+  // 轻量档的压制改在消费侧（src/wiki/inject.js 的 resolveInjectTier 判 lightMode）。
+  chorographyInject: z.union([z.const("off"), z.const("light"), z.const("full")]).default("light"),
+
   // --- scope: v0.8.0 A1 存储层（issue #17）--------------------------------
   // 总开关默认关：关闭时写入不标注 scope、去重维持 (type, title) 现状，行为
   // 逐字节不变。开启后**两条写入路径都自动盖章**（*_scope_source='auto'）：

package/lib/graph/anchoring.js

@@ -46,7 +46,12 @@ export function minMax(scores) {
 /**
  * 把一条检测通路的结果归一化成 0..1 的打分表。
  * path 是离散通路名（exact/tag/...）→ 查 DISCRETE_LEVELS；是连续通路
- * （continuous=true）→ min-max。返回 { byId: Map<id, score>, order: [id...] }。
+ * （continuous=true）→ min-max。返回 { path, byId: Map<id, score>, order }。
+ *
+ * issue #24 块1 补充：返回值带上 `path`。anchorSeeds 用它记「这个种子被哪几路
+ * 激活」（`seeds[i].paths`），复核时据此判断一条边是被精确名、Tag 桥接还是向量
+ * 拉进来的。此前只有 { byId, order }，`p.path ?? "?"` 把每一路都记成 "?"，
+ * 通路身份在合并那一步就丢了。连续通路调用方传 `path: "vector"`（cos 相似度）。
  */
 export function normalizePath(hits, { path = "exact", continuous = false } = {}) {
   const ids = Array.isArray(hits) ? hits : [];
@@ -62,7 +67,7 @@ export function normalizePath(hits, { path = "exact", continuous = false } = {})
     const level = DISCRETE_LEVELS[path] ?? DISCRETE_LEVELS.substring;
     for (const id of ids) byId.set(id, level);
   }
-  return { byId, order: [...byId.keys()] };
+  return { path, byId, order: [...byId.keys()] };
 }
 
 /**

package/lib/index.js

@@ -21,6 +21,10 @@ import { createApi } from "./api.js";
 import { createStandaloneApi } from "./api-standalone.js";
 // #275 存储生命周期第一批：无损回收（手动入口，不挂启动路径）。
 import { createMaintenance } from "./maintenance.js";
+import { createChoroQueries } from "./wiki/queries.js";
+// chorography M3：开局注入块与 /choro 只读回执。两者都只吃 queries 读侧，不写任何东西。
+import { createChoroInject } from "./wiki/inject.js";
+import { registerChoroCommand } from "./choro-command.js";
 import { createSettings } from "./settings.js";
 import { createCommandManager } from "./commands.js";
 import { createExecutionRecorder } from "./pipeline-runner.js";
@@ -152,7 +156,10 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger, serv
             return undefined;
           }
         }
-        writeAudit("success", null);
+        // 第三参必须显式传进去：writeAudit 的形参默认值 [] 是给"没有 id 可归因"
+        // 留的，省略第三参等于宣称"这条成功与任何记忆无关"——实测活库 6256 条
+        // success 行 100% 空数组，正是这个省略造成的。#405 只修了 error 半边。
+        writeAudit("success", null, relatedMemoryIds);
         return text;
       })().catch((err) => {
         logger?.warn?.(`[dsh-mneme] entity extraction llm stream failed: ${String(err)}`);
@@ -560,8 +567,26 @@ export const apply = (ctx, config) => {
   // a torn-down context.
   disposers.push(() => semantic.dispose());   // #118 重试计时器 + boot 回填计时器(搬入 semantic.js 后由它自持)
 
+  // chorography M3：地志提纲折进 memory context（不新开 context——宿主侧同 order 无
+  // 兜底排序，多一块就多一份拼装抖动；spec §7 也要求「合并成一次拼装」）。档位由
+  // chorographyInject 决定，off / 未匹配到仓库 / 渲染失败一律返回空串，宿主会过滤
+  // 掉空文本，整块消失且不占位。
+  //
+  // 预算是 0：注入块只在 memory context 里多几行，本身不做检索、不 fork git——
+  // 真过期判定留给 /choro（P29）。所以这里不需要额外的「热路径」闸，chorographyEnabled
+  // 与 chorographyInject 两个开关在 resolveInjectTier 里已经判完。
+  const choroInject = createChoroInject({
+    choro: createChoroQueries({ store }),
+    config: cfg,
+    logger: ctx.logger,
+    language: () => langOf(cfg)
+  });
+  disposers.push(() => choroInject.dispose());
+
   ctx.inject(["systemPrompt"], (promptCtx) => {
-    if (cfg.autoInject) disposers.push(createInjector(promptCtx, service, settings, cfg, preInjectGate, sessionGate));
+    if (cfg.autoInject) {
+      disposers.push(createInjector(promptCtx, service, settings, cfg, preInjectGate, sessionGate, choroInject));
+    }
   });
 
   // #249 N3：压缩边缘双落点。触发靠宿主自己落的压缩事件（订阅 + pre-step 追加），
@@ -572,9 +597,27 @@ export const apply = (ctx, config) => {
   }
 
   ctx.inject(["tools"], (toolsCtx) => {
-    disposers.push(createTools(toolsCtx, service, cfg, embedder, sessionGate));
+    // choro（M1）：只读查询对象，chorographyEnabled 关着时工具压根不注册（闸在
+    // createTools 的 hiddenTools，与 organizeEnabled 同款反向语义）。
+    disposers.push(createTools(toolsCtx, service, cfg, embedder, sessionGate, createChoroQueries({ store })));
   });
 
+  // chorography M3：/choro 只读回执。与 /mo-run 同形（ctx.commands.register），
+  // 但这里**不持有任何状态**、不写盘、不重建——spec §2 D6「只手动触发，过期只提示」
+  // 决定了这条命令只能看，不能改。位置必须在 disposers 声明之后（同 actionNudge 的
+  // TDZ 注释），否则插件加载时会直接抛 ReferenceError。
+  if (cfg.chorographyEnabled === true) {
+    const disposeChoro = registerChoroCommand({
+      ctx,
+      choro: createChoroQueries({ store }),
+      config: cfg,
+      enabled: true,
+      language: () => langOf(cfg)
+    });
+    if (disposeChoro) disposers.push(disposeChoro);
+    else ctx.logger?.info?.("[dsh-mneme] chorographyEnabled=true 但宿主没有命令注册表，/choro 未注册");
+  }
+
   const summarizer = createSummarizer(ctx, service, cfg, {}, sessionGate);
   disposers.push(summarizer.dispose);
 
@@ -599,11 +642,14 @@ export const apply = (ctx, config) => {
     // 本模块一次都不会被调用）。这样「没启用」与「没装配」在 HTTP 面上是两个可区分的
     // 答案（503 unavailable 只该出现在旧宿主/装配缺失上，不该被读成「用户没开」）。
     const extractProfileDraft = createProfileExtractor({ ctx, service, config: cfg, logger: ctx.logger });
+    // chorography 读侧（M1）：与 service 刻意分开——所有权模型相反（spec §3）。
+    // 闸在路由/工具两层（关着 409 / 不注册），queries 本体装配与开关无关。
+    const choro = createChoroQueries({ store });
     const api = createApi(ctx, service, settings, commands ?? {
       add: () => { throw new Error("commands unavailable"); },
       remove: () => false,
       list: () => []
-    }, embedder, { vectorIndex, reranker }, cfg.apiToken, cfg, maintenance, extractProfileDraft);
+    }, embedder, { vectorIndex, reranker }, cfg.apiToken, cfg, maintenance, extractProfileDraft, choro);
     disposers.push(api.dispose);
   }
 

package/lib/inject.js

@@ -93,7 +93,7 @@ function extractRounds(ctx, maxRounds) {
   }
 }
 
-export function createInjector(ctx, service, settings, config, gate = null, sessionGate = null) {
+export function createInjector(ctx, service, settings, config, gate = null, sessionGate = null, choroInject = null) {
   const language = langOf(config);
   const baseMaxItems = config.maxInjectedItems ?? 5;
   const threshold = config.importanceThreshold ?? 3;
@@ -405,9 +405,19 @@ export function createInjector(ctx, service, settings, config, gate = null, sess
         // #333（issue #34 恢复）：时间前缀只在会话首轮出现（per-session 闩锁），
         // 排在整个记忆块的最前——模型先知道「今天几号」，再看热上下文与长期记忆。
         const timePrefix = renderTimePrefix(ctx);
-        // 拼接次序：时间 → 热上下文 → 长期记忆（三者都可能为空，逐级判空拼接）。
+        // M3 仓库地志（chorography）：只注标题级提纲，档位 off/light/full。
+        // cwd 用 scope.workspace_scope——那是全仓唯一的 cwd 口径（registry 反查，
+        // header.cwd 兜底），另读一份就是两张皮且重犯 #487 的 Proxy 陷阱（P27）。
+        // 取不到 cwd / 仓库没登记 / 渲染失败一律空串：本块在热路径上，不能抛。
+        const choroText = choroInject && typeof choroInject.text === "function"
+          ? choroInject.text(scope?.workspace_scope ?? null)
+          : "";
+        // 拼接次序：时间 → 地志 → 热上下文 → 长期记忆（四者都可能为空，逐级判空）。
+        // 地志排在热上下文之前：它是「这个仓库由哪些模块组成」的稳定背景，
+        // 而热上下文是「刚才聊到哪」，越靠近正文越晚——稳定的在前，易变的在后。
         const withHot = !hotText ? body : body ? `${hotText}\n\n${body}` : hotText;
-        const finalBody = !timePrefix ? withHot : withHot ? `${timePrefix}\n\n${withHot}` : timePrefix;
+        const withChoro = !choroText ? withHot : withHot ? `${choroText}\n\n${withHot}` : choroText;
+        const finalBody = !timePrefix ? withChoro : withChoro ? `${timePrefix}\n\n${withChoro}` : timePrefix;
         // Issue #179：旁路缓存一帧——面板「注入预览」卡据此展示构成与体积。
         // chars 为条目内容的截断后近似值（与 render 同一函数计长），totalChars
         // 是本次实际返回块的精确长度。maxItems 反映自适应收缩后的生效值。
@@ -424,6 +434,8 @@ export function createInjector(ctx, service, settings, config, gate = null, sess
           // 「注入预览」卡据此展示判定是否生效与标记数。
           gate: gateFrame ? { state: gateFrame.state, nFlagged: gateFrame.flaggedIds ? gateFrame.flaggedIds.size : null, judged: gateFrame.judged ?? null } : null,
           hotChars: hotText.length,
+          // M3：地志块实际占的字符数（0 = 本帧没注入），面板据此区分「关」与「没匹配到仓库」。
+          choroChars: choroText.length,
           entries: candidates.map((m) => ({
             id: m.id,
             type: m.type,

package/lib/lang.js

@@ -415,5 +415,59 @@ export const STR = {
     en: () => "# document index — dsh-mneme\n\n<!-- Machine-owned as a whole and rebuildable from the memory store at any time (which is why it carries no generation timestamp). Annotations belong in the memory store (memory_save). managed = the file sits inside documentDir. -->\n\n"
   },
 
+
+  // --- wiki/inject.js + choro-command.js：仓库地志（chorography M3） ---------------
+  // 注入块是三句话要说清的东西：这是哪个仓库、什么时候生成的、下面这几行怎么读。
+  // 生成时间必须出现——地志是快照不是真相，读者得知道它可能是旧的（spec §2 D6：
+  // 过期只提示、绝不自动重跑，所以「提示」的唯一落点就是这里）。
+  choroBlockHeader: {
+    zh: (repo, count, date) => `[仓库地志] ${repo}：${count} 个模块，生成于 ${date}。以下是标题级提纲（不含正文）：`,
+    en: (repo, count, date) => `[Repo atlas] ${repo}: ${count} modules, generated ${date}. Title-level outline only (no page bodies):`
+  },
+  choroBlockLine: {
+    zh: (title, files, status, relPath) => `- ${title}（${files} 文件${status ? " · " + status : ""}） ${relPath}`,
+    en: (title, files, status, relPath) => `- ${title} (${files} files${status ? " · " + status : ""}) ${relPath}`
+  },
+  choroBlockMore: {
+    zh: (rest) => `- ……另有 ${rest} 个模块，需要时用 choro_module_map 看全表`,
+    en: (rest) => `- ...${rest} more modules; use choro_module_map for the full list`
+  },
+  choroStatusEnriched: { zh: "已有语义段", en: "enriched" },
+  choroStatusFailed: { zh: "生成失败", en: "failed" },
+  choroStatusStale: { zh: "可能已过期", en: "possibly stale" },
+
+  // /choro：只读回执。三条路径各自说清「看到了什么」——不写盘、不重建（P33）。
+  choroCommandDescription: {
+    zh: "仓库地志：看当前仓库的模块提纲、过期状态与用法",
+    en: "Repo atlas: show the module outline, staleness and usage hints for this repo"
+  },
+  choroCommandInputHint: { zh: "（无参数）", en: "(no arguments)" },
+  choroCommandUsage: {
+    zh: {
+      off: "chorography（仓库地志）没开。在设置的「仓库地志」里打开后重启 DSH；开之前只有空态，没有数据可看。",
+      noCwd: "拿不到这个会话的工作目录，无法判断你在哪个仓库里。",
+      noRepo: (cwd) => `当前工作目录没有登记过地志：${cwd}\n生成一份：dsh-mneme-choro <仓库路径> --apply（确定性骨架，零模型）`,
+      title: (repo, count, date) => `仓库地志 · ${repo}（${count} 个模块，生成于 ${date}）`,
+      empty: "这个仓库还没扫出任何模块（可能全部被 plan.yaml 的 include/exclude 排掉了）。",
+      truncated: (rest) => `……另有 ${rest} 个模块。完整提纲用工具 choro_module_map 看。`,
+      fresh: (head) => `基线一致：当前 HEAD 就是 ${head}，地志没过期。`,
+      stale: (baseline, head) => `⚠️ 可能已过期：地志基线 ${baseline}，当前 HEAD ${head}。它只提示、不会自己重跑——要更新就手动跑 dsh-mneme-choro <仓库路径> --apply。`,
+      noGit: "读不到当前 HEAD（不是 git 仓库或 git 不可用），没法判断是否过期。",
+      hint: "正文按模块读：先 choro_search 找命中，再 choro_read_page 取整页。重建、富化都走 CLI，不在这条命令里。"
+    },
+    en: {
+      off: "Chorography (repo atlas) is off. Turn on the atlas switch in settings, then restart DSH; until then there is nothing to read.",
+      noCwd: "Cannot determine the working directory of this session, so the repo cannot be resolved.",
+      noRepo: (cwd) => `No atlas registered for this working directory: ${cwd}\nBuild one: dsh-mneme-choro <repo path> --apply (deterministic skeleton, no model)`,
+      title: (repo, count, date) => `Repo atlas · ${repo} (${count} modules, generated ${date})`,
+      empty: "No modules were produced for this repo (plan.yaml include/exclude may have filtered everything).",
+      truncated: (rest) => `...${rest} more modules. Use the choro_module_map tool for the full outline.`,
+      fresh: (head) => `Baseline matches: HEAD is ${head}, the atlas is not stale.`,
+      stale: (baseline, head) => `Possibly stale: atlas baseline ${baseline}, current HEAD ${head}. It only warns and never rebuilds itself — rerun dsh-mneme-choro <repo path> --apply to refresh.`,
+      noGit: "Cannot read HEAD (not a git repo, or git unavailable), so staleness is unknown.",
+      hint: "Read bodies per module: choro_search to locate, choro_read_page to load a whole page. Rebuilds and enrichment stay in the CLI, not in this command."
+    }
+  },
+
   prompts: PROMPTS
 };

package/lib/quality-filter.js

@@ -15,7 +15,7 @@
 //                       memory system itself, not the user's world)    −45
 //   self_referential    title/content mentions its own type label      −15
 //   short_content       content shorter than minContentLength          −80
-//   repetitive          dedup ratio (unique chars / total) < 0.3       −50
+//   repetitive          trigram repetition ratio > 0.7                 −50
 //   duplicate           bigram similarity to a recent memory > 0.85    −80
 //
 // The meta signal alone lands a well-formed memory in the degraded band
@@ -26,6 +26,20 @@
 export const META_MEMORY_RE =
   /记忆|mneme|recall|inject|上下文|token|prompt|系统指令|作为AI|作为助手|我需要记住|总结一下刚才/;
 
+// The deduction table is exported because a SECOND reader needs the same numbers: the
+// one-time backfill in store.js reconstructs a stored score from a row's surviving tags
+// (it cannot re-score wholesale — that would also re-apply signals that were never on
+// the row). Duplicating 45/15/80/50/80 there would make "what a tag costs" two facts
+// that can drift apart, and the drift would be silent: the backfill would just write
+// slightly wrong numbers. Keys are the tag names, not the reasons.
+export const SIGNAL_DEDUCTIONS = Object.freeze({
+  meta: 45,
+  self_referential: 15,
+  short_content: 80,
+  repetitive: 50,
+  duplicate: 80
+});
+
 // Own-type labels, used for self-reference detection (the English type value
 // the AI writers emit plus the Chinese equivalent a human would type).
 const TYPE_LABELS = {
@@ -56,11 +70,33 @@ export function textSimilarity(a, b) {
   return inter / Math.min(A.size, B.size);
 }
 
-/** Fraction of characters that are unique (dedup ratio in [0,1]). */
-export function dedupRatio(text) {
-  const t = String(text);
-  if (!t.length) return 0;
-  return new Set(t).size / t.length;
+// Repetition threshold. Calibrated 2026-11-04 against a real 12,827-row library:
+// the highest trigram ratio among genuine memories was 0.591 (a note where the
+// same install paths repeat), so 0.7 keeps every real memory clear while still
+// catching degenerate fillers (a single char x20 = 0.94, a sentence x5 = 0.79).
+// Do not lower this without re-measuring: 0.6 leaves only 0.009 of headroom.
+export const REPETITION_THRESHOLD = 0.7;
+
+/**
+ * Trigram repetition ratio in [0,1]: the share of 3-char windows that are not
+ * the first occurrence of their own trigram. 0 = every trigram distinct.
+ *
+ * Why this instead of unique-chars / total (the measure shipped in v0.7.12):
+ * that one is a function of LENGTH, not of repetition. Chinese prose draws from
+ * a few hundred common characters, so uniqueChars/total decays toward 0 as the
+ * text grows — measured on a real library it fell below the old 0.3 gate for
+ * 94% of 800-2000 char memories and 100% of those over 2000 chars. Long memories
+ * were being tagged "repetitive" for being long. Trigram repetition is
+ * length-stable: concatenating distinct real memories up to 30,000 chars only
+ * reaches 0.428, while genuinely duplicated text passes 0.6 by the second copy.
+ */
+export function repetitionRatio(text) {
+  const t = String(text).replace(/\s+/g, "");
+  if (t.length < 3) return 0;
+  const total = t.length - 2;
+  const seen = new Set();
+  for (let i = 0; i < total; i++) seen.add(t.slice(i, i + 3));
+  return 1 - seen.size / total;
 }
 
 /**
@@ -85,26 +121,26 @@ export function evaluateMemoryQuality(memory, options = {}) {
   let score = 100;
 
   if (META_MEMORY_RE.test(text)) {
-    score -= 45;
+    score -= SIGNAL_DEDUCTIONS.meta;
     tags.push("meta");
     reasons.push("meta-memory vocabulary");
   }
 
   const labels = TYPE_LABELS[memory?.type];
   if (labels && labels.some((l) => text.includes(l))) {
-    score -= 15;
+    score -= SIGNAL_DEDUCTIONS.self_referential;
     tags.push("self_referential");
     reasons.push("mentions its own type");
   }
 
   if (minContentLength > 0 && trimmed.length < minContentLength) {
-    score -= 80;
+    score -= SIGNAL_DEDUCTIONS.short_content;
     tags.push("short_content");
     reasons.push(`content shorter than ${minContentLength} chars`);
   }
 
-  if (trimmed.length > 0 && dedupRatio(trimmed) < 0.3) {
-    score -= 50;
+  if (trimmed.length > 0 && repetitionRatio(trimmed) > REPETITION_THRESHOLD) {
+    score -= SIGNAL_DEDUCTIONS.repetitive;
     tags.push("repetitive");
     reasons.push("repetitive content");
   }
@@ -112,7 +148,7 @@ export function evaluateMemoryQuality(memory, options = {}) {
   if (recentContents.length > 0 && trimmed.length > 0) {
     for (const other of recentContents) {
       if (textSimilarity(trimmed, other) > 0.85) {
-        score -= 80;
+        score -= SIGNAL_DEDUCTIONS.duplicate;
         tags.push("duplicate");
         reasons.push("near-duplicate of a recent memory");
         break;