@nightpainters/dsh-ling 1.5.2 → 1.5.3

package/lib/host/memory.js

@@ -9,7 +9,7 @@ import { ensureDir, sha256Text, utcIso, mergeDeep, toIso, toEpochMs } from './ut
 // 且把 memory 当参数传(依赖注入)⇒ memory.js 引它**不成环**。
 import { archiveBefore } from './archive.js';
 
-const SCHEMA_VERSION = 13; // v13:forgotten(软遗忘标记 —— 永远不彻底删除,先归档再打标记);v12:branch_log.actor(G4 器灵侧通道 —— 工具改的树必须记在"器灵"名下,不再一律记成主人);v11:vein_suggestions(主脉提炼审核队列 R7 —— 设计稿 §5:提炼必须走审核,不直接进记忆);
+const SCHEMA_VERSION = 14; // v14:dsh_turns_raw.source(来源从"推断"变"记录",2026-10-01 主人定「来源也加个列吧」—— 旧判据是"裸 id = DSH 会话",边界是"将来若出现不带冒号的新来源名,物理上分不出来");v13:forgotten(软遗忘标记 —— 永远不彻底删除,先归档再打标记);v12:branch_log.actor(G4 器灵侧通道 —— 工具改的树必须记在"器灵"名下,不再一律记成主人);v11:vein_suggestions(主脉提炼审核队列 R7 —— 设计稿 §5:提炼必须走审核,不直接进记忆);
 // v10:tree_snapshot.kind('manual'|'auto',审计 A#9 —— 自动备份与手动快照此前外表完全一致,删错了就没有撤回路径);v9:tree_snapshot(树的保存/恢复 R1);v8:conv_branch(非会话源的枝归属覆盖层,方案 A);v7:branch_log(复盘留痕);v6:vein_link + memory_conflict(D9-b 树的生长);v5:branch(记忆分枝 D9-a);v4:title_by(定名者:user/ai);v3:title_locked;v2:conv_overview.source 放开 CHECK
 
 /** 主干枝 id(D9-a 记忆分枝,2026-09-18):存量会话与记忆天然属于主干。 */
@@ -43,11 +43,46 @@ export const BRANCH_LOG_WM_RETIRED = 'branch_log_wm.retired';
  *  `<= 0` = 关闭时间窗(全部按近期展开)。 */
 export const BRANCH_LOG_WINDOW_DAYS = 3;
 
-/** 原文命名空间(G4/2026-09-17):dsh_turns_raw 无 source 维,DSH 会话与导入原文共表。
+/** 命名空间分隔符(原文 id 的 `<ns>:<id>` 形态)。**唯一定义处**在本模块:
+ *  summarizer.js 从这里取并再导出(既有导入面不变),免得"分隔符"出现两份定义。 */
+export const RAW_NS_SEP = ':';
+
+/** 原文命名空间(G4/2026-09-17):dsh_turns_raw 曾无 source 维,DSH 会话与导入原文共表。
  *  若不隔离,概述器会把导入内容当成 DSH 会话重建(GROUP BY session_id 认领)→ 跨源双份;
  *  同 id 时更会互相覆盖原文(不可恢复)。故导入原文一律落 'import:<conv_id>'。
  *  历史数据(1.2.2 之前)的导入原文仍是裸 id —— 读取侧保留回退,写入侧一律带前缀。 */
