seer-mcp 0.1.0

package/tests/mcp-smoke.ts

@@ -0,0 +1,191 @@
+/**
+ * MCP smoke test: spawn `seer mcp` as a subprocess, drive it over stdio,
+ * and verify each tool call returns sane JSON. The test acts as a minimal
+ * JSON-RPC 2.0 client.
+ *
+ * Run with: npx tsx tests/mcp-smoke.ts
+ */
+
+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-ws-${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 Smoke Test\n=====================\n');
+
+  // Build a tiny workspace from fixtures.
+  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}`);
+
+  // Spawn the MCP server. Disable JIT/watcher for deterministic tests.
+  const proc = spawn(process.execPath, [CLI, 'mcp', '--workspace', TMP_WS, '--no-watch', '--no-jit'], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  proc.stderr.on('data', (d) => process.stderr.write(`[mcp-stderr] ${d}`));
+
+  // Buffer responses and dispatch by id.
+  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;
+      let msg: any;
+      try { msg = JSON.parse(line); } catch { continue; }
+      if (msg.id != null && pending.has(msg.id)) {
+        pending.get(msg.id)!(msg);
+        pending.delete(msg.id);
+      }
+    }
+  });
+
+  let nextId = 1;
+  function call(method: string, params: any): Promise<any> {
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      pending.set(id, resolve);
+      const msg = JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n';
+      proc.stdin.write(msg);
+      setTimeout(() => {
+        if (pending.has(id)) { pending.delete(id); reject(new Error(`timeout: ${method}`)); }
+      }, 30_000);
+    });
+  }
+
+  // Wait for the server to be ready by giving it a moment to spawn its
+  // initial index. We poll initialize until it succeeds.
+  let initOk = false;
+  for (let i = 0; i < 30; i++) {
+    try {
+      const r = await call('initialize', {
+        protocolVersion: '2024-11-05',
+        capabilities: {},
+        clientInfo: { name: 'mcp-smoke', version: '0.1.0' },
+      });
+      if (r.result) { initOk = true; break; }
+    } catch { /* not ready */ }
+    await new Promise(r => setTimeout(r, 500));
+  }
+  if (initOk) ok('initialize handshake'); else bad('initialize handshake (server never responded)');
+
+  // tools/list
+  const list = await call('tools/list', {});
+  const toolNames = (list.result?.tools ?? []).map((t: any) => t.name);
+  const expected = [
+    'seer_health', 'seer_stats', 'seer_symbols', 'seer_definition',
+    'seer_file_symbols', 'seer_callers', 'seer_callees', 'seer_search', 'seer_reindex',
+  ];
+  for (const e of expected) {
+    if (toolNames.includes(e)) ok(`tools/list includes ${e}`);
+    else bad(`tools/list missing ${e}`, toolNames);
+  }
+
+  // seer_health
+  const health = await call('tools/call', { name: 'seer_health', arguments: {} });
+  const healthText = health.result?.content?.[0]?.text;
+  if (!healthText) { bad('seer_health returned no content'); }
+  else {
+    const parsed = JSON.parse(healthText);
+    if (parsed.schemaCurrent === true) ok('seer_health reports current schema');
+    else bad('seer_health schema not current', parsed.schemaVersion);
+    if (parsed.files > 0 && parsed.symbols > 0) ok(`seer_health files=${parsed.files} symbols=${parsed.symbols}`);
+    else bad('seer_health empty index', parsed);
+  }
+
+  // seer_symbols (top)
+  const top = await call('tools/call', { name: 'seer_symbols', arguments: { top: 5 } });
+  const topText = top.result?.content?.[0]?.text;
+  const topParsed = topText ? JSON.parse(topText) : null;
+  if (topParsed && Array.isArray(topParsed.items) && topParsed.items.length > 0) {
+    ok(`seer_symbols(top=5) returned ${topParsed.items.length} items`);
+  } else {
+    bad('seer_symbols(top=5) returned empty', topParsed);
+  }
+
+  // seer_symbols (query)
+  const q = await call('tools/call', { name: 'seer_symbols', arguments: { query: 'AuthService' } });
+  const qParsed = JSON.parse(q.result?.content?.[0]?.text ?? '{}');
+  if (qParsed.items?.some((i: any) => i.name === 'AuthService')) ok('seer_symbols(query=AuthService) found it');
+  else bad('seer_symbols(query=AuthService) did not find it', qParsed);
+
+  // seer_definition (exact)
+  const def = await call('tools/call', { name: 'seer_definition', arguments: { name: 'AuthService' } });
+  const defParsed = JSON.parse(def.result?.content?.[0]?.text ?? '{}');
+  if (defParsed.items?.length >= 1) ok(`seer_definition(AuthService) returned ${defParsed.items.length}`);
+  else bad('seer_definition(AuthService) empty', defParsed);
+
+  // seer_callers
+  const callers = await call('tools/call', { name: 'seer_callers', arguments: { symbol: 'AuthService' } });
+  const callersParsed = JSON.parse(callers.result?.content?.[0]?.text ?? '{}');
+  if (callersParsed.total >= 1) ok(`seer_callers(AuthService) total=${callersParsed.total}`);
+  else bad('seer_callers(AuthService) no callers', callersParsed);
+
+  // seer_callees
+  const callees = await call('tools/call', { name: 'seer_callees', arguments: { symbol: 'process_payment' } });
+  const calleesParsed = JSON.parse(callees.result?.content?.[0]?.text ?? '{}');
+  if (calleesParsed.total >= 1) ok(`seer_callees(process_payment) total=${calleesParsed.total}`);
+  else bad('seer_callees(process_payment) no callees', calleesParsed);
+
+  // seer_file_symbols
+  const fileSyms = await call('tools/call', {
+    name: 'seer_file_symbols',
+    arguments: { file: 'sample.ts' },
+  });
+  const fsParsed = JSON.parse(fileSyms.result?.content?.[0]?.text ?? '{}');
+  if (fsParsed.total >= 1) ok(`seer_file_symbols(sample.ts) total=${fsParsed.total}`);
+  else bad('seer_file_symbols(sample.ts) empty', fsParsed);
+
+  // seer_search
+  const search = await call('tools/call', { name: 'seer_search', arguments: { query: 'auth' } });
+  const sParsed = JSON.parse(search.result?.content?.[0]?.text ?? '{}');
+  if (sParsed.symbolHits?.returned >= 1) ok(`seer_search(auth) symbolHits=${sParsed.symbolHits.returned}`);
+  else bad('seer_search(auth) empty', sParsed);
+
+  // seer_reindex
+  const reindex = await call('tools/call', { name: 'seer_reindex', arguments: {} });
+  const rParsed = JSON.parse(reindex.result?.content?.[0]?.text ?? '{}');
+  if (typeof rParsed.elapsedMs === 'number') ok(`seer_reindex completed in ${rParsed.elapsedMs}ms`);
+  else bad('seer_reindex did not return elapsedMs', rParsed);
+
+  // seer_stats
+  const stats = await call('tools/call', { name: 'seer_stats', arguments: {} });
+  const statsParsed = JSON.parse(stats.result?.content?.[0]?.text ?? '{}');
+  if (statsParsed.files >= 5 && statsParsed.roles) ok(`seer_stats files=${statsParsed.files} role-aware`);
+  else bad('seer_stats missing role breakdown', statsParsed);
+
+  proc.stdin.end();
+  proc.kill();
+  await new Promise(r => setTimeout(r, 200));
+
+  // Cleanup
+  try { fs.rmSync(TMP_WS, { recursive: true, force: true }); } catch { /* */ }
+
+  console.log(`\n══════════════════════════════════════════════════════════════`);
+  console.log(`  MCP results: ${passed} passed, ${failed} failed\n`);
+  if (failed > 0) process.exit(1);
+}
+
+main().catch(err => {
+  console.error('MCP smoke crashed:', err);
+  process.exit(1);
+});

package/tests/mcp-trackcd.ts

@@ -0,0 +1,169 @@
+/**
+ * MCP smoke test for Track-C/D tools. Spawns `seer mcp` against the
+ * fixtures-trackcd workspace and exercises every new tool over stdio.
+ *
+ * Run: npx tsx tests/mcp-trackcd.ts
+ */
+
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+const ROOT = path.resolve(__dirname, '..');
+const FIX = path.join(ROOT, 'tests/fixtures-trackcd');
+const TMP_WS = path.join(os.tmpdir(), `seer-mcp-cd-${Date.now()}`);
+const CLI = path.join(ROOT, 'dist/cli/index.js');
+
+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, 200)}` : '')); };
+
+function copyRecursive(src: string, dst: string): void {
+  fs.mkdirSync(dst, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dst, entry.name);
+    if (entry.isDirectory()) copyRecursive(s, d);
+    else fs.copyFileSync(s, d);
+  }
+}
+
+async function main(): Promise<void> {
+  console.log('\nSeer MCP Track-C/D Smoke\n==========================\n');
+  copyRecursive(FIX, TMP_WS);
+  console.log(`  Workspace: ${TMP_WS}`);
+
+  const proc = spawn(process.execPath, [CLI, 'mcp', '--workspace', TMP_WS, '--no-watch', '--no-jit'],
+    { 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;
+      let msg: any;
+      try { msg = JSON.parse(line); } catch { continue; }
+      if (msg.id != null && pending.has(msg.id)) {
+        pending.get(msg.id)!(msg);
+        pending.delete(msg.id);
+      }
+    }
+  });
+
+  let nextId = 1;
+  const 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
+  let initOk = false;
+  for (let i = 0; i < 30; i++) {
+    try {
+      const r = await call('initialize', {
+        protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 't', version: '0' },
+      });
+      if (r.result) { initOk = true; break; }
+    } catch { /* */ }
+    await new Promise(r => setTimeout(r, 500));
+  }
+  if (initOk) ok('initialize'); else { bad('initialize'); process.exit(1); }
+
+  // tools/list — verify the new tools are advertised
+  const list = await call('tools/list', {});
+  const names: string[] = (list.result?.tools ?? []).map((t: any) => t.name);
+  const newTools = [
+    'seer_routes', 'seer_dependencies', 'seer_config',
+    'seer_complexity', 'seer_behavior', 'seer_trace_path',
+    'seer_architecture', 'seer_detect_changes', 'seer_churn',
+    'seer_history', 'seer_symbol_history_build',
+  ];
+  for (const n of newTools) {
+    if (names.includes(n)) ok(`tools/list advertises ${n}`);
+    else bad(`tools/list missing ${n}`, names);
+  }
+
+  const callTool = async (name: string, args: any = {}): Promise<any> => {
+    const r = await call('tools/call', { name, arguments: args });
+    return JSON.parse(r.result?.content?.[0]?.text ?? '{}');
+  };
+
+  // seer_routes
+  const routes = await callTool('seer_routes', { limit: 100 });
+  if (routes.total >= 10) ok(`seer_routes total=${routes.total}`); else bad('seer_routes empty', routes);
+  if (routes.items?.some((r: any) => r.framework === 'fastapi')) ok('seer_routes includes fastapi'); else bad('no fastapi route', routes);
+
+  // seer_dependencies
+  const deps = await callTool('seer_dependencies', { limit: 100 });
+  if (deps.total >= 8) ok(`seer_dependencies total=${deps.total}`); else bad('seer_dependencies low', deps);
+  if (deps.items?.some((d: any) => d.name === 'express')) ok('seer_dependencies includes express'); else bad('no express dep', deps);
+
+  // seer_config
+  const cfg = await callTool('seer_config', { limit: 100 });
+  if (cfg.total >= 4) ok(`seer_config total=${cfg.total}`); else bad('seer_config low', cfg);
+  if (cfg.items?.some((c: any) => c.key === 'DATABASE_URL')) ok('seer_config has DATABASE_URL'); else bad('no DATABASE_URL', cfg);
+
+  // seer_complexity
+  const cmpx = await callTool('seer_complexity', { by: 'cyclomatic', minValue: 3, limit: 20 });
+  if (cmpx.returned >= 1) ok(`seer_complexity returned=${cmpx.returned}`); else bad('seer_complexity empty', cmpx);
+  if (cmpx.items?.[0]?.cyclomatic >= 3) ok(`seer_complexity sorted desc (top=${cmpx.items[0].cyclomatic})`); else bad('sort wrong', cmpx);
+
+  // seer_behavior — login is exercised by the test
+  const beh = await callTool('seer_behavior', { symbol: 'login' });
+  if (beh.total >= 1) ok(`seer_behavior(login) total=${beh.total}`); else bad('seer_behavior empty', beh);
+
+  // seer_trace_path
+  const trace = await callTool('seer_trace_path', { from: 'login', to: 'validateCredentials' });
+  if (trace.found && trace.depth >= 1) ok(`seer_trace_path login → validateCredentials depth=${trace.depth}`);
+  else bad('seer_trace_path failed', trace);
+
+  // seer_architecture
+  const arch = await callTool('seer_architecture', {});
+  if (arch.totals?.routes >= 10) ok(`seer_architecture routes=${arch.totals.routes}`); else bad('arch routes', arch.totals);
+  if (arch.languages?.length >= 3) ok(`seer_architecture languages=${arch.languages.length}`); else bad('arch langs', arch.languages);
+
+  // seer_symbols with FTS (the new code path)
+  const sym = await callTool('seer_symbols', { query: 'validate', limit: 10 });
+  if (sym.items?.some((s: any) => s.name === 'validateCredentials'))
+    ok('seer_symbols FTS finds validateCredentials by "validate" (camelCase split)');
+  else bad('seer_symbols FTS broken', sym);
+
+  // seer_search
+  const search = await callTool('seer_search', { query: 'auth' });
+  if (search.symbolHits?.returned >= 1) ok(`seer_search(auth) symbolHits=${search.symbolHits.returned}`);
+  else bad('seer_search empty', search);
+
+  // seer_churn — not a git repo, should return zero (cleanly)
+  const ch = await callTool('seer_churn', {});
+  if (typeof ch.elapsedMs === 'number') ok(`seer_churn returned ms=${ch.elapsedMs}`);
+  else bad('seer_churn broken', ch);
+
+  // seer_health — should report routes, externalDeps, configKeys totals now
+  const health = await callTool('seer_health', {});
+  if (health.routes >= 10) ok(`seer_health routes=${health.routes}`); else bad('health routes', health);
+  if (health.externalDependencies >= 8) ok(`seer_health deps=${health.externalDependencies}`); else bad('health deps', health);
+  if (health.configKeys >= 4) ok(`seer_health configKeys=${health.configKeys}`); else bad('health configKeys', health);
+
+  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(`  MCP Track-C/D: ${passed} passed, ${failed} failed`);
+  if (failed > 0) process.exit(1);
+}
+
+main().catch(err => { console.error('mcp-trackcd crashed:', err); process.exit(1); });

