@boyingliu01/xp-gate 0.15.1 → 0.15.2

package/lib/__tests__/sprint-audit.test.js

@@ -1,207 +1,207 @@
-/**
- * Tests for sprint-audit CLI command (Layer 2)
- * @test REQ-338 Sprint audit — final completeness check
- * @intent Verify sprint-audit correctly checks phase coverage, artifacts, consistency
- * @covers AC-AUDIT-01 (SKIP when no sprint-state.json)
- * @covers AC-AUDIT-02 (PASS when 6/6 completed)
- * @covers AC-AUDIT-03 (PASS_WITH_WARNINGS when 4-5/6 completed)
- * @covers AC-AUDIT-04 (FAIL when <4/6 completed)
- * @covers AC-AUDIT-05 (FAIL on state inconsistency)
- * @covers AC-AUDIT-06 (--json flag outputs JSON)
- * @covers AC-AUDIT-07 (report persisted to audit-report.json)
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { handleSprintAudit } from '../sprint-audit.js';
-
-describe('sprint-audit', () => {
-  let tmpDir;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sprint-audit-test-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  function writeState(state) {
-    const stateDir = path.join(tmpDir, '.sprint-state');
-    fs.mkdirSync(stateDir, { recursive: true });
-    fs.writeFileSync(path.join(stateDir, 'sprint-state.json'), JSON.stringify(state));
-  }
-
-  function makeState(overrides = {}) {
-    return {
-      _schema_version: 1,
-      id: 'sprint-test-audit',
-      task_description: 'Test audit feature',
-      phase: 6,
-      status: 'completed',
-      started_at: '2026-07-22T10:00:00Z',
-      phase_history: [],
-      isolation: { branch: 'sprint/test-audit', worktree_path: null },
-      outputs: {},
-      ...overrides,
-    };
-  }
-
-  function makePhaseHistory(completedPhases) {
-    const phaseNames = ['PREP', 'DESIGN', 'BUILD', 'VERIFY', 'SHIP', 'CLOSE'];
-    return completedPhases.map((p, i) => ({
-      phase: p,
-      phase_name: phaseNames[p - 1],
-      status: 'completed',
-      started_at: `2026-07-22T10:${String(i).padStart(2, '0')}:00Z`,
-      completed_at: `2026-07-22T10:${String(i).padStart(2, '0')}:30Z`,
-      duration_seconds: 30,
-    }));
-  }
-
-  describe('handleSprintAudit()', () => {
-    it('returns 0 and shows help with --help', async () => {
-      const code = await handleSprintAudit(['--help']);
-      expect(code).toBe(0);
-    });
-
-    it('returns SKIP (exit 0) when no sprint-state.json exists', async () => {
-      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-      const code = await handleSprintAudit(['--dir', tmpDir]);
-      expect(code).toBe(0);
-      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('No sprint-state.json'));
-      logSpy.mockRestore();
-    });
-
-    it('returns PASS when 6/6 phases completed', async () => {
-      writeState(makeState({ phase_history: makePhaseHistory([1, 2, 3, 4, 5, 6]) }));
-
-      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-      const code = await handleSprintAudit(['--dir', tmpDir]);
-      expect(code).toBe(0);
-      // Check output contains PASS
-      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
-      expect(output).toContain('PASS');
-      expect(output).toContain('6/6');
-      logSpy.mockRestore();
-    });
-
-    it('returns PASS_WITH_WARNINGS when 5/6 completed', async () => {
-      writeState(makeState({ phase: 5, phase_history: makePhaseHistory([1, 2, 3, 4, 5]) }));
-
-      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-      const code = await handleSprintAudit(['--dir', tmpDir]);
-      expect(code).toBe(0);
-      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
-      expect(output).toContain('PASS_WITH_WARNINGS');
-      logSpy.mockRestore();
-    });
-
-    it('returns PASS_WITH_WARNINGS when 4/6 completed', async () => {
-      writeState(makeState({ phase: 4, phase_history: makePhaseHistory([1, 2, 3, 4]) }));
-
-      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-      const code = await handleSprintAudit(['--dir', tmpDir]);
-      expect(code).toBe(0);
-      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
-      expect(output).toContain('PASS_WITH_WARNINGS');
-      logSpy.mockRestore();
-    });
-
-    it('returns FAIL when <4/6 completed', async () => {
-      writeState(makeState({ phase: 3, phase_history: makePhaseHistory([1, 2, 3]) }));
-
-      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-      const code = await handleSprintAudit(['--dir', tmpDir]);
-      expect(code).toBe(1);
-      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
-      expect(output).toContain('FAIL');
-      logSpy.mockRestore();
-    });
-
-    it('returns FAIL on state inconsistency (phase vs phase_history)', async () => {
-      const history = makePhaseHistory([1, 2, 3, 4, 5, 6]);
-      writeState(makeState({ phase: 3, phase_history: history })); // phase=3 but last entry is 6
-
-      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-      const code = await handleSprintAudit(['--dir', tmpDir]);
-      expect(code).toBe(1);
-      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
-      expect(output).toContain('State inconsistency');
-      logSpy.mockRestore();
-    });
-
-    it('outputs JSON when --json flag is set', async () => {
-      writeState(makeState({ phase_history: makePhaseHistory([1, 2, 3, 4, 5, 6]) }));
-
-      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-      const code = await handleSprintAudit(['--dir', tmpDir, '--json']);
-      expect(code).toBe(0);
-      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
-      const result = JSON.parse(output);
-      expect(result.verdict).toBe('PASS');
-      expect(result.coverage.completed).toBe(6);
-      logSpy.mockRestore();
-    });
-
-    it('counts skipped phases as completed in coverage', async () => {
-      const history = makePhaseHistory([1, 2, 3, 4, 5]);
-      history.push({
-        phase: 6, phase_name: 'CLOSE', status: 'skipped',
-        started_at: '2026-07-22T10:05:00Z', completed_at: '2026-07-22T10:05:00Z', duration_seconds: 0,
-      });
-      writeState(makeState({ phase: 6, phase_history: history }));
-
-      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-      const code = await handleSprintAudit(['--dir', tmpDir, '--json']);
-      expect(code).toBe(0);
-      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
-      const result = JSON.parse(output);
-      expect(result.coverage.completed).toBe(6);
-      expect(result.verdict).toBe('PASS');
-      logSpy.mockRestore();
-    });
-
-    it('warns about missing summary files for completed phases', async () => {
-      writeState(makeState({ phase_history: makePhaseHistory([1, 2, 3, 4, 5, 6]) }));
-      // No phase-outputs directory → all summaries missing
-
-      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-      const code = await handleSprintAudit(['--dir', tmpDir, '--json']);
-      expect(code).toBe(0);
-      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
-      const result = JSON.parse(output);
-      expect(result.warnings.length).toBeGreaterThan(0);
-      expect(result.warnings.some(w => w.includes('summary missing'))).toBe(true);
-      logSpy.mockRestore();
-    });
-
-    it('persists audit report to audit-report.json', async () => {
-      writeState(makeState({ phase_history: makePhaseHistory([1, 2, 3, 4, 5, 6]) }));
-
-      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-      await handleSprintAudit(['--dir', tmpDir]);
-      logSpy.mockRestore();
-
-      const reportPath = path.join(tmpDir, '.sprint-state', 'audit-report.json');
-      expect(fs.existsSync(reportPath)).toBe(true);
-      const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
-      expect(report.verdict).toBe('PASS');
-      expect(report.sprint_id).toBe('sprint-test-audit');
-    });
-
-    it('handles corrupted sprint-state.json gracefully', async () => {
-      const stateDir = path.join(tmpDir, '.sprint-state');
-      fs.mkdirSync(stateDir, { recursive: true });
-      fs.writeFileSync(path.join(stateDir, 'sprint-state.json'), 'not-valid-json');
-
-      const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      const code = await handleSprintAudit(['--dir', tmpDir]);
-      expect(code).toBe(1);
-      expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to parse'));
-      errSpy.mockRestore();
-    });
-  });
-});
+/**
+ * Tests for sprint-audit CLI command (Layer 2)
+ * @test REQ-338 Sprint audit — final completeness check
+ * @intent Verify sprint-audit correctly checks phase coverage, artifacts, consistency
+ * @covers AC-AUDIT-01 (SKIP when no sprint-state.json)
+ * @covers AC-AUDIT-02 (PASS when 6/6 completed)
+ * @covers AC-AUDIT-03 (PASS_WITH_WARNINGS when 4-5/6 completed)
+ * @covers AC-AUDIT-04 (FAIL when <4/6 completed)
+ * @covers AC-AUDIT-05 (FAIL on state inconsistency)
+ * @covers AC-AUDIT-06 (--json flag outputs JSON)
+ * @covers AC-AUDIT-07 (report persisted to audit-report.json)
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { handleSprintAudit } from '../sprint-audit.js';
+
+describe('sprint-audit', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sprint-audit-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function writeState(state) {
+    const stateDir = path.join(tmpDir, '.sprint-state');
+    fs.mkdirSync(stateDir, { recursive: true });
+    fs.writeFileSync(path.join(stateDir, 'sprint-state.json'), JSON.stringify(state));
+  }
+
+  function makeState(overrides = {}) {
+    return {
+      _schema_version: 1,
+      id: 'sprint-test-audit',
+      task_description: 'Test audit feature',
+      phase: 6,
+      status: 'completed',
+      started_at: '2026-07-22T10:00:00Z',
+      phase_history: [],
+      isolation: { branch: 'sprint/test-audit', worktree_path: null },
+      outputs: {},
+      ...overrides,
+    };
+  }
+
+  function makePhaseHistory(completedPhases) {
+    const phaseNames = ['PREP', 'DESIGN', 'BUILD', 'VERIFY', 'SHIP', 'CLOSE'];
+    return completedPhases.map((p, i) => ({
+      phase: p,
+      phase_name: phaseNames[p - 1],
+      status: 'completed',
+      started_at: `2026-07-22T10:${String(i).padStart(2, '0')}:00Z`,
+      completed_at: `2026-07-22T10:${String(i).padStart(2, '0')}:30Z`,
+      duration_seconds: 30,
+    }));
+  }
+
+  describe('handleSprintAudit()', () => {
+    it('returns 0 and shows help with --help', async () => {
+      const code = await handleSprintAudit(['--help']);
+      expect(code).toBe(0);
+    });
+
+    it('returns SKIP (exit 0) when no sprint-state.json exists', async () => {
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const code = await handleSprintAudit(['--dir', tmpDir]);
+      expect(code).toBe(0);
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('No sprint-state.json'));
+      logSpy.mockRestore();
+    });
+
+    it('returns PASS when 6/6 phases completed', async () => {
+      writeState(makeState({ phase_history: makePhaseHistory([1, 2, 3, 4, 5, 6]) }));
+
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const code = await handleSprintAudit(['--dir', tmpDir]);
+      expect(code).toBe(0);
+      // Check output contains PASS
+      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
+      expect(output).toContain('PASS');
+      expect(output).toContain('6/6');
+      logSpy.mockRestore();
+    });
+
+    it('returns PASS_WITH_WARNINGS when 5/6 completed', async () => {
+      writeState(makeState({ phase: 5, phase_history: makePhaseHistory([1, 2, 3, 4, 5]) }));
+
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const code = await handleSprintAudit(['--dir', tmpDir]);
+      expect(code).toBe(0);
+      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
+      expect(output).toContain('PASS_WITH_WARNINGS');
+      logSpy.mockRestore();
+    });
+
+    it('returns PASS_WITH_WARNINGS when 4/6 completed', async () => {
+      writeState(makeState({ phase: 4, phase_history: makePhaseHistory([1, 2, 3, 4]) }));
+
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const code = await handleSprintAudit(['--dir', tmpDir]);
+      expect(code).toBe(0);
+      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
+      expect(output).toContain('PASS_WITH_WARNINGS');
+      logSpy.mockRestore();
+    });
+
+    it('returns FAIL when <4/6 completed', async () => {
+      writeState(makeState({ phase: 3, phase_history: makePhaseHistory([1, 2, 3]) }));
+
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const code = await handleSprintAudit(['--dir', tmpDir]);
+      expect(code).toBe(1);
+      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
+      expect(output).toContain('FAIL');
+      logSpy.mockRestore();
+    });
+
+    it('returns FAIL on state inconsistency (phase vs phase_history)', async () => {
+      const history = makePhaseHistory([1, 2, 3, 4, 5, 6]);
+      writeState(makeState({ phase: 3, phase_history: history })); // phase=3 but last entry is 6
+
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const code = await handleSprintAudit(['--dir', tmpDir]);
+      expect(code).toBe(1);
+      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
+      expect(output).toContain('State inconsistency');
+      logSpy.mockRestore();
+    });
+
+    it('outputs JSON when --json flag is set', async () => {
+      writeState(makeState({ phase_history: makePhaseHistory([1, 2, 3, 4, 5, 6]) }));
+
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const code = await handleSprintAudit(['--dir', tmpDir, '--json']);
+      expect(code).toBe(0);
+      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
+      const result = JSON.parse(output);
+      expect(result.verdict).toBe('PASS');
+      expect(result.coverage.completed).toBe(6);
+      logSpy.mockRestore();
+    });
+
+    it('counts skipped phases as completed in coverage', async () => {
+      const history = makePhaseHistory([1, 2, 3, 4, 5]);
+      history.push({
+        phase: 6, phase_name: 'CLOSE', status: 'skipped',
+        started_at: '2026-07-22T10:05:00Z', completed_at: '2026-07-22T10:05:00Z', duration_seconds: 0,
+      });
+      writeState(makeState({ phase: 6, phase_history: history }));
+
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const code = await handleSprintAudit(['--dir', tmpDir, '--json']);
+      expect(code).toBe(0);
+      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
+      const result = JSON.parse(output);
+      expect(result.coverage.completed).toBe(6);
+      expect(result.verdict).toBe('PASS');
+      logSpy.mockRestore();
+    });
+
+    it('warns about missing summary files for completed phases', async () => {
+      writeState(makeState({ phase_history: makePhaseHistory([1, 2, 3, 4, 5, 6]) }));
+      // No phase-outputs directory → all summaries missing
+
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const code = await handleSprintAudit(['--dir', tmpDir, '--json']);
+      expect(code).toBe(0);
+      const output = logSpy.mock.calls.map(c => c[0]).join('\n');
+      const result = JSON.parse(output);
+      expect(result.warnings.length).toBeGreaterThan(0);
+      expect(result.warnings.some(w => w.includes('summary missing'))).toBe(true);
+      logSpy.mockRestore();
+    });
+
+    it('persists audit report to audit-report.json', async () => {
+      writeState(makeState({ phase_history: makePhaseHistory([1, 2, 3, 4, 5, 6]) }));
+
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      await handleSprintAudit(['--dir', tmpDir]);
+      logSpy.mockRestore();
+
+      const reportPath = path.join(tmpDir, '.sprint-state', 'audit-report.json');
+      expect(fs.existsSync(reportPath)).toBe(true);
+      const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+      expect(report.verdict).toBe('PASS');
+      expect(report.sprint_id).toBe('sprint-test-audit');
+    });
+
+    it('handles corrupted sprint-state.json gracefully', async () => {
+      const stateDir = path.join(tmpDir, '.sprint-state');
+      fs.mkdirSync(stateDir, { recursive: true });
+      fs.writeFileSync(path.join(stateDir, 'sprint-state.json'), 'not-valid-json');
+
+      const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const code = await handleSprintAudit(['--dir', tmpDir]);
+      expect(code).toBe(1);
+      expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to parse'));
+      errSpy.mockRestore();
+    });
+  });
+});

package/lib/doctor.js

@@ -1058,6 +1058,53 @@ function ensureTuiRegistration() {
   }
 }
 
+/**
+ * Diagnose language-specific tool availability.
+ * @returns {number} Number of issues found (missing required tools)
+ */
+function diagnoseLanguageTools() {
+  try {
+    const { detectProjectLanguages, getToolsForLanguages, LANGUAGE_REGISTRY } = require('./language-tools.js');
+    const projectRoot = process.cwd();
+    const { detected } = detectProjectLanguages(projectRoot);
+
+    if (detected.length === 0) return 0;
+
+    console.log('');
+    console.log('Language-Specific Tools:');
+    console.log('------------------------');
+
+    const toolStatus = getToolsForLanguages(detected);
+    let issues = 0;
+
+    for (const [lang, tools] of Object.entries(toolStatus)) {
+      const langDef = LANGUAGE_REGISTRY[lang];
+      console.log(`  ${langDef?.name || lang}:`);
+
+      for (const t of tools) {
+        const statusIcon = t.status === 'available' ? '✓' : '✗';
+        const optMark = t.tool.optional ? ' (optional)' : '';
+        const version = t.version || 'N/A';
+        console.log(`    ${statusIcon} ${t.tool.name}${optMark} — ${version}`);
+
+        if (t.status === 'missing' && !t.tool.optional) {
+          issues++;
+        }
+      }
+    }
+
+    if (issues > 0) {
+      console.log('');
+      console.log(`  ${issues} required tool(s) missing — gates will SKIP.`);
+      console.log('  Run "xp-gate install-tools --yes" to install.');
+    }
+
+    return issues;
+  } catch {
+    return 0;
+  }
+}
+
 async function doctor(args) {
   const fixMode = args.includes('--fix');
 
@@ -1101,6 +1148,9 @@ async function doctor(args) {
 
   issues += diagnoseOpenCodePlugin(checks);
 
+  // Language-specific tool status
+  issues += diagnoseLanguageTools();
+
   if (issues === 0) {
     console.log('\n✓ All checks passed');
     return 0;

package/lib/init.js

@@ -354,6 +354,93 @@ async function init(args) {
   return code;
 }
 
+/**
+ * Detect project languages and check/install language-specific tools.
+ * @param {string} projectRoot - Project root directory
+ * @param {boolean} autoYes - Auto-install missing tools
+ */
+async function detectAndReportLanguages(projectRoot, autoYes) {
+  const { detectProjectLanguages, getToolsForLanguages, generateProjectConfig, LANGUAGE_REGISTRY } = require('./language-tools.js');
+
+  console.log('');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('  Multi-Language Quality Gates');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+
+  const { detected, configFiles } = detectProjectLanguages(projectRoot);
+
+  if (detected.length === 0) {
+    console.log('  No project languages detected.');
+    return;
+  }
+
+  console.log(`  Detected ${detected.length} language(s):`);
+  for (const lang of detected) {
+    const langDef = LANGUAGE_REGISTRY[lang];
+    console.log(`    • ${langDef?.name || lang}`);
+  }
+  console.log('');
+
+  const toolStatus = getToolsForLanguages(detected);
+  const missingRequired = [];
+  const missingOptional = [];
+
+  for (const [lang, tools] of Object.entries(toolStatus)) {
+    for (const t of tools) {
+      if (t.status === 'missing') {
+        if (t.tool.optional) {
+          missingOptional.push({ lang, tool: t.tool });
+        } else {
+          missingRequired.push({ lang, tool: t.tool });
+        }
+      }
+    }
+  }
+
+  if (missingRequired.length === 0 && missingOptional.length === 0) {
+    console.log('  ✓ All language-specific tools are available.');
+  } else {
+    if (missingRequired.length > 0) {
+      console.log(`  ✗ ${missingRequired.length} required tool(s) missing:`);
+      for (const { lang, tool } of missingRequired) {
+        console.log(`    • ${tool.name} (${lang}) — gates will SKIP`);
+      }
+    }
+    if (missingOptional.length > 0) {
+      console.log(`  ⚠ ${missingOptional.length} optional tool(s) missing (fallback available):`);
+      for (const { lang, tool } of missingOptional) {
+        console.log(`    • ${tool.name} (${lang})`);
+      }
+    }
+    console.log('');
+
+    if (autoYes || (process.stdin.isTTY && await askYesNo('  Install missing language-specific tools now?'))) {
+      console.log('');
+      const { installTool } = require('./language-tools.js');
+      let installed = 0;
+      for (const { lang, tool } of [...missingRequired, ...missingOptional]) {
+        const result = installTool(tool);
+        if (result.success) {
+          console.log(`  ✓ ${tool.name} installed`);
+          installed++;
+        } else {
+          console.log(`  ✗ ${tool.name}: ${result.message}`);
+        }
+      }
+      if (installed > 0) {
+        console.log(`\n  ${installed} tool(s) installed successfully.`);
+      }
+    } else {
+      console.log('  Skipped. Run "xp-gate install-tools --yes" later.');
+    }
+  }
+
+  // Generate project config
+  generateProjectConfig(projectRoot, detected, toolStatus);
+  console.log(`\n  Generated .xp-gate-config.json`);
+}
+
 async function installLocal(args) {
   const gitDir = getGitDir();
   if (!gitDir) {
@@ -416,6 +503,10 @@ async function installLocal(args) {
   // Auto-install missing CLI tools (prompt user)
   const autoYes = args.includes('--yes') || args.includes('--auto-install');
   await promptBootstrap(autoYes);
+
+  // Detect project languages and check language-specific tools
+  await detectAndReportLanguages(projectRoot, autoYes);
+
   console.log('━━━ FIRST-CLASS TEST QUALITY ━━━');
   console.log('XP-Gate treats test code as a first-class citizen:');
   console.log('  • TypeScript: test files are type-checked, not excluded from tsconfig.json');