euthyna 0.1.1 → 0.3.0

package/src/facts/coverage.js

@@ -20,6 +20,7 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { makeFact, notEvaluated as notEvaluatedEntry, KIND, STATUS, shellQuote } from '../contract.js';
+import { T, DEFAULT_LANG } from '../lang.js';
 
 /** c8's default exclusions. A production file matching one of these vanishes from the report. */
 const C8_DEFAULT_EXCLUDES = [
@@ -210,7 +211,8 @@ function locateSymbolInEntry(entry, symbol) {
  * @param {string} options.coverageFile
  * @param {Array<{file?: string, symbol: string}>} options.targets
  */
-export async function collectCoverageFacts({ coverageFile, targets = [] } = {}) {
+export async function collectCoverageFacts({ coverageFile, targets = [], lang = DEFAULT_LANG } = {}) {
+  const t = T(lang);
   const facts = [];
   const evaluated = [];
   const notEvaluated = [];
@@ -223,8 +225,12 @@ export async function collectCoverageFacts({ coverageFile, targets = [] } = {})
     notEvaluated.push(
       notEvaluatedEntry(
         KIND.TEST_COVERAGE,
-        `无法读取覆盖率数据 ${coverageFile}: ${error.code ?? error.message}。` +
-          '未运行测试或测试未产出覆盖率时，这属于「未评估」，不是「未被覆盖」'
+        t(
+          `无法读取覆盖率数据 ${coverageFile}: ${error.code ?? error.message}。` +
+            '未运行测试或测试未产出覆盖率时，这属于「未评估」，不是「未被覆盖」',
+          `cannot read coverage data ${coverageFile}: ${error.code ?? error.message}. ` +
+            'When no tests ran or none produced coverage, this is "not evaluated", not "not covered"'
+        )
       )
     );
     return { facts, evaluated, notEvaluated, measured: false };
@@ -245,8 +251,13 @@ export async function collectCoverageFacts({ coverageFile, targets = [] } = {})
     notEvaluated.push(
       notEvaluatedEntry(
         KIND.TEST_COVERAGE,
-        '覆盖率数据为空对象。这通常意味着测试运行没有加载到被测代码（常见于缺少 --all 或 --source），' +
-          '因此任何「未在数据中」的文件都必须按未覆盖处理，而这里连文件清单都没有'
+        t(
+          '覆盖率数据为空对象。这通常意味着测试运行没有加载到被测代码（常见于缺少 --all 或 --source），' +
+            '因此任何「未在数据中」的文件都必须按未覆盖处理，而这里连文件清单都没有',
+          'Coverage data is an empty object. This usually means the test run never loaded the code under test ' +
+            '(commonly a missing --all or --source), so any file "not in the data" must be treated as uncovered — ' +
+            'and here there is not even a file list'
+        )
       )
     );
     return { facts, evaluated, notEvaluated, measured: false };
@@ -260,15 +271,24 @@ export async function collectCoverageFacts({ coverageFile, targets = [] } = {})
     notEvaluated.push(
       notEvaluatedEntry(
         KIND.TEST_COVERAGE,
-        '覆盖率数据不是可识别的报告形状（既无 c8/istanbul 的 fnMap/f，也无 coverage.py 的 functions）——' +
-          '它可能根本不是覆盖率文件，任何「符号未定位/未覆盖」的结论在此都不可信'
+        t(
+          '覆盖率数据不是可识别的报告形状（既无 c8/istanbul 的 fnMap/f，也无 coverage.py 的 functions）——' +
+            '它可能根本不是覆盖率文件，任何「符号未定位/未覆盖」的结论在此都不可信',
+          'Coverage data is not a recognizable report shape (neither c8/istanbul\'s fnMap/f nor coverage.py\'s functions) — ' +
+            'it may not be a coverage file at all, and any "symbol not located / not covered" conclusion is untrustworthy here'
+        )
       )
     );
     return { facts, evaluated, notEvaluated, measured: false };
   }
 
   if (targets.length === 0) {
-    notEvaluated.push(notEvaluatedEntry(KIND.TEST_COVERAGE, '没有指定要查询的符号（--symbol）'));
+    notEvaluated.push(
+      notEvaluatedEntry(
+        KIND.TEST_COVERAGE,
+        t('没有指定要查询的符号（--symbol）', 'no symbol requested for query (--symbol)')
+      )
+    );
     return { facts, evaluated, notEvaluated, measured: false };
   }
 
@@ -277,8 +297,12 @@ export async function collectCoverageFacts({ coverageFile, targets = [] } = {})
       notEvaluated.push(
         notEvaluatedEntry(
           KIND.TEST_COVERAGE,
-          `${target.file} 命中默认排除规则（c8 排除 test/ 等目录），很可能根本不在覆盖率数据里。` +
-            '需要显式 --all（c8）或 --source（coverage.py）或调整 exclude 才能测到它'
+          t(
+            `${target.file} 命中默认排除规则（c8 排除 test/ 等目录），很可能根本不在覆盖率数据里。` +
+              '需要显式 --all（c8）或 --source（coverage.py）或调整 exclude 才能测到它',
+            `${target.file} matches a default exclusion rule (c8 excludes test/ etc.), so it is likely absent from the coverage data entirely. ` +
+              'Explicit --all (c8) or --source (coverage.py), or adjusting exclude, is required to measure it'
+          )
         )
       );
     }
@@ -293,8 +317,12 @@ export async function collectCoverageFacts({ coverageFile, targets = [] } = {})
           id: `coverage-${++counter}`,
           kind: KIND.TEST_COVERAGE,
           statement:
-            `${target.file} 完全没有出现在覆盖率数据中 —— 测试运行期间该文件未被加载，` +
-            `因此其中的符号 ${target.symbol} 未曾被执行`,
+            t(
+              `${target.file} 完全没有出现在覆盖率数据中 —— 测试运行期间该文件未被加载，` +
+                `因此其中的符号 ${target.symbol} 未曾被执行`,
+              `${target.file} does not appear in the coverage data at all — the file was never loaded during the test run, ` +
+                `so the symbol ${target.symbol} inside it was never executed`
+            ),
           status: STATUS.ESTABLISHED,
           evidence: { file: target.file },
           method: 'command',
@@ -322,8 +350,12 @@ export async function collectCoverageFacts({ coverageFile, targets = [] } = {})
               id: `coverage-${++counter}`,
               kind: KIND.TEST_COVERAGE,
               statement:
-                `符号 ${target.symbol} 在本次测试运行中一次都没有被调用（调用计数为 0）—— ` +
-                `任何依赖它的行为都没有被执行验证`,
+                t(
+                  `符号 ${target.symbol} 在本次测试运行中一次都没有被调用（调用计数为 0）—— ` +
+                    `任何依赖它的行为都没有被执行验证`,
+                  `Symbol ${target.symbol} was never invoked in this test run (invocation count 0) — ` +
+                    `any behavior depending on it was never exercised`
+                ),
               status: STATUS.ESTABLISHED,
               evidence: { file: entryPath, line },
               method: 'command',
@@ -341,10 +373,18 @@ export async function collectCoverageFacts({ coverageFile, targets = [] } = {})
               kind: KIND.TEST_COVERAGE,
               statement:
                 isPy
-                  ? `符号 ${target.symbol} 至少被调用过一次，但被调用**不能**证明任何特定调用点执行过 —— ` +
-                    `本事实只能证伪，不能证实`
-                  : `符号 ${target.symbol} 被调用了 ${count} 次，但调用计数非零**不能**证明任何特定调用点执行过 —— ` +
-                    `本事实只能证伪，不能证实`,
+                  ? t(
+                      `符号 ${target.symbol} 至少被调用过一次，但被调用**不能**证明任何特定调用点执行过 —— ` +
+                        `本事实只能证伪，不能证实`,
+                      `Symbol ${target.symbol} was invoked at least once, but being invoked **cannot** prove any specific call site ran — ` +
+                        `this fact can only falsify, never confirm`
+                    )
+                  : t(
+                      `符号 ${target.symbol} 被调用了 ${count} 次，但调用计数非零**不能**证明任何特定调用点执行过 —— ` +
+                        `本事实只能证伪，不能证实`,
+                      `Symbol ${target.symbol} was invoked ${count} time(s), but a non-zero invocation count **cannot** prove any specific call site ran — ` +
+                        `this fact can only falsify, never confirm`
+                    ),
               status: STATUS.UNKNOWN,
               evidence: { file: entryPath, line },
               method: 'command',
@@ -366,13 +406,19 @@ export async function collectCoverageFacts({ coverageFile, targets = [] } = {})
           id: `coverage-${++counter}`,
           kind: KIND.TEST_COVERAGE,
           statement:
-            `未能在覆盖率数据中定位符号 ${target.symbol}` +
-            (target.file ? `（限定文件 ${target.file}）` : '') +
+            t(
+              `未能在覆盖率数据中定位符号 ${target.symbol}`,
+              `Could not locate symbol ${target.symbol} in the coverage data`
+            ) +
+            (target.file ? t(`（限定文件 ${target.file}）`, ` (restricted to file ${target.file})`) : '') +
             (isPy
-              ? ' —— 可能是被重命名、被内联，或它只在模块顶层出现'
-              : ' —— 可能是被重命名、被内联，或它只在模块顶层出现（c8 把这类调用点放在 branchMap 而非 fnMap）'),
+              ? t(' —— 可能是被重命名、被内联，或它只在模块顶层出现', ' — it may have been renamed, inlined, or it only appears at module top level')
+              : t(
+                  ' —— 可能是被重命名、被内联，或它只在模块顶层出现（c8 把这类调用点放在 branchMap 而非 fnMap）',
+                  ' — it may have been renamed, inlined, or it only appears at module top level (c8 places such call sites in branchMap, not fnMap)'
+                )),
           status: STATUS.UNKNOWN,
-          evidence: { file: target.file ?? '(未限定文件)' },
+          evidence: { file: target.file ?? t('(未限定文件)', '(unrestricted file)') },
           method: 'static',
           detail: { symbol: target.symbol, reason: 'symbol_not_located_in_fnmap' }
         })

