infernoflow 0.13.0 → 0.14.0

package/dist/bin/infernoflow.mjs

@@ -32,6 +32,9 @@ const COMMAND_DESCRIPTIONS = {
   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)",
+  "pr-comment": "Post capability drift analysis as a GitHub PR comment (works in CI automatically)",
+  dashboard: "Launch local web dashboard on localhost:7337 — live contract health, capabilities, agents",
+  "team-sync": "Sync capability contract across a team via a shared git branch (push | pull | status | init)",
 };
 
 const COMMAND_HANDLERS = {
@@ -57,6 +60,9 @@ const COMMAND_HANDLERS = {
   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),
+  "pr-comment": async (args) => (await import("../lib/commands/prComment.mjs")).prCommentCommand(args),
+  dashboard: async (args) => (await import("../lib/commands/dashboard.mjs")).dashboardCommand(args),
+  "team-sync": async (args) => (await import("../lib/commands/teamSync.mjs")).teamSyncCommand(args),
 };
 
 function formatCommandsHelp() {
@@ -167,6 +173,14 @@ ${formatCommandsHelp()}
     --apply               Write recommended version bump to package.json
     --json                Machine-readable output
 
+  ${bold("pr-comment options:")}
+    --pr <number>         PR number to comment on (auto-detected in GitHub Actions)
+    --repo <owner/repo>   GitHub repository (auto-detected in GitHub Actions)
+    --token <ghp_...>     GitHub token (auto-detected from GITHUB_TOKEN env var)
+    --ref <ref>           Base ref to diff against (auto-detected from GITHUB_BASE_REF)
+    --dry-run             Print the comment without posting it
+    --json                Machine-readable output
+
   ${bold("Machine output:")}
     ${gray("status --json")}
     ${gray("check --json")}

package/dist/lib/commands/dashboard.mjs

@@ -0,0 +1,399 @@
+/**
+ * infernoflow dashboard
+ *
+ * Launches a local web server on http://localhost:7337 showing:
+ *   - Contract health status
+ *   - Capability list with add/remove/change history
+ *   - Drift timeline (last N sessions)
+ *   - Agent activity log
+ *   - Auto-refresh via SSE (server-sent events)
+ *
+ * Usage:
+ *   infernoflow dashboard              # open on port 7337
+ *   infernoflow dashboard --port 8080  # custom port
+ *   infernoflow dashboard --no-open    # don't auto-open browser
+ */
+
+import * as fs      from "node:fs";
+import * as path    from "node:path";
+import * as http    from "node:http";
+import * as os      from "node:os";
+import { execSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { header, ok, info, warn, bold, cyan, gray } from "../ui/output.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// ── data loaders ──────────────────────────────────────────────────────────────
+
+function loadContract(infernoDir) {
+  const contractPath = path.join(infernoDir, "contract.json");
+  if (!fs.existsSync(contractPath)) return null;
+  try { return JSON.parse(fs.readFileSync(contractPath, "utf8")); } catch { return null; }
+}
+
+function loadCapabilities(infernoDir) {
+  for (const name of ["capabilities.json", "contract.json"]) {
+    const p = path.join(infernoDir, name);
+    if (!fs.existsSync(p)) continue;
+    try {
+      const obj = JSON.parse(fs.readFileSync(p, "utf8"));
+      const raw = obj.capabilities || [];
+      return raw.map(c => typeof c === "string" ? { id: c, title: c } : c);
+    } catch {}
+  }
+  return [];
+}
+
+function loadProfile(infernoDir) {
+  const p = path.join(infernoDir, "developer-profile.json");
+  if (!fs.existsSync(p)) return null;
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+}
+
+function loadAgents(infernoDir) {
+  const agentsDir = path.join(infernoDir, "agents");
+  if (!fs.existsSync(agentsDir)) return [];
+  return fs.readdirSync(agentsDir)
+    .filter(f => f.endsWith(".json"))
+    .map(f => { try { return JSON.parse(fs.readFileSync(path.join(agentsDir, f), "utf8")); } catch { return null; } })
+    .filter(Boolean);
+}
+
+function loadHookLog(infernoDir) {
+  const logPath = path.join(infernoDir, "HOOK.log");
+  if (!fs.existsSync(logPath)) return null;
+  try { return JSON.parse(fs.readFileSync(logPath, "utf8")); } catch { return null; }
+}
+
+function runCheck(infernoDir) {
+  try {
+    const out = execSync("npx infernoflow check --json", {
+      cwd: path.dirname(infernoDir),
+      encoding: "utf8",
+      timeout: 15_000,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    return JSON.parse(out);
+  } catch (err) {
+    try { return JSON.parse(err.stdout || "{}"); } catch { return { status: "error", error: "check failed" }; }
+  }
+}
+
+function gatherData(infernoDir) {
+  const caps     = loadCapabilities(infernoDir);
+  const contract = loadContract(infernoDir);
+  const profile  = loadProfile(infernoDir);
+  const agents   = loadAgents(infernoDir);
+  const hookLog  = loadHookLog(infernoDir);
+  const check    = runCheck(infernoDir);
+  const sessions = profile?.recentSessions?.slice(-10) || [];
+  const candidates = [
+    ...(profile?.agentCandidates || []),
+    ...(profile?.skillCandidates || []),
+  ];
+
+  return { caps, contract, agents, hookLog, check, sessions, candidates, infernoDir };
+}
+
+// ── HTML builder ──────────────────────────────────────────────────────────────
+
+function buildHtml(data, projectName) {
+  const { caps, agents, check, sessions, candidates } = data;
+
+  const statusColor = check?.status === "ok"      ? "#22c55e"
+                    : check?.status === "warning"  ? "#f59e0b"
+                    : check?.status === "error"    ? "#ef4444"
+                    : "#6b7280";
+
+  const statusLabel = check?.status || "unknown";
+  const capCount    = caps.length;
+  const agentCount  = agents.length;
+  const issueCount  = (check?.issues || []).length;
+
+  // Capability rows
+  const capRows = caps.map(c => {
+    const statusBadge = c.status ? `<span class="badge">${c.status}</span>` : "";
+    return `<tr>
+      <td><code>${esc(c.id)}</code></td>
+      <td>${esc(c.title || "")}${statusBadge}</td>
+      <td>${esc(c.since || "")}</td>
+    </tr>`;
+  }).join("\n");
+
+  // Agent rows
+  const agentRows = agents.map(a => {
+    const steps = (a.steps || []).map(s => typeof s === "string" ? s : s.command).join(" → ");
+    const conf  = a.confidence ? `${Math.round(a.confidence * 100)}%` : "—";
+    return `<tr>
+      <td><strong>${esc(a.name)}</strong></td>
+      <td>${esc(a.description || steps)}</td>
+      <td><code>${esc(steps)}</code></td>
+      <td>${conf}</td>
+    </tr>`;
+  }).join("\n");
+
+  // Issues
+  const issueItems = (check?.issues || []).map(i =>
+    `<li class="issue">${esc(typeof i === "string" ? i : i.message || JSON.stringify(i))}</li>`
+  ).join("\n");
+
+  // Session timeline
+  const sessionItems = sessions.slice().reverse().map(s => {
+    const cmds = (s.commands || []).join(", ");
+    const date = s.startedAt ? new Date(s.startedAt).toLocaleString() : "unknown";
+    return `<div class="session-item">
+      <span class="session-date">${esc(date)}</span>
+      <span class="session-cmds">${esc(cmds || "no commands recorded")}</span>
+    </div>`;
+  }).join("\n");
+
+  // Candidate suggestions
+  const candidateItems = candidates.map(c =>
+    `<li class="candidate">${esc(c.name || c.id || "unnamed")}: ${esc(c.description || "")}</li>`
+  ).join("\n");
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>infernoflow — ${esc(projectName)}</title>
+<style>
+  *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+  :root {
+    --bg: #0f1117; --surface: #1a1d27; --border: #2d3148;
+    --text: #e2e8f0; --muted: #64748b; --accent: #f97316;
+    --green: #22c55e; --yellow: #f59e0b; --red: #ef4444; --blue: #3b82f6;
+  }
+  body { background: var(--bg); color: var(--text); font-family: system-ui, sans-serif; font-size: 14px; line-height: 1.5; }
+  header { background: var(--surface); border-bottom: 1px solid var(--border); padding: 16px 24px; display: flex; align-items: center; gap: 12px; }
+  header h1 { font-size: 18px; font-weight: 700; }
+  header .flame { font-size: 22px; }
+  header .project { color: var(--muted); font-size: 13px; }
+  header .live { margin-left: auto; font-size: 11px; color: var(--green); display: flex; align-items: center; gap: 4px; }
+  header .live::before { content: ""; display: inline-block; width: 7px; height: 7px; border-radius: 50%; background: var(--green); animation: pulse 2s infinite; }
+  @keyframes pulse { 0%,100% { opacity: 1; } 50% { opacity: 0.4; } }
+  main { max-width: 1100px; margin: 0 auto; padding: 24px; display: grid; gap: 20px; }
+  .cards { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 16px; }
+  .card { background: var(--surface); border: 1px solid var(--border); border-radius: 10px; padding: 18px; }
+  .card .label { font-size: 11px; text-transform: uppercase; letter-spacing: 0.08em; color: var(--muted); margin-bottom: 8px; }
+  .card .value { font-size: 28px; font-weight: 700; }
+  .card .sub   { font-size: 12px; color: var(--muted); margin-top: 4px; }
+  .status-ok      { color: var(--green); }
+  .status-warning { color: var(--yellow); }
+  .status-error   { color: var(--red); }
+  section { background: var(--surface); border: 1px solid var(--border); border-radius: 10px; overflow: hidden; }
+  section h2 { font-size: 13px; font-weight: 600; padding: 14px 18px; border-bottom: 1px solid var(--border); color: var(--muted); text-transform: uppercase; letter-spacing: 0.06em; }
+  table { width: 100%; border-collapse: collapse; }
+  th, td { padding: 10px 18px; text-align: left; border-bottom: 1px solid var(--border); }
+  th { font-size: 11px; text-transform: uppercase; letter-spacing: 0.06em; color: var(--muted); background: rgba(255,255,255,0.02); }
+  tr:last-child td { border-bottom: none; }
+  tr:hover td { background: rgba(255,255,255,0.03); }
+  code { font-family: monospace; font-size: 12px; background: rgba(255,255,255,0.07); padding: 1px 5px; border-radius: 4px; }
+  .badge { font-size: 10px; background: rgba(249,115,22,0.15); color: var(--accent); padding: 1px 6px; border-radius: 9px; margin-left: 6px; }
+  .issues-list, .candidates-list { list-style: none; padding: 14px 18px; display: flex; flex-direction: column; gap: 8px; }
+  .issue { color: var(--red); font-size: 13px; }
+  .candidate { color: var(--yellow); font-size: 13px; }
+  .empty { padding: 24px 18px; color: var(--muted); text-align: center; font-size: 13px; }
+  .session-item { display: flex; gap: 16px; align-items: baseline; padding: 9px 18px; border-bottom: 1px solid var(--border); }
+  .session-item:last-child { border-bottom: none; }
+  .session-date { font-size: 11px; color: var(--muted); white-space: nowrap; min-width: 140px; }
+  .session-cmds { font-size: 12px; color: var(--text); }
+  footer { text-align: center; color: var(--muted); font-size: 11px; padding: 24px; }
+</style>
+</head>
+<body>
+<header>
+  <span class="flame">🔥</span>
+  <div>
+    <h1>infernoflow</h1>
+    <div class="project">${esc(projectName)}</div>
+  </div>
+  <div class="live">Live</div>
+</header>
+<main>
+
+  <!-- Stat cards -->
+  <div class="cards">
+    <div class="card">
+      <div class="label">Contract status</div>
+      <div class="value status-${statusLabel}" style="color:${statusColor}">${statusLabel.toUpperCase()}</div>
+      <div class="sub">${issueCount > 0 ? issueCount + " issue" + (issueCount !== 1 ? "s" : "") : "All checks passed"}</div>
+    </div>
+    <div class="card">
+      <div class="label">Capabilities</div>
+      <div class="value">${capCount}</div>
+      <div class="sub">tracked in contract</div>
+    </div>
+    <div class="card">
+      <div class="label">Agents</div>
+      <div class="value">${agentCount}</div>
+      <div class="sub">synthesized workflows</div>
+    </div>
+    <div class="card">
+      <div class="label">Sessions</div>
+      <div class="value">${sessions.length}</div>
+      <div class="sub">recent sessions logged</div>
+    </div>
+  </div>
+
+  ${issueCount > 0 ? `
+  <!-- Issues -->
+  <section>
+    <h2>⚠ Issues</h2>
+    <ul class="issues-list">${issueItems}</ul>
+  </section>` : ""}
+
+  <!-- Capabilities -->
+  <section>
+    <h2>Capabilities (${capCount})</h2>
+    ${capCount > 0 ? `
+    <table>
+      <thead><tr><th>ID</th><th>Title</th><th>Since</th></tr></thead>
+      <tbody>${capRows}</tbody>
+    </table>` : `<div class="empty">No capabilities found in inferno/capabilities.json</div>`}
+  </section>
+
+  <!-- Agents -->
+  <section>
+    <h2>Synthesized Agents (${agentCount})</h2>
+    ${agentCount > 0 ? `
+    <table>
+      <thead><tr><th>Name</th><th>Description</th><th>Steps</th><th>Confidence</th></tr></thead>
+      <tbody>${agentRows}</tbody>
+    </table>` : `<div class="empty">No agents yet — run <code>infernoflow synthesize</code> to generate them</div>`}
+  </section>
+
+  ${candidates.length > 0 ? `
+  <!-- Candidates -->
+  <section>
+    <h2>Workflow Candidates (${candidates.length})</h2>
+    <ul class="candidates-list">${candidateItems}</ul>
+  </section>` : ""}
+
+  <!-- Session timeline -->
+  <section>
+    <h2>Recent Sessions</h2>
+    ${sessions.length > 0 ? `<div>${sessionItems}</div>`
+      : `<div class="empty">No session data yet — sessions are logged automatically as you use infernoflow</div>`}
+  </section>
+
+</main>
+<footer>infernoflow dashboard · auto-refreshes every 10s · <a href="/" style="color:var(--muted)">refresh now</a></footer>
+<script>
+  // SSE live reload
+  const es = new EventSource('/events');
+  es.onmessage = () => window.location.reload();
+  es.onerror   = () => {};
+</script>
+</body>
+</html>`;
+}
+
+function esc(str) {
+  return String(str || "")
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+// ── HTTP server ───────────────────────────────────────────────────────────────
+
+function startServer(infernoDir, port) {
+  const cwd         = path.dirname(infernoDir);
+  const projectName = path.basename(cwd);
+  const sseClients  = new Set();
+
+  // Watch inferno/ for changes → notify SSE clients
+  let watchTimer = null;
+  try {
+    fs.watch(infernoDir, { recursive: true }, () => {
+      clearTimeout(watchTimer);
+      watchTimer = setTimeout(() => {
+        for (const res of sseClients) {
+          try { res.write("data: reload\n\n"); } catch {}
+        }
+      }, 500);
+    });
+  } catch {}
+
+  const server = http.createServer((req, res) => {
+    // SSE endpoint
+    if (req.url === "/events") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+      });
+      sseClients.add(res);
+      req.on("close", () => sseClients.delete(res));
+      return;
+    }
+
+    // JSON API
+    if (req.url === "/api/data") {
+      const data = gatherData(infernoDir);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(data, null, 2));
+      return;
+    }
+
+    // Dashboard HTML
+    try {
+      const data = gatherData(infernoDir);
+      const html = buildHtml(data, projectName);
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(html);
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end(`Error: ${err.message}`);
+    }
+  });
+
+  server.listen(port, "127.0.0.1", () => {});
+  return server;
+}
+
+function openBrowser(url) {
+  const platform = os.platform();
+  try {
+    if (platform === "darwin") execSync(`open "${url}"`, { stdio: "ignore" });
+    else if (platform === "win32") execSync(`start "" "${url}"`, { stdio: "ignore", shell: true });
+    else execSync(`xdg-open "${url}"`, { stdio: "ignore" });
+  } catch {}
+}
+
+// ── main ──────────────────────────────────────────────────────────────────────
+
+export async function dashboardCommand(rawArgs) {
+  const args    = rawArgs.slice(1);
+  const noOpen  = args.includes("--no-open");
+  const portIdx = args.indexOf("--port");
+  const port    = portIdx !== -1 ? parseInt(args[portIdx + 1], 10) : 7337;
+
+  const cwd        = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+
+  header("infernoflow dashboard");
+
+  if (!fs.existsSync(infernoDir)) {
+    warn("inferno/ not found — run: infernoflow init");
+    process.exit(1);
+  }
+
+  const url = `http://localhost:${port}`;
+
+  startServer(infernoDir, port);
+
+  ok(`Dashboard running → ${cyan(url)}`);
+  info("Auto-refreshes when inferno/ files change");
+  info("Press Ctrl+C to stop");
+  console.log();
+
+  if (!noOpen) openBrowser(url);
+
+  // Keep alive
+  await new Promise(() => {});
+}

package/dist/lib/commands/prComment.mjs

@@ -0,0 +1,361 @@
+/**
+ * infernoflow pr-comment
+ *
+ * Posts a capability drift analysis as a GitHub PR comment.
+ * Designed to run in CI (GitHub Actions) on pull_request events.
+ *
+ * Auto-reads context from GitHub Actions environment variables:
+ *   GITHUB_TOKEN        — required for posting comments
+ *   GITHUB_REPOSITORY   — e.g. "owner/repo"
+ *   GITHUB_EVENT_PATH   — path to the event JSON (contains PR number)
+ *   GITHUB_SHA          — current commit SHA
+ *   GITHUB_BASE_REF     — base branch name (e.g. "main")
+ *
+ * Usage:
+ *   infernoflow pr-comment                  # auto-detect from CI env
+ *   infernoflow pr-comment --pr 42          # explicit PR number
+ *   infernoflow pr-comment --repo owner/r   # explicit repo
+ *   infernoflow pr-comment --token ghp_...  # explicit token
+ *   infernoflow pr-comment --dry-run        # print comment without posting
+ *   infernoflow pr-comment --json           # machine-readable result
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import * as https from "node:https";
+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 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) {
+  for (const name of ["capabilities.json", "contract.json"]) {
+    const p = path.join(infernoDir, name);
+    if (fs.existsSync(p)) return parseCaps(fs.readFileSync(p, "utf8"));
+  }
+  return null;
+}
+
+function loadCapsAtRef(ref, cwd) {
+  for (const name of ["capabilities.json", "contract.json"]) {
+    const content = fileAtRef(ref, `inferno/${name}`, cwd);
+    if (content) return parseCaps(content);
+  }
+  return null;
+}
+
+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 };
+}
+
+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";
+}
+
+// ── comment builder ───────────────────────────────────────────────────────────
+
+function buildComment(diff, bump, ref, currentVersion, nextVersion) {
+  const lines = [];
+
+  // Header
+  const bumpEmoji = bump === "major" ? "🔴" : bump === "minor" ? "🟡" : bump === "patch" ? "🟢" : "✅";
+  const bumpLabel = bump === "none" ? "No capability changes" : `${bump.toUpperCase()} bump recommended`;
+  lines.push(`## 🔥 infernoflow — Capability Analysis`);
+  lines.push(``);
+  lines.push(`${bumpEmoji} **${bumpLabel}**${bump !== "none" ? ` · \`${currentVersion}\` → \`${nextVersion}\`` : ""}`);
+  lines.push(``);
+
+  // Summary table
+  const hasChanges = diff.added.length || diff.removed.length || diff.changed.length;
+  if (!hasChanges) {
+    lines.push(`> No capability changes detected since \`${ref}\`. Contract is in sync.`);
+  } else {
+    lines.push(`| Change | Count |`);
+    lines.push(`|--------|-------|`);
+    if (diff.added.length)   lines.push(`| ➕ Added    | ${diff.added.length} |`);
+    if (diff.removed.length) lines.push(`| ❌ Removed  | ${diff.removed.length} |`);
+    if (diff.changed.length) lines.push(`| ✏️ Modified | ${diff.changed.length} |`);
+    lines.push(``);
+
+    // Detail sections
+    if (diff.added.length) {
+      lines.push(`<details><summary>➕ Added capabilities (${diff.added.length})</summary>`);
+      lines.push(``);
+      for (const c of diff.added) lines.push(`- \`${c.id}\` — ${c.title}`);
+      lines.push(``);
+      lines.push(`</details>`);
+      lines.push(``);
+    }
+
+    if (diff.removed.length) {
+      lines.push(`<details><summary>❌ Removed capabilities (${diff.removed.length}) — breaking change</summary>`);
+      lines.push(``);
+      for (const c of diff.removed) lines.push(`- \`${c.id}\` — ${c.title}`);
+      lines.push(``);
+      lines.push(`</details>`);
+      lines.push(``);
+    }
+
+    if (diff.changed.length) {
+      lines.push(`<details><summary>✏️ Modified capabilities (${diff.changed.length})</summary>`);
+      lines.push(``);
+      for (const item of diff.changed) {
+        lines.push(`- \`${item.id}\``);
+        for (const ch of item.changes) lines.push(`  - ${ch.field}: \`${ch.from}\` → \`${ch.to}\``);
+      }
+      lines.push(``);
+      lines.push(`</details>`);
+      lines.push(``);
+    }
+  }
+
+  // Bump recommendation
+  if (bump === "major") {
+    lines.push(`> ⚠️ **Breaking change detected.** Capabilities were removed. Consider a major version bump.`);
+    lines.push(`> Run \`infernoflow version --apply\` to update \`package.json\`.`);
+  } else if (bump === "minor") {
+    lines.push(`> ℹ️ New capabilities added. A minor version bump is recommended.`);
+    lines.push(`> Run \`infernoflow version --apply\` to update \`package.json\`.`);
+  }
+
+  lines.push(``);
+  lines.push(`---`);
+  lines.push(`<sub>Generated by [infernoflow](https://github.com/ronmiz/infernoflow) · compared against \`${ref}\`</sub>`);
+
+  return lines.join("\n");
+}
+
+// ── GitHub API ────────────────────────────────────────────────────────────────
+
+function githubRequest(method, pathname, body, token) {
+  return new Promise((resolve, reject) => {
+    const data = body ? JSON.stringify(body) : null;
+    const req = https.request({
+      hostname: "api.github.com",
+      path: pathname,
+      method,
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Accept": "application/vnd.github+json",
+        "Content-Type": "application/json",
+        "User-Agent": "infernoflow-cli",
+        ...(data ? { "Content-Length": Buffer.byteLength(data) } : {}),
+      },
+    }, (res) => {
+      let raw = "";
+      res.on("data", chunk => raw += chunk);
+      res.on("end", () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(raw) }); }
+        catch { resolve({ status: res.statusCode, body: raw }); }
+      });
+    });
+    req.on("error", reject);
+    if (data) req.write(data);
+    req.end();
+  });
+}
+
+async function findExistingComment(repo, prNumber, token) {
+  // Look for a previous infernoflow comment to update instead of creating a new one
+  const res = await githubRequest("GET", `/repos/${repo}/issues/${prNumber}/comments?per_page=100`, null, token);
+  if (res.status !== 200 || !Array.isArray(res.body)) return null;
+  return res.body.find(c => c.body && c.body.includes("🔥 infernoflow — Capability Analysis")) || null;
+}
+
+async function postComment(repo, prNumber, body, token) {
+  // Update existing comment if found (avoids spam on multiple pushes)
+  const existing = await findExistingComment(repo, prNumber, token);
+  if (existing) {
+    return githubRequest("PATCH", `/repos/${repo}/issues/comments/${existing.id}`, { body }, token);
+  }
+  return githubRequest("POST", `/repos/${repo}/issues/${prNumber}/comments`, { body }, token);
+}
+
+// ── env helpers ───────────────────────────────────────────────────────────────
+
+function readGithubEventPr() {
+  const eventPath = process.env.GITHUB_EVENT_PATH;
+  if (!eventPath || !fs.existsSync(eventPath)) return null;
+  try {
+    const event = JSON.parse(fs.readFileSync(eventPath, "utf8"));
+    return event.pull_request?.number || event.number || null;
+  } catch { return null; }
+}
+
+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 p = path.join(cwd, "package.json");
+  if (!fs.existsSync(p)) return "0.0.0";
+  try { return JSON.parse(fs.readFileSync(p, "utf8")).version || "0.0.0"; } catch { return "0.0.0"; }
+}
+
+// ── main ──────────────────────────────────────────────────────────────────────
+
+export async function prCommentCommand(rawArgs) {
+  const args   = rawArgs.slice(1);
+  const dryRun = args.includes("--dry-run");
+  const asJson = args.includes("--json");
+
+  const prIdx    = args.indexOf("--pr");
+  const repoIdx  = args.indexOf("--repo");
+  const tokenIdx = args.indexOf("--token");
+  const refIdx   = args.indexOf("--ref");
+
+  const cwd = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+
+  if (!asJson) header("infernoflow pr-comment");
+
+  // ── Resolve inputs ────────────────────────────────────────────────────────
+  const token    = tokenIdx !== -1 ? args[tokenIdx + 1] : process.env.GITHUB_TOKEN;
+  const repo     = repoIdx  !== -1 ? args[repoIdx  + 1] : process.env.GITHUB_REPOSITORY;
+  const prNumber = prIdx    !== -1 ? parseInt(args[prIdx + 1], 10)
+                                   : readGithubEventPr();
+
+  let ref = refIdx !== -1 ? args[refIdx + 1] : null;
+  if (!ref) ref = process.env.GITHUB_BASE_REF ? `origin/${process.env.GITHUB_BASE_REF}` : null;
+  if (!ref) ref = lastTag(cwd);
+  if (!ref) {
+    const parentExists = capture("git rev-parse HEAD~1", cwd);
+    ref = parentExists ? "HEAD~1" : null;
+  }
+
+  // ── Validate ──────────────────────────────────────────────────────────────
+  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);
+  }
+
+  if (!dryRun && !token) {
+    const msg = "No GitHub token found. Set GITHUB_TOKEN env var or use --token";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  if (!dryRun && !repo) {
+    const msg = "No repository found. Set GITHUB_REPOSITORY env var or use --repo owner/repo";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  if (!dryRun && !prNumber) {
+    const msg = "No PR number found. Use --pr <number> or run in GitHub Actions on pull_request event";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  // ── Load capabilities and compute diff ───────────────────────────────────
+  const current  = loadCapsFromDisk(infernoDir);
+  const previous = ref ? loadCapsAtRef(ref, cwd) : null;
+
+  if (!current) {
+    const msg = "No capabilities.json or contract.json found in inferno/";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  const diff = diffCaps(previous || [], current);
+  const bump = classifyBump(diff);
+  const currentVersion = readPackageVersion(cwd);
+  const nextVersion    = bump !== "none" ? applyBump(currentVersion, bump) : currentVersion;
+
+  // ── Build comment ─────────────────────────────────────────────────────────
+  const commentBody = buildComment(diff, bump, ref || "HEAD", currentVersion, nextVersion);
+
+  // ── Dry run ───────────────────────────────────────────────────────────────
+  if (dryRun) {
+    if (asJson) {
+      console.log(JSON.stringify({ ok: true, dryRun: true, bump, currentVersion, nextVersion, comment: commentBody }));
+    } else {
+      console.log();
+      info("DRY RUN — comment that would be posted:");
+      console.log();
+      console.log(commentBody);
+      console.log();
+    }
+    return;
+  }
+
+  // ── Post comment ──────────────────────────────────────────────────────────
+  if (!asJson) info(`Posting to ${bold(repo)} PR #${prNumber}...`);
+
+  try {
+    const result = await postComment(repo, prNumber, commentBody, token);
+
+    if (result.status === 200 || result.status === 201) {
+      const commentUrl = result.body?.html_url || "";
+      if (asJson) {
+        console.log(JSON.stringify({ ok: true, bump, currentVersion, nextVersion, prNumber, repo, commentUrl }));
+      } else {
+        ok(`Comment posted → ${cyan(commentUrl || `PR #${prNumber}`)}`);
+        if (bump !== "none") {
+          console.log();
+          info(`Recommended bump: ${bold(bump.toUpperCase())}  ${currentVersion} → ${nextVersion}`);
+        }
+        console.log();
+      }
+    } else {
+      const msg = `GitHub API error ${result.status}: ${JSON.stringify(result.body)}`;
+      if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); }
+      else { warn(msg); }
+      process.exit(1);
+    }
+  } catch (err) {
+    const msg = `Failed to post comment: ${err.message}`;
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); }
+    else { warn(msg); }
+    process.exit(1);
+  }
+}

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/templates/ci/github-pr-comment.yml

@@ -0,0 +1,50 @@
+# infernoflow PR capability analysis
+#
+# Posts a comment on every PR showing:
+#   - which capabilities were added, removed, or changed
+#   - recommended semver bump (major / minor / patch)
+#   - direct link to the drift details
+#
+# Setup:
+#   1. Copy this file to .github/workflows/infernoflow-pr.yml
+#   2. Ensure GITHUB_TOKEN has write access to pull requests
+#      (default GitHub Actions token works if repo settings allow it)
+#
+# That's it — infernoflow does the rest automatically.
+
+name: infernoflow PR Analysis
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  pull-requests: write   # required to post comments
+  contents: read
+
+jobs:
+  capability-analysis:
+    name: Capability drift check
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout PR branch
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0   # full history needed for git diff
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install infernoflow
+        run: npm install -g infernoflow@latest
+
+      - name: Post capability analysis comment
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: infernoflow pr-comment
+        # infernoflow auto-reads GITHUB_TOKEN, GITHUB_REPOSITORY,
+        # GITHUB_EVENT_PATH, and GITHUB_BASE_REF from the environment.
+        # No extra config needed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infernoflow",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "The forge for liquid code - keep capabilities, contracts, and docs in sync.",
   "type": "module",
   "bin": {