-export const RAW_IMPORT_PREFIX = 'import:';
+export const RAW_IMPORT_PREFIX = 'import' + RAW_NS_SEP;
+
+/* ── v14(2026-10-01)来源列:把"来源"从**推断**变成**记录** ─────────────────────────
+ *  为什么加(主人原话:「来源也加个列吧」):在此之前的范围判据全建在 id 文本的形状上
+ *  ("有没有冒号")—— 它是**推断**,边界很硬:将来出现一个**不带冒号**的新来源名,物理上
+ *  分不出来(会被当成主人的 DSH 会话认领)。有了这一列,写入者当场把来源记下来,读者照读。
+ *  取值口径(三方共用,不许各写一份):
+ *    · 'dsh'  —— DSH 宿主会话轮次(lifecycle.js 捕获)。**读者唯一认作"自己人"的来源**;
+ *    · 命名空间名(去尾冒号),如 'import' —— 一切外来来源(别人的对话);
+ *    · NULL/'' —— **只可能来自本列落地之前的存量行**(半迁移态)。读者对这类行回落到旧判据
+ *      "裸 id = DSH 会话"(见 summarizer 的整行判据),免得同一份库里两种行为并存。
+ *  ⚠️ 写侧一律落**非空**来源,故**新行永远不靠猜**;靠猜的只有历史行与"写入者没给来源"的缺省。 */
+export const RAW_SOURCE_DSH = 'dsh';
+
+/** 来源名归一:只做 TRIM(与读取侧 SQL 的 `TRIM(source)` **同解**,两形态必须逐字同判)。
+ *  ⚠️ 刻意不做别的花样(不去尾冒号、不转小写):归一每多一条规则,SQL 形态就得跟着模仿一条,
+ *  两处一旦漂移就会出现"JS 说在范围内、SQL 说不在"这种最难查的分歧。写侧本来就不会给出
+ *  带冒号的来源名(rawSourceOf 已去尾冒号),所以这里没有需要补救的畸形输入。 */
+export function normalizeRawSource(source) {
+  return String(source ?? '').trim();
+}
+
+/** 写入侧/回填侧:按 session_id 得出该行应落的来源名(裸 id ⇒ 'dsh';`<ns>:<id>` ⇒ 'ns')。
+ *  ⚠️ 注意这是**按 id 形状推导**、不是"记录" —— 它只用于两处:
+ *    ① 写入者没显式给 source 时的缺省(与读者回落判据同解 ⇒ 老裁决一个字都不变);
+ *    ② 存量行回填(显式动作,见 backfillRawSource)。
+ *  真来源应当由写入方**显式给**(lifecycle 给 'dsh'、导入给 'import'),那才是这一列的意义。 */
+export function rawSourceOf(sessionId) {
+  const id = String(sessionId ?? '');
+  const i = id.indexOf(RAW_NS_SEP);
+  return i < 0 ? RAW_SOURCE_DSH : id.slice(0, i);
+}
 
 /** 写入侧:按来源得出该会话原文应落的 session_id。 */
 export function rawSessionId(source, convId) {
@@ -98,6 +133,10 @@ CREATE TABLE IF NOT EXISTS dsh_turns_raw (
   ts TEXT,
   model TEXT,
   text TEXT NOT NULL DEFAULT '',
+  -- v14(2026-10-01):**真实来源标记**(dsh | import | … 见 RAW_SOURCE_DSH 段口径)。
+  -- 可空:NULL 只代表"本列落地之前的存量行"(半迁移态),读者对它回落到旧的"裸 id"判据。
+  -- ⚠️ 列尾追加(不换主键、不重建表、不动既有列)⇒ 老库上是一条秒级 ALTER。
+  source TEXT,
   PRIMARY KEY (session_id, seq)
 );
 CREATE TABLE IF NOT EXISTS session_meta (
@@ -330,6 +369,29 @@ function migrateLogActor(db) {
   }
 }
 
+/** v13→v14:dsh_turns_raw 增列 source(来源从**推断**变**记录**,2026-10-01 主人定)。
+ *
+ *  为什么必须是**纯增列**:这张表是记忆的**原文底账**(真机库 5062 轮 / 104 会话),任何
+ *  "重建表 / 换主键 / 重写行"的迁移都会在一条语句里同时动到全部行的字节;而 ADD COLUMN 是
+ *  SQLite 的**元数据操作** —— 不触碰任何既有行、不动主键,失败面最小(红线:不许重建表)。
+ *  故这一列**不做回填**:历史行的 source 留 NULL,读者按旧判据("裸 id = DSH 会话")回落 ⇒
+ *  迁移前后**裁决逐字一致**;要动历史行得走显式动作 backfillRawSource(会汇报条数)。
+ *  幂等:先 `PRAGMA table_info` 探列,已有直接返回 —— 可重复运行,第二遍是零写入。
+ *  代价:老库上一条 ALTER,毫秒级;不重建表 ⇒ 不阻塞宿主启动。
+ *  @returns {boolean} 列是否确实在位(迁移后自证 —— 供构造器写 `dbg.raw_source_col` 与失败告警) */
+function migrateRawSource(db) {
+  const has = () => {
+    try { return db.prepare('PRAGMA table_info(dsh_turns_raw)').all().some((c) => String(c.name) === 'source'); } catch { return false; }
+  };
+  try {
+    if (has()) return true; // 已迁移(或新库:DDL 里已带此列)
+    db.exec('ALTER TABLE dsh_turns_raw ADD COLUMN source TEXT');
+  } catch (e) {
+    console.warn('[dsh-ling] dsh_turns_raw.source 迁移失败(忽略):', String(e?.message ?? e).slice(0, 200));
+  }
+  return has(); // 自证:ALTER 是否真的生效(失败 ⇒ 构造器留一条可见的诊断,而不是让读侧静默抛错)
+}
+
 /** 会话级成员"可展开"的谓词(审计 A#6,2026-09-22)。
  *
  *  展开(`branchMembers`)与计数(`branchMemberCounts` / `branchTree().members`)必须共用这一份 SQL,
@@ -369,13 +431,37 @@ export class MemoryStore {
     migrateBranchCols(this.db); // v4→v5:branch 表 + session_meta.branch_id(记忆分枝 D9-a)
     migrateSnapshotKind(this.db); // v9→v10:tree_snapshot.kind(区分自动备份与手动快照,审计 A#9)
     migrateLogActor(this.db); // v11→v12:branch_log.actor(区分"谁改的树",Part G G4)
+    const rawSourceOk = migrateRawSource(this.db); // v13→v14:dsh_turns_raw.source(来源从推断变记录,2026-10-01)
     this._kvGet = this.db.prepare('SELECT value FROM kv WHERE key=?');
     this._kvSet = this.db.prepare('INSERT INTO kv(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value');
+    // 迁移**自证**(2026-10-01):纯增列理论上不会失败,但万一 ALTER 被库锁/权限挡下(它会静默 catch),
+    // 读侧的 source 判据就会去读一列不存在的列 —— 症状是"概述器/习惯扫描每次抛 no such column",
+    // 而它只会在 console.debug 里出现一次。故失败时留一条可查的 kv + 一行 warn(成功路径**零 kv 写入**,
+    // 免得"干净库的 kv 键集合不变"这条既有断言被诊断项污染;陈旧告警顺手清掉)。
+    if (rawSourceOk) {
+      try { this.kvDel('dbg.raw_source_col'); } catch { /* 旧告警清不掉不影响主流程 */ }
+    } else {
+      // ⚠️ 这一笔**必须**留在 try 里(红队 2026-10-01 实测的阻断项):库只读(SQLITE_READONLY)/被写锁(SQLITE_BUSY)时
+      // 它**一定**抛,而它只是"留一条可查的痕迹",不是主流程。修前异常一路冒到 lib/index.js 的 apply() ⇒ **整个插件
+      // 加载失败**,那条为迁移失败准备的降级路径(本 else 分支 + 读侧回落"裸 id"判据)反而永远走不到(形同死代码)。
+      // 只用 try 护**这一笔诊断写入**,不把 kvSet 整体改成吞异常(那会把别处的真错误一起吞掉);
+      // "库真的打不开/表都建不出来"这类错误仍照旧往上抛(见构造器开头,DLL/DDL 未做任何兜底)。
+      try {
+        this.kvSet('dbg.raw_source_col', 'missing');
+      } catch (e) {
+        console.warn('[dsh-ling] 迁移诊断没能写进库(少了 dbg.raw_source_col 这条可查痕迹,不影响运行):'
+          + String(e?.message ?? e).slice(0, 200));
+      }
+      console.warn('[dsh-ling] dsh_turns_raw.source 列缺失(迁移未生效)—— 概述器与习惯扫描的来源判据会读不到该列,'
+        + '请检查库锁/磁盘权限;读侧回落判据(instr(session_id, 冒号) = 0)不受影响,但需人工处置。');
+    }
     // schema_version 必须跟随真实结构更新,不能只写一次:
     // v5 加了 branch 表与 session_meta.branch_id,若仍留 '4',后续会话会误判库结构。
     // v6 加 vein_link + memory_conflict 两张新表(纯新增,无 ALTER,DDL 的 IF NOT EXISTS 即迁移)。
     // v10 加 tree_snapshot.kind(ALTER,见 migrateSnapshotKind)。
