@sdsrs/code-graph 0.116.0 → 0.117.0

package/claude-plugin/scripts/doctor.js

@@ -215,6 +215,10 @@ function runHealthCheckCli(binary) {
   return execFileSync(binary, ['health-check', '--json'], hidden({
     cwd: process.cwd(),
     timeout: 5000,
+    // Same shape statusline.js hardened (audit P1-17): a wedged binary that
+    // ignores SIGTERM makes Node's timeout unreachable, so doctor — the tool
+    // you run BECAUSE something is wrong — would hang instead of diagnosing.
+    killSignal: 'SIGKILL',
     encoding: 'utf8',
     stdio: ['pipe', 'pipe', 'pipe'],
   })).trim();
@@ -676,6 +680,52 @@ function binaryVersionResolved({
   return Boolean(actual) && actual === pluginVersion();
 }
 
+/**
+ * Mirror of BOTH `binary-broken` diagnoses: the binary is on disk but does not
+ * run (runDiagnostics step 2, `--version` unreadable) or its health-check failed
+ * with no recoverable payload (healthRows' last arm). Re-asks the same two
+ * questions the diagnosis asked, so "resolved" cannot mean something weaker than
+ * "not raised". Cache dropped first: the promote happens in a CHILD process and
+ * find-binary memoizes.
+ */
+function binaryBrokenResolved({
+  find = findBinary, readVersion = readBinaryVersion, rows = healthRows,
+} = {}) {
+  clearBinaryCache();
+  const binary = find();
+  if (!binary) return false;
+  if (!readVersion(binary)) return false;
+  try {
+    return !rows(binary).some((r) => r.fixId === 'binary-broken');
+  } catch { return false; }
+}
+
+/**
+ * Build the binary in the source checkout. Injectable for the same reason
+ * rebuildIndexInPlace is: `execSync` is destructured at load, so a test that
+ * patches child_process afterwards would silently run a real 10-minute cargo
+ * build. Returns true on exit 0; throws what the build threw.
+ */
+function buildBinaryFromSource(cmd) {
+  execSync(cmd, hidden({
+    cwd: path.resolve(__dirname, '..', '..'),
+    stdio: 'inherit',
+    timeout: 600000,  // embed-model (Candle) builds exceed the old 5min
+  }));
+  clearBinaryCache();
+  return true;
+}
+
+/** Manual recovery for a binary we could not repair — the end of every failed arm. */
+function printBinaryRecovery() {
+  console.log('     Reinstall: npm install -g @sdsrs/code-graph');
+  console.log('     Or download the release asset for your platform:');
+  console.log('       https://github.com/sdsrss/code-graph-mcp/releases');
+  if (os.platform() === 'darwin') {
+    console.log('     macOS may also have quarantined it: xattr -d com.apple.quarantine <binary>');
+  }
+}
+
 /** Mirror of the `update-incomplete` diagnosis (runDiagnostics step 5). */
 function updateIncompleteResolved({ readStateFile = readUpdateState } = {}) {
   const state = readStateFile();
@@ -770,6 +820,8 @@ function runRepairs(results, {
   updateResolved = updateIncompleteResolved,
   integrityOk = integrityResolved,
   rebuildIndex = rebuildIndexInPlace,
+  binaryUsable = binaryBrokenResolved,
+  buildBinary = buildBinaryFromSource,
 } = {}) {
   const fixable = results.filter(r => r.fixId);
   if (fixable.length === 0) return 0;
@@ -851,6 +903,63 @@ function runRepairs(results, {
         break;
       }
 
+      case 'binary-broken': {
+        // The binary EXISTS but cannot run: a truncated or corrupted download, a
+        // wrong-arch asset, a missing libc, macOS quarantine, or a real crash.
+        // This fixId had no arm at all, so doctor printed "1 issue(s) found.
+        // Fixing..." and then "0/1 addressed" with nothing between the two
+        // (audit 2026-08-16 P1-13).
+        if (devMode()) {
+          // A source checkout is never repaired by downloading a release asset.
+          // Preserve the feature set for the same reason the binary-stale arm
+          // does — never silently downgrade a hybrid dev binary to FTS5-only.
+          const embed = detectEmbedModel(findBinary());
+          const buildCmd = devBuildCommand(embed === true);
+          console.log('\n  Binary is present but does not run — rebuilding from source...');
+          if (embed === null) {
+            console.log('    (could not probe the current feature set — building FTS5-only;');
+            console.log('     for semantic search rebuild with `cargo build --release --features embed-model`)');
+          }
+          console.log(`    → ${buildCmd}`);
+          try {
+            if (!buildBinary(buildCmd)) {
+              console.log('  ❌ Build failed');
+              break;
+            }
+          } catch {
+            console.log('  ❌ Build failed');
+            break;
+          }
+        } else {
+          console.log('\n  Binary is present but does not run — re-downloading it...');
+          try {
+            // The updater's stale-binary self-heal treats an unreadable
+            // `--version` as "replace it", so this reaches the verified
+            // download+promote path even without a newer release.
+            runAutoUpdate();
+          } catch {
+            console.log('  ❌ Update check failed');
+            printBinaryRecovery();
+            break;
+          }
+        }
+        // Exit 0 proves the command ran, not that the binary works. Ask it.
+        if (binaryUsable()) {
+          console.log('  ✅ Binary runs again');
+          fixed++;
+        } else {
+          console.log('  ❌ The binary still cannot run');
+          if (!devMode()) {
+            const why = autoUpdateNoOpReason();
+            if (why) console.log(`     Why the re-download may have done nothing: ${why}.`);
+            printBinaryRecovery();
+          } else {
+            console.log('     The build completed but the produced binary still fails --version/health-check.');
+          }
+        }
+        break;
+      }
+
       case 'binary-not-exec': {
         const binary = findBinary();
         if (binary) {
@@ -1048,7 +1157,7 @@ function runDoctor(opts = {}) {
   return { results, issueCount: issues.length, unresolved };
 }
 
-module.exports = { runDiagnostics, formatReport, runRepairs, runDoctor, runDoctorCli, parseDoctorArgs, unresolvedCount, surveyHookCoverage, relicRepairGuard, classifyEmbeddings, classifyIntegrity, classifyHealthReport, parseHealthPayload, integrityResolved, healthRows, detectEmbedModel, devBuildCommand, binaryVersionResolved, updateIncompleteResolved, autoUpdateNoOpReason };
+module.exports = { runDiagnostics, formatReport, runRepairs, runDoctor, runDoctorCli, parseDoctorArgs, unresolvedCount, surveyHookCoverage, relicRepairGuard, classifyEmbeddings, classifyIntegrity, classifyHealthReport, parseHealthPayload, integrityResolved, healthRows, detectEmbedModel, devBuildCommand, binaryVersionResolved, updateIncompleteResolved, binaryBrokenResolved, autoUpdateNoOpReason };
 
 // Shared by BOTH doctor entry points: `node doctor.js …` and `node lifecycle.js
 // doctor …`. It exists as one function because the first version of this guard

package/claude-plugin/scripts/hook-emit.js

@@ -5,22 +5,50 @@
 // post-grep-inject) cannot drift apart (feedback_hook_class_bug_sweep — no
 // inline copies of shared logic). DRY mirror of the project-root.js precedent.
 //
-// Why these two shapes:
+// Why these three shapes:
 //   - PreToolUse plain stdout on exit 0 goes to the DEBUG LOG ONLY — it never
 //     reaches the model (CC docs, code.claude.com/docs/en/hooks.md, v2026-06).
-//     `additionalContext` DOES reach the model, but only alongside a
-//     permissionDecision. For the safe-tool pre hooks (Read fanout hint, Edit
-//     impact summary) the elevation to `allow` is negligible and is what makes
-//     the carried context visible.
+//     `additionalContext` is what surfaces the carried text.
+//   - `permissionDecision: 'allow'` is NOT a delivery detail. The CC hooks
+//     reference defines it as: "skip the interactive permission prompt" (deny
+//     rules and connector/`requiresUserInteraction` prompts still apply). On a
+//     machine that prompts for a tool, a hook sending `allow` has answered the
+//     user's prompt for them. That is defensible for READ-ONLY Read; it is not
+//     for Edit, which writes to disk — a delivery hook must never buy context
+//     visibility with the user's write consent (audit 2026-08-16 P0-2).
+//     Therefore: `emitPreToolAllowContext` is for Read ONLY, and every
+//     write-capable tool uses `emitPreToolContext` (no decision at all, which
+//     the docs' own PreToolUse example marks as "no decision; normal permission
+//     flow applies"). If a future CC drops additionalContext without a decision,
+//     the correct outcome is that the Edit impact summary goes quiet — NOT that
+//     it re-acquires the elevation.
 //   - PostToolUse honors `additionalContext` permission-neutrally (no
 //     permissionDecision), so the Bash-side grep answer can be injected without
 //     skipping CC's default permission prompt for the underlying tool call.
 
+/**
+ * PreToolUse additionalContext envelope with NO permissionDecision (string, no
+ * trailing newline). The permission-neutral shape: the tool's normal permission
+ * flow is untouched. Use this for every write-capable tool (Edit/Write/…).
+ * @param {string} text
+ * @returns {string} JSON line
+ */
+function emitPreToolContext(text) {
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      additionalContext: text,
+    },
+  });
+}
+
 /**
  * PreToolUse allow + additionalContext envelope (string, no trailing newline).
- * Used by the safe-tool delivery hooks (pre-read-guide / pre-edit-guide) so
- * their carried hint/impact text reaches the model instead of dying in the
- * debug log.
+ *
+ * READ-ONLY TOOLS ONLY (pre-read-guide). `allow` skips the user's interactive
+ * permission prompt; for Read that grants nothing the model could not already
+ * get, and it is what keeps the fanout hint visible. Do not reuse it for a tool
+ * that mutates state — see the note above.
  * @param {string} text
  * @returns {string} JSON line
  */
@@ -50,4 +78,4 @@ function emitPostToolContext(text) {
   });
 }
 
-module.exports = { emitPreToolAllowContext, emitPostToolContext };
+module.exports = { emitPreToolContext, emitPreToolAllowContext, emitPostToolContext };

package/claude-plugin/scripts/lifecycle.js

@@ -57,7 +57,15 @@ function pluginsCacheDir() { return path.join(claudeHome(), 'plugins', 'cache');
 // unparseable case and left the unreadable one behind — a `chmod 000`
 // settings.json was still destroyed, silently, with no backup. `err.code` is the
 // whole gate; do not widen it back to a bare `catch`.
-function readJsonResult(filePath) {
+// `accept` decides what counts as a USABLE parsed value. It defaults to the
+// settings shape (a plain object) but the statusline registry is a top-level
+// ARRAY, which the default predicate calls corrupt — so the registry gets
+// `accept: Array.isArray` rather than a second, drifting copy of this function.
+function isSettingsObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readJsonResult(filePath, { accept = isSettingsObject } = {}) {
   // Read BYTES, decode separately. `readFileSync(p, 'utf8')` replaces every
   // invalid byte with U+FFFD, and `raw` is what backupCorruptFile writes to the
   // `.corrupt-*` copy before the original is overwritten — so a settings.json
@@ -88,7 +96,7 @@ function readJsonResult(filePath) {
     const value = JSON.parse(raw.trim());
     // `null` / `"str"` / `[]` parse fine but are not a settings object; treating
     // them as "absent" would rebuild over them just the same.
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    if (!accept(value)) {
       return { value: null, missing: false, corrupt: true, raw: bytes };
     }
     // VALID JSON can still have been decoded lossily. `toString('utf8')`
@@ -247,9 +255,25 @@ function readManifest() {
   return readJson(MANIFEST_FILE) || { version: null, config: {} };
 }
 
+// Same tolerant shape as tryWriteSettings, and for the same reason: this is the
+// one write in install()/update() that could still throw. `~/.cache` on a
+// read-only mount, a root-owned cache dir left by a `sudo` run, or a full disk
+// turned a SessionStart into a raw ENOSPC/EACCES stack trace out of a hook whose
+// settings work had already SUCCEEDED (audit 2026-08-16 P1-16). Report it,
+// change nothing else, and let the caller decide.
+// @returns {Error|null} the write error, or null on success
 function writeManifest(manifest) {
-  fs.mkdirSync(CACHE_DIR, { recursive: true });
-  writeJsonAtomic(MANIFEST_FILE, manifest);
+  try {
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
+    writeJsonAtomic(MANIFEST_FILE, manifest);
+    return null;
+  } catch (err) {
+    console.error(
+      `[code-graph] cannot write ${MANIFEST_FILE} (${err.code || err.name}: ${err.message}). ` +
+      'Settings changes (if any) still applied; the next run will redo the version stamp.'
+    );
+    return err;
+  }
 }
 
 function getPluginVersion() {
@@ -325,17 +349,63 @@ function isOurComposite(settings) {
 // --- StatusLine Registry ---
 // Multiple providers can register. The composite script runs them all.
 
-function readRegistry() {
-  const primary = readJson(REGISTRY_FILE);
-  if (primary && Array.isArray(primary) && primary.length > 0) return primary;
+// Read the registry for a caller that may WRITE it back.
+//
+// The registry is USER DATA: `_previous` is the statusline they had before we
+// installed (the only record of it), and third-party providers registered
+// through us live beside it. The lenient reader collapsed "exists but
+// unreadable/corrupt" into the same `[]` as "absent", and the very next
+// writeRegistry() then persisted that empty list over the primary AND the
+// durable backup — one `chmod 000` (a stray sudo, a restrictive umask) and the
+// user's original statusline was unrecoverable, silently, from a call that
+// reported success (audit 2026-08-16 P1-12). Exactly the settings.json bug
+// readJsonResult was written for, on the file two functions below it.
+//
+// Returns `{ registry, refuse }`:
+//   registry — entries to work with (possibly empty)
+//   refuse   — a copy EXISTS and could not be read: write nothing, change nothing
+function readRegistryForWrite() {
+  const asArray = { accept: Array.isArray };
+  const primary = readJsonResult(REGISTRY_FILE, asArray);
+  if (primary.value && primary.value.length > 0) return { registry: primary.value, refuse: false };
+  if (primary.corrupt) {
+    // Fall through to the backup for READING (so callers still see the user's
+    // providers) but never write while the primary is unusable: an atomic
+    // rename replaces an unreadable file just fine, which is precisely how the
+    // data was lost.
+    const backup = readJsonResult(providersBackupFile(), asArray);
+    return {
+      registry: backup.value && backup.value.length > 0 ? backup.value : [],
+      refuse: true,
+      why: `${REGISTRY_FILE} exists but cannot be read as a provider list`,
+    };
+  }
   // Self-heal: primary missing or empty (e.g. user cleaned ~/.cache/code-graph/).
   // Durable backup in ~/.claude/ retains `_previous` + third-party providers.
-  const backup = readJson(providersBackupFile());
-  if (backup && Array.isArray(backup) && backup.length > 0) {
-    try { writeJsonAtomic(REGISTRY_FILE, backup); } catch { /* ok */ }
-    return backup;
+  const backup = readJsonResult(providersBackupFile(), asArray);
+  if (backup.value && backup.value.length > 0) {
+    try { writeJsonAtomic(REGISTRY_FILE, backup.value); } catch { /* ok */ }
+    return { registry: backup.value, refuse: false };
   }
-  return [];
+  if (backup.corrupt) {
+    return { registry: [], refuse: true, why: `${providersBackupFile()} exists but cannot be read as a provider list` };
+  }
+  return { registry: [], refuse: false };
+}
+
+function readRegistry() {
+  return readRegistryForWrite().registry;
+}
+
+// One place to say why a registry mutation did nothing. Stderr, not silence:
+// the caller returns `false`, which is indistinguishable from "already
+// registered" to everything upstream.
+function warnRegistryUnusable(action, why) {
+  console.error(
+    `[code-graph] ${why}. Skipping the statusline ${action} — rewriting it would ` +
+    'destroy your previous statusline and any third-party provider entries. ' +
+    'Repair or move the file aside and re-run.'
+  );
 }
 
 function writeRegistry(registry) {
@@ -351,7 +421,11 @@ function writeRegistry(registry) {
 }
 
 function registerStatuslineProvider(id, command, needsStdin) {
-  const registry = readRegistry();
+  const { registry, refuse, why } = readRegistryForWrite();
+  if (refuse) {
+    warnRegistryUnusable('registration', why);
+    return false;
+  }
   const idx = registry.findIndex(p => p.id === id);
   const entry = { id, command, needsStdin: !!needsStdin };
   if (idx >= 0) {
@@ -366,7 +440,11 @@ function registerStatuslineProvider(id, command, needsStdin) {
 }
 
 function unregisterStatuslineProvider(id) {
-  const registry = readRegistry();
+  const { registry, refuse, why } = readRegistryForWrite();
+  if (refuse) {
+    warnRegistryUnusable('removal', why);
+    return false;
+  }
   const filtered = registry.filter(p => p.id !== id);
   if (filtered.length === registry.length) return false;
   writeRegistry(filtered);
@@ -389,11 +467,37 @@ function isPluginInactive(settings = readJson(settingsPath()) || {}) {
   return !hasInstalledPluginRecord();
 }
 
-function detachStatuslineIntegration(settings, { compositeDoomed = true } = {}) {
+function detachStatuslineIntegration(settings, { compositeDoomed = true, oneShot = false } = {}) {
   let settingsChanged = false;
 
-  unregisterStatuslineProvider('code-graph');
-  const registry = readRegistry();
+  // An unusable (not merely absent) registry means we may not WRITE it, and it
+  // may leave us unable to tell whether a `_previous` or third-party entry
+  // exists — which every branch below that rewrites `settings.statusLine`
+  // depends on (batch review of audit 2026-08-16 P1-12: the register path
+  // refused correctly while this detach path still destroyed the slot).
+  //
+  // Whether refusing is safe depends on the CALLER, so it is a parameter:
+  //   retryable (statusline render) — leave everything alone; the next frame
+  //     retries once the file is usable. Touching the slot on a bad read is
+  //     how the user's statusline got destroyed in the first place.
+  //   oneShot (uninstall) — the composite script dies with the plugin cache in
+  //     this same run, so leaving the slot pointing at it is PERMANENT
+  //     breakage with no plugin code left to repair it (pre-tag review). We
+  //     still must not write the registry, but the entries we already READ are
+  //     enough to choose the slot: `readRegistryForWrite` reads through to the
+  //     durable backup even while refusing, so a corrupt primary alone does
+  //     not lose `_previous`. When even that is unreadable the list is empty
+  //     and we clear the slot — Claude Code's default beats a dead path.
+  const { registry, refuse, why } = readRegistryForWrite();
+  if (refuse && !oneShot) {
+    warnRegistryUnusable('detach', why);
+    return false;
+  }
+  if (refuse) {
+    warnRegistryUnusable('registry rewrite (the settings slot is still neutralized — uninstall cannot retry)', why);
+  } else {
+    unregisterStatuslineProvider('code-graph');
+  }
   const previous = registry.find(p => p.id === '_previous' && p.command);
   // Third-party providers registered through our registry (e.g. gsd). They
   // must not be silently orphaned: with the composite gone from settings
@@ -422,8 +526,9 @@ function detachStatuslineIntegration(settings, { compositeDoomed = true } = {})
   }
 
   // _previous only becomes removable once no third party still relies on the
-  // registry file (writeRegistry unlinks primary+backup when emptied).
-  if (thirdParty.length === 0) unregisterStatuslineProvider('_previous');
+  // registry file (writeRegistry unlinks primary+backup when emptied). Skipped
+  // entirely while refusing: that path may not write the registry at all.
+  if (!refuse && thirdParty.length === 0) unregisterStatuslineProvider('_previous');
   return settingsChanged;
 }
 
@@ -1061,13 +1166,17 @@ function install({ reclaimStatusline = false } = {}) {
   manifest.version = version;
   manifest.installedAt = manifest.installedAt || new Date().toISOString();
   manifest.updatedAt = new Date().toISOString();
-  writeManifest(manifest);
+  const manifestErr = writeManifest(manifest);
 
   return {
     version,
     settingsChanged,
     statusLineClaimed: manifest.config.statusLine,
     hooksRegistered,
+    // Unstamped manifest: the install DID land in settings.json, but the next
+    // run will not know it and will redo the work (idempotent). Surfaced so
+    // doctor/session-init can say so instead of implying a clean install.
+    manifestUnwritable: manifestErr ? (manifestErr.code || manifestErr.name) : undefined,
     // Non-null => the previous settings.json was REPLACED and lives here now.
     settingsRebuiltFrom: backedUpTo,
   };
@@ -1109,7 +1218,10 @@ function uninstall({ purgeGlobal = false, unadoptAll = false, runNpm = defaultRu
 
   if (settings) {
     // 1. StatusLine: remove code-graph integration and restore prior statusline.
-    if (detachStatuslineIntegration(settings)) {
+    // `oneShot`: steps 6-7 below delete the plugin cache, taking
+    // statusline-composite.js with it, so this is the last chance to move the
+    // slot off a script that is about to stop existing (pre-tag review).
+    if (detachStatuslineIntegration(settings, { oneShot: true })) {
       settingsChanged = true;
     }
 
@@ -1136,7 +1248,16 @@ function uninstall({ purgeGlobal = false, unadoptAll = false, runNpm = defaultRu
   }
 
   // 5. Remove all known IDs from installed_plugins.json
-  const installedPlugins = readJson(installedPluginsPath());
+  //
+  // Read-modify-write of Claude Code's OWN file. The write is already gated on a
+  // successful parse, so an unusable file is skipped rather than clobbered (the
+  // destructive `|| {}` shape never existed here) — but the skip was SILENT, and
+  // steps 6-7 below still delete the plugin cache. The user then keeps a plugin
+  // record pointing at a directory we removed, with `uninstall` reporting
+  // success. Say so instead (audit 2026-08-16 P1-12 sweep).
+  const installedRead = readJsonResult(installedPluginsPath());
+  const installedPlugins = installedRead.value;
+  let installedPluginsUnusable = false;
   if (installedPlugins && installedPlugins.plugins) {
     let ipChanged = false;
     for (const id of [PLUGIN_ID, ...OLD_PLUGIN_IDS]) {
@@ -1145,7 +1266,24 @@ function uninstall({ purgeGlobal = false, unadoptAll = false, runNpm = defaultRu
         ipChanged = true;
       }
     }
-    if (ipChanged) writeJsonAtomic(installedPluginsPath(), installedPlugins);
+    if (ipChanged) {
+      try {
+        writeJsonAtomic(installedPluginsPath(), installedPlugins);
+      } catch (err) {
+        installedPluginsUnusable = true;
+        console.error(
+          `[code-graph] cannot write ${installedPluginsPath()} (${err.code || err.name}). ` +
+          'Claude Code still lists this plugin — remove it with `/plugin uninstall code-graph-mcp`.'
+        );
+      }
+    }
+  } else if (!installedRead.missing) {
+    installedPluginsUnusable = true;
+    console.error(
+      `[code-graph] cannot read ${installedPluginsPath()} ` +
+      `(${installedRead.error ? installedRead.error.code || installedRead.error.message : 'not a JSON object'}). ` +
+      'Left untouched — Claude Code may still list this plugin; remove it with `/plugin uninstall code-graph-mcp`.'
+    );
   }
 
   // 5.5. Global npm packages + adoption inventory — read BEFORE step 6 wipes
@@ -1208,7 +1346,7 @@ function uninstall({ purgeGlobal = false, unadoptAll = false, runNpm = defaultRu
     try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ok */ }
   }
 
-  return { settingsChanged, pluginInstalledGlobals, globalPkgsRemoved, globalPkgsRemaining, adoptedProjects, unadopted };
+  return { settingsChanged, pluginInstalledGlobals, globalPkgsRemoved, globalPkgsRemaining, adoptedProjects, unadopted, installedPluginsUnusable };
 }
 
 // --- Update (refresh config points) ---
@@ -1270,7 +1408,7 @@ function update() {
   // 6. Update manifest
   manifest.version = version;
   manifest.updatedAt = new Date().toISOString();
-  writeManifest(manifest);
+  const manifestErr = writeManifest(manifest);
 
   // 7. Clean up old cached versions (keep the newest few). NOTE: older cache
   //    dirs are NOT always inert — a running MCP server's launcher path
@@ -1280,7 +1418,10 @@ function update() {
   //    therefore skips any version still referenced by a live process cmdline.
   cleanupOldCacheVersions(5);
 
-  return { oldVersion, version, settingsChanged, hooksRegistered, settingsRebuiltFrom: backedUpTo };
+  return {
+    oldVersion, version, settingsChanged, hooksRegistered, settingsRebuiltFrom: backedUpTo,
+    manifestUnwritable: manifestErr ? (manifestErr.code || manifestErr.name) : undefined,
+  };
 }
 
 /**
@@ -1528,7 +1669,7 @@ module.exports = {
   isPluginExplicitlyDisabled, isPluginInactive, isPluginUninstalled, removeCacheResidue,
   cleanupDisabledStatusline,
   readManifest, readJson, readJsonResult, readSettingsForWrite, writeJsonAtomic,
-  readRegistry, writeRegistry,
+  readRegistry, readRegistryForWrite, writeRegistry,
   getPluginVersion, cleanupOldCacheVersions,
   removeHooksFromSettings, isOurHookEntry,
   registerHooksToSettings, buildSettingsHookEntries,                  // v0.32.0
@@ -1540,7 +1681,7 @@ module.exports = {
   activeInstallPath, isStaleRelicContext,                              // v0.49.1 — stale-relic downgrade guard
   SETTINGS_HOOK_DESC, OUR_HOOK_SCRIPTS, OUR_DESCRIPTIONS,              // v0.32.0 — for tests
   PLUGIN_ROOT,                                                         // v0.32.1 — for tests / consumers
-  registerStatuslineProvider, unregisterStatuslineProvider,
+  registerStatuslineProvider, unregisterStatuslineProvider, detachStatuslineIntegration,
   installedGlobalPkgs, GLOBAL_INSTALL_MARKER, INSTALL_LOCK_FILE, SHELL_PKG,   // uninstall residue
   PLUGIN_ID, OLD_PLUGIN_IDS, MARKETPLACE_NAME, CACHE_DIR, REGISTRY_FILE,
   settingsPath, installedPluginsPath, providersBackupFile, pluginsCacheDir,

package/claude-plugin/scripts/pr-impact-comment.js

@@ -124,11 +124,20 @@ function computeReview(binary, changedFiles, cwd) {
   // Per-file test-gap: a changed PRODUCTION (non-test) file is "uncovered" when
   // running `affected` on it alone surfaces zero test files. Run per-file so the
   // signal is attributable (the aggregate union can't be split back per file).
+  //
+  // `runAffected` returns null for BOTH "spawn failed / timed out / non-zero
+  // exit" and "unparseable output" — none of which say anything about test
+  // coverage. Those files go to `unanalyzed` and are disclosed. Folding them
+  // into the same else-branch as "has tests" made a 60s timeout render as a
+  // covered file: the most dangerous direction for a test-gap report to fail in.
   const uncovered = [];
+  const unanalyzed = [];
   for (const f of changed) {
     if (isTestPath(f)) continue;
     const single = runAffected(binary, ['affected', f, '--json'], cwd, '');
-    if (single && (single.tests || []).length === 0) {
+    if (!single) {
+      unanalyzed.push(f);
+    } else if ((single.tests || []).length === 0) {
       uncovered.push(f);
     }
   }
@@ -145,6 +154,7 @@ function computeReview(binary, changedFiles, cwd) {
     blast_radius: affectedFiles.length,
     top_affected: topAffected,
     uncovered: uncovered.sort(),
+    unanalyzed: unanalyzed.sort(),
   };
 }
 
@@ -177,6 +187,16 @@ function renderMarkdown(review) {
     lines.push('');
   }
 
+  // Absence of a result is not a result. These files are listed apart from the
+  // test gaps because the analysis never produced an answer for them.
+  const unanalyzed = review.unanalyzed || [];
+  if (unanalyzed.length > 0) {
+    lines.push(`### ❔ Not analyzed (${unanalyzed.length})`);
+    lines.push('The `affected` run for these files failed or timed out, so their test coverage is unknown:');
+    for (const p of unanalyzed) lines.push(`- \`${p}\``);
+    lines.push('');
+  }
+
   if (review.tests.length > 0) {
     lines.push('<details><summary>Tests to re-run</summary>', '');
     for (const t of review.tests) lines.push(`- \`${t}\``);
@@ -265,11 +285,23 @@ function main(argv) {
     process.stdout.write(body + '\n');
   }
 
+  const unanalyzed = review.unanalyzed || [];
+  if (unanalyzed.length > 0) {
+    console.error(`[pr-impact] ${unanalyzed.length} changed file(s) could not be analyzed: ${unanalyzed.join(', ')}`);
+  }
+
   const failOnRisk = /^(1|true|yes)$/i.test(process.env.CODE_GRAPH_FAIL_ON_RISK || '');
   if (failOnRisk && review.uncovered.length > 0) {
     console.error(`[pr-impact] fail-on-risk: ${review.uncovered.length} changed file(s) have no covering test.`);
     process.exit(1);
   }
+  // A file the analyzer never answered for is unmeasured risk, not cleared
+  // risk: under an explicit fail-on-risk gate it blocks like a test gap does,
+  // with its own message so the two causes stay distinguishable in CI logs.
+  if (failOnRisk && unanalyzed.length > 0) {
+    console.error(`[pr-impact] fail-on-risk: ${unanalyzed.length} changed file(s) could not be analyzed.`);
+    process.exit(1);
+  }
 }
 
 if (require.main === module) {

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

@@ -14,7 +14,7 @@ const { cgTmpDir, cwdHash } = require('./tmp-dir');
 const { resolveProjectRoot } = require('./project-root');
 const { recordRecommendation } = require('./recommendation-log');
 const { formatCoveringTests } = require('./covering-tests');
-const { emitPreToolAllowContext } = require('./hook-emit');
+const { emitPreToolContext } = require('./hook-emit');
 const { hidden } = require('./proc-opts');
 
 // v0.49 — walk up from the shell cwd (subdir-cwd fix). The per-cwd index.db
@@ -217,10 +217,18 @@ summary += formatCoveringTests(jsonResult.test_callers, editedFile);
 // fire with the count alone — the verdict must stay coherent either way.
 summary += `  → Before this edit: confirm each caller of ${symbol}() still holds with your change, or note why it is unaffected.\n`;
 
-// Compound-grep sibling sweep: deliver via the PreToolUse allow+additionalContext
-// envelope (shared hook-emit.js). Bare stdout on a PreToolUse exit-0 lands in the
-// debug log only and never reaches the model (CC docs v2026-06); additionalContext
-// is what actually surfaces the impact summary. Impact must stay PRE-edit (so the
-// reconciliation happens before the change), hence allow + additionalContext, not
-// a PostToolUse inject.
-process.stdout.write(emitPreToolAllowContext(summary) + '\n');
+// Deliver via the PERMISSION-NEUTRAL PreToolUse additionalContext envelope
+// (shared hook-emit.js). Bare stdout on a PreToolUse exit-0 lands in the debug
+// log only and never reaches the model (CC docs v2026-06); additionalContext is
+// what surfaces the impact summary, and it is delivered without any
+// permissionDecision — the tool's normal permission flow is untouched.
+//
+// It used to send `permissionDecision: 'allow'` alongside it. That is documented
+// as "skip the interactive permission prompt", so on a machine that prompts for
+// Edit this hook silently answered that prompt for the user, for every symbol
+// with >=1 caller outside the 2-minute cooldown (audit 2026-08-16 P0-2). Context
+// delivery is never worth a write consent: if a future CC requires a decision to
+// carry additionalContext, this summary goes quiet rather than elevating again.
+// Impact must stay PRE-edit (the reconciliation happens before the change), so a
+// PostToolUse inject is not an alternative here.
+process.stdout.write(emitPreToolContext(summary) + '\n');

package/claude-plugin/scripts/proc-opts.js

@@ -16,6 +16,21 @@
  * ALLOCATING a console — inherited stdio handles still work, so an interactive
  * `doctor` run in a real terminal is unaffected. No-op on non-Windows.
  *
+ * `killSignal` is deliberately NOT defaulted here. Node's `timeout` option
+ * sends SIGTERM and then WAITS, so a child that traps SIGTERM makes the
+ * timeout unreachable (audit 2026-08-16 P1-17: one deaf third-party statusline
+ * provider blanked the status line on every frame). The two statusline call
+ * sites pass `killSignal: 'SIGKILL'` themselves — they run UNTRUSTED provider
+ * commands / a possibly-wedged binary on the render hot path, and nothing
+ * there shuts down gracefully at timeout anyway. It is not a global default
+ * because our other timed children DO need SIGTERM's grace: a timed-out
+ * `git pull` hard-killed mid-write leaves `.git/index.lock` behind and every
+ * later marketplace refresh then fails silently; npm has equivalent lock
+ * files (batch review of the P1-17 fix). New call sites that run untrusted or
+ * hang-prone children with a timeout should opt in the same way.
+ * (Caveat SIGKILL does not fix: it reaches the direct child only. A grandchild
+ * holding the same stdout pipe can still stall a *Sync call until it exits.)
+ *
  * Every child_process call site under claude-plugin/scripts/ must route through
  * here (or set windowsHide itself); `windows-hide.test.js` fails the build on a
  * new call site that doesn't.