@sdsrs/code-graph 0.82.1 → 0.84.0

package/README.md

@@ -7,7 +7,7 @@ A high-performance code knowledge graph server implementing the [Model Context P
 - **Multi-language parsing** — Tree-sitter AST extraction across tiers of depth:
   - **Full** (calls + imports + inheritance + HTTP routes + test markers): TypeScript/TSX, JavaScript, Go, Python, Rust, Java
   - **Smoke-tested** (calls + imports + inheritance): C#, Kotlin, Ruby, PHP, Swift, Dart
-  - **Limited** (functions + calls + `#include` imports + gtest test markers; `Class::method` scope qualification deferred): C, C++
+  - **Limited** (functions + calls + `#include` imports + gtest test markers + C++ base-class inheritance; `Class::method` scope qualification deferred): C, C++
   - **Scripting**: Bash (functions + commands + `source`/`.` imports), Markdown (headings)
   - **File-FTS only** (no AST symbol extraction): HTML, CSS, JSON
 - **Semantic code search** — Hybrid BM25 full-text + vector semantic search with Reciprocal Rank Fusion (RRF), powered by sqlite-vec
@@ -301,7 +301,7 @@ Available when installed as a Claude Code plugin:
 |----------|-----------|-------------------|
 | TypeScript | .ts, .tsx | calls, imports, exports, inherits, implements, routes_to |
 | JavaScript | .js, .jsx, .mjs, .cjs | calls, imports, exports, inherits, routes_to |
-| Go | .go | calls, imports, routes_to |
+| Go | .go | calls, imports, inherits, routes_to |
 | Python | .py, .pyi | calls, imports, inherits, routes_to |
 | Rust | .rs | calls, imports, inherits, implements |
 | Java | .java | calls, imports, inherits, implements |
@@ -310,7 +310,7 @@ Available when installed as a Claude Code plugin:
 | Ruby | .rb | calls, imports, inherits |
 | PHP | .php | calls, imports, inherits, implements |
 | Swift | .swift | calls, imports, inherits |
-| Dart | .dart | calls, imports, implements |
+| Dart | .dart | calls, imports, inherits, implements |
 | C | .c, .h | calls, imports |
 | C++ | .cpp, .cc, .cxx, .hpp | calls, imports, inherits |
 | HTML | .html, .htm | structural parsing |

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

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

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.82.1",
+  "version": "0.84.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.82.1",
-    "@sdsrs/code-graph-linux-arm64": "0.82.1",
-    "@sdsrs/code-graph-darwin-x64": "0.82.1",
-    "@sdsrs/code-graph-darwin-arm64": "0.82.1",
-    "@sdsrs/code-graph-win32-x64": "0.82.1"
+    "@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"
   }
 }