dsh-manage-session 0.2.3 → 0.3.3

package/src/client/locales.ts

@@ -59,12 +59,15 @@ export const zh = {
   // 分批扫描的进度读数：done/total + 已用秒数（total 由宿主报告的总数给出）
   'health.progress': '{done}/{total} · 已用 {sec}s',
   'health.empty': '未发现异常会话。',
-  'health.clean': '四门全绿。',
+  'health.clean': '全部检查通过。',
   'health.level.ok': '正常',
   'health.level.warn': '注意',
   // 中性档：本门无从判定（如冷态会话无热态投影），不参与 warn 聚合
   'health.level.skipped': '未检查',
   'health.level.fail': '异常',
+  // 处置优先级：当前代是从迁移暂存（TMP）发布出来的会话，排在最前
+  'health.priority.high': '优先',
+  'health.gate.generation': '代次产物',
   'health.gate.log-integrity': '日志完整性',
   'health.gate.projection-cache': '投影缓存',
   'health.gate.lossless-json': '无损 JSON',
@@ -147,11 +150,13 @@ export const en: Record<LocaleKey, string> = {
   'health.scanning': 'Running…',
   'health.progress': '{done}/{total} · {sec}s elapsed',
   'health.empty': 'No problem session found.',
-  'health.clean': 'All four gates are green.',
+  'health.clean': 'All checks passed.',
   'health.level.ok': 'ok',
   'health.level.warn': 'warn',
   'health.level.skipped': 'Not checked',
   'health.level.fail': 'fail',
+  'health.priority.high': 'Priority',
+  'health.gate.generation': 'Generation artifact',
   'health.gate.log-integrity': 'Log integrity',
   'health.gate.projection-cache': 'Projection cache',
   'health.gate.lossless-json': 'Lossless JSON',

package/src/host/health/cache.ts

@@ -1,7 +1,7 @@
 /**
  * 体检结果的进程内缓存（**不落盘**）。
  *
- * 为什么要缓存：面板每打开一次就全量重扫语料（每个会话都要解 zstd、跑四门），
+ * 为什么要缓存：面板每打开一次就全量重扫语料（每个会话都要解 zstd、跑门），
  * 关掉再打开等于重做一遍。有缓存后「关面板 → 重开」零延迟出内容。
  *
  * 为什么不落盘：会话日志与语料一直在变，落盘就必须配失效策略，而判断失效的代价

package/src/host/health/decode.ts

@@ -36,6 +36,14 @@ export interface SessionLogRead {
   decoder: 'official' | 'local'
   /** 尾部是否仍有未收尾的 open step。 */
   openStep?: { turn: number; step: number }
+  /**
+   * 日志首行的 header（`type: 'session'` 记录）。
+   *
+   * 取它是为了拿到 `version`（格式代次）：文件名代次与 header 代次都由宿主的
+   * 代次发布路径写入，二者一致是发布不变量。首行不是 JSON 时为 undefined，
+   * 由 `log-integrity` 门按解码问题如实报出，不在这里抛。
+   */
+  header?: Record<string, unknown>
 }
 
 /** 解码后的事件（结构子集）。 */
@@ -209,7 +217,7 @@ export function decodeRecordLocal(value: unknown): DecodedEvent[] {
 
 /**
  * 读取一个会话日志文件（zip 帧扫描 + 解包 + seq 连续性）。
- * @param file - `session.jsonl.zstd` 绝对路径。
+ * @param file - 当前代日志的绝对路径（由代次解析得出，不假定具体文件名）。
  * @param bytes - 文件内容（调用方读取，便于测试注入）。
  * @param decoders - 可选官方解码器（缺省用本地等价实现）。
  * @returns 事件、统计与问题清单。
@@ -276,6 +284,15 @@ export function decodeSessionLogBytes(
     if (gapped) break
   }
   const openStep = findOpenStep(events)
+  // 首行是 header，不参与事件序列（下面的事件循环从 index 1 起）。
+  let header: Record<string, unknown> | undefined
+  const headerLine = lines[0]
+  if (headerLine !== undefined) {
+    try {
+      const parsed: unknown = JSON.parse(headerLine)
+      if (typeof parsed === 'object' && parsed !== null) header = parsed as Record<string, unknown>
+    } catch { /* 首行不是 JSON：header 不可读，由 log-integrity 门报出 */ }
+  }
   return {
     events,
     frames: frames.length,
@@ -284,6 +301,7 @@ export function decodeSessionLogBytes(
     issues,
     decoder: decoders === undefined ? 'local' : 'official',
     ...(openStep === undefined ? {} : { openStep }),
+    ...(header === undefined ? {} : { header }),
   }
 }
 

