@sdsrs/code-graph 0.83.0 → 0.84.1

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

@@ -4,7 +4,7 @@
   "author": {
     "name": "sdsrs"
   },
-  "version": "0.83.0",
+  "version": "0.84.1",
   "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/claude-plugin/scripts/post-grep-inject.js

@@ -62,6 +62,115 @@ function findFoldableGrepSegment(cmd) {
   return null;
 }
 
+// Callgraph is the marginal-value inject (cross-file caller tree the grep can't
+// return); the grep/show echo modes measured redundant (2026-06-26 audit: 0
+// CONSUMED). Prior gate required the WHOLE grep pattern to be one identifier, so
+// an alternation / multi-symbol grep (`markSuperseded|created_at`, `foo|bar_baz`)
+// fell to the echo. These bounds widen it: extract the identifier tokens and try
+// callgraph on each until one has real edges. Cheap — callgraph is ~30ms/call.
+const MAX_CALLGRAPH_SYMBOLS = 3;
+const MIN_MULTI_SYMBOL_LEN = 3;
+
+/**
+ * Identifier tokens from a grep pattern, as callgraph candidates. A lone
+ * identifier returns [itself] (any length — exact prior behavior). A multi-token
+ * / regex pattern (alternation, word-boundaries, char classes) is stripped of
+ * backslash escapes FIRST — so `\bdate` yields `date`, not `bdate` (the letter
+ * after `\b`/`\d`/`\w` is a regex metachar, not part of the symbol) — then its
+ * identifier tokens are collected: <3-char noise dropped, deduped, capped. Order
+ * preserved so the FIRST alternand (usually the primary symbol) is tried first.
+ * runCallgraphAnswer self-filters non-symbols (returns `hits` only with real
+ * edges), so a junk token just costs one ~30ms no-hits call.
+ * @param {string} rawPattern
+ * @returns {string[]}
+ */
+function extractCallgraphSymbols(rawPattern) {
+  if (typeof rawPattern !== 'string' || !rawPattern) return [];
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(rawPattern)) return [rawPattern];
+  const cleaned = rawPattern.replace(/\\[A-Za-z]/g, ' ');
+  const seen = new Set();
+  const out = [];
+  for (const m of cleaned.matchAll(/[A-Za-z_][A-Za-z0-9_]*/g)) {
+    const tok = m[0];
+    if (tok.length < MIN_MULTI_SYMBOL_LEN) continue;
+    if (seen.has(tok)) continue;
+    seen.add(tok);
+    out.push(tok);
+    if (out.length >= MAX_CALLGRAPH_SYMBOLS) break;
+  }
+  return out;
+}
+
+/**
+ * The command's actual stdout, from the PostToolUse payload. VERIFIED against the
+ * Claude Code runtime (v2.1.198 binary): the hook input carries `tool_response`,
+ * and the Bash result is the OBJECT `{stdout, stderr, interrupted, ...}` — so
+ * `tool_response.stdout` is the real, load-bearing path. (The published hooks doc
+ * says a top-level `tool_output` string, which the runtime does NOT emit — checked
+ * first only for forward-compat if a future version adopts the documented name.)
+ * `tool_response` as a bare string / `.output` are extra defensive fallbacks. null
+ * when no output field is present → the gate can't confirm redundancy → it injects
+ * (pre-gate behavior, no regression on any unhandled shape).
+ * @returns {string|null}
+ */
+function extractGrepOutput(input) {
+  if (!input || typeof input !== 'object') return null;
+  if (typeof input.tool_output === 'string') return input.tool_output;  // doc-stated, forward-compat
+  const tr = input.tool_response;
+  if (typeof tr === 'string') return tr;
+  if (tr && typeof tr === 'object') {
+    if (typeof tr.stdout === 'string') return tr.stdout;  // ← real runtime shape (Bash result obj)
+    if (typeof tr.output === 'string') return tr.output;
+  }
+  return null;
+}
+
+// A stdout line that looks like a grep HIT, as opposed to a sibling `echo`/prose
+// line. grep prints one of: `path:content` (-H), `path:line:content` (-rn),
+// `line:content` (-n on a single named file — NO path prefix), or a bare `path`
+// (-l). Recognizing all four is what lets the gate skip a real hit in ANY of these
+// formats (the compound greps the model actually runs use all of them) while still
+// NOT counting `echo "find Sym" && grep Sym wrongpath/` (grep MISSED → only the echo
+// prose lands, which matches none of these shapes), so the additive grep-empty inject
+// stays reachable and measurable post-ship.
+const GREP_HIT_LINE = /(?:^|\s)[^\s:]*[/.][^\s:]*:|^\s*\d+:/;  // path:… OR linenum: (single-file -n)
+const BARE_PATH_LINE = /^\S*[/.]\S+$/;                        // grep -l: a lone path, no spaces
+// GREP_HIT_LINE has two `[^\s:]*` stars before a required `:`, so a long line that
+// carries `/` or `.` but NO colon backtracks O(n²) (~33s on a 400KB line). grep's
+// hit marker (`path:` / `NN:`) is always at the START of the line, so testing only a
+// bounded prefix is faithful AND caps the scan — untrusted grep stdout on a blocking
+// hook must not stall.
+const HIT_SHAPE_SCAN_MAX = 256;
+
+/**
+ * Did the command's own output already surface the grepped symbol? The inject is
+ * redundant exactly then — the model has the hits in front of it (2026-07-03 audit:
+ * 18/18 injects 0 CONSUMED, all on greps that already hit). Two guards keep this from
+ * over-suppressing the additive (grep-missed) case: (1) only GREP-HIT-SHAPED lines
+ * count — a sibling `echo "…Sym…"` prose line does NOT (fixes the common
+ * `echo <Symbol> && grep <Symbol>` shape); (2) the identifier is matched as a WHOLE
+ * WORD, so a `date` alternand isn't swallowed by `update`/`validate`. When unsure it
+ * returns false → the caller injects (safe side: tax, never a wrong/missing answer).
+ * Uses the same identifier tokenization as the callgraph path.
+ * @returns {boolean} true only when a grep hit for the symbol is CONFIRMED in output.
+ */
+function grepFoundPattern(output, rawPattern) {
+  if (typeof output !== 'string' || !output) return false;
+  const ids = extractCallgraphSymbols(rawPattern);
+  if (ids.length === 0) return false;
+  // ids are pure `[A-Za-z_]\w*` tokens (no regex metachars) → safe to embed in \b…\b.
+  const wordRes = ids.map((id) => new RegExp(`\\b${id}\\b`));
+  return output.split('\n').some((line) => {
+    // Decide hit-shape from a bounded prefix (ReDoS guard — see HIT_SHAPE_SCAN_MAX).
+    // A `-l` bare path is short, so a line longer than the cap is never one.
+    const head = line.length > HIT_SHAPE_SCAN_MAX ? line.slice(0, HIT_SHAPE_SCAN_MAX) : line;
+    const hitShaped = GREP_HIT_LINE.test(head)
+      || (line.length <= HIT_SHAPE_SCAN_MAX && BARE_PATH_LINE.test(line));
+    if (!hitShaped) return false;
+    return wordRes.some((re) => re.test(line));  // \b…\b is linear — safe on the full line
+  });
+}
+
 // Short header so the model recognizes this as cg's parallel structural view of
 // the grep it just ran (the grep already executed; this is additive context).
 const INJECT_HEADER = '[code-graph] AST-aware view of your grep (ran alongside):';
