infernoflow 0.12.0 → 0.14.0

package/dist/lib/commands/teamSync.mjs

@@ -0,0 +1,388 @@
+/**
+ * infernoflow team-sync
+ *
+ * Shared capability contract sync across a team.
+ * Uses a dedicated git branch (`inferno-contracts`) as the source of truth.
+ *
+ * Sub-commands:
+ *   infernoflow team-sync push      — push local contract to shared branch
+ *   infernoflow team-sync pull      — pull shared contract, detect conflicts
+ *   infernoflow team-sync status    — show diff between local and shared
+ *   infernoflow team-sync init      — create the shared branch if it doesn't exist
+ *
+ * Flags:
+ *   --branch <name>   Shared branch name (default: inferno-contracts)
+ *   --remote <name>   Git remote (default: origin)
+ *   --json            Machine-readable output
+ *   --force           Overwrite conflicts without prompting
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+import { header, ok, warn, info, done, bold, cyan, gray, green, red, yellow } from "../ui/output.mjs";
+
+// ── git helpers ───────────────────────────────────────────────────────────────
+
+function capture(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  } catch { return null; }
+}
+
+function run(cmd, cwd) {
+  execSync(cmd, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+}
+
+function currentBranch(cwd) {
+  return capture("git rev-parse --abbrev-ref HEAD", cwd) || "HEAD";
+}
+
+function currentUser(cwd) {
+  return capture("git config user.name", cwd) || capture("git config user.email", cwd) || "unknown";
+}
+
+function hasRemote(remote, cwd) {
+  return !!capture(`git remote get-url ${remote}`, cwd);
+}
+
+function branchExistsRemote(remote, branch, cwd) {
+  return !!capture(`git ls-remote --heads ${remote} refs/heads/${branch}`, cwd);
+}
+
+// ── capability helpers ────────────────────────────────────────────────────────
+
+function parseCaps(jsonText) {
+  if (!jsonText) return [];
+  try {
+    const obj = JSON.parse(jsonText);
+    const raw = obj.capabilities || [];
+    return raw.map(c => typeof c === "string" ? { id: c, title: c } : c);
+  } catch { return []; }
+}
+
+function capsToMap(caps) {
+  return new Map(caps.map(c => [c.id, c]));
+}
+
+function detectConflicts(local, shared, base) {
+  // A conflict occurs when BOTH local and shared changed the same capability
+  // since the last sync (base).
+  const localMap  = capsToMap(local);
+  const sharedMap = capsToMap(shared);
+  const baseMap   = capsToMap(base);
+
+  const conflicts = [];
+  const localOnly = [];
+  const sharedOnly = [];
+
+  const allIds = new Set([...localMap.keys(), ...sharedMap.keys(), ...baseMap.keys()]);
+
+  for (const id of allIds) {
+    const localCap  = localMap.get(id);
+    const sharedCap = sharedMap.get(id);
+    const baseCap   = baseMap.get(id);
+
+    const localChanged  = JSON.stringify(localCap)  !== JSON.stringify(baseCap);
+    const sharedChanged = JSON.stringify(sharedCap) !== JSON.stringify(baseCap);
+
+    if (localChanged && sharedChanged && JSON.stringify(localCap) !== JSON.stringify(sharedCap)) {
+      conflicts.push({ id, local: localCap, shared: sharedCap, base: baseCap });
+    } else if (localCap && !sharedCap && !baseCap) {
+      localOnly.push(localCap);    // added locally, not in shared yet
+    } else if (!localCap && sharedCap && !baseCap) {
+      sharedOnly.push(sharedCap); // added in shared, not locally yet
+    }
+  }
+
+  return { conflicts, localOnly, sharedOnly };
+}
+
+// ── shared branch operations ──────────────────────────────────────────────────
+
+function readContractFromBranch(remote, branch, cwd) {
+  // Fetch the branch first
+  try { run(`git fetch ${remote} ${branch} --quiet`, cwd); } catch {}
+
+  const content = capture(`git show ${remote}/${branch}:inferno/contract.json`, cwd);
+  if (!content) return null;
+  try { return JSON.parse(content); } catch { return null; }
+}
+
+function readLastSyncBase(infernoDir) {
+  const basePath = path.join(infernoDir, ".team-sync-base.json");
+  if (!fs.existsSync(basePath)) return null;
+  try { return JSON.parse(fs.readFileSync(basePath, "utf8")); } catch { return null; }
+}
+
+function writeLastSyncBase(infernoDir, contract) {
+  const basePath = path.join(infernoDir, ".team-sync-base.json");
+  fs.writeFileSync(basePath, JSON.stringify(contract, null, 2), "utf8");
+}
+
+// ── sub-commands ──────────────────────────────────────────────────────────────
+
+function initSharedBranch(cwd, remote, branch, infernoDir, asJson) {
+  if (!hasRemote(remote, cwd)) {
+    const msg = `Remote "${remote}" not found. Add it first: git remote add ${remote} <url>`;
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  if (branchExistsRemote(remote, branch, cwd)) {
+    if (asJson) { console.log(JSON.stringify({ ok: true, action: "already_exists", branch })); }
+    else { ok(`Shared branch ${bold(branch)} already exists on ${remote}`); }
+    return;
+  }
+
+  // Create orphan branch with just the contract
+  const contractPath = path.join(infernoDir, "contract.json");
+  if (!fs.existsSync(contractPath)) {
+    const msg = "inferno/contract.json not found — run: infernoflow init";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  // Use a temp worktree approach: push contract.json to the branch
+  const tmpDir = path.join(infernoDir, ".team-sync-tmp");
+  try {
+    fs.mkdirSync(tmpDir, { recursive: true });
+    const contractContent = fs.readFileSync(contractPath, "utf8");
+    fs.writeFileSync(path.join(tmpDir, "contract.json"), contractContent);
+
+    // Create an empty tree commit on the shared branch
+    run(`git checkout --orphan ${branch}`, cwd);
+    run(`git rm -rf . --quiet 2>/dev/null || true`, cwd);
+    run(`git checkout ${currentBranch(cwd)} -- inferno/contract.json`, cwd);
+    run(`git add inferno/contract.json`, cwd);
+    run(`git commit -m "infernoflow: initialize shared contract branch"`, cwd);
+    run(`git push ${remote} ${branch}`, cwd);
+    run(`git checkout -`, cwd); // back to previous branch
+  } catch (err) {
+    // Restore original branch on failure
+    try { run(`git checkout -`, cwd); } catch {}
+    const msg = `Failed to create shared branch: ${err.message}`;
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  } finally {
+    try { fs.rmSync(tmpDir, { recursive: true }); } catch {}
+  }
+
+  if (asJson) { console.log(JSON.stringify({ ok: true, action: "created", branch, remote })); }
+  else { done(`Shared branch ${bold(branch)} created on ${bold(remote)}`); }
+}
+
+function pushToShared(cwd, remote, branch, infernoDir, asJson, force) {
+  const contractPath = path.join(infernoDir, "contract.json");
+  if (!fs.existsSync(contractPath)) {
+    const msg = "inferno/contract.json not found";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  const localContract = JSON.parse(fs.readFileSync(contractPath, "utf8"));
+  const user          = currentUser(cwd);
+
+  // Stamp the push metadata
+  localContract._teamSync = {
+    pushedBy:  user,
+    pushedAt:  new Date().toISOString(),
+    fromBranch: currentBranch(cwd),
+  };
+
+  // Write updated contract
+  fs.writeFileSync(contractPath, JSON.stringify(localContract, null, 2), "utf8");
+
+  // Commit + push to shared branch
+  try {
+    run(`git fetch ${remote} ${branch} --quiet`, cwd);
+    // Use a temporary stash-push approach: push just the contract file
+    capture(`git stash --quiet`, cwd);
+    try {
+      run(`git checkout ${remote}/${branch} -- inferno/contract.json 2>/dev/null || git checkout ${remote}/${branch} inferno/contract.json`, cwd);
+    } catch {}
+    capture(`git stash pop --quiet`, cwd);
+
+    // Write the updated content
+    fs.writeFileSync(contractPath, JSON.stringify(localContract, null, 2), "utf8");
+    run(`git add inferno/contract.json`, cwd);
+    run(`git commit -m "infernoflow team-sync: push by ${user}"`, cwd);
+    run(`git push ${remote} HEAD:${branch}`, cwd);
+
+    // Save base snapshot
+    writeLastSyncBase(infernoDir, localContract);
+
+    if (asJson) { console.log(JSON.stringify({ ok: true, action: "pushed", remote, branch, user })); }
+    else { done(`Contract pushed to ${bold(remote + "/" + branch)} by ${bold(user)}`); }
+  } catch (err) {
+    const msg = `Push failed: ${err.message}`;
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg);
+    info(`Try: git push ${remote} HEAD:${branch} --force  (use --force flag)`);
+    process.exit(1);
+  }
+}
+
+function pullFromShared(cwd, remote, branch, infernoDir, asJson, force) {
+  const contractPath = path.join(infernoDir, "contract.json");
+
+  // Fetch remote contract
+  const sharedContract = readContractFromBranch(remote, branch, cwd);
+  if (!sharedContract) {
+    const msg = `Could not read contract from ${remote}/${branch}. Run: infernoflow team-sync init`;
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  const localContract = fs.existsSync(contractPath)
+    ? JSON.parse(fs.readFileSync(contractPath, "utf8")) : { capabilities: [] };
+
+  const baseContract = readLastSyncBase(infernoDir) || { capabilities: [] };
+
+  const localCaps  = parseCaps(JSON.stringify(localContract));
+  const sharedCaps = parseCaps(JSON.stringify(sharedContract));
+  const baseCaps   = parseCaps(JSON.stringify(baseContract));
+
+  const { conflicts, localOnly, sharedOnly } = detectConflicts(localCaps, sharedCaps, baseCaps);
+
+  if (conflicts.length > 0 && !force) {
+    if (asJson) {
+      console.log(JSON.stringify({ ok: false, error: "conflicts_detected", conflicts, hint: "Use --force to overwrite with remote version" }));
+      process.exit(1);
+    }
+    warn(`${conflicts.length} capability conflict${conflicts.length !== 1 ? "s" : ""} detected:\n`);
+    for (const c of conflicts) {
+      console.log(`  ${red("✗")} ${bold(c.id)}`);
+      console.log(`      local:  ${gray(c.local?.title || "(removed)")}`);
+      console.log(`      shared: ${gray(c.shared?.title || "(removed)")}`);
+    }
+    console.log();
+    warn("Resolve conflicts manually or use --force to take the shared version");
+    process.exit(1);
+  }
+
+  // Merge: take shared as base, apply localOnly additions
+  const merged = { ...sharedContract };
+  const mergedCaps = [...sharedCaps];
+  for (const cap of localOnly) mergedCaps.push(cap);
+  merged.capabilities = mergedCaps;
+  delete merged._teamSync;
+
+  fs.writeFileSync(contractPath, JSON.stringify(merged, null, 2), "utf8");
+  writeLastSyncBase(infernoDir, merged);
+
+  if (asJson) {
+    console.log(JSON.stringify({
+      ok: true, action: "pulled", remote, branch,
+      conflicts: conflicts.length,
+      localOnly: localOnly.length,
+      sharedOnly: sharedOnly.length,
+    }));
+  } else {
+    console.log();
+    ok("Contract updated from shared branch");
+    if (conflicts.length > 0) warn(`${conflicts.length} conflict(s) resolved with --force (shared version wins)`);
+    if (localOnly.length  > 0) ok(`${localOnly.length} local capability(-ies) preserved`);
+    if (sharedOnly.length > 0) ok(`${sharedOnly.length} new capability(-ies) pulled from shared`);
+    if (conflicts.length === 0 && localOnly.length === 0 && sharedOnly.length === 0) {
+      info("Already in sync — no changes");
+    }
+    console.log();
+  }
+}
+
+function showStatus(cwd, remote, branch, infernoDir, asJson) {
+  const contractPath = path.join(infernoDir, "contract.json");
+
+  try { run(`git fetch ${remote} ${branch} --quiet`, cwd); } catch {}
+
+  const sharedContract = readContractFromBranch(remote, branch, cwd);
+  if (!sharedContract) {
+    const msg = `Shared branch ${remote}/${branch} not found. Run: infernoflow team-sync init`;
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  const localContract = fs.existsSync(contractPath)
+    ? JSON.parse(fs.readFileSync(contractPath, "utf8")) : { capabilities: [] };
+
+  const localCaps  = parseCaps(JSON.stringify(localContract));
+  const sharedCaps = parseCaps(JSON.stringify(sharedContract));
+
+  const localMap  = capsToMap(localCaps);
+  const sharedMap = capsToMap(sharedCaps);
+
+  const onlyLocal  = localCaps.filter(c => !sharedMap.has(c.id));
+  const onlyShared = sharedCaps.filter(c => !localMap.has(c.id));
+  const inSync     = onlyLocal.length === 0 && onlyShared.length === 0;
+  const pushedBy   = sharedContract._teamSync?.pushedBy || "unknown";
+  const pushedAt   = sharedContract._teamSync?.pushedAt || "unknown";
+
+  if (asJson) {
+    console.log(JSON.stringify({
+      ok: true, inSync,
+      local: localCaps.length, shared: sharedCaps.length,
+      onlyLocal: onlyLocal.map(c => c.id),
+      onlyShared: onlyShared.map(c => c.id),
+      lastPush: { by: pushedBy, at: pushedAt },
+    }));
+    return;
+  }
+
+  console.log();
+  console.log(`  Shared branch  ${bold(cyan(remote + "/" + branch))}`);
+  console.log(`  Last push      ${bold(pushedBy)}  ${gray(pushedAt.slice(0, 19).replace("T", " "))}`);
+  console.log();
+
+  if (inSync) {
+    ok("Local and shared contracts are in sync");
+  } else {
+    if (onlyLocal.length) {
+      console.log(`  ${yellow("→")} ${bold(onlyLocal.length)} local capability(-ies) not yet pushed:`);
+      for (const c of onlyLocal) console.log(`    ${yellow("+")} ${c.id}  ${gray(c.title)}`);
+    }
+    if (onlyShared.length) {
+      console.log(`  ${cyan("←")} ${bold(onlyShared.length)} shared capability(-ies) not yet pulled:`);
+      for (const c of onlyShared) console.log(`    ${cyan("+")} ${c.id}  ${gray(c.title)}`);
+    }
+    console.log();
+    if (onlyLocal.length)  info(`Run ${cyan("infernoflow team-sync push")} to share your changes`);
+    if (onlyShared.length) info(`Run ${cyan("infernoflow team-sync pull")} to get team changes`);
+  }
+
+  console.log();
+}
+
+// ── main ──────────────────────────────────────────────────────────────────────
+
+export async function teamSyncCommand(rawArgs) {
+  const args   = rawArgs.slice(1);
+  const asJson = args.includes("--json");
+  const force  = args.includes("--force");
+
+  const branchIdx = args.indexOf("--branch");
+  const remoteIdx = args.indexOf("--remote");
+  const branch = branchIdx !== -1 ? args[branchIdx + 1] : "inferno-contracts";
+  const remote = remoteIdx !== -1 ? args[remoteIdx + 1] : "origin";
+
+  const sub = args.find(a => !a.startsWith("-")) || "status";
+
+  const cwd        = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+
+  if (!asJson) header("infernoflow team-sync");
+
+  if (!fs.existsSync(infernoDir)) {
+    const msg = "inferno/ not found — run: infernoflow init";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  switch (sub) {
+    case "init":   initSharedBranch(cwd, remote, branch, infernoDir, asJson); break;
+    case "push":   pushToShared(cwd, remote, branch, infernoDir, asJson, force); break;
+    case "pull":   pullFromShared(cwd, remote, branch, infernoDir, asJson, force); break;
+    case "status":
+    default:       showStatus(cwd, remote, branch, infernoDir, asJson); break;
+  }
+}

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();
+}