dsh-log-contract 0.3.10 → 0.3.12

package/lib/prewrite.js

@@ -17,7 +17,9 @@
  * 所有判定复用 `lib/checks.js`（与离线体检同一套逻辑），
  * 保证"体检看到的问题 = 写入前拦下的问题"。
  */
-import { envelopeViolations, engineViolations, finalFold, isSafeInt, nullTurnStepViolations, pluginViolations, replaySurface, stepKeyViolations, tokenMeterViolations, turnEndReasonViolations, violation } from './checks.js';
+import { envelopeViolations, engineViolations, finalFold, isSafeInt, nullTurnStepViolations, pluginViolations, replaySurface, stepKeyViolations, tokenMeterViolations, turnEndReasonViolations, violation, wireViolations } from './checks.js';
+import { resolveFormatVersion } from './vocab.js';
+import { normalizeEventSeqRanges } from './compat.js';
 
 /** retrace 类 marker：data.editor 存在（assistant/message replace，turn/step=null）。 */
 function isKnownMarkerCandidate(event) {
@@ -32,17 +34,28 @@ function normalizeCandidate(candidate, nextSeq) {
 /**
  * 基于当前日志事件列表建立写前校验器。
  *
- * @param {{ events: Array<object>, baseSeq?: number }} input 当前日志的已解码事件
- *   （按日志顺序；无 seq 字段的事件按位置补 seq，用于窗口校验）。
+ * **格式版本（C2）**：`formatVersion` > `header.version` > 事件形状推断 > 0，在**本次
+ * `createPreWriter` 调用内固定**并显式传给每条按版本择路的判定。**不再读写模块级全局**
+ * `fileVersion`——旧实现下同一进程"先 validate(v3) 再 prewrite(v0)"会把同一份合法 v0 输入
+ * 的结论翻成 S4+S8（独立审核复现 B）。下游 `dsh-retrace` 正是只传 `events` 直接调用
+ * （`lib/prewrite-guard.js:166`），所以缺省时必须能自行推断，不能把 v3 输入按 0 处理
+ * （否则首次调用即 10 条 E3/S2/S8 误报，复现 C）。
+ *
+ * @param {{ events: Array<object>, baseSeq?: number, formatVersion?: number, header?: object|null }} input
+ *   当前日志的已解码事件（按日志顺序；无 seq 字段的事件按位置补 seq，用于窗口校验）。
+ *   `formatVersion`/`header` 二者其一优先决定被检文件的格式版本。
  * @returns {{
- *   events: Array, nextSeq: number,
+ *   events: Array, nextSeq: number, formatVersion: number,
  *   validateAppend(candidate, opts?): { ok, violations, stateAfter },
  *   validateEdit(editedEvents, opts?): { ok, violations, stateAfter },
  * }}
  */
 export function createPreWriter(input = {}) {
-  const { baseSeq = 0 } = input;
-  let events = [...input.events];
+  const { baseSeq = 0, header = null } = input;
+  // C1：v3 storage-form 区间编码 → 内存稠密序列（与 log-reader 同一归一，覆盖"直接传 events"入口）
+  let events = (input.events ?? []).map(normalizeEventSeqRanges);
+  // C2：版本显式解析并固定在本次调用内（不读模块级全局）
+  const formatVersion = resolveFormatVersion({ formatVersion: input.formatVersion, header, events });
   // 窗口校验支持"无 seq 的原始事件列表"：按位置补齐 seq 与 time。
   let nextSeq = baseSeq;
   events = events.map((e) => {
@@ -71,18 +84,21 @@ export function createPreWriter(input = {}) {
     // E1/E3/E4/E5/E6 + M1 + P1/P2 —— 逐事件
     for (const event of candidateEvents) {
       const loc = { seq: event.seq, lineNo: null, eventType: event.type };
-      violations.push(...envelopeViolations(event, loc));
+      violations.push(...envelopeViolations(event, loc, formatVersion));
       violations.push(...engineViolations(event, loc));
       violations.push(...pluginViolations(event, loc));
     }
     // S1–S7 —— 与官方同语义的增量重放（含拟写事件）
-    const replay = replaySurface(candidateEvents.map((event) => ({ event })));
+    const replay = replaySurface(candidateEvents.map((event) => ({ event })), formatVersion);
     violations.push(...replay.violations);
-    // S8 —— 官方 foldSurface 终验
-    const folded = finalFold(candidateEvents);
+    // S8 —— fold 终验（按当前文件版本选：v3 官方 foldSurface / v0–v2 本地 legacyFoldSurface）
+    const folded = finalFold(candidateEvents, formatVersion);
     if (folded.error) {
-      violations.push(violation('S8', { lineNo: null }, `官方 foldSurface 重放失败：${folded.error.message} —— 会话加载会被拒（SessionPersistenceCorruptionError）`));
+      violations.push(violation('S8', { lineNo: null }, `foldSurface 重放失败（按文件版本选：v3 官方 / v0–v2 本地等价）：${folded.error.message} —— 会话加载会被拒（SessionPersistenceCorruptionError）`));
     }
+    // W1/W2 —— wire 流配对（2026-09-09 V3 验证补：离线 check 有、写前原漏——悬空 tool
+    // 编辑必须写前拦，否则违约写入先落盘、体检才报 = 晚一步）
+    violations.push(...wireViolations(candidateEvents.map((event) => ({ event })), formatVersion));
     // T1 —— token-meter 配对（事故根因 3 固化）。写前校验只判定**拟写事件自身**
     // 的 step 配对：retrace 的 turn-null 编辑/撤回 marker 必然命中（空
     // assistant/message replace 无 step 可配对），但编辑功能必须可用——白名单
@@ -129,6 +145,7 @@ export function createPreWriter(input = {}) {
 
   return {
     events,
+    formatVersion,
     get nextSeq() {
       return nextSeq;
     },
@@ -147,7 +164,7 @@ export function createPreWriter(input = {}) {
           nextSeq,
         };
       }
-      const normalized = normalizeCandidate(candidate, nextSeq);
+      const normalized = normalizeEventSeqRanges(normalizeCandidate(candidate, nextSeq));
       const after = [...events, normalized];
       const result = runChecks(after, nextSeq);      result.stateAfter = {
         events: after,
@@ -172,9 +189,10 @@ export function createPreWriter(input = {}) {
           nextSeq,
         };
       }
-      const result = runChecks(editedEvents, undefined);
+      const edited = editedEvents.map(normalizeEventSeqRanges);
+      const result = runChecks(edited, undefined);
       result.stateAfter = {
-        events: editedEvents,
+        events: edited,
         nextSeq: result.nextSeq,
         surfaceNodes: result.surface?.nodes ?? [],
       };
@@ -189,5 +207,5 @@ export function createPreWriter(input = {}) {
  */
 export function preWriterFromLog(log) {
   const events = (log.events ?? []).map((e) => e.event);
-  return createPreWriter({ events });
+  return createPreWriter({ events, header: log?.header ?? null });
 }

package/lib/validate.js

@@ -3,18 +3,24 @@
  *
  * 离线体检引擎：对 `loadSessionLog` 的结果逐条跑契约规则，产出违规报告。
  *
- * 判定哲学（复盘事故 §四-1）：**持久化层以官方 `foldSurface` 不抛为通过**，
+ * 判定哲学（复盘事故 §四-1）：**持久化层以 fold 不抛为通过**，
  * 但为定位问题，先用与官方同语义的增量重放做逐事件归因（S1–S7），
- * 再跑官方 foldSurface 作终验（S8）——两套都绿才算过。
+ * 再跑 fold 终验（S8）——两套都绿才算过。
+ * 终验按**被检文件 header.version** 选：v3 → 运行时官方 `foldSurface`；
+ * v0/v1/v2 → 本地等价实现 `legacyFoldSurface`（0.1.5 的 foldSurface 是 v3 语义，对旧格式会误报）。
  */
 import { ruleById } from './contracts.js';
+import { normalizeEventSeqRanges } from './compat.js';
+import { HOST_MAX_FILE_VERSION, MIGRATION_TARGET_VERSION, hostCapability, isAssessableFileVersion } from './vocab.js';
 import {
   CHUNK_ROW_TYPES,
   envelopeViolations,
+  ignorableTypeViolations,
   engineViolations,
   finalFold,
   inboxReplayViolations,
   isSafeInt,
+  migrationPrecheckViolations,
   nullTurnStepViolations,
   physicalOrderViolations,
   pluginViolations,
@@ -29,6 +35,9 @@ import {
   wireViolations,
 } from './checks.js';
 
+/** 宿主能力闸触发时**跳过**的规则（v3/被检版本语义相关）——报告里显式列出，避免"静默通过"。 */
+const VERSION_DEPENDENT_RULES = ['E3', 'E7', 'S1', 'S2', 'S3', 'S4', 'S5', 'S6', 'S7', 'S8', 'W1', 'W2', 'T1', 'T2', 'T3', 'T4', 'T5', 'G1', 'G2'];
+
 /**
  * 对会话日志执行全量离线体检。
  *
@@ -44,7 +53,23 @@ import {
 export function validateSessionLog(log, opts = {}) {
   const { baseSeq = 0 } = opts;
   const violations = [];
-  const { header, headerLine, rows, events, frameInfo } = log;
+  const { header, headerLine, rows, frameInfo } = log;
+  // C1 防御（多入口一致）：即使调用方手搓 log 对象、未经 `loadSessionLog`，也在体检入口
+  // 归一一次 v3 区间编码。正常路径（loadSessionLog 已展开）下这是幂等的恒等映射。
+  const events = (log.events ?? []).map((e) => ({ ...e, event: normalizeEventSeqRanges(e.event) }));
+  // 1.3 第二半：词表/折叠路径按**被检文件自身版本**选择（不按运行时）。
+  // C2：版本是**本次调用的局部量**，显式传给每条按版本择路的判定——不再写模块级全局
+  // （旧实现 `setFileFormatVersion()` 会被同进程后调用的 prewrite 读到，造成结论翻转）。
+  const formatVersion = Number.isSafeInteger(header?.version) && header.version >= 0 ? header.version : 0;
+
+  // ── 宿主能力闸（S2·安全）──────────────────────────────────────────────────
+  // 被检文件版本 > 本宿主支持的最大文件版本 ⇒ 本宿主没有该版本的词表/折叠语义。继续按
+  // 本宿主语义判定会产出**假阳性**（独立复核实测：rc.7 上同一真实 v3 文件 →
+  // `S8×1 + E3×40 / verdict=broken / loadable:false`），危险是用户以为日志坏了去跑
+  // `fix --apply`。改为：只跑与版本无关的结构检查 + 显式"不可在本宿主评估"档。
+  if (!isAssessableFileVersion(formatVersion)) {
+    return unassessableResult({ header, headerLine, rows, events, frameInfo, baseSeq, formatVersion });
+  }
 
   // ── Z · 帧结构 ─────────────────────────────────────────────────────────
   if (frameInfo?.torn) {
@@ -61,8 +86,8 @@ export function validateSessionLog(log, opts = {}) {
     if (header.type !== 'session') {
       violations.push(violation('H1', { lineNo: headerLine }, `首行 type 必须为 "session"（实际 ${String(header.type)}）`));
     }
-    if (header.version !== 0) {
-      violations.push(violation('H2', { lineNo: headerLine }, `header.version 必须为 0（实际 ${String(header.version)}）——格式版本演进无迁移机制（F1）`));
+    if (![0, 1, 2, 3].includes(header.version)) {
+      violations.push(violation('H2', { lineNo: headerLine }, `header.version 未知（实际 ${String(header.version)}）——已知 0/1/2/3；未知版本按 0 处理会误判，请先确认格式`));
     }
     if (typeof header.id !== 'string' || header.id === '') {
       violations.push(violation('H2', { lineNo: headerLine }, 'header.id 必须为非空字符串'));
@@ -78,6 +103,13 @@ export function validateSessionLog(log, opts = {}) {
     }
   }
 
+  // ── Z3 · 空文件体检（2026-09-09 反向挑刺 T3 增量）──────────────────────────
+  // 空态无覆盖:36 条规则全来自"有内容"事故,空会话文件应显式报(不管 DSH 编排层怎么处理)。
+  // 有 header 但零事件 = 异常空会话(warning,不破坏 ok);连 header 都没有 → H1 已报。
+  if (header !== null && events.length === 0) {
+    violations.push(violation('Z3', { lineNo: headerLine }, `会话文件无任何事件（仅 header）——异常空会话（新建即空或写入未落盘）；空态不在任何有内容规则的覆盖下，显式报出供人判断`));
+  }
+
   // ── R · 存储行 ─────────────────────────────────────────────────────────
   for (const row of rows) {
     if (row.error && row.value === null) {
@@ -92,7 +124,7 @@ export function validateSessionLog(log, opts = {}) {
   let seqBroken = false;
   for (const { event, lineNo } of events) {
     const loc = { seq: event.seq, lineNo, eventType: event.type };
-    violations.push(...envelopeViolations(event, loc));
+    violations.push(...envelopeViolations(event, loc, formatVersion));
     if (typeof event.seq === 'number' && Number.isSafeInteger(event.seq) && event.seq >= 0) {
       if (event.seq !== expectedSeq) {
         const kind = event.seq < expectedSeq ? '倒退（backward）' : '缺口（gap）';
@@ -109,10 +141,10 @@ export function validateSessionLog(log, opts = {}) {
   violations.push(...physicalOrderViolations(rows));
 
   // ── S · surface 增量重放（归因）+ 官方 foldSurface 终验 ────────────────
-  const replay = replaySurface(events);
+  const replay = replaySurface(events, formatVersion);
   violations.push(...replay.violations);
 
-  const folded = finalFold(events.map((e) => e.event));
+  const folded = finalFold(events.map((e) => e.event), formatVersion);
 
   // ── T · token meter 配对（事故根因 3 + 2026-08-30 两类刷屏）──
   violations.push(...tokenMeterViolations(events));
@@ -124,6 +156,9 @@ export function validateSessionLog(log, opts = {}) {
   violations.push(...nullTurnStepViolations(events));
   violations.push(...turnEndReasonViolations(events));
 
+  // ── E7 · ignorable 未知 type 合法性（反向挑刺 T2）────────────────────
+  violations.push(...ignorableTypeViolations(events, formatVersion));
+
   // ── I1 · inbox seed 相对重放（fork 边界孤儿；交接书 L1）──────────────
   violations.push(...inboxReplayViolations(events, header));
 
@@ -131,11 +166,11 @@ export function validateSessionLog(log, opts = {}) {
   violations.push(...toolPairingViolations(events));
   violations.push(...toolResultStructureViolations(events));
   if (folded.error) {
-    violations.push(violation('S8', { lineNo: null }, `官方 foldSurface 重放失败：${folded.error.message} —— 会话加载会被拒（SessionPersistenceCorruptionError）`));
+    violations.push(violation('S8', { lineNo: null }, `foldSurface 重放失败（按文件版本选：v3 官方 / v0–v2 本地等价）：${folded.error.message} —— 会话加载会被拒（SessionPersistenceCorruptionError）`));
   }
 
   // ── W · wire 消息流（严格端点拒绝的悬空 tool / 顺序破坏）──────────────
-  violations.push(...wireViolations(events));
+  violations.push(...wireViolations(events, formatVersion));
 
   // ── M / P ──────────────────────────────────────────────────────────────
   for (const { event, lineNo } of events) {
@@ -149,6 +184,11 @@ export function validateSessionLog(log, opts = {}) {
     violations.push(violation('C1', { lineNo: null }, 'seq 缺口/倒退是多写入者（≥2 个 Host 进程共享同一 session 目录）并发写的典型后果；离线体检无法观测竞态本身，但此痕迹需人工核查（N6）'));
   }
 
+  // ── G · 迁移预检（**独立维度**：官方升级路径会不会拒；不进 ok/verdict）──────
+  // 官方把 v0/v1/v2 升到当前格式时的规则集比本工具的"读取/折叠"规则集更严：本工具判
+  // ok/compactable **不代表**官方迁移会接受。这里只加 migration 层 warning（见 contracts G1/G2）。
+  violations.push(...migrationPrecheckViolations(events, formatVersion));
+
   // ── 汇总 ───────────────────────────────────────────────────────────────
   violations.sort((a, b) => (a.seq ?? -1) - (b.seq ?? -1) || (a.lineNo ?? -1) - (b.lineNo ?? -1));
   const bySeverity = { error: 0, warning: 0, info: 0 };
@@ -167,14 +207,193 @@ export function validateSessionLog(log, opts = {}) {
     frames: frameInfo?.frames ?? 0,
     compressedBytes: frameInfo?.compressedBytes ?? 0,
     plaintextBytes: frameInfo?.plaintextBytes ?? 0,
+    fileVersion: formatVersion,
+    hostMaxFileVersion: HOST_MAX_FILE_VERSION,
+    assessable: true,
   };
 
-  return {
+  const result = {
     ok: bySeverity.error === 0,
+    assessable: true,
     violations,
     summary,
     surface: folded.surface ?? { nodes: replay.nodes, replacements: [] },
   };
+  result.migration = migrationVerdict(result);
+  result.assessmentScope = result.migration.assessmentScope;
+  return result;
+}
+
+/**
+ * 宿主能力闸的结果（S2）：被检文件版本 > 本宿主支持的最大版本。
+ *
+ * 只跑**与版本无关**的结构检查（Z 帧 / H header / R 行 / E1·E2·E4·E5·E6 信封不含 E3 词表 /
+ * S9 物理序 / M·P / P3·P4 / I1），其余（S1–S8/W/T/E3/E7/G）显式跳过并在 `notAssessable.skippedRules`
+ * 里列出。**ok 固定 false**（不认证），但 `structuralOk` 单独给出结构层结论——
+ * 语义是"本宿主评估不了"，不是"日志坏了"。
+ */
+function unassessableResult({ header, headerLine, rows, events, frameInfo, baseSeq, formatVersion }) {
+  const violations = [];
+  const cap = hostCapability();
+  const notAssessable = {
+    fileVersion: formatVersion,
+    hostMaxFileVersion: HOST_MAX_FILE_VERSION,
+    hostPackage: cap.hostPackage,
+    skippedRules: VERSION_DEPENDENT_RULES,
+    reason: `被检文件 version=${formatVersion} 高于本宿主 @deepseek-ai/dsh-session@${cap.hostPackage} 支持的最大文件版本 ${HOST_MAX_FILE_VERSION}`
+      + `（本宿主只有 ≤${HOST_MAX_FILE_VERSION} 的词表/折叠语义）⇒ 按本宿主语义判定会产出假阳性（如 S8/E3）。`
+      + '这不表示日志损坏；请用 0.1.5+ 宿主评估。',
+  };
+
+  // ── Z · 帧结构（版本无关）──
+  if (frameInfo?.torn) violations.push(violation('Z1', { lineNo: null }, `zstd 尾帧撕裂：可能是写入中的 in-flight 帧或文件被截断（帧数 ${frameInfo.frames}）`));
+  if (frameInfo?.error) violations.push(violation('Z2', { lineNo: null }, frameInfo.error));
+
+  // ── H · header（版本无关）──
+  if (header === null) {
+    violations.push(violation('H1', { lineNo: headerLine }, '首行不是合法 JSON —— 整个会话不可读'));
+  } else {
+    if (header.type !== 'session') violations.push(violation('H1', { lineNo: headerLine }, `首行 type 必须为 "session"（实际 ${String(header.type)}）`));
+    if (![0, 1, 2, 3].includes(header.version)) violations.push(violation('H2', { lineNo: headerLine }, `header.version 未知（实际 ${String(header.version)}）`));
+    if (typeof header.id !== 'string' || header.id === '') violations.push(violation('H2', { lineNo: headerLine }, 'header.id 必须为非空字符串'));
+    if (!Number.isSafeInteger(header.createdAt) || header.createdAt < 0) violations.push(violation('H2', { lineNo: headerLine }, 'header.createdAt 必须为非负安全整数'));
+    if (header.cwd !== undefined && (typeof header.cwd !== 'string' || !header.cwd.startsWith('/'))) violations.push(violation('H2', { lineNo: headerLine }, 'header.cwd 若存在必须为绝对路径'));
+    if (header.origin !== undefined && header.origin !== 'subagent') violations.push(violation('H2', { lineNo: headerLine }, `header.origin 只能为 "subagent"（实际 ${String(header.origin)}）`));
+  }
+  if (header !== null && events.length === 0) violations.push(violation('Z3', { lineNo: headerLine }, '会话文件无任何事件（仅 header）——异常空会话'));
+
+  // ── R · 存储行（版本无关）──
+  for (const row of rows) {
+    if (row.error && row.value === null) violations.push(violation('R1', { lineNo: row.lineNo }, '该行不是合法 JSON（损坏行）'));
+    else if (row.error && CHUNK_ROW_TYPES.has(row.value?.type)) violations.push(violation('R2', { lineNo: row.lineNo }, `chunk 行 "${row.value.type}" 损坏：${row.error.message}`));
+  }
+
+  // ── E · 信封 + seq（E3 词表判定**跳过**：词表随被检版本而变，本宿主没有该版本词表）──
+  let expectedSeq = baseSeq;
+  let seqBroken = false;
+  for (const { event, lineNo } of events) {
+    const loc = { seq: event.seq, lineNo, eventType: event.type };
+    violations.push(...envelopeViolations(event, loc, formatVersion).filter((v) => v.id !== 'E3'));
+    if (typeof event.seq === 'number' && Number.isSafeInteger(event.seq) && event.seq >= 0) {
+      if (event.seq !== expectedSeq) {
+        violations.push(violation('E2', loc, `seq ${event.seq} 不连续：${event.seq < expectedSeq ? '倒退（backward）' : '缺口（gap）'}，期望 ${expectedSeq}`));
+        seqBroken = true;
+        expectedSeq = event.seq + 1;
+      } else expectedSeq = event.seq + 1;
+    }
+  }
+  violations.push(...physicalOrderViolations(rows));
+  violations.push(...inboxReplayViolations(events, header));
+  violations.push(...toolPairingViolations(events));
+  violations.push(...toolResultStructureViolations(events));
+  for (const { event, lineNo } of events) {
+    const loc = { seq: event.seq, lineNo, eventType: event.type };
+    violations.push(...engineViolations(event, loc));
+    violations.push(...pluginViolations(event, loc));
+  }
+  if (seqBroken) violations.push(violation('C1', { lineNo: null }, 'seq 缺口/倒退是多写入者并发写的典型后果（N6）'));
+
+  violations.sort((a, b) => (a.seq ?? -1) - (b.seq ?? -1) || (a.lineNo ?? -1) - (b.lineNo ?? -1));
+  const bySeverity = { error: 0, warning: 0, info: 0 };
+  const byLayer = {};
+  for (const v of violations) {
+    bySeverity[v.severity] = (bySeverity[v.severity] ?? 0) + 1;
+    byLayer[v.layer] = (byLayer[v.layer] ?? 0) + 1;
+  }
+  const result = {
+    ok: false,                 // 不认证（**不是**"broken"——语义见 notAssessable.reason）
+    assessable: false,
+    structuralOk: bySeverity.error === 0,
+    notAssessable,
+    violations,
+    summary: {
+      total: violations.length,
+      bySeverity,
+      byLayer,
+      events: events.length,
+      surfaceNodes: null,
+      replaceGeneration: null,
+      frames: frameInfo?.frames ?? 0,
+      compressedBytes: frameInfo?.compressedBytes ?? 0,
+      plaintextBytes: frameInfo?.plaintextBytes ?? 0,
+      fileVersion: formatVersion,
+      hostMaxFileVersion: HOST_MAX_FILE_VERSION,
+      assessable: false,
+    },
+    surface: null,
+  };
+  result.migration = migrationVerdict(result);
+  result.assessmentScope = result.migration.assessmentScope;
+  return result;
+}
+
+/**
+ * 迁移预检结论（S1）——**独立维度**：官方把 v0/v1/v2 升到当前格式会不会拒。
+ *
+ * 与 `ok` / `loadable` / `resumable` / `compactable` **并列且互不蕴含**：
+ * 本工具判 ok **不代表**官方迁移会接受（反之亦然）。只统计 `layer === 'migration'` 的违规
+ * （G1/G2），并**显式声明覆盖边界**——未覆盖的官方迁移规则不等于通过。
+ *
+ * @param {object} result `validateSessionLog()` 的返回值
+ */
+export function migrationVerdict(result) {
+  const violations = result?.violations ?? [];
+  const fileVersion = result?.summary?.fileVersion ?? result?.notAssessable?.fileVersion ?? null;
+  const coverage = {
+    implemented: [
+      'G1  v0 源：subagent/descriptor.data.version !== 3',
+      'G2  v0 源：事件类型不在官方 v0 dispositions 内（含 ignorable:true）',
+    ],
+    uncovered: [
+      // 2026-09-14 第四轮（最终复核实测）：官方 v1→v2 的 turn/start 规则有**两个方向**——
+      // "does not close the prior turn"（未闭合）与 "does not open expected turn"（未打开预期轮）。
+      // 残余 27 例里有 7 例是后者；类文本原先只写"未闭合" ⇒ 标注与事实不符。此处扩类。
+      'turn/start 未闭合前一轮 / 未打开预期轮（官方：does not close the prior turn / does not open expected turn）',
+      'assistant/attempt 配对/闭合（migration refuses the transformed artifact）',
+      'session/title messageSeqs 越界',
+      'Session inheritedEventCut / 继承切点',
+      'stored log corrupt（SessionFormatError）',
+      'v0→v1 对其余事件的形状拒绝',
+    ],
+    note: '未覆盖 ≠ 通过：本维度只对 implemented 两条负责。官方判据版本：@deepseek-ai/dsh-session-format-v0-to-v1@0.1.5-rc.2',
+  };
+  if (result?.assessable === false) {
+    return { assessable: false, applies: null, ready: null, fileVersion, blocked: [], coverage, assessmentScope: 'none', reason: result?.notAssessable?.reason ?? null };
+  }
+  const blocked = violations.filter((v) => v.layer === 'migration');
+  if (fileVersion !== null && fileVersion === MIGRATION_TARGET_VERSION) {
+    return { assessable: true, applies: false, ready: null, fileVersion, targetFileVersion: MIGRATION_TARGET_VERSION, blocked, coverage, assessmentScope: 'full', reason: `被检文件已是当前官方格式（version=${fileVersion}），无需迁移` };
+  }
+  const applies = fileVersion !== null && fileVersion < MIGRATION_TARGET_VERSION;
+  return {
+    assessable: true,
+    applies,
+    ready: applies ? blocked.length === 0 : null,
+    fileVersion,
+    targetFileVersion: MIGRATION_TARGET_VERSION,
+    hostMaxFileVersion: HOST_MAX_FILE_VERSION,
+    blocked,
+    coverage,
+    // 2026-09-14 第四轮（最终复核）：待迁移文件（applies=true）**只**被 2 条 G 规则覆盖，
+    // 另有 6 类官方迁移规则未覆盖 ⇒ 评估范围只能是 "partial"。工具无法逐文件知道
+    // 本文件是否命中未覆盖类（那要先把 6 类实现出来或跑官方迁移），但它**知道**这件事。
+    assessmentScope: applies ? 'partial' : 'full',
+  };
+}
+
+/**
+ * 评估范围（S1 收窄后的机器可判字段）。
+ * - `'partial'`：被检文件需要迁移（`migration.applies === true`）⇒ 迁移维度只覆盖 2 条规则，
+ *   另有 6 类未覆盖；`ok`/`loadable`/`compactable` **不构成**"官方升级会接受"。
+ * - `'full'`：被检文件已是当前官方格式（无需迁移）⇒ 迁移维度不适用，结构维度为全集。
+ * - `'none'`：本宿主能力不足以评估该文件版本（S2 闸）⇒ 不给任何档位结论。
+ * @param {object} result `validateSessionLog()` 的返回值
+ * @returns {'full'|'partial'|'none'}
+ */
+export function assessmentScope(result) {
+  return result?.migration?.assessmentScope
+    ?? result?.assessmentScope
+    ?? migrationVerdict(result).assessmentScope;
 }
 
 /**
@@ -191,13 +410,30 @@ export function validateSessionLog(log, opts = {}) {
  *
  * @param {{ok: boolean, violations: Array, summary: object}} result validateSessionLog 的返回值
  * @returns {{
- *   verdict: 'loadable' | 'resumable' | 'compactable' | 'broken',
+ *   verdict: 'loadable' | 'resumable' | 'compactable' | 'broken' | 'not-assessable',
+ *   assessable: boolean,
  *   loadable: boolean, resumable: boolean, compactable: boolean,
+ *   migration: object,
  *   blocking: { loadable: Array, resumable: Array, compactable: Array },
  * }}
  */
 export function resumeVerdict(result) {
   const { ok, violations = [] } = result;
+  // 宿主能力闸（S2）：本宿主评估不了 ⇒ 新档位 `not-assessable`（**不是** broken）。
+  // 三档 loadable/resumable/compactable 一律 false（不认证），原因在 notAssessable.reason。
+  if (result?.assessable === false) {
+    return {
+      verdict: 'not-assessable',
+      assessable: false,
+      loadable: false,
+      resumable: false,
+      compactable: false,
+      notAssessable: result.notAssessable ?? null,
+      migration: result.migration ?? migrationVerdict(result),
+      blocking: { loadable: [], resumable: [], compactable: [] },
+      violationsByTier: { structural: [], inbox: [], tokenMeter: [] },
+    };
+  }
   // 三档各自的「阻断规则集」——按任务书 §L3 档位定义：
   //   可加载：结构层（PERSISTENCE/FRAMING）+ 引擎层非 I1/T1/T2/T3/T4 的 error；
   //   可继续：+ I1（inbox 重放）；
@@ -230,9 +466,11 @@ export function resumeVerdict(result) {
 
   return {
     verdict,
+    assessable: true,
     loadable,
     resumable,
     compactable,
+    migration: result.migration ?? migrationVerdict(result),
     blocking: {
       loadable: [...new Set(loadableBlockers)],
       resumable: resumableBlockers,