0xray 4.0.12 → 4.0.14

package/scripts/foundry/blip.mjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/**
+ * Factory-blip CLI — sibling plant to mill + sound, not a mill bolt-on.
+ *   npx @0xray/foundry blip render --brief TEXT --mode still|motion:<id> [--look focus|cage] [--bed PATH] [--engine rippel|wireframe] [--out FILE]
+ *   npx @0xray/foundry blip inspect
+ */
+
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveMillRoot } from "./mill-root.mjs";
+
+const require = createRequire(import.meta.url);
+const blip = require("./blip-render.cjs");
+
+const HELP =
+  "Usage: npx @0xray/foundry blip <render|inspect> [...args]\n" +
+  "\n" +
+  "Factory-blip plant, sibling to mill + sound. FOUNDRY_ROOT overrides cwd.\n" +
+  "render: brief → checksum seed → still|motion:<id> → 4.44s mp4 + audio bed → receipt.\n" +
+  "v0 ids: still, orb, swirl, snap, waves, spark (Rippel five are imports).\n" +
+  "Motions: Rippel VisualConfig.circles at ≥720p (default). --look focus|cage (seed picks if omitted).\n" +
+  "--engine wireframe is emergency only.\n" +
+  "Every mp4 muxes a 4.44s bed (--bed PATH or auto sound mill). Silent = inspect FAIL.\n" +
+  "kapow is a growth stub (FAIL until a renderer ships). Unknown id FAIL.\n" +
+  "still: Power Plant ident — plate dissolves over 4.44s at ≥720p, not a frozen poster.\n" +
+  "inspect: last .xray/blip/receipt.json PASS/FAIL (missing is FAIL). Lists live registry ids.\n";
+
+function argValue(argv, name, fallback) {
+  const i = argv.indexOf(name);
+  if (i < 0 || i + 1 >= argv.length) return fallback;
+  return argv[i + 1];
+}
+
+function writeJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+function inspectBlip(root) {
+  const motions = blip.listMotionIds();
+  const receipt = blip.readReceipt(root);
+  if (!receipt) {
+    return {
+      ok: false,
+      status: "FAIL",
+      failClosed: true,
+      plant: "blip",
+      motions,
+      detail: "missing .xray/blip/receipt.json",
+      receipt: null,
+    };
+  }
+  const evaluated = blip.evaluateReceipt(root, receipt);
+  const status = evaluated.status === "PASS" ? "PASS" : "FAIL";
+  return {
+    ok: status === "PASS",
+    status,
+    failClosed: true,
+    plant: "blip",
+    motions,
+    mode: evaluated.mode || receipt.motionId || receipt.mode || null,
+    pictureMode: evaluated.pictureMode || receipt.pictureMode || null,
+    durationSec: evaluated.durationSec ?? receipt.durationSec ?? null,
+    receipt,
+  };
+}
+
+function main() {
+  const argv = process.argv.slice(2);
+  const cmd = argv[0];
+  const rest = argv.slice(1);
+  const root = resolveMillRoot();
+
+  if (!cmd || cmd === "--help" || cmd === "-h" || cmd === "help") {
+    process.stdout.write(HELP);
+    process.exit(cmd ? 0 : 1);
+  }
+
+  if (cmd === "inspect") {
+    const report = inspectBlip(root);
+    writeJson(report);
+    process.exit(report.ok ? 0 : 1);
+  }
+
+  if (cmd === "render") {
+    const result = blip.renderBlip({
+      root,
+      brief: argValue(rest, "--brief", "factory-blip"),
+      pictureMode: argValue(rest, "--picture-mode", argValue(rest, "--mode", "still")),
+      lookKind: argValue(rest, "--look", null),
+      bed: argValue(rest, "--bed", null),
+      engine: argValue(rest, "--engine", "rippel"),
+      out: argValue(rest, "--out", null),
+    });
+    writeJson(result.receipt);
+    process.exit(result.receipt.status === "PASS" ? 0 : 1);
+  }
+
+  process.stderr.write(HELP);
+  process.exit(1);
+}
+
+export { inspectBlip };
+
+const isMain =
+  process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  main();
+}