package/src/facts/deps.js

@@ -24,6 +24,7 @@
 import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { makeFact, notEvaluated as notEvaluatedEntry, KIND, STATUS, shellQuote } from '../contract.js';
+import { T, DEFAULT_LANG } from '../lang.js';
 
 /** Formats this producer can parse, and the filenames that select them. */
 const SUPPORTED = [
@@ -149,7 +150,8 @@ function resolveGo(text, dep) {
  * that cannot be read. The throw happens once, up front, so a malformed file
  * becomes one notEvaluated reason instead of one failed fact per dependency.
  */
-function makeResolver(type, text) {
+function makeResolver(type, text, lang = DEFAULT_LANG) {
+  const t = T(lang);
   if (type === 'npm') {
     const root = JSON.parse(text); // throws on malformed JSON
     // A syntactically valid but structurally empty file (e.g. `{}`) is not a
@@ -160,23 +162,38 @@ function makeResolver(type, text) {
       typeof root !== 'object' ||
       (root.packages === undefined && root.dependencies === undefined && root.lockfileVersion === undefined)
     ) {
-      throw new Error('package-lock.json 结构不完整（缺 lockfileVersion/packages/dependencies），不像真实的 npm 锁文件');
+      throw new Error(
+        t(
+          'package-lock.json 结构不完整（缺 lockfileVersion/packages/dependencies），不像真实的 npm 锁文件',
+          'package-lock.json is structurally incomplete (missing lockfileVersion/packages/dependencies); it does not look like a real npm lockfile'
+        )
+      );
     }
     return (dep) => resolveNpm(root, dep, text);
   }
   if (type === 'cargo') {
     if (!/\[\[package\]\]|^version\s*=/m.test(text)) {
-      throw new Error('Cargo.lock 结构不完整（无 [[package]] 块或 version 头），不像真实的 Cargo 锁文件');
+      throw new Error(
+        t(
+          'Cargo.lock 结构不完整（无 [[package]] 块或 version 头），不像真实的 Cargo 锁文件',
+          'Cargo.lock is structurally incomplete (no [[package]] blocks or version header); it does not look like a real Cargo lockfile'
+        )
+      );
     }
     return (dep) => resolveCargo(text, dep);
   }
   if (type === 'go') {
     if (!/^module\s+\S+/m.test(text)) {
-      throw new Error('go.mod 结构不完整（无 module 行），不像真实的 go.mod');
+      throw new Error(
+        t(
+          'go.mod 结构不完整（无 module 行），不像真实的 go.mod',
+          'go.mod is structurally incomplete (no module line); it does not look like a real go.mod'
+        )
+      );
     }
     return (dep) => resolveGo(text, dep);
   }
-  throw new Error(`不受支持的依赖清单格式: ${type}`);
+  throw new Error(t(`不受支持的依赖清单格式: ${type}`, `unsupported dependency manifest format: ${type}`));
 }
 
 function typeForFile(name) {
@@ -222,14 +239,20 @@ async function unsupportedIn(cwd) {
  * @param {string} [options.lockfile]  explicit manifest path (overrides detection)
  * @param {string[]} options.deps  dependency names to query (repeatable)
  */
-export async function collectDependencyFacts({ cwd = process.cwd(), lockfile, deps = [] } = {}) {
+export async function collectDependencyFacts({ cwd = process.cwd(), lockfile, deps = [], lang = DEFAULT_LANG } = {}) {
+  const t = T(lang);
   const facts = [];
   const evaluated = [];
   const notEvaluated = [];
   let counter = 0;
 
   if (deps.length === 0) {
-    notEvaluated.push(notEvaluatedEntry(KIND.DEPENDENCY, '没有指定要查询的依赖（--dep）'));
+    notEvaluated.push(
+      notEvaluatedEntry(
+        KIND.DEPENDENCY,
+        t('没有指定要查询的依赖（--dep）', 'no dependency requested for query (--dep)')
+      )
+    );
     return { facts, evaluated, notEvaluated, measured: false };
   }
 
@@ -241,7 +264,10 @@ export async function collectDependencyFacts({ cwd = process.cwd(), lockfile, de
       await stat(filePath);
     } catch {
       notEvaluated.push(
-        notEvaluatedEntry(KIND.DEPENDENCY, `无法读取依赖清单 ${filePath}: ENOENT`)
+        notEvaluatedEntry(
+          KIND.DEPENDENCY,
+          t(`无法读取依赖清单 ${filePath}: ENOENT`, `cannot read dependency manifest ${filePath}: ENOENT`)
+        )
       );
       return { facts, evaluated, notEvaluated, measured: false };
     }
@@ -249,7 +275,10 @@ export async function collectDependencyFacts({ cwd = process.cwd(), lockfile, de
       notEvaluated.push(
         notEvaluatedEntry(
           KIND.DEPENDENCY,
-          `${path.basename(filePath)} 不是受支持的依赖清单格式；本产出器支持 package-lock.json / Cargo.lock / go.mod`
+          t(
+            `${path.basename(filePath)} 不是受支持的依赖清单格式；本产出器支持 package-lock.json / Cargo.lock / go.mod`,
+            `${path.basename(filePath)} is not a supported dependency manifest format; this producer supports package-lock.json / Cargo.lock / go.mod`
+          )
         )
       );
       return { facts, evaluated, notEvaluated, measured: false };
@@ -260,8 +289,14 @@ export async function collectDependencyFacts({ cwd = process.cwd(), lockfile, de
     if (found.length === 0) {
       const unsupported = await unsupportedIn(cwd);
       const reason = unsupported.length
-        ? `检测到 ${unsupported.join('、')}，但 Tier 0 暂不支持；本产出器支持 package-lock.json / Cargo.lock / go.mod`
-        : '未找到受支持的依赖清单（package-lock.json / Cargo.lock / go.mod），没有可测量的锁定版本';
+        ? t(
+            `检测到 ${unsupported.join('、')}，但 Tier 0 暂不支持；本产出器支持 package-lock.json / Cargo.lock / go.mod`,
+            `detected ${unsupported.join(', ')}, but Tier 0 does not support them yet; this producer supports package-lock.json / Cargo.lock / go.mod`
+          )
+        : t(
+            '未找到受支持的依赖清单（package-lock.json / Cargo.lock / go.mod），没有可测量的锁定版本',
+            'no supported dependency manifest found (package-lock.json / Cargo.lock / go.mod); no pinned versions to measure'
+          );
       notEvaluated.push(notEvaluatedEntry(KIND.DEPENDENCY, reason));
       return { facts, evaluated, notEvaluated, measured: false };
     }
@@ -275,7 +310,10 @@ export async function collectDependencyFacts({ cwd = process.cwd(), lockfile, de
       notEvaluated.push(
         notEvaluatedEntry(
           KIND.DEPENDENCY,
-          `同目录还检测到 ${unsupported.join('、')}（Tier 0 暂不支持），本次只测了 ${target.file}`
+          t(
+            `同目录还检测到 ${unsupported.join('、')}（Tier 0 暂不支持），本次只测了 ${target.file}`,
+            `also detected ${unsupported.join(', ')} in the same directory (Tier 0 does not support them yet); only ${target.file} was measured this run`
+          )
         )
       );
     }
@@ -286,26 +324,36 @@ export async function collectDependencyFacts({ cwd = process.cwd(), lockfile, de
     text = await readFile(target.path, 'utf8');
   } catch (error) {
     notEvaluated.push(
-      notEvaluatedEntry(KIND.DEPENDENCY, `无法读取 ${target.path}: ${error.code ?? error.message}`)
+      notEvaluatedEntry(
+        KIND.DEPENDENCY,
+        t(
+          `无法读取 ${target.path}: ${error.code ?? error.message}`,
+          `cannot read ${target.path}: ${error.code ?? error.message}`
+        )
+      )
     );
     return { facts, evaluated, notEvaluated, measured: false };
   }
 
   let resolver;
   try {
-    resolver = makeResolver(target.type, text);
+    resolver = makeResolver(target.type, text, lang);
   } catch (error) {
     notEvaluated.push(
       notEvaluatedEntry(
         KIND.DEPENDENCY,
-        `${target.path} 解析失败（${target.type}）：${error.message}`
+        t(
+          `${target.path} 解析失败（${target.type}）：${error.message}`,
+          `${target.path} failed to parse (${target.type}): ${error.message}`
+        )
       )
     );
     return { facts, evaluated, notEvaluated, measured: false };
   }
 
-  const verb = target.type === 'go' ? '声明' : '锁定';
-  const listLabel = target.type === 'go' ? 'go.mod' : 'lockfile';
+  const isGo = target.type === 'go';
+  const verb = isGo ? t('声明', 'declared') : t('锁定', 'locked');
+  const listLabel = isGo ? 'go.mod' : 'lockfile';
 
   for (const dep of deps) {
     const hits = resolver(dep);
@@ -319,10 +367,16 @@ export async function collectDependencyFacts({ cwd = process.cwd(), lockfile, de
           id: `dependency-${++counter}`,
           kind: KIND.DEPENDENCY,
           statement:
-            `依赖 ${dep} 在 ${listLabel}（${target.type}）中被${verb}为版本 ${versions.join(' / ')}` +
-            (target.type === 'go'
-              ? ' —— 这是声明的需求版本，非最终解析版本（go.sum 不含版本，无法在此验证解析结果）'
-              : ''),
+            t(
+              `依赖 ${dep} 在 ${listLabel}（${target.type}）中被${verb}为版本 ${versions.join(' / ')}` +
+                (isGo
+                  ? ' —— 这是声明的需求版本，非最终解析版本（go.sum 不含版本，无法在此验证解析结果）'
+                  : ''),
+              isGo
+                ? `Dependency ${dep} is declared as version ${versions.join(' / ')} in the ${listLabel} (${target.type})` +
+                  ' — this is the declared requirement version, not the final resolved version (go.sum carries no versions, so the resolution cannot be verified here)'
+                : `Dependency ${dep} is locked to version ${versions.join(' / ')} in the ${listLabel} (${target.type})`
+            ),
           status: STATUS.ESTABLISHED,
           evidence: { file: target.path, ...(first.line ? { line: first.line } : {}) },
           method: 'command',
@@ -334,7 +388,7 @@ export async function collectDependencyFacts({ cwd = process.cwd(), lockfile, de
             // go.mod declares a requirement; calling it "resolved" would let a
             // consumer mistake it for the final build version. The field name
             // must not oversell what the source can prove.
-            ...(target.type === 'go' ? { declaredVersions: versions } : { resolvedVersions: versions }),
+            ...(isGo ? { declaredVersions: versions } : { resolvedVersions: versions }),
             locations: hits.map((h) => h.location)
           }
         })
@@ -344,7 +398,10 @@ export async function collectDependencyFacts({ cwd = process.cwd(), lockfile, de
         makeFact({
           id: `dependency-${++counter}`,
           kind: KIND.DEPENDENCY,
-          statement: `依赖 ${dep} 未出现在 ${listLabel}（${target.type}）的依赖树中 —— 声称它影响本应用的声明在此被证伪`,
+          statement: t(
+            `依赖 ${dep} 未出现在 ${listLabel}（${target.type}）的依赖树中 —— 声称它影响本应用的声明在此被证伪`,
+            `Dependency ${dep} does not appear in the dependency tree of the ${listLabel} (${target.type}) — the claim that it affects this application is falsified here`
+          ),
           status: STATUS.ESTABLISHED,
           evidence: { file: target.path },
           method: 'command',
@@ -352,7 +409,7 @@ export async function collectDependencyFacts({ cwd = process.cwd(), lockfile, de
           detail: {
             lockfileType: target.type,
             dependency: dep,
-            ...(target.type === 'go' ? { declaredVersions: [] } : { resolvedVersions: [] }),
+            ...(isGo ? { declaredVersions: [] } : { resolvedVersions: [] }),
             reason: 'absent_from_lockfile'
           }
         })

package/src/facts/history.js

@@ -11,6 +11,7 @@
  */
 import { git, commitSummaries } from '../git.js';
 import { makeFact, notEvaluated as notEvaluatedEntry, KIND, STATUS, shellQuote } from '../contract.js';
+import { T, DEFAULT_LANG } from '../lang.js';
 
 /**
  * Strong signal: the commit is about security.
@@ -216,8 +217,10 @@ export async function collectHistoryFacts({
   origins = false,
   maxOrigins = 40,
   securityPattern = SECURITY_PATTERN,
-  fixPattern = FIX_PATTERN
+  fixPattern = FIX_PATTERN,
+  lang = DEFAULT_LANG
 } = {}) {
+  const t = T(lang);
   const facts = [];
   const evaluated = [];
   const notEvaluated = [];
@@ -229,7 +232,13 @@ export async function collectHistoryFacts({
 
   if (files.length === 0) {
     notEvaluated.push(
-      notEvaluatedEntry('history', `范围 ${base}..${head} 内没有文件变更，没有可归属的删除行`)
+      notEvaluatedEntry(
+        'history',
+        t(
+          `范围 ${base}..${head} 内没有文件变更，没有可归属的删除行`,
+          `No file changes in ${base}..${head}; no deleted lines to attribute`
+        )
+      )
     );
     return { facts, evaluated, notEvaluated, files, measured: true };
   }
@@ -271,8 +280,12 @@ export async function collectHistoryFacts({
     notEvaluated.push(
       notEvaluatedEntry(
         'history',
-        `范围 ${base}..${head} 内有 ${files.length} 个文件变更，但没有任何一行被删除，` +
-          '因此没有可归属的历史来源'
+        t(
+          `范围 ${base}..${head} 内有 ${files.length} 个文件变更，但没有任何一行被删除，` +
+            '因此没有可归属的历史来源',
+          `Range ${base}..${head} changes ${files.length} file(s) but deletes no lines; ` +
+            'there is no attributable history source'
+        )
       )
     );
   }
@@ -369,7 +382,10 @@ export async function collectHistoryFacts({
       notEvaluated.push(
         notEvaluatedEntry(
           'history-origins',
-          `git log -S 来源探针上限 ${maxOrigins} 已用尽，其余删除行保留 blame 归属`
+          t(
+            `git log -S 来源探针上限 ${maxOrigins} 已用尽，其余删除行保留 blame 归属`,
+            `git log -S origin probe cap (${maxOrigins}) exhausted; remaining deleted lines keep their blame attribution`
+          )
         )
       );
     }
@@ -377,8 +393,12 @@ export async function collectHistoryFacts({
       notEvaluated.push(
         notEvaluatedEntry(
           'history-origins',
-          `${shortSkipped} 行内容过短（< ${MIN_PICKAXE_LINE_LENGTH} 字符），` +
-            '未做来源追溯（太通用时 -S 会指向整个历史的第一个提交而非真实来源），保留 blame 归属'
+          t(
+            `${shortSkipped} 行内容过短（< ${MIN_PICKAXE_LINE_LENGTH} 字符），` +
+              '未做来源追溯（太通用时 -S 会指向整个历史的第一个提交而非真实来源），保留 blame 归属',
+            `${shortSkipped} line(s) too short (< ${MIN_PICKAXE_LINE_LENGTH} chars); ` +
+              'no origin tracing done (for generic content, -S points at the first commit of the whole history rather than a real origin); blame attribution kept'
+          )
         )
       );
     }
@@ -386,8 +406,12 @@ export async function collectHistoryFacts({
     notEvaluated.push(
       notEvaluatedEntry(
         'history-origins',
-        '未启用 --origins，删除行的归属基于 git blame 的「最后修改」语义；' +
-          '被删行本身或提交 diff 含安全关键词时仍会标为 security'
+        t(
+          '未启用 --origins，删除行的归属基于 git blame 的「最后修改」语义；' +
+            '被删行本身或提交 diff 含安全关键词时仍会标为 security',
+          '--origins not enabled; deleted lines are attributed by git blame\'s "last modified" semantics; ' +
+            'lines whose content or commit diff contains security vocabulary are still classified security'
+        )
       )
     );
   }
@@ -395,8 +419,9 @@ export async function collectHistoryFacts({
   // Split every blame group into its remainder (blame attribution) and its
   // refined subsets (one fact per origin commit). Each becomes a fact.
   const pending = [];
+  const unreadableSubject = () => t('(提交信息不可读)', '(unreadable commit message)');
   for (const [hash, entry] of blameByCommit) {
-    const summary = summaries.get(hash) ?? { subject: '(提交信息不可读)', author: null, date: null };
+    const summary = summaries.get(hash) ?? { subject: unreadableSubject(), author: null, date: null };
     const groups = originGroups.get(hash);
     if (!groups) {
       pending.push({ hash, entry, summary, originMethod: 'blame' });
@@ -436,7 +461,7 @@ export async function collectHistoryFacts({
           lines: [...group.byFile.values()].reduce((sum, a) => sum + a.length, 0),
           byFile: group.byFile
         },
-        summary: group.summary ?? { subject: '(提交信息不可读)', author: null, date: null },
+        summary: group.summary ?? { subject: unreadableSubject(), author: null, date: null },
         originMethod: 'pickaxe',
         blameCommit: hash,
         contents: group.contents
@@ -493,13 +518,25 @@ export async function collectHistoryFacts({
     // the wrong place and makes an accurate attribution look wrong.
     const originPhrase =
       originMethod === 'pickaxe'
-        ? `本次变更删除了 ${entry.lines} 行代码，其内容最初由提交 ${hash.slice(0, 10)} 引入` +
-          `（git blame 的最后修改者是 ${blameCommit.slice(0, 10)}）`
-        : `本次变更删除了 ${entry.lines} 行来自提交 ${hash.slice(0, 10)} 的代码`;
+        ? t(
+            `本次变更删除了 ${entry.lines} 行代码，其内容最初由提交 ${hash.slice(0, 10)} 引入` +
+              `（git blame 的最后修改者是 ${blameCommit.slice(0, 10)}）`,
+            `This change deleted ${entry.lines} lines whose content was first introduced by commit ${hash.slice(0, 10)} ` +
+              `(git blame's last modifier is ${blameCommit.slice(0, 10)})`
+          )
+        : t(
+            `本次变更删除了 ${entry.lines} 行来自提交 ${hash.slice(0, 10)} 的代码`,
+            `This change deleted ${entry.lines} lines of code from commit ${hash.slice(0, 10)}`
+          );
     const statement =
       originPhrase +
-      (fileCount > 1 ? `，分布在 ${fileCount} 个文件` : `（文件：${byFile[0].file}）`) +
-      `。提交信息：${JSON.stringify(summary.subject)}，分类：${classification}`;
+      (fileCount > 1
+        ? t(`，分布在 ${fileCount} 个文件`, `, spread across ${fileCount} files`)
+        : t(`（文件：${byFile[0].file}）`, ` (file: ${byFile[0].file})`)) +
+      t(
+        `。提交信息：${JSON.stringify(summary.subject)}，分类：${classification}`,
+        `. Commit message: ${JSON.stringify(summary.subject)}, classification: ${classification}`
+      );
 
     const detail = {
       classification,
@@ -514,8 +551,14 @@ export async function collectHistoryFacts({
       // covers lines in the other files too.
       reproductionNote:
         fileCount > 1
-          ? `上面的命令只复现「${primary.file}」中的归属；其余 ${fileCount - 1} 个文件的行区间见 byFile`
-          : '上面的命令复现本事实涉及的全部行'
+          ? t(
+              `上面的命令只复现「${primary.file}」中的归属；其余 ${fileCount - 1} 个文件的行区间见 byFile`,
+              `The command above only reproduces the attribution for "${primary.file}"; the other ${fileCount - 1} file(s) line ranges are in byFile`
+            )
+          : t(
+              '上面的命令复现本事实涉及的全部行',
+              'The command above reproduces every line this fact covers'
+            )
     };
 
     if (originMethod === 'pickaxe') {
@@ -552,7 +595,13 @@ export async function collectHistoryFacts({
 
   if (ranked.length === 0 && linesByFile.size > 0) {
     notEvaluated.push(
-      notEvaluatedEntry('history', '有删除行但 blame 未能归属到任何提交（可能是二进制文件或路径异常）')
+      notEvaluatedEntry(
+        'history',
+        t(
+          '有删除行但 blame 未能归属到任何提交（可能是二进制文件或路径异常）',
+          'Deleted lines exist but blame could not attribute them to any commit (possibly binary files or path anomalies)'
+        )
+      )
     );
   }
 
@@ -565,7 +614,8 @@ export async function collectHistoryFacts({
       maxPickaxe,
       securityPattern,
       fixPattern,
-      startCounter: counter
+      startCounter: counter,
+      lang
     });
     facts.push(...reintro.facts);
     counter = reintro.counter;
@@ -573,7 +623,10 @@ export async function collectHistoryFacts({
     notEvaluated.push(...reintro.notEvaluated);
   } else {
     notEvaluated.push(
-      notEvaluatedEntry('reintroduction', '未启用 --pickaxe，未检查「被移除又加回」的代码行')
+      notEvaluatedEntry(
+        'reintroduction',
+        t('未启用 --pickaxe，未检查「被移除又加回」的代码行', '--pickaxe not enabled; reintroduced lines were not checked')
+      )
     );
   }
 
@@ -602,8 +655,10 @@ async function collectReintroductionFacts({
   maxPickaxe,
   securityPattern,
   fixPattern,
-  startCounter
+  startCounter,
+  lang = DEFAULT_LANG
 }) {
+  const t = T(lang);
   const facts = [];
   const notEvaluated = [];
   let counter = startCounter;
@@ -654,9 +709,15 @@ async function collectReintroductionFacts({
           id: `reintroduction-${++counter}`,
           kind: KIND.REINTRODUCTION,
           statement:
-            `本次变更加回了一行在 ${base} 中不存在的代码，而该行的出现次数曾被 ${hashes.length} 个提交改变` +
+            t(
+              `本次变更加回了一行在 ${base} 中不存在的代码，而该行的出现次数曾被 ${hashes.length} 个提交改变`,
+              `This change re-adds a line that did not exist at ${base}, and whose occurrence count was changed by ${hashes.length} commit(s)`
+            ) +
             (securityOrigin
-              ? `，其中提交 ${securityOrigin.hash.slice(0, 10)} 的提交信息含安全关键词`
+              ? t(
+                  `，其中提交 ${securityOrigin.hash.slice(0, 10)} 的提交信息含安全关键词`,
+                  `, and commit ${securityOrigin.hash.slice(0, 10)} has security vocabulary in its message`
+                )
               : ''),
           status: STATUS.ESTABLISHED,
           evidence: { file, snippet: line.slice(0, 160), commit: hashes[0] },
@@ -682,7 +743,10 @@ async function collectReintroductionFacts({
     notEvaluated.push(
       notEvaluatedEntry(
         'reintroduction',
-        `pickaxe 探针上限 ${maxPickaxe} 已用尽，另有 ${candidates - probed} 行新增代码未检查`
+        t(
+          `pickaxe 探针上限 ${maxPickaxe} 已用尽，另有 ${candidates - probed} 行新增代码未检查`,
+          `pickaxe probe cap (${maxPickaxe}) exhausted; ${candidates - probed} added line(s) were not checked`
+        )
       )
     );
   }