0xray 3.4.1 → 3.4.2

package/dist/nucleus/autonomy-kernel.js

@@ -0,0 +1,176 @@
+/**
+ * Lead-dev plan builder — internal implementation for orchestrator + hooks.
+ * Config: features.json → multi_agent_orchestration (lead_dev_mode), NOT a separate surface.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { featuresConfigLoader } from '../core/features-config.js';
+import { scoreComplexity } from './thin-dispatch.js';
+export const LEAD_DEV_RULES = [
+    'Phased plan + detailed todos; assign best subagent; monitor output; iterate fully',
+    'Lead dev takes helm — loop test fix until complete; no permission pings',
+    'Per-suite test triage after major changes; full suite only when individuals pass',
+    'Lead stays main thread; subagents execute; update todos continuously',
+    'Read all console and test output; triage fix rerun',
+    'Never defer errors as pre-existing — add todo and resolve',
+    'Resolve all errors before phase completion',
+];
+export const MANDATORY_MAJOR_CONSULTS = [
+    'researcher',
+    'architect-tools',
+    'code-review',
+];
+const TASK_TYPE_ROUTES = {
+    plan: 'strategist',
+    architecture: 'architect-tools',
+    research: 'researcher',
+    implement: 'backend-engineer',
+    frontend: 'frontend-engineer',
+    test: 'bug-triage',
+    review: 'code-review',
+    security: 'security-audit',
+    governance: 'enforcer',
+};
+function orchestrationConfig() {
+    try {
+        return featuresConfigLoader.loadConfig().multi_agent_orchestration;
+    }
+    catch {
+        return { enabled: true };
+    }
+}
+export function isLeadDevModeActive() {
+    const cfg = orchestrationConfig();
+    return cfg.enabled && cfg.lead_dev_mode !== false;
+}
+export function routeSubagent(taskType) {
+    return TASK_TYPE_ROUTES[taskType.toLowerCase().trim()] ?? 'backend-engineer';
+}
+export function shouldFlagFullTestSuite(command) {
+    const cfg = orchestrationConfig();
+    if (!cfg.enabled || cfg.per_suite_test_triage === false)
+        return false;
+    const cmd = command.toLowerCase();
+    const isTest = /\b(npm\s+(run\s+)?test|vitest\s+run|pnpm\s+test|yarn\s+test)\b/.test(cmd);
+    const hasFocusedTarget = /--\s+\S+\.test/.test(cmd) ||
+        /vitest\s+run\s+\S+\.test/.test(cmd) ||
+        /\btest:\w+/.test(cmd);
+    return isTest && !hasFocusedTarget;
+}
+export function buildLeadDevPlan(description, taskTypes = ['implement']) {
+    if (!isLeadDevModeActive())
+        return null;
+    const cfg = orchestrationConfig();
+    const threshold = cfg.phased_plan_threshold ?? 25;
+    const score = scoreComplexity(description, { taskTypes });
+    const complexity = score.score;
+    const requiresPhasedPlan = complexity > threshold;
+    const mandatoryConsults = cfg.auto_consult_major_work !== false && requiresPhasedPlan
+        ? [...MANDATORY_MAJOR_CONSULTS]
+        : [];
+    const phases = requiresPhasedPlan
+        ? [
+            {
+                id: 'phase-1',
+                name: 'Research & architecture',
+                goal: 'Understand scope before edits',
+                definitionOfDone: 'researcher + architect-tools + code-review consulted',
+                todos: mandatoryConsults.map((subagent, i) => ({
+                    id: `1.${i + 1}`,
+                    task: `Consult ${subagent} on: ${description.slice(0, 120)}`,
+                    subagent: subagent,
+                    status: 'pending',
+                })),
+            },
+            {
+                id: 'phase-2',
+                name: 'Implementation',
+                goal: 'Execute with best subagent per todo',
+                definitionOfDone: 'Affected per-suite tests green',
+                todos: taskTypes.map((type, i) => ({
+                    id: `2.${i + 1}`,
+                    task: description.slice(0, 200),
+                    subagent: routeSubagent(type),
+                    status: 'pending',
+                })),
+            },
+            {
+                id: 'phase-3',
+                name: 'Verification',
+                goal: 'Per-suite triage then full suite gate',
+                definitionOfDone: 'Full test suite green; zero open errors',
+                todos: [
+                    {
+                        id: '3.1',
+                        task: 'Run affected test files individually; triage and fix',
+                        subagent: 'bug-triage',
+                        status: 'pending',
+                    },
+                    {
+                        id: '3.2',
+                        task: 'Run full test suite gate',
+                        subagent: 'bug-triage',
+                        status: 'pending',
+                    },
+                ],
+            },
+        ]
+        : [
+            {
+                id: 'phase-1',
+                name: 'Direct execution',
+                goal: description.slice(0, 120),
+                definitionOfDone: 'Task complete with tests green',
+                todos: [
+                    {
+                        id: '1.1',
+                        task: description.slice(0, 200),
+                        subagent: routeSubagent(taskTypes[0] ?? 'implement'),
+                        status: 'pending',
+                    },
+                ],
+            },
+        ];
+    return {
+        active: true,
+        rules: LEAD_DEV_RULES,
+        codexTerms: [59, 67, 68, 69],
+        description,
+        complexity,
+        requiresPhasedPlan,
+        recommendedStrategy: score.recommendedStrategy,
+        mandatoryConsults,
+        phases,
+        testProtocol: {
+            perSuiteFirst: cfg.per_suite_test_triage !== false,
+            fullSuiteGate: true,
+            hint: 'After major changes: npm test -- path/to/file.test.ts → fix → repeat → full npm test last',
+        },
+    };
+}
+export function buildSessionBootContext() {
+    if (!isLeadDevModeActive()) {
+        return { lead_dev_mode: false, reason: 'multi_agent_orchestration.lead_dev_mode=false' };
+    }
+    return {
+        lead_dev_mode: true,
+        codexTerms: [67, 68],
+        rules: LEAD_DEV_RULES,
+        mcpBoot: 'xray-orchestrator → analyze-complexity (includes lead-dev plan when active)',
+        message: '[0xRay] Lead dev mode ON — phased todos, subagent dispatch, loop until green.',
+    };
+}
+/** Persist plan for PreToolUse spawn_subagent gate */
+export function persistLeadDevPlan(plan, projectRoot = process.cwd()) {
+    const stateDir = path.join(projectRoot, '.xray', 'state');
+    fs.mkdirSync(stateDir, { recursive: true });
+    const planPath = path.join(stateDir, 'lead-dev-plan.json');
+    const payload = { ...plan, persistedAt: new Date().toISOString() };
+    fs.writeFileSync(planPath, JSON.stringify(payload, null, 2));
+    return planPath;
+}
+/** @deprecated Use isLeadDevModeActive */
+export const isAutonomyKernelActive = isLeadDevModeActive;
+/** @deprecated Use buildLeadDevPlan */
+export const buildAutonomyIntake = buildLeadDevPlan;
+export const AUTONOMY_RULES = LEAD_DEV_RULES;

