0xray 3.5.0 → 3.5.1

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

@@ -52,33 +52,55 @@ let frameworkReady = false;
 let frameworkLoadAttempted = false;
 
 // ── Project root detection ───────────────────────────────────
+function isConsumerWorkspace(dir) {
+  return (
+    existsSync(join(dir, ".xray", "features.json")) ||
+    existsSync(join(dir, "node_modules", "0xray", "package.json"))
+  );
+}
+
 function findProjectRoot() {
   const envHome = process.env.XRAY_HOME || process.env.XRAY_ROOT;
-  if (envHome && existsSync(join(envHome, "package.json"))) return envHome;
+  if (envHome) {
+    const resolved = join(envHome);
+    if (existsSync(join(resolved, "package.json")) || isConsumerWorkspace(resolved)) {
+      return resolved;
+    }
+  }
 
   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;
+      if (marked && (existsSync(join(marked, "package.json")) || isConsumerWorkspace(marked))) {
+        return marked;
+      }
     } catch {
       // fall through
     }
   }
 
+  // Prefer consumer workspace (--cwd / process.chdir) over framework package root
+  let dir = process.cwd();
+  for (let i = 0; i < 12; i++) {
+    if (isConsumerWorkspace(dir)) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
   const candidates = [
-    process.cwd(),
     join(homedir(), "dev", "xray"),
-    join(dirname(__dirname), "..", "..", "..", ".."), // plugin dir -> project root
+    join(dirname(__dirname), "..", "..", "..", ".."), // plugin dir -> package root
   ];
 
-  for (const dir of candidates) {
+  for (const candidate of candidates) {
     try {
-      const pkgPath = join(dir, "package.json");
+      const pkgPath = join(candidate, "package.json");
       if (existsSync(pkgPath)) {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (pkg.name === "0xray" || pkg.dependencies?.["0xray"] || pkg.name === "0xray" || pkg.dependencies?.["0xray"]) {
-          return dir;
+        if (pkg.name === "0xray" || pkg.dependencies?.["0xray"]) {
+          return candidate;
         }
       }
     } catch {
@@ -786,9 +808,53 @@ async function handleApply(input, projectRoot, logDir) {
 // ── Known commands for positional-arg mode ──────────────────
 const KNOWN_COMMANDS = new Set([
   "health", "stats", "pre-process", "post-process", "validate", "codex-check", "hooks", "govern", "apply",
-  "skill-install", "skill-registry",
+  "skill-install", "skill-registry", "delegation-gate",
 ]);
 
+async function handleDelegationGate(command, projectRoot, logDir) {
+  try {
+    const gate = await import("../hooks/delegation-gate-runtime.mjs");
+    const phase = command.phase || "pre";
+    const tool = command.tool || command.toolName || "unknown";
+    const args = command.args || command.toolInput || {};
+    const sessionId = command.sessionId || command.taskId || null;
+    const host = command.host || "hermes";
+
+    if (phase === "post") {
+      if (!gate.isSubagentTool(tool)) {
+        return { allow: true, phase: "post", skipped: true };
+      }
+      const result = gate.evaluatePostToolSpawn(tool, args, projectRoot);
+      if (result.satisfied.length > 0) {
+        logToActivity(
+          logDir,
+          `[delegation-gate-post] satisfied=${result.satisfied.map((d) => d.id).join(",")} clearedAll=${result.clearedAll}`,
+        );
+      }
+      return { allow: true, phase: "post", ...result };
+    }
+
+    const features = gate.loadDelegationGateFeatures(projectRoot);
+    const outcome = gate.evaluatePreToolGate(tool, args, {
+      projectRoot,
+      sessionId,
+      features,
+      host,
+    });
+
+    if (!outcome.allow) {
+      logToActivity(
+        logDir,
+        `[delegation-gate] deny tool=${tool} gate=${outcome.gate} reason=${outcome.reason}`,
+      );
+    }
+
+    return { phase: "pre", ...outcome };
+  } catch (error) {
+    return { error: `delegation-gate failed: ${error.message || error}` };
+  }
+}
+
 // ── Skill management ──────────────────────────────────────────
 
 async function handleSkillInstall(command, projectRoot, logDir) {
@@ -918,6 +984,9 @@ async function main() {
     case "skill-registry":
       response = await handleSkillRegistry(command, projectRoot, logDir);
       break;
+    case "delegation-gate":
+      response = await handleDelegationGate(command, projectRoot, logDir);
+      break;
     default:
       response = { error: `Unknown command: ${cmd}` };
   }

package/dist/integrations/hooks/delegation-gate-runtime.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+/**
+ * Load compiled delegation-gate SSOT from consumer or package dist.
+ * Used by Grok hooks, Hermes bridge, and verify fixtures.
+ */
+import { createRequire } from 'node:module';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/** 0xray package root — never use consumer workspace env (GROK_WORKSPACE_ROOT / XRAY_ROOT). */
+function resolvePackageRoot() {
+  let dir = __dirname;
+  for (let i = 0; i < 10; i++) {
+    const pkg = join(dir, 'package.json');
+    if (existsSync(pkg)) {
+      try {
+        const require = createRequire(join(dir, 'package.json'));
+        const name = require('./package.json').name;
+        if (name === '0xray') return dir;
+      } catch {
+        /* continue */
+      }
+    }
+    const nm = join(dir, 'node_modules', '0xray', 'package.json');
+    if (existsSync(nm)) {
+      return dirname(nm);
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(__dirname, '../../..');
+}
+
+function loadDelegationGate() {
+  const root = resolvePackageRoot();
+  const candidates = [
+    join(__dirname, '../../nucleus/delegation-gate.js'),
+    join(root, 'dist/nucleus/delegation-gate.js'),
+    join(process.cwd(), 'node_modules/0xray/dist/nucleus/delegation-gate.js'),
+  ];
+  const found = candidates.find((p) => existsSync(p));
+  if (!found) {
+    throw new Error(
+      'delegation-gate.js missing — run npm run build in 0xray or npm install 0xray@^3.5.1',
+    );
+  }
+  return createRequire(import.meta.url)(found);
+}
+
+const gate = loadDelegationGate();
+
+export const {
+  loadDelegationGateFeatures,
+  normalizeHostToolInput,
+  evaluatePreToolGate,
+  evaluatePendingDelegationGate,
+  evaluateSpawnPlanGate,
+  evaluatePostToolSpawn,
+  checkPendingDelegationGate,
+  checkSubagentGate,
+  satisfyDelegationsFromToolInput,
+  isSubagentTool,
+  isOrchestrateToolEvent,
+  isReadOnlyTool,
+  isWriteTool,
+  isShellTool,
+  getActivePendingDelegations,
+  validateSpawnMatchesTodo,
+  updatePlanTodoStatus,
+  updatePlanTodoStatusInPlace,
+} = gate;

package/dist/nucleus/delegation-gate.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Multi-host delegation gate SSOT — pending-delegations + spawn todo enforcement.
+ * Grok / Hermes / OpenCode adapters call evaluatePreToolGate; Grok-only logic was
+ * previously duplicated in grok-hook-utils.js.
+ */
+import { type PendingDelegation } from './pending-delegations.js';
+export { getActivePendingDelegations } from './pending-delegations.js';
+import { updatePlanTodoStatus, type SpawnToolInput } from './lead-dev-plan-persistence.js';
+export { validateSpawnMatchesTodo, updatePlanTodoStatus, savePersistedLeadDevPlan, } from './lead-dev-plan-persistence.js';
+export declare const updatePlanTodoStatusInPlace: typeof updatePlanTodoStatus;
+export type DelegationGateHost = 'grok' | 'hermes' | 'opencode' | 'openclaw' | 'generic';
+export interface DelegationGateFeatures {
+    lead_dev_mode: boolean;
+    auto_chain_delegations: boolean;
+}
+export interface ToolGateInput {
+    prompt?: string;
+    description?: string;
+    task?: string;
+    subagent_type?: string;
+    agent?: string;
+    delegationId?: string;
+    delegation_id?: string;
+    planTodoId?: string;
+    command?: string;
+    path?: string;
+    file_path?: string;
+    filePath?: string;
+    toolName?: string;
+    tool?: string;
+    name?: string;
+    server?: string;
+    mcpServer?: string;
+    arguments?: Record<string, unknown>;
+    args?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface PreToolGateContext {
+    projectRoot: string;
+    sessionId: string | null;
+    features: DelegationGateFeatures;
+    host?: DelegationGateHost;
+}
+export interface PreToolGateDeny {
+    allow: false;
+    reason: string;
+    gate: string;
+    hint?: Record<string, unknown>;
+    pendingCount?: number;
+    delegationId?: string;
+}
+export interface PreToolGateAllow {
+    allow: true;
+}
+export type PreToolGateResult = PreToolGateAllow | PreToolGateDeny;
+export interface PostToolSpawnResult {
+    satisfied: PendingDelegation[];
+    clearedAll: boolean;
+    expectedTodoId?: string | null;
+}
+export declare function loadDelegationGateFeatures(projectRoot?: string): DelegationGateFeatures;
+export declare function normalizeHostToolInput(toolInput: ToolGateInput): SpawnToolInput & {
+    command?: string;
+};
+export declare function isSubagentTool(toolName: string): boolean;
+export declare function isShellTool(toolName: string): boolean;
+export declare function isWriteTool(toolName: string, host?: DelegationGateHost): boolean;
+export declare function isReadOnlyTool(toolName: string): boolean;
+/** Spawn plan missing — applies before auto_chain opt-out for subagent tools. */
+export declare function evaluateSpawnPlanGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
+/** Block writes / unrelated work while pending delegations exist. */
+export declare function evaluatePendingDelegationGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
+/**
+ * Full pre-tool evaluation — same order as Grok PreToolUse:
+ * pending gate first, then spawn todo gate for subagent tools.
+ */
+export declare function evaluatePreToolGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
+export declare function evaluatePostToolSpawn(toolName: string, toolInput: ToolGateInput, projectRoot: string): PostToolSpawnResult;
+export declare function isOrchestrateToolEvent(toolName: string, toolInput?: ToolGateInput): boolean;
+/** Back-compat shims for Grok hook-utils and tests. */
+export declare function checkPendingDelegationGate(toolName: string, toolInput: ToolGateInput, features: DelegationGateFeatures, projectRoot: string, sessionId: string | null): PreToolGateDeny | null;
+export declare function checkSubagentGate(toolName: string, features: DelegationGateFeatures, projectRoot: string, sessionId: string | null, toolInput?: ToolGateInput): PreToolGateDeny | null;
+export declare function satisfyDelegationsFromToolInput(toolInput: ToolGateInput, projectRoot: string): {
+    satisfied: PendingDelegation[];
+    clearedAll: boolean;
+};

package/dist/nucleus/delegation-gate.js

@@ -0,0 +1,275 @@
+/**
+ * Multi-host delegation gate SSOT — pending-delegations + spawn todo enforcement.
+ * Grok / Hermes / OpenCode adapters call evaluatePreToolGate; Grok-only logic was
+ * previously duplicated in grok-hook-utils.js.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getActivePendingDelegations, satisfyDelegation, } from './pending-delegations.js';
+export { getActivePendingDelegations } from './pending-delegations.js';
+import { allPlanTodos, hasValidLeadDevPlanForSpawn, loadPersistedLeadDevPlan, validateSpawnMatchesTodo, updatePlanTodoStatus, } from './lead-dev-plan-persistence.js';
+export { validateSpawnMatchesTodo, updatePlanTodoStatus, savePersistedLeadDevPlan, } from './lead-dev-plan-persistence.js';
+export const updatePlanTodoStatusInPlace = updatePlanTodoStatus;
+const READ_TOOLS = new Set([
+    'read_file',
+    'Read',
+    'read',
+    'grep',
+    'Grep',
+    'glob',
+    'Glob',
+    'list_dir',
+    'ListDir',
+    'web_search',
+    'WebSearch',
+    'codebase_search',
+    'SemanticSearch',
+    'search_files',
+]);
+const SUBAGENT_TOOLS = new Set(['spawn_subagent', 'task', 'Task', 'delegate_task']);
+const ORCHESTRATOR_CONSULT_TOOLS = new Set([
+    'analyze-complexity',
+    'analyze_complexity',
+    'get-orchestration-status',
+    'get_orchestration_status',
+    'orchestrate-task',
+    'orchestrate_task',
+]);
+const HERMES_WRITE_TOOLS = new Set(['write_file', 'patch', 'write', 'edit']);
+const OPENCODE_WRITE_TOOLS = new Set(['write', 'edit', 'multiedit']);
+export function loadDelegationGateFeatures(projectRoot = process.cwd()) {
+    const featuresPath = path.join(projectRoot, '.xray', 'features.json');
+    if (!fs.existsSync(featuresPath)) {
+        return { lead_dev_mode: true, auto_chain_delegations: true };
+    }
+    try {
+        const data = JSON.parse(fs.readFileSync(featuresPath, 'utf8'));
+        const orch = data.multi_agent_orchestration ?? {};
+        return {
+            lead_dev_mode: orch.enabled !== false && orch.lead_dev_mode !== false,
+            auto_chain_delegations: orch.auto_chain_delegations !== false,
+        };
+    }
+    catch {
+        return { lead_dev_mode: true, auto_chain_delegations: true };
+    }
+}
+export function normalizeHostToolInput(toolInput) {
+    const normalized = {
+        prompt: String(toolInput.prompt ?? toolInput.description ?? toolInput.task ?? ''),
+        subagent_type: String(toolInput.subagent_type ?? toolInput.agent ?? ''),
+    };
+    if (toolInput.description != null)
+        normalized.description = String(toolInput.description);
+    if (toolInput.task != null)
+        normalized.task = String(toolInput.task);
+    if (toolInput.agent != null)
+        normalized.agent = String(toolInput.agent);
+    const delegationId = toolInput.delegationId ?? toolInput.delegation_id;
+    if (delegationId != null)
+        normalized.delegationId = String(delegationId);
+    if (toolInput.planTodoId != null)
+        normalized.planTodoId = String(toolInput.planTodoId);
+    if (toolInput.command != null)
+        normalized.command = String(toolInput.command);
+    return normalized;
+}
+export function isSubagentTool(toolName) {
+    return SUBAGENT_TOOLS.has(toolName) || /^task$/i.test(toolName) || toolName === 'spawn_subagent';
+}
+export function isShellTool(toolName) {
+    return /terminal|bash|shell|run_terminal/i.test(toolName);
+}
+export function isWriteTool(toolName, host = 'generic') {
+    if (host === 'hermes' && HERMES_WRITE_TOOLS.has(toolName))
+        return true;
+    if (host === 'opencode' && OPENCODE_WRITE_TOOLS.has(toolName))
+        return true;
+    return (/write|edit|replace|patch|notebook/i.test(toolName) &&
+        !isReadOnlyTool(toolName));
+}
+export function isReadOnlyTool(toolName) {
+    return READ_TOOLS.has(toolName) || /^(read|grep|glob|list|search_files)/i.test(toolName);
+}
+function extractMcpToolName(toolInput) {
+    const candidates = [
+        toolInput.toolName,
+        toolInput.tool,
+        toolInput.name,
+        toolInput.mcpToolName,
+    ];
+    for (const c of candidates) {
+        if (c)
+            return String(c);
+    }
+    const server = String(toolInput.server ?? toolInput.mcpServer ?? '');
+    const args = (toolInput.arguments ?? toolInput.args ?? {});
+    if (args.toolName)
+        return String(args.toolName);
+    if (server.includes('orchestrator') && args.name)
+        return String(args.name);
+    return '';
+}
+function isOrchestratorConsultMcp(toolName, toolInput) {
+    if (!/mcp|CallMcpTool/i.test(toolName))
+        return false;
+    const inner = extractMcpToolName(toolInput).toLowerCase();
+    if (!inner)
+        return false;
+    for (const t of ORCHESTRATOR_CONSULT_TOOLS) {
+        if (inner.includes(t) || inner.includes(t.replace(/-/g, '_')))
+            return true;
+    }
+    return false;
+}
+function isFocusedTestCommand(cmd) {
+    const cmdText = (cmd || '').toLowerCase();
+    return (/\b(npm\s+(run\s+)?test|vitest\s+run|pnpm\s+test|yarn\s+test)\b/.test(cmdText) &&
+        (/--\s+\S+\.test/.test(cmdText) || /vitest\s+run\s+\S+\.test/.test(cmdText)));
+}
+function denyFromSpawnValidation(validation) {
+    const deny = {
+        allow: false,
+        reason: validation.reason ?? 'Spawn blocked by lead-dev plan',
+        gate: validation.gate ?? 'spawn-todo-persistence',
+    };
+    if (validation.hint)
+        deny.hint = validation.hint;
+    return deny;
+}
+function denyFromPending(primary, pendingCount) {
+    return {
+        allow: false,
+        reason: 'Pending implementation delegation — spawn host Task before other work',
+        gate: 'auto-chain-pending',
+        hint: { ...(primary.spawnHint ?? {
+                tool: 'Task',
+                subagent_type: primary.agent,
+                description: primary.taskDescription,
+                planTodoId: primary.planTodoId,
+                delegationId: primary.id,
+            }) },
+        pendingCount,
+        delegationId: primary.id,
+    };
+}
+/** Spawn plan missing — applies before auto_chain opt-out for subagent tools. */
+export function evaluateSpawnPlanGate(toolName, toolInput, ctx) {
+    if (!ctx.features.lead_dev_mode || !isSubagentTool(toolName)) {
+        return { allow: true };
+    }
+    if (!hasValidLeadDevPlanForSpawn(ctx.projectRoot, ctx.sessionId)) {
+        return {
+            allow: false,
+            reason: 'Codex 59/67: call xray-orchestrator analyze-complexity first — ' +
+                'writes .xray/state/lead-dev-plan.json required before spawn_subagent',
+            gate: 'spawn-plan-missing',
+        };
+    }
+    if (ctx.features.auto_chain_delegations === false) {
+        return { allow: true };
+    }
+    const pending = getActivePendingDelegations(ctx.sessionId, ctx.projectRoot);
+    const plan = loadPersistedLeadDevPlan(ctx.projectRoot);
+    const expectedTodo = pending[0]?.planTodoId && plan
+        ? allPlanTodos(plan).find((t) => t.id === pending[0].planTodoId) ?? null
+        : null;
+    const validation = validateSpawnMatchesTodo(normalizeHostToolInput(toolInput), ctx.projectRoot, expectedTodo);
+    if (!validation.valid) {
+        return denyFromSpawnValidation(validation);
+    }
+    return { allow: true };
+}
+/** Block writes / unrelated work while pending delegations exist. */
+export function evaluatePendingDelegationGate(toolName, toolInput, ctx) {
+    if (!ctx.features.lead_dev_mode || ctx.features.auto_chain_delegations === false) {
+        return { allow: true };
+    }
+    if (!ctx.sessionId)
+        return { allow: true };
+    const pending = getActivePendingDelegations(ctx.sessionId, ctx.projectRoot);
+    if (pending.length === 0)
+        return { allow: true };
+    if (isSubagentTool(toolName))
+        return { allow: true };
+    if (isReadOnlyTool(toolName))
+        return { allow: true };
+    if (isOrchestratorConsultMcp(toolName, toolInput))
+        return { allow: true };
+    if (isShellTool(toolName)) {
+        const cmd = String(toolInput.command ?? '');
+        if (isFocusedTestCommand(cmd))
+            return { allow: true };
+    }
+    return denyFromPending(pending[0], pending.length);
+}
+/**
+ * Full pre-tool evaluation — same order as Grok PreToolUse:
+ * pending gate first, then spawn todo gate for subagent tools.
+ */
+export function evaluatePreToolGate(toolName, toolInput, ctx) {
+    const pendingBlock = evaluatePendingDelegationGate(toolName, toolInput, ctx);
+    if (!pendingBlock.allow)
+        return pendingBlock;
+    const spawnBlock = evaluateSpawnPlanGate(toolName, toolInput, ctx);
+    if (!spawnBlock.allow)
+        return spawnBlock;
+    return { allow: true };
+}
+export function evaluatePostToolSpawn(toolName, toolInput, projectRoot) {
+    const normalized = normalizeHostToolInput(toolInput);
+    const spawnCheck = validateSpawnMatchesTodo(normalized, projectRoot);
+    const satisfyInput = {
+        toolPrompt: normalized.prompt ?? '',
+    };
+    if (normalized.delegationId)
+        satisfyInput.delegationId = normalized.delegationId;
+    const agent = normalized.subagent_type || normalized.agent;
+    if (agent)
+        satisfyInput.agent = agent;
+    if (normalized.planTodoId)
+        satisfyInput.planTodoId = normalized.planTodoId;
+    const result = satisfyDelegation(satisfyInput, projectRoot);
+    return {
+        ...result,
+        expectedTodoId: spawnCheck.expectedTodoId ?? null,
+    };
+}
+export function isOrchestrateToolEvent(toolName, toolInput = {}) {
+    const inner = extractMcpToolName(toolInput).toLowerCase();
+    if (/orchestrate[-_]?task/.test(inner))
+        return true;
+    const blob = JSON.stringify(toolInput).toLowerCase();
+    return /orchestrate[-_]?task/.test(blob);
+}
+/** Back-compat shims for Grok hook-utils and tests. */
+export function checkPendingDelegationGate(toolName, toolInput, features, projectRoot, sessionId) {
+    const result = evaluatePendingDelegationGate(toolName, toolInput, {
+        projectRoot,
+        sessionId,
+        features,
+    });
+    return result.allow ? null : result;
+}
+export function checkSubagentGate(toolName, features, projectRoot, sessionId, toolInput = {}) {
+    const result = evaluateSpawnPlanGate(toolName, toolInput, {
+        projectRoot,
+        sessionId,
+        features,
+    });
+    return result.allow ? null : result;
+}
+export function satisfyDelegationsFromToolInput(toolInput, projectRoot) {
+    const normalized = normalizeHostToolInput(toolInput);
+    const satisfyInput = {
+        toolPrompt: normalized.prompt ?? '',
+    };
+    if (normalized.delegationId)
+        satisfyInput.delegationId = normalized.delegationId;
+    const agent = normalized.subagent_type || normalized.agent;
+    if (agent)
+        satisfyInput.agent = agent;
+    if (normalized.planTodoId)
+        satisfyInput.planTodoId = normalized.planTodoId;
+    return satisfyDelegation(satisfyInput, projectRoot);
+}

package/dist/nucleus/lead-dev-plan-persistence.js

@@ -26,15 +26,15 @@ export function savePersistedLeadDevPlan(plan, projectRoot = process.cwd()) {
     return planPath;
 }
 export function allPlanTodos(plan) {
-    return plan.phases.flatMap((p) => p.todos);
+    return (plan.phases ?? []).flatMap((p) => p.todos ?? []);
 }
 export function getOutstandingTodos(plan) {
     return allPlanTodos(plan).filter((t) => t.status === 'pending' || t.status === 'in_progress');
 }
 /** First outstanding todo in phase order */
 export function getNextRequiredTodo(plan) {
-    for (const phase of plan.phases) {
-        const next = phase.todos.find((t) => t.status === 'pending' || t.status === 'in_progress');
+    for (const phase of plan.phases ?? []) {
+        const next = (phase.todos ?? []).find((t) => t.status === 'pending' || t.status === 'in_progress');
         if (next)
             return next;
     }

package/dist/plugin/xray-codex-injection.js

@@ -7,6 +7,9 @@ import { getOrCreateLogger } from "./plugin-logger.js";
 import { resolveStateDir, importSystemPromptGenerator, loadXrayComponents, getProcessorManager, getXrayStateManager, getFeaturesConfigLoader, getDetectTaskType, getSystemPromptGenerator, } from "./plugin-modules.js";
 import { getFrameworkIdentity, classifyTaskType, isWriteEditOperation, isPublishOperation, resolveAgentName, registerAllProcessors, registerAfterPostProcessors, logPreProcessorResults, logPostProcessorResults, logTestAutoCreationResult, spawnPromise, } from "./plugin-helpers.js";
 import { runEnforcerQualityGate } from "./plugin-quality-gate.js";
+import { evaluatePostToolSpawn, evaluatePreToolGate, isSubagentTool, loadDelegationGateFeatures, } from "../nucleus/delegation-gate.js";
+import { readFileSync } from "fs";
+import { join } from "path";
 // Re-export all public API for test compatibility
 export { classifyTaskType } from "./plugin-helpers.js";
 export { validateModulePath } from "./plugin-modules.js";
@@ -81,6 +84,25 @@ export default async function xrayCodexPlugin(input) {
                 throw new Error(`ENFORCER BLOCKED: ${qualityGateResult.violations.join("; ")}`);
             }
             logger.log(`✅ Quality gate passed for ${tool}`);
+            const features = loadDelegationGateFeatures(directory);
+            let sessionId = process.env.GROK_SESSION_ID ?? null;
+            try {
+                const boot = JSON.parse(readFileSync(join(directory, ".xray", "state", "session-boot.json"), "utf8"));
+                sessionId = boot.sessionId ?? sessionId;
+            }
+            catch {
+                /* no session boot */
+            }
+            const delegationGate = evaluatePreToolGate(tool, (args ?? {}), {
+                projectRoot: directory,
+                sessionId,
+                features,
+                host: "opencode",
+            });
+            if (!delegationGate.allow) {
+                logger.error(`🚫 Delegation gate: ${delegationGate.reason}`);
+                throw new Error(`DELEGATION GATE: ${delegationGate.reason}`);
+            }
             if (isWriteEditOperation(tool)) {
                 const _ProcessorManager = getProcessorManager();
                 const _XrayStateManager = getXrayStateManager();
@@ -158,6 +180,17 @@ export default async function xrayCodexPlugin(input) {
             const logger = await getOrCreateLogger(directory);
             await loadXrayComponents();
             const { tool, args, result } = input;
+            if (isSubagentTool(tool)) {
+                try {
+                    const spawnResult = evaluatePostToolSpawn(tool, (args ?? {}), directory);
+                    if (spawnResult.satisfied.length > 0) {
+                        logger.log(`🔗 Delegation gate post: satisfied ${spawnResult.satisfied.map((d) => d.id).join(", ")}`);
+                    }
+                }
+                catch (error) {
+                    logger.error("Delegation gate post-hook error", error);
+                }
+            }
             try {
                 const { routingOutcomeTracker } = await import("../delegation/analytics/outcome-tracker.js");
                 const { TOOL_AGENT_MAP } = await import("./plugin-helpers.js");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "3.5.0",
+  "version": "3.5.1",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",
@@ -127,7 +127,9 @@
     "publish": "npm run release:gate && npm run safe-publish && npm publish --access public",
     "release:patch": "node scripts/node/release.mjs patch",
     "verify:orchestrator-behavior": "npm run build && node scripts/mjs/verify-orchestrator-behavior.mjs",
-    "verify:grok-delegation-gate": "npm run build && node scripts/mjs/verify-grok-delegation-gate.mjs"
+    "verify:grok-delegation-gate": "npm run build && node scripts/mjs/verify-grok-delegation-gate.mjs",
+    "verify:hermes-delegation-gate": "npm run build && node scripts/mjs/verify-hermes-delegation-gate.mjs",
+    "verify:delegation-gate": "npm run build && node scripts/mjs/verify-delegation-gate-core.mjs --host=grok && node scripts/mjs/verify-delegation-gate-core.mjs --host=hermes && node scripts/mjs/verify-delegation-gate-core.mjs --host=opencode && node scripts/mjs/verify-grok-delegation-gate.mjs && node scripts/mjs/verify-hermes-delegation-gate.mjs"
   },
   "files": [
     "dist/",
@@ -141,6 +143,9 @@
     "scripts/mjs/validate-postinstall-config.mjs",
     "scripts/mjs/verify-orchestrator-behavior.mjs",
     "scripts/mjs/verify-grok-delegation-gate.mjs",
+    "scripts/mjs/verify-hermes-delegation-gate.mjs",
+    "scripts/mjs/verify-delegation-gate-core.mjs",
+    "scripts/mjs/delegation-gate-fixture.mjs",
     "src/opencode/",
     "src/opencode/codex.codex",
     "src/opencode/commands/",