@boyingliu01/xp-gate 0.35.19 → 0.35.20

package/hooks/pre-commit

@@ -4017,6 +4017,30 @@ else
 
   # Check if architecture config exists (use $PROJECT_ROOT — hook may have cd'd to a subdir via ARCH-03)
   if [ -f "$PROJECT_ROOT/architecture.yaml" ] || [ -f "$PROJECT_ROOT/.architecturerc" ] || [ -f "$PROJECT_ROOT/.archlint.yaml" ]; then
+    # #686: an `architecture.yaml` is NOT evidence that layer boundaries are
+    # checked. Gate 6 only ever tested for the file's existence; archlint is
+    # invoked without --config, and even with a config it cannot enforce layers:
+    # @archlinter/cli 0.16.0 lists a `layer_violation` detector but produces no
+    # results for it under any configuration (-A, -d layer_violation, enabled:
+    # true, globs, exact paths — all exit 0 with zero layer findings). See
+    # docs/plans/2026-11-02-arch-01-gate6-layers-not-enforced-design.md §2.2.
+    #
+    # So a repo that declares layers gets a generic-smell check and a green
+    # verdict, which reads as "layers are clean". It is not: nothing looked.
+    # This block records that fact as a per-language reason so the quality
+    # report cannot score the dimension as covered, and emits a marker the
+    # terminal output can be asserted against.
+    #
+    # Deliberately NOT a capability probe: archlint silently tolerates unknown
+    # config keys, so "it did not complain" is a tautological guard — it would
+    # return "supported" no matter what. File presence is the only honest input.
+    GATE_6_LAYERS_UNCHECKED=0
+    if [ -f "$PROJECT_ROOT/architecture.yaml" ] || [ -f "$PROJECT_ROOT/.architecturerc" ]; then
+      GATE_6_LAYERS_UNCHECKED=1
+      echo "     ⚠️  [WARN:LAYERS_UNCHECKED] 分层规则未校验：architecture.yaml 声明的层边界当前不被任何检测器消费"
+      echo "        (实测 @archlinter/cli 0.16.0 的 layer_violation 启用后亦无输出；见 #686)"
+      echo "        本次仅校验通用架构坏味道（循环依赖 / 上帝类 / 死代码）。"
+    fi
     # #537: per-language reason bookkeeping. Gate 3/4 are single-language gates
     # and get away with one scalar reason; Gate 6 loops, so a scalar would lose
     # information ("TS passed, PS has no detector" cannot be one string).
@@ -4265,6 +4289,20 @@ JAVAARCHROOTS
     GATE_6_LANG_REASONS=""
     _g6_seen=""
     _g6_mixed=0
+    # #686: a language that archlint actually measured and passed still carries a
+    # reason when the repo declared layer boundaries, because the layer dimension
+    # itself was never measured. Only languages WITHOUT a reason get this stamp —
+    # an existing reason (tool missing, tests failed, ...) is more specific and
+    # must not be overwritten. The `-z` test is what keeps this honest: stamping
+    # unconditionally would erase the real reason and make every language look
+    # alike in the report.
+    if [ "${GATE_6_LAYERS_UNCHECKED:-0}" = "1" ] && [ "${BASH_VERSINFO[0]:-0}" -ge 4 ]; then
+      for _g6_lang in $PROJECT_LANGS; do
+        if [ -z "${GATE_6_REASON_BY_LANG[$_g6_lang]:-}" ]; then
+          GATE_6_REASON_BY_LANG["$_g6_lang"]="layers_config_not_enforced"
+        fi
+      done
+    fi
     for _g6_lang in $PROJECT_LANGS; do
       _g6_r=""
       if [ "${BASH_VERSINFO[0]:-0}" -ge 4 ]; then
@@ -4313,19 +4351,27 @@ JAVAARCHROOTS
       echo "   Required configuration file (.archlint.yaml / architecture.yaml) is NOT found."
       echo "   Architecture Quality Gate requires explicit architecture constraints."
       echo ""