package/dist/nucleus/index.js

@@ -8,4 +8,5 @@ export { handleGovernRequest, governSingle, getGovernanceService, GovernHTTPAdap
 export { pluginRegistry, } from './plugin-registry.js';
 export { scoreComplexity, routeToAgent, scoreAndRoute } from './thin-dispatch.js';
 export { NUCLEUS_THIN_DISPATCH_VERSION } from './thin-dispatch.js';
+export { LEAD_DEV_RULES, isLeadDevModeActive, buildLeadDevPlan, buildSessionBootContext, shouldFlagFullTestSuite, } from './autonomy-kernel.js';
 export { registerDefaultPlugins } from './default-plugins.js';

package/dist/skills/boot-orchestrator/SKILL.md

@@ -28,10 +28,6 @@ Framework initialization and boot orchestration.
 - **initialization**: Initialization
 - **framework_startup**: Framework startup
 
-## Usage
-
-This skill provides infrastructure capabilities for boot orchestrator functionality.
-
 ## Integration
 
-Activated when infrastructure capabilities are requested through the skills system.
+Lead-dev boot is handled by SessionStart hook + `orchestrator` skill — see `multi_agent_orchestration.lead_dev_mode` in features.json.

package/dist/skills/orchestrator/SKILL.md

@@ -1,11 +1,11 @@
 ---
 source: framework
 name: orchestrator
-description: Multi-agent workflow coordination and task delegation
+description: Multi-agent workflow coordination, lead-dev operating model (codex 67-68), and task delegation. Default when suit is worn — no keywords required.
 author: Xray Framework
 version: 1.0.0
 schema_version: "1.0"
-tags: [orchestration, orchestrator]
+tags: [orchestration, orchestrator, lead-dev]
 capabilities:
   - coordinate_agents
   - delegate_tasks
@@ -18,20 +18,43 @@ mcp:
     args: [node_modules/0xray/dist/mcps/orchestrator.server.js]
 ---
 
-# Orchestrator Skill
+# Orchestrator Skill — includes lead-dev operating model
 
-Multi-agent workflow coordination and task delegation.
+When `multi_agent_orchestration.lead_dev_mode` is true in `features.json` (default when suit is worn), this is the **default OS behavior** — not a separate skill or MCP.
 
-## Tools Available
+## Seven rules (codex 67–68)
 
-- **task_coordination**: Task coordination
-- **agent_delegation**: Agent delegation
-- **workflow_management**: Workflow management
+1. Phased plan + detailed todos; assign best subagent; monitor output
+2. Lead dev loops test→fix until green; no permission pings
+3. Per-suite test triage after major changes; full suite last
+4. Lead stays main thread; subagents execute; update todos
+5. Read all console and test output; triage fix rerun
+6. Never defer errors as "pre-existing" — add todo and resolve
+7. Resolve all errors before phase completion
 
-## Usage
+## MCP loop (one tool surface — no autonomy-intake)
 
-This skill provides orchestration capabilities for orchestrator functionality.
+| Step | MCP tool | Notes |
+|------|----------|-------|
+| **Intake + classify** | `analyze-complexity` | Pass `tasks` array; response includes **lead-dev plan JSON** when mode is on |
+| Delegate | `orchestrate-task` | Include agent + sessionId (codex 67) |
+| Monitor | `get-orchestration-status` | Lead updates todos |
+| Major work | researcher + architect-tools + code-review | Auto-listed in plan when complexity > threshold |
 
-## Integration
+## Subagent routing
 
-Activated when orchestration capabilities are requested through the skills system.
+| Task | Subagent |
+|------|----------|
+| Phasing | strategist |
+| Architecture | architect-tools |
+| Research | researcher |
+| Implementation | backend-engineer / frontend-engineer |
+| Test failures | bug-triage |
+| Review | code-review |
+
+## Hooks (rewired, not new MCPs)
+
+- **SessionStart** → `session-start.js` boots lead_dev_mode
+- **PreToolUse** → hints `per_suite_triage_required` on full `npm test`
+
+Config: `features.json` → `multi_agent_orchestration.lead_dev_mode`

package/dist/skills/researcher/SKILL.md

@@ -28,10 +28,23 @@ Multi-repo analysis, documentation lookup, and implementation examples.
 - **find_implementations**: Find implementations
 - **analyze_documentation**: Analyze documentation
 
-## Usage
+## When to invoke (autonomy-command)
 
-This skill provides research capabilities for researcher functionality.
+Lead dev dispatches researcher **before** major planning, refactors, or cross-repo work — not only when user says "research."
 
-## Integration
+| Trigger | Action |
+|---------|--------|
+| Major refactor / new phase | `search_codebase`, `get_documentation`, `find_implementation` |
+| Prior art / patterns | Search sibling repos (xray, groover, repertoire) |
+| Proposal analysis | `analyze_proposal` via xray-researcher MCP |
 
-Activated when research capabilities are requested through the skills system.
+## MCP tools (xray-researcher)
+
+- `get_documentation` — module/class docs (`target` required)
+- `search_codebase` — text search in workspace
+- `find_implementation` — locate implementations
+- `analyze_proposal` — governance-aware proposal review
+
+## Return shape for lead
+
+Summarize: findings (3–5 bullets), file paths, recommended next todos. Do not defer work back to lead without concrete patches or todos.

package/dist/skills/strategist/SKILL.md

@@ -30,3 +30,15 @@ Think deeply before recommending. Consider trade-offs and long-term implications
 - Risk analysis and mitigation planning
 - High-level system design and framework evolution
 - Technical debt identification and prioritization
+
+## When to invoke (autonomy-command)
+
+Lead dev dispatches strategist when `analyze-complexity` score **>25** or work spans multiple repos/phases.
+
+| Output required | Format |
+|-----------------|--------|
+| Phased plan | Phase N + goal + definition of done |
+| Todo breakdown | ID, task, subagent assignment |
+| Risks | Top 3 with mitigations |
+
+Use `orchestrate-task` or Task subagent. Return actionable todos — not essays.

package/dist/skills/testing-strategy/SKILL.md

@@ -38,6 +38,17 @@ This skill helps design and optimize testing strategies for:
 - Test coverage optimization
 - Testing best practices implementation
 
-## Integration
+## Per-suite triage (autonomy-command rule 3)
 
-Provides testing expertise and coverage analysis when requested through the skills system.
+After major changes, **do not** run the full test suite first.
+
+```text
+1. Identify affected test file(s) from the diff
+2. Run ONE suite: npm test -- path/to/focused.test.ts
+3. Read ALL failure output — triage root cause
+4. Fix → rerun that suite until green
+5. Repeat for each affected suite
+6. Only then: npm test (full suite gate)
+```
+
+Lead dev owns every failure. No "pre-existing" deferrals.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "3.4.1",
+  "version": "3.4.2",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",
@@ -55,12 +55,16 @@
     "plugin": "./dist/plugin/xray-codex-injection.js",
     "mcps": "./dist/mcps/"
   },
