0xray 3.5.4 → 4.0.0

package/dist/governance/governance-service.js

@@ -18,8 +18,9 @@
 import { mcpClientManager } from '../mcps/mcp-client.js';
 import { callInProcessSkill } from '../mcps/in-process-skill-registry.js';
 import { getGovernanceIntegration, } from '../integrations/governance/index.js';
-import { mergeVotes } from './governance-core.js';
+import { applyDecisionMatrix, calculateMetamorphosisScore, mergeVotes, } from './governance-core.js';
 import { frameworkLogger } from '../core/framework-logger.js';
+import { featuresConfigLoader } from '../core/features-config.js';
 export class GovernanceService {
     constructor() {
         // We deliberately do *not* cache the integration here.
@@ -39,7 +40,7 @@ export class GovernanceService {
      */
     async govern(request) {
         const { proposals, context, options } = request;
-        const requireExternal = options?.requireExternalDynamo ?? true;
+        const requireExternal = this.resolveRequireExternalDynamo(options?.requireExternalDynamo);
         const timeoutMs = options?.timeoutMs ?? 90000;
         const maxAbstentionThreshold = options?.maxAbstentionThreshold ?? 1.0;
         frameworkLogger.log('governance-service', 'govern-start', 'info', {
@@ -59,7 +60,7 @@ export class GovernanceService {
             }
         }
         // Run governance with end-to-end timeout
-        const result = await this.runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs);
+        const result = await this.runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs, options?.metamorphosisThreshold);
         // Check abstention threshold
         if (result.results.length > 0 && maxAbstentionThreshold < 1.0) {
             const totalVotes = result.results.reduce((sum, r) => sum + r.votes.length, 0);
@@ -91,7 +92,26 @@ export class GovernanceService {
             },
         };
     }
-    async runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs) {
+    resolveRequireExternalDynamo(explicit) {
+        if (explicit !== undefined)
+            return explicit;
+        if (process.env.XRAY_LOCAL_MODE === '1' || process.env.XRAY_LOCAL_MODE === 'true') {
+            return false;
+        }
+        try {
+            const config = featuresConfigLoader.loadConfig();
+            const ig = config.inference_governance;
+            if (ig?.require_external_dynamo === false)
+                return false;
+            if (ig?.local_mode === true)
+                return false;
+        }
+        catch {
+            /* default strict */
+        }
+        return true;
+    }
+    async runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs, metamorphosisThreshold = 0.7) {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
         try {
@@ -112,12 +132,67 @@ export class GovernanceService {
                     ...(externalVotes[index] || []),
                 ];
                 const merged = mergeVotes(votes);
+                const externalVote = votes.find((v) => v.server === 'external-dynamo');
+                let finalDecision = merged.finalDecision;
+                let averageConfidence = merged.averageConfidence;
+                let moralOverride = 'none';
+                if (externalVote?.moralTension ||
+                    externalVote?.moralScore != null ||
+                    externalVote?.moralFusion != null) {
+                    const matrixInput = {
+                        resonance: averageConfidence,
+                        isotopicRatio: externalVote.moralFusion ?? 0.5,
+                    };
+                    if (externalVote.moralTension != null) {
+                        matrixInput.moralTension = externalVote.moralTension;
+                    }
+                    if (externalVote.moralScore != null) {
+                        matrixInput.moralScore = externalVote.moralScore;
+                    }
+                    if (externalVote.moralFusion != null) {
+                        matrixInput.moralFusion = externalVote.moralFusion;
+                    }
+                    const matrix = applyDecisionMatrix(matrixInput);
+                    moralOverride = matrix.moralOverride ?? 'none';
+                    if (matrix.recommendation === 'REJECT') {
+                        finalDecision = 'reject';
+                    }
+                    else if (matrix.recommendation === 'NEEDS_REVISION' && finalDecision === 'approve') {
+                        finalDecision = 'needs_revision';
+                    }
+                    else if (matrix.recommendation === 'PASS' && finalDecision !== 'reject') {
+                        finalDecision = 'approve';
+                    }
+                    averageConfidence = matrix.confidence;
+                }
+                let metamorphosisScore;
+                if (proposal.type === 'metamorphosis' || proposal.source === 'metamorphosis') {
+                    const proposalType = proposal.type === 'compliance'
+                        ? 'compliance'
+                        : proposal.type === 'automate' || proposal.type === 'codify'
+                            ? proposal.type
+                            : 'fix';
+                    const metamorphosisInput = {
+                        averageConfidence,
+                        proposalType,
+                        resonanceScore: averageConfidence,
+                    };
+                    if (externalVote?.moralFusion != null) {
+                        metamorphosisInput.historicalCoherence = externalVote.moralFusion;
+                    }
+                    metamorphosisScore = calculateMetamorphosisScore(metamorphosisInput);
+                    if (metamorphosisScore < metamorphosisThreshold) {
+                        finalDecision = 'needs_revision';
+                    }
+                }
                 return {
                     proposalId: proposal.id,
-                    finalDecision: merged.finalDecision,
-                    averageConfidence: merged.averageConfidence,
+                    finalDecision,
+                    averageConfidence,
                     votes,
                     reasoningSummary: merged.reasoningSummary,
+                    moralOverride,
+                    ...(metamorphosisScore != null ? { metamorphosisScore } : {}),
                 };
             });
             return { results };

package/dist/infrastructure/schemas/cloud-schemas.d.ts

@@ -50,8 +50,8 @@ export declare const AWSLoadBalancerConfigSchema: z.ZodObject<{
             name: z.ZodString;
             priority: z.ZodNumber;
             action: z.ZodEnum<{
-                allow: "allow";
                 deny: "deny";
+                allow: "allow";
                 count: "count";
             }>;
             conditions: z.ZodArray<z.ZodObject<{

package/dist/integrations/enforcement-gate.js

@@ -252,12 +252,22 @@ export async function afterToolHook(tool, args, _result, _error, _context) {
             const result = _result;
             if (result && typeof result === "object" && "title" in result && "description" in result) {
                 const { handleGovernRequest } = await import("../nucleus/index.js");
+                const localMode = process.env.XRAY_LOCAL_MODE === "1" || process.env.XRAY_LOCAL_MODE === "true";
                 const governanceResult = await handleGovernRequest({
-                    proposalId: `gate-${Date.now()}`,
-                    title: String(result.title || ""),
-                    description: String(result.description || ""),
-                    type: String(result.type || "fix"),
-                    content: result,
+                    proposals: [
+                        {
+                            id: `gate-${Date.now()}`,
+                            type: String(result.type || "fix"),
+                            title: String(result.title || ""),
+                            description: String(result.description || ""),
+                            evidence: [],
+                            source: "manual",
+                            metadata: result,
+                        },
+                    ],
+                    options: {
+                        requireExternalDynamo: localMode ? false : undefined,
+                    },
                 });
                 governanceTriggered = governanceResult?.overallDecision === 'approve';
                 if (governanceTriggered) {

package/dist/integrations/grok/grok-cli.d.ts

@@ -19,7 +19,10 @@ export interface GrokInstallOptions {
     dryRun?: boolean;
 }
 export declare function installForGrokCLI(options?: GrokInstallOptions): Promise<void>;
+/** Grok TUI reads <project>/.grok/config.toml, not the package copy. */
+export declare function writeProjectRepertoireMcp(projectRoot: string): string | null;
 declare const _default: {
     installForGrokCLI: typeof installForGrokCLI;
+    writeProjectRepertoireMcp: typeof writeProjectRepertoireMcp;
 };
 export default _default;

package/dist/integrations/grok/grok-cli.js

@@ -24,17 +24,8 @@ import { syncBuiltinSkills } from '../../cli/commands/skill-install.js';
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
 const packageRoot = path.resolve(__dirname, '..', '..', '..');
 const requireCjs = createRequire(import.meta.url);
-const { resolveConsumerTargetDir } = requireCjs(path.join(packageRoot, 'scripts/node/install-bridges.cjs'));
-/** Canonical 7-server MCP surface — matches install-bridges.cjs and package .mcp.json */
-const XRAY_MCP_SERVERS = [
-    { name: 'xray-governance', mcpCmd: 'governance', env: { XRAY_FORCE_MCP_GOVERNANCE: 'true' } },
-    { name: 'xray-skills', mcpCmd: 'skills', env: {} },
-    { name: 'xray-orchestrator', mcpCmd: 'orchestrator', env: {} },
-    { name: 'xray-enforcer', mcpCmd: 'enforcer', env: {} },
-    { name: 'xray-researcher', mcpCmd: 'researcher', env: {} },
-    { name: 'xray-code-review', mcpCmd: 'code-review', env: {} },
-    { name: 'xray-architect-tools', mcpCmd: 'architect-tools', env: {} },
-];
+const { resolveConsumerTargetDir, patchGrokHooks } = requireCjs(path.join(packageRoot, 'scripts/node/install-bridges.cjs'));
+const { XRAY_MCP_SERVERS, resolveRepertoireMcp } = requireCjs(path.join(packageRoot, 'scripts/node/bridge-mcp-wiring.cjs'));
 function registerGrokMcpServers(targetDir) {
     try {
         execSync('which grok', { stdio: 'ignore' });
@@ -99,6 +90,17 @@ export async function installForGrokCLI(options = {}) {
         if (globalCopied > 0) {
             console.log(`\x1b[32m✓ Synced ${globalCopied} builtin skills to ~/.grok/skills/\x1b[0m`);
         }
+        pinGrokPluginToInstalledDist(targetPluginDir, packageRoot, targetDir);
+        wearGrokHookCommands(targetPluginDir, packageRoot, targetDir);
+        const projectPluginDir = path.join(targetDir, '.grok', 'plugins', '0xray');
+        if (projectPluginDir !== targetPluginDir) {
+            if (!fs.existsSync(projectPluginDir) || options.force) {
+                fs.cpSync(sourceDir, projectPluginDir, { recursive: true, force: true });
+            }
+            pinGrokPluginToInstalledDist(projectPluginDir, packageRoot, targetDir);
+            wearGrokHookCommands(projectPluginDir, packageRoot, targetDir);
+        }
+        writeProjectRepertoireMcp(targetDir);
         // Attempt auto-trust (best effort)
         try {
             execSync(`grok plugins trust "${targetPluginDir}"`, { stdio: 'ignore' });
@@ -115,11 +117,88 @@ export async function installForGrokCLI(options = {}) {
         console.log('Restart Grok or run `grok` to load the new hooks and MCP servers.');
     }
     catch (err) {
-        frameworkLogger.log('grok-integration', 'install-error', 'error', { error: err.message });
-        console.error('Failed to install Grok plugin:', err.message);
+        const message = err instanceof Error ? err.message : String(err);
+        frameworkLogger.log('grok-integration', 'install-error', 'error', { error: message });
+        console.error('Failed to install Grok plugin:', message);
     }
     frameworkLogger.log('grok-integration', 'install-complete', 'info', {});
 }
+function wearGrokHookCommands(pluginDir, xrayRoot, targetDir) {
+    patchGrokHooks(pluginDir, xrayRoot, targetDir, (label, action, status, details) => {
+        const level = status === 'success' ||
+            status === 'error' ||
+            status === 'info' ||
+            status === 'debug' ||
+            status === 'warning'
+            ? status
+            : 'info';
+        frameworkLogger.log(label, action, level, details ?? {});
+    }, 'grok-install');
+}
+function pinGrokPluginToInstalledDist(pluginDir, xrayRoot, targetDir) {
+    const hookJs = path.join(xrayRoot, 'dist/integrations/grok/hooks/pre-tool-use.js');
+    const cliJs = path.join(xrayRoot, 'dist/cli/index.js');
+    if (!fs.existsSync(hookJs))
+        return;
+    const hooksPath = path.join(pluginDir, 'hooks', 'hooks.json');
+    if (fs.existsSync(hooksPath)) {
+        const text = fs.readFileSync(hooksPath, 'utf8');
+        fs.writeFileSync(hooksPath, text.split('${XRAY_AI_PATH:-node_modules/0xray}').join(xrayRoot));
+    }
+    const mcpPath = path.join(pluginDir, '.mcp.json');
+    if (fs.existsSync(mcpPath) && fs.existsSync(cliJs)) {
+        const mcp = JSON.parse(fs.readFileSync(mcpPath, 'utf8'));
+        for (const server of Object.values(mcp.mcpServers ?? {})) {
+            if (server.command === 'npx' && Array.isArray(server.args) && server.args.includes('mcp')) {
+                const mcpIdx = server.args.indexOf('mcp');
+                const mcpCmd = server.args[mcpIdx + 1] ?? 'governance';
+                server.command = 'node';
+                server.args = [cliJs, 'mcp', mcpCmd];
+            }
+        }
+        const repertoireMcp = resolveRepertoireMcp(targetDir);
+        if (mcp.mcpServers) {
+            if (repertoireMcp) {
+                mcp.mcpServers.repertoire = {
+                    command: 'node',
+                    args: [repertoireMcp],
+                };
+            }
+            else {
+                delete mcp.mcpServers.repertoire;
+            }
+        }
+        fs.writeFileSync(mcpPath, `${JSON.stringify(mcp, null, 2)}\n`);
+    }
+}
+/** Grok TUI reads <project>/.grok/config.toml, not the package copy. */
+export function writeProjectRepertoireMcp(projectRoot) {
+    const repertoireMcp = resolveRepertoireMcp(projectRoot);
+    if (!repertoireMcp)
+        return null;
+    const grokDir = path.join(projectRoot, '.grok');
+    fs.mkdirSync(grokDir, { recursive: true });
+    const tomlPath = path.join(grokDir, 'config.toml');
+    const block = `[mcp_servers.repertoire]
+command = "node"
+args = [${JSON.stringify(repertoireMcp)}]
+enabled = true
+`;
+    let existing = '';
+    if (fs.existsSync(tomlPath)) {
+        existing = fs.readFileSync(tomlPath, 'utf8');
+    }
+    if (/\[mcp_servers\.repertoire\]/.test(existing)) {
+        existing = existing.replace(/\[mcp_servers\.repertoire\][\s\S]*?(?=\n\[|$)/, block.trim());
+        fs.writeFileSync(tomlPath, existing.endsWith('\n') ? existing : `${existing}\n`);
+    }
+    else {
+        const prefix = existing.trim() ? `${existing.trim()}\n\n` : '';
+        fs.writeFileSync(tomlPath, `${prefix}${block}`);
+    }
+    return tomlPath;
+}
 export default {
     installForGrokCLI,
+    writeProjectRepertoireMcp,
 };

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

@@ -17,7 +17,16 @@ import {
   getActivePendingDelegations,
   validateSpawnMatchesTodo,
   updatePlanTodoStatusInPlace,
+  loadDelegationGateFeatures,
 } from '../../hooks/delegation-gate-runtime.mjs';
+import { isConferPendingForSession } from '../../hooks/confer-hook-runtime.mjs';
+import { getActiveUserAsideBoot } from '../../hooks/user-aside-hook-runtime.mjs';
+import {
+  applyStationHeat,
+  buildRepertoireResume as stationRepertoireResume,
+  readExistingBoot,
+  writeStationMarkdown,
+} from '../../hooks/station-hook-runtime.mjs';
 
 export {
   checkPendingDelegationGate,
@@ -105,9 +114,44 @@ export function resolveCodexPath(root = workspaceRoot()) {
   return null;
 }
 
+export function resolveSiblingWorkspaceRoots(root = workspaceRoot()) {
+  const featuresPath = resolveFeaturesPath(root);
+  if (!featuresPath) return [];
+  try {
+    const data = JSON.parse(fs.readFileSync(featuresPath, 'utf8'));
+    const siblings = data.multi_agent_orchestration?.sibling_repos ?? [];
+    if (!Array.isArray(siblings)) return [];
+    const resolved = [];
+    for (const entry of siblings) {
+      const rel = typeof entry === 'string' ? entry : entry?.path;
+      if (!rel || typeof rel !== 'string') continue;
+      const abs = path.isAbsolute(rel) ? rel : path.resolve(root, rel);
+      if (!fs.existsSync(abs)) continue;
+      resolved.push({
+        path: abs,
+        label: typeof entry === 'object' && entry.label ? entry.label : path.basename(abs),
+      });
+    }
+    return resolved;
+  } catch {
+    return [];
+  }
+}
+
+export function buildRepertoireResume(root = workspaceRoot()) {
+  return stationRepertoireResume(root);
+}
+
 export function loadFeatures(root = workspaceRoot()) {
   const featuresPath = resolveFeaturesPath(root);
-  if (!featuresPath) return { lead_dev_mode: true, no_new_surface: true, per_suite_triage: true };
+  if (!featuresPath) {
+    return {
+      lead_dev_mode: true,
+      no_new_surface: true,
+      per_suite_triage: true,
+      grok_postprocessor_light: false,
+    };
+  }
   try {
     const data = JSON.parse(fs.readFileSync(featuresPath, 'utf8'));
     const orch = data.multi_agent_orchestration ?? {};
@@ -116,6 +160,8 @@ export function loadFeatures(root = workspaceRoot()) {
       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,
+      grok_postprocessor_light: data.grok_postprocessor_light === true,
+      sibling_repos: resolveSiblingWorkspaceRoots(root),
     };
   } catch {
     return {
@@ -123,6 +169,8 @@ export function loadFeatures(root = workspaceRoot()) {
       no_new_surface: true,
       per_suite_triage: true,
       auto_chain_delegations: true,
+      grok_postprocessor_light: false,
+      sibling_repos: [],
     };
   }
 }
@@ -160,9 +208,11 @@ export function extractToolContext(event) {
   return { toolName, toolInput, paths, content, cmd: String(toolInput.command || '') };
 }
 
-export function checkCodexPatterns(content) {
+export function checkCodexPatterns(content, options = {}) {
   if (!content) return null;
-  for (const { message, pattern } of CODEX_BLOCK_PATTERNS) {
+  const only = Array.isArray(options.terms) ? options.terms : null;
+  for (const { message, pattern, terms } of CODEX_BLOCK_PATTERNS) {
+    if (only && !terms.some((n) => only.includes(n))) continue;
     if (pattern.test(content)) return message;
     pattern.lastIndex = 0;
   }
@@ -215,23 +265,51 @@ export function sessionBootPath(root = workspaceRoot()) {
   return path.join(root, '.xray', 'state', 'session-boot.json');
 }
 
+export function loadConferPending(root = workspaceRoot(), sessionId = null) {
+  try {
+    return isConferPendingForSession(root, sessionId);
+  } catch {
+    return false;
+  }
+}
+
 export function buildSessionBootPayload(root, source = '0xray/grok-session-start', extra = {}) {
-  const features = loadFeatures();
+  const features = loadFeatures(root);
   const blockingTerms = loadBlockingCodexTerms();
+  const siblingRoots = features.sibling_repos ?? resolveSiblingWorkspaceRoots(root);
+  const sessionId =
+    extra.sessionId || process.env.GROK_SESSION_ID || process.env.GROK_SESSION || null;
+  const conferPending = loadConferPending(root, sessionId);
+  const userAsideBoot = getActiveUserAsideBoot(root, sessionId);
+  const gateFeatures = loadDelegationGateFeatures(root, 'grok');
+  const frontier = gateFeatures.ceremony === 'lite';
+  const existing = readExistingBoot(root);
+  const heat = applyStationHeat(root, extra.host || 'grok', extra, existing);
   return {
     hook: source,
     lead_dev_mode: features.lead_dev_mode,
     no_new_surface: features.no_new_surface,
+    host: extra.host || 'grok',
+    suit_profile: gateFeatures.suit_profile ?? 'guided',
+    ceremony: gateFeatures.ceremony ?? 'full',
+    spawn_plan_mode: gateFeatures.spawn_plan_mode ?? 'deny',
     codexBlockingTermCount: blockingTerms.length,
     codexTerms: [59, 67, 68, 69],
     rules: features.lead_dev_mode ? LEAD_DEV_RULES : [],
-    mcpIntake: 'xray-orchestrator → analyze-complexity (required before spawn_subagent)',
-    enforcement: 'PreToolUse hook — codex patterns + surface area + spawn gate',
+    mcpIntake: frontier
+      ? 'xray-orchestrator analyze-complexity optional on frontier (spawn warns, does not deny)'
+      : 'xray-orchestrator → analyze-complexity (required before spawn_subagent)',
+    enforcement: 'PreToolUse hook — Codex constitution always on; ceremony scales by suit_temperament',
     workspaceRoot: root,
-    sessionId: process.env.GROK_SESSION_ID || null,
+    ...heat,
+    ...(siblingRoots.length > 0 ? { siblingWorkspaceRoots: siblingRoots } : {}),
+    ...(conferPending ? { conferPending: true, conferTrigger: 'analyze-complexity at synthesis checkpoint' } : {}),
+    ...(userAsideBoot ?? {}),
+    sessionId,
     timestamp: new Date().toISOString(),
     source,
     ...extra,
+    ...heat,
   };
 }
 
@@ -240,19 +318,31 @@ export function writeSessionBoot(root, payload) {
     const stateDir = path.join(root, '.xray', 'state');
     fs.mkdirSync(stateDir, { recursive: true });
     fs.writeFileSync(sessionBootPath(root), JSON.stringify(payload, null, 2));
+    writeStationMarkdown(root, payload);
     return sessionBootPath(root);
   } catch {
     return null;
   }
 }
 
-/** Boot on SessionStart, UserPromptSubmit, or first PreToolUse if missing. */
+export function sessionBootNeedsRefresh(existing, root) {
+  if (!existing || typeof existing !== 'object') return true;
+  if (existing.lead_dev_mode === undefined) return true;
+  if (existing.host !== 'grok') return true;
+  if (!existing.suit_profile) return true;
+  if (existing.workspaceRoot && existing.workspaceRoot !== root) return true;
+  if (!existing.repertoireResume) return true;
+  if (!existing.stationLine) return true;
+  return false;
+}
+
+/** Boot on SessionStart, UserPromptSubmit, or first PreToolUse if missing/stale. */
 export function ensureSessionBoot(root = workspaceRoot(), source = '0xray/grok-boot') {
   const bootPath = sessionBootPath(root);
   if (fs.existsSync(bootPath)) {
     try {
       const existing = JSON.parse(fs.readFileSync(bootPath, 'utf8'));
-      if (existing.lead_dev_mode !== undefined) return bootPath;
+      if (!sessionBootNeedsRefresh(existing, root)) return bootPath;
     } catch {
       /* rewrite corrupt boot */
     }

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

@@ -8,6 +8,8 @@ import {
   extractToolContext,
   isOrchestrateToolEvent,
   isSubagentTool,
+  isWriteTool,
+  loadFeatures,
   readStdinJson,
   resolveSessionId,
   workspaceRoot,
@@ -17,6 +19,7 @@ import {
   evaluatePostToolSpawn,
   isOrchestrateToolEvent as gateIsOrchestrateToolEvent,
 } from '../../hooks/delegation-gate-runtime.mjs';
+import { recordRoutingOutcome, runGrokPostprocessorLight } from '../../hooks/pipeline-hook-runtime.mjs';
 
 function extractToolOutput(event) {
   return (
@@ -29,40 +32,77 @@ function extractToolOutput(event) {
   );
 }
 
-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);
+export function handlePostToolUse(event, root = workspaceRoot()) {
+  const eventRoot = event.workspaceRoot || event.cwd || root;
+  const sessionId = resolveSessionId(event);
+  const { toolName, toolInput } = extractToolContext(event);
 
-    if (isOrchestrateToolEvent(toolName, toolInput) || gateIsOrchestrateToolEvent(toolName, toolInput)) {
-      appendHookActivity(eventRoot, 'grok-post-tool-use', 'auto-chain-pending', 'info', {
+  if (isOrchestrateToolEvent(toolName, toolInput) || gateIsOrchestrateToolEvent(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',
+    });
+    try {
+      recordRoutingOutcome(eventRoot, {
         tool: toolName,
+        agent: toolInput?.subagent_type ?? toolInput?.agent ?? 'orchestrate-task',
+        planTodoId: toolInput?.planTodoId ?? null,
         sessionId,
-        note: 'orchestrate-task completed — pending-delegations.json written by task-handler',
       });
+    } catch {
+      /* non-blocking */
     }
+  }
+
+  const features = loadFeatures(eventRoot);
+  if (features.grok_postprocessor_light === true && isWriteTool(toolName)) {
+    try {
+      const paths = [
+        toolInput?.path,
+        toolInput?.filePath,
+        toolInput?.file_path,
+      ].filter(Boolean);
+      runGrokPostprocessorLight(eventRoot, { tool: toolName, paths });
+    } catch {
+      /* non-blocking */
+    }
+  }
+
+  if (isSubagentTool(toolName)) {
+    const spawnResult = evaluatePostToolSpawn(toolName, toolInput, eventRoot, {
+      toolOutput: extractToolOutput(event),
+      sessionId,
+    });
 
-    if (isSubagentTool(toolName)) {
-      const spawnResult = evaluatePostToolSpawn(toolName, toolInput, eventRoot, {
-        toolOutput: extractToolOutput(event),
+    if (spawnResult.satisfied.length > 0 || spawnResult.expectedTodoId) {
+      appendHookActivity(eventRoot, 'grok-post-tool-use', 'auto-chain-cleared', 'success', {
+        tool: toolName,
+        satisfied: spawnResult.satisfied.map((d) => d.id),
+        clearedAll: spawnResult.clearedAll,
+        planTodoId: spawnResult.expectedTodoId ?? null,
+        receiptRecorded: spawnResult.receiptRecorded ?? false,
+        todoCompleted: spawnResult.todoCompleted ?? false,
+      });
+    }
+    try {
+      recordRoutingOutcome(eventRoot, {
+        tool: toolName,
+        agent: toolInput?.subagent_type ?? toolInput?.agent ?? 'subagent',
+        planTodoId: toolInput?.planTodoId ?? spawnResult.expectedTodoId ?? null,
         sessionId,
       });
-
-      if (spawnResult.satisfied.length > 0 || spawnResult.expectedTodoId) {
-        appendHookActivity(eventRoot, 'grok-post-tool-use', 'auto-chain-cleared', 'success', {
-          tool: toolName,
-          satisfied: spawnResult.satisfied.map((d) => d.id),
-          clearedAll: spawnResult.clearedAll,
-          planTodoId: spawnResult.expectedTodoId ?? null,
-          receiptRecorded: spawnResult.receiptRecorded ?? false,
-          todoCompleted: spawnResult.todoCompleted ?? false,
-        });
-      }
+    } catch {
+      /* non-blocking */
     }
+  }
+}
 
+async function main() {
+  const root = workspaceRoot();
+  try {
+    const event = await readStdinJson();
+    handlePostToolUse(event, root);
     process.exit(0);
   } catch (err) {
     appendHookActivity(root, 'grok-post-tool-use', 'hook-error', 'error', {
@@ -72,4 +112,7 @@ async function main() {
   }
 }
 
-main();
+const launchedAsCli = Boolean(process.argv[1] && process.argv[1].endsWith('post-tool-use.js'));
+if (launchedAsCli) {
+  main();
+}