package/scripts/foundry/cli.mjs

@@ -2,7 +2,7 @@
 /**
  * @0xray/foundry CLI — mill, not exo. No fifth MCP.
  *
- *   npx @0xray/foundry <reconcile|stamp|gate|release|docs-check|docs-build|mint|inspect|ci|hooks> [...args]
+ *   npx @0xray/foundry <reconcile|stamp|gate|release|docs-check|docs-build|mint|inspect|sound|blip|ci|hooks> [...args]
  */
 
 import { spawnSync } from "node:child_process";
@@ -17,17 +17,21 @@ const COMMANDS = {
   "docs-build": { script: "docs-build.mjs", preset: [] },
   mint: { script: "mint.mjs", preset: [] },
   inspect: { script: "inspect.mjs", preset: [] },
+  sound: { script: "sound.mjs", preset: [] },
+  blip: { script: "blip.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|inspect|ci|hooks> [...args]\n" +
+  "Usage: npx @0xray/foundry <reconcile|stamp|gate|release|docs-check|docs-build|mint|inspect|sound|blip|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 fastens mill plant then overlays their plant (mill-fill JSON), then runs inspect. PPE stays worn.\n" +
-  "inspect runs the six mill checks (diff, plant vs worn, receipt, CI, live tarball GET, isolated HOME). Not an 8th MCP.\n" +
+  "Mint fastens the requested factory plant (default mill; foundry.json plant: sound|blip turns mill off), then inspect.\n" +
+  "inspect runs mill checks plus, on a sound seat, last bed receipt PASS/FAIL; on a blip seat, last blip receipt.\n" +
+  "sound render|inspect is the factory-sound plant (brief → seed → genre → wav → metrics). Sibling to mill, not a mill copy.\n" +
+  "blip render|inspect is the factory-blip plant (brief → seed → still|motion:<id> → 4.44s mp4). Sibling to mill + sound.\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];

package/scripts/foundry/inspect.mjs

@@ -82,15 +82,25 @@ function checkDiff(root) {
 }
 
 function checkPlantVsWorn(root, millRoot) {
-  const plantDir = mint.millPlantDir(millRoot);
+  const kinds = mint.loadFactoryPlantKinds(root);
+  const allow = mint.factoryPlantAllowlist(millRoot, root);
   const millPlant = {
-    skills: plantDir ? mint.listSkillNamesAt(path.join(plantDir, "skills")) : [],
-    agents: plantDir ? mint.listAgentFilesAt(path.join(plantDir, "agents")) : [],
+    skills: kinds.includes("mill") ? mint.catalogPlant("mill").skills : [],
+    agents: kinds.includes("mill") ? mint.catalogPlant("mill").agents : [],
+    sound: kinds.includes("sound") ? mint.catalogPlant("sound") : { skills: [], agents: [] },
+    blip: kinds.includes("blip") ? mint.catalogPlant("blip") : { skills: [], agents: [] },
   };
   const params = mint.loadFoundryParams(root);
   const tree = {
     skills: mint.listConsumerSkillNames(root, params.skills),
     agents: mint.listConsumerAgentFiles(root, params.agents),
+    plantKinds: kinds,
+    soundPlantSkills: millPlant.sound.skills,
+    soundPlantAgents: millPlant.sound.agents,
+    sound: millPlant.sound,
+    blipPlantSkills: millPlant.blip.skills,
+    blipPlantAgents: millPlant.blip.agents,
+    blip: millPlant.blip,
   };
   const shopPlant = mint.loadShopPlant(root);
   try {
@@ -98,10 +108,14 @@ function checkPlantVsWorn(root, millRoot) {
     return {
       id: "plant-vs-worn",
       ok: true,
+      plant: kinds,
       millPlant: millPlant.skills,
+      soundPlant: millPlant.sound.skills,
+      blipPlant: millPlant.blip.skills,
       shopPlant,
       tree: tree.skills,
       worn: mint.wornSkillNames(root),
+      allow: allow.skills,
     };
   } catch (err) {
     return {
@@ -110,6 +124,9 @@ function checkPlantVsWorn(root, millRoot) {
       detail: err instanceof Error ? err.message : String(err),
       extraSkills: err.extraSkills || [],
       extraAgents: err.extraAgents || [],
+      plant: kinds,
+      soundPlant: millPlant.sound.skills,
+      blipPlant: millPlant.blip.skills,
       shopPlant,
     };
   }
@@ -125,18 +142,107 @@ function checkReceipt(root) {
     return { id: "receipt", ok: false, detail: "missing .xray/foundry-inventory.json" };
   }
   const millPlantSkills = inventory.millPlant?.skills || [];
-  const hasMill = millPlantSkills.includes("mill");
-  const hasInspect = millPlantSkills.includes("inspect");
-  const ok = hasMill && hasInspect;
+  const soundPlantSkills = inventory.soundPlant?.skills || [];
+  const blipPlantSkills = inventory.blipPlant?.skills || [];
+  const kinds = mint.inventoryPlantKinds(inventory);
+  const needMill = kinds.includes("mill");
+  const needSound = kinds.includes("sound");
+  const needBlip = kinds.includes("blip");
+  const millOk = !needMill || (millPlantSkills.includes("mill") && millPlantSkills.includes("inspect"));
+  const soundOk =
+    !needSound || (soundPlantSkills.includes("sound") && soundPlantSkills.includes("sound-inspect"));
+  const blipOk =
+    !needBlip || (blipPlantSkills.includes("blip") && blipPlantSkills.includes("blip-inspect"));
+  const ok = millOk && soundOk && blipOk && (needMill || needSound || needBlip);
+  let detail = null;
+  if (!ok && needMill && !millOk) detail = "millPlant.skills must include mill and inspect";
+  else if (!ok && needSound && !soundOk) detail = "soundPlant.skills must include sound and sound-inspect";
+  else if (!ok && needBlip && !blipOk) detail = "blipPlant.skills must include blip and blip-inspect";
+  else if (!ok) detail = "inventory plant is empty";
   return {
     id: "receipt",
     ok,
     suit: inventory.suit,
     mill: inventory.mill,
+    plant: kinds,
     millPlant: millPlantSkills,
+    soundPlant: soundPlantSkills,
+    blipPlant: blipPlantSkills,
     dna: typeof inventory.dna === "string" ? inventory.dna : null,
     pack: "0xray-suit",
-    detail: ok ? null : "millPlant.skills must include mill and inspect",
+    detail,
+  };
+}
+
+function checkSoundBed(root) {
+  const inventory = readJson(path.join(root, ".xray", "foundry-inventory.json"));
+  const kinds = inventory ? mint.inventoryPlantKinds(inventory) : mint.loadFactoryPlantKinds(root);
+  if (!kinds.includes("sound")) return null;
+  const bed = require("./sound-bed.cjs");
+  const receipt = bed.readReceipt(root);
+  if (!receipt) {
+    return {
+      id: "sound-bed",
+      ok: true,
+      skipped: true,
+      status: "NONE",
+      plant: kinds,
+      detail: "no bed receipt yet — npx @0xray/foundry sound render",
+    };
+  }
+  const status = receipt.status === "PASS" ? "PASS" : "FAIL";
+  const unreadable = receipt.reason === "receipt-unreadable";
+  return {
+    id: "sound-bed",
+    ok: status === "PASS" && !unreadable,
+    status,
+    failClosed: true,
+    plant: kinds,
+    metrics: receipt.metrics || null,
+    gates: receipt.gates || null,
+    wav: receipt.wav || null,
+    seed: receipt.seed || null,
+    detail: status === "PASS" ? null : receipt.reason || "bed receipt FAIL",
+  };
+}
+
+function checkBlip(root) {
+  const inventory = readJson(path.join(root, ".xray", "foundry-inventory.json"));
+  const kinds = inventory ? mint.inventoryPlantKinds(inventory) : mint.loadFactoryPlantKinds(root);
+  if (!kinds.includes("blip")) return null;
+  const blip = require("./blip-render.cjs");
+  const receipt = blip.readReceipt(root);
+  const motions = blip.listMotionIds();
+  if (!receipt) {
+    return {
+      id: "blip",
+      ok: true,
+      skipped: true,
+      status: "NONE",
+      plant: kinds,
+      motions,
+      detail: "no blip receipt yet — npx @0xray/foundry blip render --brief \"...\" --mode still",
+    };
+  }
+  const evaluated = blip.evaluateReceipt(root, receipt);
+  const status = evaluated.status === "PASS" ? "PASS" : "FAIL";
+  const unreadable = receipt.reason === "receipt-unreadable";
+  return {
+    id: "blip",
+    ok: status === "PASS" && !unreadable,
+    status,
+    failClosed: true,
+    plant: kinds,
+    motions,
+    mode: evaluated.mode || receipt.motionId || receipt.mode || null,
+    pictureMode: evaluated.pictureMode || receipt.pictureMode || null,
+    palette: receipt.palette || null,
+    plate: receipt.plate || null,
+    durationSec: evaluated.durationSec ?? receipt.durationSec ?? null,
+    mp4: evaluated.mp4 || receipt.mp4 || null,
+    hasVideo: evaluated.hasVideo ?? receipt.hasVideo ?? null,
+    hasAudio: evaluated.hasAudio ?? receipt.hasAudio ?? null,
+    detail: status === "PASS" ? null : evaluated.reason || receipt.reason || "blip receipt FAIL",
   };
 }
 
@@ -268,6 +374,10 @@ export async function inspectSuit(root, opts = {}) {
   checks.push(checkDiff(root));
   checks.push(checkPlantVsWorn(root, millRoot));
   checks.push(checkReceipt(root));
+  const soundBed = checkSoundBed(root);
+  if (soundBed) checks.push(soundBed);
+  const blip = checkBlip(root);
+  if (blip) checks.push(blip);
   checks.push(checkCi(root));
 
   if (skipLive) {

package/scripts/foundry/mint-suit.cjs

@@ -24,6 +24,17 @@ const DEFAULT_PARAMS = {
 /** Factory shop plant. First-class with mill plant. Not 45/42 costume. */
 const FACTORY_SHOP_SKILLS = ["shop-extract", "shop-witness", "shop-pin"];
 
+/** Factory plant kinds. Mill is default. Sound is a bed factory. Blip is a tiny-video factory. */
+const FACTORY_PLANT_CATALOG = {
+  mill: { skills: ["mill", "inspect"], agents: ["mill.yml", "inspect.yml"] },
+  sound: { skills: ["sound", "sound-inspect"], agents: ["sound.yml", "sound-inspect.yml"] },
+  blip: { skills: ["blip", "blip-inspect"], agents: ["blip.yml", "blip-inspect.yml"] },
+};
+
+function isFactoryPlantKind(kind) {
+  return Boolean(kind && FACTORY_PLANT_CATALOG[kind]);
+}
+
 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;
@@ -118,6 +129,90 @@ function millPlantDir(millPackageRoot) {
   return null;
 }
 
+function emptyPlantFiles() {
+  return { skills: [], agents: [] };
+}
+
+function catalogPlant(kind) {
+  const spec = FACTORY_PLANT_CATALOG[kind];
+  return spec ? { skills: [...spec.skills], agents: [...spec.agents] } : emptyPlantFiles();
+}
+
+/** foundry.json plant: "sound" | "blip" | "mill" | ["mill","sound","blip"]. millPlant:false turns mill off. */
+function loadFactoryPlantKinds(targetDir) {
+  const extra = loadFoundryExtra(targetDir);
+  const kinds = [];
+  const raw = extra.plant;
+  if (Array.isArray(raw)) {
+    for (const item of raw) {
+      if (isFactoryPlantKind(item)) kinds.push(item);
+    }
+  } else if (isFactoryPlantKind(raw)) {
+    kinds.push(raw);
+  } else if (extra.soundPlant === true || extra.blipPlant === true) {
+    if (extra.millPlant !== false) kinds.push("mill");
+    if (extra.soundPlant === true) kinds.push("sound");
+    if (extra.blipPlant === true) kinds.push("blip");
+  } else {
+    kinds.push("mill");
+  }
+  if (extra.millPlant === false) {
+    return [...new Set(kinds.filter((kind) => kind !== "mill"))];
+  }
+  return [...new Set(kinds)];
+}
+
+function unionPlantFiles(kinds) {
+  const skills = [];
+  const agents = [];
+  for (const kind of kinds) {
+    const spec = catalogPlant(kind);
+    for (const name of spec.skills) {
+      if (!skills.includes(name)) skills.push(name);
+    }
+    for (const file of spec.agents) {
+      if (!agents.includes(file)) agents.push(file);
+    }
+  }
+  return { skills, agents };
+}
+
+function existingPlantFiles(plantDir, spec) {
+  if (!plantDir || !spec) return emptyPlantFiles();
+  const skillsSrc = path.join(plantDir, "skills");
+  const agentsSrc = path.join(plantDir, "agents");
+  const haveSkills = new Set(listSkillNamesAt(skillsSrc));
+  const haveAgents = new Set(listAgentFilesAt(agentsSrc));
+  return {
+    skills: spec.skills.filter((name) => haveSkills.has(name)),
+    agents: spec.agents.filter((file) => haveAgents.has(file)),
+  };
+}
+
+function factoryPlantAllowlist(millPackageRoot, targetDir) {
+  const kinds = loadFactoryPlantKinds(targetDir);
+  return {
+    kinds,
+    ...existingPlantFiles(millPlantDir(millPackageRoot), unionPlantFiles(kinds)),
+  };
+}
+
+function inventoryPlantKinds(inventory) {
+  if (!inventory || typeof inventory !== "object") return ["mill"];
+  if (Array.isArray(inventory.plant) && inventory.plant.length > 0) {
+    return inventory.plant.filter((kind) => isFactoryPlantKind(kind));
+  }
+  if (isFactoryPlantKind(inventory.plant)) return [inventory.plant];
+  const hasSound = Array.isArray(inventory.soundPlant?.skills) && inventory.soundPlant.skills.length > 0;
+  const hasBlip = Array.isArray(inventory.blipPlant?.skills) && inventory.blipPlant.skills.length > 0;
+  const hasMill = Array.isArray(inventory.millPlant?.skills) && inventory.millPlant.skills.length > 0;
+  const kinds = [];
+  if (hasMill) kinds.push("mill");
+  if (hasSound) kinds.push("sound");
+  if (hasBlip) kinds.push("blip");
+  return kinds.length > 0 ? kinds : ["mill"];
+}
+
 function listSkillNamesAt(skillsSrc) {
   if (!isDirectory(skillsSrc)) return [];
   const names = [];
@@ -141,20 +236,18 @@ function listAgentFilesAt(agentsSrc) {
     .map((entry) => entry.name);
 }
 
-/** Fasten mill plant first. Mill names they did not plant stay; same-name overlay wins. */
-function fastenMillPlant(millPackageRoot, targetDir, log) {
-  const plant = millPlantDir(millPackageRoot);
-  if (!plant) return { skills: [], agents: [] };
+function copyPlantFiles(plant, spec, targetDir) {
   const skillsSrc = path.join(plant, "skills");
   const agentsSrc = path.join(plant, "agents");
-  const skills = listSkillNamesAt(skillsSrc);
-  const agents = listAgentFilesAt(agentsSrc);
+  const skills = spec.skills || [];
+  const agents = spec.agents || [];
   const skillDirs = listProjectSkillDirs(targetDir);
   const agentsDest = path.join(targetDir, ".opencode", "agents");
   for (const dir of skillDirs) {
     for (const name of skills) {
       const src = path.join(skillsSrc, name, "SKILL.md");
       const destMd = path.join(dir, name, "SKILL.md");
+      if (!fs.existsSync(src)) continue;
       if (path.resolve(src) === path.resolve(destMd)) continue;
       if (fs.existsSync(destMd)) continue;
       fs.mkdirSync(path.dirname(destMd), { recursive: true });
@@ -164,18 +257,44 @@ function fastenMillPlant(millPackageRoot, targetDir, log) {
   for (const file of agents) {
     const src = path.join(agentsSrc, file);
     const dest = path.join(agentsDest, file);
+    if (!fs.existsSync(src)) continue;
     if (path.resolve(src) === path.resolve(dest)) continue;
     if (fs.existsSync(dest)) continue;
     fs.mkdirSync(agentsDest, { recursive: true });
     fs.copyFileSync(src, dest);
   }
-  if (log && (skills.length > 0 || agents.length > 0)) {
-    log("foundry-mint", "Fastened mill plant", "info", {
-      skills: skills.length,
-      agents: agents.length,
+  return { skills, agents };
+}
+
+/** Fasten requested factory plants. Default mill only. Sound/blip seats skip mill unless asked. */
+function fastenMillPlant(millPackageRoot, targetDir, log) {
+  const plant = millPlantDir(millPackageRoot);
+  const kinds = loadFactoryPlantKinds(targetDir);
+  if (!plant) {
+    return { skills: [], agents: [], kinds, sound: emptyPlantFiles(), blip: emptyPlantFiles() };
+  }
+  const mill = kinds.includes("mill")
+    ? existingPlantFiles(plant, catalogPlant("mill"))
+    : emptyPlantFiles();
+  const sound = kinds.includes("sound")
+    ? existingPlantFiles(plant, catalogPlant("sound"))
+    : emptyPlantFiles();
+  const blip = kinds.includes("blip")
+    ? existingPlantFiles(plant, catalogPlant("blip"))
+    : emptyPlantFiles();
+  const fastened = copyPlantFiles(
+    plant,
+    unionPlantFiles(kinds.filter((kind) => isFactoryPlantKind(kind))),
+    targetDir,
+  );
+  if (log && (fastened.skills.length > 0 || fastened.agents.length > 0)) {
+    log("foundry-mint", "Fastened factory plant", "info", {
+      plant: kinds,
+      skills: fastened.skills.length,
+      agents: fastened.agents.length,
     });
   }
-  return { skills, agents };
+  return { skills: mill.skills, agents: mill.agents, kinds, sound, blip };
 }
 
 function isDirectory(p) {
@@ -371,30 +490,80 @@ function previousTreeAllowlist(targetDir) {
     const shopSkills = Array.isArray(shopFromInv)
       ? normalizeNameList(shopFromInv)
       : normalizeNameList(shopFromInv?.skills);
+    const soundFromInv = inventory?.soundPlant;
+    const soundSkills = Array.isArray(soundFromInv)
+      ? normalizeNameList(soundFromInv)
+      : normalizeNameList(soundFromInv?.skills);
+    const soundAgents = normalizeNameList(soundFromInv?.agents);
+    const blipFromInv = inventory?.blipPlant;
+    const blipSkills = Array.isArray(blipFromInv)
+      ? normalizeNameList(blipFromInv)
+      : normalizeNameList(blipFromInv?.skills);
+    const blipAgents = normalizeNameList(blipFromInv?.agents);
     return {
       skills: [
         ...(Array.isArray(inventory?.tree?.skills) ? inventory.tree.skills : []),
+        ...(Array.isArray(inventory?.millPlant?.skills) ? inventory.millPlant.skills : []),
         ...shopSkills,
+        ...soundSkills,
+        ...blipSkills,
+      ],
+      agents: [
+        ...(Array.isArray(inventory?.tree?.agents) ? inventory.tree.agents : []),
+        ...(Array.isArray(inventory?.millPlant?.agents) ? inventory.millPlant.agents : []),
+        ...soundAgents,
+        ...blipAgents,
       ],
-      agents: Array.isArray(inventory?.tree?.agents) ? inventory.tree.agents : [],
     };
   } catch {
     return { skills: [], agents: [] };
   }
 }
 
-/** Extra worn names that are neither mill plant, their plant, shop plant, nor a prior overlay. */
+function soundPlantFromTree(targetDir, tree) {
+  if (Array.isArray(tree?.soundPlantSkills) || Array.isArray(tree?.sound?.skills)) {
+    return {
+      skills: normalizeNameList(tree.soundPlantSkills || tree.sound?.skills),
+      agents: normalizeNameList(tree.soundPlantAgents || tree.sound?.agents),
+    };
+  }
+  const kinds = Array.isArray(tree?.plantKinds) ? tree.plantKinds : loadFactoryPlantKinds(targetDir);
+  return kinds.includes("sound") ? catalogPlant("sound") : emptyPlantFiles();
+}
+
+function blipPlantFromTree(targetDir, tree) {
+  if (Array.isArray(tree?.blipPlantSkills) || Array.isArray(tree?.blip?.skills)) {
+    return {
+      skills: normalizeNameList(tree.blipPlantSkills || tree.blip?.skills),
+      agents: normalizeNameList(tree.blipPlantAgents || tree.blip?.agents),
+    };
+  }
+  const kinds = Array.isArray(tree?.plantKinds) ? tree.plantKinds : loadFactoryPlantKinds(targetDir);
+  return kinds.includes("blip") ? catalogPlant("blip") : emptyPlantFiles();
+}
+
+/** Extra worn names that are neither mill/sound/blip plant, their plant, shop plant, nor a prior overlay. */
 function costumeDumpExtras(targetDir, millPlant, tree) {
   const prior = previousTreeAllowlist(targetDir);
   const shopPlant = loadShopPlant(targetDir);
+  const soundPlant = soundPlantFromTree(targetDir, tree);
+  const blipPlant = blipPlantFromTree(targetDir, tree);
   const allowedSkills = new Set([
     ...(Array.isArray(millPlant?.skills) ? millPlant.skills : []),
+    ...(Array.isArray(millPlant?.sound?.skills) ? millPlant.sound.skills : []),
+    ...(Array.isArray(millPlant?.blip?.skills) ? millPlant.blip.skills : []),
+    ...soundPlant.skills,
+    ...blipPlant.skills,
     ...(Array.isArray(tree?.skills) ? tree.skills : []),
     ...prior.skills,
     ...shopPlant,
   ]);
   const allowedAgents = new Set([
     ...(Array.isArray(millPlant?.agents) ? millPlant.agents : []),
+    ...(Array.isArray(millPlant?.sound?.agents) ? millPlant.sound.agents : []),
+    ...(Array.isArray(millPlant?.blip?.agents) ? millPlant.blip.agents : []),
+    ...soundPlant.agents,
+    ...blipPlant.agents,
     ...(Array.isArray(tree?.agents) ? tree.agents : []),
     ...prior.agents,
   ]);
@@ -482,10 +651,19 @@ function mintConsumerFromSsot(packageRoot, targetDir, log, tree) {
   const millPlanted =
     (Array.isArray(tree?.millPlantSkills) && tree.millPlantSkills.length > 0) ||
     (Array.isArray(tree?.millPlantAgents) && tree.millPlantAgents.length > 0);
+  const soundPlanted =
+    (Array.isArray(tree?.soundPlantSkills) && tree.soundPlantSkills.length > 0) ||
+    (Array.isArray(tree?.soundPlantAgents) && tree.soundPlantAgents.length > 0);
+  const blipPlanted =
+    (Array.isArray(tree?.blipPlantSkills) && tree.blipPlantSkills.length > 0) ||
+    (Array.isArray(tree?.blipPlantAgents) && tree.blipPlantAgents.length > 0);
+  const plantKinds = Array.isArray(tree?.plantKinds) && tree.plantKinds.length > 0
+    ? tree.plantKinds
+    : loadFactoryPlantKinds(targetDir);
   const costume = wantsCostume(targetDir);
   const suit = overlayed
     ? "overlay"
-    : millPlanted
+    : millPlanted || soundPlanted || blipPlanted
       ? "fastened"
       : costume
         ? "costume"
@@ -494,12 +672,21 @@ function mintConsumerFromSsot(packageRoot, targetDir, log, tree) {
     mill: { name: mill.name || "@0xray/foundry", version: mill.version },
     consumer: { name: consumer.name, version: consumer.version },
     suit,
+    plant: plantKinds,
     params: tree?.params || loadFoundryParams(targetDir),
     tree: { skills, agents },
     millPlant: {
       skills: Array.isArray(tree?.millPlantSkills) ? tree.millPlantSkills : [],
       agents: Array.isArray(tree?.millPlantAgents) ? tree.millPlantAgents : [],
     },
+    soundPlant: {
+      skills: Array.isArray(tree?.soundPlantSkills) ? tree.soundPlantSkills : [],
+      agents: Array.isArray(tree?.soundPlantAgents) ? tree.soundPlantAgents : [],
+    },
+    blipPlant: {
+      skills: Array.isArray(tree?.blipPlantSkills) ? tree.blipPlantSkills : [],
+      agents: Array.isArray(tree?.blipPlantAgents) ? tree.blipPlantAgents : [],
+    },
     shopPlant: {
       skills: Array.isArray(tree?.shopPlantSkills) ? tree.shopPlantSkills : loadShopPlant(targetDir),
     },
@@ -539,8 +726,15 @@ function mintConsumerSuit(millPackageRoot, targetDir, log) {
   const params = loadFoundryParams(targetDir);
   const millPlant = fastenMillPlant(millPackageRoot, targetDir, log);
   const tree = overlayConsumerTree(targetDir, log, params);
+  tree.plantKinds = millPlant.kinds || loadFactoryPlantKinds(targetDir);
   tree.millPlantSkills = millPlant.skills;
   tree.millPlantAgents = millPlant.agents;
+  tree.soundPlantSkills = millPlant.sound?.skills || [];
+  tree.soundPlantAgents = millPlant.sound?.agents || [];
+  tree.sound = millPlant.sound || emptyPlantFiles();
+  tree.blipPlantSkills = millPlant.blip?.skills || [];
+  tree.blipPlantAgents = millPlant.blip?.agents || [];
+  tree.blip = millPlant.blip || emptyPlantFiles();
   tree.shopPlantSkills = loadShopPlant(targetDir);
   tree.codex = overlayJsonFacet(
     resolveInside(targetDir, params.codex),
@@ -569,6 +763,8 @@ function mintConsumerSuit(millPackageRoot, targetDir, log) {
 module.exports = {
   DEFAULT_PARAMS,
   FACTORY_SHOP_SKILLS,
+  FACTORY_PLANT_CATALOG,
+  isFactoryPlantKind,
   deepMerge,
   loadFoundryParams,
   loadFoundryExtra,
@@ -576,6 +772,11 @@ module.exports = {
   declaredShopPlant,
   wantsCostume,
   millPlantDir,
+  loadFactoryPlantKinds,
+  factoryPlantAllowlist,
+  inventoryPlantKinds,
+  catalogPlant,
+  unionPlantFiles,
   listSkillNamesAt,
   listAgentFilesAt,
   fastenMillPlant,