0xray 3.4.10 → 3.5.1

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

@@ -0,0 +1,155 @@
+/**
+ * Todo-level lead-dev plan persistence — spawn gate survives beyond 4h mtime
+ * while outstanding todos remain. SSOT for plan todo status sync.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { DEFAULT_PENDING_TTL_MS } from './pending-delegations.js';
+export function leadDevPlanStatePath(projectRoot = process.cwd()) {
+    return path.join(projectRoot, '.xray', 'state', 'lead-dev-plan.json');
+}
+export function loadPersistedLeadDevPlan(projectRoot = process.cwd()) {
+    const planPath = leadDevPlanStatePath(projectRoot);
+    if (!fs.existsSync(planPath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(planPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function savePersistedLeadDevPlan(plan, projectRoot = process.cwd()) {
+    const planPath = leadDevPlanStatePath(projectRoot);
+    fs.mkdirSync(path.dirname(planPath), { recursive: true });
+    fs.writeFileSync(planPath, JSON.stringify(plan, null, 2));
+    return planPath;
+}
+export function allPlanTodos(plan) {
+    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');
+        if (next)
+            return next;
+    }
+    return null;
+}
+/**
+ * Plan valid for spawn when active and either:
+ * - outstanding todos remain (ignores 4h mtime), or
+ * - all todos complete and persistedAt within TTL
+ */
+export function hasValidLeadDevPlanForSpawn(projectRoot = process.cwd(), _sessionId) {
+    const plan = loadPersistedLeadDevPlan(projectRoot);
+    if (!plan?.active)
+        return false;
+    const outstanding = getOutstandingTodos(plan);
+    if (outstanding.length > 0)
+        return true;
+    const persistedAt = plan.persistedAt;
+    if (!persistedAt) {
+        try {
+            const stat = fs.statSync(leadDevPlanStatePath(projectRoot));
+            return Date.now() - stat.mtimeMs <= DEFAULT_PENDING_TTL_MS;
+        }
+        catch {
+            return false;
+        }
+    }
+    return Date.now() - new Date(persistedAt).getTime() <= DEFAULT_PENDING_TTL_MS;
+}
+export function updatePlanTodoStatus(todoId, status, projectRoot = process.cwd()) {
+    const plan = loadPersistedLeadDevPlan(projectRoot);
+    if (!plan)
+        return false;
+    let updated = false;
+    for (const phase of plan.phases) {
+        for (const todo of phase.todos) {
+            if (todo.id === todoId) {
+                todo.status = status;
+                updated = true;
+            }
+        }
+    }
+    if (updated)
+        savePersistedLeadDevPlan(plan, projectRoot);
+    return updated;
+}
+export function bindPlanToSession(sessionId, projectRoot = process.cwd()) {
+    const plan = loadPersistedLeadDevPlan(projectRoot);
+    if (!plan)
+        return null;
+    const generation = (plan.planGeneration ?? 0) + 1;
+    const next = {
+        ...plan,
+        sessionId,
+        planGeneration: generation,
+        persistedAt: new Date().toISOString(),
+    };
+    savePersistedLeadDevPlan(next, projectRoot);
+    return next;
+}
+function normalizeAgent(agent) {
+    const key = agent.toLowerCase().trim();
+    const aliases = {
+        'bug-triage-specialist': 'bug-triage',
+        'code-reviewer': 'code-review',
+    };
+    return aliases[key] ?? key;
+}
+function agentsAlign(expected, actual) {
+    const e = normalizeAgent(expected);
+    const a = normalizeAgent(actual);
+    return e === a || e.includes(a) || a.includes(e);
+}
+export function validateSpawnMatchesTodo(toolInput, projectRoot = process.cwd(), expectedTodo) {
+    const plan = loadPersistedLeadDevPlan(projectRoot);
+    const nextTodo = expectedTodo ?? (plan ? getNextRequiredTodo(plan) : null);
+    if (!nextTodo) {
+        return { valid: true };
+    }
+    const prompt = String(toolInput.prompt || toolInput.description || toolInput.task || '').toLowerCase();
+    const subagent = String(toolInput.subagent_type || toolInput.agent || '');
+    const explicitTodo = toolInput.planTodoId || toolInput.delegationId;
+    if (explicitTodo && explicitTodo === nextTodo.id) {
+        return { valid: true, expectedTodoId: nextTodo.id };
+    }
+    if (prompt.includes(nextTodo.id.toLowerCase())) {
+        return { valid: true, expectedTodoId: nextTodo.id };
+    }
+    if (prompt.includes(nextTodo.task.toLowerCase().slice(0, 30))) {
+        return { valid: true, expectedTodoId: nextTodo.id };
+    }
+    if (subagent && agentsAlign(nextTodo.subagent, subagent) && prompt.length > 20) {
+        return { valid: true, expectedTodoId: nextTodo.id };
+    }
+    return {
+        valid: false,
+        reason: `Spawn must target plan todo ${nextTodo.id} before other work`,
+        gate: 'spawn-todo-persistence',
+        expectedTodoId: nextTodo.id,
+        hint: {
+            tool: 'Task',
+            subagent_type: nextTodo.subagent,
+            planTodoId: nextTodo.id,
+            description: `Lead-dev todo ${nextTodo.id}: ${nextTodo.task}. ` +
+                `Include plan todo id in Task prompt.`,
+        },
+    };
+}
+export function markTodoInProgressOnSpawn(toolInput, projectRoot = process.cwd()) {
+    const plan = loadPersistedLeadDevPlan(projectRoot);
+    if (!plan)
+        return null;
+    const validation = validateSpawnMatchesTodo(toolInput, projectRoot);
+    if (!validation.valid || !validation.expectedTodoId)
+        return null;
+    updatePlanTodoStatus(validation.expectedTodoId, 'in_progress', projectRoot);
+    return validation.expectedTodoId;
+}

