@boyingliu01/xp-gate 0.35.23 → 0.35.24

package/adapter-common.sh

@@ -104,41 +104,30 @@ detect_project_lang() {
   fi
 }
 
-route_to_adapter() {
-  local action="$1"
-  local lang
-  lang=$(detect_project_lang)
-  
-  local adapter_file=""
-
-  # 3-tier resolution matching pre-commit ADAPTER_DIR logic
-  # Tier 1: Global flat layout (~/.config/xp-gate/adapters/lang.sh)
-  if [ -f "$HOME/.config/xp-gate/adapters/${lang}.sh" ]; then
-    adapter_file="$HOME/.config/xp-gate/adapters/${lang}.sh"
-  # Tier 2: Project nested layout (githooks/adapters/lang.sh)
-  elif [ -f "githooks/adapters/${lang}.sh" ]; then
-    adapter_file="githooks/adapters/${lang}.sh"
-  elif [ -f "./githooks/adapters/${lang}.sh" ]; then
-    adapter_file="./githooks/adapters/${lang}.sh"
-  fi
-
-  if [ -n "$adapter_file" ]; then
-    # shellcheck source=./githooks/adapters/lang.sh
-    source "$adapter_file"
-    
-    # Execute the requested action
-    case "$action" in
-      "static_analysis") run_static_analysis ;;
-      "lint") run_lint ;;
-      "tests") run_tests ;;
-      "coverage") run_coverage ;;
-      *) return 1 ;;
-    esac
-  else
-    echo "No adapter found for language: $lang (searched: ~/.config/xp-gate/adapters/, githooks/adapters/)"
-    return 1
-  fi
-}
+# ---------------------------------------------------------------------------
+# REMOVED in #688: route_to_adapter()
+#
+# It was a dispatcher with zero production callers. pre-commit sources an
+# adapter and calls `run_static_analysis` / `run_lint` / `run_tests` /
+# `run_coverage` directly; nothing ever went through this function, so its
+# `case "$action"` enumeration was dead too -- including the "add an
+# `architecture` arm and it'll work" assumption in #688, which would have been
+# a no-op.
+#
+# Its two never-invoked dependants are gone with it: `run_architecture()` in
+# adapters/python.sh and adapters/go.sh. Gate 6 already implements both checks
+# INLINE in pre-commit, and does it better than the adapter versions did:
+#   * Python: detects 4 config carriers (.import-linter.yml /
+#     import_linter_config.yml / .importlinter / pyproject [tool.importlinter]),
+#     where the adapter checked 2, and BLOCKs when lint-imports is missing
+#     instead of `require_tool ... || return 0` silently passing.
+#   * Go: reads the checker's own exit status via PIPESTATUS[0] (#630), where a
+#     `arch-go check | head` pipeline would have reported head's status.
+# Wiring the adapter version back in would therefore have been a regression,
+# so the dead code was deleted instead of connected.
+#
+# tests: githooks/__tests__/issue-688-dead-dispatcher-removed.test.bats
+# ---------------------------------------------------------------------------
 
 check_if_tool_available() {
   local tool_name="$1"

package/adapters/go.sh

@@ -43,17 +43,12 @@ run_lint() {
   return $?
 }
 
-run_architecture() {
-  if ! require_tool arch-go "arch-go (Go architecture checker)" 2>/dev/null; then
-    echo "⚠ arch-go not available, installing..."
-    go install github.com/arch-go/arch-go@latest 2>/dev/null
-    require_tool arch-go "arch-go" || return 0
-  fi
-
-  echo "Running Go architecture checks (arch-go)..."
-  arch-go check
-  return $?
-}
+# REMOVED in #688: run_architecture()
+# Never invoked -- its only would-be caller, route_to_adapter(), had no callers
+# either. Gate 6 implements arch-go in pre-commit (grep "arch-go"), and reads
+# the checker's own exit status via PIPESTATUS[0] (#630) instead of letting a
+# `| head` pipeline report head's. See githooks/adapter-common.sh for the full
+# rationale.
 
 run_tests() {
   require_tool go "Go SDK" || return 1

package/adapters/python.sh

@@ -180,17 +180,12 @@ run_lint() {
   fi
 }
 
-run_architecture() {
-  if [ ! -f ".import-linter.yml" ] && [ ! -f "import_linter_config.yml" ]; then
-    return 0
-  fi
-
-  require_tool lint-imports "import-linter" || return 0
-
-  echo "Running Python architecture checks (import-linter)..."
-  lint-imports
-  return $?
-}
+# REMOVED in #688: run_architecture()
+# Never invoked -- its only would-be caller, route_to_adapter(), had no callers
+# either. Gate 6 implements import-linter in pre-commit (grep "import-linter"),
+# and more thoroughly: it detects 4 config carriers instead of the 2 checked
+# here, and BLOCKs on a missing lint-imports rather than `|| return 0` passing.
+# See githooks/adapter-common.sh for the full rationale.
 
 run_tests() {
   require_tool pytest "pytest" || return 1

package/hooks/adapter-common.sh

@@ -104,41 +104,30 @@ detect_project_lang() {
   fi
 }
 
-route_to_adapter() {
-  local action="$1"
-  local lang
-  lang=$(detect_project_lang)
-  
-  local adapter_file=""
-
-  # 3-tier resolution matching pre-commit ADAPTER_DIR logic
-  # Tier 1: Global flat layout (~/.config/xp-gate/adapters/lang.sh)
-  if [ -f "$HOME/.config/xp-gate/adapters/${lang}.sh" ]; then
-    adapter_file="$HOME/.config/xp-gate/adapters/${lang}.sh"
-  # Tier 2: Project nested layout (githooks/adapters/lang.sh)
-  elif [ -f "githooks/adapters/${lang}.sh" ]; then
-    adapter_file="githooks/adapters/${lang}.sh"
-  elif [ -f "./githooks/adapters/${lang}.sh" ]; then
-    adapter_file="./githooks/adapters/${lang}.sh"
-  fi
-
-  if [ -n "$adapter_file" ]; then
-    # shellcheck source=./githooks/adapters/lang.sh
-    source "$adapter_file"
-    
-    # Execute the requested action
-    case "$action" in
-      "static_analysis") run_static_analysis ;;
-      "lint") run_lint ;;
-      "tests") run_tests ;;
-      "coverage") run_coverage ;;
-      *) return 1 ;;
-    esac
-  else
-    echo "No adapter found for language: $lang (searched: ~/.config/xp-gate/adapters/, githooks/adapters/)"
-    return 1
-  fi
-}
+# ---------------------------------------------------------------------------
+# REMOVED in #688: route_to_adapter()
+#
+# It was a dispatcher with zero production callers. pre-commit sources an
+# adapter and calls `run_static_analysis` / `run_lint` / `run_tests` /
+# `run_coverage` directly; nothing ever went through this function, so its
+# `case "$action"` enumeration was dead too -- including the "add an
+# `architecture` arm and it'll work" assumption in #688, which would have been
+# a no-op.
+#
+# Its two never-invoked dependants are gone with it: `run_architecture()` in
+# adapters/python.sh and adapters/go.sh. Gate 6 already implements both checks
+# INLINE in pre-commit, and does it better than the adapter versions did:
+#   * Python: detects 4 config carriers (.import-linter.yml /
+#     import_linter_config.yml / .importlinter / pyproject [tool.importlinter]),
+#     where the adapter checked 2, and BLOCKs when lint-imports is missing
+#     instead of `require_tool ... || return 0` silently passing.
+#   * Go: reads the checker's own exit status via PIPESTATUS[0] (#630), where a
+#     `arch-go check | head` pipeline would have reported head's status.
+# Wiring the adapter version back in would therefore have been a regression,
+# so the dead code was deleted instead of connected.
+#
+# tests: githooks/__tests__/issue-688-dead-dispatcher-removed.test.bats
+# ---------------------------------------------------------------------------
 
 check_if_tool_available() {
   local tool_name="$1"

package/lib/__tests__/doctor-delphi.test.js

@@ -403,7 +403,7 @@ describe('doctor delphi #684 global config fallback', () => {
     return { logs, restore: () => spy.mockRestore() };
   }
 
-  it('AC-684-01: a valid global config with no project copy PASSes instead of failing', async () => {
+  it('AC-721-01: a valid global config with no project copy PASSes instead of failing', async () => {
     const globalPath = writeGlobalConfig();
     const project = path.join(tmpHome, 'a-project-with-no-config');
     fs.mkdirSync(project, { recursive: true });
@@ -417,7 +417,7 @@ describe('doctor delphi #684 global config fallback', () => {
     expect(cfgLine).toMatch(/global/i);
   });
 
-  it('AC-684-02: no config in either scope still FAILs (fallback must not mask a broken install)', async () => {
+  it('AC-721-02: no config in either scope still FAILs (fallback must not mask a broken install)', async () => {
     const project = path.join(tmpHome, 'bare-project');
     fs.mkdirSync(project, { recursive: true });
     const { logs, restore } = captureLogs();
@@ -436,7 +436,7 @@ describe('doctor delphi #684 global config fallback', () => {
     expect(cfgLine).toMatch(/not found/);
   });
 
-  it('AC-684-03: a project config still wins over the global one', async () => {
+  it('AC-721-03: a project config still wins over the global one', async () => {
     const globalPath = writeGlobalConfig();
     const project = path.join(tmpHome, 'project-with-own-config');
     fs.mkdirSync(project, { recursive: true });

package/lib/__tests__/doctor-tui-skill-freshness.test.js

@@ -336,7 +336,7 @@ describe('doctor-tui skill freshness #681 equal version, different content', ()
     return { issues, check: checks.find((c) => c.name === `Skill: ${name}`) };
   }
 
-  it('AC-681-01: same version but a missing chapter is WARN, not "Up to date"', () => {
+  it('AC-718-01: same version but a missing chapter is WARN, not "Up to date"', () => {
     const bundled = fs.readFileSync(path.join(bundledSkillsDir, 'delphi-review', 'SKILL.md'), 'utf8');
     // Keep the frontmatter (version included), drop a large slice of the body.
     const idx = bundled.indexOf('\n---', 4);
@@ -352,7 +352,7 @@ describe('doctor-tui skill freshness #681 equal version, different content', ()
     expect(issues).toBe(1);
   });
 
-  it('AC-681-02: same version and same content is still "Up to date" (no false alarm)', () => {
+  it('AC-718-02: same version and same content is still "Up to date" (no false alarm)', () => {
     const bundled = fs.readFileSync(path.join(bundledSkillsDir, 'delphi-review', 'SKILL.md'), 'utf8');
     installSkill('delphi-review', bundled);
     const { issues, check } = runFreshness('delphi-review');
@@ -360,7 +360,7 @@ describe('doctor-tui skill freshness #681 equal version, different content', ()
     expect(issues).toBe(0);
   });
 
-  it('AC-681-03: line endings alone still do not count as a difference', () => {
+  it('AC-718-03: line endings alone still do not count as a difference', () => {
     const bundled = fs.readFileSync(path.join(bundledSkillsDir, 'delphi-review', 'SKILL.md'), 'utf8');
     installSkill('delphi-review', bundled.replace(/\r\n/g, '\n').replace(/\n/g, '\r\n'));
     const { issues, check } = runFreshness('delphi-review');

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

@@ -17,37 +17,60 @@ function listDirs(root) {
     .sort();
 }
 
-describe('install-skill', () => {
-  let tmpHome, originalHome;
-
-  beforeEach(() => {
-    originalHome = process.env.HOME;
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-in-'));
-    process.env.HOME = tmpHome;
+/**
+ * Shared fixture for the blocks that need a throwaway HOME and a clean module
+ * cache.
+ *
+ * install-skill reads caches HOME at module load, so every test has to reset
+ * four modules and silence three console channels. Two copies of that boilerplate
+ * tripped the clone detector, and the two copies had already drifted (one
+ * afterEach waited for a pending setImmediate, the other did not) -- which is
+ * exactly how a teardown race starts. The stricter teardown wins here.
+ */
+function makeHomeFixture(prefix) {
+  const handle = { tmpHome: null, originalHome: null };
+  const MODULES = ['../install-skill', '../detect-deps', '../shared-paths', '../rollback'];
+
+  handle.dropModuleCache = () => {
+    for (const mod of MODULES) delete require.cache[require.resolve(mod)];
+  };
+
+  handle.beforeEach = () => {
+    handle.originalHome = process.env.HOME;
+    handle.tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    process.env.HOME = handle.tmpHome;
     vi.resetModules();
-    for (const mod of ['../install-skill', '../detect-deps', '../shared-paths', '../rollback']) {
-      delete require.cache[require.resolve(mod)];
-    }
+    handle.dropModuleCache();
     vi.spyOn(console, 'log').mockImplementation(() => {});
     vi.spyOn(console, 'error').mockImplementation(() => {});
     vi.spyOn(console, 'warn').mockImplementation(() => {});
-  });
+  };
 
-  afterEach(async () => {
+  handle.afterEach = async () => {
     await new Promise((resolve) => setImmediate(resolve));
-    process.env.HOME = originalHome;
+    process.env.HOME = handle.originalHome;
     vi.restoreAllMocks();
-    if (fs.existsSync(tmpHome)) {
-      fs.rmSync(tmpHome, { recursive: true, force: true });
+    if (fs.existsSync(handle.tmpHome)) {
+      fs.rmSync(handle.tmpHome, { recursive: true, force: true });
     }
-  });
+    handle.dropModuleCache();
+  };
+
+  return handle;
+}
+
+describe('install-skill', () => {
+  const fx = makeHomeFixture('xpgate-in-');
+
+  beforeEach(fx.beforeEach);
+  afterEach(fx.afterEach);
 
   function skillsDir() {
-    return path.join(tmpHome, '.config', 'opencode', 'skills');
+    return path.join(fx.tmpHome, '.config', 'opencode', 'skills');
   }
 
   function configDir() {
-    return path.join(tmpHome, '.config', 'xp-gate');
+    return path.join(fx.tmpHome, '.config', 'xp-gate');
   }
 
   function setupValidDeps() {
@@ -161,8 +184,13 @@ describe('install-skill', () => {
     expect(fs.existsSync(configFile)).toBe(true);
     const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
     expect(config.installedSkills).toHaveProperty('delphi-review');
-    // Read version dynamically from VERSION file — no hardcoded version to break on bump
-    const expectedVersion = fs.readFileSync(path.join(__dirname, '..', '..', '..', '..', 'VERSION'), 'utf8').trim();
+    // Read the version dynamically so a bump never breaks this test. The source
+    // is package.json, not the repo's VERSION: that file is a release stamp
+    // ('0.35.23.0'), is not shipped in the npm package, and resolving it from
+    // __dirname only works inside a checkout (#713).
+    const expectedVersion = JSON.parse(
+      fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf8')
+    ).version;
     expect(config.installedSkills['delphi-review'].version).toBe(expectedVersion);
     expect(config.installedSkills['delphi-review'].installedAt).toMatch(/^\d{4}-/);
   });
@@ -246,3 +274,62 @@ describe('install-skill', () => {
     expect(result).toBe(0);
   });
 });
+
+// ── #713: the "unknown skill" hint must not print a fake version ─────────────
+// getCliVersion() resolved `../../../VERSION` relative to __dirname. In an
+// installed package __dirname is
+// `node_modules/@boyingliu01/xp-gate/lib`, so three levels up lands in
+// `node_modules/` -- and the package does not ship a VERSION file at all. The
+// catch therefore fed `0.0.0` to every caller that prints it, so a user seeing
+//
+//   xp-gate 0.0.0 bundles: ...
+//
+// reasonably concluded their install was broken. The version has to come from
+// the package.json the CLI is actually running out of.
+describe('install-skill #713 CLI version reporting', () => {
+  const fx = makeHomeFixture('xpgate-ver-');
+
+  beforeEach(fx.beforeEach);
+  afterEach(fx.afterEach);
+
+  /**
+   * @test REQ-713 Honest version reporting
+   * @intent An unknown-skill error must name the real package version, never 0.0.0
+   * @covers AC-713-04
+   *
+   * The repo checkout masks this bug: `<repo>/VERSION` exists, so resolving
+   * `../../../VERSION` from `src/npm-package/lib/` lands on it and looks correct.
+   * An installed package has no such luck -- npm's `files` list does not include
+   * VERSION, and three levels up from `node_modules/@boyingliu01/xp-gate/lib` is
+   * `node_modules/`. So the assertion that matters is the one that holds in the
+   * shipped layout, which is measured here by demanding the value AGREE with
+   * package.json rather than with whatever VERSION happens to sit above the tree.
+   */
+  it('AC-713-04: unknown-skill error reports the package version, not 0.0.0 and not repo VERSION', async () => {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf8'));
+
+    // install-skill destructures checkDeps at require time, so a spy on the
+    // module object cannot intercept it. Inject a stub into the require cache
+    // BEFORE install-skill loads -- the deps gate runs ahead of the name check,
+    // and this test measures version reporting, not dependency probing.
+    const detectPath = require.resolve('../detect-deps.js');
+    require.cache[detectPath] = {
+      id: detectPath,
+      filename: detectPath,
+      loaded: true,
+      exports: {
+        ...require('../detect-deps.js'),
+        checkDeps: async () => ({ ok: true }),
+      },
+    };
+
+    const { installSkill } = require('../install-skill');
+    const code = await installSkill('definitely-not-a-bundled-skill', { force: true });
+    expect(code).toBe(1);
+
+    const said = console.error.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(said).toMatch(/Unknown skill/);
+    expect(said).not.toContain('0.0.0');
+    expect(said).toContain(`xp-gate ${pkg.version} bundles:`);
+  });
+});

package/lib/__tests__/uninstall-global-residue.test.js

@@ -44,6 +44,21 @@ function makeHome() {
   return home;
 }
 
+/**
+ * Load a module fresh so it re-reads HOME. Every lib reads os.homedir() at call
+ * time, but a cached module still holds `GLOBAL_DIRS` values captured earlier.
+ * Shared by every describe block here: three copies of this loop tripped the
+ * clone detector, and they had to stay byte-identical to be correct.
+ */
+function freshRequire(relPath) {
+  for (const key of Object.keys(require.cache)) {
+    if (key.includes(`${path.sep}npm-package${path.sep}lib${path.sep}`)) {
+      delete require.cache[key];
+    }
+  }
+  return require(relPath);
+}
+
 /**
  * Reproduce the on-disk shape `xp-gate setup-global` leaves behind, including the
  * parts that were measured as residue in #663.
@@ -84,15 +99,6 @@ describe('uninstall --global plans the whole installation, not just hooks (#663)
    * Load a module fresh so it re-reads HOME. Every lib reads os.homedir() at call
    * time, but a cached module still holds `GLOBAL_DIRS` values captured earlier.
    */
-  function freshRequire(relPath) {
-    for (const key of Object.keys(require.cache)) {
-      if (key.includes(`${path.sep}npm-package${path.sep}lib${path.sep}`)) {
-        delete require.cache[key];
-      }
-    }
-    return require(relPath);
-  }
-
   it('AC-670-37: modules, node_modules and the manifest files are all in scope', () => {
     const { buildPlan } = freshRequire('../uninstall');
     expect(typeof buildPlan).toBe('function');
@@ -158,3 +164,218 @@ describe('uninstall --global plans the whole installation, not just hooks (#663)
     expect(names).not.toContain('edited-skill');
   });
 });
+
+// -- #714: the residue must be DELETED, not merely scheduled --------------------
+// #663 taught `buildPlan()` to list modules/, node_modules/, package.json,
+// package-lock.json and xp-gate.json, so AC-670-37 passed -- but it only ever
+// asserted those paths appear in the plan. On Windows the run still printed
+//
+//   Warning: ~/.config/xp-gate/xp-gate.json does not contain xp-gate signature - skipping
+//
+// for all three files (the two directories were deleted, because a `dir` step
+// recurses without an ownership check). The plan entries carried neither
+// `signature` nor `manifestKey`, so removeFile() reached
+// `content.includes(undefined)`, which is always false. Worst case: the
+// uninstaller had just written `"mode": "uninstalled"` into xp-gate.json and
+// then reported that file as "not xp-gate's".
+//
+// The lesson these tests encode: a residue test that only inspects the PLAN
+// cannot see a broken DELETE. Every assertion below runs the real uninstall.
+describe('uninstall --global actually removes the residue (#714)', () => {
+  let home;
+  const savedEnv = {};
+  const realArgv = process.argv;
+
+  beforeEach(() => {
+    home = makeHome();
+    savedEnv.HOME = process.env.HOME;
+    savedEnv.USERPROFILE = process.env.USERPROFILE;
+    process.env.HOME = home;
+    process.env.USERPROFILE = home;
+    process.argv = ['node', 'xp-gate', 'uninstall', '--global', '--force'];
+  });
+
+  afterEach(() => {
+    process.argv = realArgv;
+    process.env.HOME = savedEnv.HOME;
+    process.env.USERPROFILE = savedEnv.USERPROFILE;
+    fs.rmSync(home, { recursive: true, force: true });
+  });
+
+  function configDir() {
+    return path.join(home, '.config', 'xp-gate');
+  }
+
+  /**
+   * Seed a REAL setup-global layout: the three manifest-ish files carry the
+   * content `setup-global` writes, so a signature check has to succeed or fail
+   * on realistic input rather than on `{}`.
+   */
+  function seedRealisticInstall() {
+    for (const rel of ['hooks', 'adapters', 'modules/principles', 'node_modules/js-yaml']) {
+      fs.mkdirSync(path.join(configDir(), rel), { recursive: true });
+      fs.writeFileSync(path.join(configDir(), rel, 'index.js'), 'module.exports = {};\n');
+    }
+    fs.writeFileSync(
+      path.join(configDir(), 'package.json'),
+      JSON.stringify({ dependencies: { 'js-yaml': '^5.2.2', zod: '^4.4.3' } }, null, 2)
+    );
+    fs.writeFileSync(
+      path.join(configDir(), 'package-lock.json'),
+      JSON.stringify({ name: 'xp-gate-global', lockfileVersion: 3, packages: {} }, null, 2)
+    );
+    // `mode: 'global'` is what uninstall() reads to decide there is anything to
+    // do; without it the run exits "No xp-gate installation found" and the test
+    // would pass while touching nothing.
+    fs.writeFileSync(
+      path.join(configDir(), 'xp-gate.json'),
+      JSON.stringify(
+        {
+          lastInit: new Date().toISOString(),
+          mode: 'global',
+          manifest: { files: {} },
+        },
+        null,
+        2
+      )
+    );
+    fs.writeFileSync(path.join(configDir(), '.delphi-config.json'), '{ "active_profile": "default" }\n');
+  }
+
+  /**
+   * @test REQ-717 Uninstall completeness
+   * @intent A file step in the residue plan must be deleted, not skipped for lack of a signature
+   * @covers AC-717-01
+   */
+  it('AC-717-01: package.json, package-lock.json and xp-gate.json are gone after uninstall', async () => {
+    seedRealisticInstall();
+    const { uninstall } = freshRequire('../uninstall');
+    await uninstall(['--global', '--force']);
+
+    for (const file of ['package.json', 'package-lock.json']) {
+      expect(
+        fs.existsSync(path.join(configDir(), file)),
+        `${file} survived uninstall - it is xp-gate's own file, not user data`
+      ).toBe(false);
+    }
+
+    // xp-gate.json is deliberately retained: the state machine rewrites it with
+    // `mode: "uninstalled"` so a second `uninstall` is a clean no-op (AC-09).
+    // What #714 broke was not the retention but the CLAIM about it -- the run
+    // called this file "not xp-gate's" while rewriting it. AC-717-04 pins that.
+    const manifestFile = path.join(configDir(), 'xp-gate.json');
+    expect(fs.existsSync(manifestFile)).toBe(true);
+    const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
+    expect(manifest.mode).toBe('uninstalled');
+  });
+
+  /**
+   * @test REQ-717 Uninstall completeness
+   * @intent The two residue directories must go too, so a later setup-global cannot reuse them
+   * @covers AC-717-02
+   */
+  it('AC-717-02: modules/ and node_modules/ are gone after uninstall', async () => {
+    seedRealisticInstall();
+    const { uninstall } = freshRequire('../uninstall');
+    await uninstall(['--global', '--force']);
+
+    expect(fs.existsSync(path.join(configDir(), 'modules'))).toBe(false);
+    expect(fs.existsSync(path.join(configDir(), 'node_modules'))).toBe(false);
+    expect(fs.existsSync(path.join(configDir(), 'adapters'))).toBe(false);
+  });
+
+  /**
+   * @test REQ-717 Uninstall completeness
+   * @intent User data must still survive the now-working deletion path
+   * @covers AC-717-03
+   */
+  it('AC-717-03: .delphi-config.json survives the completed uninstall', async () => {
+    seedRealisticInstall();
+    const { uninstall } = freshRequire('../uninstall');
+    await uninstall(['--global', '--force']);
+
+    expect(fs.existsSync(path.join(configDir(), '.delphi-config.json'))).toBe(true);
+  });
+
+  /**
+   * @test REQ-717 Uninstall completeness
+   * @intent The uninstall must not report success while leaving its own residue behind
+   * @covers AC-717-04
+   */
+  it('AC-717-04: uninstall does not warn that its own residue files are foreign', async () => {
+    seedRealisticInstall();
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      const { uninstall } = freshRequire('../uninstall');
+      await uninstall(['--global', '--force']);
+
+      const said = warnSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+      for (const file of ['package.json', 'package-lock.json', 'xp-gate.json']) {
+        expect(
+          said.includes(`${file} does not contain xp-gate signature`),
+          `uninstall disowned ${file}: ${said}`
+        ).toBe(false);
+      }
+    } finally {
+      warnSpy.mockRestore();
+      logSpy.mockRestore();
+    }
+  });
+});
+
+describe('uninstall hooks directory ownership (#714)', () => {
+  let home;
+  const savedEnv = {};
+
+  beforeEach(() => {
+    home = makeHome();
+    savedEnv.HOME = process.env.HOME;
+    savedEnv.USERPROFILE = process.env.USERPROFILE;
+    process.env.HOME = home;
+    process.env.USERPROFILE = home;
+  });
+
+  afterEach(() => {
+    process.env.HOME = savedEnv.HOME;
+    process.env.USERPROFILE = savedEnv.USERPROFILE;
+    fs.rmSync(home, { recursive: true, force: true });
+  });
+
+  /**
+   * @test REQ-717 Hook ownership
+   * @intent post-commit is installed by copyHooks(), so it must count as xp-gate's own
+   * @covers AC-717-05
+   */
+  it('AC-717-05: post-commit is classified as xp-gate-owned, not foreign', () => {
+    const { planHooksDirRemoval } = freshRequire('../uninstall');
+    const hooksDir = path.join(process.env.HOME, '.config', 'xp-gate', 'hooks');
+    fs.mkdirSync(hooksDir, { recursive: true });
+    // copyHooks() installs exactly these; post-commit was the one it forgot.
+    for (const f of ['pre-commit', 'pre-push', 'post-merge', 'post-commit', 'hook-module-resolution.sh']) {
+      fs.writeFileSync(path.join(hooksDir, f), '#!/bin/sh\n');
+    }
+
+    const result = planHooksDirRemoval(hooksDir);
+    const foreignNames = (result.foreign || []).map((f) => f.name);
+    expect(foreignNames).not.toContain('post-commit');
+  });
+
+  /**
+   * @test REQ-717 Hook ownership
+   * @intent A genuinely foreign hook (git-lfs) must still be protected
+   * @covers AC-717-06
+   */
+  it('AC-717-06: a third-party hook is still classified as foreign and kept', () => {
+    const { planHooksDirRemoval } = freshRequire('../uninstall');
+    const hooksDir = path.join(process.env.HOME, '.config', 'xp-gate', 'hooks');
+    fs.mkdirSync(hooksDir, { recursive: true });
+    fs.writeFileSync(path.join(hooksDir, 'pre-commit'), '#!/bin/sh\n');
+    fs.writeFileSync(path.join(hooksDir, 'post-checkout'), '#!/bin/sh\n# git-lfs\n');
+
+    const result = planHooksDirRemoval(hooksDir);
+    const foreignNames = (result.foreign || []).map((f) => f.name);
+    expect(foreignNames).toContain('post-checkout');
+    expect(result.action).toBe('remove-owned-only');
+  });
+});