package/tests/mcp-tracke.ts

@@ -0,0 +1,229 @@
+/**
+ * MCP smoke test for Track-E tools. Spawns `seer mcp` against the
+ * fixtures-tracke workspace and exercises every new tool over stdio.
+ *
+ * Run: npx tsx tests/mcp-tracke.ts
+ */
+
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+const ROOT = path.resolve(__dirname, '..');
+const FIX = path.join(ROOT, 'tests/fixtures-tracke');
+const TMP_WS = path.join(os.tmpdir(), `seer-mcp-e-${Date.now()}`);
+const CLI = path.join(ROOT, 'dist/cli/index.js');
+
+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, 200)}` : '')); };
+
+function copyRecursive(src: string, dst: string): void {
+  fs.mkdirSync(dst, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dst, entry.name);
+    if (entry.isDirectory()) copyRecursive(s, d);
+    else fs.copyFileSync(s, d);
+  }
+}
+
+async function main(): Promise<void> {
+  console.log('\nSeer MCP Track-E Smoke\n==========================\n');
+  copyRecursive(FIX, TMP_WS);
+  console.log(`  Workspace: ${TMP_WS}`);
+
+  const proc = spawn(process.execPath, [CLI, 'mcp', '--workspace', TMP_WS, '--no-watch', '--no-jit'],
+    { 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;
+      let msg: any;
+      try { msg = JSON.parse(line); } catch { continue; }
+      if (msg.id != null && pending.has(msg.id)) {
+        pending.get(msg.id)!(msg);
+        pending.delete(msg.id);
+      }
+    }
+  });
+
+  let nextId = 1;
+  const 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
+  let initOk = false;
+  for (let i = 0; i < 30; i++) {
+    try {
+      const r = await call('initialize', {
+        protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 't', version: '0' },
+      });
+      if (r.result) { initOk = true; break; }
+    } catch { /* */ }
+    await new Promise(r => setTimeout(r, 500));
+  }
+  if (initOk) ok('initialize'); else { bad('initialize'); process.exit(1); }
+
+  // tools/list — verify Track-E tools are advertised
+  const list = await call('tools/list', {});
+  const names: string[] = (list.result?.tools ?? []).map((t: any) => t.name);
+  const trackeTools = [
+    'seer_modules', 'seer_module_members', 'seer_symbol_module',
+    'seer_module_dependencies', 'seer_modules_build',
+    'seer_trace_file_dependencies', 'seer_trace_module_dependencies',
+    'seer_trace_callers', 'seer_trace_callees',
+    'seer_risk', 'seer_context',
+  ];
+  for (const n of trackeTools) {
+    if (names.includes(n)) ok(`tools/list advertises ${n}`);
+    else bad(`tools/list missing ${n}`, names);
+  }
+
+  const callTool = async (name: string, args: any = {}): Promise<any> => {
+    const r = await call('tools/call', { name, arguments: args });
+    return JSON.parse(r.result?.content?.[0]?.text ?? '{}');
+  };
+
+  // seer_modules
+  const mods = await callTool('seer_modules', { limit: 10 });
+  if (mods.total >= 2) ok(`seer_modules total=${mods.total}`); else bad('seer_modules empty', mods);
+  if (mods.items?.some((m: any) => m.label === 'auth')) ok('seer_modules contains auth'); else bad('no auth module', mods);
+
+  const authModule = mods.items?.find((m: any) => m.label === 'auth');
+  const billingModule = mods.items?.find((m: any) => m.label === 'billing');
+  if (!authModule || !billingModule) { bad('auth/billing modules not found'); process.exit(1); }
+
+  // seer_module_members by id
+  const members = await callTool('seer_module_members', { id: authModule.id });
+  if (members.files?.total >= 2) ok(`seer_module_members(auth) files=${members.files.total}`);
+  else bad('auth module has < 2 files', members);
+  if (members.topSymbols?.items?.some((s: any) => s.name === 'AuthService'))
+    ok('seer_module_members topSymbols includes AuthService');
+  else bad('no AuthService in topSymbols', members.topSymbols);
+
+  // seer_module_members by label
+  const membersByLabel = await callTool('seer_module_members', { label: 'billing' });
+  if (membersByLabel.module?.label === 'billing') ok('seer_module_members works by label');
+  else bad('seer_module_members by label failed', membersByLabel);
+
+  // seer_module_members for missing label
+  const missingMember = await callTool('seer_module_members', { label: '__no_such_module__' });
+  if (missingMember.found === false) ok('seer_module_members returns found=false for unknown label');
+  else bad('seer_module_members did not surface missing label', missingMember);
+
+  // seer_symbol_module
+  const sm = await callTool('seer_symbol_module', { symbol: 'validateCredentials' });
+  if (sm.matches?.some((m: any) => m.module?.label === 'auth'))
+    ok('seer_symbol_module(validateCredentials) → auth');
+  else bad('seer_symbol_module wrong module', sm);
+
+  // seer_module_dependencies — billing → auth
+  const deps = await callTool('seer_module_dependencies', { label: 'billing', direction: 'out' });
+  if (deps.items?.some((d: any) => d.label === 'auth'))
+    ok('seer_module_dependencies(billing, out) includes auth');
+  else bad('billing→auth dep missing', deps);
+
+  // seer_module_dependencies — direction=in
+  const depsIn = await callTool('seer_module_dependencies', { label: 'auth', direction: 'in' });
+  if (depsIn.items?.some((d: any) => d.label === 'billing'))
+    ok('seer_module_dependencies(auth, in) includes billing');
+  else bad('auth←billing dep missing (in)', depsIn);
+
+  // seer_trace_file_dependencies — billing/Billing.ts → auth/AuthService.ts
+  const fdep = await callTool('seer_trace_file_dependencies', { file: 'billing/Billing.ts', maxDepth: 3 });
+  if (fdep.items?.some((c: any) => c.relPath?.includes('auth/AuthService')))
+    ok('seer_trace_file_dependencies reaches auth/AuthService.ts');
+  else bad('file closure missing auth', fdep);
+
+  // seer_trace_module_dependencies — billing → auth
+  const mdep = await callTool('seer_trace_module_dependencies', { label: 'billing', direction: 'out' });
+  if (mdep.items?.some((m: any) => m.label === 'auth'))
+    ok('seer_trace_module_dependencies(billing, out) reaches auth');
+  else bad('module trace missing auth', mdep);
+
+  // seer_trace_callers — validateCredentials has transitive callers
+  const trc = await callTool('seer_trace_callers', { symbol: 'validateCredentials', maxDepth: 4 });
+  if ((trc.total ?? 0) >= 1) ok(`seer_trace_callers total=${trc.total}`);
+  else bad('seer_trace_callers empty', trc);
+
+  // seer_trace_callees — chargeCustomer reaches validateCredentials
+  const trCe = await callTool('seer_trace_callees', { symbol: 'chargeCustomer', maxDepth: 5 });
+  if (trCe.items?.some((i: any) => i.name === 'validateCredentials'))
+    ok('seer_trace_callees(chargeCustomer) reaches validateCredentials');
+  else bad('forward trace did not reach target', trCe);
+
+  // seer_behavior 2.0 — direct + indirect counts
+  const beh = await callTool('seer_behavior', { symbol: 'validateCredentials', limit: 20 });
+  if ((beh.direct ?? 0) >= 1) ok(`seer_behavior direct=${beh.direct}`);
+  else bad('seer_behavior no direct tests', beh);
+  if ((beh.indirect ?? 0) >= 1) ok(`seer_behavior indirect=${beh.indirect}`);
+  else bad('seer_behavior no indirect tests', beh);
+  if (Array.isArray(beh.tests) && beh.tests[0]?.relationship === 'direct-call')
+    ok('seer_behavior ranks direct tests first');
+  else bad('seer_behavior ranking wrong', beh.tests);
+
+  // seer_risk
+  const risk = await callTool('seer_risk', { symbol: 'chargeCustomer' });
+  if (risk.signals?.routeExposed) ok('seer_risk(chargeCustomer) routeExposed=true');
+  else bad('seer_risk routeExposed false', risk.signals);
+  if (Array.isArray(risk.signalContributions) && risk.signalContributions.length >= 10)
+    ok(`seer_risk signalContributions=${risk.signalContributions.length}`);
+  else bad('seer_risk signals incomplete', risk.signalContributions);
+  if (['low', 'medium', 'high'].includes(risk.risk))
+    ok(`seer_risk verdict=${risk.risk}`);
+  else bad('seer_risk verdict invalid', risk);
+
+  // seer_context — must include every Track-E section
+  const ctx = await callTool('seer_context', { symbol: 'validateCredentials' });
+  if (ctx.symbol?.name === 'validateCredentials') ok('seer_context symbol returned');
+  else bad('seer_context missing symbol', ctx);
+  if (ctx.module?.label === 'auth') ok('seer_context.module=auth');
+  else bad('seer_context module wrong', ctx.module);
+  if (ctx.callers?.total >= 1) ok('seer_context.callers.total ≥ 1');
+  else bad('seer_context callers empty', ctx.callers);
+  if (Array.isArray(ctx.behavior?.preview)) ok('seer_context.behavior present');
+  else bad('seer_context behavior missing', ctx.behavior);
+  if (Array.isArray(ctx.risk?.signalContributions)) ok('seer_context.risk.signalContributions present');
+  else bad('seer_context risk missing', ctx.risk);
+  if (Array.isArray(ctx.blastRadius?.topAffected)) ok('seer_context.blastRadius present');
+  else bad('seer_context blastRadius missing', ctx.blastRadius);
+
+  // seer_modules_build — idempotent
+  const rebuild = await callTool('seer_modules_build', {});
+  if (typeof rebuild.modules === 'number' && rebuild.modules === mods.total)
+    ok(`seer_modules_build idempotent (${rebuild.modules} modules)`);
+  else bad('seer_modules_build not idempotent', rebuild);
+
+  // seer_health surfaces modules
+  const health = await callTool('seer_health', {});
+  if ((health.modules ?? 0) >= 2) ok(`seer_health modules=${health.modules}`);
+  else bad('seer_health.modules low', health);
+
+  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(`  MCP Track-E: ${passed} passed, ${failed} failed`);
+  if (failed > 0) process.exit(1);
+}
+
+main().catch(err => { console.error('mcp-tracke crashed:', err); process.exit(1); });