@modusensus/dsh-mneme 0.12.0 → 0.13.0

package/lib/service.js

@@ -7,6 +7,7 @@ import { STR, langOf } from "./lang.js";
 import { computeHeat } from "./heat.js";
 import { recallStats } from "./recall-stats.js";
 import { evaluateMemoryQuality } from "./quality-filter.js";
+import { CAPACITY_WARNING_DEFAULTS } from "./config.js";
 // 外来行（source='imported'，导入路径落的来源）的身份判定只许有一个定义处——本文件的
 // 两处汇流口与巩固/降级那些读侧行池都调这同一个谓词，避免各处自己写字符串比较然后各自漂移。
 import { isImportedRow } from "./memory-source.js";
@@ -532,6 +533,25 @@ export function createService({ store, mirror, config, onWrite, logger, document
     return dot / (Math.sqrt(na) * Math.sqrt(nb));
   }
 
+  // BM25 语料索引缓存（#617 审计 O2）。此前每次渲染都 store.list 500 行 + 重新
+  // tokenize 全语料，实测 4.318ms/次、每个 step 一次；其中 store.list 占 4.318ms
+  // 里的绝大部分，而语料在两次写入之间根本没变。
+  //
+  // 失效键用 mirror_state.generation，不另建计数器：改正文/可见性的写入（insert /
+  // update / remove / setArchived / setForgotten / setContent …）都已经 bump 它，
+  // 而 last_accessed_at 与 embedding 这两类写入**刻意不 bump**（store.js 里写明
+  // reads must not mark the mirror dirty）——这两类恰好也不改 title+content 语料，
+  // 正是我们要的失效粒度，不用额外判断。
+  //
+  // 水位每次从库里现读，不在进程内记本地计数：多宿主共用一个 memoryDir 是支持形态
+  // （busy_timeout + WAL），另一个进程写完 bump 的是库里的 generation，本地计数
+  // 永远看不见，只有现读才收得到。
+  //
+  // 只缓存索引、不缓存查询结果：search() 返回的是 {...row, score} 副本，索引里
+  // 留着的原始行不会被调用方改到；缓存结果则会跨 step 串味（同一 query 在不同
+  // 池子状态下该给不同答案）。
+  let bm25IndexCache = null; // { generation, index } | null
+
   /**
    * BM25 third recall path (v0.5.0 1.1). Scores the query tokens against the
    * live non-archived rows and returns the top `limit` hits with scores
@@ -541,14 +561,40 @@ export function createService({ store, mirror, config, onWrite, logger, document
   function bm25Recall(q, limit) {
     if (config?.bm25SearchEnabled === false) return [];
     try {
-      const docs = store.list({ limit: 500, includeForgotten: false }).filter((m) => !m.archived);
-      if (!docs.length) return [];
-      return createBM25Index(docs).search(q, { limit });
+      const index = bm25CorpusIndex();
+      if (!index) return [];
+      return index.search(q, { limit });
     } catch {
       return [];
     }
   }
 
+  /**
+   * 取（必要时重建）BM25 语料索引。水位读不到时退化成每次重建而不是报错：这条
+   * 通路是 recall booster，读不到 mirror_state 只该慢一点，不该让词法召回整批消失。
+   */
+  function bm25CorpusIndex() {
+    let generation = null;
+    try {
+      generation = store.getMirrorState().generation;
+    } catch { /* 水位不可读：本次退回重建，且不写缓存 */ }
+    if (bm25IndexCache && generation !== null && bm25IndexCache.generation === generation) {
+      return bm25IndexCache.index;
+    }
+    const docs = store.list({ limit: 500, includeForgotten: false }).filter((m) => !m.archived);
+    if (!docs.length) {
+      bm25IndexCache = null;
+      return null;
+    }
+    const index = createBM25Index(docs);
+    // 水位读不到时**不碰缓存**，保留上一份「已知有效 generation」的条目：读失败
+    // 若只是偶发（库锁、迁移窗口）而期间没有写入，恢复后水位与条目一致，直接命中；
+    // 期间真有写入，水位已经变了，下一轮自然重建。反过来把 null 当键存进去则是纯
+    // 噪声——那样的条目永远命不中，还把有效的那份挤掉了。
+    if (generation !== null) bm25IndexCache = { generation, index };
+    return index;
+  }
+
   /**
    * Graph fourth recall path (issue #219 → #24 块1 锚定层). When the query text
    * mentions a known entity name, memories linked to that entity (attrs +
@@ -922,18 +968,13 @@ export function createService({ store, mirror, config, onWrite, logger, document
       }
     }
 
-    // Mode contract, auto (aligns rrf/minmax with blend): keyword leads, the
-    // recipe fills the remaining slots. blend.auto already front-loads keyword;
-    // rrf/minmax rank across sources, so re-apply the same "keyword first"
-    // ordering here to preserve the pre-fusion auto contract — the keyword
-    // hit list keeps its power, and only slots it couldn't fill go to the
-    // recipe's ranking.
-    if (recipe !== "blend" && mode === "auto" && keyword.length) {
-      const head = keyword.slice(0, lim);
-      const seen = new Set(head.map((m) => m.id));
-      const tail = merged.filter((m) => !seen.has(m.id)).slice(0, Math.max(0, lim - head.length));
-      merged = head.concat(tail);
-    }
+    // #617 第 3 条：这里原本还有一段「recipe !== "blend" 且 mode === "auto" 时用
+    // keyword.slice(0,lim) 覆盖 merged」的收尾，注释自称是「保留 blend 的 auto
+    // 契约」。但 rrf/minmax 的全部意义就是跨源排序——把它们算出来的序整个换成
+    // 「关键词命中先上」，等于配置了 rrf 却在 auto 下拿到 keyword 的顺序，配方
+    // 白选。auto 的「关键词领位」语义只属于 blend（它在 :906-922 里自己实现了，
+    // 且带 seen 去重与容量控制），不该由收尾段替别的配方代劳。删掉后 rrf/minmax
+    // 的 auto 排序就是它们各自算出来的排序。
 
     return { merged, signals };
   }
@@ -1778,62 +1819,60 @@ export function createService({ store, mirror, config, onWrite, logger, document
           (effImportance(a) * qualityWeight(a) * heatOf(a) * scopeMultOf(a));
       });
     let candidates = items;
+    // #617 第 2 条（前半）：向量路与 BM25 路此前是**互斥**的——`if (!semanticItems.length)`
+    // 包住 BM25，于是「有向量」等于「词法命中整批消失」。可两条路测的不是同一件事：
+    // 向量管「意思像」，BM25 管「词面撞上」，专有名词、issue 编号、函数名这类查询
+    // 恰恰是向量最容易糊、词法最准的地方。现在两路都跑，用 RRF（k=60）融合排名：
+    // 某一路的第 1 名恒得 1/(60+1)，两路都靠前的行自然走高，不再由「谁先跑」决定。
+    // 另外先按 fetchLimit 多取再过滤——旧代码先按 poolSize 截断再筛门控，筛掉的
+    // 名额永远补不回来（缩水），池子越脏越明显。
+    let fusedRrf = null; // id -> RRF 原始分；selectiveInject 复用它做二次重排
     if (config.hybridInject !== false && q) {
-      // Bug4: semantic-first recall. Vector hits (queryVector, cached by the
-      // injector's async prefetch) lead when present; otherwise the last
-      // searchMemories recall for the exact same query is reused. Rule-based
-      // items fill + dedupe the remaining slots. Empty query / no vector /
-      // no cached recall → pure legacy rule-based selection.
-      const semanticItems = [];
+      const fetchLimit = Math.max(poolSize * 4, 40);
+      const passesGate = (m) => Boolean(m) && !m.archived && injectTypes.has(m.type) && !m.forgotten &&
+        (m.source !== "narrative" || allowNarrative) &&
+        codingGate(m) &&
+        (m.type === "summary" || m.type === "preference" || m.importance >= threshold);
+      const vectorHits = [];
       if (Array.isArray(queryVector) && queryVector.length && vectorIndex) {
         try {
-          const hits = vectorIndex.search(queryVector, { limit: poolSize, threshold: 0 });
-          for (const m of hits) {
-            if (m && !m.archived && injectTypes.has(m.type) && !m.forgotten &&
-              (m.source !== "narrative" || allowNarrative) &&
-              codingGate(m) &&
-              (m.type === "summary" || m.type === "preference" || m.importance >= threshold)) {
-              semanticItems.push(m);
-            }
+          for (const m of vectorIndex.search(queryVector, { limit: fetchLimit, threshold: 0 })) {
+            if (passesGate(m)) vectorHits.push(m);
           }
         } catch { /* vector unavailable: fall through to the recall cache */ }
       }
