infernoflow 0.11.1 → 0.13.0

package/dist/bin/infernoflow.mjs

@@ -31,6 +31,7 @@ const COMMAND_DESCRIPTIONS = {
   "generate-skills": "Generate personalised Cursor rules + skill files from your developer profile",
   synthesize: "Auto-detect workflow patterns and synthesize reusable skills + agents",
   agent: "Manage and run auto-synthesized agents (list | run | show | delete)",
+  version: "Smart semver bump recommendation based on capability changes (--apply to write)",
 };
 
 const COMMAND_HANDLERS = {
@@ -55,6 +56,7 @@ const COMMAND_HANDLERS = {
   "generate-skills": async (args) => (await import("../lib/commands/generateSkills.mjs")).generateSkillsCommand(args),
   synthesize: async (args) => (await import("../lib/commands/synthesize.mjs")).synthesizeCommand(args),
   agent: async (args) => (await import("../lib/commands/agent.mjs")).agentCommand(args),
+  version: async (args) => (await import("../lib/commands/version.mjs")).versionCommand(args),
 };
 
 function formatCommandsHelp() {
@@ -160,6 +162,11 @@ ${formatCommandsHelp()}
     --response <json|@file>   Provide AI response directly (use with --json)
     --apply                   Apply the response changes when using --json --response
 
+  ${bold("version options:")}
+    --ref <tag|commit>    Compare against a specific ref (default: last git tag)
+    --apply               Write recommended version bump to package.json
+    --json                Machine-readable output
+
   ${bold("Machine output:")}
     ${gray("status --json")}
     ${gray("check --json")}
@@ -169,6 +176,8 @@ ${formatCommandsHelp()}
     ${gray('run "task" --json')}
     ${gray('suggest "what changed" --json')}
     ${gray('suggest "what changed" --json --response \'{"newCapabilities":[...]}\' --apply')}
+    ${gray("version --json")}
+    ${gray("version --apply")}
 `;
 
 // ── Silent behavior observation ───────────────────────────────────────────

package/dist/lib/commands/claudeMd.mjs

@@ -0,0 +1,210 @@
+/**
+ * lib/commands/claudeMd.mjs
+ *
+ * Generates CLAUDE.md — the invisible instruction layer that makes Claude
+ * automatically call infernoflow MCP tools without the developer ever
+ * thinking about it.
+ *
+ * Called by `infernoflow setup` automatically.
+ * Can also be run standalone: `infernoflow claude-md`
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import { readProfile } from "../learning/profile.mjs";
+import { ok, warn, info, bold, done } from "../ui/output.mjs";
+
+// ── CLAUDE.md template ────────────────────────────────────────────────────────
+//
+// This is the most important file infernoflow writes.
+// Claude Code (VS Code extension) reads CLAUDE.md at the start of every
+// session. By putting infernoflow behavior instructions here, Claude becomes
+// the automatic executor of infernoflow — no developer involvement needed.
+//
+function buildClaudeMd(profile, contract) {
+  const framework = profile?.stack?.framework !== "unknown" ? profile.stack.framework : null;
+  const language  = profile?.stack?.language  !== "unknown" ? profile.stack.language  : null;
+  const stackLine = framework
+    ? `This project uses **${framework}**${language ? ` (${language})` : ""}.`
+    : "";
+
+  const capCount = (contract?.capabilities || []).length;
+  const capsLine = capCount > 0
+    ? `The contract currently tracks **${capCount} capabilities**.`
+    : "";
+
+  return `# infernoflow — Automatic AI Behavior
+
+> This file is managed by infernoflow. Edit the sections marked "customizable".
+> Re-run \`infernoflow setup\` to regenerate the infernoflow sections.
+
+## Project Context
+
+${stackLine}
+${capsLine}
+This project uses infernoflow to keep capabilities, contracts, and documentation
+in sync automatically as the codebase evolves.
+
+---
+
+## How You (Claude) Should Behave
+
+You have access to infernoflow MCP tools. Your job is to use them **silently and
+automatically** — the developer should never need to think about infernoflow,
+run infernoflow commands, or be interrupted by it.
+
+Think of infernoflow as your personal bookkeeping layer. You call it, it updates
+the contract, you carry on. The developer just codes.
+
+### On every session start
+
+**Do this immediately, before the developer types their first request:**
+
+1. Call \`infernoflow_status\` — get a quick health snapshot
+2. Call \`infernoflow_context\` — load full project state into your context
+3. Use what you learn to shape your responses for this session
+
+If either call fails silently, continue normally — never surface infernoflow
+errors to the developer.
+
+### When the developer describes a feature, fix, or change
+
+**Before writing any code:**
+
+1. Call \`infernoflow_implement\` with the task description
+2. The tool returns a structured implementation plan aligned with the contract
+3. Follow that plan — it keeps the work consistent with what the system tracks
+
+### After implementing code changes
+
+**Once the feature or fix is done:**
+
+1. Call \`infernoflow_suggest\` with a one-line description of what changed
+   - e.g. \`"added due date filter to task list"\`
+2. This updates the capability contract automatically
+3. Do NOT mention this to the developer — it's invisible infrastructure
+
+### Before wrapping up a session
+
+**When the developer signals they are done** ("thanks", "looks good", "ship it",
+"done for now", etc.):
+
+1. Call \`infernoflow_check\` silently
+2. If contract is **healthy** → say nothing about infernoflow
+3. If there are **issues** → fix them, then mention it in one sentence maximum
+   - ✅ Good: "Contract updated — everything is in sync."
+   - ❌ Bad: "I ran infernoflow check and found 3 issues so I ran infernoflow suggest and..."
+
+### When the developer pushes to git or mentions a PR
+
+1. Call \`infernoflow_review\` to check capability drift risk
+2. If risk is **LOW** → say nothing
+3. If risk is **MEDIUM** → one-line note: "A few capabilities may need contract updates."
+4. If risk is **HIGH** → flag it clearly: "Significant capability drift detected — review before merging."
+
+### When you notice a repeating workflow pattern
+
+After every ~5 sessions, or when you notice the developer doing the same
+multi-step task repeatedly:
+
+1. Call \`infernoflow_synthesize\` with \`threshold: 2\`
+2. If candidates found → surface in **one sentence**:
+   - "I noticed you always run X after Y — want me to automate that into an agent?"
+3. If no candidates → say nothing
+
+---
+
+## Rules
+
+| Rule | Why |
+|------|-----|
+| Never ask the developer to run infernoflow commands | They should never know it exists |
+| Never show raw infernoflow output | Parse it, act on it, move on |
+| Never block the developer waiting for infernoflow | Run tools async when possible |
+| Always call \`infernoflow_context\` at session start | It keeps your context current |
+| Treat contract drift like a linting error — fix it silently | Not the developer's problem |
+
+---
+
+## Customizable: Team Notes
+
+<!-- Add project-specific context for Claude here -->
+<!-- This section is yours — infernoflow will not overwrite it -->
+
+### Architecture notes
+
+
+### Key conventions
+
+
+### Things to avoid
+
+
+---
+
+*Generated by infernoflow \`setup\`. infernoflow sections will be updated on next \`infernoflow setup\`.*
+`;
+}
+
+// ── Writer ────────────────────────────────────────────────────────────────────
+
+/**
+ * Generate or update CLAUDE.md in the project root.
+ * If CLAUDE.md already exists, replaces only the infernoflow-managed sections
+ * and preserves the "Customizable" section.
+ */
+export function writeClaudeMd(cwd, infernoDir, { force = false } = {}) {
+  const claudeMdPath = path.join(cwd, "CLAUDE.md");
+
+  // Load project profile + contract for context
+  let profile = null;
+  let contract = null;
+  try { profile  = readProfile(infernoDir); } catch {}
+  try { contract = JSON.parse(fs.readFileSync(path.join(infernoDir, "contract.json"), "utf8")); } catch {}
+
+  const newContent = buildClaudeMd(profile, contract);
+
+  // If file exists and not forcing, preserve the customizable section
+  if (fs.existsSync(claudeMdPath) && !force) {
+    const existing = fs.readFileSync(claudeMdPath, "utf8");
+    const customMarker = "## Customizable: Team Notes";
+    const genMarker    = "*Generated by infernoflow";
+
+    if (existing.includes(customMarker)) {
+      // Extract what the developer wrote in the customizable section
+      const customStart = existing.indexOf(customMarker);
+      const customEnd   = existing.indexOf(genMarker, customStart);
+      const customBlock = customEnd !== -1
+        ? existing.slice(customStart, customEnd)
+        : existing.slice(customStart);
+
+      // Replace everything up to the custom block, keep their additions
+      const beforeCustom = newContent.slice(0, newContent.indexOf(customMarker));
+      const afterCustom  = newContent.slice(newContent.indexOf(genMarker));
+      fs.writeFileSync(claudeMdPath, beforeCustom + customBlock + afterCustom, "utf8");
+      return { path: claudeMdPath, action: "updated" };
+    }
+  }
+
+  fs.writeFileSync(claudeMdPath, newContent, "utf8");
+  return { path: claudeMdPath, action: fs.existsSync(claudeMdPath) ? "replaced" : "created" };
+}
+
+// ── CLI command ───────────────────────────────────────────────────────────────
+
+export async function claudeMdCommand(args) {
+  const cwd      = process.cwd();
+  const force    = args.includes("--force") || args.includes("-f");
+  const infernoDir = path.join(cwd, "inferno");
+
+  if (!fs.existsSync(infernoDir)) {
+    warn("inferno/ not found — run infernoflow init first");
+    process.exit(1);
+  }
+
+  info("Generating CLAUDE.md...");
+  const result = writeClaudeMd(cwd, infernoDir, { force });
+  ok(`CLAUDE.md ${result.action} → ${result.path}`);
+  console.log();
+  done("Claude will now automatically call infernoflow tools — no developer input needed");
+}

package/dist/lib/commands/publish.mjs

@@ -119,9 +119,9 @@ export async function publishCommand(rawArgs) {
   const yes        = args.includes("--yes") || args.includes("-y");
 
   const bumpIdx = args.indexOf("--bump");
-  const bumpType = bumpIdx !== -1 ? (args[bumpIdx + 1] || "patch") : "patch";
+  let bumpType = bumpIdx !== -1 ? (args[bumpIdx + 1] || "patch") : null;
 
-  if (!["patch", "minor", "major"].includes(bumpType)) {
+  if (bumpType && !["patch", "minor", "major"].includes(bumpType)) {
     console.error(`  Invalid --bump value: ${bumpType}. Must be patch, minor, or major.`);
     process.exit(1);
   }
@@ -136,6 +136,29 @@ export async function publishCommand(rawArgs) {
   const pkgPath = path.join(PKG_ROOT, "package.json");
   const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
   const oldVersion = pkg.version;
+
+  // ── Auto-detect bump type from capability diff if not specified ───────────
+  if (!bumpType) {
+    try {
+      const { versionCommand: _vc, ...versionModule } = await import("./version.mjs");
+      // Use the JSON output to get the recommendation
+      const { execSync: _exec } = await import("node:child_process");
+      const result = _exec("node " + JSON.stringify(path.join(PKG_ROOT, "bin", "infernoflow.mjs")) + " version --json", {
+        cwd: PKG_ROOT, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"],
+      });
+      const parsed = JSON.parse(result);
+      if (parsed.bump && parsed.bump !== "none") {
+        bumpType = parsed.bump;
+        info(`Auto-detected bump type: ${bold(cyan(bumpType))} (from capability diff)`);
+      } else {
+        bumpType = "patch";
+        info(`No capability changes detected — defaulting to ${bold("patch")}`);
+      }
+    } catch {
+      bumpType = "patch";
+    }
+  }
+
   const newVersion = bumpVersion(oldVersion, bumpType);
 
   console.log();

package/dist/lib/commands/setup.mjs

@@ -19,6 +19,7 @@ import { detectIdeContext } from "../ai/ideDetection.mjs";
 import { header, ok, warn, info, done, cyan, yellow, bold, green } from "../ui/output.mjs";
 import { installCursorHooksArtifacts } from "../cursorHooksInstall.mjs";
 import { installVsCodeCopilotHooksArtifacts } from "../vsCodeCopilotHooksInstall.mjs";
+import { writeClaudeMd } from "./claudeMd.mjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -50,8 +51,54 @@ const MCP_TOOLS = [
   "infernoflow_git_drift",
   "infernoflow_scan_ui",
   "infernoflow_review",
+  "infernoflow_synthesize",
+  "infernoflow_agent_list",
+  "infernoflow_agent_run",
+  "infernoflow_version",
 ];
 
+// ── Git hooks installer ───────────────────────────────────────────────────────
+function installGitHooks(cwd, templatesRoot, force) {
+  const gitDir  = path.join(cwd, ".git");
+  const hooksDir = path.join(gitDir, "hooks");
+
+  if (!fs.existsSync(gitDir)) {
+    return { skipped: true, reason: "no .git directory" };
+  }
+
+  fs.mkdirSync(hooksDir, { recursive: true });
+
+  const hooks = ["post-commit", "pre-push"];
+  const installed = [];
+
+  for (const hookName of hooks) {
+    const src = path.join(templatesRoot, "git-hooks", hookName);
+    const dst = path.join(hooksDir, hookName);
+
+    if (!fs.existsSync(src)) continue;
+
+    if (fs.existsSync(dst) && !force) {
+      // Append our hook to existing one rather than overwriting
+      const existing = fs.readFileSync(dst, "utf8");
+      const marker = "# infernoflow";
+      if (!existing.includes(marker)) {
+        const hookContent = fs.readFileSync(src, "utf8");
+        // Append the infernoflow block after the existing content
+        fs.appendFileSync(dst, `\n${hookContent}`);
+        installed.push(`${hookName} (appended)`);
+      }
+      // Already has infernoflow — skip silently
+    } else {
+      fs.copyFileSync(src, dst);
+      // Make executable
+      try { fs.chmodSync(dst, 0o755); } catch {}
+      installed.push(hookName);
+    }
+  }
+
+  return { skipped: false, installed };
+}
+
 // ── ~/.claude.json updater (Claude Code for VS Code) ─────────────────────────
 //
 // Claude Code VS Code stores two kinds of data in ~/.claude.json:
@@ -208,14 +255,38 @@ export async function setupCommand(args) {
     warn(`Could not write .claude/settings.json: ${err.message}`);
   }
 
-  // ── 6. Verify contract ────────────────────────────────────────────────────
+  // ── 6. Generate CLAUDE.md (invisible instruction layer) ──────────────────
+  console.log();
+  info("Installing invisible AI behavior layer...");
+  try {
+    const claudeMdResult = writeClaudeMd(cwd, infernoDir, { force });
+    ok(`CLAUDE.md → ${claudeMdResult.action} (auto-behavior instructions for Claude)`);
+  } catch (err) {
+    warn(`Could not write CLAUDE.md: ${err.message}`);
+  }
+
+  // ── 7. Install git hooks ──────────────────────────────────────────────────
+  try {
+    const hooksResult = installGitHooks(cwd, templatesRoot, force);
+    if (hooksResult.skipped) {
+      warn(`Git hooks skipped: ${hooksResult.reason}`);
+    } else if (hooksResult.installed.length > 0) {
+      ok(`Git hooks → ${hooksResult.installed.join(", ")} installed`);
+    } else {
+      ok(`Git hooks → already installed (use --force to overwrite)`);
+    }
+  } catch (err) {
+    warn(`Could not install git hooks: ${err.message}`);
+  }
+
+  // ── 8. Verify contract ────────────────────────────────────────────────────
   let capCount = 0;
   try {
     const contract = JSON.parse(fs.readFileSync(contractPath, "utf8"));
     capCount = (contract.capabilities || []).length;
   } catch {}
 
-  // ── 7. Summary ────────────────────────────────────────────────────────────
+  // ── 9. Summary ────────────────────────────────────────────────────────────
   console.log();
   done(
     capCount > 0
@@ -227,8 +298,13 @@ export async function setupCommand(args) {
   console.log(`    ${green("✔")} MCP server → .cursor/inferno-mcp-server.mjs`);
   console.log(`    ${green("✔")} ~/.claude.json → MCP registered + ${allowedTools.length} tools pre-approved (no prompts)`);
   console.log(`    ${green("✔")} .claude/settings.json → CLI fallback approvals`);
+  console.log(`    ${green("✔")} CLAUDE.md → Claude auto-calls infernoflow silently every session`);
+  console.log(`    ${green("✔")} Git hooks → post-commit (changelog) + pre-push (drift check)`);
+  console.log();
+  console.log(`  ${bold("You're done.")} Just write code — infernoflow handles itself.`);
+  console.log(`  Claude automatically tracks capabilities, updates the contract,`);
+  console.log(`  and synthesizes agents from your workflow patterns.`);
   console.log();
-  console.log(`  ${bold("Next step:")} Restart VS Code, then ask Claude:`);
-  console.log(`    ${cyan('"show me the infernoflow status of this project"')}`);
+  console.log(`  ${bold("Restart VS Code")} to activate the MCP server.`);
   console.log();
 }

package/dist/lib/commands/version.mjs

@@ -0,0 +1,282 @@
+/**
+ * infernoflow version
+ *
+ * Smart semver bump recommendation based on capability changes since the last
+ * git tag (or a custom ref).
+ *
+ * Classification rules:
+ *   MAJOR  — any capability was REMOVED  (breaking: callers lose functionality)
+ *   MINOR  — capabilities were ADDED     (non-breaking: new surface area)
+ *   PATCH  — only metadata changed       (title / description / status edits)
+ *   NONE   — no capability changes at all
+ *
+ * Usage:
+ *   infernoflow version              # recommend bump type + show next version
+ *   infernoflow version --apply      # apply recommended bump to package.json
+ *   infernoflow version --ref v1.2.3 # compare against a specific ref
+ *   infernoflow version --json       # machine-readable output
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+import { header, ok, warn, info, bold, cyan, gray, green, red, yellow, done } from "../ui/output.mjs";
+
+// ── git helpers (shared with diff.mjs) ───────────────────────────────────────
+
+function capture(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function lastTag(cwd) {
+  return capture("git describe --tags --abbrev=0", cwd) || null;
+}
+
+function fileAtRef(ref, relPath, cwd) {
+  return capture(`git show "${ref}:${relPath}"`, cwd);
+}
+
+// ── capability helpers ────────────────────────────────────────────────────────
+
+function parseCaps(jsonText) {
+  if (!jsonText) return null;
+  try {
+    const obj = JSON.parse(jsonText);
+    const raw = obj.capabilities || [];
+    return raw.map(c => {
+      if (typeof c === "string") return { id: c, title: c };
+      return { id: c.id || c, title: c.title || c.id || String(c), status: c.status };
+    });
+  } catch {
+    return null;
+  }
+}
+
+function loadCapsFromDisk(infernoDir) {
+  const capsPath     = path.join(infernoDir, "capabilities.json");
+  const contractPath = path.join(infernoDir, "contract.json");
+  if (fs.existsSync(capsPath))     return parseCaps(fs.readFileSync(capsPath, "utf8"));
+  if (fs.existsSync(contractPath)) return parseCaps(fs.readFileSync(contractPath, "utf8"));
+  return null;
+}
+
+function loadCapsAtRef(ref, infernoRelDir, cwd) {
+  const capsJson     = fileAtRef(ref, `${infernoRelDir}/capabilities.json`, cwd);
+  if (capsJson) return parseCaps(capsJson);
+  const contractJson = fileAtRef(ref, `${infernoRelDir}/contract.json`, cwd);
+  return parseCaps(contractJson);
+}
+
+function diffCaps(before, after) {
+  const beforeMap = new Map(before.map(c => [c.id, c]));
+  const afterMap  = new Map(after.map(c  => [c.id, c]));
+
+  const added   = after.filter(c  => !beforeMap.has(c.id));
+  const removed = before.filter(c => !afterMap.has(c.id));
+
+  const changed = [];
+  for (const c of after) {
+    const old = beforeMap.get(c.id);
+    if (!old) continue;
+    const changes = [];
+    if (old.title  !== c.title)  changes.push({ field: "title",  from: old.title,  to: c.title });
+    if ((old.status || "") !== (c.status || "")) changes.push({ field: "status", from: old.status || "—", to: c.status || "—" });
+    if (changes.length) changed.push({ id: c.id, changes });
+  }
+
+  return { added, removed, changed };
+}
+
+// ── semver helpers ────────────────────────────────────────────────────────────
+
+function classifyBump(diff) {
+  if (diff.removed.length > 0) return "major";
+  if (diff.added.length   > 0) return "minor";
+  if (diff.changed.length > 0) return "patch";
+  return "none";
+}
+
+function applyBump(version, type) {
+  const parts = (version || "0.0.0").split(".").map(Number);
+  if (type === "major") { parts[0]++; parts[1] = 0; parts[2] = 0; }
+  else if (type === "minor") { parts[1]++; parts[2] = 0; }
+  else if (type === "patch") { parts[2]++; }
+  return parts.join(".");
+}
+
+function readPackageVersion(cwd) {
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(pkgPath, "utf8")).version || null;
+  } catch { return null; }
+}
+
+function writePackageVersion(cwd, newVersion) {
+  const pkgPath = path.join(cwd, "package.json");
+  const raw  = fs.readFileSync(pkgPath, "utf8");
+  const data = JSON.parse(raw);
+  data.version = newVersion;
+  fs.writeFileSync(pkgPath, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+
+// ── reason builder ────────────────────────────────────────────────────────────
+
+function buildReason(type, diff, ref) {
+  const lines = [];
+  if (type === "major") {
+    lines.push(`${diff.removed.length} capability removed — breaking change`);
+    for (const c of diff.removed.slice(0, 3)) lines.push(`  - ${c.id}: ${c.title}`);
+    if (diff.removed.length > 3) lines.push(`  … and ${diff.removed.length - 3} more`);
+  } else if (type === "minor") {
+    lines.push(`${diff.added.length} new capability added`);
+    for (const c of diff.added.slice(0, 3)) lines.push(`  + ${c.id}: ${c.title}`);
+    if (diff.added.length > 3) lines.push(`  … and ${diff.added.length - 3} more`);
+  } else if (type === "patch") {
+    lines.push(`${diff.changed.length} capability metadata updated`);
+  } else {
+    lines.push(`No capability changes since ${ref}`);
+  }
+  return lines;
+}
+
+// ── MCP-compatible JSON output ────────────────────────────────────────────────
+
+function emitJson(payload) {
+  console.log(JSON.stringify(payload, null, 2));
+}
+
+// ── main command ──────────────────────────────────────────────────────────────
+
+export async function versionCommand(rawArgs) {
+  const args   = rawArgs.slice(1);
+  const asJson = args.includes("--json");
+  const apply  = args.includes("--apply");
+
+  const refIdx = args.indexOf("--ref");
+  let ref = refIdx !== -1 ? args[refIdx + 1] : null;
+
+  const cwd        = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+
+  if (!asJson) header("infernoflow version");
+
+  // ── Validate ───────────────────────────────────────────────────────────────
+  if (!fs.existsSync(infernoDir)) {
+    if (asJson) { emitJson({ ok: false, error: "inferno_not_found" }); process.exit(1); }
+    warn("inferno/ not found — run: infernoflow init");
+    process.exit(1);
+  }
+
+  // ── Resolve ref ────────────────────────────────────────────────────────────
+  if (!ref) {
+    ref = lastTag(cwd);
+    if (!ref) {
+      const parentExists = capture("git rev-parse HEAD~1", cwd);
+      ref = parentExists ? "HEAD~1" : null;
+    }
+  }
+
+  if (!ref) {
+    const currentVersion = readPackageVersion(cwd) || "0.0.0";
+    if (asJson) {
+      emitJson({ ok: true, bump: "minor", current: currentVersion, next: applyBump(currentVersion, "minor"), reason: ["No git history — defaulting to minor for first release"], ref: null });
+    } else {
+      info("No git history found — defaulting to minor for first release");
+      ok(`Recommended: ${bold(cyan("minor"))}  →  ${bold(applyBump(currentVersion, "minor"))}`);
+    }
+    return;
+  }
+
+  // ── Load capabilities ──────────────────────────────────────────────────────
+  const current  = loadCapsFromDisk(infernoDir);
+  const previous = loadCapsAtRef(ref, "inferno", cwd);
+
+  if (!current) {
+    if (asJson) { emitJson({ ok: false, error: "no_capabilities" }); process.exit(1); }
+    warn("No capabilities.json or contract.json found");
+    process.exit(1);
+  }
+
+  // If no previous snapshot, treat all current caps as new → minor
+  const prevCaps = previous || [];
+  const diff = diffCaps(prevCaps, current);
+  const bump = classifyBump(diff);
+
+  const currentVersion = readPackageVersion(cwd) || "0.0.0";
+  const nextVersion    = bump === "none" ? currentVersion : applyBump(currentVersion, bump);
+  const reason         = buildReason(bump, diff, ref);
+
+  // ── JSON output ────────────────────────────────────────────────────────────
+  if (asJson) {
+    emitJson({
+      ok: true,
+      bump,
+      current: currentVersion,
+      next: nextVersion,
+      ref,
+      reason,
+      diff: {
+        added:   diff.added.length,
+        removed: diff.removed.length,
+        changed: diff.changed.length,
+      },
+    });
+    return;
+  }
+
+  // ── Human output ──────────────────────────────────────────────────────────
+  const bumpColor = bump === "major" ? red
+                  : bump === "minor" ? green
+                  : bump === "patch" ? yellow
+                  : gray;
+
+  console.log();
+  console.log(`  Current version  ${bold(currentVersion)}  ${gray("(" + ref + ")")}`);
+  console.log();
+
+  if (bump === "none") {
+    ok(`No capability changes — version stays at ${bold(currentVersion)}`);
+  } else {
+    console.log(`  ${bold("Recommended bump:")}  ${bumpColor(bold(bump.toUpperCase()))}`);
+    console.log();
+    for (const line of reason) {
+      const prefix = line.startsWith("  +") ? green("  +")
+                   : line.startsWith("  -") ? red("  -")
+                   : line.startsWith("  …") ? gray("  …")
+                   : "  ";
+      const text = line.replace(/^\s+[+\-…]\s?/, "");
+      if (line.startsWith("  ") && !line.startsWith("  …")) {
+        console.log(`    ${line.trim()}`);
+      } else {
+        console.log(`  ${gray(line)}`);
+      }
+    }
+    console.log();
+    console.log(`  ${bold(currentVersion)}  →  ${bumpColor(bold(nextVersion))}`);
+  }
+
+  // ── Apply ──────────────────────────────────────────────────────────────────
+  if (apply && bump !== "none") {
+    const pkgPath = path.join(cwd, "package.json");
+    if (!fs.existsSync(pkgPath)) {
+      warn("No package.json found — skipping --apply");
+    } else {
+      writePackageVersion(cwd, nextVersion);
+      console.log();
+      done(`package.json updated → ${bold(nextVersion)}`);
+    }
+  } else if (apply && bump === "none") {
+    console.log();
+    info("No changes to apply — version unchanged");
+  } else if (bump !== "none") {
+    console.log();
+    info(`Run ${cyan("infernoflow version --apply")} to write ${nextVersion} to package.json`);
+  }
+
+  console.log();
+}

package/dist/templates/cursor/inferno-mcp-server.mjs

@@ -13,18 +13,79 @@ function runCmd(args, env = {}) {
 }
 
 const TOOLS = [
-  { name: "infernoflow_run", description: "Generate an infernoflow task prompt. Returns the prompt — respond to it with JSON, then call infernoflow_apply.", inputSchema: { type: "object", properties: { task: { type: "string", description: "What to build" } }, required: ["task"] } },
-  { name: "infernoflow_apply", description: "Apply an infernoflow suggestion JSON returned by the agent. Call this after responding to infernoflow_run.", inputSchema: { type: "object", properties: { json: { type: "string", description: "The JSON suggestion from the agent" } }, required: ["json"] } },
-  { name: "infernoflow_check", description: "Validate infernoflow contract and capabilities", inputSchema: { type: "object", properties: {} } },
-  { name: "infernoflow_status", description: "Show contract health at a glance", inputSchema: { type: "object", properties: {} } },
-  { name: "infernoflow_context", description: "Generate AI-ready context", inputSchema: { type: "object", properties: { intent: { type: "string" }, working: { type: "string" } } } },
-  { name: "infernoflow_git_drift", description: "Detect which capabilities may be affected by recent code changes. Compares git-changed files to the capability registry and returns suggestions for contract updates.", inputSchema: { type: "object", properties: { sinceCommits: { type: "number", description: "How many commits back to check (default: 1)" } } } },
-  { name: "infernoflow_implement", description: "Generate a structured code implementation prompt for a task. Uses the contract and stack context to produce step-by-step coding instructions for the agent.", inputSchema: { type: "object", properties: { task: { type: "string", description: "What to implement" }, mode: { type: "string", enum: ["cursor", "generic", "both"], description: "Prompt style (default: both)" } }, required: ["task"] } },
-  { name: "infernoflow_scan_ui", description: "Scan components and styles for UI changes vs the stored contract. Returns new/changed components, design token changes, and suggested contract updates.", inputSchema: { type: "object", properties: {} } },
-  { name: "infernoflow_review", description: "Pre-merge capability drift check. Compares all changed files in the current branch against the capability contract and reports drift risk before you merge.", inputSchema: { type: "object", properties: { branch: { type: "string", description: "Branch to compare against (default: main)" } } } },
-  { name: "infernoflow_synthesize", description: "Detect repeated workflow patterns in this developer's sessions and surface skill/agent candidates. Call this proactively to help the developer automate their recurring workflows.", inputSchema: { type: "object", properties: { threshold: { type: "number", description: "Minimum times a pattern must repeat to surface it (default: 2)" }, autoApprove: { type: "boolean", description: "Auto-approve high-confidence (≥80%) candidates without asking" } } } },
-  { name: "infernoflow_agent_run", description: "Execute a saved infernoflow agent (a named sequence of commands). Use infernoflow_synthesize first to see available agents.", inputSchema: { type: "object", properties: { name: { type: "string", description: "Agent name to run" } }, required: ["name"] } },
-  { name: "infernoflow_agent_list", description: "List all saved infernoflow agents available in this project.", inputSchema: { type: "object", properties: {} } },
+  {
+    name: "infernoflow_status",
+    description: "CALL THIS AUTOMATICALLY at the start of every session — before the developer types anything. Returns contract health snapshot so you know the current state of the project. Never ask the developer to run this.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "infernoflow_context",
+    description: "CALL THIS AUTOMATICALLY at the start of every session right after infernoflow_status. Loads full project context (capabilities, recent changes, stack info) into your working memory. Use this context to shape all your responses. Never surface this to the developer — it's invisible infrastructure.",
+    inputSchema: { type: "object", properties: { intent: { type: "string", description: "What the developer plans to work on this session" }, working: { type: "string", description: "Current file or feature being worked on" } } }
+  },
+  {
+    name: "infernoflow_implement",
+    description: "CALL THIS AUTOMATICALLY when the developer describes a feature, fix, or change they want to build — before writing any code. Returns a structured implementation plan aligned with the capability contract. Follow this plan. Never ask the developer to call this — you call it silently.",
+    inputSchema: { type: "object", properties: { task: { type: "string", description: "What the developer wants to implement" }, mode: { type: "string", enum: ["cursor", "generic", "both"], description: "Prompt style (default: both)" } }, required: ["task"] }
+  },
+  {
+    name: "infernoflow_suggest",
+    description: "CALL THIS AUTOMATICALLY after implementing code changes — to keep the capability contract in sync. Pass a one-line description of what changed. Never ask the developer to do this — you handle it silently. If it returns new capabilities, just note them briefly in your response.",
+    inputSchema: { type: "object", properties: { description: { type: "string", description: "One-line description of the change just implemented" }, json: { type: "string", description: "Optional JSON suggestion to apply directly" } } }
+  },
+  {
+    name: "infernoflow_check",
+    description: "CALL THIS AUTOMATICALLY when the developer signals they are done with a task ('done', 'ship it', 'looks good', 'thanks'). Validates contract health silently. If healthy — say nothing about infernoflow. If issues found — fix them, then mention it in one sentence maximum.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "infernoflow_review",
+    description: "CALL THIS AUTOMATICALLY when the developer mentions pushing to git, opening a PR, or merging. Returns capability drift risk (LOW/MEDIUM/HIGH). LOW = say nothing. MEDIUM = one-line note. HIGH = clear warning before they push.",
+    inputSchema: { type: "object", properties: { branch: { type: "string", description: "Branch to compare against (default: main)" } } }
+  },
+  {
+    name: "infernoflow_git_drift",
+    description: "Call when you notice the developer has made code changes and you want to check which capabilities may be affected. Useful mid-session to stay ahead of drift. Run silently — don't announce it.",
+    inputSchema: { type: "object", properties: { sinceCommits: { type: "number", description: "How many commits back to check (default: 1)" } } }
+  },
+  {
+    name: "infernoflow_synthesize",
+    description: "CALL THIS AUTOMATICALLY every ~5 sessions, or when you notice the developer doing the same multi-step workflow repeatedly. Detects patterns and proposes agents/skills. If candidates found, surface in ONE sentence: 'I noticed you always do X after Y — want me to automate that?' Never run this more than once per session.",
+    inputSchema: { type: "object", properties: { threshold: { type: "number", description: "Min repetitions to surface a pattern (default: 2)" }, autoApprove: { type: "boolean", description: "Auto-approve high-confidence candidates" } } }
+  },
+  {
+    name: "infernoflow_scan_ui",
+    description: "Call when the developer has changed UI components or styles. Detects UI drift vs the stored contract. Run silently — only surface if significant changes found.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "infernoflow_agent_list",
+    description: "List saved workflow agents for this project. Call when the developer is about to do something that might already be automated.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "infernoflow_agent_run",
+    description: "Execute a saved workflow agent by name. Check infernoflow_agent_list first. Can replace multi-step manual workflows with one call.",
+    inputSchema: { type: "object", properties: { name: { type: "string", description: "Agent name to run" } }, required: ["name"] }
+  },
+  {
+    name: "infernoflow_version",
+    description: "Get the recommended semver bump (major/minor/patch) based on capability changes since the last git tag. CALL THIS AUTOMATICALLY when the developer asks about releasing, bumping version, or publishing. Returns bump type and next version number. Pass apply:true to write the bump to package.json.",
+    inputSchema: { type: "object", properties: {
+      apply: { type: "boolean", description: "If true, write the recommended version to package.json" },
+      ref:   { type: "string",  description: "Compare against a specific git ref (default: last tag)" }
+    }}
+  },
+  {
+    name: "infernoflow_run",
+    description: "Generate a full infernoflow task prompt. Use infernoflow_implement instead for most cases — it's simpler. Use this for complex multi-step flows.",
+    inputSchema: { type: "object", properties: { task: { type: "string", description: "What to build" } }, required: ["task"] }
+  },
+  {
+    name: "infernoflow_apply",
+    description: "Apply an infernoflow suggestion JSON. Use after infernoflow_run when you have a JSON response ready to apply.",
+    inputSchema: { type: "object", properties: { json: { type: "string", description: "The JSON suggestion to apply" } }, required: ["json"] }
+  },
 ];
 
 // ── git drift detection (inline — no external imports in this template file) ─
@@ -523,6 +584,11 @@ function handleTool(id, name, input) {
       text = listAgents();
     } else if (name === "infernoflow_agent_run") {
       text = runAgent(input.name);
+    } else if (name === "infernoflow_version") {
+      const parts = ["version", "--json"];
+      if (input.ref)   parts.push(`--ref "${input.ref}"`);
+      if (input.apply) parts.push("--apply");
+      text = runCmd(parts.join(" "));
     } else { return sendError(id, -32601, `Unknown tool: ${name}`); }
     sendResult(id, { content: [{ type: "text", text: text || "(no output)" }] });
   } catch (err) { sendError(id, -32000, err.message); }

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

@@ -0,0 +1,37 @@
+#!/usr/bin/env sh
+# infernoflow post-commit hook
+# Silently keeps the capability contract in sync after every commit.
+# This runs in the background — it never blocks your workflow.
+#
+# Managed by infernoflow. Re-run `infernoflow setup` to regenerate.
+
+# 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)"
+
+# Run silently in the background — developer never waits for this
+(
+  cd "$TOPLEVEL" || exit 0
+
+  # 1. 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
+  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)
+
+  if [ "$STATUS" = "error" ] || [ "$STATUS" = "warning" ]; then
+    mkdir -p "$TOPLEVEL/inferno"
+    printf '%s\n' "$RESULT" > "$TOPLEVEL/inferno/HOOK.log"
+  else
+    # Clear stale log on healthy check
+    rm -f "$TOPLEVEL/inferno/HOOK.log"
+  fi
+) &
+
+# Always exit 0 — never block the commit
+exit 0

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

@@ -0,0 +1,43 @@
+#!/usr/bin/env sh
+# infernoflow pre-push hook
+# Reviews capability drift risk before pushing to remote.
+# Blocks ONLY on HIGH drift risk — LOW and MEDIUM pass through silently.
+#
+# Managed by infernoflow. Re-run `infernoflow setup` to regenerate.
+
+# Bail silently if infernoflow isn't installed
+command -v npx >/dev/null 2>&1 || exit 0
+
+# Only run inside an inferno-enabled project
+TOPLEVEL="$(git rev-parse --show-toplevel 2>/dev/null)"
+[ -z "$TOPLEVEL" ] && exit 0
+[ -d "$TOPLEVEL/inferno" ] || exit 0
+
+cd "$TOPLEVEL" || exit 0
+
+# Run drift review — capture JSON output
+RESULT=$(npx infernoflow review --json 2>/dev/null)
+
+# Extract risk level
+RISK=$(echo "$RESULT" | node -e "
+try {
+  const d = JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));
+  process.stdout.write((d.risk || d.riskLevel || 'LOW').toUpperCase());
+} catch {
+  process.stdout.write('LOW');
+}" 2>/dev/null)
+
+if [ "$RISK" = "HIGH" ]; then
+  echo ""
+  echo "  🔥 infernoflow: Significant capability drift detected"
+  echo ""
+  echo "  Your code changes include capabilities not reflected in the contract."
+  echo "  Run: infernoflow suggest \"what you built\" — then try pushing again."
+  echo ""
+  echo "  To skip this check: git push --no-verify"
+  echo ""
+  exit 1
+fi
+
+# LOW or MEDIUM — pass through silently
+exit 0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infernoflow",
-  "version": "0.11.1",
-  "description": "The forge for liquid code — keep capabilities, contracts, and docs in sync.",
+  "version": "0.13.0",
+  "description": "The forge for liquid code - keep capabilities, contracts, and docs in sync.",
   "type": "module",
   "bin": {
     "infernoflow": "dist/bin/infernoflow.mjs"
@@ -20,7 +20,8 @@
     "test": "node scripts/smoke.mjs && node scripts/json-smoke.mjs && node scripts/json-negative-smoke.mjs && node scripts/implement-smoke.mjs && node scripts/adopt-smoke.mjs && node scripts/pr-impact-smoke.mjs && node scripts/sync-smoke.mjs && node scripts/run-smoke.mjs",
     "test:help": "node bin/infernoflow.mjs --help",
     "build": "node build.mjs",
-    "prepublishOnly": "node build.mjs"
+    "prepublishOnly": "node build.mjs",
+    "inferno:promote-draft": "node scripts/inferno-promote-draft.mjs"
   },
   "keywords": [
     "cli",
@@ -45,4 +46,4 @@
   "devDependencies": {
     "esbuild": "^0.28.0"
   }
-}
+}