ai-lens 0.8.35 → 0.8.37

package/.commithash

@@ -1 +1 @@
-b3f67d5
+888a8ca

package/README.md

@@ -21,6 +21,18 @@ This will:
 
 Re-running is safe — it updates outdated hooks and skips current ones.
 
+### Deploying hooks in a specific project (project-level hooks)
+
+To write hooks into the project directory (`.cursor/hooks.json` and `.claude/settings.json`) instead of global `~/.cursor/` and `~/.claude/`, run from the project root:
+
+```bash
+npx git+ssh://git@rantsports.gitlab.yandexcloud.net:ai-first-workspace/internal/analytics/ai-lens.git init --server https://ai-lens.rantsports.com --no-mcp --project-hooks
+```
+
+Add `--use-repo-path` to run `capture.js` directly from the package (repo or npx cache) instead of copying to `~/.ai-lens/client/`. Useful when the repo is next to the workspace.
+
+Hooks use the path `~/.ai-lens/client/capture.js` by default (or the package path with `--use-repo-path`); the config can be committed to the repo.
+
 Configure the server URL and optionally filter projects:
 
 ```bash

package/bin/ai-lens.js

@@ -39,6 +39,7 @@ switch (command) {
     console.log('    --server URL    Server URL (default: saved or http://localhost:3000)');
     console.log('    --yes, -y       Non-interactive: accept all defaults, no prompts');
     console.log('    --projects LIST Comma-separated project paths to track');
+    console.log('    --no-hooks      Skip writing hooks and MCP (config + auth only)');
     console.log('    --no-mcp        Skip MCP server registration');
     console.log('    --mcp-scope S   MCP scope: user, local, or project (default: user)');
     console.log('  remove          Remove AI Lens hooks and client files');

package/cli/hooks.js

@@ -30,6 +30,9 @@ const CONFIG_PATH = join(homedir(), '.ai-lens', 'config.json');
 // Hooks always point to the installed copy at ~/.ai-lens/client/capture.js
 export const CAPTURE_PATH = join(CLIENT_INSTALL_DIR, 'capture.js');
 
+/** Path to capture.js in this package (repo or npx cache). Use with --use-repo-path to run from source. */
+export const REPO_CAPTURE_PATH = join(PKG_ROOT, 'client', 'capture.js');
+
 // ---------------------------------------------------------------------------
 // AI Lens config (~/.ai-lens/config.json)
 // ---------------------------------------------------------------------------
@@ -99,23 +102,33 @@ function findStableNodePath() {
   return '/usr/bin/env node';
 }
 
-export function captureCommand() {
+/**
+ * @param {boolean} [useTilde] - If true, use ~/.ai-lens/client/capture.js (for project-level hooks so path is portable).
+ * @param {boolean} [rawPath] - If true, do not quote the path (for Claude Code config; path written without quotes).
+ * @param {string} [customPath] - If set, use this path (e.g. REPO_CAPTURE_PATH for --use-repo-path); rawPath implied.
+ */
+export function captureCommand(useTilde = false, rawPath = false, customPath = null) {
   const nodePath = findStableNodePath();
-  // Normalize to forward slashes: both cmd.exe and Node.js accept forward slashes on Windows,
-  // and bash-layer environments (e.g. Git Bash) misinterpret backslashes as escape sequences.
-  const capturePath = CAPTURE_PATH.replace(/\\/g, '/');
-  const escaped = shellEscape(capturePath);
-  // /usr/bin/env doesn't need shell-escaping, but named paths do
+  const capturePath = customPath != null
+    ? customPath.replace(/\\/g, '/')
+    : useTilde
+      ? '~/.ai-lens/client/capture.js'
+      : CAPTURE_PATH.replace(/\\/g, '/');
+  const pathPart = (customPath != null || rawPath) ? capturePath : shellEscape(capturePath);
   return nodePath === '/usr/bin/env node'
-    ? `/usr/bin/env node ${escaped}`
-    : `${shellEscape(nodePath.replace(/\\/g, '/'))} ${escaped}`;
+    ? `/usr/bin/env node ${pathPart}`
+    : `${shellEscape(nodePath.replace(/\\/g, '/'))} ${pathPart}`;
 }
 
 // Cursor on Windows executes hooks via PowerShell, which treats a quoted path like
 // "node.exe" as a string expression, not a command invocation. The & (call) operator
 // is required. Claude Code uses bash or cmd.exe where & is not needed (and breaks bash).
-export function cursorCaptureCommand() {
-  const cmd = captureCommand();
+/**
+ * @param {boolean} [useTilde] - If true, use ~/.ai-lens/client/capture.js (for --project-hooks).
+ * @param {string} [customPath] - If set, use this path (e.g. REPO_CAPTURE_PATH for --use-repo-path).
+ */
+export function cursorCaptureCommand(useTilde = false, customPath = null) {
+  const cmd = customPath != null ? captureCommand(false, true, customPath) : captureCommand(useTilde);
   return process.platform === 'win32' ? `& ${cmd}` : cmd;
 }
 
@@ -164,36 +177,97 @@ export function removeClientFiles() {
 // Hook definitions per tool
 // ---------------------------------------------------------------------------
 
+// Use tilde path (~/.ai-lens/...) so settings are portable (no absolute paths).
 const CLAUDE_CODE_HOOKS = {
-  SessionStart: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand() }] }),
-  SessionEnd: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand() }] }),
-  UserPromptSubmit: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand() }] }),
-  PreToolUse: () => ({ matcher: 'EnterPlanMode|ExitPlanMode', hooks: [{ type: 'command', command: captureCommand() }] }),
-  PostToolUse: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand() }] }),
-  PostToolUseFailure: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand() }] }),
-  Stop: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand() }] }),
-  PreCompact: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand() }] }),
-  SubagentStart: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand() }] }),
-  SubagentStop: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand() }] }),
+  SessionStart: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand(true, true) }] }),
+  SessionEnd: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand(true, true) }] }),
+  UserPromptSubmit: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand(true, true) }] }),
+  PreToolUse: () => ({ matcher: 'EnterPlanMode|ExitPlanMode', hooks: [{ type: 'command', command: captureCommand(true, true) }] }),
+  PostToolUse: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand(true, true) }] }),
+  PostToolUseFailure: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand(true, true) }] }),
+  Stop: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand(true, true) }] }),
+  PreCompact: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand(true, true) }] }),
+  SubagentStart: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand(true, true) }] }),
+  SubagentStop: () => ({ matcher: '', hooks: [{ type: 'command', command: captureCommand(true, true) }] }),
 };
 
+// Use tilde path (~/.ai-lens/...) so settings are portable (no absolute paths).
 const CURSOR_HOOKS = {
-  sessionStart: () => ({ command: cursorCaptureCommand() }),
-  beforeSubmitPrompt: () => ({ command: cursorCaptureCommand() }),
-  postToolUse: () => ({ command: cursorCaptureCommand() }),
-  postToolUseFailure: () => ({ command: cursorCaptureCommand() }),
-  afterFileEdit: () => ({ command: cursorCaptureCommand() }),
-  afterShellExecution: () => ({ command: cursorCaptureCommand() }),
-  afterMCPExecution: () => ({ command: cursorCaptureCommand() }),
-  subagentStart: () => ({ command: cursorCaptureCommand() }),
-  subagentStop: () => ({ command: cursorCaptureCommand() }),
-  preCompact: () => ({ command: cursorCaptureCommand() }),
-  afterAgentResponse: () => ({ command: cursorCaptureCommand() }),
-  afterAgentThought: () => ({ command: cursorCaptureCommand() }),
-  stop: () => ({ command: cursorCaptureCommand() }),
-  sessionEnd: () => ({ command: cursorCaptureCommand() }),
+  sessionStart: () => ({ command: cursorCaptureCommand(true) }),
+  beforeSubmitPrompt: () => ({ command: cursorCaptureCommand(true) }),
+  postToolUse: () => ({ command: cursorCaptureCommand(true) }),
+  postToolUseFailure: () => ({ command: cursorCaptureCommand(true) }),
+  afterFileEdit: () => ({ command: cursorCaptureCommand(true) }),
+  afterShellExecution: () => ({ command: cursorCaptureCommand(true) }),
+  afterMCPExecution: () => ({ command: cursorCaptureCommand(true) }),
+  subagentStart: () => ({ command: cursorCaptureCommand(true) }),
+  subagentStop: () => ({ command: cursorCaptureCommand(true) }),
+  preCompact: () => ({ command: cursorCaptureCommand(true) }),
+  afterAgentResponse: () => ({ command: cursorCaptureCommand(true) }),
+  afterAgentThought: () => ({ command: cursorCaptureCommand(true) }),
+  stop: () => ({ command: cursorCaptureCommand(true) }),
+  sessionEnd: () => ({ command: cursorCaptureCommand(true) }),
 };
 
+// Same as CURSOR_HOOKS but command uses ~/.ai-lens/... (for --project-hooks)
+const CURSOR_HOOKS_TILDE = Object.fromEntries(
+  Object.keys(CURSOR_HOOKS).map(k => [k, () => ({ command: cursorCaptureCommand(true) })]),
+);
+
+// Same as CLAUDE_CODE_HOOKS but command uses ~/.ai-lens/... (for --project-hooks), path without quotes
+const CLAUDE_CODE_HOOKS_TILDE = {};
+for (const [k, fn] of Object.entries(CLAUDE_CODE_HOOKS)) {
+  CLAUDE_CODE_HOOKS_TILDE[k] = () => {
+    const r = fn();
+    r.hooks[0].command = captureCommand(true, true);
+    return r;
+  };
+}
+
+/**
+ * Claude Code hook defs that point to a custom path (e.g. REPO_CAPTURE_PATH for --use-repo-path).
+ * @param {string} capturePath - Absolute path to client/capture.js.
+ */
+export function getClaudeCodeHookDefsWithPath(capturePath) {
+  const cmd = captureCommand(false, true, capturePath);
+  return {
+    SessionStart: () => ({ matcher: '', hooks: [{ type: 'command', command: cmd }] }),
+    SessionEnd: () => ({ matcher: '', hooks: [{ type: 'command', command: cmd }] }),
+    UserPromptSubmit: () => ({ matcher: '', hooks: [{ type: 'command', command: cmd }] }),
+    PreToolUse: () => ({ matcher: 'EnterPlanMode|ExitPlanMode', hooks: [{ type: 'command', command: cmd }] }),
+    PostToolUse: () => ({ matcher: '', hooks: [{ type: 'command', command: cmd }] }),
+    PostToolUseFailure: () => ({ matcher: '', hooks: [{ type: 'command', command: cmd }] }),
+    Stop: () => ({ matcher: '', hooks: [{ type: 'command', command: cmd }] }),
+    PreCompact: () => ({ matcher: '', hooks: [{ type: 'command', command: cmd }] }),
+    SubagentStart: () => ({ matcher: '', hooks: [{ type: 'command', command: cmd }] }),
+    SubagentStop: () => ({ matcher: '', hooks: [{ type: 'command', command: cmd }] }),
+  };
+}
+
+/**
+ * Cursor hook defs that point to a custom path (e.g. REPO_CAPTURE_PATH for --use-repo-path).
+ * @param {string} capturePath - Absolute path to client/capture.js.
+ */
+export function getCursorHookDefsWithPath(capturePath) {
+  const command = cursorCaptureCommand(false, capturePath);
+  return {
+    sessionStart: () => ({ command }),
+    beforeSubmitPrompt: () => ({ command }),
+    postToolUse: () => ({ command }),
+    postToolUseFailure: () => ({ command }),
+    afterFileEdit: () => ({ command }),
+    afterShellExecution: () => ({ command }),
+    afterMCPExecution: () => ({ command }),
+    subagentStart: () => ({ command }),
+    subagentStop: () => ({ command }),
+    preCompact: () => ({ command }),
+    afterAgentResponse: () => ({ command }),
+    afterAgentThought: () => ({ command }),
+    stop: () => ({ command }),
+    sessionEnd: () => ({ command }),
+  };
+}
+
 export const TOOL_CONFIGS = [
   {
     name: 'Claude Code',
@@ -229,6 +303,28 @@ export function getCursorToolConfig(projectRoot, label = 'Cursor (project)') {
     name: label,
     dirPath: join(projectRoot, '.cursor'),
     configPath: join(projectRoot, '.cursor', 'hooks.json'),
+    hookDefs: CURSOR_HOOKS_TILDE,
+  };
+}
+
+/**
+ * Claude Code tool config with hooks in project's .claude/ instead of ~/.claude/.
+ * Use for init (--project-hooks) and remove (when project has .claude/settings.json with AI Lens).
+ * @param {string} projectRoot - Absolute path to project root (e.g. process.cwd()).
+ * @param {string} [label] - Display name (default: 'Claude Code (project)').
+ * @returns {{ name: string, dirPath: string, configPath: string, hookDefs: object, topLevelFields: object, sharedConfig: boolean, legacyConfigPaths: array }}
+ */
+export function getClaudeCodeToolConfig(projectRoot, label = 'Claude Code (project)') {
+  const base = TOOL_CONFIGS.find(t => t.name === 'Claude Code');
+  if (!base) return null;
+  return {
+    ...base,
+    name: label,
+    dirPath: join(projectRoot, '.claude'),
+    configPath: join(projectRoot, '.claude', 'settings.json'),
+    hookDefs: CLAUDE_CODE_HOOKS_TILDE,
+    sharedConfig: false,
+    legacyConfigPaths: [],
   };
 }
 
@@ -236,34 +332,39 @@ export function getCursorToolConfig(projectRoot, label = 'Cursor (project)') {
 // AI Lens hook detection
 // ---------------------------------------------------------------------------
 
+// Both ~/.ai-lens/client/capture.js and repo path (e.g. internal/analytics/ai-lens/client/capture.js) are valid.
+function isAiLensCapturePath(cmd) {
+  const n = (cmd || '').replace(/\\/g, '/');
+  return n.includes('.ai-lens/client/capture.js') || n.includes('ai-lens/client/capture.js');
+}
+
 export function isAiLensHook(entry) {
-  // Match by canonical suffix so we also catch Windows 8.3 short-name paths
-  // (e.g. C:/Users/08A4~1/.ai-lens/...) that differ from homedir().
-  const SUFFIX = '.ai-lens/client/capture.js';
-  const matches = cmd => cmd.replace(/\\/g, '/').includes(SUFFIX);
   // Flat format (Cursor): { command: "..." }
-  if (matches(entry?.command || '')) return true;
+  if (isAiLensCapturePath(entry?.command || '')) return true;
   // Nested format (Claude Code): { matcher, hooks: [{ command: "..." }] }
   if (Array.isArray(entry?.hooks)) {
-    return entry.hooks.some(h => matches(h?.command || ''));
+    return entry.hooks.some(h => isAiLensCapturePath(h?.command || ''));
   }
   return false;
 }
 
 function isCurrentAiLensHook(entry, expected) {
-  // Extract expected command from the hook definition (supports per-tool commands,
-  // e.g. Cursor uses & prefix on Windows for PowerShell, Claude Code does not).
-  const expected_cmd = expected?.command
-    || expected?.hooks?.[0]?.command
-    || captureCommand(); // fallback
-  // Normalize separators so hooks installed before path-normalization fix still match
+  // Any valid AI Lens capture path is "current" (tilde or repo path from --use-repo-path).
   const norm = s => (s || '').replace(/\\/g, '/');
   // Flat format (Cursor)
-  if (norm(entry?.command) === norm(expected_cmd)) return true;
-  // Nested format (Claude Code): command + matcher must match
+  if (entry?.command != null) {
+    if (isAiLensCapturePath(entry.command)) return true;
+    if (norm(entry.command) === norm(expected?.command || expected?.hooks?.[0]?.command || '')) return true;
+    return false;
+  }
+  // Nested format (Claude Code): valid path + matcher must match when expected has matcher
   if (Array.isArray(entry?.hooks)) {
-    if (!entry.hooks.some(h => norm(h?.command) === norm(expected_cmd))) return false;
-    // Matcher must match expected definition (e.g. PreToolUse needs specific tool filter)
+    const hasValidPath = entry.hooks.some(h => isAiLensCapturePath(h?.command));
+    if (!hasValidPath && !entry.hooks.some(h => norm(h?.command) === norm(expected?.hooks?.[0]?.command || ''))) return false;
+    if (!hasValidPath) {
+      if (expected?.matcher !== undefined && entry.matcher !== expected.matcher) return false;
+      return true;
+    }
     if (expected?.matcher !== undefined && entry.matcher !== expected.matcher) return false;
     return true;
   }

package/cli/init.js

@@ -1,7 +1,7 @@
 import { createInterface } from 'node:readline';
 import { execSync, spawn } from 'node:child_process';
 import { existsSync, copyFileSync, readdirSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { join, resolve, relative } from 'node:path';
 import { homedir } from 'node:os';
 import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
@@ -13,9 +13,10 @@ import {
 import { getGitIdentity } from '../client/config.js';
 import { migrateIfNeeded } from '../client/sender.js';
 import {
-  CAPTURE_PATH, detectInstalledTools, getCursorToolConfig,
+  CAPTURE_PATH, REPO_CAPTURE_PATH, detectInstalledTools, getCursorToolConfig, getClaudeCodeToolConfig,
   analyzeToolHooks, buildMergedConfig, writeHooksConfig, describePlan,
   installClientFiles, readLensConfig, saveLensConfig, getVersionInfo,
+  getClaudeCodeHookDefsWithPath, getCursorHookDefsWithPath,
   cleanupLegacyHooks, cleanupEmptyMcpJson, addCursorMcp, removeCursorMcp,
   checkHooksDisabled, enableHooks,
 } from './hooks.js';
@@ -298,9 +299,15 @@ function getInitArgs() {
       case '--no-mcp':
         flags.noMcp = true;
         break;
+      case '--no-hooks':
+        flags.noHooks = true;
+        break;
       case '--project-hooks':
         flags.projectHooks = true;
         break;
+      case '--use-repo-path':
+        flags.useRepoPath = true;
+        break;
       case '--mcp-scope':
         if (i + 1 < args.length) flags.mcpScope = args[++i];
         else process.stderr.write('Warning: --mcp-scope requires a value\n');
@@ -309,7 +316,7 @@ function getInitArgs() {
         const a = args[i];
         if (a.startsWith('-')) {
           process.stderr.write(`Warning: unknown flag "${a}" — did you mean --${a.replace(/^-+/, '')}?\n`);
-        } else if (['server', 'projects', 'yes', 'no-mcp', 'project-hooks', 'mcp-scope'].includes(a)) {
+        } else if (['server', 'projects', 'yes', 'no-mcp', 'no-hooks', 'project-hooks', 'use-repo-path', 'mcp-scope'].includes(a)) {
           process.stderr.write(`Warning: unexpected argument "${a}" — did you mean --${a}?\n`);
         }
       }
@@ -334,15 +341,48 @@ export default async function init() {
   heading('Detecting installed AI tools...');
   let tools = detectInstalledTools();
 
-  // When --project-hooks: put Cursor hooks in project's .cursor/ instead of ~/.cursor/
+  // When --project-hooks: put Cursor and Claude Code hooks in project's .cursor/ and .claude/ instead of ~/
   if (flags.projectHooks) {
     const projectRoot = resolve(process.cwd());
     const cursorProject = getCursorToolConfig(projectRoot);
+    const claudeProject = getClaudeCodeToolConfig(projectRoot);
     if (cursorProject) {
       tools = tools.filter(t => t.name !== 'Cursor');
       tools.push(cursorProject);
       info('  Cursor hooks will be written to this project (.cursor/hooks.json).');
     }
+    if (claudeProject) {
+      tools = tools.filter(t => t.name !== 'Claude Code');
+      tools.push(claudeProject);
+      info('  Claude Code hooks will be written to this project (.claude/settings.json).');
+    }
+  }
+
+  // When --use-repo-path: run capture.js from this package; in hooks use relative or tilde path (never absolute).
+  if (flags.useRepoPath) {
+    if (!existsSync(REPO_CAPTURE_PATH)) {
+      error(`  --use-repo-path: capture.js not found at ${REPO_CAPTURE_PATH}`);
+      process.exit(1);
+    }
+    const repoPathAbs = resolve(REPO_CAPTURE_PATH);
+    const home = homedir();
+    let pathInHooks;
+    if (flags.projectHooks) {
+      const projectRoot = resolve(process.cwd());
+      pathInHooks = relative(projectRoot, repoPathAbs).replace(/\\/g, '/');
+      info('  Project hooks will use relative path to capture.js (from project root).');
+    } else {
+      pathInHooks = repoPathAbs.startsWith(home)
+        ? ('~' + repoPathAbs.slice(home.length)).replace(/\\/g, '/')
+        : repoPathAbs.replace(/\\/g, '/');
+      info('  Hooks will point to capture.js in this package (portable path).');
+    }
+    for (const tool of tools) {
+      if (tool.name.startsWith('Claude Code')) tool.hookDefs = getClaudeCodeHookDefsWithPath(pathInHooks);
+      else if (tool.name.startsWith('Cursor')) tool.hookDefs = getCursorHookDefsWithPath(pathInHooks);
+    }
+  } else if (flags.projectHooks) {
+    info('  Project hooks use path ~/.ai-lens/client/capture.js.');
   }
 
   if (tools.length === 0) {
@@ -421,14 +461,18 @@ export default async function init() {
   // Build new config in memory — saved after "Proceed?" confirmation
   const newConfig = { ...currentConfig, serverUrl, projects };
 
-  // Install client files to ~/.ai-lens/client/
-  heading('Installing client files...');
-  try {
-    installClientFiles();
-    success('  Copied client files to ~/.ai-lens/client/');
-  } catch (err) {
-    error(`  Failed to install client files: ${err.message}`);
-    return;
+  // Install client files to ~/.ai-lens/client/ (skip when --use-repo-path)
+  if (!flags.useRepoPath) {
+    heading('Installing client files...');
+    try {
+      installClientFiles();
+      success('  Copied client files to ~/.ai-lens/client/');
+    } catch (err) {
+      error(`  Failed to install client files: ${err.message}`);
+      return;
+    }
+  } else {
+    detail('  Skipping client install (--use-repo-path: using package copy).');
   }
 
   // Authentication
@@ -486,163 +530,168 @@ export default async function init() {
     }
   }
 
-  // Analyze each tool
-  heading('Analyzing hook configurations...');
-  const analyses = tools.map(tool => ({
-    tool,
-    analysis: analyzeToolHooks(tool),
-  }));
-
-  for (const { tool, analysis } of analyses) {
-    const labels = {
-      fresh: 'no hooks.json — will create',
-      current: 'AI Lens hooks up-to-date',
-      outdated: 'AI Lens hooks need updating',
-      absent: 'hooks.json exists, no AI Lens hooks — will add',
-      malformed: `hooks.json malformed — backed up, will recreate`,
-    };
-    const label = labels[analysis.status] || analysis.status;
-    if (analysis.status === 'current') {
-      success(`  ${tool.name}: ${label}`);
-    } else if (analysis.status === 'malformed') {
-      warn(`  ${tool.name}: ${label}`);
-    } else {
-      info(`  ${tool.name}: ${label}`);
-    }
-  }
-  blank();
-
-  // Filter to tools that need changes
-  const pending = analyses.filter(a => a.analysis.status !== 'current');
-
-  if (pending.length === 0) {
+  if (flags.noHooks) {
+    info('--no-hooks: skipping hook configuration and MCP setup');
     saveLensConfig(newConfig);
-
-    // Clean up legacy hook locations (safe: hooks are already current)
-    for (const { tool } of analyses) {
-      try {
-        for (const lr of cleanupLegacyHooks(tool)) {
-          success(`  ${tool.name}: ${lr.action} legacy hooks in ${lr.path}`);
-        }
-      } catch (err) {
-        // non-fatal — hooks are current, legacy cleanup is best-effort
-      }
-    }
-
-    success('Hooks are up-to-date.');
   } else {
-    // Show plan
-    heading('Plan:');
-    for (const { tool, analysis } of pending) {
-      const plan = describePlan(tool, analysis);
-      if (!plan) continue;
-      info(`  ${plan.description}`);
+    // Analyze each tool
+    heading('Analyzing hook configurations...');
+    const analyses = tools.map(tool => ({
+      tool,
+      analysis: analyzeToolHooks(tool),
+    }));
+
+    for (const { tool, analysis } of analyses) {
+      const labels = {
+        fresh: 'no hooks.json — will create',
+        current: 'AI Lens hooks up-to-date',
+        outdated: 'AI Lens hooks need updating',
+        absent: 'hooks.json exists, no AI Lens hooks — will add',
+        malformed: `hooks.json malformed — backed up, will recreate`,
+      };
+      const label = labels[analysis.status] || analysis.status;
+      if (analysis.status === 'current') {
+        success(`  ${tool.name}: ${label}`);
+      } else if (analysis.status === 'malformed') {
+        warn(`  ${tool.name}: ${label}`);
+      } else {
+        info(`  ${tool.name}: ${label}`);
+      }
     }
     blank();
 
-    // Confirm
-    if (!auto) {
-      const answer = await ask('Proceed? [Y/n] ');
-      if (answer && !['y', 'yes'].includes(answer.toLowerCase())) {
-        info('Aborted.');
-        return;
-      }
-    }
+    // Filter to tools that need changes
+    const pending = analyses.filter(a => a.analysis.status !== 'current');
 
-    // Apply
-    heading('Applying changes...');
-    const results = [];
+    if (pending.length === 0) {
+      saveLensConfig(newConfig);
 
-    for (const { tool, analysis } of pending) {
-      try {
-        // Backup malformed shared configs (e.g. ~/.claude/settings.json) before overwriting
-        if (analysis.status === 'malformed' && tool.sharedConfig) {
-          try { copyFileSync(tool.configPath, tool.configPath + '.bak'); } catch { /* file may be gone */ }
+      // Clean up legacy hook locations (safe: hooks are already current)
+      for (const { tool } of analyses) {
+        try {
+          for (const lr of cleanupLegacyHooks(tool)) {
+            success(`  ${tool.name}: ${lr.action} legacy hooks in ${lr.path}`);
+          }
+        } catch (err) {
+          // non-fatal — hooks are current, legacy cleanup is best-effort
         }
-        const existingConfig = analysis.config || null;
-        const merged = buildMergedConfig(tool, existingConfig);
-        writeHooksConfig(tool, merged);
-        success(`  ${tool.name}: done`);
-        results.push({ tool: tool.name, ok: true });
-      } catch (err) {
-        error(`  ${tool.name}: failed — ${err.message}`);
-        results.push({ tool: tool.name, ok: false, error: err.message });
       }
-    }
 
-    // Persist config only after hooks are written — avoids inconsistency where
-    // config has new serverUrl/projects but hooks still use old commands.
-    saveLensConfig(newConfig);
+      success('Hooks are up-to-date.');
+    } else {
+      // Show plan
+      heading('Plan:');
+      for (const { tool, analysis } of pending) {
+        const plan = describePlan(tool, analysis);
+        if (!plan) continue;
+        info(`  ${plan.description}`);
+      }
+      blank();
 
-    // Verify hooks were written correctly
-    heading('Verifying hooks...');
-    let verifyFailed = false;
-    for (const { tool } of pending) {
-      const recheck = analyzeToolHooks(tool);
-      if (recheck.status === 'current') {
-        success(`  ${tool.name}: hooks verified`);
-      } else {
-        error(`  ${tool.name}: hooks not current (status: ${recheck.status})`);
-        verifyFailed = true;
+      // Confirm
+      if (!auto) {
+        const answer = await ask('Proceed? [Y/n] ');
+        if (answer && !['y', 'yes'].includes(answer.toLowerCase())) {
+          info('Aborted.');
+          return;
+        }
       }
-    }
 
-    // Clean up legacy hook locations only AFTER new hooks are verified.
-    // Without this guard, a failed write would delete working legacy hooks,
-    // leaving the user with no hooks at all.
-    if (!verifyFailed) {
-      for (const { tool } of analyses) {
+      // Apply
+      heading('Applying changes...');
+      const results = [];
+
+      for (const { tool, analysis } of pending) {
         try {
-          for (const lr of cleanupLegacyHooks(tool)) {
-            success(`  ${tool.name}: ${lr.action} legacy hooks in ${lr.path}`);
+          // Backup malformed shared configs (e.g. ~/.claude/settings.json) before overwriting
+          if (analysis.status === 'malformed' && tool.sharedConfig) {
+            try { copyFileSync(tool.configPath, tool.configPath + '.bak'); } catch { /* file may be gone */ }
           }
+          const existingConfig = analysis.config || null;
+          const merged = buildMergedConfig(tool, existingConfig);
+          writeHooksConfig(tool, merged);
+          success(`  ${tool.name}: done`);
+          results.push({ tool: tool.name, ok: true });
         } catch (err) {
-          // non-fatal — hooks are verified, legacy cleanup is best-effort
+          error(`  ${tool.name}: failed — ${err.message}`);
+          results.push({ tool: tool.name, ok: false, error: err.message });
         }
       }
-    }
 
-    // Summary
-    heading('Summary');
-    for (const r of results) {
-      if (r.ok) {
-        success(`  ${r.tool}: configured`);
-      } else {
-        error(`  ${r.tool}: failed (${r.error})`);
+      // Persist config only after hooks are written — avoids inconsistency where
+      // config has new serverUrl/projects but hooks still use old commands.
+      saveLensConfig(newConfig);
+
+      // Verify hooks were written correctly
+      heading('Verifying hooks...');
+      let verifyFailed = false;
+      for (const { tool } of pending) {
+        const recheck = analyzeToolHooks(tool);
+        if (recheck.status === 'current') {
+          success(`  ${tool.name}: hooks verified`);
+        } else {
+          error(`  ${tool.name}: hooks not current (status: ${recheck.status})`);
+          verifyFailed = true;
+        }
       }
-    }
-    if (results.some(r => !r.ok) || verifyFailed) {
-      process.exitCode = 1;
-    }
-  }
 
-  // Enable hooks if globally disabled (e.g. disableAllHooks in settings.local.json)
-  for (const { tool } of analyses) {
-    const disabled = checkHooksDisabled(tool);
-    if (disabled.length > 0) {
-      for (const d of disabled) {
-        warn(`  ${tool.name}: hooks disabled by disableAllHooks in ${d.filePath}`);
+      // Clean up legacy hook locations only AFTER new hooks are verified.
+      // Without this guard, a failed write would delete working legacy hooks,
+      // leaving the user with no hooks at all.
+      if (!verifyFailed) {
+        for (const { tool } of analyses) {
+          try {
+            for (const lr of cleanupLegacyHooks(tool)) {
+              success(`  ${tool.name}: ${lr.action} legacy hooks in ${lr.path}`);
+            }
+          } catch (err) {
+            // non-fatal — hooks are verified, legacy cleanup is best-effort
+          }
+        }
       }
-      let shouldFix;
-      if (auto) {
-        shouldFix = true;
-      } else {
-        const answer = await ask('Remove disableAllHooks to enable hooks? [Y/n] ');
-        shouldFix = !answer || ['y', 'yes'].includes(answer.toLowerCase());
+
+      // Summary
+      heading('Summary');
+      for (const r of results) {
+        if (r.ok) {
+          success(`  ${r.tool}: configured`);
+        } else {
+          error(`  ${r.tool}: failed (${r.error})`);
+        }
       }
-      if (shouldFix) {
+      if (results.some(r => !r.ok) || verifyFailed) {
+        process.exitCode = 1;
+      }
+    }
+
+    // Enable hooks if globally disabled (e.g. disableAllHooks in settings.local.json)
+    for (const { tool } of analyses) {
+      const disabled = checkHooksDisabled(tool);
+      if (disabled.length > 0) {
         for (const d of disabled) {
-          try {
-            enableHooks(d.filePath);
-            success(`  Removed disableAllHooks from ${d.filePath}`);
-          } catch (err) {
-            error(`  Could not fix ${d.filePath}: ${err.message}`);
+          warn(`  ${tool.name}: hooks disabled by disableAllHooks in ${d.filePath}`);
+        }
+        let shouldFix;
+        if (auto) {
+          shouldFix = true;
+        } else {
+          const answer = await ask('Remove disableAllHooks to enable hooks? [Y/n] ');
+          shouldFix = !answer || ['y', 'yes'].includes(answer.toLowerCase());
+        }
+        if (shouldFix) {
+          for (const d of disabled) {
+            try {
+              enableHooks(d.filePath);
+              success(`  Removed disableAllHooks from ${d.filePath}`);
+            } catch (err) {
+              error(`  Could not fix ${d.filePath}: ${err.message}`);
+            }
           }
+        } else {
+          warn('  Hooks will remain disabled. AI Lens cannot collect events.');
         }
-      } else {
-        warn('  Hooks will remain disabled. AI Lens cannot collect events.');
+        blank();
       }
-      blank();
     }
   }
 
@@ -680,81 +729,79 @@ export default async function init() {
   }
 
   // MCP setup (HTTP transport — auth via OAuth in browser, no token needed)
-  const mcpUrl = `${serverUrl}/mcp`;
-  const setupMcp = !flags.noMcp;
-
-  // Claude Code MCP
-  const claudeDir = join(homedir(), '.claude');
-  const hasClaudeDir = existsSync(claudeDir);
-  let hasClaudeCli = false;
-  try { execSync(process.platform === 'win32' ? 'where claude' : 'which claude', { stdio: 'ignore' }); hasClaudeCli = true; } catch {}
-
-  if (hasClaudeDir && hasClaudeCli) {
-    heading('MCP Server — Claude Code');
-    let doSetup;
-    if (auto || flags.noMcp !== undefined) {
-      doSetup = setupMcp;
-    } else {
-      const mcpAnswer = await ask('Set up AI Lens MCP server in Claude Code? [Y/n] ');
-      doSetup = !mcpAnswer || mcpAnswer.toLowerCase() === 'y';
-    }
-
-    if (doSetup) {
-      let scope;
-      if (flags.mcpScope && ['local', 'project', 'user'].includes(flags.mcpScope)) {
-        scope = flags.mcpScope;
-      } else if (auto) {
-        scope = 'user';
+  if (!flags.noMcp) {
+    const mcpUrl = `${serverUrl}/mcp`;
+
+    // Claude Code MCP
+    const claudeDir = join(homedir(), '.claude');
+    const hasClaudeDir = existsSync(claudeDir);
+    let hasClaudeCli = false;
+    try { execSync(process.platform === 'win32' ? 'where claude' : 'which claude', { stdio: 'ignore' }); hasClaudeCli = true; } catch {}
+
+    if (hasClaudeDir && hasClaudeCli) {
+      heading('MCP Server — Claude Code');
+      let doSetup;
+      if (auto) {
+        doSetup = true;
       } else {
-        const scopeInput = await ask('  Scope — user, local, or project? (Enter = user): ');
-        scope = ['local', 'project', 'user'].includes(scopeInput) ? scopeInput : 'user';
+        const mcpAnswer = await ask('Set up AI Lens MCP server in Claude Code? [Y/n] ');
+        doSetup = !mcpAnswer || mcpAnswer.toLowerCase() === 'y';
       }
-      try {
-        // Remove old stdio-based MCP from all scopes, then add HTTP-based
-        try { execSync('claude mcp remove ai-lens -s local', { stdio: 'ignore', shell: true }); } catch {}
-        try { execSync('claude mcp remove ai-lens -s project', { stdio: 'ignore', shell: true }); } catch {}
-        try { execSync('claude mcp remove ai-lens -s user', { stdio: 'ignore', shell: true }); } catch {}
-        cleanupEmptyMcpJson();
-        // Shell-escape mcpUrl to prevent command injection (value is user-supplied via --server).
-        // cmd.exe escapes quotes by doubling (""); Unix shells use backslash-single-quote.
-        const escapedMcpUrl = process.platform === 'win32'
-          ? `"${mcpUrl.replace(/"/g, '""')}"`
-          : `'${mcpUrl.replace(/'/g, "'\\''")}'`;
-        execSync(
-          `claude mcp add --transport http ai-lens -s ${scope} ${escapedMcpUrl}`,
-          { stdio: 'inherit', shell: true },
-        );
-        success(`  MCP server registered in Claude Code (${scope})`);
-      } catch (err) {
-        error(`  Failed to register MCP server: ${err.message}`);
+
+      if (doSetup) {
+        let scope;
+        if (flags.mcpScope && ['local', 'project', 'user'].includes(flags.mcpScope)) {
+          scope = flags.mcpScope;
+        } else if (auto) {
+          scope = 'user';
+        } else {
+          const scopeInput = await ask('  Scope — user, local, or project? (Enter = user): ');
+          scope = ['local', 'project', 'user'].includes(scopeInput) ? scopeInput : 'user';
+        }
+        try {
+          try { execSync('claude mcp remove ai-lens -s local', { stdio: 'ignore', shell: true }); } catch {}
+          try { execSync('claude mcp remove ai-lens -s project', { stdio: 'ignore', shell: true }); } catch {}
+          try { execSync('claude mcp remove ai-lens -s user', { stdio: 'ignore', shell: true }); } catch {}
+          cleanupEmptyMcpJson();
+          const escapedMcpUrl = process.platform === 'win32'
+            ? `"${mcpUrl.replace(/"/g, '""')}"`
+            : `'${mcpUrl.replace(/'/g, "'\\''")}'`;
+          execSync(
+            `claude mcp add --transport http ai-lens -s ${scope} ${escapedMcpUrl}`,
+            { stdio: 'inherit', shell: true },
+          );
+          success(`  MCP server registered in Claude Code (${scope})`);
+        } catch (err) {
+          error(`  Failed to register MCP server: ${err.message}`);
+        }
+      } else {
+        info('  Skipped');
       }
-    } else {
-      info('  Skipped');
     }
