ai-lens 0.8.96 → 0.8.98

package/.commithash

@@ -1 +1 @@
-549ce90
+5d8b7f1

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 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.98 — 2026-06-17
+- fix: Cursor hooks on Windows no longer use the `conhost.exe --headless` wrapper — it made Cursor report a "JSON Parse Error" on every hook (conhost emits terminal escape codes that Cursor tries to parse as the hook's output) and broke capture. Cursor returns to the plain working form; machines that briefly got the conhost'd Cursor hook are auto-downgraded on the next `ai-lens init`/`/setup`. Claude Code keeps the windowless wrapper (it tolerates the output). The minor Cursor console flash on Windows is upstream Cursor behaviour
+
+## 0.8.97 — 2026-06-17
+- fix: `ai-lens init` no longer leaves an invalid `{ "version": 1 }` (no hooks) in `~/.cursor/hooks.json` when migrating to project hooks — Cursor flagged such a file as an error and stopped running ALL hooks, silently killing capture even when project hooks were correct. init now deletes the empty file, and repairs machines already left in this state on the next run
+
 ## 0.8.96 — 2026-06-17
 - fix: `ai-lens status` now reports a Windows Cursor (or Claude Code) hook that lacks the windowless `conhost.exe --headless` wrapper as outdated, so a normal re-run of `ai-lens init` (or `/setup`) upgrades it in place. Previously the console-flash fix from 0.8.95 only applied to brand-new installs; existing hooks were considered up-to-date and never rewritten. macOS/Linux, older Windows, and Codex hooks are unaffected
 

package/cli/hooks.js

@@ -375,13 +375,17 @@ export function cursorCaptureCommand(opts = {}) {
   // hint when building the underlying command (avoids the cmd.exe `call` prefix
   // which PowerShell doesn't understand).
   const shell = platform === 'win32' ? 'powershell' : null;
-  // windowless: on Windows ≥1809 wrap node in `conhost.exe --headless` so Cursor
-  // doesn't flash a console window on every event (incl. session start). `& ` still
-  // works in front of conhost; the detector strips `& ` then the conhost prefix, so
-  // the form stays recognised as current (no churn). Mac/old-Windows: unchanged.
+  // NOTE: Cursor deliberately does NOT get the `conhost.exe --headless` windowless
+  // wrapper (unlike Claude Code). conhost runs a ConPTY and emits VT escape sequences
+  // (e.g. ESC[?9001h win32-input-mode) onto the hook's output stream, and Cursor
+  // parses a hook's stdout as JSON → "JSON Parse Error … is not valid JSON", which
+  // breaks the hook. Claude Code tolerates non-JSON hook stdout, so it keeps conhost.
+  // The residual Cursor console flash on Windows is upstream (how Cursor spawns the
+  // hook process) and is the lesser evil vs a broken hook. (ADR 0003 §3.2 deferred
+  // Cursor+conhost as unverified; verified incompatible — reverted here.)
   const cmd = customPath != null
-    ? captureCommand({ rawPath: true, customPath, windowless: true, ctx, shell })
-    : captureCommand({ useTilde: effectiveUseTilde, windowless: true, ctx, shell });
+    ? captureCommand({ rawPath: true, customPath, ctx, shell })
+    : captureCommand({ useTilde: effectiveUseTilde, ctx, shell });
   return platform === 'win32' ? `& ${cmd}` : cmd;
 }
 
@@ -1089,25 +1093,28 @@ function isCurrentAiLensHook(entry, expected, opts = {}) {
   // $CLAUDE_PROJECT_DIR/%CLAUDE_PROJECT_DIR% hook written for the OTHER OS won't
   // expand on this platform, so flag it outdated to let init rewrite it.
   //
-  // Windowless exception (same allowPlatformRewrite gate): when the freshly
-  // regenerated `expected` command carries the `conhost.exe --headless` wrapper
-  // (Cursor/Claude on conhost-capable Windows) but the stored command does NOT,
-  // flag it outdated so init upgrades it — otherwise a pre-conhost install stays
-  // `current` forever and keeps flashing a console window on every event. We
-  // compare ONLY the windowless dimension (not the whole command), so legitimate
-  // path/node/install-mode variation never false-flags. `expected` already bakes
-  // in tool+platform+conhost-support (makeCursorHookDefs/makeClaudeHookDefs pass
-  // windowless:true; makeCodexHookDefs does not), so this self-scopes: Codex,
-  // macOS, and old Windows produce a non-conhost `expected` and never trip it.
-  // 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 provides the windowless path.
+  // Windowless exception (same allowPlatformRewrite gate): flag a hook outdated when
+  // its stored `conhost.exe --headless` wrapper DISAGREES with the freshly regenerated
+  // `expected` command — in EITHER direction — so init re-syncs it:
+  //   - expected has conhost, stored doesn't → ADD it (Claude on conhost-capable
+  //     Windows that predates the windowless form);
+  //   - expected has NO conhost, stored DOES → REMOVE it (Cursor: conhost is
+  //     incompatible — its ConPTY VT output breaks Cursor's JSON parse of hook stdout
+  //     — so we downgrade machines that got the short-lived conhost'd Cursor form).
+  // We compare ONLY the windowless dimension (not the whole command), so legitimate
+  // path/node/install-mode variation never false-flags. `expected` already bakes in
+  // tool+platform+conhost-support (makeClaudeHookDefs passes windowless:true;
+  // makeCursorHookDefs and makeCodexHookDefs do NOT), so this self-scopes: Codex,
+  // Cursor, macOS, and old Windows produce a non-conhost `expected`, and only Claude
+  // on conhost-capable Windows produces a conhost `expected`. 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 provides it.
   const { platform = process.platform, allowPlatformRewrite = false } = opts;
   const expectedCmd = expected?.command ?? expected?.hooks?.[0]?.command ?? '';
   const expectedWindowless = isConhostHeadlessCommand(expectedCmd);
   const ok = (cmd) => isAcceptableHookCommand(cmd)
     && !(allowPlatformRewrite && isWrongPlatformProjectDirCommand(cmd, platform))
-    && !(allowPlatformRewrite && expectedWindowless && !isConhostHeadlessCommand(cmd));
+    && !(allowPlatformRewrite && expectedWindowless !== isConhostHeadlessCommand(cmd));
   // Flat format (Cursor): single command per entry.
   if (entry?.command != null) {
     return ok(entry.command);
@@ -1312,8 +1319,15 @@ export function buildStrippedConfig(tool, existingConfig) {
   // If no hooks remain, clean up
   if (Object.keys(base.hooks).length === 0) {
     delete base.hooks;
-    // If other settings remain (shared config like settings.json), keep them
-    if (Object.keys(base).length > 0) {
+    // Keep the file only if REAL user settings remain — i.e. keys beyond the tool's
+    // OWN scaffolding (e.g. Cursor's `version: 1`, which we wrote ourselves). Leaving
+    // a Cursor hooks.json as just `{ "version": 1 }` is an invalid hookless config:
+    // Cursor flags it as an error and stops running hooks. In that case return null so
+    // the caller deletes the file. Real settings (Claude settings.json env/statusLine,
+    // not in topLevelFields) are still preserved.
+    const scaffolding = new Set(Object.keys(tool.topLevelFields || {}));
+    const meaningful = Object.keys(base).filter((k) => !scaffolding.has(k));
+    if (meaningful.length > 0) {
       return base;
     }
     return null;
@@ -1800,7 +1814,19 @@ export function cleanupOppositeScope(activeTools) {
     try { config = JSON.parse(raw); } catch { continue; }
 
     const hooks = config.hooks;
-    if (!hooks || typeof hooks !== 'object') continue;
+    if (!hooks || typeof hooks !== 'object') {
+      // Repair: an older CLI could strip the opposite-scope hooks but leave behind an
+      // invalid hookless scaffolding file (e.g. Cursor's `{ "version": 1 }`), which the
+      // tool then flags as an error and stops running hooks. If a non-shared opposite
+      // file has no hooks and only our own scaffolding keys, delete it.
+      const scaffold = new Set(Object.keys(global.topLevelFields || {}));
+      const onlyScaffold = Object.keys(config).every((k) => scaffold.has(k));
+      if (!global.sharedConfig && onlyScaffold) {
+        try { unlinkSync(oppositeConfigPath); } catch { /* already gone */ }
+        results.push({ path: oppositeConfigPath, action: 'removed', toolName: oppositeToolName });
+      }
+      continue;
+    }
 
     let hasAiLens = false;
     for (const entries of Object.values(hooks)) {
@@ -1816,8 +1842,18 @@ export function cleanupOppositeScope(activeTools) {
     if (stripped) {
       writeHooksConfig({ configPath: oppositeConfigPath }, stripped);
       results.push({ path: oppositeConfigPath, action: 'cleaned', toolName: oppositeToolName });
+    } else if (global.sharedConfig) {
+      // Shared config (Claude settings.json): drop the hooks but keep the file —
+      // it may carry the user's other settings.
+      writeHooksConfig({ configPath: oppositeConfigPath }, {});
+      results.push({ path: oppositeConfigPath, action: 'cleaned', toolName: oppositeToolName });
+    } else {
+      // Non-shared (Cursor/Codex): the file held only AI Lens hooks plus our own
+      // scaffolding (e.g. Cursor's `version: 1`). Delete it rather than leave an
+      // invalid hookless `{ "version": 1 }` that breaks the tool's hook loading.
+      try { unlinkSync(oppositeConfigPath); } catch { /* already gone */ }
+      results.push({ path: oppositeConfigPath, action: 'removed', toolName: oppositeToolName });
     }
-    // Don't delete the file — global settings.json may have other settings
   }
   return results;
 }

package/package.json

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