package/dist/nucleus/pending-delegations.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Pending delegations SSOT — written by task-handler on delegate-deferred.
+ * Grok hooks read the same file; PostToolUse never re-parses MCP output.
+ */
+import type { LeadDevPlan, LeadDevTodo } from './autonomy-kernel.js';
+export declare const DEFAULT_PENDING_TTL_MS: number;
+export type DelegationMatchMethod = 'taskId' | 'description' | 'agent-only' | 'none';
+export interface SpawnHint {
+    tool: 'Task';
+    subagent_type: string;
+    description: string;
+    planTodoId: string | null;
+    delegationId: string;
+}
+export interface PendingDelegation {
+    id: string;
+    taskId: string;
+    agent: string;
+    taskDescription: string;
+    taskType: string;
+    sessionId: string;
+    planTodoId: string | null;
+    planTodoTask: string | null;
+    matchMethod: DelegationMatchMethod;
+    matchConfidence: number;
+    status: 'pending' | 'satisfied';
+    createdAt: string;
+    satisfiedAt: string | null;
+    spawnHint: SpawnHint;
+}
+export interface PendingDelegationsState {
+    sessionId: string;
+    createdAt: string;
+    ttlMs: number;
+    delegations: PendingDelegation[];
+}
+export interface DeferredTaskRecord {
+    taskId: string;
+    agent: string;
+    description: string;
+    type?: string;
+}
+export declare function pendingDelegationsPath(projectRoot?: string): string;
+export declare function leadDevPlanPath(projectRoot?: string): string;
+export declare function isAutoChainDelegationsEnabled(projectRoot?: string): boolean;
+export declare function matchPlanTodo(agent: string, taskDescription: string, taskId: string, plan: LeadDevPlan | null): {
+    todo: LeadDevTodo | null;
+    method: DelegationMatchMethod;
+    confidence: number;
+};
+export declare function mapSubagentToTaskType(agent: string): string;
+export declare function buildSpawnHint(delegation: Pick<PendingDelegation, 'id' | 'agent' | 'taskDescription' | 'planTodoId' | 'planTodoTask'>): SpawnHint;
+export declare function loadPendingDelegationsState(projectRoot?: string): PendingDelegationsState | null;
+export declare function savePendingDelegationsState(state: PendingDelegationsState, projectRoot?: string): string;
+export declare function recordDeferredDelegations(sessionId: string, deferrals: DeferredTaskRecord[], projectRoot?: string): PendingDelegation[];
+export declare function isPendingStateActive(state: PendingDelegationsState | null, sessionId: string | null | undefined): boolean;
+export declare function getActivePendingDelegations(sessionId: string | null | undefined, projectRoot?: string): PendingDelegation[];
+export interface SatisfyDelegationInput {
+    delegationId?: string;
+    taskId?: string;
+    planTodoId?: string;
+    agent?: string;
+    toolPrompt?: string;
+}
+export declare function satisfyDelegation(input: SatisfyDelegationInput, projectRoot?: string): {
+    satisfied: PendingDelegation[];
+    clearedAll: boolean;
+};
+export declare function clearPendingDelegations(projectRoot?: string): boolean;
+export declare function clearPendingDelegationsForSessionChange(newSessionId: string | null | undefined, projectRoot?: string): boolean;
+export declare function delegationSummaryForResponse(delegations: PendingDelegation[]): Array<Record<string, unknown>>;

