feat(tools): 翻译清单改为 v3 紧凑格式并增量校验

history_language_manifest.json 从 v2 的 77MB 压到 v3 的 23MB：selector
按 blocks 分组共享，sourceSelector 利用 96% 与 selector 相同的事实改为
四态折叠，source 提升为文件级默认值，history/+common/ 全部 8722 个
文件入册并记录字节 sha256。加载改为展开回 v2 内存形状，下游消费方
（validate.mjs、build_history_english.mjs、dynasty_language_audit.mjs）
无需感知格式变化。

validate.mjs 的清单相位改为增量：hash 一致的文件跳过解析，稳态耗时
75s 降至约 1s；hash 失配报 manifest-stale 并提示 stamp。
build_history_english.mjs 在清单过期时拒绝构建，构建成功自动 stamp。

清单维护不再手改 JSON，新增 tools/history_language_manifest.mjs 的
migrate/stamp/add 命令；已用迁移前后英文 overlay 全量哈希比对验证
渲染等价（6386 文件 0 差异）。

AGENTS.md

@@ -57,18 +57,21 @@ await eu4.save();
 
 ## 翻译清单（history_language_manifest.json）
 
-这份文件（约 189MB）记录了 `history/` 和 `common/` 里所有直写中文的英文翻译，供英文覆盖层使用。
+这份文件（v3 紧凑格式，每个文件记录一行）记录了 `history/` 和 `common/` 里所有直写中文的英文翻译，供英文覆盖层使用。每个文件还存了字节的 sha256，校验时只重新解析变过的文件。
 
-每条记录用"在哪个键下面、第几次出现"来定位中文文本，不用行号（行号会随编辑漂移）。添加条目时用 `selectorForToken(tree, token)` 自动获取位置，不要手写。
+每条记录用"在哪个键下面、第几次出现"来定位中文文本，不用行号（行号会随编辑漂移）。清单由工具维护，不要手改 JSON：
+
+- 新增中文条目：`node tools/history_language_manifest.mjs add <file> <chinese> <english> [--occurrence N]`
+- 改了 `history/` 或 `common/` 文件后若 `validate.mjs` 报 `manifest-stale`：`node tools/history_language_manifest.mjs stamp` 刷新哈希（会先全量校验，内容不合法会拒绝）
+- `build_history_english.mjs build` 在清单过期时拒绝构建，构建成功后会自动 stamp
 
 改了这个清单等于改了英文层。直接改英文层文件会绕过清单，下次校验会失败。
 
 需要同步更新清单的情况：
-- **删了文件** -> 删掉清单里对应的整个文件块
-- **改了字段名** -> 更新对应条目的键名
-- **删了字段** -> 删掉对应条目
-- **改了文件结构**（如省份从单个名称变成多个名称）-> 更新对应条目的定位方式
-- **新增了含中文的字段** -> 添加新条目，填好中文、英文、来源
+- **删了文件** -> stamp 自动移除对应文件块
+- **新增了含中文的字段** -> 用 add 命令添加条目
+- **改动不动中文 token**（改数值、日期、注释等）-> stamp 刷新哈希即可
+- **改了字段名、删了字段、改了文件结构** -> 对应条目定位会失败（validate 报错），必须先手工修正清单条目再 stamp
 
 ## 校验
 

CHANGELOG.md

@@ -63,6 +63,7 @@
 
 - 增加 Clausewitz 数据读写与完整性校验工具。
 - 本地化构建改为基于内容清单的增量流程。
