0xray 4.0.0 → 4.0.2

package/scripts/foundry/ci-monitor.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+/**
+ * Mill CI monitor. Reports GitHub Actions for the milled cwd.
+ * Not PPE. Not an auto-push bot.
+ *
+ *   npx @0xray/foundry ci [--commit SHA] [--report]
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveMillRoot } from "./mill-root.mjs";
+
+const args = process.argv.slice(2);
+const commitIdx = args.indexOf("--commit");
+const shaArg = commitIdx >= 0 ? args[commitIdx + 1] : "";
+const sha = (shaArg && !shaArg.startsWith("-") ? shaArg : process.env.GITHUB_SHA || "").trim();
+const root = resolveMillRoot();
+const reportPath = path.join(root, ".opencode", "logs", "ci-cd-monitor-report.json");
+
+function writeReport(report) {
+  fs.mkdirSync(path.dirname(reportPath), { recursive: true });
+  fs.writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`);
+}
+
+function emptyReport(status, reason) {
+  return {
+    ci_status: status,
+    health_score: status === "healthy" || status === "unknown" ? 100 : 0,
+    issues: [],
+    reason,
+    sha: sha || null,
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+async function main() {
+  const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN || "";
+  const repo = process.env.GITHUB_REPOSITORY || "";
+  if (!token || !repo.includes("/")) {
+    const report = emptyReport(
+      "unknown",
+      "no GITHUB_TOKEN or GITHUB_REPOSITORY — mill CI monitor skipped",
+    );
+    writeReport(report);
+    process.stdout.write("SUCCESS: mill CI monitor skipped (no GitHub token)\n");
+    process.stdout.write("No failed jobs\n");
+    return 0;
+  }
+
+  const url = new URL(`https://api.github.com/repos/${repo}/actions/runs`);
+  url.searchParams.set("per_page", "50");
+  if (sha) url.searchParams.set("head_sha", sha);
+
+  const res = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      "User-Agent": "0xray-foundry-ci-monitor",
+    },
+  });
+  if (!res.ok) {
+    const report = emptyReport("warning", `GitHub API ${res.status}`);
+    writeReport(report);
+    process.stderr.write(`mill ci: GitHub API ${res.status}\n`);
+    return 1;
+  }
+  const body = await res.json();
+  const runs = Array.isArray(body.workflow_runs) ? body.workflow_runs : [];
+  const failed = runs.filter((run) => {
+    const conclusion = String(run.conclusion || "");
+    return conclusion === "failure" || conclusion === "timed_out" || conclusion === "startup_failure";
+  });
+  const issues = failed.map((run) => ({
+    name: run.name || run.display_title || "workflow",
+    conclusion: run.conclusion,
+    html_url: run.html_url,
+    head_sha: run.head_sha,
+  }));
+  const uniqueFails = new Set(issues.map((i) => i.name)).size;
+  const health = Math.max(0, 100 - uniqueFails * 20);
+  const ci_status = uniqueFails === 0 ? "healthy" : uniqueFails >= 3 ? "critical" : "warning";
+  const report = {
+    ci_status,
+    health_score: health,
+    issues,
+    sha: sha || null,
+    run_count: runs.length,
+    generatedAt: new Date().toISOString(),
+  };
+  writeReport(report);
+
+  if (uniqueFails === 0) {
+    process.stdout.write("SUCCESS: All workflows passed\n");
+    process.stdout.write("No failed jobs\n");
+    return 0;
+  }
+  process.stdout.write(`FAILURE: ${issues.map((i) => i.name).join(", ")}\n`);
+  return 1;
+}
+
+const isMain =
+  process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+
+if (isMain) {
+  main()
+    .then((code) => process.exit(code))
+    .catch((err) => {
+      process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+      process.exit(1);
+    });
+}
+
+export { main };

package/scripts/foundry/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./cli.mjs";

package/scripts/foundry/cli.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * @0xray/foundry CLI — mill, not exo. No fifth MCP.
+ *
+ *   npx @0xray/foundry <reconcile|stamp|gate|release|docs-check|docs-build|mint|ci|hooks> [...args]
+ */
+
+import { spawnSync } from "node:child_process";
+import { millScript, resolveMillRoot } from "./mill-root.mjs";
+
+const COMMANDS = {
+  reconcile: { script: "reconcile-version.mjs", preset: [] },
+  stamp: { script: "version-manager.mjs", preset: ["--artifacts-only"] },
+  gate: { script: "release-gate.mjs", preset: [] },
+  release: { script: "release.mjs", preset: [] },
+  "docs-check": { script: "validate-release-docs.mjs", preset: [] },
+  "docs-build": { script: "docs-build.mjs", preset: [] },
+  mint: { script: "mint.mjs", preset: [] },
+  ci: { script: "ci-monitor.mjs", preset: [] },
+  hooks: { script: "hooks.mjs", preset: [] },
+};
+
+const HELP =
+  "Usage: npx @0xray/foundry <reconcile|stamp|gate|release|docs-check|docs-build|mint|ci|hooks> [...args]\n" +
+  "\n" +
+  "Mill, not exo. FOUNDRY_ROOT overrides cwd (the repo being milled).\n" +
+  "release bumps/commits/pushes/publishes the milled cwd — pass --dry-run or --i-mean-it (or FOUNDRY_RELEASE=1).\n" +
+  "Mint overlays their plant onto project hangers (mill-fill). PPE stays worn.\n" +
+  "gate is build+test. docs-build is Docusaurus on the 0xray exo. ci reports GitHub Actions (no auto-push). hooks installs git pre/post hooks.\n";
+
+const cmd = process.argv[2];
+const rest = process.argv.slice(3);
+
+if (cmd === "--help" || cmd === "-h" || cmd === "help") {
+  process.stdout.write(HELP);
+  process.exit(0);
+}
+
+if (!cmd || !COMMANDS[cmd]) {
+  process.stderr.write(HELP);
+  process.exit(1);
+}
+
+const spec = COMMANDS[cmd];
+const root = resolveMillRoot();
+const result = spawnSync(
+  process.execPath,
+  [millScript(spec.script), ...spec.preset, ...rest],
+  {
+    stdio: "inherit",
+    cwd: root,
+    env: { ...process.env, FOUNDRY_ROOT: root },
+  },
+);
+process.exit(result.status === null ? 1 : result.status);

