euthyna 0.2.0 → 0.3.1

package/src/contract.js

@@ -15,6 +15,7 @@
  */
 
 import { stripVTControlCharacters } from 'node:util';
+import { T, DEFAULT_LANG } from './lang.js';
 
 export const SCHEMA_VERSION = '0.1';
 
@@ -189,10 +190,11 @@ export function notEvaluated(kind, reason) {
  * Ordering is deliberate: what was NOT measured comes last but is never
  * omitted, so a reader cannot finish the output without seeing it.
  */
-export function renderReport(report, { write: rawWrite = console.log } = {}) {
+export function renderReport(report, { write: rawWrite = console.log, lang = DEFAULT_LANG } = {}) {
   // Render boundary: every repo-controlled string below passes through safeText
   // exactly once, here, rather than at each producer. The JSON channel
   // (cli.js) needs no equivalent — JSON.stringify escapes control bytes.
+  const t = T(lang);
   const write = (line) => rawWrite(safeText(line));
   const { producer, subject, facts, coverage } = report;
 
@@ -202,9 +204,9 @@ export function renderReport(report, { write: rawWrite = console.log } = {}) {
 
   write('');
   write(`euthyna ${producer.name} — ${producer.purpose || ''}`.trim());
-  write(`目标: ${subject.repo ?? subject.coverageFile ?? '(未指定)'}`);
+  write(`${t('目标: ', 'Target: ')}${subject.repo ?? subject.coverageFile ?? t('(未指定)', '(unspecified)')}`);
   if (subject.base || subject.head) {
-    write(`范围: ${subject.base ?? '?'}..${subject.head ?? 'HEAD'}`);
+    write(`${t('范围: ', 'Range: ')}${subject.base ?? '?'}..${subject.head ?? 'HEAD'}`);
   }
   write('');
 
@@ -214,26 +216,26 @@ export function renderReport(report, { write: rawWrite = console.log } = {}) {
     for (const fact of list) {
       write(`  • ${fact.statement}`);
       const where = [fact.evidence.file, fact.evidence.line].filter(Boolean).join(':');
-      write(`      证据: ${where}${fact.evidence.commit ? ` (${fact.evidence.commit.slice(0, 10)})` : ''}`);
-      if (fact.command) write(`      复现: ${fact.command}`);
+      write(`       ${t('证据: ', 'Evidence: ')}${where}${fact.evidence.commit ? ` (${fact.evidence.commit.slice(0, 10)})` : ''}`);
+      if (fact.command) write(`       ${t('复现: ', 'Reproduce: ')}${fact.command}`);
       if (fact.confidence === 'approximate') {
-        write('      ⚠ approximate —— 不得用于门禁判定');
+        write(t('      ⚠ approximate —— 不得用于门禁判定', '      ⚠ approximate — must not be used for gate adjudication'));
       }
     }
     write('');
   };
 
-  section('已确证', established);
-  section('已证伪', refuted);
-  section('无法判定', unknown);
+  section(t('已确证', 'Established'), established);
+  section(t('已证伪', 'Refuted'), refuted);
+  section(t('无法判定', 'Unknown'), unknown);
 
   if (facts.length === 0) {
-    write('  本次运行没有产出任何事实。');
+    write(t('  本次运行没有产出任何事实。', '  This run produced no facts.'));
     write('');
   }
 
   if (coverage.notEvaluated.length > 0) {
-    write('⚠ 未评估的判据（缺数据不等于干净）：');
+    write(t('⚠ 未评估的判据（缺数据不等于干净）：', '⚠ Criteria not evaluated (missing data is not clean):'));
     for (const item of coverage.notEvaluated) {
       write(`  • ${item.kind}: ${item.reason}`);
     }
@@ -241,9 +243,14 @@ export function renderReport(report, { write: rawWrite = console.log } = {}) {
   }
 
   if (coverage.evaluated.length > 0) {
-    write('已评估的判据：');
+    write(t('已评估的判据：', 'Evaluated criteria:'));
     for (const item of coverage.evaluated) {
-      write(`  • ${item.kind}: ${item.count} 条 (${item.producer})`);
+      write(
+        t(
+          `  • ${item.kind}: ${item.count} 条 (${item.producer})`,
+          `  • ${item.kind}: ${item.count} (${item.producer})`
+        )
+      );
     }
     write('');
   }

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'
           }
         })