package/src/host/health/gates.ts

@@ -1,5 +1,5 @@
 /**
- * 四个体检 gate（每个可独立测试）与报告聚合。
+ * 五个体检 gate（每个可独立测试）与报告聚合。
  *
  * 统一输出形状：`{ id, level, evidence, attribution, detail }`；
  * 聚合结果 `SessionHealthReport` 供「体检 → 处方 → 出院」三步流程使用。
@@ -10,6 +10,11 @@ import { existsSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 import { decodeSessionLogFile, type SessionLogRead } from './decode.ts'
+import {
+  sessionPriority,
+  type SessionGenerations,
+  type SessionPriority,
+} from './generation.ts'
 import { firstLosslessViolation, type LosslessViolation } from './lossless.ts'
 
 /**
@@ -40,7 +45,7 @@ export interface GateAttribution {
 
 /** 一个 gate 的结果。 */
 export interface GateResult {
-  id: 'log-integrity' | 'projection-cache' | 'lossless-json' | 'cold-read'
+  id: 'generation' | 'log-integrity' | 'projection-cache' | 'lossless-json' | 'cold-read'
   level: GateLevel
   evidence: string
   attribution?: GateAttribution
@@ -51,6 +56,12 @@ export interface GateResult {
 export interface SessionHealthReport {
   sessionId: string
   level: GateLevel
+  /**
+   * 处置优先级：`high` = 该会话的当前代是从迁移暂存（TMP）发布出来的。
+   *
+   * 与 `level` 正交：优先级答「先看谁」，档位答「要不要处置」。
+   */
+  priority: SessionPriority
   gates: GateResult[]
   generatedAt: number
 }
@@ -64,6 +75,12 @@ export interface GateContext {
   logPath?: string
   /** 已解码的日志（复用，避免重复解码）。 */
   log?: SessionLogRead
+  /**
+   * 会话目录的代次事实（见 `generation.ts`）。
+   *
+   * 不提供时 `generation` 门记 `skipped`（无从判定），不猜、也不当作正常。
+   */
+  generations?: SessionGenerations
   /** 热态：宿主 `sessionProjections.checkpoint(session)` 的逐行状态。 */
   projectionState?: Record<string, unknown>
   /** 归属查询函数（投影 key → 包名）。 */
@@ -114,6 +131,73 @@ export function readTailFacts(log: SessionLogRead): TailFacts {
   }
 }
 
+/**
+ * gate 0：代次事实（当前代是历史代还是已发布代、有没有暂存残留）。
+ *
+ * 存在的理由：一个会话目录里可以有多份日志产物，而**读哪一份**决定了后面所有
+ * 门的结论。早期版本固定读 `session.jsonl.zstd`，于是对已发布当前代的会话要么
+ * 读错（读历史代那份，12MB 全量回放）、要么完全发现不了。本门把这个前提显式化成
+ * 可判定的证据，档位判据只取「有据可依」的三条：
+ *   - 没有任何规范产物（只剩暂存）→ `fail`：当前代尚未发布；
+ *   - 有暂存残留 → `warn`：发布源仍在原地（发布完成未清，或尚未发布）；
+ *   - 文件名代次与 header 代次不一致 → `warn`：发布不变量被破坏。
+ * 历史代与当前代并存是宿主**契约要求**（已提交代次不删不改），故记 `ok` 并写进
+ * 证据，不抬档 —— 抬档会把 34 个完全正常的会话变成噪声。
+ * @param facts - 会话目录的代次事实；缺省表示无从判定。
+ * @param log - 已解码的日志（用于取 header.version 交叉核对）。
+ */
+export function gateGeneration(facts: SessionGenerations | undefined, log?: SessionLogRead): GateResult {
+  if (facts === undefined) {
+    return { id: 'generation', level: 'skipped', evidence: '未提供代次事实，本门无从判定' }
+  }
+  const current = facts.current
+  const headerVersion = typeof log?.header?.['version'] === 'number' ? log.header['version'] as number : undefined
+  const detail = {
+    currentVersion: current?.version,
+    currentName: current?.name,
+    currentCompression: current?.compression,
+    canonicalVersions: facts.canonical.map(artifact => artifact.version),
+    staging: facts.staging.map(artifact => artifact.name),
+    legacyOnly: facts.legacyOnly,
+    priority: sessionPriority(facts),
+    ...(headerVersion === undefined ? {} : { headerVersion }),
+  }
+  if (current === undefined) {
+    return {
+      id: 'generation',
+      level: 'fail',
+      evidence: `目录内没有任何规范代次产物，仅剩 ${facts.staging.length} 份迁移暂存：当前代尚未从暂存发布`,
+      detail,
+    }
+  }
+  if (facts.staging.length > 0) {
+    return {
+      id: 'generation',
+      level: 'warn',
+      evidence: `当前代 v${current.version}（${current.name}）旁留有 ${facts.staging.length} 份迁移暂存残留：` +
+        facts.staging.map(artifact => artifact.name).join('、'),
+      detail,
+    }
+  }
+  if (headerVersion !== undefined && headerVersion !== current.version) {
+    return {
+      id: 'generation',
+      level: 'warn',
+      evidence: `文件名代次与日志头代次不一致：${current.name} 名为 v${current.version}，header.version=${headerVersion}`,
+      detail,
+    }
+  }
+  const note = facts.legacyOnly
+    ? '；目录内只有历史代，宿主首次写访问时才发布当前代'
+    : facts.legacy === undefined ? '' : '；历史代 v0 按契约保留未删'
+  return {
+    id: 'generation',
+    level: 'ok',
+    evidence: `当前代 v${current.version}（${current.name}）${note}`,
+    detail,
+  }
+}
+
 /** gate 1：日志完整性（可解码、seq 连续、无撕裂尾帧）。 */
 export function gateLogIntegrity(log: SessionLogRead): GateResult {
   if (log.issues.length > 0) {
@@ -302,12 +386,14 @@ export function gateColdRead(facts: TailFacts): GateResult {
   return { id: 'cold-read', level: 'ok', evidence: `最后一轮 completed 结束，会话可原地接续（末 seq ${facts.lastSeq}）`, detail }
 }
 
-/** 聚合四门结果为一份报告。 */
+/** 聚合全部 gate 结果为一份报告。 */
 export function buildSessionReport(context: GateContext): SessionHealthReport {
   const log = context.log ?? (context.logPath === undefined
     ? undefined
     : decodeSessionLogFile(context.logPath))
   const gates: GateResult[] = []
+  // 代次门恒在首位：它断言的是「读的是哪一份产物」，是后面所有门的前提。
+  gates.push(gateGeneration(context.generations, log))
   if (log === undefined) {
     gates.push({ id: 'log-integrity', level: 'fail', evidence: '未提供日志读取结果或日志路径' })
   } else {
@@ -325,6 +411,8 @@ export function buildSessionReport(context: GateContext): SessionHealthReport {
   return {
     sessionId: context.sessionId,
     level,
+    // 没有代次事实就不主张优先级：优先级是「先看谁」的排序主张，无据时按普通处理。
+    priority: context.generations === undefined ? 'normal' : sessionPriority(context.generations),
     gates,
     generatedAt: (context.now ?? Date.now)(),
   }

package/src/host/health/generation.ts

@@ -0,0 +1,216 @@
+/**
+ * 会话日志的「代次」文件名契约（对齐宿主 session 操作核心）。
+ *
+ * 一个会话目录里可以同时存在多份日志产物：
+ *
+ *     session.jsonl.zstd                          历史代 0（无版本号）
+ *     session.v<N>.jsonl.zstd                     当前代 N（N ≥ 1）
+ *     session.migration.<token>.jsonl.zstd.tmp    迁移暂存（当前代的发布源）
+ *
+ * **当前代由目录实测的最高代次决定，不硬编码 `v3`；日志名由代次推导，不硬编码
+ * `session.jsonl.zstd`。** 硬编码 v0 正是本插件此前「看不见任何已发布当前代的
+ * 会话」的病根：实测 449 个会话目录中有 61 个只留当前代，旧发现逻辑对它们一条
+ * 都发现不了，因而既扫不到也修不了。
+ *
+ * 宿主侧的代次发布顺序是「写暂存 → fsync → 校验 → 原子发布成当前代」，所以
+ * **当前代次非 0 等价于「这份日志是从 TMP 里移出来的」**；目录内仍有暂存残留
+ * 则是发布源仍在原地的物证。本模块据此给出处置优先级。
+ *
+ * 语法逐条对齐宿主包，改动它们必须同步这里（`tests/generation.spec.ts` 复刻了
+ * 宿主的全部拒绝用例，宿主放宽/收紧时该组测试会失败）：
+ *   - `@deepseek-ai/dsh-session-format/src/filename.ts`
+ *     `CANONICAL_LOG_FILENAME = /^session(?:\.v([1-9][0-9]*))?\.jsonl$/u`
+ *   - `@deepseek-ai/dsh-session-persistence-jsonl/src/format.ts` 的压缩后缀
+ *   - `@deepseek-ai/dsh-session-persistence-jsonl/src/generation.ts:725`
+ *     暂存名 `session.migration.${randomToken()}${suffix}.tmp`（token 为 16 位小写十六进制）
+ */
+import { readdirSync, statSync, type Dirent } from 'node:fs'
+import { join } from 'node:path'
+
+/** 日志的物理编码（对齐宿主的 `JsonlCompression`）。 */
+export type LogCompression = 'zstd' | 'none'
+
+/** 处置优先级：`high` = 该会话的当前代是从暂存（TMP）发布出来的。 */
+export type SessionPriority = 'high' | 'normal'
+
+/**
+ * 规范日志名的语法（不含压缩后缀）。
+ *
+ * 与宿主 `session-format/src/filename.ts` 逐字一致：版本 0 不带版本号，
+ * 后续代次必须是小写数字且无前导零；`.v0`、`.v01`、`.V1`、`session.v1.backup.jsonl`
+ * 都不识别为规范代次。
+ */
+const CANONICAL_LOG_BASENAME = /^session(?:\.v([1-9][0-9]*))?\.jsonl$/u
+
+/**
+ * 迁移暂存名的语法（对齐 `generation.ts:725` 的写入名）。
+ *
+ * token 的位数与字符集是宿主内部细节，这里只固定**形状**
+ * `session.migration.<hex>.jsonl[.zstd].tmp`，宿主换 token 长度时本插件不会失明。
+ */
+const MIGRATION_STAGING_NAME = /^session\.migration\.[0-9a-f]+\.jsonl(?:\.zstd)?\.tmp$/u
+
+/** 一份日志产物在磁盘上的事实。 */
+export interface LogArtifact {
+  /** 文件名（不含目录）。 */
+  name: string
+  /** 绝对路径。 */
+  path: string
+  bytes: number
+  /** mtime（epoch ms）。 */
+  mtimeMs: number
+}
+
+/** 一份规范代次产物。 */
+export interface GenerationArtifact extends LogArtifact {
+  /** 该文件承载的格式代次；0 为无版本号的历史代。 */
+  version: number
+  /** 该文件的物理编码。 */
+  compression: LogCompression
+}
+
+/** 一个会话目录的代次事实。 */
+export interface SessionGenerations {
+  /** 目录内全部规范产物，按代次升序（同代次再按 mtime 升序）。 */
+  canonical: GenerationArtifact[]
+  /** 当前代 = 规范产物中代次最高的一份；目录内没有规范产物时为 undefined。 */
+  current?: GenerationArtifact
+  /** 历史代（代次 0）；宿主按契约保留已提交的旧代次，不删不改。 */
+  legacy?: GenerationArtifact
+  /** 迁移暂存残留（发布源）。 */
+  staging: LogArtifact[]
+  /** 只有历史代、尚无更高代次：宿主首次写访问才会发布，冷读要全量内存迁移。 */
+  legacyOnly: boolean
+}
+
+function compressionSuffix(compression: LogCompression): '.zstd' | '' {
+  return compression === 'zstd' ? '.zstd' : ''
+}
+
+/**
+ * 某代次的规范日志文件名。
+ * @param version - 非负安全整数的格式代次。
+ * @param compression - 物理编码（缺省 zstd）。
+ * @returns 该代次在会话目录内的文件名。
+ */
+export function generationLogFilename(version: number, compression: LogCompression = 'zstd'): string {
+  if (!Number.isSafeInteger(version) || version < 0) {
+    throw new Error(`session log generation must be a non-negative safe integer, got ${String(version)}`)
+  }
+  const basename = version === 0 ? 'session.jsonl' : `session.v${version}.jsonl`
+  return `${basename}${compressionSuffix(compression)}`
+}
+
+/**
+ * 把一个规范日志名解析回代次。
+ *
+ * 与宿主 `parseGenerationLogFilename` 同语义：非规范名（临时、大写、前导零、
+ * `.v0`、别的压缩后缀）一律返回 undefined，**不猜**。
+ * @param filename - 会话目录里的一个文件名。
+ * @param compression - 该目录使用的物理编码（缺省 zstd）。
+ * @returns 其格式代次，或名字不构成规范代次时的 undefined。
+ */
+export function parseGenerationLogFilename(filename: string, compression: LogCompression = 'zstd'): number | undefined {
+  const suffix = compressionSuffix(compression)
+  if (!filename.endsWith(suffix)) return undefined
+  const match = CANONICAL_LOG_BASENAME.exec(filename.slice(0, filename.length - suffix.length))
+  if (match === null) return undefined
+  if (match[1] === undefined) return 0
+  const version = Number(match[1])
+  return Number.isSafeInteger(version) ? version : undefined
+}
+
+/**
+ * 两种压缩编码都试一遍，判定该名字是不是某代的规范产物。
+ *
+ * 发现路径不能假设部署里的 `compression` 配置：配置在 profile 侧，插件读不到，
+ * 而日志就在磁盘上。因此按名字本身分类，编码作为结果一并带回。
+ * @param filename - 会话目录里的一个文件名。
+ * @returns 代次与编码，或该名字不是规范代次时的 undefined。
+ */
+export function classifyGenerationFilename(filename: string): { version: number; compression: LogCompression } | undefined {
+  const zstd = parseGenerationLogFilename(filename, 'zstd')
+  if (zstd !== undefined) return { version: zstd, compression: 'zstd' }
+  const none = parseGenerationLogFilename(filename, 'none')
+  if (none !== undefined) return { version: none, compression: 'none' }
+  return undefined
+}
+
+/**
+ * 该文件名是否是迁移暂存（当前代的发布源）。
+ * @param filename - 会话目录里的一个文件名。
+ * @returns 是否形如 `session.migration.<token>.jsonl[.zstd].tmp`。
+ */
+export function isMigrationStagingFilename(filename: string): boolean {
+  return MIGRATION_STAGING_NAME.test(filename)
+}
+
+/**
+ * 读取一个会话目录的代次事实（只读，不碰任何文件内容）。
+ * @param dir - 会话目录的绝对路径。
+ * @returns 规范产物（按代次升序）、当前代、历史代与暂存残留。
+ */
+export function readSessionGenerations(dir: string): SessionGenerations {
+  const canonical: GenerationArtifact[] = []
+  const staging: LogArtifact[] = []
+  let entries: Dirent[]
+  try {
+    entries = readdirSync(dir, { withFileTypes: true })
+  } catch {
+    // 目录在枚举与读取之间消失（宿主正在删会话）：如实返回「没有产物」，
+    // 由调用方决定是否跳过这一步，不在这里抛。
+    return { canonical: [], staging: [], legacyOnly: false }
+  }
+  for (const entry of entries) {
+    if (!entry.isFile()) continue
+    const path = join(dir, entry.name)
+    let bytes: number
+    let mtimeMs: number
+    try {
+      const stat = statSync(path)
+      bytes = stat.size
+      mtimeMs = stat.mtimeMs
+    } catch {
+      continue
+    }
+    const artifact: LogArtifact = { name: entry.name, path, bytes, mtimeMs }
+    const generation = classifyGenerationFilename(entry.name)
+    if (generation !== undefined) {
+      canonical.push({ ...artifact, version: generation.version, compression: generation.compression })
+      continue
+    }
+    if (isMigrationStagingFilename(entry.name)) staging.push(artifact)
+  }
+  canonical.sort((left, right) => left.version - right.version || left.mtimeMs - right.mtimeMs)
+  staging.sort((left, right) => left.mtimeMs - right.mtimeMs)
+  const current = canonical.at(-1)
+  const legacy = canonical.find(artifact => artifact.version === 0)
+  return {
+    canonical,
+    staging,
+    ...(current === undefined ? {} : { current }),
+    ...(legacy === undefined ? {} : { legacy }),
+    legacyOnly: canonical.length > 0 && current?.version === 0,
+  }
+}
+
+/** 目录内全部已识别产物的最新 mtime。 */
+export function latestArtifactMtime(facts: SessionGenerations): number | undefined {
+  const times = [...facts.canonical, ...facts.staging].map(artifact => artifact.mtimeMs)
+  return times.length === 0 ? undefined : Math.max(...times)
+}
+
+/**
+ * 该会话的处置优先级。
+ *
+ * `high` 的判据就是「从 TMP 移出来」本身：当前代次非 0（当前代是经
+ * `session.migration.*.tmp` 暂存发布出来的），或目录内仍有暂存残留。
+ * 代次 0 的历史代是宿主按契约保留的未发布会话，旧发现逻辑读的就是它 —— 这类
+ * 会话既没有发布痕迹、也没有被读错，故为 `normal`。
+ * @param facts - 会话目录的代次事实。
+ * @returns 处置优先级。
+ */
+export function sessionPriority(facts: SessionGenerations): SessionPriority {
+  if (facts.staging.length > 0) return 'high'
+  return (facts.current?.version ?? 0) > 0 ? 'high' : 'normal'
+}

package/src/host/health/repair.ts

@@ -96,6 +96,20 @@ export function prescribe(report: SessionHealthReport, dshHome?: string): string
   const gate = (id: SessionHealthReport['gates'][number]['id']): SessionHealthReport['gates'][number] | undefined =>
     report.gates.find(entry => entry.id === id)
 
+  const generation = gate('generation')
+  if (generation?.level === 'fail' || generation?.level === 'warn') {
+    lines.push(`# 代次异常：${generation.evidence}`)
+    // 处方文本只讲判据，不写死具体代次：当前代由目录实测得出（detail.currentVersion）。
+    // 写死 `v3` 正是本插件此前「版本适配落后」的形态。
+    const currentVersion = generation.detail?.['currentVersion']
+    lines.push(typeof currentVersion === 'number'
+      ? `# 当前代 v${currentVersion}：本插件不改会话日志，暂存残留的发布/隔离需用会话代次工具处理`
+      : '# 目录内只有迁移暂存、还没有规范产物：需先用会话代次工具发布当前代，或重启宿主触发发布')
+    if (report.priority === 'high') {
+      lines.push('# 该会话优先级为 high（当前代由暂存发布而来），建议先处置它')
+    }
+  }
+
   const lossless = gate('lossless-json')
   if (lossless?.level === 'fail') {
     const pkg = lossless.attribution?.package ?? 'unknown'
@@ -132,7 +146,7 @@ export function prescribe(report: SessionHealthReport, dshHome?: string): string
     // 「无从判定」不是「全绿」：把 skipped 的门如实列出，避免用户以为都检查过了。
     const unjudged = report.gates.filter(entry => entry.level === 'skipped')
     lines.push(unjudged.length === 0
-      ? '# 四门全绿：无需处置'
+      ? '# 全部检查通过：无需处置'
       : `# 无可处置项（${unjudged.length} 门无从判定，非异常）：${unjudged.map(entry => entry.id).join(' / ')}`)
   }
   return lines
@@ -145,7 +159,7 @@ export function describeHome(dshHome?: string): string {
 
 /** 处置结果的定性分类。 */
 export type RepairVerdict =
-  /** 四门全绿，没有要做的事。 */
+  /** 全部检查通过，没有要做的事。 */
   | 'nothing-to-do'
   /** 处置生效且异常已消除。 */
   | 'repaired'
@@ -165,6 +179,15 @@ export interface RepairAssessment {
   residual: { id: string; level: GateLevel }[]
 }
 
+/** 残留门的可读归因：区分「本插件有能力处置」与「按红线只能等 / 交给别的工具」。 */
+function residualNote(residual: { id: string }[]): string {
+  if (residual.some(entry => entry.id === 'generation')) {
+    return '其中 generation 来自会话目录的代次产物（暂存残留或当前代尚未发布），' +
+      '本插件不改会话日志，需用会话代次工具处置。'
+  }
+  return '这类异常来自会话日志或宿主运行态，本插件不改会话日志，请等待宿主结算后重新体检。'
+}
+
 /**
  * 判定一次处置的结果，并给出人读说明。
  *
@@ -187,7 +210,7 @@ export function assessRepair(input: {
   const residualIds = residual.map(entry => entry.id).join(' / ')
 
   if (before.level === 'ok') {
-    return { verdict: 'nothing-to-do', explanation: '四门全绿，无需处置', residual: [] }
+    return { verdict: 'nothing-to-do', explanation: '全部检查通过，无需处置', residual: [] }
   }
 
   if (repair.ok) {
@@ -195,8 +218,7 @@ export function assessRepair(input: {
       ? { verdict: 'repaired', explanation: '处置生效：已隔离投影缓存记录，体检结果已恢复', residual: [] }
       : {
           verdict: 'repaired-with-residual',
-          explanation: `已隔离投影缓存记录；但仍有与该缓存无关的异常：${residualIds}。` +
-            '这类异常来自会话日志或宿主运行态，本插件不改会话日志，请等待宿主结算后重新体检。',
+          explanation: `已隔离投影缓存记录；但仍有与该缓存无关的异常：${residualIds}。${residualNote(residual)}`,
           residual,
         }
   }
@@ -208,8 +230,7 @@ export function assessRepair(input: {
       verdict: 'not-applicable',
       explanation: residualIds === ''
         ? '当前异常无可逆处置项'
-        : `当前异常无可逆处置项（投影缓存无可隔离记录）；异常来自 ${residualIds}，` +
-          '本插件不改会话日志，请等待宿主结算后重新体检。',
+        : `当前异常无可逆处置项（投影缓存无可隔离记录）；异常来自 ${residualIds}，${residualNote(residual)}`,
       residual,
     }
   }