@sdsrs/code-graph 0.162.0 → 0.163.0

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

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

package/claude-plugin/scripts/session-edits.js

@@ -9,7 +9,9 @@
 //
 //   .cg-edits-<cwdHash>-<sid>.jsonl  one line per Edit call: {ts, file, symbol[, sigs]}
 //   .cg-stop-<cwdHash>-<sid>.json    written by the Stop hook only:
-//                                    {lastStopAt, reported: ["file#symbol", …]}
+//                                    {lastStopAt, reported: ["file#symbol", …],
+//                                     pending?: {at, files: […]}} — the last
+//                                    report's caller files, until its follow-up
 //
 // The edit log is APPEND-only: parallel Edit calls each run their own hook
 // process, and a read-modify-write JSON file would drop one of two concurrent
@@ -108,10 +110,15 @@ function readStopState(root, sessionId) {
   if (!p) return empty;
   try {
     const s = JSON.parse(fs.readFileSync(p, 'utf8'));
-    return {
+    const out = {
       lastStopAt: typeof s.lastStopAt === 'number' ? s.lastStopAt : null,
       reported: Array.isArray(s.reported) ? s.reported.filter((x) => typeof x === 'string') : [],
     };
+    const p2 = s.pending;
+    if (p2 && typeof p2.at === 'number' && Array.isArray(p2.files)) {
+      out.pending = { at: p2.at, files: p2.files.filter((x) => typeof x === 'string') };
+    }
+    return out;
   } catch { return empty; }
 }
 

package/claude-plugin/scripts/stop-impact.js

@@ -291,6 +291,7 @@ function computeStopReport({ edits, state, now, workText, callers, mtimeMs }) {
   }
 
   const lines = [];
+  const listed = new Set();
   for (const c of changed.slice(0, MAX_SYMBOLS_CHECKED)) {
     const refs = callers(c.symbol, c.file);
     if (!refs || refs.length === 0) continue;
@@ -318,6 +319,7 @@ function computeStopReport({ edits, state, now, workText, callers, mtimeMs }) {
     }
     lines.push(line);
     next.reported.push(c.key);
+    for (const r of untouched) listed.add(r.file);
   }
   // Changed beyond the query cap: named, not dropped in silence (review M1).
   // Not marked reported, and a later turn does not see them as changed again
@@ -327,7 +329,54 @@ function computeStopReport({ edits, state, now, workText, callers, mtimeMs }) {
     lines.push('  ' + unchecked.length + ' more changed, callers not checked: ' +
       unchecked.map((c) => shellQuoteArg(c.symbol) + '() in ' + shellQuoteArg(c.file)).join(', '));
   }
-  return { lines, state: next };
+  // `symbols` / `files`: what the report names, for its telemetry and its
+  // follow-up (D#163). Not part of `state`.
+  return { lines, state: next, symbols: next.reported.length - state.reported.length, files: [...listed].sort() };
+}
+
+// The follow-up remembers at most this many of a report's caller files.
+const MAX_FOLLOWUP_FILES = 64;
+
+/**
+ * What a report leaves behind (D#163): the `stop_check` record — for every
+ * report the model is shown, the one made only of the "more changed, callers
+ * not checked" line included — and the follow-up to judge at the next Stop,
+ * only when the report named caller files. `callers` counts every caller file
+ * the report found, the ones past the text's per-symbol cap included.
+ * @param {{lines:string[], state:{lastStopAt:number}, symbols?:number, files?:string[]}} report
+ * @returns {{check: object|null, pending: {at:number, files:string[]}|null}}
+ */
+function reportRecords(report) {
+  if (!report.lines.length) return { check: null, pending: null };
+  const files = report.files || [];
+  return {
+    check: { hook: 'stop', action: 'stop_check', symbols: report.symbols || 0, callers: files.length },
+    pending: files.length ? { at: report.state.lastStopAt, files: files.slice(0, MAX_FOLLOWUP_FILES) } : null,
+  };
+}
+
+/**
+ * Whether a report was acted on: a caller file it listed was edited after it —
+ * an Edit logged since `pending.at`, or an mtime at or after it (Write, `sed
+ * -i`, formatters; the same reading as "touched this turn"). Judged at the
+ * next Stop, which is the end of the continuation the feedback starts.
+ * @param {{at:number, files:string[]}} pending  left in the Stop state by the report
+ * @param {{ts:number, file:string}[]} edits  the session's edit log
+ * @param {(file:string)=>number|null} mtimeMs
+ * @returns {{adopted:boolean, listed:number, edited:number}}
+ */
+function followUpOf(pending, edits, mtimeMs) {
+  const listed = new Set(pending.files);
+  const edited = new Set();
+  for (const e of edits) {
+    if (e.ts >= pending.at && listed.has(e.file)) edited.add(e.file);
+  }
+  for (const f of listed) {
+    if (edited.has(f)) continue;
+    const m = mtimeMs(f);
+    if (m !== null && m >= pending.at) edited.add(f);
+  }
+  return { adopted: edited.size > 0, listed: listed.size, edited: edited.size };
 }
 
 function formatStopContext(lines) {
@@ -350,17 +399,32 @@ function readStdinJson() {
 function runMain() {
   if (process.env.CODE_GRAPH_QUIET_HOOKS === '1') return;
   const input = readStdinJson();
-  if (!input || input.stop_hook_active === true) return;
-  if (!input.session_id) return;
+  if (!input || !input.session_id) return;
 
   const { resolveProjectRoot } = require('./project-root');
   const root = resolveProjectRoot(typeof input.cwd === 'string' && input.cwd ? input.cwd : process.cwd());
   if (root === null) return;
 
   const sessionEdits = require('./session-edits');
+  const { recordRecommendation } = require('./recommendation-log');
+  const mtimeMs = (file) => {
+    try { return fs.statSync(path.join(root, file)).mtimeMs; } catch { return null; }
+  };
+  const state = sessionEdits.readStopState(root, input.session_id);
+  // The previous report's follow-up (D#163), at every Stop — the one ending
+  // the continuation that report started included. It only records: nothing
+  // is emitted, so a continuation cannot loop through it.
+  if (state.pending) {
+    const f = followUpOf(state.pending, sessionEdits.readEdits(root, input.session_id), mtimeMs);
+    recordRecommendation(root, { hook: 'stop', action: 'stop_followup', ...f });
+    delete state.pending;
+    sessionEdits.writeStopState(root, input.session_id, state);
+  }
+  // A continuation caused by a Stop hook is never re-checked.
+  if (input.stop_hook_active === true) return;
+
   const edits = sessionEdits.readEdits(root, input.session_id);
   if (edits.length === 0) return; // no log → nothing to check, and nothing written
-  const state = sessionEdits.readStopState(root, input.session_id);
 
   const { remainingMs } = require('./hook-fail-open');
   const run = (cmd, args, defaultMs) => {
@@ -410,11 +474,12 @@ function runMain() {
             return { file: r.file_path, name: r.name, line: findCallSiteLine(text, symbol, r.start_line) };
           });
       },
-      mtimeMs: (file) => {
-        try { return fs.statSync(path.join(root, file)).mtimeMs; } catch { return null; }
-      },
+      mtimeMs,
     });
   }