package/dist/nucleus/pending-delegations.js

@@ -0,0 +1,285 @@
+/**
+ * Pending delegations SSOT — written by task-handler on delegate-deferred.
+ * Grok hooks read the same file; PostToolUse never re-parses MCP output.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { featuresConfigLoader } from '../core/features-config.js';
+import { updatePlanTodoStatus } from './lead-dev-plan-persistence.js';
+export const DEFAULT_PENDING_TTL_MS = 4 * 60 * 60 * 1000;
+const AGENT_ALIASES = {
+    'bug-triage-specialist': 'bug-triage',
+    'code-reviewer': 'code-review',
+    'security-auditor': 'security-audit',
+};
+const TASK_TYPE_BY_AGENT = {
+    'backend-engineer': 'backend-engineer',
+    'frontend-engineer': 'frontend-engineer',
+    'bug-triage': 'bug-triage',
+    'bug-triage-specialist': 'bug-triage',
+    strategist: 'strategist',
+    researcher: 'generalPurpose',
+    'architect-tools': 'generalPurpose',
+    'code-review': 'code-review',
+    'code-reviewer': 'code-review',
+};
+export function pendingDelegationsPath(projectRoot = process.cwd()) {
+    return path.join(projectRoot, '.xray', 'state', 'pending-delegations.json');
+}
+export function leadDevPlanPath(projectRoot = process.cwd()) {
+    return path.join(projectRoot, '.xray', 'state', 'lead-dev-plan.json');
+}
+export function isAutoChainDelegationsEnabled(projectRoot = process.cwd()) {
+    try {
+        const localPath = path.join(projectRoot, '.xray', 'features.json');
+        if (fs.existsSync(localPath)) {
+            const data = JSON.parse(fs.readFileSync(localPath, 'utf8'));
+            const cfg = data.multi_agent_orchestration ?? {};
+            if (cfg.enabled === false || cfg.lead_dev_mode === false)
+                return false;
+            return cfg.auto_chain_delegations !== false;
+        }
+        const cfg = featuresConfigLoader.loadConfig().multi_agent_orchestration;
+        if (!cfg.enabled || cfg.lead_dev_mode === false)
+            return false;
+        return cfg.auto_chain_delegations !== false;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeAgent(agent) {
+    const key = agent.toLowerCase().trim();
+    return AGENT_ALIASES[key] ?? key;
+}
+function loadLeadDevPlan(projectRoot) {
+    const planPath = leadDevPlanPath(projectRoot);
+    if (!fs.existsSync(planPath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(planPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function allPlanTodos(plan) {
+    return plan.phases.flatMap((p) => p.todos);
+}
+export function matchPlanTodo(agent, taskDescription, taskId, plan) {
+    if (!plan) {
+        return { todo: null, method: 'none', confidence: 0 };
+    }
+    const normalizedAgent = normalizeAgent(agent);
+    const pendingTodos = allPlanTodos(plan).filter((t) => t.status === 'pending');
+    const byTaskId = pendingTodos.find((t) => t.id === taskId || t.task.includes(taskId));
+    if (byTaskId) {
+        return { todo: byTaskId, method: 'taskId', confidence: 0.95 };
+    }
+    const desc = taskDescription.toLowerCase().trim();
+    if (desc) {
+        const byDesc = pendingTodos.find((t) => {
+            const todoText = t.task.toLowerCase();
+            return todoText.includes(desc) || desc.includes(todoText.slice(0, 40));
+        });
+        if (byDesc) {
+            return { todo: byDesc, method: 'description', confidence: 0.75 };
+        }
+    }
+    const byAgent = pendingTodos.find((t) => normalizeAgent(t.subagent) === normalizedAgent);
+    if (byAgent) {
+        return { todo: byAgent, method: 'agent-only', confidence: 0.5 };
+    }
+    return { todo: null, method: 'none', confidence: 0 };
+}
+export function mapSubagentToTaskType(agent) {
+    const key = agent.toLowerCase().trim();
+    return TASK_TYPE_BY_AGENT[key] ?? TASK_TYPE_BY_AGENT[normalizeAgent(key)] ?? 'generalPurpose';
+}
+export function buildSpawnHint(delegation) {
+    const todoLine = delegation.planTodoTask
+        ? `[plan todo ${delegation.planTodoId}] ${delegation.planTodoTask}`
+        : delegation.taskDescription;
+    return {
+        tool: 'Task',
+        subagent_type: mapSubagentToTaskType(delegation.agent),
+        description: `Lead-dev implementation delegation. ${todoLine}. ` +
+            `Complete this todo per .xray/state/lead-dev-plan.json; run per-suite tests; report results.`,
+        planTodoId: delegation.planTodoId,
+        delegationId: delegation.id,
+    };
+}
+export function loadPendingDelegationsState(projectRoot = process.cwd()) {
+    const filePath = pendingDelegationsPath(projectRoot);
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function savePendingDelegationsState(state, projectRoot = process.cwd()) {
+    const filePath = pendingDelegationsPath(projectRoot);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(state, null, 2));
+    return filePath;
+}
+function newDelegationId() {
+    return `del-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+export function recordDeferredDelegations(sessionId, deferrals, projectRoot = process.cwd()) {
+    if (!isAutoChainDelegationsEnabled(projectRoot) || deferrals.length === 0) {
+        return [];
+    }
+    const plan = loadLeadDevPlan(projectRoot);
+    const existing = loadPendingDelegationsState(projectRoot);
+    const now = new Date().toISOString();
+    const base = existing && existing.sessionId === sessionId
+        ? existing
+        : {
+            sessionId,
+            createdAt: now,
+            ttlMs: DEFAULT_PENDING_TTL_MS,
+            delegations: [],
+        };
+    const created = [];
+    for (const d of deferrals) {
+        const { todo, method, confidence } = matchPlanTodo(d.agent, d.description, d.taskId, plan);
+        const partial = {
+            id: newDelegationId(),
+            taskId: d.taskId,
+            agent: d.agent,
+            taskDescription: d.description,
+            taskType: d.type ?? 'implement',
+            sessionId,
+            planTodoId: todo?.id ?? null,
+            planTodoTask: todo?.task ?? null,
+            matchMethod: method,
+            matchConfidence: confidence,
+            status: 'pending',
+            createdAt: now,
+            satisfiedAt: null,
+        };
+        created.push({
+            ...partial,
+            spawnHint: buildSpawnHint(partial),
+        });
+    }
+    base.delegations = [
+        ...base.delegations.filter((d) => d.status === 'pending'),
+        ...created,
+    ];
+    if (base.sessionId !== sessionId) {
+        base.sessionId = sessionId;
+        base.createdAt = now;
+        base.delegations = created;
+    }
+    savePendingDelegationsState(base, projectRoot);
+    return created;
+}
+export function isPendingStateActive(state, sessionId) {
+    if (!state)
+        return false;
+    if (!sessionId || state.sessionId !== sessionId)
+        return false;
+    const age = Date.now() - new Date(state.createdAt).getTime();
+    if (age > state.ttlMs)
+        return false;
+    return state.delegations.some((d) => d.status === 'pending');
+}
+export function getActivePendingDelegations(sessionId, projectRoot = process.cwd()) {
+    const state = loadPendingDelegationsState(projectRoot);
+    if (!isPendingStateActive(state, sessionId))
+        return [];
+    return state.delegations.filter((d) => d.status === 'pending');
+}
+export function satisfyDelegation(input, projectRoot = process.cwd()) {
+    const state = loadPendingDelegationsState(projectRoot);
+    if (!state)
+        return { satisfied: [], clearedAll: false };
+    const pending = state.delegations.filter((d) => d.status === 'pending');
+    if (pending.length === 0)
+        return { satisfied: [], clearedAll: false };
+    const prompt = (input.toolPrompt ?? '').toLowerCase();
+    let matches = [];
+    if (input.delegationId) {
+        matches = pending.filter((d) => d.id === input.delegationId);
+    }
+    else if (input.planTodoId) {
+        matches = pending.filter((d) => d.planTodoId === input.planTodoId || prompt.includes(input.planTodoId.toLowerCase()));
+    }
+    else if (input.taskId) {
+        matches = pending.filter((d) => d.taskId === input.taskId || prompt.includes(input.taskId.toLowerCase()));
+    }
+    else if (input.agent) {
+        const norm = normalizeAgent(input.agent);
+        matches = pending.filter((d) => normalizeAgent(d.agent) === norm);
+    }
+    if (matches.length === 0 && prompt) {
+        for (const d of pending) {
+            if (d.planTodoId && prompt.includes(d.planTodoId.toLowerCase())) {
+                matches.push(d);
+                break;
+            }
+            if (prompt.includes(d.taskId.toLowerCase())) {
+                matches.push(d);
+                break;
+            }
+        }
+    }
+    if (matches.length === 0 && pending.length === 1) {
+        const only = pending[0];
+        const hint = only.spawnHint.description.toLowerCase();
+        if (prompt && hint && prompt.includes(hint.slice(0, 40))) {
+            matches = [only];
+        }
+    }
+    if (matches.length === 0) {
+        return { satisfied: [], clearedAll: false };
+    }
+    const now = new Date().toISOString();
+    const matchIds = new Set(matches.map((m) => m.id));
+    for (const d of state.delegations) {
+        if (matchIds.has(d.id) && d.status === 'pending') {
+            d.status = 'satisfied';
+            d.satisfiedAt = now;
+        }
+    }
+    savePendingDelegationsState(state, projectRoot);
+    for (const m of matches) {
+        if (m.planTodoId) {
+            updatePlanTodoStatus(m.planTodoId, 'in_progress', projectRoot);
+        }
+    }
+    const stillPending = state.delegations.some((d) => d.status === 'pending');
+    return { satisfied: matches, clearedAll: !stillPending };
+}
+export function clearPendingDelegations(projectRoot = process.cwd()) {
+    const filePath = pendingDelegationsPath(projectRoot);
+    if (!fs.existsSync(filePath))
+        return false;
+    fs.unlinkSync(filePath);
+    return true;
+}
+export function clearPendingDelegationsForSessionChange(newSessionId, projectRoot = process.cwd()) {
+    const state = loadPendingDelegationsState(projectRoot);
+    if (!state)
+        return false;
+    if (newSessionId && state.sessionId === newSessionId)
+        return false;
+    fs.unlinkSync(pendingDelegationsPath(projectRoot));
+    return true;
+}
+export function delegationSummaryForResponse(delegations) {
+    return delegations.map((d) => ({
+        id: d.id,
+        taskId: d.taskId,
+        agent: d.agent,
+        planTodoId: d.planTodoId,
+        matchMethod: d.matchMethod,
+        matchConfidence: d.matchConfidence,
+        spawnHint: d.spawnHint,
+    }));
+}

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.4.10",
+  "version": "3.5.1",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",
@@ -126,7 +126,10 @@
     "safe-publish": "npm run prepare-consumer && npm run build",
     "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: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: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/",
@@ -139,6 +142,10 @@
     "scripts/mjs/validate-mcp-connectivity.cjs",
     "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/",

package/scripts/mjs/delegation-gate-fixture.mjs

@@ -0,0 +1,84 @@
+/**
+ * Shared 4/4 delegation gate fixture — seeds consumer tmp workspace.
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const FIXTURE_SESSION_ID = 'verify-gate';
+
+export function seedDelegationGateFixture(tmp) {
+  mkdirSync(join(tmp, '.xray', 'state'), { recursive: true });
+  writeFileSync(
+    join(tmp, '.xray', 'features.json'),
+    JSON.stringify({
+      multi_agent_orchestration: {
+        enabled: true,
+        lead_dev_mode: true,
+        auto_chain_delegations: true,
+      },
+    }),
+  );
+  writeFileSync(
+    join(tmp, '.xray', 'state', 'lead-dev-plan.json'),
+    JSON.stringify({
+      active: true,
+      persistedAt: new Date().toISOString(),
+      phases: [],
+    }),
+  );
+  writeFileSync(
+    join(tmp, '.xray', 'state', 'pending-delegations.json'),
+    JSON.stringify({
+      sessionId: FIXTURE_SESSION_ID,
+      createdAt: new Date().toISOString(),
+      ttlMs: 14400000,
+      delegations: [
+        {
+          id: 'del-verify',
+          taskId: 'impl-1',
+          agent: 'backend-engineer',
+          taskDescription: 'implement',
+          taskType: 'implement',
+          sessionId: FIXTURE_SESSION_ID,
+          planTodoId: '2.1',
+          planTodoTask: 'swap deps',
+          matchMethod: 'agent-only',
+          matchConfidence: 0.5,
+          status: 'pending',
+          createdAt: new Date().toISOString(),
+          satisfiedAt: null,
+          spawnHint: {
+            tool: 'Task',
+            subagent_type: 'backend-engineer',
+            description: 'Lead-dev delegation 2.1',
+            planTodoId: '2.1',
+            delegationId: 'del-verify',
+          },
+        },
+      ],
+    }),
+  );
+}
+
+export function seedSpawnTodoPlan(tmp) {
+  writeFileSync(
+    join(tmp, '.xray', 'state', 'lead-dev-plan.json'),
+    JSON.stringify({
+      active: true,
+      persistedAt: new Date().toISOString(),
+      phases: [
+        {
+          id: 'phase-2',
+          todos: [
+            {
+              id: '2.1',
+              task: 'swap deps',
+              subagent: 'backend-engineer',
+              status: 'pending',
+            },
+          ],
+        },
+      ],
+    }),
+  );
+}