package/scripts/foundry/docs-build.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+/**
+ * Mill Docusaurus build. Full corpus only on the 0xray exo (docs-site/).
+ * Stranger mills skip. Not PPE. Not an 8th MCP.
+ *
+ *   npx @0xray/foundry docs-build
+ */
+
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isXrayExoRepo, resolveMillRoot } from "./mill-root.mjs";
+
+function run(cmd, args, cwd) {
+  const result = spawnSync(cmd, args, { cwd, stdio: "inherit", env: process.env });
+  return result.status === null ? 1 : result.status;
+}
+
+function main() {
+  const root = resolveMillRoot();
+  if (!isXrayExoRepo(root)) {
+    process.stdout.write("docs-build: skipped (not 0xray exo with docs-site)\n");
+    process.exit(0);
+  }
+  const docs = path.join(root, "docs-site");
+  if (!fs.existsSync(path.join(docs, "node_modules"))) {
+    const install = run("npm", ["ci"], docs);
+    if (install !== 0) process.exit(install);
+  }
+  process.exit(run("npm", ["run", "build"], docs));
+}
+
+const isMain =
+  process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  main();
+}

package/scripts/foundry/hooks.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * Mill git hooks: install pre-commit / post-commit / pre-push / post-push.
+ * Wear-time installer lives at scripts/hooks/install-hooks.cjs (dogfood)
+ * or node_modules/0xray/scripts/hooks/install-hooks.cjs (published mill).
+ *
+ *   npx @0xray/foundry hooks
+ */
+
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveHookInstaller, resolveMillRoot } from "./mill-root.mjs";
+
+function main() {
+  const root = resolveMillRoot();
+  const installer = resolveHookInstaller(root);
+  if (!installer) {
+    process.stderr.write(
+      "mill hooks: no install-hooks.cjs (dogfood scripts/hooks or node_modules/0xray/scripts/hooks)\n",
+    );
+    process.exit(1);
+  }
+  const result = spawnSync(process.execPath, [installer, ...process.argv.slice(2)], {
+    stdio: "inherit",
+    cwd: root,
+    env: { ...process.env, FOUNDRY_ROOT: root },
+  });
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+const isMain =
+  process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  main();
+}