+  "xray": {
+    "dist": "dist",
+    "mcpServersPath": "dist/mcps"
+  },
   "scripts": {
-    "prepublishOnly": "npm run prepare-consumer && npm run build:all && find dist -name '*.d.ts' -o -name '*.d.ts.map' -o -name '*.js.map' | xargs rm -f",
+    "prepublishOnly": "node scripts/node/reconcile-version.mjs --check && npm run prepare-consumer && npm run build:all && find dist -name '*.d.ts' -o -name '*.d.ts.map' -o -name '*.js.map' | xargs rm -f",
     "version:bump": "node scripts/node/version-manager.mjs",
     "version": "node scripts/node/version-manager.mjs",
     "prebuild": "rm -rf dist tsconfig.tsbuildinfo tsconfig.*.tsbuildinfo",
-    "build": "tsc && mkdir -p dist/public dist/scripts && cp -r public/* dist/public/ && cp scripts/hooks/pre-command dist/scripts/ && cp scripts/hooks/pre-command.mjs dist/scripts/ && cp README.md AGENTS.md SKILLS.md CHANGELOG.md LICENSE .gitignore.default dist/ && find src -name '*.mjs' ! -path '*/__tests__/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done && for dir in skills integrations mcps; do find src/$dir -type f ! -name '*.ts' ! -path '*/.pytest_cache/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done; done && mkdir -p dist/plugin && (find dist/plugin -name '*codex-injection*.js' -exec cp {} dist/plugin/xray-codex-injection.js \\; 2>/dev/null || true) && cp -r src/opencode/ .opencode/ && mkdir -p .xray && cp xray/codex.json .xray/codex.json 2>/dev/null || true",
+    "build": "tsc && mkdir -p dist/public dist/scripts && cp -r public/* dist/public/ && cp scripts/hooks/pre-command dist/scripts/ && cp scripts/hooks/pre-command.mjs dist/scripts/ && cp README.md AGENTS.md SKILLS.md CHANGELOG.md LICENSE .gitignore.default dist/ && find src -name '*.mjs' ! -path '*/__tests__/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done && for dir in skills integrations mcps; do find src/$dir -type f ! -name '*.ts' ! -path '*/.pytest_cache/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done; done && mkdir -p dist/plugin && (find dist/plugin -name '*codex-injection*.js' -exec cp {} dist/plugin/xray-codex-injection.js \\; 2>/dev/null || true) && cp -r src/opencode/ .opencode/ && mkdir -p .xray && for f in codex.json features.json features.schema.json config.json; do cp xray/$f .xray/$f 2>/dev/null || true; done",
     "build:all": "npm run build",
     "ci-install": "npm ci",
     "clean": "rm -rf dist tsconfig.tsbuildinfo tsconfig.*.tsbuildinfo",
@@ -94,6 +98,7 @@
     "test:dependency-scan": "npm run security-audit",
     "test:integration": "node scripts/mjs/test-consumer-readiness.mjs && node scripts/mjs/test-mcp-functionality.mjs",
     "test:e2e": "node scripts/node/validate-mcp-connectivity.js && node scripts/node/validate-external-processes.js",
+    "live-feedback-session": "npx --yes tsx scripts/live-taskhandler-feedback-session.ts",
     "validate": "echo \"[xray] Use 'npm test' or 'npm run test:comprehensive'.\"",
     "validate:quick": "npm run validate",
     "debug:inference:force": "XRAY_FORCE_MCP_GOVERNANCE=true XRAY_DEV_PATH=dist node dist/cli/index.js inference:run --force",
@@ -108,15 +113,18 @@
     "build:clean": "node scripts/build/utils.js clean",
     "build:verify": "node scripts/build/utils.js verify",
     "enforce:versions": "bash scripts/node/enforce-version-compliance.sh",
-    "version:sync": "node scripts/node/universal-version-manager.js",
-    "preversion": "npm run version:sync",
-    "release": "node scripts/node/release.js",
+    "version:sync": "node scripts/node/version-manager.mjs --artifacts-only",
+    "release": "node scripts/node/release.mjs patch",
     "release:minor": "node scripts/node/release.mjs minor",
     "release:major": "node scripts/node/release.mjs major",
-    "release:dry": "node scripts/node/release.js --dry-run",
+    "release:dry": "node scripts/node/release.mjs patch --dry-run",
+    "version:reconcile": "node scripts/node/reconcile-version.mjs",
+    "consumer:smoke": "node scripts/node/consumer-install-smoke.mjs",
+    "release:gate": "node scripts/node/release-gate.mjs",
+    "release:docs-check": "node scripts/node/validate-release-docs.mjs",
     "pre-publish-guard": "node scripts/node/pre-publish-guard.js",
     "safe-publish": "npm run prepare-consumer && npm run build",
-    "publish": "npm run pre-publish-guard && npm run safe-publish",
+    "publish": "npm run release:gate && npm run safe-publish && npm publish --access public",
     "release:patch": "node scripts/node/release.mjs patch"
   },
   "files": [
@@ -155,6 +163,13 @@
     "SKILLS.md",
     "xray/agents_template.md",
     "xray/codex.json",
+    "xray/features.json",
+    "xray/features.schema.json",
+    "xray/config.json",
+    ".xray/codex.json",
+    ".xray/features.json",
+    ".xray/features.schema.json",
+    ".xray/config.json",
     ".gitignore.default",
     "LICENSE"
   ],

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

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * consumer-install-smoke.mjs — Clean-room pack + install verification.
+ *
+ * Simulates what consumers receive from npm without publishing.
+ *
+ * Usage:
+ *   node scripts/node/consumer-install-smoke.mjs
+ */
+
+import { execSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(__dirname, "../..");
+
+const XRAY_MCP_NAMES = [
+  "xray-governance",
+  "xray-skills",
+  "xray-orchestrator",
+  "xray-enforcer",
+  "xray-researcher",
+  "xray-code-review",
+  "xray-architect-tools",
+];
+
+function run(cmd, cwd, { inherit = false } = {}) {
+  const result = execSync(cmd, {
+    cwd,
+    encoding: inherit ? undefined : "utf-8",
+    stdio: inherit ? "inherit" : "pipe",
+  });
+  return inherit ? "" : String(result).trim();
+}
+
+function main() {
+  console.log("\n=== Consumer Install Smoke ===\n");
+
+  const pkg = JSON.parse(fs.readFileSync(path.join(rootDir, "package.json"), "utf-8"));
+  const version = pkg.version;
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "0xray-smoke-"));
+  let tarball = null;
+
+  try {
+    console.log("📦 npm pack...");
+    const packOut = run("npm pack --silent", rootDir);
+    tarball = packOut.split("\n").filter(Boolean).pop();
+    const tarballPath = path.join(rootDir, tarball);
+    if (!fs.existsSync(tarballPath)) {
+      throw new Error(`Tarball not found: ${tarballPath}`);
+    }
+
+    const consumerPkg = {
+      name: "0xray-smoke-consumer",
+      private: true,
+      version: "1.0.0",
+      dependencies: {
+        "0xray": `file:${tarballPath}`,
+      },
+    };
+    fs.writeFileSync(
+      path.join(tmpRoot, "package.json"),
+      JSON.stringify(consumerPkg, null, 2) + "\n",
+    );
+
+    console.log("📥 npm install (runs postinstall)...");
+    run("npm install", tmpRoot, { inherit: true });
+
+    const nmRoot = path.join(tmpRoot, "node_modules", "0xray");
+    const requiredFiles = [
+      "scripts/node/install-bridges.cjs",
+      "scripts/node/postinstall.cjs",
+      "package.json",
+      "xray/features.json",
+      "xray/features.schema.json",
+    ];
+
+    for (const rel of requiredFiles) {
+      const full = path.join(nmRoot, rel);
+      if (!fs.existsSync(full)) {
+        throw new Error(`Missing in tarball install: ${rel}`);
+      }
+      console.log(`  ✅ ${rel}`);
+    }
+
+    const installedPkg = JSON.parse(fs.readFileSync(path.join(nmRoot, "package.json"), "utf-8"));
+    if (installedPkg.version !== version) {
+      throw new Error(`Installed version ${installedPkg.version} != packed ${version}`);
+    }
+
+    const bridges = require(path.join(nmRoot, "scripts/node/install-bridges.cjs"));
+    for (const exp of ["installAllBridges", "resolveConsumerTargetDir", "isConsumerInstall"]) {
+      if (typeof bridges[exp] !== "function") {
+        throw new Error(`install-bridges missing export: ${exp}`);
+      }
+    }
+    console.log("  ✅ install-bridges exports");
+
+    if (!bridges.isConsumerInstall(nmRoot, tmpRoot)) {
+      throw new Error("isConsumerInstall should be true for node_modules/0xray → project root");
+    }
+    console.log("  ✅ consumer target resolution");
+
+    // Postinstall should have run; verify .mcp.json merge
+    const mcpPath = path.join(tmpRoot, ".mcp.json");
+    if (!fs.existsSync(mcpPath)) {
+      throw new Error(".mcp.json not created by postinstall");
+    }
+    const mcp = JSON.parse(fs.readFileSync(mcpPath, "utf-8"));
+    const servers = Object.keys(mcp.mcpServers || {});
+    for (const name of XRAY_MCP_NAMES) {
+      if (!servers.includes(name)) {
+        throw new Error(`Missing MCP server in .mcp.json: ${name}`);
+      }
+      const entry = mcp.mcpServers[name];
+      if (entry.command !== "npx") {
+        throw new Error(`${name} should use npx, got ${entry.command}`);
+      }
+    }
+    console.log(`  ✅ .mcp.json has ${XRAY_MCP_NAMES.length} npx MCP servers`);
+
+    const consumerFeaturesPath = path.join(tmpRoot, ".xray", "features.json");
+    if (!fs.existsSync(consumerFeaturesPath)) {
+      throw new Error(".xray/features.json not deployed to consumer project by postinstall");
+    }
+    const features = JSON.parse(fs.readFileSync(consumerFeaturesPath, "utf-8"));
+    if (!features.memory_routing) {
+      throw new Error("Deployed features.json missing memory_routing block");
+    }
+    console.log("  ✅ .xray/features.json deployed with memory_routing");
+
+    const schemaInPackage = path.join(nmRoot, "xray", "features.schema.json");
+    if (!fs.existsSync(schemaInPackage)) {
+      throw new Error("xray/features.schema.json missing from installed package");
+    }
+    console.log("  ✅ xray/features.schema.json in package");
+
+    console.log("\n✅ Consumer install smoke passed\n");
+  } catch (err) {
+    console.error(`\n❌ Consumer smoke failed: ${err.message}\n`);
+    process.exit(1);
+  } finally {
+    if (tarball) {
+      try {
+        fs.unlinkSync(path.join(rootDir, tarball));
+      } catch {
+        /* best-effort */
+      }
+    }
+    try {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    } catch {
+      /* best-effort */
+    }
+  }
+}
+
+main();

