contextspin 0.6.0 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "contextspin",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Replace Claude Code spinner/statusline text with live org context (meetings, Slack, CI, incidents, PRs) aggregated from your existing MCP servers, CLIs, and HTTP endpoints.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -25,7 +25,11 @@ import {
   isDaemonRunning,
   readCache,
 } from './daemon.js';
-import { installStatusline, uninstallStatusline } from './inject/statusline.js';
+import {
+  installStatusline,
+  uninstallStatusline,
+  uninstallAllStatuslines,
+} from './inject/statusline.js';
 import { installPatcher, restorePatcher } from './inject/patcher.js';
 import { detectSources } from './detect.js';
 
@@ -580,13 +584,21 @@ async function runInstall() {
  */
 async function runUninstall() {
   const removedHook = removeSessionStartHook();
-  await uninstallStatusline({});
+  // Tear down EVERY scope we wired (user + each project the hook touched), not
+  // just the user scope — otherwise project-scoped wirings keep rendering.
+  const results = await uninstallAllStatuslines();
+  const removed = results.filter((r) => r && r.removed);
   await stopDaemon();
   console.log(
-    removedHook
-      ? 'ContextSpin uninstalled (hook removed, statusline restored, daemon stopped).'
-      : 'ContextSpin hook not found; statusline restored and daemon stopped.',
+    `ContextSpin uninstalled: removed the statusline from ${removed.length} ` +
+      `scope${removed.length === 1 ? '' : 's'}, ` +
+      `${removedHook ? 'dropped the SessionStart hook, ' : ''}stopped the daemon.`,
   );
+  const projectScopes = removed.filter((r) => r.scope === 'project');
+  if (projectScopes.length > 0) {
+    console.log('Cleaned project statuslines:');
+    for (const r of projectScopes) console.log(`  ${r.settingsPath}`);
+  }
 }
 
 /**

package/src/config.js

@@ -47,6 +47,16 @@ export const STATUSLINE_JS = path.join(STATE_DIR, "statusline-render.js");
  */
 export const PREV_STATUSLINE_PATH = path.join(STATE_DIR, "prev-statusline.json");
 
+/**
+ * Path to the registry of every settings file ContextSpin has wired its
+ * statusLine into. A JSON array of scope KEYS ("" for the user scope, else an
+ * absolute realpath'd project dir). `installStatusline` appends to it; a full
+ * `uninstall` walks it so EVERY scope is torn down — not just the user scope.
+ * Without this, project-scoped wirings (written by the SessionStart hook per
+ * CLAUDE_PROJECT_DIR) would linger after uninstall.
+ */
+export const WIRED_STATUSLINES_PATH = path.join(STATE_DIR, "wired-statuslines.json");
+
 /** Path to Claude Code's settings file (patched by the statusline injector). */
 export const CLAUDE_SETTINGS_PATH = path.join(HOME, ".claude", "settings.json");
 

package/src/daemon.js

@@ -5,7 +5,7 @@ import fsp from "node:fs/promises";
 import process from "node:process";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { CACHE_PATH, STATE_DIR, PID_PATH, LOG_PATH, loadConfig } from "./config.js";
+import { CACHE_PATH, STATE_DIR, PID_PATH, LOG_PATH, loadConfig, configExists } from "./config.js";
 import { runSource } from "./runner.js";
 
 /**
@@ -187,6 +187,15 @@ export async function runDaemonLoop(opts = {}) {
   const runtime = { lastRun: {}, buckets: {}, snippets: [] };
   // eslint-disable-next-line no-constant-condition
   while (true) {
+    // Self-exit if the config has been deleted (e.g. the user ran
+    // `contextspin uninstall` or removed ~/.contextspin.json by hand). Without
+    // this the daemon would keep polling stale sources and writing the cache
+    // forever, so the statusline would still show text after a teardown.
+    if (!configExists(opts.configPath)) {
+      console.log("contextspin config removed — daemon shutting down.");
+      shutdown();
+      return;
+    }
     try {
       const snippets = await pollOnce(config, runtime);
       await writeCache({ updatedAt: nowISO(), snippets });

package/src/inject/statusline.js

@@ -33,6 +33,7 @@ import {
   CONFIG_PATH,
   CLAUDE_SETTINGS_PATH,
   DEFAULT_SNIPPETS,
+  WIRED_STATUSLINES_PATH,
 } from "../config.js";
 
 /**
@@ -460,6 +461,29 @@ async function writePrevMap(map) {
   await writeJsonAtomic(PREV_STATUSLINE_PATH, map);
 }
 
+/**
+ * Read the wired-statuslines registry: an array of scope KEYS ("" for user
+ * scope, else an absolute project dir). Tolerates a missing/bad file (-> []).
+ * @returns {string[]}
+ */
+function readWiredList() {
+  const raw = readJsonSafeSync(WIRED_STATUSLINES_PATH, null);
+  return Array.isArray(raw) ? raw.filter((k) => typeof k === "string") : [];
+}
+
+/**
+ * Record a scope KEY in the wired-statuslines registry (idempotent).
+ * @param {string} key - "" for user scope, else an absolute project dir.
+ * @returns {Promise<void>}
+ */
+async function addWired(key) {
+  const list = readWiredList();
+  if (!list.includes(key)) {
+    list.push(key);
+    await writeJsonAtomic(WIRED_STATUSLINES_PATH, list);
+  }
+}
+
 /**
  * Resolve the statusLine command currently configured in a settings file (if
  * any), ignoring our own wrapper. Returns null when the file has no usable
@@ -625,6 +649,10 @@ export async function installStatusline(config, opts = {}) {
 
   await writeJsonAtomic(targetPath, settingsObj);
 
+  // Record this scope in the wired registry so a later `uninstall` can tear down
+  // EVERY scope we touched (not just the user scope).
+  await addWired(key);
+
   if (composed) {
     const priorCmd = prior ? prior.command : (map[key] && map[key].command);
     warning =
@@ -772,3 +800,42 @@ export async function uninstallStatusline(opts = {}) {
     note: "Removed the ContextSpin statusLine entry.",
   };
 }
+
+/**
+ * Tear down EVERY statusline scope ContextSpin has wired, by walking the wired
+ * registry (plus the user scope, always). This is what a full `uninstall` should
+ * call: project-scoped wirings written by the SessionStart hook (one per
+ * CLAUDE_PROJECT_DIR) are otherwise invisible to a user-scope-only uninstall and
+ * would keep rendering the ContextSpin line after removal.
+ *
+ * Clears the registry when done. Never throws — a failure for one scope is
+ * captured in that scope's result and the walk continues.
+ *
+ * @returns {Promise<UninstallStatuslineResult[]>}
+ */
+export async function uninstallAllStatuslines() {
+  // Always include the user scope (""), plus every recorded project key.
+  const keys = Array.from(new Set(["", ...readWiredList()]));
+  const results = [];
+  for (const key of keys) {
+    const projectDir = key === "" ? undefined : key;
+    try {
+      results.push(await uninstallStatusline({ projectDir }));
+    } catch (err) {
+      results.push({
+        removed: false,
+        restored: false,
+        settingsPath: key,
+        scope: projectDir ? "project" : "user",
+        note: `failed: ${err && err.message ? err.message : String(err)}`,
+      });
+    }
+  }
+  // Registry is consumed — drop it.
+  try {
+    await fsp.unlink(WIRED_STATUSLINES_PATH);
+  } catch {
+    // best effort
+  }
+  return results;
+}