@boyingliu01/xp-gate 0.18.5 → 0.19.1

package/lib/__tests__/sprint-discovery.test.ts

@@ -13,7 +13,6 @@ import os from 'os';
 
 // Types mirroring DiscoveredSprint interface
 interface DiscoveredSprint {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   state: any;
   sourcePath: string;
   worktreeExists: boolean;

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

@@ -14,7 +14,22 @@ let TMP_DIR;
 let cwdSpy;
 
 function git(cmd, dir) {
-  return execSync(`git ${cmd}`, { cwd: dir || TMP_DIR, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+  const gitEnv = { ...process.env };
+  for (const name of [
+    'GIT_ALTERNATE_OBJECT_DIRECTORIES', 'GIT_CONFIG', 'GIT_CONFIG_PARAMETERS',
+    'GIT_CONFIG_COUNT', 'GIT_OBJECT_DIRECTORY', 'GIT_DIR', 'GIT_WORK_TREE',
+    'GIT_IMPLICIT_WORK_TREE', 'GIT_GRAFT_FILE', 'GIT_INDEX_FILE',
+    'GIT_NO_REPLACE_OBJECTS', 'GIT_REPLACE_REF_BASE', 'GIT_PREFIX',
+    'GIT_SHALLOW_FILE', 'GIT_COMMON_DIR',
+  ]) {
+    delete gitEnv[name];
+  }
+  return execSync(`git ${cmd}`, {
+    cwd: dir || TMP_DIR,
+    env: gitEnv,
+    encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
 }
 
 function writeSprintState(state, dir) {
@@ -181,4 +196,88 @@ describe('sprint-status --rework-check (#369)', () => {
     expect(code).toBe(0);
     expect(output).toContain('No closed sprints within 1 day');
   });
+
+  test('(e) --dir takes precedence over inherited Git hook repository variables', async () => {
+    const targetDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rework-target-'));
+    const outerDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rework-outer-'));
+
+    for (const dir of [targetDir, outerDir]) {
+      git('init', dir);
+      git('config user.email "test@test.com"', dir);
+      git('config user.name "Test"', dir);
+    }
+    makeCommit('feat: target initial', targetDir);
+    makeCommit('fix: target bug', targetDir);
+    makeCommit('fix: outer one', outerDir);
+    makeCommit('fix: outer two', outerDir);
+    makeCommit('fix: outer three', outerDir);
+
+    writeSprintState({
+      _schema_version: 1,
+      id: 'sprint-hook-env',
+      task_description: 'Hook environment sprint',
+      phase: 6,
+      status: 'completed',
+      started_at: daysAgo(9),
+      isolation: { worktree_path: null, branch: 'main' },
+      phase_history: [],
+      metrics: { completed_at: daysAgo(2), total_sprint_commits: 10 },
+    }, targetDir);
+    cwdSpy.mockReturnValue(targetDir);
+
+    const previousGitDir = process.env.GIT_DIR;
+    const previousWorkTree = process.env.GIT_WORK_TREE;
+    process.env.GIT_DIR = path.join(outerDir, '.git');
+    process.env.GIT_WORK_TREE = outerDir;
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      const code = await handleSprintStatus([
+        '--rework-check', '--window-days', '7', '--dir', targetDir,
+      ]);
+      const output = logSpy.mock.calls.map(c => c.join(' ')).join('\n');
+
+      expect(code).toBe(0);
+      expect(output).toContain('10.0%');
+      expect(output).toContain('1 fix / 10 total commits');
+    } finally {
+      logSpy.mockRestore();
+      if (previousGitDir === undefined) delete process.env.GIT_DIR;
+      else process.env.GIT_DIR = previousGitDir;
+      if (previousWorkTree === undefined) delete process.env.GIT_WORK_TREE;
+      else process.env.GIT_WORK_TREE = previousWorkTree;
+      fs.rmSync(targetDir, { recursive: true, force: true });
+      fs.rmSync(outerDir, { recursive: true, force: true });
+    }
+  });
+
+  test('(f) completed_at cannot inject shell commands into the Git log query', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rework-injection-'));
+    const markerFile = path.join(dir, 'injection-marker');
+    cwdSpy.mockReturnValue(dir);
+    git('init', dir);
+    git('config user.email "test@test.com"', dir);
+    git('config user.name "Test"', dir);
+    makeCommit('fix: target bug', dir);
+
+    writeSprintState({
+      _schema_version: 1,
+      id: 'sprint-injection',
+      phase: 6,
+      status: 'completed',
+      metrics: {
+        completed_at: `Thu, 06 Aug 2026 00:00:00 GMT ("; touch ${markerFile}; #)`,
+        total_sprint_commits: 1,
+      },
+    }, dir);
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      const code = await handleSprintStatus(['--rework-check', '--window-days', '3650', '--dir', dir]);
+      expect(code).toBe(0);
+      expect(fs.existsSync(markerFile)).toBe(false);
+    } finally {
+      logSpy.mockRestore();
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
 });

package/lib/__tests__/update-hooks.test.js

@@ -3,9 +3,9 @@
  * @intent Verify updateHooks correctly syncs hook files with proper backup, dry-run, scope, and detection behavior
  * @covers AC-265-01, AC-265-02, AC-265-03, AC-265-04, AC-265-05
  */
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
 
 describe('updateHooks', () => {
   let tmpHome;
@@ -14,7 +14,6 @@ describe('updateHooks', () => {
   let originalHome;
   let logSpy;
   let warnSpy;
-  let errorSpy;
 
   beforeEach(() => {
     originalHome = process.env.HOME;
@@ -25,7 +24,6 @@ describe('updateHooks', () => {
     vi.resetModules();
     logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
   });
 
   afterEach(() => {
@@ -39,17 +37,26 @@ describe('updateHooks', () => {
   /** Helper: create a fake package structure under tmpPackage */
   function createPackageSource(overrides = {}) {
     const hooksDir = path.join(tmpPackage, 'hooks');
+    const hooksLibDir = path.join(hooksDir, 'lib');
     const adaptersDir = path.join(tmpPackage, 'adapters');
-    fs.mkdirSync(hooksDir, { recursive: true });
+    fs.mkdirSync(hooksLibDir, { recursive: true });
     fs.mkdirSync(adaptersDir, { recursive: true });
 
     fs.writeFileSync(path.join(hooksDir, 'pre-commit'), overrides['hooks/pre-commit'] || '#!/bin/bash\necho "hook-v2"');
     fs.writeFileSync(path.join(hooksDir, 'pre-push'), overrides['hooks/pre-push'] || '#!/bin/bash\necho "push-v2"');
+    fs.writeFileSync(path.join(hooksLibDir, 'now-ms.sh'), overrides['hooks/lib/now-ms.sh'] || 'now_ms() { echo 123; }');
     fs.writeFileSync(path.join(tmpPackage, 'adapter-common.sh'), overrides['adapter-common.sh'] || '#!/bin/bash\necho "adapter-common-v2"');
     fs.writeFileSync(path.join(adaptersDir, 'typescript.sh'), overrides['adapters/typescript.sh'] || '#!/bin/bash\necho "ts-v2"');
     fs.writeFileSync(path.join(adaptersDir, 'python.sh'), overrides['adapters/python.sh'] || '#!/bin/bash\necho "py-v2"');
     fs.writeFileSync(path.join(tmpPackage, 'gate-3.sh'), overrides['gate-3.sh'] || '#!/bin/bash\necho "gate3-v2"');
     fs.writeFileSync(path.join(tmpPackage, 'gate-4.sh'), overrides['gate-4.sh'] || '#!/bin/bash\necho "gate4-v2"');
+
+    // Quality gate modules (principles, mutation, mock-policy, build-integrity)
+    ['principles', 'build-integrity'].forEach(module => {
+      const moduleDir = path.join(tmpPackage, module);
+      fs.mkdirSync(moduleDir, { recursive: true });
+      fs.writeFileSync(path.join(moduleDir, 'index.ts'), overrides[`${module}/index.ts`] || `export const ${module} = 1;`);
+    });
   }
 
   /** Helper: get fresh updateHooks module */
@@ -145,16 +152,16 @@ describe('updateHooks', () => {
       expect(fs.readFileSync(path.join(dest, 'gate-4.sh'), 'utf8')).toContain('gate4-v2');
     });
 
-    it('copies sprint-gate.sh alongside gate-*.sh scripts (#335)', () => {
+    it('copies gate-12-file-hygiene.sh to the adapters directory', () => {
       createPackageSource();
-      fs.writeFileSync(path.join(tmpPackage, 'sprint-gate.sh'), '#!/bin/bash\necho "sprint-gate-v1"');
+      fs.writeFileSync(path.join(tmpPackage, 'gate-12-file-hygiene.sh'), '#!/bin/bash\necho "hygiene-v1"');
       const mod = getModule();
-      const dest = path.join(tmpProject, 'gates-sprint');
+      const dest = path.join(tmpProject, 'gates-hygiene');
       fs.mkdirSync(dest, { recursive: true });
 
       mod.copyGateScripts(tmpPackage, dest, false, true);
 
-      expect(fs.readFileSync(path.join(dest, 'sprint-gate.sh'), 'utf8')).toContain('sprint-gate-v1');
+      expect(fs.readFileSync(path.join(dest, 'gate-12-file-hygiene.sh'), 'utf8')).toContain('hygiene-v1');
     });
 
     it('does not copy non-gate files', () => {
@@ -167,6 +174,7 @@ describe('updateHooks', () => {
       mod.copyGateScripts(tmpPackage, dest, false, true);
 
       expect(fs.existsSync(path.join(dest, 'some-other.sh'))).toBe(false);
+      expect(fs.existsSync(path.join(dest, 'sprint-gate.sh'))).toBe(false);
     });
 
     it('handles missing source directory gracefully', () => {
@@ -181,6 +189,73 @@ describe('updateHooks', () => {
     });
   });
 
+  // ===== copySprintGate tests =====
+
+  describe('copySprintGate', () => {
+    it('copies sprint-gate.sh to the hooks directory', () => {
+      createPackageSource();
+      fs.writeFileSync(path.join(tmpPackage, 'sprint-gate.sh'), '#!/bin/bash\necho "sprint-gate-v1"');
+      const mod = getModule();
+      const hooksDest = path.join(tmpProject, 'hooks-dest');
+      fs.mkdirSync(hooksDest, { recursive: true });
+
+      mod.copySprintGate(tmpPackage, hooksDest, false, true);
+
+      expect(fs.readFileSync(path.join(hooksDest, 'sprint-gate.sh'), 'utf8')).toContain('sprint-gate-v1');
+    });
+
+    it('skips silently when sprint-gate.sh is absent from package root', () => {
+      createPackageSource();
+      const mod = getModule();
+      const hooksDest = path.join(tmpProject, 'hooks-no-sprint');
+      fs.mkdirSync(hooksDest, { recursive: true });
+
+      mod.copySprintGate(tmpPackage, hooksDest, false, true);
+
+      expect(fs.existsSync(path.join(hooksDest, 'sprint-gate.sh'))).toBe(false);
+    });
+  });
+
+  // ===== copyModules tests =====
+
+  describe('copyModules', () => {
+    it('copies quality gate module directories to the modules destination', () => {
+      createPackageSource();
+      const mod = getModule();
+      const modulesDest = path.join(tmpProject, 'modules-dest');
+      fs.mkdirSync(modulesDest, { recursive: true });
+
+      mod.copyModules(tmpPackage, modulesDest, false, true);
+
+      expect(fs.readFileSync(path.join(modulesDest, 'principles', 'index.ts'), 'utf8')).toContain('principles');
+      expect(fs.readFileSync(path.join(modulesDest, 'build-integrity', 'index.ts'), 'utf8')).toContain('build-integrity');
+    });
+
+    it('skips modules absent from the package root', () => {
+      createPackageSource();
+      const mod = getModule();
+      const modulesDest = path.join(tmpProject, 'modules-dest-skip');
+      fs.mkdirSync(modulesDest, { recursive: true });
+      fs.rmSync(path.join(tmpPackage, 'mutation'), { recursive: true, force: true });
+
+      mod.copyModules(tmpPackage, modulesDest, false, true);
+
+      expect(fs.existsSync(path.join(modulesDest, 'mutation'))).toBe(false);
+      expect(fs.existsSync(path.join(modulesDest, 'principles'))).toBe(true);
+    });
+
+    it('does not write files in dry-run mode', () => {
+      createPackageSource();
+      const mod = getModule();
+      const modulesDest = path.join(tmpProject, 'modules-dest-dry');
+      fs.mkdirSync(modulesDest, { recursive: true });
+
+      mod.copyModules(tmpPackage, modulesDest, true, true);
+
+      expect(fs.existsSync(path.join(modulesDest, 'principles', 'index.ts'))).toBe(false);
+    });
+  });
+
   // ===== atomicCopyFile tests =====
 
   describe('atomicCopyFile', () => {
@@ -403,6 +478,47 @@ describe('updateHooks', () => {
       mod.getPackageRoot = origGetPackageRoot;
     });
 
+    it('copies hooks/lib/now-ms.sh during a normal update', () => {
+      createPackageSource();
+      const hooksDest = path.join(tmpProject, '.git', 'hooks');
+      fs.mkdirSync(hooksDest, { recursive: true });
+      vi.spyOn(process, 'cwd').mockReturnValue(tmpProject);
+      const mod = getModule();
+      mod.getPackageRoot = () => tmpPackage;
+
+      const result = mod.updateHooks({
+        global: false,
+        force: true,
+        dryRun: false,
+        noBackup: true,
+        scope: 'hooks',
+      });
+
+      expect(result).toBe(0);
+      expect(fs.readFileSync(path.join(hooksDest, 'lib', 'now-ms.sh'), 'utf8')).toContain('echo 123');
+    });
+
+    it('does not write hooks/lib/now-ms.sh during a dry run', () => {
+      createPackageSource();
+      const hooksDest = path.join(tmpProject, '.git', 'hooks');
+      fs.mkdirSync(hooksDest, { recursive: true });
+      vi.spyOn(process, 'cwd').mockReturnValue(tmpProject);
+      const mod = getModule();
+      mod.getPackageRoot = () => tmpPackage;
+
+      const result = mod.updateHooks({
+        global: false,
+        force: true,
+        dryRun: true,
+        noBackup: true,
+        scope: 'hooks',
+      });
+
+      expect(result).toBe(0);
+      expect(logSpy).toHaveBeenCalledWith('  would update: lib/now-ms.sh');
+      expect(fs.existsSync(path.join(hooksDest, 'lib', 'now-ms.sh'))).toBe(false);
+    });
+
     it('returns 1 when local modifications detected and no --force', () => {
       createPackageSource();
       const hooksDest = path.join(tmpProject, '.git', 'hooks');
@@ -447,6 +563,8 @@ describe('updateHooks', () => {
       });
       expect(result).toBe(0);
       expect(fs.readFileSync(path.join(hooksDest, 'pre-commit'), 'utf8')).toContain('hook-v2');
+      // scope 'all' also re-deploys quality-gate modules (repairs existing installs)
+      expect(fs.readFileSync(path.join(tmpProject, '.xp-gate', 'modules', 'build-integrity', 'index.ts'), 'utf8')).toContain('build-integrity');
 
       mod.getPackageRoot = origGetPackageRoot;
     });
@@ -589,4 +707,19 @@ describe('updateHooks', () => {
       mod.getPackageRoot = origGetPackageRoot;
     });
   });
+
+  describe('warnMissingModuleDeps', () => {
+    it('warns when global module runtime deps are absent', () => {
+      const mod = getModule();
+      mod.warnMissingModuleDeps(true, false);
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('setup-global'));
+    });
+
+    it('does not warn for local installs or dry-runs', () => {
+      const mod = getModule();
+      mod.warnMissingModuleDeps(false, false);
+      mod.warnMissingModuleDeps(true, true);
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+  });
 });

package/lib/__tests__/upgrade-exec.test.js

@@ -13,8 +13,56 @@
  */
 
 const { EventEmitter } = require('events');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 
 describe('upgrade.js --apply execSync path', () => {
+  let cacheDir;
+  let savedCacheDir;
+  let savedHttpsGet;
+  let savedSpawn;
+  let savedReadFileSync;
+
+  beforeEach(() => {
+    savedCacheDir = process.env.XP_GATE_CACHE_DIR;
+    savedHttpsGet = require('https').get;
+    savedSpawn = require('child_process').spawn;
+    savedReadFileSync = fs.readFileSync;
+    cacheDir = undefined;
+    cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), 'upgrade-cache-'));
+    process.env.XP_GATE_CACHE_DIR = cacheDir;
+  });
+
+  afterEach(() => {
+    if (savedCacheDir === undefined) delete process.env.XP_GATE_CACHE_DIR;
+    else process.env.XP_GATE_CACHE_DIR = savedCacheDir;
+    require('https').get = savedHttpsGet;
+    require('child_process').spawn = savedSpawn;
+    fs.readFileSync = savedReadFileSync;
+    if (cacheDir) fs.rmSync(cacheDir, { recursive: true, force: true });
+  });
+
+  function installFakeHttpsGet(latestVersion) {
+    const https = require('https');
+    const saved = https.get;
+    https.get = (_url, options, callbackArg) => {
+      const callback = typeof options === 'function' ? options : callbackArg;
+      const request = new EventEmitter();
+      request.destroy = () => undefined;
+      if (!callback) return request;
+      const response = new EventEmitter();
+      response.statusCode = 200;
+      callback(response);
+      response.emit('data', JSON.stringify({ latest: latestVersion }));
+      response.emit('end');
+      return request;
+    };
+    return () => {
+      https.get = saved;
+    };
+  }
+
   function evictCache() {
     const resolved = require.resolve('../upgrade');
     const cvResolved = require.resolve('../check-version');
@@ -38,39 +86,36 @@ describe('upgrade.js --apply execSync path', () => {
     return ee;
   }
 
-  function withMockedEnv(latestVersion, spawnImpl, fn) {
-    const fs = require('fs');
-    const os = require('os');
-    const cpPath = require('path').join(os.homedir(), '.xp-gate', 'version-cache.json');
+  async function withMockedEnv(latestVersion, spawnImpl, fn) {
+    const cpPath = path.join(cacheDir, 'version-cache.json');
     if (fs.existsSync(cpPath)) {
       try { fs.unlinkSync(cpPath); } catch { }
     }
     evictCache();
     const cp = require('child_process');
-    const https = require('https');
-    const saved = { spawn: cp.spawn, httpsGet: https.get };
+    const updateSkillPath = require.resolve('../update-skill');
+    const saved = {
+      spawn: cp.spawn,
+      updateSkillCache: require.cache[updateSkillPath],
+    };
     cp.spawn = spawnImpl;
-    const body = JSON.stringify({ latest: latestVersion });
-    https.get = (_url, _opts, cb) => {
-      const callback = typeof _opts === 'function' ? _opts : cb;
-      if (!callback) return { on: () => undefined, destroy: () => undefined };
-      const mockRes = {
-        statusCode: 200,
-        on: (evt, handler) => {
-          if (evt === 'data') handler(body);
-          if (evt === 'end') handler();
-          return mockRes;
-        },
-      };
-      callback(mockRes);
-      return { on: () => undefined, destroy: () => undefined };
+    require.cache[updateSkillPath] = {
+      id: updateSkillPath,
+      filename: updateSkillPath,
+      loaded: true,
+      exports: { updateSkill: vi.fn(async () => 0) },
+      children: [],
+      paths: [],
     };
+    const restoreHttpsGet = installFakeHttpsGet(latestVersion);
     try {
       const m = require('../upgrade');
-      return fn(m);
+      return await fn(m);
     } finally {
       cp.spawn = saved.spawn;
-      https.get = saved.httpsGet;
+      restoreHttpsGet();
+      if (saved.updateSkillCache) require.cache[updateSkillPath] = saved.updateSkillCache;
+      else delete require.cache[updateSkillPath];
     }
   }
 
@@ -134,17 +179,14 @@ describe('upgrade.js --apply execSync path', () => {
   }, 10000);
 
   // ── withMockedEnv variant: also mocks getLocalVersion() to return null ──
-  function withMockedEnvNoLocal(latestVersion, spawnImpl, fn) {
-    const fs = require('fs');
-    const os = require('os');
-    const cpPath = require('path').join(os.homedir(), '.xp-gate', 'version-cache.json');
+  async function withMockedEnvNoLocal(latestVersion, spawnImpl, fn) {
+    const cpPath = path.join(cacheDir, 'version-cache.json');
     if (fs.existsSync(cpPath)) {
       try { fs.unlinkSync(cpPath); } catch { }
     }
     evictCache();
     const cp = require('child_process');
-    const https = require('https');
-    const saved = { spawn: cp.spawn, httpsGet: https.get, fsReadFileSync: fs.readFileSync };
+    const saved = { spawn: cp.spawn, fsReadFileSync: fs.readFileSync };
     cp.spawn = spawnImpl;
     // Make getLocalVersion() return null by making fs.readFileSync throw for package.json
     fs.readFileSync = (filePath, encoding) => {
@@ -155,27 +197,13 @@ describe('upgrade.js --apply execSync path', () => {
       }
       return saved.fsReadFileSync.call(fs, filePath, encoding);
     };
-    const body = JSON.stringify({ latest: latestVersion });
-    https.get = (_url, _opts, cb) => {
-      const callback = typeof _opts === 'function' ? _opts : cb;
-      if (!callback) return { on: () => undefined, destroy: () => undefined };
-      const mockRes = {
-        statusCode: 200,
-        on: (evt, handler) => {
-          if (evt === 'data') handler(body);
-          if (evt === 'end') handler();
-          return mockRes;
-        },
-      };
-      callback(mockRes);
-      return { on: () => undefined, destroy: () => undefined };
-    };
+    const restoreHttpsGet = installFakeHttpsGet(latestVersion);
     try {
       const m = require('../upgrade');
-      return fn(m);
+      return await fn(m);
     } finally {
       cp.spawn = saved.spawn;
-      https.get = saved.httpsGet;
+      restoreHttpsGet();
       fs.readFileSync = saved.fsReadFileSync;
     }
   }

package/lib/__tests__/upgrade-skill-sync.test.js

@@ -57,7 +57,7 @@ describe('doctor skill version check — #332', () => {
 
   // AC-332-05: diagnoseInstalledSkills compares installed skills against package-bundled skills
   it('AC-332-05: diagnoseInstalledSkills reads config installedSkills and package skills dir', () => {
-    const source = fs.readFileSync(require.resolve('../doctor.js'), 'utf8');
+    const source = fs.readFileSync(require.resolve('../doctor-tui.js'), 'utf8');
     expect(source).toContain('installedSkills');
     expect(source).toContain('diagnoseInstalledSkills');
     expect(source).toContain('skills');

package/lib/__tests__/upgrade.test.js

@@ -18,8 +18,9 @@ function capture() {
 }
 
 describe('upgrade.js — REQ-001-02', () => {
-  let mod;
   let r;
+  let cacheDir;
+  let savedCacheDir;
 
   function evictLibCache() {
     const resolved = require.resolve('../upgrade');
@@ -33,20 +34,22 @@ describe('upgrade.js — REQ-001-02', () => {
   }
 
   beforeEach(() => {
-    // Clear disk cache so checkUpgrade doesn't see stale data from
-    // upgrade-exec.test.js's mock (which wrote version-cache.json).
-    const fs = require('fs');
-    const os = require('os');
-    const cpPath = require('path').join(os.homedir(), '.xp-gate', 'version-cache.json');
-    if (fs.existsSync(cpPath)) { try { fs.unlinkSync(cpPath); } catch { } }
+    savedCacheDir = process.env.XP_GATE_CACHE_DIR;
+    r = undefined;
+    cacheDir = undefined;
+    cacheDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'upgrade-test-cache-'));
+    process.env.XP_GATE_CACHE_DIR = cacheDir;
     evictLibCache();
     vi.resetModules();
     r = capture();
-    mod = require('../upgrade');
+    require('../upgrade');
   });
 
   afterEach(() => {
-    r.restore();
+    r?.restore();
+    if (savedCacheDir === undefined) delete process.env.XP_GATE_CACHE_DIR;
+    else process.env.XP_GATE_CACHE_DIR = savedCacheDir;
+    if (cacheDir) fs.rmSync(cacheDir, { recursive: true, force: true });
   });
 
   // AC-002-01 through AC-002-06: tested in upgrade-exec.test.js (isolated, no real network)
@@ -73,5 +76,3 @@ describe('upgrade.js — REQ-001-02', () => {
     });
   });
 });
-
-

package/lib/doctor.js

@@ -275,6 +275,7 @@ const EXPECTED_GATE_SCRIPTS = [
   'gate-7.sh',
   'gate-8.sh',
   'gate-9.sh',
+  'gate-10.sh',
 ];
 
 async function checkAdapters(checks, mode, gitDirPromise) {
@@ -713,7 +714,7 @@ function fixMissingAdapters(mode, srcDir, adaptersDir) {
 
 /**
  * Restore missing gate scripts from package root to adapters directory.
- * Gate scripts (gate-3.sh through gate-9.sh) are stored in the package root,
+ * Gate scripts (gate-3.sh through gate-10.sh) are stored in the package root,
  * not in the adapters subdirectory.
  */
 function fixMissingGateScripts(srcDir, adaptersDir) {