+  const rec = reportRecords(report);
+  if (rec.check) recordRecommendation(root, rec.check);
+  if (rec.pending) report.state.pending = rec.pending;
   sessionEdits.writeStopState(root, input.session_id, report.state);
 
   const text = formatStopContext(report.lines);
@@ -427,5 +492,5 @@ if (require.main === module) runMain();
 
 module.exports = {
   extractSignatures, signatureChanged, findCallSiteLine, computeStopReport, formatStopContext,
-  MAX_SYMBOLS_CHECKED, MAX_CALLERS_LISTED,
+  followUpOf, reportRecords, MAX_SYMBOLS_CHECKED, MAX_CALLERS_LISTED, MAX_FOLLOWUP_FILES,
 };

package/claude-plugin/scripts/subagent-start.js

@@ -88,6 +88,14 @@ function runMain() {
   if (!text) return;
   const { emitEventContext } = require('./hook-emit');
   process.stdout.write(emitEventContext('SubagentStart', text) + '\n');
+  // D#163: how many subagents were handed the facts. Whether they then used
+  // the index is in their transcripts, not here (scripts/subagent_share.py).
+  // The agent type is harness input; only a plain name is kept.
+  const agent = typeof input.agent_type === 'string' && /^[\w:.-]{1,64}$/.test(input.agent_type)
+    ? input.agent_type : null;
+  require('./recommendation-log').recordRecommendation(root, {
+    hook: 'subagent', action: 'subagent_context', ...(agent ? { agent } : {}),
+  });
 }
 
 if (require.main === module) runMain();

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.162.0 code-graph-mcp snapshot create --out snapshot.db
+          npx -y -p @sdsrs/code-graph@0.163.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.162.0",
+  "version": "0.163.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.162.0",
-    "@sdsrs/code-graph-linux-arm64": "0.162.0",
-    "@sdsrs/code-graph-darwin-x64": "0.162.0",
-    "@sdsrs/code-graph-darwin-arm64": "0.162.0",
-    "@sdsrs/code-graph-win32-x64": "0.162.0"
+    "@sdsrs/code-graph-linux-x64": "0.163.0",
+    "@sdsrs/code-graph-linux-arm64": "0.163.0",
+    "@sdsrs/code-graph-darwin-x64": "0.163.0",
+    "@sdsrs/code-graph-darwin-arm64": "0.163.0",
+    "@sdsrs/code-graph-win32-x64": "0.163.0"
   }
 }