@sdsrs/code-graph 0.94.0 → 0.95.0

package/claude-plugin/scripts/lifecycle.test.js

@@ -1,786 +0,0 @@
-'use strict';
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { execFileSync } = require('child_process');
-
-const lifecyclePath = path.join(__dirname, 'lifecycle.js');
-const statuslinePath = path.join(__dirname, 'statusline.js');
-
-function mkHome(t) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'code-graph-home-'));
-  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
-  return dir;
-}
-
-function writeJson(filePath, value) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n');
-}
-
-function seedDisabledComposite(homeDir) {
-  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
-  const registryPath = path.join(homeDir, '.cache', 'code-graph', 'statusline-registry.json');
-  writeJson(settingsPath, {
-    statusLine: { type: 'command', command: 'node "/plugin/statusline-composite.js"' },
-    enabledPlugins: { 'code-graph-mcp@code-graph-mcp': false },
-  });
-  writeJson(registryPath, [
-    { id: '_previous', command: 'echo previous-status', needsStdin: true },
-    { id: 'code-graph', command: 'node "/plugin/statusline.js"', needsStdin: false },
-  ]);
-  return { settingsPath, registryPath };
-}
-
-function seedOrphanedComposite(homeDir) {
-  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
-  const registryPath = path.join(homeDir, '.cache', 'code-graph', 'statusline-registry.json');
-  const installedPath = path.join(homeDir, '.claude', 'plugins', 'installed_plugins.json');
-  writeJson(settingsPath, {
-    statusLine: { type: 'command', command: 'node "/plugin/statusline-composite.js"' },
-    enabledPlugins: {},
-  });
-  writeJson(installedPath, { plugins: {} });
-  writeJson(registryPath, [
-    { id: '_previous', command: 'echo previous-status', needsStdin: true },
-    { id: 'code-graph', command: 'node "/plugin/statusline.js"', needsStdin: false },
-  ]);
-  return { settingsPath, registryPath };
-}
-
-test('cleanupDisabledStatusline restores previous statusline and removes registry', (t) => {
-  const homeDir = mkHome(t);
-  const { settingsPath, registryPath } = seedDisabledComposite(homeDir);
-
-  const out = execFileSync(process.execPath, ['-e', `
-    const { cleanupDisabledStatusline } = require(${JSON.stringify(lifecyclePath)});
-    process.stdout.write(JSON.stringify(cleanupDisabledStatusline()));
-  `], { env: { ...process.env, HOME: homeDir } }).toString();
-
-  assert.deepEqual(JSON.parse(out), { cleaned: true, settingsChanged: true });
-  const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  assert.equal(settings.statusLine.command, 'echo previous-status');
-  assert.equal(fs.existsSync(registryPath), false);
-});
-
-test('statusline exits cleanly and self-heals when plugin is disabled', (t) => {
-  const homeDir = mkHome(t);
-  const { settingsPath, registryPath } = seedDisabledComposite(homeDir);
-  const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'code-graph-project-'));
-  t.after(() => fs.rmSync(projectDir, { recursive: true, force: true }));
-  fs.mkdirSync(path.join(projectDir, '.code-graph'), { recursive: true });
-  fs.writeFileSync(path.join(projectDir, '.code-graph', 'index.db'), '');
-
-  const stdout = execFileSync(process.execPath, [statuslinePath], {
-    env: { ...process.env, HOME: homeDir },
-    cwd: projectDir,
-  }).toString();
-
-  assert.equal(stdout, '');
-  const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  assert.equal(settings.statusLine.command, 'echo previous-status');
-  assert.equal(fs.existsSync(registryPath), false);
-});
-
-test('cleanupDisabledStatusline also heals orphaned statusline after uninstall', (t) => {
-  const homeDir = mkHome(t);
-  const { settingsPath, registryPath } = seedOrphanedComposite(homeDir);
-
-  const out = execFileSync(process.execPath, ['-e', `
-    const { cleanupDisabledStatusline } = require(${JSON.stringify(lifecyclePath)});
-    process.stdout.write(JSON.stringify(cleanupDisabledStatusline()));
-  `], { env: { ...process.env, HOME: homeDir } }).toString();
-
-  assert.deepEqual(JSON.parse(out), { cleaned: true, settingsChanged: true });
-  const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  assert.equal(settings.statusLine.command, 'echo previous-status');
-  assert.equal(fs.existsSync(registryPath), false);
-});
-
-test('isPluginUninstalled distinguishes a genuine uninstall from a temporary disable', (t) => {
-  // Orphaned composite (installed_plugins exists, no code-graph record) = uninstalled.
-  const uninstalledHome = mkHome(t);
-  seedOrphanedComposite(uninstalledHome);
-  // enabledPlugins[id]=false = user toggled it off; may re-enable → NOT uninstalled.
-  const disabledHome = mkHome(t);
-  seedDisabledComposite(disabledHome);
-
-  const probe = (home) => JSON.parse(execFileSync(process.execPath, ['-e', `
-    const { isPluginUninstalled } = require(${JSON.stringify(lifecyclePath)});
-    process.stdout.write(JSON.stringify(isPluginUninstalled()));
-  `], { env: { ...process.env, HOME: home } }).toString());
-
-  assert.equal(probe(uninstalledHome), true, 'orphaned/no-record → uninstalled');
-  assert.equal(probe(disabledHome), false, 'explicit disable → not uninstalled (re-enable safe)');
-});
-
-test('removeCacheResidue deletes ~/.cache/code-graph and is idempotent', (t) => {
-  const homeDir = mkHome(t);
-  const cacheDir = path.join(homeDir, '.cache', 'code-graph');
-  writeJson(path.join(cacheDir, 'bin', 'marker.json'), { v: 1 });
-  fs.writeFileSync(path.join(cacheDir, 'update-state.json'), '{}');
-
-  const run = () => execFileSync(process.execPath, ['-e', `
-    const { removeCacheResidue } = require(${JSON.stringify(lifecyclePath)});
-    process.stdout.write(JSON.stringify(removeCacheResidue()));
-  `], { env: { ...process.env, HOME: homeDir } }).toString();
-
-  assert.equal(run(), 'true');
-  assert.equal(fs.existsSync(cacheDir), false, 'cache dir removed');
-  assert.equal(run(), 'true', 'second call is a no-op success (idempotent force-rm)');
-});
-
-function legacyHooksFromPlugin() {
-  return {
-    SessionStart: [{
-      matcher: 'startup|clear|compact',
-      description: 'StatusLine self-heal, lifecycle sync, project map injection',
-      hooks: [{ type: 'command', command: 'node "/stale/cache/0.8.2/claude-plugin/scripts/session-init.js"', timeout: 5 }],
-    }],
-    PostToolUse: [{
-      matcher: 'tool == "Write" || tool == "Edit"',
-      description: 'Auto-update code graph index after file edits',
-      hooks: [{ type: 'command', command: 'node "/stale/code-graph/incremental-index.js"', timeout: 10 }],
-    }],
-  };
-}
-
-test('isOurHookEntry matches legacy description-tagged entries', () => {
-  const entry = legacyHooksFromPlugin().SessionStart[0];
-  const out = execFileSync(process.execPath, ['-e', `
-    const { isOurHookEntry } = require(${JSON.stringify(lifecyclePath)});
-    process.stdout.write(JSON.stringify(isOurHookEntry(${JSON.stringify(entry)})));
-  `]).toString();
-  assert.equal(JSON.parse(out), true);
-});
-
-test('isOurHookEntry matches script-name + path fallback (missing description)', () => {
-  const entry = {
-    matcher: 'tool == "Edit"',
-    hooks: [{ type: 'command', command: 'node "/cache/code-graph-mcp/scripts/pre-edit-guide.js"' }],
-  };
-  const out = execFileSync(process.execPath, ['-e', `
-    const { isOurHookEntry } = require(${JSON.stringify(lifecyclePath)});
-    process.stdout.write(JSON.stringify(isOurHookEntry(${JSON.stringify(entry)})));
-  `]).toString();
-  assert.equal(JSON.parse(out), true);
-});
-
-test('isOurHookEntry leaves unrelated entries alone', () => {
-  const entry = {
-    matcher: 'startup',
-    description: 'some other plugin hook',
-    hooks: [{ type: 'command', command: 'node /some/other/script.js' }],
-  };
-  const out = execFileSync(process.execPath, ['-e', `
-    const { isOurHookEntry } = require(${JSON.stringify(lifecyclePath)});
-    process.stdout.write(JSON.stringify(isOurHookEntry(${JSON.stringify(entry)})));
-  `]).toString();
-  assert.equal(JSON.parse(out), false);
-});
-
-test('removeHooksFromSettings strips our entries but keeps unrelated hooks', () => {
-  const settings = {
-    hooks: {
-      SessionStart: [
-        legacyHooksFromPlugin().SessionStart[0],
-        {
-          matcher: 'startup',
-          description: 'some other plugin hook',
-          hooks: [{ type: 'command', command: 'node /some/other/script.js' }],
-        },
-      ],
-      PostToolUse: [legacyHooksFromPlugin().PostToolUse[0]],
-    },
-  };
-
-  const out = execFileSync(process.execPath, ['-e', `
-    const { removeHooksFromSettings } = require(${JSON.stringify(lifecyclePath)});
-    const s = ${JSON.stringify(settings)};
-    const changed = removeHooksFromSettings(s);
-    process.stdout.write(JSON.stringify({ changed, s }));
-  `]).toString();
-
-  const { changed, s } = JSON.parse(out);
-  assert.equal(changed, true);
-  // Only the unrelated SessionStart entry remains; PostToolUse removed entirely.
-  assert.equal(s.hooks.SessionStart.length, 1);
-  assert.equal(s.hooks.SessionStart[0].description, 'some other plugin hook');
-  assert.ok(!s.hooks.PostToolUse, 'empty event key should be deleted');
-});
-
-test('writeRegistry mirrors entries to durable backup outside ~/.cache/', (t) => {
-  const homeDir = mkHome(t);
-  const registryPath = path.join(homeDir, '.cache', 'code-graph', 'statusline-registry.json');
-  const backupPath = path.join(homeDir, '.claude', 'statusline-providers.json');
-
-  execFileSync(process.execPath, ['-e', `
-    const { registerStatuslineProvider } = require(${JSON.stringify(lifecyclePath)});
-    registerStatuslineProvider('_previous', 'echo prev', true);
-    registerStatuslineProvider('code-graph', 'node /cg.js', false);
-  `], { env: { ...process.env, HOME: homeDir } });
-
-  const primary = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
-  const backup = JSON.parse(fs.readFileSync(backupPath, 'utf8'));
-  assert.deepEqual(primary, backup);
-  assert.equal(primary.length, 2);
-});
-
-test('readRegistry self-heals primary from durable backup after cache wipe', (t) => {
-  const homeDir = mkHome(t);
-  const cacheDir = path.join(homeDir, '.cache', 'code-graph');
-  const registryPath = path.join(cacheDir, 'statusline-registry.json');
-  const backupPath = path.join(homeDir, '.claude', 'statusline-providers.json');
-
-  // Seed both files, then simulate user wiping ~/.cache/code-graph/
-  writeJson(registryPath, [
-    { id: '_previous', command: 'echo gsd', needsStdin: true },
-    { id: 'code-graph', command: 'node /cg.js', needsStdin: false },
-  ]);
-  writeJson(backupPath, [
-    { id: '_previous', command: 'echo gsd', needsStdin: true },
-    { id: 'code-graph', command: 'node /cg.js', needsStdin: false },
-  ]);
-  fs.rmSync(cacheDir, { recursive: true, force: true });
-  assert.equal(fs.existsSync(registryPath), false);
-
-  const out = execFileSync(process.execPath, ['-e', `
-    const { readRegistry } = require(${JSON.stringify(lifecyclePath)});
-    process.stdout.write(JSON.stringify(readRegistry()));
-  `], { env: { ...process.env, HOME: homeDir } }).toString();
-
-  const restored = JSON.parse(out);
-  assert.equal(restored.length, 2);
-  assert.equal(restored[0].id, '_previous');
-  // Primary file rebuilt from backup
-  assert.equal(fs.existsSync(registryPath), true);
-});
-
-test('writeRegistry([]) clears both primary and backup', (t) => {
-  const homeDir = mkHome(t);
-  const registryPath = path.join(homeDir, '.cache', 'code-graph', 'statusline-registry.json');
-  const backupPath = path.join(homeDir, '.claude', 'statusline-providers.json');
-
-  execFileSync(process.execPath, ['-e', `
-    const { registerStatuslineProvider, unregisterStatuslineProvider } = require(${JSON.stringify(lifecyclePath)});
-    registerStatuslineProvider('code-graph', 'node /cg.js', false);
-    unregisterStatuslineProvider('code-graph');
-  `], { env: { ...process.env, HOME: homeDir } });
-
-  assert.equal(fs.existsSync(registryPath), false);
-  assert.equal(fs.existsSync(backupPath), false);
-});
-
-test('statusline-chain CLI register/unregister/list + reserved-id guard', (t) => {
-  const homeDir = mkHome(t);
-  const chainPath = path.join(__dirname, 'statusline-chain.js');
-  const env = { ...process.env, HOME: homeDir };
-
-  const reg = execFileSync(process.execPath, [chainPath, 'register', 'gsd', 'node /gsd.cjs', '--stdin'], { env }).toString();
-  assert.match(reg, /registered gsd/);
-
-  const reRun = execFileSync(process.execPath, [chainPath, 'register', 'gsd', 'node /gsd.cjs', '--stdin'], { env }).toString();
-  assert.match(reRun, /unchanged gsd/);
-
-  const list = execFileSync(process.execPath, [chainPath, 'list'], { env }).toString();
-  assert.match(list, /gsd \[stdin\]: node \/gsd\.cjs/);
-
-  // Reserved ids rejected — both should exit 2 with stderr "reserved"
-  const { spawnSync } = require('child_process');
-  for (const rid of ['_previous', 'code-graph']) {
-    const r = spawnSync(process.execPath, [chainPath, 'register', rid, 'x'], { env });
-    assert.equal(r.status, 2, `${rid} should exit 2`);
-    assert.match(r.stderr.toString(), /reserved/);
-  }
-
-  const un = execFileSync(process.execPath, [chainPath, 'unregister', 'gsd'], { env }).toString();
-  assert.match(un, /unregistered gsd/);
-});
-
-// ════════════════════════════════════════════════════════════════════
-// v0.32.0 — settings.json hook registration (replaces the v0.8.3 strip)
-// ════════════════════════════════════════════════════════════════════
-
-test('install() registers PreToolUse/PostToolUse/UserPromptSubmit hooks in settings.json', (t) => {
-  const homeDir = mkHome(t);
-  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
-  writeJson(settingsPath, {
-    statusLine: { type: 'command', command: 'echo previous-status' },
-  });
-
-  execFileSync(process.execPath, [lifecyclePath, 'install'], {
-    env: { ...process.env, HOME: homeDir },
-  });
-
-  const after = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  assert.ok(after.hooks, 'install() must add hooks block');
-  assert.ok(after.hooks.PreToolUse, 'PreToolUse must be registered');
-  assert.ok(after.hooks.PostToolUse, 'PostToolUse must be registered');
-  assert.ok(after.hooks.UserPromptSubmit, 'UserPromptSubmit must be registered');
-
-  // Verify the matchers we promised exist
-  const ptuMatchers = after.hooks.PreToolUse.map(e => e.matcher);
-  for (const m of ['Edit', 'Bash', 'Read']) {
-    assert.ok(ptuMatchers.includes(m), `PreToolUse matcher ${m} missing; got ${JSON.stringify(ptuMatchers)}`);
-  }
-
-  // Every registered entry must carry the description marker for cleanup
-  for (const entries of Object.values(after.hooks)) {
-    for (const e of entries) {
-      if (e.description) {
-        assert.ok(e.description.includes('[code-graph-mcp'),
-          `entry without our marker leaked through: ${JSON.stringify(e.description)}`);
-      }
-    }
-  }
-
-  // statusLine composite still set
-  assert.match(after.statusLine.command, /statusline-composite/);
-});
-
-test('install() strips legacy code-graph hooks AND writes fresh ones (migration path)', (t) => {
-  const homeDir = mkHome(t);
-  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
-  // Seed with v0.8.2-era legacy entries that should be cleaned up
-  writeJson(settingsPath, {
-    hooks: legacyHooksFromPlugin(),
-  });
-
-  execFileSync(process.execPath, [lifecyclePath, 'install'], {
-    env: { ...process.env, HOME: homeDir },
-  });
-
-  const after = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  // Legacy stale paths should be gone — no `/stale/cache/0.8.2/` survivors
-  const serialized = JSON.stringify(after.hooks || {});
-  assert.ok(!serialized.includes('/stale/cache/'),
-    'legacy stale paths must be evicted: ' + serialized);
-  // BUT fresh entries (v0.32.0 markers) should be present
-  assert.ok(serialized.includes('[code-graph-mcp v0.32+]'),
-    'fresh v0.32+ entries should be installed');
-});
-
-test('install() is idempotent on settings.json (second call no-op)', (t) => {
-  const homeDir = mkHome(t);
-  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
-
-  execFileSync(process.execPath, [lifecyclePath, 'install'], {
-    env: { ...process.env, HOME: homeDir },
-  });
-  const first = fs.readFileSync(settingsPath, 'utf8');
-
-  execFileSync(process.execPath, [lifecyclePath, 'install'], {
-    env: { ...process.env, HOME: homeDir },
-  });
-  const second = fs.readFileSync(settingsPath, 'utf8');
-
-  assert.equal(first, second, 'second install() must produce byte-identical settings.json');
-});
-
-test('install() preserves foreign plugin hooks (other plugins\' entries survive)', (t) => {
-  const homeDir = mkHome(t);
-  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
-  // Seed with an unrelated plugin's hooks alongside ours
-  writeJson(settingsPath, {
-    hooks: {
-      PreToolUse: [{
-        matcher: 'Bash',
-        description: 'some-other-plugin Bash inspector',
-        hooks: [{ type: 'command', command: 'node /opt/other-plugin/bash-check.js', timeout: 3 }],
-      }],
-      PostToolUse: [{
-        matcher: '*',
-        description: 'foreign post-tool logger',
-        hooks: [{ type: 'command', command: 'bash /opt/foreign/post.sh', timeout: 5 }],
-      }],
-    },
-  });
-
-  execFileSync(process.execPath, [lifecyclePath, 'install'], {
-    env: { ...process.env, HOME: homeDir },
-  });
-
-  const after = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  // Foreign entries must still be there
-  const ptu = after.hooks.PreToolUse;
-  const otherBash = ptu.find(e => e.description === 'some-other-plugin Bash inspector');
-  assert.ok(otherBash, 'foreign Bash hook was stripped — never strip non-code-graph entries');
-
-  const ptoFor = after.hooks.PostToolUse.find(e => e.description === 'foreign post-tool logger');
-  assert.ok(ptoFor, 'foreign PostToolUse hook was stripped');
-
-  // Ours are also there
-  assert.ok(after.hooks.PreToolUse.some(e => e.matcher === 'Edit' && e.description?.includes('[code-graph-mcp')));
-});
-
-test('registerHooksToSettings is idempotent when called directly', () => {
-  // Pure-function direct call, no process spawn
-  const { registerHooksToSettings } = require('./lifecycle.js');
-  const settings = {};
-  const changed1 = registerHooksToSettings(settings);
-  const snapshot1 = JSON.stringify(settings);
-  const changed2 = registerHooksToSettings(settings);
-  const snapshot2 = JSON.stringify(settings);
-  assert.equal(changed1, true, 'first call must report change');
-  assert.equal(changed2, false, 'second call must report no-change (idempotent)');
-  assert.equal(snapshot1, snapshot2, 'settings must be byte-identical after second call');
-});
-
-test('removeHooksFromSettings cleans up v0.32+ entries (uninstall path)', () => {
-  const { registerHooksToSettings, removeHooksFromSettings } = require('./lifecycle.js');
-  const settings = {};
-  registerHooksToSettings(settings);
-  // Sanity: have entries
-  assert.ok(settings.hooks.PreToolUse && settings.hooks.PreToolUse.length > 0);
-
-  const changed = removeHooksFromSettings(settings);
-  assert.equal(changed, true);
-  assert.ok(!settings.hooks || Object.keys(settings.hooks).length === 0,
-    'all our entries must be removed; got: ' + JSON.stringify(settings.hooks));
-});
-
-test('uninstall() removes settings.json hook entries end-to-end', (t) => {
-  const homeDir = mkHome(t);
-  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
-
-  execFileSync(process.execPath, [lifecyclePath, 'install'], {
-    env: { ...process.env, HOME: homeDir },
-  });
-  const afterInstall = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  assert.ok(afterInstall.hooks?.PreToolUse, 'install must have created hooks');
-
-  execFileSync(process.execPath, [lifecyclePath, 'uninstall'], {
-    env: { ...process.env, HOME: homeDir },
-  });
-  const afterUninstall = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  // Our hooks should be gone (foreign ones would survive but we didn't seed any)
-  const serialized = JSON.stringify(afterUninstall.hooks || {});
-  assert.ok(!serialized.includes('[code-graph-mcp'),
-    'uninstall must strip all our entries; got: ' + serialized);
-});
-
-test('hook commands use absolute paths (no ${CLAUDE_PLUGIN_ROOT} in settings.json)', (t) => {
-  // settings.json hook commands run with env-pollution risk per
-  // feedback_plugin_env_isolation.md — they must NOT depend on
-  // ${CLAUDE_PLUGIN_ROOT} (different plugins overwrite each other's value).
-  const homeDir = mkHome(t);
-  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
-
-  execFileSync(process.execPath, [lifecyclePath, 'install'], {
-    env: { ...process.env, HOME: homeDir },
-  });
-  const after = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  const serialized = JSON.stringify(after.hooks || {});
-  assert.ok(!serialized.includes('${CLAUDE_PLUGIN_ROOT}'),
-    'settings.json hook commands must not reference ${CLAUDE_PLUGIN_ROOT}: ' + serialized);
-});
-
-// ════════════════════════════════════════════════════════════════════
-// v0.32.2 — update() upgrade-path integration tests (reviewer Rec #2)
-// ════════════════════════════════════════════════════════════════════
-// Covers the actual v0.31.x → v0.32.x migration path that runs in
-// production via session-init.js syncLifecycleConfig detecting a manifest
-// version mismatch and calling update(). Previously only install() was
-// tested end-to-end; the upgrade path shared the registerHooksToSettings
-// code internally but had no integration test exercising the wiring.
-
-test('update() from v0.31.x manifest registers fresh hooks in empty settings.json', (t) => {
-  const homeDir = mkHome(t);
-  const manifestPath = path.join(homeDir, '.cache', 'code-graph', 'install-manifest.json');
-  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
-
-  // Seed v0.31.2 manifest state. updatedAt is the v0.31.2 release date.
-  writeJson(manifestPath, {
-    version: '0.31.2',
-    installedAt: '2026-03-16T18:56:17.656Z',
-    updatedAt: '2026-05-23T16:46:39.353Z',
-    config: { statusLine: false },
-  });
-  // settings.json empty (mirrors real v0.31.x state — pre-v0.32.0 strategy
-  // was "strip from settings.json, rely on plugin-cache hooks.json").
-  writeJson(settingsPath, {});
-
-  const out = execFileSync(process.execPath, [lifecyclePath, 'update'], {
-    env: { ...process.env, HOME: homeDir },
-  }).toString();
-  assert.match(out, /Updated 0\.31\.2 → /, 'CLI output must show version transition');
-
-  // Manifest version was bumped to current
-  const manifestAfter = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-  assert.notEqual(manifestAfter.version, '0.31.2', 'manifest version must advance');
-  assert.ok(/^\d+\.\d+\.\d+$/.test(manifestAfter.version),
-    `manifest version must be semver, got ${manifestAfter.version}`);
-
-  // settings.json got the v0.32+ hook entries
-  const settingsAfter = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  assert.ok(settingsAfter.hooks, 'update() must populate hooks block');
-  assert.ok(settingsAfter.hooks.PreToolUse, 'PreToolUse must be registered');
-  assert.ok(settingsAfter.hooks.PostToolUse, 'PostToolUse must be registered');
-  assert.ok(settingsAfter.hooks.UserPromptSubmit, 'UserPromptSubmit must be registered');
-
-  // Every entry must carry the v0.32+ marker
-  for (const entries of Object.values(settingsAfter.hooks)) {
-    for (const e of entries) {
-      assert.ok(e.description && e.description.includes('[code-graph-mcp v0.32+'),
-        `update() entry without v0.32+ marker: ${JSON.stringify(e.description)}`);
-    }
-  }
-});
-
-test('update() from v0.31.x evicts legacy v0.7/v0.8 entries with stale paths', (t) => {
-  const homeDir = mkHome(t);
-  const manifestPath = path.join(homeDir, '.cache', 'code-graph', 'install-manifest.json');
-  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
-
-  writeJson(manifestPath, {
-    version: '0.31.2',
-    installedAt: '2026-03-16T18:56:17.656Z',
-    config: { statusLine: false },
-  });
-  // Seed with legacy v0.8.2-era entries that should be evicted on update.
-  writeJson(settingsPath, {
-    hooks: legacyHooksFromPlugin(),
-  });
-
-  execFileSync(process.execPath, [lifecyclePath, 'update'], {
-    env: { ...process.env, HOME: homeDir },
-  });
-
-  const settingsAfter = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  const serialized = JSON.stringify(settingsAfter.hooks || {});
-  // Stale paths must be gone
-  assert.ok(!serialized.includes('/stale/cache/'),
-    'legacy stale paths must be evicted by update(): ' + serialized);
-  // Fresh v0.32+ entries must be present
-  assert.ok(serialized.includes('[code-graph-mcp v0.32+'),
-    'fresh v0.32+ entries must be installed by update()');
-});
-
-test('update() preserves foreign plugin hooks during upgrade', (t) => {
-  const homeDir = mkHome(t);
-  const manifestPath = path.join(homeDir, '.cache', 'code-graph', 'install-manifest.json');
-  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
-
-  writeJson(manifestPath, {
-    version: '0.31.2',
-    config: { statusLine: false },
-  });
-  // Seed with an unrelated plugin's hooks — must survive our update().
-  writeJson(settingsPath, {
-    hooks: {
-      PreToolUse: [{
-        matcher: 'Bash',
-        description: 'foreign-plugin Bash watcher',
-        hooks: [{ type: 'command', command: 'node /opt/foreign/bash.js', timeout: 3 }],
-      }],
-    },
-  });
-
-  execFileSync(process.execPath, [lifecyclePath, 'update'], {
-    env: { ...process.env, HOME: homeDir },
-  });
-
-  const settingsAfter = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  const ptu = settingsAfter.hooks.PreToolUse;
-  assert.ok(ptu.some(e => e.description === 'foreign-plugin Bash watcher'),
-    'foreign Bash hook must survive update() — never strip non-code-graph entries');
-  // And our own entries must coexist
-  assert.ok(ptu.some(e => e.description && e.description.includes('[code-graph-mcp v0.32+')),
-    'update() must add our v0.32+ entries alongside the foreign one');
-});
-
-// ════════════════════════════════════════════════════════════════════
-// v0.32.2 — healthCheck post-repair re-verification
-// (Reviewer M3: repaired:true was set blindly after install() without
-//  re-scanning to confirm the issues actually resolved.)
-// ════════════════════════════════════════════════════════════════════
-
-function runHealthCheckInChild(homeDir) {
-  const code = `
-    const lc = require(${JSON.stringify(lifecyclePath)});
-    process.stdout.write(JSON.stringify(lc.healthCheck()));
-  `;
-  const out = execFileSync(process.execPath, ['-e', code], {
-    env: { ...process.env, HOME: homeDir },
-    encoding: 'utf8',
-  });
-  return JSON.parse(out);
-}
-
-test('healthCheck on a clean state returns healthy:true and never sets remaining', (t) => {
-  const homeDir = mkHome(t);
-  // No settings.json, no registry — clean slate.
-  const r = runHealthCheckInChild(homeDir);
-  assert.equal(r.healthy, true, 'fresh empty state must be healthy');
-  assert.deepEqual(r.issues, [], 'no issues on empty state');
-  assert.equal(r.repaired, false, 'no repair runs when nothing was broken');
-  assert.equal(r.remaining, undefined, 'no remaining field when no repair attempted');
-});
-
-test('healthCheck repaired:true ONLY after post-repair re-scan returns clean', (t) => {
-  const homeDir = mkHome(t);
-  // Seed a hook entry whose path is broken AND carries our marker. install()
-  // will overwrite our entries with fresh absolute paths derived from
-  // __dirname (which is real in the test env), so the re-scan should be clean.
-  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
-  writeJson(settingsPath, {
-    hooks: {
-      PreToolUse: [{
-        matcher: 'Edit',
-        description: '[code-graph-mcp v0.32+] PreToolUse re-routed via settings.json (cache hooks.json silently ignored for this event by current CC)',
-        hooks: [{ type: 'command', command: 'node "/nonexistent/code-graph-mcp/pre-edit-guide.js"' }],
-      }],
-    },
-  });
-
-  const r = runHealthCheckInChild(homeDir);
-  assert.equal(r.healthy, false, 'pre-repair scan must have flagged the broken path');
-  assert.ok(r.issues.length >= 1, 'pre-repair issues must list the broken hook');
-  assert.equal(r.repaired, true, 'install() rewrote our entry → post-scan clean → repaired:true');
-  assert.deepEqual(r.remaining, [], 'remaining must be empty when repair succeeded');
-});
-
-test('healthCheck repaired:false when install() cannot resolve a flagged path', (t) => {
-  const homeDir = mkHome(t);
-  // Seed the registry with a non-`_previous` third-party provider whose path
-  // is broken. install() only manages the 'code-graph' registry entry, so
-  // the third-party entry survives untouched and the post-repair re-scan
-  // still flags it. This is the canonical "auto-repair could not fix it"
-  // path — previously the function lied and returned repaired:true anyway.
-  const registryPath = path.join(homeDir, '.cache', 'code-graph', 'statusline-registry.json');
-  writeJson(registryPath, [
-    { id: 'third-party-statusline', command: 'node "/nonexistent/foreign/sl.js"', needsStdin: false },
-  ]);
-
-  const r = runHealthCheckInChild(homeDir);
-  assert.equal(r.healthy, false, 'broken third-party path must be flagged on entry');
-  assert.ok(r.issues.some(i => i.type === 'registry' && i.id === 'third-party-statusline'),
-    'pre-repair issue list must contain the third-party entry');
-  assert.equal(r.repaired, false,
-    'install() does not touch third-party providers → re-scan still broken → repaired must be false');
-  assert.ok(Array.isArray(r.remaining), 'remaining must be present when install() was attempted');
-  assert.ok(r.remaining.some(i => i.id === 'third-party-statusline'),
-    'remaining must still contain the un-fixable third-party entry');
-});
-
-test('scanForBrokenPaths is exported and returns the issue structure', (t) => {
-  // Direct unit test of the extracted scanner — no install() side effects.
-  // Verifies the contract M3 relies on: a pure function whose return
-  // shape is what healthCheck composes its result from.
-  const homeDir = mkHome(t);
-  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
-  writeJson(settingsPath, {
-    hooks: {
-      PreToolUse: [{
-        matcher: 'Edit',
-        description: '[code-graph-mcp v0.32+] PreToolUse re-routed via settings.json (cache hooks.json silently ignored for this event by current CC)',
-        hooks: [{ type: 'command', command: 'node "/nonexistent/code-graph-mcp/pre-edit-guide.js"' }],
-      }],
-    },
-  });
-
-  const code = `
-    const lc = require(${JSON.stringify(lifecyclePath)});
-    process.stdout.write(JSON.stringify(lc.scanForBrokenPaths()));
-  `;
-  const out = execFileSync(process.execPath, ['-e', code], {
-    env: { ...process.env, HOME: homeDir },
-    encoding: 'utf8',
-  });
-  const issues = JSON.parse(out);
-  assert.ok(Array.isArray(issues));
-  assert.ok(issues.some(i => i.type === 'hook' && i.event === 'PreToolUse' && i.path.includes('/nonexistent/')),
-    'scanForBrokenPaths must report the seeded broken hook entry');
-});
-// ── isStaleRelicContext (v0.49.1 downgrade-war guard) ──────────────────────
-
-test('isStaleRelicContext: relic in plugins cache defers to a different active install', (t) => {
-  const { isStaleRelicContext } = require('./lifecycle');
-  const cacheRoot = '/home/u/.claude/plugins/cache';
-  const relicRoot = `${cacheRoot}/code-graph-mcp/code-graph-mcp/0.48.0`;
-  const activeRoot = `${cacheRoot}/code-graph-mcp/code-graph-mcp/0.49.0`;
-
-  // The downgrade-war case: running from old cache dir, active points elsewhere.
-  assert.equal(isStaleRelicContext({
-    pluginRoot: relicRoot, cacheRoot, activePath: activeRoot,
-    existsSync: () => true,
-  }), true);
-
-  // Running FROM the active install → full self-heal rights.
-  assert.equal(isStaleRelicContext({
-    pluginRoot: activeRoot, cacheRoot, activePath: activeRoot,
-    existsSync: () => true,
-  }), false);
-
-  // Dev checkout / npm install (pluginRoot outside the plugins cache) → exempt.
-  assert.equal(isStaleRelicContext({
-    pluginRoot: '/repo/code-graph-mcp/claude-plugin', cacheRoot, activePath: activeRoot,
-    existsSync: () => true,
-  }), false);
-
-  // No installed_plugins record → exempt (nothing authoritative to defer to).
-  assert.equal(isStaleRelicContext({
-    pluginRoot: relicRoot, cacheRoot, activePath: null,
-    existsSync: () => true,
-  }), false);
-
-  // Active path recorded but its lifecycle.js is gone (cache wiped) → the
-  // relic is the only working copy left; keep self-heal rights.
-  assert.equal(isStaleRelicContext({
-    pluginRoot: relicRoot, cacheRoot, activePath: activeRoot,
-    existsSync: () => false,
-  }), false);
-});
-
-test('cleanupOldCacheVersions keeps an in-use version even beyond the keep window', (t) => {
-  const { cleanupOldCacheVersions } = require('./lifecycle.js');
-  const cacheParent = fs.mkdtempSync(path.join(os.tmpdir(), 'code-graph-cache-'));
-  t.after(() => fs.rmSync(cacheParent, { recursive: true, force: true }));
-  const pluginDir = path.join(cacheParent, 'code-graph-mcp');
-  // Seven versions, oldest -> newest by mtime.
-  const vers = ['0.78.0', '0.80.2', '0.80.3', '0.81.0', '0.81.1', '0.81.2', '0.81.3'];
-  vers.forEach((v, i) => {
-    const scripts = path.join(pluginDir, v, 'scripts');
-    fs.mkdirSync(scripts, { recursive: true });
-    fs.writeFileSync(path.join(scripts, 'mcp-launcher.js'), '// stub');
-    const ts = (i + 1) * 3600; // distinct, increasing mtimes
-    fs.utimesSync(path.join(pluginDir, v), ts, ts);
-  });
-  // A live MCP server is running from the OLDEST version (beyond keep=5) — this
-  // is the v0.80.2 reconnect-(-32000) scenario.
-  const inUse = path.join(pluginDir, '0.78.0');
-  const fakeCmdlines = [`node ${path.join(inUse, 'scripts', 'mcp-launcher.js')} `];
-
-  cleanupOldCacheVersions(5, () => fakeCmdlines, cacheParent);
-
-  assert.equal(fs.existsSync(inUse), true,
-    'in-use version must survive prune even when it is the oldest');
-  assert.equal(fs.existsSync(path.join(pluginDir, '0.80.2')), false,
-    'a non-in-use version beyond the keep window is still pruned');
-  assert.equal(fs.existsSync(path.join(pluginDir, '0.81.3')), true,
-    'newest version (within keep window) is kept');
-});
-
-test('cleanupOldCacheVersions prunes beyond keep when nothing is in use', (t) => {
-  const { cleanupOldCacheVersions } = require('./lifecycle.js');
-  const cacheParent = fs.mkdtempSync(path.join(os.tmpdir(), 'code-graph-cache-'));
-  t.after(() => fs.rmSync(cacheParent, { recursive: true, force: true }));
-  const pluginDir = path.join(cacheParent, 'code-graph-mcp');
-  const vers = ['0.78.0', '0.80.2', '0.80.3', '0.81.0', '0.81.1', '0.81.2', '0.81.3'];
-  vers.forEach((v, i) => {
-    fs.mkdirSync(path.join(pluginDir, v), { recursive: true });
-    const ts = (i + 1) * 3600;
-    fs.utimesSync(path.join(pluginDir, v), ts, ts);
-  });
-  // No live process references any version → recency-only pruning (pre-guard).
-  cleanupOldCacheVersions(5, () => [], cacheParent);
-
-  assert.equal(fs.existsSync(path.join(pluginDir, '0.78.0')), false, 'oldest pruned');
-  assert.equal(fs.existsSync(path.join(pluginDir, '0.80.2')), false, '2nd-oldest pruned');
-  assert.equal(fs.existsSync(path.join(pluginDir, '0.80.3')), true, 'within keep window kept');
-  assert.equal(
-    fs.readdirSync(pluginDir).filter(n => fs.statSync(path.join(pluginDir, n)).isDirectory()).length,
-    5, 'exactly keep=5 versions remain');
-});