-  }
 
-  // Cursor MCP
-  const cursorDir = join(homedir(), '.cursor');
-  if (existsSync(cursorDir)) {
-    heading('MCP Server — Cursor');
-    let doSetup;
-    if (auto || flags.noMcp !== undefined) {
-      doSetup = setupMcp;
-    } else {
-      const cursorMcpAnswer = await ask('Set up AI Lens MCP server in Cursor? [Y/n] ');
-      doSetup = !cursorMcpAnswer || cursorMcpAnswer.toLowerCase() === 'y';
-    }
+    // Cursor MCP
+    const cursorDir = join(homedir(), '.cursor');
+    if (existsSync(cursorDir)) {
+      heading('MCP Server — Cursor');
+      let doSetup;
+      if (auto) {
+        doSetup = true;
+      } else {
+        const cursorMcpAnswer = await ask('Set up AI Lens MCP server in Cursor? [Y/n] ');
+        doSetup = !cursorMcpAnswer || cursorMcpAnswer.toLowerCase() === 'y';
+      }
 
-    if (doSetup) {
-      try {
-        removeCursorMcp();
-        addCursorMcp(mcpUrl);
-        success('  MCP server registered in Cursor (~/.cursor/mcp.json)');
-      } catch (err) {
-        error(`  Failed to register MCP server: ${err.message}`);
+      if (doSetup) {
+        try {
+          removeCursorMcp();
+          addCursorMcp(mcpUrl);
+          success('  MCP server registered in Cursor (~/.cursor/mcp.json)');
+        } catch (err) {
+          error(`  Failed to register MCP server: ${err.message}`);
+        }
+      } else {
+        info('  Skipped');
       }
-    } else {
-      info('  Skipped');
     }
   }
 

package/cli/remove.js

@@ -8,7 +8,7 @@ import {
   heading, detail, blank, getLogPath,
 } from './logger.js';
 import {
-  detectInstalledTools, getCursorToolConfig, analyzeToolHooks,
+  detectInstalledTools, getCursorToolConfig, getClaudeCodeToolConfig, analyzeToolHooks,
   buildStrippedConfig, writeHooksConfig, removeClientFiles, getVersionInfo,
   cleanupLegacyHooks, cleanupEmptyMcpJson, removeCursorMcp,
 } from './hooks.js';
@@ -31,14 +31,20 @@ export default async function remove() {
   heading(`AI Lens — Remove  v${version} (${commit})`);
   blank();
 
-  // Detect tools with AI Lens hooks (global + project .cursor/hooks.json if present)
+  // Detect tools with AI Lens hooks (global + project .cursor/ and .claude/ if present)
   heading('Scanning for AI Lens hooks...');
   let tools = detectInstalledTools();
-  const projectCursor = getCursorToolConfig(resolve(process.cwd()), 'Cursor (project)');
+  const projectRoot = resolve(process.cwd());
+  const projectCursor = getCursorToolConfig(projectRoot, 'Cursor (project)');
   if (projectCursor && existsSync(projectCursor.configPath)) {
     tools = tools.filter(t => t.name !== 'Cursor' || t.configPath !== projectCursor.configPath);
     tools.push(projectCursor);
   }
+  const projectClaude = getClaudeCodeToolConfig(projectRoot, 'Claude Code (project)');
+  if (projectClaude && existsSync(projectClaude.configPath)) {
+    tools = tools.filter(t => t.name !== 'Claude Code' || t.configPath !== projectClaude.configPath);
+    tools.push(projectClaude);
+  }
   const withHooks = [];
 
   for (const tool of tools) {

package/cli/status.js

@@ -4,7 +4,7 @@ import { join } from 'node:path';
 import { homedir, release as osRelease, arch as osArch } from 'node:os';
 import { randomUUID } from 'node:crypto';
 
-import { getVersionInfo, readLensConfig, detectInstalledTools, analyzeToolHooks, checkHooksDisabled, CAPTURE_PATH, TOOL_CONFIGS } from './hooks.js';
+import { getVersionInfo, readLensConfig, detectInstalledTools, getCursorToolConfig, getClaudeCodeToolConfig, analyzeToolHooks, checkHooksDisabled, CAPTURE_PATH, TOOL_CONFIGS } from './hooks.js';
 import { DATA_DIR, PENDING_DIR, SENDING_DIR, SESSION_PATHS_DIR, LOG_PATH, CAPTURE_LOG_PATH, getGitIdentity } from '../client/config.js';
 import { isLockStale } from '../client/sender.js';
 import { initLogger, info, success, warn, error, heading, blank } from './logger.js';
@@ -82,16 +82,25 @@ function extractHookCommand(tool) {
   return null;
 }
 
+function expandTilde(pathStr) {
+  if (!pathStr || typeof pathStr !== 'string') return pathStr;
+  const home = homedir();
+  if (pathStr === '~') return home;
+  if (pathStr.startsWith('~/')) return join(home, pathStr.slice(2));
+  if (pathStr.startsWith('~\\')) return join(home, pathStr.slice(2));
+  return pathStr;
+}
+
 function validateHookCommandPaths(tool) {
   const command = extractHookCommand(tool);
   if (!command) return null;
 
   const issues = [];
 
-  // Extract capture.js path using 'capture.js' as anchor
+  // Extract capture.js path using 'capture.js' as anchor (expand ~ so existsSync works)
   const captureMatch = command.match(/["']([^"']*capture\.js)["']|(\S*capture\.js)/);
   if (captureMatch) {
-    const capturePath = captureMatch[1] || captureMatch[2];
+    const capturePath = expandTilde(captureMatch[1] || captureMatch[2]);
     if (!existsSync(capturePath)) {
       issues.push(`capture.js not found at: ${capturePath}`);
     }
@@ -103,7 +112,7 @@ function validateHookCommandPaths(tool) {
   if (!cmdForNode.startsWith('/usr/bin/env node')) {
     const nodeMatch = cmdForNode.match(/^["']([^"']+)["']|^(\S+)/);
     if (nodeMatch) {
-      const nodePath = nodeMatch[1] || nodeMatch[2];
+      const nodePath = expandTilde(nodeMatch[1] || nodeMatch[2]);
       if (nodePath !== 'node' && !existsSync(nodePath)) {
         issues.push(`node not found at: ${nodePath}`);
       }
@@ -113,6 +122,21 @@ function validateHookCommandPaths(tool) {
   return issues.length > 0 ? issues : null;
 }
 
+/**
+ * Global tools (detectInstalledTools) plus project-level tools when cwd has .cursor/hooks.json
+ * or .claude/settings.json. Status is assumed to be run from the project root where hooks live.
+ */
+function getToolsForCaptureTest() {
+  const global = detectInstalledTools();
+  const projectRoot = process.cwd();
+  const projectTools = [];
+  const cursorProject = getCursorToolConfig(projectRoot);
+  if (cursorProject && existsSync(cursorProject.configPath)) projectTools.push(cursorProject);
+  const claudeProject = getClaudeCodeToolConfig(projectRoot);
+  if (claudeProject && existsSync(claudeProject.configPath)) projectTools.push(claudeProject);
+  return [...global, ...projectTools];
+}
+
 function checkCaptureRun(installedTools) {
   // Collect commands from ALL installed tools — not just the first found (Issues 8-9).
   // If Claude Code works but Cursor is broken, both must be tested to surface the failure.
@@ -126,8 +150,22 @@ function checkCaptureRun(installedTools) {
     return { ok: null, summary: 'no hook command found', detail: 'Could not find an AI Lens hook command in any tool config' };
   }
 
+  const defaultCaptureScript = join(homedir(), '.ai-lens', 'client', 'capture.js');
+  const repoCaptureScript = join(process.cwd(), 'internal', 'analytics', 'ai-lens', 'client', 'capture.js');
   const toolResults = [];
   for (const { name, command } of toolCommands) {
+    // Prefer capture.js path from this tool's command when it exists; else default; else repo path (status run from workspace root).
+    const captureMatch = command.match(/["']([^"']*capture\.js)["']|(\S*capture\.js)/);
+    const rawPath = captureMatch ? (captureMatch[1] || captureMatch[2]) : null;
+    const fromCommand = rawPath ? expandTilde(rawPath) : null;
+    const captureScript = (fromCommand && existsSync(fromCommand))
+      ? fromCommand
+      : existsSync(defaultCaptureScript)
+        ? defaultCaptureScript
+        : existsSync(repoCaptureScript)
+          ? repoCaptureScript
+          : defaultCaptureScript;
+
     // Unique session_id per tool run so capture.log entries can be matched precisely (Issue 10).
     const testSessionId = 'status-check-' + Date.now() + '-' + Math.random().toString(36).slice(2, 7);
     const testEvent = JSON.stringify({
@@ -136,9 +174,6 @@ function checkCaptureRun(installedTools) {
       stop_reason: 'test',
       cwd: join(homedir(), '.ai-lens-status-check-cwd'),
     });
-    // Use spawnSync with stdin piped directly — avoids shell echo pipe syntax
-    // that fails on Windows (no /usr/bin/env, single-quote handling differs).
-    const captureScript = join(homedir(), '.ai-lens', 'client', 'capture.js');
     const testCmd = `${process.execPath} ${captureScript} < (test event)`;
     let exitOk = false;
     let exitDetail = '';
@@ -191,23 +226,35 @@ function checkCaptureRun(installedTools) {
     try {
       // On Windows, Cursor runs hooks via PowerShell (needs `& "..."` call-operator),
       // but Claude Code runs hooks via bash/cmd (no `&` prefix).
-      // Test each tool with the shell it actually uses.
+      // On non-Windows, strip leading "& " if present (e.g. config copied from Windows) so bash doesn't background the process.
       const isWin = process.platform === 'win32';
       const isCursor = name === 'Cursor';
       const usePS = isWin && isCursor;
+      let shellCommand = !isWin && command.startsWith('& ') ? command.slice(2).trim() : command;
+      // Expand ~ in the command: bash/zsh won't expand ~ inside single quotes,
+      // so replace '~/...' and bare ~/... with the absolute home path.
+      if (!isWin) {
+        const home = homedir();
+        shellCommand = shellCommand
+          .replace(/'~\//g, `'${home}/`)
+          .replace(/"~\//g, `"${home}/`)
+          .replace(/(^|[ =])~\//g, `$1${home}/`);
+      }
+      // If the command's capture.js path doesn't exist, substitute the working path so the shell test can pass (e.g. only repo path exists).
+      if (rawPath && !existsSync(expandTilde(rawPath)) && captureScript !== expandTilde(rawPath)) {
+        const replacement = captureScript.includes(' ') ? `"${captureScript.replace(/"/g, '\\"')}"` : captureScript;
+        shellCommand = shellCommand.replace(rawPath, replacement);
+      }
       const shellResult = spawnSync(
-        usePS ? 'powershell.exe' : isWin ? 'cmd.exe' : command,
+        usePS ? 'powershell.exe' : isWin ? 'cmd.exe' : '/bin/sh',
         usePS ? ['-NoProfile', '-Command', command]
           : isWin ? ['/c', command]
-          : [],
+          : ['-c', shellCommand],
         {
-          // Prepend UTF-8 BOM on Windows — PowerShell adds it when piping stdin,
-          // so we must test that capture.js handles it correctly.
           input: isWin ? '\uFEFF' + shellEvent : shellEvent,
-          shell: !isWin,
           encoding: 'utf-8',
           timeout: 10_000,
-          env: { ...process.env, AI_LENS_PROJECTS: join(homedir(), '.ai-lens-status-check-nonexistent') },
+          env: { ...process.env, AI_LENS_PROJECTS: join(homedir(), '.ai-lens-status-check-nonexistent'), AI_LENS_STATUS_CHECK: '1' },
           windowsHide: true,
         },
       );
@@ -291,11 +338,10 @@ function checkToolVersion(appName) {
     const version = execSafe(`defaults read "${plistPath}" CFBundleShortVersionString 2>/dev/null`);
     if (version) return { ok: true, summary: `v${version}`, detail: `${appName}: v${version}` };
   }
-  // Cross-platform fallback: use spawnSync with shell:true for reliable PATH resolution
-  // on Windows (handles .exe extensions and PATH lookup automatically).
+  // Cross-platform fallback: spawn without shell to avoid DEP0190.
   const cliName = appName.toLowerCase().replace(/\s+/g, '');
   try {
-    const result = spawnSync(cliName, ['--version'], { encoding: 'utf-8', timeout: 5000, shell: true });
+    const result = spawnSync(cliName, ['--version'], { encoding: 'utf-8', timeout: 5000 });
     const version = (result.stdout || result.stderr || '').trim();
     if (result.status === 0 && version) return { ok: true, summary: version, detail: `${appName}: ${version}` };
   } catch {}
@@ -979,25 +1025,32 @@ export default async function status() {
   const configResult = checkConfig();
   printLine('Config', configResult);
 
-  // 6. Hooks per installed tool
+  // 6. Hooks: global + project (Cursor then Claude Code; within each: global then project)
   const installedTools = detectInstalledTools();
-  for (const tool of installedTools) {
-    printLine(tool.name, checkHooks(tool));
+  const toolsWithProject = getToolsForCaptureTest();
+  const toolLabel = (tool) => (TOOL_CONFIGS.includes(tool) ? `${tool.name} (global)` : tool.name);
+  const hooksOrder = (a, b) => {
+    const nameA = toolLabel(a), nameB = toolLabel(b);
+    const cursorFirst = (n) => (n.startsWith('Cursor') ? 0 : 1);
+    const globalFirst = (n) => (n.includes('(global)') ? 0 : 1);
+    return cursorFirst(nameA) - cursorFirst(nameB) || globalFirst(nameA) - globalFirst(nameB);
+  };
+  for (const tool of toolsWithProject.slice().sort(hooksOrder)) {
+    printLine(toolLabel(tool), checkHooks(tool));
   }
-  // Also report tools from TOOL_CONFIGS that aren't installed
-  for (const tool of TOOL_CONFIGS) {
-    if (!installedTools.includes(tool)) {
-      const r = { ok: null, summary: 'not installed', detail: `${tool.name} directory not found at ${tool.dirPath}` };
-      printLine(tool.name, r);
-    }
+  // Global tools not installed (no ~/.cursor or ~/.claude) — same order: Cursor then Claude Code
+  const notInstalled = TOOL_CONFIGS.filter(t => !installedTools.includes(t));
+  for (const tool of notInstalled.sort((a, b) => (a.name === 'Cursor' ? -1 : b.name === 'Cursor' ? 1 : 0))) {
+    const r = { ok: null, summary: 'not installed', detail: `${tool.name} directory not found at ${tool.dirPath}` };
+    printLine(toolLabel(tool), r);
   }
 
   // 7. Queue (before capture test so test event doesn't show as pending)
   const queueResult = checkQueue();
   printLine('Queue', queueResult);
 
-  // 8. Smoke-test the hook command
-  printLine('Capture test', checkCaptureRun(installedTools));
+  // 8. Smoke-test the hook command (global + project)
+  printLine('Capture test', checkCaptureRun(toolsWithProject));
 
   // 9. Sender log
   printLine('Sender log', checkSenderLog());

package/client/capture.js

@@ -585,6 +585,11 @@ function trySpawnSender() {
 // =============================================================================
 
 async function main() {
+  // Skip capture when called from subprocess (e.g. analyze-person-dossier.py)
+  if (process.env.AI_LENS_SKIP === '1') {
+    process.exit(0);
+  }
+
   // Check server is configured
   const serverUrl = getServerUrl();
   if (!serverUrl) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-lens",
-  "version": "0.8.35",
+  "version": "0.8.37",
   "type": "module",
   "description": "Centralized session analytics for AI coding tools",
   "bin": {
@@ -15,6 +15,9 @@
   ],
   "scripts": {
     "prepare": "git rev-parse --short HEAD > .commithash 2>/dev/null || true",
+    "init": "node bin/ai-lens.js init",
+    "remove": "node bin/ai-lens.js remove",
+    "status": "node bin/ai-lens.js status",
     "prestart": "npm install --prefix server",
     "start": "node server/index.js",
     "test": "DATABASE_URL=postgresql://ailens:ailens@localhost:5432/ailens_test vitest run",