-  echo "   Quick fix: create .archlint.yaml with: npx archlint init --no-interactive"
-      echo "   Or architecture.yaml for custom Clean Architecture layer definitions:"
-      echo "     layers:"
-      echo "       - name: api"
-      echo "         paths: [\"src/api/**\"]"
-      echo "       - name: domain"
-      echo "         paths: [\"src/domain/**\"]"
-      echo "         allowed_imports: [domain]"
-      echo "       - name: infrastructure"
-      echo "         paths: [\"src/infrastructure/**\"]"
-      echo "         allowed_imports: [domain, infrastructure]"
+      echo "   Quick fix: create .archlint.yaml with: npx archlint init --no-interactive"
+      echo "   Or write one by hand — this is archlint's own config format, and the"
+      echo "   only one it actually reads:"
+      echo "     rules:"
+      echo "       cyclic_dependency:"
+      echo "         severity: high"
+      echo "       god_module:"
+      echo "         severity: high"
+      echo ""
+      # #686: this used to recommend a top-level `layers:` block. That format is
+      # silently ignored by @archlinter/cli 0.16.0 (verified against a fixture
+      # with a textbook domain->infra violation: the layer_violation detector is
+      # listed by `archlint detectors list` but produces no results under any
+      # configuration, including -A and an explicit -d layer_violation). The hint
+      # therefore taught users to write a file that bought them nothing while
+      # Gate 6 reported green — the worst possible combination.
+      echo "   NOTE: layer-boundary rules are NOT enforced by archlint 0.16.0."
+      echo "   Do not write a top-level 'layers:' block expecting it to be checked;"
+      echo "   Gate 6 will tell you when that changes. See #686 / #690 / #692."
       echo ""
-      echo "   After creating architecture.yaml, retry the commit."
+      echo "   After creating the config, retry the commit."
       echo "   (To skip with warning, create .architecture-skip file)"
       exit 1
     fi

package/lib/__tests__/sprint-status-rework-704.test.js