package/scripts/foundry/mill-root.mjs

@@ -0,0 +1,62 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const millDir = path.dirname(fileURLToPath(import.meta.url));
+
+export function millPackageDir() {
+  return millDir;
+}
+
+export function millScript(basename) {
+  return path.join(millDir, basename);
+}
+
+/** Repo being milled: FOUNDRY_ROOT, else cwd. Not this package's __dirname. */
+export function resolveMillRoot() {
+  const env = process.env.FOUNDRY_ROOT;
+  if (typeof env === "string" && env.trim()) {
+    return path.resolve(env.trim());
+  }
+  return process.cwd();
+}
+
+/**
+ * Git hook installer. Dogfood is `scripts/hooks` next to `scripts/foundry`.
+ * Published mill lives in `node_modules/@0xray/foundry` — sibling `@0xray/hooks`
+ * does not exist. Use the worn 0xray garment installer instead.
+ */
+export function resolveHookInstaller(rootDir = resolveMillRoot(), millPkg = millPackageDir()) {
+  const candidates = [
+    path.join(millPkg, "..", "hooks", "install-hooks.cjs"),
+    path.join(rootDir, "node_modules", "0xray", "scripts", "hooks", "install-hooks.cjs"),
+    path.join(rootDir, "scripts", "hooks", "install-hooks.cjs"),
+  ];
+  return candidates.find((p) => fs.existsSync(p)) ?? null;
+}
+
+export function readRootPackage(rootDir = resolveMillRoot()) {
+  const pkgPath = path.join(rootDir, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    return { name: null, version: null, scripts: {} };
+  }
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return {
+      name: typeof pkg.name === "string" ? pkg.name : null,
+      version: typeof pkg.version === "string" ? pkg.version : null,
+      scripts: pkg.scripts && typeof pkg.scripts === "object" ? pkg.scripts : {},
+    };
+  } catch {
+    return { name: null, version: null, scripts: {} };
+  }
+}
+
+export function hasDocsSite(rootDir = resolveMillRoot()) {
+  return fs.existsSync(path.join(rootDir, "docs-site"));
+}
+
+export function isXrayExoRepo(rootDir = resolveMillRoot()) {
+  const pkg = readRootPackage(rootDir);
+  return pkg.name === "0xray" && hasDocsSite(rootDir);
+}

package/scripts/foundry/mint-suit.cjs

