0xray 3.4.9 → 3.5.0

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.9** — 7 MCP servers · 45 skills · 68 codex terms · 4 platform bridges
+**v3.5.0** — 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.9**).
+Quick reference for the xray AI orchestration framework (**v3.5.0**).
 
 **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.9** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
+**v3.5.0** — 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.9** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
+**v3.5.0** — **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.9**).
+Quick reference for the xray AI orchestration framework (**v3.5.0**).
 
 **42 agents** · **45 skills** · **7 consumer MCP servers** · **68 codex terms** · **3,226 tests**
 

package/dist/CHANGELOG.md

@@ -4,6 +4,38 @@ 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.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
+- **Routing SSOT** — `selectAgentForTask` checks `routeSubagent(taskType)` before capability scoring or memory routing; `type: implement` → `backend-engineer` (not `code-reviewer`)
+- **Unified complexity** — `buildLeadDevPlan` uses `max(thin-dispatch, MCP overallComplexity)`; `dependencyCount: 8` at complexity 70 forces phased plan
+
+### ✅ Tests
+- `verify-orchestrator-behavior.mjs` ships in tarball — 5 behavior assertions (NaN, multi-task todos, implement routing, phased plan, honest deferral)
+- Unit coverage: `agent-capabilities-routing`, extended `autonomy-kernel` + `execution-planner-dependencies`
+
+---
+
 ## [3.4.9] - 2026-06-19
 
 ### ⚠️ Breaking Changes

package/dist/README.md

@@ -1,6 +1,6 @@
 # xray — MCP-Centric AI Governance OS
 
-**v3.4.9** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
+**v3.5.0** — 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.9** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
+**v3.5.0** — **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

@@ -90,9 +90,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,
+    };
   }
 }
 
