ai-lens 0.8.91 → 0.8.93

package/.commithash

@@ -1 +1 @@
-8894c21
+255d9a3

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 History of changes to the `ai-lens` CLI package on npm. New entries go on top. Format: `## X.Y.Z — YYYY-MM-DD`, followed by user-facing bullets.
 
+## 0.8.93 — 2026-06-15
+- fix: on Windows, committed Claude Code project hooks no longer flash a console window that steals focus on every event — the hook command is wrapped in `conhost.exe --headless` (Windows 10 1809+), which runs capture with no visible window while still capturing every event. Older Windows builds and macOS/Linux are unchanged
+
+## 0.8.92 — 2026-06-11
+- fix: when global `~/.claude` hooks are active, `ai-lens init` no longer also installs the `.claude/settings.local.json` platform overlay (and removes a previously-written one) — global hooks already capture every project, and registering both made every hook event fire capture twice
+- improve: `ai-lens status` shows committed other-OS project hooks as healthy ("capture covered by global hooks") when global hooks are doing the work, instead of a false warning
+
 ## 0.8.91 — 2026-06-11
 - fix: Claude Code hooks committed to a repo now work on both Windows and macOS/Linux. A committed `.claude/settings.json` can only carry one OS's `CLAUDE_PROJECT_DIR` syntax, so on the other OS hooks silently captured nothing; `ai-lens init` now writes the running OS's form into `.claude/settings.local.json` (per-machine, auto-gitignored) without touching the shared file
 - improve: `ai-lens status` correctly diagnoses committed project hooks — green when the platform overlay is in place, a clear fix hint when it's missing, and no more false "command path missing" on healthy setups

package/cli/hooks.js

