@sdsrs/code-graph 0.85.2 → 0.85.4

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

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

package/claude-plugin/scripts/doctor.js

@@ -496,10 +496,21 @@ function runRepairs(results) {
       case 'hooks-invalid': {
         console.log('\n  Repairing hooks...');
         if (relicRepairGuard()) break;
-        const { install } = require('./lifecycle');
+        const { install, scanForBrokenPaths } = require('./lifecycle');
         install();
-        console.log('  \u2705 Hooks repaired \u2014 restart Claude Code to apply');
-        fixed++;
+        // Diagnosis already ran install()+re-scan and the paths were STILL
+        // broken (that `repaired:false` is what raised hooks-invalid). Verify
+        // this second attempt actually cleared them before counting it fixed \u2014
+        // a blind fixed++ here would let doctor exit 0 ("healthy") while the
+        // hook paths stay broken.
+        const remaining = scanForBrokenPaths();
+        if (remaining.length === 0) {
+          console.log('  \u2705 Hooks repaired \u2014 restart Claude Code to apply');
+          fixed++;
+        } else {
+          console.log(`  \u274c ${remaining.length} hook path(s) still invalid \u2014 plugin scripts may be missing.`);
+          console.log('     Reinstall: npm install -g @sdsrs/code-graph  (or re-run the plugin installer)');
+        }
         break;
       }
 
@@ -532,25 +543,43 @@ function runRepairs(results) {
 
 // ── Main ──────────────────────────────────────────────────
 
+// Exit status for a doctor run reflects what remains BROKEN, not what was found:
+//   --check-only → every found issue is unresolved (report cleanliness, no repair).
+//   repair mode  → issueCount minus what runRepairs resolved. A run that fixes
+//                  everything ("N/N addressed") reports 0 so `doctor && …` and
+//                  self-heal automation don't read a successful repair as a
+//                  failure. runRepairs counts an issue fixed only when its repair
+//                  reports success — and the hooks arm re-scans after install() to
+//                  confirm, so a still-broken re-scan is NOT counted (stays
+//                  unresolved → exit 1). An issue with no working repair
+//                  (schema-mismatch is advisory only) likewise keeps this > 0.
+function unresolvedCount({ checkOnly, issueCount, fixed }) {
+  return checkOnly ? issueCount : issueCount - fixed;
+}
+
 function runDoctor(opts = {}) {
   const results = runDiagnostics();
   console.log(formatReport(results, { checkOnly: opts.checkOnly }));
 
   const issues = results.filter(r => r.status === 'warn' || r.status === 'error');
 
+  let fixed = 0;
   if (issues.length > 0 && !opts.checkOnly) {
-    const fixed = runRepairs(results);
+    fixed = runRepairs(results);
     console.log(`\n  ${fixed}/${issues.length} issue(s) addressed.`);
   }
 
-  return { results, issueCount: issues.length };
+  const unresolved = unresolvedCount({
+    checkOnly: opts.checkOnly, issueCount: issues.length, fixed,
+  });
+  return { results, issueCount: issues.length, unresolved };
 }
 
-module.exports = { runDiagnostics, formatReport, runRepairs, runDoctor, surveyHookCoverage, relicRepairGuard, classifyEmbeddings, detectEmbedModel, devBuildCommand };
+module.exports = { runDiagnostics, formatReport, runRepairs, runDoctor, unresolvedCount, surveyHookCoverage, relicRepairGuard, classifyEmbeddings, detectEmbedModel, devBuildCommand };
 
 if (require.main === module) {
   const args = process.argv.slice(2);
   const checkOnly = args.includes('--check-only');
-  const { issueCount } = runDoctor({ checkOnly });
-  process.exit(issueCount > 0 ? 1 : 0);
+  const { unresolved } = runDoctor({ checkOnly });
+  process.exit(unresolved > 0 ? 1 : 0);
 }

package/claude-plugin/scripts/doctor.test.js

@@ -165,3 +165,51 @@ test('detectEmbedModel reads model_available from `health-check --json`; probe f
   // no binary → null
   assert.equal(detectEmbedModel(null), null);
 });
+
+test('unresolvedCount: repair mode exits 0 iff every found issue was fixed', () => {
+  const { unresolvedCount } = require('./doctor');
+  // Clean run — nothing found.
+  assert.equal(unresolvedCount({ checkOnly: false, issueCount: 0, fixed: 0 }), 0);
+  // Repair fixed everything ("N/N addressed") → 0, so `doctor && …` and
+  // self-heal automation don't read a successful repair as failure. This is
+  // the regression this contract guards: previously exited 1 on any issue found.
+  assert.equal(unresolvedCount({ checkOnly: false, issueCount: 3, fixed: 3 }), 0);
+  // Partial repair → the remainder is unresolved (nonzero → exit 1).
+  assert.equal(unresolvedCount({ checkOnly: false, issueCount: 3, fixed: 1 }), 2);
+  // Advisory-only issue with no working auto-repair (fixed stays 0) → unresolved.
+  assert.equal(unresolvedCount({ checkOnly: false, issueCount: 1, fixed: 0 }), 1);
+});
+
+test('unresolvedCount: --check-only reports every found issue (never repairs)', () => {
+  const { unresolvedCount } = require('./doctor');
+  // check-only performs no repair, so fixed is 0; a found issue must still
+  // surface as unresolved (exit 1) — check mode reports cleanliness.
+  assert.equal(unresolvedCount({ checkOnly: true, issueCount: 2, fixed: 0 }), 2);
+  assert.equal(unresolvedCount({ checkOnly: true, issueCount: 0, fixed: 0 }), 0);
+});
+
+test('runRepairs: hooks-invalid counts fixed only when the post-install re-scan is clean', () => {
+  // hooks-invalid is raised only after diagnosis already ran install()+re-scan
+  // and paths were STILL broken. The repair arm must re-verify, else it reports
+  // a false exit 0 ("healthy") while the hooks stay broken. Stub the lifecycle
+  // deps runRepairs pulls via require('./lifecycle') on the shared cached export
+  // object; restore in finally so no other test sees the stubs.
+  const { runRepairs } = require('./doctor');
+  const lc = require('./lifecycle');
+  const orig = { install: lc.install, scan: lc.scanForBrokenPaths, relic: lc.isStaleRelicContext };
+  const hooksInvalid = [{ name: 'Hooks', status: 'warn', fixId: 'hooks-invalid' }];
+  try {
+    lc.isStaleRelicContext = () => false;   // not a relic → repair proceeds
+    lc.install = () => {};                    // install() that cannot restore the paths
+    // Re-scan still broken → must NOT count as fixed (old code did fixed++ blindly).
+    lc.scanForBrokenPaths = () => [{ type: 'hook', event: 'PreToolUse:Edit', path: '/gone.js' }];
+    assert.equal(runRepairs(hooksInvalid), 0, 'still-broken after install must not count as fixed');
+    // Re-scan clean → the repair took effect → counts as fixed.
+    lc.scanForBrokenPaths = () => [];
+    assert.equal(runRepairs(hooksInvalid), 1, 'verified-clean after install counts as fixed');
+  } finally {
+    lc.install = orig.install;
+    lc.scanForBrokenPaths = orig.scan;
+    lc.isStaleRelicContext = orig.relic;
+  }
+});

package/claude-plugin/scripts/lifecycle.js

@@ -983,8 +983,10 @@ if (require.main === module) {
   } else if (cmd === 'doctor') {
     const { runDoctor } = require('./doctor');
     const checkOnly = process.argv.includes('--check-only');
-    const { issueCount } = runDoctor({ checkOnly });
-    process.exit(issueCount > 0 ? 1 : 0);
+    // Exit on issues that remain UNRESOLVED after repair, not issues found —
+    // a run that fixes everything exits 0. See unresolvedCount in doctor.js.
+    const { unresolved } = runDoctor({ checkOnly });
+    process.exit(unresolved > 0 ? 1 : 0);
   } else if (cmd === 'verify-hooks-fire') {
     // v0.67.0 — Layer-A firing self-test. Spawned detached by session-init
     // (off the SessionStart budget); writes a small state file the next

package/package.json

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