0xray 4.0.13 → 4.0.15

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

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * Grok PostToolUse — auto-chain observability + consult receipt gate on Task spawn.
+ * Passive hook: stdout ignored by Grok; side effects only.
+ */
+
+import {
+  extractToolContext,
+  isOrchestrateToolEvent,
+  isSubagentTool,
+  isWriteTool,
+  loadFeatures,
+  readStdinJson,
+  resolveSessionId,
+  workspaceRoot,
+} from './grok-hook-utils.js';
+import { appendHookActivity } from './grok-hook-activity.js';
+import {
+  evaluatePostToolSpawn,
+  isOrchestrateToolEvent as gateIsOrchestrateToolEvent,
+} from '../../hooks/delegation-gate-runtime.mjs';
+import { recordRoutingOutcome, runGrokPostprocessorLight } from '../../hooks/pipeline-hook-runtime.mjs';
+
+function extractToolOutput(event) {
+  return (
+    event.toolOutput ??
+    event.toolResult ??
+    event.result ??
+    event.output ??
+    event.tool_output ??
+    null
+  );
+}
+
+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', {
+      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,
+      });
+    } 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 (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 */
+    }
+  }
+}
+
+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', {
+      error: err.message,
+    });
+    process.exit(0);
+  }
+}
+
+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

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+/**
+ * Grok CLI PreToolUse — ironclad OS gate
+ * Contract: stdin JSON → stdout {"decision":"allow"} | {"decision":"deny","reason":"..."}
+ */
+
+import {
+  evaluatePreToolGate,
+  loadDelegationGateFeatures,
+} from '../../hooks/delegation-gate-runtime.mjs';
+import {
+  checkCodexPatterns,
+  checkFullTestSuite,
+  ensureSessionBoot,
+  isShellTool,
+  isWriteTool,
+  loadFeatures,
+  readStdinJson,
+  resolveSessionId,
+  workspaceRoot,
+} from './grok-hook-utils.js';
+import { appendHookActivity } from './grok-hook-activity.js';
+
+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);
+}
+
+async function main() {
+  const root = workspaceRoot();
+  let toolName = 'unknown';
+
+  try {
+    const event = await readStdinJson();
+    const eventRoot = event.workspaceRoot || event.cwd || root;
+    ensureSessionBoot(eventRoot, '0xray/grok-pre-tool-use-boot');
+
+    const features = loadFeatures(eventRoot);
+    const gateFeatures = loadDelegationGateFeatures(eventRoot, 'grok');
+    const ctx = extractFromEvent(event);
+    toolName = ctx.toolName;
+    const { content, cmd, toolInput } = ctx;
+    const sessionId = resolveSessionId(event);
+
+    const gateBlock = evaluatePreToolGate(toolName, toolInput, {
+      projectRoot: eventRoot,
+      sessionId,
+      features: gateFeatures,
+      host: 'grok',
+    });
+    if (!gateBlock.allow) {
+      finish(
+        eventRoot,
+        'deny',
+        gateBlock.reason,
+        gateBlock.hint,
+        toolName,
+        { gate: gateBlock.gate },
+      );
+    }
+
+    // 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,
+        'allow',
+        gateBlock.reason,
+        gateBlock.hint,
+        toolName,
+        { gate: gateBlock.gate, warn: true },
+      );
+    }
+
+    finish(eventRoot, 'allow', null, null, toolName);
+  } catch (err) {
+    appendHookActivity(root, 'grok-pre-tool-use', 'hook-error', 'error', {
+      tool: toolName,
+      error: err.message,
+    });
+    finish(
+      root,
+      'deny',
+      `PreToolUse hook error — blocked for safety: ${err.message}`,
+      null,
+      toolName,
+      { gate: 'hook-error' },
+    );
+  }
+}
+
+function extractFromEvent(event) {
+  const toolName = event.toolName || process.env.TOOL_NAME || 'unknown';
+  const toolInput = event.toolInput ?? {};
+  const paths = [];
+  let content = '';
+
+  if (toolInput.path) paths.push(String(toolInput.path));
+  if (toolInput.file_path) paths.push(String(toolInput.file_path));
+  if (toolInput.target_notebook) paths.push(String(toolInput.target_notebook));
+  if (Array.isArray(toolInput.paths)) paths.push(...toolInput.paths.map(String));
+
+  if (toolInput.new_string) content += String(toolInput.new_string);
+  if (toolInput.contents) content += String(toolInput.contents);
+  if (toolInput.command) content += String(toolInput.command);
+  if (toolInput.prompt) content += String(toolInput.prompt);
+
+  return {
+    toolName,
+    toolInput,
+    paths,
+    content,
+    cmd: String(toolInput.command || ''),
+  };
+}
+
+main();

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

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+/**
+ * Grok SessionStart / UserPromptSubmit / PreCompact / PostCompact.
+ * Grok ignores stdout here; station heat is session-boot.json + STATION.md.
+ */
+
+import {
+  buildSessionBootPayload,
+  clearPendingDelegationsForSessionChange,
+  ensureSessionBoot,
+  readStdinJson,
+  resolveSessionId,
+  workspaceRoot,
+  writeSessionBoot,
+} from './grok-hook-utils.js';
+import { appendHookActivity } from './grok-hook-activity.js';
+import { recordSynthesisTurnSlice } from '../../hooks/synthesis-hook-runtime.mjs';
+import { archiveStaleLeadDevPlan } from '../../hooks/plan-hook-runtime.mjs';
+import {
+  maybeRunReflectionStub,
+  scheduleAutonomousReportingMarker,
+  runInferenceImprovementLight,
+} from '../../hooks/pipeline-hook-runtime.mjs';
+
+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 ||
+    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';
+  try {
+    const event = await readStdinJson();
+    HOOK_EVENT = resolveHookEvent(event);
+    const eventRoot = event.workspaceRoot || event.cwd || root;
+    const sessionId = resolveSessionId(event);
+    if (HOOK_EVENT === 'user_prompt_submit' && sessionId) {
+      recordSynthesisTurnSlice(eventRoot, sessionId);
+    }
+    if (clearPendingDelegationsForSessionChange(sessionId, eventRoot)) {
+      appendHookActivity(eventRoot, 'grok-session-start', 'stale-pending-cleared', 'info', {
+        sessionId,
+      });
+    }
+
+    try {
+      const archived = archiveStaleLeadDevPlan(eventRoot);
+      if (archived.archived) {
+        appendHookActivity(eventRoot, 'grok-session-start', 'stale-plan-archived', 'info', {
+          archivePath: archived.archivePath,
+          reason: archived.reason,
+        });
+      }
+    } catch {
+      /* non-blocking */
+    }
+    const source =
+      HOOK_EVENT === 'user_prompt_submit'
+        ? '0xray/grok-user-prompt-submit'
+        : 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 {
+      scheduleAutonomousReportingMarker(eventRoot);
+      if (HOOK_EVENT === 'session_start') {
+        maybeRunReflectionStub(eventRoot);
+        runInferenceImprovementLight(eventRoot);
+      }
+    } catch {
+      /* non-blocking pipeline facets */
+    }
+
+    console.log(JSON.stringify(payload));
+    process.exit(0);
+  } catch (err) {
+    appendHookActivity(root, 'grok-session-start', 'session-boot-error', 'error', {
+      error: err.message,
+      hookEvent: HOOK_EVENT,
+    });
+    process.exit(0);
+  }
+}
+
+main();

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

@@ -0,0 +1,35 @@
+{
+  "mcpServers": {
+    "xray-governance": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "governance"],
+      "env": {
+        "XRAY_FORCE_MCP_GOVERNANCE": "true"
+      }
+    },
+    "xray-skills": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "skills"]
+    },
+    "xray-orchestrator": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "orchestrator"]
+    },
+    "xray-enforcer": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "enforcer"]
+    },
+    "xray-researcher": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "researcher"]
+    },
+    "xray-code-review": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "code-review"]
+    },
+    "xray-architect-tools": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "architect-tools"]
+    }
+  }
+}

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

@@ -0,0 +1,70 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "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
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "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\"",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "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=user_prompt_submit",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "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/.mcp.json

@@ -0,0 +1,32 @@
+{
+  "mcpServers": {
+    "xray-governance": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "governance"]
+    },
+    "xray-skills": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "skills"]
+    },
+    "xray-researcher": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "researcher"]
+    },
+    "xray-code-review": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "code-review"]
+    },
+    "xray-architect-tools": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "architect-tools"]
+    },
+    "xray-enforcer": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "enforcer"]
+    },
+    "xray-orchestrator": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "orchestrator"]
+    }
+  }
+}