ai-lens 0.8.80 → 0.8.84

package/.commithash

@@ -1 +1 @@
-a6ad00e
+8a405c3

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 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.84 — 2026-06-08
+- fix: `ai-lens init` no longer wipes your saved auth token when a re-authentication is started but not finished — a closed browser, a timeout, or a transient server hiccup that briefly mis-flags a valid token. Previously this left `authToken: null` in your config and silently stopped all event capture until someone noticed; now the existing token is kept until a new one is actually obtained. If a server that requires auth does end up without a token, init now prints a loud "capture is OFF" error instead of a quiet note.
+
+## 0.8.83 — 2026-06-05
+- fix: on Windows, a Claude Code project hook written with the macOS/Linux `$CLAUDE_PROJECT_DIR` syntax silently captures nothing (Windows needs `%CLAUDE_PROJECT_DIR%`). `ai-lens init` now detects this for per-machine (gitignored) hook files and rewrites it to the running OS's form, and `ai-lens status` flags it instead of showing it as fine. Committed shared hook files are left untouched.
+
+## 0.8.82 — 2026-06-05
+- feat: `ai-lens init` now offers to import your local Claude Code history right away, so a fresh dashboard isn't empty — `npx -y ai-lens init --server <url>` sets up and (on confirm) imports in one step. Use `--no-import` to skip or `--import` to force.
+- fix: `ai-lens import claude-code` works on a self-host instance without login (personal mode) — it ships via your git identity, the same way live capture does, instead of requiring a token.
+
+## 0.8.81 — 2026-06-05
+- improve: `ai-lens status` now tells a stale error from an active one — a past send failure no longer shows red once sending has recovered, and the time and code of the last error are shown (e.g. "recovered — last error 1d ago (ECONNRESET)").
+- improve: `ai-lens status` retries the server health check a few times before reporting "unreachable", so a one-off network blip no longer flags the server as down.
+- improve: `ai-lens status --report` now includes your config and hook files (Cursor / Claude Code / Codex, both global and project scope), with the auth token masked, so setup issues can be diagnosed remotely without sending your local status file.
+
 ## 0.8.80 — 2026-06-04
 - fix: `ai-lens import claude-code` now caps long prompts (so a huge pasted prompt is no longer dropped by the server), captures prompts from messages that mix text with images/documents (shown as a safe `[N attachment(s)]` placeholder — never the image data), and avoids a stale session "end" time on transcripts that are still being written.
 

package/cli/hooks.js