+- 翻译清单 `history_language_manifest.json` 改为 v3 紧凑格式（77MB → 23MB，每个文件记录一行），并为每个文件记录字节 sha256；`validate.mjs` 的清单相位改为增量校验（75s → 约 1s）。清单维护改用 `tools/history_language_manifest.mjs` 的 `add`/`stamp` 命令，不再手改 JSON。
 - 删除不适用于 EU4 1.37.5 的旧编码偏移兼容接口和依赖真实工作树状态的测试。
 - 在 `localisation_english_provenance.json` 登记新英文覆盖层 `loadingtips_l_english.yml`，并为该文件设置 `allowVanillaOverride`，允许其覆盖同名的原版 `LOADING_TIP_*` 键。
 - `tools/build_variants.mjs` 新增按文件粒度的 `allowVanillaOverride` 白名单校验，仅放过在 `localisation_english_provenance.json` 中显式标记的源文件。

history_language_manifest.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:34b3da615f7a0a7901d0885f8a6d80d97e2195dbdcaa0486eab797e90a8d1391
-size 78709081
+oid sha256:02d29360e162100b3641eae7d0e3beb227362a8ea311e332e7fec484b74030a0
+size 23233081

tools/build_history_english.mjs

@@ -3,7 +3,7 @@ import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { readGameText, writeGameText } from './eu4_clausewitz/src/codec.mjs';
 import { auditDynastyLanguage } from './dynasty_language_audit.mjs';
