infernoflow 0.34.2 → 0.35.4

package/dist/bin/infernoflow.mjs

@@ -74,6 +74,8 @@ const COMMAND_DESCRIPTIONS = {
   ask:        "Query session memory — search gotchas, decisions, and failed attempts by keyword or type",
   recap:      "End-of-session summary — what was captured, what git changes weren't logged, session health score",
   uninstall:  "Remove infernoflow from a project — inferno/, CLAUDE.md, MCP server, git hooks (--dry-run to preview)",
+  feedback:   "60-second CLI survey about how you use infernoflow (--form to open web form)",
+  telemetry:  "Manage anonymous usage telemetry (on | off | status) — opt-in, command names only",
 };
 
 const COMMAND_HANDLERS = {
@@ -141,6 +143,8 @@ const COMMAND_HANDLERS = {
   ask:       async (args) => (await import("../lib/commands/ask.mjs")).askCommand(args),
   recap:     async (args) => (await import("../lib/commands/recap.mjs")).recapCommand(args),
   uninstall: async (args) => (await import("../lib/commands/uninstall.mjs")).uninstallCommand(args),
+  feedback:  async (args) => (await import("../lib/commands/feedback.mjs")).feedbackCommand(args),
+  telemetry: async (args) => (await import("../lib/telemetry.mjs")).telemetryCommand(args),
 };
 
 function formatCommandsHelp() {
@@ -151,15 +155,49 @@ function formatCommandsHelp() {
     .join("\n");
 }
 
+// ── Full grouped command list (infernoflow commands) ──────────────────────────
+const COMMAND_GROUPS = {
+  "Session Memory":  ["log", "ask", "switch", "recap", "stats", "theme"],
+  "Context":         ["context", "scan", "suggest", "check", "status"],
+  "Code Analysis":   ["graph", "impact", "why", "coverage", "stability", "freeze", "thaw", "scout"],
+  "Workflow":        ["run", "sync", "watch", "vibe", "implement", "doc-gate", "synthesize", "agent"],
+  "Publishing":      ["publish", "version", "changelog", "diff"],
+  "Team":            ["team-sync", "cloud", "share", "notify", "pr-comment", "pr-impact"],
+  "Quality":         ["health", "audit", "review", "snapshot", "export", "link"],
+  "Integration":     ["ai", "ci", "coverage"],
+  "Setup":           ["init", "setup", "adopt", "demo", "doctor", "onboard", "generate-skills", "upgrade", "uninstall"],
+  "Advanced":        ["scaffold", "explain", "test", "report", "monorepo", "feedback", "telemetry"],
+};
+
+function formatCommandGroups() {
+  const w = 18;
+  return Object.entries(COMMAND_GROUPS).map(([group, cmds]) =>
+    `  ${bold(group + ":")}
+    ${cmds.join("  ")}`
+  ).join("\n\n");
+}
+
 const HELP = `
   ${bold("🔥 infernoflow")} ${gray("v" + VERSION)}
-  ${gray("The forge for liquid code — keep every AI session in sync")}
+  ${gray("Persistent memory for AI coding sessions")}
 
   ${bold("Usage:")}
-    infernoflow <command> [options]
+    infernoflow [command] [options]
 
-  ${bold("Commands:")}
-${formatCommandsHelp()}
+  ${bold("Core Commands:")}
+    ${cyan("log")} ${gray('"..."')}         Add to session memory ${gray("(--type gotcha|decision|attempt|preference)")}
+    ${cyan("ask")} ${gray('"..."')}         Search your memory by keyword ${gray("(gotchas surface first)")}
+    ${cyan("switch")}            Generate handoff for next AI agent
+    ${cyan("recap")}             End-of-session health score + unlogged changes
+    ${cyan("status")}            Contract health at a glance
+
+  ${bold("Getting Started:")}
+    ${cyan("setup")}             One command to get fully operational
+    ${cyan("demo")}              Interactive walkthrough ${gray("(5 minutes)")}
+    ${cyan("doctor")}            Diagnose your setup
+
+  ${gray("Run")} ${cyan("infernoflow commands")} ${gray("to see all commands.")}
+  ${gray("Run")} ${cyan("infernoflow <command> --help")} ${gray("for command-specific options.")}
 
   ${bold("diff options:")}
     --ref <tag|commit>        Compare against a specific ref (default: last git tag)
@@ -503,12 +541,19 @@ if (cmd === "--version" || cmd === "-v") {
   console.log(VERSION);
   process.exit(0);
 }
+if (cmd === "commands") {
+  console.log(`\n  ${bold("🔥 infernoflow")} ${gray("v" + VERSION)} ${gray("— all commands")}\n`);
+  console.log(formatCommandGroups());
+  console.log(`\n  ${gray("Run")} ${cyan("infernoflow <command> --help")} ${gray("for options.")}\n`);
+  process.exit(0);
+}
 
 const commands = Object.keys(COMMAND_HANDLERS);
 
 if (!commands.includes(cmd)) {
   console.error(red(`\nUnknown command: ${cmd}`));
-  console.error(gray("Run: infernoflow --help\n"));
+  console.error(gray(`Run: infernoflow commands  (see all commands)`));
+  console.error(gray("Run: infernoflow --help    (quick start)\n"));
   process.exit(1);
 }
 

package/dist/lib/commands/cloud.mjs

@@ -7,7 +7,12 @@
  * Sub-commands:
  *   cloud init                 Generate a project token and write inferno/.cloud.json
  *   cloud push                 Upload local contract to cloud
+ *   cloud push --memory        Also push session memory (sessions.jsonl) — Pro tier value prop
  *   cloud pull                 Download latest contract from cloud
+ *   cloud pull --memory        Also pull session memory — restores inferno/sessions.jsonl
+ *   cloud memory push          Push session memory only
+ *   cloud memory pull          Pull session memory only
+ *   cloud memory status        Compare local vs remote memory entry count
  *   cloud status               Show local vs cloud diff
  *   cloud dashboard            Print hosted dashboard URL
  *
@@ -16,12 +21,14 @@
  *   --endpoint <url>           Override default endpoint
  *   --dry-run                  Print what would happen without sending
  *   --json                     Machine-readable output
+ *   --memory                   Include session memory (sessions.jsonl) in push/pull
  *
  * Usage:
  *   infernoflow cloud init
  *   infernoflow cloud push
- *   infernoflow cloud pull
- *   infernoflow cloud status --json
+ *   infernoflow cloud push --memory
+ *   infernoflow cloud pull --memory
+ *   infernoflow cloud memory status --json
  */
 
 import * as fs     from "node:fs";
@@ -117,6 +124,233 @@ function contractHash(contract) {
   return crypto.createHash("sha256").update(JSON.stringify(contract)).digest("hex").slice(0, 12);
 }
 
+// ── Session memory helpers ────────────────────────────────────────────────────
+
+const SESSIONS_FILE = "sessions.jsonl";
+
+function readMemory(infernoDir) {
+  const p = path.join(infernoDir, SESSIONS_FILE);
+  if (!fs.existsSync(p)) return [];
+  return fs.readFileSync(p, "utf8")
+    .split("\n").filter(Boolean)
+    .map(l => { try { return JSON.parse(l); } catch { return null; } })
+    .filter(Boolean);
+}
+
+function writeMemory(infernoDir, entries) {
+  const p = path.join(infernoDir, SESSIONS_FILE);
+  fs.writeFileSync(p, entries.map(e => JSON.stringify(e)).join("\n") + "\n", "utf8");
+}
+
+function memoryHash(entries) {
+  return crypto.createHash("sha256")
+    .update(JSON.stringify(entries.map(e => e.ts + e.summary)))
+    .digest("hex").slice(0, 12);
+}
+
+/**
+ * Merge remote memory with local — union by (ts, summary) deduplication.
+ * Keeps all local entries + any remote entries not already present.
+ */
+function mergeMemory(local, remote) {
+  const localKeys = new Set(local.map(e => `${e.ts}|${e.summary}`));
+  const merged = [...local];
+  for (const e of remote) {
+    if (!localKeys.has(`${e.ts}|${e.summary}`)) {
+      merged.push(e);
+    }
+  }
+  return merged.sort((a, b) => a.ts.localeCompare(b.ts));
+}
+
+// ── Memory push/pull ──────────────────────────────────────────────────────────
+
+async function pushMemory(args, infernoDir, config, quietly = false) {
+  const jsonMode = args.includes("--json");
+  const dryRun   = args.includes("--dry-run");
+  const token    = getToken(config, args);
+  const endpoint = getEndpoint(config, args);
+  const projectId = config?.projectId;
+
+  if (!token || !projectId) {
+    const msg = "No token/project found. Run: infernoflow cloud init";
+    if (jsonMode) console.log(JSON.stringify({ ok: false, error: msg }));
+    else if (!quietly) warn(msg);
+    return { ok: false };
+  }
+
+  const entries = readMemory(infernoDir);
+  if (!entries.length) {
+    if (!quietly && !jsonMode) info("No session memory to push (inferno/sessions.jsonl is empty).");
+    return { ok: true, entries: 0 };
+  }
+
+  const hash = memoryHash(entries);
+
+  if (dryRun) {
+    if (jsonMode) console.log(JSON.stringify({ ok: true, dryRun: true, entries: entries.length, hash }));
+    else if (!quietly) info(`Dry run — would push ${bold(String(entries.length))} memory entries (hash: ${hash})`);
+    return { ok: true, dryRun: true };
+  }
+
+  try {
+    const resp = await httpsRequest(
+      "PUT",
+      `${endpoint}/api/projects/${projectId}/memory`,
+      { entries, hash, pushedAt: new Date().toISOString() },
+      token
+    );
+    const ok_flag = resp.status === 200 || resp.status === 201 || resp.status === 204;
+    if (jsonMode) console.log(JSON.stringify({ ok: ok_flag, entries: entries.length, hash }));
+    else if (!quietly) {
+      if (ok_flag) ok(`Pushed ${bold(String(entries.length))} memory entries`);
+      else warn(`Cloud returned ${resp.status}`);
+    }
+    return { ok: ok_flag, entries: entries.length };
+  } catch (err) {
+    if (jsonMode) console.log(JSON.stringify({ ok: false, error: err.message }));
+    else if (!quietly) warn(`Memory push failed: ${err.message}`);
+    return { ok: false };
+  }
+}
+
+async function pullMemory(args, infernoDir, config, quietly = false) {
+  const jsonMode = args.includes("--json");
+  const dryRun   = args.includes("--dry-run");
+  const token    = getToken(config, args);
+  const endpoint = getEndpoint(config, args);
+  const projectId = config?.projectId;
+  const forceOverwrite = args.includes("--force") || args.includes("-f");
+
+  if (!token || !projectId) {
+    const msg = "No token/project found. Run: infernoflow cloud init";
+    if (jsonMode) console.log(JSON.stringify({ ok: false, error: msg }));
+    else if (!quietly) warn(msg);
+    return { ok: false };
+  }
+
+  try {
+    const resp = await httpsRequest(
+      "GET",
+      `${endpoint}/api/projects/${projectId}/memory`,
+      null,
+      token
+    );
+
+    if (resp.status !== 200) {
+      const errMsg = `Cloud returned ${resp.status}`;
+      if (jsonMode) console.log(JSON.stringify({ ok: false, error: errMsg }));
+      else if (!quietly) warn(errMsg);
+      return { ok: false };
+    }
+
+    const remote = resp.body?.entries;
+    if (!remote || !remote.length) {
+      if (!quietly && !jsonMode) info("No session memory in cloud yet. Push first.");
+      return { ok: true, entries: 0 };
+    }
+
+    const local   = readMemory(infernoDir);
+    const merged  = forceOverwrite ? remote : mergeMemory(local, remote);
+    const newCount = merged.length - local.length;
+
+    if (dryRun) {
+      if (jsonMode) console.log(JSON.stringify({ ok: true, dryRun: true, remote: remote.length, local: local.length, merged: merged.length }));
+      else if (!quietly) info(`Dry run — would merge ${bold(String(remote.length))} remote + ${bold(String(local.length))} local = ${bold(String(merged.length))} entries`);
+      return { ok: true, dryRun: true };
+    }
+
+    writeMemory(infernoDir, merged);
+
+    if (jsonMode) console.log(JSON.stringify({ ok: true, remote: remote.length, local: local.length, merged: merged.length, newEntries: newCount }));
+    else if (!quietly) ok(`Merged ${bold(String(remote.length))} remote entries → ${bold(String(merged.length))} total (${newCount} new)`);
+    return { ok: true, entries: merged.length };
+  } catch (err) {
+    if (jsonMode) console.log(JSON.stringify({ ok: false, error: err.message }));
+    else if (!quietly) warn(`Memory pull failed: ${err.message}`);
+    return { ok: false };
+  }
+}
+
+async function subcmdMemory(args, cwd, infernoDir) {
+  const jsonMode = args.includes("--json");
+  const config   = readCloudConfig(infernoDir);
+  const token    = getToken(config, args);
+  const endpoint = getEndpoint(config, args);
+
+  const sub2 = args[0];
+  const sub2Args = args.slice(1);
+
+  if (sub2 === "push") {
+    if (!jsonMode) header("Pushing session memory to cloud");
+    return pushMemory(sub2Args, infernoDir, config);
+  }
+
+  if (sub2 === "pull") {
+    if (!jsonMode) header("Pulling session memory from cloud");
+    return pullMemory(sub2Args, infernoDir, config);
+  }
+
+  if (sub2 === "status" || !sub2) {
+    const local = readMemory(infernoDir);
+    const projectId = config?.projectId;
+
+    if (!config || !token) {
+      if (jsonMode) console.log(JSON.stringify({ ok: false, error: "Not initialised. Run: infernoflow cloud init" }));
+      else warn("Cloud not configured. Run: infernoflow cloud init");
+      return;
+    }
+
+    let remoteCount = null;
+    let remoteHash  = null;
+    let reachable   = false;
+
+    try {
+      const resp = await httpsRequest("GET", `${endpoint}/api/projects/${projectId}/memory`, null, token);
+      if (resp.status === 200 && resp.body?.entries) {
+        reachable   = true;
+        remoteCount = resp.body.entries.length;
+        remoteHash  = memoryHash(resp.body.entries);
+      }
+    } catch {}
+
+    const localHash = local.length ? memoryHash(local) : null;
+
+    if (jsonMode) {
+      console.log(JSON.stringify({
+        ok: true,
+        local:  { entries: local.length, hash: localHash },
+        remote: reachable ? { entries: remoteCount, hash: remoteHash } : null,
+        reachable,
+        inSync: localHash === remoteHash,
+      }));
+      return;
+    }
+
+    console.log();
+    console.log(`  ${bold("infernoflow cloud memory status")}`);
+    console.log();
+    console.log(`  Local:  ${bold(String(local.length))} entries  ${gray("(hash: " + (localHash || "none") + ")")}`);
+    if (!reachable) {
+      console.log(`  Cloud:  ${yellow("unreachable")}`);
+    } else {
+      console.log(`  Cloud:  ${bold(String(remoteCount))} entries  ${gray("(hash: " + (remoteHash || "none") + ")")}`);
+      if (localHash === remoteHash) console.log(`\n  ${green("✔")}  Memory in sync`);
+      else console.log(`\n  ${yellow("⚠")}  Out of sync — run ${cyan("infernoflow cloud memory push")} or ${cyan("infernoflow cloud memory pull")}`);
+    }
+    console.log();
+    return;
+  }
+
+  console.log();
+  console.log(`  ${bold("infernoflow cloud memory")} — session memory sync`);
+  console.log();
+  console.log(`  ${cyan("infernoflow cloud memory push")}    Upload sessions.jsonl to cloud`);
+  console.log(`  ${cyan("infernoflow cloud memory pull")}    Download + merge remote memory`);
+  console.log(`  ${cyan("infernoflow cloud memory status")}  Compare local vs remote`);
+  console.log();
+}
+
 // ── Sub-commands ──────────────────────────────────────────────────────────────
 
 async function subcmdInit(args, cwd, infernoDir) {
@@ -243,6 +477,13 @@ async function subcmdPush(args, cwd, infernoDir) {
         console.log(`  ${gray("Dashboard:")} ${cyan(`${endpoint}/p/${projectId}`)}`);
         console.log();
       }
+
+      // Also push session memory if --memory flag set
+      if (args.includes("--memory")) {
+        if (!jsonMode) info("Pushing session memory...");
+        await pushMemory(args, infernoDir, config, jsonMode);
+        if (!jsonMode) ok("Session memory pushed");
+      }
     } else {
       const errMsg = `Cloud returned ${resp.status}`;
       if (jsonMode) { console.log(JSON.stringify({ ok: false, error: errMsg, status: resp.status })); }
@@ -351,6 +592,12 @@ async function subcmdPull(args, cwd, infernoDir) {
       if (onlyLocal.length) warn(`${onlyLocal.length} local-only capabilities were overwritten.`);
       console.log();
     }
+
+    // Also pull session memory if --memory flag set
+    if (args.includes("--memory")) {
+      if (!jsonMode) info("Pulling session memory...");
+      await pullMemory(args, infernoDir, config, jsonMode);
+    }
   } catch (err) {
     if (jsonMode) { console.log(JSON.stringify({ ok: false, error: err.message })); }
     else { warn(`Cloud unreachable: ${err.message}`); }
@@ -501,19 +748,24 @@ export async function cloudCommand(rawArgs) {
       return subcmdStatus(subArgs, cwd, infernoDir);
     case "dashboard":
       return subcmdDashboard(subArgs, cwd, infernoDir);
+    case "memory":
+      return subcmdMemory(subArgs, cwd, infernoDir);
     default: {
       const jsonMode = args.includes("--json");
-      const msg = `Unknown cloud sub-command: ${subcmd || "(none)"}. Use: init | push | pull | status | dashboard`;
+      const msg = `Unknown cloud sub-command: ${subcmd || "(none)"}. Use: init | push | pull | memory | status | dashboard`;
       if (jsonMode) { console.log(JSON.stringify({ ok: false, error: msg })); }
       else {
         console.log();
-        console.log(`  ${bold("infernoflow cloud")} — hosted contract sync`);
+        console.log(`  ${bold("infernoflow cloud")} — hosted contract + memory sync`);
         console.log();
-        console.log(`  ${cyan("infernoflow cloud init")}       Set up cloud sync for this project`);
-        console.log(`  ${cyan("infernoflow cloud push")}       Upload local contract to cloud`);
-        console.log(`  ${cyan("infernoflow cloud pull")}       Download latest contract from cloud`);
-        console.log(`  ${cyan("infernoflow cloud status")}     Compare local vs cloud`);
-        console.log(`  ${cyan("infernoflow cloud dashboard")}  Open hosted dashboard in browser`);
+        console.log(`  ${cyan("infernoflow cloud init")}               Set up cloud sync for this project`);
+        console.log(`  ${cyan("infernoflow cloud push")}              Upload local contract to cloud`);
+        console.log(`  ${cyan("infernoflow cloud push --memory")}     Also push sessions.jsonl`);
+        console.log(`  ${cyan("infernoflow cloud pull")}              Download latest contract from cloud`);
+        console.log(`  ${cyan("infernoflow cloud pull --memory")}     Also pull + merge session memory`);
+        console.log(`  ${cyan("infernoflow cloud memory push/pull")}  Session memory only`);
+        console.log(`  ${cyan("infernoflow cloud status")}            Compare local vs cloud`);
+        console.log(`  ${cyan("infernoflow cloud dashboard")}         Open hosted dashboard in browser`);
         console.log();
       }
     }

package/dist/lib/commands/feedback.mjs

@@ -0,0 +1,168 @@
+/**
+ * infernoflow feedback
+ *
+ * Collects in-CLI feedback about infernoflow and optionally opens the web form.
+ *
+ * Usage:
+ *   infernoflow feedback            Interactive 5-question survey
+ *   infernoflow feedback --form     Open Google Form in browser
+ *   infernoflow feedback --json     Print last stored feedback as JSON
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import * as os   from "node:os";
+import * as readline from "node:readline";
+import { execSync } from "node:child_process";
+import { bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+
+const FEEDBACK_FORM_URL = "https://forms.gle/infernoflow-feedback"; // placeholder — replace with real form
+const FEEDBACK_FILE     = path.join(os.homedir(), ".infernoflow", "feedback.json");
+
+const QUESTIONS = [
+  {
+    id:      "usage",
+    label:   "How often do you use infernoflow?",
+    choices: ["daily", "a few times a week", "rarely", "just started"],
+  },
+  {
+    id:      "ide",
+    label:   "Which IDE are you using?",
+    choices: ["VS Code + Copilot", "Cursor", "Claude Code", "Windsurf", "Other"],
+  },
+  {
+    id:      "top_command",
+    label:   "Which infernoflow command do you use most?",
+    choices: ["log", "switch", "recap", "status / check", "context", "other"],
+  },
+  {
+    id:      "missing",
+    label:   "What feature do you wish infernoflow had?",
+    freeText: true,
+  },
+  {
+    id:      "email",
+    label:   "Email (optional — for follow-up questions):",
+    freeText: true,
+    optional: true,
+  },
+];
+
+function saveFeedback(responses) {
+  const dir = path.dirname(FEEDBACK_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+  const record = {
+    ts: new Date().toISOString(),
+    version: getVersion(),
+    responses,
+  };
+
+  // Append to array
+  let existing = [];
+  if (fs.existsSync(FEEDBACK_FILE)) {
+    try { existing = JSON.parse(fs.readFileSync(FEEDBACK_FILE, "utf8")); } catch {}
+  }
+  existing.push(record);
+  fs.writeFileSync(FEEDBACK_FILE, JSON.stringify(existing, null, 2), "utf8");
+  return record;
+}
+
+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";
+  }
+}
+
+function openBrowser(url) {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin")  execSync(`open "${url}"`, { stdio: "ignore" });
+    else if (platform === "win32") execSync(`start "" "${url}"`, { stdio: "ignore" });
+    else                           execSync(`xdg-open "${url}"`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function prompt(rl, question) {
+  return new Promise(resolve => rl.question(question, resolve));
+}
+
+async function runSurvey() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  console.log("\n  " + bold("🔥 infernoflow feedback") + "\n");
+  console.log(gray("  Takes ~60 seconds. Helps make infernoflow better.\n"));
+
+  const responses = {};
+
+  for (const q of QUESTIONS) {
+    console.log(cyan(`  ${q.label}`));
+
+    if (q.choices) {
+      q.choices.forEach((c, i) => console.log(gray(`    ${i + 1}. ${c}`)));
+      const raw = await prompt(rl, "  → ");
+      const idx = parseInt(raw.trim()) - 1;
+      responses[q.id] = (idx >= 0 && idx < q.choices.length) ? q.choices[idx] : raw.trim();
+    } else {
+      const raw = await prompt(rl, "  → ");
+      responses[q.id] = raw.trim() || (q.optional ? null : "—");
+    }
+    console.log();
+  }
+
+  rl.close();
+
+  const record = saveFeedback(responses);
+
+  console.log(green("  ✔ Feedback saved — thank you!\n"));
+  console.log(gray("  Stored in: ~/.infernoflow/feedback.json"));
+  console.log(gray(`  Version: ${record.version}`));
+
+  // Nudge to share
+  console.log(gray("\n  To share more detail or attach files, run: infernoflow feedback --form\n"));
+}
+
+export async function feedbackCommand(args) {
+  const has = (f) => args.includes(f);
+
+  // ── --form mode ─────────────────────────────────────────────────────────────
+  if (has("--form")) {
+    console.log(cyan(`\n  Opening feedback form → ${FEEDBACK_FORM_URL}\n`));
+    const opened = openBrowser(FEEDBACK_FORM_URL);
+    if (!opened) {
+      console.log(yellow("  Could not open browser automatically."));
+      console.log(gray(`  Please open manually: ${FEEDBACK_FORM_URL}\n`));
+    }
+    return;
+  }
+
+  // ── --json mode ──────────────────────────────────────────────────────────────
+  if (has("--json")) {
+    if (!fs.existsSync(FEEDBACK_FILE)) {
+      console.log(JSON.stringify([], null, 2));
+      return;
+    }
+    try {
+      const data = JSON.parse(fs.readFileSync(FEEDBACK_FILE, "utf8"));
+      console.log(JSON.stringify(data, null, 2));
+    } catch {
+      console.log(JSON.stringify([], null, 2));
+    }
+    return;
+  }
+
+  // ── Interactive survey ───────────────────────────────────────────────────────
+  if (!process.stdin.isTTY) {
+    console.log(red("  ✘ infernoflow feedback requires an interactive terminal.\n"));
+    console.log(gray("  Run in a terminal or use: infernoflow feedback --form\n"));
+    process.exit(1);
+  }
+
+  await runSurvey();
+}

package/dist/lib/commands/log.mjs

@@ -15,6 +15,11 @@
  *   infernoflow log --show 5        Print last 5 entries
  *   infernoflow log --clear         Archive and clear the log
  *   infernoflow log --json          Print entries as JSON array
+ *
+ * Auto-capture flags (for git hooks / automation):
+ *   infernoflow log "..." --auto              Mark as auto-captured; silent exit if no inferno/
+ *   infernoflow log "..." --quiet             Suppress all output
+ *   infernoflow log "..." --source git-hook   Tag the origin of this log entry
  */
 
 import * as fs   from "node:fs";
@@ -37,12 +42,14 @@ function readEntries() {
     .filter(Boolean);
 }
 
-function appendEntry(entry) {
+function appendEntry(entry, { auto = false, quiet = false } = {}) {
   if (!fs.existsSync(INFERNO_DIR)) {
-    console.error(red("  ✘ inferno/ not found — run: infernoflow init\n"));
+    if (auto) return false; // silently skip — hook running in non-inferno project
+    if (!quiet) console.error(red("  ✘ inferno/ not found — run: infernoflow init\n"));
     process.exit(1);
   }
   fs.appendFileSync(SESSIONS_FILE, JSON.stringify(entry) + "\n", "utf8");
+  return true;
 }
 
 function detectAgent() {
@@ -78,6 +85,9 @@ export async function logCommand(args) {
   const showFlag  = has("--show");
   const clearFlag = has("--clear");
   const jsonFlag  = has("--json");
+  const autoFlag  = has("--auto");   // auto-captured; silent exit if no inferno/
+  const quietFlag = has("--quiet");  // suppress all console output
+  const source    = flag("--source", null); // origin tag, e.g. "git-hook"
 
   // ── Show mode ───────────────────────────────────────────────────────────────
   if (showFlag || jsonFlag) {
@@ -116,8 +126,11 @@ export async function logCommand(args) {
   }
 
   // ── Append mode ─────────────────────────────────────────────────────────────
-  // Collect the message — everything that's not a flag
-  const messageTokens = args.filter(a => !a.startsWith("--") && a !== flag("--type","") && a !== flag("--result","") && a !== flag("--agent",""));
+  // Collect the message — everything that's not a flag or a flag value
+  const flagValues = new Set([
+    flag("--type",""), flag("--result",""), flag("--agent",""), flag("--source","")
+  ].filter(Boolean));
+  const messageTokens = args.filter(a => !a.startsWith("--") && !flagValues.has(a));
   const summary = messageTokens.join(" ").trim();
 
   if (!summary) {
@@ -131,7 +144,8 @@ export async function logCommand(args) {
     console.log(gray('    infernoflow log --json          Print as JSON'));
     console.log();
     console.log(gray("  Types: note · attempt · decision · gotcha · preference · theme · handoff · error"));
-    console.log(gray("  Results: worked · failed · partial · unknown\n"));
+    console.log(gray("  Results: worked · failed · partial · unknown"));
+    console.log(gray("  Auto-capture: --auto (silent skip if no inferno/) · --quiet · --source <name>\n"));
     return;
   }
 
@@ -140,11 +154,11 @@ export async function logCommand(args) {
   const agent  = flag("--agent",  detectAgent());
 
   if (!VALID_TYPES.includes(type)) {
-    console.error(red(`  ✘ Invalid type: ${type}. Valid: ${VALID_TYPES.join(", ")}\n`));
+    if (!quietFlag) console.error(red(`  ✘ Invalid type: ${type}. Valid: ${VALID_TYPES.join(", ")}\n`));
     process.exit(1);
   }
   if (result && !VALID_RESULTS.includes(result)) {
-    console.error(red(`  ✘ Invalid result: ${result}. Valid: ${VALID_RESULTS.join(", ")}\n`));
+    if (!quietFlag) console.error(red(`  ✘ Invalid result: ${result}. Valid: ${VALID_RESULTS.join(", ")}\n`));
     process.exit(1);
   }
 
@@ -153,12 +167,18 @@ export async function logCommand(args) {
     agent,
     type,
     summary,
-    ...(result ? { result } : {}),
+    ...(result  ? { result }        : {}),
+    ...(source  ? { source }        : {}),
+    ...(autoFlag ? { auto: true }   : {}),
   };
 
-  appendEntry(entry);
+  const written = appendEntry(entry, { auto: autoFlag, quiet: quietFlag });
+  if (!written) return; // auto mode, no inferno/ — skip silently
 
-  const typeLabel = type !== "note" ? cyan(` [${type}]`) : "";
-  const resultLabel = result ? gray(` → ${result}`) : "";
-  console.log(green(`  ✔ Logged${typeLabel}${resultLabel}: `) + summary + "\n");
+  if (!quietFlag) {
+    const typeLabel   = type !== "note" ? cyan(` [${type}]`) : "";
+    const resultLabel = result ? gray(` → ${result}`) : "";
+    const sourceLabel = source ? gray(` (via ${source})`) : "";
+    console.log(green(`  ✔ Logged${typeLabel}${resultLabel}${sourceLabel}: `) + summary + "\n");
+  }
 }

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/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)
 

package/dist/templates/git-hooks/pre-stash

@@ -0,0 +1,23 @@
+#!/usr/bin/env sh
+# infernoflow pre-stash hook
+# Auto-logs a stash as an attempt entry in session memory.
+# Runs silently — never blocks your workflow.
+#
+# Managed by infernoflow. Re-run `infernoflow setup` to regenerate.
+# Note: pre-stash requires git 2.32+
+
+# Bail silently if infernoflow isn't installed
+command -v npx >/dev/null 2>&1 || exit 0
+
+# Only run inside an inferno-enabled project
+[ -d "$(git rev-parse --show-toplevel)/inferno" ] || exit 0
+
+TOPLEVEL="$(git rev-parse --show-toplevel)"
+STASH_MSG="${1:-stash}"
+
+(
+  cd "$TOPLEVEL" || exit 0
+  npx infernoflow log "stashed: $STASH_MSG" --type attempt --auto --quiet --source git-hook >/dev/null 2>&1
+) &
+
+exit 0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infernoflow",
-  "version": "0.34.2",
-  "description": "The forge for liquid code - keep capabilities, contracts, and docs in sync.",
+  "version": "0.35.4",
+  "description": "Persistent memory for AI coding sessions — captures what agents can't infer from code alone. Works with Copilot, Cursor, Claude, and Windsurf.",
   "type": "module",
   "bin": {
     "infernoflow": "dist/bin/infernoflow.mjs"
@@ -25,14 +25,26 @@
     "inferno:promote-draft": "node scripts/inferno-promote-draft.mjs"
   },
   "keywords": [
-    "cli",
-    "capabilities",
-    "contract",
-    "documentation",
     "ai",
-    "liquid-code",
-    "dx",
-    "developer-tools"
+    "ai-memory",
+    "ai-context",
+    "ai-coding",
+    "session-memory",
+    "persistent-memory",
+    "agent-memory",
+    "agent-handoff",
+    "copilot",
+    "cursor",
+    "claude",
+    "windsurf",
+    "mcp",
+    "mcp-server",
+    "context-switching",
+    "developer-tools",
+    "cli",
+    "infernoflow",
+    "gotchas",
+    "coding-assistant"
   ],
   "author": "infernoflow",
   "license": "MIT",