@nightpainters/dsh-ling 1.5.1 → 1.5.3

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/persona.js

@@ -42,6 +42,10 @@ export const DEFAULT_SETTINGS = Object.freeze({
     toneWork: '',         // 工作模式语气('' = 跟随 tone)
     toneLife: '',         // 生活模式语气('' = 跟随 tone)
     extraLore: '',        // 自由扩展设定
+    duty: '',             // 职业/职责/责任(1.5.2 I-5):改变率极低的身份级设定。**只收陈述句**
+                          //   (「我承担/我擅长/我能给出」),**禁授权式**(「我应当/我必须/我的任务/我的责任是」)——
+                          //   授权式写法把人写成"被授权者",是语义劫持最好用的钩子(同 [规矩] 段头那次的教训)。
+                          //   默认只能是 ''(约束 B):机制不设非空默认、也不从历史/模式推断预填。
     pronoun: '她',        // 第三人称代词(她/他/TA/它,或自定义):用于「给模型看的提示词」;界面文案第二步跟随
   },
   styles: {
@@ -75,6 +79,11 @@ export const DEFAULT_SETTINGS = Object.freeze({
     trackWorkspaces: ['*'],
     idleRefresh: true,                // B:长会话在空闲边界按需刷新 L1(运行中永不刷新)
     idleRefreshMinIntervalMin: 10,    // 同一个会话两次空闲刷新的最小间隔(分钟;0 = 不限制)
+    // E0(1.5.2)「那一行跟着会话走」:每轮用户在 `agent/pre-step` 追加一条带序号的活行
+    // (标题 + 最新进展,只追不替,见 lib/host/session-line.js)。
+    // 关掉即回到原样:已写入的历史行留着(平台无删除),但不再追加。
+    // ⚠️ 这是**内存态**设置(`settings-file.js` 的 get() 每轮读),面板 update() 立即改 ⇒ 不用重启宿主。
+    sessionProgressLine: true,
   },
   updates: { applyWhileRunning: false }, // D4 语义固化:默认冻结
   guard: {              // /api 守卫(2026-09-16 加固 ①+②;2026-09-17 加固 ③)
@@ -160,12 +169,16 @@ export function assemblePersona(settings, modeKey) {
   // 为什么不把每条 push 都用 '\n\n' 连接:那样条目之间会变成双倍空行(段内反而更糊)。
   const segs = [];
   const self = [];
-  const who = p.aiName ? `你是"${p.aiName}"` : '你是 DeepSeek 助手';
+  // 身份段正文过 escSegBrackets:与底线/规矩/习惯/承担/设定同规格,禁止正文自造段边界。
+  // **只包正文**:段头 [身份·X] 的方括号是字面量,保持半角(段边界判据是"行首是不是 [")。
+  // 但段头里嵌着 aiName —— 名字本身是用户文本,所以**逐字段**转义:名字/称呼/自述各过一遍,
+  // 有意的引号(")、分号(;)、逗号(,)一律不动(它们不是段边界判据的一部分)。
+  const who = p.aiName ? `你是"${escSegBrackets(p.aiName)}"` : '你是 DeepSeek 助手';
   const callName = userTitleForMode(p.userTitle, mode); // 工作=正式名(首段),生活=昵称(尾段)
-  const call = callName ? `;你称用户为"${callName}"` : '';
+  const call = callName ? `;你称用户为"${escSegBrackets(callName)}"` : '';
   // 定位自述允许多行书写,注入时压缩为一行(避免破坏身份句段落)
   const titleOneLine = p.aiTitle ? p.aiTitle.replace(/\s+/g, ' ').trim() : '';
-  const title = titleOneLine ? `,${titleOneLine}` : '';
+  const title = titleOneLine ? `,${escSegBrackets(titleOneLine)}` : '';
   // 结尾标点归一:title 自带句尾标点时不重复补(否则会出现 "拜上。。")
   const headSelf = `${who}${call}${title}`;
   self.push(headSelf.replace(/([。.!！?？])\s*$/, '') + '。');
@@ -174,7 +187,10 @@ export function assemblePersona(settings, modeKey) {
   const tPick = mode === 'work' ? p.toneWork : p.toneLife;
   const tone = (tPick && TONES[tPick]) ? tPick : ((p.tone && TONES[p.tone]) ? p.tone : '');
   if (tone) self.push(`语气:${TONES[tone]}`);
-  segs.push([`[身份·${coreNameOf(p.aiName)}]`, ...self].join('\n'));
+  // 段头里的名字(aiName)与正文各字段一样是用户文本 ⇒ 那一处也必须转义(最容易漏的一处);
+  // 而 [身份· 与 ] 两个字面量**不转** —— 跟着一起转掉等于整段从注入面凭空消失。
+  // 正文再逐行兜一次(幂等):语气文案/语言文案将来若带上 [, 不必回来改这里。
+  segs.push([`[身份·${escSegBrackets(coreNameOf(p.aiName))}]`, ...self.map((s) => escSegBrackets(s))].join('\n'));
   if (Array.isArray(p.bottomLines) && p.bottomLines.length) {
     const seg = ['[底线]'];
     for (const r of p.bottomLines) if (typeof r === 'string' && r.trim()) seg.push(`- ${escSegBrackets(r.trim())}`);
@@ -199,16 +215,31 @@ export function assemblePersona(settings, modeKey) {
     (h) => h && h.byUser === true && h.amendedBy !== 'ling' && typeof h.text === 'string' && h.text.trim(),
   );
   if (awaiting.length) {
-    segs.push(`[待我回应] 用户提的习惯候选:${awaiting.map((h) => `「${h.text.trim()}」`).join('、')}`
+    // 正文(h.text)过 escSegBrackets:与底线/规矩/习惯/承担/设定同规格,禁止正文自造段边界。
+    // **只包正文**:段头 [待我回应] 保持半角;包在正文外的「」引号与 、 分隔符是有意的结构,不动它们
+    // (转义只落在引号**里面**的文本上,「」配对关系逐字不变)。
+    // 为什么这一段特别要兜:此处**直接读 p.habitsPending**(没走 habitsPendingOf() 的 norm()),
+    // 而 norm() 会把换行压成空格、trim() 不会 —— 所以手改 settings.json 往某条候选的 text 里
+    // 塞「换行 + 半角 [」是通的,注入面就会真多出一个行首段头。出口转义是这条路上唯一一道闸。
+    segs.push(`[待我回应] 用户提的习惯候选:${awaiting.map((h) => `「${escSegBrackets(h.text.trim())}」`).join('、')}`
       + '——用 habit_resolve 表态(accept / amend 改说法 / decline)');
   }
+  // 职责(1.5.2 I-5):身份级、改变率极低。空值**不渲染整段**(不留空段头 —— 空段头会被模型当成"有内容但被藏起来")。
+  // 正文过 escSegBrackets:与底线/规矩/习惯同规格,禁止正文自造段边界。
+  if (typeof p.duty === 'string' && p.duty.trim()) {
+    segs.push(`[承担]\n${escSegBrackets(p.duty.trim())}`);
+  }
+  // 正文过 escSegBrackets:与底线/规矩/习惯/承担同规格,禁止正文自造段边界。
+  // **只包正文**:段头 [设定] 必须保持半角 —— 段边界判据是"行首是不是 [",段头被转全角等于整段凭空消失。
   if (typeof p.extraLore === 'string' && p.extraLore.trim()) {
-    segs.push(`[设定]\n${p.extraLore.trim()}`);
+    segs.push(`[设定]\n${escSegBrackets(p.extraLore.trim())}`);
   }
   const style = settings?.styles?.[mode];
   if (typeof style === 'string' && style.trim()) {
     // 段头与内容合并为一行(2026-09-16 瘦身:原来两行且重复"本会话为X模式")
-    segs.push(`[${mode === 'work' ? '工作' : '生活'}模式]${style.trim()}`);
+    // 正文过 escSegBrackets:与底线/规矩/习惯/承担同规格,禁止正文自造段边界(style 里的换行 + [ 也能伪造段头)。
+    // **只包正文**:段头 [工作模式]/[生活模式] 保持半角,否则段边界判据失效。
+    segs.push(`[${mode === 'work' ? '工作' : '生活'}模式]${escSegBrackets(style.trim())}`);
   }
   return segs.join('\n\n');
 }

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)