contextspin 0.1.2 → 0.3.0

package/.contextspin.example.json

@@ -1,55 +1,12 @@
 {
   "sources": [
-    {
-      "type": "mcp",
-      "tool": "slack_search_public",
-      "args": {
-        "query": "mentions:me is:unread"
-      },
-      "format": "Slack: {{ text }}",
-      "label": "Slack",
-      "cooldown": 300,
-      "maxSnippets": 2
-    },
     {
       "type": "cli",
-      "command": "gh pr list --review-requested @me --json title,number --limit 3",
-      "format": "PR #{{ number }} needs your review: {{ title }}",
-      "label": "GitHub",
+      "command": "gh pr list --review-requested @me --json number,title --limit 5",
+      "format": "👀 review #{{ number }}: {{ title }}",
+      "label": "review",
       "cooldown": 120,
       "maxSnippets": 3
-    },
-    {
-      "type": "cli",
-      "command": "gh run list --json status,name,headBranch --limit 5",
-      "filter": "{{ status }} == failure",
-      "format": "CI failing: {{ name }} on {{ headBranch }}",
-      "label": "CI",
-      "cooldown": 60,
-      "maxSnippets": 2
-    },
-    {
-      "type": "mcp",
-      "tool": "notion-search",
-      "args": {
-        "query": "assigned:me status:open"
-      },
-      "format": "Notion: {{ text }}",
-      "label": "Notion",
-      "cooldown": 300,
-      "maxSnippets": 2
-    },
-    {
-      "type": "http",
-      "url": "https://grafana.example.com/api/datasources/proxy/1/query?q=incidents",
-      "headers": {
-        "Authorization": "Bearer {{ env.GRAFANA_TOKEN }}"
-      },
-      "jq": ".results[0].value",
-      "format": "Grafana: {{ value }}",
-      "label": "Grafana",
-      "cooldown": 30,
-      "maxSnippets": 1
     }
   ],
   "injection": {
@@ -60,13 +17,6 @@
   "snippets": {
     "deduplication": true,
     "cooldownAfterShown": 3,
-    "priorityOrder": [
-      "incident",
-      "ci",
-      "slack",
-      "calendar",
-      "github",
-      "jira"
-    ]
+    "priorityOrder": ["review", "incident", "ci", "slack", "calendar", "github", "gitlab", "jira"]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "contextspin",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "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

@@ -2,7 +2,6 @@
 // src/cli.js — Commander-based command-line interface for ContextSpin.
 
 import fs from 'node:fs';
-import fsp from 'node:fs/promises';
 import path from 'node:path';
 import process from 'node:process';
 import readline from 'node:readline/promises';
@@ -12,10 +11,13 @@ import { Command } from 'commander';
 
 import {
   CONFIG_PATH,
+  STATUSLINE_SH,
+  CLAUDE_SETTINGS_PATH,
   configExists,
   loadConfig,
   saveConfig,
   normalizeConfig,
+  defaultConfig,
 } from './config.js';
 import {
   startDaemonDetached,
@@ -25,6 +27,7 @@ import {
 } from './daemon.js';
 import { installStatusline, uninstallStatusline } from './inject/statusline.js';
 import { installPatcher, restorePatcher } from './inject/patcher.js';
+import { detectSources } from './detect.js';
 
 /** Absolute path to this module's directory. */
 const HERE = path.dirname(fileURLToPath(import.meta.url));
@@ -91,27 +94,8 @@ function printSetupHint() {
 }
 
 /**
- * Write the bundled example config to the destination path. Confirms before
- * overwriting an existing file unless `force` is true.
- * @param {string} dest
- * @param {boolean} force
- * @returns {Promise<boolean>} true if written, false if skipped.
- */
-async function writeExampleConfig(dest, force) {
-  const examplePath = path.join(ROOT, '.contextspin.example.json');
-  const raw = await fsp.readFile(examplePath, 'utf8');
-  if (fs.existsSync(dest) && !force) {
-    console.log(`Config already exists at ${dest} (left unchanged).`);
-    return false;
-  }
-  await fsp.writeFile(dest, raw);
-  console.log(`Wrote example config to ${dest}`);
-  return true;
-}
-
-/**
- * Run the setup command: create a config either non-interactively (example
- * config) or via an interactive prompt that builds a minimal config.
+ * Run the setup command: create a config either non-interactively (a REAL
+ * config built from detected sources) or via an interactive prompt.
  * @param {{ yes?: boolean }} opts
  * @returns {Promise<void>}
  */
@@ -119,11 +103,13 @@ async function runSetup(opts = {}) {
   const interactive = process.stdin.isTTY && !opts.yes;
 
   if (!interactive) {
-    // Non-TTY or --yes: drop the example config unless one already exists.
+    // Non-TTY or --yes: write a real detected config unless one already exists.
     if (configExists()) {
       console.log(`Config already exists at ${CONFIG_PATH} (left unchanged).`);
     } else {
-      await writeExampleConfig(CONFIG_PATH, false);
+      const cfg = normalizeConfig(defaultConfig(await detectSources()));
+      await saveConfig(cfg, CONFIG_PATH);
+      console.log(`Wrote a detected config to ${CONFIG_PATH}`);
     }
     console.log('');
     console.log('Next steps:');
@@ -169,35 +155,21 @@ async function runSetup(opts = {}) {
       : 30;
 
     /** @type {Array<object>} */
-    const sources = [];
+    let sources = [];
     const seedAns = (
-      await rl.question('Seed a couple of safe starter sources? (Y/n) ')
+      await rl.question(
+        'Seed the safe starter sources detected for your environment? (Y/n) ',
+      )
     )
       .trim()
       .toLowerCase();
     if (seedAns !== 'n' && seedAns !== 'no') {
-      // Safe starters: read-only `gh` queries that do nothing harmful.
-      sources.push({
-        type: 'cli',
-        command: 'gh pr list --review-requested @me --json title,number --limit 3',
-        format: 'PR #{{ number }} needs your review: {{ title }}',
-        label: 'GitHub',
-        cooldown: 120,
-        maxSnippets: 3,
-      });
-      sources.push({
-        type: 'cli',
-        command: 'gh run list --json status,name,headBranch --limit 5',
-        filter: '{{ status }} == failure',
-        format: 'CI failing: {{ name }} on {{ headBranch }}',
-        label: 'CI',
-        cooldown: 60,
-        maxSnippets: 2,
-      });
+      // Read-only starters detected from the local environment (gh/glab).
+      sources = await detectSources();
     }
 
     const config = normalizeConfig({
-      sources,
+      ...defaultConfig(sources),
       injection: { mode, refresh },
     });
     await saveConfig(config, CONFIG_PATH);
@@ -211,6 +183,102 @@ async function runSetup(opts = {}) {
   }
 }
 
+/**
+ * The TARGET Claude settings file for a given scope: the project's gitignored
+ * settings.local.json when a projectDir is known, else the user settings.json.
+ * @param {string|undefined} projectDir
+ * @returns {string}
+ */
+function targetSettingsPath(projectDir) {
+  if (projectDir) {
+    return path.join(path.resolve(projectDir), '.claude', 'settings.local.json');
+  }
+  return CLAUDE_SETTINGS_PATH;
+}
+
+/**
+ * Whether the statusLine in the scope's TARGET settings file already points at
+ * our wrapper. Best-effort: any read/parse/missing-file error -> false.
+ * @param {string|undefined} projectDir - Project scope dir, or undefined for user scope.
+ * @returns {boolean}
+ */
+function statuslineIsOurs(projectDir) {
+  try {
+    const target = targetSettingsPath(projectDir);
+    if (!fs.existsSync(target)) return false;
+    const parsed = JSON.parse(fs.readFileSync(target, 'utf8'));
+    const sl = parsed && parsed.statusLine;
+    return !!(sl && typeof sl === 'object' && sl.command === STATUSLINE_SH);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The ENSURE flow: idempotent, non-interactive, safe to run every session
+ * (this is what the plugin SessionStart hook invokes). It:
+ *   (a) creates a detected config if none exists,
+ *   (b) wires the statusline if the mode is statusline/both and it is not
+ *       already pointing at our wrapper, and
+ *   (c) starts the daemon if it is not already running.
+ * Prints a concise one-line summary. Never throws on the normal paths; any
+ * error prints a clean line and the process still exits 0 (the hook depends on
+ * this — a non-zero exit would surface an error to the user every session).
+ * @returns {Promise<void>}
+ */
+async function runEnsure() {
+  /** @type {string[]} */
+  const did = [];
+  try {
+    let createdConfig = false;
+    if (!configExists()) {
+      const cfg = normalizeConfig(defaultConfig(await detectSources()));
+      await saveConfig(cfg, CONFIG_PATH);
+      createdConfig = true;
+      did.push('created config');
+    }
+
+    const config = await loadConfig();
+    const mode =
+      config && config.injection && config.injection.mode
+        ? config.injection.mode
+        : 'statusline';
+
+    // Claude Code sets CLAUDE_PROJECT_DIR in hooks. When present we wire the
+    // scope-aware project settings.local.json (which outranks a repo's tracked
+    // statusLine); when absent we stay in user scope and do NOT guess from cwd.
+    const projectDir = process.env.CLAUDE_PROJECT_DIR || undefined;
+
+    if (mode === 'statusline' || mode === 'both') {
+      // Always (re-)install: installStatusline is idempotent for the settings
+      // write, and re-running it every session refreshes the composed prior so a
+      // repo that later changes its own statusLine gets picked up. Only announce
+      // it as a fresh wiring the first time.
+      const wasOurs = statuslineIsOurs(projectDir);
+      await installStatusline(config, { projectDir });
+      if (!wasOurs) did.push('wired statusline');
+    }
+
+    if (!isDaemonRunning().running) {
+      startDaemonDetached();
+      did.push('started daemon');
+    }
+
+    if (did.length === 0) {
+      console.log('ContextSpin: already set up.');
+    } else {
+      console.log(
+        `ContextSpin: ${did.join(', ')}.` +
+          (createdConfig ? ` Edit ${CONFIG_PATH} to add your own sources.` : ''),
+      );
+    }
+  } catch (err) {
+    const message = err && err.message ? err.message : String(err);
+    // Never break the session-start hook: report and exit 0.
+    console.log(`ContextSpin: setup skipped (${message}).`);
+  }
+}
+
 /**
  * Start the background daemon. Requires a valid config.
  * @returns {Promise<void>}
@@ -306,7 +374,7 @@ function resolveMode(optionMode, config) {
 
 /**
  * Run the inject command for the chosen mode (statusline / patcher / both).
- * @param {{ mode?: string }} opts
+ * @param {{ mode?: string, project?: string }} opts
  * @returns {Promise<void>}
  */
 async function runInject(opts = {}) {
@@ -318,9 +386,12 @@ async function runInject(opts = {}) {
     );
   }
 
+  const projectDir = opts.project || process.env.CLAUDE_PROJECT_DIR || undefined;
+
   if (mode === 'statusline' || mode === 'both') {
-    const res = await installStatusline(config);
+    const res = await installStatusline(config, { projectDir });
     console.log('Statusline installed:');
+    console.log(`  scope:    ${res.scope}`);
     console.log(`  script:   ${res.statuslineSh}`);
     console.log(`  renderer: ${res.statuslineJs}`);
     console.log(`  settings: ${res.settingsPath}`);
@@ -357,7 +428,7 @@ async function runInject(opts = {}) {
 
 /**
  * Run the uninject command, reversing whichever injection mode is selected.
- * @param {{ mode?: string }} opts
+ * @param {{ mode?: string, project?: string }} opts
  * @returns {Promise<void>}
  */
 async function runUninject(opts = {}) {
@@ -369,8 +440,10 @@ async function runUninject(opts = {}) {
     );
   }
 
+  const projectDir = opts.project || process.env.CLAUDE_PROJECT_DIR || undefined;
+
   if (mode === 'statusline' || mode === 'both') {
-    const res = await uninstallStatusline();
+    const res = await uninstallStatusline({ projectDir });
     if (res.removed) {
       console.log(
         res.restored
@@ -431,10 +504,17 @@ function buildProgram() {
 
   program
     .command('setup')
-    .description('Create a ContextSpin config (interactive, or --yes for example)')
-    .option('--yes', 'skip prompts and write the example config')
+    .description('Create a ContextSpin config (interactive, or --yes for a detected config)')
+    .option('--yes', 'skip prompts and write a detected config')
     .action(action(async (opts) => runSetup(opts)));
 
+  program
+    .command('ensure')
+    .description(
+      'One-shot, idempotent setup (create config + wire statusline + start daemon)',
+    )
+    .action(async () => runEnsure());
+
   program
     .command('start')
     .description('Start the background daemon')
@@ -459,12 +539,22 @@ function buildProgram() {
     .command('inject')
     .description('Wire ContextSpin into Claude Code (statusline/patcher/both)')
     .option('--mode <m>', 'injection mode: statusline, patcher, or both')
+    .option(
+      '--project <dir>',
+      'wire the project-scoped settings.local.json under <dir> (defaults to $CLAUDE_PROJECT_DIR); composes any statusline the repo ships',
+      process.env.CLAUDE_PROJECT_DIR,
+    )
     .action(action(async (opts) => runInject(opts)));
 
   program
     .command('uninject')
     .description('Remove ContextSpin from Claude Code')
     .option('--mode <m>', 'injection mode: statusline, patcher, or both')
+    .option(
+      '--project <dir>',
+      'uninject from the project-scoped settings.local.json under <dir> (defaults to $CLAUDE_PROJECT_DIR)',
+      process.env.CLAUDE_PROJECT_DIR,
+    )
     .action(action(async (opts) => runUninject(opts)));
 
   // Default action: run when no subcommand is provided. Any leftover operand

package/src/config.js

@@ -37,6 +37,16 @@ export const STATUSLINE_SH = path.join(STATE_DIR, "statusline.sh");
 /** Path to the generated statusline Node render script. */
 export const STATUSLINE_JS = path.join(STATE_DIR, "statusline-render.js");
 
+/**
+ * Path to the recorded prior statusLine commands (captured when we wrap an
+ * existing statusline so we can run it and prepend its output). Holds a MAP
+ * keyed by absolute project dir (with "" reserved for the user/no-project
+ * scope); each value is { command, type }. An old single-object file (with a
+ * top-level `command` field) is migrated to the "" entry on read. Entries are
+ * removed per-scope on uninstall.
+ */
+export const PREV_STATUSLINE_PATH = path.join(STATE_DIR, "prev-statusline.json");
+
 /** Path to Claude Code's settings file (patched by the statusline injector). */
 export const CLAUDE_SETTINGS_PATH = path.join(HOME, ".claude", "settings.json");
 
@@ -124,6 +134,36 @@ export function normalizeConfig(raw) {
   return { ...input, injection, snippets, sources };
 }
 
+/**
+ * Build a complete default config object from a set of sources. Mirrors the
+ * shipped example config's injection/snippets shape (statusline mode, 30s
+ * refresh, 5 visible, dedup on, a sensible priority order). The result is a
+ * plain config (NOT normalized) — pass it through normalizeConfig before use.
+ *
+ * @param {Array<object>} sources - Source objects (e.g. from detectSources).
+ * @returns {object} A default config: { sources, injection, snippets }.
+ */
+export function defaultConfig(sources) {
+  return {
+    sources: Array.isArray(sources) ? sources : [],
+    injection: { mode: "statusline", refresh: 30, maxVisible: 5 },
+    snippets: {
+      deduplication: true,
+      cooldownAfterShown: 3,
+      priorityOrder: [
+        "review",
+        "incident",
+        "ci",
+        "slack",
+        "calendar",
+        "github",
+        "gitlab",
+        "jira",
+      ],
+    },
+  };
+}
+
 /**
  * Validate a config (raw or normalized). Throws an Error with a clear message on
  * any problem; returns the same config object on success.
@@ -135,8 +175,12 @@ export function validateConfig(config) {
   if (!config || typeof config !== "object" || Array.isArray(config)) {
     throw new Error("Invalid config: expected a JSON object.");
   }
-  if (!Array.isArray(config.sources) || config.sources.length === 0) {
-    throw new Error('Invalid config: "sources" must be a non-empty array.');
+  // sources must be an array, but MAY be empty: a source-less config is valid —
+  // the daemon polls nothing and the injectors degrade to no snippets, which is
+  // the correct "installed but not configured yet" state (and lets `ensure`
+  // wire the statusline + start the daemon without a hard failure).
+  if (!Array.isArray(config.sources)) {
+    throw new Error('Invalid config: "sources" must be an array.');
   }
 
   config.sources.forEach((src, i) => {

package/src/daemon.js

@@ -41,7 +41,10 @@ export async function readCache() {
  * @returns {Promise<void>}
  */
 export async function writeCache(state) {
-  const tmp = CACHE_PATH + ".tmp";
+  // Per-process temp name so the daemon and the statusline render script (which
+  // also writes the cache to bump shownCount) never share one .tmp and tear each
+  // other's writes. rename-onto-target stays atomic.
+  const tmp = CACHE_PATH + "." + process.pid + ".tmp";
   await fsp.writeFile(tmp, JSON.stringify(state, null, 2));
   await fsp.rename(tmp, CACHE_PATH);
 }

package/src/detect.js

@@ -0,0 +1,121 @@
+// src/detect.js — best-effort, zero-network detection of the single starter source.
+//
+// ContextSpin has ONE job: show "review requests waiting on you" — the PRs/MRs
+// where you are the requested reviewer — in the Claude Code statusline. We seed
+// exactly one source for that, using whichever code-host CLI is already on PATH
+// (and already authenticated), so there is zero token/secret setup.
+//
+// Detection heuristic (all local, no secrets, no network):
+//   - We probe PATH for the `gh` (GitHub CLI) and `glab` (GitLab CLI) binaries
+//     using a short, swallowed child-process check (`<tool> --version`). Anything
+//     that errors, times out, or exits non-zero is treated as "not present".
+//   - If `gh` is present we seed the GitHub "review requested of you" source.
+//   - Else if `glab` is present we seed the GitLab equivalent.
+//   - If NEITHER is present we still return the `gh` source as a graceful
+//     placeholder. cli sources fail gracefully per-source in the daemon runner,
+//     so a missing binary just yields no snippets rather than breaking anything —
+//     and the config is then a working template the user can edit.
+//
+// All format strings use the double-curly-brace token syntax understood by
+// src/formatter.js. The returned source object has NO `id` — normalizeConfig
+// assigns ids by index.
+
+import { spawn } from "node:child_process";
+
+/**
+ * Best-effort check whether a binary is on PATH by running `<tool> --version`.
+ * Swallows every failure (missing binary, non-zero exit, timeout, spawn error)
+ * and resolves to a boolean. Never throws.
+ *
+ * @param {string} tool - The binary name to probe (e.g. "gh").
+ * @param {number} [timeoutMs=2000] - Kill the probe after this long.
+ * @returns {Promise<boolean>}
+ */
+function hasBinary(tool, timeoutMs = 2000) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve(value);
+    };
+    let child;
+    try {
+      child = spawn(tool, ["--version"], { stdio: "ignore" });
+    } catch {
+      done(false);
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        // ignore
+      }
+      done(false);
+    }, timeoutMs);
+    if (timer.unref) timer.unref();
+    child.on("error", () => {
+      clearTimeout(timer);
+      done(false);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      done(code === 0);
+    });
+  });
+}
+
+/** The GitHub "review requests waiting on you" source. */
+function ghSource() {
+  return {
+    type: "cli",
+    command: "gh pr list --review-requested @me --json number,title --limit 5",
+    format: "👀 review #{{ number }}: {{ title }}",
+    label: "review",
+    cooldown: 120,
+    maxSnippets: 3,
+  };
+}
+
+/** The GitLab "review requests waiting on you" source. */
+function glabSource() {
+  return {
+    type: "cli",
+    command: "glab mr list --reviewer=@me --output json --per-page 5",
+    format: "👀 review !{{ iid }}: {{ title }}",
+    label: "review",
+    cooldown: 120,
+    maxSnippets: 3,
+  };
+}
+
+/**
+ * Detect the single safe, read-only starter source from the local environment.
+ *
+ * Best-effort and side-effect-free beyond local `<tool> --version` probes (no
+ * network). See the file header for the detection heuristic. Always returns a
+ * non-empty array holding exactly one source object WITHOUT an id
+ * (normalizeConfig assigns ids).
+ *
+ * @param {{ timeoutMs?: number }} [opts]
+ * @returns {Promise<Array<object>>}
+ */
+export async function detectSources(opts = {}) {
+  const timeoutMs = opts.timeoutMs;
+
+  // Probe both CLIs in parallel; each probe swallows its own failures.
+  const [gh, glab] = await Promise.all([
+    hasBinary("gh", timeoutMs),
+    hasBinary("glab", timeoutMs),
+  ]);
+
+  if (gh) return [ghSource()];
+  if (glab) return [glabSource()];
+
+  // Neither present: return the gh source as a graceful, gracefully-failing
+  // placeholder the user can edit.
+  return [ghSource()];
+}
+
+export default detectSources;

package/src/inject/statusline.js

@@ -1,6 +1,25 @@
 // src/inject/statusline.js — installs/uninstalls the Claude Code statusLine integration.
-// Generates a self-contained render script (always exits 0, reads+discards stdin)
-// and wires it into ~/.claude/settings.json under the camelCase `statusLine` key.
+// Generates a self-contained render script (always exits 0, buffers stdin) and
+// wires it into a Claude Code settings file under the camelCase `statusLine` key.
+//
+// SCOPE-AWARE + NON-DESTRUCTIVE:
+//
+//  - User scope (no project dir): we patch the user ~/.claude/settings.json.
+//  - Project scope (a projectDir is known, e.g. CLAUDE_PROJECT_DIR in a hook):
+//    we patch <projectDir>/.claude/settings.local.json. That file is gitignored
+//    and OUTRANKS the project's tracked .claude/settings.json — so a repo that
+//    ships its own statusLine in settings.json no longer SHADOWS ContextSpin.
+//
+//  - In either scope, if a statusLine command (other than ours) is currently
+//    effective, we record it in a PREV map (keyed by the absolute project dir,
+//    with "" reserved for the user scope) and the generated render script RUNS
+//    that prior command (piping Claude Code's stdin to it) and prints its output
+//    FIRST, then prints the ContextSpin snippet line on its own line beneath. The
+//    prior statusline is composed with ours, never discarded.
+//
+//  - The render script picks the prior PER PROJECT at render time: it parses the
+//    stdin payload for the project dir and looks the prior command up in the PREV
+//    map by that dir, falling back to the user ("") entry.
 
 import fs from "node:fs";
 import fsp from "node:fs/promises";
@@ -9,6 +28,7 @@ import {
   STATE_DIR,
   STATUSLINE_SH,
   STATUSLINE_JS,
+  PREV_STATUSLINE_PATH,
   CACHE_PATH,
   CONFIG_PATH,
   CLAUDE_SETTINGS_PATH,
@@ -19,71 +39,220 @@ import {
  * for each status-bar refresh.
  *
  * Runtime behavior of the generated script:
- *  - Reads and DISCARDS all of stdin (Claude Code pipes a JSON payload; we never
- *    use it, but we must drain it so the writer never gets EPIPE).
- *  - Reads the cache (tolerating a missing file -> exit 0 silently).
+ *  - Reads and BUFFERS all of stdin (Claude Code pipes a JSON payload). We must
+ *    consume it so the writer never gets EPIPE; we also feed it to a wrapped
+ *    prior statusline command (below).
+ *  - Tolerantly JSON-parses the buffered stdin to find the project dir (trying
+ *    workspace.project_dir, then workspace.current_dir, then cwd), then looks up
+ *    the prior command in the PREV map by that dir, falling back to the user ("")
+ *    entry. If a prior command is found, it spawns that command via the shell,
+ *    writes the buffered stdin to ITS stdin, captures its stdout with a 2000ms
+ *    timeout (SIGKILL on timeout), and prints that output VERBATIM first (it may
+ *    be multiple lines). Any failure here is swallowed.
+ *  - Reads the cache (tolerating a missing file).
  *  - Reads `cooldownAfterShown` from the config (fallback 3).
  *  - Selects snippets where shownCount < cooldownAfterShown, picks the one with
  *    the LOWEST shownCount then the most recent fetchedAt, bumps its shownCount,
  *    and writes the cache back atomically.
- *  - Prints that snippet's text on a single line; prints nothing if none eligible.
- *  - Wraps EVERYTHING so any error still exits 0 with no output (never breaks the
- *    user's status bar).
+ *  - Prints that snippet's text on its OWN line beneath the prior output; prints
+ *    nothing for the ContextSpin line if none eligible.
+ *  - Wraps EVERYTHING so any error still exits 0 with whatever output succeeded
+ *    (the prior statusline must never be lost and the bar must never break).
  *
- * The cache and config paths are baked into the script as string literals so the
- * generated file is fully self-contained and has no import dependencies.
+ * The cache, config, and prev-statusline-map paths are baked into the script as
+ * string literals so the generated file is fully self-contained with no imports
+ * beyond node builtins.
  *
  * @param {string} cachePath - Absolute path to the snippet cache JSON file.
  * @param {string} configPath - Absolute path to the ContextSpin config JSON file.
+ * @param {string} prevPath - Absolute path to the prev-statusline MAP JSON file.
  * @returns {string} The ESM source of the render script.
  */
-function buildRenderScript(cachePath, configPath) {
+function buildRenderScript(cachePath, configPath, prevPath) {
   const CACHE = JSON.stringify(cachePath);
   const CONFIG = JSON.stringify(configPath);
-  return `// contextspin statusline-render.js (generated) — prints one context snippet.
-// MUST always exit 0 and print nothing on error so the status bar never breaks.
+  const PREV = JSON.stringify(prevPath);
+  return `// contextspin statusline-render.js (generated) — composes any prior
+// statusline (looked up per-project) with one ContextSpin snippet line. MUST
+// always exit 0 and never lose the prior statusline's output, so the user's
+// status bar never breaks.
 import fs from "node:fs";
+import { spawn } from "node:child_process";
 
 const CACHE_PATH = ${CACHE};
 const CONFIG_PATH = ${CONFIG};
+const PREV_STATUSLINE_PATH = ${PREV};
 
-/** Drain and discard stdin so Claude Code's JSON pipe never gets EPIPE. */
-function drainStdin() {
+/** Buffer ALL of stdin into a Buffer. Resolves on end/close/error/timeout. */
+function readStdin() {
   return new Promise((resolve) => {
+    const chunks = [];
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      resolve(Buffer.concat(chunks));
+    };
     try {
       const stdin = process.stdin;
-      stdin.on("error", () => {});
-      stdin.on("data", () => {});
-      stdin.on("end", () => resolve());
-      stdin.on("close", () => resolve());
+      stdin.on("error", () => finish());
+      stdin.on("data", (chunk) =>
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)))
+      );
+      stdin.on("end", () => finish());
+      stdin.on("close", () => finish());
       stdin.resume();
       // Safety timer: don't hang forever if no EOF arrives.
-      setTimeout(resolve, 250).unref?.();
+      setTimeout(finish, 250).unref?.();
     } catch {
-      resolve();
+      finish();
+    }
+  });
+}
+
+/**
+ * Tolerantly parse the buffered stdin payload for the project dir. Tries
+ * workspace.project_dir, then workspace.current_dir, then cwd. Returns "" on any
+ * failure (which falls back to the user-scope prev entry).
+ */
+function projectDirFromStdin(stdinBuf) {
+  try {
+    const payload = JSON.parse(stdinBuf.toString("utf8"));
+    const ws = payload && typeof payload.workspace === "object" ? payload.workspace : {};
+    const dir =
+      (ws && ws.project_dir) ||
+      (ws && ws.current_dir) ||
+      (payload && payload.cwd) ||
+      "";
+    return typeof dir === "string" ? dir : "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Read the prev-statusline MAP (keyed by absolute project dir, with "" for the
+ * user scope). Tolerates a missing/old file. An OLD single-object file (one with
+ * a top-level \`command\` field) is migrated in-memory to the "" (user) entry.
+ * Returns an object map (possibly empty); never throws.
+ */
+function readPrevMap() {
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(PREV_STATUSLINE_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+  if (!raw || typeof raw !== "object") return {};
+  // Migrate an old single-object record to the user ("") entry.
+  if (typeof raw.command === "string") {
+    return { "": { command: raw.command, type: raw.type || "command" } };
+  }
+  return raw;
+}
+
+/**
+ * Resolve the prior statusline command for a given project dir from the map,
+ * falling back to the user ("") entry. Returns "" when none is recorded.
+ */
+function priorCommandFor(projectDir) {
+  const map = readPrevMap();
+  // Try the raw dir, then its realpath (the install side keys by realpath, so a
+  // symlinked root still matches), then fall back to the user ("") entry.
+  const candidates = [];
+  if (projectDir) {
+    candidates.push(projectDir);
+    try { candidates.push(fs.realpathSync(projectDir)); } catch {}
+  }
+  candidates.push("");
+  for (const k of candidates) {
+    const entry = map[k];
+    if (entry && typeof entry === "object" && typeof entry.command === "string") {
+      return entry.command;
+    }
+  }
+  return "";
+}
+
+/**
+ * Run the recorded prior statusline command, feeding it the buffered stdin, and
+ * resolve with its captured stdout (string). Swallows every failure -> "".
+ */
+function runPrevStatusline(command, stdinBuf) {
+  return new Promise((resolve) => {
+    if (!command) {
+      resolve("");
+      return;
+    }
+    let child;
+    try {
+      child = spawn(command, { shell: true });
+    } catch {
+      resolve("");
+      return;
+    }
+    let out = "";
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      resolve(out);
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        // ignore
+      }
+      finish();
+    }, 2000);
+    if (timer.unref) timer.unref();
+    if (child.stdout) {
+      child.stdout.setEncoding("utf8");
+      child.stdout.on("data", (chunk) => {
+        out += chunk;
+      });
+    }
+    if (child.stderr) child.stderr.on("data", () => {});
+    child.on("error", () => {
+      clearTimeout(timer);
+      finish();
+    });
+    child.on("close", () => {
+      clearTimeout(timer);
+      finish();
+    });
+    try {
+      if (child.stdin) {
+        child.stdin.on("error", () => {});
+        if (stdinBuf && stdinBuf.length) child.stdin.write(stdinBuf);
+        child.stdin.end();
+      }
+    } catch {
+      // ignore: prior command may not read stdin
     }
   });
 }
 
-/** Atomically replace a JSON file (write tmp then rename). */
+/** Atomically replace a JSON file (write tmp then rename). The temp name is
+// per-process so this render script and the daemon never share one .tmp and
+// tear each other's cache writes. */
 function writeJsonAtomic(filePath, data) {
-  const tmp = filePath + ".tmp";
+  const tmp = filePath + "." + process.pid + ".tmp";
   fs.writeFileSync(tmp, JSON.stringify(data));
   fs.renameSync(tmp, filePath);
 }
 
-async function main() {
-  await drainStdin();
-
-  // Missing cache -> nothing to show.
+/** Compute the ContextSpin snippet line (may be ""); bumps shownCount. */
+function contextSpinLine() {
   let cache;
   try {
     cache = JSON.parse(fs.readFileSync(CACHE_PATH, "utf8"));
   } catch {
-    return; // no output
+    return "";
   }
   const snippets = Array.isArray(cache && cache.snippets) ? cache.snippets : [];
-  if (snippets.length === 0) return;
+  if (snippets.length === 0) return "";
 
   // cooldownAfterShown from config (fallback 3).
   let cooldownAfterShown = 3;
@@ -95,13 +264,11 @@ async function main() {
     // keep fallback
   }
 
-  // Eligible: shownCount < cooldownAfterShown.
   const eligible = snippets.filter(
     (s) => s && typeof s.text === "string" && (s.shownCount || 0) < cooldownAfterShown
   );
-  if (eligible.length === 0) return;
+  if (eligible.length === 0) return "";
 
-  // Pick lowest shownCount, then most recent fetchedAt.
   eligible.sort((a, b) => {
     const ca = a.shownCount || 0;
     const cb = b.shownCount || 0;
@@ -112,7 +279,6 @@ async function main() {
   });
   const chosen = eligible[0];
 
-  // Bump shownCount on the chosen snippet within the original array and persist.
   chosen.shownCount = (chosen.shownCount || 0) + 1;
   try {
     writeJsonAtomic(CACHE_PATH, cache);
@@ -120,13 +286,53 @@ async function main() {
     // If we cannot persist, still show the snippet this time.
   }
 
-  // Single line of output. Await the write callback so the bytes are flushed to
-  // the pipe before process.exit (which does not wait for async stdout writes).
-  await new Promise((resolve) => {
-    process.stdout.write(String(chosen.text).replace(/\\r?\\n/g, " "), resolve);
+  return String(chosen.text).replace(/\\r?\\n/g, " ");
+}
+
+/** Write a string to stdout, awaiting the flush callback. */
+function writeOut(text) {
+  return new Promise((resolve) => {
+    try {
+      process.stdout.write(text, resolve);
+    } catch {
+      resolve();
+    }
   });
 }
 
+async function main() {
+  const stdinBuf = await readStdin();
+
+  // (a) Prior statusline output FIRST (verbatim, possibly multi-line), looked up
+  // per-project from the PREV map.
+  let prevOut = "";
+  try {
+    const projectDir = projectDirFromStdin(stdinBuf);
+    const command = priorCommandFor(projectDir);
+    prevOut = await runPrevStatusline(command, stdinBuf);
+  } catch {
+    prevOut = "";
+  }
+
+  // (b) ContextSpin snippet line.
+  let line = "";
+  try {
+    line = contextSpinLine();
+  } catch {
+    line = "";
+  }
+
+  // (c) Compose: prior output, then our line on its own line beneath. We only
+  // insert a separating newline when there is prior output that does not
+  // already end in one, so a lone ContextSpin line stays a single clean line.
+  let composed = prevOut;
+  if (line) {
+    if (composed && !composed.endsWith("\\n")) composed += "\\n";
+    composed += line;
+  }
+  if (composed) await writeOut(composed);
+}
+
 main()
   .then(() => process.exit(0))
   .catch(() => process.exit(0));
@@ -148,6 +354,20 @@ async function readJsonSafe(filePath, fallback) {
   }
 }
 
+/**
+ * Synchronous JSON read returning a fallback on any read/parse error.
+ * @param {string} filePath
+ * @param {*} fallback
+ * @returns {*}
+ */
+function readJsonSafeSync(filePath, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
 /**
  * Atomically write a pretty-printed JSON file (write tmp then rename).
  * @param {string} filePath
@@ -160,62 +380,184 @@ async function writeJsonAtomic(filePath, data) {
   await fsp.rename(tmp, filePath);
 }
 
+/**
+ * Read the prev-statusline MAP from disk: an object keyed by absolute project
+ * dir (with "" reserved for the user scope), each value { command, type }.
+ *
+ * Tolerates a missing/unparseable file (-> {}). Migrates an OLD single-object
+ * file (one with a top-level `command` field) by treating it as the "" (user)
+ * entry. Never throws.
+ *
+ * @returns {Record<string, {command: string, type: string}>}
+ */
+function readPrevMap() {
+  const raw = readJsonSafeSync(PREV_STATUSLINE_PATH, null);
+  if (!raw || typeof raw !== "object") return {};
+  // Migrate an old single-object record to the user ("") entry.
+  if (typeof raw.command === "string") {
+    return { "": { command: raw.command, type: raw.type || "command" } };
+  }
+  return raw;
+}
+
+/**
+ * Persist the prev-statusline MAP atomically.
+ * @param {Record<string, {command: string, type: string}>} map
+ * @returns {Promise<void>}
+ */
+async function writePrevMap(map) {
+  await writeJsonAtomic(PREV_STATUSLINE_PATH, map);
+}
+
+/**
+ * Resolve the statusLine command currently configured in a settings file (if
+ * any), ignoring our own wrapper. Returns null when the file has no usable
+ * non-ours statusLine command.
+ *
+ * @param {string} settingsPath
+ * @returns {{command: string, type: string}|null}
+ */
+function priorFromSettings(settingsPath) {
+  const settings = readJsonSafeSync(settingsPath, null);
+  const sl = settings && typeof settings === "object" ? settings.statusLine : null;
+  if (
+    sl &&
+    typeof sl === "object" &&
+    typeof sl.command === "string" &&
+    sl.command &&
+    sl.command !== STATUSLINE_SH
+  ) {
+    return { command: sl.command, type: sl.type || "command" };
+  }
+  return null;
+}
+
 /**
  * @typedef {Object} InstallStatuslineResult
  * @property {string} statuslineSh - Path to the generated bash wrapper.
  * @property {string} statuslineJs - Path to the generated Node render script.
  * @property {string} settingsPath - Path to the patched Claude settings file.
+ * @property {"project"|"user"} scope - Whether we wrote project or user settings.
  * @property {boolean} backedUp - Whether an existing statusLine was backed up.
+ * @property {boolean} composed - Whether we wrapped an existing statusline
+ *   (its output is composed above the ContextSpin line).
  * @property {string|null} warning - Human-readable warning, or null.
  */
 
 /**
- * Install the ContextSpin statusline integration:
- *  - Writes the self-contained render script to STATUSLINE_JS.
- *  - Writes an executable bash wrapper to STATUSLINE_SH that execs the render
- *    script with stderr silenced.
- *  - Patches ~/.claude/settings.json so `statusLine` points at our wrapper, with
- *    `refreshInterval` in SECONDS (from config.injection.refresh). If an existing
- *    statusLine command (other than ours) is present, it is backed up once.
+ * Install the ContextSpin statusline integration (SCOPE-AWARE, NON-DESTRUCTIVE).
+ *
+ * TARGET settings file + PREV map KEY:
+ *  - If opts.projectDir is set: TARGET = <projectDir>/.claude/settings.local.json
+ *    (gitignored, outranks the tracked settings.json); KEY = the resolved
+ *    absolute projectDir.
+ *  - Else: TARGET = the user ~/.claude/settings.json; KEY = "" (user scope).
+ *
+ * PRIOR detection (the statusline currently effective and NOT ours, to compose):
+ *  - If projectDir set: the project's tracked .claude/settings.json statusLine if
+ *    present and not ours; else the user settings.json statusLine if not ours;
+ *    else none.
+ *  - Else: the user settings.json statusLine if present and not ours; else none.
+ * We never treat our own STATUSLINE_SH as a prior, and record the detected prior
+ * into the PREV map under KEY (refreshing it if it differs).
  *
  * @param {object} config - Normalized ContextSpin config (uses injection.refresh).
+ * @param {{ projectDir?: string }} [opts]
  * @returns {Promise<InstallStatuslineResult>}
  */
-export async function installStatusline(config) {
+export async function installStatusline(config, opts = {}) {
   await fsp.mkdir(STATE_DIR, { recursive: true });
 
-  // (1) Render script.
-  const renderSource = buildRenderScript(CACHE_PATH, CONFIG_PATH);
+  // Canonicalize with realpath so the PREV-map key matches whatever the render
+  // script derives from Claude Code's stdin (symlinked roots like macOS /var vs
+  // /private/var would otherwise diverge). Fall back to path.resolve if realpath
+  // throws (e.g. the dir does not exist yet).
+  let projectDir = null;
+  if (opts && typeof opts.projectDir === "string" && opts.projectDir) {
+    try {
+      projectDir = fs.realpathSync(opts.projectDir);
+    } catch {
+      projectDir = path.resolve(opts.projectDir);
+    }
+  }
+
+  // Resolve TARGET settings file + PREV-map KEY by scope.
+  const scope = projectDir ? "project" : "user";
+  const targetPath = projectDir
+    ? path.join(projectDir, ".claude", "settings.local.json")
+    : CLAUDE_SETTINGS_PATH;
+  const key = projectDir || "";
+
+  // (1) PRIOR detection. We look at the *currently effective* non-ours
+  // statusLine so the render script can compose it.
+  let prior = null;
+  if (projectDir) {
+    // The tracked project settings.json (which currently shadows us), then fall
+    // back to the user settings.json.
+    prior =
+      priorFromSettings(path.join(projectDir, ".claude", "settings.json")) ||
+      priorFromSettings(CLAUDE_SETTINGS_PATH);
+  } else {
+    prior = priorFromSettings(CLAUDE_SETTINGS_PATH);
+  }
+
+  // (2) Record the prior into the PREV map under KEY. Refresh the entry if it
+  // differs; never record our own STATUSLINE_SH (priorFromSettings already
+  // excludes it). When there is no prior, drop any stale entry for this KEY.
+  const map = readPrevMap();
+  let composed = false;
+  if (prior && prior.command && prior.command !== STATUSLINE_SH) {
+    // Detected a real prior at this scope -> record/refresh it, so a repo that
+    // later changes its own statusLine is picked up on the next `ensure`.
+    map[key] = { command: prior.command, type: prior.type || "command" };
+    composed = true;
+  } else if (scope === "project") {
+    // Project priors come from the TRACKED settings.json, which we never write,
+    // so "no prior" means the repo genuinely has no statusLine -> drop any stale
+    // entry rather than keep running a command the repo has since removed.
+    if (map[key]) delete map[key];
+    composed = false;
+  } else {
+    // User scope: the prior source IS the file we overwrite with our wrapper, so
+    // "no prior" usually just means our wrapper is already installed. Keep any
+    // previously-recorded original prior.
+    composed = !!(map[key] && map[key].command);
+  }
+  await writePrevMap(map);
+
+  // (3) Render script (knows the prev-statusline MAP path) + bash wrapper.
+  const renderSource = buildRenderScript(CACHE_PATH, CONFIG_PATH, PREV_STATUSLINE_PATH);
   await fsp.writeFile(STATUSLINE_JS, renderSource);
 
-  // (2) Bash wrapper. Silence stderr so node warnings never reach the status bar.
+  // Silence stderr so node warnings never reach the status bar.
   const shSource = `#!/usr/bin/env bash\nexec node ${JSON.stringify(STATUSLINE_JS)} 2>/dev/null\n`;
   await fsp.writeFile(STATUSLINE_SH, shSource);
   await fsp.chmod(STATUSLINE_SH, 0o755);
 
-  // (3) Patch Claude settings.
-  await fsp.mkdir(path.dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
-  const settings = await readJsonSafe(CLAUDE_SETTINGS_PATH, {});
+  // (4) JSON-MERGE our statusLine into TARGET, preserving every other key.
+  await fsp.mkdir(path.dirname(targetPath), { recursive: true });
+  const targetExisted = fs.existsSync(targetPath);
+  const settings = await readJsonSafe(targetPath, {});
   const settingsObj = settings && typeof settings === "object" ? settings : {};
 
   let backedUp = false;
   let warning = null;
 
-  const existing = settingsObj.statusLine;
+  // If TARGET already held a non-ours statusLine, back it up once.
+  const targetExisting = settingsObj.statusLine;
   if (
-    existing &&
-    typeof existing === "object" &&
-    existing.command &&
-    existing.command !== STATUSLINE_SH
+    targetExisted &&
+    targetExisting &&
+    typeof targetExisting === "object" &&
+    typeof targetExisting.command === "string" &&
+    targetExisting.command &&
+    targetExisting.command !== STATUSLINE_SH
   ) {
-    const backupPath = CLAUDE_SETTINGS_PATH + ".contextspin.bak";
+    const backupPath = targetPath + ".contextspin.bak";
     if (!fs.existsSync(backupPath)) {
-      await fsp.copyFile(CLAUDE_SETTINGS_PATH, backupPath);
+      await fsp.copyFile(targetPath, backupPath);
       backedUp = true;
     }
-    warning =
-      `Existing statusLine command was overwritten (\`${existing.command}\`). ` +
-      `A backup of your settings is at ${backupPath}. Run \`contextspin uninject\` to restore it.`;
   }
 
   const refresh =
@@ -230,13 +572,26 @@ export async function installStatusline(config) {
     refreshInterval: refresh, // SECONDS
   };
 
-  await writeJsonAtomic(CLAUDE_SETTINGS_PATH, settingsObj);
+  await writeJsonAtomic(targetPath, settingsObj);
+
+  if (composed) {
+    const priorCmd = prior ? prior.command : (map[key] && map[key].command);
+    warning =
+      `Existing statusLine command (\`${priorCmd}\`) is preserved: ` +
+      `ContextSpin runs it and shows its output above the ContextSpin line. ` +
+      (scope === "project"
+        ? `Wired into ${targetPath} (gitignored; outranks the tracked settings.json). `
+        : ``) +
+      `Run \`contextspin uninject\` to restore it.`;
+  }
 
   return {
     statuslineSh: STATUSLINE_SH,
     statuslineJs: STATUSLINE_JS,
-    settingsPath: CLAUDE_SETTINGS_PATH,
+    settingsPath: targetPath,
+    scope,
     backedUp,
+    composed,
     warning,
   };
 }
@@ -245,24 +600,75 @@ export async function installStatusline(config) {
  * @typedef {Object} UninstallStatuslineResult
  * @property {boolean} removed - Whether our statusLine entry was removed.
  * @property {boolean} restored - Whether settings were restored from backup.
- * @property {string} settingsPath - Path to the Claude settings file.
+ * @property {string} settingsPath - Path to the Claude settings file operated on.
+ * @property {"project"|"user"} scope - Which scope was operated on.
  * @property {string|null} note - Human-readable note, or null.
  */
 
 /**
- * Uninstall the ContextSpin statusline integration. If the current
- * `statusLine.command` is ours, restore the `.contextspin.bak` backup when
- * present, otherwise just drop the `statusLine` key.
+ * Remove a scope's entry from the prev-statusline MAP (best-effort). When the
+ * map becomes empty the file is removed; otherwise it is rewritten.
+ * @param {string} key - The PREV-map key ("" for user scope, else absolute dir).
+ * @returns {Promise<void>}
+ */
+async function removePrevEntry(key) {
+  try {
+    const map = readPrevMap();
+    if (Object.prototype.hasOwnProperty.call(map, key)) {
+      delete map[key];
+    }
+    if (Object.keys(map).length === 0) {
+      await fsp.unlink(PREV_STATUSLINE_PATH).catch(() => {});
+    } else {
+      await writePrevMap(map);
+    }
+  } catch {
+    // best effort
+  }
+}
+
+/**
+ * Uninstall the ContextSpin statusline integration (SCOPE-AWARE reverse).
+ *
+ *  - Project scope (opts.projectDir set): operate on
+ *    <projectDir>/.claude/settings.local.json. If a `.contextspin.bak` exists,
+ *    restore it; else JSON-merge to delete just the `statusLine` key (preserving
+ *    other keys). Remove that project's entry from the PREV map.
+ *  - User scope: operate on the user ~/.claude/settings.json the same way and
+ *    remove the "" (user) PREV entry.
  *
+ * @param {{ projectDir?: string }} [opts]
  * @returns {Promise<UninstallStatuslineResult>}
  */
-export async function uninstallStatusline() {
-  const settings = await readJsonSafe(CLAUDE_SETTINGS_PATH, null);
+export async function uninstallStatusline(opts = {}) {
+  // Canonicalize with realpath so the PREV-map key matches whatever the render
+  // script derives from Claude Code's stdin (symlinked roots like macOS /var vs
+  // /private/var would otherwise diverge). Fall back to path.resolve if realpath
+  // throws (e.g. the dir does not exist yet).
+  let projectDir = null;
+  if (opts && typeof opts.projectDir === "string" && opts.projectDir) {
+    try {
+      projectDir = fs.realpathSync(opts.projectDir);
+    } catch {
+      projectDir = path.resolve(opts.projectDir);
+    }
+  }
+
+  const scope = projectDir ? "project" : "user";
+  const targetPath = projectDir
+    ? path.join(projectDir, ".claude", "settings.local.json")
+    : CLAUDE_SETTINGS_PATH;
+  const key = projectDir || "";
+
+  const settings = await readJsonSafe(targetPath, null);
   if (!settings || typeof settings !== "object") {
+    // Nothing in TARGET, but still drop any recorded prev entry for this scope.
+    await removePrevEntry(key);
     return {
       removed: false,
       restored: false,
-      settingsPath: CLAUDE_SETTINGS_PATH,
+      settingsPath: targetPath,
+      scope,
       note: "No Claude settings file found; nothing to uninstall.",
     };
   }
@@ -272,39 +678,46 @@ export async function uninstallStatusline() {
     current && typeof current === "object" && current.command === STATUSLINE_SH;
 
   if (!isOurs) {
+    await removePrevEntry(key);
     return {
       removed: false,
       restored: false,
-      settingsPath: CLAUDE_SETTINGS_PATH,
+      settingsPath: targetPath,
+      scope,
       note: "statusLine is not managed by ContextSpin; left unchanged.",
     };
   }
 
-  const backupPath = CLAUDE_SETTINGS_PATH + ".contextspin.bak";
+  const backupPath = targetPath + ".contextspin.bak";
   if (fs.existsSync(backupPath)) {
     const backup = await readJsonSafe(backupPath, null);
     if (backup && typeof backup === "object") {
-      await writeJsonAtomic(CLAUDE_SETTINGS_PATH, backup);
+      await writeJsonAtomic(targetPath, backup);
       try {
         await fsp.unlink(backupPath);
       } catch {
         // best effort
       }
+      await removePrevEntry(key);
       return {
         removed: true,
         restored: true,
-        settingsPath: CLAUDE_SETTINGS_PATH,
+        settingsPath: targetPath,
+        scope,
         note: "Restored previous Claude settings from backup.",
       };
     }
   }
 
+  // No backup: JSON-merge to delete just our statusLine key (preserve the rest).
   delete settings.statusLine;
-  await writeJsonAtomic(CLAUDE_SETTINGS_PATH, settings);
+  await writeJsonAtomic(targetPath, settings);
+  await removePrevEntry(key);
   return {
     removed: true,
     restored: false,
-    settingsPath: CLAUDE_SETTINGS_PATH,
+    settingsPath: targetPath,
+    scope,
     note: "Removed the ContextSpin statusLine entry.",
   };
 }