0xray 3.5.5 → 4.0.0

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

@@ -8,6 +8,8 @@ import {
   extractToolContext,
   isOrchestrateToolEvent,
   isSubagentTool,
+  isWriteTool,
+  loadFeatures,
   readStdinJson,
   resolveSessionId,
   workspaceRoot,
@@ -17,7 +19,7 @@ import {
   evaluatePostToolSpawn,
   isOrchestrateToolEvent as gateIsOrchestrateToolEvent,
 } from '../../hooks/delegation-gate-runtime.mjs';
-import { recordRoutingOutcome } from '../../hooks/pipeline-hook-runtime.mjs';
+import { recordRoutingOutcome, runGrokPostprocessorLight } from '../../hooks/pipeline-hook-runtime.mjs';
 
 function extractToolOutput(event) {
   return (
@@ -30,60 +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',
       });
-      try {
-        recordRoutingOutcome(eventRoot, {
-          tool: toolName,
-          agent: toolInput?.subagent_type ?? toolInput?.agent ?? 'orchestrate-task',
-          planTodoId: toolInput?.planTodoId ?? null,
-          sessionId,
-        });
-      } catch {
-        /* non-blocking */
-      }
+    } 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,
-        });
-      }
-      try {
-        recordRoutingOutcome(eventRoot, {
-          tool: toolName,
-          agent: toolInput?.subagent_type ?? toolInput?.agent ?? 'subagent',
-          planTodoId: toolInput?.planTodoId ?? spawnResult.expectedTodoId ?? null,
-          sessionId,
-        });
-      } catch {
-        /* non-blocking */
-      }
+    } 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', {
@@ -93,4 +112,7 @@ async function main() {
   }
 }
 
-main();
+const launchedAsCli = Boolean(process.argv[1] && process.argv[1].endsWith('post-tool-use.js'));
+if (launchedAsCli) {
+  main();
+}

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

