seer-mcp 0.1.0

package/tests/git-features.ts

@@ -0,0 +1,267 @@
+/**
+ * Git-dependent features: file churn, symbol history, detect_changes, PR/URL
+ * mining. We build a tiny git repo on the fly in a temp dir and assert that
+ * each pass correctly captures the history we just committed.
+ *
+ * Run with: npx tsx tests/git-features.ts
+ */
+
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { spawnSync } from 'child_process';
+import { Indexer } from '../src/indexer/index';
+import { Store } from '../src/db/store';
+import { collectChurn } from '../src/indexer/churn';
+import { buildSymbolHistory } from '../src/indexer/symbolhistory';
+import { detectChanges } from '../src/indexer/detectchanges';
+import { extractPrNumber, githubPrUrl } from '../src/indexer/git';
+
+const TMP = path.join(os.tmpdir(), `seer-git-${Date.now()}`);
+const REPO = path.join(TMP, 'repo');
+const DB = path.join(TMP, 'graph.db');
+
+let passed = 0;
+let failed = 0;
+
+function assert(cond: boolean, msg: string): void {
+  if (cond) { console.log(`  ✓ ${msg}`); passed++; }
+  else { console.error(`  ✗ ${msg}`); failed++; }
+}
+
+function git(...args: string[]): { stdout: string; status: number } {
+  const r = spawnSync('git', ['-C', REPO, ...args], { encoding: 'utf8' });
+  return { stdout: r.stdout ?? '', status: r.status ?? 1 };
+}
+
+function commit(message: string, author = 'Alice <alice@example.com>'): string {
+  git('add', '.');
+  const r = spawnSync(
+    'git',
+    ['-C', REPO, '-c', `user.email=${author.replace(/^.* <(.+)>$/, '$1')}`,
+            '-c', `user.name=${author.replace(/ <.+>$/, '')}`,
+            'commit', '-m', message, '--no-gpg-sign'],
+    { encoding: 'utf8' },
+  );
+  if (r.status !== 0) throw new Error(`git commit failed: ${r.stderr}`);
+  const sha = git('rev-parse', 'HEAD').stdout.trim();
+  return sha;
+}
+
+function write(rel: string, content: string): void {
+  const full = path.join(REPO, rel);
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  fs.writeFileSync(full, content, 'utf8');
+}
+
+async function run(): Promise<void> {
+  console.log('\nSeer Git-Features Tests');
+  console.log('=========================\n');
+
+  // Setup
+  fs.mkdirSync(REPO, { recursive: true });
+  const initRes = spawnSync('git', ['-C', REPO, 'init', '-q', '-b', 'main'], { encoding: 'utf8' });
+  if (initRes.status !== 0) {
+    // try without -b on older git
+    spawnSync('git', ['-C', REPO, 'init', '-q'], { encoding: 'utf8' });
+  }
+  git('config', 'commit.gpgsign', 'false');
+
+  // Configure a fake GitHub remote so PR URL mining can run.
+  git('remote', 'add', 'origin', 'git@github.com:example/myrepo.git');
+
+  // Commit 1: initial files
+  write('app.ts', `
+export function login(user: string, password: string): boolean {
+  return user === password;
+}
+
+export function logout(token: string): void {
+  // noop
+}
+
+export function helper(x: number): number {
+  return x * 2;
+}
+`.trimStart());
+  write('README.md', '# Demo\n');
+  const sha1 = commit('Initial commit', 'Alice <alice@example.com>');
+
+  // Commit 2: extend login
+  write('app.ts', `
+export function login(user: string, password: string): boolean {
+  if (!user || !password) return false;
+  return user === password;
+}
+
+export function logout(token: string): void {
+  // noop
+}
+
+export function helper(x: number): number {
+  return x * 2;
+}
+`.trimStart());
+  const sha2 = commit('Add empty-credentials guard to login (#42)', 'Bob <bob@example.com>');
+
+  // Commit 3: add new file
+  write('utils.ts', `
+export function formatUser(u: string): string { return u.toUpperCase(); }
+`.trimStart());
+  const sha3 = commit('Merge pull request #99 from feature/utils\n\nAdd utils module', 'Alice <alice@example.com>');
+
+  // Commit 4: tweak helper
+  write('app.ts', `
+export function login(user: string, password: string): boolean {
+  if (!user || !password) return false;
+  return user === password;
+}
+
+export function logout(token: string): void {
+  // noop
+}
+
+export function helper(x: number): number {
+  return x * 4;
+}
+`.trimStart());
+  const sha4 = commit('Tweak helper multiplier', 'Bob <bob@example.com>');
+
+  console.log(`  4 commits made: ${sha1.slice(0,8)} … ${sha4.slice(0,8)}\n`);
+
+  // Index it
+  const store = new Store(DB);
+  const indexer = new Indexer(store);
+  const r = await indexer.indexDirectory(REPO, { quiet: true });
+  console.log(`  Indexed: files=${r.filesIndexed} symbols=${r.symbols} edges=${r.edges}\n`);
+
+  // ── File churn ────────────────────────────────────────────────────────────
+  console.log('── File churn ──');
+  const ch = await collectChurn(REPO, store);
+  console.log(`  ${ch.filesWithChurn}/${ch.filesAnalyzed} files have history, HEAD ${ch.headSha?.slice(0,8)}`);
+  assert(ch.headSha === sha4, `churn.headSha matches HEAD (${ch.headSha?.slice(0,8)})`);
+  assert(ch.filesWithChurn >= 2, `churn covers ≥2 files (app.ts and utils.ts)`);
+
+  const appChurn = store.getFileChurn(path.join(REPO, 'app.ts'));
+  console.log(`  app.ts: commits=${appChurn?.commitCount}, top=${appChurn?.topAuthor}, second=${appChurn?.secondAuthor}`);
+  assert(appChurn !== null, 'getFileChurn(app.ts) returns a row');
+  assert(appChurn!.commitCount === 3, `app.ts touched in 3 commits (got ${appChurn!.commitCount})`);
+  // Bob did 2 commits to app.ts (sha2 + sha4), Alice did 1 (sha1)
+  assert(appChurn!.topAuthor === 'Bob', `app.ts top author = Bob (got ${appChurn!.topAuthor})`);
+  assert(appChurn!.secondAuthor === 'Alice', `app.ts second author = Alice (got ${appChurn!.secondAuthor})`);
+  assert(appChurn!.lastCommitSha === sha4, `app.ts last commit = sha4 (got ${appChurn!.lastCommitSha?.slice(0,8)})`);
+  assert(appChurn!.lastCommitAt !== null && appChurn!.lastCommitAt > 0, 'last commit timestamp populated');
+
+  const utilsChurn = store.getFileChurn(path.join(REPO, 'utils.ts'));
+  assert(utilsChurn !== null && utilsChurn.commitCount === 1, `utils.ts: 1 commit`);
+
+  // top churned files
+  const topChurn = store.topChurnedFiles(10);
+  assert(topChurn[0].filePath.endsWith('app.ts'), `topChurnedFiles: app.ts first (most edited)`);
+
+  // ── Git index state ──────────────────────────────────────────────────────
+  console.log('\n── git_index_state ──');
+  const state = store.getGitIndexState();
+  assert(state !== null, 'git_index_state row populated');
+  assert(state!.lastHeadSha === sha4, `git_index_state.last_head_sha = HEAD`);
+  assert(state!.remoteUrl !== null, `git_index_state.remote_url captured`);
+
+  // ── PR mining ────────────────────────────────────────────────────────────
+  console.log('\n── PR / URL mining ──');
+  assert(extractPrNumber('Add foo (#42)') === 42, 'extractPrNumber inline (#42)');
+  assert(extractPrNumber('Merge pull request #99 from foo') === 99, 'extractPrNumber merge form');
+  assert(extractPrNumber('  #123 fix') === 123, 'extractPrNumber leading');
+  assert(extractPrNumber('no number here') === null, 'extractPrNumber empty');
+  assert(githubPrUrl('git@github.com:foo/bar.git', 7) === 'https://github.com/foo/bar/pull/7',
+    'githubPrUrl SSH form');
+  assert(githubPrUrl('https://github.com/foo/bar.git', 7) === 'https://github.com/foo/bar/pull/7',
+    'githubPrUrl HTTPS form');
+  assert(githubPrUrl('https://gitlab.com/foo/bar.git', 7) === null, 'githubPrUrl rejects non-github');
+  assert(githubPrUrl(null, 7) === null, 'githubPrUrl null remote');
+
+  // ── Symbol history (Track D) ─────────────────────────────────────────────
+  console.log('\n── Symbol history ──');
+  const sh = await buildSymbolHistory(REPO, store, { skipIfHeadUnchanged: false, log: () => {} });
+  console.log(`  inserts=${sh.historyRowsInserted}, files=${sh.filesProcessed}, symbols=${sh.symbolsProcessed}`);
+  assert(sh.historyRowsInserted >= 4, `symbol history: ≥4 rows`);
+  assert(sh.filesProcessed >= 1, `symbol history: ≥1 file processed`);
+
+  // login was modified in sha2 — verify
+  const loginDef = store.getDefinition('login')[0];
+  assert(loginDef !== undefined, 'login defined');
+  const loginHistory = store.getSymbolHistory(loginDef.id, { limit: 10 });
+  console.log(`  login history: ${loginHistory.length} commits`);
+  for (const h of loginHistory) {
+    console.log(`    ${h.commitSha.slice(0,8)}  ${h.authorName ?? '?'}  pr=${h.prNumber}  ${(h.message ?? '').split('\n')[0].slice(0,40)}`);
+  }
+  assert(loginHistory.length >= 2, `login history: ≥2 commits (got ${loginHistory.length})`);
+  assert(loginHistory.some(h => h.commitSha === sha1), `login history includes sha1`);
+  assert(loginHistory.some(h => h.commitSha === sha2 && h.prNumber === 42),
+    `login history sha2 includes PR #42`);
+  assert(loginHistory.some(h => h.prUrl === 'https://github.com/example/myrepo/pull/42'),
+    `login history includes GitHub PR URL`);
+
+  // helper was modified in sha1 (added) and sha4 (multiplier change)
+  const helperDef = store.getDefinition('helper')[0];
+  const helperHistory = store.getSymbolHistory(helperDef.id);
+  console.log(`  helper history: ${helperHistory.length} commits`);
+  assert(helperHistory.some(h => h.commitSha === sha4), `helper history includes sha4`);
+
+  // logout was NOT modified after sha1 (only sha1 in its history)
+  const logoutDef = store.getDefinition('logout')[0];
+  const logoutHistory = store.getSymbolHistory(logoutDef.id);
+  console.log(`  logout history: ${logoutHistory.length} commits`);
+  assert(logoutHistory.length === 1 && logoutHistory[0].commitSha === sha1,
+    `logout history is exactly sha1 (got ${logoutHistory.length})`);
+
+  // count
+  const loginCount = store.countSymbolHistory(loginDef.id);
+  assert(loginCount === loginHistory.length, 'countSymbolHistory matches getSymbolHistory');
+
+  // skipIfHeadUnchanged: second run with no commits should be a no-op
+  const sh2 = await buildSymbolHistory(REPO, store, { skipIfHeadUnchanged: true, log: () => {} });
+  assert(sh2.skipped === true, 'second buildSymbolHistory skips because HEAD unchanged');
+
+  // ── detect_changes ────────────────────────────────────────────────────────
+  console.log('\n── detect_changes ──');
+  // Make an uncommitted edit to app.ts (modify logout body)
+  write('app.ts', `
+export function login(user: string, password: string): boolean {
+  if (!user || !password) return false;
+  return user === password;
+}
+
+export function logout(token: string): void {
+  console.log("logging out " + token);
+}
+
+export function helper(x: number): number {
+  return x * 4;
+}
+`.trimStart());
+
+  const dc = detectChanges(REPO, store, { callerDepth: 2 });
+  console.log(`  changedFiles=${dc.changedFiles.length} directly=${dc.directlyChanged.length} transitively=${dc.transitivelyAffected.length}`);
+  for (const f of dc.changedFiles) {
+    console.log(`    ${path.basename(f.path)}: hunks=${f.hunks}, symbols=${f.symbols.map(s => s.symbol.name).join(',')}`);
+  }
+  assert(dc.changedFiles.length === 1, 'detect_changes finds 1 modified file');
+  assert(dc.directlyChanged.some(s => s.name === 'logout'), 'detect_changes flags logout as directly-changed');
+  assert(!dc.directlyChanged.some(s => s.name === 'helper'), 'detect_changes does NOT flag helper');
+
+  // detect_changes between two refs
+  const dcRange = detectChanges(REPO, store, { fromRef: sha1, toRef: sha2, callerDepth: 2 });
+  // sha1 → sha2 touched login only
+  assert(dcRange.directlyChanged.some(s => s.name === 'login'), 'between-refs detect_changes flags login');
+
+  // ── Cleanup ───────────────────────────────────────────────────────────────
+  store.close();
+  try { fs.rmSync(TMP, { recursive: true, force: true }); } catch { /* */ }
+
+  console.log(`\n══════════════════════════════════════════════════════════════`);
+  console.log(`  Results: ${passed} passed, ${failed} failed`);
+  if (failed > 0) { console.error('\n  GIT-FEATURES TEST FAILED\n'); process.exit(1); }
+  else            { console.log('\n  All git-features tests passed! ✓\n'); }
+}
+
+run().catch(err => { console.error('git-features crashed:', err); process.exit(1); });