-      if (!semanticItems.length && lastSemanticRecall?.query === q && lastSemanticRecall.items?.length) {
-        // CodeRabbit on #404：这条回填分支此前独漏重要度门槛——向量路（上方）与
-        // BM25 路（下方 :1655 注释「门控与向量路径一致（含 importance 阈值）」）
+      if (!vectorHits.length && lastSemanticRecall?.query === q && lastSemanticRecall.items?.length) {
+        // CodeRabbit on #404：这条回填分支此前独漏重要度门槛——向量路与 BM25 路
         // 都带着它。#369 收编 history 后缺口会被放大：库里低于闸门的行（实测
         // history 378 条中有 27 条 i<=2）走一次检索进缓存就能绕开门槛占注入位。
-        for (const m of lastSemanticRecall.items) {
-          if (m && !m.archived && injectTypes.has(m.type) && !m.forgotten &&
-            (m.source !== "narrative" || allowNarrative) && codingGate(m) &&
-            (m.type === "summary" || m.type === "preference" || m.importance >= threshold)) semanticItems.push(m);
-        }
+        for (const m of lastSemanticRecall.items) if (passesGate(m)) vectorHits.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, poolSize)) {
-          if (hit && !hit.archived && injectTypes.has(hit.type) && !hit.forgotten &&
-            (hit.source !== "narrative" || allowNarrative) &&
-            codingGate(hit) &&
-            (hit.type === "summary" || hit.type === "preference" || hit.importance >= threshold)) {
-            semanticItems.push(hit);
-          }
-        }
-        // issue #339（CodeRabbit review on #350）：首轮 BM25 兜底领跑合并池，
-        // 而 selectiveInject 相似度重排要等查询向量就绪才执行——软加权必须
-        // 在这里就位，否则 foreign 命中绕过降权直接占注入位。
-        if (softScopeActive) {
-          semanticItems.sort((a, b) =>
-            (b.score ?? 0) * scopeMultOf(b) - (a.score ?? 0) * scopeMultOf(a));
-        }
-      }
-      if (semanticItems.length) {
+      // Issue #198：BM25 词法路。首轮（无向量、无缓存召回）这是唯一的同步相关性
+      // 信号；有向量时它补上向量糊掉的那一类命中。#617 之后它不再被向量挤掉。
+      const bm25Hits = [];
+      for (const hit of bm25Recall(q, fetchLimit)) if (passesGate(hit)) bm25Hits.push(hit);
+      if (vectorHits.length || bm25Hits.length) {
+        const RRF_K = 60;
+        const rrf = new Map();
+        const rowById = new Map();
+        const addList = (list) => {
+          list.forEach((m, idx) => {
+            rowById.set(m.id, m);
+            rrf.set(m.id, (rrf.get(m.id) ?? 0) + 1 / (RRF_K + idx + 1));
+          });
+        };
+        addList(vectorHits);
+        addList(bm25Hits);
+        fusedRrf = rrf;
+        // 软加权（issue #339 / CodeRabbit on #350）作用在融合分上：foreign 行不再
+        // 靠一路的原始 score 绕过降权，也不需要像旧代码那样单独给 BM25 排一次序。
+        const ranked = [...rrf.entries()]
+          .map(([id, score]) => {
+            const m = rowById.get(id);
+            return { m, score: score * scopeMultOf(m) };
+          })
+          .sort((a, b) => b.score - a.score)
+          .map((row) => row.m);
         const seen = new Set();
         const merged = [];
         const push = (m) => {
@@ -1841,7 +1880,7 @@ export function createService({ store, mirror, config, onWrite, logger, document
           seen.add(m.id);
           merged.push(m);
         };
-        for (const m of semanticItems) {
+        for (const m of ranked) {
           push(m);
           if (merged.length >= poolSize) break;
         }
@@ -1927,16 +1966,29 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // vector, so the injected slots go to memories on the current topic
     // rather than to the rule-based order. Rows the index did not return
     // keep their relative order after the scored ones.
+    //
+    // #617 第 2 条（后半）：这段此前是**纯余弦**全量 sort，于是上游用 RRF 顶上来的
+    // BM25 命中（词面精确、余弦却低）会被重新压到 maxItems 之后，再被 general 槽
+    // 的 `general.length >= maxItems` 丢掉——融合白做。现在余弦只占一半权重，另一半
+    // 给 RRF 分（同一轮融合算出来的那份）：纯余弦命中仍是主体，但词法精确命中
+    // 不会因为「意思不够像」被挤出去。
+    // RRF 归一化：单路第 1 名原始分 1/(60+1)，乘 (60+1)/2 得 0.5，双路都在第 1 名
+    // 得 1.0 —— 与余弦同量纲，且天然落在 [0,1]。
     if (config?.selectiveInjectEnabled !== false && Array.isArray(queryVector) && queryVector.length && vectorIndex) {
       try {
         const hits = vectorIndex.search(queryVector, { limit: 200, threshold: 0 });
         const sim = new Map(hits.map((m) => [m.id, m.score ?? 0]));
         if (sim.size) {
-          // 软加权作用在真实 sim 上；未命中的规则候选保持 -1 沉底（缺失项
-          // 乘乘数会让 foreign 缺失项反而排到自己的缺失项之上，故不乘）。
+          const RRF_NORM = (60 + 1) / 2;
+          // 软加权乘在融合分上（不是乘在某一路的原始分上）；两路都没有的规则
+          // 候选保持 -1 沉底（缺失项乘乘数会让 foreign 缺失项反而排到自己的缺失
+          // 项之上，故不乘）。
           const scopedSim = (m) => {
             const s = sim.get(m.id);
-            return s === undefined ? -1 : s * scopeMultOf(m);
+            const rrf = fusedRrf?.get(m.id);
+            if (s === undefined && rrf === undefined) return -1;
+            const fused = 0.5 * (s ?? 0) + 0.5 * (rrf ?? 0) * RRF_NORM;
+            return fused * scopeMultOf(m);
           };
           candidates = [...candidates].sort((a, b) => scopedSim(b) - scopedSim(a));
         }
@@ -2260,6 +2312,10 @@ export function createService({ store, mirror, config, onWrite, logger, document
       id: r.id,
       run_id: r.run_id ?? null,
       reason: r.reason ?? null,
+      // Issue #603 第 2 层：入队时记下的相似度（0–1）。存量行与 LLM 裁决路径
+      // 没记 → null。面板据此排序与画条，不再从 reason 文本里正则回收；
+      // null 与 0 必须区分开（「没测过」不是「不相似」）。
+      similarity: typeof r.similarity === "number" ? r.similarity : null,
       created_at: r.created_at,
       memory_a: side(r.memory_a),
       memory_b: side(r.memory_b)
@@ -2612,6 +2668,71 @@ export function createService({ store, mirror, config, onWrite, logger, document
     }
   }
 
+  // getCapacityHealth：容量预警（#275 空间维度）——库体积 / 归档区规模是否过线。
+  // 与 getMirrorHealth 同款 fail-safe：读失败显式 unknown，绝不伪装成 ok，也绝不
+  // 向外抛（/health 还有镜像那半张答复，容量不能把整张健康面拖塌）。
+  // 阈值读 config.capacityWarning；config 缺席（直连调用方 / 测试传裸对象）时退回
+  // config.js 的同一份常量，不另立一套数字。答复里只有数字，**绝不带 storageStats
+  // 的 path**——那是本机文件系统布局，/health 是半张对外面。
+  function getCapacityHealth() {
+    const unknown = () => ({
+      status: "unknown",
+      file_bytes: null,
+      freelist_bytes: null,
+      active_rows: null,
+      archived_rows: null,
+      archived_ratio: null,
+      checks: []
+    });
+    try {
+      const cfg = { ...CAPACITY_WARNING_DEFAULTS, ...(config?.capacityWarning ?? {}) };
+      const stats = store.storageStats();
+      const counts = store.capacityStats();
+      const total = counts.active + counts.archived;
+      const ratio = total > 0 ? counts.archived / total : null;
+      const checks = [];
+      // 每条检查：阈值 > 0 才启用（0 = 显式关掉这一条），过线判 >= ——「到阈值」
+      // 即报警（#275 口径）。没法评的检查直接缺席而不是伪装 ok：file_bytes 为
+      // null（:memory: 库）时体积检查进不了列表，total 为 0 时占比检查同理。
+      if (cfg.dbSizeWarnMb > 0 && stats.fileBytes !== null) {
+        checks.push({
+          key: "db_size",
+          status: stats.fileBytes >= cfg.dbSizeWarnMb * 1048576 ? "warn" : "ok",
+          value_bytes: stats.fileBytes,
+          threshold_bytes: cfg.dbSizeWarnMb * 1048576
+        });
+      }
+      if (cfg.archivedRowsWarn > 0) {
+        checks.push({
+          key: "archived_rows",
+          status: counts.archived >= cfg.archivedRowsWarn ? "warn" : "ok",
+          value: counts.archived,
+          threshold: cfg.archivedRowsWarn
+        });
+      }
+      if (cfg.archivedRatioWarn > 0 && ratio !== null) {
+        checks.push({
+          key: "archived_ratio",
+          status: ratio >= cfg.archivedRatioWarn ? "warn" : "ok",
+          value: Math.round(ratio * 1000) / 1000,
+          threshold: cfg.archivedRatioWarn
+        });
+      }
+      return {
+        status: checks.some((c) => c.status === "warn") ? "warn" : "ok",
+        file_bytes: stats.fileBytes,
+        freelist_bytes: stats.freelistCount * stats.pageSize,
+        active_rows: counts.active,
+        archived_rows: counts.archived,
+        archived_ratio: ratio === null ? null : Math.round(ratio * 1000) / 1000,
+        checks
+      };
+    } catch (error) {
+      logger?.warn?.("getCapacityHealth failed:", error);
+      return unknown();
+    }
+  }
+
   // 返回字面量与内部裁决器（resolveConflictPending → applyDecisions 的 conflict
   // 处置）共用的写路径：mirror 同步、写通知、嵌入调度全部同源，不能各写一份。
   function updateMemory(id, p, ctx = {}) {
@@ -2765,6 +2886,7 @@ export function createService({ store, mirror, config, onWrite, logger, document
     organize,
     recoverMirror,
     getMirrorHealth,
+    getCapacityHealth,
     getMirrorState: () => store.getMirrorState(),
     injectCandidates,
     mergeHumanEdits,
@@ -2897,6 +3019,7 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // 向量出身的两个分组读数：状态端点 /semantic 用它们区分「有向量」和
     // 「可检索」（byModel 按行级 embedding_model，byDimension 按向量维数）。
     // passthrough 形状与 embeddedCount 同款，api 层不直接摸 store。
+    countNeedsEmbeddingFor: (modelHash) => store.countNeedsEmbeddingFor(modelHash),
     embeddingModelBreakdown: () => store.embeddingModelBreakdown(),
     embeddingDimensionBreakdown: () => store.embeddingDimensionBreakdown(),
     // #383：维度探针，供 /context 判「库里有没有一条活跃向量与查询同维」。注意
@@ -2916,6 +3039,8 @@ export function createService({ store, mirror, config, onWrite, logger, document
     list: (o) => store.list(o),
     all: () => store.all(),
     count: (type, opts) => store.count(type, opts),
+    // #597：/list 的 typeCounts——同一份筛选、不带 type 的全库分布（面板分类栏数字源）。
+    countByType: (opts) => store.countByType(opts),
     getById: (id) => store.getById(id),
     remove: (id) => {
       store.remove(id);
@@ -3035,6 +3160,8 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // migrates entity_attrs on merge. Bookkeeping writes like the audit
     // passthroughs above — never write-hook-triggering memory mutations.
     saveRelation: (r) => store.saveRelation(r),
+    // #619：同一条边被后续观察补充证据时回写 metadata（情感相位判重命中）。
+    updateRelationMetadata: (id, metadata) => store.updateRelationMetadata(id, metadata),
     listEntities: (o) => store.listEntities(o),
     countEntities: () => store.countEntities(),
     getRelations: (id) => store.getRelations(id),

package/lib/settings.js

@@ -34,7 +34,9 @@ function parseList(raw) {
 // persona 对象的字段白名单：写入时只挑这些键，未知字段丢弃（设计稿①：字段从简，
 // beta 收到真实反馈再加；provenance 是 v1.5 协作式人格的预留位，v1 不写管道）。
 // 读侧损坏即回空对象——同一容错口径照 parseList（坏值不抛错、面板显示为空可重写）。
-const PERSONA_FIELDS = ["name", "personality", "replyStyle", "enabled", "provenance"];
+// scenario / mesExample（#606）：对标 Character Card V2 的同名字段，是「人格卡能装
+// 下完整角色」所需的最小补充。两者都可选、都不写时渲染零输出（老用户逐字节不变）。
+const PERSONA_FIELDS = ["name", "personality", "replyStyle", "scenario", "mesExample", "enabled", "provenance"];
 
 function parsePersona(raw) {
   try {
@@ -54,14 +56,20 @@ function parsePersona(raw) {
 // 兼容层：v1 存的是单对象（有 PERSONA_FIELDS 键、无 default/byAgent 键），读侧
 // 判形状——单对象原样落 default 位，旧数据零迁移。byAgent 的键是 agent 身份
 // id（注入时按会话身份寻址，取不到落 default）。default 卡不可删（兜底位）。
+//
+// 绑会话（v1.3，#606）：加第三维 bySession: { <sessionId>: <卡> }。为什么需要它——
+// byAgent 的键来自 session.header.agentPreset，而 DS Bot 这类宿主把它写成常量
+// （所有 bot 会话都是 "standard"，实测 43/50），按 bot 名字建卡永远不命中。会话 id
+// 才是那个「一个 bot 一张卡」真正能分开的键。bySession 同样是纯加法：没有这个键
+// 的老数据读成 {}，注入文本逐字节不变。
 function parsePersonaStore(raw) {
   try {
     const value = JSON.parse(raw);
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
-      return { default: {}, byAgent: {} };
+      return { default: {}, byAgent: {}, bySession: {} };
     }
-    // 新形：含 default 或 byAgent 键 → 按多卡解析
-    if ("default" in value || "byAgent" in value) {
+    // 新形：含 default / byAgent / bySession 任一键 → 按多卡解析
+    if ("default" in value || "byAgent" in value || "bySession" in value) {
       const byAgent = {};
       if (value.byAgent && typeof value.byAgent === "object" && !Array.isArray(value.byAgent)) {
         for (const [agentId, card] of Object.entries(value.byAgent)) {
@@ -69,19 +77,27 @@ function parsePersonaStore(raw) {
           if (Object.keys(parsed).length) byAgent[String(agentId)] = parsed;
         }
       }
-      return { default: parsePersona(JSON.stringify(value.default ?? {})), byAgent };
+      const bySession = {};
+      if (value.bySession && typeof value.bySession === "object" && !Array.isArray(value.bySession)) {
+        for (const [sessionId, card] of Object.entries(value.bySession)) {
+          const parsed = parsePersona(JSON.stringify(card ?? {}));
+          if (Object.keys(parsed).length) bySession[String(sessionId)] = parsed;
+        }
+      }
+      return { default: parsePersona(JSON.stringify(value.default ?? {})), byAgent, bySession };
     }
     // 旧形：v1 单对象 → 整体作 default（字段白名单在 parsePersona 内裁）
-    return { default: parsePersona(raw), byAgent: {} };
+    return { default: parsePersona(raw), byAgent: {}, bySession: {} };
   } catch {
-    return { default: {}, byAgent: {} };
+    return { default: {}, byAgent: {}, bySession: {} };
   }
 }
 
 function serializePersonaStore(store) {
   const out = {
     default: parsePersona(JSON.stringify(store?.default ?? {})),
-    byAgent: {}
+    byAgent: {},
+    bySession: {}
   };
   if (store?.byAgent && typeof store.byAgent === "object") {
     for (const [agentId, card] of Object.entries(store.byAgent)) {
@@ -89,6 +105,12 @@ function serializePersonaStore(store) {
       if (Object.keys(parsed).length) out.byAgent[String(agentId)] = parsed;
     }
   }
+  if (store?.bySession && typeof store.bySession === "object") {
+    for (const [sessionId, card] of Object.entries(store.bySession)) {
+      const parsed = parsePersona(JSON.stringify(card ?? {}));
+      if (Object.keys(parsed).length) out.bySession[String(sessionId)] = parsed;
+    }
+  }
   return JSON.stringify(out);
 }
 
@@ -137,15 +159,27 @@ const FEATURE_FLAG_BOOLEANS = [
   // Issue #230：document 型记忆——agent 产长文档的指针行（注册校验/摘要+
   // doc_path 落库/C2 去重/supersede 记账；全文归 agent；默认关，lightMode 强制关）。
   "documentMemoryEnabled",
+  // 日记本：跨天惰性判定 + 启动补写，正文落 <memoryDir>/diaries/<项目键>/。
+  // 默认关，进 LIGHT_MODE_OFF（要调模型，与低资源档互斥）。与 documentMemoryEnabled
+  // 成对但不相依：关掉文档记忆只影响检索，正文照样写。
+  "diaryEnabled",
   "codingRetrospect",
   "autoDream",
   // Issue #292：autoDream 连续失败退避（默认关）。基数是 dreamMinIntervalMinutes，
   // 有效间隔 = 基数 × 2^连续失败数（成功清零），封顶 30 分钟；面板可启停。
   "autoDreamFailureBackoff",
+  // Issue #557：dream 审计行输入快照瘦身（默认关）。开启后 auto 轮只落骨架
+  // （不含 content），organize 轮的重放载荷不受影响；面板可启停。
+  "dreamInputSummaryEnabled",
   "sleepModeEnabled",
   // Issue #529：sleep 连续失败退避（默认关）。基数是 sleepMinIntervalHours，
   // 有效间隔 = 基数 × 2^连续失败数（成功清零），封顶 max(基数, 24h)；面板可启停。
   "sleepFailureBackoff",
+  // Issue #619：情感归因相位（默认关）。把「某人某场合的情绪」写成 occasion-bound
+  // 的 affective_context 关系，只有跨够 sleepAffectiveTraitMinSessions 个独立会话
+  // 才允许升成稳定特质。要调模型且依赖实体抽取，所以必须显式打开、可随时关掉；
+  // 它是 sleepModeEnabled 的子相：父开关关着时整个 sleep 不跑。
+  "sleepAffectiveEnabled",
   "heatEnabled",
   // issue #218 / E5：注入侧 heat 独立开关（默认关，老用户 injectHeatEnabled=true 回滚）。
   "injectHeatEnabled",
@@ -159,6 +193,11 @@ const FEATURE_FLAG_BOOLEANS = [
   "reflectionFailureTracking",
   "bm25SearchEnabled",
   "conflictFreezeEnabled",
+  // Issue #603 第 4 层：自动裁决档（默认关）。相似度极高的同 scope 重复对直接
+  // 保留新条、归档旧条，不进人工队列；模糊地带照旧留给人。会归档记忆，所以必须
+  // 显式打开，面板可启停。阈值见 FEATURE_FLAG_NUMBER_RANGES 的
+  // conflictAutoResolveMinSimilarity。
+  "conflictAutoResolveEnabled",
   "trustEpistemicWeighting",
   // Plan #2: attach per-source {keyword, vector, bm25, final} signals to each
   // search result for transparency/debugging. Default off, purely decorative.
@@ -255,7 +294,14 @@ const FEATURE_FLAG_BOOLEANS = [
   // #539：逐会话无痕默认关闭；子代理开关受总开关约束。手动 session id 名单留在配置，
   // 不进入只支持标量的 feature_flags 白名单。
   "sessionGateEnabled",
-  "sessionGateSubagents"
+  "sessionGateSubagents",
+  // 2026-11-08 kb-qoder parity（契约 §3.1）：chorography 面板闭环的两个授权闸 +
+  // kb 子系统总闸。三条都与 config.js schema 成对出现，计数锁 test/api.test.js 钉住。
+  // 不进 LIGHT_MODE_OFF —— 它们是「谁按下了按钮」而不是「每轮付多少」，理由写在
+  // config.js 那三个键的注释里。kbEnabled 本车道只登记、不接线（B 线做子系统）。
+  "chorographyAutoRefresh",
+  "chorographyT1FromPanel",
+  "kbEnabled"
 ];
 // 整数开关的闭区间，与 config.js 里 z.natural().min().max() 对齐。
 const FEATURE_FLAG_INT_RANGES = {
@@ -280,6 +326,9 @@ const FEATURE_FLAG_INT_RANGES = {
   summarizePeakMaxDeferMinutes: [0, 1440],
   // Issue #239 第 4 项镜像到巩固：同一口径（分钟，0 = 不设上限）。
   dreamPeakMaxDeferMinutes: [0, 1440],
+  // v0.13 日记定时写：每隔 N 分钟唤醒一次跨天判定（0 = 关，只在 turn/end 与
+  // 启动时判）。上限一天——判定单位是天，更长的间隔没有意义。
+  diaryWriteEveryMinutes: [0, 1440],
   // Issue #125：hybrid 候选量上限（0 = 复用 dreamMaxSnapshotSize）。
   dreamCandidateMax: [0, 5000],
   // #135 成本审计派生：单轮 merge 决策上限（merge 是唯一回吐正文的动作，默认 40
@@ -295,6 +344,11 @@ const FEATURE_FLAG_INT_RANGES = {
   pinnedInjectBudget: [0, 5],
   // Issue #257：sleep 冲突/模式阶段的 LLM 输出预算（原硬编码 2048，实测不足）。
   sleepMaxTokens: [256, 131072],
+  // Issue #619：情感归因的两个闸——升特质所需的最小独立会话数（下界 2：N=1 就是
+  // 单次场合，正是必须禁止升特质的那个情形），以及单轮可写的 affective_context
+  // 关系条数上限（0 = 关闭关系通道）。闭区间与 config.js 的 z.natural() 对齐。
+  sleepAffectiveTraitMinSessions: [2, 10],
+  sleepAffectiveMaxRelationsPerRun: [0, 50],
   // Issue #529：sleep 冲突阶段的输入侧预算（此前完全没有——全部候选对一次进一个
   // prompt，实测 163,054 token 撞服务端 163,840 上限）。两个键都是 0 = 不设上限，
   // 与 config.js 的 z.natural().min(0).max() 成对。
@@ -309,7 +363,12 @@ const FEATURE_FLAG_INT_RANGES = {
   graphInjectBudget: [0, 5],
   // Issue #399：蒸馏原文记录的保留天数（与 config.js 的 z.natural().min(1).max(3650)
   // 对齐；同 llmAudit.retentionDays，是 int 而非开关）。
-  "distillRecords.retentionDays": [1, 3650]
+  "distillRecords.retentionDays": [1, 3650],
+  // #275 容量预警阈值（嵌套点号键，必须同时进 api.js 的 NESTED_FLAG_PATHS）。
+  // 0 = 显式关掉那一条检查（阈值判级的启用条件写在 service.getCapacityHealth）。
+  // 上限与 config.js 的 z.natural().min(0).max() 成对。
+  "capacityWarning.dbSizeWarnMb": [0, 1048576],
+  "capacityWarning.archivedRowsWarn": [0, 10000000]
 };
 // 浮点开关的闭区间（与 config.js 的 z.number().min().max() 对齐）。与整数开关
 // 分开：面板的整数控件要求 Number.isInteger，而余弦相似度阈值必须允许小数。
@@ -319,7 +378,14 @@ const FEATURE_FLAG_NUMBER_RANGES = {
   // Issue #125：hybrid 判"高相似"的阈值。
   dreamCandidateMinSim: [0.5, 0.99],
   // Issue #24 块2：单次有效触达的边权抬升幅度（与 config.js 的闭区间对齐）。
-  graphWeightDelta: [0, 1]
+  graphWeightDelta: [0, 1],
+  // Issue #603 第 4 层：自动裁决的相似度门槛。下界 0.85 与冲突检测阈值同源——
+  // 低于它就不是「重复」而是「相似」，不该自动归档任何一条。
+  conflictAutoResolveMinSimilarity: [0.85, 1],
+  // #275 容量预警的归档占比阈值（0 = 关）：健康形态本身就落在 0.8~0.9，默认
+  // 0.95 起才算「归档区吞掉活跃区」——0.9 会对着健康库天天报警（依据见 config.js
+  // capacityWarning 的注释）。浮点键，同 conflictAutoResolveMinSimilarity 的缘由。
+  "capacityWarning.archivedRatioWarn": [0, 1]
 };
 // 自由字符串开关（与 config.js 的 z.string() 同名同型）：trim 后 ≤200 字符，
 // 空串合法（= 跟随主对话模型/默认路径，面板显示 placeholder）。
@@ -534,10 +600,10 @@ export function createSettings(db) {
       return parsePersonaStore(getSetting("persona") ?? "{}");
     },
     setPersona(input) {
-      // 双形兼容：单对象形 = 只更新 default、byAgent 保留（旧面板/旧调用方合并语义）；
-      // 多卡形 = 全量替换。坏体（非对象）在此不落库不抛错，保值由调用方守卫。
+      // 双形兼容：单对象形 = 只更新 default、byAgent/bySession 保留（旧面板/旧调用方
+      // 合并语义）；多卡形 = 全量替换。坏体（非对象）在此不落库不抛错，保值由调用方守卫。
       if (typeof input !== "object" || input === null || Array.isArray(input)) return;
-      if ("default" in input || "byAgent" in input) {
+      if ("default" in input || "byAgent" in input || "bySession" in input) {
         setSetting("persona", serializePersonaStore(input));
         return;
       }
@@ -573,6 +639,38 @@ export function createSettings(db) {
       return true;
     },
 
+    /**
+     * 绑会话卡（#606）：按 sessionId 存/删/列。形状与 setPersonaFor 一族逐一对应，
+     * 只是换了一个维度——为什么需要第二维见 parsePersonaStore 的注释。
+     * sessionId 为空或 "default" 拒绝（与 byAgent 同一条纪律：兜底位不可被顶替）。
+     */
+    setPersonaForSession(sessionId, card) {
+      const id = typeof sessionId === "string" && sessionId.trim() ? sessionId.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.bySession[id] = clean;
+      else delete store.bySession[id];
+      setSetting("persona", serializePersonaStore(store));
+      return true;
+    },
+    /** bySession 键列表（面板「按会话建的卡」用，default 不在其中）。 */
+    listPersonaSessions() {
+      return Object.keys(parsePersonaStore(getSetting("persona") ?? "{}").bySession);
+    },
+    /** 删一张 bySession 卡；不存在返回 false。 */
+    removePersonaForSession(sessionId) {
+      const id = typeof sessionId === "string" && sessionId.trim() ? sessionId.trim() : "";
+      if (!id || id === "default") return false;
+      const store = parsePersonaStore(getSetting("persona") ?? "{}");
+      if (!(id in store.bySession)) return false;
+      delete store.bySession[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();