0xray 4.0.30 → 4.0.32

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

@@ -17,10 +17,10 @@ const {
   unlinkSync,
   writeFileSync,
 } = require("fs");
-const { join } = require("path");
+const { join, resolve } = require("path");
 
 const HOOKS_DIR = __dirname;
-const { plateStockLine } = require("./plates.cjs");
+const { plateStockLine, recallPlate, stampPlateIfMissing } = require("./plates.cjs");
 
 const INTENT_MAX = 240;
 
@@ -363,7 +363,7 @@ function destLawNameSet(root) {
   return names;
 }
 
-/** Drop hangar repo-* and git-slug keywords. Keep factory + stack laws. */
+/** Drop diary slugs. Keep factory, stack, and subject-overlay names. */
 function pruneKeywordDest(root) {
   const dest = destSignalsPath(root);
   if (!dest || !existsSync(dest)) return { removed: 0, kept: 0 };
@@ -376,12 +376,13 @@ function pruneKeywordDest(root) {
   if (!Array.isArray(data.signals)) return { removed: 0, kept: 0 };
   const factory = signalNameSet(repertoireDataFile(root, "curated_signals.json"));
   const stack = signalNameSet(repertoireDataFile(root, "stack-overlay.json"));
+  const subject = signalNameSet(repertoireDataFile(root, "subject-overlay.json"));
   const kept = [];
   let removed = 0;
   for (const signal of data.signals) {
     const name = String((signal && signal.name) || "").trim();
     if (!name) continue;
-    const protectedLaw = factory.has(name) || stack.has(name);
+    const protectedLaw = factory.has(name) || stack.has(name) || subject.has(name);
     if (!protectedLaw && (isKeywordDestName(name) || isGenericFieldObservedSignal(signal))) {
       removed += 1;
       continue;
@@ -780,20 +781,28 @@ function growDestOnWake(root) {
   const helper = join(HOOKS_DIR, "station-memory-ingest.mjs");
   if (!existsSync(helper)) return null;
   try {
+    const dest = destSignalsPath(root);
+    const before = countCuratedSignals(dest) || 0;
     const out = execFileSync(process.execPath, [helper, root, "--grow"], {
       encoding: "utf8",
       timeout: 45000,
       stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, REPERTOIRE_FIELD_SYNC: "0", REPERTOIRE_DEST_LOCK: "held" },
+      env: {
+        ...process.env,
+        REPERTOIRE_FIELD_SYNC: "0",
+        REPERTOIRE_DEST_LOCK: "held",
+        REPERTOIRE_SUBJECT_OVERLAY: "0",
+      },
     });
     const line = String(out).trim().split("\n").filter(Boolean).at(-1) || "{}";
     const parsed = JSON.parse(line);
     const pruned = pruneKeywordDest(root);
-    const destCount = countCuratedSignals(destSignalsPath(root)) || 0;
-    if (!parsed || typeof parsed !== "object") return { pruned: pruned.removed, destCount };
+    const destCount = countCuratedSignals(dest) || 0;
+    if (!parsed || typeof parsed !== "object") return { before, pruned: pruned.removed, destCount, after: destCount };
     const heated = Array.isArray(parsed.heated) ? parsed.heated.length : 0;
     return {
       ...parsed,
+      before,
       observed: heated,
       pruned: pruned.removed,
       destCount,
@@ -947,8 +956,8 @@ function applyStationHeat(root, host, extra = {}, existing = {}) {
   const matchText = clipIntent([intent, pickup, approaches].filter(Boolean).join(" "));
   const git = readGitBrief(root);
   const planLine = resolveHeatPlan(root, extra, existing);
-  const repertoireResume =
-    typeof extra.repertoireResume === "string" ? extra.repertoireResume : buildRepertoireResume(root);
+  // A passed string is the previous card. Count the project file after this wake.
+  const repertoireResume = buildRepertoireResume(root);
   const swapBit = hotSwap ? `hot-swap ${hotSwap.from} → ${hotSwap.to}` : `host ${host}`;
   const intentBit = intent ? `intent: ${intent}` : "intent: (none yet)";
   const gitBit = git ? `git ${git.branch}@${git.head}` : "git: n/a";
@@ -1085,7 +1094,7 @@ function stationBootNeedsRefresh(existing, root, host) {
   if (!existing || typeof existing !== "object") return true;
   if (host && existing.host && existing.host !== host) return true;
   if (!existing.suit_profile) return true;
-  if (existing.workspaceRoot && existing.workspaceRoot !== root) return true;
+  if (existing.workspaceRoot && !sameWorkspaceRoot(existing.workspaceRoot, root)) return true;
   if (!existing.stationLine) return true;
   const liveGit = readGitBrief(root);
   const bootHead = existing.git && existing.git.head ? String(existing.git.head) : "";
@@ -1108,13 +1117,27 @@ function stationDurableHoldsNpm(root) {
     .some((line) => isHoldNpmLine(line));
 }
 
+function sameWorkspaceRoot(left, right) {
+  if (!left || !right) return false;
+  return resolve(String(left)) === resolve(String(right));
+}
+
+function isFooterFragment(line) {
+  const lower = String(line || "").trim().toLowerCase();
+  if (!lower || /^[.]+$/.test(lower)) return true;
+  return STOCK_STATION_FOOTERS.some((footer) => {
+    if (lower.length >= 12 && footer.includes(lower)) return true;
+    return lower.length >= 3 && lower.length < 12 && footer.endsWith(lower);
+  });
+}
+
 function isStockStationLine(line) {
   const trimmed = String(line || "").trim();
   if (!trimmed) return true;
   if (/^#\s+station\s*$/i.test(trimmed)) return true;
   if (DESIGN_MAP_LINES.includes(trimmed)) return true;
   const lower = trimmed.toLowerCase();
-  if (STOCK_STATION_FOOTERS.includes(lower)) return true;
+  if (STOCK_STATION_FOOTERS.includes(lower) || isFooterFragment(trimmed)) return true;
   return STOCK_STATION_PREFIXES.some((prefix) => lower.startsWith(prefix));
 }
 
@@ -1210,6 +1233,12 @@ function writeStationMarkdown(root, fields) {
   try {
     const dir = join(root, ".xray", "state");
     mkdirSync(dir, { recursive: true });
+    try {
+      const plate = recallPlate(fields && fields.intent);
+      if (plate) stampPlateIfMissing(root, plate.id);
+    } catch {
+      /* a missing plate doc must not block the card */
+    }
     const dest = stationMarkdownPath(root);
     const next = mergeStationMarkdown(formatStationMarkdown(fields), readExistingStationMarkdown(root));
     writeFileSync(dest, next);

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

@@ -24,6 +24,9 @@ const UNREAD_DIARY_FILES = [
 const root = process.argv[2];
 const mode = process.argv[3] || 'station';
 
+// Project dest keeps factory and stack laws. Subject repo-* stay off it.
+process.env.REPERTOIRE_SUBJECT_OVERLAY = '0';
+
 function readRouting(projectRoot) {
   let routing = { enabled: false, provider: 'null' };
   const featuresPath = join(projectRoot, '.xray', 'features.json');

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

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

package/dist/mcps/orchestrator/config/agent-capabilities.js

@@ -8,6 +8,7 @@ import { AGENT_REGISTRY } from "../../../agents/registry.js";
 import { initializeMemoryRouting } from '../../../memory-routing/index.js';
 import { getProvider, toMemoryCapabilityMap, fromMemoryCapabilityMap, } from './memory-routing-bridge.js';
 import { routeSubagent } from '../../../nucleus/autonomy-kernel.js';
+import { scoreAndRoute } from '../../../nucleus/thin-dispatch.js';
 /** routeSubagent names → AGENT_REGISTRY keys */
 const ROUTE_AGENT_ALIASES = {
     'code-review': 'code-reviewer',
@@ -78,6 +79,12 @@ export class AgentCapabilitiesManager {
      * Select the best agent for a task based on complexity, capabilities, and memory routing.
      */
     selectAgentForTask(requiredCapabilities, complexity, operationDescription = '', taskType = '') {
+        if (operationDescription.trim()) {
+            const routed = scoreAndRoute(operationDescription, {});
+            if (routed.memoryRouting?.overridden && this.capabilities.has(routed.agent)) {
+                return routed.agent;
+            }
+        }
         if (taskType.trim()) {
             const routed = routeSubagent(taskType);
             const resolved = resolveRoutedAgent(routed, this.capabilities);

package/dist/memory-routing/plates.d.ts

@@ -1,4 +1,4 @@
-export declare const PLATE_IDS: readonly ["routing", "governance", "boot", "orchestration", "processor", "reporting", "memory-recall", "house"];
+export declare const PLATE_IDS: readonly ["routing", "governance", "boot", "orchestration", "processor", "reporting", "memory-recall", "house", "goggles", "suit", "kits", "host-pack", "glossary"];
 export type PlateId = (typeof PLATE_IDS)[number];
 export interface PlateStamp {
     id: PlateId;

package/dist/memory-routing/plates.js

@@ -14,6 +14,11 @@ export const PLATE_IDS = [
     'reporting',
     'memory-recall',
     'house',
+    'goggles',
+    'suit',
+    'kits',
+    'host-pack',
+    'glossary',
 ];
 function isPlateId(value) {
     return PLATE_IDS.includes(value);

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

@@ -5,6 +5,8 @@ import { pathToFileURL } from 'node:url';
 import { frameworkLogger } from '../core/framework-logger.js';
 import { createMemoryRoutingProvider as createNullProvider } from './null-provider.js';
 import { validateMemoryRoutingConfig } from './validate-config.js';
+// Opening the organ must not merge subject repo-* back onto the project file.
+process.env.REPERTOIRE_SUBJECT_OVERLAY ??= '0';
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/nucleus/thin-dispatch.d.ts

@@ -30,6 +30,7 @@ export declare function scoreAndRoute(operation: string, context: unknown, thres
         providerId: string;
         adjustedScore: number;
         signals: string[];
+        overridden: boolean;
         lessons?: MemorySignalLessons[];
     };
 };

package/dist/nucleus/thin-dispatch.js

@@ -57,7 +57,8 @@ export function routeToAgent(scoreOrLevel, level) {
  */
 export function scoreAndRoute(operation, context, thresholds) {
     const score = scoreComplexity(operation, context, thresholds);
-    let agent = routeToAgent(score);
+    const baseAgent = routeToAgent(score);
+    let agent = baseAgent;
     const provider = ensureMemoryRoutingProviderSync();
     let memoryRouting;
     if (provider.id !== "null") {
@@ -67,12 +68,13 @@ export function scoreAndRoute(operation, context, thresholds) {
             providerId: resolved.context.providerId,
             adjustedScore: resolved.adjustedScore,
             signals: resolved.context.matchedSignals,
+            overridden: agent !== baseAgent,
             ...(resolved.context.lessons ? { lessons: resolved.context.lessons } : {}),
         };
         const adjustedLevel = getLevelFromScore(resolved.adjustedScore, thresholds);
         frameworkLogger.log("nucleus-thin-dispatch", "memory-routing", "info", {
             providerId: resolved.context.providerId,
-            baseAgent: routeToAgent(score),
+            baseAgent,
             resolvedAgent: agent,
             baseScore: score.score,
             adjustedScore: resolved.adjustedScore,

package/dist/skills/orchestrator/SKILL.md

@@ -53,6 +53,18 @@ When `multi_agent_orchestration.lead_dev_mode` is true in `features.json` (defau
 | Test failures | bug-triage |
 | Review | code-review |
 
+## Goggles
+
+The command is `0xray look`. `0xray goggles` is the same organ. A pipe keeps the line card. A terminal shows that card as a pane. Chat seats without hooks use the `goggles` MCP tools `look` and `status_lens`. Same organ.
+
+Kind 0 is actuality. It compares the list in the file to the same six names in the code. It speaks only when those lists differ. A match is quiet. It does not read the suit that is running. It is not a plate type.
+
+Kind 1 names one plane: dichotomy, syncopate, synthesis, or loop. The lens holds that plane. An action on that plane is quiet. An action on another plane, or on a pipeline drawing, is stopped. A pipeline drawing is not a scope stop. Ground is not a scope stop. Scope, when named, is ecosystem, part, one flow, or one artifact, and an action wider than that scope is stopped. One kind and one scope level at a time. Two planes, calling, ground, and a pipeline name do not arm the lens. `outer` without one plane is `Name one plane.` After 1 is empty. Nothing is picked.
+
+`digest` and `triage` return the card already built by `assemblePlane`. The fields are from, digest, plate, entry, exit, files, skills, setup, teardown, and worn. Empty stays empty. The rows are ground, routing, house, boot, governance, memory-recall, orchestration, processor, and reporting. Those nine are not Kind 0. `digest` fills the card. Entry and exit are the plate's input and output box titles when that plate has them. Setup and teardown stay empty unless the row names them. The mill path is `scripts/foundry`. `triage` adds the empty fields and whether the row holds. Zoom after the card is the same ladder: ecosystem, part, one flow, one artifact. One file is one artifact. Several files are not narrowed to a guessed file.
+
+The hold lasts for the work that named the plane. It does not stop one tool and then forget. Work that says goggles clears the hold and stays quiet. The suit does not invent the plane.
+
 ## Hooks (rewired, not new MCPs)
 
 - **SessionStart** → `session-start.js` boots lead_dev_mode

package/docs-site/docs/plates/glossary.md

@@ -0,0 +1,27 @@
+---
+title: Glossary
+sidebar_label: Glossary
+plate_type: domain model
+---
+
+# Glossary
+
+What the words mean.
+
+```
+  ┌────────────────────────────────────────────────────────────┐
+  │ SAY WHAT PEOPLE GET                                        │
+  ├────────────────────────────────────────────────────────────┤
+  │ suit · what the agent wears                                │
+  │ power · memory, judgment, or payments                      │
+  │ where it runs · the tool you already open                  │
+  │ goggles · it views one plane                               │
+  │ house · shared rules, one board, memory that sticks        │
+  │ mill · the shop that builds and ships                      │
+  │ plane · one view, not the whole job                        │
+  │ plate · the drawing, not the live run                      │
+  │ grok-bot · the package you install                         │
+  └────────────────────────────────────────────────────────────┘
+```
+
+

package/docs-site/docs/plates/goggles.md

@@ -0,0 +1,18 @@
+---
+title: Goggles
+sidebar_label: Goggles
+plate_type: domain model
+---
+
+# Goggles
+
+It views one plane.
+
+```
+  ┌────────────────────────────────────────────────────────────┐
+  │ GOGGLES                                                    │
+  ├────────────────────────────────────────────────────────────┤
+  │ · it views one plane                                       │
+  │ · not every plane at once                                  │
+  └────────────────────────────────────────────────────────────┘
+```

package/docs-site/docs/plates/grokbot.md

@@ -0,0 +1,41 @@
+---
+title: Grok Bot
+sidebar_label: Grok Bot
+plate_type: domain model
+---
+
+# Grok Bot
+
+Give your bots a house: shared rules, one board for the work, and memory that sticks.
+
+```
+  ┌──────────────────────────────┐     ┌──────────────────────────────┐     ┌──────────────────────────────┐
+  │ SUIT · 0xray                 │ ─── │ HOUSE · grok-bot             │ ─── │ WAVEBOARD · grok-bot         │
+  ├──────────────────────────────┤     ├──────────────────────────────┤     ├──────────────────────────────┤
+  │ · rules on every step        │     │ · one folder, six headings   │     │ · open cards                 │
+  │ · hooks into your AI tools   │     │ · who owns what              │     │ · one card, one owner        │
+  │ · wear on, unwear off        │     │ · what needs asking first    │     │ · done means proof           │
+  └──────────────────────────────┘     └──────────────────────────────┘     └──────────────────────────────┘
+                  │                                    │                                    │
+                  │                                    │                                    │
+  ┌──────────────────────────────┐     ┌──────────────────────────────┐     ┌──────────────────────────────┐
+  │ MEMORY · 0xray (repertoire)  │     │ DOCTOR · grok-bot            │     │ ATTENTION · grok-bot         │
+  ├──────────────────────────────┤     ├──────────────────────────────┤     ├──────────────────────────────┤
+  │ · lessons as named rules     │     │ · checks the house           │     │ · only what needs you        │
+  │ · handed back on the job     │     │ · fails on leftover examples │     │ · ask-first items wait here  │
+  │ · ships in the suit          │     │ · says House: PASS when set  │     │ · read right after the board │
+  └──────────────────────────────┘     └──────────────────────────────┘     └──────────────────────────────┘
+                  │                                    │                                    │
+                  └────────────────────────────────────┼────────────────────────────────────┘
+                                       ┌───────────────┴──────────────┐
+                                       │ STATION · 0xray              │
+                                       ├──────────────────────────────┤
+                                       │ · the pickup card            │
+                                       │ · read first on every wake   │
+                                       │ · then board, then memory    │
+                                       └──────────────────────────────┘
+
+  code links: suit → memory, house → doctor, memory → station. Other lines show reading order only.
+```
+
+stamped · 0xray 4.0.30 · @0xray/grok-bot 0.1.8

package/docs-site/docs/plates/host-pack.md

@@ -0,0 +1,32 @@
+---
+title: Host Pack
+sidebar_label: Host Pack
+plate_type: domain model
+---
+
+# Host Pack
+
+Run it in the tool you already open. Same suit. No new app.
+
+```
+  ┌────────────────────────────────────────────────────────────┐
+  │ WHERE IT RUNS                                              │
+  ├────────────────────────────────────────────────────────────┤
+  │ · same suit                                                │
+  │ · the tool you already open                                │
+  └────────────────────────────────────────────────────────────┘
+  
+  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐
+  │ grok-bot         │  │ Hermes           │  │ OpenCode         │
+  │ · already runs   │  │ · already runs   │  │ · already runs   │
+  └──────────────────┘  └──────────────────┘  └──────────────────┘
+  
+  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐
+  │ OpenClaw         │  │ Grok CLI         │  │ Cursor           │
+  │ · already runs   │  │ · already runs   │  │ · already runs   │
+  └──────────────────┘  └──────────────────┘  └──────────────────┘
+  
+    same suit → the tool you open → powers snap on
+```
+
+These six already run.

package/docs-site/docs/plates/house.md

@@ -1,50 +1,53 @@
 ---
 title: House
 sidebar_label: House
+plate_type: state flow
 ---
 
 # House
 
-One team, one folder. `grok-bot house init` copies `HOUSE.md`, `WAVEBOARD.md`, and `ATTENTION_STATE.md` into `./house`. It does not copy `EXAMPLE.md`. It refuses when a target file is already there. Doctor reads `HOUSE.md` through `GROK_BOT_HOUSE`, or by walking up when that variable is unset, and FAILs with `house/EXAMPLE.md exists — delete it` when that file is present. A wake reads the station, then the board files in `house/`.
+A state flow plate: the stages a house goes through before doctor says House: PASS.
 
 ```
-┌──────────────────────────────────────────────────────────────┐
-│ INPUT LAYER                                                  │
-│                                                              │
-│   npx @0xray/grok-bot house init                             │
-│   copies HOUSE.md, WAVEBOARD.md, ATTENTION_STATE.md only     │
-│   refuses if a target file is already there                  │
-└──────────────────────────────┬───────────────────────────────┘
-                               v
-┌──────────────────────────────┼───────────────────────────────┐
-│ PROCESSING LAYER             v                               │
-│                                                              │
-│   ┌──────────────────────────────────────────────────────┐   │
-│   │ HOUSE.md — six headings                              │   │
-│   │ owner · seats · public voice · allowed · ask first   │   │
-│   │ board: WAVEBOARD.md + ATTENTION_STATE.md             │   │
-│   │ the owner approves Allowed before it counts          │   │
-│   └───────────────────────────┬──────────────────────────┘   │
-│                                v                             │
-│   ┌──────────────────────────────────────────────────────┐   │
-│   │ grok-bot doctor                                      │   │
-│   │ GROK_BOT_HOUSE, or walk up for house/HOUSE.md        │   │
-│   │ a set path that is missing warns and does not walk   │   │
-│   │ a line that starts with (example) fails              │   │
-│   │ house/EXAMPLE.md exists — delete it                  │   │
-│   └───────────────────────────┬──────────────────────────┘   │
-└──────────────────────────────┼───────────────────────────────┘
-                               v
-┌──────────────────────────────┼───────────────────────────────┐
-│ OUTPUT LAYER                 v                               │
-│                                                              │
-│   read the station, then house/WAVEBOARD.md                  │
-│   and house/ATTENTION_STATE.md                               │
-│   a missing board file uses templates/house/                 │
-│   one card, one owner                                        │
-│   change the house when the owner says a rule twice          │
-└──────────────────────────────────────────────────────────────┘
-
+  ┌──────────────────────────────┐
+  │ EMPTY                        │
+  ├──────────────────────────────┤
+  │ · no house/ folder yet       │
+  └──────────────────────────────┘
+                  │  house init
+                  v
+  ┌──────────────────────────────┐
+  │ STARTER FILES COPIED         │
+  ├──────────────────────────────┤
+  │ · copy starter               │
+  │ · HOUSE.md, WAVEBOARD.md,    │
+  │   ATTENTION_STATE.md         │
+  └──────────────────────────────┘
+                  │
+                  v
+  ┌──────────────────────────────┐
+  │ HEADINGS FILLED              │ <──────────┐
+  ├──────────────────────────────┤            │
+  │ · fill six headings          │            │
+  │ · owner, seats, public voice │            │
+  │   allowed, ask first, board  │            │
+  └──────────────────────────────┘            │
+                  │                           │
+                  v                           │
+  ┌──────────────────────────────┐            │  not yet
+  │ OWNER APPROVES               │            │
+  ├──────────────────────────────┤            │
+  │ · owner approves Allowed     │            │
+  │ · doctor cannot check this   │            │
+  └──────────────────────────────┘            │
+                  │                           │
+                  v                           │
+  ┌──────────────────────────────┐            │
+  │ DOCTOR · House: PASS?        │ ───────────┘
+  ├──────────────────────────────┤
+  │ · doctor checks it           │
+  │ · yes: House: PASS           │
+  └──────────────────────────────┘
 ```
 
-stamped · 0xray · @0xray/grok-bot 0.1.7
+stamped · 0xray 4.0.30 · @0xray/grok-bot 0.1.8

package/docs-site/docs/plates/index.md

@@ -13,4 +13,16 @@ The station card stays the short subsystem table. That table is the index still
 
 The markdown file is the source of truth for that stamp. When the pipeline changes, edit the plate. A worn project may hold a copy at `.xray/state/plates/<id>.md`. The copy is written only when that file is missing, so a local edit stays.
 
-[Routing](./routing.md) · [Governance](./governance.md) · [Boot](./boot.md) · [Orchestration](./orchestration.md) · [Processor](./processor.md) · [Reporting](./reporting.md) · [Memory recall](./memory-recall.md) · [House](./house.md)
+Plates have a type. A domain model plate shows how named parts fit. A state flow plate shows the stages one thing goes through.
+
+## Domain model
+
+[Goggles](./goggles.md) · [Suit](./suit.md) · [Kits](./kits.md) · [Host Pack](./host-pack.md) · [Glossary](./glossary.md) · [Grok Bot](./grokbot.md)
+
+## State flow
+
+[House](./house.md)
+
+## Not yet typed
+
+[Routing](./routing.md) · [Governance](./governance.md) · [Boot](./boot.md) · [Orchestration](./orchestration.md) · [Processor](./processor.md) · [Reporting](./reporting.md) · [Memory recall](./memory-recall.md)

package/docs-site/docs/plates/kits.md

@@ -0,0 +1,28 @@
+---
+title: Kits
+sidebar_label: Kits
+plate_type: domain model
+---
+
+# Kits
+
+Add a power. Memory, judgment, or payments.
+
+```
+  ┌──────────────────────┐  ┌──────────────────────┐  ┌──────────────────────┐
+  │ REPERTOIRE           │  │ DYNAMO               │  │ CLEARING             │
+  ├──────────────────────┤  ├──────────────────────┤  ├──────────────────────┤
+  │ · it remembers       │  │ · yes or no          │  │ · you pay            │
+  │ · the lesson stays   │  │ · before it ships    │  │ · you get a receipt  │
+  └──────────────────────┘  └──────────────────────┘  └──────────────────────┘
+  
+  ┌────────────────────────────────────────────────────────────┐
+  │ NOT POWERS                                                 │
+  ├────────────────────────────────────────────────────────────┤
+  │ · the team folder                                          │
+  │ · the shop that builds                                     │
+  │ · where the suit runs                                      │
+  └────────────────────────────────────────────────────────────┘
+```
+
+Three. That's the set.

package/docs-site/docs/plates/suit.md

@@ -0,0 +1,40 @@
+---
+title: Suit
+sidebar_label: Suit
+plate_type: domain model
+---
+
+# Suit
+
+Give your agent a suit. The rules stay on, you add powers, and it runs in the tool you already open.
+
+```
+  ┌────────────────────────────────────────────────────────────┐
+  │ SUIT · what it wears                                       │
+  ├────────────────────────────────────────────────────────────┤
+  │ · the rules stay on                                        │
+  │ · you put it on once                                       │
+  │ · it builds the factories                                  │
+  └────────────────────────────────────────────────────────────┘
+                                │
+                          you add powers
+                                v
+  ┌────────────────────────────────────────────────────────────┐
+  │ WHERE IT RUNS                                              │
+  ├────────────────────────────────────────────────────────────┤
+  │ · the tool you already open                                │
+  │ · grok-bot · Hermes · OpenCode                             │
+  │ · OpenClaw · Grok CLI · Cursor                             │
+  └────────────────────────────────────────────────────────────┘
+                                │
+                           they snap on
+                                v
+  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐
+  │ REPERTOIRE       │  │ DYNAMO           │  │ CLEARING         │
+  │ · memory         │  │ · judgment       │  │ · payments       │
+  └──────────────────┘  └──────────────────┘  └──────────────────┘
+  
+    goggles views one plane
+```
+
+Same rules in the repo. You are not locked into one app.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "4.0.30",
+  "version": "4.0.32",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",
@@ -170,6 +170,7 @@
     "scripts/mjs/verify-temperament-live.mjs",
     "scripts/mjs/verify-four-floor-compact.mjs",
     "scripts/mjs/run-repertoire-mcp.mjs",
+    "scripts/mjs/run-goggles-mcp.mjs",
     "scripts/mjs/verify-delegation-gate-core.mjs",
     "scripts/mjs/delegation-gate-fixture.mjs",
     "src/opencode/",

package/scripts/foundry/assert-packed-dist-cli.mjs

@@ -29,8 +29,17 @@ export const REQUIRED_PACK_PATHS = [
   "dist/integrations/cursor/hooks/pre-compact.sh",
   "dist/integrations/cursor/hooks/after-file-edit.sh",
   "dist/integrations/hooks/plates.cjs",
+  "dist/integrations/hooks/goggles-pipeline.mjs",
+  "dist/integrations/hooks/goggles-planes.json",
+  "dist/integrations/hooks/goggles-mcp.mjs",
+  "scripts/mjs/run-goggles-mcp.mjs",
   "docs-site/docs/plates/memory-recall.md",
   "docs-site/docs/plates/processor.md",
+  "docs-site/docs/plates/goggles.md",
+  "docs-site/docs/plates/suit.md",
+  "docs-site/docs/plates/kits.md",
+  "docs-site/docs/plates/host-pack.md",
+  "docs-site/docs/plates/glossary.md",
 ];
 
 export function packedFilePaths(files) {