0xray 4.0.11 → 4.0.13

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

@@ -1,118 +0,0 @@
-#!/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

@@ -1,136 +0,0 @@
-#!/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

@@ -1,189 +0,0 @@
-#!/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

@@ -1,35 +0,0 @@
-{
-  "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

@@ -1,70 +0,0 @@
-{
-  "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

@@ -1,32 +0,0 @@
-{
-  "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"]
-    }
-  }
-}