package/tests/init.ts

@@ -0,0 +1,141 @@
+/**
+ * Tests for `seer init` — the cross-agent MCP installer.
+ *
+ * These exercise only the project-local clients (claude, cursor, vscode,
+ * codex, gemini), which write inside a throwaway workspace. We never touch the
+ * user-level clients (antigravity) here, so the test cannot scribble on a real
+ * home config.
+ *
+ * Run: npx tsx tests/init.ts
+ */
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { runInit, ClientId } from '../src/cli/init';
+
+let passed = 0;
+let failed = 0;
+const ok = (m: string): void => { passed++; console.log(`  ✓ ${m}`); };
+const bad = (m: string, x?: unknown): void => {
+  failed++;
+  console.error(`  ✗ ${m}` + (x !== undefined ? `  ::  ${JSON.stringify(x).slice(0, 240)}` : ''));
+};
+const check = (c: boolean, m: string, x?: unknown): void => { c ? ok(m) : bad(m, x); };
+
+const PROJECT_CLIENTS: ClientId[] = ['claude', 'cursor', 'vscode', 'codex', 'gemini'];
+
+function freshWs(tag: string): string {
+  const ws = path.join(os.tmpdir(), `seer-init-${tag}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  fs.mkdirSync(ws, { recursive: true });
+  return ws;
+}
+
+function main(): void {
+  console.log('\nSeer Init Tests\n===============\n');
+
+  // ── 1. Fresh write across all project-local clients ───────────────────────
+  {
+    const ws = freshWs('fresh');
+    const r = runInit({ workspace: ws, clients: PROJECT_CLIENTS });
+
+    check(r.launch.command === 'node', '1.launcher uses node by default', r.launch);
+    check(r.launch.args.includes('mcp') && r.launch.args.includes('--workspace'),
+      '1.launcher carries "mcp --workspace"', r.launch.args);
+
+    const mcp = JSON.parse(fs.readFileSync(path.join(ws, '.mcp.json'), 'utf8'));
+    check(!!mcp.mcpServers?.seer, '1.claude .mcp.json has mcpServers.seer');
+    check(mcp.mcpServers.seer.command === 'node', '1.claude entry command is node');
+
+    const cursor = JSON.parse(fs.readFileSync(path.join(ws, '.cursor', 'mcp.json'), 'utf8'));
+    check(!!cursor.mcpServers?.seer, '1.cursor .cursor/mcp.json has mcpServers.seer');
+
+    const vscode = JSON.parse(fs.readFileSync(path.join(ws, '.vscode', 'mcp.json'), 'utf8'));
+    check(!!vscode.servers?.seer, '1.vscode uses the "servers" root key');
+    check(vscode.servers.seer.type === 'stdio', '1.vscode entry carries type:stdio');
+
+    const gemini = JSON.parse(fs.readFileSync(path.join(ws, '.gemini', 'settings.json'), 'utf8'));
+    check(!!gemini.mcpServers?.seer, '1.gemini .gemini/settings.json has mcpServers.seer');
+
+    const toml = fs.readFileSync(path.join(ws, '.codex', 'config.toml'), 'utf8');
+    check(/\[mcp_servers\.seer\]/.test(toml), '1.codex config.toml has [mcp_servers.seer]');
+    check(/command = "node"/.test(toml), '1.codex block has command = "node"');
+
+    const agents = fs.readFileSync(path.join(ws, 'AGENTS.md'), 'utf8');
+    check(agents.includes('<!-- seer:begin -->') && agents.includes('<!-- seer:end -->'),
+      '1.AGENTS.md written with seer markers');
+    check(agents.includes('seer_preflight'), '1.AGENTS.md mentions seer_preflight workflow');
+
+    fs.rmSync(ws, { recursive: true, force: true });
+  }
+
+  // ── 2. Idempotency: a second run skips, --force updates ────────────────────
+  {
+    const ws = freshWs('idem');
+    runInit({ workspace: ws, clients: PROJECT_CLIENTS });
+    const r2 = runInit({ workspace: ws, clients: PROJECT_CLIENTS });
+    check(r2.entries.every((e) => e.action === 'skipped'), '2.re-run skips every client', r2.entries.map((e) => e.action));
+    check(r2.agents?.action === 'skipped', '2.re-run skips AGENTS.md');
+
+    const r3 = runInit({ workspace: ws, clients: PROJECT_CLIENTS, force: true });
+    check(r3.entries.every((e) => e.action === 'updated'), '3.--force updates every client', r3.entries.map((e) => e.action));
+
+    fs.rmSync(ws, { recursive: true, force: true });
+  }
+
+  // ── 3. Merge: existing config keeps its other servers ─────────────────────
+  {
+    const ws = freshWs('merge');
+    fs.writeFileSync(path.join(ws, '.mcp.json'),
+      JSON.stringify({ mcpServers: { other: { command: 'foo', args: ['bar'] } } }, null, 2));
+    fs.mkdirSync(path.join(ws, '.codex'), { recursive: true });
+    fs.writeFileSync(path.join(ws, '.codex', 'config.toml'),
+      '[model]\nname = "gpt-5.5"\n\n[mcp_servers.other]\ncommand = "foo"\nargs = []\n');
+
+    runInit({ workspace: ws, clients: ['claude', 'codex'] });
+
+    const mcp = JSON.parse(fs.readFileSync(path.join(ws, '.mcp.json'), 'utf8'));
+    check(!!mcp.mcpServers.other && !!mcp.mcpServers.seer, '4.json merge keeps existing "other" server + adds seer', mcp.mcpServers);
+
+    const toml = fs.readFileSync(path.join(ws, '.codex', 'config.toml'), 'utf8');
+    check(/\[model\]/.test(toml) && /\[mcp_servers\.other\]/.test(toml) && /\[mcp_servers\.seer\]/.test(toml),
+      '4.toml append keeps [model] + [mcp_servers.other] + adds seer');
+
+    fs.rmSync(ws, { recursive: true, force: true });
+  }
+
+  // ── 4. --npx launcher is portable (no machine paths, no --workspace) ───────
+  {
+    const ws = freshWs('npx');
+    const r = runInit({ workspace: ws, clients: ['claude'], npx: true, pkg: 'seer-core' });
+    check(r.launch.command === 'npx', '5.--npx launcher command is npx', r.launch);
+    check(r.launch.args.join(' ') === '-y seer-core mcp', '5.--npx args are "-y seer-core mcp"', r.launch.args);
+    const mcp = JSON.parse(fs.readFileSync(path.join(ws, '.mcp.json'), 'utf8'));
+    check(JSON.stringify(mcp).indexOf(ws) === -1, '5.--npx config carries no absolute workspace path');
+    fs.rmSync(ws, { recursive: true, force: true });
+  }
+
+  // ── 5. --print writes nothing ──────────────────────────────────────────────
+  {
+    const ws = freshWs('print');
+    const r = runInit({ workspace: ws, clients: PROJECT_CLIENTS, print: true });
+    check(!fs.existsSync(path.join(ws, '.mcp.json')), '6.--print does not write .mcp.json');
+    check(!fs.existsSync(path.join(ws, 'AGENTS.md')), '6.--print does not write AGENTS.md');
+    check(r.entries.length === PROJECT_CLIENTS.length, '6.--print still returns a full plan');
+    check(r.entries.every((e) => !!e.snippet), '6.--print plan carries snippets to preview');
+    fs.rmSync(ws, { recursive: true, force: true });
+  }
+
+  // ── 6. --no-agents skips the guide ─────────────────────────────────────────
+  {
+    const ws = freshWs('noagents');
+    const r = runInit({ workspace: ws, clients: ['claude'], agents: false });
+    check(r.agents === undefined, '7.--no-agents returns no agents plan');
+    check(!fs.existsSync(path.join(ws, 'AGENTS.md')), '7.--no-agents writes no AGENTS.md');
+    fs.rmSync(ws, { recursive: true, force: true });
+  }
+
+  console.log(`\n${failed === 0 ? 'PASS' : 'FAIL'}  ${passed} passed, ${failed} failed\n`);
+  if (failed > 0) process.exit(1);
+}
+
+main();

package/tests/mcp-jit.ts

@@ -0,0 +1,130 @@
+/**
+ * JIT-freshness MCP integration test.
+ *
+ * Procedure:
+ *   1. Start `seer mcp --workspace <tmp>` with watcher off and JIT on.
+ *   2. Verify a symbol from sample.ts is queryable (post initial index).
+ *   3. Append a new function to sample.ts on disk (no calls in/out).
+ *   4. Issue another query and verify JIT picked up the new symbol.
+ *   5. Delete a fixture file, issue another query, verify it's gone.
+ *
+ * This catches regressions where the JIT pass either fails to reindex
+ * (returning stale results) or kicks off a full reindex on every call
+ * (which would still be correct but should be measurable as slow).
+ */
+
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+const ROOT = path.resolve(__dirname, '..');
+const FIXTURES = path.join(ROOT, 'tests/fixtures');
+const TMP_WS = path.join(os.tmpdir(), `seer-mcp-jit-${Date.now()}`);
+const CLI = path.join(ROOT, 'dist/cli/index.js');
+
+let passed = 0;
+let failed = 0;
+function ok(label: string): void { passed++; console.log(`  ✓ ${label}`); }
+function bad(label: string, extra?: unknown): void {
+  failed++;
+  console.error(`  ✗ ${label}` + (extra !== undefined ? ` :: ${JSON.stringify(extra)}` : ''));
+}
+
+async function main(): Promise<void> {
+  console.log('\nSeer MCP JIT Freshness Test\n=============================\n');
+
+  fs.mkdirSync(TMP_WS, { recursive: true });
+  for (const f of fs.readdirSync(FIXTURES)) {
+    fs.copyFileSync(path.join(FIXTURES, f), path.join(TMP_WS, f));
+  }
+  console.log(`  Workspace: ${TMP_WS}\n`);
+
+  const proc = spawn(process.execPath, [CLI, 'mcp', '--workspace', TMP_WS, '--no-watch'], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  proc.stderr.on('data', (d) => process.stderr.write(`[mcp-stderr] ${d}`));
+
+  let buf = '';
+  const pending = new Map<number, (msg: any) => void>();
+  proc.stdout.on('data', (chunk: Buffer) => {
+    buf += chunk.toString('utf8');
+    let nl: number;
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      try {
+        const msg = JSON.parse(line);
+        if (msg.id != null && pending.has(msg.id)) {
+          pending.get(msg.id)!(msg);
+          pending.delete(msg.id);
+        }
+      } catch { /* skip */ }
+    }
+  });
+
+  let nextId = 1;
+  function call(method: string, params: any): Promise<any> {
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      pending.set(id, resolve);
+      proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+      setTimeout(() => {
+        if (pending.has(id)) { pending.delete(id); reject(new Error(`timeout: ${method}`)); }
+      }, 30_000);
+    });
+  }
+
+  // Wait for ready
+  for (let i = 0; i < 30; i++) {
+    try {
+      const r = await call('initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'jit-smoke', version: '0.1.0' } });
+      if (r.result) break;
+    } catch { /* */ }
+    await new Promise(r => setTimeout(r, 500));
+  }
+  ok('server initialized');
+
+  // Baseline: AuthService should exist
+  const before = JSON.parse((await call('tools/call', { name: 'seer_symbols', arguments: { query: 'AuthService' } })).result.content[0].text);
+  if (before.items.some((i: any) => i.name === 'AuthService')) ok('baseline: AuthService visible');
+  else bad('baseline: AuthService missing');
+
+  // ── Edit sample.ts: add a new function ──
+  const samplePath = path.join(TMP_WS, 'sample.ts');
+  const original = fs.readFileSync(samplePath, 'utf8');
+  const newFn = `\n\nexport function jitInjectedFunction(): string {\n  return "added by JIT test";\n}\n`;
+  fs.writeFileSync(samplePath, original + newFn);
+  // Give the OS a moment to flush; chokidar isn't running here so it doesn't matter, but the
+  // hash check needs the on-disk content to differ.
+  await new Promise(r => setTimeout(r, 100));
+
+  const after = JSON.parse((await call('tools/call', { name: 'seer_symbols', arguments: { query: 'jitInjectedFunction' } })).result.content[0].text);
+  if (after.items.some((i: any) => i.name === 'jitInjectedFunction')) ok('JIT picked up new function after file edit');
+  else bad('JIT did not pick up new function', after);
+
+  // ── Remove a fixture file and verify it disappears ──
+  const goPath = path.join(TMP_WS, 'sample.go');
+  if (fs.existsSync(goPath)) fs.unlinkSync(goPath);
+  await new Promise(r => setTimeout(r, 100));
+
+  const stats = JSON.parse((await call('tools/call', { name: 'seer_stats', arguments: {} })).result.content[0].text);
+  if (!('go' in stats.languages)) ok('JIT pruned removed sample.go (go language gone from stats)');
+  else bad('JIT did not prune sample.go', stats.languages);
+
+  proc.stdin.end();
+  proc.kill();
+  await new Promise(r => setTimeout(r, 200));
+
+  try { fs.rmSync(TMP_WS, { recursive: true, force: true }); } catch { /* */ }
+
+  console.log(`\n══════════════════════════════════════════════════════════════`);
+  console.log(`  JIT results: ${passed} passed, ${failed} failed\n`);
+  if (failed > 0) process.exit(1);
+}
+
+main().catch(err => {
+  console.error('JIT smoke crashed:', err);
+  process.exit(1);
+});