@sdsrs/code-graph 0.84.0 → 0.85.0

package/claude-plugin/.claude-plugin/plugin.json

@@ -4,7 +4,7 @@
   "author": {
     "name": "sdsrs"
   },
-  "version": "0.84.0",
+  "version": "0.85.0",
   "keywords": [
     "code-graph",
     "ast",

package/claude-plugin/scripts/mcp-launcher.js

@@ -11,6 +11,7 @@ const { spawn, spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 const { isNonProjectCwd } = require('./project-detect');
+const { serveEmptyMcpStub } = require('./mcp-stub');
 
 // Set plugin root so find-binary.js can locate bundled/dev binaries
 // Always derive from __dirname — CLAUDE_PLUGIN_ROOT can leak from other plugins
@@ -38,46 +39,8 @@ function projectHasLocalCodeGraphMcp(cwd) {
   } catch { return false; }
 }
 
-function serveEmptyMcpStub() {
-  let buf = '';
-  process.stdin.setEncoding('utf8');
-  process.stdin.on('data', (chunk) => {
-    buf += chunk;
-    let nl;
-    while ((nl = buf.indexOf('\n')) >= 0) {
-      const line = buf.slice(0, nl).trim();
-      buf = buf.slice(nl + 1);
-      if (!line) continue;
-      let req;
-      try { req = JSON.parse(line); } catch { continue; }
-      if (!req || typeof req.method !== 'string') continue;
-      // JSON-RPC notifications (id missing) get no response.
-      if (typeof req.id === 'undefined') continue;
-      const method = req.method;
-      let result, error;
-      if (method === 'initialize') {
-        result = {
-          protocolVersion: '2024-11-05',
-          capabilities: { tools: { listChanged: false } },
-          serverInfo: { name: 'code-graph-mcp (plugin stub, dedup)', version: '0.31.1' },
-        };
-      } else if (method === 'tools/list') {
-        result = { tools: [] };
-      } else if (method === 'resources/list') {
-        result = { resources: [] };
-      } else if (method === 'prompts/list') {
-        result = { prompts: [] };
-      } else {
-        error = { code: -32601, message: 'method not found (plugin MCP is in dedup stub mode)' };
-      }
-      const resp = error
-        ? { jsonrpc: '2.0', id: req.id, error }
-        : { jsonrpc: '2.0', id: req.id, result };
-      process.stdout.write(JSON.stringify(resp) + '\n');
-    }
-  });
-  process.stdin.on('end', () => process.exit(0));
-}
+// serveEmptyMcpStub lives in ./mcp-stub.js — a permanent 0-tool stub by default,
+// or an in-place upgrading stub when passed { upgrade } (see the non-project gate).
 
 if (process.env.CODE_GRAPH_FORCE_PLUGIN_MCP !== '1' && projectHasLocalCodeGraphMcp(process.cwd())) {
   process.stderr.write(
@@ -98,10 +61,27 @@ if (process.env.CODE_GRAPH_FORCE_PLUGIN_MCP !== '1' && projectHasLocalCodeGraphM
 // CODE_GRAPH_FORCE_PLUGIN_MCP=1 override as the dedup gate above.
 if (process.env.CODE_GRAPH_FORCE_PLUGIN_MCP !== '1' && isNonProjectCwd(process.cwd())) {
   process.stderr.write(
-    '[code-graph] non-project cwd (no .git/manifest); plugin MCP serving 0 tools, ' +
-    'no index created. Set CODE_GRAPH_FORCE_PLUGIN_MCP=1 to override.\n'
+    '[code-graph] non-project cwd (no .git/manifest); plugin MCP serving 0 tools ' +
+    '(auto-upgrades to real tools if this dir becomes a project — no restart). ' +
+    'Set CODE_GRAPH_FORCE_PLUGIN_MCP=1 to override.\n'
   );
-  serveEmptyMcpStub();
+  // Upgradeable stub: the non-project verdict is re-checked on a poll. If the
+  // cwd becomes a real project (git init / scaffold) with no local code-graph
+  // server, spawn the real binary and hand the live MCP connection over to it —
+  // fixes the "stub latched at launch" gap without a Claude Code restart.
+  serveEmptyMcpStub({
+    upgrade: {
+      shouldUpgrade: () =>
+        !isNonProjectCwd(process.cwd()) && !projectHasLocalCodeGraphMcp(process.cwd()),
+      spawnReal: () => {
+        const { findBinary } = require('./find-binary');
+        const bin = findBinary();
+        if (!bin) return null;
+        process.stderr.write(`[code-graph] cwd became a project — upgrading plugin MCP to real tools via ${bin} (restart Claude Code for full tool steering)\n`);
+        return spawn(bin, ['serve'], { stdio: ['pipe', 'pipe', 'inherit'], env: process.env });
+      },
+    },
+  });
   return;
 }
 

package/claude-plugin/scripts/mcp-stub.js

@@ -0,0 +1,214 @@
+'use strict';
+/**
+ * Minimal MCP server used by mcp-launcher.js when the plugin should NOT run the
+ * real binary — either the project already registers its own code-graph server
+ * (dedup) or the cwd is not a project (e.g. /tmp headless calls).
+ *
+ * Two modes:
+ *   serveEmptyMcpStub()               permanent 0-tool stub (dedup / genuine /tmp)
+ *   serveEmptyMcpStub({ upgrade })    0-tool stub that UPGRADES in place
+ *
+ * The upgrade path closes the "stub latch" gap: the non-project gate is
+ * evaluated once at launcher start, so a directory that becomes a project
+ * mid-session (bare dir → `git init` + scaffold) would otherwise stay toolless
+ * until a full Claude Code restart. With { upgrade } the stub advertises
+ * `tools.listChanged:true`, polls `shouldUpgrade()`, and when the cwd becomes a
+ * project spawns the real binary, proxies JSON-RPC to it, and emits
+ * `notifications/tools/list_changed` so the client re-fetches the (now real)
+ * tool list — no restart. Genuinely non-project /tmp callers never satisfy
+ * shouldUpgrade(), so they stay cheap (never spawn the binary).
+ *
+ * Known limitation: the child's ENTIRE `initialize` result is swallowed (the
+ * client keeps the stub's) — not just the code-graph `instructions` block but
+ * all negotiated server capabilities and the protocolVersion. For a tools-only
+ * server that's fine; tools work immediately, but the instructions steering and
+ * any non-tool capability only appear after a normal restart. Acceptable: tools
+ * are the point, and MCP has no post-init way to re-deliver `instructions`.
+ *
+ * Deps (input / output / spawn timing / exit) are injectable so the proxy
+ * handoff is unit-testable without spawning a real server.
+ */
+
+const DEFAULT_POLL_MS = 4000;
+// Bound the retry loop: a persistently unresolvable/broken binary would
+// otherwise re-spawn every pollMs for the whole session (~60s at the default).
+const MAX_UPGRADE_FAILURES = 15;
+// Distinct from any id Claude Code uses (it increments from 1) so the child's
+// reply to our replayed initialize is unambiguous to swallow.
+const SENTINEL_ID = 2147483646;
+
+function serveEmptyMcpStub(opts = {}) {
+  const input = opts.input || process.stdin;
+  const output = opts.output || process.stdout;
+  const upgrade = opts.upgrade || null;
+  const setIv = opts.setInterval || setInterval;
+  const clearIv = opts.clearInterval || clearInterval;
+  const exit = opts.exit || ((code) => process.exit(code));
+  const canUpgrade = !!upgrade;
+
+  let savedInitialize = null;   // client's initialize request, replayed to the child
+  let child = null;             // real binary, once upgraded
+  let childReady = false;       // child finished its (replayed) handshake
+  const queuedForChild = [];    // client lines seen after spawn, before child is ready
+  let poller = null;
+  let upgradeFailures = 0;      // consecutive failed upgrade attempts (see noteUpgradeFailure)
+
+  function writeCc(obj) { output.write(JSON.stringify(obj) + '\n'); }
+
+  function stubInitializeResult() {
+    if (canUpgrade) {
+      // Only tools.listChanged is load-bearing (it lets the client honor our
+      // later notifications/tools/list_changed). Deliberately NOT advertising
+      // resources/prompts here so a genuine /tmp caller that never upgrades
+      // stays as cheap as the permanent stub (no extra resources/prompts probes).
+      return {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: { listChanged: true } },
+        serverInfo: { name: 'code-graph-mcp (plugin stub, upgrading)', version: '0.31.1' },
+      };
+    }
+    return {
+      protocolVersion: '2024-11-05',
+      capabilities: { tools: { listChanged: false } },
+      serverInfo: { name: 'code-graph-mcp (plugin stub, dedup)', version: '0.31.1' },
+    };
+  }
+
+  function answerAsStub(req) {
+    if (typeof req.id === 'undefined') return; // JSON-RPC notification → no response
+    const m = req.method;
+    let result, error;
+    if (m === 'initialize') result = stubInitializeResult();
+    else if (m === 'tools/list') result = { tools: [] };
+    else if (m === 'resources/list') result = { resources: [] };
+    else if (m === 'prompts/list') result = { prompts: [] };
+    else error = {
+      code: -32601,
+      message: canUpgrade
+        ? 'method not found (plugin MCP stub; upgrades when cwd becomes a project)'
+        : 'method not found (plugin MCP is in dedup stub mode)',
+    };
+    writeCc(error ? { jsonrpc: '2.0', id: req.id, error } : { jsonrpc: '2.0', id: req.id, result });
+  }
+
+  // ---- client → stub (or → child once proxying) ----
+  let buf = '';
+  input.setEncoding('utf8');
+  input.on('data', (chunk) => {
+    buf += chunk;
+    let nl;
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      if (child) {                                   // proxy mode
+        if (childReady) {
+          try { child.stdin.write(line + '\n'); }
+          catch { /* child stream gone; 'error'/'exit' handler cleans up */ }
+        } else {
+          queuedForChild.push(line);
+        }
+        continue;
+      }
+      let req;
+      try { req = JSON.parse(line); } catch { continue; }
+      if (!req || typeof req.method !== 'string') continue;
+      if (req.method === 'initialize') savedInitialize = req;
+      answerAsStub(req);
+    }
+  });
+  input.on('end', () => {
+    if (child) { try { child.stdin.end(); } catch { /* ok */ } }
+    else exit(0);
+  });
+
+  // ---- upgrade: poll, then hand the live connection to the real binary ----
+  function noteUpgradeFailure(reason) {
+    // After the cap, stop polling and surface a one-time actionable hint instead
+    // of re-spawning a doomed binary forever.
+    if (++upgradeFailures < MAX_UPGRADE_FAILURES) return;
+    if (poller) { clearIv(poller); poller = null; }
+    process.stderr.write(`[code-graph] plugin MCP could not upgrade after ${upgradeFailures} attempts (${reason}); restart Claude Code once this project is set up. Staying in 0-tool stub.\n`);
+  }
+
+  function attemptUpgrade() {
+    if (child || !upgrade) return;
+    if (!upgrade.shouldUpgrade()) return;            // not a project yet — not a failure
+    const spawned = upgrade.spawnReal();
+    if (!spawned) { noteUpgradeFailure('binary-unresolved'); return; }
+    if (poller) { clearIv(poller); poller = null; }
+    child = spawned;
+    beginProxy();
+  }
+
+  function fallBackToStub(reason) {
+    // Child spawned but died/errored before it was ready: answer anything the
+    // client queued (so it doesn't hang on those ids), resume polling, and count
+    // the failure toward the retry cap.
+    process.stderr.write(`[code-graph] plugin MCP upgrade aborted (${reason}); staying in 0-tool stub, will retry\n`);
+    const requeued = queuedForChild.splice(0);
+    child = null;
+    childReady = false;
+    for (const line of requeued) {
+      try { const req = JSON.parse(line); if (req && typeof req.method === 'string') answerAsStub(req); }
+      catch { /* ignore */ }
+    }
+    if (upgrade && !poller) poller = setIv(attemptUpgrade, upgrade.pollMs || DEFAULT_POLL_MS);
+    noteUpgradeFailure(reason);
+  }
+
+  function beginProxy() {
+    const thisChild = child;   // guard against terminal events from a superseded spawn
+    thisChild.stdin.on('error', () => { /* EPIPE if the child died — 'error'/'exit' handle it */ });
+    thisChild.stdout.on('error', () => {});
+
+    const params = (savedInitialize && savedInitialize.params) || {
+      protocolVersion: '2024-11-05', capabilities: {},
+      clientInfo: { name: 'code-graph-plugin-launcher', version: '0' },
+    };
+    // Replay initialize under a sentinel id; the child's reply is swallowed
+    // (the client already received OUR initialize result).
+    thisChild.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: SENTINEL_ID, method: 'initialize', params }) + '\n');
+
+    let cbuf = '';
+    thisChild.stdout.setEncoding('utf8');
+    thisChild.stdout.on('data', (chunk) => {
+      cbuf += chunk;
+      let nl;
+      while ((nl = cbuf.indexOf('\n')) >= 0) {
+        const line = cbuf.slice(0, nl);
+        cbuf = cbuf.slice(nl + 1);
+        if (!line.trim()) continue;
+        let msg = null;
+        try { msg = JSON.parse(line); } catch { /* forward non-JSON verbatim */ }
+        if (msg && msg.id === SENTINEL_ID) {
+          // Child handshake complete: finish MCP init, flush queued client
+          // requests, and tell the client its tool list changed.
+          thisChild.stdin.write(JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }) + '\n');
+          childReady = true;
+          for (const l of queuedForChild.splice(0)) thisChild.stdin.write(l + '\n');
+          writeCc({ jsonrpc: '2.0', method: 'notifications/tools/list_changed' });
+          continue;                                  // swallow the sentinel reply
+        }
+        output.write(line + '\n');                   // forward child → client verbatim
+      }
+    });
+    thisChild.on('error', () => {
+      if (child !== thisChild) return;               // superseded spawn — ignore
+      if (childReady) { exit(1); return; }           // a ready child broke → die like the binary died (avoid a flapping stub)
+      fallBackToStub('spawn-error');
+    });
+    thisChild.on('exit', (code, signal) => {
+      if (child !== thisChild) return;
+      if (!childReady) { fallBackToStub('early-exit'); return; }
+      if (signal) process.kill(process.pid, signal);
+      else exit(code == null ? 1 : code);
+    });
+  }
+
+  if (upgrade) poller = setIv(attemptUpgrade, upgrade.pollMs || DEFAULT_POLL_MS);
+
+  return { attemptUpgrade, _state: () => ({ hasChild: !!child, childReady }) };
+}
+
+module.exports = { serveEmptyMcpStub, SENTINEL_ID, DEFAULT_POLL_MS, MAX_UPGRADE_FAILURES };

