0xray 3.4.10 → 3.5.1

package/.xray/features.json

@@ -35,7 +35,8 @@
     "per_suite_test_triage": true,
     "phased_plan_threshold": 25,
     "auto_consult_major_work": true,
-    "no_new_surface": true
+    "no_new_surface": true,
+    "auto_chain_delegations": true
   },
   "autonomous_reporting": {
     "enabled": true,

package/AGENTS-consumer.md

@@ -4,7 +4,7 @@
 
 Quick reference for the 0xRay AI orchestration framework (shipped to your project on `npm install 0xray`).
 
-**v3.4.10** — 7 MCP servers · 45 skills · 68 codex terms · 4 platform bridges
+**v3.5.1** — 7 MCP servers · 45 skills · 68 codex terms · 4 platform bridges
 
 ## Postinstall (automatic)
 

package/AGENTS.md

@@ -1,6 +1,6 @@
 # xray Agents
 
-Quick reference for the xray AI orchestration framework (**v3.4.10**).
+Quick reference for the xray AI orchestration framework (**v3.5.1**).
 
 **42 agents** · **45 skills** · **7 consumer MCP servers** · **68 codex terms** · **3,226 tests**
 

package/README.md

@@ -1,6 +1,6 @@
 # xray — MCP-Centric AI Governance OS
 
-**v3.4.10** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
+**v3.5.1** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
 
 ## Your AI Power Suit
 

package/SKILLS.md

@@ -1,6 +1,6 @@
 # 0xray Skills
 
-**v3.4.10** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
+**v3.5.1** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
 
 xray ships 45 knowledge skills (`src/skills/<name>/SKILL.md`) across the full software lifecycle. Lead-dev operating model lives in **`orchestrator`** skill + `multi_agent_orchestration.lead_dev_mode` in features.json. Skills load on demand via the **xray-skills** MCP server (`npx -y 0xray mcp skills`), agent `@mentions`, or platform skill directories after postinstall.
 

package/dist/AGENTS.md

@@ -1,6 +1,6 @@
 # xray Agents
 
-Quick reference for the xray AI orchestration framework (**v3.4.10**).
+Quick reference for the xray AI orchestration framework (**v3.5.1**).
 
 **42 agents** · **45 skills** · **7 consumer MCP servers** · **68 codex terms** · **3,226 tests**
 

package/dist/CHANGELOG.md

@@ -4,6 +4,42 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Conventional Commits](https://www.conventionalcommits.org/).
 
+## [3.5.1] - 2026-06-19
+
+### ✨ Features
+- **Multi-host delegation gates** — `src/nucleus/delegation-gate.ts` SSOT; `evaluatePreToolGate` / `evaluatePostToolSpawn` shared across Grok, Hermes, OpenCode
+- **Hermes** — `pre_tool_call` returns `{"action":"block"}` via bridge `delegation-gate`; `post_tool_call` clears pending on `delegate_task`
+- **OpenCode** — `tool.execute.before` / `after` enforce delegation gate + post-spawn clear
+
+### ✅ Tests
+- `delegation-gate.test.ts`; `verify-delegation-gate-core.mjs`; `verify-hermes-delegation-gate.mjs`; shared `delegation-gate-fixture.mjs`
+- Grok hook-utils deduped — re-exports nucleus SSOT via `delegation-gate-runtime.mjs`
+
+### 📋 Deferred
+- **OpenClaw host veto** — no consumer tool-block API; observability-only until platform supports pre-tool deny
+
+---
+
+## [3.5.0] - 2026-06-19
+
+### ✨ Features
+- **Auto-chain bridge (PR1)** — `pending-delegations.json` SSOT on `delegate-deferred`; PreToolUse surgical gate blocks writes while pending; PostToolUse logs + targeted clear on Task; session-bound TTL; `delegations[]` in orchestrate response
+- **Spawn todo persistence (PR2)** — lead-dev plan stays enforced while outstanding todos remain (beyond 4h mtime); `checkSubagentGate` validates Task targets next plan todo; plan todo `in_progress` sync on matched spawn; new intake clears pending delegations + binds `sessionId`/`planGeneration`
+- **`auto_chain_delegations: false`** — disables PR1 delegation gate and PR2 spawn-todo validation (opt-out of full auto-chain enforcement)
+
+### 🐛 Bug Fixes
+- **verify-orchestrator-behavior** — checks `pending-delegations.json` in consumer cwd (not package root)
+
+### ✅ Tests
+- `pending-delegations`, `lead-dev-plan-persistence`, `grok-pending-delegation-gate` unit tests; `verify-grok-delegation-gate.mjs` hook fixture (4/4); orchestrator behavior verify 8/8
+
+### 📋 Deferred (3.5.1+)
+- **#3 Observability** — full session trail (`sessionId` / `taskId` / `planTodoId` / gate deny count correlation)
+- **#4 Rule 1 vs Rule 2** — lead-dev arbitration when read/triage conflicts with spawn-first gate
+- **#5 Codex hard-fail** — silent fallback removal (independent of auto-chain)
+
+---
+
 ## [3.4.10] - 2026-06-19
 
 ### 🐛 Bug Fixes

package/dist/README.md

@@ -1,6 +1,6 @@
 # xray — MCP-Centric AI Governance OS
 
-**v3.4.10** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
+**v3.5.1** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
 
 ## Your AI Power Suit
 

package/dist/SKILLS.md

@@ -1,6 +1,6 @@
 # 0xray Skills
 
-**v3.4.10** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
+**v3.5.1** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
 
 xray ships 45 knowledge skills (`src/skills/<name>/SKILL.md`) across the full software lifecycle. Lead-dev operating model lives in **`orchestrator`** skill + `multi_agent_orchestration.lead_dev_mode` in features.json. Skills load on demand via the **xray-skills** MCP server (`npx -y 0xray mcp skills`), agent `@mentions`, or platform skill directories after postinstall.
 

package/dist/core/features-config.d.ts

@@ -63,6 +63,8 @@ export interface MultiAgentOrchestrationConfig {
     auto_consult_major_work?: boolean;
     /** Codex 69 — block new MCP/skill/handler files via PreToolUse (default true) */
     no_new_surface?: boolean;
+    /** 3.5.0 — PreToolUse gate after delegate-deferred (default true when lead_dev_mode) */
+    auto_chain_delegations?: boolean;
 }
 export interface AutonomousReportingConfig {
     enabled: boolean;

package/dist/integrations/grok/hooks/grok-hook-utils.js

@@ -6,6 +6,31 @@
 
 import fs from 'fs';
 import path from 'path';
+import {
+  checkPendingDelegationGate,
+  checkSubagentGate,
+  satisfyDelegationsFromToolInput,
+  isSubagentTool,
+  isOrchestrateToolEvent,
+  isReadOnlyTool,
+  isShellTool,
+  getActivePendingDelegations,
+  validateSpawnMatchesTodo,
+  updatePlanTodoStatusInPlace,
+} from '../../hooks/delegation-gate-runtime.mjs';
+
+export {
+  checkPendingDelegationGate,
+  checkSubagentGate,
+  satisfyDelegationsFromToolInput,
+  isSubagentTool,
+  isOrchestrateToolEvent,
+  isReadOnlyTool,
+  isShellTool,
+  getActivePendingDelegations,
+  validateSpawnMatchesTodo,
+  updatePlanTodoStatusInPlace,
+};
 
 export const LEAD_DEV_RULES = [
   'Phased plan + todos; assign best subagent; monitor output',
@@ -90,9 +115,15 @@ export function loadFeatures() {
       lead_dev_mode: orch.enabled !== false && orch.lead_dev_mode !== false,
       no_new_surface: orch.no_new_surface !== false,
       per_suite_test_triage: orch.per_suite_test_triage !== false,
+      auto_chain_delegations: orch.auto_chain_delegations !== false,
     };
   } catch {
-    return { lead_dev_mode: true, no_new_surface: true, per_suite_triage: true };
+    return {
+      lead_dev_mode: true,
+      no_new_surface: true,
+      per_suite_triage: true,
+      auto_chain_delegations: true,
+    };
   }
 }
 
@@ -110,23 +141,6 @@ export function loadBlockingCodexTerms() {
   }
 }
 