@@ -11,7 +11,6 @@ import {
 import {
   checkCodexPatterns,
   checkFullTestSuite,
-  checkSurfaceArea,
   ensureSessionBoot,
   isShellTool,
   isWriteTool,
@@ -21,7 +20,6 @@ import {
   workspaceRoot,
 } from './grok-hook-utils.js';
 import { appendHookActivity } from './grok-hook-activity.js';
-import { runGrokPostprocessorLight } from '../../hooks/pipeline-hook-runtime.mjs';
 
 function finish(root, decision, reason, hint, toolName, extra = {}) {
   const out = { decision, ...extra };
@@ -47,10 +45,10 @@ async function main() {
     ensureSessionBoot(eventRoot, '0xray/grok-pre-tool-use-boot');
 
     const features = loadFeatures(eventRoot);
-    const gateFeatures = loadDelegationGateFeatures(eventRoot);
+    const gateFeatures = loadDelegationGateFeatures(eventRoot, 'grok');
     const ctx = extractFromEvent(event);
     toolName = ctx.toolName;
-    const { paths, content, cmd, toolInput } = ctx;
+    const { content, cmd, toolInput } = ctx;
     const sessionId = resolveSessionId(event);
 
     const gateBlock = evaluatePreToolGate(toolName, toolInput, {
@@ -70,6 +68,18 @@ async function main() {
       );
     }
 
+    // Constitution (11/29/69 + destructive shell) is in evaluatePreToolGate.
+    // Grok extra: Codex 2/7 (TODO/FIXME/STUB, console.log).
+    if (isWriteTool(toolName) && content) {
+      const extraBlock = checkCodexPatterns(content, { terms: [2, 7] });
+      if (extraBlock) finish(eventRoot, 'deny', extraBlock, null, toolName);
+    }
+
+    if (isShellTool(toolName) && cmd) {
+      const testHint = checkFullTestSuite(cmd, features);
+      if (testHint) finish(eventRoot, 'allow', null, testHint, toolName);
+    }
+
     if (gateBlock.reason) {
       finish(
         eventRoot,
@@ -81,33 +91,6 @@ async function main() {
       );
     }
 
-    if (features.no_new_surface && isWriteTool(toolName) && paths.length) {
-      const surfaceBlock = checkSurfaceArea(paths, eventRoot);
-      if (surfaceBlock) finish(eventRoot, 'deny', surfaceBlock, null, toolName);
-    }
-
-    if (isWriteTool(toolName) && content) {
-      const codexBlock = checkCodexPatterns(content);
-      if (codexBlock) finish(eventRoot, 'deny', codexBlock, null, toolName);
-    }
-
-    if (isShellTool(toolName) && cmd) {
-      const destructive =
-        /\brm\s+-rf\s+\/\b|\bmkfs\b|\bdd\s+if=|:()\s*\{\s*:\|&\s*\}\s*;:/i.test(cmd);
-      if (destructive) finish(eventRoot, 'deny', 'Blocked destructive shell command', null, toolName);
-
-      const testHint = checkFullTestSuite(cmd, features);
-      if (testHint) finish(eventRoot, 'allow', null, testHint, toolName);
-    }
-
-    if (features.grok_postprocessor_light === true && isWriteTool(toolName)) {
-      try {
-        runGrokPostprocessorLight(eventRoot, { tool: toolName, paths });
-      } catch {
-        /* non-blocking */
-      }
-    }
-
     finish(eventRoot, 'allow', null, null, toolName);
   } catch (err) {
     appendHookActivity(root, 'grok-pre-tool-use', 'hook-error', 'error', {

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
- * Grok SessionStart / UserPromptSubmit — writes session-boot.json + activity.log.
- * Stdout is ignored by Grok for these events; side effects are the suit contract.
+ * Grok SessionStart / UserPromptSubmit / PreCompact / PostCompact.
+ * Grok ignores stdout here; station heat is session-boot.json + STATION.md.
  */
 
 import {
@@ -26,17 +26,89 @@ function resolveHookEvent(event) {
   if (process.env.GROK_HOOK_EVENT) return process.env.GROK_HOOK_EVENT;
   const flag = process.argv.find((a) => a.startsWith('--hook-event='));
   if (flag) return flag.slice('--hook-event='.length);
+  const named = event.hookEventName || event.hook;
+  if (named === 'PreCompact' || named === 'pre_compact') return 'pre_compact';
+  if (named === 'PostCompact' || named === 'post_compact') return 'post_compact';
   if (
     event.prompt != null ||
     event.userMessage != null ||
     event.user_prompt != null ||
-    event.hook === 'UserPromptSubmit'
+    named === 'UserPromptSubmit' ||
+    named === 'user_prompt_submit'
   ) {
     return 'user_prompt_submit';
   }
   return 'session_start';
 }
 
+function extractIntent(event) {
+  return event.prompt || event.userMessage || event.user_prompt || event.compactContext || null;
+}
+
+async function loadStationProvider(root) {
+  const { loadMemoryRoutingProvider } = await import('../../../memory-routing/index.js');
+  const { readFileSync, existsSync } = await import('node:fs');
+  const { join } = await import('node:path');
+  let routing = { enabled: false, provider: 'null' };
+  const featuresPath = join(root, '.xray', 'features.json');
+  if (existsSync(featuresPath)) {
+    try {
+      routing = JSON.parse(readFileSync(featuresPath, 'utf8')).memory_routing || routing;
+    } catch {
+      /* leftover default */
+    }
+  }
+  return loadMemoryRoutingProvider(routing, root);
+}
+
+async function matchStationSignals(root, intent) {
+  if (!intent) return [];
+  try {
+    const provider = await loadStationProvider(root);
+    if (!provider || provider.id === 'null' || typeof provider.getTaskConfidence !== 'function') {
+      return [];
+    }
+    const conf = provider.getTaskConfidence({
+      id: 'station',
+      description: String(intent),
+      type: 'station',
+    });
+    const names = Array.isArray(conf.matchedSignals) ? conf.matchedSignals : [];
+    const safe = [];
+    for (const signalName of names) {
+      const name = String(signalName || '').trim();
+      if (!name || name.toLowerCase().startsWith('bedrock-')) continue;
+      safe.push(name);
+      if (safe.length >= 4) break;
+    }
+    return safe;
+  } catch {
+    return [];
+  }
+}
+
+const COMPACT_EVENTS = new Set(['pre_compact', 'post_compact']);
+
+async function ingestStationFeedback(root, sessionId, hookEvent, matchedSignals) {
+  if (!COMPACT_EVENTS.has(hookEvent) || !matchedSignals.length) return;
+  try {
+    const provider = await loadStationProvider(root);
+    if (!provider || typeof provider.ingestFeedback !== 'function') return;
+    provider.ingestFeedback({
+      timestamp: new Date().toISOString(),
+      sessionId: sessionId || 'station',
+      taskId: `station-${hookEvent}`,
+      assignedAgent: 'station',
+      memorySignals: matchedSignals,
+      complexity: 0,
+      success: true,
+      durationMs: 0,
+    });
+  } catch {
+    /* working-state file is the session memory; registry ingest is best-effort */
+  }
+}
+
 async function main() {
   const root = workspaceRoot();
   let HOOK_EVENT = 'session_start';
@@ -68,19 +140,29 @@ async function main() {
     const source =
       HOOK_EVENT === 'user_prompt_submit'
         ? '0xray/grok-user-prompt-submit'
-        : '0xray/grok-session-start';
+        : HOOK_EVENT === 'pre_compact' || HOOK_EVENT === 'post_compact'
+          ? '0xray/grok-compact'
+          : '0xray/grok-session-start';
 
+    const intent = extractIntent(event);
+    const matchedSignals = await matchStationSignals(eventRoot, intent);
     const payload = buildSessionBootPayload(eventRoot, source, {
       hookEvent: HOOK_EVENT,
       sessionId: event.sessionId || process.env.GROK_SESSION_ID || null,
+      ...(intent ? { intent } : {}),
+      ...(matchedSignals.length ? { matchedSignals } : {}),
     });
 
     const bootPath = writeSessionBoot(eventRoot, payload) || ensureSessionBoot(eventRoot, source);
+    await ingestStationFeedback(eventRoot, sessionId, HOOK_EVENT, matchedSignals);
 
     appendHookActivity(eventRoot, 'grok-session-start', 'session-boot-written', 'success', {
       bootPath,
       hookEvent: HOOK_EVENT,
       lead_dev_mode: payload.lead_dev_mode,
+      repertoireResume: payload.repertoireResume,
+      stationLine: payload.stationLine,
+      hotSwap: payload.hotSwap || null,
     });
 
     try {

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

@@ -2,15 +2,11 @@
   "hooks": {
     "PreToolUse": [
       {
-        "matcher": ".*",
         "hooks": [
           {
             "type": "command",
-            "command": "node",
-            "args": [
-              "${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/pre-tool-use.js"
-            ],
-            "timeout": 30000
+            "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/pre-tool-use.js\"",
+            "timeout": 30
           }
         ]
       }
@@ -20,11 +16,8 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node",
-            "args": [
-              "${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js"
-            ],
-            "timeout": 15000
+            "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js\"",
+            "timeout": 30
           }
         ]
       }
@@ -34,30 +27,44 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node",
-            "args": [
-              "${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js",
-              "--hook-event=user_prompt_submit"
-            ],
-            "timeout": 15000
+            "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js\" --hook-event=user_prompt_submit",
+            "timeout": 30
           }
         ]
       }
     ],
     "PostToolUse": [
       {
-        "matcher": ".*",
         "hooks": [
           {
             "type": "command",
-            "command": "node",
-            "args": [
-              "${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/post-tool-use.js"
-            ],
-            "timeout": 15000
+            "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/post-tool-use.js\"",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js\" --hook-event=pre_compact",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PostCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "XRAY_AI_PATH=\"${XRAY_AI_PATH:-node_modules/0xray}\" node \"${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/session-start.js\" --hook-event=post_compact",
+            "timeout": 30
           }
         ]
       }
     ]
   }
-}
+}

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

@@ -436,6 +436,24 @@ async function handleSessionStart(input, projectRoot, logDir) {
     /* non-blocking — dist may be absent during dev */
   }
 
+  try {
+    const gate = await import('../hooks/delegation-gate-runtime.mjs');
+    if (typeof gate.writeSuitSessionBoot === 'function') {
+      const compact =
+        input.compact === true ||
+        input.hookEvent === 'pre_compact' ||
+        input.hookEvent === 'post_compact';
+      gate.writeSuitSessionBoot(projectRoot, 'hermes', {
+        source: compact ? '0xray/hermes-compact' : '0xray/hermes-session-start',
+        sessionId,
+        hookEvent: compact ? 'post_compact' : 'session_start',
+        ...(input.intent ? { intent: input.intent } : {}),
+      });
+    }
+  } catch {
+    /* dist may be absent during dev */
+  }
+
   logToActivity(logDir, `session-start: session=${sessionId} source=bridge`);
   return { ok: true, sessionId, planArchive };
 }
@@ -862,7 +880,7 @@ async function handleDelegationGate(command, projectRoot, logDir) {
       await recordHermesSynthesisTurn(projectRoot, sessionId);
     }
 
-    const features = gate.loadDelegationGateFeatures(projectRoot);
+    const features = gate.loadDelegationGateFeatures(projectRoot, host);
     const outcome = gate.evaluatePreToolGate(tool, args, {
       projectRoot,
       sessionId,

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

@@ -4,7 +4,8 @@
  * Used by Grok hooks, Hermes bridge, and verify fixtures.
  */
 import { createRequire } from 'node:module';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -35,17 +36,40 @@ function resolvePackageRoot() {
   return resolve(__dirname, '../../..');
 }
 
+function markedRoots() {
+  const files = [
+    join(homedir(), '.hermes', 'plugins', 'xray-hermes', 'xray-consumer-root.txt'),
+    join(homedir(), '.openclaw', 'xray-consumer-root.txt'),
+  ];
+  const roots = [];
+  for (const file of files) {
+    if (!existsSync(file)) continue;
+    try {
+      const marked = readFileSync(file, 'utf8').trim();
+      if (marked) {
+        roots.push(marked, join(marked, 'node_modules', '0xray'));
+      }
+    } catch {
+      /* ignore unreadable marker */
+    }
+  }
+  return roots;
+}
+
 function loadDelegationGate() {
   const root = resolvePackageRoot();
+  const envRoot = process.env.XRAY_AI_PATH || '';
   const candidates = [
     join(__dirname, '../../nucleus/delegation-gate.js'),
     join(root, 'dist/nucleus/delegation-gate.js'),
+    envRoot ? join(envRoot, 'dist/nucleus/delegation-gate.js') : '',
+    ...markedRoots().map((r) => join(r, 'dist/nucleus/delegation-gate.js')),
     join(process.cwd(), 'node_modules/0xray/dist/nucleus/delegation-gate.js'),
-  ];
+  ].filter(Boolean);
   const found = candidates.find((p) => existsSync(p));
   if (!found) {
     throw new Error(
-      'delegation-gate.js missing — run npm run build in 0xray or npm install 0xray@^3.5.1',
+      'delegation-gate.js missing — run npm run build in 0xray or npm install 0xray',
     );
   }
   return createRequire(import.meta.url)(found);
@@ -53,6 +77,9 @@ function loadDelegationGate() {
 
 const gate = loadDelegationGate();
 
+export const writeSuitSessionBoot = gate.writeSuitSessionBoot;
+export const maybeHeatHostStation = gate.maybeHeatHostStation;
+
 export const {
   loadDelegationGateFeatures,
   normalizeHostToolInput,
@@ -78,4 +105,6 @@ export const {
   buildReceiptFromConsultOutput,
   parseConsultVerdictFromText,
   isSynthesisConsultTodoId,
+  archiveStaleLeadDevPlan,
+  findRecentStalePlanArchive,
 } = gate;

package/dist/integrations/hooks/pipeline-hook-runtime.mjs

@@ -189,7 +189,7 @@ export function runGrokPostprocessorLight(projectRoot, entry = {}) {
     phase: 'post-process-light',
     tool: entry.tool ?? 'unknown',
     paths: entry.paths ?? [],
-    mode: 'grok-pre-tool-light',
+    mode: 'grok-post-tool-light',
   };
   writeFileSync(markerPath, `${JSON.stringify(payload, null, 2)}\n`);
   appendActivity(projectRoot, 'postprocessor-light', 'info', {