@@ -1,6 +1,6 @@
 import { existsSync, lstatSync, readFileSync, writeFileSync, copyFileSync, renameSync, mkdirSync, rmSync, unlinkSync, chmodSync, readdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
-import { homedir } from 'node:os';
+import { homedir, release } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { execFileSync } from 'node:child_process';
 
@@ -302,6 +302,22 @@ export function writeLauncher({ clientDir = CLIENT_INSTALL_DIR, nodePath, platfo
 // Hook command construction
 // ---------------------------------------------------------------------------
 
+// `conhost.exe --headless` runs a console program with no visible window — the
+// fix for Windows hooks flashing/stealing focus on every event (Claude Code spawns
+// the hook process without CREATE_NO_WINDOW; upstream anthropics/claude-code#61051).
+// Unlike wscript/`-WindowStyle Hidden`, it keeps stdin wired, so capture.js still
+// receives the hook payload. `--headless` requires the modern conhost shipped in
+// Windows 10 1809 (build 17763); on older builds the flag errors, so we gate on it
+// and fall back to the bare-node form (still flashes, but captures).
+const WIN_HEADLESS_MIN_BUILD = 17763;
+
+export function supportsConhostHeadless(osRelease = release()) {
+  // os.release() on Windows looks like '10.0.22631'. Build = the third segment.
+  const m = /^\d+\.\d+\.(\d+)/.exec(String(osRelease || ''));
+  if (!m) return false;
+  return Number(m[1]) >= WIN_HEADLESS_MIN_BUILD;
+}
+
 // Lazy default ctx for callers that don't pass one (legacy tests, TOOL_CONFIGS at
 // import-time). Resolver isn't called at module load — only when captureCommand runs.
 function resolveDefaultCtx() {
@@ -310,6 +326,7 @@ function resolveDefaultCtx() {
     nodeResolution,
     platform: process.platform,
     clientDir: CLIENT_INSTALL_DIR,
+    conhost: process.platform === 'win32' && supportsConhostHeadless(),
   };
 }
 
@@ -340,6 +357,9 @@ export function captureCommand(opts = {}) {
   const clientDir = ctx.clientDir ?? CLIENT_INSTALL_DIR;
   const nodeResolution = ctx.nodeResolution;
   const isWin = platform === 'win32';
+  // Windows-only windowless wrapper (see supportsConhostHeadless). Resolved per-ctx
+  // so a build < 1809 falls back to the bare form. Never applied off Windows.
+  const conhost = isWin && (ctx.conhost ?? supportsConhostHeadless());
   // shell hint distinguishes cmd.exe (Claude Code) from PowerShell (Cursor) on
   // Windows — the two need different escaping for paths with spaces.
   const isPS = shell === 'powershell';
@@ -354,6 +374,13 @@ export function captureCommand(opts = {}) {
   // POSIX shells use $VAR.
   if (projectDirRelPath != null) {
     const rel = projectDirRelPath.replace(/\\/g, '/').replace(/^\.?\/+/, '');
+    if (conhost) {
+      // Windowless form. conhost is the launched image (no cmd.exe shell), so the
+      // path must use $CLAUDE_PROJECT_DIR — Claude Code substitutes that variable
+      // itself before exec on every OS (the %VAR% form would survive unexpanded
+      // since there's no shell to expand it). Verified on Windows 11 / cc 2.1.177.
+      return `conhost.exe --headless node "$CLAUDE_PROJECT_DIR/${rel}"`;
+    }
     const dir = isWin ? '%CLAUDE_PROJECT_DIR%' : '$CLAUDE_PROJECT_DIR';
     return `node "${dir}/${rel}"`;
   }
@@ -945,10 +972,21 @@ function isAcceptableHookCommand(cmd) {
 export function isWrongPlatformProjectDirCommand(cmd, platform = process.platform) {
   if (!isClaudeProjectDirCommand(cmd)) return false;
   const n = (cmd || '').replace(/\\/g, '/');
+  // The conhost windowless form is unambiguously a Windows command (conhost.exe is
+  // Windows-only) and deliberately uses $CLAUDE_PROJECT_DIR — Claude Code substitutes
+  // that itself, so it expands on Windows too. It is therefore correct on win32 and
+  // wrong (won't run) anywhere else; the %VAR% rule below doesn't apply to it.
+  if (isConhostHeadlessCommand(n)) return platform !== 'win32';
   const correctVar = platform === 'win32' ? '%CLAUDE_PROJECT_DIR%' : '$CLAUDE_PROJECT_DIR';
   return !n.includes(correctVar);
 }
 
+// `conhost.exe --headless …` windowless wrapper (Windows). Tolerates an optional
+// `.exe` and arbitrary spacing between the two tokens.
+export function isConhostHeadlessCommand(cmd) {
+  return /(^|[\\/\s])conhost(\.exe)?\s+--headless\b/i.test(String(cmd || '').replace(/\\/g, '/'));
+}
+
 // Whether a hook-config file is committed (tracked) in git. The anti-churn rule
 // (treat both $ and % CLAUDE_PROJECT_DIR forms as current) exists ONLY to keep a
 // COMMITTED cross-platform hook file from being flipped to one OS's syntax and
@@ -1080,6 +1118,43 @@ export function writeClaudeLocalOverlay(tool, opts = {}) {
   return { written: true, localPath: a.localPath };
 }
 
+/**
+ * Whether GLOBAL Claude Code hooks (~/.claude/settings.json) are active on this
+ * machine — current AI Lens hooks and not disabled. When they are, the
+ * settings.local.json platform overlay is redundant: global hooks fire for every
+ * project, and registering both would double-capture each event (collapsed by the
+ * server's content-hash dedup, but pointless client work).
+ * @param {object} [globalTool] — override for tests (defaults to the real ~/.claude tool)
+ */
+export function globalClaudeHooksActive(globalTool = TOOL_CONFIGS.find(t => t.name === 'Claude Code')) {
+  if (!globalTool || !existsSync(globalTool.configPath)) return false;
+  if (analyzeToolHooks(globalTool).status !== 'current') return false;
+  return checkHooksDisabled(globalTool).length === 0;
+}
+
+/**
+ * Strip AI Lens hooks from the settings.local.json overlay (e.g. after global
+ * Claude Code hooks were installed and the overlay became a double-capture source).
+ * Preserves everything else in the file; refuses a malformed file.
+ */
+export function removeClaudeLocalOverlay(tool) {
+  const localPath = claudeLocalSettingsPath(tool);
+  if (!existsSync(localPath)) return { removed: false, reason: 'no settings.local.json' };
+  let config;
+  try {
+    config = JSON.parse(readFileSync(localPath, 'utf-8'));
+  } catch {
+    return { removed: false, reason: `${localPath} is malformed`, localPath };
+  }
+  const hasAiLens = config.hooks && typeof config.hooks === 'object'
+    && Object.values(config.hooks).some(en => Array.isArray(en) && en.some(e => isAiLensHook(e)));
+  if (!hasAiLens) return { removed: false, reason: 'no AI Lens hooks in overlay', localPath };
+  const probe = { ...tool, configPath: localPath, sharedConfig: true };
+  const stripped = buildStrippedConfig(probe, config);
+  writeHooksConfig(probe, stripped ?? {});
+  return { removed: true, localPath };
+}
+
 function isCurrentAiLensHook(entry, expected, opts = {}) {
   // "Current" = a GUI-safe install (launcher OR absolute-node capture.js) OR a
   // committed Claude Code $CLAUDE_PROJECT_DIR project hook. We do NOT require an exact

package/cli/init.js

@@ -15,7 +15,7 @@ import { migrateIfNeeded } from '../client/sender.js';
 import {
   CAPTURE_PATH, REPO_CAPTURE_PATH, detectInstalledTools, getCursorToolConfig, getClaudeCodeToolConfig, getCodexToolConfig,
   analyzeToolHooks, buildMergedConfig, writeHooksConfig, describePlan, enableCodexHookTrust,
-  analyzeClaudeLocalOverlay, writeClaudeLocalOverlay,
+  analyzeClaudeLocalOverlay, writeClaudeLocalOverlay, removeClaudeLocalOverlay, globalClaudeHooksActive,
   installClientFiles, readLensConfig, saveLensConfig, getVersionInfo,
   getClaudeCodeHookDefsWithPath, getClaudeCodeHookDefsWithProjectDir, getCursorHookDefsWithPath, getCodexHookDefsWithPath,
   cleanupLegacyHooks, cleanupOppositeScope, cleanupEmptyMcpJson, addCursorMcp, removeCursorMcp,
@@ -1002,7 +1002,16 @@ export default async function init() {
       const overlayClaudeTool = getClaudeCodeToolConfig(overlayProjectRoot, 'Claude Code (project)', ctx);
       if (overlayClaudeTool && existsSync(overlayClaudeTool.configPath)) {
         const overlay = analyzeClaudeLocalOverlay(overlayClaudeTool);
-        if (overlay.applicable && !overlay.overlayCurrent) {
+        if (overlay.applicable && globalClaudeHooksActive()) {
+          // Global ~/.claude hooks fire for every project — an overlay would only
+          // double-register capture. Make sure it's absent rather than present.
+          const rm = removeClaudeLocalOverlay(overlayClaudeTool);
+          if (rm.removed) {
+            success(`  Claude Code: global hooks cover this project — removed the redundant overlay from ${rm.localPath}`);
+          } else {
+            info('  Claude Code: global hooks cover this project — settings.local.json overlay not needed.');
+          }
+        } else if (overlay.applicable && !overlay.overlayCurrent) {
           const r = writeClaudeLocalOverlay(overlayClaudeTool, { analysis: overlay });
           if (r.written) {
             success(`  Claude Code: committed project hooks use the other OS's CLAUDE_PROJECT_DIR syntax — wrote this OS's form to ${r.localPath} (per-machine, not committed)`);

package/cli/status.js

@@ -7,7 +7,7 @@ import tls from 'node:tls';
 
 import { TLS_TRUST_CODES, tlsCodeOf, tlsVerdictSummary, issuerName } from '../client/tls-trust.js';
 
-import { getVersionInfo, readLensConfig, detectInstalledTools, getCursorToolConfig, getClaudeCodeToolConfig, getCodexToolConfig, analyzeToolHooks, checkHooksDisabled, verifyCodexHookTrust, CAPTURE_PATH, TOOL_CONFIGS, isClaudeProjectDirCommand, analyzeClaudeLocalOverlay, extractProjectDirRelPath } from './hooks.js';
+import { getVersionInfo, readLensConfig, detectInstalledTools, getCursorToolConfig, getClaudeCodeToolConfig, getCodexToolConfig, analyzeToolHooks, checkHooksDisabled, verifyCodexHookTrust, CAPTURE_PATH, TOOL_CONFIGS, isClaudeProjectDirCommand, analyzeClaudeLocalOverlay, extractProjectDirRelPath, globalClaudeHooksActive } from './hooks.js';
 import { DATA_DIR, PENDING_DIR, SENDING_DIR, SESSION_PATHS_DIR, LOG_PATH, CAPTURE_LOG_PATH, LAST_STATUS_REPORT_PATH, getGitIdentity, getMonitoredProjects } from '../client/config.js';
 import { isLockStale } from '../client/sender.js';
 import { initLogger, info, success, warn, error, heading, blank } from './logger.js';
@@ -555,6 +555,13 @@ function checkHooks(tool) {
     if (cmd && isClaudeProjectDirCommand(cmd)) {
       const overlay = analyzeClaudeLocalOverlay(tool);
       if (overlay.applicable) {
+        if (globalClaudeHooksActive()) {
+          return {
+            ok: true,
+            summary: 'committed hooks are for the other OS \u2014 capture covered by global hooks',
+            detail: `${detail}\n\nCommitted settings.json uses the other OS's CLAUDE_PROJECT_DIR syntax (never fires here), but global ~/.claude hooks are active and capture every project \u2014 no overlay needed.`,
+          };
+        }
         if (overlay.overlayCurrent) {
           return {
             ok: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-lens",
-  "version": "0.8.91",
+  "version": "0.8.93",
   "type": "module",
   "description": "Centralized session analytics for AI coding tools",
   "bin": {