package/claude-plugin/scripts/mcp-stub.test.js

@@ -0,0 +1,207 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { PassThrough } = require('stream');
+const { EventEmitter } = require('events');
+const { serveEmptyMcpStub, SENTINEL_ID } = require('./mcp-stub');
+
+const tick = () => new Promise((r) => setImmediate(r));
+
+// A fake child_process: collect what the launcher writes to child.stdin, and
+// let the test push child.stdout lines + emit exit/error.
+function makeFakeChild() {
+  const stdin = new PassThrough();
+  const stdout = new PassThrough();
+  const ee = new EventEmitter();
+  const linesToChild = [];
+  let sbuf = '';
+  stdin.setEncoding('utf8');
+  stdin.on('data', (c) => {
+    sbuf += c;
+    let nl;
+    while ((nl = sbuf.indexOf('\n')) >= 0) { linesToChild.push(sbuf.slice(0, nl)); sbuf = sbuf.slice(nl + 1); }
+  });
+  return {
+    stdin, stdout,
+    on: (e, cb) => ee.on(e, cb),
+    emit: (e, ...a) => ee.emit(e, ...a),
+    linesToChild,
+  };
+}
+
+function makeRig(upgrade) {
+  const input = new PassThrough();
+  const out = [];
+  const output = { write: (s) => { out.push(s); return true; } };
+  let exitCode = null;
+  const handle = serveEmptyMcpStub({
+    input, output,
+    setInterval: () => 0, clearInterval: () => {},   // no real timer; drive attemptUpgrade() manually
+    exit: (c) => { exitCode = c; },
+    upgrade,
+  });
+  const send = (obj) => input.write(JSON.stringify(obj) + '\n');
+  return { input, out, handle, send, getExit: () => exitCode };
+}
+
+const INIT = { jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'cc', version: '1' } } };
+
+test('permanent stub: 0 tools, listChanged:false, unknown method → -32601', async () => {
+  const { out, send } = makeRig(null);
+  send(INIT);
+  send({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
+  send({ jsonrpc: '2.0', id: 3, method: 'nope/nope', params: {} });
+  await tick();
+  const initResp = JSON.parse(out[0]);
+  assert.equal(initResp.result.capabilities.tools.listChanged, false);
+  assert.match(initResp.result.serverInfo.name, /dedup/);
+  assert.deepEqual(JSON.parse(out[1]).result.tools, []);
+  assert.equal(JSON.parse(out[2]).error.code, -32601);
+});
+
+test('upgradeable stub advertises tools.listChanged:true', async () => {
+  const { out, send } = makeRig({ shouldUpgrade: () => false, spawnReal: () => null });
+  send(INIT);
+  await tick();
+  assert.equal(JSON.parse(out[0]).result.capabilities.tools.listChanged, true);
+});
+
+test('upgradeable stub does NOT spawn while shouldUpgrade() is false', async () => {
+  let spawnCalls = 0;
+  const { handle } = makeRig({ shouldUpgrade: () => false, spawnReal: () => { spawnCalls++; return null; } });
+  handle.attemptUpgrade();
+  await tick();
+  assert.equal(spawnCalls, 0);
+  assert.equal(handle._state().hasChild, false);
+});
+
+test('upgrade handoff: proxies to real binary + emits tools/list_changed + forwards real tools', async () => {
+  const child = makeFakeChild();
+  let allow = false;
+  const { out, send, handle } = makeRig({ shouldUpgrade: () => allow, spawnReal: () => child });
+
+  // 1. client initialize + tools/list while still a non-project stub
+  send(INIT);
+  send({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
+  await tick();
+  assert.equal(JSON.parse(out[0]).result.capabilities.tools.listChanged, true);
+  assert.deepEqual(JSON.parse(out[1]).result.tools, []);          // stub → empty
+  const outLenBeforeUpgrade = out.length;
+
+  // 2. cwd becomes a project → upgrade fires
+  allow = true;
+  handle.attemptUpgrade();
+  await tick();
+  assert.equal(handle._state().hasChild, true);
+  // launcher replayed initialize to the child under the sentinel id
+  const replay = JSON.parse(child.linesToChild[0]);
+  assert.equal(replay.method, 'initialize');
+  assert.equal(replay.id, SENTINEL_ID);
+
+  // 3. child answers the sentinel initialize
+  child.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: SENTINEL_ID, result: { capabilities: { tools: { listChanged: false } }, instructions: 'real server' } }) + '\n');
+  await tick();
+  // launcher must: send initialized to child, and tools/list_changed to client
+  assert.ok(child.linesToChild.some((l) => JSON.parse(l).method === 'notifications/initialized'));
+  const newClientMsgs = out.slice(outLenBeforeUpgrade).map((s) => JSON.parse(s));
+  assert.ok(newClientMsgs.some((m) => m.method === 'notifications/tools/list_changed'),
+    'client must be told tools changed');
+  // the sentinel init reply must NOT leak to the client
+  assert.ok(!newClientMsgs.some((m) => m.id === SENTINEL_ID), 'sentinel reply must be swallowed');
+
+  // 4. client re-requests tools/list → forwarded to child (not answered empty)
+  const childLinesBefore = child.linesToChild.length;
+  send({ jsonrpc: '2.0', id: 3, method: 'tools/list', params: {} });
+  await tick();
+  const forwarded = child.linesToChild.slice(childLinesBefore).map((l) => JSON.parse(l));
+  assert.ok(forwarded.some((m) => m.id === 3 && m.method === 'tools/list'), 'tools/list forwarded to real binary');
+
+  // 5. child returns real tools → forwarded verbatim to client
+  child.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: 3, result: { tools: [{ name: 'get_call_graph' }, { name: 'semantic_code_search' }] } }) + '\n');
+  await tick();
+  const toolResp = out.map((s) => JSON.parse(s)).find((m) => m.id === 3);
+  assert.ok(toolResp, 'client received a tools/list response');
+  assert.deepEqual(toolResp.result.tools.map((t) => t.name), ['get_call_graph', 'semantic_code_search']);
+});
+
+test('upgrade with unresolvable binary stays a stub and keeps answering', async () => {
+  let allow = true;
+  const { out, send, handle } = makeRig({ shouldUpgrade: () => allow, spawnReal: () => null });
+  send(INIT);
+  await tick();
+  handle.attemptUpgrade();               // spawnReal returns null → no child
+  await tick();
+  assert.equal(handle._state().hasChild, false);
+  send({ jsonrpc: '2.0', id: 9, method: 'tools/list', params: {} });
+  await tick();
+  const resp = out.map((s) => JSON.parse(s)).find((m) => m.id === 9);
+  assert.deepEqual(resp.result.tools, []);   // still served by the stub
+});
+
+test('upgrade: a request in the handoff window is queued then flushed to the child in order', async () => {
+  const child = makeFakeChild();
+  const { send, handle } = makeRig({ shouldUpgrade: () => true, spawnReal: () => child });
+  send(INIT);
+  await tick();
+  handle.attemptUpgrade();                     // child spawned; sentinel initialize sent; NOT ready yet
+  await tick();
+  // client sends a call while the child is mid-handshake → must be queued, not forwarded
+  send({ jsonrpc: '2.0', id: 7, method: 'tools/call', params: { name: 'x' } });
+  await tick();
+  assert.equal(child.linesToChild.length, 1);
+  assert.equal(JSON.parse(child.linesToChild[0]).id, SENTINEL_ID);
+  // child completes its handshake → queued request flushes AFTER initialized
+  child.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: SENTINEL_ID, result: { capabilities: {} } }) + '\n');
+  await tick();
+  const methods = child.linesToChild.map((l) => { const m = JSON.parse(l); return m.method || `id:${m.id}`; });
+  assert.deepEqual(methods, ['initialize', 'notifications/initialized', 'tools/call']);
+});
+
+test('upgrade: child that exits before ready falls back to stub and answers queued requests', async () => {
+  const child = makeFakeChild();
+  const { out, send, handle } = makeRig({ shouldUpgrade: () => true, spawnReal: () => child });
+  send(INIT);
+  await tick();
+  handle.attemptUpgrade();                     // child spawned, not ready
+  await tick();
+  send({ jsonrpc: '2.0', id: 8, method: 'tools/list', params: {} });   // queued during handoff
+  await tick();
+  child.emit('exit', 1, null);                 // child dies BEFORE the sentinel reply
+  await tick();
+  assert.equal(handle._state().hasChild, false);                       // reverted to stub
+  const resp = out.map((s) => JSON.parse(s)).find((m) => m.id === 8);
+  assert.ok(resp, 'queued request got a stub answer (client not left hanging)');
+  assert.deepEqual(resp.result.tools, []);
+});
+
+test('upgrade: error on a READY child exits instead of reverting to a flapping stub', async () => {
+  const child = makeFakeChild();
+  const { send, handle, getExit } = makeRig({ shouldUpgrade: () => true, spawnReal: () => child });
+  send(INIT);
+  await tick();
+  handle.attemptUpgrade();
+  await tick();
+  child.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: SENTINEL_ID, result: { capabilities: {} } }) + '\n');
+  await tick();
+  assert.equal(handle._state().childReady, true);
+  child.emit('error', new Error('boom'));      // a READY child errors
+  await tick();
+  assert.equal(handle._state().hasChild, true, 'must NOT revert to stub (that would flap)');
+  assert.equal(getExit(), 1, 'ready-child error exits the launcher like the binary died');
+});
+
+test('poller is wired to attemptUpgrade at the default interval', () => {
+  const input = new PassThrough();
+  const out = [];
+  let captured = null, spawnCalls = 0;
+  serveEmptyMcpStub({
+    input, output: { write: (s) => out.push(s) },
+    setInterval: (fn, ms) => { captured = { fn, ms }; return 1; },
+    clearInterval: () => {}, exit: () => {},
+    upgrade: { shouldUpgrade: () => true, spawnReal: () => { spawnCalls++; return null; } },
+  });
+  assert.ok(captured, 'poller started via setInterval');
+  assert.equal(captured.ms, 4000);             // DEFAULT_POLL_MS
+  captured.fn();                                // simulate one poll tick
+  assert.equal(spawnCalls, 1);                  // tick attempted the upgrade
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdsrs/code-graph",
-  "version": "0.84.0",
+  "version": "0.85.0",
   "description": "MCP server that indexes codebases into an AST knowledge graph with semantic search, call graph traversal, and HTTP route tracing",
   "license": "MIT",
   "repository": {
@@ -35,10 +35,10 @@
     "node": ">=16"
   },
   "optionalDependencies": {
-    "@sdsrs/code-graph-linux-x64": "0.84.0",
-    "@sdsrs/code-graph-linux-arm64": "0.84.0",
-    "@sdsrs/code-graph-darwin-x64": "0.84.0",
-    "@sdsrs/code-graph-darwin-arm64": "0.84.0",
-    "@sdsrs/code-graph-win32-x64": "0.84.0"
+    "@sdsrs/code-graph-linux-x64": "0.85.0",
+    "@sdsrs/code-graph-linux-arm64": "0.85.0",
+    "@sdsrs/code-graph-darwin-x64": "0.85.0",
+    "@sdsrs/code-graph-darwin-arm64": "0.85.0",
+    "@sdsrs/code-graph-win32-x64": "0.85.0"
   }
 }