-import { loadManifest, renderText, validateManifestAgainstRoot } from './history_language_manifest.mjs';
+import { loadManifest, renderText, saveManifest, stampManifest, validateManifestAgainstRoot } from './history_language_manifest.mjs';
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const manifestPath = join(root, 'history_language_manifest.json');
@@ -13,6 +13,9 @@ const stagingRoot = resolve(root, '..', 'Ab_Integro_English.history-staging');
 async function check() {
   const manifest = await loadManifest(manifestPath);
   const summary = await validateManifestAgainstRoot(manifest, root);
+  if (summary.stale.length) {
+    throw new Error(`Manifest is out of date for ${summary.stale.length} file(s); run: node tools/history_language_manifest.mjs stamp`);
+  }
   const dynastyMap = JSON.parse(await readFile(join(root, 'tools', 'dynasty_translation_map.json'), 'utf8'));
   const dynastyFindings = await auditDynastyLanguage(root, manifest, dynastyMap.translations);
   if (dynastyFindings.length) throw new Error(`Dynasty language audit failed:\n${JSON.stringify(dynastyFindings, null, 2)}`);
@@ -23,7 +26,8 @@ async function check() {
 async function build() {
   const manifest = await check();
   await rm(stagingRoot, { recursive: true, force: true });
-  const files = [...manifest.files];
+  const files = [...manifest.files].filter((file) => file.entries.length);
+  const fileCount = files.length;
   async function renderNext() {
     const file = files.pop();
     if (!file) return;
@@ -39,7 +43,9 @@ async function build() {
   for (const scope of ['history', 'common']) await rm(join(overlayRoot, scope), { recursive: true, force: true });
   for (const scope of ['history', 'common']) await rename(join(stagingRoot, scope), join(overlayRoot, scope));
   await rm(stagingRoot, { recursive: true, force: true });
-  console.log(`English history overlay built: ${manifest.files.length} files.`);
+  const stamped = await stampManifest(manifest, root);
+  await saveManifest(stamped, manifestPath);
+  console.log(`English history overlay built: ${fileCount} files.`);
 }
 
 const command = process.argv[2] ?? 'build';

tools/eu4_clausewitz/test/history_language_manifest.test.mjs

@@ -1,9 +1,17 @@
 import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { test } from 'node:test';
 import {
+  addManifestEntry,
+  loadManifest,
   parsedText,
   renderText,
+  saveManifest,
   selectorForToken,
+  stampManifest,
+  validateManifestAgainstRoot,
   valueTokens,
 } from '../../history_language_manifest.mjs';
 
@@ -52,3 +60,111 @@ test('a Chinese value drift fails at the selector location', () => {
   const changed = 'name = "乙"\n';
   assert.throws(() => renderText(changed, [entry(before, '甲', 'One')]), /expected Chinese/);
 });
+
+test('v3 manifest serializes and reloads to the same expanded form', async () => {
+  const blocksA = [{ key: 'monarch_names', occurrence: 0 }];
+  const sel = (blocks, target) => ({ blocks, target });
+  const expanded = {
+    version: 3,
+    sources: [
+      { id: 's0', upstream: 'vanilla', path: 'common/countries/X.txt' },
+      { id: 's1', upstream: 'vanilla', path: 'common/countries/Y.txt' },
+    ],
+    files: [
+      {
+        path: 'history/x.txt', sha256: 'a'.repeat(64),
+        entries: [
+          { selector: sel(blocksA, { kind: 'key', occurrence: 0 }), chinese: '甲 #0', english: 'A #0', source: 's0', sourceSelector: sel(blocksA, { kind: 'key', occurrence: 0 }) },
+          { selector: sel(blocksA, { kind: 'key', occurrence: 1 }), chinese: '乙 #1', english: 'B #1', source: 's0', sourceSelector: sel(blocksA, { kind: 'key', occurrence: 5 }) },
+          { selector: sel(blocksA, { kind: 'key', occurrence: 2 }), chinese: '丙 #2', english: 'C #2', source: 's1', sourceSelector: sel([{ key: 'other', occurrence: 1 }], { kind: 'bare', occurrence: 0 }) },
+          { selector: sel([{ key: 'dynasty_names', occurrence: 0 }], { kind: 'bare', occurrence: 0 }), chinese: '丁', english: 'D', source: 's0' },
+        ],
+      },
+      { path: 'history/clean.txt', sha256: 'b'.repeat(64), entries: [] },
+    ],
+  };
+  const dir = await mkdtemp(join(tmpdir(), 'hlm-'));
+  const file = join(dir, 'manifest.json');
+  await saveManifest(expanded, file);
+  const loaded = await loadManifest(file);
+  assert.deepEqual(loaded, expanded);
+});
+
+test('v3 compact entries render identically to the expanded form', async () => {
+  const text = 'name = "甲"\nmonarch_names = { "乙" "丙" }\n';
+  const entries = [entry(text, '甲', 'One'), entry(text, '乙', 'Two'), entry(text, '丙', 'Three')];
+  const manifest = {
+    version: 3,
+    sources: [{ id: 's0', upstream: 'vanilla', path: 'history/x.txt' }],
+    files: [{ path: 'history/x.txt', sha256: 'a'.repeat(64), entries: entries.map((item) => ({ ...item, source: 's0' })) }],
+  };
+  const dir = await mkdtemp(join(tmpdir(), 'hlm-'));
+  const file = join(dir, 'manifest.json');
+  await saveManifest(manifest, file);
+  const loaded = await loadManifest(file);
+  assert.equal(renderText(text, loaded.files[0].entries), 'name = "One"\nmonarch_names = { "Two" "Three" }\n');
+});
+
+test('incremental validation skips unchanged files and detects drift', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'hlm-root-'));
+  await mkdir(join(dir, 'history'), { recursive: true });
+  await mkdir(join(dir, 'common'), { recursive: true });
+  const chineseText = 'name = "甲" # comment\n';
+  await writeFile(join(dir, 'history', 'a.txt'), chineseText);
+  await writeFile(join(dir, 'common', 'b.txt'), 'name = "Vanilla"\n');
+  const parsed = parsedText(chineseText);
+  const token = valueTokens(parsed.tree).find((candidate) => candidate.value === '甲');
+  const manifest = {
+    version: 3,
+    sources: [{ id: 's0', upstream: 'vanilla', path: 'history/a.txt' }],
+    files: [{ path: 'history/a.txt', sha256: '', entries: [{ selector: selectorForToken(parsed.tree, token), chinese: '甲', english: 'A', source: 's0' }] }],
+  };
+  const stamped = await stampManifest(manifest, dir);
+  assert.equal(stamped.files.length, 2);
+  const clean = await validateManifestAgainstRoot(stamped, dir);
+  assert.deepEqual(clean.stale, []);
+
+  // Byte change that keeps the Chinese token: only that file is re-checked.
+  await writeFile(join(dir, 'history', 'a.txt'), 'name = "甲" # other comment\n');
+  const touched = await validateManifestAgainstRoot(stamped, dir);
+  assert.deepEqual(touched.stale, ['history/a.txt']);
+
+  // Chinese drift fails even though the selector still resolves.
+  await writeFile(join(dir, 'history', 'a.txt'), 'name = "乙"\n');
+  await assert.rejects(() => validateManifestAgainstRoot(stamped, dir), /expected Chinese/);
+
+  // A new clean file is stale; a new Chinese file without entries fails.
+  await writeFile(join(dir, 'history', 'a.txt'), chineseText);
+  await writeFile(join(dir, 'common', 'c.txt'), 'name = "New"\n');
+  const added = await validateManifestAgainstRoot(stamped, dir);
+  assert.deepEqual(added.stale, ['common/c.txt']);
+  await rm(join(dir, 'common', 'c.txt'));
+  await writeFile(join(dir, 'common', 'd.txt'), 'name = "新"\n');
+  await assert.rejects(() => validateManifestAgainstRoot(stamped, dir), /no manifest record/);
+
+  // A recorded file that disappears fails.
+  await rm(join(dir, 'common', 'd.txt'));
+  await rm(join(dir, 'common', 'b.txt'));
+  await assert.rejects(() => validateManifestAgainstRoot(stamped, dir), /missing file/);
+});
+
+test('addManifestEntry locates the token and refreshes the file hash', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'hlm-add-'));
+  await mkdir(join(dir, 'history'), { recursive: true });
+  const text = 'first = "同"\nsecond = "同"\n';
+  await writeFile(join(dir, 'history', 'a.txt'), text);
+  const parsed = parsedText(text);
+  const first = valueTokens(parsed.tree).find((candidate) => candidate.value === '同');
+  const manifest = {
+    version: 3,
+    sources: [{ id: 's0', upstream: 'vanilla', path: 'history/a.txt' }],
+    files: [{ path: 'history/a.txt', sha256: '', entries: [{ selector: selectorForToken(parsed.tree, first), chinese: '同', english: 'First', source: 's0' }] }],
+  };
+  await assert.rejects(() => addManifestEntry(manifest, dir, 'history/a.txt', '同', 'Second'), /--occurrence/);
+  await addManifestEntry(manifest, dir, 'history/a.txt', '同', 'Second', 1);
+  assert.equal(manifest.files[0].entries.length, 2);
+  assert.match(manifest.files[0].sha256, /^[0-9a-f]{64}$/);
+  assert.equal(renderText(text, manifest.files[0].entries), 'first = "First"\nsecond = "Second"\n');
+  await assert.rejects(() => addManifestEntry(manifest, dir, 'history/a.txt', '同', 'Third', 0), /already has an entry/);
+  await assert.rejects(() => addManifestEntry(manifest, dir, 'history/nope.txt', '同', 'X'), /no manifest entries/);
+});