@@ -114,17 +120,134 @@ 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;
+const DEFAULT_PLAN_TTL_MS = 4 * 60 * 60 * 1000;
+
+export function loadPersistedLeadDevPlan(root = workspaceRoot()) {
+  const planPath = leadDevPlanPath(root);
+  if (!fs.existsSync(planPath)) return null;
   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;
+    return JSON.parse(fs.readFileSync(planPath, 'utf8'));
   } catch {
-    return false;
+    return null;
+  }
+}
+
+export function savePersistedLeadDevPlan(plan, root = workspaceRoot()) {
+  const planPath = leadDevPlanPath(root);
+  fs.mkdirSync(path.dirname(planPath), { recursive: true });
+  fs.writeFileSync(planPath, JSON.stringify(plan, null, 2));
+  return planPath;
+}
+
+export function getOutstandingPlanTodos(plan) {
+  if (!plan?.phases) return [];
+  return plan.phases.flatMap((p) => p.todos).filter(
+    (t) => t.status === 'pending' || t.status === 'in_progress',
+  );
+}
+
+export function getNextRequiredPlanTodo(plan) {
+  if (!plan?.phases) return null;
+  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;
+}
+
+/** Todo-level persistence: plan stays valid while outstanding todos exist */
+export function hasValidLeadDevPlanForSpawn(root = workspaceRoot()) {
+  const plan = loadPersistedLeadDevPlan(root);
+  if (!plan?.active) return false;
+  const outstanding = getOutstandingPlanTodos(plan);
+  if (outstanding.length > 0) return true;
+  const persistedAt = plan.persistedAt;
+  if (!persistedAt) {
+    try {
+      const stat = fs.statSync(leadDevPlanPath(root));
+      return Date.now() - stat.mtimeMs <= DEFAULT_PLAN_TTL_MS;
+    } catch {
+      return false;
+    }
+  }
+  return Date.now() - new Date(persistedAt).getTime() <= DEFAULT_PLAN_TTL_MS;
+}
+
+export function hasFreshLeadDevPlan(maxAgeMs = DEFAULT_PLAN_TTL_MS) {
+  return hasValidLeadDevPlanForSpawn();
+}
+
+function normalizeSpawnAgent(agent) {
+  const key = String(agent || '').toLowerCase().trim();
+  const aliases = {
+    'bug-triage-specialist': 'bug-triage',
+    'code-reviewer': 'code-review',
+  };
+  return aliases[key] ?? key;
+}
+
+function agentsAlign(expected, actual) {
+  const e = normalizeSpawnAgent(expected);
+  const a = normalizeSpawnAgent(actual);
+  return e === a || e.includes(a) || a.includes(e);
+}
+
+export function validateSpawnMatchesTodo(toolInput, root = workspaceRoot(), expectedTodo = null) {
+  const plan = loadPersistedLeadDevPlan(root);
+  const nextTodo = expectedTodo ?? (plan ? getNextRequiredPlanTodo(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, hint: null };
   }
+  if (prompt.includes(nextTodo.id.toLowerCase())) {
+    return { valid: true, expectedTodoId: nextTodo.id, hint: null };
+  }
+  if (prompt.includes(nextTodo.task.toLowerCase().slice(0, 30))) {
+    return { valid: true, expectedTodoId: nextTodo.id, hint: null };
+  }
+  if (subagent && agentsAlign(nextTodo.subagent, subagent) && prompt.length > 20) {
+    return { valid: true, expectedTodoId: nextTodo.id, hint: null };
+  }
+
+  return {
+    valid: false,
+    expectedTodoId: nextTodo.id,
+    reason: `Spawn must target plan todo ${nextTodo.id} before other work`,
+    gate: 'spawn-todo-persistence',
+    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 updatePlanTodoStatusInPlace(todoId, status, root = workspaceRoot()) {
+  const plan = loadPersistedLeadDevPlan(root);
+  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) {
+    fs.writeFileSync(leadDevPlanPath(root), JSON.stringify(plan, null, 2));
+  }
+  return updated;
 }
 
 export function extractToolContext(event) {
@@ -167,14 +290,39 @@ export function checkSurfaceArea(paths, root = workspaceRoot()) {
   return null;
 }
 
-export function checkSubagentGate(toolName, features) {
+export function checkSubagentGate(toolName, features, root = workspaceRoot(), sessionId = null, toolInput = {}) {
   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'
-  );
+  if (!isSubagentTool(toolName)) return null;
+
+  if (!hasValidLeadDevPlanForSpawn(root)) {
+    return {
+      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 (features.auto_chain_delegations === false) return null;
+
+  const pending = getActivePendingDelegations(root, sessionId);
+  const expectedTodo =
+    pending[0]?.planTodoId && loadPersistedLeadDevPlan(root)
+      ? loadPersistedLeadDevPlan(root).phases
+          .flatMap((p) => p.todos)
+          .find((t) => t.id === pending[0].planTodoId) ?? null
+      : null;
+
+  const validation = validateSpawnMatchesTodo(toolInput, root, expectedTodo);
+  if (!validation.valid) {
+    return {
+      reason: validation.reason,
+      gate: validation.gate,
+      hint: validation.hint,
+    };
+  }
+
+  return null;
 }
 
 export function checkFullTestSuite(cmd, features) {
@@ -258,4 +406,230 @@ export function ensureSessionBoot(root = workspaceRoot(), source = '0xray/grok-b
     }
   }
   return writeSessionBoot(root, buildSessionBootPayload(root, source));
+}
+
+const READ_TOOLS = new Set([
+  'read_file',
+  'Read',
+  'grep',
+  'Grep',
+  'glob',
+  'Glob',
+  'list_dir',
+  'ListDir',
+  'web_search',
+  'WebSearch',
+  'codebase_search',
+  'SemanticSearch',
+]);
+
+const ORCHESTRATOR_CONSULT_TOOLS = new Set([
+  'analyze-complexity',
+  'analyze_complexity',
+  'get-orchestration-status',
+  'get_orchestration_status',
+  'orchestrate-task',
+  'orchestrate_task',
+]);
+
+export function pendingDelegationsPath(root = workspaceRoot()) {
+  return path.join(root, '.xray', 'state', 'pending-delegations.json');
+}
+
+export function loadPendingDelegationsState(root = workspaceRoot()) {
+  const filePath = pendingDelegationsPath(root);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function savePendingDelegationsState(state, root = workspaceRoot()) {
+  const filePath = pendingDelegationsPath(root);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(state, null, 2));
+}
+
+export function resolveSessionId(event) {
+  return (
+    event.sessionId ||
+    process.env.GROK_SESSION_ID ||
+    null
+  );
+}
+
+export function isPendingStateActive(state, sessionId) {
+  if (!state || !sessionId || state.sessionId !== sessionId) return false;
+  const age = Date.now() - new Date(state.createdAt).getTime();
+  if (age > (state.ttlMs ?? 4 * 60 * 60 * 1000)) return false;
+  return state.delegations?.some((d) => d.status === 'pending');
+}
+
+export function getActivePendingDelegations(root, sessionId) {
+  const state = loadPendingDelegationsState(root);
+  if (!isPendingStateActive(state, sessionId)) return [];
+  return state.delegations.filter((d) => d.status === 'pending');
+}
+
+export function clearPendingDelegationsForSessionChange(newSessionId, root = workspaceRoot()) {
+  const state = loadPendingDelegationsState(root);
+  if (!state) return false;
+  if (newSessionId && state.sessionId === newSessionId) return false;
+  try {
+    fs.unlinkSync(pendingDelegationsPath(root));
+    return true;
+  } catch {
+    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 isReadOnlyTool(toolName) {
+  return READ_TOOLS.has(toolName) || /^(read|grep|glob|list)/i.test(toolName);
+}
+
+export function isSubagentTool(toolName) {
+  return SUBAGENT_TOOLS.has(toolName) || /^task$/i.test(toolName) || toolName === 'spawn_subagent';
+}
+
+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;
+}
+
+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);
+}
+
+export function satisfyDelegationsFromToolInput(toolInput, root = workspaceRoot()) {
+  const state = loadPendingDelegationsState(root);
+  if (!state) return { satisfied: [], clearedAll: false };
+
+  const prompt = String(
+    toolInput.prompt || toolInput.description || toolInput.task || '',
+  ).toLowerCase();
+  const subagent = String(toolInput.subagent_type || toolInput.agent || '').toLowerCase();
+  const delegationId = toolInput.delegationId || toolInput.delegation_id;
+
+  const pending = state.delegations.filter((d) => d.status === 'pending');
+  if (pending.length === 0) return { satisfied: [], clearedAll: false };
+
+  let matches = [];
+  if (delegationId) {
+    matches = pending.filter((d) => d.id === delegationId);
+  } else {
+    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 (subagent && d.agent.toLowerCase().includes(subagent)) {
+        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, 30))) {
+      matches = [only];
+    }
+  }
+
+  if (matches.length === 0) return { satisfied: [], clearedAll: false };
+
+  const now = new Date().toISOString();
+  const ids = new Set(matches.map((m) => m.id));
+  for (const d of state.delegations) {
+    if (ids.has(d.id) && d.status === 'pending') {
+      d.status = 'satisfied';
+      d.satisfiedAt = now;
+    }
+  }
+  savePendingDelegationsState(state, root);
+  for (const m of matches) {
+    if (m.planTodoId) {
+      updatePlanTodoStatusInPlace(m.planTodoId, 'in_progress', root);
+    }
+  }
+  const clearedAll = !state.delegations.some((d) => d.status === 'pending');
+  return { satisfied: matches, clearedAll };
+}
+
+/**
+ * Surgical gate: block writes and unrelated work while pending delegations exist.
+ * Allows read-only tools, orchestrator consult MCP, focused test shell, and Task/spawn.
+ */
+export function checkPendingDelegationGate(toolName, toolInput, features, root, sessionId) {
+  if (!features.lead_dev_mode || features.auto_chain_delegations === false) return null;
+  if (!sessionId) return null;
+
+  const pending = getActivePendingDelegations(root, sessionId);
+  if (pending.length === 0) return null;
+
+  if (isSubagentTool(toolName)) return null;
+
+  if (isReadOnlyTool(toolName)) return null;
+
+  if (isOrchestratorConsultMcp(toolName, toolInput)) return null;
+
+  if (isShellTool(toolName)) {
+    const cmd = String(toolInput.command || '');
+    if (isFocusedTestCommand(cmd)) return null;
+  }
+
+  const primary = pending[0];
+  return {
+    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: pending.length,
+    delegationId: primary.id,
+  };
 }

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();