0xray 4.0.3 → 4.0.5

package/.xray/features.json

@@ -1,6 +1,6 @@
 {
   "$schema": "./features.schema.json",
-  "version": "4.0.3",
+  "version": "4.0.1",
   "description": "0xRay Framework - Unified Feature Configuration",
   "suit_temperament": {
     "profile": "auto",

package/AGENTS-consumer.md

@@ -19,7 +19,7 @@ Before other work, Read `.xray/state/STATION.md`. Compaction and host change are
 `npm install 0xray` runs `install-bridges.cjs` and:
 
 - Copies this file → **`AGENTS.md`** in your project root
-- Mill plant (`mill` skill) onto hangers, then overlays **your** `src/skills` (same name wins). Does **not** dump 45/42 costume unless `foundry.json` `"costume": true`. Does **not** write root **`SKILLS.md`**
+- Fastens mill plant (`mill` + `inspect`) then overlays **your** `src/skills` (same name wins). `npx @0xray/foundry inspect` runs the mill checks (chat is not a receipt). Does **not** dump 45/42 costume unless `foundry.json` `"costume": true`. Does **not** write root **`SKILLS.md`**
 - Seeds **`.gitignore`** (from template, if absent)
 - Deploys **`.xray/`** (`codex.json`, `features.json`, `config.json`) then overlays **your** mill SSOT (`xray/codex.json`, `xray/features.json`, `src/skills`, `src/opencode/agents`; remap with `foundry.json`)
 - Writes **`.mcp.json`** with 7 MCPs servers (`npx -y 0xray mcp …`)
@@ -58,6 +58,7 @@ Governance deliberation uses **code-review**, **security-audit** (via enforcer/s
 | `npx 0xray codex check` | Check codex rules |
 | `npx 0xray health` | Framework health check |
 | `npx 0xray mcp <server>` | Start an MCP server (stdio) |
+| `npx @0xray/foundry inspect` | Mill inspect (nested mill). Chat is not a receipt. |
 
 ## Governance
 

package/dist/CHANGELOG.md

@@ -27,6 +27,22 @@ The format is based on [Conventional Commits](https://www.conventionalcommits.or
 - Published mill `hooks` uses the 0xray garment installer (`node_modules/0xray/scripts/hooks`), not `node_modules/@0xray/hooks`. Mill tree 0.1.4 (not a 0xray bump).
 - Nested mill in the 0xray tarball (`scripts/foundry/`). Wear no longer needs a second `npm i @0xray/foundry` for mint-on-install. 4.0.2.
 - Empty garment: mill plant (`mill` skill) is the hanger. Not 45/42 costume unless `foundry.json` `"costume": true`. Mill 0.1.5.
+- Mill plant fastens **inspect** (inspect AI work) plus `mill`. Not empty. Mill 0.1.6.
+- Nested mill **0.1.7**: inspect organ, four floors, passwd HOME, mill CI receipt. 4.0.5.
+
+---
+
+## [4.0.5] - 2026-09-04
+
+Nested mill **0.1.7**. Inspect is a mill command (`npx @0xray/foundry inspect`): costume dump fails mint, live PUT GETs the `.tgz`, four project floors, mill CI receipt, passwd HOME isolation. Mill plant stays `mill` + `inspect`. Not 45/42 costume. Not 5.0.0.
+
+---
+
+## [4.0.4] - 2026-09-04
+
+Mill **fastens** an inspect suit: mill plant is `mill` + `inspect` (inspect AI work — diffs, traces, mill receipts, CI). Not empty. Not 45/42 costume unless `foundry.json` `"costume": true`. Factory Repertoire + PPE stay. Mill **0.1.6**. Not 5.0.0.
+
+Naming: inventory `suit` (`fastened` / `overlay` / `costume`). Not garment. Not hanger. Costume is the 45/42 dump flag only.
 
 ---
 

package/dist/cli/commands/opencode-install.js

@@ -111,7 +111,7 @@ async function installForOpencode(options = {}) {
             }
             else {
                 fs.mkdirSync(opencodeDest, { recursive: true });
-                frameworkLogger.log('opencode-integration', 'empty-garment-plugin', 'info', { destination: opencodeDest });
+                frameworkLogger.log('opencode-integration', 'mill-plant-plugin', 'info', { destination: opencodeDest });
             }
             const pluginSource = path.join(__dirname, '..', '..', '..', 'dist', 'plugin', 'xray-codex-injection.js');
             const pluginDest = path.join(opencodeDest, 'plugin', 'xray-codex-injection.js');

package/dist/integrations/grok/grok-cli.js

@@ -50,8 +50,18 @@ function registerGrokMcpServers(targetDir) {
 }
 export async function installForGrokCLI(options = {}) {
     frameworkLogger.log('grok-integration', 'install-start', 'info', { options });
+    const millSuit = requireCjs(path.join(packageRoot, 'scripts/foundry/mint-suit.cjs'));
     const home = process.env.HOME || process.env.USERPROFILE || '';
+    const machine = millSuit.machineHome();
     const targetPluginDir = path.join(home, '.grok/plugins/0xray');
+    if (millSuit.wouldClobberMachineGrok(targetPluginDir, process.env, machine)) {
+        frameworkLogger.log('grok-integration', 'refuse-machine-grok-clobber', 'error', {
+            home,
+            machineHome: machine,
+            targetPluginDir,
+        });
+        throw new Error('foundry-inspect: isolated HOME must not clobber ~/.grok/plugins/0xray');
+    }
     // Try to find the plugin source from the installed package
     const possibleSources = [
         path.join(__dirname, '..', '..', '..', 'src/integrations/grok/plugin/0xray'), // dev

package/dist/integrations/openclaw/plugin/xray-pre-tool/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xray-pre-tool",
-  "version": "4.0.3",
+  "version": "4.0.4",
   "private": true,
   "type": "module",
   "description": "0xRay constitution + temperament PreToolUse for OpenClaw",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "4.0.3",
+  "version": "4.0.5",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",

package/scripts/foundry/CHANGELOG.md

@@ -1,12 +1,22 @@
 # Changelog
 
+## [0.1.7] - 2026-09-04
+
+Inspect is mill flesh: `npx @0xray/foundry inspect` runs diff, plant vs worn (mint fails costume dump), mill receipt, CI, GET the `.tgz` (HTTP 200), isolated HOME vs passwd home. Four project skill floors created on fasten (OpenCode, Grok, Hermes, OpenClaw). CI report is `.xray/foundry-ci-report.json`. Not an 8th MCP. Not 5.0.
+
+## [0.1.6] - 2026-09-04
+
+Mill plant fastens an **inspect** suit: inspect AI work (diffs, traces, mill receipts, CI). Not empty. `mill` + `inspect` skills. Costume dump still opt-in.
+
+Inventory field is `suit` (`fastened` / `overlay` / `costume` / `dogfood`). Not `garment`. `foundry.json` `"costume": true` is the 45/42 dump.
+
 ## [0.1.5] - 2026-09-04
 
-Empty garment: consumer hangers get mill plant (`plant/skills/mill`), not 45/42 costume. `foundry.json` `"costume": true` restores the dump. Plant overlay still mill-fill.
+Mill plant (`plant/skills/mill`) fastened by default, not 45/42 costume. `foundry.json` `"costume": true` restores the dump. Plant overlay still mill-fill.
 
 ## [0.1.4] - 2026-09-04
 
-`npx @0xray/foundry hooks` on a published mill uses the worn garment
+`npx @0xray/foundry hooks` on a published mill uses the worn 0xray installer
 `node_modules/0xray/scripts/hooks/install-hooks.cjs`. Dogfood still uses
 `scripts/hooks` next to `scripts/foundry`. Missing installer fails honestly
 (no spawn of `node_modules/@0xray/hooks/...`).

package/scripts/foundry/README.md

@@ -2,7 +2,7 @@
 
 The **mill**, not the worn exo. Reconcile, stamp JSON/CHANGELOG, verify docs, gate, publish, overlay their suit params.
 
-PPE (`evaluatePreToolGate`) stays worn. The mill plants **their** constitution, features, skills, and agents onto the hanger. It is not a fifth MCP. The suit is [`0xray`](https://www.npmjs.com/package/0xray).
+PPE (`evaluatePreToolGate`) stays worn. The mill **fastens** their constitution, features, skills, and agents as the suit. It is not a fifth MCP. The suit is [`0xray`](https://www.npmjs.com/package/0xray).
 
 ## Install
 
@@ -23,6 +23,7 @@ npx @0xray/foundry release [patch|minor|major] --i-mean-it
 npx @0xray/foundry release --publish-only --dry-run
 npx @0xray/foundry release --publish-only --i-mean-it
 npx @0xray/foundry mint
+npx @0xray/foundry inspect [--skip-live]
 npx @0xray/foundry ci [--commit SHA] [--report]
 npx @0xray/foundry hooks
 ```
@@ -31,28 +32,28 @@ npx @0xray/foundry hooks
 
 `FOUNDRY_ROOT` overrides cwd (the repo being milled).
 
-`gate` is build + test + docs-check. `docs-build` runs Docusaurus on the 0xray exo (`docs-site/`); stranger mills skip. `ci` reports GitHub Actions (no auto-push). `hooks` installs git pre/post hooks. GitHub `0xRay CI/CD` is the mill gate on `main`. `Deploy Docs` is the mill Pages put.
+`gate` is build + test + docs-check. `docs-build` runs Docusaurus on the 0xray exo (`docs-site/`); stranger mills skip. `inspect` runs the six mill checks (diff, plant vs worn, receipt, CI, live tarball GET, isolated HOME). Mint fails on a costume dump. Isolated HOME skips machine `~/.grok`. `ci` reports GitHub Actions (no auto-push). `hooks` installs git pre/post hooks. GitHub `0xRay CI/CD` is the mill gate on `main`. `Deploy Docs` is the mill Pages put.
 
 `docs-check` and `gate` run **full** 0xRay corpus only when the milled `package.json` name is `0xray` and `docs-site/` exists. Otherwise **light**: `package.json` + CHANGELOG.
 
-`hooks` installs git hooks via `scripts/hooks/install-hooks.cjs` (dogfood) or `node_modules/0xray/scripts/hooks/install-hooks.cjs` (published mill + worn garment). It does not look for `@0xray/hooks`.
+`hooks` installs git hooks via `scripts/hooks/install-hooks.cjs` (dogfood) or `node_modules/0xray/scripts/hooks/install-hooks.cjs` (published mill + worn suit). It does not look for `@0xray/hooks`.
 
 ## Suit params (`mint`)
 
-After the garment is on the hanger, overlay their plant (defaults; remap in `foundry.json` or `.xray/foundry.json`):
+After mill plant is fastened, overlay their plant (defaults; remap in `foundry.json` or `.xray/foundry.json`):
 
-| Facet | Default plant | Hanger |
+| Facet | Default plant | Worn |
 |---|---|---|
 | Constitution | `xray/codex.json` | `.xray/codex.json` |
 | Features / temperament | `xray/features.json` | `.xray/features.json` |
 | Config | `xray/config.json` | `.xray/config.json` |
-| Skills | `src/skills/<name>/SKILL.md` | `.opencode/skills/` and project `.grok/plugins/0xray/skills` if that dir exists |
-| Agents | `src/opencode/agents/*.yml` | `.opencode/agents/` (OpenCode hangar; other floors do not read mill YML agents) |
+| Skills | `src/skills/<name>/SKILL.md` | project `.opencode/skills`, `.grok/plugins/0xray/skills`, `.hermes/plugins/xray-hermes/skills`, `.openclaw/skills` (created on fasten; never machine home) |
+| Agents | `src/opencode/agents/*.yml` | `.opencode/agents/` (OpenCode wear dir; other floors do not read mill YML agents) |
 | Agents card | `xray/AGENTS.md` | `AGENTS.md` if mill-managed |
 
-**Mill-fill is law:** their keys/files win; mill names they did not plant stay unless they overlay the same name. JSON facets always merge. Skill overlay is project hangers only. CLI re-wear calls mint **once** after mill copies.
+**Mill-fill is law:** their keys/files win; mill names they did not plant stay unless they overlay the same name. JSON facets always merge. Skill overlay is project dirs on every TUI floor (OpenCode, Grok, Hermes, OpenClaw). YML agents stay OpenCode. CLI re-wear calls mint **once** after mill copies. Isolated HOME is passwd home, not `os.homedir()`. CI report is `.xray/foundry-ci-report.json` (`.opencode/logs` shim).
 
-**Empty garment (default):** mill plant (`plant/skills/mill`) is the hanger. Not 45 skills / 42 agents. `foundry.json` `"costume": true` copies that mill garment. Factory Repertoire still enable-when-resolves. PPE stays worn.
+**Default mill plant:** `mill` + `inspect` (inspect AI work). Fastens a suit, not an empty one. Not 45/42 costume. `foundry.json` `"costume": true` copies that dump. Factory Repertoire still enable-when-resolves. PPE stays worn.
 
 ## Publish this mill
 

package/scripts/foundry/ci-monitor.mjs

@@ -16,11 +16,15 @@ 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");
+const millReportPath = path.join(root, ".xray", "foundry-ci-report.json");
+const shimReportPath = 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`);
+  const body = `${JSON.stringify(report, null, 2)}\n`;
+  for (const reportPath of [millReportPath, shimReportPath]) {
+    fs.mkdirSync(path.dirname(reportPath), { recursive: true });
+    fs.writeFileSync(reportPath, body);
+  }
 }
 
 function emptyReport(status, reason) {

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|ci|hooks> [...args]
+ *   npx @0xray/foundry <reconcile|stamp|gate|release|docs-check|docs-build|mint|inspect|ci|hooks> [...args]
  */
 
 import { spawnSync } from "node:child_process";
@@ -16,16 +16,18 @@ const COMMANDS = {
   "docs-check": { script: "validate-release-docs.mjs", preset: [] },
   "docs-build": { script: "docs-build.mjs", preset: [] },
   mint: { script: "mint.mjs", preset: [] },
+  inspect: { script: "inspect.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" +
+  "Usage: npx @0xray/foundry <reconcile|stamp|gate|release|docs-check|docs-build|mint|inspect|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" +
+  "Mint fastens mill plant then overlays their plant (mill-fill JSON). 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" +
   "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

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+/**
+ * Mill inspect organ. Runs the six checks. Not an 8th MCP. Not PPE.
+ *
+ *   npx @0xray/foundry inspect [--skip-live]
+ */
+
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { millPackageDir, resolveMillRoot } from "./mill-root.mjs";
+
+const require = createRequire(import.meta.url);
+const mint = require("./mint-suit.cjs");
+
+export function npmTarballUrl(name, version) {
+  if (typeof name !== "string" || !name || typeof version !== "string" || !version) return null;
+  if (name.startsWith("@")) {
+    const slash = name.indexOf("/");
+    if (slash < 1) return null;
+    const pkg = name.slice(slash + 1);
+    return `https://registry.npmjs.org/${name}/-/${pkg}-${version}.tgz`;
+  }
+  return `https://registry.npmjs.org/${name}/-/${name}-${version}.tgz`;
+}
+
+export function isIsolatedHome(env = process.env, machine = mint.machineHome()) {
+  return mint.isIsolatedHome(env, machine);
+}
+
+export function machineGrokPluginDir(machine = mint.machineHome()) {
+  return mint.machineGrokPluginDir(machine);
+}
+
+export function wouldClobberMachineGrok(
+  dest,
+  env = process.env,
+  machine = mint.machineHome(),
+) {
+  return mint.wouldClobberMachineGrok(dest, env, machine);
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function checkDiff(root) {
+  const status = spawnSync("git", ["status", "-sb"], { cwd: root, encoding: "utf8" });
+  if (status.error || status.status === 128) {
+    return {
+      id: "diff",
+      ok: true,
+      skipped: true,
+      detail: status.stderr?.trim() || "not a git repo",
+    };
+  }
+  const diff = spawnSync("git", ["diff", "--stat"], { cwd: root, encoding: "utf8" });
+  return {
+    id: "diff",
+    ok: true,
+    status: (status.stdout || "").trim(),
+    diffStat: (diff.stdout || "").trim(),
+  };
+}
+
+function checkPlantVsWorn(root, millRoot) {
+  const plantDir = mint.millPlantDir(millRoot);
+  const millPlant = {
+    skills: plantDir ? mint.listSkillNamesAt(path.join(plantDir, "skills")) : [],
+    agents: plantDir ? mint.listAgentFilesAt(path.join(plantDir, "agents")) : [],
+  };
+  const params = mint.loadFoundryParams(root);
+  const tree = {
+    skills: mint.listConsumerSkillNames(root, params.skills),
+    agents: mint.listConsumerAgentFiles(root, params.agents),
+  };
+  try {
+    mint.assertNoCostumeDump(root, millPlant, tree);
+    return {
+      id: "plant-vs-worn",
+      ok: true,
+      millPlant: millPlant.skills,
+      tree: tree.skills,
+      worn: mint.wornSkillNames(root),
+    };
+  } catch (err) {
+    return {
+      id: "plant-vs-worn",
+      ok: false,
+      detail: err instanceof Error ? err.message : String(err),
+      extraSkills: err.extraSkills || [],
+      extraAgents: err.extraAgents || [],
+    };
+  }
+}
+
+function checkReceipt(root) {
+  const file = path.join(root, ".xray", "foundry-inventory.json");
+  if (mint.isDogfood(millPackageDir(), root)) {
+    return { id: "receipt", ok: true, skipped: true, detail: "dogfood / exo — no consumer inventory" };
+  }
+  const inventory = readJson(file);
+  if (!inventory) {
+    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;
+  return {
+    id: "receipt",
+    ok,
+    suit: inventory.suit,
+    mill: inventory.mill,
+    millPlant: millPlantSkills,
+    detail: ok ? null : "millPlant.skills must include mill and inspect",
+  };
+}
+
+function checkCi(root) {
+  const millPath = path.join(root, ".xray", "foundry-ci-report.json");
+  const shimPath = path.join(root, ".opencode", "logs", "ci-cd-monitor-report.json");
+  const report = readJson(millPath) || readJson(shimPath);
+  if (!report) {
+    return {
+      id: "ci",
+      ok: true,
+      skipped: true,
+      detail: "no mill ci report — run npx @0xray/foundry ci --report",
+    };
+  }
+  const status = String(report.ci_status || "");
+  if (status === "failure" || status === "unhealthy") {
+    return { id: "ci", ok: false, status, reason: report.reason || null };
+  }
+  return {
+    id: "ci",
+    ok: true,
+    skipped: status === "unknown",
+    status,
+    reason: report.reason || null,
+  };
+}
+
+export async function checkLivePut(packages, fetchFn = fetch) {
+  const results = [];
+  for (const pkg of packages) {
+    const url = npmTarballUrl(pkg.name, pkg.version);
+    if (!url) {
+      results.push({ name: pkg.name, version: pkg.version, ok: false, detail: "missing name/version" });
+      continue;
+    }
+    let status = 0;
+    try {
+      const head = await fetchFn(url, { method: "HEAD" });
+      status = head.status;
+      if (status === 405 || status === 501) {
+        const get = await fetchFn(url, { method: "GET" });
+        status = get.status;
+      }
+    } catch (err) {
+      results.push({
+        name: pkg.name,
+        version: pkg.version,
+        url,
+        ok: false,
+        detail: err instanceof Error ? err.message : String(err),
+      });
+      continue;
+    }
+    results.push({ name: pkg.name, version: pkg.version, url, status, ok: status === 200 });
+  }
+  return results;
+}
+
+function packagesToProbe(root) {
+  const pkgs = [];
+  const inventory = readJson(path.join(root, ".xray", "foundry-inventory.json"));
+  if (inventory?.mill?.name && inventory?.mill?.version) {
+    pkgs.push({ name: inventory.mill.name, version: inventory.mill.version });
+  }
+  const worn = readJson(path.join(root, "node_modules", "0xray", "package.json"));
+  if (worn?.name && worn?.version) {
+    pkgs.push({ name: worn.name, version: worn.version });
+  }
+  const self = readJson(path.join(root, "package.json"));
+  if (self?.name === "0xray" && self?.version) {
+    pkgs.push({ name: "0xray", version: self.version });
+  }
+  const seen = new Set();
+  return pkgs.filter((p) => {
+    const key = `${p.name}@${p.version}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function checkIsolatedHome(env = process.env, machine = mint.machineHome()) {
+  const isolated = isIsolatedHome(env, machine);
+  const machinePlugin = machineGrokPluginDir(machine);
+  const home = env.HOME || env.USERPROFILE || "";
+  const dest = home ? path.join(home, ".grok", "plugins", "0xray") : "";
+  const clobber = wouldClobberMachineGrok(dest, env, machine);
+  if (clobber) {
+    return {
+      id: "isolated-home",
+      ok: false,
+      isolated,
+      detail: `isolated HOME must not write ${machinePlugin}`,
+    };
+  }
+  return {
+    id: "isolated-home",
+    ok: true,
+    isolated,
+    machinePlugin,
+    dest: dest || null,
+  };
+}
+
+export async function inspectSuit(root, opts = {}) {
+  const millRoot = opts.millRoot || millPackageDir();
+  const fetchFn = opts.fetch || fetch;
+  const skipLive = Boolean(opts.skipLive);
+  const env = opts.env || process.env;
+  const machineHome = opts.machineHome || mint.machineHome();
+
+  const checks = [];
+  checks.push(checkDiff(root));
+  checks.push(checkPlantVsWorn(root, millRoot));
+  checks.push(checkReceipt(root));
+  checks.push(checkCi(root));
+
+  if (skipLive) {
+    checks.push({ id: "live-put", ok: true, skipped: true, detail: "--skip-live" });
+  } else {
+    const pkgs = packagesToProbe(root);
+    if (pkgs.length === 0) {
+      checks.push({
+        id: "live-put",
+        ok: true,
+        skipped: true,
+        detail: "no mill/0xray package identity to GET",
+      });
+    } else {
+      const puts = await checkLivePut(pkgs, fetchFn);
+      checks.push({
+        id: "live-put",
+        ok: puts.every((p) => p.ok),
+        packages: puts,
+      });
+    }
+  }
+
+  checks.push(checkIsolatedHome(env, machineHome));
+
+  const failed = checks.filter((c) => c.ok === false);
+  return {
+    ok: failed.length === 0,
+    failed: failed.map((c) => c.id),
+    checks,
+  };
+}
+
+async function main() {
+  const skipLive = process.argv.includes("--skip-live");
+  const root = resolveMillRoot();
+  const report = await inspectSuit(root, { skipLive });
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  process.exit(report.ok ? 0 : 1);
+}
+
+const isMain =
+  process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  main();
+}

package/scripts/foundry/mill-root.mjs

@@ -24,7 +24,7 @@ export function resolveMillRoot() {
 /**
  * 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.
+ * does not exist. Use the worn 0xray installer instead.
  */
 export function resolveHookInstaller(rootDir = resolveMillRoot(), millPkg = millPackageDir()) {
   const candidates = [

package/scripts/foundry/mint-suit.cjs

@@ -1,5 +1,5 @@
 /**
- * Mill overlay: their plant onto the hanger. Not PPE (evaluatePreToolGate).
+ * Mill overlay: fasten their plant as the suit. Not PPE (evaluatePreToolGate).
  *
  * Default SSOT (override with foundry.json or .xray/foundry.json):
  *   xray/codex.json, xray/features.json, xray/config.json,
@@ -7,6 +7,7 @@
  */
 
 const fs = require("fs");
+const os = require("os");
 const path = require("path");
 
 const DEFAULT_PARAMS = {
@@ -135,20 +136,20 @@ function listAgentFilesAt(agentsSrc) {
     .map((entry) => entry.name);
 }
 
-/** Mill mill-fill mill plant: mill mill mill mill-fill mill names they did not plant stay. */
-function millFillMillPlant(millPackageRoot, targetDir, log) {
+/** 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: [] };
   const skillsSrc = path.join(plant, "skills");
   const agentsSrc = path.join(plant, "agents");
   const skills = listSkillNamesAt(skillsSrc);
   const agents = listAgentFilesAt(agentsSrc);
-  const skillHangers = listSkillHangers(targetDir);
+  const skillDirs = listProjectSkillDirs(targetDir);
   const agentsDest = path.join(targetDir, ".opencode", "agents");
-  for (const hanger of skillHangers) {
+  for (const dir of skillDirs) {
     for (const name of skills) {
       const src = path.join(skillsSrc, name, "SKILL.md");
-      const destMd = path.join(hanger, name, "SKILL.md");
+      const destMd = path.join(dir, name, "SKILL.md");
       if (path.resolve(src) === path.resolve(destMd)) continue;
       if (fs.existsSync(destMd)) continue;
       fs.mkdirSync(path.dirname(destMd), { recursive: true });
@@ -164,7 +165,7 @@ function millFillMillPlant(millPackageRoot, targetDir, log) {
     fs.copyFileSync(src, dest);
   }
   if (log && (skills.length > 0 || agents.length > 0)) {
-    log("foundry-mint", "Mill plant onto hangers", "info", {
+    log("foundry-mint", "Fastened mill plant", "info", {
       skills: skills.length,
       agents: agents.length,
     });
@@ -180,12 +181,57 @@ function isDirectory(p) {
   }
 }
 
-/** 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;
+/** Passwd home. `os.homedir()` follows $HOME and cannot detect last-mile isolation. */
+function machineHome() {
+  try {
+    const passwd = os.userInfo().homedir;
+    if (typeof passwd === "string" && passwd) return passwd;
+  } catch {
+    /* no passwd */
+  }
+  return os.homedir();
+}
+
+function processHome(env) {
+  const e = env || process.env;
+  return e.HOME || e.USERPROFILE || "";
+}
+
+function isIsolatedHome(env, machine) {
+  const home = processHome(env);
+  if (!home) return false;
+  const real = machine || machineHome();
+  try {
+    return path.resolve(home) !== path.resolve(real);
+  } catch {
+    return false;
+  }
+}
+
+function machineGrokPluginDir(machine) {
+  return path.join(machine || machineHome(), ".grok", "plugins", "0xray");
+}
+
+function wouldClobberMachineGrok(dest, env, machine) {
+  if (!dest) return false;
+  const realMachine = machine || machineHome();
+  if (!isIsolatedHome(env, realMachine)) return false;
+  const real = path.resolve(machineGrokPluginDir(realMachine));
+  const target = path.resolve(dest);
+  return target === real || target.startsWith(`${real}${path.sep}`);
+}
+
+/**
+ * Project skill dirs on every TUI floor. Create on fasten. Never machine home.
+ * YML agents stay OpenCode (`.opencode/agents`).
+ */
+function listProjectSkillDirs(targetDir) {
+  return [
+    path.join(targetDir, ".opencode", "skills"),
+    path.join(targetDir, ".grok", "plugins", "0xray", "skills"),
+    path.join(targetDir, ".hermes", "plugins", "xray-hermes", "skills"),
+    path.join(targetDir, ".openclaw", "skills"),
+  ];
 }
 
 function overlayJsonFacet(src, dest) {
@@ -238,6 +284,69 @@ function overlayAgentsCard(targetDir, params) {
   return true;
 }
 
+function wornSkillNames(targetDir) {
+  const names = new Set();
+  for (const dir of listProjectSkillDirs(targetDir)) {
+    for (const name of listSkillNamesAt(dir)) names.add(name);
+  }
+  return [...names];
+}
+
+function wornAgentFiles(targetDir) {
+  return listAgentFilesAt(path.join(targetDir, ".opencode", "agents"));
+}
+
+function previousTreeAllowlist(targetDir) {
+  const file = path.join(targetDir, ".xray", "foundry-inventory.json");
+  if (!fs.existsSync(file)) return { skills: [], agents: [] };
+  try {
+    const inventory = JSON.parse(fs.readFileSync(file, "utf8"));
+    return {
+      skills: Array.isArray(inventory?.tree?.skills) ? inventory.tree.skills : [],
+      agents: Array.isArray(inventory?.tree?.agents) ? inventory.tree.agents : [],
+    };
+  } catch {
+    return { skills: [], agents: [] };
+  }
+}
+
+/** Extra worn names that are neither mill plant, their plant, nor a prior overlay. */
+function costumeDumpExtras(targetDir, millPlant, tree) {
+  const prior = previousTreeAllowlist(targetDir);
+  const allowedSkills = new Set([
+    ...(Array.isArray(millPlant?.skills) ? millPlant.skills : []),
+    ...(Array.isArray(tree?.skills) ? tree.skills : []),
+    ...prior.skills,
+  ]);
+  const allowedAgents = new Set([
+    ...(Array.isArray(millPlant?.agents) ? millPlant.agents : []),
+    ...(Array.isArray(tree?.agents) ? tree.agents : []),
+    ...prior.agents,
+  ]);
+  return {
+    extraSkills: wornSkillNames(targetDir).filter((name) => !allowedSkills.has(name)),
+    extraAgents: wornAgentFiles(targetDir).filter((name) => !allowedAgents.has(name)),
+  };
+}
+
+function assertNoCostumeDump(targetDir, millPlant, tree) {
+  if (wantsCostume(targetDir)) {
+    return { ok: true, extraSkills: [], extraAgents: [] };
+  }
+  const extras = costumeDumpExtras(targetDir, millPlant, tree);
+  if (extras.extraSkills.length > 0 || extras.extraAgents.length > 0) {
+    const listed = [...extras.extraSkills, ...extras.extraAgents].join(", ");
+    const err = new Error(
+      `foundry-inspect: costume dump without foundry.json "costume": true (${listed})`,
+    );
+    err.code = "FOUNDRY_COSTUME_DUMP";
+    err.extraSkills = extras.extraSkills;
+    err.extraAgents = extras.extraAgents;
+    throw err;
+  }
+  return { ok: true, extraSkills: [], extraAgents: [] };
+}
+
 function overlayConsumerTree(targetDir, log, params) {
   const resolved = params || loadFoundryParams(targetDir);
   const skillsRel = resolved.skills;
@@ -246,13 +355,13 @@ function overlayConsumerTree(targetDir, log, params) {
   const agents = listConsumerAgentFiles(targetDir, agentsRel);
   const skillsSrc = resolveInside(targetDir, skillsRel);
   const agentsSrc = resolveInside(targetDir, agentsRel);
-  const skillHangers = listSkillHangers(targetDir);
+  const skillDirs = listProjectSkillDirs(targetDir);
   const agentsDest = path.join(targetDir, ".opencode", "agents");
 
-  for (const hanger of skillHangers) {
+  for (const dir of skillDirs) {
     for (const name of skills) {
       const src = path.join(skillsSrc, name, "SKILL.md");
-      const destMd = path.join(hanger, name, "SKILL.md");
+      const destMd = path.join(dir, name, "SKILL.md");
       if (path.resolve(src) === path.resolve(destMd)) continue;
       fs.mkdirSync(path.dirname(destMd), { recursive: true });
       fs.copyFileSync(src, destMd);
@@ -267,10 +376,10 @@ function overlayConsumerTree(targetDir, log, params) {
   }
 
   if (log && (skills.length > 0 || agents.length > 0)) {
-    log("foundry-mint", "Overlaid consumer skills/agents onto hangers", "info", {
+    log("foundry-mint", "Overlaid consumer skills/agents", "info", {
       skills: skills.length,
       agents: agents.length,
-      skillHangers: skillHangers.length,
+      skillDirs: skillDirs.length,
     });
   }
   return { skills, agents, params: resolved };
@@ -278,7 +387,7 @@ function overlayConsumerTree(targetDir, log, params) {
 
 function mintConsumerFromSsot(packageRoot, targetDir, log, tree) {
   if (isDogfood(packageRoot, targetDir)) {
-    return { garment: "dogfood", skipped: true, consumer: readPackageIdentity(path.join(targetDir, "package.json")) };
+    return { suit: "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"));
@@ -299,17 +408,17 @@ function mintConsumerFromSsot(packageRoot, targetDir, log, tree) {
     (Array.isArray(tree?.millPlantSkills) && tree.millPlantSkills.length > 0) ||
     (Array.isArray(tree?.millPlantAgents) && tree.millPlantAgents.length > 0);
   const costume = wantsCostume(targetDir);
-  const garment = overlayed
+  const suit = overlayed
     ? "overlay"
     : millPlanted
-      ? "mill-fill"
+      ? "fastened"
       : costume
-        ? "copied-onto-hanger"
-        : "mill-fill";
+        ? "costume"
+        : "fastened";
   const inventory = {
     mill: { name: mill.name || "@0xray/foundry", version: mill.version },
     consumer: { name: consumer.name, version: consumer.version },
-    garment,
+    suit,
     params: tree?.params || loadFoundryParams(targetDir),
     tree: { skills, agents },
     millPlant: {
@@ -337,7 +446,7 @@ function mintConsumerFromSsot(packageRoot, targetDir, log, tree) {
     log("foundry-mint", "Minted foundry-inventory from consumer mill SSOT", "info", {
       consumer: consumer.name,
       version: consumer.version,
-      garment,
+      suit,
     });
   }
   return inventory;
@@ -345,10 +454,10 @@ function mintConsumerFromSsot(packageRoot, targetDir, log, tree) {
 
 function mintConsumerSuit(millPackageRoot, targetDir, log) {
   if (isDogfood(millPackageRoot, targetDir)) {
-    return { garment: "dogfood", skipped: true };
+    return { suit: "dogfood", skipped: true };
   }
   const params = loadFoundryParams(targetDir);
-  const millPlant = millFillMillPlant(millPackageRoot, targetDir, log);
+  const millPlant = fastenMillPlant(millPackageRoot, targetDir, log);
   const tree = overlayConsumerTree(targetDir, log, params);
   tree.millPlantSkills = millPlant.skills;
   tree.millPlantAgents = millPlant.agents;
@@ -365,6 +474,7 @@ function mintConsumerSuit(millPackageRoot, targetDir, log) {
     path.join(targetDir, ".xray", "config.json"),
   );
   tree.agentsCard = overlayAgentsCard(targetDir, params);
+  assertNoCostumeDump(targetDir, millPlant, tree);
   if (log && (tree.codex || tree.features || tree.config)) {
     log("foundry-mint", "Overlaid consumer suit facets onto .xray", "info", {
       constitution: tree.codex,
@@ -382,16 +492,27 @@ module.exports = {
   loadFoundryExtra,
   wantsCostume,
   millPlantDir,
-  millFillMillPlant,
+  listSkillNamesAt,
+  listAgentFilesAt,
+  fastenMillPlant,
   resolveInside,
   overlayJsonFacet,
   overlayAgentsCard,
   overlayConsumerTree,
   listConsumerSkillNames,
   listConsumerAgentFiles,
-  listSkillHangers,
+  listProjectSkillDirs,
   mintConsumerFromSsot,
   mintConsumerSuit,
   isDogfood,
   readPackageIdentity,
+  wornSkillNames,
+  wornAgentFiles,
+  costumeDumpExtras,
+  assertNoCostumeDump,
+  machineHome,
+  processHome,
+  isIsolatedHome,
+  machineGrokPluginDir,
+  wouldClobberMachineGrok,
 };

package/scripts/foundry/mint.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Overlay their mill SSOT onto the hanger (cwd / FOUNDRY_ROOT).
+ * Overlay their mill SSOT onto the project (cwd / FOUNDRY_ROOT).
  * Not a fifth 0xray CLI. Not PPE.
  */
 
@@ -15,11 +15,17 @@ 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`);
-  });
+  let inventory;
+  try {
+    inventory = mintConsumerSuit(millRoot, target, (component, action, status) => {
+      process.stdout.write(`${component} ${action} ${status}\n`);
+    });
+  } catch (err) {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+  }
   if (inventory.skipped) {
-    process.stderr.write("mint: skipped dogfood / 0xray exo plant (not a consumer hanger)\n");
+    process.stderr.write("mint: skipped dogfood / 0xray exo plant (not a consumer project)\n");
     process.exit(0);
   }
   process.stdout.write(`${JSON.stringify(inventory, null, 2)}\n`);

package/scripts/foundry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xray/foundry",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "private": false,
   "type": "module",
   "description": "0xRay mill: mint their suit params, stamp, gate, publish, CI report, git hooks. Not the worn exo.",
@@ -37,6 +37,7 @@
     "./release-gate": "./release-gate.mjs",
     "./mill-root": "./mill-root.mjs",
     "./mint-suit": "./mint-suit.cjs",
+    "./inspect": "./inspect.mjs",
     "./ci-monitor": "./ci-monitor.mjs",
     "./hooks": "./hooks.mjs",
     "./docs-build": "./docs-build.mjs"

package/scripts/foundry/plant/agents/inspect.yml

@@ -0,0 +1,5 @@
+name: inspect
+skill: inspect
+description: "Inspect AI work: diffs, traces, mill receipts, CI. Fastened mill plant."
+version: "0.1.7"
+mode: subagent

package/scripts/foundry/plant/agents/mill.yml

@@ -1,5 +1,5 @@
 name: mill
 skill: mill
-description: "Mill mill-fill mill plant. Their plant is the suit. Factory Repertoire."
-version: "0.1.5"
+description: "Fasten their plant as the suit. Factory Repertoire. Inspect is the mill discipline."
+version: "0.1.7"
 mode: subagent

package/scripts/foundry/plant/skills/inspect/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: inspect
+description: Inspect AI work — diffs, tool traces, mill receipts, CI. Factory mill plant. Not 45/42 costume.
+---
+
+# Inspect
+
+This mill **fastens** a suit for **inspecting AI work**. Not an empty suit. Not a copy of 0xRay's 45/42 costume.
+
+Mill **does** these checks (`npx @0xray/foundry inspect`). Mint fails on a costume dump. Live PUT GETs the `.tgz`. Isolated HOME refuses `~/.grok/plugins/0xray`. Not an 8th MCP.
+
+## What mill inspects
+
+1. **Diff.** `git status` / `git diff --stat` of the milled cwd. Ignore the agent's summary if the diff disagrees.
+2. **Plant vs worn.** `src/skills`, `src/opencode/agents` vs `.opencode/skills`, `.opencode/agents`. Same name: plant wins. Costume dump (worn names they did not plant and mill did not fasten) fails mint unless `foundry.json` has `"costume": true`.
+3. **Mill receipt.** `.xray/foundry-inventory.json` — mill name/version, `suit` (`fastened` / `overlay` / `costume`), `millPlant.skills` must include `mill` and `inspect`.
+4. **CI.** GitHub mill CI report (`.opencode/logs/ci-cd-monitor-report.json`), not a green check in chat. No token is a skip, not a pass invented.
+5. **Live PUT.** HTTP 200 on the npm `.tgz`. Metadata without a tarball is not shipped.
+6. **Isolated HOME.** Last-mile must not clobber `~/.grok/plugins/0xray`. Mill compares `$HOME` to the passwd home (`os.userInfo().homedir`), not `os.homedir()` (which follows `$HOME`).
+
+## How to work
+
+- Open the files. Quote paths. Do not invent a pass.
+- Constitution stays on (Codex 11 / 69 / destructive). Inspecting is not a license to add an 8th MCP.
+- Factory Repertoire is the organ, not the inspection.
+- Fasten their plant on top; do not dump our costume.
+
+```bash
+npx @0xray/foundry mint
+npx @0xray/foundry inspect
+npx @0xray/foundry ci --report
+```

package/scripts/foundry/plant/skills/mill/SKILL.md

@@ -1,22 +1,20 @@
 ---
 name: mill
-description: Mill mill-fill mill plant. Their plant is the suit. Factory Repertoire. Not 45/42 costume.
+description: Fasten their plant as the suit. Factory Repertoire. Inspect is the mill discipline. Not 45/42 costume.
 ---
 
 # Mill
 
-The mill **fastens** their plant onto the hanger. It does not copy the 0xRay 45-skill / 42-agent costume unless they opt in.
+The mill **fastens** a suit. Default mill plant is **inspect** (inspecting AI work) plus this mill card. Not empty. Not 0xRay's 45-skill / 42-agent costume unless they opt in.
 
 **Plant (their SSOT):** `xray/codex.json`, `xray/features.json`, `xray/config.json`, `src/skills/<name>/SKILL.md`, `src/opencode/agents/*.yml`. Remap with `foundry.json`.
 
-**Mill-fill:** their keys/files win. Mill mill mill-fill mill names they did not plant stay. JSON always merges.
+**Mill-fill:** their keys/files win. Mill plant names they did not overlay stay. JSON always merges.
 
-**Factory:** Repertoire organ enable-when-resolves. Seven generated MCP. Constitution (PPE) stays worn. Not a fifth MCP. Not 5.0.
+**Factory:** Repertoire enable-when-resolves. Seven generated MCP. Constitution (PPE) stays worn. Not a fifth MCP. Not 5.0.
 
-**Costume:** `foundry.json` `"costume": true` copies the 45/42 mill garment. Default is empty garment + this mill mill-fill mill plant.
+**Costume:** `foundry.json` `"costume": true` copies the 45/42 mill costume.
 
 ```bash
 npx @0xray/foundry mint
 ```
-
-Nested mill: `node node_modules/0xray/scripts/foundry/cli.js mint`.

package/scripts/node/bridge-mcp-wiring.cjs

@@ -222,6 +222,13 @@ function isEphemeralInstallRoot(targetDir) {
   return /\/T\/|\/tmp\/|\/var\/folders\/|\/Temp\//i.test(normalized);
 }
 
+const millSuit = require("../foundry/mint-suit.cjs");
+
+/** Last-mile isolated HOME vs passwd home. `os.homedir()` follows $HOME. */
+function isIsolatedHome(env = process.env, machine = millSuit.machineHome()) {
+  return millSuit.isIsolatedHome(env, machine);
+}
+
 function copyHermesHookRuntimes(packageRoot) {
   const hooksSrc = [
     path.join(packageRoot, "dist", "integrations", "hooks"),
@@ -560,6 +567,7 @@ module.exports = {
   isDefaultMemoryRoutingOff,
   enableMemoryRoutingIfResolves,
   isEphemeralInstallRoot,
+  isIsolatedHome,
   copyHermesHookRuntimes,
   resolveOpenClawPreToolHookSource,
   resolveOpenClawPluginDir,

package/scripts/node/consumer-install-smoke.mjs

@@ -226,16 +226,16 @@ function main() {
 
     const millSkillHanger = path.join(tmpRoot, ".opencode", "skills", "mill", "SKILL.md");
     if (!fs.existsSync(millSkillHanger)) {
-      throw new Error("empty garment missing mill plant skill on hanger");
+      throw new Error("mill plant missing mill skill");
     }
-    const hangerSkills = path.join(tmpRoot, ".opencode", "skills");
-    const hangerNames = fs.existsSync(hangerSkills)
-      ? fs.readdirSync(hangerSkills).filter((n) =>
-          fs.existsSync(path.join(hangerSkills, n, "SKILL.md")),
+    const wornSkills = path.join(tmpRoot, ".opencode", "skills");
+    const wornNames = fs.existsSync(wornSkills)
+      ? fs.readdirSync(wornSkills).filter((n) =>
+          fs.existsSync(path.join(wornSkills, n, "SKILL.md")),
         )
       : [];
-    if (hangerNames.length > 3) {
-      throw new Error(`costume dump on empty garment: ${hangerNames.join(",")}`);
+    if (wornNames.length > 3) {
+      throw new Error(`costume dump: ${wornNames.join(",")}`);
     }
 
     const installedPkg = JSON.parse(fs.readFileSync(path.join(nmRoot, "package.json"), "utf-8"));

package/scripts/node/install-bridges.cjs

@@ -8,7 +8,7 @@ const fs = require("fs");
 const path = require("path");
 const os = require("os");
 const { execSync } = require("child_process");
-const { wantsCostume } = require("../foundry/mint-suit.cjs");
+const { wantsCostume, isIsolatedHome, machineHome } = require("../foundry/mint-suit.cjs");
 const {
   wireHermesBridge,
   wireOpencodeBridge,
@@ -308,7 +308,7 @@ function installOpencodeBridge(targetDir, packageRoot, log) {
     const copied = syncCostumeSkills(path.join(opencodeDest, "skills"), packageRoot, targetDir);
     if (copied > 0) log("opencode-bridge", `skills synced (${copied})`, "info", { path: ".opencode/skills/" });
   } else {
-    log("opencode-bridge", "empty garment — plugin only, mill mill-fill mill plant", "info");
+    log("opencode-bridge", "mill plant — plugin only, not costume dump", "info");
     fs.mkdirSync(opencodeDest, { recursive: true });
     copyOpencodePlugin(packageRoot, opencodeDest, log);
   }
@@ -375,18 +375,25 @@ function installGrokBridge(targetDir, packageRoot, log) {
     return;
   }
 
-  const home = os.homedir();
+  const machine = machineHome();
   const ephemeral = isEphemeralInstallRoot(targetDir);
+  const isolated = isIsolatedHome();
   const targets = [path.join(targetDir, ".grok", "plugins", "0xray")];
-  if (!ephemeral) {
-    targets.push(path.join(home, ".grok", "plugins", "0xray"));
+  if (!ephemeral && !isolated) {
+    targets.push(path.join(machine, ".grok", "plugins", "0xray"));
   } else {
-    log("grok-bridge", "skip machine ~/.grok plugin — ephemeral consumer", "info");
+    log(
+      "grok-bridge",
+      isolated
+        ? "skip machine ~/.grok plugin — isolated HOME"
+        : "skip machine ~/.grok plugin — ephemeral consumer",
+      "info",
+    );
   }
 
   for (const dest of targets) {
     if (copyPluginDir(sourceDir, dest)) {
-      const rel = dest.startsWith(home) ? dest.replace(home, "~") : path.relative(targetDir, dest);
+      const rel = dest.startsWith(machine) ? dest.replace(machine, "~") : path.relative(targetDir, dest);
       log("grok-bridge", "plugin copied", "info", { path: rel || dest });
       writePluginMcpJson(dest, targetDir, log, "grok-bridge");
       patchGrokHooks(dest, packageRoot, targetDir, log, "grok-bridge");
@@ -395,8 +402,8 @@ function installGrokBridge(targetDir, packageRoot, log) {
     }
   }
 
-  if (!ephemeral) {
-    const grokGlobalSkills = path.join(home, ".grok", "skills");
+  if (!ephemeral && !isolated) {
+    const grokGlobalSkills = path.join(machine, ".grok", "skills");
     const globalCopied = syncCostumeSkills(grokGlobalSkills, packageRoot, targetDir);
     if (globalCopied > 0) {
       log("grok-bridge", `global skills synced (${globalCopied})`, "info", { path: "~/.grok/skills/" });
@@ -706,5 +713,6 @@ module.exports = {
   grokHookShellCommand,
   writeGrokDiscoveredHooks,
   isEphemeralInstallRoot,
+  isIsolatedHome,
   installFrameworkDogfoodWear,
 };

package/src/integrations/openclaw/plugin/xray-pre-tool/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xray-pre-tool",
-  "version": "4.0.3",
+  "version": "4.0.4",
   "private": true,
   "type": "module",
   "description": "0xRay constitution + temperament PreToolUse for OpenClaw",

package/xray/features.json

@@ -1,6 +1,6 @@
 {
   "$schema": "./features.schema.json",
-  "version": "4.0.3",
+  "version": "4.0.1",
   "description": "0xRay Framework - Unified Feature Configuration",
   "suit_temperament": {
     "profile": "auto",