@@ -0,0 +1,313 @@
+/**
+ * Mill overlay: their plant onto the hanger. Not PPE (evaluatePreToolGate).
+ *
+ * Default SSOT (override with foundry.json or .xray/foundry.json):
+ *   xray/codex.json, xray/features.json, xray/config.json,
+ *   src/skills/<name>/SKILL.md, src/opencode/agents/*.yml
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const DEFAULT_PARAMS = {
+  codex: "xray/codex.json",
+  features: "xray/features.json",
+  config: "xray/config.json",
+  skills: "src/skills",
+  agents: "src/opencode/agents",
+  agentsCard: "xray/AGENTS.md",
+};
+
+function deepMerge(src, dest) {
+  if (typeof src !== "object" || src === null) return dest !== undefined ? dest : src;
+  if (Array.isArray(src)) return Array.isArray(dest) ? dest : src;
+  const result = {};
+  for (const key of Object.keys(src)) {
+    result[key] =
+      dest && typeof dest[key] !== "undefined" ? deepMerge(src[key], dest[key]) : src[key];
+  }
+  if (dest && typeof dest === "object") {
+    for (const key of Object.keys(dest)) {
+      if (!(key in src)) result[key] = dest[key];
+    }
+  }
+  return result;
+}
+
+function readPackageIdentity(pkgPath) {
+  if (!fs.existsSync(pkgPath)) return { name: null, version: null };
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return {
+      name: typeof pkg.name === "string" ? pkg.name : null,
+      version: typeof pkg.version === "string" ? pkg.version : null,
+    };
+  } catch {
+    return { name: null, version: null };
+  }
+}
+
+function isExoRepo(dir) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+    return pkg.name === "0xray" && fs.existsSync(path.join(dir, "docs-site"));
+  } catch {
+    return false;
+  }
+}
+
+function isDogfood(millPackageRoot, targetDir) {
+  if (path.resolve(millPackageRoot) === path.resolve(targetDir)) return true;
+  return isExoRepo(targetDir);
+}
+
+/** Rel must stay inside targetDir. Absolute and `..` escapes return null. */
+function resolveInside(targetDir, rel) {
+  if (typeof rel !== "string" || !rel.trim()) return null;
+  if (path.isAbsolute(rel)) return null;
+  const rootAbs = path.resolve(targetDir);
+  const resolved = path.resolve(rootAbs, rel);
+  const prefix = rootAbs.endsWith(path.sep) ? rootAbs : `${rootAbs}${path.sep}`;
+  if (resolved !== rootAbs && !resolved.startsWith(prefix)) return null;
+  return resolved;
+}
+
+function loadFoundryParams(targetDir) {
+  const candidates = [
+    path.join(targetDir, "foundry.json"),
+    path.join(targetDir, ".xray", "foundry.json"),
+  ];
+  let extra = {};
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) extra = parsed;
+    } catch {
+      extra = {};
+    }
+    break;
+  }
+  const params = { ...DEFAULT_PARAMS };
+  for (const key of ["codex", "features", "config", "skills", "agents", "agentsCard"]) {
+    if (typeof extra[key] === "string" && extra[key].trim()) params[key] = extra[key].trim();
+  }
+  return params;
+}
+
+function isDirectory(p) {
+  try {
+    return Boolean(p) && fs.existsSync(p) && fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/** Project skill hangers only. */
+function listSkillHangers(targetDir) {
+  const dests = [path.join(targetDir, ".opencode", "skills")];
+  const projectGrok = path.join(targetDir, ".grok", "plugins", "0xray", "skills");
+  if (isDirectory(projectGrok)) dests.push(projectGrok);
+  return dests;
+}
+
+function overlayJsonFacet(src, dest) {
+  if (!src || !fs.existsSync(src) || !fs.statSync(src).isFile()) return false;
+  if (path.resolve(src) === path.resolve(dest)) return false;
+  let theirs;
+  try {
+    theirs = JSON.parse(fs.readFileSync(src, "utf8"));
+  } catch {
+    return false;
+  }
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  if (!fs.existsSync(dest)) {
+    fs.writeFileSync(dest, `${JSON.stringify(theirs, null, 2)}\n`);
+    return true;
+  }
+  try {
+    const mill = JSON.parse(fs.readFileSync(dest, "utf8"));
+    const merged = deepMerge(mill, theirs);
+    fs.writeFileSync(dest, `${JSON.stringify(merged, null, 2)}\n`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function listConsumerSkillNames(targetDir, skillsRel) {
+  const rel = skillsRel || DEFAULT_PARAMS.skills;
+  const skillsSrc = resolveInside(targetDir, rel);
+  if (!isDirectory(skillsSrc)) return [];
+  const names = [];
+  for (const entry of fs.readdirSync(skillsSrc, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const skillMd = path.join(skillsSrc, entry.name, "SKILL.md");
+    if (!fs.existsSync(skillMd)) continue;
+    names.push(entry.name);
+  }
+  return names;
+}
+
+function listConsumerAgentFiles(targetDir, agentsRel) {
+  const rel = agentsRel || DEFAULT_PARAMS.agents;
+  const agentsSrc = resolveInside(targetDir, rel);
+  if (!isDirectory(agentsSrc)) return [];
+  return fs
+    .readdirSync(agentsSrc, { withFileTypes: true })
+    .filter(
+      (entry) =>
+        entry.isFile() && (entry.name.endsWith(".yml") || entry.name.endsWith(".yaml")),
+    )
+    .map((entry) => entry.name);
+}
+
+const MANAGED_AGENTS_MARKER = "<!-- 0xray-managed -->";
+
+function overlayAgentsCard(targetDir, params) {
+  const src = resolveInside(targetDir, params.agentsCard || DEFAULT_PARAMS.agentsCard);
+  if (!src || !fs.existsSync(src) || !fs.statSync(src).isFile()) return false;
+  const dest = path.join(targetDir, "AGENTS.md");
+  if (path.resolve(src) === path.resolve(dest)) return false;
+  if (fs.existsSync(dest) && !fs.readFileSync(dest, "utf8").includes(MANAGED_AGENTS_MARKER)) {
+    return false;
+  }
+  fs.copyFileSync(src, dest);
+  return true;
+}
+
+function overlayConsumerTree(targetDir, log, params) {
+  const resolved = params || loadFoundryParams(targetDir);
+  const skillsRel = resolved.skills;
+  const agentsRel = resolved.agents;
+  const skills = listConsumerSkillNames(targetDir, skillsRel);
+  const agents = listConsumerAgentFiles(targetDir, agentsRel);
+  const skillsSrc = resolveInside(targetDir, skillsRel);
+  const agentsSrc = resolveInside(targetDir, agentsRel);
+  const skillHangers = listSkillHangers(targetDir);
+  const agentsDest = path.join(targetDir, ".opencode", "agents");
+
+  for (const hanger of skillHangers) {
+    for (const name of skills) {
+      const src = path.join(skillsSrc, name, "SKILL.md");
+      const destMd = path.join(hanger, name, "SKILL.md");
+      if (path.resolve(src) === path.resolve(destMd)) continue;
+      fs.mkdirSync(path.dirname(destMd), { recursive: true });
+      fs.copyFileSync(src, destMd);
+    }
+  }
+  for (const file of agents) {
+    const src = path.join(agentsSrc, file);
+    const dest = path.join(agentsDest, file);
+    if (path.resolve(src) === path.resolve(dest)) continue;
+    fs.mkdirSync(agentsDest, { recursive: true });
+    fs.copyFileSync(src, dest);
+  }
+
+  if (log && (skills.length > 0 || agents.length > 0)) {
+    log("foundry-mint", "Overlaid consumer skills/agents onto hangers", "info", {
+      skills: skills.length,
+      agents: agents.length,
+      skillHangers: skillHangers.length,
+    });
+  }
+  return { skills, agents, params: resolved };
+}
+
+function mintConsumerFromSsot(packageRoot, targetDir, log, tree) {
+  if (isDogfood(packageRoot, targetDir)) {
+    return { garment: "dogfood", skipped: true, consumer: readPackageIdentity(path.join(targetDir, "package.json")) };
+  }
+  const mill = readPackageIdentity(path.join(packageRoot, "package.json"));
+  const consumer = readPackageIdentity(path.join(targetDir, "package.json"));
+  const skills = Array.isArray(tree?.skills) ? tree.skills : [];
+  const agents = Array.isArray(tree?.agents) ? tree.agents : [];
+  const constitution = Boolean(tree?.codex);
+  const features = Boolean(tree?.features);
+  const config = Boolean(tree?.config);
+  const agentsCard = Boolean(tree?.agentsCard);
+  const overlayed =
+    skills.length > 0 ||
+    agents.length > 0 ||
+    constitution ||
+    features ||
+    config ||
+    agentsCard;
+  const garment = overlayed ? "overlay" : "copied-onto-hanger";
+  const inventory = {
+    mill: { name: mill.name || "@0xray/foundry", version: mill.version },
+    consumer: { name: consumer.name, version: consumer.version },
+    garment,
+    params: tree?.params || loadFoundryParams(targetDir),
+    tree: { skills, agents },
+    facets: {
+      constitution,
+      features,
+      config,
+      agentsCard,
+      skills,
+      agents,
+    },
+    mintedAt: new Date().toISOString(),
+  };
+  const xrayDir = path.join(targetDir, ".xray");
+  if (!fs.existsSync(xrayDir)) fs.mkdirSync(xrayDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(xrayDir, "foundry-inventory.json"),
+    `${JSON.stringify(inventory, null, 2)}\n`,
+  );
+  if (log) {
+    log("foundry-mint", "Minted foundry-inventory from consumer mill SSOT", "info", {
+      consumer: consumer.name,
+      version: consumer.version,
+      garment,
+    });
+  }
+  return inventory;
+}
+
+function mintConsumerSuit(millPackageRoot, targetDir, log) {
+  if (isDogfood(millPackageRoot, targetDir)) {
+    return { garment: "dogfood", skipped: true };
+  }
+  const params = loadFoundryParams(targetDir);
+  const tree = overlayConsumerTree(targetDir, log, params);
+  tree.codex = overlayJsonFacet(
+    resolveInside(targetDir, params.codex),
+    path.join(targetDir, ".xray", "codex.json"),
+  );
+  tree.features = overlayJsonFacet(
+    resolveInside(targetDir, params.features),
+    path.join(targetDir, ".xray", "features.json"),
+  );
+  tree.config = overlayJsonFacet(
+    resolveInside(targetDir, params.config),
+    path.join(targetDir, ".xray", "config.json"),
+  );
+  tree.agentsCard = overlayAgentsCard(targetDir, params);
+  if (log && (tree.codex || tree.features || tree.config)) {
+    log("foundry-mint", "Overlaid consumer suit facets onto .xray", "info", {
+      constitution: tree.codex,
+      features: tree.features,
+      config: tree.config,
+    });
+  }
+  return mintConsumerFromSsot(millPackageRoot, targetDir, log, tree);
+}
+
+module.exports = {
+  DEFAULT_PARAMS,
+  deepMerge,
+  loadFoundryParams,
+  resolveInside,
+  overlayJsonFacet,
+  overlayAgentsCard,
+  overlayConsumerTree,
+  listConsumerSkillNames,
+  listConsumerAgentFiles,
+  listSkillHangers,
+  mintConsumerFromSsot,
+  mintConsumerSuit,
+  isDogfood,
+  readPackageIdentity,
+};

package/scripts/foundry/mint.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+/**
+ * Overlay their mill SSOT onto the hanger (cwd / FOUNDRY_ROOT).
+ * Not a fifth 0xray CLI. Not PPE.
+ */
+
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { millPackageDir, resolveMillRoot } from "./mill-root.mjs";
+
+const require = createRequire(import.meta.url);
+const { mintConsumerSuit } = require("./mint-suit.cjs");
+
+function main() {
+  const target = resolveMillRoot();
+  const millRoot = millPackageDir();
+  const inventory = mintConsumerSuit(millRoot, target, (component, action, status) => {
+    process.stdout.write(`${component} ${action} ${status}\n`);
+  });
+  if (inventory.skipped) {
+    process.stderr.write("mint: skipped dogfood / 0xray exo plant (not a consumer hanger)\n");
+    process.exit(0);
+  }
+  process.stdout.write(`${JSON.stringify(inventory, null, 2)}\n`);
+}
+
+const isMain =
+  process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+
+if (isMain) {
+  main();
+}