@sdsrs/code-graph 0.134.0 → 0.135.0

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

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

package/claude-plugin/scripts/cg-answer.js

@@ -105,11 +105,41 @@ function resolveAnswerBinary(opts) {
   return binary || null;
 }
 
-/** One spawn, one options block, one `CODE_GRAPH_INTERNAL` stamp. */
+/**
+ * One spawn, one options block, one `CODE_GRAPH_INTERNAL` stamp.
+ *
+ * The timeout is the SMALLER of this call's own budget and whatever is left of
+ * the hook process's registered budget, because the callers run these in
+ * series: post-grep-inject loops callgraph over every symbol in the pattern
+ * before falling back to show and then grep, so three 2 s answers overran a 5 s
+ * hook and Claude Code killed it — which the user sees as a hook error on their
+ * own tool call, not as a missing hint (audit 2026-09-05 JS-03). Out of budget
+ * returns a synthetic timeout the exit-code table already reads as
+ * `unavailable`, so the caller degrades to the static path exactly as it does
+ * for a real timeout.
+ *
+ * `killSignal: 'SIGKILL'`: the child we are giving up on is most often one
+ * wedged waiting on `index.lock`, and node's `timeout` sends SIGTERM and then
+ * WAITS. It reads no stdin and holds no lock file worth unwinding — the same
+ * reasoning statusline.js and doctor.js already apply (see proc-opts.js).
+ */
 function runCg(binary, args, { cwd, timeoutMs }) {
+  const budget = require('./hook-fail-open').remainingMs(timeoutMs);
+  if (budget === null) {
+    // `error` is what classifyRun reads (→ `unavailable`); `budgetExhausted` is
+    // for the one caller that loops and must not mistake this for "that symbol
+    // did not resolve" — see runShowAnswer.
+    return {
+      error: new Error('hook budget exhausted'),
+      budgetExhausted: true,
+      status: null,
+      stdout: '',
+    };
+  }
   return spawnSync(binary, args, hidden({
     cwd,
-    timeout: timeoutMs,
+    timeout: budget,
+    killSignal: 'SIGKILL',
     encoding: 'utf8',
     maxBuffer: 4 * 1024 * 1024,
     stdio: ['ignore', 'pipe', 'ignore'],
@@ -230,6 +260,15 @@ function runShowAnswer(opts = {}) {
     for (const sym of symbols.slice(0, 3)) {
       if (typeof sym !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(sym)) continue;
       const res = runCg(binary, ['show', sym], { cwd, timeoutMs });
+      // Out of hook budget is not "this symbol did not resolve". This loop
+      // `continue`s past every failure and reports `no-hits` when none of the
+      // three produced output, so without this arm an exhausted budget reached
+      // recordRecommendation as a genuine empty result — and the whole reason
+      // `no-binary` is kept distinct from `unavailable` (see this function's
+      // docs) is that the deny funnel has to tell those causes apart. Nothing
+      // later in the loop can succeed either: the budget is gone for all three
+      // (pre-ship review 2026-09-05).
+      if (res.budgetExhausted) return { status: 'unavailable' };
       // A symbol that did not resolve is SKIPPED, not fatal — exit 1 included,
       // which is why this asks for `exitOneIsNoHits: false` and then treats
       // every non-`ok` verdict the same way.

package/claude-plugin/scripts/hook-fail-open.js

@@ -19,7 +19,87 @@
 //
 // EPIPE is silent by design. It means the consumer closed the pipe — Claude
 // Code moved on, or a `| head` upstream exited. There is nobody left to tell.
+// The budget Claude Code kills each hook at, in SECONDS — the single source for
+// both halves of that contract: `lifecycle.js` registers these numbers into
+// settings.json, and `remainingMs` below spends against them. `hooks.test.js`
+// pins both registration sites to this table so a bump in one cannot drift from
+// the other.
+//
+// `session-init.js` is here for its REGISTRATION only. It is registered from
+// `claude-plugin/hooks/hooks.json` (SessionStart is the one event Claude Code
+// loads from plugin-cache), it predates `installHookFailOpen` and wraps its own
+// main in a try/catch, so nothing arms a deadline for it and none of its six
+// child spawns clamp — 15.5 s of serial timeouts against the 5 s below. That is
+// the largest overrun of the seven and it is NOT fixed here; pre-ship review
+// 2026-09-05 finding 1, carried in the audit report as NEW-05. Wiring it means
+// deciding, per child, whether an out-of-budget SessionStart should skip a
+// binary health check or a quarantine probe, which is not a mechanical change.
+const HOOK_TIMEOUT_SECONDS = {
+  'pre-edit-guide.js': 4,
+  'pre-grep-guide.js': 3,
+  'pre-read-guide.js': 3,
+  'incremental-index.js': 10,
+  'post-grep-inject.js': 5,
+  'user-prompt-context.js': 5,
+  'session-init.js': 5,
+};
+
+// Left for the hook to render its answer and exit after the last child returns.
+const WRITE_RESERVE_MS = 400;
+
+// Wall-clock instant this process must be finished by, or null when nothing
+// armed one (a hook `require`d by a test, or an unlisted script).
+let deadlineAt = null;
+
+/**
+ * Arm the process deadline from the registered budget of `script`.
+ *
+ * The hooks' internal timeouts were each sized in isolation and run in SERIES:
+ * pre-edit-guide alone could spend 5 × 2000 ms of candidate greps plus 2500 ms
+ * of impact against a 4 s budget, and post-grep-inject looped callgraph over
+ * every symbol in the pattern before its show/grep fallbacks — 2–3× the budget
+ * either way. Nothing enforced the sum, so a binary wedged on `index.lock` got
+ * the hook killed by Claude Code, which surfaces to the user as a hook error on
+ * THEIR tool call (audit 2026-09-05 JS-03).
+ *
+ * `process.uptime()` is subtracted because the budget starts when Claude Code
+ * spawns us, not when this line runs: cold node startup is real time already
+ * spent, and on a loaded machine it is hundreds of milliseconds.
+ */
+function armHookDeadline(script) {
+  const seconds = HOOK_TIMEOUT_SECONDS[script];
+  if (!seconds) return;
+  deadlineAt = Math.floor(Date.now() + seconds * 1000 - process.uptime() * 1000 - WRITE_RESERVE_MS);
+}
+
+/**
+ * How long a child may run: `defaultMs`, or whatever is left of the budget.
+ *
+ * Returns `null` when there is nothing left — meaning DO NOT RUN, not "run
+ * unbounded". Callers must branch on it: node reads `timeout: 0` as no timeout
+ * at all, so a numeric zero here would turn the last child into the unbounded
+ * one, which is the exact failure this exists to prevent.
+ *
+ * Always an INTEGER. `child_process` validates `timeout` with
+ * `validateTimeout` and throws `ERR_OUT_OF_RANGE` on a fraction — and the one
+ * fractional term here (`process.uptime()`) made every spawn throw, which the
+ * runners' own try/catch turned into a silent `unavailable`: the hooks stopped
+ * answering and still exited 0. Caught by pre-grep-guide's e2e suite.
+ */
+function remainingMs(defaultMs) {
+  if (deadlineAt === null) return Math.floor(defaultMs);
+  const left = deadlineAt - Date.now();
+  if (left <= 0) return null;
+  return Math.floor(Math.min(defaultMs, left));
+}
+
+/** Test seam: drop any armed deadline so one test file can't leak into another. */
+function resetHookDeadline() {
+  deadlineAt = null;
+}
+
 function installHookFailOpen(label) {
+  armHookDeadline(require('path').basename(process.argv[1] || ''));
   const bail = (err) => {
     const code = (err && err.code) || (err && err.name) || 'Error';
     if (code !== 'EPIPE') {
@@ -46,4 +126,10 @@ function installHookFailOpen(label) {
   process.on('unhandledRejection', bail);
 }
 
-module.exports = { installHookFailOpen };
+module.exports = {
+  installHookFailOpen,
+  HOOK_TIMEOUT_SECONDS,
+  armHookDeadline,
+  remainingMs,
+  resetHookDeadline,
+};

package/claude-plugin/scripts/lifecycle.js

@@ -142,6 +142,41 @@ function readJson(filePath) {
 /** How many `.corrupt-*` copies of one file to keep. */
 const MAX_CORRUPT_BACKUPS = 5;
 
+/**
+ * Owner-only. What every file this module creates under `~/.claude` gets when
+ * there is no prior file whose bits to preserve, and what a `.corrupt-*` copy
+ * gets unconditionally: settings.json routinely carries an `env` block with API
+ * keys, and a backup of one is the same secret in a second file (audit
+ * 2026-09-05 JS-01).
+ */
+const SECRET_FILE_MODE = 0o600;
+
+/**
+ * Pin `target` at exactly `mode`, because neither route that creates our files
+ * does it on its own: `writeFileSync`'s `mode` option goes to `open(O_CREAT)`
+ * and is masked by umask (and ignored outright when the file already exists),
+ * and `copyFileSync` carries the SOURCE's bits.
+ *
+ * Reported, not swallowed: the whole point of the call is that the file may
+ * hold a key, so a permission we could not set is exactly the thing the user
+ * needs to hear about. The write itself has already succeeded — a failure here
+ * is a disclosure, not a reason to unwind it.
+ */
+function restrictMode(target, mode) {
+  try {
+    fs.chmodSync(target, mode);
+  } catch (err) {
+    // No return value: both call sites act on the stderr line, not on a bool,
+    // and a discarded success flag is an invitation to branch on it later
+    // without noticing that nothing ever did (pre-ship review 2026-09-05).
+    console.error(
+      `[code-graph] wrote ${target} but could not set its permissions to ` +
+      `0${mode.toString(8)} (${err.code || err.name}). If it contains an API key, ` +
+      `it may be readable by other users on this machine.`
+    );
+  }
+}
+
 /**
  * Delete all but the newest `MAX_CORRUPT_BACKUPS` copies of `filePath`.
  *
@@ -180,9 +215,14 @@ function backupCorruptFile(filePath, raw) {
   const dest = `${filePath}.corrupt-${stamp}`;
   try {
     // Buffer, not string: see readJsonResult. A string here would re-encode.
-    if (Buffer.isBuffer(raw)) fs.writeFileSync(dest, raw);
-    else if (typeof raw === 'string') fs.writeFileSync(dest, Buffer.from(raw, 'utf8'));
-    else fs.copyFileSync(filePath, dest);
+    if (Buffer.isBuffer(raw)) fs.writeFileSync(dest, raw, { mode: SECRET_FILE_MODE });
+    else if (typeof raw === 'string') {
+      fs.writeFileSync(dest, Buffer.from(raw, 'utf8'), { mode: SECRET_FILE_MODE });
+    } else fs.copyFileSync(filePath, dest);
+    // Owner-only regardless of what the original was: up to MAX_CORRUPT_BACKUPS
+    // of these accumulate beside settings.json with its `env` block copied
+    // verbatim, so a 0644 original must not mint 0644 duplicates.
+    restrictMode(dest, SECRET_FILE_MODE);
     pruneCorruptBackups(filePath);
     return dest;
   } catch {
@@ -261,11 +301,23 @@ function readSettingsForWrite(pre) {
   return { settings: {}, backedUpTo: backup };
 }
 
+// Replace-by-rename loses the permission bits unless they are carried over
+// deliberately: the new inode is the TMP file's, created under our umask, so a
+// settings.json the user had put at 0600 came back 0644 on the first
+// install()/update()/cleanupDisabledStatusline() — with its `env` API keys in
+// it, silently, on a file we were only meant to add two hook entries to (audit
+// 2026-09-05 JS-01). Stat the original and restore its exact mode; when there
+// is no original, create owner-only rather than at whatever umask says.
 function writeJsonAtomic(filePath, data) {
   const dir = path.dirname(filePath);
   fs.mkdirSync(dir, { recursive: true });
+  let mode = null;
+  try { mode = fs.statSync(filePath).mode & 0o777; } catch { /* new file */ }
   const tmp = filePath + '.tmp.' + process.pid;
-  fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', { mode: mode ?? SECRET_FILE_MODE });
+  // umask can only have cleared bits the original had, so chmod is what makes
+  // this preservation rather than tightening.
+  restrictMode(tmp, mode ?? SECRET_FILE_MODE);
   fs.renameSync(tmp, filePath);
 }
 
@@ -907,7 +959,13 @@ function removeHooksFromSettings(settings) {
 
 function buildSettingsHookEntries() {
   const root = PLUGIN_ROOT;
-  const scriptCmd = (name, timeout) => {
+  // The budget is read from the table the hooks THEMSELVES spend against
+  // (hook-fail-open.js), not written twice: a number registered here that the
+  // hook does not know about is the JS-03 shape — the hook overruns a limit it
+  // cannot see and Claude Code kills it mid-tool-call.
+  const { HOOK_TIMEOUT_SECONDS } = require('./hook-fail-open');
+  const scriptCmd = (name) => {
+    const timeout = HOOK_TIMEOUT_SECONDS[name];
     const script = path.join(root, 'scripts', name);
     // POSIX: existence-guarded. After `/plugin uninstall`, CC may delete the
     // plugin-cache dir before our statusline teardown gets to strip these
@@ -924,16 +982,16 @@ function buildSettingsHookEntries() {
 
   return {
     PreToolUse: [
-      { description: SETTINGS_HOOK_DESC.preToolUse, matcher: 'Edit', hooks: [scriptCmd('pre-edit-guide.js', 4)] },
-      { description: SETTINGS_HOOK_DESC.preToolUse, matcher: 'Bash', hooks: [scriptCmd('pre-grep-guide.js', 3)] },
-      { description: SETTINGS_HOOK_DESC.preToolUse, matcher: 'Read', hooks: [scriptCmd('pre-read-guide.js', 3)] },
+      { description: SETTINGS_HOOK_DESC.preToolUse, matcher: 'Edit', hooks: [scriptCmd('pre-edit-guide.js')] },
+      { description: SETTINGS_HOOK_DESC.preToolUse, matcher: 'Bash', hooks: [scriptCmd('pre-grep-guide.js')] },
+      { description: SETTINGS_HOOK_DESC.preToolUse, matcher: 'Read', hooks: [scriptCmd('pre-read-guide.js')] },
     ],
     PostToolUse: [
-      { description: SETTINGS_HOOK_DESC.postToolUseEdit, matcher: 'Write|Edit', hooks: [scriptCmd('incremental-index.js', 10)] },
-      { description: SETTINGS_HOOK_DESC.postToolUseInject, matcher: 'Bash', hooks: [scriptCmd('post-grep-inject.js', 5)] },
+      { description: SETTINGS_HOOK_DESC.postToolUseEdit, matcher: 'Write|Edit', hooks: [scriptCmd('incremental-index.js')] },
+      { description: SETTINGS_HOOK_DESC.postToolUseInject, matcher: 'Bash', hooks: [scriptCmd('post-grep-inject.js')] },
     ],
     UserPromptSubmit: [
-      { description: SETTINGS_HOOK_DESC.userPromptSubmit, matcher: '', hooks: [scriptCmd('user-prompt-context.js', 5)] },
+      { description: SETTINGS_HOOK_DESC.userPromptSubmit, matcher: '', hooks: [scriptCmd('user-prompt-context.js')] },
     ],
   };
 }

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

@@ -24,6 +24,7 @@ const { recordRecommendation } = require('./recommendation-log');
 const { formatCoveringTests } = require('./covering-tests');
 const { emitPreToolContext } = require('./hook-emit');
 const { hidden } = require('./proc-opts');
+const { remainingMs } = require('./hook-fail-open');
 
 // v0.49 — walk up from the shell cwd (subdir-cwd fix). The per-cwd index.db
 // gate kept this hook dark for entire sessions after `cd backend/` — daagu
@@ -114,10 +115,17 @@ if (!symbol || symbol.length < 3) {
       const candidates = [...new Set(identifiers)]
         .filter(id => !skipWords.has(id.toLowerCase()))
         .sort((a, b) => b.length - a.length);
-      for (const candidate of candidates.slice(0, 5)) {
+      // Two candidates, not five. They are sorted most-specific-first, so the
+      // 3rd–5th were the least likely to resolve AND the ones that pushed this
+      // loop past the hook's whole 4 s budget (5 × 2000 ms here + 2500 ms of
+      // impact below); the impact query they starve is the hook's actual output
+      // (audit 2026-09-05 JS-03).
+      for (const candidate of candidates.slice(0, 2)) {
+        const budget = remainingMs(2000);
+        if (budget === null) break;
         try {
           const raw = execFileSync(binary, ['grep', candidate, filePath, '--json'], hidden({
-            cwd, timeout: 2000, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+            cwd, timeout: budget, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
             env: internalEnv,
           }));
           const grepResult = JSON.parse(raw);
@@ -170,6 +178,11 @@ try {
 const editedFile = (input.tool_input && input.tool_input.file_path) || '';
 const relFile = editedFile ? path.relative(cwd, editedFile) : '';
 let jsonResult;
+// Whatever is left of the registered 4 s, capped at this call's own 2500 ms.
+// `null` = the candidate loop above already spent the budget; running anyway is
+// what got the hook killed by Claude Code mid-Edit (audit 2026-09-05 JS-03).
+const impactBudget = remainingMs(2500);
+if (impactBudget === null) process.exit(0);
 try {
   const args = ['impact', symbol, '--json'];
   if (relFile && !relFile.startsWith('..')) args.push('--file', relFile);
@@ -177,7 +190,7 @@ try {
   // diverging from the findBinary() result the rest of the hook trusts).
   const raw = execFileSync(binary, args, hidden({
     cwd,
-    timeout: 2500,
+    timeout: impactBudget,
     encoding: 'utf8',
     stdio: ['pipe', 'pipe', 'pipe'],
     env: internalEnv,

package/claude-plugin/templates/code-graph-snapshot.yml

@@ -35,7 +35,7 @@ jobs:
           node-version: '20'
       - name: Build snapshot
         run: |
-          npx -y -p @sdsrs/code-graph@0.134.0 code-graph-mcp snapshot create --out snapshot.db
+          npx -y -p @sdsrs/code-graph@0.135.0 code-graph-mcp snapshot create --out snapshot.db
           zstd -9 snapshot.db -o snapshot.db.zst
           mv snapshot.db.zst "code-graph-snapshot-${GITHUB_SHA:0:7}.db.zst"
       - name: Upload to release

package/package.json

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