@sdsrs/code-graph 0.47.1 → 0.49.0

package/claude-plugin/scripts/pre-grep-guide.test.js

@@ -4,9 +4,17 @@ const assert = require('node:assert/strict');
 const {
   shouldHint,
   shouldBlock,
+  classifyBlock,
+  extractDeclSymbols,
+  translateBreToRg,
+  buildShowDenyReason,
+  extractSedReadTargets,
   extractPatterns,
   extractSearchPath,
   normalizeCommandPaths,
+  resolveProjectRoot,
+  rebaseRelativePaths,
+  commandHasBypass,
   pickBlockPattern,
   buildHint,
   buildBlockReason,
@@ -314,30 +322,81 @@ test('shouldBlock: rg with CamelCase on lib/', () => {
 
 // ── shouldBlock: should NOT block (downgrade to hint) — precision flags ─
 
-test('shouldBlock: grep -l (files-with-matches) → hint only', () => {
-  assert.equal(shouldBlock('grep -rl "EmbeddingModel" src/'), false);
+test('shouldBlock: grep -l (files-with-matches) → deny, grep answer covers file lists (v0.49)', () => {
+  assert.equal(shouldBlock('grep -rl "EmbeddingModel" src/'), true);
+  assert.deepEqual(classifyBlock('grep -rl "EmbeddingModel" src/'), { mode: 'grep' });
 });
 
-test('shouldBlock: --include=*.rs → user already filtering, hint only', () => {
-  assert.equal(shouldBlock('grep -rn --include="*.rs" "EmbeddingModel" src/'), false);
+test('shouldBlock: --include=*.rs → deny, path-scoped grep answer covers it (v0.49)', () => {
+  assert.equal(shouldBlock('grep -rn --include="*.rs" "EmbeddingModel" src/'), true);
 });
 
-test('shouldBlock: --exclude-dir=tests → hint only', () => {
+test('shouldBlock: --exclude=tests → hint only (answer cannot honor exclusion)', () => {
   assert.equal(shouldBlock('grep -rn --exclude=tests "EmbeddingModel" src/'), false);
 });
 
-test('shouldBlock: -A 3 context flag → hint only', () => {
+test('shouldBlock: -L / -v inverted intents → hint only', () => {
+  assert.equal(shouldBlock('grep -rL "EmbeddingModel" src/'), false);
+  assert.equal(shouldBlock('grep -rnv "EmbeddingModel" src/'), false);
+});
+
+test('shouldBlock: -A 3 with bare identifier → hint only (cannot honor ±N lines)', () => {
   assert.equal(shouldBlock('grep -rn -A 3 "EmbeddingModel" src/'), false);
 });
 
-test('shouldBlock: -B 2 context flag → hint only', () => {
+test('shouldBlock: -B 2 with bare identifier → hint only', () => {
   assert.equal(shouldBlock('grep -rn -B 2 "EmbeddingModel" src/'), false);
 });
 
-test('shouldBlock: -C 5 context flag → hint only', () => {
+test('shouldBlock: -C 5 with bare identifier → hint only', () => {
   assert.equal(shouldBlock('grep -rn -C 5 "EmbeddingModel" src/'), false);
 });
 
+// ── translateBreToRg (v0.49) — BRE→rust-regex dialect bridge ─────────
+
+test('translateBreToRg: plain grep BRE alternation unescaped', () => {
+  assert.equal(
+    translateBreToRg('grep -rn "UnifiedPickerEngine\\|engine.run" src/', 'UnifiedPickerEngine\\|engine.run'),
+    'UnifiedPickerEngine|engine.run');
+});
+
+test('translateBreToRg: rg patterns untouched (already extended)', () => {
+  assert.equal(translateBreToRg('rg "a\\|b" src/', 'a\\|b'), 'a\\|b');
+});
+
+test('translateBreToRg: grep -E untouched', () => {
+  assert.equal(translateBreToRg('grep -rnE "a\\|b" src/', 'a\\|b'), 'a\\|b');
+});
+
+test('translateBreToRg: unescapes groups/braces/quantifiers for plain grep', () => {
+  assert.equal(translateBreToRg('grep "fn \\(x\\)\\+" src/', 'fn \\(x\\)\\+'), 'fn (x)+');
+});
+
+// ── classifyBlock: show mode (v0.49) — the daagu 22/128 function-body reads ──
+
+test('classifyBlock: declaration anchor + -A → show mode with symbols', () => {
+  assert.deepEqual(
+    classifyBlock('rg -n "def cascade_failure|def reset_task" -A 25 backend/app/'),
+    { mode: 'show', symbols: ['cascade_failure', 'reset_task'] });
+});
+
+test('classifyBlock: multi-decl alternation caps at 3 symbols', () => {
+  const c = classifyBlock('rg -n "def a_one|def b_two|class CThree|fn d_four" -A 10 src/');
+  assert.equal(c.mode, 'show');
+  assert.deepEqual(c.symbols, ['a_one', 'b_two', 'CThree']);
+});
+
+test('classifyBlock: declaration anchor WITHOUT context flag → plain grep deny', () => {
+  assert.deepEqual(classifyBlock('grep -rn "def fetch_user" backend/app/services/'),
+    { mode: 'grep' });
+});
+
+test('extractDeclSymbols: dedupes and spans fn/def/class/struct anchors', () => {
+  assert.deepEqual(
+    extractDeclSymbols(['fn alpha_one', 'struct BetaTwo', 'fn alpha_one']),
+    ['alpha_one', 'BetaTwo']);
+});
+
 // ── shouldBlock: should NOT block — marker-only patterns ────────────
 
 test('shouldBlock: bare TODO marker → hint only (no cg equivalent)', () => {
@@ -399,8 +458,8 @@ test('buildBlockReason: lists cg grep + ast-search + callgraph', () => {
   assert.match(out, /code-graph-mcp callgraph/);
 });
 
-test('buildBlockReason: documents the escape hatch env var', () => {
-  assert.match(buildBlockReason(), /CODE_GRAPH_NO_BLOCK_GREP=1/);
+test('buildBlockReason: NEVER documents the escape hatch (v0.49 — the "THIS command only" scoping was adopted as a permanent prefix in 8s on 2026-06-12)', () => {
+  assert.doesNotMatch(buildBlockReason(), /CODE_GRAPH_NO_BLOCK_GREP/);
 });
 
 test('buildBlockReason: under 700-byte budget (single CC message)', () => {
@@ -580,11 +639,11 @@ test('replay: real abs-path symbol grep → BLOCK after normalization', () => {
   assert.equal(shouldBlock(norm), true);
 });
 
-test('replay: real abs-path -rln grep → HINT only after normalization (precision flag)', () => {
+test('replay: real abs-path -rln grep → DENY after normalization (v0.49: file lists answerable)', () => {
   const cmd = `grep -rln "load_active_config_standalone" ${DAAGU}/backend/tests/ | head -5`;
   const norm = normalizeCommandPaths(cmd, DAAGU);
   assert.equal(shouldHint(norm), true);
-  assert.equal(shouldBlock(norm), false);                     // -l cluster disqualifies block
+  assert.deepEqual(classifyBlock(norm), { mode: 'grep' });    // grep answer lists files per hit
 });
 
 test('replay: abs-path config-only grep stays silent after normalization', () => {
@@ -651,17 +710,23 @@ test('pickBlockPattern: no identifier-like pattern → undefined', () => {
 
 // ── v0.47.0 deny-with-answer: message builders + env gate ───────────
 
-test('buildBlockReasonWithAnswer: embeds results, command, and escape hatch', () => {
+test('buildBlockReasonWithAnswer: embeds results and command', () => {
   const reason = buildBlockReasonWithAnswer('fts5_search', 'src/storage/', {
     status: 'hits', text: 'src/storage/db.rs:42  fn fts5_search()', truncated: false,
   });
   assert.match(reason, /already ran/);
   assert.match(reason, /code-graph-mcp grep "fts5_search" src\/storage\//);
   assert.match(reason, /src\/storage\/db\.rs:42/);
-  assert.match(reason, /CODE_GRAPH_NO_BLOCK_GREP=1/);
   assert.doesNotMatch(reason, /truncated/);
 });
 
+test('buildBlockReasonWithAnswer: NEVER advertises the bypass (v0.48 — one deny taught a 14-grep permanent prefix)', () => {
+  const reason = buildBlockReasonWithAnswer('fts5_search', 'src/storage/', {
+    status: 'hits', text: 'hit', truncated: false,
+  });
+  assert.doesNotMatch(reason, /CODE_GRAPH_NO_BLOCK_GREP/);
+});
+
 test('buildBlockReasonWithAnswer: no searchPath → command has no path arg', () => {
   const reason = buildBlockReasonWithAnswer('fts5_search', undefined, {
     status: 'hits', text: 'hit', truncated: false,
@@ -706,9 +771,9 @@ function e2eFixture(stubBody) {
   return { dir, stub };
 }
 
-function runHook(cmd, fixture) {
+function runHook(cmd, fixture, cwdOverride) {
   const res = spawnHook(process.execPath, [pathE2e.join(__dirname, 'pre-grep-guide.js')], {
-    cwd: fixture.dir,
+    cwd: cwdOverride || fixture.dir,
     input: JSON.stringify({ tool_input: { command: cmd } }),
     encoding: 'utf8',
     env: {
@@ -837,3 +902,217 @@ test('e2e: CODE_GRAPH_NO_ANSWER_IN_DENY=1 → static deny even when stub would h
     cleanupFixture(fixture, cmd);
   }
 });
+
+// ── v0.48 subdir-cwd dark fix: resolveProjectRoot / rebaseRelativePaths ──
+// daagu 2026-06-11: the persistent shell `cd backend/` darkened 38/40
+// head-greps for the rest of the night — gate 5 checked process.cwd() only.
+
+const { sanitizeSearchPath } = require('./cg-answer');
+
+test('resolveProjectRoot: index at start dir', () => {
+  const base = fsE2e.mkdtempSync(pathE2e.join(osE2e.tmpdir(), 'cg-root-'));
+  try {
+    fsE2e.mkdirSync(pathE2e.join(base, 'proj', '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(base, 'proj', '.code-graph', 'index.db'), '');
+    assert.equal(
+      resolveProjectRoot(pathE2e.join(base, 'proj'), { home: base }),
+      pathE2e.join(base, 'proj'));
+  } finally { fsE2e.rmSync(base, { recursive: true, force: true }); }
+});
+
+test('resolveProjectRoot: walks up from nested subdir to the indexed root', () => {
+  const base = fsE2e.mkdtempSync(pathE2e.join(osE2e.tmpdir(), 'cg-root-'));
+  try {
+    const proj = pathE2e.join(base, 'proj');
+    fsE2e.mkdirSync(pathE2e.join(proj, '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(proj, '.code-graph', 'index.db'), '');
+    const deep = pathE2e.join(proj, 'backend', 'app', 'services');
+    fsE2e.mkdirSync(deep, { recursive: true });
+    assert.equal(resolveProjectRoot(deep, { home: base }), proj);
+  } finally { fsE2e.rmSync(base, { recursive: true, force: true }); }
+});
+
+test('resolveProjectRoot: no index up to $HOME → null (home itself still checked)', () => {
+  const base = fsE2e.mkdtempSync(pathE2e.join(osE2e.tmpdir(), 'cg-root-'));
+  try {
+    const deep = pathE2e.join(base, 'somewhere', 'deep');
+    fsE2e.mkdirSync(deep, { recursive: true });
+    assert.equal(resolveProjectRoot(deep, { home: base }), null);
+    // home itself holding an index is honored
+    fsE2e.mkdirSync(pathE2e.join(base, '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(base, '.code-graph', 'index.db'), '');
+    assert.equal(resolveProjectRoot(deep, { home: base }), base);
+  } finally { fsE2e.rmSync(base, { recursive: true, force: true }); }
+});
+
+test('rebaseRelativePaths: daagu shape — bare `app` from backend/ cwd', () => {
+  const exists = (p) => p.endsWith(pathE2e.join('backend', 'app'));
+  const cmd = 'grep -rn "rr_source\\|max_retries" app --include=*.py';
+  const rebased = rebaseRelativePaths(cmd, 'backend', '/proj', exists);
+  assert.equal(rebased, 'grep -rn "rr_source\\|max_retries" backend/app --include=*.py');
+  assert.equal(shouldHint(rebased), true);
+  assert.equal(extractSearchPath(rebased), 'backend/app');
+});
+
+test('rebaseRelativePaths: deep relPrefix, multiple file args', () => {
+  const exists = (p) => p.endsWith('.py');
+  const rel = 'backend/app/services/scheduler/tasks';
+  const cmd = 'grep -n "except Exception" asr_preload.py xuanlun_pro_scan.py';
+  const rebased = rebaseRelativePaths(cmd, rel, '/proj', exists);
+  assert.match(rebased, /backend\/app\/services\/scheduler\/tasks\/asr_preload\.py/);
+  assert.match(rebased, /backend\/app\/services\/scheduler\/tasks\/xuanlun_pro_scan\.py/);
+  assert.equal(shouldHint(rebased), true);
+});
+
+test('rebaseRelativePaths: quoted patterns are never rebased even if a same-named path exists', () => {
+  const exists = () => true; // adversarial: everything "exists"
+  const cmd = 'grep -rn "retry" app';
+  const rebased = rebaseRelativePaths(cmd, 'backend', '/proj', exists);
+  assert.equal(rebased, 'grep -rn "retry" backend/app');
+});
+
+test('rebaseRelativePaths: flags, absolute, traversal, operators untouched', () => {
+  const exists = () => true;
+  const cmd = 'grep -rn "X" /etc/hosts ../up --include=*.py 2>/dev/null';
+  assert.equal(rebaseRelativePaths(cmd, 'backend', '/proj', exists), cmd);
+});
+
+test('rebaseRelativePaths: non-source relPrefix (docs/) → unchanged', () => {
+  const exists = () => true;
+  const cmd = 'grep -rn "X" app';
+  assert.equal(rebaseRelativePaths(cmd, 'docs', '/proj', exists), cmd);
+});
+
+test('rebaseRelativePaths: unquoted pattern word does not exist → untouched', () => {
+  const exists = (p) => p.endsWith('/backend/app');
+  const cmd = 'grep -rn retry_count app';
+  const rebased = rebaseRelativePaths(cmd, 'backend', '/proj', exists);
+  assert.equal(rebased, 'grep -rn retry_count backend/app');
+});
+
+// ── v0.48 bypass visibility: GREP_HEAD bare-prefix + commandHasBypass ──
+
+test('shouldHint: bare KEY=VALUE prefixed grep now matches GREP_HEAD', () => {
+  assert.equal(shouldHint('CODE_GRAPH_NO_BLOCK_GREP=1 grep -rn "fts5_search" src/'), true);
+});
+
+test('extractPatterns: bare KEY=VALUE prefix stripped with the verb', () => {
+  assert.deepEqual(
+    extractPatterns('CODE_GRAPH_NO_BLOCK_GREP=1 grep -rn "split_identifier" src/'),
+    ['split_identifier']);
+});
+
+test('commandHasBypass: =1 prefix detected, other values / absence are not', () => {
+  assert.equal(commandHasBypass('CODE_GRAPH_NO_BLOCK_GREP=1 grep -rn "X" src/'), true);
+  assert.equal(commandHasBypass('FOO=1 CODE_GRAPH_NO_BLOCK_GREP=1 grep "X" src/'), true);
+  assert.equal(commandHasBypass('CODE_GRAPH_NO_BLOCK_GREP=0 grep -rn "X" src/'), false);
+  assert.equal(commandHasBypass('grep -rn "CODE_GRAPH_NO_BLOCK_GREP=1" src/'), false);
+  assert.equal(commandHasBypass('grep -rn "X" src/'), false);
+});
+
+// ── v0.48 replay: the exact command behind the night's only deny ──
+// (answered:false — glob path reached rg literally and exited 1)
+
+test('replay: daagu denied glob command → block + sanitized search path', () => {
+  const cmd = 'grep -rn "async def chat\\|def chat\\|retry\\|rate.limit\\|rate-limit\\|RateLimit\\|429\\|max_retries\\|backoff\\|fallback_model\\|temporarily" backend/app/services/llm_engine/*.py | head -40';
+  assert.equal(shouldHint(cmd), true);
+  assert.equal(shouldBlock(cmd), true);
+  const raw = extractSearchPath(cmd);
+  assert.equal(raw, 'backend/app/services/llm_engine/*.py');
+  assert.equal(sanitizeSearchPath(raw), 'backend/app/services/llm_engine');
+});
+
+// ── v0.48 e2e: hook process spawned exactly as CC does ──
+
+test('e2e: subdir cwd — hook resolves root, rebases path, records at root', () => {
+  const uniq = `sub_dir_fix_${Date.now()}`;
+  const fixture = e2eFixture(
+    `process.stdout.write('backend/app/x.py:1  fn hit()\\n');`);
+  const cmd = `grep -rn "${uniq}\\|max_retries" app`;
+  try {
+    fsE2e.mkdirSync(pathE2e.join(fixture.dir, 'backend', 'app'), { recursive: true });
+    const res = runHook(cmd, fixture, pathE2e.join(fixture.dir, 'backend'));
+    const out = JSON.parse(res.stdout);
+    assert.equal(out.hookSpecificOutput.permissionDecision, 'deny');
+    const recs = fsE2e.readFileSync(
+      pathE2e.join(fixture.dir, '.code-graph', 'recommendations.jsonl'), 'utf8');
+    assert.match(recs, /"action":"deny"/);
+    // never creates .code-graph in the subdir
+    assert.equal(fsE2e.existsSync(pathE2e.join(fixture.dir, 'backend', '.code-graph')), false);
+  } finally {
+    cleanupFixture(fixture, cmd);
+  }
+});
+
+test('e2e: bypassed grep is silent but recorded as action:bypass', () => {
+  const uniq = `bypass_vis_${Date.now()}`;
+  const fixture = e2eFixture(`process.stdout.write('never called\\n');`);
+  const cmd = `CODE_GRAPH_NO_BLOCK_GREP=1 grep -rn "${uniq}\\|fts5_search" src/`;
+  try {
+    fsE2e.mkdirSync(pathE2e.join(fixture.dir, 'src'), { recursive: true });
+    const res = runHook(cmd, fixture);
+    assert.equal(res.stdout, '');
+    const recs = fsE2e.readFileSync(
+      pathE2e.join(fixture.dir, '.code-graph', 'recommendations.jsonl'), 'utf8');
+    assert.match(recs, /"action":"bypass"/);
+  } finally {
+    cleanupFixture(fixture, cmd);
+  }
+});
+
+test('e2e: glob path arg → answer runs against the glob-truncated dir', () => {
+  const uniq = `GlobTrunc${Date.now()}`;
+  const fixture = e2eFixture(
+    `process.stdout.write('args=' + JSON.stringify(process.argv.slice(2)) + '\\n');`);
+  const cmd = `grep -rn "${uniq}" src/storage/*.rs`;
+  try {
+    fsE2e.mkdirSync(pathE2e.join(fixture.dir, 'src', 'storage'), { recursive: true });
+    const res = runHook(cmd, fixture);
+    const out = JSON.parse(res.stdout);
+    assert.equal(out.hookSpecificOutput.permissionDecision, 'deny');
+    assert.match(out.hookSpecificOutput.permissionDecisionReason,
+      new RegExp(`args=\\["grep","${uniq}","src/storage"\\]`));
+  } finally {
+    cleanupFixture(fixture, cmd);
+  }
+});
+
+test('rebaseRelativePaths: glob token rebases when its glob-truncated dir exists', () => {
+  // daagu shape: shell in backend/, command scopes a glob under it. Without
+  // the truncated probe the token stayed subdir-relative while the answer ran
+  // from the root → rg ENOENT → answered:false (the original night bug).
+  const exists = (p) => p.endsWith(pathE2e.join('backend', 'app', 'services', 'llm_engine'));
+  const cmd = 'grep -rn "def chat\\|max_retries" app/services/llm_engine/*.py';
+  const rebased = rebaseRelativePaths(cmd, 'backend', '/proj', exists);
+  assert.equal(
+    extractSearchPath(rebased), 'backend/app/services/llm_engine/*.py');
+  assert.equal(
+    sanitizeSearchPath(extractSearchPath(rebased)), 'backend/app/services/llm_engine');
+});
+
+// ── extractSedReadTargets (v0.49) — sed-range reads feed read-fanout ──
+
+test('extractSedReadTargets: plain and quoted ranges, abs and rel paths', () => {
+  assert.deepEqual(
+    extractSedReadTargets('sed -n 620,700p /abs/proj/backend/app/services/market.py'),
+    ['/abs/proj/backend/app/services/market.py']);
+  assert.deepEqual(
+    extractSedReadTargets("sed -n '230,310p' backend/app/services/tushare.py"),
+    ['backend/app/services/tushare.py']);
+});
+
+test('extractSedReadTargets: multiple segments in one command, deduped', () => {
+  const cmd = 'sed -n 60,200p src/a.py; echo ===; sed -n 250,300p src/b.py && sed -n 250,300p src/b.py';
+  assert.deepEqual(extractSedReadTargets(cmd), ['src/a.py', 'src/b.py']);
+});
+
+test('extractSedReadTargets: non-range sed (substitution) ignored', () => {
+  assert.deepEqual(extractSedReadTargets("sed -i 's/a/b/' src/a.py"), []);
+  assert.deepEqual(extractSedReadTargets('sed -n /pattern/p src/a.py'), []);
+});
+
+test('extractSedReadTargets: pipeline sed after grep still extracted', () => {
+  assert.deepEqual(
+    extractSedReadTargets('grep -n "x" src/a.py | sed -n 1,5p src/b.py'),
+    ['src/b.py']);
+});

package/claude-plugin/scripts/pre-read-guide.js

@@ -27,6 +27,8 @@ const path = require('path');
 const crypto = require('crypto');
 const { cgTmpDir } = require('./tmp-dir');
 const { recordRecommendation } = require('./recommendation-log');
+const { resolveProjectRoot } = require('./project-root');
+const { runOverviewAnswer } = require('./cg-answer');
 
 // --- Configuration ---
 
@@ -119,50 +121,87 @@ function buildHint(dir) {
   return `[code-graph] 5+ Reads into ${dir}/ — \`code-graph-mcp overview ${dir}/\` gives symbols+callers in one call (MCP: \`module_overview path=${dir}\`). Skip if you need raw file contents.`;
 }
 
+// v0.49 — the hint DELIVERS the overview instead of advising a tool call
+// (advice measured 0/40 transfer on 2026-06-12; delivered answers satisfied
+// 5/5 in place). Falls back to the advice-only line when the CLI is
+// unavailable or the dir has no overview.
+function buildHintWithAnswer(dir, answer) {
+  const lines = [
+    `[code-graph] 5+ Reads into ${dir}/ — module overview from the AST index (saves the remaining file-by-file reads):`,
+    answer.text,
+  ];
+  if (answer.truncated) {
+    lines.push(`(truncated — \`code-graph-mcp overview ${dir}/\` for the full map)`);
+  }
+  return lines.join('\n');
+}
+
 function isSilenced(env = process.env) {
   return env.CODE_GRAPH_QUIET_HOOKS === '1';
 }
 
+// v0.49 — answer tier opt-out, shared name with the grep hook's deny-answer
+// opt-out: =1 restores advice-only hints (no CLI run inside the hook).
+function isAnswerDisabled(env = process.env) {
+  return env.CODE_GRAPH_NO_ANSWER_IN_DENY === '1';
+}
+
+// --- Shared tracking core (also driven by pre-grep-guide's sed-range path) ---
+
+/// Record one read of `rel` (project-root-relative source path) and fire the
+/// fanout hint when the threshold crosses. Emits to stdout + records the
+/// recommendation. Returns true when a hint fired.
+function trackReadAndMaybeHint(root, rel, now = Date.now()) {
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return false;
+  const dir = path.dirname(rel);
+  if (!dir || dir === '.' || dir === '') return false;  // top-level file: not fanout
+
+  const state = loadState(root, now);
+  recordRead(state, dir, now);
+  let fired = false;
+  if (shouldHint(state, dir, now)) {
+    markHint(state, dir, now);
+    fired = true;
+  }
+  saveState(root, state);
+  if (!fired) return false;
+
+  let answer = { status: 'unavailable' };
+  if (!isAnswerDisabled()) {
+    answer = runOverviewAnswer({ cwd: root, dir });
+  }
+  const answered = answer.status === 'hits';
+  recordRecommendation(root, { hook: 'read', action: 'hint', answered });
+  process.stdout.write((answered ? buildHintWithAnswer(dir, answer) : buildHint(dir)) + '\n');
+  return true;
+}
+
 // --- Main execution ---
 
 function runMain() {
   if (isSilenced()) return;
-  const cwd = process.cwd();
-  const dbPath = path.join(cwd, '.code-graph', 'index.db');
-  if (!fs.existsSync(dbPath)) return;
+  // v0.49 — walk up from the shell cwd (subdir-cwd fix; the read hook had
+  // recorded NOTHING in daagu history because sessions sat in backend/).
+  const root = resolveProjectRoot(process.cwd());
+  if (root === null) return;
 
   let input;
   try {
-    input = JSON.parse(fs.readFileSync('/dev/stdin', 'utf8'));
+    // fd 0, not '/dev/stdin': the path form fails ENXIO on socketpair stdin.
+    input = JSON.parse(fs.readFileSync(0, 'utf8'));
   } catch { return; }
 
   const filePath = (input.tool_input && input.tool_input.file_path) || '';
   if (!isSourceFile(filePath)) return;
 
-  // Normalize to a cwd-relative path. If the file is outside cwd, skip —
-  // a hint pointing at an unrelated dir helps no one.
+  // Normalize to a root-relative path. Read sends absolute paths; files
+  // outside the project (other repos, ~/.claude/) stay silent.
   let rel;
   try {
-    rel = path.relative(cwd, filePath);
+    rel = path.relative(root, filePath);
   } catch { return; }
-  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return;
-
-  const dir = path.dirname(rel);
-  if (!dir || dir === '.' || dir === '') return;  // top-level file: not fanout
 
-  const now = Date.now();
-  const state = loadState(cwd, now);
-  recordRead(state, dir, now);
-  let fired = false;
-  if (shouldHint(state, dir, now)) {
-    markHint(state, dir, now);
-    fired = true;
-  }
-  saveState(cwd, state);
-  if (fired) {
-    recordRecommendation(cwd, { hook: 'read', action: 'hint' });
-    process.stdout.write(buildHint(dir) + '\n');
-  }
+  trackReadAndMaybeHint(root, rel);
 }
 
 if (require.main === module) {
@@ -172,6 +211,7 @@ if (require.main === module) {
 module.exports = {
   isSourceFile, dirOf, cwdHash, statePath,
   loadState, saveState, recordRead, shouldHint, markHint,
-  buildHint, isSilenced,
+  buildHint, buildHintWithAnswer, isSilenced, isAnswerDisabled,
+  trackReadAndMaybeHint,   // v0.49 — shared with pre-grep-guide's sed-range path
   FANOUT_THRESHOLD, COOLDOWN_MS, STATE_TTL_MS, SRC_EXT,
 };

package/claude-plugin/scripts/pre-read-guide.test.js

@@ -8,7 +8,8 @@ const crypto = require('crypto');
 
 const {
   isSourceFile, dirOf, recordRead, shouldHint, markHint,
-  buildHint, isSilenced,
+  buildHint, buildHintWithAnswer, isSilenced, isAnswerDisabled,
+  trackReadAndMaybeHint,
   FANOUT_THRESHOLD, COOLDOWN_MS, STATE_TTL_MS,
   loadState, saveState, statePath,
 } = require('./pre-read-guide');
@@ -243,3 +244,60 @@ test('flow: 5 reads to same dir → hint, 6th read same dir → no hint (cooldow
   recordRead(s, 'src/foo', 1005);
   assert.equal(shouldHint(s, 'src/foo', 1005), false);
 });
+
+// ── v0.49: answer-in-hint + shared tracking core ─────────────────────
+
+test('buildHintWithAnswer: embeds overview text and truncation pointer', () => {
+  const out = buildHintWithAnswer('src/storage', { text: 'Module src/storage\n  conn (57 callers)', truncated: true });
+  assert.match(out, /^\[code-graph\] 5\+ Reads into src\/storage\//);
+  assert.match(out, /conn \(57 callers\)/);
+  assert.match(out, /truncated — `code-graph-mcp overview src\/storage\/`/);
+});
+
+test('isAnswerDisabled: CODE_GRAPH_NO_ANSWER_IN_DENY=1 → advice-only hints', () => {
+  assert.equal(isAnswerDisabled({ CODE_GRAPH_NO_ANSWER_IN_DENY: '1' }), true);
+  assert.equal(isAnswerDisabled({}), false);
+});
+
+test('trackReadAndMaybeHint: fires on 5th read with stubbed overview answer', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'readfan-track-'));
+  // Stub CLI: prints a fake overview (hook resolves binary via _CG_ANSWER_BINARY).
+  const stub = path.join(root, 'stub.js');
+  fs.writeFileSync(stub, '#!/usr/bin/env node\nprocess.stdout.write("Module overview stub: 3 symbols\\n");');
+  fs.chmodSync(stub, 0o755);
+  const oldEnv = process.env._CG_ANSWER_BINARY;
+  process.env._CG_ANSWER_BINARY = stub;
+  // .code-graph present so recordRecommendation appends.
+  fs.mkdirSync(path.join(root, '.code-graph'), { recursive: true });
+
+  const written = [];
+  const origWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = (chunk) => { written.push(String(chunk)); return true; };
+  try {
+    let fired = false;
+    for (let i = 0; i < 5; i++) {
+      fired = trackReadAndMaybeHint(root, 'src/storage/file' + i + '.rs');
+    }
+    assert.equal(fired, true, '5th same-dir read must fire');
+    assert.match(written.join(''), /Module overview stub/, 'hint must EMBED the overview answer');
+    const recs = fs.readFileSync(path.join(root, '.code-graph', 'recommendations.jsonl'), 'utf8');
+    assert.match(recs, /"hook":"read"/);
+    assert.match(recs, /"answered":true/);
+  } finally {
+    process.stdout.write = origWrite;
+    if (oldEnv === undefined) delete process.env._CG_ANSWER_BINARY;
+    else process.env._CG_ANSWER_BINARY = oldEnv;
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('trackReadAndMaybeHint: top-level and outside-root paths never fire', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'readfan-skip-'));
+  try {
+    assert.equal(trackReadAndMaybeHint(root, 'main.rs'), false);
+    assert.equal(trackReadAndMaybeHint(root, '../other/file.rs'), false);
+    assert.equal(trackReadAndMaybeHint(root, '/abs/file.rs'), false);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

package/claude-plugin/scripts/project-root.js

@@ -0,0 +1,30 @@
+'use strict';
+// Shared project-root resolution for the PreToolUse hooks (v0.49 — extracted
+// from pre-grep-guide so pre-read-guide gets the same subdir-cwd fix without a
+// circular require).
+//
+// The hook's process.cwd() follows the PERSISTENT shell, not the project root:
+// after the model runs `cd backend/`, every per-cwd gate (index.db existence,
+// relative-path matching) fails silently for the rest of the session (daagu
+// 2026-06-11: 38/40 head-greps dark; the read hook never recorded AT ALL).
+// Walk up to the nearest ancestor holding `.code-graph/index.db`; stop at
+// $HOME (checked, not crossed) and fs root.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function resolveProjectRoot(startDir, opts = {}) {
+  const home = opts.home !== undefined ? opts.home : os.homedir();
+  const exists = opts.exists || fs.existsSync;
+  let dir = path.resolve(startDir || '.');
+  for (;;) {
+    if (exists(path.join(dir, '.code-graph', 'index.db'))) return dir;
+    if (dir === home) return null;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+module.exports = { resolveProjectRoot };

package/claude-plugin/templates/plugin_code_graph_mcp.md

@@ -38,6 +38,11 @@ type: reference
 
 ## 何时调用 MCP/CLI（替代多步 Grep/Read）
 
+> **v0.49 起 CLI 优先**：Claude Code 里 MCP 工具是 deferred（首次调用前要
+> ToolSearch 加载），而 Bash 永远在线——真实编程夜（2026-06-12）观测到的全部
+> 转化都是 CLI 调用。结构化查询的最快路径是 Bash 直呼
+> `code-graph-mcp callgraph X / show X / overview <dir> / grep "pat" / impact X`。
+>
 > v0.10.0 起：tools/list 默认只暴露 7 个核心工具；下表"进阶 5"中的工具
 > 已从 tools/list 隐藏以节省 session 启动 tokens。**Claude Code 里请走 CLI
 > 子命令**（MCP schema 不在 list，Claude Code 的 ToolSearch 不会加载，直接

package/package.json

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