0xray 3.3.1 → 3.4.2

package/dist/integrations/grok/hooks/session-start.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+/**
+ * Grok SessionStart / UserPromptSubmit — writes session-boot.json + activity.log.
+ * Stdout is ignored by Grok for these events; side effects are the suit contract.
+ */
+
+import {
+  buildSessionBootPayload,
+  ensureSessionBoot,
+  readStdinJson,
+  workspaceRoot,
+  writeSessionBoot,
+} from './grok-hook-utils.js';
+import { appendHookActivity } from './grok-hook-activity.js';
+
+const HOOK_EVENT = process.env.GROK_HOOK_EVENT || 'session_start';
+
+async function main() {
+  const root = workspaceRoot();
+  try {
+    const event = await readStdinJson();
+    const eventRoot = event.workspaceRoot || event.cwd || root;
+    const source =
+      HOOK_EVENT === 'user_prompt_submit'
+        ? '0xray/grok-user-prompt-submit'
+        : '0xray/grok-session-start';
+
+    const payload = buildSessionBootPayload(eventRoot, source, {
+      hookEvent: HOOK_EVENT,
+      sessionId: event.sessionId || process.env.GROK_SESSION_ID || null,
+    });
+
+    const bootPath = writeSessionBoot(eventRoot, payload) || ensureSessionBoot(eventRoot, source);
+
+    appendHookActivity(eventRoot, 'grok-session-start', 'session-boot-written', 'success', {
+      bootPath,
+      hookEvent: HOOK_EVENT,
+      lead_dev_mode: payload.lead_dev_mode,
+    });
+
+    console.log(JSON.stringify(payload));
+    process.exit(0);
+  } catch (err) {
+    appendHookActivity(root, 'grok-session-start', 'session-boot-error', 'error', {
+      error: err.message,
+      hookEvent: HOOK_EVENT,
+    });
+    process.exit(0);
+  }
+}
+
+main();

package/dist/integrations/grok/plugin/0xray/hooks/hooks.json

@@ -20,11 +20,28 @@
         "hooks": [
           {
             "type": "command",
-            "command": "echo",
-            "args": ["[0xRay] Grok session started with 0xRay governance enabled"]
+            "command": "node",
+            "args": [
+              "${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js"
+            ],
+            "timeout": 15000
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node",
+            "args": [
+              "${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js"
+            ],
+            "timeout": 15000
           }
         ]
       }
     ]
   }
-}
+}

package/dist/integrations/hermes-agent/bridge.mjs