@@ -156,23 +265,31 @@ function runMain() {
   const { segment, block } = found;
   // Run the answer exactly like the deny path.
   const rawPattern = pickBlockPattern(segment);
+  // Grep-response gate (2026-07-03 audit: 18/18 injects were 0 CONSUMED because they
+  // re-stated hits the model already had). If the command's OWN output already
+  // surfaced the grepped symbol, the inject is redundant → skip it, saving the
+  // ~1KB context tax. Only a grep that found NOTHING (or an unreadable output —
+  // no regression on older CC) proceeds: then cg's structural answer (the real
+  // location / cross-file callers a failed grep never showed) is genuinely additive.
+  if (grepFoundPattern(extractGrepOutput(input), rawPattern)) return;
   const pattern = translateBreToRg(segment, rawPattern);
   const searchPath = sanitizeSearchPath(extractSearchPath(segment));
   let answer = { status: 'unavailable' };
   let answeredMode = block.mode;
 
-  // PREFER the cross-file caller/callee tree when the grep targets a single clean
-  // identifier — that is the marginal signal a raw grep can't return (2026-06-26
-  // inject audit: 13 events / 0 CONSUMED because the grep-echo just re-stated the
-  // model's own hits). runCallgraphAnswer returns `hits` ONLY when the symbol has
-  // real edges; a leaf/absent symbol degrades to the show/grep echo below.
-  const symbol = (typeof rawPattern === 'string' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(rawPattern))
-    ? rawPattern : null;
-  if (symbol) {
+  // PREFER the cross-file caller/callee tree — the marginal signal a raw grep can't
+  // return (2026-06-26 inject audit: 13 events / 0 CONSUMED because the grep-echo
+  // just re-stated the model's own hits). Try every identifier the pattern
+  // carries (alternation / multi-symbol grep), not just a lone-identifier pattern,
+  // stopping at the first symbol with real edges. runCallgraphAnswer returns `hits`
+  // ONLY when the symbol has edges → a leaf/absent symbol self-filters to the
+  // show/grep echo below.
+  for (const symbol of extractCallgraphSymbols(rawPattern)) {
     const cg = runCallgraphAnswer({ cwd: root, symbol });
     if (cg.status === 'hits') {
       answer = cg;
       answeredMode = 'callgraph';
+      break;
     }
   }
 
@@ -209,6 +326,9 @@ if (require.main === module) {
 
 module.exports = {
   findFoldableGrepSegment,
+  extractCallgraphSymbols,
+  extractGrepOutput,
+  grepFoundPattern,
   buildInjectText,
   isSilenced,
   isInjectDisabled,

package/claude-plugin/scripts/post-grep-inject.test.js

@@ -9,12 +9,163 @@ const { cgTmpDir } = require('./tmp-dir');
 
 const {
   findFoldableGrepSegment,
+  extractCallgraphSymbols,
+  extractGrepOutput,
+  grepFoundPattern,
   isSilenced,
   isInjectDisabled,
   buildInjectText,
   commandHash,
 } = require('./post-grep-inject');
 
+// ── grep-response gate ──────────────────────────────────────────────
+// 2026-07-03 audit: 18/18 injects were 0 CONSUMED — they re-stated hits the model
+// already had in its OWN grep output. PostToolUse hands the hook the command's
+// actual output (tool_response); skip the inject when the grep already surfaced the
+// symbol (redundant), inject only when it found nothing (cg's structural answer is
+// then genuinely additive: "it's actually here / who calls it").
+
+test('extractGrepOutput: reads top-level tool_output string (doc-stated shape; forward-compat)', () => {
+  assert.equal(extractGrepOutput({ tool_output: 'src/a.rs:1 hit' }), 'src/a.rs:1 hit');
+});
+
+test('extractGrepOutput: reads tool_response.stdout (VERIFIED real CC runtime shape — Bash result obj)', () => {
+  // CC v2.1.198 binary: hook input = {tool_response:{stdout,stderr,interrupted,...}}.
+  // This is the load-bearing path the gate actually fires on in production.
+  assert.equal(extractGrepOutput({ tool_response: { stdout: 'src/a.rs:1 hit' } }), 'src/a.rs:1 hit');
+});
+
+test('extractGrepOutput: defensive fallback — tool_response as a bare string', () => {
+  assert.equal(extractGrepOutput({ tool_response: 'raw output' }), 'raw output');
+});
+
+test('extractGrepOutput: defensive fallback — tool_response.output field', () => {
+  assert.equal(extractGrepOutput({ tool_response: { output: 'out text' } }), 'out text');
+});
+
+test('extractGrepOutput: absent output → null (unknown, caller injects — no regression)', () => {
+  assert.equal(extractGrepOutput({}), null);
+  assert.equal(extractGrepOutput({ tool_response: {} }), null);
+  assert.equal(extractGrepOutput(null), null);
+});
+
+test('grepFoundPattern: output line containing the symbol → true (grep hit)', () => {
+  assert.equal(grepFoundPattern('src/foo.rs:7  fn EmbeddingModel()', 'EmbeddingModel'), true);
+});
+
+test('grepFoundPattern: no line contains the symbol → false (grep found nothing)', () => {
+  // e.g. `echo "===" && grep Sym f` where grep matched nothing — only the echo lands.
+  assert.equal(grepFoundPattern('===\n', 'EmbeddingModel'), false);
+});
+
+test('grepFoundPattern: alternation — ANY alternand present → true', () => {
+  assert.equal(grepFoundPattern('src/x.rs:3 created_at', 'markSuperseded|created_at'), true);
+});
+
+test('grepFoundPattern: null / empty output or pattern → false', () => {
+  assert.equal(grepFoundPattern(null, 'Sym'), false);
+  assert.equal(grepFoundPattern('', 'Sym'), false);
+  assert.equal(grepFoundPattern('anything', ''), false);
+  assert.equal(grepFoundPattern('anything', null), false);
+});
+
+test('grepFoundPattern: sibling echo mentions the symbol but grep MISSED → false (no hit-shaped line)', () => {
+  // `echo "search for EmbeddingModel" && grep EmbeddingModel wrongpath/` where grep
+  // found nothing → stdout is just the echo prose. Must NOT count as a hit, or the
+  // additive grep-empty inject is unreachable for this common shape (review MEDIUM).
+  assert.equal(grepFoundPattern('search for EmbeddingModel', 'EmbeddingModel'), false);
+  assert.equal(grepFoundPattern('=== callers of EmbeddingModel ===', 'EmbeddingModel'), false);
+});
+
+test('grepFoundPattern: identifier matched as a WHOLE WORD, not a substring', () => {
+  // `date` must not be swallowed by `update`/`validate` on a real hit line (review LOW#2).
+  assert.equal(grepFoundPattern('src/x.rs:3  updated the row and validated it', 'TaskState|date'), false);
+  // …but a genuine whole-word hit on a hit-shaped line still counts.
+  assert.equal(grepFoundPattern('src/x.rs:3  const date = now()', 'TaskState|date'), true);
+});
+
+test('grepFoundPattern: bare path line (grep -l output) with the symbol → true', () => {
+  assert.equal(grepFoundPattern('src/getVocabulary.rs', 'getVocabulary'), true);
+});
+
+test('grepFoundPattern: single-file `grep -n` linenum:content hit (no path prefix) → true', () => {
+  // Real shape from a compound `grep -n Sym onefile.mjs` — the hit line is
+  // `2:import { parseGitHubUrl }` with NO path token. Must still count as a hit.
+  assert.equal(grepFoundPattern('2:import { parseGitHubUrl } from "../x.mjs";', 'parseGitHubUrl'), true);
+});
+
+test('grepFoundPattern: long colon-free line does NOT ReDoS (bounded prefix scan)', () => {
+  // GREP_HIT_LINE's two `[^\s:]*` stars backtrack O(n²) on a long line carrying `/`.`
+  // but no colon (~33s on 400KB pre-fix). The prefix cap must keep it O(1)/line.
+  const huge = '/x.'.repeat(200000) + ' EmbeddingModel';  // ~600KB, has /. but no colon
+  const t0 = process.hrtime.bigint();
+  const r = grepFoundPattern(huge, 'EmbeddingModel');
+  const ms = Number(process.hrtime.bigint() - t0) / 1e6;
+  assert.ok(ms < 200, `grepFoundPattern took ${ms.toFixed(0)}ms on a 600KB line — ReDoS regressed`);
+  // Not a grep-hit-shaped line (no colon in the prefix, too long for a bare path) → false.
+  assert.equal(r, false);
+});
+
+test('grepFoundPattern: symbol present only in prose (no path token on the line) → false', () => {
+  // Defends the hit-line requirement: a plain content line without a path:col prefix
+  // (e.g. a `grep` on a single unnamed file, or non-grep sibling output) → inject
+  // (safe over-inject) rather than a false-skip.
+  assert.equal(grepFoundPattern('the EmbeddingModel struct is here', 'EmbeddingModel'), false);
+});
+
+// ── extractCallgraphSymbols ─────────────────────────────────────────
+// Widen callgraph eligibility: an alternation / multi-symbol grep pattern
+// used to fall to the redundant grep-echo because the WHOLE pattern wasn't a lone
+// identifier. Extract the identifier tokens (callgraph self-filters non-symbols).
+
+test('extractCallgraphSymbols: a lone identifier → [itself] (prior behavior)', () => {
+  assert.deepEqual(extractCallgraphSymbols('markSuperseded'), ['markSuperseded']);
+});
+
+test('extractCallgraphSymbols: a lone SHORT identifier is preserved (no length filter on the fast path)', () => {
+  // The <3-char length filter applies ONLY to multi-token extraction; a grep for
+  // a lone 2-char symbol must still get its callgraph, exactly as before.
+  assert.deepEqual(extractCallgraphSymbols('ok'), ['ok']);
+});
+
+test('extractCallgraphSymbols: alternation → each identifier in order', () => {
+  assert.deepEqual(
+    extractCallgraphSymbols('markSuperseded|created_at'),
+    ['markSuperseded', 'created_at']);
+});
+
+test('extractCallgraphSymbols: strips regex escapes so `\\bdate` yields `date`, not `bdate`', () => {
+  // The letter after \b/\d/\w is a regex metachar, not part of the symbol.
+  assert.deepEqual(
+    extractCallgraphSymbols('markSuperseded|\\bdate:|created_at'),
+    ['markSuperseded', 'date', 'created_at']);
+});
+
+test('extractCallgraphSymbols: drops <3-char noise tokens in multi mode', () => {
+  // `a|bb|ccc` → only `ccc` survives (a=1, bb=2 filtered).
+  assert.deepEqual(extractCallgraphSymbols('a|bb|ccc'), ['ccc']);
+});
+
+test('extractCallgraphSymbols: dedups repeated tokens, order-preserving', () => {
+  assert.deepEqual(extractCallgraphSymbols('foo|bar|foo'), ['foo', 'bar']);
+});
+
+test('extractCallgraphSymbols: caps attempts at 3', () => {
+  assert.deepEqual(
+    extractCallgraphSymbols('aaa|bbb|ccc|ddd|eee'),
+    ['aaa', 'bbb', 'ccc']);
+});
+
+test('extractCallgraphSymbols: non-string / empty → []', () => {
+  assert.deepEqual(extractCallgraphSymbols(null), []);
+  assert.deepEqual(extractCallgraphSymbols(''), []);
+  assert.deepEqual(extractCallgraphSymbols(undefined), []);
+});
+
+test('extractCallgraphSymbols: pattern with no identifier token → []', () => {
+  assert.deepEqual(extractCallgraphSymbols('\\d+\\.\\d+'), []);
+});
+
 // ── Pure logic: findFoldableGrepSegment ─────────────────────────────
 // Reuses splitTopLevelSegments + classifyBlock from pre-grep-guide. The FIRST
 // segment whose head is grep AND whose classifyBlock is non-null is the foldable
@@ -135,10 +286,15 @@ function e2eFixture(stubBody) {
   return { dir, stub };
 }
 
-function runHook(cmd, fixture, extraEnv = {}, cwdOverride) {
+function runHook(cmd, fixture, extraEnv = {}, cwdOverride, toolOutput) {
+  const payload = { tool_input: { command: cmd } };
+  // Drive the REAL CC runtime shape (verified against the v2.1.198 binary): the Bash
+  // result reaches the hook as `tool_response.stdout`. Absent → unknown → the gate
+  // injects (pre-gate behavior; no regression).
+  if (toolOutput !== undefined) payload.tool_response = { stdout: toolOutput };
   return spawnSync(process.execPath, [path.join(__dirname, 'post-grep-inject.js')], {
     cwd: cwdOverride || fixture.dir,
-    input: JSON.stringify({ tool_input: { command: cmd } }),
+    input: JSON.stringify(payload),
     encoding: 'utf8',
     env: {
       ...process.env,
@@ -251,6 +407,108 @@ test('e2e: per-command cooldown — verbatim re-run within window injects only o
   }
 });
 
+test('e2e: alternation grep `Alpha|Beta` → callgraph mode when a symbol has edges', () => {
+  // The whole pattern is not a lone identifier, but the FIRST alternand resolves
+  // to a symbol with cross-file edges → callgraph payload, not the grep echo.
+  const uniq = `AltCg${Date.now()}`;
+  const fixture = e2eFixture(
+    // stub: argv = [node, stub, subcmd, sym/pattern, ...]. callgraph → edge-bearing
+    // tree; anything else (grep) → a plain hit line.
+    `const sub = process.argv[2], arg = process.argv[3];\n` +
+    `if (sub === 'callgraph') { process.stdout.write(arg + '\\n  \\u2190 called by: someCaller (src/x.rs:3)\\n'); process.exit(0); }\n` +
+    `process.stdout.write('src/foo.rs:7  fn ' + arg + '()\\n');`);
+  const cmd = `echo "x" && grep "${uniq}|OtherSym" src/`;
+  try {
+    const res = runHook(cmd, fixture);
+    assert.equal(res.status, 0);
+    const out = JSON.parse(res.stdout);
+    assert.match(out.hookSpecificOutput.additionalContext, /Cross-file call graph/,
+      'a resolving alternand must produce the callgraph payload, not the grep echo');
+    assert.match(out.hookSpecificOutput.additionalContext, /called by: someCaller/);
+    const recs = fs.readFileSync(
+      path.join(fixture.dir, '.code-graph', 'recommendations.jsonl'), 'utf8');
+    const rec = JSON.parse(recs.trim().split('\n').pop());
+    assert.equal(rec.action, 'inject');
+    assert.equal(rec.mode, 'callgraph', 'inject rec must record mode:callgraph');
+  } finally {
+    cleanupFixture(fixture, cmd);
+  }
+});
+
+test('e2e: alternation grep, no symbol has edges → falls back to grep echo (grep mode)', () => {
+  // callgraph returns exit 1 (no node) for every alternand → the grep-echo path
+  // still delivers, mode:grep. Guards that widening never LOSES the echo fallback.
+  const uniq = `AltEcho${Date.now()}`;
+  const fixture = e2eFixture(
+    `const sub = process.argv[2], arg = process.argv[3];\n` +
+    `if (sub === 'callgraph') { process.exit(1); }\n` +
+    `process.stdout.write('src/foo.rs:7  fn matched()\\n');`);
+  const cmd = `echo "x" && grep "${uniq}|OtherSym" src/`;
+  try {
+    const res = runHook(cmd, fixture);
+    assert.equal(res.status, 0);
+    const out = JSON.parse(res.stdout);
+    assert.match(out.hookSpecificOutput.additionalContext, /AST-aware view of your grep/);
+    const recs = fs.readFileSync(
+      path.join(fixture.dir, '.code-graph', 'recommendations.jsonl'), 'utf8');
+    const rec = JSON.parse(recs.trim().split('\n').pop());
+    assert.equal(rec.mode, 'grep');
+  } finally {
+    cleanupFixture(fixture, cmd);
+  }
+});
+
+test('e2e: grep-response gate — grep ALREADY showed the symbol → skip inject (redundant)', () => {
+  // The model's own grep output contains the symbol → inject would re-state hits it
+  // already has (the 18/18-CONSUMED=0 case). Even though the stub WOULD answer, the
+  // gate suppresses the redundant inject.
+  const uniq = `GateHit${Date.now()}`;
+  const fixture = e2eFixture(`process.stdout.write('src/foo.rs:7  fn ' + process.argv[3] + '()\\n');`);
+  const cmd = `echo "x" && grep "${uniq}" src/`;
+  const grepOutput = `src/real.rs:42  fn ${uniq}() {  // the model's own grep already found it`;
+  try {
+    const res = runHook(cmd, fixture, {}, undefined, grepOutput);
+    assert.equal(res.status, 0);
+    assert.equal(res.stdout.trim(), '', 'a grep that already surfaced the symbol must NOT trigger a redundant inject');
+  } finally {
+    cleanupFixture(fixture, cmd);
+  }
+});
+
+test('e2e: grep-response gate — grep found NOTHING → inject (cg answer is additive)', () => {
+  // The grep produced no hit for the symbol (dialect/scope miss) → cg's structural
+  // answer is genuinely new info → inject fires.
+  const uniq = `GateMiss${Date.now()}`;
+  const fixture = e2eFixture(`process.stdout.write('src/foo.rs:7  fn ' + process.argv[3] + '()\\n');`);
+  const cmd = `echo "===" && grep "${uniq}" src/`;
+  const grepOutput = `===\n`; // only the echo landed; grep matched nothing
+  try {
+    const res = runHook(cmd, fixture, {}, undefined, grepOutput);
+    assert.equal(res.status, 0);
+    const out = JSON.parse(res.stdout);
+    assert.match(out.hookSpecificOutput.additionalContext, new RegExp(uniq),
+      'a grep that found nothing must still get the additive cg answer');
+  } finally {
+    cleanupFixture(fixture, cmd);
+  }
+});
+
+test('e2e: grep-response gate — absent output field → inject (no regression on unknown)', () => {
+  // No tool_response (older CC, or unreadable) → the gate can't confirm redundancy →
+  // it injects, exactly as before the gate existed.
+  const uniq = `GateUnknown${Date.now()}`;
+  const fixture = e2eFixture(`process.stdout.write('src/foo.rs:7  fn ' + process.argv[3] + '()\\n');`);
+  const cmd = `echo "x" && grep "${uniq}" src/`;
+  try {
+    const res = runHook(cmd, fixture); // no toolOutput arg
+    assert.equal(res.status, 0);
+    const out = JSON.parse(res.stdout);
+    assert.match(out.hookSpecificOutput.additionalContext, new RegExp(uniq));
+  } finally {
+    cleanupFixture(fixture, cmd);
+  }
+});
+
 test('e2e: no index up to $HOME → silent exit 0', () => {
   // A cwd with no .code-graph anywhere up the tree resolves to null root → exit.
   const bare = fs.mkdtempSync(path.join(os.tmpdir(), 'post-grep-noidx-'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdsrs/code-graph",
-  "version": "0.83.0",
+  "version": "0.84.1",
   "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.83.0",
-    "@sdsrs/code-graph-linux-arm64": "0.83.0",
-    "@sdsrs/code-graph-darwin-x64": "0.83.0",
-    "@sdsrs/code-graph-darwin-arm64": "0.83.0",
-    "@sdsrs/code-graph-win32-x64": "0.83.0"
+    "@sdsrs/code-graph-linux-x64": "0.84.1",
+    "@sdsrs/code-graph-linux-arm64": "0.84.1",
+    "@sdsrs/code-graph-darwin-x64": "0.84.1",
+    "@sdsrs/code-graph-darwin-arm64": "0.84.1",
+    "@sdsrs/code-graph-win32-x64": "0.84.1"
   }
 }