@@ -2,6 +2,7 @@ import { existsSync, lstatSync, readFileSync, writeFileSync, copyFileSync, renam
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { execFileSync } from 'node:child_process';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG_ROOT = join(__dirname, '..');
@@ -934,20 +935,59 @@ function isAcceptableHookCommand(cmd) {
   return isGuiSafeHookCommand(cmd) || isClaudeProjectDirCommand(cmd);
 }
 
-function isCurrentAiLensHook(entry, expected) {
+// True when an ai-lens $CLAUDE_PROJECT_DIR / %CLAUDE_PROJECT_DIR% hook is written
+// with the OTHER platform's variable syntax — `$VAR` on Windows (cmd.exe wants
+// `%VAR%`) or `%VAR%` on POSIX (sh wants `$VAR`). Claude Code hands the command to
+// the native OS shell, so a wrong-syntax var never expands and the hook silently
+// fails (Anthropic claude-code#24710). Used to flag such a PER-MACHINE hook as
+// outdated so init rewrites it to the running OS's form. Committed hooks are
+// protected separately — see analyzeToolHooks / allowPlatformRewrite.
+export function isWrongPlatformProjectDirCommand(cmd, platform = process.platform) {
+  if (!isClaudeProjectDirCommand(cmd)) return false;
+  const n = (cmd || '').replace(/\\/g, '/');
+  const correctVar = platform === 'win32' ? '%CLAUDE_PROJECT_DIR%' : '$CLAUDE_PROJECT_DIR';
+  return !n.includes(correctVar);
+}
+
+// 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
+// re-committed, breaking teammates on the other OS. For per-machine files
+// (untracked / gitignored — the supported model), there's nothing to protect, so
+// init may rewrite a wrong-OS form to the running platform. Returns false on any
+// error (git missing, not a repo, untracked) → treat as per-machine, free to rewrite.
+function isGitTracked(filePath) {
+  try {
+    execFileSync('git', ['-C', dirname(filePath), 'ls-files', '--error-unmatch', '--', filePath], {
+      stdio: 'ignore',
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+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
   // match against the expected command form — every valid install method captures
   // reliably, so none should be reported outdated. Only PATH-dependent forms
   // (bare `node`, `/usr/bin/env node`) WITHOUT $CLAUDE_PROJECT_DIR are outdated.
+  //
+  // 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.
+  const { platform = process.platform, allowPlatformRewrite = false } = opts;
+  const ok = (cmd) => isAcceptableHookCommand(cmd)
+    && !(allowPlatformRewrite && isWrongPlatformProjectDirCommand(cmd, platform));
   // Flat format (Cursor): single command per entry.
   if (entry?.command != null) {
-    return isAcceptableHookCommand(entry.command);
+    return ok(entry.command);
   }
   // Nested format (Claude Code / Codex): { matcher, hooks: [{ command }] }
   if (Array.isArray(entry?.hooks)) {
     if (expected?.matcher !== undefined && entry.matcher !== expected.matcher) return false;
-    return entry.hooks.some(h => isAcceptableHookCommand(h?.command || ''));
+    return entry.hooks.some(h => ok(h?.command || ''));
   }
   return false;
 }
@@ -970,7 +1010,7 @@ export function detectInstalledTools(ctx = null) {
  * Returns { status, config?, error? }
  *   status: 'fresh' | 'current' | 'outdated' | 'absent' | 'malformed'
  */
-export function analyzeToolHooks(tool) {
+export function analyzeToolHooks(tool, opts = {}) {
   if (!existsSync(tool.configPath)) {
     return { status: 'fresh', disableAllHooks: false };
   }
@@ -1002,6 +1042,12 @@ export function analyzeToolHooks(tool) {
     return { status: 'absent', config, disableAllHooks };
   }
 
+  // Per-machine (untracked/gitignored) hook files may be rewritten to the running
+  // OS's CLAUDE_PROJECT_DIR syntax; committed (tracked) files are protected from
+  // churn. Caller may override both (tests, or callers with known context).
+  const platform = opts.platform ?? process.platform;
+  const allowPlatformRewrite = opts.allowPlatformRewrite ?? !isGitTracked(tool.configPath);
+
   // Check if any AI Lens hooks exist
   let hasAiLens = false;
   let allCurrent = true;
@@ -1013,7 +1059,7 @@ export function analyzeToolHooks(tool) {
     for (const entry of entries) {
       if (isAiLensHook(entry)) {
         hasAiLens = true;
-        if (!isCurrentAiLensHook(entry, expected)) {
+        if (!isCurrentAiLensHook(entry, expected, { platform, allowPlatformRewrite })) {
           allCurrent = false;
         }
       }

package/cli/import/claude-code.js

@@ -94,13 +94,19 @@ export async function fetchCoverage(sessionIds, { fetchImpl = globalThis.fetch }
   if (!sessionIds.length || !fetchImpl) return out;
   const base = getServerUrl();
   const token = getAuthToken();
+  // Auth: token preferred, else git-identity headers so coverage also works in
+  // self-host personal mode (no token) — same fallback the ingest path uses.
+  const ident = token ? null : getGitIdentity(process.cwd());
+  const authHeaders = token
+    ? { 'X-Auth-Token': token }
+    : (ident?.email ? { 'X-Developer-Git-Email': ident.email, ...(ident.name ? { 'X-Developer-Name': ident.name } : {}) } : {});
   const CHUNK = 400;
   for (let i = 0; i < sessionIds.length; i += CHUNK) {
     const batch = sessionIds.slice(i, i + CHUNK);
     try {
       const res = await fetchImpl(new URL('/api/events/coverage', base), {
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', ...(token ? { 'X-Auth-Token': token } : {}) },
+        headers: { 'Content-Type': 'application/json', ...authHeaders },
         body: JSON.stringify({ session_ids: batch }),
       });
       if (res.ok) Object.assign(out, await res.json());
@@ -109,6 +115,15 @@ export async function fetchCoverage(sessionIds, { fetchImpl = globalThis.fetch }
   return out;
 }
 
+/**
+ * Can the importer actually deliver events? A personal auth token OR a resolvable
+ * git email (the ingest path accepts either). Pure-ish; takes the two resolvers so
+ * it's testable without touching real git/env.
+ */
+export function hasDeliverableIdentity(token, gitEmail) {
+  return !!token || !!gitEmail;
+}
+
 /**
  * Drop events at/after the live-coverage boundary for their session, so import
  * only adds the pre-live backlog. No boundary ⇒ keep all. (Pure, for tests.)
@@ -209,8 +224,10 @@ export default async function importClaudeCode(flags) {
     warn(`No Claude Code history found at ${PROJECTS_DIR}`);
     return;
   }
-  if (!dryRun && !getAuthToken()) {
-    error('No auth token. Run `npx ai-lens init` first (or set AI_LENS_AUTH_TOKEN).');
+  // Need a way to attribute events: a token, OR a git email (self-host personal
+  // mode ships via the git-identity fallback, just like live capture).
+  if (!dryRun && !hasDeliverableIdentity(getAuthToken(), getGitIdentity(process.cwd())?.email)) {
+    error('No identity to attribute events. Run `npx ai-lens init` first, or set a git user.email (or AI_LENS_AUTH_TOKEN).');
     return;
   }
   if (noRedact) warn('⚠ --no-redact: secrets in raw transcripts are NOT redacted client-side and persist locally in the spool if a send fails. Use only for debugging.');

package/cli/init.js

@@ -361,6 +361,12 @@ function getInitArgs() {
       case '--install-launcher':
         flags.installLauncher = true;
         break;
+      case '--import':
+        flags.importHistory = true;
+        break;
+      case '--no-import':
+        flags.noImport = 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');
@@ -628,29 +634,35 @@ export default async function init() {
 
   // Authentication
   heading('Authentication');
+  // Never null an existing token up front. An abandoned device-code login — or a
+  // transient server hiccup that mis-flags a good token (e.g. during a deploy) —
+  // must not leave the user with authToken:null, which silently breaks capture
+  // until someone notices. newConfig already inherits the prior token via the
+  // spread above; we only OVERWRITE it once we hold a confirmed new token.
+  let needsAuth = !currentConfig.authToken;
+  let authConfigured = true; // flipped false only if the server reports no Auth0
   if (currentConfig.authToken) {
     const tokenStatus = await validateExistingToken(serverUrl, currentConfig.authToken);
     if (tokenStatus === 'valid') {
       success('  Already authenticated (token verified)');
     } else if (tokenStatus === 'unknown') {
       warn('  Token format not recognized — re-authenticating...');
-      currentConfig.authToken = null;
-      newConfig.authToken = null;
+      needsAuth = true;
     } else if (tokenStatus === 'invalid') {
       warn('  Existing token is invalid or revoked — re-authenticating...');
-      currentConfig.authToken = null;
-      newConfig.authToken = null;
+      needsAuth = true;
     } else {
       warn('  Could not reach server to verify token — keeping existing token');
     }
   }
-  if (!currentConfig.authToken) {
+  if (needsAuth) {
     let authResult = null;
     try {
       authResult = await deviceCodeAuth(serverUrl);
     } catch (err) {
       const msg = (err && err.message) ? err.message : String(err);
       if (msg.includes('not configured')) {
+        authConfigured = false;
         warn(`  Auth not configured on server — personal mode (events sent via git identity)`);
       } else {
         warn(`  Authentication failed: ${msg}`);
@@ -663,17 +675,29 @@ export default async function init() {
         saveLensConfig(newConfig);
         success(`  Authenticated as ${authResult.name} (${authResult.email})`);
       } catch (err) {
+        // Keep whatever token newConfig already holds — do NOT null it.
         warn(`  Authenticated but failed to save token: ${err.message}`);
         warn(`  Run "npx -y ai-lens init" again later to persist authentication`);
-        newConfig.authToken = null;
       }
+    } else if (currentConfig.authToken) {
+      // Re-auth didn't complete. Preserve the prior token rather than stranding
+      // the user tokenless: a transient false-negative keeps capture working, and
+      // a genuinely revoked token simply re-prompts on the next init.
+      warn('  Re-authentication not completed — keeping the existing token for now.');
     }
   }
 
-  // Validate identity: no token + no git email = events will be dropped
+  // Loud failure when capture is actually broken: a server with Auth0 drops every
+  // event without a token (the git-email header path is personal-mode only), so a
+  // missing token here is not a soft warning — it's a silent data outage.
   if (!newConfig.authToken) {
     const { email } = getGitIdentity();
-    if (!email) {
+    if (authConfigured) {
+      blank();
+      error('  No auth token — this server requires one, so EVERY event will be dropped.');
+      error('  Capture is OFF until you authenticate.');
+      info('  Fix: run "npx -y ai-lens init" and finish the browser login.');
+    } else if (!email) {
       blank();
       error('  No auth token and no git email configured.');
       error('  Events will be silently dropped until one is available.');
@@ -1194,5 +1218,42 @@ export default async function init() {
   }
   blank();
 
+  // Primary warm-start trigger: offer to import local Claude Code history right now,
+  // so the dashboard isn't empty on first open.
+  await maybeOfferImportHistory(flags);
+
   detail(`Log: ${getLogPath()}`);
 }
+
+/**
+ * After a successful init, offer to import the developer's local Claude Code
+ * history. `--no-import` skips; `--import` or `--yes` runs it without prompting;
+ * otherwise asks interactively. No-op if there's no `~/.claude/projects`.
+ */
+async function maybeOfferImportHistory(flags) {
+  if (flags.noImport) return;
+  if (!existsSync(join(homedir(), '.claude', 'projects'))) return;
+
+  let run = flags.importHistory || flags.yes;
+  if (!run) {
+    try {
+      const answer = (await ask('Import your local Claude Code history now? (Y/n) ')).toLowerCase();
+      run = answer === '' || answer === 'y' || answer === 'yes';
+    } catch { run = false; }
+  }
+  if (!run) {
+    blank();
+    info('  Skipped import. Run `npx -y ai-lens import claude-code` anytime to bring it in.');
+    return;
+  }
+
+  blank();
+  heading('Importing local history');
+  try {
+    const { default: importClaudeCode } = await import('./import/claude-code.js');
+    await importClaudeCode({ days: 30 }); // server URL + git identity were just configured
+  } catch (err) {
+    error(`  Import failed: ${err.message}`);
+    info('  You can retry later: `npx -y ai-lens import claude-code`');
+  }
+}

package/cli/status.js

@@ -619,40 +619,69 @@ function checkSenderLog() {
     return { ok: false, summary: `error reading log: ${err.message}`, detail: `Error: ${err.message}` };
   }
 
-  // Aggregate across all log entries for observability
+  // Aggregate across all log entries for observability. Counts are all-time, but
+  // we also track recency (last error ts + a 24h window) so a single old failure
+  // doesn't flag the check red forever — see `recovered` below.
   let sentOk = 0;       // total events successfully delivered to server
   let failedCount = 0;  // total failed send attempts (connection/auth errors)
+  let recentFailed = 0; // failed sends within the last 24h
   let rollbackCount = 0; // total rollbacks (partial + full) — events re-queued for retry
   let lastSend = null;
+  let lastSendMs = 0;
+  let lastError = null;     // ts of the most recent failure/error
+  let lastErrorMs = 0;
+  let lastErrorCode = null; // connection/error code of that last failure
   let hasErrors = false;
+  const DAY_MS = 24 * 60 * 60 * 1000;
+  const now = Date.now();
 
   for (const line of lines) {
     try {
       const entry = JSON.parse(line);
+      const tsMs = entry.ts ? new Date(entry.ts).getTime() : NaN;
       if (entry.msg === 'sent') {
         lastSend = entry.ts;
+        if (!isNaN(tsMs) && tsMs > lastSendMs) lastSendMs = tsMs;
         sentOk += parseInt(entry.events, 10) || 0;
       }
       if (entry.msg === 'failed' || entry.msg === 'error' || entry.msg === 'auth-failed') {
         hasErrors = true;
         if (entry.msg === 'failed') failedCount++;
+        if (!isNaN(tsMs)) {
+          if (tsMs > lastErrorMs) {
+            lastErrorMs = tsMs;
+            lastError = entry.ts;
+            lastErrorCode = entry.cause?.code || entry.code || entry.error || null;
+          }
+          if (entry.msg === 'failed' && now - tsMs <= DAY_MS) recentFailed++;
+        }
       }
       if (entry.msg === 'rollback' || entry.msg === 'partial-rollback') rollbackCount++;
     } catch { /* non-JSON line */ }
   }
 
+  // Recovered = the last successful send is newer than the last error, so the
+  // failures are historical noise rather than an active problem. Only treat
+  // errors as active (red) when nothing has succeeded since the last one.
+  const recovered = lastErrorMs > 0 && lastSendMs > lastErrorMs;
+  const activeErrors = hasErrors && !recovered;
+
   const stats = [];
   if (sentOk > 0) stats.push(`${sentOk} events sent`);
-  if (failedCount > 0) stats.push(`${failedCount} failed`);
+  if (failedCount > 0) stats.push(`${failedCount} failed${recentFailed > 0 ? `, ${recentFailed} in 24h` : ''}`);
   if (rollbackCount > 0) stats.push(`${rollbackCount} rollbacks`);
 
+  const errNote = lastError
+    ? `last error ${relativeTime(lastError)}${lastErrorCode ? ` (${lastErrorCode})` : ''}`
+    : 'has errors';
+
   let summary;
   if (lastSend) {
     summary = `last send ${relativeTime(lastSend)}`;
     if (stats.length > 0) summary += ` (${stats.join(', ')})`;
-    if (hasErrors) summary += ', has errors';
+    if (hasErrors) summary += recovered ? `, recovered — ${errNote}` : `, ${errNote}`;
   } else if (hasErrors) {
-    summary = 'errors in log';
+    summary = `errors in log — ${errNote}`;
     if (stats.length > 0) summary += ` (${stats.join(', ')})`;
   } else {
     summary = `${lines.length} entries`;
@@ -660,10 +689,11 @@ function checkSenderLog() {
   }
 
   const last20 = lines.slice(-20);
+  const state = activeErrors ? 'ACTIVE ERRORS' : recovered ? 'recovered' : 'healthy';
   return {
-    ok: !hasErrors,
+    ok: !activeErrors,
     summary,
-    detail: `Log: ${LOG_PATH}\nTotal entries: ${lines.length}\nCounters: sent_ok=${sentOk}, failed=${failedCount}, rollbacks=${rollbackCount}\nLast 20 entries:\n${last20.join('\n')}`,
+    detail: `Log: ${LOG_PATH}\nTotal entries: ${lines.length}\nCounters: sent_ok=${sentOk}, failed=${failedCount} (${recentFailed} in 24h), rollbacks=${rollbackCount}\nLast send: ${lastSend || '(never)'}\nLast error: ${lastError || '(none)'}${lastErrorCode ? ` (${lastErrorCode})` : ''}\nState: ${state}\nLast 20 entries:\n${last20.join('\n')}`,
   };
 }
 
@@ -816,31 +846,46 @@ async function checkServer(serverUrl) {
   }
 
   const url = `${serverUrl}/api/health`;
-  const start = Date.now();
-  try {
-    const res = await fetch(url, { signal: AbortSignal.timeout(8000) });
-    const latency = Date.now() - start;
-    const body = await res.text();
-    if (res.ok) {
+  // A single probe times out on a transient network blip (VPN reconnect, brief
+  // packet loss) and flags the server red even when it's actually fine. Retry a
+  // few times with a short backoff before the verdict; an HTTP response (even an
+  // error status) short-circuits — the server answered, no point retrying.
+  const ATTEMPTS = 3;
+  const PER_ATTEMPT_TIMEOUT = 5000;
+  const codes = [];
+  const attemptLog = [];
+  for (let attempt = 1; attempt <= ATTEMPTS; attempt++) {
+    const start = Date.now();
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(PER_ATTEMPT_TIMEOUT) });
+      const latency = Date.now() - start;
+      const body = await res.text();
+      if (res.ok) {
+        const note = attempt > 1 ? `, ${attempt}/${ATTEMPTS} attempts` : '';
+        return {
+          ok: true,
+          summary: `reachable (${latency}ms${note})`,
+          detail: `URL: ${url}\nStatus: ${res.status}\nLatency: ${latency}ms\nAttempt: ${attempt}/${ATTEMPTS}\nResponse: ${body}`,
+        };
+      }
       return {
-        ok: true,
-        summary: `reachable (${latency}ms)`,
+        ok: false,
+        summary: `HTTP ${res.status} (${latency}ms)`,
         detail: `URL: ${url}\nStatus: ${res.status}\nLatency: ${latency}ms\nResponse: ${body}`,
       };
+    } catch (err) {
+      const latency = Date.now() - start;
+      const code = err.code || err.cause?.code || err.message;
+      codes.push(code);
+      attemptLog.push(`#${attempt}: ${code} (${latency}ms)`);
+      if (attempt < ATTEMPTS) await new Promise(r => setTimeout(r, 1000));
     }
-    return {
-      ok: false,
-      summary: `HTTP ${res.status} (${latency}ms)`,
-      detail: `URL: ${url}\nStatus: ${res.status}\nLatency: ${latency}ms\nResponse: ${body}`,
-    };
-  } catch (err) {
-    const latency = Date.now() - start;
-    return {
-      ok: false,
-      summary: `unreachable (${err.code || err.cause?.code || err.message})`,
-      detail: `URL: ${url}\nError: ${err.message}\nLatency: ${latency}ms`,
-    };
   }
+  return {
+    ok: false,
+    summary: `unreachable (${codes[codes.length - 1]}, ${ATTEMPTS} attempts)`,
+    detail: `URL: ${url}\nUnreachable after ${ATTEMPTS} attempts:\n${attemptLog.join('\n')}`,
+  };
 }
 
 async function checkToken(serverUrl, authToken) {
@@ -1097,7 +1142,50 @@ function buildReport(results, timestamp, warnings = [], allTools = TOOL_CONFIGS)
 // Report mode: POST structured status to server
 // ---------------------------------------------------------------------------
 
-async function sendStatusReport(results, warnings, clientVersion, clientCommit, serverUrl, authToken) {
+// AI Lens config (~/.ai-lens/config.json) with the auth token masked, or null if
+// absent/unreadable. Mirrors the masked dump buildReport writes to the local file.
+function maskedAiLensConfig() {
+  try {
+    const raw = readFileSync(join(homedir(), '.ai-lens', 'config.json'), 'utf-8');
+    const config = JSON.parse(raw);
+    if (config.authToken) config.authToken = maskToken(config.authToken);
+    return config;
+  } catch {
+    return null;
+  }
+}
+
+// Hook-config file contents for every tool (Cursor/Claude Code/Codex), both
+// global and project scope, so a single remote report is enough to diagnose hook
+// wiring (actual command form, scope, $CLAUDE_PROJECT_DIR vs %VAR%, missing file)
+// without asking the developer for their local ~/ai-lens-status.txt.
+function collectHookConfigs(allTools) {
+  const entries = [];
+  const readHooks = (tool, scope, path) => {
+    let hooks = null, error = null;
+    try {
+      const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+      hooks = parsed.hooks ?? null;
+      if (hooks === null) error = 'no hooks section';
+    } catch (err) {
+      error = err.code === 'ENOENT' ? 'not found' : err.message;
+    }
+    entries.push({ tool: tool.name, scope, path, hooks, error });
+  };
+  for (const tool of allTools) {
+    const scope = TOOL_CONFIGS.includes(tool) ? 'global' : 'project';
+    readHooks(tool, scope, tool.configPath);
+    // Claude Code keeps a separate settings.local.json (personal/project override)
+    // that can carry or disable hooks — capture it when present.
+    if (tool.name.startsWith('Claude Code') && tool.dirPath) {
+      const localPath = join(tool.dirPath, 'settings.local.json');
+      if (existsSync(localPath)) readHooks(tool, `${scope}-local`, localPath);
+    }
+  }
+  return entries;
+}
+
+async function sendStatusReport(results, warnings, clientVersion, clientCommit, serverUrl, authToken, allTools = TOOL_CONFIGS) {
   if (!serverUrl || !authToken) return;
 
   const payload = {
@@ -1108,6 +1196,12 @@ async function sendStatusReport(results, warnings, clientVersion, clientCommit,
     os: `${process.platform} ${osRelease()} ${osArch()}`,
     checks: results.map(({ label, ok, summary, detail }) => ({ label, ok, summary, detail })),
     warnings: warnings.map(({ msg, action }) => ({ msg, action })),
+    // Config + hook dumps (token masked) — the local-file-only sections, now also
+    // sent so remote triage doesn't need the developer's ~/ai-lens-status.txt.
+    configs: {
+      ai_lens: maskedAiLensConfig(),
+      hooks: collectHookConfigs(allTools),
+    },
   };
 
   try {
@@ -1332,16 +1426,18 @@ export default async function status({ report = false } = {}) {
     }
   }
 
+  // Global TOOL_CONFIGS (always listed, even if not installed) + project tools.
+  // Used by both report modes: the server JSON config dump and the local text file.
+  const allToolsForReport = [...TOOL_CONFIGS, ...toolsWithProject.filter(t => !TOOL_CONFIGS.includes(t))];
+
   if (report) {
     // --report mode: same on-screen output as normal status, but POST the
     // structured JSON to the server instead of writing the local text file.
-    await sendStatusReport(results, warnings, version, commit, serverUrl, authToken);
+    await sendStatusReport(results, warnings, version, commit, serverUrl, authToken, allToolsForReport);
     blank();
   } else {
     // Normal mode: write text report file
     const timestamp = new Date().toISOString();
-    // Merge global TOOL_CONFIGS (always listed, even if not installed) with project tools
-    const allToolsForReport = [...TOOL_CONFIGS, ...toolsWithProject.filter(t => !TOOL_CONFIGS.includes(t))];
     const reportText = buildReport(results, timestamp, warnings, allToolsForReport);
     try {
       writeFileSync(REPORT_PATH, reportText);

package/package.json

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