infernoflow 0.34.1 → 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");
+  }
 }