dsh-config-manager 0.1.78 → 0.1.79

package/src/foreign/claude-plugins.test.ts

@@ -0,0 +1,234 @@
+/**
+ * Claude Code **插件读盘层**的回归护栏（2026-10-18）。
+ *
+ * 夹具形态取自本机真实布局（known_marketplaces.json / marketplace.json / plugins|external_plugins /
+ * .claude-plugin/plugin.json / skills / commands / agents / hooks / .mcp.json），**绝不含真凭据**：
+ * 假 token 只放在两个「绝不该被读进返回值」的地方（hooks 代码内容、仓库 URL 的 userinfo）。
+ */
+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 { readClaudePlugins } from './read-claude-plugins.ts';
+import type { ClaudePluginReadResult } from './read-claude-plugins.ts';
+import type { ClaudePluginInput } from './types.ts';
+
+const NL = String.fromCharCode(10);
+const SKILL_MD = ['---', 'name: demo', 'description: fixture skill', '---', '', '# body', ''].join(NL);
+/** 假凭据：只用于「绝不泄露」断言（hooks 内容与 repo userinfo） */
+const FAKE_TOKEN = 'sk-ant-FAKE-0123456789abcdef';
+
+async function withClaudeDir(fn: (claudeDir: string) => Promise<void>): Promise<void> {
+  const claudeDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dcm-claude-plugins-'));
+  try {
+    await fn(claudeDir);
+  } finally {
+    await fs.rm(claudeDir, { recursive: true, force: true });
+  }
+}
+
+async function write(file: string, text: string): Promise<void> {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, text);
+}
+
+function pluginOf(result: ClaudePluginReadResult, name: string): ClaudePluginInput | undefined {
+  return result.plugins.find((plugin) => plugin.name === name);
+}
+
+/** 真机布局夹具：两个市场（其中一个 repo 带 userinfo）、启用/未启用/缺目录三种插件 */
+async function buildFixture(claudeDir: string): Promise<{ demoDir: string; extDir: string }> {
+  const pluginsDir = path.join(claudeDir, 'plugins');
+  const marketDir = path.join(pluginsDir, 'marketplaces', 'demo-market');
+  await write(path.join(pluginsDir, 'known_marketplaces.json'), JSON.stringify({
+    'token-market': {
+      source: { source: 'git', url: 'https://user:' + FAKE_TOKEN + '@github.com/acme/secret-plugins.git' },
+      lastUpdated: '2026-10-01T00:00:00Z',
+    },
+    'demo-market': {
+      source: { source: 'github', repo: 'acme/claude-plugins' },
+      installLocation: marketDir,
+      lastUpdated: '2026-10-02T00:00:00Z',
+    },
+  }));
+  await write(path.join(marketDir, '.claude-plugin', 'marketplace.json'), JSON.stringify({
+    name: 'demo-market',
+    description: 'fixture marketplace',
+    owner: { name: 'acme' },
+    plugins: [{ name: 'demo', description: 'demo plugin', author: 'acme', category: 'dev', source: { source: 'github', repo: 'acme/demo', ref: 'main' } }],
+  }));
+
+  const demoDir = path.join(marketDir, 'plugins', 'demo');
+  await write(path.join(demoDir, '.claude-plugin', 'plugin.json'), JSON.stringify({ name: 'demo', version: '1.2.3', description: 'demo plugin' }));
+  await write(path.join(demoDir, 'skills', 'hello', 'SKILL.md'), SKILL_MD);
+  await write(path.join(demoDir, 'commands', 'one.md'), 'cmd one');
+  await write(path.join(demoDir, 'commands', 'nested', 'two.md'), 'cmd two');
+  await write(path.join(demoDir, 'agents', 'reviewer.md'), 'agent body');
+  await write(path.join(demoDir, 'hooks', 'hook.js'), 'console.log(' + JSON.stringify(FAKE_TOKEN) + ')');
+  await write(path.join(demoDir, 'hooks.json'), JSON.stringify({ hooks: {} }));
+  await write(path.join(demoDir, '.mcp.json'), JSON.stringify({ 'demo-server': { type: 'http', url: 'https://mcp.example.com' } }));
+
+  const extDir = path.join(marketDir, 'external_plugins', 'ext');
+  await write(path.join(extDir, '.claude-plugin', 'plugin.json'), JSON.stringify({ name: 'ext' }));
+  await write(path.join(extDir, 'skills', 'ext-skill', 'SKILL.md'), SKILL_MD);
+
+  /* 未启用插件：安装在、但值不是真值 → 绝不产出 */
+  await write(path.join(marketDir, 'plugins', 'off', '.claude-plugin', 'plugin.json'), JSON.stringify({ name: 'off' }));
+
+  return { demoDir, extDir };
+}
+
+const ENABLED_BOTH = {
+  enabledPlugins: {
+    'demo@demo-market': true,
+    'ext@demo-market': true,
+    'off@demo-market': false,
+    'ghost@demo-market': true,
+  },
+};
+
+test('市场与启用插件：名字/repo 正确、userinfo 被剥离、组件与计数都对得上', async () => {
+  await withClaudeDir(async (claudeDir) => {
+    await buildFixture(claudeDir);
+    const result = await readClaudePlugins({ claudeDir, settings: ENABLED_BOTH });
+
+    assert.deepEqual(result.marketplaces, [
+      { name: 'demo-market', repo: 'acme/claude-plugins' },
+      { name: 'token-market', repo: 'https://github.com/acme/secret-plugins.git' },
+    ], 'repo 必须来自 source.repo 或 source.url，且 URL 的 userinfo 被剥离');
+
+    assert.deepEqual(result.plugins.map((p) => p.name), ['demo', 'ext'], '未启用(false)与找不到安装目录的插件不得产出');
+
+    const demo = pluginOf(result, 'demo');
+    assert.ok(demo !== undefined);
+    assert.equal(demo.version, '1.2.3');
+    assert.equal(demo.marketplace, 'demo-market');
+    assert.equal(demo.repo, 'acme/claude-plugins');
+    assert.equal(demo.installRel, 'marketplaces/demo-market/plugins/demo');
+    assert.deepEqual(demo.components, ['skills', 'mcp', 'commands', 'agents', 'hooks']);
+    assert.deepEqual(demo.skills?.map((s) => s.name), ['hello']);
+    assert.deepEqual(demo.mcpJson, { 'demo-server': { type: 'http', url: 'https://mcp.example.com' } }, '.mcp.json 必须被读到（原样交翻译层）');
+    assert.equal(demo.commandCount, 2, 'commands 递归计数（含 nested/）');
+    assert.deepEqual(demo.agents, ['reviewer.md'], 'agents 只取文件名');
+    assert.equal(demo.hookFiles, 2, 'hooks/ 下的文件数 + hooks.json 各算 1');
+    assert.equal(demo.readFindings, undefined, '完整插件不得产出 finding');
+
+    const ext = pluginOf(result, 'ext');
+    assert.ok(ext !== undefined);
+    assert.equal(ext.installRel, 'marketplaces/demo-market/external_plugins/ext', 'external_plugins/ 布局必须能找到');
+    assert.deepEqual(ext.components, ['skills']);
+
+    assert.deepEqual(result.counts, {
+      marketplaces: 2,
+      // 真值才算启用：demo / ext / ghost 三条（off 的值是 false）
+      enabledPlugins: 3,
+      plugins: 2,
+      pluginSkills: 2,
+      pluginCommands: 2,
+      pluginAgents: 1,
+      pluginHooks: 2,
+    });
+    assert.deepEqual(
+      result.skipped.map((s) => [s.code, s.origin]),
+      [['source-unreadable', 'plugin:ghost']],
+      '有启用记录但没有安装目录：如实报码（不产出半成品条目）',
+    );
+
+    const serialized = JSON.stringify(result);
+    assert.equal(serialized.includes(FAKE_TOKEN), false, '假 token（URL userinfo / hooks 内容）绝不允许出现在返回值里');
+    assert.equal(serialized.includes('sk-ant-'), false, '任何 token 形状都不得出现在返回值里');
+  });
+});
+
+test('plugins/config.json 形状认不出来：报 plugins-config-unknown-shape，绝不瞎猜', async () => {
+  await withClaudeDir(async (claudeDir) => {
+    await write(path.join(claudeDir, 'plugins', 'config.json'), JSON.stringify({ version: 2, unknown: ['demo'] }));
+    const result = await readClaudePlugins({ claudeDir, settings: {} });
+    assert.deepEqual(result.plugins, [], '认不出来的形状绝不能被当成插件清单');
+    const skip = result.skipped.find((s) => s.detail === 'plugins-config-unknown-shape');
+    assert.ok(skip !== undefined, '必须报码：' + JSON.stringify(result.skipped));
+    assert.equal(skip.code, 'source-unreadable');
+    assert.equal(skip.origin, 'plugins/config.json');
+  });
+});
+
+test('plugins/config.json 形状可自证（{ plugins: { "name@market": true } }）：认出来就用', async () => {
+  await withClaudeDir(async (claudeDir) => {
+    await buildFixture(claudeDir);
+    await write(path.join(claudeDir, 'plugins', 'config.json'), JSON.stringify({ plugins: { 'demo@demo-market': true } }));
+    const result = await readClaudePlugins({ claudeDir, settings: {} });
+    assert.deepEqual(result.plugins.map((p) => p.name), ['demo']);
+    assert.equal(result.skipped.some((s) => s.detail === 'plugins-config-unknown-shape'), false);
+  });
+});
+
+test('既无 enabledPlugins 也无 config.json：plugins 为空且不报码（诚实：没有启用的插件）', async () => {
+  await withClaudeDir(async (claudeDir) => {
+    const result = await readClaudePlugins({ claudeDir, settings: {} });
+    assert.deepEqual(result.plugins, []);
+    assert.deepEqual(result.marketplaces, []);
+    assert.deepEqual(result.skipped, []);
+    assert.equal(result.counts['plugins'], 0);
+  });
+});
+
+test('known_marketplaces.json 存在但解析失败：报 source-unreadable（不静默）', async () => {
+  await withClaudeDir(async (claudeDir) => {
+    await write(path.join(claudeDir, 'plugins', 'known_marketplaces.json'), '{ not json');
+    const result = await readClaudePlugins({ claudeDir, settings: {} });
+    const skip = result.skipped.find((s) => s.origin === 'plugins/known_marketplaces.json');
+    assert.ok(skip !== undefined, '解析失败必须报码：' + JSON.stringify(result.skipped));
+    assert.equal(skip.code, 'source-unreadable');
+    assert.equal(skip.detail, 'json-error');
+    assert.deepEqual(result.marketplaces, []);
+  });
+});
+
+test('插件数触顶报 max-plugins-reached（不静默）', async () => {
+  await withClaudeDir(async (claudeDir) => {
+    await buildFixture(claudeDir);
+    const result = await readClaudePlugins({ claudeDir, settings: ENABLED_BOTH, limits: { maxPlugins: 1 } });
+    assert.equal(result.plugins.length, 1);
+    const skip = result.skipped.find((s) => s.detail === 'max-plugins-reached');
+    assert.ok(skip !== undefined, '触顶必须报码：' + JSON.stringify(result.skipped));
+    assert.equal(skip.origin, 'plugins');
+    assert.equal(skip.count, 1);
+  });
+});
+
+test('单插件文件数触顶报 max-plugin-files-reached，且载荷里不超过上限', async () => {
+  await withClaudeDir(async (claudeDir) => {
+    const { demoDir } = await buildFixture(claudeDir);
+    await write(path.join(demoDir, 'skills', 'hello', 'extra1.md'), 'x');
+    await write(path.join(demoDir, 'skills', 'hello', 'extra2.md'), 'y');
+    const result = await readClaudePlugins({
+      claudeDir,
+      settings: { enabledPlugins: { 'demo@demo-market': true } },
+      limits: { maxPluginFiles: 2 },
+    });
+    const demo = pluginOf(result, 'demo');
+    assert.ok(demo !== undefined);
+    const skip = demo.readFindings?.find((s) => s.detail === 'max-plugin-files-reached');
+    assert.ok(skip !== undefined, '单插件触顶必须报码：' + JSON.stringify(demo.readFindings));
+    assert.equal(skip.origin, 'plugin:demo');
+    assert.equal(skip.count, 2);
+    const carried = demo.skills?.reduce((sum, skill) => sum + skill.files.length, 0) ?? 0;
+    assert.ok(carried <= 2, '载荷里不得带超过上限的技能文件（实际 ' + String(carried) + '）');
+  });
+});
+
+test('plugin.json 解析失败：回落目录名并报码（绝不猜字段）', async () => {
+  await withClaudeDir(async (claudeDir) => {
+    const pluginDir = path.join(claudeDir, 'plugins', 'marketplaces', 'm', 'plugins', 'broken');
+    await write(path.join(pluginDir, '.claude-plugin', 'plugin.json'), '{ oops');
+    const result = await readClaudePlugins({ claudeDir, settings: { enabledPlugins: { 'broken@m': true } } });
+    const plugin = pluginOf(result, 'broken');
+    assert.ok(plugin !== undefined, '安装目录存在就必须产出条目：' + JSON.stringify(result.skipped));
+    assert.equal(plugin.version, undefined);
+    const skip = plugin.readFindings?.find((s) => s.origin === 'plugin:broken/plugin.json');
+    assert.ok(skip !== undefined, '解析失败必须报码：' + JSON.stringify(plugin.readFindings));
+    assert.equal(skip.detail, 'json-error');
+  });
+});