tools/history_language_manifest.mjs

@@ -1,11 +1,31 @@
-import { readFile, readdir } from 'node:fs/promises';
-import { join, relative } from 'node:path';
+// History language manifest: records the English translation of every piece of
+// Chinese direct text under history/ and common/, keyed by structural
+// selectors (key path + occurrence) instead of line numbers.
+//
+// On-disk format v3: one JSON line per file record inside "files". Entries
+// are grouped by shared selector blocks; per entry only the target ("t"),
+// Chinese ("zh") and English ("en") are stored. "src" overrides the
+// file-level default source. "ssel" encodes the upstream source selector:
+//   omitted                          -> identical to the entry selector
+//   { "t": ... }                     -> same blocks, different target
+//   { "blocks": ..., "target": ... } -> fully independent position
+//   null                             -> no recorded position in the source
+// Every file under history/ and common/ is recorded, each with the sha256 of
+// its current bytes; files without Chinese carry no "groups" and serve as a
+// clean-file cache so validation only re-parses files whose bytes changed.
+
+import { createHash } from 'node:crypto';
+import { readFile, readdir, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { parse } from './eu4_clausewitz/src/ast.mjs';
 import { countBraces } from './eu4_clausewitz/src/edit.mjs';
 import { tokenize } from './eu4_clausewitz/src/lexer.mjs';
 import { readGameText } from './eu4_clausewitz/src/codec.mjs';
 
-export const CJK = /[\u3400-\u9fff\uf900-\ufaff]/u;
+export const CJK = /[㐀-鿿豈-﫿]/u;
+
+const CONCURRENCY = 16;
 
 function scalarToken(item) {
   return item.kind === 'pair' && item.value.type === 'scalar' ? item.value.token : null;
@@ -124,26 +144,106 @@ export function renderText(text, entries, path = '<memory>') {
   return output;
 }
 
+// --- v3 load / save ----------------------------------------------------------
+
 export async function loadManifest(path) {
-  const manifest = JSON.parse(await readFile(path, 'utf8'));
-  if (manifest.version !== 2 || !Array.isArray(manifest.files) || !Array.isArray(manifest.sources)) {
-    throw new Error(`${path}: expected history language manifest v2`);
+  const raw = JSON.parse(await readFile(path, 'utf8'));
+  if (raw.version === 2) {
+    throw new Error(`${path}: manifest is v2; run: node tools/history_language_manifest.mjs migrate`);
   }
-  const sourceIds = new Set(manifest.sources.map((source) => source.id));
+  if (raw.version !== 3 || !Array.isArray(raw.files) || !Array.isArray(raw.sources)) {
+    throw new Error(`${path}: expected history language manifest v3`);
+  }
+  const sourceIds = new Set(raw.sources.map((source) => source.id));
   const paths = new Set();
-  for (const file of manifest.files) {
+  const files = raw.files.map((file) => {
     if (!file.path?.match(/^(history|common)\/.+\.txt$/)) throw new Error(`${path}: invalid target path ${file.path}`);
     if (paths.has(file.path)) throw new Error(`${path}: duplicate target file ${file.path}`);
     paths.add(file.path);
-    if (!Array.isArray(file.entries) || file.entries.length === 0) throw new Error(`${path}: ${file.path} has no entries`);
-    for (const entry of file.entries) {
-      if (!entry.selector || typeof entry.chinese !== 'string' || typeof entry.english !== 'string') throw new Error(`${path}: malformed entry in ${file.path}`);
-      if (!CJK.test(entry.chinese)) throw new Error(`${path}: non-Chinese source value in ${file.path}`);
-      if (CJK.test(entry.english)) throw new Error(`${path}: CJK English value in ${file.path}`);
-      if (!sourceIds.has(entry.source)) throw new Error(`${path}: unknown source ${entry.source} in ${file.path}`);
+    if (typeof file.sha256 !== 'string' || !/^[0-9a-f]{64}$/.test(file.sha256)) {
+      throw new Error(`${path}: ${file.path} has no sha256`);
+    }
+    const entries = [];
+    if (file.groups !== undefined) {
+      if (!sourceIds.has(file.source)) throw new Error(`${path}: ${file.path} has unknown default source ${file.source}`);
+      if (!Array.isArray(file.groups)) throw new Error(`${path}: ${file.path} has malformed groups`);
+      for (const group of file.groups) {
+        if (!Array.isArray(group.blocks) || !Array.isArray(group.entries) || group.entries.length === 0) {
+          throw new Error(`${path}: malformed group in ${file.path}`);
+        }
+        for (const item of group.entries) {
+          if (!item.t || typeof item.zh !== 'string' || typeof item.en !== 'string') {
+            throw new Error(`${path}: malformed entry in ${file.path}`);
+          }
+          if (!CJK.test(item.zh)) throw new Error(`${path}: non-Chinese source value in ${file.path}`);
+          if (CJK.test(item.en)) throw new Error(`${path}: CJK English value in ${file.path}`);
+          const source = item.src ?? file.source;
+          if (!sourceIds.has(source)) throw new Error(`${path}: unknown source ${source} in ${file.path}`);
+          const selector = { blocks: group.blocks, target: item.t };
+          const entry = { selector, chinese: item.zh, english: item.en, source };
+          if (item.ssel === undefined) {
+            entry.sourceSelector = { blocks: group.blocks, target: item.t };
+          } else if (item.ssel !== null) {
+            entry.sourceSelector = item.ssel.blocks
+              ? { blocks: item.ssel.blocks, target: item.ssel.target }
+              : { blocks: group.blocks, target: item.ssel.t };
+          }
+          entries.push(entry);
+        }
+      }
+    }
+    return { path: file.path, sha256: file.sha256, entries };
+  });
+  return { version: 3, sources: raw.sources, files };
+}
+
+function majoritySource(entries) {
+  const counts = new Map();
+  for (const entry of entries) counts.set(entry.source, (counts.get(entry.source) ?? 0) + 1);
+  return [...counts].sort((left, right) => right[1] - left[1])[0][0];
+}
+
+function compactFile(file) {
+  if (file.entries.length === 0) return { path: file.path, sha256: file.sha256 };
+  const source = majoritySource(file.entries);
+  const groups = [];
+  let current = null;
+  let lastBlocks = null;
+  for (const entry of file.entries) {
+    const blocksJson = JSON.stringify(entry.selector.blocks);
+    if (blocksJson !== lastBlocks) {
+      current = { blocks: entry.selector.blocks, entries: [] };
+      groups.push(current);
+      lastBlocks = blocksJson;
+    }
+    const item = { t: entry.selector.target, zh: entry.chinese, en: entry.english };
+    if (entry.source !== source) item.src = entry.source;
+    if (!entry.sourceSelector) {
+      item.ssel = null;
+    } else if (selectorKey(entry.sourceSelector) !== selectorKey(entry.selector)) {
+      item.ssel = JSON.stringify(entry.sourceSelector.blocks) === blocksJson
+        ? { t: entry.sourceSelector.target }
+        : { blocks: entry.sourceSelector.blocks, target: entry.sourceSelector.target };
     }
+    current.entries.push(item);
   }
-  return manifest;
+  return { path: file.path, sha256: file.sha256, source, groups };
+}
+
+export function serializeManifest(manifest) {
+  const sources = manifest.sources.map((source) => JSON.stringify(source)).join(',\n');
+  const files = manifest.files.map((file) => JSON.stringify(compactFile(file))).join(',\n');
+  return `{"version":3,"sources":[\n${sources}\n],"files":[\n${files}\n]}\n`;
+}
+
+export async function saveManifest(manifest, path) {
+  await writeFile(path, serializeManifest(manifest), 'utf8');
+}
+
+// --- validation / stamping ---------------------------------------------------
+
+function sha256(buffer) {
+  return createHash('sha256').update(buffer).digest('hex');
 }
 
 async function listTextFiles(root, current = root) {
@@ -156,21 +256,147 @@ async function listTextFiles(root, current = root) {
   return files;
 }
 
-export async function validateManifestAgainstRoot(manifest, root) {
-  const byPath = new Map(manifest.files.map((file) => [file.path, file.entries]));
+async function listScopedTextFiles(root) {
   const actual = [];
   for (const scope of ['history', 'common']) {
     for (const path of await listTextFiles(join(root, scope))) actual.push(`${scope}/${path}`);
   }
-  for (const path of actual) {
-    const { text } = await readGameText(join(root, path));
-    const parsed = parsedText(text);
-    const hasCjk = valueTokens(parsed.tree).some((token) => CJK.test(token.value));
-    if (hasCjk && !byPath.has(path)) throw new Error(`${path}: contains Chinese direct text but has no manifest record`);
-    if (byPath.has(path)) renderText(text, byPath.get(path), path);
+  return actual.sort();
+}
+
+async function mapConcurrent(items, fn) {
+  const queue = [...items];
+  async function worker() {
+    for (let item; (item = queue.pop()) !== undefined;) await fn(item);
   }
+  await Promise.all(Array.from({ length: CONCURRENCY }, worker));
+}
+
+export async function validateManifestAgainstRoot(manifest, root) {
+  const byPath = new Map(manifest.files.map((file) => [file.path, file]));
+  const actual = await listScopedTextFiles(root);
+  const actualSet = new Set(actual);
+  const errors = [];
+  const stale = [];
+  await mapConcurrent(actual, async (path) => {
+    try {
+      const record = byPath.get(path);
+      const hash = sha256(await readFile(join(root, path)));
+      if (record && record.sha256 === hash) return;
+      const { text } = await readGameText(join(root, path));
+      if (record && record.entries.length) {
+        renderText(text, record.entries, path);
+      } else {
+        const parsed = parsedText(text);
+        if (valueTokens(parsed.tree).some((token) => CJK.test(token.value))) {
+          throw new Error(`${path}: contains Chinese direct text but has no manifest record`);
+        }
+      }
+      stale.push(path);
+    } catch (error) {
+      errors.push(error.message);
+    }
+  });
   for (const path of byPath.keys()) {
-    if (!actual.includes(path)) throw new Error(`manifest references missing file ${path}`);
+    if (!actualSet.has(path)) errors.push(`manifest references missing file ${path}`);
+  }
+  if (errors.length) {
+    const shown = errors.slice(0, 10).join('\n');
+    throw new Error(errors.length > 10 ? `${shown}\n... and ${errors.length - 10} more` : shown);
+  }
+  return {
+    files: manifest.files.length,
+    entries: manifest.files.reduce((count, file) => count + file.entries.length, 0),
+    stale: stale.sort(),
+  };
+}
+
+export async function stampManifest(manifest, root) {
+  const actual = await listScopedTextFiles(root);
+  const byPath = new Map(manifest.files.map((file) => [file.path, file]));
+  const records = new Map();
+  await mapConcurrent(actual, async (path) => {
+    const hash = sha256(await readFile(join(root, path)));
+    const record = byPath.get(path);
+    records.set(path, record && record.entries.length
+      ? { path, sha256: hash, entries: record.entries }
+      : { path, sha256: hash, entries: [] });
+  });
+  return { version: 3, sources: manifest.sources, files: actual.map((path) => records.get(path)) };
+}
+
+export async function addManifestEntry(manifest, root, path, chinese, english, occurrence = null) {
+  const record = manifest.files.find((file) => file.path === path);
+  if (!record || record.entries.length === 0) {
+    throw new Error(`${path}: no manifest entries yet; provenance cannot be guessed, add the first entry manually`);
+  }
+  if (!CJK.test(chinese)) throw new Error(`not Chinese: ${JSON.stringify(chinese)}`);
+  if (CJK.test(english)) throw new Error(`English value contains CJK: ${JSON.stringify(english)}`);
+  const absolute = join(root, path);
+  const { text } = await readGameText(absolute);
+  const parsed = parsedText(text);
+  const matches = valueTokens(parsed.tree).filter((token) => token.value === chinese);
+  if (matches.length === 0) throw new Error(`${path}: no token with value ${JSON.stringify(chinese)}`);
+  let token = matches[0];
+  if (matches.length > 1) {
+    if (occurrence === null) {
+      throw new Error(`${path}: ${matches.length} tokens with value ${JSON.stringify(chinese)}; pass --occurrence 0-${matches.length - 1}`);
+    }
+    token = matches[occurrence];
+    if (!token) throw new Error(`${path}: occurrence ${occurrence} out of range (${matches.length} matches)`);
+  }
+  const selector = selectorForToken(parsed.tree, token);
+  if (record.entries.some((entry) => selectorKey(entry.selector) === selectorKey(selector))) {
+    throw new Error(`${path}: manifest already has an entry at ${selectorKey(selector)}`);
   }
-  return { files: manifest.files.length, entries: manifest.files.reduce((count, file) => count + file.entries.length, 0) };
+  record.entries.push({ selector, chinese, english, source: majoritySource(record.entries) });
+  record.sha256 = sha256(await readFile(absolute));
+  return record;
 }
+
+// --- CLI ---------------------------------------------------------------------
+
+async function main() {
+  const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+  const manifestPath = join(root, 'history_language_manifest.json');
+  const [command, ...args] = process.argv.slice(2);
+  if (command === 'migrate') {
+    const raw = JSON.parse(await readFile(manifestPath, 'utf8'));
+    if (raw.version !== 2) throw new Error(`${manifestPath}: migrate expects a v2 manifest`);
+    const manifest = {
+      version: 3,
+      sources: raw.sources,
+      files: raw.files.map((file) => ({ path: file.path, sha256: '', entries: file.entries })),
+    };
+    const summary = await validateManifestAgainstRoot(manifest, root);
+    const stamped = await stampManifest(manifest, root);
+    await saveManifest(stamped, manifestPath);
+    console.log(`Migrated manifest to v3: ${stamped.files.length} files, ${summary.entries} entries.`);
+    return;
+  }
+  if (command === 'stamp') {
+    const manifest = await loadManifest(manifestPath);
+    await validateManifestAgainstRoot(manifest, root);
+    const stamped = await stampManifest(manifest, root);
+    await saveManifest(stamped, manifestPath);
+    console.log(`Manifest stamped: ${stamped.files.length} files.`);
+    return;
+  }
+  if (command === 'add') {
+    const occurrenceIndex = args.indexOf('--occurrence');
+    const occurrence = occurrenceIndex === -1 ? null : Number(args[occurrenceIndex + 1]);
+    const positional = occurrenceIndex === -1 ? args : args.slice(0, occurrenceIndex);
+    const [path, chinese, english] = positional;
+    if (!path || !chinese || !english) {
+      throw new Error('Usage: node tools/history_language_manifest.mjs add <file> <chinese> <english> [--occurrence N]');
+    }
+    const manifest = await loadManifest(manifestPath);
+    addManifestEntry(manifest, root, path, chinese, english, occurrence);
+    await saveManifest(manifest, manifestPath);
+    console.log(`Added manifest entry: ${path}: ${chinese} -> ${english}`);
+    return;
+  }
+  throw new Error('Usage: node tools/history_language_manifest.mjs <migrate|stamp|add>');
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main();

tools/validate.mjs

@@ -499,15 +499,24 @@ async function runScopeRefs(mapSets) {
 
 async function runManifestCheck() {
   const findings = [];
+  const started = Date.now();
   try {
     const manifest = await loadManifest(MANIFEST_PATH);
-    await validateManifestAgainstRoot(manifest, root);
+    const summary = await validateManifestAgainstRoot(manifest, root);
+    if (summary.stale.length) {
+      const sample = summary.stale.slice(0, 5).join(', ');
+      findings.push({
+        id: 'manifest-stale', level: 'error',
+        message: `${summary.stale.length} file(s) changed since last manifest stamp (e.g. ${sample}${summary.stale.length > 5 ? ', ...' : ''}); run: node tools/history_language_manifest.mjs stamp`,
+      });
+    }
   } catch (error) {
     findings.push({
       id: 'manifest-consistency', level: 'error',
       message: error.message,
     });
   }
+  console.log(`Manifest check took ${((Date.now() - started) / 1000).toFixed(1)}s`);
   return findings;
 }