@boyingliu01/xp-gate 0.19.3 → 0.20.0

package/lib/__tests__/install-skill-full-dir.test.js

@@ -0,0 +1,151 @@
+/**
+ * @test REQ-416
+ * @intent install-skill/update-skill 只从 GitHub main 下载单个 SKILL.md，导致 13 个技能里
+ *         8 个的 references/templates/scripts 全部缺失、SKILL.md 内的路径引用悬空，而
+ *         update 先删目录再只写回 SKILL.md 会把用户已有的完整目录清空（#416）
+ * @covers AC-416-01, AC-416-02, AC-416-03, AC-416-04
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const BUNDLED_SKILLS = path.join(__dirname, '..', '..', 'skills');
+
+function listFiles(dir, prefix = '') {
+  const out = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) out.push(...listFiles(path.join(dir, entry.name), rel));
+    else out.push(rel);
+  }
+  return out;
+}
+
+describe('install-skill full skill directory (#416)', () => {
+  let tmpHome;
+  let originalHome;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-full-'));
+    process.env.HOME = tmpHome;
+    vi.resetModules();
+    for (const mod of ['../install-skill', '../update-skill', '../detect-deps', '../shared-paths', '../rollback']) {
+      delete require.cache[require.resolve(mod)];
+    }
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    // Dependency gate: superpowers + gstack must look installed.
+    for (const name of ['superpowers', 'gstack']) {
+      const dir = path.join(tmpHome, '.config', 'opencode', 'skills', name);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ version: '2.0.0' }));
+    }
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    vi.restoreAllMocks();
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  it('installs every file the bundled skill ships, not only SKILL.md', async () => {
+    const { installSkill } = require('../install-skill');
+    const result = await installSkill('ralph-loop');
+
+    expect(result).toBe(0);
+    const installed = path.join(tmpHome, '.config', 'opencode', 'skills', 'ralph-loop');
+    expect(listFiles(installed)).toEqual(listFiles(path.join(BUNDLED_SKILLS, 'ralph-loop')));
+    expect(fs.existsSync(path.join(installed, 'references'))).toBe(true);
+  });
+
+  it('installs from the package without touching the network', async () => {
+    // The npm package already carries the content, so there is no `main`-branch
+    // download left to drift against the installed CLI version.
+    const https = require('https');
+    const getSpy = vi.spyOn(https, 'get').mockImplementation(() => {
+      throw new Error('install-skill must not reach the network');
+    });
+
+    const { installSkill } = require('../install-skill');
+    const result = await installSkill('delphi-review');
+
+    expect(result).toBe(0);
+    expect(getSpy).not.toHaveBeenCalled();
+    const installed = path.join(tmpHome, '.config', 'opencode', 'skills', 'delphi-review');
+    expect(fs.readFileSync(path.join(installed, 'SKILL.md'), 'utf8'))
+      .toBe(fs.readFileSync(path.join(BUNDLED_SKILLS, 'delphi-review', 'SKILL.md'), 'utf8'));
+  });
+
+  it('replaces a stale installed directory with the complete bundled one on update', async () => {
+    const installed = path.join(tmpHome, '.config', 'opencode', 'skills', 'ralph-loop');
+    fs.mkdirSync(installed, { recursive: true });
+    fs.writeFileSync(path.join(installed, 'SKILL.md'), '# old');
+    fs.writeFileSync(path.join(installed, 'obsolete-reference.md'), '# deleted upstream');
+
+    const { updateSkill } = require('../update-skill');
+    const configDir = path.join(tmpHome, '.config', 'xp-gate');
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(configDir, 'xp-gate.json'),
+      JSON.stringify({ installedSkills: { 'ralph-loop': { version: '0.0.1' } } })
+    );
+
+    const result = await updateSkill('ralph-loop', {});
+    expect(result).toBe(0);
+    expect(listFiles(installed)).toEqual(listFiles(path.join(BUNDLED_SKILLS, 'ralph-loop')));
+    expect(fs.existsSync(path.join(installed, 'obsolete-reference.md'))).toBe(false);
+  });
+
+  it('updates the skills directory of the platform actually in use', async () => {
+    // update-skill used to hardcode the opencode path while install-skill wrote
+    // to the platform dir, so on Qoder it deleted nothing (or the wrong copy).
+    for (const name of ['superpowers', 'gstack']) {
+      const dir = path.join(tmpHome, '.qoder', 'skills', name);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ version: '2.0.0' }));
+    }
+    const qoderSkills = path.join(tmpHome, '.qoder', 'skills', 'ralph-loop');
+    fs.mkdirSync(qoderSkills, { recursive: true });
+    fs.writeFileSync(path.join(qoderSkills, 'SKILL.md'), '# old qoder copy');
+    fs.writeFileSync(path.join(qoderSkills, 'obsolete.md'), 'stale');
+    const opencodeSkills = path.join(tmpHome, '.config', 'opencode', 'skills', 'ralph-loop');
+    fs.mkdirSync(opencodeSkills, { recursive: true });
+    fs.writeFileSync(path.join(opencodeSkills, 'SKILL.md'), 'untouched');
+
+    const configDir = path.join(tmpHome, '.config', 'xp-gate');
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(configDir, 'xp-gate.json'),
+      JSON.stringify({ installedSkills: { 'ralph-loop': { version: '0.0.1' } } })
+    );
+
+    const { updateSkill } = require('../update-skill');
+    expect(await updateSkill('ralph-loop', {})).toBe(0);
+
+    expect(fs.existsSync(path.join(qoderSkills, 'obsolete.md'))).toBe(false);
+    expect(listFiles(qoderSkills)).toEqual(listFiles(path.join(BUNDLED_SKILLS, 'ralph-loop')));
+    expect(fs.readFileSync(path.join(opencodeSkills, 'SKILL.md'), 'utf8')).toBe('untouched');
+  });
+
+  it('keeps the installed directory when the package no longer bundles the skill', async () => {
+    // update-skill used to rmSync the target before delegating to install, so a
+    // skill the installed package does not carry was destroyed first and the
+    // update failed afterwards — data loss with nothing to show for it.
+    const installed = path.join(tmpHome, '.config', 'opencode', 'skills', 'removed-in-this-version');
+    fs.mkdirSync(installed, { recursive: true });
+    fs.writeFileSync(path.join(installed, 'SKILL.md'), '# user copy');
+    const configDir = path.join(tmpHome, '.config', 'xp-gate');
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(configDir, 'xp-gate.json'),
+      JSON.stringify({ installedSkills: { 'removed-in-this-version': { version: '0.0.1' } } })
+    );
+
+    const { updateSkill } = require('../update-skill');
+    expect(await updateSkill('removed-in-this-version', {})).toBe(1);
+    expect(fs.readFileSync(path.join(installed, 'SKILL.md'), 'utf8')).toBe('# user copy');
+  });
+});

package/lib/__tests__/install-skill.test.js

@@ -1,62 +1,20 @@
 /**
  * @test install-skill
- * @intent Verify installSkill() handles deps check, registry lookup, download, config, and errors
+ * @intent Verify installSkill() handles deps check, bundle lookup, config, backup, and errors
+ * @covers AC-416-01, AC-416-05
  */
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const https = require('https');
-const { EventEmitter } = require('events');
-
-function mockHttpsGet(optsOrList) {
-  const list = Array.isArray(optsOrList) ? [...optsOrList] : [optsOrList];
-  // Synchronous fake createWriteStream — the real one opens the FD asynchronously
-  // and races against downloadFile's unlinkSync(dest) in 301/302/error branches,
-  // causing ENOENT unhandled errors.
-  vi.spyOn(fs, 'createWriteStream').mockImplementation((dest) => {
-    let buf = '';
-    try {
-      fs.writeFileSync(dest, '');
-    } catch {
-      /* dest dir may not exist; downstream code will surface that */
-    }
-    const stream = new EventEmitter();
-    stream.write = (chunk) => {
-      buf += chunk;
-      return true;
-    };
-    stream.end = () => {
-      try {
-        fs.writeFileSync(dest, buf);
-      } catch {
-        /* file may have been unlinked by source; safe to ignore */
-      }
-      process.nextTick(() => stream.emit('finish'));
-    };
-    stream.close = () => {};
-    return stream;
-  });
 
-  vi.spyOn(https, 'get').mockImplementation((url, options, cb) => {
-    const callback = typeof options === 'function' ? options : cb;
-    const req = new EventEmitter();
-    const config = list.shift() || { statusCode: 200, body: '# Skill' };
-    process.nextTick(() => {
-      if (config.errorAfter) {
-        req.emit('error', new Error('Network error'));
-        return;
-      }
-      const response = new EventEmitter();
-      response.statusCode = config.statusCode != null ? config.statusCode : 200;
-      response.headers = config.redirectTo ? { location: config.redirectTo } : {};
-      response.pipe = (file) => {
-        file.write(config.body != null ? config.body : '# Skill');
-        file.end();
-      };
-      callback(response);
-    });
-    return req;
-  });
+const BUNDLED_SKILLS = path.join(__dirname, '..', '..', 'skills');
+
+function listDirs(root) {
+  return fs
+    .readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort();
 }
 
 describe('install-skill', () => {
@@ -67,11 +25,9 @@ describe('install-skill', () => {
     tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-in-'));
     process.env.HOME = tmpHome;
     vi.resetModules();
-    delete require.cache[require.resolve('../install-skill')];
-    delete require.cache[require.resolve('../detect-deps')];
-    delete require.cache[require.resolve('../shared-paths')];
-    delete require.cache[require.resolve('../download-skill')];
-    delete require.cache[require.resolve('../rollback')];
+    for (const mod of ['../install-skill', '../detect-deps', '../shared-paths', '../rollback']) {
+      delete require.cache[require.resolve(mod)];
+    }
     vi.spyOn(console, 'log').mockImplementation(() => {});
     vi.spyOn(console, 'error').mockImplementation(() => {});
     vi.spyOn(console, 'warn').mockImplementation(() => {});
@@ -145,7 +101,7 @@ describe('install-skill', () => {
     );
   });
 
-  it('returns 1 + Unknown skill error for unregistered name', async () => {
+  it('returns 1 + Unknown skill error for a name the bundle does not carry', async () => {
     setupValidDeps();
     const { installSkill } = require('../install-skill');
     const result = await installSkill('not-a-real-skill');
@@ -153,23 +109,50 @@ describe('install-skill', () => {
     expect(console.error).toHaveBeenCalledWith('Error: Unknown skill: not-a-real-skill');
   });
 
-  it('returns 0 and writes SKILL.md when install succeeds', async () => {
+  // The old hand-maintained SKILLS_REGISTRY could list a skill the bundle did not
+  // ship (or miss one it did). The error hint must come from the bundle itself.
+  it('names exactly the bundled skills in the unknown-skill hint', async () => {
+    setupValidDeps();
+    const { installSkill } = require('../install-skill');
+    await installSkill('not-a-real-skill');
+
+    const hint = console.error.mock.calls
+      .map(([message]) => message)
+      .find((message) => typeof message === 'string' && message.includes('bundles:'));
+    expect(hint).toBeDefined();
+    expect(hint.match(/bundles: ([^.]*)\./)[1].split(', ').sort()).toEqual(listDirs(BUNDLED_SKILLS));
+  });
+
+  it('keeps an existing directory when the skill is not bundled', async () => {
+    // Validation must precede backupExisting(), which rmSyncs the target: a
+    // leftover skill from an older package must never be wiped by a failed install.
+    setupValidDeps();
+    const target = path.join(skillsDir(), 'removed-in-this-version');
+    fs.mkdirSync(target, { recursive: true });
+    fs.writeFileSync(path.join(target, 'SKILL.md'), 'keep me');
+
+    const { installSkill } = require('../install-skill');
+    const result = await installSkill('removed-in-this-version');
+
+    expect(result).toBe(1);
+    expect(fs.readFileSync(path.join(target, 'SKILL.md'), 'utf8')).toBe('keep me');
+  });
+
+  it('returns 0 and installs the bundled skill when install succeeds', async () => {
     setupValidDeps();
-    mockHttpsGet({ statusCode: 200, body: '# Sprint Flow\nskill content' });
 
     const { installSkill } = require('../install-skill');
     const result = await installSkill('sprint-flow');
 
     expect(result).toBe(0);
     const installedFile = path.join(skillsDir(), 'sprint-flow', 'SKILL.md');
-    expect(fs.existsSync(installedFile)).toBe(true);
-    expect(fs.readFileSync(installedFile, 'utf8')).toContain('Sprint Flow');
+    expect(fs.readFileSync(installedFile, 'utf8'))
+      .toBe(fs.readFileSync(path.join(BUNDLED_SKILLS, 'sprint-flow', 'SKILL.md'), 'utf8'));
     expect(console.log).toHaveBeenCalledWith('✓ sprint-flow installed');
   });
 
   it('updates config with installedSkills metadata after successful install', async () => {
     setupValidDeps();
-    mockHttpsGet({ statusCode: 200, body: '# Content' });
 
     const { installSkill } = require('../install-skill');
     await installSkill('delphi-review');
@@ -202,15 +185,15 @@ describe('install-skill', () => {
     const target = path.join(skillsDir(), 'sprint-flow');
     fs.mkdirSync(target, { recursive: true });
     fs.writeFileSync(path.join(target, 'OLD.md'), 'old-content');
-    mockHttpsGet({ statusCode: 200, body: '# New Content' });
 
     const { installSkill } = require('../install-skill');
     const result = await installSkill('sprint-flow', { force: true });
 
     expect(result).toBe(0);
     const skillMd = path.join(target, 'SKILL.md');
-    expect(fs.existsSync(skillMd)).toBe(true);
-    expect(fs.readFileSync(skillMd, 'utf8')).toContain('New Content');
+    expect(fs.readFileSync(skillMd, 'utf8'))
+      .toBe(fs.readFileSync(path.join(BUNDLED_SKILLS, 'sprint-flow', 'SKILL.md'), 'utf8'));
+    expect(fs.existsSync(path.join(target, 'OLD.md'))).toBe(false);
 
     const backupRoot = path.join(configDir(), 'backup');
     expect(fs.existsSync(backupRoot)).toBe(true);
@@ -221,66 +204,16 @@ describe('install-skill', () => {
     expect(fs.readFileSync(backedUpFile, 'utf8')).toBe('old-content');
   });
 
-  it('returns 1 + Failed to download when network fails (non-offline)', async () => {
-    setupValidDeps();
-    mockHttpsGet({ statusCode: 404 });
-
-    const { installSkill } = require('../install-skill');
-    const result = await installSkill('sprint-flow');
-
-    expect(result).toBe(1);
-    expect(console.error).toHaveBeenCalledWith('Error: Failed to download sprint-flow');
-  });
-
-  it('returns 2 + offline-cache error when offline=true and no cache', async () => {
-    setupValidDeps();
-
-    const { installSkill } = require('../install-skill');
-    const result = await installSkill('sprint-flow', { offline: true });
-
-    expect(result).toBe(2);
-    expect(console.error).toHaveBeenCalledWith(
-      expect.stringContaining('--offline specified but sprint-flow not in cache')
-    );
-  });
-
-  it('verbose=true prints Downloading and Installed-to logs', async () => {
+  it('verbose=true prints Installing and Installed-to logs', async () => {
     setupValidDeps();
-    mockHttpsGet({ statusCode: 200, body: '# X' });
 
     const { installSkill } = require('../install-skill');
     await installSkill('test-driven-development', { verbose: true });
 
-    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Downloading '));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Installing '));
     expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Installed to '));
   });
 
-  it('verbose=true prints download-failure warning when network errors', async () => {
-    setupValidDeps();
-    mockHttpsGet({ statusCode: 500 });
-
-    const { installSkill } = require('../install-skill');
-    const result = await installSkill('ralph-loop', { verbose: true });
-
-    expect(result).toBe(1);
-    expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Download failed'));
-  });
-
-  it('follows redirect (302) to download successfully', async () => {
-    setupValidDeps();
-    mockHttpsGet([
-      { statusCode: 302, redirectTo: 'https://new.example.com/skill.md' },
-      { statusCode: 200, body: '# Redirected Content' },
-    ]);
-
-    const { installSkill } = require('../install-skill');
-    const result = await installSkill('sprint-flow');
-
-    expect(result).toBe(0);
-    const installedFile = path.join(skillsDir(), 'sprint-flow', 'SKILL.md');
-    expect(fs.readFileSync(installedFile, 'utf8')).toContain('Redirected Content');
-  });
-
   it('merges new skill into existing installedSkills config', async () => {
     setupValidDeps();
     fs.mkdirSync(configDir(), { recursive: true });
@@ -291,7 +224,6 @@ describe('install-skill', () => {
         otherSetting: true,
       })
     );
-    mockHttpsGet({ statusCode: 200, body: '# X' });
 
     const { installSkill } = require('../install-skill');
     await installSkill('delphi-review');
@@ -308,22 +240,9 @@ describe('install-skill', () => {
     setupValidDeps();
     fs.mkdirSync(configDir(), { recursive: true });
     fs.writeFileSync(path.join(configDir(), 'xp-gate.json'), '{not-valid-json');
-    mockHttpsGet({ statusCode: 200, body: '# X' });
 
     const { installSkill } = require('../install-skill');
     const result = await installSkill('sprint-flow');
     expect(result).toBe(0);
   });
-
-  it('returns 1 + Failed to download on network error (non-verbose silent)', async () => {
-    setupValidDeps();
-    mockHttpsGet({ errorAfter: true });
-
-    const { installSkill } = require('../install-skill');
-    const result = await installSkill('test-driven-development');
-
-    expect(result).toBe(1);
-    expect(console.warn).not.toHaveBeenCalled();
-    expect(console.error).toHaveBeenCalledWith('Error: Failed to download test-driven-development');
-  });
 });

package/lib/__tests__/language-tools-detect.test.js

@@ -0,0 +1,158 @@
+/**
+ * @test REQ-468
+ * @intent detectProjectLanguages() 只按 configFiles 判定语言，而 shell/powershell 两条
+ *         注册表项的 configFiles 为空数组 —— 这两种没有包管理器配置的语言因此永远检不出，
+ *         doctor/check-tools 对 147 个 .sh + 27 个 .ps1 的仓库视而不见（#468）
+ * @covers AC-468-01, AC-468-02, AC-468-03, AC-468-04, AC-468-05
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function makeFixture(spec) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-lang-'));
+  for (const [rel, content] of Object.entries(spec)) {
+    const target = path.join(root, rel);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, content);
+  }
+  return root;
+}
+
+describe('detectProjectLanguages extension fallback (#468)', () => {
+  let loadModule;
+
+  beforeEach(() => {
+    vi.resetModules();
+    for (const mod of ['../language-tools']) {
+      delete require.cache[require.resolve(mod)];
+    }
+    loadModule = () => require('../language-tools');
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  function detectedIn(spec) {
+    const root = makeFixture(spec);
+    try {
+      return loadModule().detectProjectLanguages(root).detected;
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  }
+
+  it('detects Shell from .sh files with no shell config file present', () => {
+    expect(detectedIn({ 'scripts/build.sh': '#!/bin/sh\necho hi\n' })).toContain('shell');
+  });
+
+  it('detects PowerShell from .ps1 files with no config file present', () => {
+    expect(detectedIn({ 'tools/audit.ps1': 'Write-Host hi\n' })).toContain('powershell');
+  });
+
+  it('does not report Shell for a project that has no shell script', () => {
+    const detected = detectedIn({ 'package.json': '{}' });
+    expect(detected).not.toContain('shell');
+    expect(detected).not.toContain('powershell');
+  });
+
+  // node_modules ships .sh files, so scanning it would label every Node project a
+  // Shell project and make check-tools demand shellcheck forever.
+  it('ignores dependency and VCS directories when scanning extensions', () => {
+    const detected = detectedIn({
+      'package.json': '{}',
+      'node_modules/left-pad/build.sh': '#!/bin/sh\n',
+      '.git/hooks/pre-commit.ps1': 'x\n',
+    });
+    expect(detected).not.toContain('shell');
+    expect(detected).not.toContain('powershell');
+  });
+
+  // The fallback is only for languages that have no config-file signal. Extensions
+  // are registered for every language, and IaC lists yaml/yml — applying them
+  // across the board would make any repo with a CI YAML an IaC project.
+  it('does not turn an unrelated YAML file into an IaC project', () => {
+    const detected = detectedIn({
+      'package.json': '{}',
+      '.github/workflows/ci.yml': 'name: ci\n',
+    });
+    expect(detected).not.toContain('iac');
+  });
+
+  it('keeps config-file detection for the languages that already had it', () => {
+    const root = makeFixture({
+      'package.json': '{"name":"x"}',
+      'tsconfig.json': '{}',
+    });
+    let result;
+    try {
+      result = loadModule().detectProjectLanguages(root);
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+    expect(result.detected).toContain('typescript');
+    expect(result.configFiles.typescript).toContain('tsconfig.json');
+  });
+});
+
+describe('check-tools language selection (#468)', () => {
+  let fixtureRoot;
+
+  beforeEach(() => {
+    vi.resetModules();
+    delete require.cache[require.resolve('../language-tools')];
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    fixtureRoot = makeFixture({ 'scripts/build.sh': '#!/bin/sh\necho hi\n' });
+    // vitest workers forbid process.chdir(), and the command resolves the project
+    // root through process.cwd().
+    vi.spyOn(process, 'cwd').mockReturnValue(fixtureRoot);
+  });
+
+  afterEach(() => {
+    fs.rmSync(fixtureRoot, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('--languages <lang> with a space is not silently ignored', async () => {
+    const { handleCheckTools } = require('../language-tools');
+    const code = await handleCheckTools(['--languages', 'shell', '--json']);
+
+    expect(code).toBe(0);
+    const reported = JSON.parse(console.log.mock.calls.at(-1)[0]);
+    expect(Object.keys(reported)).toEqual(['shell']);
+    expect(reported.shell.map((t) => t.name)).toContain('shellcheck');
+  });
+
+  it('--languages=<lang> keeps working', async () => {
+    const { handleCheckTools } = require('../language-tools');
+    const code = await handleCheckTools(['--languages=shell', '--json']);
+
+    expect(code).toBe(0);
+    const reported = JSON.parse(console.log.mock.calls.at(-1)[0]);
+    expect(Object.keys(reported)).toEqual(['shell']);
+  });
+
+  it('auto-detection reaches Shell, so check-tools with no flag lists shellcheck', async () => {
+    const { handleCheckTools } = require('../language-tools');
+    const code = await handleCheckTools(['--json']);
+
+    expect(code).toBe(0);
+    const reported = JSON.parse(console.log.mock.calls.at(-1)[0]);
+    expect(Object.keys(reported)).toContain('shell');
+  });
+
+  // Round 1 review (architecture MI-02): `--languages=` split into [''], which
+  // was treated as an explicit selection and reported a language named '' instead
+  // of falling back to detection like the bare flag does.
+  it('--languages= with an empty value falls back to auto-detection', async () => {
+    const { handleCheckTools } = require('../language-tools');
+    const code = await handleCheckTools(['--languages=', '--json']);
+
+    expect(code).toBe(0);
+    const reported = JSON.parse(console.log.mock.calls.at(-1)[0]);
+    expect(Object.keys(reported)).not.toContain('');
+    expect(Object.keys(reported)).toContain('shell');
+  });
+});

package/lib/__tests__/phase-transition.test.js

@@ -697,7 +697,21 @@ describe('phase-transition', () => {
       const outsideDir = fs.mkdtempSync(path.join(os.tmpdir(), 'requirements-context-'));
       const outsideFile = path.join(outsideDir, 'CONTEXT.md');
       fs.writeFileSync(outsideFile, 'outside context\n', 'utf8');
-      fs.symlinkSync(outsideFile, path.join(tmpDir, 'CONTEXT.md'));
+      // Creating a symlink needs SeCreateSymbolicLinkPrivilege (or Developer Mode)
+      // on Windows and fails with EPERM otherwise. Returning early here would
+      // leave an assertion that can never fail, so the gap is reported instead --
+      // and the try/finally below still cleans up the temp dir.
+      try {
+        fs.symlinkSync(outsideFile, path.join(tmpDir, 'CONTEXT.md'));
+      } catch (error) {
+        fs.rmSync(outsideDir, { recursive: true, force: true });
+        console.warn(
+          '[skip] symlink privilege unavailable on this host; the outside-root ' +
+            'context symlink rejection is NOT covered by this run.',
+        );
+        expect(error.code).toBe('EPERM');
+        return;
+      }
       const evidence = validRequirementsReview(tmpDir, { context_file_used: 'CONTEXT.md' });
       writeRequirementsReview(tmpDir, evidence);