@@ -53,9 +53,19 @@ let frameworkLoadAttempted = false;
 
 // ── Project root detection ───────────────────────────────────
 function findProjectRoot() {
-  const envHome = process.env.XRAY_HOME;
+  const envHome = process.env.XRAY_HOME || process.env.XRAY_ROOT;
   if (envHome && existsSync(join(envHome, "package.json"))) return envHome;
 
+  const consumerMarker = join(__dirname, "xray-consumer-root.txt");
+  if (existsSync(consumerMarker)) {
+    try {
+      const marked = readFileSync(consumerMarker, "utf-8").trim();
+      if (marked && existsSync(join(marked, "package.json"))) return marked;
+    } catch {
+      // fall through
+    }
+  }
+
   const candidates = [
     process.cwd(),
     join(homedir(), "dev", "xray"),

package/dist/mcps/config/server-config-registry.js

@@ -38,10 +38,11 @@ function resolveFrameworkPaths() {
         if (fs.existsSync(pkgPath)) {
             try {
                 const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-                if (pkg.name === '0xray' && pkg.xray) {
-                    const xrayCfg = pkg.xray;
+                if (pkg.name === '0xray') {
+                    const xrayCfg = (pkg.xray ?? {});
                     const frameworkRoot = currentDir;
-                    const declaredMcp = xrayCfg.mcpServersPath || (xrayCfg.dist ? join(xrayCfg.dist, 'mcps') : 'dist/mcps');
+                    const declaredMcp = xrayCfg.mcpServersPath ||
+                        (xrayCfg.dist ? join(xrayCfg.dist, 'mcps') : 'dist/mcps');
                     return {
                         frameworkRoot,
                         mcpServersPath: join(frameworkRoot, declaredMcp),

package/dist/mcps/orchestrator/handlers/complexity-handler.js

@@ -4,6 +4,7 @@
  * Handles complexity analysis requests
  */
 import { frameworkLogger } from '../../../core/framework-logger.js';
+import { buildLeadDevPlan, isLeadDevModeActive, persistLeadDevPlan, } from '../../../nucleus/autonomy-kernel.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
 import { addObservations, extractComplexityObservations } from '../aside-context.js';
 /**
@@ -24,11 +25,24 @@ export class ComplexityHandler {
             if (asideId) {
                 addObservations(asideId, extractComplexityObservations(analysis));
             }
+            const primaryDescription = tasks.map((t) => t.description).filter(Boolean).join(' ');
+            const taskTypes = tasks.map((t) => t.type).filter(Boolean);
+            const leadDevPlan = isLeadDevModeActive() && primaryDescription
+                ? buildLeadDevPlan(primaryDescription, taskTypes.length ? taskTypes : ['implement'])
+                : null;
+            if (leadDevPlan) {
+                try {
+                    persistLeadDevPlan(leadDevPlan);
+                }
+                catch (err) {
+                    await frameworkLogger.log('orchestrator.server', 'lead-dev-plan-persist-failed', 'warning', { error: err instanceof Error ? err.message : String(err) });
+                }
+            }
             return {
                 content: [
                     {
                         type: 'text',
-                        text: this.formatComplexityResponse(analysis, recommendations, tasks.length),
+                        text: this.formatComplexityResponse(analysis, recommendations, tasks.length, leadDevPlan),
                     },
                 ],
             };
@@ -72,7 +86,23 @@ export class ComplexityHandler {
     /**
      * Format complexity response
      */
-    formatComplexityResponse(analysis, recommendations, taskCount) {
+    formatComplexityResponse(analysis, recommendations, taskCount, leadDevPlan = null) {
+        const leadDevSection = leadDevPlan
+            ? `
+
+**Lead-dev plan (codex ${leadDevPlan.codexTerms.join(', ')}):**
+${leadDevPlan.phases
+                .map((p) => `### ${p.id} — ${p.name}\n${p.todos
+                .map((t) => `- [ ] ${t.id} (${t.subagent}): ${t.task}`)
+                .join('\n')}`)
+                .join('\n\n')}
+
+**Test protocol:** ${leadDevPlan.testProtocol.hint}
+
+\`\`\`json
+${JSON.stringify(leadDevPlan, null, 2)}
+\`\`\``
+            : '';
         return `🔍 Complexity Analysis Results
 
 **Tasks Analyzed:** ${taskCount}
@@ -93,6 +123,6 @@ ${analysis.agentAssignments
 ${recommendations.map((r) => `• 💡 ${r}`).join('\n')}
 
 **Execution Estimate:** ${analysis.estimatedDuration}ms
-**Parallel Potential:** ${Math.round(analysis.parallelPotential * 100)}%`;
+**Parallel Potential:** ${Math.round(analysis.parallelPotential * 100)}%${leadDevSection}`;
     }
 }

package/dist/mcps/orchestrator/server.js

@@ -105,7 +105,7 @@ export class OrchestratorServer {
                     },
                     {
                         name: 'analyze-complexity',
-                        description: 'Analyze task complexity and recommend optimal orchestration strategy',
+                        description: 'Analyze task complexity and recommend orchestration strategy. When lead_dev_mode is on (features.json), includes phased plan + todos + subagent routes.',
                         inputSchema: {
                             type: 'object',
                             properties: {

package/dist/mcps/registry.json

@@ -1,5 +1,4 @@
 {
-  "version": "3.1.0",
   "description": "0xRay Community MCPs Registry - curated API-focused MCP servers",
   "sources": [
     {

package/dist/mcps/researcher.server.js

@@ -11,11 +11,14 @@ import * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { tryLLMGovernance } from "../governance/llm-governance-provider.js";
+import { initializeMemoryRouting } from "../memory-routing/index.js";
 import { buildMemoryRoutingEvidence, formatMemoryRoutingBlock, resolveResearcherMemoryContext, } from "./researcher-confidence.js";
 import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 class XrayLibrarianServer extends XrayKnowledgeSkillBase {
     constructor() {
         super("researcher", "3.1.0");
+        // Kick off MemoryRoutingProvider load so trap routing is ready in MCP subprocess mode.
+        initializeMemoryRouting();
         this.tools = [
             {
                 name: "search_codebase",

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/orchestrator/universal-registry-bridge.js

@@ -113,7 +113,7 @@ export class UniversalRegistryBridge {
                 currentAgent = {
                     name: nameMatch[1].trim(),
                     description: "",
-                    version: "3.1.0",
+                    version: "",
                 };
                 inAgent = true;
                 continue;

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/registry.json

@@ -1,5 +1,4 @@
 {
-  "version": "3.1.0",
   "description": "0xRay Skills Registry - recommended skill sources for consumers",
   "sources": [
     {

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.3.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"
   ],