@boyingliu01/xp-gate 0.35.19 → 0.35.21

package/hooks/pre-commit

@@ -857,9 +857,14 @@ echo ""
 GATE_0_START=$(gate_start_ms)
 GATE_0_STATUS="PASS"
 
-CURRENT_BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "HEAD")
+CURRENT_BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || git rev-parse --abbrev-ref HEAD 2>/dev/null) || CURRENT_BRANCH=""
+CURRENT_BRANCH=$(printf '%s' "$CURRENT_BRANCH" | tr -d '\r\n'); [ -n "$CURRENT_BRANCH" ] || CURRENT_BRANCH="HEAD"
 PROTECTED_BRANCHES="master develop trunk mainline"
-ROOT_DIR=$(git rev-parse --show-toplevel 2>/dev/null || echo ".")
+# #711: same shape as the branch/commit captures above — `git rev-parse` can
+# print a partial line before failing, so `|| echo "."` can yield "<something>\n."
+# and every later `cd "$ROOT_DIR"` / path join would silently use a two-line value.
+ROOT_DIR=$(git rev-parse --show-toplevel 2>/dev/null) || ROOT_DIR=""
+ROOT_DIR=$(printf '%s' "$ROOT_DIR" | tr -d '\r\n'); [ -n "$ROOT_DIR" ] || ROOT_DIR="."
 
 # Optional: project-level .protected-branches config file
 if [ -f "$ROOT_DIR/.protected-branches" ]; then
@@ -2664,7 +2669,8 @@ else
 
   SKIP_5A_BLOCK=false
   if [ "${SKIP_GATE_5A_BLOCK:-0}" = "1" ]; then
-    CURRENT_BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "HEAD")
+    CURRENT_BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || git rev-parse --abbrev-ref HEAD 2>/dev/null) || CURRENT_BRANCH=""
+    CURRENT_BRANCH=$(printf '%s' "$CURRENT_BRANCH" | tr -d '\r\n'); [ -n "$CURRENT_BRANCH" ] || CURRENT_BRANCH="HEAD"
     if [ "$CURRENT_BRANCH" != "main" ] && [ "$CURRENT_BRANCH" != "master" ]; then
       REASON="${SKIP_GATE_5A_BLOCK_REASON:-not specified}"
       mkdir -p .xp-gate/reports
@@ -4017,6 +4023,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 +4295,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 +4357,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
@@ -4942,8 +4994,26 @@ generate_quality_report() {
   local WARN_COUNT=0
   local NONPASS_COUNT=0
 
-  COMMIT_HASH=$(git rev-parse HEAD 2>/dev/null || echo "unknown")
-  BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")
+  # #711: capture the probe output first, then fall back — never `|| echo` a
+  # command whose stdout is only shown on success.
+  #
+  # On a repository with no commits yet, `git rev-parse --abbrev-ref HEAD`
+  # PRINTS "HEAD" and then exits non-zero. With `$(cmd || echo unknown)` the
+  # captured value becomes "HEAD\nunknown" — two lines — and it is embedded
+  # verbatim into the JSON report as `"branch": "HEAD\nunknown"`, which is not
+  # valid JSON (a raw newline cannot appear inside a string literal).
+  #
+  # Gate 12 then reads that report on the NEXT commit and BLOCKS with
+  # "YAML/JSON syntax errors" against a file the gate itself wrote. The first
+  # commit of every freshly-initialised consumer repo therefore fails once for a
+  # reason that has nothing to do with the user's change.
+  COMMIT_HASH=$(git rev-parse HEAD 2>/dev/null) || COMMIT_HASH=""
+  [ -n "$COMMIT_HASH" ] || COMMIT_HASH="unknown"
+  BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null) || BRANCH=""
+  # A detached HEAD reports the literal word "HEAD"; keep it (it is the truth)
+  # but never allow a multi-line value into the report.
+  BRANCH=$(printf '%s' "$BRANCH" | tr -d '\r\n')
+  [ -n "$BRANCH" ] || BRANCH="unknown"
   TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
 
   # Scoring per #507 S3: SKIP removes a gate from the denominator (a missing

package/hooks/pre-push