-export function leadDevPlanPath(root = workspaceRoot()) {
-  return path.join(root, '.xray', 'state', 'lead-dev-plan.json');
-}
-
-export function hasFreshLeadDevPlan(maxAgeMs = 4 * 60 * 60 * 1000) {
-  const planPath = leadDevPlanPath();
-  if (!fs.existsSync(planPath)) return false;
-  try {
-    const stat = fs.statSync(planPath);
-    if (Date.now() - stat.mtimeMs > maxAgeMs) return false;
-    const plan = JSON.parse(fs.readFileSync(planPath, 'utf8'));
-    return plan.active === true;
-  } catch {
-    return false;
-  }
-}
-
 export function extractToolContext(event) {
   const toolName = event.toolName || process.env.TOOL_NAME || 'unknown';
   const toolInput = event.toolInput ?? {};
@@ -167,16 +181,6 @@ export function checkSurfaceArea(paths, root = workspaceRoot()) {
   return null;
 }
 
-export function checkSubagentGate(toolName, features) {
-  if (!features.lead_dev_mode) return null;
-  if (!SUBAGENT_TOOLS.has(toolName)) return null;
-  if (hasFreshLeadDevPlan()) return null;
-  return (
-    'Codex 59/67: call xray-orchestrator analyze-complexity first — ' +
-    'writes .xray/state/lead-dev-plan.json required before spawn_subagent'
-  );
-}
-
 export function checkFullTestSuite(cmd, features) {
   if (!features.per_suite_test_triage) return null;
   const cmdText = cmd.toLowerCase();
@@ -195,10 +199,6 @@ export function isWriteTool(toolName) {
   return WRITE_TOOLS.has(toolName) || /write|edit|replace/i.test(toolName);
 }
 
-export function isShellTool(toolName) {
-  return /terminal|bash|shell|run_terminal/i.test(toolName);
-}
-
 export async function readStdinJson() {
   const chunks = [];
   for await (const chunk of process.stdin) chunks.push(chunk);
@@ -258,4 +258,25 @@ export function ensureSessionBoot(root = workspaceRoot(), source = '0xray/grok-b
     }
   }
   return writeSessionBoot(root, buildSessionBootPayload(root, source));
+}
+
+export function resolveSessionId(event) {
+  return (
+    event.sessionId ||
+    process.env.GROK_SESSION_ID ||
+    null
+  );
+}
+
+export function clearPendingDelegationsForSessionChange(newSessionId, root = workspaceRoot()) {
+  const filePath = path.join(root, '.xray', 'state', 'pending-delegations.json');
+  if (!fs.existsSync(filePath)) return false;
+  try {
+    const state = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    if (newSessionId && state.sessionId === newSessionId) return false;
+    fs.unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
 }

package/dist/integrations/grok/hooks/post-tool-use.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * Grok PostToolUse — auto-chain observability + targeted clear on Task spawn.
+ * Passive hook: stdout ignored by Grok; side effects only.
+ */
+
+import {
+  extractToolContext,
+  isOrchestrateToolEvent,
+  isSubagentTool,
+  readStdinJson,
+  resolveSessionId,
+  satisfyDelegationsFromToolInput,
+  validateSpawnMatchesTodo,
+  updatePlanTodoStatusInPlace,
+  workspaceRoot,
+} from './grok-hook-utils.js';
+import { appendHookActivity } from './grok-hook-activity.js';
+
+async function main() {
+  const root = workspaceRoot();
+  try {
+    const event = await readStdinJson();
+    const eventRoot = event.workspaceRoot || event.cwd || root;
+    const sessionId = resolveSessionId(event);
+    const { toolName, toolInput } = extractToolContext(event);
+
+    if (isOrchestrateToolEvent(toolName, toolInput)) {
+      appendHookActivity(eventRoot, 'grok-post-tool-use', 'auto-chain-pending', 'info', {
+        tool: toolName,
+        sessionId,
+        note: 'orchestrate-task completed — pending-delegations.json written by task-handler',
+      });
+    }
+
+    if (isSubagentTool(toolName)) {
+      const spawnCheck = validateSpawnMatchesTodo(toolInput, eventRoot);
+      if (spawnCheck.valid && spawnCheck.expectedTodoId) {
+        updatePlanTodoStatusInPlace(spawnCheck.expectedTodoId, 'in_progress', eventRoot);
+      }
+
+      const result = satisfyDelegationsFromToolInput(toolInput, eventRoot);
+      if (result.satisfied.length > 0) {
+        appendHookActivity(eventRoot, 'grok-post-tool-use', 'auto-chain-cleared', 'success', {
+          tool: toolName,
+          satisfied: result.satisfied.map((d) => d.id),
+          clearedAll: result.clearedAll,
+          planTodoId: spawnCheck.expectedTodoId ?? null,
+        });
+      }
+    }
+
+    process.exit(0);
+  } catch (err) {
+    appendHookActivity(root, 'grok-post-tool-use', 'hook-error', 'error', {
+      error: err.message,
+    });
+    process.exit(0);
+  }
+}
+
+main();

package/dist/integrations/grok/hooks/pre-tool-use.js

@@ -7,6 +7,7 @@
 import {
   checkCodexPatterns,
   checkFullTestSuite,
+  checkPendingDelegationGate,
   checkSubagentGate,
   checkSurfaceArea,
   ensureSessionBoot,
@@ -14,18 +15,20 @@ import {
   isWriteTool,
   loadFeatures,
   readStdinJson,
+  resolveSessionId,
   workspaceRoot,
 } from './grok-hook-utils.js';
 import { appendHookActivity } from './grok-hook-activity.js';
 
-function finish(root, decision, reason, hint, toolName) {
-  const out = { decision };
+function finish(root, decision, reason, hint, toolName, extra = {}) {
+  const out = { decision, ...extra };
   if (reason) out.reason = reason;
   if (hint) out.hint = hint;
   console.log(JSON.stringify(out));
   appendHookActivity(root, 'grok-pre-tool-use', decision, decision === 'deny' ? 'error' : 'info', {
     tool: toolName,
     reason: reason || hint || null,
+    gate: extra.gate || null,
     livePath: true,
   });
   process.exit(0);
@@ -43,10 +46,44 @@ async function main() {
     const features = loadFeatures();
     const ctx = extractFromEvent(event);
     toolName = ctx.toolName;
-    const { paths, content, cmd } = ctx;
+    const { paths, content, cmd, toolInput } = ctx;
+    const sessionId = resolveSessionId(event);
+
+    const delegationBlock = checkPendingDelegationGate(
+      toolName,
+      toolInput,
+      features,
+      eventRoot,
+      sessionId,
+    );
+    if (delegationBlock) {
+      finish(
+        eventRoot,
+        'deny',
+        delegationBlock.reason,
+        delegationBlock.hint,
+        toolName,
+        { gate: delegationBlock.gate },
+      );
+    }
 
-    const subagentBlock = checkSubagentGate(toolName, features);
-    if (subagentBlock) finish(eventRoot, 'deny', subagentBlock, null, toolName);
+    const subagentBlock = checkSubagentGate(
+      toolName,
+      features,
+      eventRoot,
+      sessionId,
+      toolInput,
+    );
+    if (subagentBlock) {
+      finish(
+        eventRoot,
+        'deny',
+        subagentBlock.reason || subagentBlock,
+        subagentBlock.hint || null,
+        toolName,
+        { gate: subagentBlock.gate || 'spawn-gate' },
+      );
+    }
 
     if (features.no_new_surface && isWriteTool(toolName) && paths.length) {
       const surfaceBlock = checkSurfaceArea(paths, eventRoot);
@@ -95,6 +132,7 @@ function extractFromEvent(event) {
 
   return {
     toolName,
+    toolInput,
     paths,
     content,
     cmd: String(toolInput.command || ''),

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

@@ -6,8 +6,10 @@
 
 import {
   buildSessionBootPayload,
+  clearPendingDelegationsForSessionChange,
   ensureSessionBoot,
   readStdinJson,
+  resolveSessionId,
   workspaceRoot,
   writeSessionBoot,
 } from './grok-hook-utils.js';
@@ -20,6 +22,12 @@ async function main() {
   try {
     const event = await readStdinJson();
     const eventRoot = event.workspaceRoot || event.cwd || root;
+    const sessionId = resolveSessionId(event);
+    if (clearPendingDelegationsForSessionChange(sessionId, eventRoot)) {
+      appendHookActivity(eventRoot, 'grok-session-start', 'stale-pending-cleared', 'info', {
+        sessionId,
+      });
+    }
     const source =
       HOOK_EVENT === 'user_prompt_submit'
         ? '0xray/grok-user-prompt-submit'

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

@@ -42,6 +42,21 @@
           }
         ]
       }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node",
+            "args": [
+              "${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/post-tool-use.js"
+            ],
+            "timeout": 15000
+          }
+        ]
+      }
     ]
   }
 }

package/dist/integrations/hermes-agent/__init__.py

@@ -187,17 +187,52 @@ def _is_xray_mcp(tool_name: str) -> bool:
     return tool_name.startswith("mcp_xray_")
 
 
+def _delegation_gate_block(tool_name: str, args: dict, task_id: str, **kwargs):
+    """3.5.1 multi-host parity — block via nucleus delegation-gate SSOT."""
+    session_id = (
+        kwargs.get("session_id")
+        or kwargs.get("sessionId")
+        or task_id
+        or ""
+    )
+    bridge_result = _call_bridge(
+        {
+            "command": "delegation-gate",
+            "phase": "pre",
+            "tool": tool_name,
+            "args": args or {},
+            "sessionId": session_id,
+            "host": "hermes",
+        },
+        timeout=10,
+    )
+    if bridge_result.get("allow") is False:
+        reason = bridge_result.get("reason", "Delegation gate blocked this tool")
+        gate = bridge_result.get("gate", "delegation-gate")
+        _log_to_file(
+            "activity.log",
+            f"[delegation-gate] deny tool={tool_name} gate={gate} reason={reason}",
+        )
+        return {"action": "block", "message": reason}
+    return None
+
+
 def _on_pre_tool_call(tool_name: str, args: dict, task_id: str, **kwargs):
     """Fires before ANY tool executes.
 
     Pipeline:
       1. Track stats
       2. Log tool-start event to disk
-      3. For code-producing tools: run quality gate + pre-processors via bridge
-      4. For non-code tools: nudge if Xray alternative exists
+      3. Delegation gate (pending + spawn todo) — may block tool
+      4. For code-producing tools: run quality gate + pre-processors via bridge
+      5. For non-code tools: nudge if Xray alternative exists
     """
     _session_stats["total_tool_calls"] += 1
 
+    block = _delegation_gate_block(tool_name, args, task_id, **kwargs)
+    if block:
+        return block
+
     # Log start event
     _log_tool_event("start", tool_name, args)
 
@@ -329,9 +364,21 @@ def _on_post_tool_call(tool_name: str, args: dict, result, task_id: str, **kwarg
     # Record outcome for the inference feedback loop
     _record_tool_outcome(tool_name, args or {}, error is None)
 
-    # delegate_task: validate all files the subagent changed
+    # delegate_task: clear pending delegations + validate subagent changes
     if tool_name == "delegate_task":
         tid = kwargs.get("task_id", "") or args.get("task_id", "") or task_id
+        session_id = kwargs.get("session_id") or kwargs.get("sessionId") or tid
+        _call_bridge(
+            {
+                "command": "delegation-gate",
+                "phase": "post",
+                "tool": tool_name,
+                "args": args or {},
+                "sessionId": session_id,
+                "host": "hermes",
+            },
+            timeout=10,
+        )
         if tid:
             _validate_subagent_changes(tid)
         return

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}` };
   }