@@ -0,0 +1,149 @@
+/**
+ * @test REQ-704 Sprint Status 返工率
+ * @intent `--rework-check` 的返工率恒为 0，且会把任何正确的值覆盖成 0。
+ *
+ *         根因有两层，必须同时修好才算真的修好：
+ *         (1) 统计区间的下界用了 `completed_at` —— 按定义它是 sprint **结束**的
+ *             时刻，而 sprint 的全部提交都发生在它之前。于是 `git log --since
+ *             <completed_at>` 返回空集。要统计的区间是「开始 → 结束」，
+ *             实际统计的区间是「结束 → 现在」，恰好是空的。
+ *         (2) `total_sprint_commits` 从未被计算过，只被读取（值恒为 0），
+ *             再经 `Math.max(total, 1)` 兜底成 1，使 `0/1` 恒等于 0。
+ *
+ *         这是一个质量指标的 fail-open：返工率是 #369 用来暴露「门禁全过但仍
+ *         返工」的唯一信号，恒为 0 意味着返工永远不可观测，而 CLI 还会主动打印
+ *         「All sprints within acceptable rework rate」。告警阈值永不触发。
+ *
+ *         测试必须用真实 git 仓库：这个 bug 的全部性质都藏在 `git log --since`
+ *         的行为里，任何 mock 都能让它「通过」。
+ * @covers AC-704-01, AC-704-02, AC-704-03, AC-704-04
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const sprintStatus = require('../sprint-status');
+
+function git(cwd, args, env = {}) {
+  // `-c core.hooksPath=` disables hooks for this fixture. Without it, the
+  // temporary repo inherits this machine's global hooksPath and every fixture
+  // commit runs the full pre-commit suite (~60s each, and it can BLOCK on
+  // unrelated file-hygiene findings in .xp-gate/reports). The test asserts on
+  // `git log`, so hooks contribute nothing but time and flakiness.
+  return execFileSync('git', ['-c', 'core.hooksPath=', ...args], {
+    cwd,
+    encoding: 'utf8',
+    env: { ...process.env, ...env },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+}
+
+/** Capture console.log so assertions read the CLI output, not a return value. */
+function captureLogs(fn) {
+  const lines = [];
+  const original = console.log;
+  console.log = (...args) => lines.push(args.join(' '));
+  try {
+    const result = fn();
+    return { lines, result };
+  } finally {
+    console.log = original;
+  }
+}
+
+describe('sprint-status --rework-check 返工率 (#704)', () => {
+  let dir;
+  let stateFile;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rework-704-'));
+    git(dir, ['init', '-q', '.']);
+    git(dir, ['config', 'user.email', 'test@example.com']);
+    git(dir, ['config', 'user.name', 'Test']);
+
+    // 4 commits: 2 feat + 2 fix => real rework rate 50%, above the 30% threshold.
+    // Author/committer dates are pinned so the sprint window is deterministic.
+    const commits = [
+      ['2026-11-01T10:00:00Z', 'a.txt', 'feat: initial'],
+      ['2026-11-01T10:10:00Z', 'b.txt', 'fix(core): repair the thing'],
+      ['2026-11-01T10:20:00Z', 'c.txt', 'feat: another'],
+      ['2026-11-01T10:30:00Z', 'd.txt', 'fix: 修掉一个缺陷'],
+    ];
+    for (const [date, file, message] of commits) {
+      fs.writeFileSync(path.join(dir, file), file);
+      git(dir, ['add', '-A']);
+      git(dir, ['commit', '-q', '-m', message], {
+        GIT_AUTHOR_DATE: date,
+        GIT_COMMITTER_DATE: date,
+      });
+    }
+
+    fs.mkdirSync(path.join(dir, '.sprint-state'), { recursive: true });
+    stateFile = path.join(dir, '.sprint-state', 'sprint-state.json');
+    // completed_at is AFTER every commit — this is the real CLOSE ordering, and
+    // the exact input that made `--since completed_at` return an empty set.
+    fs.writeFileSync(stateFile, JSON.stringify({
+      _schema_version: 1,
+      id: 'sprint-2026-11-01-01',
+      phase: 6,
+      status: 'completed',
+      started_at: '2026-11-01T09:00:00.000Z',
+      metrics: { completed_at: '2026-11-01T11:00:00.000Z' },
+    }, null, 2));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('AC-704-01: counts fix commits between sprint start and completion, not after completion', () => {
+    const { lines } = captureLogs(() => sprintStatus.handleReworkCheck(dir, 3650));
+    const output = lines.join('\n');
+
+    // The two fix commits happened inside the sprint window. Reporting 0 means
+    // the lower bound is on the wrong side of the sprint.
+    expect(output).toMatch(/2 fix \/ 4 total commits/);
+  });
+
+  it('AC-704-02: reports the real rate and raises the >30% alert', () => {
+    const { lines } = captureLogs(() => sprintStatus.handleReworkCheck(dir, 3650));
+    const output = lines.join('\n');
+
+    expect(output).toMatch(/50\.0%/);
+    expect(output).toMatch(/exceeds 30% threshold/);
+    // The all-clear line must NOT be printed when a sprint is over threshold:
+    // that sentence is what turns a fail-open into a false reassurance.
+    expect(output).not.toMatch(/All sprints within acceptable rework rate/);
+  });
+
+  it('AC-704-03: persists the computed rate and the commit total it was computed from', () => {
+    captureLogs(() => sprintStatus.handleReworkCheck(dir, 3650));
+
+    const persisted = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+    expect(persisted.metrics.rework_rate).toBe(0.5);
+    // total_sprint_commits was never computed before; the report needs it to
+    // stay meaningful on the next run.
+    expect(persisted.metrics.total_sprint_commits).toBe(4);
+  });
+
+  it('AC-704-04: an empty window reports 0/0, not a confident 0%', () => {
+    // Second sprint state: its window contains no commits at all.
+    fs.writeFileSync(stateFile, JSON.stringify({
+      _schema_version: 1,
+      id: 'sprint-2026-11-02-01',
+      phase: 6,
+      status: 'completed',
+      started_at: '2026-11-01T10:35:00.000Z',
+      metrics: { completed_at: '2026-11-01T12:00:00.000Z' },
+    }, null, 2));
+
+    const { lines } = captureLogs(() => sprintStatus.handleReworkCheck(dir, 3650));
+    const output = lines.join('\n');
+
+    // Zero commits in the window is NOT "0% rework" — it is "nothing to
+    // measure". Rendering it as 0.0% would recreate this same fail-open one
+    // level down.
+    expect(output).toMatch(/0 fix \/ 0 total commits/);
+  });
+});