@@ -53,7 +53,11 @@ write_pre_push_report() {
   report_ts=$(date -u +"%Y-%m-%d-%H%M%S")
   reports_dir=".xp-gate/reports/pre-push"
   report_file="${reports_dir}/${report_ts}.json"
-  commit_hash=$(git rev-parse HEAD 2>/dev/null || echo "unknown")
+  # #710: `git rev-parse` prints a partial line before it fails, so
+  # `$(cmd || echo x)` captures "<partial>\nx". Strip newlines before the value
+  # reaches this JSON journal — a raw newline cannot appear inside a JSON string.
+  commit_hash=$(git rev-parse HEAD 2>/dev/null) || commit_hash=""
+  commit_hash=$(printf '%s' "$commit_hash" | tr -d '\r\n'); [ -n "$commit_hash" ] || commit_hash="unknown"
   verdict=$([ "$exit_code" -eq 0 ] && echo "PASS" || echo "BLOCKED")
   mkdir -p "$reports_dir"
   # #544: the survivor detail is a JSON document, so it cannot be interpolated
@@ -352,7 +356,9 @@ _mp_now_ms() {
   esac
 }
 MP_START_MS="$(_mp_now_ms)"
-MP_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || echo .)"
+MP_ROOT=$(git rev-parse --show-toplevel 2>/dev/null) || MP_ROOT=""
+MP_ROOT=$(printf '%s' "$MP_ROOT" | tr -d '
+'); [ -n "$MP_ROOT" ] || MP_ROOT="."
 if [ -f "$MP_ROOT/scripts/check-hook-mirror.sh" ]; then
   if (cd "$MP_ROOT" && bash scripts/check-hook-mirror.sh); then
     GATE_MP_STATUS="PASS"
@@ -418,7 +424,9 @@ fi
 # Uses sprint-gate.sh for standalone validation logic
 # ============================================================================
 GATE_S_STATUS="PASS"
-PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || echo ".")"
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null) || PROJECT_ROOT=""
+PROJECT_ROOT=$(printf '%s' "$PROJECT_ROOT" | tr -d '
+'); [ -n "$PROJECT_ROOT" ] || PROJECT_ROOT="."
 SPRINT_GATE_SCRIPT=""
 
 # Same chain as pre-commit's Gate 11 (#476). The two tiers here both point at
@@ -1128,7 +1136,36 @@ if [[ "$XP_GATE_SKIP_UI_GATES" == "1" ]]; then
     exit 1
   fi
   echo "⚠️  UI Gate BYPASSED — reason: $XP_GATE_BYPASS_REASON"
-  AUDIT_ENTRY="{\"timestamp\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"branch\":\"$CURRENT_BRANCH\",\"commit\":\"$(git rev-parse HEAD)\",\"user\":\"$(git config user.name || echo 'unknown')\",\"reason\":\"$XP_GATE_BYPASS_REASON\",\"bypass_type\":\"ui-gates\"}"
+  # #710: build the whole record in node rather than interpolating shell
+  # variables into a JSON string. Values come from the environment so no shell
+  # quoting layer can mangle them (an earlier sed-based escaper silently
+  # dropped the reason entirely when its backslash expression broke).
+  #
+  # The reason is free-form USER INPUT: one double quote in it used to end the
+  # JSON string early and turn the audit line into garbage. An audit trail that
+  # can be corrupted by the thing it is auditing is not an audit trail.
+  AUDIT_ENTRY=$(
+    _AJ_TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ") \
+    _AJ_BRANCH="$CURRENT_BRANCH" \
+    _AJ_COMMIT="$(git rev-parse HEAD 2>/dev/null)" \
+    _AJ_USER="$(git config user.name 2>/dev/null)" \
+    _AJ_REASON="$XP_GATE_BYPASS_REASON" \
+    node -e '
+      const env = process.env;
+      const clean = (v, fallback) => {
+        const s = String(v === undefined ? "" : v).replace(/[\r\n]+/g, " ").trim();
+        return s === "" ? fallback : s;
+      };
+      process.stdout.write(JSON.stringify({
+        timestamp: env._AJ_TS,
+        branch: clean(env._AJ_BRANCH, "unknown"),
+        commit: clean(env._AJ_COMMIT, "unknown"),
+        user: clean(env._AJ_USER, "unknown"),
+        reason: clean(env._AJ_REASON, ""),
+        bypass_type: "ui-gates",
+      }));
+    ' 2>/dev/null
+  )
   echo "$AUDIT_ENTRY" >> .audit-log.jsonl
 else
     # Detect UI changes in pushed files.
@@ -1310,7 +1347,9 @@ CURRENT_TIME=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
 # evidence (#574). It is passed explicitly instead of letting the validator
 # infer it from cwd: the gate's subject is the repo being pushed, and a cwd-
 # derived lookup would bind xp-gate's own config whenever the suite runs here.
-MW_PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || echo "")
+MW_PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null) || MW_PROJECT_ROOT=""
+MW_PROJECT_ROOT=$(printf '%s' "$MW_PROJECT_ROOT" | tr -d '
+')
 if ! VALIDATION_ERROR=$(node "$MW_VALIDATOR" "$RESULT_FILE" "$EXPECTED_COMMIT" "$CURRENT_BRANCH" "$CURRENT_TIME" "$MW_PROJECT_ROOT" 2>&1); then
   echo ""
   echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

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,177 @@
+/**
+ * @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';
+
+// The AC id is assembled at runtime so this file contains no literal `AC-…`
+// reference. scripts/__tests__/ac-reference-guard.test.cjs treats every
+// `AC-<WORD>-<digits>` token in tracked sources as a claim about the real
+// specification, and this fixture deliberately names an id that is not in
+// specification.yaml — it only has to satisfy the parser's id shape.
+const FIXTURE_AC = ['AC', 'FIXTURE', '01', '01'].join('-');
+
+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 ${FIXTURE_AC}
+ */
+class ProbeTest {
+    @Test
+    void shouldProbe() {
+        assertEquals(1, 1);
+        assertEquals(2, 2);
+        assertTrue(true);
+    }
+}
+`;
+
+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 a @covers tag. 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(FIXTURE_AC);
+    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: ${FIXTURE_AC}
+          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');
+  });
+});