package/src/foreign/claude-sessions.test.ts

@@ -178,3 +178,144 @@ test('t3 产物可被 DSH 自己的 codec 解码回逻辑事件（本机无 code
   assert.ok(types.includes('tool/result'));
   assert.ok(types.includes('turn/end'));
 });
+/* ---------------- 会话保真（2026-10-18，task-4）---------------- */
+
+/** 极简 JSONL 构造器（与文件顶部同形：一行一条 JSON） */
+function jsonl(records: readonly Record<string, unknown>[]): string {
+  return records.map((r) => line(r)).join(NL) + NL;
+}
+
+/** 稳定的消息 uuid（避免各用例手写一长串） */
+function uuidOf(n: number): string {
+  return 'aaaaaaaa-0000-4000-8000-' + String(n).padStart(12, '0');
+}
+
+/** 产物的 header（形态运用文件头的 readSessionLogShapeFromBytes：失败就断言失败，不伪装） */
+function headerOf(bytes: Uint8Array): Record<string, unknown> {
+  const shape = readSessionLogShapeFromBytes(bytes);
+  assert.equal(shape.ok, true, '产物必须是 DSH 可扫的 zstd 帧序列');
+  if (!shape.ok) return {};
+  return shape.headerValue as Record<string, unknown>;
+}
+
+/** 产物的逻辑事件行（null 行用空对象占位，方便后续断言） */
+function rowsOf(bytes: Uint8Array): Record<string, unknown>[] {
+  const shape = readSessionLogShapeFromBytes(bytes);
+  assert.equal(shape.ok, true, '产物必须是 DSH 可扫的 zstd 帧序列');
+  if (!shape.ok) return [];
+  return shape.rows.map((r) => (r === null ? {} : (r as Record<string, unknown>)));
+}
+
+/** 某条助手消息的 content 块（第一条） */
+function assistantContentOf(bytes: Uint8Array): Record<string, unknown>[] {
+  const assistant = rowsOf(bytes).find((r) => r['type'] === 'assistant/message');
+  assert.ok(assistant !== undefined, '语料里应有助手消息');
+  return (assistant?.['data'] as { message: { content: Record<string, unknown>[] } }).message.content;
+}
+
+const FIXED = 1_700_000_000_000;
+const CREATED = Date.parse('2026-09-09T09:09:09.000Z');
+
+test('保真 t4：isSidechain 记录不进 IR（子代理正文绝不混进父对话），整类计报 isSidechain', () => {
+  const text = jsonl([
+    { type: 'user', uuid: uuidOf(1), timestamp: '2026-10-01T10:00:00.000Z', cwd: CWD, message: { role: 'user', content: 'parent question' } },
+    { type: 'assistant', uuid: uuidOf(2), timestamp: '2026-10-01T10:00:01.000Z', cwd: CWD, message: { model: 'claude-sonnet-4', content: [{ type: 'text', text: 'parent answer' }] } },
+    { type: 'user', uuid: uuidOf(3), timestamp: '2026-10-01T10:00:02.000Z', cwd: CWD, isSidechain: true, message: { role: 'user', content: 'SIDECHAIN_DO_NOT_LEAK' } },
+    { type: 'assistant', uuid: uuidOf(4), timestamp: '2026-10-01T10:00:03.000Z', cwd: CWD, isSidechain: true, message: { model: 'claude-sonnet-4', content: [{ type: 'text', text: 'SIDECHAIN_DO_NOT_LEAK' }] } },
+  ]);
+  const result = transcodeClaudeSession({ id: ID, text }, { formatVersion: 3, now: FIXED });
+  assert.ok(result.session, '父对话本身必须照常转码');
+  const s = result.session;
+  assert.equal(s.info.records, 4, 'records 是源记录原始条数（含被忽略的）');
+  assert.equal(s.info.userMessages, 1, '子代理记录不算父对话的用户消息');
+  assert.equal(s.info.assistantMessages, 1);
+  assert.equal(s.info.ignored['isSidechain'], 2, '子代理记录必须整类计报（下游 detail = isSidechain）');
+  const rows = rowsOf(s.data);
+  assert.equal(JSON.stringify(rows).includes('SIDECHAIN_DO_NOT_LEAK'), false, '子代理正文绝不得进产物');
+  assert.equal(rows.filter((r) => r['type'] === 'user/message').length, 1, '只有父对话那一条用户消息');
+  assert.equal(JSON.stringify(rows).includes('parent answer'), true, '父对话正文不受影响');
+});
+
+test('保真 t4：记录 sessionId 与文件名 stem 不一致 → findings 报 session-id-mismatch（id 仍用 stem）', () => {
+  const base = { id: ID, text: sessionText() };
+  const mismatch = transcodeClaudeSession({ ...base, recordSessionId: 'ffffffff-2222-4222-8222-222222222222' }, { formatVersion: 3, now: FIXED });
+  assert.ok(mismatch.session, '不一致不是跳过理由：会话照样产出');
+  assert.equal(mismatch.session.id, ID, '会话 id 仍以文件名 stem 为准（DSH 按目录/文件名定位）');
+  assert.deepEqual(mismatch.findings, [{ code: 'session-id-mismatch', origin: ID }]);
+  assert.deepEqual(transcodeClaudeSession({ ...base, recordSessionId: ID }, { formatVersion: 3, now: FIXED }).findings, [], '一致就不报');
+  assert.deepEqual(transcodeClaudeSession(base, { formatVersion: 3, now: FIXED }).findings, [], '读盘层没给就不猜');
+  assert.deepEqual(transcodeClaudeSession({ ...base, recordSessionId: '' }, { formatVersion: 3, now: FIXED }).findings, [], '空串视同没给');
+  const skipped = transcodeClaudeSession({ id: 'a/b', text: sessionText(), recordSessionId: 'x' }, { formatVersion: 3, now: FIXED });
+  assert.equal(skipped.skip?.code, 'session-unsafe-id');
+  assert.equal(skipped.findings.length, 1, '不一致是文件级事实：跳过面也要带上 findings');
+});
+
+test('保真 t4：推理块计报 thinking 且不进正文；非 Claude 的 reasoning 形状保持既有口径', () => {
+  const text = jsonl([
+    { type: 'user', uuid: uuidOf(1), timestamp: '2026-10-01T10:00:00.000Z', cwd: CWD, message: { role: 'user', content: 'q' } },
+    { type: 'assistant', uuid: uuidOf(2), timestamp: '2026-10-01T10:00:01.000Z', cwd: CWD, message: { model: 'claude-sonnet-4', content: [
+      { type: 'thinking', thinking: 'THINKING_DO_NOT_LEAK', signature: 'sig' },
+      { type: 'text', text: 'answer' },
+      { type: 'redacted_thinking', data: 'REDACTED_DO_NOT_LEAK' },
+    ] } },
+  ]);
+  const result = transcodeClaudeSession({ id: ID, text }, { formatVersion: 3, now: FIXED });
+  assert.ok(result.session);
+  assert.equal(result.session.info.ignored['thinking'], 2, 'thinking / redacted_thinking 逐条计报');
+  const rows = rowsOf(result.session.data);
+  assert.equal(JSON.stringify(rows).includes('DO_NOT_LEAK'), false, '推理正文绝不得进产物');
+  assert.deepEqual(
+    assistantContentOf(result.session.data),
+    [{ type: 'text', text: 'answer' }],
+    '推理块既不进 IR、也不留空文本块（空块会污染串联后的正文换行）',
+  );
+
+  // 非 Claude 原生的 `{type:'reasoning', text:'…'}`（别的导出器的命名）刻意保持既有口径：
+  // 它命中共享 IR “对象带 text 就算文本块”的兼底分支（该分支被逐字节回归钉住），
+  // 所以本次计报口径**不含它**。谁要一并丢弃/计报，改 REASONING_BLOCK_TYPES 一个数组即可，
+  // 并同步更新 claude-sessions-bytes.test.ts 的对应基线（该案 728 → 722 字节）。
+  const legacy = transcodeClaudeSession({
+    id: ID,
+    text: jsonl([
+      { type: 'user', uuid: uuidOf(1), timestamp: '2026-10-01T10:00:00.000Z', cwd: CWD, message: { role: 'user', content: 'q' } },
+      { type: 'assistant', uuid: uuidOf(2), timestamp: '2026-10-01T10:00:01.000Z', cwd: CWD, message: { model: 'claude-sonnet-4', content: [{ type: 'reasoning', text: 'r' }, { type: 'text', text: 'c' }] } },
+    ]),
+  }, { formatVersion: 3, now: FIXED });
+  assert.ok(legacy.session);
+  assert.equal(legacy.session.info.ignored['thinking'], undefined, 'reasoning 形状不在本次计报口径内（见注释）');
+  assert.deepEqual(assistantContentOf(legacy.session.data), [{ type: 'text', text: 'r' + NL + 'c' }], '既有文本兜底分支原样保留');
+});
+
+test('保真 t4：幂等 —— 同一来源两次转码逐字节相同（墙钟回落只有一个确定性来源）', () => {
+  // ① 记录自带时间戳：确定性来自记录本身（**不注入 now**）
+  const a = transcodeClaudeSession({ id: ID, text: sessionText() }, { formatVersion: 3 });
+  const b = transcodeClaudeSession({ id: ID, text: sessionText() }, { formatVersion: 3 });
+  assert.ok(a.session !== undefined && b.session !== undefined);
+  assert.deepEqual(a.session.data, b.session.data, '同一输入两次转码必须逐字节相同（否则 DSH 侧“同内容 → Skip”永不成立）');
+  assert.equal(a.session.info.counts['timestampsFallback'], 0);
+  assert.equal(headerOf(a.session.data)['createdAt'], Date.parse('2026-10-01T10:00:00.000Z'), 'createdAt 取记录自身最早时间戳');
+
+  // ② 记录没有时间戳：回落 input.createdAtMs（读盘层给的确定性值）
+  const noTs = jsonl([
+    { type: 'user', uuid: uuidOf(1), cwd: CWD, message: { role: 'user', content: 'q' } },
+    { type: 'assistant', uuid: uuidOf(2), cwd: CWD, message: { model: 'claude-sonnet-4', content: [{ type: 'text', text: 'a' }] } },
+  ]);
+  const c = transcodeClaudeSession({ id: ID, text: noTs, createdAtMs: CREATED }, { formatVersion: 3 });
+  const d = transcodeClaudeSession({ id: ID, text: noTs, createdAtMs: CREATED }, { formatVersion: 3 });
+  assert.ok(c.session !== undefined && d.session !== undefined);
+  assert.deepEqual(c.session.data, d.session.data, 'createdAtMs 回落同样必须幂等');
+  assert.equal(c.session.info.counts['timestampsFallback'], 0, '有确定性回落值就不应记 timestampsFallback');
+  assert.equal(headerOf(c.session.data)['createdAt'], CREATED);
+  // **全程只有一个墙钟来源**：所有事件的 time 都必须等于 createdAtMs
+  // （旧实现 parse 与 synthesize 各调一次 Date.now()，两处可能落在不同毫秒）
+  for (const row of rowsOf(c.session.data)) assert.equal(row['time'], CREATED);
+
+  // ③ 两者都没有：只能墙钟回落，并如实记账
+  const e = transcodeClaudeSession({ id: ID, text: noTs }, { formatVersion: 3 });
+  assert.ok(e.session);
+  assert.equal(e.session.info.counts['timestampsFallback'], 1, '没有确定性时间来源必须如实记账');
+  // 非安全整数视同“没给”（DSH 对时间字段要求安全整数），绝不把坏值写进行里
+  const f = transcodeClaudeSession({ id: ID, text: noTs, createdAtMs: Number.NaN }, { formatVersion: 3 });
+  assert.ok(f.session);
+  assert.equal(f.session.info.counts['timestampsFallback'], 1, '非法 createdAtMs 不得当成确定性值');
+});