0xray 3.5.5 → 4.0.1

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

@@ -24,8 +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'));
-const { XRAY_MCP_SERVERS } = requireCjs(path.join(packageRoot, 'scripts/node/bridge-mcp-wiring.cjs'));
+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' });
@@ -90,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' });
@@ -106,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,9 +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,
@@ -131,9 +138,20 @@ export function resolveSiblingWorkspaceRoots(root = workspaceRoot()) {
   }
 }
 
+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 ?? {};
@@ -142,6 +160,7 @@ 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 {
@@ -150,6 +169,7 @@ export function loadFeatures(root = workspaceRoot()) {
       no_new_surface: true,
       per_suite_triage: true,
       auto_chain_delegations: true,
+      grok_postprocessor_light: false,
       sibling_repos: [],
     };
   }
@@ -188,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;
   }
@@ -259,16 +281,27 @@ export function buildSessionBootPayload(root, source = '0xray/grok-session-start
     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,
+    ...heat,
     ...(siblingRoots.length > 0 ? { siblingWorkspaceRoots: siblingRoots } : {}),
     ...(conferPending ? { conferPending: true, conferTrigger: 'analyze-complexity at synthesis checkpoint' } : {}),
     ...(userAsideBoot ?? {}),
@@ -276,6 +309,7 @@ export function buildSessionBootPayload(root, source = '0xray/grok-session-start
     timestamp: new Date().toISOString(),
     source,
     ...extra,
+    ...heat,
   };
 }
 
@@ -284,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,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 {