ai-lens 0.8.99 → 0.8.102

package/.commithash

@@ -1 +1 @@
-b23bf01
+3747fae

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 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.102 — 2026-06-17
+- fix: the per-machine `settings.local.json` overlay for committed Claude Code hooks now also writes the absolute launcher form on Windows (matching the main install path), so a repo whose tracked `settings.json` carries `$CLAUDE_PROJECT_DIR` hooks captures correctly on Windows without manual fix-up. `ai-lens status`/`init` now flag any leftover `$CLAUDE_PROJECT_DIR`/`%CLAUDE_PROJECT_DIR%` Claude hook on Windows as outdated so it migrates to the absolute form.
+- fix: the Windows windowless hook launcher (`ai-lens-hook.ps1`) now sends the event payload to node as raw UTF-8 bytes (Cyrillic prompts and accented paths are no longer mangled by PowerShell's default codepage) and fails open — on any internal error it exits cleanly and writes nothing to stdout, so a launcher hiccup can never break a Cursor hook or disrupt the session.
+
+## 0.8.101 — 2026-06-17
+- fix: Claude Code hooks on Windows now use an absolute path to capture.js instead of `$CLAUDE_PROJECT_DIR`, which Claude Code does not expand on Windows (the v0.8.100 form failed to find the launcher and, when Cursor also ran the hook, produced a visible error). Capture is restored. Existing installs migrate on the next `ai-lens init` / `/setup`. macOS/Linux keep `$CLAUDE_PROJECT_DIR` (expanded there). Note: a brief console window can still flash on Claude Code hooks on Windows — that's an upstream Claude Code behaviour (it launches the hook shell without hiding the window) and can't be fixed from the hook side
+
+## 0.8.100 — 2026-06-17
+- fix: Claude Code hooks on Windows now actually capture. The previous windowless wrapper (`conhost.exe --headless`) hid the console window but silently swallowed the hook's stdin, so the event payload never reached AI Lens and nothing was recorded. Claude Code now uses the same windowless launcher as Cursor (`ai-lens-hook.ps1`), which both suppresses the window and delivers the payload. Existing installs migrate on the next `ai-lens init` / `/setup`. macOS/Linux unchanged. (The launcher was renamed from `cursor-ai-lens-hook.ps1` since it now serves both tools.)
+
 ## 0.8.99 — 2026-06-17
 - fix: Cursor hooks on Windows no longer flash a console window on every event. The flash was `node.exe` (a console app) allocating its own window when Cursor runs the hook; a new windowless launcher (`cursor-ai-lens-hook.ps1`) starts node with no window and forwards the event to it, so capture keeps working with no flash. Existing Cursor installs migrate automatically on the next `ai-lens init` / `/setup`. macOS/Linux and Claude Code are unchanged
 

package/cli/hooks.js

@@ -295,11 +295,14 @@ 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). Gated by the
-  // `windowless` opt so it's applied to CLAUDE forms only — Cursor/Codex never set it
-  // (no reported flash + unverified conhost+stdin for those tools; ADR 0003 §3.2).
-  // A build < 1809 falls back to the bare form. Never applied off Windows.
-  const conhost = isWin && windowless && (ctx.conhost ?? supportsConhostHeadless());
+  // Windows windowless launcher (ai-lens-hook.ps1). Gated by the `windowless` opt, so
+  // it applies to CLAUDE forms only here — Cursor builds its own launcher form in
+  // cursorCaptureCommand, Codex never sets windowless. We DON'T use conhost.exe
+  // --headless: it hides the window but breaks capture (swallows node's stdin → the
+  // payload never arrives; and for Cursor it corrupts stdout). The launcher uses
+  // ProcessStartInfo + CreateNoWindow + RedirectStandardInput instead — windowless AND
+  // stdin-preserving — and works on all Windows (no ≥1809 requirement). Never off Windows.
+  const winLauncher = isWin && windowless;
   // 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';