-    if (this.kvGet('schema_version') !== String(SCHEMA_VERSION)) this.kvSet('schema_version', String(SCHEMA_VERSION));
+    // v14 加 dsh_turns_raw.source(ALTER,见 migrateRawSource);失败时 schema_version **不前进**,
+    // 下一次启动还会再试一遍(探列幂等 ⇒ 成功即跳过)。
+    if (rawSourceOk && this.kvGet('schema_version') !== String(SCHEMA_VERSION)) this.kvSet('schema_version', String(SCHEMA_VERSION));
   }
 
   close() {
@@ -913,12 +999,19 @@ export class MemoryStore {
     if (!s || !c) return { ok: false, reason: 'bad-key' };
     let wroteTurns = 0;
     try {
-      const ins = this.db.prepare(`INSERT INTO dsh_turns_raw (session_id,seq,role,ts,model,text)
-        VALUES (?,?,?,?,?,?) ON CONFLICT(session_id,seq) DO UPDATE SET
-        role=excluded.role, ts=excluded.ts, model=excluded.model, text=excluded.text`);
+      const ins = this.db.prepare(`INSERT INTO dsh_turns_raw (session_id,seq,role,ts,model,text,source)
+        VALUES (?,?,?,?,?,?,?) ON CONFLICT(session_id,seq) DO UPDATE SET
+        role=excluded.role, ts=excluded.ts, model=excluded.model, text=excluded.text,
+        source=COALESCE(dsh_turns_raw.source, excluded.source)`);
+      // v14:回灌也要带来源。取 `rawSourceOf(c)`(= 写入目标 id 的形状)而**不是**概述的 `source` 字段:
+      //   · 目标 id 带前缀(import:)⇒ 'import' —— 与写入侧同一口径;
+      //   · 目标 id 是裸的 ⇒ 'dsh' —— 与读者对空 source 的回落判据同解 ⇒ 回灌前后裁决一致
+      //     (若改按 `source` 字段记 'dsweb'/'vein',这些回灌的原文会**当场从概述器眼里消失**:越权改裁决)。
+      //   冲突分支同样 COALESCE(首写为准),不回退已记录的来源。
+      const rawSrc = rawSourceOf(c) || null;
       this.db.exec('BEGIN');
       for (const t of (Array.isArray(turns) ? turns : [])) {
-        ins.run(c, Number(t.seq) || 0, String(t.role || ''), t.ts ?? null, t.model ?? null, String(t.text ?? ''));
+        ins.run(c, Number(t.seq) || 0, String(t.role || ''), t.ts ?? null, t.model ?? null, String(t.text ?? ''), rawSrc);
         wroteTurns += 1;
       }
       this.db.exec('COMMIT');
@@ -2261,14 +2354,22 @@ export class MemoryStore {
   }
 
   // ---- raw turns (DSH incremental capture, passive) ----
-  appendRawTurn(sessionId, { seq, role, ts, model, text }) {
+  /** 追加一条原文轮次(幂等:(session_id,seq) 冲突时更新正文)。
+   *  v14:`source` 记**这条原文属于哪个来源**(取值口径见 RAW_SOURCE_DSH 段)。缺省 null ⇒ 按 id
+   *  形状推导(rawSourceOf)—— 与读者对空 source 的回落判据**同解**,故老调用点一个字不改也写不错;
+   *  但**知道来源的调用方应当显式给**(lifecycle 给 'dsh'、导入给 'import'):那才是这一列的意义。 */
+  appendRawTurn(sessionId, { seq, role, ts, model, text, source = null }) {
     if (!sessionId || typeof text !== 'string' || !text) return;
+    const src = normalizeRawSource(source) || rawSourceOf(sessionId);
     this.db.prepare(
-      `INSERT INTO dsh_turns_raw (session_id, seq, role, ts, model, text)
-       VALUES (?,?,?,?,?,?)
-       ON CONFLICT(session_id, seq) DO UPDATE SET text=excluded.text`,
+      `INSERT INTO dsh_turns_raw (session_id, seq, role, ts, model, text, source)
+       VALUES (?,?,?,?,?,?,?)
+       ON CONFLICT(session_id, seq) DO UPDATE SET text=excluded.text,
+         source=COALESCE(dsh_turns_raw.source, excluded.source)`,
+      // 冲突分支的来源取 COALESCE(首写为准):同一轮被重扫/重导时**不把已记录的来源降级成推断值**
+      // (例如一行已被显式记成某个外来来源,重扫不该把它改回 'dsh');而 NULL 的存量行会被填上。
       // 写侧归一(修 A):一律存 ISO;数字/浮点串(如 "1789006881011.0")也归一后再落库。
-    ).run(String(sessionId), Number(seq), String(role ?? '?'), toIso(ts), model || null, text);
+    ).run(String(sessionId), Number(seq), String(role ?? '?'), toIso(ts), model || null, text, src || null);
     this.db.prepare(
       'INSERT INTO session_meta(session_id, raw_seq) VALUES(?,?) ON CONFLICT(session_id) DO UPDATE SET raw_seq=excluded.raw_seq',
     ).run(String(sessionId), Number(seq));
@@ -2276,6 +2377,54 @@ export class MemoryStore {
     this.db.prepare('UPDATE session_meta SET archived=0 WHERE session_id=? AND archived=1').run(String(sessionId));
   }
 
+  /** 存量行来源回填(v14,**可选**动作,2026-10-01)。**只有显式调用才会跑** —— 构造器与概述器
+   *  都不会自己碰它:这是唯一会**写历史行**的动作,偷偷跑等于让这一列的可信度打折(读者会以为
+   *  每行的来源都是写入当时记下来的)。规则(顺序不可调):
+   *    ① 只填 `source IS NULL` 或空串的行 —— **已有的非空来源绝不覆盖**(记录优先于推断);
+   *    ② 值按 session_id 推导(rawSourceOf:裸 id ⇒ 'dsh';`<ns>:<id>` ⇒ 'ns');
+   *    ③ 幂等(第二遍 filled=0);④ 汇报条数(filled / 按来源分组 / 推不出来的 unresolved)。
+   *  ⚠️ 回填只给**已经存在的行**加一个字段,**不改变任何裁决** —— 推导口径与读者的空 source 回落
+   *  判据同解(裸 id ⇒ dsh、带前缀 ⇒ 排除),迁移前后同一份库的概述集逐字相同。
+   *  ⚠️ 代价(明说):历史行的 source 是**事后推断**的,不是当场记的 —— 若某个老来源的 id 恰好是裸
+   *  形状(不带冒号),回填会把它**固化成 'dsh'**,此后再也分不出来。故本动作须由人显式触发。
+   *  @returns {{ok:boolean,filled:number,scanned:number,bySource:Object,unresolved:number}} */
+  backfillRawSource() {
+    const out = { ok: true, filled: 0, scanned: 0, bySource: {}, unresolved: 0 };
+    try {
+      const rows = this.db.prepare(
+        "SELECT session_id, COUNT(*) AS n FROM dsh_turns_raw WHERE source IS NULL OR TRIM(source)='' GROUP BY session_id",
+      ).all();
+      const upd = this.db.prepare(
+        "UPDATE dsh_turns_raw SET source=? WHERE session_id=? AND (source IS NULL OR TRIM(source)='')",
+      );
+      this.db.exec('BEGIN');
+      for (const r of rows) {
+        const sid = String(r?.session_id ?? '');
+        const n = Number(r?.n) || 0;
+        out.scanned += n;
+        const src = rawSourceOf(sid);            // 裸 id ⇒ 'dsh';'<ns>:<id>' ⇒ 'ns'
+        if (!src) { out.unresolved += n; continue; } // id 以冒号开头(推不出来源名)⇒ 留 NULL,交给读者回落/告警
+        const res = upd.run(src, sid);
+        const filled = Number(res?.changes || 0);
+        out.filled += filled;
+        out.bySource[src] = (out.bySource[src] || 0) + filled;
+      }
+      this.db.exec('COMMIT');
+    } catch (e) {
+      try { this.db.exec('ROLLBACK'); } catch { /* ignore */ }
+      return { ...out, ok: false, message: String(e?.message ?? e).slice(0, 160) };
+    }
+    return out;
+  }
+
+  /** 来源分布(只读;给报告/诊断用):`{[source]: 行数}`,NULL 记作 '(null)'。 */
+  rawSourceCounts() {
+    const rows = this.db.prepare(
+      "SELECT COALESCE(NULLIF(TRIM(source),''),'(null)') AS s, COUNT(*) AS n FROM dsh_turns_raw GROUP BY s ORDER BY n DESC",
+    ).all();
+    return Object.fromEntries(rows.map((r) => [String(r.s), Number(r.n)]));
+  }
+
   rawTurnCount(sessionId) {
     const r = this.db.prepare('SELECT COUNT(*) AS n FROM dsh_turns_raw WHERE session_id=?').get(String(sessionId));
     return r ? Number(r.n) : 0;
@@ -2518,7 +2667,7 @@ export class MemoryStore {
    *  ⚠️ 代价是 0/0 也是"合法键值",所以下面三个缓存字段**只在重算真正完成后才推**。
    *  ⚠️ 别把这两个字段的存在当成"守卫一定在工作":`statSync` 抽风/漏 import 时它恒返 [0,0],
    *  面板照旧显示、测试照旧全绿,而守卫是**静默空转**的(本轮就踩过:忘了 import statSync,
-   *  ReferenceError 被本方法的 catch 吞掉)。要确认它活着,见 _probe/tmp-fp-wal-guard.mjs 的
+   *  ReferenceError 被本方法的 catch 吞掉)。要确认它活着,得跑一次性运行时探针的
    *  【陷阱守卫】断言:它必须返回真实 size/mtime,不能是 [0,0]。 */
   _walStamp() {
     try {
@@ -2532,7 +2681,7 @@ export class MemoryStore {
   /** data_version 守卫(1.5.2):缓存键的**第三**来源,专补 `-wal` 那一维的盲区。
    *  上面的 `_walStamp()` 有个洞:维护/备份脚本若用 `journal_mode=DELETE` 改库,**根本没有 `-wal`
    *  文件**,stat 恒返 [0,0] 哨兵 ⇒ 外进程改完面板还是旧指纹。`PRAGMA data_version` 正好互补
-   *  (实测见 _probe/tmp-dv-semantics.mjs,数值原样):
+   *  (一次性运行时探针实测,数值原样):
    *    · 本连接自己写 ⇒ **不变**(2→2)  ⇒ 它**不能**替代 `total_changes()`,只补位;
    *    · 别的连接提交 ⇒ **变**(2→3;DELETE 模式 1→2);
    *    · 外连接写完立刻 `wal_checkpoint(TRUNCATE)` 把 -wal 截成 0 ⇒ **照样变**(3→4);

package/lib/host/mode-service.js

@@ -0,0 +1,85 @@
+// dsh-ling host — 模式服务（P3-A，2026-09-29）：把「给某个会话设模式」做成跨插件能力。
+//
+// 为什么需要它：器灵的模式记录是**私有**的（memory.db 的 `session_meta.mode`），
+// 而 memory / gate / settings 三个依赖只活在器灵自己的 apply 闭包里 —— 别的插件
+// （如飞书桥 dsh-feishu-host）拿不到，于是「来自飞书的会话默认走生活挡位」一直做不到。
+// 本模块把这个动作注册成 cordis 服务 `dsh-ling/mode`，调用方按**软依赖**取用：
+//
+//   const ling = ctx.get('dsh-ling/mode');            // 拿不到就是 undefined，不是错误
+//   await ling?.applyMode(sessionId, 'life', { keepModel: { provider, model } });
+//
+// 契约（语义与 mode.js 一致，差别只在默认值）：
+//   applyMode(sessionId, modeKey, opts) -> Promise<Result>
+//     · **不改全局** `settings.mode.lastMode`
+//       —— GUI 的 `applyModeToSession` 才改，那是「同时设为新会话默认」的语义；
+//          跨插件调用若照做，会把飞书的挡位泄漏成桌面端的默认值。
+//     · opts.keepModel    调用方自带的模型。**跨插件调用必须传** —— 不传就退回
+//                         「读全局当前选择」，会把 GUI 正选着的模型覆盖到对方会话上。
+//     · opts.syncEffort   默认 true（模式的实质就是推理等级）；false = 只记模式。
+//     · **失败不抛**：以 `{ok:false, reason}` 返回。调用方不该因为器灵缺席/出错
+//       而中断自己的流程。
+//
+// Result = { ok, mode, reasoningEffort, warning?, queued?, lastMode?, reason? }
+import { KNOWN_MODES, applyModeToSession, currentMode } from './mode.js';
+
+export const MODE_SERVICE_NAME = 'dsh-ling/mode';
+
+/**
+ * 把模式能力注册成服务。
+ *
+ * 用 `ctx.provide()` 而不是 `class extends Service`：本插件的 apply 是函数形态，
+ * 且 dsh-ling 以 `file:` + Junction 加载、包内无 node_modules，`import '@deepseek-ai/cordis'`
+ * 会走 realpath 回到**本包根目录**再向上找 —— 找不到。`ctx.provide` 是同一套
+ * reflect 机制的上层入口，零 import、同样由 fiber 生命周期托管（返回 disposer）。
+ *
+ * @param {object} ctx    cordis 上下文（插件自己的）。
+ * @param {object} deps   `{ gate, memory, settings }`，与 mode.js 同源。
+ * @returns {() => void}  disposer（拆服务）。
+ */
+export function registerModeService(ctx, { gate, memory, settings }) {
+  const api = {
+    name: MODE_SERVICE_NAME,
+    knownModes: KNOWN_MODES,
+
+    /**
+     * 给某个会话设模式。
+     *
+     * @param {string} sessionId 目标会话（飞书侧形如 `feishu-<uuid>`）。
+     * @param {'work'|'life'} modeKey
+     * @param {{keepModel?: {provider: string, model: string}, syncEffort?: boolean}} [opts]
+     */
+    async applyMode(sessionId, modeKey, opts = {}) {
+      if (!sessionId) return { ok: false, reason: 'no-session-id' };
+      if (!KNOWN_MODES.includes(modeKey)) return { ok: false, reason: `unknown-mode:${modeKey}` };
+      try {
+        return await applyModeToSession(ctx, gate, memory, settings, sessionId, modeKey, {
+          setDefault: false, // 跨插件：只改这条会话，不动全局默认
+          keepModel: opts.keepModel ?? null,
+          syncEffort: opts.syncEffort !== false,
+        });
+      } catch (e) {
+        return { ok: false, reason: 'throw:' + String(e?.message ?? e) };
+      }
+    },
+
+    /** 读某个会话当前生效的模式（session_meta → lastMode → 'life'）。 */
+    currentMode(sessionId) {
+      try {
+        return currentMode(memory, settings, sessionId);
+      } catch {
+        return 'life';
+      }
+    },
+  };
+
+  try {
+    const dispose = ctx.provide(MODE_SERVICE_NAME, api);
+    console.info('[dsh-ling] mode service provided: %s', MODE_SERVICE_NAME);
+    return typeof dispose === 'function' ? dispose : () => {};
+  } catch (e) {
+    // 同名服务已被别的 fiber 占用（例如器灵被加载了两遍）：只记日志，不抛 ——
+    // 器灵其余功能照常，不能因为一个可选能力注册失败就整插件起不来。
+    console.debug('[dsh-ling] mode service provide failed', e);
+    return () => {};
+  }
+}

package/lib/host/mode.js

@@ -45,13 +45,26 @@ export function currentModelSelection(ctx) {
   return null;
 }
 
-async function doApply(ctx, memory, settings, sessionId, modeKey) {
+/**
+ * @param {object} [opts]  P3-A(2026-09-29) 加的调用方选项,缺省 = 原行为(GUI 路径)。
+ * @param {boolean} [opts.setDefault]  是否把全局 `mode.lastMode` 一起改掉(=「设为新会话默认」)。
+ *   GUI 的 applyModeToSession 走 true;跨插件(器灵模式服务)走 false —— 否则飞书的挡位
+ *   会泄漏成桌面端的默认值。
+ * @param {?{provider:string,model:string}} [opts.keepModel]  调用方自带的「当前模型」。
+ *   不传才退回读**全局**当前选择;跨插件调用必须传,否则会把别人的模型写回本会话。
+ * @param {boolean} [opts.syncEffort]  是否同步推理等级,默认 true(模式的实质就是它)。
+ */
+async function doApply(ctx, memory, settings, sessionId, modeKey, opts = {}) {
   const reasoningEffort = resolveModeEffort(settings.get(), modeKey);
   const controller = svc(ctx, 'sessionController');
   let warning;
-  if (controller && typeof controller.selectModel === 'function') {
-    const keep = currentModelSelection(ctx); // 当前模型:原样带回,不改
-    if (!keep) {
+  if (opts.syncEffort === false) {
+    warning = 'effort-sync-skipped';
+  } else if (controller && typeof controller.selectModel === 'function') {
+    const keep = (opts.keepModel && opts.keepModel.provider && opts.keepModel.model)
+      ? opts.keepModel
+      : currentModelSelection(ctx); // 当前模型:原样带回,不改
+    if (!keep || !keep.provider || !keep.model) {
       warning = 'unknown-current-model; 推理等级未同步(拒绝替用户指定模型)';
       console.debug('[dsh-ling]', warning);
     } else {
@@ -73,23 +86,30 @@ async function doApply(ctx, memory, settings, sessionId, modeKey) {
     warning = 'no-sessionController; mode recorded only';
   }
   memory.setSessionMode(sessionId, modeKey);
-  const s = await settings.update({ mode: { lastMode: modeKey } }); // D2 跟随
-  return { ok: true, warning, sessionId, mode: modeKey, reasoningEffort, lastMode: s.mode.lastMode };
+  let lastMode = settings.get().mode?.lastMode;
+  if (opts.setDefault === true) {
+    const s = await settings.update({ mode: { lastMode: modeKey } }); // D2 跟随
+    lastMode = s.mode.lastMode;
+  }
+  return { ok: true, warning, sessionId, mode: modeKey, reasoningEffort, lastMode };
 }
 
 /**
  * Apply mode to a session (D4): running → queue (returns queued), idle → apply now.
+ *
+ * @param {object} [opts] 见 doApply。缺省 `{setDefault:true}` = GUI 语义(改本会话 + 设为默认)。
  */
-export async function applyModeToSession(ctx, gate, memory, settings, sessionId, modeKey) {
+export async function applyModeToSession(ctx, gate, memory, settings, sessionId, modeKey, opts = {}) {
   if (!sessionId) return { ok: false, reason: 'no-session-id' };
   if (!KNOWN_MODES.includes(modeKey)) return { ok: false, reason: `unknown-mode:${modeKey}` };
+  const merged = { setDefault: true, ...opts };
   const queued = gate.enqueueIfRunning(sessionId, () => {
-    doApply(ctx, memory, settings, sessionId, modeKey).catch((e) =>
+    doApply(ctx, memory, settings, sessionId, modeKey, merged).catch((e) =>
       console.debug('[dsh-ling] queued mode apply failed', e),
     );
   });
   if (queued) return { ok: true, queued: true, running: true, sessionId, mode: modeKey };
-  return await doApply(ctx, memory, settings, sessionId, modeKey);
+  return await doApply(ctx, memory, settings, sessionId, modeKey, merged);
 }
 
 /** Current mode for a session: session_meta → settings.lastMode. */

package/lib/host/retitle.js

@@ -14,6 +14,12 @@ import { summarizeWithRetry } from './dsweb-summary.js';
 import { llmOnce } from './deepsummary.js';
 import { rawSessionCandidates } from './memory.js';
 
+/** 标题**生成上限**(`heuristicTitle` 切句读/硬截的落点:它决定"机器造出来的标题最长多少字")。
+ *  ⚠️ 与 `session-line.js` 的 `TITLE_MAX_CHARS`(= 60)**同名但不同语义**(E1 判定,2026-10-01):
+ *  那个是"那一行的**显示兜底**夹取",作用于**任何来源**的标题(含源库自带、主人手改 ≤120)。
+ *  两处的读者与方向都不同 ⇒ **不要把两处"统一"成一个数**:统一到 58 会让手改/源库标题多切一刀,
+ *  统一到 60 会改变下面 `heuristicTitle` 在 59-60 字输入上的行为(两个方向都是行为变更)。
+ *  唯一的不变式是**显示兜底 ≥ 本值**(否则机器刚造出来的标题会在那一行里被再切一刀)。 */
 export const TITLE_MAX_CHARS = 58;   // 46 → 58:46 会把一句完整的话切成半句
 export const LEGACY_TITLE_MAX = 46;  // 1.2.2 之前的硬截上限 —— 长度"达到"它就说明这条标题曾被切过
 export const MACHINE_TITLE_MAX = 40; // 机器生成标题的上限(手改上限在 memory.renameTitle:120)

package/lib/host/session-line.js

@@ -49,7 +49,16 @@ export const TIER_TURNS_DEFAULT = 10;
 export const LINE_MAX_CHARS = 110;
 /** 「最新进展」上限:真人发言首句。 */
 export const PROGRESS_MAX_CHARS = 40;
-/** 标题段上限(概述器侧的标题上限是 58,这里只做兜底)。 */
+/** 标题段**显示兜底**上限(超出留 `…`,见 `clip`)。
+ *  ⚠️ **与 `retitle.js` 的同名常量语义不同,别把两者"统一"成一个数**(E1 判定,2026-10-01):
+ *    · `retitle.js:TITLE_MAX_CHARS`(= 58)= **生成上限** —— `heuristicTitle()` 切句读/硬截的落点,
+ *      它决定"机器造出来的标题最长多少字"(`summarizer.js` / `import-file.js` 只拿它当兜底);
+ *    · 本常量(= 60)= **显示兜底** —— `resolveTitle()` 给那一行印标题时,把**任何来源**的标题硬夹到这里:
+ *      除本机生成(≤58)外,还有源库自带标题(不做首句截断)与主人手改(`memory.renameTitle` 上限 120)。
+ *  不变式:**本值必须 ≥ `retitle.js` 的生成上限** —— 否则机器刚造出来的标题会在那一行里被**再切一刀**,
+ *  "那一行印的标题"与"记忆里的标题"当场对不上。60 = 58 + 2,余量留给非本机来源的短标题。
+ *  (两处靠模块边界分开;**没有任何模块同时 import 这两个常量**,将来若要改名以消除同名,
+ *   建议本处叫 `LINE_TITLE_MAX_CHARS` —— 属结构调整,未做。) */
 export const TITLE_MAX_CHARS = 60;
 export const KV_LAST = 'sessline.last.';
 export const KV_COUNTS = 'sessline.counts.';
@@ -158,6 +167,31 @@ export function progressKey(title, progress) {
   return md5(oneLine(title) + '\u0000' + oneLine(progress));
 }
 
+/**
+ * **C 闸「内容真变了?」的唯一判据** —— 写路径(`maybeSessionLine`)与只读预览(`sessionLinePreview`)
+ * 共用**这一处**,谁都不许在自己那头另写一份。
+ * 为什么必须共用:两条路曾各自内联判据,写路径 3 条、预览只有 2 条(少 md5)
+ * ⇒ 同一份状态能出现「预览说会追加、写路径判 same」的分叉 —— 属"读数与行为不一致",最误导人。
+ *
+ * 三条判据,任一说"没变"就算没变(`changed:false`):
+ *   ① 逐字节:`candidate` 与上次那条的原文相同。⚠️ **两条路的基准不同源** ——
+ *      写路径取 kv `st.text`,预览取**面上那条**(HTTP 面板路径常常根本没有会话面);
+ *   ② `md5(candidate)` 与上次记录的 md5 相同(kv `sessline.last.*.md5`,裁定点名要用的那道):
+ *      它的基准**两条路都读得到** ⇒ 这是两条路唯一真正共享的判据,**一条都不许缺**;
+ *   ③ 实质键:`progressKey(标题, 最新进展)` 与上次追加时记的相同(剥掉 `#N`/`第 N 轮`/`HH:MM`)。
+ *      ⚠️ 预览的键基准可能退让到"从上次那条正文里反解出的标题/进展"(面板看不到进展时),与写路径未必同源
+ *      —— 那是**已知且有意**的差异,注释见 `sessionLinePreview` ④。
+ * `candidate` 为空串不做额外守卫:记录里的 md5 一律来自**非空**正文(`maybeSessionLine` 从不追加空文本),
+ * 故 `md5('')` 不可能等于任何一条记录。
+ * @returns {{changed:boolean, textSame:boolean, md5Same:boolean, keySame:boolean}}
+ */
+export function contentChanged({ candidate = '', lastText = '', lastMd5 = '', lastKey = '', curKey = '' } = {}) {
+  const textSame = !!lastText && String(candidate) === String(lastText);
+  const md5Same = !!lastMd5 && md5(candidate) === String(lastMd5);
+  const keySame = !!lastKey && !!curKey && String(curKey) === String(lastKey);
+  return { changed: !(textSame || md5Same || keySame), textSame, md5Same, keySame };
+}
+
 /** 从我们那条活行的正文里把"标题 + 进展"两段拆出来(给预览/自愈当比较基准)。
  *  正文形如 `[本次会话·进展 #N] {标题} —— 最近:{进展} · 第 T 轮 · HH:MM`,尾部整段是格式位。
  *  解不出(老格式/被夹过)⇒ 两段都空。 */
@@ -397,11 +431,12 @@ export function maybeSessionLine({ memory, agent, payload, stateMap, now = Date.
   //    为什么要 ③:只留 ①② 时,`#N` 每尝试一次就 +1 ⇒ 恒判"变了",闸等于没有(实测钉过);
   //    为什么要 ①②:同一轮内同参重入时,只有逐字节那一侧才拦得住。`st.key` 是**新增字段**,
   //    不动任何已有 kv 的含义;老记录没有它 ⇒ 第一次一律追加一条,之后照常。
+  //    ⚠️ 这三条**只在 `contentChanged` 里实现一处**(旧写法在本函数内联三条、预览那头内联两条 ⇒ 曾能分叉);
+  //    本路径的基准:① kv `st.text` ② kv `md5` ③ kv `key`。
   const lastMd5 = String(st.md5 || '');
   const lastKey = String(st.key || '');
-  const textUnchanged = !!st.text && candidate === String(st.text);
   const curKey = progressKey(title, progress);
-  const changed = !(textUnchanged || (!!lastMd5 && md5(candidate) === lastMd5) || (!!lastKey && curKey === lastKey));
+  const changed = contentChanged({ candidate, lastText: st.text, lastMd5, lastKey, curKey }).changed;
   const verdict = decideSessionLine({ onSurface: scan, candidate, lastMd5, changed });
   if (verdict.action !== 'append') {
     // kv 语义**不变**:`skippedSame` = "被内容闸挡下"(旧义是"面末条逐字节相同",新义是"与 lastMd5/面末条相同",
@@ -550,9 +585,14 @@ export function sessionLinePreview(memory, settings, sessionId, { turn } = {}) {
     const basis = progress ? 'title+progress' : (scan.latestUser ? 'title+progress' : 'title-only');
     const curKey = effTitle || effProgress ? progressKey(effTitle, effProgress) : '';
     const judgeText = buildSessionLineText({ title: effTitle, progress: effProgress, ordinal, at: Date.now() }); // 无轮次版
-    const textUnchanged = scan.count === 1 && !!judgeText && String(scan.lastText) === judgeText;
-    const changed = !(textUnchanged || (!!lastKey && !!curKey && curKey === lastKey));
-    if (process.env.DSH_LING_DBG) console.log('[pv]', JSON.stringify({ cnt: scan.count, ord: ordinal, basis, lastKey: lastKey.slice(0, 6), curKey: curKey.slice(0, 6), lastParts, effTitle, effProgress, textUnchanged, judge: judgeText }));
+    // ④′ 判据**与写路径同一处**(`contentChanged`):旧写法这里只内联两条(逐字节 + 实质键),
+    //     少了 md5 那条 ⇒ 当 kv 记着 md5 而 `last.text` 缺失/不新鲜时,预览说"会追加"、写路径判 same
+    //     (同一份状态两种读数)。逐字节那条的基准是**面上那条**(没有面时为空 ⇒ 该条不参与,与旧写法一致)。
+    const judge = contentChanged({
+      candidate: judgeText, lastText: scan.count === 1 ? scan.lastText : '', lastMd5, lastKey, curKey,
+    });
+    const changed = judge.changed;
+    if (process.env.DSH_LING_DBG) console.log('[pv]', JSON.stringify({ cnt: scan.count, ord: ordinal, basis, lastKey: lastKey.slice(0, 6), curKey: curKey.slice(0, 6), lastParts, effTitle, effProgress, textSame: judge.textSame, md5Same: judge.md5Same, keySame: judge.keySame, judge: judgeText }));
     const verdict = decideSessionLine({ onSurface: scan, candidate: judgeText, lastMd5, changed });
     out.blocked = verdict.reason;
     out.wouldAppend = verdict.action === 'append';