0xray 4.0.21 → 4.0.22

package/dist/integrations/cursor/hooks/cursor-hook-utils.js

@@ -182,6 +182,25 @@ export function cursorHeatRoots(event = {}) {
   return out;
 }
 
+function packageNameAt(root) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    return typeof pkg.name === 'string' ? pkg.name : '';
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Constitution follows the suit mill when that package is in the heat set.
+ * A sibling repo's leftover synthesis checkpoint must not deny the host.
+ */
+export function cursorGateRoot(heatRoots, eventRoot) {
+  const mill = heatRoots.find((root) => packageNameAt(root) === '0xray');
+  if (mill) return mill;
+  return heatRoots[0] || eventRoot;
+}
+
 export function cursorSessionId(event = {}) {
   return (
     event.conversation_id ||

package/dist/integrations/cursor/hooks/pre-tool-use.js

@@ -9,6 +9,7 @@ import {
   appendHookActivity,
   checkCodexPatterns,
   checkFullTestSuite,
+  cursorGateRoot,
   cursorHeatRoots,
   cursorSessionId,
   cursorToolContext,
@@ -53,7 +54,7 @@ async function main() {
     for (const root of heatRoots) {
       ensureCursorSessionBoot(root, '0xray/cursor-pre-tool-use-boot', { sessionId });
     }
-    const gateRoot = heatRoots[0] || eventRoot;
+    const gateRoot = cursorGateRoot(heatRoots, eventRoot);
 
     const features = loadFeatures(gateRoot);
     const gateFeatures = loadDelegationGateFeatures(gateRoot, 'cursor');

package/dist/integrations/hooks/station-hook-runtime.cjs

@@ -395,6 +395,30 @@ function pruneKeywordDest(root) {
   return { removed, kept: kept.length };
 }
 
+const STACK_LAW_FIELDS = [
+  "definition",
+  "tags",
+  "priority",
+  "evaluation_criteria",
+  "validation_experiment",
+  "example_inference_snippet",
+  "implementation_notes",
+];
+
+/** Stack text cadences onto an existing project law. Observation stats stay. */
+function refreshStackLaw(existing, signal) {
+  let dirty = false;
+  for (const field of STACK_LAW_FIELDS) {
+    if (signal[field] == null) continue;
+    const next = signal[field];
+    const prev = existing[field];
+    if (JSON.stringify(prev) === JSON.stringify(next)) continue;
+    existing[field] = next;
+    dirty = true;
+  }
+  return dirty;
+}
+
 function mergeMissingSignals(destPath, incoming) {
   if (!incoming.length || !existsSync(destPath)) return 0;
   let data;
@@ -404,24 +428,35 @@ function mergeMissingSignals(destPath, incoming) {
     return 0;
   }
   if (!Array.isArray(data.signals)) return 0;
-  const have = new Set(
-    data.signals.map((signal) => String((signal && signal.name) || "").trim()).filter(Boolean),
-  );
-  let added = 0;
+  const byName = new Map();
+  for (const signal of data.signals) {
+    const name = String((signal && signal.name) || "").trim();
+    if (name) byName.set(name, signal);
+  }
+  let changed = 0;
   for (const signal of incoming) {
     const name = String(signal.name).trim();
-    if (!name || have.has(name)) continue;
-    data.signals.push({
-      ...signal,
-      name,
-      tags: Array.isArray(signal.tags) ? signal.tags : [],
-      definition: typeof signal.definition === "string" ? signal.definition : name,
-    });
-    have.add(name);
-    added += 1;
+    if (!name) continue;
+    const existing = byName.get(name);
+    if (!existing) {
+      const created = {
+        ...signal,
+        name,
+        tags: Array.isArray(signal.tags) ? signal.tags : [],
+        definition: typeof signal.definition === "string" ? signal.definition : name,
+      };
+      data.signals.push(created);
+      byName.set(name, created);
+      changed += 1;
+      continue;
+    }
+    if (refreshStackLaw(existing, signal)) changed += 1;
+  }
+  if (changed) {
+    data.last_updated = new Date().toISOString();
+    writeFileSync(destPath, `${JSON.stringify(data, null, 2)}\n`);
   }
-  if (added) writeFileSync(destPath, `${JSON.stringify(data, null, 2)}\n`);
-  return added;
+  return changed;
 }
 
 /** Hydrate project dest from seed + stack. Subject repo-* stay off dest. */
@@ -661,6 +696,7 @@ function maybeCaptureSessionOnHeadMove(root) {
     from: stamp && stamp.head ? stamp.head : commits[commits.length - 1] ? commits[commits.length - 1].hash : git.head,
     to: git.head,
   };
+  const patterns = patternsFromGit(root, commits, span);
   const session = {
     sessionId,
     timestamp: new Date().toISOString(),
@@ -669,8 +705,8 @@ function maybeCaptureSessionOnHeadMove(root) {
     approaches,
     wrongTurns: [],
     solutions: [],
-    patterns: patternsFromGit(root, commits, span),
-    matched_primitives: [],
+    patterns,
+    matched_primitives: preferLawHits(patterns.map((row) => row && row.name)),
     metrics: { commits: commits.length },
   };
   const outDir = join(root, "docs", "inference");
@@ -754,8 +790,16 @@ function growDestOnWake(root) {
     const line = String(out).trim().split("\n").filter(Boolean).at(-1) || "{}";
     const parsed = JSON.parse(line);
     const pruned = pruneKeywordDest(root);
-    if (!parsed || typeof parsed !== "object") return { pruned };
-    return { ...parsed, pruned: pruned.removed, destCount: countCuratedSignals(destSignalsPath(root)) };
+    const destCount = countCuratedSignals(destSignalsPath(root)) || 0;
+    if (!parsed || typeof parsed !== "object") return { pruned: pruned.removed, destCount };
+    const heated = Array.isArray(parsed.heated) ? parsed.heated.length : 0;
+    return {
+      ...parsed,
+      observed: heated,
+      pruned: pruned.removed,
+      destCount,
+      after: destCount,
+    };
   } catch {
     return null;
   }
@@ -811,6 +855,28 @@ function retainCompactFields(existing, extra = {}) {
   return kept;
 }
 
+/** Persist heated length. A number stays a number. An array is a count. Never drop a number to 0. */
+function workingGrowSnapshot(grow) {
+  if (!grow || typeof grow !== "object") return null;
+  if (typeof grow.after !== "number") {
+    return typeof grow.skipped === "string" ? grow.skipped : null;
+  }
+  const observed =
+    typeof grow.observed === "number"
+      ? grow.observed
+      : Array.isArray(grow.observed)
+        ? grow.observed.length
+        : Array.isArray(grow.heated)
+          ? grow.heated.length
+          : 0;
+  return {
+    before: grow.before,
+    after: grow.after,
+    imported: grow.imported,
+    observed,
+  };
+}
+
 function formatWorkingLine(working) {
   if (!working || typeof working !== "object") return null;
   const matched = stationSafeSignals(working.matchedSignals);
@@ -826,7 +892,7 @@ function buildRepertoireResume(root) {
   const modulePath = resolveRepertoireProviderModule(root);
   const mr = readMemoryRoutingConfig(root);
   if (!modulePath) {
-    return "Repertoire: not installed (memory_routing stays off)";
+    return "Repertoire: module unresolved";
   }
   const destPath = destSignalsPath(root);
   let signalsPath = existsSync(destPath) ? destPath : mr.config && mr.config.signalsPath;
@@ -932,15 +998,8 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
   if (pickup) workingSnapshot.pickup = pickup;
   if (matchText) workingSnapshot.matchText = matchText;
   if (captured) workingSnapshot.sessionCapture = captured;
-  if (grow && grow.skipped) workingSnapshot.grow = grow.skipped;
-  if (grow && typeof grow.after === "number") {
-    workingSnapshot.grow = {
-      before: grow.before,
-      after: grow.after,
-      imported: grow.imported,
-      observed: Array.isArray(grow.observed) ? grow.observed.length : 0,
-    };
-  }
+  const growReceipt = workingGrowSnapshot(grow);
+  if (growReceipt) workingSnapshot.grow = growReceipt;
   if (matchedSignals.length) workingSnapshot.matchedSignals = matchedSignals.slice(0, 8);
   const opProcNames = readOpProcNames(root);
   if (opProcNames.length) workingSnapshot.opProcNames = opProcNames;
@@ -1108,7 +1167,7 @@ function formatStationMarkdown(fields) {
   } else {
     lines.push("Git: n/a");
   }
-  lines.push(fields.repertoireResume || "Repertoire: not installed (memory_routing stays off)");
+  lines.push(fields.repertoireResume || "Repertoire: module unresolved");
   if (fields.workingLine) {
     lines.push(fields.workingLine);
   }
@@ -1165,6 +1224,7 @@ module.exports = {
   readNotesPickup,
   maybeCaptureSessionOnHeadMove,
   formatWorkingLine,
+  workingGrowSnapshot,
   applyStationHeat,
   isStockTicket,
   readStationTicketField,

package/dist/integrations/hooks/station-hook-runtime.mjs

@@ -28,6 +28,7 @@ export const patternsFromGit = impl.patternsFromGit;
 export const readNotesPickup = impl.readNotesPickup;
 export const maybeCaptureSessionOnHeadMove = impl.maybeCaptureSessionOnHeadMove;
 export const formatWorkingLine = impl.formatWorkingLine;
+export const workingGrowSnapshot = impl.workingGrowSnapshot;
 export const applyStationHeat = impl.applyStationHeat;
 export const isStockTicket = impl.isStockTicket;
 export const readStationTicketField = impl.readStationTicketField;

package/dist/integrations/hooks/station-memory-ingest.mjs

@@ -128,13 +128,15 @@ async function growDest(projectRoot) {
         sources: [...(kernel.sources || []), ...cleanup.sources],
       });
       const after = service.signalsManager.load().signals.length;
+      const heatedNames = Array.isArray(diary.heated) ? diary.heated : [];
       process.stdout.write(
         `${JSON.stringify({
           before,
           after,
           imported: sessions.imported,
-          observed: 0,
-          heated: diary.heated,
+          observed: heatedNames.length,
+          heated: heatedNames,
+          destCount: after,
         })}\n`,
       );
       return;

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

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

package/dist/memory-routing/provider-loader.d.ts

@@ -1,6 +1,8 @@
 import type { MemoryRoutingConfig, MemoryRoutingProvider } from './types.js';
 export declare function isExplicitMemoryRoutingOptOut(config: MemoryRoutingConfig): boolean;
-/** Leftover shipped default: enabled false + provider null. Not an explicit opt-out. */
+/** Leftover shipped default: enabled false + provider null. Not an explicit opt-out.
+ *  resolveLeftoverEnabledConfig migrates old tarballs when the organ is on disk.
+ *  Explicit opt-out is enabled: false + provider: repertoire. */
 export declare function isLeftoverMemoryRoutingOff(config: MemoryRoutingConfig): boolean;
 export declare function resolveLeftoverEnabledConfig(config: MemoryRoutingConfig, cwd: string): MemoryRoutingConfig | null;
 export declare function loadMemoryRoutingProvider(config: MemoryRoutingConfig, cwd?: string): Promise<MemoryRoutingProvider>;

package/dist/memory-routing/provider-loader.js

@@ -59,7 +59,9 @@ function defaultPathForProvider(provider, cwd) {
 export function isExplicitMemoryRoutingOptOut(config) {
     return config.enabled === false && config.provider === 'repertoire';
 }
-/** Leftover shipped default: enabled false + provider null. Not an explicit opt-out. */
+/** Leftover shipped default: enabled false + provider null. Not an explicit opt-out.
+ *  resolveLeftoverEnabledConfig migrates old tarballs when the organ is on disk.
+ *  Explicit opt-out is enabled: false + provider: repertoire. */
 export function isLeftoverMemoryRoutingOff(config) {
     if (config.enabled === true)
         return false;

package/dist/nucleus/thin-dispatch.js

@@ -7,7 +7,7 @@
  * Import from here or from delegation/index.ts (which re-exports these).
  */
 import { frameworkLogger } from "../core/framework-logger.js";
-import { getLevelFromScore, getAgentForTier, levelToTier, } from "../delegation/complexity-core.js";
+import { getLevelFromScore, getAgentForTier, getAgentCountForLevel, getStrategyForLevel, levelToTier, } from "../delegation/complexity-core.js";
 import { ComplexityAnalyzer } from "../delegation/complexity-analyzer.js";
 import { getMemoryRoutingProviderSync, initializeMemoryRouting, } from "../memory-routing/index.js";
 initializeMemoryRouting();
@@ -18,6 +18,9 @@ export const NUCLEUS_THIN_DISPATCH_VERSION = "0.1.0";
  */
 export function scoreComplexity(operation, context, thresholds) {
     const analyzer = new ComplexityAnalyzer();
+    if (thresholds) {
+        analyzer.setThresholds(thresholds);
+    }
     const metrics = analyzer.analyzeComplexity(operation, context);
     const score = analyzer.calculateComplexityScore(metrics);
     frameworkLogger.log("nucleus-thin-dispatch", "score-complexity", "info", {
@@ -76,7 +79,13 @@ export function scoreAndRoute(operation, context, thresholds) {
             signals: resolved.context.matchedSignals,
         });
         return {
-            score: { ...score, score: resolved.adjustedScore, level: adjustedLevel },
+            score: {
+                ...score,
+                score: resolved.adjustedScore,
+                level: adjustedLevel,
+                recommendedStrategy: getStrategyForLevel(adjustedLevel),
+                estimatedAgents: getAgentCountForLevel(adjustedLevel),
+            },
             agent,
             memoryRouting,
         };

package/dist/processors/implementations/agents-md-validation-processor.js

@@ -224,7 +224,7 @@ export class AgentsMdValidationProcessor {
                 "",
                 "## Codex",
                 "",
-                `0xRay enforces Universal Development Codex (60 terms) for systematic error prevention.`,
+                `0xRay enforces Universal Development Codex (69 terms) for systematic error prevention.`,
                 "",
             ].join("\n"),
             "## CLI Commands": [

package/dist/skills/hermes-agent/SKILL.md

@@ -64,7 +64,7 @@ Returns: pass/fail with per-file results and violations.
 
 ### xray_codex_check
 
-Validate code against the 60-term Universal Development Codex. Checks error-handling, type-safety, performance, security, architecture.
+Validate code against the 69-term Universal Development Codex. Checks error-handling, type-safety, performance, security, architecture.
 
 ```
 xray_codex_check(code="const x: any = foo()", operation="create")

package/dist/skills/orchestrator/SKILL.md

@@ -64,6 +64,10 @@ Config: `features.json` → `multi_agent_orchestration.lead_dev_mode`
 
 The seven rules are the engine. The cadence is the time signature. Disk SSOT: `grok-bot/ops/LEAD-CADENCE.md`.
 
+Jargon is not the job. Review and cadence ask whether the change works. Do not spend the loop reciting dest names, mill liturgy, or host mantras.
+
+- **Feat rebase:** when the mandated work turns into mantra, or the job has split across planes that no longer share one present, stop. Go up a level and answer the original message again from this seat. Do not continue the side thread and call that the job.
+
 - **Peer test:** another instance with only worn 0xRay continues the ticket. No command stream.
 - **Wear first:** Read `.xray/state/STATION.md`. Same cloud. Same critic (resume only). Dummy Reads Station.
 - **Dummy tests `SKILLS.md`:** a suited dummy proves the worn catalog. Same-sess bodies keep context and hold a Station card.
@@ -73,6 +77,24 @@ The seven rules are the engine. The cadence is the time signature. Disk SSOT: `g
 - **Live tick, not pacer:** `/loop` runs work now. Keep workstreams moving. Do not idle-wait 12 minutes. **Clean ticks every cycle** — unsubscribe then resubscribe so the prompt matches metal. Name-dedupe does not rewrite. A stale prompt (waiting URL after live, Hold after strip) is dirty: rewrite, do not act. **If the card and WAVEBOARD are idle, unsubscribe and do not resubscribe.**
 - **Board clock:** PR events + resume the same critic. Not two idle pacers. Merge after PASS+CI (gate A). Publish only after mill-gate D + `foundry gate`.
 - **Dispatch:** ticket + PR URLs + “Wear, then review.” The critic Reads `SEATS.md` Reviewer. Do not paste a command novel. When a law is spoken twice, encode it this wake.
+- **Cascade:** Chat is not the brain. A cascade that must survive compaction is a named repertoire signal on the stack overlay, hydrated onto the project law list. NOTES holds the same cascade for the second Read. Station stays the ticket. A reflection is not this capture. Capture priority: a law is an invariant you would otherwise re-read the source to relearn. One law per subsystem bone. Heat touches last_seen and does not append a confidence sample, so more hits do not raise conviction. Heat touches last_seen only when the diary contains that signal's name; two definition words are not a hit; a weak session score is not lifted to 0.55 and a sample below 0.55 is not recorded. Constructing the organ does not append workspace samples. Hero names: `heat-is-not-conviction`, `inference-cycle-invariant`, `governance-vote-invariant`, `thin-dispatch-invariant`. Repertoire mergeStackOverlay refreshes a changed stack definition and keeps observation stats.
+- **Cold brief:** a new critic or any new subagent that does not already have this thread gets the latest commit SHA on the branch under review (fetch it; do not reuse an earlier SHA from a previous pass) and the Station card (`.xray/state/STATION.md`: intent, plan, git). If the card is missing, give branch + HEAD + what just changed. If the branch moves after you brief them, send the new SHA before they verdict.
+- **Control:** The lead keeps control. Do not assume the subagent has the context. Give the duty, the latest SHA, the Station card, and the laws that apply. The subagent wears the applicable 0xRay suit before it works: the tree under review, built and installed. An older published package is not that suit. The lead checks the result.
+
+### Engine cadence
+
+This suite is the engine that builds the engine. When a seat sees OP-PROC, write it onto these existing surfaces in the same wake. Do not open a new skill.
+
+1. Change the engine with precision.
+2. Ship it local: build and install the tree. A live npm version stays live. Once a version is live, the stamper strips every present-tense patch pin from shipped guides and shipped OP-PROC, or reconcile advances the next cut. The stamper does not edit Station, NOTES, dest, or node_modules. It does not publish.
+3. Test the change.
+4. Run another deep review of the diff you just made.
+5. Monitor long-term memory (dest name count and whether observations are the only growth) and short-term memory (Station: intent, plan, git).
+6. Ship the PR.
+
+### Planes
+
+Operating planes: code, OP-PROC, model, suit, mill, host, and test/ship. Test/ship is the critical OP-PROC plane. Test then ship is the hero. Ship without that proof is the catastrophe. Long-term memory is the project law list. Each wake refreshes a changed stack definition and keeps observation stats. Heat writes the matched names onto Station, the short-term card that survives compaction. Reactive decisions move out of TypeScript into OP-PROC as the model improves. That move is why the mill and the suit exist. It is not fully proved. Once a version is live, the stamper strips every present-tense patch pin from shipped guides and shipped OP-PROC, or reconcile advances the next cut. The stamper does not edit Station, NOTES, dest, or node_modules. It does not publish. Do not freeze the live cut.
 - **Close:** loop until Station is done. Compact: Station survives the cut. Overlay dest names are OP-PROC — reload `repertoire-working.json` `opProcNames`, not Station.
 - **Board:** critic Strict comments; forge implements; lead stays main thread.
 - **Codex 69:** rewire this skill and existing ops. Do not add a new `SKILL.md` to hold the cadence.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "4.0.21",
+  "version": "4.0.22",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",
@@ -106,7 +106,7 @@
     "debug:inference:force": "XRAY_FORCE_MCP_GOVERNANCE=true XRAY_DEV_PATH=dist node dist/cli/index.js inference:run --force",
     "validate:full": "npm run validate",
     "test:unified": "node scripts/test/test-unified-framework.mjs",
-    "test:consumer": "node scripts/test/test-consumer-readiness.cjs",
+    "test:consumer": "node scripts/mjs/test-consumer-readiness.mjs",
     "config:setup": "node scripts/config/utils.js setup-dev",
     "monitoring:start": "node scripts/monitoring/daemon.js start",
     "monitoring:stop": "node scripts/monitoring/daemon.js stop",

package/scripts/foundry/CHANGELOG.md

@@ -4,6 +4,8 @@
 
 Shim `sound-voice.cjs` → `@0xray/blip/sound-voice`. Depend on published `@0xray/blip@^0.1.2`. Foundry stamp stays 0.1.12. Do not vendor mill drawers.
 
+Inspect `--go` emits a shop-style forge GO receipt (harness profile: bare / suited / partial). Observational by default: Cursor/Grok `hooks.json` bound, Repertoire fastened (`node_modules` or `.xray/state/repertoire`), Station present. `--require-harness=` gates dual-cloud A/B. Vendor Repertoire source and `memory_routing` declaration are not fasten. Not an 8th MCP. Not PPE. Not 5.0.
+
 ## [0.1.12] - 2026-09-18
 
 Fasten is foundry-plant/0: mill packages declare plants in package.json (`mill.protocol`, prefix selection when skills/agents are omitted) and foundry copies organs from that package. Builtin catalog is mill+inspect only; foundry does not catalog mill organs. `foundry.json` `"plant": "blip"|"sound"` are package aliases for `@0xray/blip`, not skill lists. Unknown mill packages fail closed (`npm i`). Inventory records `millPackage` and `millProtocol` when a mill package was used.

package/scripts/foundry/README.md

@@ -23,7 +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 inspect [--skip-live] [--go] [--go-out PATH] [--require-harness=bare|suited|partial]
 npx @0xray/foundry sound render [--brief TEXT] [--genre ambient|techno|jazz]
 npx @0xray/foundry sound inspect
 npx @0xray/foundry sound mix
@@ -39,7 +39,7 @@ 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. `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`. Shared HOME last-mile dest is project `.grok/plugins/0xray` (no last-wins machine plugin). `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) plus observational harness (Cursor/Grok hooks bound, Repertoire fastened, Station present). `--go` emits a shop-style forge GO receipt; `--require-harness=bare|suited|partial` turns that observation into a gate. Mint fails on a costume dump. Isolated HOME skips machine `~/.grok`. Shared HOME last-mile dest is project `.grok/plugins/0xray` (no last-wins machine plugin). `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.
 

package/scripts/foundry/cli.mjs

@@ -29,7 +29,7 @@ const HELP =
   "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 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" +
+  "inspect runs mill checks plus, on a sound seat, last bed receipt PASS/FAIL; on a blip seat, last blip receipt. Observational harness (hooks / Repertoire / Station). --go emits a forge GO receipt. Not an 8th MCP.\n" +
   "sound render|inspect|mix is the factory-sound plant (brief → seed → genre → wav → metrics; mix levels every variation). Sibling to mill, not a mill copy.\n" +
   "blip render|inspect|vibe|look is the factory-blip plant (brief → seed → still|motion:<id> → 4.44s mp4; vibe is stamp density, look is the friend hitting replay, ship bar 8). 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";

package/scripts/foundry/inspect.mjs

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 /**
- * Mill inspect organ. Runs the six checks. Not an 8th MCP. Not PPE.
+ * Mill inspect organ. Runs the six plant checks plus observational harness.
+ * Not an 8th MCP. Not PPE. Does not fasten hooks or Repertoire.
  *
- *   npx @0xray/foundry inspect [--skip-live]
+ *   npx @0xray/foundry inspect [--skip-live] [--go] [--go-out PATH]
+ *     [--require-harness=bare|suited|partial] [--goal TEXT]
  */
 
 import { spawnSync } from "node:child_process";
@@ -63,6 +65,140 @@ function readJson(file) {
   }
 }
 
+const HARNESS_PROFILES = new Set(["bare", "suited", "partial"]);
+
+export function parseInspectArgs(argv = process.argv.slice(2)) {
+  const out = {
+    skipLive: false,
+    go: false,
+    goOut: null,
+    requireHarness: null,
+    goal: null,
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--skip-live") out.skipLive = true;
+    else if (arg === "--go") out.go = true;
+    else if (arg === "--go-out") out.goOut = argv[++i] || null;
+    else if (arg.startsWith("--go-out=")) out.goOut = arg.slice("--go-out=".length);
+    else if (arg === "--require-harness") out.requireHarness = argv[++i] || null;
+    else if (arg.startsWith("--require-harness=")) {
+      out.requireHarness = arg.slice("--require-harness=".length);
+    } else if (arg === "--goal") out.goal = argv[++i] || null;
+    else if (arg.startsWith("--goal=")) out.goal = arg.slice("--goal=".length);
+  }
+  if (out.goOut) out.go = true;
+  return out;
+}
+
+function hooksFileBound(file) {
+  if (!fs.existsSync(file)) return false;
+  const json = readJson(file);
+  const hooks = json?.hooks;
+  if (!hooks || typeof hooks !== "object") return false;
+  return Object.values(hooks).some(
+    (list) =>
+      Array.isArray(list) &&
+      list.some((entry) => typeof entry?.command === "string" && entry.command.trim()),
+  );
+}
+
+export function classifyHarnessProfile({ hooksBound, repertoireFastened, stationPresent }) {
+  if (!hooksBound && !repertoireFastened && !stationPresent) return "bare";
+  if (hooksBound && repertoireFastened) return "suited";
+  return "partial";
+}
+
+export function probeHarness(root) {
+  const cursorHooks = path.join(root, ".cursor", "hooks.json");
+  const grokHooks = path.join(root, ".grok", "plugins", "0xray", "hooks", "hooks.json");
+  const grokPluginHooks = path.join(root, ".grok-plugin", "hooks", "hooks.json");
+  const hooks = {
+    cursor: hooksFileBound(cursorHooks),
+    grok: hooksFileBound(grokHooks) || hooksFileBound(grokPluginHooks),
+  };
+  hooks.bound = Boolean(hooks.cursor || hooks.grok);
+
+  const repertoire = {
+    nodeModules: fs.existsSync(path.join(root, "node_modules", "@0xray", "repertoire")),
+    state: fs.existsSync(path.join(root, ".xray", "state", "repertoire")),
+    vendorSource: fs.existsSync(path.join(root, "vendor", "@0xray", "repertoire")),
+  };
+  repertoire.fastened = Boolean(repertoire.nodeModules || repertoire.state);
+
+  const features =
+    readJson(path.join(root, ".xray", "features.json")) ||
+    readJson(path.join(root, "xray", "features.json"));
+  repertoire.memoryRoutingDeclared = features?.memory_routing?.provider === "repertoire";
+
+  const stationPresent = fs.existsSync(path.join(root, ".xray", "state", "STATION.md"));
+  const profile = classifyHarnessProfile({
+    hooksBound: hooks.bound,
+    repertoireFastened: repertoire.fastened,
+    stationPresent,
+  });
+
+  return {
+    id: "harness",
+    hooks,
+    repertoire,
+    station: { present: stationPresent },
+    profile,
+  };
+}
+
+export function checkHarness(root, requireHarness = null) {
+  const probe = probeHarness(root);
+  if (requireHarness && !HARNESS_PROFILES.has(requireHarness)) {
+    return {
+      ...probe,
+      ok: false,
+      require: requireHarness,
+      detail: `unknown --require-harness=${requireHarness} (bare|suited|partial)`,
+    };
+  }
+  if (requireHarness && probe.profile !== requireHarness) {
+    return {
+      ...probe,
+      ok: false,
+      require: requireHarness,
+      detail: `harness profile ${probe.profile} != required ${requireHarness}`,
+    };
+  }
+  return {
+    ...probe,
+    ok: true,
+    require: requireHarness,
+    skipped: !requireHarness,
+    detail: requireHarness ? null : "observational — pass --require-harness to gate",
+  };
+}
+
+function gitRemote(root) {
+  const remote = spawnSync("git", ["config", "--get", "remote.origin.url"], {
+    cwd: root,
+    encoding: "utf8",
+  });
+  if (remote.error || remote.status !== 0) return null;
+  return (remote.stdout || "").trim() || null;
+}
+
+export function buildForgeGo(root, harness, opts = {}) {
+  return {
+    kind: "forge-go",
+    mill: "inspect",
+    profile: harness.profile,
+    hooksBound: Boolean(harness.hooks?.bound),
+    repertoireFastened: Boolean(harness.repertoire?.fastened),
+    stationPresent: Boolean(harness.station?.present),
+    require: harness.require || null,
+    ok: harness.ok !== false,
+    goal: opts.goal || process.env.FOUNDRY_GO_GOAL || null,
+    repo: gitRemote(root),
+    generatedAt: new Date().toISOString(),
+  };
+}
+
 function checkDiff(root) {
   const status = spawnSync("git", ["status", "-sb"], { cwd: root, encoding: "utf8" });
   if (status.error || status.status === 128) {
@@ -412,6 +548,9 @@ export async function inspectSuit(root, opts = {}) {
   const skipLive = Boolean(opts.skipLive);
   const env = opts.env || process.env;
   const machineHome = opts.machineHome || mint.machineHome();
+  const requireHarness = opts.requireHarness || null;
+  const go = Boolean(opts.go);
+  const goal = opts.goal || null;
 
   const checks = [];
   checks.push(checkDiff(root));
@@ -445,22 +584,38 @@ export async function inspectSuit(root, opts = {}) {
   }
 
   checks.push(checkIsolatedHome(root, env, machineHome));
+  checks.push(checkHarness(root, requireHarness));
 
   const failed = checks.filter((c) => c.ok === false);
   const receipt = checks.find((c) => c.id === "receipt") || {};
-  return {
+  const harness = checks.find((c) => c.id === "harness") || {};
+  const report = {
     ok: failed.length === 0,
     failed: failed.map((c) => c.id),
     checks,
     dna: receipt.dna || null,
     pack: "0xray-suit",
   };
+  if (go) {
+    report.go = buildForgeGo(root, harness, { goal });
+  }
+  return report;
 }
 
 async function main() {
-  const skipLive = process.argv.includes("--skip-live");
+  const args = parseInspectArgs(process.argv.slice(2));
   const root = resolveMillRoot();
-  const report = await inspectSuit(root, { skipLive });
+  const report = await inspectSuit(root, {
+    skipLive: args.skipLive,
+    requireHarness: args.requireHarness,
+    go: args.go,
+    goal: args.goal,
+  });
+  if (args.goOut) {
+    const dest = path.isAbsolute(args.goOut) ? args.goOut : path.join(root, args.goOut);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, `${JSON.stringify(report.go || report, null, 2)}\n`);
+  }
   process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
   process.exit(report.ok ? 0 : 1);
 }