@@ -313,14 +316,13 @@ export function captureCommand(opts = {}) {
   // binary or /home/<user> path. Windows Claude Code shells via cmd.exe (%VAR%);
   // POSIX shells use $VAR.
   if (projectDirRelPath != null) {
+    // POSIX/macOS only: bare node + $CLAUDE_PROJECT_DIR (the shell expands $VAR; the
+    // path stays machine-agnostic for committed hooks + cwd-robust). On WINDOWS this
+    // form must NOT be used — Claude Code's hook spawn (Git Bash / PowerShell) does NOT
+    // expand $CLAUDE_PROJECT_DIR nor %CLAUDE_PROJECT_DIR% (verified live: both reached
+    // the shell literally and the path failed). Callers therefore route Windows Claude
+    // hooks to the absolute getClaudeCodeHookDefsWithPath form instead of this one.
     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}"`;
   }
@@ -342,12 +344,15 @@ export function captureCommand(opts = {}) {
     : shellEscape(capturePath, platform);
   const nodeNorm = nodeResolution.path.replace(/\\/g, '/');
 
-  // Windowless (Claude + Windows ≥ 1809): conhost.exe is the launched image and runs
-  // node directly, so it needs neither the cmd.exe `call` nor the PowerShell `&`
-  // wrapper. stdin is forwarded (verified). The node path is always double-quoted on
-  // Windows (it can contain spaces, e.g. C:/Program Files/nodejs/node.exe).
-  if (conhost) {
-    return `conhost.exe --headless "${nodeNorm.replace(/"/g, '""')}" ${pathPart}`;
+  // Windowless (Claude on Windows): run node through the ai-lens-hook.ps1 launcher,
+  // which starts node with CreateNoWindow + forwards stdin (conhost would swallow it).
+  // Claude Code spawns powershell to run the launcher; the payload arrives on the
+  // process's OS stdin, which the launcher reads via [Console]::In. The launcher ships
+  // next to capture.js. node + capture + launcher all double-quoted (may contain spaces).
+  if (winLauncher) {
+    const q = (s) => `"${s.replace(/"/g, '""')}"`;
+    const launcherAbs = capturePath.replace(/[^/]*$/, 'ai-lens-hook.ps1');
+    return `powershell -NoProfile -ExecutionPolicy Bypass -File ${q(launcherAbs)} ${q(nodeNorm)} ${q(capturePath)}`;
   }
   if (isWin && rawPath && nodeNorm.includes(' ')) {
     const quotedNode = `"${nodeNorm.replace(/"/g, '""')}"`;
@@ -371,14 +376,14 @@ export function cursorCaptureCommand(opts = {}) {
   const platform = ctx.platform ?? process.platform;
 
   if (platform === 'win32') {
-    // Windows: route node through the windowless launcher cursor-ai-lens-hook.ps1.
+    // Windows: route node through the windowless launcher ai-lens-hook.ps1.
     // Cursor spawns hooks via a hidden powershell and pipes the payload through the
     // PS pipeline ($input); launching node.exe directly there pops a console window
     // on every event (node is console-subsystem, parent powershell has no console).
     // conhost.exe --headless hides the window but corrupts Cursor's JSON-parse of hook
     // stdout with ConPTY VT codes (verified). The launcher starts node with
     // CreateNoWindow=$true and forwards $input → node stdin: no window, clean stdout.
-    // Form: & "<...>/cursor-ai-lens-hook.ps1" "<absNode>" "<capture.js>"
+    // Form: & "<...>/ai-lens-hook.ps1" "<absNode>" "<capture.js>"
     const clientDir = (ctx.clientDir ?? CLIENT_INSTALL_DIR).replace(/\\/g, '/');
     const nodeResolution = ctx.nodeResolution;
     if (!nodeResolution || !nodeResolution.path) {
@@ -388,7 +393,7 @@ export function cursorCaptureCommand(opts = {}) {
     const capturePath = (customPath ?? `${clientDir}/capture.js`).replace(/\\/g, '/');
     // The launcher ships next to capture.js (installed client dir, or the repo client
     // dir for --use-repo-path) — derive its path from capturePath's directory.
-    const launcher = capturePath.replace(/[^/]*$/, 'cursor-ai-lens-hook.ps1');
+    const launcher = capturePath.replace(/[^/]*$/, 'ai-lens-hook.ps1');
     const q = (s) => `"${s.replace(/"/g, '""')}"`;
     return `& ${q(launcher)} ${q(node)} ${q(capturePath)}`;
   }
@@ -413,8 +418,8 @@ export function cursorCaptureCommand(opts = {}) {
  */
 export function listClientFiles(sourceDir = join(__dirname, '..', 'client')) {
   // .js — all client modules (sibling imports must all be present).
-  // .ps1 — the Windows windowless Cursor hook launcher (cursor-ai-lens-hook.ps1);
-  // a missing launcher would break every Cursor hook on Windows, so ship it too.
+  // .ps1 — the Windows windowless hook launcher (ai-lens-hook.ps1), used by Cursor AND
+  // Claude Code; a missing launcher would break every Windows hook, so ship it too.
   return readdirSync(sourceDir).filter(f => f.endsWith('.js') || f.endsWith('.ps1')).sort();
 }
 
@@ -810,16 +815,6 @@ export function _parseHookCommand(cmd) {
     return { kind: 'launcher', path: first, prefix, nodePrefix: null };
   }
 
-  // Windows windowless Cursor launcher: & "<...>/cursor-ai-lens-hook.ps1" "<node>" "<capture.js>".
-  // node is the SECOND token (the launcher's first arg); capture.js is the third.
-  if (first.endsWith('cursor-ai-lens-hook.ps1')) {
-    return {
-      kind: 'cursorWindowless',
-      path: first,
-      prefix,
-      nodePrefix: tokens.length >= 2 ? normalizePath(tokens[1]) : null,
-    };
-  }
 
   if (tokens.length >= 2) {
     const second = normalizePath(tokens[1]);
@@ -878,14 +873,19 @@ function normalizePath(p) {
 // still classifies run.* as ai-lens so `remove`/strip cleans up stale launchers.)
 export function isGuiSafeHookCommand(cmd) {
   if (!isAiLensCommand(cmd).isAiLens) return false;
-  // GUI-safe when an ABSOLUTE node path is baked in — either the direct capture.js form
-  // (`<absNode> capture.js`) or the Windows windowless launcher form
-  // (`& "<...>/cursor-ai-lens-hook.ps1" "<absNode>" "<capture.js>"`), where node is the
-  // launcher's first arg. Bare `node` / `/usr/bin/env node` are NOT GUI-safe (depend on
-  // PATH, which GUI Cursor/Claude often lack). The old run.sh/run.cmd launcher is NOT
-  // recognised here (ADR 0003) — it stays `outdated` so init migrates it.
+  // Our Windows windowless launcher (ai-lens-hook.ps1) is GUI-safe by construction — it
+  // starts node with CreateNoWindow. Matched by substring so it covers BOTH invocations:
+  // Cursor `& "<...>/ai-lens-hook.ps1" <node> <capture>` and Claude
+  // `powershell ... -File "<...>/ai-lens-hook.ps1" <node> <capture>` (also the older
+  // cursor-ai-lens-hook.ps1 name). The node arg's existence is validated in status.js.
+  const n = (cmd || '').replace(/\\/g, '/');
+  if (/ai-lens-hook\.ps1/i.test(n)) return true;
+  // Direct capture.js form: GUI-safe only with an ABSOLUTE node path baked in. Bare
+  // `node` / `/usr/bin/env node` are NOT GUI-safe (depend on PATH, which GUI
+  // Cursor/Claude often lack). The old run.sh/run.cmd launcher is NOT recognised here
+  // (ADR 0003) — it stays `outdated` so init migrates it.
   const p = _parseHookCommand(cmd);
-  if ((p.kind === 'captureJs' || p.kind === 'cursorWindowless') && p.nodePrefix) {
+  if (p.kind === 'captureJs' && p.nodePrefix) {
     const np = p.nodePrefix;
     const isAbsolute = np.startsWith('/') || /^[a-zA-Z]:\//.test(np);
     const isEnvShim = np === '/usr/bin/env' || np.endsWith('/env');
@@ -923,13 +923,17 @@ 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.
+  // The legacy conhost.exe --headless form is unambiguously a Windows command and uses
+  // $CLAUDE_PROJECT_DIR: correct on win32, wrong elsewhere. (Migration off conhost is
+  // driven separately by the wrapper-kind check in isCurrentAiLensHook.)
   if (isConhostHeadlessCommand(n)) return platform !== 'win32';
-  const correctVar = platform === 'win32' ? '%CLAUDE_PROJECT_DIR%' : '$CLAUDE_PROJECT_DIR';
-  return !n.includes(correctVar);
+  // On Windows, NEITHER $CLAUDE_PROJECT_DIR nor %CLAUDE_PROJECT_DIR% actually expands in
+  // Claude Code's hook spawn (verified live) — so ANY variable-bearing form is wrong on
+  // win32 and must migrate to the absolute path form (incl. a stale $VAR-launcher or a
+  // %VAR% overlay). On POSIX the shell expands $CLAUDE_PROJECT_DIR, so $VAR is the only
+  // correct form there.
+  if (platform === 'win32') return true;
+  return !n.includes('$CLAUDE_PROJECT_DIR');
 }
 
 // Leading `conhost.exe --headless ` windowless wrapper, with the trailing space so a
@@ -1032,13 +1036,27 @@ export function analyzeClaudeLocalOverlay(tool, opts = {}) {
   if (!rel) return { applicable: false, reason: 'could not extract capture.js path from hook command' };
 
   const localPath = claudeLocalSettingsPath(tool);
+  // Committed-file → per-machine overlay mirror. On Windows $CLAUDE_PROJECT_DIR/%VAR% does
+  // NOT expand in Claude Code's hook spawn, so the overlay (like init's main path) writes
+  // the absolute windowless-launcher form — rel resolved against the project root, node
+  // resolved on this machine. POSIX keeps the $CLAUDE_PROJECT_DIR form (the shell expands it).
+  const overlayCtx = { ...(opts.ctx ?? {}), platform };
+  let overlayHookDefs;
+  if (platform === 'win32') {
+    const projectRoot = dirname(dirname(tool.configPath));
+    const absCapture = join(projectRoot, rel).replace(/\\/g, '/');
+    const nodeResolution = overlayCtx.nodeResolution ?? findStableNodePath({ platform });
+    overlayHookDefs = getClaudeCodeHookDefsWithPath(absCapture, { ...overlayCtx, nodeResolution });
+  } else {
+    overlayHookDefs = getClaudeCodeHookDefsWithProjectDir(rel, overlayCtx);
+  }
   const localTool = {
     ...tool,
     name: `${tool.name} (settings.local.json overlay)`,
     configPath: localPath,
     // Never backup/rename a user's settings.local.json wholesale on parse errors.
     sharedConfig: true,
-    hookDefs: getClaudeCodeHookDefsWithProjectDir(rel, { ...(opts.ctx ?? {}), platform }),
+    hookDefs: overlayHookDefs,
   };
   const overlayAnalysis = analyzeToolHooks(localTool, { platform, allowPlatformRewrite: true });
   return {
@@ -1124,24 +1142,23 @@ function isCurrentAiLensHook(entry, expected, opts = {}) {
   //
   // Windows-wrapper exception (same allowPlatformRewrite gate): flag a hook outdated
   // when its stored windowless wrapper DISAGREES with the freshly regenerated `expected`
-  // command, so init re-syncs it. We compare ONLY the wrapper kind — conhost vs the
-  // Cursor `cursor-ai-lens-hook.ps1` launcher vs plain — never the whole command, so
-  // legitimate path/node/install-mode variation never false-flags. `expected` already
-  // bakes in tool+platform: Claude on conhost-capable Windows → `conhost`; Cursor on
-  // Windows → `cursorPs1` (the windowless launcher; conhost corrupts Cursor's stdout
-  // JSON-parse); Codex, macOS, and old Windows → `plain`. So this self-scopes per tool:
-  //   - Claude: stored plain → outdated (add conhost); stored conhost → current.
-  //   - Cursor: stored plain/conhost → outdated (migrate to the .ps1 launcher); ps1 → current.
-  //   - Codex/macOS: expected plain, stored plain → current (untouched).
-  // Committed (tracked) files are exempt via allowPlatformRewrite — they carry one
-  // OS-agnostic syntax and can't bake a Windows-only wrapper; the per-machine overlay
-  // (or the local .cursor/hooks.json) provides it.
+  // command, so init re-syncs it. We compare ONLY the wrapper kind — `conhost` vs the
+  // `ai-lens-hook.ps1` launcher (keyed on its basename) vs `plain` — never the whole
+  // command, so legitimate path/node/install-mode variation never false-flags.
+  // `expected` bakes in tool+platform: on Windows BOTH Cursor and Claude now use the
+  // launcher (`ps1:ai-lens-hook.ps1`); Codex, macOS → `plain`. So this self-scopes:
+  //   - conhost (old Claude/Cursor) → mismatch → outdated → migrate to the launcher;
+  //   - old `cursor-ai-lens-hook.ps1` → `ps1:cursor-ai-lens-hook.ps1` ≠ `ps1:ai-lens-hook.ps1`
+  //     → outdated → migrate to the renamed launcher;
+  //   - launcher already current → match → current; Codex/macOS plain → current.
+  // Committed (tracked) files are exempt via allowPlatformRewrite.
   const { platform = process.platform, allowPlatformRewrite = false } = opts;
   const expectedCmd = expected?.command ?? expected?.hooks?.[0]?.command ?? '';
   const wrapperKind = (c) => {
     const s = String(c || '');
     if (isConhostHeadlessCommand(s)) return 'conhost';
-    if (/cursor-ai-lens-hook\.ps1/i.test(s)) return 'cursorPs1';
+    const m = s.match(/([\w.-]*ai-lens-hook\.ps1)/i);
+    if (m) return 'ps1:' + m[1].toLowerCase();
     return 'plain';
   };
   const expectedWrapper = wrapperKind(expectedCmd);

package/cli/init.js

@@ -182,9 +182,13 @@ function makeNestedClaudeTool(projectDir, capturePathInHooks, ctx = null) {
     // cwd. Absolute/tilde paths keep the legacy <node> <capture.js> form.
     const rel = capturePathInHooks.replace(/\\/g, '/');
     const isRelative = !rel.startsWith('/') && !rel.startsWith('~') && !/^[a-zA-Z]:\//.test(rel);
-    tool.hookDefs = (isRelative && /(?:^|\/)ai-lens\//.test(rel))
+    // $CLAUDE_PROJECT_DIR is expanded by the shell on POSIX but NOT on Windows (Claude's
+    // hook spawn takes it literally) — so on Windows resolve rel to an absolute path
+    // against the nested project root instead of using the projectDir form.
+    const useProjectDir = isRelative && /(?:^|\/)ai-lens\//.test(rel) && ctx?.platform !== 'win32';
+    tool.hookDefs = useProjectDir
       ? getClaudeCodeHookDefsWithProjectDir(rel, ctx)
-      : getClaudeCodeHookDefsWithPath(capturePathInHooks, ctx);
+      : getClaudeCodeHookDefsWithPath(isRelative ? join(projectDir, rel).replace(/\\/g, '/') : capturePathInHooks, ctx);
   }
   return tool;
 }
@@ -513,9 +517,13 @@ export default async function init() {
       : repoPathAbs.replace(/\\/g, '/');
     for (const tool of tools) {
       if (tool.name.startsWith('Claude Code')) {
-        tool.hookDefs = claudeProjectDirRel
+        // On Windows, Claude Code's hook spawn does NOT expand $CLAUDE_PROJECT_DIR (Git
+        // Bash / PowerShell take it literally), so the projectDir form can't resolve —
+        // use the resolved absolute repo path instead (per-machine, so absolute is fine).
+        // POSIX/macOS keep $CLAUDE_PROJECT_DIR (cwd-robust + the shell expands it).
+        tool.hookDefs = (claudeProjectDirRel && ctx?.platform !== 'win32')
           ? getClaudeCodeHookDefsWithProjectDir(claudeProjectDirRel, ctx)
-          : getClaudeCodeHookDefsWithPath(pathInHooks, ctx);
+          : getClaudeCodeHookDefsWithPath(claudeProjectDirRel ? repoPathAbs.replace(/\\/g, '/') : pathInHooks, ctx);
       }
       else if (tool.name.startsWith('Cursor')) tool.hookDefs = getCursorHookDefsWithPath(pathInHooks, ctx);
       else if (tool.name.startsWith('Codex')) tool.hookDefs = getCodexHookDefsWithPath(codexPathInHooks, ctx);

package/cli/status.js

@@ -150,24 +150,28 @@ function validateHookCommandPaths(tool) {
 
   const issues = [];
   const launcherMatch = command.match(/["']([^"']*run\.(?:sh|cmd))["']|(\S*run\.(?:sh|cmd))/);
-  const ps1Match = command.match(/["']([^"']*cursor-ai-lens-hook\.ps1)["']|(\S*cursor-ai-lens-hook\.ps1)/);
+  // Matches both ai-lens-hook.ps1 and the older cursor-ai-lens-hook.ps1.
+  const ps1Match = command.match(/["']([^"']*ai-lens-hook\.ps1)["']|(\S*ai-lens-hook\.ps1)/);
+  // Paths containing $CLAUDE_PROJECT_DIR / %CLAUDE_PROJECT_DIR% can't be resolved here
+  // (Claude Code substitutes the var at runtime) — skip existence checks for those.
+  const resolvable = (p) => !/CLAUDE_PROJECT_DIR/.test(p);
 
   if (ps1Match) {
-    // Windows windowless Cursor launcher: & "<...>/cursor-ai-lens-hook.ps1" "<node>" "<capture.js>".
-    // Validate the launcher, the node arg (2nd token), and capture.js (3rd token) all exist.
+    // Windows windowless launcher (Cursor: `& "<...>.ps1" <node> <capture>`; Claude:
+    // `powershell ... -File "<...>.ps1" <node> <capture>`). Validate launcher + node arg
+    // + capture.js exist (when their paths are resolvable, i.e. not $CLAUDE_PROJECT_DIR).
     const ps1Path = expandTilde(ps1Match[1] || ps1Match[2]);
-    if (!existsSync(ps1Path)) issues.push(`Cursor hook launcher not found at: ${ps1Path}`);
+    if (resolvable(ps1Path) && !existsSync(ps1Path)) issues.push(`AI Lens hook launcher not found at: ${ps1Path}`);
     const capMatch = command.match(/["']([^"']*capture\.js)["']|(\S*capture\.js)/);
     if (capMatch) {
       const capturePath = expandTilde(capMatch[1] || capMatch[2]);
-      if (!existsSync(capturePath)) issues.push(`capture.js not found at: ${capturePath}`);
+      if (resolvable(capturePath) && !existsSync(capturePath)) issues.push(`capture.js not found at: ${capturePath}`);
     }
     // node = the launcher's first argument (token right after the .ps1 path)
-    const nodeArg = command.replace(/^& /, '')
-      .match(/cursor-ai-lens-hook\.ps1["']?\s+(?:["']([^"']+)["']|(\S+))/);
+    const nodeArg = command.match(/ai-lens-hook\.ps1["']?\s+(?:["']([^"']+)["']|(\S+))/);
     if (nodeArg) {
       const nodePath = expandTilde(nodeArg[1] || nodeArg[2]);
-      if (nodePath !== 'node' && !existsSync(nodePath)) {
+      if (nodePath !== 'node' && resolvable(nodePath) && !existsSync(nodePath)) {
         issues.push(`node not found at: ${nodePath} — re-run \`ai-lens init\` to re-resolve node`);
       }
     }

package/client/ai-lens-hook.ps1

@@ -0,0 +1,50 @@
+# AI Lens — windowless hook launcher (Windows only). Used by BOTH Cursor and Claude Code.
+#
+# Why this exists: a hook spawns node.exe, a console-subsystem binary; launched from a
+# console-less parent it allocates its own console window → a flash on every event. The
+# obvious windowless wrapper, `conhost.exe --headless`, is unusable for hook capture:
+#   - for Cursor it emits ConPTY VT escape codes onto stdout, which Cursor fails to JSON-parse;
+#   - for Claude Code it replaces node's stdin with the pseudoconsole, so the JSON payload
+#     never reaches capture.js (it reads empty stdin and drops the event).
+# This launcher instead starts node via ProcessStartInfo with CreateNoWindow=$true (no
+# window) and RedirectStandardInput (real stdin forwarded) — so capture works AND there's
+# no flash. It is fail-open: on ANY error it exits 0 and writes NOTHING to stdout (Cursor
+# parses a hook's stdout as JSON — leaking an error there would break the hook).
+#
+# Payload source differs by caller, so read BOTH:
+#   - Cursor pipes it through the PowerShell pipeline → $input.
+#   - Claude Code pipes it to the process's OS stdin → [Console]::In.
+# Read $input first; if empty (Claude Code invocation), fall back to [Console]::In.
+#
+# Args: $args[0] = node path, $args[1] = capture.js path.
+
+$ErrorActionPreference = 'Stop'
+try {
+  $node = $args[0]
+  $capture = $args[1]
+
+  $payload = @($input) -join "`n"
+  if ([string]::IsNullOrEmpty($payload)) {
+    $payload = [Console]::In.ReadToEnd()
+  }
+
+  $psi = New-Object System.Diagnostics.ProcessStartInfo
+  $psi.FileName = $node
+  $psi.Arguments = '"' + $capture + '"'
+  $psi.UseShellExecute = $false
+  $psi.CreateNoWindow = $true
+  $psi.RedirectStandardInput = $true
+
+  $proc = [System.Diagnostics.Process]::Start($psi)
+  # Write the payload as raw UTF-8 bytes to node's stdin (capture.js reads UTF-8). Going
+  # through BaseStream avoids the StreamWriter's default codepage on Windows PowerShell
+  # 5.1 mangling non-ASCII content (e.g. Cyrillic prompts, accented paths).
+  $bytes = [System.Text.Encoding]::UTF8.GetBytes($payload)
+  $proc.StandardInput.BaseStream.Write($bytes, 0, $bytes.Length)
+  $proc.StandardInput.BaseStream.Flush()
+  $proc.StandardInput.Close()
+  $proc.WaitForExit()
+} catch {
+  # Fail-open: never disrupt the session, never emit non-JSON to the hook's stdout.
+  exit 0
+}

package/package.json

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

package/client/cursor-ai-lens-hook.ps1

@@ -1,32 +0,0 @@
-# AI Lens — Cursor windowless hook launcher (Windows only).
-#
-# Why this exists: Cursor runs a hook by spawning a (hidden) powershell that pipes the
-# event payload through the PowerShell pipeline ($input) — e.g.
-#     Get-Content <tmp>.json -Raw | & { $input | & "<this.ps1>" "<node>" "<capture.js>" }
-# Launching node.exe directly there pops a console window on every event (node is a
-# console-subsystem binary and the parent powershell has no console). conhost.exe
-# --headless hides the window but emits ConPTY VT escape codes onto stdout, which Cursor
-# then fails to JSON-parse. This launcher instead starts node with CreateNoWindow=$true
-# (no window) while forwarding the payload to node's stdin — so capture still works and
-# nothing extra is written to stdout.
-#
-# Args: $args[0] = absolute node path, $args[1] = capture.js path.
-# Payload arrives on the PowerShell pipeline as $input (NOT [Console]::In, which is empty
-# here because the data is an in-process pipeline object, not the process's OS stdin).
-
-$ErrorActionPreference = 'Stop'
-$node = $args[0]
-$capture = $args[1]
-$payload = @($input) -join "`n"
-
-$psi = New-Object System.Diagnostics.ProcessStartInfo
-$psi.FileName = $node
-$psi.Arguments = '"' + $capture + '"'
-$psi.UseShellExecute = $false
-$psi.CreateNoWindow = $true
-$psi.RedirectStandardInput = $true
-
-$proc = [System.Diagnostics.Process]::Start($psi)
-$proc.StandardInput.Write($payload)
-$proc.StandardInput.Close()
-$proc.WaitForExit()