ai-lens 0.8.94 → 0.8.96

package/.commithash

@@ -1 +1 @@
-1b043cc
+549ce90

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 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.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
+
+## 0.8.95 — 2026-06-17
+- fix: on Windows, Cursor hooks no longer flash a console window on every event (including new-session start) — the hook command is now wrapped in `conhost.exe --headless` (Windows 10 1809+), the same windowless form Claude Code hooks already use. Older Windows builds and macOS/Linux are unchanged. Re-run `ai-lens init` to apply
+- feat: `ai-lens init` now warns when the configured `projects` filter does not cover the workspace you're setting up — a stale filter silently drops all capture (hooks look configured but record nothing)
+- feat: the Claude Code history-import offer now previews how much there is to import ("Found N sessions from A to B") before asking, instead of a bare yes/no
+
 ## 0.8.94 — 2026-06-16
 - feat: capture 8 more Claude Code events that were previously ignored — turn failures (session-limit / prompt-too-long / server-overload messages), notifications, permission requests, post-compact summaries, task created/completed, instructions loaded, and slash-command expansions. Re-run `ai-lens init` to install them; they're collected and forwarded only (no dashboard changes yet)
 

package/cli/hooks.js

@@ -375,9 +375,13 @@ 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.
   const cmd = customPath != null
-    ? captureCommand({ useTilde: false, rawPath: true, customPath, ctx, shell })
-    : captureCommand({ useTilde: effectiveUseTilde, ctx, shell });
+    ? captureCommand({ rawPath: true, customPath, windowless: true, ctx, shell })
+    : captureCommand({ useTilde: effectiveUseTilde, windowless: true, ctx, shell });
   return platform === 'win32' ? `& ${cmd}` : cmd;
 }
 
@@ -1084,9 +1088,26 @@ function isCurrentAiLensHook(entry, expected, opts = {}) {
   // Exception (allowPlatformRewrite, set for untracked/per-machine files): a
   // $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.
   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 && isWrongPlatformProjectDirCommand(cmd, platform))
+    && !(allowPlatformRewrite && expectedWindowless && !isConhostHeadlessCommand(cmd));
   // Flat format (Cursor): single command per entry.
   if (entry?.command != null) {
     return ok(entry.command);

package/cli/import/claude-code.js

@@ -92,6 +92,31 @@ export function resolveCutoff({ days, since, from }, now = new Date()) {
   return new Date(now.getTime() - d * DAY_MS).toISOString();
 }
 
+/**
+ * Cheap preview for the init import offer — how many local transcripts (≈ sessions)
+ * fall within the window and their date span, by file mtime (no file reads). Lets
+ * init show "Found N sessions from A to B" before asking to import.
+ * @returns {{ count: number, earliest: string|null, latest: string|null }}
+ */
+export function previewClaudeCode({ days = 90, dir = PROJECTS_DIR } = {}, now = new Date()) {
+  if (!existsSync(dir)) return { count: 0, earliest: null, latest: null };
+  const cutoffMs = Date.parse(resolveCutoff({ days }, now));
+  let count = 0, min = Infinity, max = -Infinity;
+  for (const f of walkJsonl(dir)) {
+    let m;
+    try { m = statSync(f).mtimeMs; } catch { continue; }
+    if (m < cutoffMs) continue;
+    count++;
+    if (m < min) min = m;
+    if (m > max) max = m;
+  }
+  return {
+    count,
+    earliest: count ? new Date(min).toISOString() : null,
+    latest: count ? new Date(max).toISOString() : null,
+  };
+}
+
 /**
  * Resolve the INCLUSIVE lower bound from `--from` (or null when open-ended).
  * Unlike the file-level `cutoff` (which only decides whether to read a file),

package/cli/init.js

@@ -596,6 +596,27 @@ export default async function init() {
     info('  Tracking: all projects');
   }
 
+  // Loud guard: a narrow `projects` filter that does NOT cover this workspace silently
+  // drops ALL capture (project_filter) — hooks look configured but record nothing. This
+  // bites when init inherits a stale `projects` from an old config (a leftover test path).
+  // Warn against the cwd (the workspace init is being run from).
+  if (projects) {
+    const cwd = resolve(process.cwd());
+    const norm = (p) => p.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+    const cwdN = norm(cwd);
+    const covered = projects.split(',').map(norm).some(m => m && (cwdN === m || cwdN.startsWith(m + '/')));
+    if (!covered) {
+      blank();
+      warn(`  ⚠ Projects filter does not include this workspace — events from here will be DROPPED.`);
+      warn(`    filter: ${projects}`);
+      warn(`    here:   ${cwd}`);
+      info(`    Capture will look configured but record nothing. Fix: re-run with \`--projects all\``);
+      info(`    (track everything), or edit ~/.ai-lens/config.json and remove/adjust "projects".`);
+      info(`    (Ignore if you deliberately track only other paths.)`);
+      blank();
+    }
+  }
+
   // Build new config in memory — saved after "Proceed?" confirmation
   const newConfig = { ...currentConfig, serverUrl, projects };
 
@@ -1256,10 +1277,28 @@ async function maybeOfferImportHistory(flags) {
   if (flags.noImport) return;
   if (!existsSync(join(homedir(), '.claude', 'projects'))) return;
 
+  // Preview so the offer isn't a blind yes/no: count of local transcripts (≈ sessions)
+  // and their date span within the 90d window (cheap mtime scan, no file reads).
+  let preview = null;
+  try {
+    const mod = await import('./import/claude-code.js');
+    if (mod.previewClaudeCode) preview = mod.previewClaudeCode({ days: 90 });
+  } catch { /* preview is best-effort */ }
+  if (preview && preview.count === 0) {
+    info('  No local Claude Code history in the last 90 days — nothing to import.');
+    return;
+  }
+  const day = (iso) => (iso || '').slice(0, 10);
+  const previewLine = preview
+    ? `Found ${preview.count} Claude Code session${preview.count === 1 ? '' : 's'} from ${day(preview.earliest)} to ${day(preview.latest)} (last 90d).`
+    : 'Local Claude Code history found.';
+
   let run = flags.importHistory || flags.yes;
-  if (!run) {
+  if (run) {
+    info(`  ${previewLine}`);
+  } else {
     try {
-      const answer = (await ask('Import your local Claude Code history now? (Y/n) ')).toLowerCase();
+      const answer = (await ask(`${previewLine} Import now? (Y/n) `)).toLowerCase();
       run = answer === '' || answer === 'y' || answer === 'yes';
     } catch { run = false; }
   }

package/package.json

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