dsh-config-manager 0.1.71 → 0.1.73

package/src/core/rollback.ts

@@ -7,7 +7,7 @@
  *    如实标记 failed + manualHint（人工补录）；
  *  - settings 回滚仍走 expectedRevision 乐观锁，避免覆盖导入后用户的新修改。
  */
-import { resolveFileTarget } from './backup.ts';
+import { fsForSection, resolveFileTarget } from './backup.ts';
 import { isPatchLayerRel, USER_PATCH_FILE } from './patch-layers.ts';
 import { msgOf } from './messages.ts';
 import type {
@@ -88,13 +88,15 @@ async function compensateOne(
     }
     case 'file': {
       try {
+        // 门面按分区选（pluginData / pluginAssets 在系统 home 根；见 backup.ts 的 fsForSection）
+        const fsFacade = fsForSection(ctx, entry.adapter);
         const abs = resolveFileTarget(ctx, entry.adapter, entry.ref);
         if (entry.existed && entry.copiedTo && store) {
           const data = await store.readBlob(entry.snapshotId ?? '', entry.copiedTo);
-          await ctx.fs.writeFile(abs, data);
+          await fsFacade.writeFile(abs, data);
         } else if (!entry.existed) {
           // 原文件不存在 → 删除导入写入的文件
-          if (await ctx.fs.exists(abs)) await ctx.fs.remove(abs);
+          if (await fsFacade.exists(abs)) await fsFacade.remove(abs);
         }
         return null;
       } catch (err) {

package/src/core/run-registry.ts

@@ -20,6 +20,7 @@
  */
 import { randomBytes } from 'node:crypto'
 import { zhMsg } from './messages.ts'
+import { engineMsg } from './messages-core.ts'
 import type { MsgFunc } from './messages.ts'
 
 /** run 类型：导出 / 导入 / 自动同步 / 一键同步逐项应用 / 定时备份 / 快照恢复 / 配置档案切换 / recovery 恢复。 */
@@ -80,15 +81,15 @@ export class RunConflictError extends Error {
       kind === 'export'
         ? msg('run.conflict.export', { runId })
         : kind === 'autosync'
-          ? '自动同步已在进行中'
+          ? engineMsg('core.run.autosyncBusy')
           : kind === 'sync-apply'
-            ? '一键同步已在进行中'
+            ? engineMsg('core.run.syncApplyBusy')
             : kind === 'backup-schedule'
-              ? '定时备份已在进行中'
+              ? engineMsg('core.run.backupScheduleBusy')
               : kind === 'restore'
-                ? '快照恢复已在进行中（请等待当前恢复完成）'
+                ? engineMsg('core.run.restoreBusy')
                 : kind === 'recovery'
-                  ? '恢复/回滚已在进行中（请等待当前恢复完成）'
+                  ? engineMsg('core.run.recoveryBusy')
                   : msg('run.conflict.import', { runId }),
     )
     this.name = 'RunConflictError'

package/src/core/session-health.ts

@@ -154,12 +154,27 @@ export interface SessionHealthContext {
 export interface SessionHealthRow {
   unitId: string;
   sessionId: string;
+  /**
+   * 界面标题（**宿主侧补**，不是分类判定的一部分）。
+   *
+   * 来源 = DSH 会话缓存 `storages/session_projcache.json` 的 `rows.title.val`，由宿主在扫描后用
+   * `core/session-meta.ts` 的 `applySessionTitles` 统一补上（本模块零 IO，自己不读盘）。
+   * 读不到 = 缺省 → 界面回落显示会话目录名（绝不编造标题）。
+   */
+  title?: string;
   projectKey: string;
   severity: SessionHealthSeverity;
   issues: SessionHealthIssue[];
   version?: number;
   cwd?: string;
   origin?: string;
+  /**
+   * 空白会话（从未提问过；宿主侧从会话投影补的**事实**）。
+   *
+   * 用途：这类会话在 DSH 自己那里也没有标题（显示本地化的「新会话」）—— 界面据此显示同样的
+   * 占位名，而不是把 `session-<uuid>` 当标题。只下发事实，文案由界面按当前语言解析。
+   */
+  blank?: boolean;
   sizeBytes?: number;
   mtimeMs?: number;
 }

package/src/core/session-meta.test.ts

@@ -10,7 +10,7 @@ import assert from 'node:assert/strict';
 
 import { makeContext, MemFs } from '../adapters/test-helpers.ts';
 import type { ExportUnit } from './types.ts';
-import { applySessionMeta, applySessionMetaToPlanItems, applySessionParentLinks, clearSessionMetaCache, projectKeyOf, readSessionMeta, subagentParentMap } from './session-meta.ts';
+import { applySessionMeta, applySessionMetaToPlanItems, applySessionParentLinks, applySessionTitles, clearSessionMetaCache, projectKeyOf, readSessionMeta, readSessionMetaWithTitles, sessionBareKeyOf, subagentParentMap } from './session-meta.ts';
 
 const HOME = 'C:\\Users\\alice';
 const UUID_A = '19495390-402b-463d-a4cc-882287c1f04e';
@@ -314,3 +314,119 @@ test('clearSessionMetaCache：清空后下一次调用重新读盘', async () =>
   assert.equal(fs.reads.length, 4, '清空后必须重读（宿主可在存储重载信号上调用）');
   clearSessionMetaCache();
 });
+
+/**
+ * 体检行补标题（2026-10-12 用户反馈：会话体检列表只有 `session-<uuid>`，同屏十几条里认不出
+ * 哪条是自己的对话）。查表口径必须与导出选择器**逐字同一套**（裸键归一化）。
+ */
+test('applySessionTitles：体检行补对话标题（两种目录名形态都命中；没有标题绝不编造）', async () => {
+  const meta = await readSessionMeta(await seedStorages(HOME));
+  const rows = [
+    { unitId: `${PROJECT}/session-${UUID_A}`, sessionId: `session-${UUID_A}`, severity: 'invisible' },
+    { unitId: `${PROJECT}/${UUID_A}`, sessionId: UUID_A, severity: 'invisible' },
+    { unitId: `${OTHER_PROJECT}/${UUID_B}`, sessionId: UUID_B, severity: 'invisible' },
+  ];
+  const out = applySessionTitles(rows, meta);
+  assert.equal(out[0]?.title, '推送更新到 GitHub 并发布新版本', '带 session- 前缀的目录名同样要命中（查表前归一化）');
+  assert.equal(out[1]?.title, '推送更新到 GitHub 并发布新版本', '裸 uuid 形态同样命中');
+  assert.equal(out[2]?.title, undefined, '缓存里没有标题 → 不加字段（界面回落目录名，不编造）');
+  assert.deepEqual(out.map((r) => r.unitId), rows.map((r) => r.unitId), '只加展示字段，不动行上的任何既有字段');
+  assert.deepEqual(out.map((r) => r.severity), rows.map((r) => r.severity), '严重级等事实字段逐字不变');
+
+  // 读不到 DSH 缓存（空索引）→ 原样返回，绝不抛错（体检本身仍然可用）
+  const empty = { bySessionId: new Map(), workspaceTitleByProjectKey: new Map(), workspacePathByProjectKey: new Map() };
+  assert.deepEqual(applySessionTitles(rows, empty).map((r) => r.title), [undefined, undefined, undefined]);
+});
+/* ---------------- 逐会话投影文件（全量标题来源）----------------
+ * 用户要求（2026-10-12）：「历史对话的文本**始终**用对话标题，而不是只取缓存里的标题」。
+ * 本机实测（2026-10-12，1347 个会话目录）：聚合缓存只覆盖 445 条，而逐会话投影文件覆盖**每一条**
+ * —— 1150 份带标题，其余 197 份是 blank=true 的空白会话（DSH 自己给它们显示「新会话」）。
+ */
+
+/** 写一份逐会话投影文件（真机形状：`{ version, record: { identity, rows } }`）。 */
+async function seedProjection(
+  ctx: ReturnType<typeof makeContext>,
+  fileName: string,
+  rows: Record<string, unknown>,
+): Promise<void> {
+  const body = { version: 7, record: { identity: { cwd: 'D:\\Projects' }, rows } };
+  // 文件名 = 会话目录名 + `.json`（真机形态）；调用方可以省掉后缀
+  const name = fileName.endsWith('.json') ? fileName : fileName + '.json';
+  await ctx.fs.writeFile('storages/session_projcache/sessions/' + name, Buffer.from(JSON.stringify(body), 'utf8'));
+}
+
+test('readSessionMetaWithTitles：聚合缓存缺标题时读逐会话投影文件补上（两种文件名形态都认）', async () => {
+  clearSessionMetaCache();
+  const ctx = await seedStorages(HOME); // 聚合里：A 有标题、B 没有
+  // B 的投影文件（真机：文件名 = 会话目录名，两种形态并存）
+  await seedProjection(ctx, 'session-' + UUID_B, {
+    title: { ver: 1, seq: 3, val: '投影里的标题' },
+    sessionListMetadata: { val: { blank: false } },
+  });
+  // 另一条只有裸 uuid 形态的投影文件
+  const bareId = 'ffffffff-0000-0000-0000-000000000000';
+  await seedProjection(ctx, bareId + '.json', { title: { ver: 1, seq: 2, val: '裸文件名形态的标题' } });
+
+  const index = await readSessionMetaWithTitles(ctx, ['sessions:' + PROJECT + '/session-' + UUID_A, 'sessions:' + PROJECT + '/' + UUID_B, bareId, 'nonexistent-id']);
+  assert.equal(index.bySessionId.get(UUID_A)?.title, '推送更新到 GitHub 并发布新版本', '聚合缓存里的标题原样保留（不被投影覆盖）');
+  assert.equal(index.bySessionId.get(UUID_B)?.title, '投影里的标题', '聚合缺标题 → 用逐会话投影补上');
+  assert.equal(index.bySessionId.get(bareId)?.title, '裸文件名形态的标题', '两种投影文件名形态都要认');
+  assert.equal(index.bySessionId.get('nonexistent-id')?.title, undefined, '两边都没有 → 不编造');
+
+  // 只读、纯：不改原索引对象
+  const plain = await readSessionMeta(ctx);
+  assert.equal(plain.bySessionId.get(UUID_B)?.title, undefined, 'readSessionMetaWithTitles 不得污染 readSessionMeta 的缓存索引');
+});
+
+test('readSessionMetaWithTitles：空白会话下发 blank 事实（没有标题可显示，界面显示「新会话」）', async () => {
+  clearSessionMetaCache();
+  const ctx = await seedStorages(HOME);
+  await seedProjection(ctx, UUID_B + '.json', { sessionListMetadata: { val: { blank: true, lastPromptAt: null } } });
+  const index = await readSessionMetaWithTitles(ctx, [UUID_B]);
+  assert.equal(index.bySessionId.get(UUID_B)?.blank, true, '空白事实必须下发（界面据此显示本地化的「新会话」）');
+  assert.equal(index.bySessionId.get(UUID_B)?.title, undefined, '空白会话没有标题 —— 绝不编造一个');
+});
+
+test('readSessionMetaWithTitles：只读「聚合里缺标题」的那些，且 mtime 未变时第二次不再读盘', async () => {
+  clearSessionMetaCache();
+  const { ctx, fs } = await seededCounting('C:\\Users\\proj-cache', 4000);
+  await seedProjection(ctx, 'session-' + UUID_B, { title: { ver: 1, seq: 2, val: '投影标题 B' } });
+  fs.setMtime('storages/session_projcache/sessions/session-' + UUID_B + '.json', 4100);
+  const first = await readSessionMetaWithTitles(ctx, [UUID_A, UUID_B]);
+  assert.equal(first.bySessionId.get(UUID_B)?.title, '投影标题 B');
+  const after = fs.reads.length;
+  const second = await readSessionMetaWithTitles(ctx, [UUID_A, UUID_B]);
+  assert.equal(second.bySessionId.get(UUID_B)?.title, '投影标题 B');
+  assert.equal(fs.reads.length, after, '同一批会话重复查询不得重复读盘（投影文件走 mtime 缓存）');
+  // A 在聚合里已有标题 → 不该去读它的投影文件
+  assert.equal(fs.reads.filter((rel) => rel.includes('session-' + UUID_A + '.json')).length, 0, '已有标题的会话不得多读一份文件');
+});
+
+test('sessionBareKeyOf：单元 id / 目录名两种入参都归一化到裸键', () => {
+  assert.equal(sessionBareKeyOf('sessions:' + PROJECT + '/session-' + UUID_A), UUID_A);
+  assert.equal(sessionBareKeyOf('session-' + UUID_A), UUID_A);
+  assert.equal(sessionBareKeyOf(UUID_A), UUID_A);
+});
+
+
+test('blank 事实：导出单元与体检行都透传（界面据此显示本地化「新会话」而不是 uuid）', async () => {
+  clearSessionMetaCache();
+  const ctx = await seedStorages(HOME);
+  await seedProjection(ctx, UUID_B + '.json', { sessionListMetadata: { val: { blank: true } } });
+  const index = await readSessionMetaWithTitles(ctx, [UUID_B]);
+
+  const units = applySessionMeta([unit(OTHER_PROJECT + '/' + UUID_B)], index);
+  assert.equal(units[0]?.blank, true, '空白会话的导出单元必须带 blank（ContentPicker 显示「新会话」）');
+  assert.equal(units[0]?.label, OTHER_PROJECT + '/' + UUID_B, '没有标题 → label 仍是目录名（界面按 blank 显示占位名）');
+
+  const rows = applySessionTitles([{ unitId: OTHER_PROJECT + '/' + UUID_B, sessionId: UUID_B }], index);
+  assert.equal(rows[0]?.blank, true, '体检行同样要带 blank');
+  assert.equal(rows[0]?.title, undefined, '空白会话没有标题');
+
+  const plan = applySessionMetaToPlanItems(
+    [{ id: 'sessions:' + OTHER_PROJECT + '/' + UUID_B, unitId: 'sessions:' + OTHER_PROJECT + '/' + UUID_B, adapter: 'sessions', kind: 'Create', description: 'x' }],
+    index,
+  );
+  assert.equal(plan[0]?.blank, true, '导入计划项同样要带 blank');
+});
+

package/src/core/session-meta.ts

@@ -17,6 +17,14 @@ import type { ExportUnit, HostContext, SessionParentRelation } from './types.ts'
 
 const SESSION_PROJCACHE = 'storages/session_projcache.json';
 const WORKSPACE_STORE = 'storages/workspace.json';
+/**
+ * **逐会话**投影存储目录（`storages/session_projcache/sessions/<会话目录名>.json`）。
+ *
+ * 与 `session_projcache.json` 的关系：那个是**会淘汰的近期聚合**（本机实测只覆盖 445/1347 条会话），
+ * 这个目录才是 DSH 为**每条会话**留下的投影（本机 1349 份，其中 1150 份带标题）。只读聚合缓存会让
+ * 其余会话在选择器 / 体检列表里退化成 uuid 目录名 —— 用户认不出哪条是哪条。
+ */
+const SESSION_PROJECTION_DIR = 'storages/session_projcache/sessions';
 
 // projectKeyOf 已下移到**零依赖**模块 `session-select.ts`（客户端勾选联动要按 cwd 目录键认领工作区，
 // 而本模块会用 Buffer 读 DSH 存储缓存，不能进浏览器 bundle）。这里 re-export，既有导入路径逐字不变。
@@ -78,9 +86,19 @@ function asRecord(value: unknown): Record<string, unknown> | null {
  */
 const metaCache = new Map<string, { key: string; index: SessionMetaIndex }>();
 
-/** 清空索引缓存（测试用；宿主在收到「DSH 存储已重载」信号时也可调用）。 */
+/**
+ * 逐会话投影文件的**进程内缓存**（键含 homeDir + 相对路径，失效判据 = 该文件 mtime）。
+ *
+ * 为什么需要：导出选择器一次要补上千条会话的标题，而同一批会话在一次交互里会被反复查询
+ * （打开选择器 → 勾选 → 会话↔工作区联动补跑）。每次重读 1300 个小文件会把「打开弹窗」拖成秒级。
+ * 与 `metaCache` 同一条纪律：**读不到 mtime 就不缓存**（宁可贵一点，也绝不拿陈旧标题骗用户）。
+ */
+const projectionCache = new Map<string, { key: string; facts: ProjectedSessionFacts | undefined }>();
+
+/** 清空索引与逐会话投影缓存（测试用；宿主在收到「DSH 存储已重载」信号时也可调用）。 */
 export function clearSessionMetaCache(): void {
   metaCache.clear();
+  projectionCache.clear();
 }
 
 /** 文件 mtime（毫秒；门面未实现 / 读不到 → null = 无法判定新鲜度，调用方不得缓存）。 */
@@ -154,6 +172,102 @@ async function loadSessionMeta(ctx: HostContext): Promise<SessionMetaIndex> {
   return index;
 }
 
+/** 逐会话投影文件里**展示所需**的事实（只取这两项；文件读不到 = undefined）。 */
+interface ProjectedSessionFacts {
+  /** 界面标题（`record.rows.title.val`） */
+  title?: string;
+  /** 空白会话（`record.rows.sessionListMetadata.val.blank`）—— DSH 自己也据此显示「新会话」 */
+  blank?: boolean;
+}
+
+/**
+ * 会话单元 id（`sessions:<项目键>/<目录名>`）或裸目录名 → **归一化裸键**（`sessionIdKey`）。
+ *
+ * 为什么要有：调用方手上是单元 id / 计划项 id（末段才是目录名），而索引与投影文件都按**裸键**存。
+ */
+export function sessionBareKeyOf(ref: string): string {
+  const slash = ref.lastIndexOf('/');
+  return sessionIdKey(slash >= 0 ? ref.slice(slash + 1) : ref);
+}
+
+/** 逐会话投影文件的候选名（DSH 实测两种目录名形态并存：`session-<uuid>.json` 与 `<uuid>.json`）。 */
+function projectionFileNames(bare: string): string[] {
+  return ['session-' + bare + '.json', bare + '.json'];
+}
+
+/**
+ * 读一条会话的**逐会话投影文件**（`storages/session_projcache/sessions/<会话目录名>.json`）。
+ *
+ * 形状与聚合缓存略有差异：文件里是 `{ version, record: { identity, rows } }`，聚合里是 `{ identity, rows }`
+ * —— 两种都认（`record` 缺省即顶层）。**只读、尽力而为、绝不抛错**：读不到 / 形状不认 → undefined。
+ */
+async function readProjectedSession(ctx: HostContext, bare: string): Promise<ProjectedSessionFacts | undefined> {
+  for (const name of projectionFileNames(bare)) {
+    const rel = SESSION_PROJECTION_DIR + '/' + name;
+    const cacheId = ctx.homeDir + '\u0000' + rel;
+    const mtime = await mtimeOf(ctx, rel);
+    if (mtime !== null) {
+      const hit = projectionCache.get(cacheId);
+      if (hit !== undefined && hit.key === String(mtime)) return hit.facts;
+    }
+    let facts: ProjectedSessionFacts | undefined;
+    const raw = asRecord(await readJsonSafe(ctx, rel));
+    if (raw !== null) {
+      const rec = asRecord(raw['record']) ?? raw;
+      const rows = asRecord(rec['rows']);
+      const title = asRecord(rows?.['title'])?.['val'];
+      const listMeta = asRecord(asRecord(rows?.['sessionListMetadata'])?.['val']);
+      const out: ProjectedSessionFacts = {};
+      if (typeof title === 'string' && title.trim() !== '') out.title = title.trim();
+      if (listMeta?.['blank'] === true) out.blank = true;
+      facts = out;
+    }
+    if (mtime === null) projectionCache.delete(cacheId);
+    else projectionCache.set(cacheId, { key: String(mtime), facts });
+    if (facts !== undefined) return facts;
+  }
+  return undefined;
+}
+
+/** 一次并发读多少份投影文件（小文件；32 路实测把 1300 条压到百毫秒级）。 */
+const PROJECTION_CONCURRENCY = 32;
+
+/**
+ * 「界面标题」的**全量**解析：聚合缓存优先，缺的按需读**逐会话投影文件**。
+ *
+ * 用户要求（2026-10-12）：「历史对话的文本**始终**用对话标题，而不是只取缓存里的标题」。
+ * 只读聚合缓存（`session_projcache.json`）时，本机 1347 条会话里有 902 条拿不到标题 → 界面退化成
+ * `session-<uuid>`，用户在同屏十几条里认不出哪条是自己的对话。
+ *
+ * 成本：只读「聚合缓存里没有标题」的那些（本机约 900 条小文件；实测全量顺序读 1349 份 = 361 ms），
+ * 32 路并发 + mtime 缓存 —— 同一批会话重复查询（打开选择器 / 勾选 / 联动补跑）不再重复读盘。
+ *
+ * 语义：**只增不改** —— 已缓存的标题与 blank 一律保留；实在读不到的会话原样返回（界面回落目录名）。
+ *
+ * @param refs 会话单元 id（`sessions:<项目键>/<目录名>`）或裸目录名，混着传也行
+ */
+export async function readSessionMetaWithTitles(ctx: HostContext, refs: readonly string[]): Promise<SessionMetaIndex> {
+  const index = await readSessionMeta(ctx);
+  const need = [...new Set(refs.map((ref) => sessionBareKeyOf(ref)).filter((bare) => bare !== ''))]
+    .filter((bare) => index.bySessionId.get(bare)?.title === undefined);
+  if (need.length === 0) return index;
+  const bySessionId = new Map(index.bySessionId);
+  for (let i = 0; i < need.length; i += PROJECTION_CONCURRENCY) {
+    const chunk = need.slice(i, i + PROJECTION_CONCURRENCY);
+    const found = await Promise.all(chunk.map(async (bare) => [bare, await readProjectedSession(ctx, bare)] as const));
+    for (const [bare, facts] of found) {
+      if (facts === undefined) continue;
+      const existing = bySessionId.get(bare) ?? {};
+      bySessionId.set(bare, {
+        ...existing,
+        ...(facts.title !== undefined ? { title: facts.title } : {}),
+        ...(facts.blank !== undefined ? { blank: facts.blank } : {}),
+      });
+    }
+  }
+  return { ...index, bySessionId };
+}
+
 /** 单元 id（`sessions:<项目键>/<会话目录名>`）→ 会话目录名；形状不符 → null。 */
 function sessionIdOfUnit(sectionId: string, unitId: string): { projectKey: string; sessionId: string } | null {
   const prefix = sectionId + ':';
@@ -176,7 +290,7 @@ function sessionIdOfUnit(sectionId: string, unitId: string): { projectKey: strin
  */
 export function applySessionMetaToPlanItems<
   T extends { id: string; unitId?: string; adapter: string; label?: string; group?: string },
->(items: readonly T[], index: SessionMetaIndex, sectionId = 'sessions'): T[] {
+>(items: readonly T[], index: SessionMetaIndex, sectionId = 'sessions'): (T & { blank?: boolean })[] {
   return items.map((item) => {
     if (item.adapter !== sectionId) return item;
     const parsed = sessionIdOfUnit(sectionId, item.unitId ?? item.id);
@@ -188,6 +302,8 @@ export function applySessionMetaToPlanItems<
     return {
       ...item,
       ...(meta?.title !== undefined ? { label: meta.title } : {}),
+      // 空白会话（从未提问）：DSH 自己显示「新会话」而不是 uuid；标记随计划项下发，由界面本地化
+      ...(meta?.blank === true ? { blank: true } : {}),
       group,
     };
   });
@@ -234,6 +350,35 @@ export function applySessionParentLinks<T extends { id: string; parentSessionId?
   });
 }
 
+/**
+ * 给**会话体检行**补上「界面标题」（行上的 `sessionId` = 会话目录名，索引键是裸键 → 查表前必须归一化）。
+ *
+ * 为什么需要：体检列表此前只显示目录名（`session-20d2722c-…`），用户在同一屏十几条里认不出哪条是自己的
+ * 对话（2026-10-12 用户反馈截图实证）。标题的唯一可靠来源就是 DSH 自己的会话缓存
+ * （`storages/session_projcache.json` 的 `rows.title.val`）—— 与导出选择器**同一份索引、同一套
+ * `sessionIdKey` 归一化口径**，绝不另写一套查表规则。
+ *
+ * 只读、纯函数、**绝不编造**：索引里没有这条会话 / 没有标题 → 原样返回（界面回落显示目录名）。
+ * 索引本身由 `readSessionMetaWithTitles()` 产出（聚合缓存 + **逐会话投影文件**兜底，见那里）。
+ */
+export function applySessionTitles<T extends { sessionId?: string | null }>(
+  rows: readonly T[],
+  index: SessionMetaIndex,
+): (T & { title?: string; blank?: boolean })[] {
+  return rows.map((row) => {
+    // 会话 id 缺失 / 空串的记录**一个字段都不加**（回滚台账里有这类历史记录：绝不猜它属于哪条对话）
+    if (typeof row.sessionId !== 'string' || row.sessionId === '') return row;
+    const meta = index.bySessionId.get(sessionIdKey(row.sessionId));
+    if (meta === undefined) return row;
+    return {
+      ...row,
+      ...(meta.title !== undefined ? { title: meta.title } : {}),
+      // 空白会话（从未提问）：没有标题，界面据此显示本地化的「新会话」（与 DSH 的 session.new 同口径）
+      ...(meta.blank === true ? { blank: true } : {}),
+    };
+  });
+}
+
 /**
  * 给 sessions 分区的单元补上「界面标题 + 工作区分组」，并按「工作区 → 最近在前」排序。
  *
@@ -267,6 +412,8 @@ export function applySessionMeta(
       label: meta?.title ?? unit.label,
       ...(detail !== undefined ? { detail } : {}),
       group: workspaceTitle ?? parsed.projectKey,
+      // 空白会话（从未提问）：没有标题可显示，标记出来让界面显示本地化的「新会话」（与 DSH 同口径）
+      ...(meta?.blank === true ? { blank: true } : {}),
     };
   });
   // 排序：先按工作区（保持首次出现顺序），组内最近活跃的在前；无时间的排在组内末尾。

package/src/core/session-title.test.ts

@@ -0,0 +1,127 @@
+/**
+ * 「会话标题」的**日志兜底**单测（2026-10-12 用户要求：缓存里没有这条会话，就自动读这条会话自己的名字）。
+ *
+ * 钉住的语义：`session/title` 事件 → 标题（多条取最后一条 = 用户改名压过自动标题）；读不到一律 null
+ * （界面回落显示会话 id，**绝不从首条消息编造**）；越界 / 形状不符的 unitId 不拼路径；
+ * 缓存按 mtime+size 失效；一次请求的读盘有界（同 unitId 只读一次）。
+ */
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { encodeZstdFrame } from '../utils/zstd-frame.ts';
+import {
+  applySessionLogTitles,
+  clearSessionTitleCache,
+  readSessionTitleFromLog,
+} from './session-title.ts';
+
+async function withTmp<T>(fn: (dir: string) => Promise<T>): Promise<T> {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-cm-session-title-'));
+  try {
+    return await fn(dir);
+  } finally {
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+}
+
+/** 造一个会话日志：第 1 帧 = header 行，其余每行一帧（与 DSH 的多帧容器同形）。 */
+function logBytes(id: string, lines: readonly string[]): Buffer {
+  const frames: Buffer[] = [encodeZstdFrame(Buffer.from(JSON.stringify({ version: 3, id, cwd: 'D:/P' }) + '\n', 'utf8'))];
+  for (const line of lines) frames.push(encodeZstdFrame(Buffer.from(line, 'utf8')));
+  return Buffer.concat(frames);
+}
+
+/** `session/title` 事件行（DSH 的形状：data = { title, messageSeqs, source }）。 */
+function titleLine(title: string, source = 'auto'): string {
+  return JSON.stringify({ seq: 9, type: 'session/title', data: { title, messageSeqs: [1], source } }) + '\n';
+}
+
+const PROJECT_KEY = '--D--Projects-personal-demo--';
+const UNIT = PROJECT_KEY + '/session-0b46a72f-d25e-423f-af4b-ef768938292e';
+
+async function writeUnit(sessionsDir: string, unitId: string, bytes: Buffer, name = 'session.jsonl'): Promise<string> {
+  const dir = path.join(sessionsDir, ...unitId.split('/'));
+  await fs.mkdir(dir, { recursive: true });
+  const file = path.join(dir, name);
+  await fs.writeFile(file, bytes);
+  return file;
+}
+
+test('session/title 事件 → 标题；多条取最后一条（用户改名压过自动标题）', async () => {
+  await withTmp(async (dir) => {
+    clearSessionTitleCache();
+    await writeUnit(dir, UNIT, logBytes('session-a', [titleLine('自动生成的标题'), titleLine('用户改的名字', 'user')]));
+    assert.equal(await readSessionTitleFromLog(dir, UNIT), '用户改的名字');
+  });
+});
+
+test('没有标题事件 / 空标题 / 形状不符 → null（绝不编造）', async () => {
+  await withTmp(async (dir) => {
+    clearSessionTitleCache();
+    await writeUnit(dir, UNIT, logBytes('session-a', ['{"seq":1,"type":"message"}\n']));
+    assert.equal(await readSessionTitleFromLog(dir, UNIT), null, '没有 session/title 事件 → null');
+
+    const emptyTitle = UNIT + '-empty';
+    await writeUnit(dir, emptyTitle, logBytes('session-b', [titleLine('   ')]));
+    assert.equal(await readSessionTitleFromLog(dir, emptyTitle), null, '空白标题不算标题');
+
+    const wrongShape = UNIT + '-shape';
+    await writeUnit(dir, wrongShape, logBytes('session-c', ['{"seq":2,"type":"session/title","data":null}\n']));
+    assert.equal(await readSessionTitleFromLog(dir, wrongShape), null, 'data 形状不符 → null');
+  });
+});
+
+test('目录 / 文件缺失、unitId 形状不符（单段 / 越界）→ null（不拼可疑路径）', async () => {
+  await withTmp(async (dir) => {
+    clearSessionTitleCache();
+    assert.equal(await readSessionTitleFromLog(dir, UNIT), null, '目录不存在 → null');
+    assert.equal(await readSessionTitleFromLog(dir, 'session-only'), null, '单段 unitId → null');
+    assert.equal(await readSessionTitleFromLog(dir, PROJECT_KEY + '/../..'), null, '越界段 → null');
+    const dirOnly = PROJECT_KEY + '/session-no-log';
+    await fs.mkdir(path.join(dir, ...dirOnly.split('/')), { recursive: true });
+    await fs.writeFile(path.join(dir, ...dirOnly.split('/'), 'notes.txt'), 'not a log');
+    assert.equal(await readSessionTitleFromLog(dir, dirOnly), null, '目录里没有会话日志 → null');
+  });
+});
+
+test('缓存按 mtime+size 失效：日志增长后能读到新落盘的标题', async () => {
+  await withTmp(async (dir) => {
+    clearSessionTitleCache();
+    const file = await writeUnit(dir, UNIT, logBytes('session-a', ['{"seq":1}\n']));
+    assert.equal(await readSessionTitleFromLog(dir, UNIT), null, '第一次：还没有标题');
+    // 追加一帧（保留原字节）⇒ 文件变大 ⇒ 缓存必须失效，下次读得到刚落盘的标题
+    await fs.appendFile(file, encodeZstdFrame(Buffer.from(titleLine('刚生成的标题'), 'utf8')));
+    assert.equal(await readSessionTitleFromLog(dir, UNIT), '刚生成的标题');
+  });
+});
+
+test('applySessionLogTitles：已有标题不动、同 unitId 只读一次、读盘次数有上界', async () => {
+  await withTmp(async (dir) => {
+    clearSessionTitleCache();
+    const unitB = PROJECT_KEY + '/session-b';
+    await writeUnit(dir, UNIT, logBytes('session-a', [titleLine('A 的标题')]));
+    await writeUnit(dir, unitB, logBytes('session-b', [titleLine('B 的标题')]));
+
+    const rows = await applySessionLogTitles([
+      { sessionId: 'a1', unitId: UNIT },
+      { sessionId: 'a1', unitId: UNIT },
+      { sessionId: 'b1', unitId: unitB, title: '缓存里已有' },
+      { sessionId: 'c1', unitId: null },
+    ], dir);
+    assert.equal(rows[0]?.title, 'A 的标题');
+    assert.equal(rows[1]?.title, 'A 的标题', '同 unitId 的其余行复用同一次读取');
+    assert.equal(rows[2]?.title, '缓存里已有', '已有标题的行原样保留（不覆盖缓存结论）');
+    assert.equal(rows[3]?.title, undefined, '没有 unitId 的行不猜归属');
+
+    // 上界：maxReads=1 时，第二个**不同**会话不再读盘（保持无标题，界面回落显示 id）
+    const capped = await applySessionLogTitles([
+      { sessionId: 'a1', unitId: UNIT },
+      { sessionId: 'b1', unitId: unitB },
+    ], dir, { maxReads: 1 });
+    assert.equal(capped[0]?.title, 'A 的标题');
+    assert.equal(capped[1]?.title, undefined, '超过上界的会话不再读盘（绝不把盘读穿）');
+  });
+});