package/lib/__tests__/sprint-status-rework.test.js

@@ -55,6 +55,21 @@ function daysAgo(n) {
   return new Date(Date.now() - n * 86400000).toISOString();
 }
 
+/**
+ * Hour-level offset, needed to express a sprint window that actually CONTAINS
+ * the fixture's commits (#704).
+ *
+ * The commits are made "now", so a window built from daysAgo(9)→daysAgo(2) held
+ * no commits at all. The old fixtures compensated by hand-writing
+ * `total_sprint_commits: 10` — a number nothing in the code ever produced — which
+ * pinned the expected rate against a value that could only exist in the test.
+ * Negative = in the future; used for `completed_at`, which in the real CLOSE
+ * ordering is stamped after the last commit.
+ */
+function hoursAgo(n) {
+  return new Date(Date.now() - n * 3600000).toISOString();
+}
+
 beforeAll(() => {
   TMP_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'rework-test-'));
   cwdSpy = vi.spyOn(process, 'cwd');
@@ -101,9 +116,14 @@ describe('sprint-status --rework-check (#369)', () => {
     git('init', dir);
     git('config user.email "test@test.com"', dir);
     git('config user.name "Test"', dir);
+    // 10 commits, 2 of them fixes => 20%, below the 30% threshold.
+    // The count has to come from real history: the old fixture made 3 commits
+    // and declared 'total_sprint_commits: 10' by hand, so the expected 20%
+    // could only ever be produced by the fabricated number (#704).
     makeCommit('feat: initial', dir);
     makeCommit('fix: resolve login bug', dir);
     makeCommit('fix(auth): handle timeout', dir);
+    for (let i = 0; i < 7; i += 1) makeCommit(`feat: feature ${i}`, dir);
 
     writeSprintState({
       _schema_version: 1,
@@ -111,10 +131,10 @@ describe('sprint-status --rework-check (#369)', () => {
       task_description: 'Sprint B',
       phase: 6,
       status: 'completed',
-      started_at: daysAgo(9),
+      started_at: hoursAgo(1),
       isolation: { worktree_path: null, branch: 'main' },
       phase_history: [],
-      metrics: { completed_at: daysAgo(2), total_sprint_commits: 10 },
+      metrics: { completed_at: hoursAgo(-1) },
     }, dir);
 
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
@@ -142,12 +162,13 @@ describe('sprint-status --rework-check (#369)', () => {
     git('init', dir);
     git('config user.email "test@test.com"', dir);
     git('config user.name "Test"', dir);
+    // 10 commits, 5 of them fixes => 50%, above the 30% threshold.
     makeCommit('fix: one', dir);
     makeCommit('fix: two', dir);
     makeCommit('bugfix: three', dir);
     makeCommit('hotfix: four', dir);
     makeCommit('patch: five', dir);
-    makeCommit('feat: six', dir);
+    for (let i = 0; i < 5; i += 1) makeCommit(`feat: feature ${i}`, dir);
 
     writeSprintState({
       _schema_version: 1,
@@ -155,10 +176,10 @@ describe('sprint-status --rework-check (#369)', () => {
       task_description: 'Sprint C',
       phase: 6,
       status: 'completed',
-      started_at: daysAgo(9),
+      started_at: hoursAgo(1),
       isolation: { worktree_path: null, branch: 'main' },
       phase_history: [],
-      metrics: { completed_at: daysAgo(2), total_sprint_commits: 10 },
+      metrics: { completed_at: hoursAgo(-1) },
     }, dir);
 
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
@@ -208,6 +229,10 @@ describe('sprint-status --rework-check (#369)', () => {
     }
     makeCommit('feat: target initial', targetDir);
     makeCommit('fix: target bug', targetDir);
+    // 8 more target commits => 10 total, 1 fix => 10%. The count must come from
+    // real history; the old fixture declared it in the state file by hand, and
+    // this test's actual subject is GIT_DIR precedence, not arithmetic (#704).
+    for (let i = 0; i < 8; i += 1) makeCommit(`feat: target feature ${i}`, targetDir);
     makeCommit('fix: outer one', outerDir);
     makeCommit('fix: outer two', outerDir);
     makeCommit('fix: outer three', outerDir);
@@ -218,10 +243,10 @@ describe('sprint-status --rework-check (#369)', () => {
       task_description: 'Hook environment sprint',
       phase: 6,
       status: 'completed',
-      started_at: daysAgo(9),
+      started_at: hoursAgo(1),
       isolation: { worktree_path: null, branch: 'main' },
       phase_history: [],
-      metrics: { completed_at: daysAgo(2), total_sprint_commits: 10 },
+      metrics: { completed_at: hoursAgo(-1) },
     }, targetDir);
     cwdSpy.mockReturnValue(targetDir);
 

package/lib/__tests__/test-alignment-java-702.test.ts

@@ -0,0 +1,182 @@
+/**
+ * @test REQ-702 Test Alignment 语言覆盖
+ * @intent `parseTestFiles` 只认 .ts/.tsx/.js/.jsx/.py/.go。`.java` 文件被读进内存、
+ *         取出扩展名、然后什么都不做 —— 不是被拒绝，是被丢弃。
+ *
+ *         一个判定分支不存在时，系统报告的是「通过」而不是「未检查」：
+ *         纯 Java 工程 totalTests=0、totalAssertions=0，对齐分数在空集上计算，
+ *         但状态看起来是「跑过了」；混合工程里 Java 侧的覆盖被误报成
+ *         「未覆盖」，产生假阳性 gap。
+ *
+ *         与 #623（Gate 0 bypass 永不生效）、#645（真实仓库被测试写脏）同类：
+ *         共同点是静默失效。
+ *
+ *         修复要分三层，缺一层就还是 fail-open：
+ *         (1) 加 .java 分支，按 JUnit 5 的实际写法解析 @test/@intent 与断言；
+ *         (2) 未适配的扩展名必须 fail-loud，不能静默丢弃；
+ *         (3) 已适配集合显式化，集合外的扩展名要被报出来（.kt/.cs/.rb/.rs 同理）。
+ * @covers AC-702-01, AC-702-02, AC-702-03, AC-702-04, AC-702-05, AC-702-06
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import {
+  parseTestFiles,
+  UNSUPPORTED_TEST_EXTENSIONS,
+  runFullAlignment,
+} from '../test-alignment';
+
+const JAVA_TEST = `import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * @test REQ-001-01
+ * @intent probe intent
+ * @covers AC-001-01-01
+ */
+class ProbeTest {
+    @Test
+    void shouldProbe() {
+        assertEquals(1, 1);
+        assertEquals(2, 2);
+        assertTrue(true);
+    }
+}
+`;
+
+const JS_TEST = `/**
+ * @test REQ-001-01
+ * @intent probe intent
+ * @covers AC-001-01-01
+ */
+describe('probe', () => {
+  it('should probe', () => {
+    expect(1).toBe(1);
+  });
+});
+`;
+
+describe('test-alignment 语言覆盖 (#702)', () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'align-702-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('AC-702-01: a .java test file produces a TestCase with its REQ and covers', () => {
+    const javaFile = path.join(dir, 'ProbeTest.java');
+    fs.writeFileSync(javaFile, JAVA_TEST);
+
+    const map = parseTestFiles([javaFile]);
+
+    // The file declares @test REQ-001-01 and @covers AC-001-01-01. Dropping it
+    // means the AC is reported "not covered by any test" — a false gap in a
+    // mixed project and a structurally empty report in a pure-Java one.
+    expect(map.totalTests).toBe(1);
+    expect(map.tests[0].requirementId).toBe('REQ-001-01');
+    expect(map.tests[0].name).toBe('shouldProbe');
+    expect(map.tests[0].covers).toContain('AC-001-01-01');
+    expect(map.tests[0].intent).toBe('probe intent');
+  });
+
+  it('AC-702-02: JUnit 5 assertion calls are counted', () => {
+    const javaFile = path.join(dir, 'ProbeTest.java');
+    fs.writeFileSync(javaFile, JAVA_TEST);
+
+    const map = parseTestFiles([javaFile]);
+
+    // assertEquals x2 + assertTrue x1. countAssertions() only knew JS/Python
+    // patterns, so a Java test would have parsed as zero-assertion.
+    expect(map.tests[0].assertions).toBe(3);
+    expect(map.totalAssertions).toBe(3);
+  });
+
+  it('AC-702-03: an unsupported test extension is reported, never silently dropped', () => {
+    const ktFile = path.join(dir, 'ProbeTest.kt');
+    fs.writeFileSync(ktFile, `/** @test REQ-001-01 */\nclass ProbeTest {}\n`);
+
+    const map = parseTestFiles([ktFile]);
+
+    // Silently returning an empty map is the bug: the caller cannot tell
+    // "no tests here" from "tests here I could not read".
+    expect(map.unsupportedFiles).toBeDefined();
+    expect(map.unsupportedFiles.length).toBe(1);
+    expect(map.unsupportedFiles[0]).toContain('ProbeTest.kt');
+  });
+
+  it('AC-702-04: the supported extension set is explicit and includes .java', () => {
+    // A hardcoded if/else chain is why .java fell through: there was no list to
+    // check the code against, so a missing branch looked like a complete one.
+    expect(Array.isArray(UNSUPPORTED_TEST_EXTENSIONS)).toBe(true);
+    expect(UNSUPPORTED_TEST_EXTENSIONS).toContain('.kt');
+    expect(UNSUPPORTED_TEST_EXTENSIONS).toContain('.rs');
+    expect(UNSUPPORTED_TEST_EXTENSIONS).not.toContain('.java');
+    expect(UNSUPPORTED_TEST_EXTENSIONS).not.toContain('.ts');
+    expect(UNSUPPORTED_TEST_EXTENSIONS).not.toContain('.go');
+  });
+});
+
+describe('runFullAlignment surfaces unparsed test files (#702)', () => {
+  const SPEC = `specification:
+  requirements:
+    - id: REQ-001-01
+      title: Probe requirement
+      acceptance_criteria:
+        - id: AC-001-01-01
+          criteria: The probe test asserts something
+          test_type: unit
+`;
+
+  let dir: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'align-full-702-'));
+    fs.mkdirSync(path.join(dir, 'spec'), { recursive: true });
+    fs.mkdirSync(path.join(dir, 'tests'), { recursive: true });
+    fs.writeFileSync(path.join(dir, 'spec', 'specification.yaml'), SPEC);
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('AC-702-05: a pure-Kotlin test dir cannot PASS on an empty parsed set', () => {
+    fs.writeFileSync(
+      path.join(dir, 'tests', 'ProbeTest.kt'),
+      '/** @test REQ-001-01 */\nclass ProbeTest {}\n',
+    );
+
+    const report = runFullAlignment({
+      specPath: path.join(dir, 'spec', 'specification.yaml'),
+      testDirs: [path.join(dir, 'tests')],
+    });
+
+    // Zero parsed tests + zero parseable files used to look like a clean run.
+    // It is the opposite: nothing was read, so nothing can be certified.
+    expect(report.alignment_status).toBe('FAIL');
+    expect(report.errors.some(e => e.includes('ProbeTest.kt'))).toBe(true);
+    expect(report.anti_pattern_detected).toBe(true);
+  });
+
+  it('AC-702-06: a high score does not override the presence of unparsed files', () => {
+    // Java test covers the AC, so the score would be high on its own.
+    fs.writeFileSync(path.join(dir, 'tests', 'ProbeTest.java'), JAVA_TEST);
+    // One unparseable Rust test is enough to make the number untrustworthy.
+    fs.writeFileSync(path.join(dir, 'tests', 'ProbeTest.rs'), 'fn probe() {}\n');
+
+    const report = runFullAlignment({
+      specPath: path.join(dir, 'spec', 'specification.yaml'),
+      testDirs: [path.join(dir, 'tests')],
+    });
+
+    expect(report.errors.some(e => e.includes('ProbeTest.rs'))).toBe(true);
+    expect(report.alignment_status).toBe('FAIL');
+  });
+});

package/lib/__tests__/test-alignment.test.ts

@@ -384,6 +384,7 @@ describe('REQ-ALIGN-003: verifyAlignment()', () => {
         { name: 'testA', file: 'a.test.ts', requirementId: 'REQ-A', intent: 'test A', covers: ['AC-A-01'], assertions: 2, edgeCases: [] },
       ],
       totalTests: 1,
+      unsupportedFiles: [],
       totalAssertions: 2,
     };
 
@@ -420,6 +421,7 @@ describe('REQ-ALIGN-003: verifyAlignment()', () => {
       }],
       totalTests: 1,
       totalAssertions: 2,
+      unsupportedFiles: [],
     };
 
     const report = verifyAlignment(specMap, testMap);
@@ -447,6 +449,7 @@ describe('REQ-ALIGN-003: verifyAlignment()', () => {
       }],
       totalTests: 1,
       totalAssertions: 1,
+      unsupportedFiles: [],
     };
 
     const report = verifyAlignment(specMap, testMap);
@@ -553,7 +556,7 @@ specification:
     const spec = parseSpecification(specFile);
     expect(spec.requirements).toHaveLength(0);
 
-    const testMap = { tests: [], totalTests: 0, totalAssertions: 0 };
+    const testMap = { tests: [], totalTests: 0, totalAssertions: 0, unsupportedFiles: [] };
     const report = verifyAlignment(spec, testMap);
     // 0/0 = division by zero must be handled gracefully
     expect(report.coverage.requirementsTotal).toBe(0);
@@ -576,7 +579,7 @@ specification:
 `;
     const specFile = writeTempFile('no-tests-spec.yaml', specYaml);
     const spec = parseSpecification(specFile);
-    const testMap = { tests: [], totalTests: 0, totalAssertions: 0 };
+    const testMap = { tests: [], totalTests: 0, totalAssertions: 0, unsupportedFiles: [] };
     const report = verifyAlignment(spec, testMap);
 
     expect(report.coverage.requirementsCovered).toBe(0);
@@ -747,6 +750,7 @@ specification:
       }],
       totalTests: 1,
       totalAssertions: 3,
+      unsupportedFiles: [],
     };
     const report = verifyAlignment(spec, testMap);
     const score = calculateScore(report.issues, report.coverage, testMap);

package/lib/mattpocock-license-verdict.json

@@ -2,6 +2,6 @@
   "verdict": "PASS",
   "license_type": "MIT",
   "sha256": "0e7ac423bf2c6e223b7c5b156f8cf72da49d748e56a1641402c31f22ad07dbb5",
-  "checked_at": "2026-11-01T15:38:49.220Z",
+  "checked_at": "2026-11-02T02:08:42.160Z",
   "source": "network"
 }