infernoflow 0.17.0 → 0.19.0

package/dist/lib/commands/monorepo.mjs

@@ -0,0 +1,427 @@
+/**
+ * infernoflow monorepo
+ *
+ * Monorepo-aware capability tracking. Detects packages in a monorepo
+ * (nx, turborepo, pnpm workspaces, yarn workspaces, Lerna) and manages
+ * per-package contracts.
+ *
+ * Sub-commands:
+ *   monorepo init              Detect packages, scaffold inferno/ per package
+ *   monorepo list              List all detected packages + contract status
+ *   monorepo status            Show health across all packages at once
+ *   monorepo diff [--package]  Diff capabilities for one or all packages
+ *   monorepo sync              Sync all package contracts to root summary
+ *
+ * Usage:
+ *   infernoflow monorepo init
+ *   infernoflow monorepo list
+ *   infernoflow monorepo status
+ *   infernoflow monorepo diff --package auth
+ *   infernoflow monorepo sync
+ *   infernoflow monorepo status --json
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { header, ok, warn, info, done, bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+
+// ── Package detection ─────────────────────────────────────────────────────────
+
+function detectWorkspaceType(cwd) {
+  const has = (f) => fs.existsSync(path.join(cwd, f));
+
+  if (has("nx.json"))          return "nx";
+  if (has("turbo.json"))       return "turborepo";
+  if (has("lerna.json"))       return "lerna";
+  if (has("pnpm-workspace.yaml")) return "pnpm";
+
+  const pkg = (() => {
+    try { return JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8")); }
+    catch { return {}; }
+  })();
+
+  if (pkg.workspaces) return Array.isArray(pkg.workspaces) ? "yarn" : "npm-workspaces";
+  return null;
+}
+
+function readWorkspaceGlobs(cwd, wsType) {
+  try {
+    if (wsType === "pnpm") {
+      const raw = fs.readFileSync(path.join(cwd, "pnpm-workspace.yaml"), "utf8");
+      const matches = [...raw.matchAll(/^\s*-\s*['"]?([^'"]+)['"]?/gm)];
+      return matches.map(m => m[1].trim());
+    }
+    if (wsType === "lerna") {
+      const cfg = JSON.parse(fs.readFileSync(path.join(cwd, "lerna.json"), "utf8"));
+      return cfg.packages || ["packages/*"];
+    }
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8"));
+    const ws  = pkg.workspaces;
+    if (Array.isArray(ws)) return ws;
+    if (ws?.packages) return ws.packages;
+  } catch {}
+  return ["packages/*", "apps/*", "libs/*"];
+}
+
+function globToPackages(cwd, globs) {
+  const packages = [];
+  for (const pattern of globs) {
+    // Simple glob: handle "packages/*" and "apps/*" patterns
+    const parts  = pattern.split("/");
+    const parent = parts.slice(0, -1).join("/");
+    const leaf   = parts[parts.length - 1];
+    const dir    = path.join(cwd, parent);
+
+    if (!fs.existsSync(dir)) continue;
+    if (leaf === "*") {
+      try {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+          if (entry.isDirectory()) {
+            const pkgPath = path.join(dir, entry.name, "package.json");
+            if (fs.existsSync(pkgPath)) {
+              const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+              packages.push({
+                name:    pkg.name || entry.name,
+                dir:     path.join(dir, entry.name),
+                version: pkg.version || "0.0.0",
+              });
+            }
+          }
+        }
+      } catch {}
+    } else {
+      const fullDir = path.join(cwd, pattern);
+      const pkgPath = path.join(fullDir, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        packages.push({ name: pkg.name || leaf, dir: fullDir, version: pkg.version || "0.0.0" });
+      }
+    }
+  }
+  return packages;
+}
+
+function detectPackages(cwd) {
+  const wsType = detectWorkspaceType(cwd);
+  if (!wsType) return { type: null, packages: [] };
+  const globs    = readWorkspaceGlobs(cwd, wsType);
+  const packages = globToPackages(cwd, globs);
+  return { type: wsType, packages };
+}
+
+// ── Contract helpers ──────────────────────────────────────────────────────────
+
+function readPackageContract(pkgDir) {
+  for (const f of ["contract.json", "capabilities.json"]) {
+    const p = path.join(pkgDir, "inferno", f);
+    if (fs.existsSync(p)) { try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch {} }
+  }
+  return null;
+}
+
+function hasInferno(pkgDir) {
+  return fs.existsSync(path.join(pkgDir, "inferno"));
+}
+
+function contractStatus(pkgDir) {
+  if (!hasInferno(pkgDir)) return "not-init";
+  const contract = readPackageContract(pkgDir);
+  if (!contract) return "no-contract";
+  return "ok";
+}
+
+// ── CLI runner ────────────────────────────────────────────────────────────────
+
+function runInferno(args, cwd) {
+  const binPath = path.join(path.dirname(path.dirname(new URL(import.meta.url).pathname)), "..", "bin", "infernoflow.mjs");
+  const result  = spawnSync(process.execPath, [binPath, ...args], {
+    cwd,
+    encoding: "utf8",
+    timeout:  60_000,
+    env: { ...process.env, NO_COLOR: "1" },
+  });
+  return { stdout: result.stdout || "", stderr: result.stderr || "", status: result.status };
+}
+
+// ── Sub-commands ──────────────────────────────────────────────────────────────
+
+async function subcmdInit(args, cwd) {
+  const jsonMode = args.includes("--json");
+  const force    = args.includes("--force") || args.includes("-f");
+  const autoYes  = args.includes("--yes") || args.includes("-y");
+
+  const { type, packages } = detectPackages(cwd);
+
+  if (!type) {
+    const msg = "No monorepo configuration detected. Supported: nx, turborepo, pnpm workspaces, yarn workspaces, lerna.";
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: msg })); } else { warn(msg); }
+    process.exit(1);
+  }
+
+  if (!jsonMode) {
+    header(`Monorepo init (${type})`);
+    console.log(`  Detected ${bold(String(packages.length))} packages:\n`);
+    packages.forEach(p => {
+      const status = contractStatus(p.dir);
+      const icon   = status === "ok" ? green("✔") : yellow("·");
+      console.log(`  ${icon}  ${bold(p.name)}  ${gray(path.relative(cwd, p.dir))}`);
+    });
+    console.log();
+  }
+
+  if (packages.length === 0) {
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: "No packages found" })); }
+    else { warn("No packages found matching workspace globs."); }
+    process.exit(1);
+  }
+
+  const results = [];
+  for (const pkg of packages) {
+    const status = contractStatus(pkg.dir);
+    if (status === "ok" && !force) {
+      if (!jsonMode) info(`${pkg.name}: already initialised (use --force to reinit)`);
+      results.push({ name: pkg.name, status: "skipped" });
+      continue;
+    }
+
+    if (!jsonMode) process.stdout.write(`  Initialising ${cyan(pkg.name)}… `);
+
+    const initArgs = ["init", "--adopt", "--yes"];
+    if (force) initArgs.push("--force");
+    const r = runInferno(initArgs, pkg.dir);
+
+    if (r.status === 0) {
+      if (!jsonMode) console.log(green("done"));
+      results.push({ name: pkg.name, status: "ok" });
+    } else {
+      if (!jsonMode) console.log(red("failed"));
+      results.push({ name: pkg.name, status: "error", error: r.stderr.trim().slice(0, 120) });
+    }
+  }
+
+  // Write root summary
+  const summary = {
+    monorepoType: type,
+    packages: results,
+    updatedAt: new Date().toISOString(),
+  };
+  fs.writeFileSync(path.join(cwd, "inferno-monorepo.json"), JSON.stringify(summary, null, 2) + "\n");
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, type, packages: results }));
+  } else {
+    console.log();
+    const succeeded = results.filter(r => r.status === "ok").length;
+    done(`Initialised ${bold(String(succeeded))} of ${results.length} packages`);
+    console.log(`  ${gray("Root summary:")} ${cyan("inferno-monorepo.json")}`);
+    console.log();
+  }
+}
+
+async function subcmdList(args, cwd) {
+  const jsonMode = args.includes("--json");
+  const { type, packages } = detectPackages(cwd);
+
+  if (!type && packages.length === 0) {
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: "No monorepo detected" })); }
+    else { warn("No monorepo detected. Run: infernoflow monorepo init"); }
+    return;
+  }
+
+  const rows = packages.map(p => ({
+    name:    p.name,
+    dir:     path.relative(cwd, p.dir),
+    version: p.version,
+    status:  contractStatus(p.dir),
+    caps:    (() => {
+      const c = readPackageContract(p.dir);
+      return c ? (c.capabilities || []).length : 0;
+    })(),
+  }));
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, type, packages: rows }));
+    return;
+  }
+
+  console.log();
+  console.log(`  ${bold("Monorepo packages")}  ${gray("(" + type + ")")}`);
+  console.log();
+  const w = Math.max(...rows.map(r => r.name.length), 8) + 2;
+  rows.forEach(r => {
+    const icon = r.status === "ok" ? green("✔") : r.status === "not-init" ? yellow("○") : red("✗");
+    const caps = r.status === "ok" ? gray(`${r.caps} caps`) : gray(r.status);
+    console.log(`  ${icon}  ${r.name.padEnd(w)}${r.version.padEnd(12)}${caps}`);
+  });
+  console.log();
+}
+
+async function subcmdStatus(args, cwd) {
+  const jsonMode = args.includes("--json");
+  const { type, packages } = detectPackages(cwd);
+
+  if (!packages.length) {
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: "No packages found" })); }
+    else { warn("No packages found."); }
+    return;
+  }
+
+  if (!jsonMode) header(`Monorepo status (${packages.length} packages)`);
+
+  const results = [];
+  for (const pkg of packages) {
+    if (!hasInferno(pkg.dir)) {
+      results.push({ name: pkg.name, status: "not-init", caps: 0 });
+      if (!jsonMode) console.log(`  ${yellow("○")}  ${bold(pkg.name)}  ${gray("not initialised")}`);
+      continue;
+    }
+    const r = runInferno(["status", "--json"], pkg.dir);
+    try {
+      const data = JSON.parse(r.stdout.trim());
+      const caps = (data.capabilityDetails || []).length;
+      const ok_  = data.ok !== false;
+      results.push({ name: pkg.name, status: ok_ ? "ok" : "error", caps, version: data.policyVersion });
+      if (!jsonMode) {
+        const icon = ok_ ? green("✔") : red("✗");
+        console.log(`  ${icon}  ${bold(pkg.name.padEnd(28))}${gray("v" + (data.policyVersion || "?"))}  ${caps} caps`);
+      }
+    } catch {
+      results.push({ name: pkg.name, status: "error", caps: 0, error: "status failed" });
+      if (!jsonMode) console.log(`  ${red("✗")}  ${bold(pkg.name)}  ${gray("status check failed")}`);
+    }
+  }
+
+  if (jsonMode) {
+    const allOk = results.every(r => r.status === "ok");
+    console.log(JSON.stringify({ ok: allOk, type, packages: results }));
+  } else {
+    console.log();
+    const ok_ = results.filter(r => r.status === "ok").length;
+    console.log(`  ${ok_ === results.length ? green("✔") : yellow("⚠")}  ${ok_}/${results.length} packages healthy`);
+    console.log();
+  }
+}
+
+async function subcmdDiff(args, cwd) {
+  const jsonMode   = args.includes("--json");
+  const pkgFilter  = args.includes("--package") ? args[args.indexOf("--package") + 1] : null;
+  const { packages } = detectPackages(cwd);
+
+  const targets = pkgFilter
+    ? packages.filter(p => p.name === pkgFilter || p.name.endsWith("/" + pkgFilter))
+    : packages.filter(p => hasInferno(p.dir));
+
+  if (!targets.length) {
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: pkgFilter ? `Package not found: ${pkgFilter}` : "No initialised packages found" })); }
+    else { warn(pkgFilter ? `Package not found: ${pkgFilter}` : "No initialised packages found."); }
+    return;
+  }
+
+  if (!jsonMode && !pkgFilter) header(`Monorepo diff (${targets.length} packages)`);
+
+  const allResults = [];
+  for (const pkg of targets) {
+    const r = runInferno(["diff", "--json"], pkg.dir);
+    try {
+      const data    = JSON.parse(r.stdout.trim());
+      const added   = (data.added   || []).length;
+      const removed = (data.removed || []).length;
+      const changed = (data.changed || []).length;
+      allResults.push({ name: pkg.name, added, removed, changed, data });
+      if (!jsonMode) {
+        if (added || removed || changed) {
+          console.log(`  ${bold(pkg.name)}`);
+          if (added)   console.log(`    ${green("+")} ${added} added`);
+          if (removed) console.log(`    ${red("-")} ${removed} removed`);
+          if (changed) console.log(`    ${yellow("~")} ${changed} changed`);
+        } else {
+          console.log(`  ${green("✔")}  ${bold(pkg.name)}  ${gray("no changes")}`);
+        }
+      }
+    } catch {
+      allResults.push({ name: pkg.name, error: "diff failed" });
+      if (!jsonMode) console.log(`  ${red("✗")}  ${bold(pkg.name)}  ${gray("diff failed")}`);
+    }
+  }
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, packages: allResults }));
+  } else {
+    console.log();
+  }
+}
+
+async function subcmdSync(args, cwd) {
+  const jsonMode = args.includes("--json");
+  const { type, packages } = detectPackages(cwd);
+
+  if (!jsonMode) header("Syncing monorepo contracts");
+
+  // Build a root aggregate contract
+  const aggregate = {
+    monorepoType: type,
+    updatedAt:    new Date().toISOString(),
+    packages:     [],
+  };
+
+  for (const pkg of packages) {
+    const contract = readPackageContract(pkg.dir);
+    if (!contract) continue;
+    aggregate.packages.push({
+      name:         pkg.name,
+      version:      contract.policyVersion || pkg.version,
+      capabilities: (contract.capabilities || []).map(c => typeof c === "string" ? c : c.id),
+      capsCount:    (contract.capabilities || []).length,
+    });
+    if (!jsonMode) console.log(`  ${green("✔")}  ${bold(pkg.name)}  ${gray((contract.capabilities || []).length + " caps")}`);
+  }
+
+  const outPath = path.join(cwd, "inferno-monorepo.json");
+  fs.writeFileSync(outPath, JSON.stringify(aggregate, null, 2) + "\n");
+
+  const totalCaps = aggregate.packages.reduce((sum, p) => sum + p.capsCount, 0);
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, packages: aggregate.packages.length, totalCaps }));
+  } else {
+    console.log();
+    done(`Synced ${bold(String(aggregate.packages.length))} packages (${totalCaps} total capabilities)`);
+    console.log(`  ${cyan(outPath)}`);
+    console.log();
+  }
+}
+
+// ── Entry ─────────────────────────────────────────────────────────────────────
+
+export async function monorepoCommand(rawArgs) {
+  const args   = rawArgs.slice(1);
+  const subcmd = args[0];
+  const cwd    = process.cwd();
+  const rest   = args.slice(1);
+
+  switch (subcmd) {
+    case "init":    return subcmdInit(rest, cwd);
+    case "list":    return subcmdList(rest, cwd);
+    case "status":  return subcmdStatus(rest, cwd);
+    case "diff":    return subcmdDiff(rest, cwd);
+    case "sync":    return subcmdSync(rest, cwd);
+    default: {
+      const jsonMode = args.includes("--json");
+      const msg = `Unknown monorepo sub-command: ${subcmd || "(none)"}`;
+      if (jsonMode) { console.log(JSON.stringify({ ok: false, error: msg })); return; }
+      console.log();
+      console.log(`  ${bold("infernoflow monorepo")} — per-package capability tracking`);
+      console.log();
+      console.log(`  ${cyan("infernoflow monorepo init")}      Scaffold inferno/ in each package`);
+      console.log(`  ${cyan("infernoflow monorepo list")}      List packages and contract status`);
+      console.log(`  ${cyan("infernoflow monorepo status")}    Health check across all packages`);
+      console.log(`  ${cyan("infernoflow monorepo diff")}      Capability diff for all packages`);
+      console.log(`  ${cyan("infernoflow monorepo diff --package auth")}  Diff a specific package`);
+      console.log(`  ${cyan("infernoflow monorepo sync")}      Aggregate all contracts to inferno-monorepo.json`);
+      console.log();
+      console.log(`  ${gray("Supported: nx, turborepo, pnpm workspaces, yarn workspaces, lerna")}`);
+      console.log();
+    }
+  }
+}

package/dist/lib/commands/notify.mjs

@@ -0,0 +1,258 @@
+/**
+ * infernoflow notify
+ *
+ * Post capability drift summaries to Slack or Discord.
+ * Runs automatically after significant capability changes (via git hook or CI).
+ * Can also be triggered manually.
+ *
+ * Usage:
+ *   infernoflow notify                    Auto-detect channel from config
+ *   infernoflow notify --slack <url>      Post to Slack webhook URL
+ *   infernoflow notify --discord <url>    Post to Discord webhook URL
+ *   infernoflow notify --dry-run          Print message without sending
+ *   infernoflow notify --json             Machine-readable: { ok, platform, message }
+ *   infernoflow notify --on-change        Only notify if capabilities actually changed
+ *
+ * Config (inferno/notify.json):
+ *   { "slack": "https://hooks.slack.com/...", "discord": "https://discord.com/api/webhooks/..." }
+ *
+ * Or set env vars:
+ *   INFERNOFLOW_SLACK_WEBHOOK
+ *   INFERNOFLOW_DISCORD_WEBHOOK
+ */
+
+import * as fs    from "node:fs";
+import * as path  from "node:path";
+import * as https from "node:https";
+import * as http  from "node:http";
+import { spawnSync } from "node:child_process";
+import { done, warn, info, bold, cyan, gray, green, red, yellow } from "../ui/output.mjs";
+
+// ── Config ────────────────────────────────────────────────────────────────────
+
+function loadNotifyConfig(infernoDir, args) {
+  const configPath = path.join(infernoDir, "notify.json");
+  const fileConfig = fs.existsSync(configPath)
+    ? (() => { try { return JSON.parse(fs.readFileSync(configPath, "utf8")); } catch { return {}; } })()
+    : {};
+
+  const slackIdx   = args.indexOf("--slack");
+  const discordIdx = args.indexOf("--discord");
+
+  return {
+    slack:   slackIdx   !== -1 ? args[slackIdx + 1]   : process.env.INFERNOFLOW_SLACK_WEBHOOK   || fileConfig.slack,
+    discord: discordIdx !== -1 ? args[discordIdx + 1] : process.env.INFERNOFLOW_DISCORD_WEBHOOK || fileConfig.discord,
+  };
+}
+
+// ── Data loading ──────────────────────────────────────────────────────────────
+
+function runJson(cmd, cwd) {
+  try {
+    const result = spawnSync(process.execPath, [
+      path.join(path.dirname(path.dirname(new URL(import.meta.url).pathname)), "..", "bin", "infernoflow.mjs"),
+      ...cmd.split(" ").slice(1),
+    ], { cwd, encoding: "utf8", timeout: 20_000 });
+    const out = result.stdout?.trim();
+    if (out) return JSON.parse(out);
+  } catch {}
+  return null;
+}
+
+function buildSummary(checkResult, diffResult, contract) {
+  const status  = checkResult?.status || "unknown";
+  const caps    = (contract?.capabilities || []).length;
+  const version = contract?.policyVersion || "?";
+  const project = contract?.policyId || "project";
+  const added   = diffResult?.added   || [];
+  const removed = diffResult?.removed || [];
+  const changed = diffResult?.changed || [];
+
+  return { status, caps, version, project, added, removed, changed };
+}
+
+// ── Slack message builder ─────────────────────────────────────────────────────
+
+function buildSlackMessage(summary) {
+  const { status, caps, version, project, added, removed, changed } = summary;
+  const statusEmoji = status === "ok" ? "✅" : status === "warning" ? "⚠️" : "❌";
+  const hasChanges  = added.length || removed.length || changed.length;
+
+  const blocks = [
+    {
+      type: "header",
+      text: { type: "plain_text", text: `🔥 infernoflow — ${project} v${version}`, emoji: true },
+    },
+    {
+      type: "section",
+      fields: [
+        { type: "mrkdwn", text: `*Status*\n${statusEmoji} ${status.toUpperCase()}` },
+        { type: "mrkdwn", text: `*Capabilities*\n${caps} tracked` },
+      ],
+    },
+  ];
+
+  if (hasChanges) {
+    const lines = [];
+    if (added.length)   lines.push(`✅ *${added.length}* added: ${added.slice(0, 3).join(", ")}${added.length > 3 ? ` +${added.length - 3} more` : ""}`);
+    if (removed.length) lines.push(`❌ *${removed.length}* removed: ${removed.slice(0, 3).join(", ")}${removed.length > 3 ? ` +${removed.length - 3} more` : ""}`);
+    if (changed.length) lines.push(`📝 *${changed.length}* changed`);
+    blocks.push({ type: "section", text: { type: "mrkdwn", text: lines.join("\n") } });
+  }
+
+  blocks.push({
+    type: "context",
+    elements: [{ type: "mrkdwn", text: `<https://github.com/ronmiz/infernoflow|infernoflow> · ${new Date().toLocaleString()}` }],
+  });
+
+  return { blocks };
+}
+
+// ── Discord message builder ───────────────────────────────────────────────────
+
+function buildDiscordMessage(summary) {
+  const { status, caps, version, project, added, removed, changed } = summary;
+  const color  = status === "ok" ? 0x4ade80 : status === "warning" ? 0xf97316 : 0xf87171;
+  const hasChanges = added.length || removed.length || changed.length;
+
+  const fields = [
+    { name: "Status",       value: status.toUpperCase(), inline: true },
+    { name: "Capabilities", value: String(caps),         inline: true },
+    { name: "Version",      value: `v${version}`,        inline: true },
+  ];
+
+  if (added.length)   fields.push({ name: "✅ Added",   value: added.slice(0,5).join(", ") + (added.length > 5 ? ` +${added.length-5}` : ""),   inline: false });
+  if (removed.length) fields.push({ name: "❌ Removed", value: removed.slice(0,5).join(", ") + (removed.length > 5 ? ` +${removed.length-5}` : ""), inline: false });
+
+  return {
+    embeds: [{
+      title:       `🔥 infernoflow — ${project}`,
+      description: hasChanges ? "Capability changes detected" : "Contract healthy",
+      color,
+      fields,
+      footer:      { text: "infernoflow · " + new Date().toLocaleString() },
+      url:         "https://github.com/ronmiz/infernoflow",
+    }],
+  };
+}
+
+// ── HTTP post ─────────────────────────────────────────────────────────────────
+
+function postWebhook(url, payload) {
+  return new Promise((resolve, reject) => {
+    const body    = JSON.stringify(payload);
+    const parsed  = new URL(url);
+    const isHttps = parsed.protocol === "https:";
+    const lib     = isHttps ? https : http;
+
+    const req = lib.request({
+      hostname: parsed.hostname,
+      port:     parsed.port || (isHttps ? 443 : 80),
+      path:     parsed.pathname + (parsed.search || ""),
+      method:   "POST",
+      headers:  { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body), "User-Agent": "infernoflow-cli" },
+    }, (res) => {
+      let data = "";
+      res.on("data", d => (data += d));
+      res.on("end", () => resolve({ status: res.statusCode, body: data }));
+    });
+
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+export async function notifyCommand(rawArgs) {
+  const args       = rawArgs.slice(1);
+  const jsonMode   = args.includes("--json");
+  const dryRun     = args.includes("--dry-run");
+  const onlyChange = args.includes("--on-change");
+  const cwd        = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+
+  if (!fs.existsSync(infernoDir)) {
+    const msg = "inferno/ not found. Run: infernoflow init";
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: msg })); } else { warn(msg); }
+    process.exit(1);
+  }
+
+  const config = loadNotifyConfig(infernoDir, args);
+
+  if (!config.slack && !config.discord) {
+    const msg = "No webhook configured. Use --slack <url>, --discord <url>, or set INFERNOFLOW_SLACK_WEBHOOK / INFERNOFLOW_DISCORD_WEBHOOK.";
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: msg })); } else { warn(msg); }
+    if (!jsonMode) {
+      console.log();
+      console.log(`  ${gray("To configure permanently, create inferno/notify.json:")}`);
+      console.log(`  ${cyan('{ "slack": "https://hooks.slack.com/...", "discord": "https://discord.com/api/webhooks/..." }')}`);
+      console.log();
+    }
+    process.exit(1);
+  }
+
+  // Load data
+  const contract    = (() => {
+    for (const f of ["contract.json", "capabilities.json"]) {
+      const p = path.join(infernoDir, f);
+      if (fs.existsSync(p)) { try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch {} }
+    }
+    return {};
+  })();
+  const checkResult = runJson("check --json", cwd);
+  const diffResult  = runJson("diff --json", cwd);
+  const summary     = buildSummary(checkResult, diffResult, contract);
+
+  // --on-change: skip if nothing changed
+  if (onlyChange && !summary.added.length && !summary.removed.length && !summary.changed.length) {
+    if (jsonMode) { console.log(JSON.stringify({ ok: true, skipped: true, reason: "no capability changes" })); }
+    else { info("No capability changes — skipping notification."); }
+    return;
+  }
+
+  const results = [];
+
+  // Slack
+  if (config.slack) {
+    const payload = buildSlackMessage(summary);
+    if (dryRun) {
+      if (!jsonMode) { info("Slack payload (dry run):"); console.log(JSON.stringify(payload, null, 2)); }
+      results.push({ platform: "slack", ok: true, dryRun: true });
+    } else {
+      try {
+        const resp = await postWebhook(config.slack, payload);
+        const ok   = resp.status >= 200 && resp.status < 300;
+        if (!jsonMode) { ok ? done("Slack notification sent") : warn(`Slack returned ${resp.status}`); }
+        results.push({ platform: "slack", ok, status: resp.status });
+      } catch (err) {
+        if (!jsonMode) warn(`Slack failed: ${err.message}`);
+        results.push({ platform: "slack", ok: false, error: err.message });
+      }
+    }
+  }
+
+  // Discord
+  if (config.discord) {
+    const payload = buildDiscordMessage(summary);
+    if (dryRun) {
+      if (!jsonMode) { info("Discord payload (dry run):"); console.log(JSON.stringify(payload, null, 2)); }
+      results.push({ platform: "discord", ok: true, dryRun: true });
+    } else {
+      try {
+        const resp = await postWebhook(config.discord, payload);
+        const ok   = resp.status >= 200 && resp.status < 300;
+        if (!jsonMode) { ok ? done("Discord notification sent") : warn(`Discord returned ${resp.status}`); }
+        results.push({ platform: "discord", ok, status: resp.status });
+      } catch (err) {
+        if (!jsonMode) warn(`Discord failed: ${err.message}`);
+        results.push({ platform: "discord", ok: false, error: err.message });
+      }
+    }
+  }
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: results.every(r => r.ok), results, summary }));
+  }
+}