infernoflow 0.34.1 → 0.35.4

package/dist/lib/commands/setup.mjs

@@ -68,7 +68,7 @@ function installGitHooks(cwd, templatesRoot, force) {
 
   fs.mkdirSync(hooksDir, { recursive: true });
 
-  const hooks = ["post-commit", "pre-push"];
+  const hooks = ["post-commit", "pre-push", "pre-stash"];
   const installed = [];
 
   for (const hookName of hooks) {

package/dist/lib/commands/switch.mjs

@@ -27,15 +27,17 @@
 
 import * as fs   from "node:fs";
 import * as path from "node:path";
+import * as os   from "node:os";
 import { execSync } from "node:child_process";
 import { bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
 
-const INFERNO_DIR    = "inferno";
-const HANDOFF_FILE   = path.join(INFERNO_DIR, "HANDOFF.md");
-const SESSIONS_FILE  = path.join(INFERNO_DIR, "sessions.jsonl");
-const STATE_FILE     = path.join(INFERNO_DIR, "context-state.json");
-const CONTRACT_FILE  = path.join(INFERNO_DIR, "contract.json");
-const THEME_FILE     = path.join(INFERNO_DIR, "theme.json");
+const INFERNO_DIR       = "inferno";
+const HANDOFF_FILE      = path.join(INFERNO_DIR, "HANDOFF.md");
+const SESSIONS_FILE     = path.join(INFERNO_DIR, "sessions.jsonl");
+const STATE_FILE        = path.join(INFERNO_DIR, "context-state.json");
+const CONTRACT_FILE     = path.join(INFERNO_DIR, "contract.json");
+const THEME_FILE        = path.join(INFERNO_DIR, "theme.json");
+const ADOPTION_FILE     = path.join(INFERNO_DIR, "adoption_profile.json");
 
 function readJSON(f) { try { return JSON.parse(fs.readFileSync(f, "utf8")); } catch { return null; } }
 function readFile(f) { try { return fs.readFileSync(f, "utf8"); } catch { return null; } }
@@ -45,6 +47,14 @@ function fmtDate(iso) {
   return new Date(iso).toLocaleString("en-GB", { day: "2-digit", month: "short", hour: "2-digit", minute: "2-digit" });
 }
 
+function fmtDuration(ms) {
+  if (ms < 0) return "unknown";
+  const h = Math.floor(ms / 3600000);
+  const m = Math.floor((ms % 3600000) / 60000);
+  if (h > 0) return `${h}h ${m}m`;
+  return `${m}m`;
+}
+
 function getAllEntries() {
   if (!fs.existsSync(SESSIONS_FILE)) return [];
   return fs.readFileSync(SESSIONS_FILE, "utf8")
@@ -92,37 +102,139 @@ function copyToClipboard(text) {
   } catch { return false; }
 }
 
+/** Detect current IDE from environment */
+function detectIde() {
+  if (process.env.CURSOR_SESSION)       return "Cursor";
+  if (process.env.COPILOT_SESSION)      return "GitHub Copilot";
+  if (process.env.CLAUDE_CODE_SESSION)  return "Claude Code";
+  if (process.env.WINDSURF_SESSION)     return "Windsurf";
+  if (process.env.TERM_PROGRAM === "vscode") return "VS Code";
+  // Check adoption profile
+  const profile = readJSON(ADOPTION_FILE);
+  if (profile?.ide)  return profile.ide;
+  return null;
+}
+
+/** Get git diff stat since last commit */
+function getGitDiffStat() {
+  try {
+    const stat = execSync("git diff --stat HEAD 2>/dev/null || git diff --cached --stat 2>/dev/null", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    if (!stat) {
+      // Try HEAD~1 if nothing staged/unstaged
+      const logStat = execSync("git log --stat -1 --pretty= 2>/dev/null", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+      return logStat || null;
+    }
+    return stat;
+  } catch {
+    return null;
+  }
+}
+
+/** Get recent git commits in this session */
+function getGitCommits(since) {
+  try {
+    const sinceArg = since ? `--after="${since.toISOString()}"` : "-5";
+    const log = execSync(`git log ${sinceArg} --pretty=format:"%h %s" 2>/dev/null`, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    return log ? log.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+
+/** Detect "open threads" — attempts without resolution + entries containing TODO/WIP markers */
+function findOpenThreads(sessions) {
+  const open = [];
+
+  // Failed/partial attempts that were never followed by a worked attempt
+  const attempts = sessions.filter(e => e.type === "attempt" && (e.result === "failed" || e.result === "partial" || !e.result));
+  for (const a of attempts) {
+    const followedByWorked = sessions.find(e =>
+      e.type === "attempt" &&
+      e.result === "worked" &&
+      new Date(e.ts) > new Date(a.ts) &&
+      e.summary.toLowerCase().includes(a.summary.split(" ")[0].toLowerCase())
+    );
+    if (!followedByWorked) {
+      open.push({ text: a.summary, ts: a.ts, kind: "unresolved-attempt" });
+    }
+  }
+
+  // Any entry explicitly marked TODO/WIP in summary
+  for (const e of sessions) {
+    if (/\b(TODO|WIP|FIXME|BLOCKED|pending)\b/i.test(e.summary)) {
+      if (!open.find(o => o.text === e.summary)) {
+        open.push({ text: e.summary, ts: e.ts, kind: "flagged" });
+      }
+    }
+  }
+
+  return open.slice(0, 8); // cap at 8
+}
+
 function buildHandoff(toAgent, sinceArg, allFlag) {
   const state      = readJSON(STATE_FILE)    || {};
   const contract   = readJSON(CONTRACT_FILE) || {};
   const theme      = readJSON(THEME_FILE);
+  const adoption   = readJSON(ADOPTION_FILE);
   const allEntries = getAllEntries();
   const sessionStart = findSessionStart(allEntries, sinceArg, allFlag);
-  // Session entries: everything since boundary; also keep last 5 for "recent log"
   const sessions   = allEntries.filter(e => new Date(e.ts || 0) > sessionStart);
-  const recentFallback = allEntries.slice(-5); // fallback if session is empty
-  const now        = new Date().toLocaleString("en-GB", { day: "2-digit", month: "short", year: "numeric", hour: "2-digit", minute: "2-digit" });
-
-  const projectId = contract.policyId || path.basename(process.cwd());
-  const version   = contract.policyVersion || "?";
-  const caps      = (contract.capabilities || []).slice(0, 20);
-
-  // ── Session memory grouped by type ────────────────────────────────────────
+  const recentFallback = allEntries.slice(-5);
+  const now        = new Date();
+  const nowStr     = now.toLocaleString("en-GB", { day: "2-digit", month: "short", year: "numeric", hour: "2-digit", minute: "2-digit" });
+
+  const projectId  = contract.policyId || path.basename(process.cwd());
+  const version    = contract.policyVersion || "?";
+  const caps       = (contract.capabilities || []).slice(0, 20);
+  const ide        = detectIde();
+
+  // Session metadata
+  const sessionDurationMs = sessionStart.getTime() > 0 ? now - sessionStart : -1;
+  const sessionDuration   = fmtDuration(sessionDurationMs);
+  // Short session ID: hex of sessionStart ms
+  const sessionId = sessionStart.getTime() > 0
+    ? sessionStart.getTime().toString(16).slice(-6).toUpperCase()
+    : "ALL";
+
+  // Git data
+  const commits    = getGitCommits(sessionStart.getTime() > 0 ? sessionStart : null);
+  const diffStat   = getGitDiffStat();
+
+  // Memory pool
   const pool      = sessions.length > 0 ? sessions : recentFallback;
   const gotchas   = pool.filter(e => e.type === "gotcha");
   const decisions = pool.filter(e => e.type === "decision");
   const attempts  = pool.filter(e => e.type === "attempt").filter(e => e.result === "failed" || e.result === "partial");
   const prefs     = pool.filter(e => e.type === "preference");
-  const recent    = pool.slice(-8); // last 8 regardless of type
+  const recent    = pool.slice(-8);
+  const openThreads = findOpenThreads(pool);
 
   const sinceStr = sessionStart.getTime() === 0
     ? "all time"
     : sessionStart.toLocaleString("en-GB", { day: "2-digit", month: "short", hour: "2-digit", minute: "2-digit" });
 
+  // ── Sources header ─────────────────────────────────────────────────────────
+  const sourcesList = ["sessions.jsonl"];
+  if (state.working || state.intent) sourcesList.push("context-state.json");
+  if (theme)    sourcesList.push("theme.json");
+  if (contract.capabilities?.length) sourcesList.push("contract.json");
+  if (adoption) sourcesList.push("adoption_profile.json");
+  if (commits.length) sourcesList.push("git log");
+
   const lines = [
     `# 🔥 infernoflow Handoff — ${projectId}`,
-    `> Generated: ${now}${toAgent ? ` | Handing off to: **${toAgent}**` : ""}`,
-    `> Session memory: **${sessions.length} entries** since ${sinceStr}`,
+    `> Generated: ${nowStr}${toAgent ? ` | Handing off to: **${toAgent}**` : ""}`,
+    `> Session: **#${sessionId}** · ${sessionDuration} · **${sessions.length} entries** since ${sinceStr}`,
+    `> Sources: ${sourcesList.join(" · ")}${ide ? ` · IDE: ${ide}` : ""}`,
     "",
     "---",
     "",
@@ -139,6 +251,16 @@ function buildHandoff(toAgent, sinceArg, allFlag) {
     lines.push("_No working state set. Run: `infernoflow context --working \"...\"` to set it._", "");
   }
 
+  // ── Open threads — unresolved items ───────────────────────────────────────
+  if (openThreads.length) {
+    lines.push("## 🔓 Open threads — not yet resolved", "");
+    for (const t of openThreads) {
+      const badge = t.kind === "flagged" ? "[flagged]" : "[unresolved]";
+      lines.push(`- ${badge} ${t.text}  _(${fmtDate(t.ts)})_`);
+    }
+    lines.push("");
+  }
+
   // ── Gotchas first — most critical for a new agent ─────────────────────────
   if (gotchas.length) {
     lines.push("## ⚠ Gotchas — read these first", "");
@@ -176,6 +298,23 @@ function buildHandoff(toAgent, sinceArg, allFlag) {
     lines.push("");
   }
 
+  // ── Git activity this session ──────────────────────────────────────────────
+  if (commits.length || diffStat) {
+    lines.push("## Git activity this session", "");
+    if (commits.length) {
+      lines.push("**Commits:**");
+      for (const c of commits) lines.push(`- \`${c}\``);
+      lines.push("");
+    }
+    if (diffStat) {
+      lines.push("**Uncommitted changes:**");
+      lines.push("```");
+      lines.push(diffStat.split("\n").slice(0, 15).join("\n")); // cap at 15 lines
+      lines.push("```");
+      lines.push("");
+    }
+  }
+
   // ── Design system ─────────────────────────────────────────────────────────
   if (theme) {
     lines.push("## Design system", "");
@@ -206,13 +345,14 @@ function buildHandoff(toAgent, sinceArg, allFlag) {
     lines.push("## Recent session log", "");
     for (const e of recent) {
       const result = e.result ? ` [${e.result}]` : "";
-      lines.push(`- **${e.type}**${result}: ${e.summary}  _(${fmtDate(e.ts)})_`);
+      const src = e.source ? ` {${e.source}}` : "";
+      lines.push(`- **${e.type}**${result}${src}: ${e.summary}  _(${fmtDate(e.ts)})_`);
     }
     lines.push("");
   }
 
   lines.push("---");
-  lines.push("_Paste this at the start of your next AI session. Generated by infernoflow._");
+  lines.push(`_Session #${sessionId} · ${sessionDuration} · Generated by infernoflow._`);
 
   return lines.join("\n");
 }
@@ -252,10 +392,25 @@ export async function switchCommand(args) {
     const state      = readJSON(STATE_FILE)    || {};
     const contract   = readJSON(CONTRACT_FILE) || {};
     const theme      = readJSON(THEME_FILE);
+    const adoption   = readJSON(ADOPTION_FILE);
     const allEntries = getAllEntries();
     const sessionStart = findSessionStart(allEntries, sinceArg, allFlag);
     const sessions   = allEntries.filter(e => new Date(e.ts || 0) > sessionStart);
-    console.log(JSON.stringify({ state, contract: { policyId: contract.policyId, policyVersion: contract.policyVersion, capabilities: contract.capabilities }, theme, sessions, sessionStart: sessionStart.toISOString(), generatedAt: new Date().toISOString() }, null, 2));
+    const commits    = getGitCommits(sessionStart.getTime() > 0 ? sessionStart : null);
+    const ide        = detectIde();
+    console.log(JSON.stringify({
+      state,
+      contract: { policyId: contract.policyId, policyVersion: contract.policyVersion, capabilities: contract.capabilities },
+      theme,
+      adoption,
+      sessions,
+      commits,
+      ide,
+      sessionStart: sessionStart.toISOString(),
+      sessionId: sessionStart.getTime() > 0 ? sessionStart.getTime().toString(16).slice(-6).toUpperCase() : "ALL",
+      sessionDuration: fmtDuration(sessionStart.getTime() > 0 ? Date.now() - sessionStart.getTime() : -1),
+      generatedAt: new Date().toISOString(),
+    }, null, 2));
     return;
   }
 
@@ -274,23 +429,36 @@ export async function switchCommand(args) {
     fs.appendFileSync(SESSIONS_FILE, JSON.stringify(entry) + "\n", "utf8");
   }
 
-  // Print preview
-  const allEntriesForCount = getAllEntries();
-  const sessionStartForCount = findSessionStart(allEntriesForCount, sinceArg, allFlag);
-  const sessionEntries = allEntriesForCount.filter(e => new Date(e.ts || 0) > sessionStartForCount);
-  const state    = readJSON(STATE_FILE) || {};
-  const theme    = readJSON(THEME_FILE);
-  const contract = readJSON(CONTRACT_FILE) || {};
-
-  console.log("  " + bold("Handoff summary"));
+  // ── Rich summary printout ─────────────────────────────────────────────────
+  const allEntriesNow  = getAllEntries();
+  const sessionStartNow = findSessionStart(allEntriesNow, sinceArg, allFlag);
+  const sessionEntries = allEntriesNow.filter(e => new Date(e.ts || 0) > sessionStartNow);
+  const state          = readJSON(STATE_FILE)    || {};
+  const theme          = readJSON(THEME_FILE);
+  const contract       = readJSON(CONTRACT_FILE) || {};
+  const commits        = getGitCommits(sessionStartNow.getTime() > 0 ? sessionStartNow : null);
+  const ide            = detectIde();
+  const pool           = sessionEntries.length > 0 ? sessionEntries : allEntriesNow.slice(-5);
+  const openThreads    = findOpenThreads(pool);
+  const sessionDuration = fmtDuration(sessionStartNow.getTime() > 0 ? Date.now() - sessionStartNow.getTime() : -1);
+  const sessionId      = sessionStartNow.getTime() > 0
+    ? sessionStartNow.getTime().toString(16).slice(-6).toUpperCase()
+    : "ALL";
+
+  // Print rich summary
+  console.log("  " + bold("Handoff ready"));
   console.log("  " + "─".repeat(50));
+  console.log("  " + gray("Session #" + sessionId + " · " + sessionDuration));
   if (state.working) console.log("  Working on    " + cyan(state.working));
   if (state.intent)  console.log("  Intent        " + cyan(state.intent));
-  console.log("  Session       " + sessionEntries.length + " entries (total: " + allEntriesForCount.length + ")");
+  console.log("  Memory        " + sessionEntries.length + " entries this session  (total: " + allEntriesNow.length + ")");
+  if (openThreads.length) console.log("  Open threads  " + yellow(openThreads.length + " unresolved"));
+  if (commits.length)    console.log("  Git commits   " + commits.length + " this session");
   console.log("  Capabilities  " + (contract.capabilities || []).length + " registered");
   if (theme?.fonts?.primary) console.log("  Font          " + theme.fonts.primary);
   if (theme?.colors?.mode)   console.log("  Color mode    " + theme.colors.mode);
-  if (toAgent) console.log("  Handing off → " + cyan(toAgent));
+  if (ide)           console.log("  IDE           " + ide);
+  if (toAgent)       console.log("  Handing off → " + cyan(toAgent));
   console.log();
 
   if (copyFlag) {

package/dist/lib/commands/uninstall.mjs

@@ -5,13 +5,16 @@
  * The inverse of `infernoflow setup`.
  *
  * What it removes:
- *   - inferno/           — contract, capabilities, session memory, HANDOFF.md
- *   - CLAUDE.md          — auto-behavior instruction file
- *   - .claude/           — settings.json with pre-approved tools
- *   - .cursor/inferno-mcp-server.mjs  — MCP server file
- *   - .cursor/mcp.json   — infernoflow entry (other entries preserved)
- *   - ~/.claude.json     — infernoflow mcpServers entry (other entries preserved)
- *   - .git/hooks/post-commit / pre-push — infernoflow sections (other hooks preserved)
+ *   - inferno/                              — contract, capabilities, session memory, HANDOFF.md
+ *   - CLAUDE.md                             — auto-behavior instruction file
+ *   - .claude/settings.json                 — pre-approved tools (infernoflow entries only)
+ *   - .cursor/inferno-mcp-server.mjs        — MCP server file
+ *   - .cursor/hooks.json                    — cursor hooks config (if infernoflow-only)
+ *   - .cursor/hooks/inferno-session-draft.mjs — cursor hook script
+ *   - .cursor/mcp.json                      — infernoflow entry (other entries preserved)
+ *   - inferno-mcp-server.mjs                — root-level MCP server copy
+ *   - ~/.claude.json                        — infernoflow mcpServers entry (other entries preserved)
+ *   - .git/hooks/post-commit / pre-push     — infernoflow sections (other hooks preserved)
  *
  * Flags:
  *   --dry-run         Preview what would be removed without touching anything
@@ -33,15 +36,18 @@ import * as os   from "node:os";
 import * as readline from "node:readline";
 import { bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
 
-const INFERNO_DIR    = "inferno";
-const CLAUDE_MD      = "CLAUDE.md";
-const CLAUDE_DIR     = ".claude";
-const CURSOR_DIR     = ".cursor";
-const MCP_SERVER     = path.join(CURSOR_DIR, "inferno-mcp-server.mjs");
-const CURSOR_MCP     = path.join(CURSOR_DIR, "mcp.json");
-const CLAUDE_JSON    = path.join(os.homedir(), ".claude.json");
-const GIT_HOOKS      = [".git/hooks/post-commit", ".git/hooks/pre-push"];
-const INFERNO_MARKER = "# infernoflow";
+const INFERNO_DIR      = "inferno";
+const CLAUDE_MD        = "CLAUDE.md";
+const CLAUDE_DIR       = ".claude";
+const CURSOR_DIR       = ".cursor";
+const MCP_SERVER       = path.join(CURSOR_DIR, "inferno-mcp-server.mjs");
+const MCP_SERVER_ROOT  = "inferno-mcp-server.mjs";  // root-level copy from install-cursor-hooks
+const CURSOR_HOOKS_JSON= path.join(CURSOR_DIR, "hooks.json");
+const CURSOR_HOOK_FILE = path.join(CURSOR_DIR, "hooks", "inferno-session-draft.mjs");
+const CURSOR_MCP       = path.join(CURSOR_DIR, "mcp.json");
+const CLAUDE_JSON      = path.join(os.homedir(), ".claude.json");
+const GIT_HOOKS        = [".git/hooks/post-commit", ".git/hooks/pre-push"];
+const INFERNO_MARKER   = "# infernoflow";
 
 // ── helpers ──────────────────────────────────────────────────────────────────
 
@@ -123,9 +129,26 @@ function planClaudeDir(cwd) {
 }
 
 function planCursorMcpServer(cwd) {
-  const p = path.join(cwd, MCP_SERVER);
-  if (!exists(p)) return [];
-  return [{ type: "rm", path: MCP_SERVER }];
+  const items = [];
+  // .cursor/inferno-mcp-server.mjs
+  if (exists(path.join(cwd, MCP_SERVER))) items.push({ type: "rm", path: MCP_SERVER });
+  // root-level inferno-mcp-server.mjs (written by install-cursor-hooks)
+  if (exists(path.join(cwd, MCP_SERVER_ROOT))) items.push({ type: "rm", path: MCP_SERVER_ROOT });
+  // .cursor/hooks/inferno-session-draft.mjs
+  if (exists(path.join(cwd, CURSOR_HOOK_FILE))) items.push({ type: "rm", path: CURSOR_HOOK_FILE });
+  // .cursor/hooks.json — only remove if it only contains the infernoflow hook
+  const hooksJsonPath = path.join(cwd, CURSOR_HOOKS_JSON);
+  if (exists(hooksJsonPath)) {
+    const cfg = readJSON(hooksJsonPath);
+    const hooks = cfg?.hooks || [];
+    const hasOnlyInferno = hooks.every(h => (h.name || h.command || "").includes("inferno"));
+    if (hasOnlyInferno) {
+      items.push({ type: "rm", path: CURSOR_HOOKS_JSON, desc: "infernoflow-only hooks config" });
+    } else {
+      items.push({ type: "edit", path: CURSOR_HOOKS_JSON, desc: "remove infernoflow hook entry (preserve others)" });
+    }
+  }
+  return items;
 }
 
 function planCursorMcpJson(cwd) {
@@ -212,7 +235,15 @@ function removeCursorMcpServer(cwd, plan, dryRun) {
   if (dryRun) return;
   for (const item of plan) {
     if (item.type === "rm") {
-      try { fs.unlinkSync(path.join(cwd, MCP_SERVER)); } catch {}
+      try { fs.unlinkSync(path.join(cwd, item.path)); } catch {}
+    } else if (item.type === "edit" && item.path === CURSOR_HOOKS_JSON) {
+      try {
+        const cfg = readJSON(path.join(cwd, CURSOR_HOOKS_JSON));
+        if (cfg?.hooks) {
+          cfg.hooks = cfg.hooks.filter(h => !(h.name || h.command || "").includes("inferno"));
+        }
+        fs.writeFileSync(path.join(cwd, CURSOR_HOOKS_JSON), JSON.stringify(cfg, null, 2) + "\n", "utf8");
+      } catch {}
     }
   }
 }

package/dist/lib/telemetry.mjs

@@ -0,0 +1,194 @@
+/**
+ * infernoflow telemetry
+ *
+ * Opt-in, fire-and-forget usage analytics.
+ *
+ * - Stored in ~/.infernoflow/telemetry.json
+ * - Never enabled without explicit consent
+ * - Never blocks the CLI — all sends are async / best-effort
+ * - Never sends code, file contents, capability names, or personal data
+ *   Only sends: command name, infernoflow version, Node version, OS platform
+ *
+ * Consent is requested lazily on the first interactive infernoflow run
+ * after install (if no consent decision is stored).
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import * as os   from "node:os";
+import * as https from "node:https";
+
+const CONFIG_DIR    = path.join(os.homedir(), ".infernoflow");
+const TELEMETRY_FILE = path.join(CONFIG_DIR, "telemetry.json");
+const EVENTS_FILE    = path.join(CONFIG_DIR, "events.jsonl");
+
+const ENDPOINT = "https://telemetry.infernoflow.dev/v1/event"; // placeholder
+
+// ── Config helpers ────────────────────────────────────────────────────────────
+
+function readConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(TELEMETRY_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeConfig(data) {
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(TELEMETRY_FILE, JSON.stringify(data, null, 2), "utf8");
+}
+
+/** Returns true if the user has opted in */
+export function isTelemetryEnabled() {
+  const cfg = readConfig();
+  return cfg?.enabled === true;
+}
+
+/** Returns true if the user has made a consent decision (either way) */
+export function hasConsentDecision() {
+  const cfg = readConfig();
+  return cfg !== null && typeof cfg.enabled === "boolean";
+}
+
+// ── Consent prompt ────────────────────────────────────────────────────────────
+
+/**
+ * Silently skip if consent already given, or if running non-interactively.
+ * Call this once at the start of each interactive CLI run.
+ */
+export async function ensureTelemetryConsent() {
+  if (hasConsentDecision()) return;
+  if (!process.stdin.isTTY) return;
+
+  // Only ask after 3+ runs (let the user experience it first)
+  const cfg = readConfig() || {};
+  const runs = (cfg.runs || 0) + 1;
+  writeConfig({ ...cfg, runs, enabled: false }); // default off until explicit consent
+
+  if (runs < 3) return;
+
+  // Show one-time prompt
+  const { createInterface } = await import("node:readline");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  const answer = await new Promise(resolve => {
+    process.stdout.write(
+      "\n  📡 Help improve infernoflow?\n" +
+      "  Share anonymous usage data (command names only — no code, no content).\n" +
+      "  Type 'y' to opt in, any other key to decline. You can change this later with: infernoflow telemetry on/off\n" +
+      "  → "
+    );
+    rl.question("", resolve);
+  });
+  rl.close();
+
+  const enabled = answer.trim().toLowerCase() === "y";
+  writeConfig({ enabled, runs, decidedAt: new Date().toISOString() });
+
+  if (enabled) {
+    process.stdout.write("  ✔ Telemetry enabled — thank you! (infernoflow telemetry off to disable)\n\n");
+  } else {
+    process.stdout.write("  ✔ Got it — telemetry off. (infernoflow telemetry on to enable later)\n\n");
+  }
+}
+
+// ── Event tracking ────────────────────────────────────────────────────────────
+
+/** Get current package version */
+function getVersion() {
+  try {
+    const pkgPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../package.json");
+    return JSON.parse(fs.readFileSync(pkgPath, "utf8")).version;
+  } catch {
+    return "unknown";
+  }
+}
+
+/**
+ * Track a command invocation. Fire-and-forget — never throws, never blocks.
+ * @param {string} command  The command name (e.g. "log", "switch", "recap")
+ */
+export function trackEvent(command) {
+  if (!isTelemetryEnabled()) return;
+
+  const event = {
+    ts:      new Date().toISOString(),
+    command,
+    version: getVersion(),
+    node:    process.version,
+    os:      process.platform,
+  };
+
+  // Always append to local event log first
+  try {
+    if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.appendFileSync(EVENTS_FILE, JSON.stringify(event) + "\n", "utf8");
+  } catch {}
+
+  // Fire-and-forget HTTP POST (best effort — no await)
+  try {
+    const body = JSON.stringify(event);
+    const url  = new URL(ENDPOINT);
+    const req  = https.request({
+      hostname: url.hostname,
+      path:     url.pathname,
+      method:   "POST",
+      headers:  { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+      timeout:  3000,
+    });
+    req.on("error", () => {}); // silently ignore all errors
+    req.write(body);
+    req.end();
+  } catch {}
+}
+
+// ── CLI subcommand ────────────────────────────────────────────────────────────
+
+export async function telemetryCommand(args) {
+  const { bold, cyan, gray, green, yellow, red } = await import("./ui/output.mjs");
+  const sub = args[0];
+
+  if (sub === "on") {
+    const cfg = readConfig() || {};
+    writeConfig({ ...cfg, enabled: true, decidedAt: new Date().toISOString() });
+    console.log(green("\n  ✔ Telemetry enabled — thank you for helping improve infernoflow!\n"));
+    return;
+  }
+
+  if (sub === "off") {
+    const cfg = readConfig() || {};
+    writeConfig({ ...cfg, enabled: false, decidedAt: new Date().toISOString() });
+    console.log(green("\n  ✔ Telemetry disabled.\n"));
+    return;
+  }
+
+  if (sub === "status" || !sub) {
+    const cfg = readConfig();
+    const enabled = cfg?.enabled === true;
+    const decided = cfg?.decidedAt ? new Date(cfg.decidedAt).toLocaleDateString() : "never";
+
+    // Count local events
+    let eventCount = 0;
+    try {
+      const lines = fs.readFileSync(EVENTS_FILE, "utf8").split("\n").filter(Boolean);
+      eventCount = lines.length;
+    } catch {}
+
+    console.log("\n  " + bold("🔥 infernoflow telemetry status") + "\n");
+    console.log("  Telemetry     " + (enabled ? green("enabled") : yellow("disabled")));
+    console.log("  Decided       " + gray(decided));
+    console.log("  Events logged " + gray(eventCount + " (local only until enabled)"));
+    console.log("  Data sent     " + gray("command name, infernoflow version, Node version, OS platform"));
+    console.log("  Data never    " + gray("code, file names, capability names, email, personal data"));
+    console.log();
+    console.log(gray("  infernoflow telemetry on   — enable"));
+    console.log(gray("  infernoflow telemetry off  — disable"));
+    console.log();
+    return;
+  }
+
+  console.error(red(`\n  ✘ Unknown subcommand: ${sub}`));
+  console.log(gray("  Usage: infernoflow telemetry [on | off | status]\n"));
+  process.exit(1);
+}

package/dist/templates/git-hooks/post-commit

@@ -1,6 +1,7 @@
 #!/usr/bin/env sh
 # infernoflow post-commit hook
 # Silently keeps the capability contract in sync after every commit.
+# Also auto-captures decisions, gotchas, and fixes from commit messages.
 # This runs in the background — it never blocks your workflow.
 #
 # Managed by infernoflow. Re-run `infernoflow setup` to regenerate.
@@ -17,10 +18,29 @@ TOPLEVEL="$(git rev-parse --show-toplevel)"
 (
   cd "$TOPLEVEL" || exit 0
 
-  # 1. Auto-update changelog with commit info
+  # 1. Auto-capture session memory from commit message
+  # Gets the first line of the commit message (the subject)
+  COMMIT_MSG="$(git log -1 --pretty=%s 2>/dev/null)"
+
+  if [ -n "$COMMIT_MSG" ]; then
+    # Decision patterns: chose/switched/because/use X over Y
+    if echo "$COMMIT_MSG" | grep -qiE "(decided|chose|switched to|use .+ over|instead of|because|prefer .+)"; then
+      npx infernoflow log "$COMMIT_MSG" --type decision --auto --quiet --source git-hook >/dev/null 2>&1
+
+    # Gotcha / fix patterns: bugs, workarounds, reversals
+    elif echo "$COMMIT_MSG" | grep -qiE "^(fix|bug|revert|hotfix|workaround|hack|broke|issue|gotcha|caveat|warn)"; then
+      npx infernoflow log "$COMMIT_MSG" --type gotcha --auto --quiet --source git-hook >/dev/null 2>&1
+
+    # Attempt / WIP patterns
+    elif echo "$COMMIT_MSG" | grep -qiE "^(wip|draft|attempt|try|experiment|test|prototype|spike)"; then
+      npx infernoflow log "$COMMIT_MSG" --type attempt --auto --quiet --source git-hook >/dev/null 2>&1
+    fi
+  fi
+
+  # 2. Auto-update changelog with commit info
   npx infernoflow changelog update --append >/dev/null 2>&1
 
-  # 2. Check contract health; log issues to inferno/HOOK.log so MCP can read it
+  # 3. Check contract health; log issues to inferno/HOOK.log so MCP can read it
   RESULT=$(npx infernoflow check --json 2>/dev/null)
   STATUS=$(echo "$RESULT" | node -e "try{const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));process.stdout.write(d.status||'ok')}catch{process.stdout.write('ok')}" 2>/dev/null)