package/scripts/node/install-bridges.cjs

@@ -397,18 +397,27 @@ function installOpenclawBridge(targetDir, packageRoot, log) {
   if (copied > 0) log("openclaw-bridge", `skills synced (${copied})`, "info", { path: "~/.openclaw/skills/" });
 }
 
+const XRAY_CONFIG_FILES = ["codex.json", "features.json", "features.schema.json", "config.json"];
+
+function resolveXrayConfigSource(packageRoot, file) {
+  const dotXray = path.join(packageRoot, ".xray", file);
+  if (fs.existsSync(dotXray)) return dotXray;
+  const xrayDir = path.join(packageRoot, "xray", file);
+  if (fs.existsSync(xrayDir)) return xrayDir;
+  return null;
+}
+
 function deployXrayConfig(targetDir, packageRoot, log) {
-  const xraySourceDir = path.join(packageRoot, ".xray");
   const xrayTargetDir = path.join(targetDir, ".xray");
-  const configFiles = ["codex.json", "features.json", "config.json"];
-  if (!fs.existsSync(xraySourceDir)) return;
+  const hasAnySource = XRAY_CONFIG_FILES.some((file) => resolveXrayConfigSource(packageRoot, file));
+  if (!hasAnySource) return;
 
   if (!fs.existsSync(xrayTargetDir)) fs.mkdirSync(xrayTargetDir, { recursive: true });
   let copied = 0;
-  for (const file of configFiles) {
-    const src = path.join(xraySourceDir, file);
+  for (const file of XRAY_CONFIG_FILES) {
+    const src = resolveXrayConfigSource(packageRoot, file);
     const dst = path.join(xrayTargetDir, file);
-    if (!fs.existsSync(src)) continue;
+    if (!src) continue;
     const shouldCopy = !fs.existsSync(dst) || fs.statSync(src).mtime > fs.statSync(dst).mtime;
     if (shouldCopy) {
       fs.copyFileSync(src, dst);
@@ -416,6 +425,7 @@ function deployXrayConfig(targetDir, packageRoot, log) {
     }
   }
   if (copied > 0) log("xray-config", `${copied} files deployed`, "info", { path: ".xray/" });
+  return copied;
 }
 
 function installGitHooks(packageRoot, log) {
@@ -463,4 +473,7 @@ module.exports = {
   resolveConsumerTargetDir,
   syncBuiltinSkills,
   isConsumerInstall,
+  deployXrayConfig,
+  resolveXrayConfigSource,
+  XRAY_CONFIG_FILES,
 };