0xray 3.5.4 → 4.0.0

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

@@ -11,7 +11,6 @@ import {
 import {
   checkCodexPatterns,
   checkFullTestSuite,
-  checkSurfaceArea,
   ensureSessionBoot,
   isShellTool,
   isWriteTool,
@@ -46,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, {
@@ -69,25 +68,29 @@ 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);
-    }
-
+    // Constitution (11/29/69 + destructive shell) is in evaluatePreToolGate.
+    // Grok extra: Codex 2/7 (TODO/FIXME/STUB, console.log).
     if (isWriteTool(toolName) && content) {
-      const codexBlock = checkCodexPatterns(content);
-      if (codexBlock) finish(eventRoot, 'deny', codexBlock, null, toolName);
+      const extraBlock = checkCodexPatterns(content, { terms: [2, 7] });
+      if (extraBlock) finish(eventRoot, 'deny', extraBlock, 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 (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', {

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 {
@@ -15,22 +15,100 @@ import {
 } 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 ||
-    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';
@@ -47,24 +125,56 @@ async function main() {
         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'
-        : '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 {
+      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) {

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/__init__.py

@@ -206,6 +206,10 @@ def _delegation_gate_block(tool_name: str, args: dict, task_id: str, **kwargs):
         },
         timeout=10,
     )
+    if bridge_result.get("error") and bridge_result.get("allow") is not False:
+        err = bridge_result.get("error", "delegation-gate bridge error")
+        _log_to_file("activity.log", f"[delegation-gate] bridge-error tool={tool_name} {err}")
+        return {"action": "block", "message": err}
     if bridge_result.get("allow") is False:
         reason = bridge_result.get("reason", "Delegation gate blocked this tool")
         gate = bridge_result.get("gate", "delegation-gate")
@@ -376,6 +380,8 @@ def _on_post_tool_call(tool_name: str, args: dict, result, task_id: str, **kwarg
                 "args": args or {},
                 "sessionId": session_id,
                 "host": "hermes",
+                "toolOutput": result,
+                "result": result,
             },
             timeout=10,
         )
@@ -452,6 +458,10 @@ def _on_session_start(session_id: str, platform: str, **kwargs):
     _ensure_log_dir()
     _log_to_file("activity.log",
         f"[session-start] session={session_id} platform={platform}")
+    try:
+        _call_bridge({"command": "session-start", "sessionId": session_id}, timeout=10)
+    except Exception as e:
+        logger.debug("[xray] session-start bridge skipped: %s", e)
     logger.info("[xray] Session %s started on %s", session_id, platform)
 
 
@@ -771,7 +781,7 @@ def register(ctx):
 
     # Log session-start since on_session_start may not fire in oneshot mode
     _log_to_file("activity.log",
-        f"[session-start] session={session_id}")
+        "[session-start] session=bootstrap source=plugin-load")
 
     logger.info(
         "[xray] Plugin v2.2 loaded: 6 tools, 2 hooks, "

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

@@ -15,6 +15,7 @@
  *   codex-check   - Check code against codex rules
  *   stats         - Return bridge/framework statistics
  *   hooks         - Manage git hooks (install, uninstall, list, status)
+ *   session-start - Session boot: archive stale lead-dev plans (synthesis exempt)
  *   govern        - Govern inference proposals through weighted voting
  *   apply         - Govern + apply approved inference proposals
  *
@@ -36,13 +37,42 @@ import {
   unlinkSync,
   renameSync,
 } from "fs";
-import { join, dirname, relative } from "path";
-import { fileURLToPath } from "url";
+import { join, dirname, relative, resolve } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 import { homedir } from "os";
-import { findProjectRoot } from "../../../scripts/helpers/find-project-root.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+/** Resolve find-project-root from plugin install, dist layout, or consumer node_modules. */
+function resolveFindProjectRootPath() {
+  const candidates = [];
+  const marker = join(__dirname, "xray-consumer-root.txt");
+  if (existsSync(marker)) {
+    try {
+      const marked = readFileSync(marker, "utf-8").trim();
+      if (marked) {
+        candidates.push(
+          join(marked, "node_modules", "0xray", "scripts", "helpers", "find-project-root.mjs"),
+        );
+      }
+    } catch {
+      /* fall through */
+    }
+  }
+  candidates.push(
+    join(__dirname, "scripts", "helpers", "find-project-root.mjs"),
+    join(__dirname, "..", "..", "..", "scripts", "helpers", "find-project-root.mjs"),
+    join(__dirname, "../../../scripts/helpers/find-project-root.mjs"),
+  );
+  for (const candidate of candidates) {
+    const abs = resolve(candidate);
+    if (existsSync(abs)) return abs;
+  }
+  throw new Error("find-project-root.mjs not found — re-run: npx 0xray hermes install --force");
+}
+
+const { findProjectRoot } = await import(pathToFileURL(resolveFindProjectRootPath()).href);
+
 // ── Framework components (lazy-loaded) ───────────────────────
 let ProcessorManager = null;
 let XrayStateManager = null;
@@ -389,6 +419,45 @@ async function handleHealth(input) {
   };
 }
 
+async function handleSessionStart(input, projectRoot, logDir) {
+  const sessionId = input.sessionId || `bridge-${Date.now()}`;
+  let planArchive = { archived: false };
+
+  try {
+    const { archiveStaleLeadDevPlan } = await import('../hooks/plan-hook-runtime.mjs');
+    planArchive = archiveStaleLeadDevPlan(projectRoot);
+    if (planArchive.archived) {
+      logToActivity(
+        logDir,
+        `session-start: stale-plan-archived path=${planArchive.archivePath ?? 'unknown'}`,
+      );
+    }
+  } catch {
+    /* 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 };
+}
+
 async function handlePreProcess(input, projectRoot, logDir) {
   const { tool, args } = input;
   const startTime = Date.now();
@@ -766,7 +835,7 @@ async function handleApply(input, projectRoot, logDir) {
 // ── Known commands for positional-arg mode ──────────────────
 const KNOWN_COMMANDS = new Set([
   "health", "stats", "pre-process", "post-process", "validate", "codex-check", "hooks", "govern", "apply",
-  "skill-install", "skill-registry", "delegation-gate",
+  "skill-install", "skill-registry", "delegation-gate", "session-start",
 ]);
 
 async function recordHermesSynthesisTurn(projectRoot, sessionId) {
@@ -792,7 +861,12 @@ async function handleDelegationGate(command, projectRoot, logDir) {
       if (!gate.isSubagentTool(tool)) {
         return { allow: true, phase: "post", skipped: true };
       }
-      const result = gate.evaluatePostToolSpawn(tool, args, projectRoot);
+      const toolOutput =
+        command.toolOutput ?? command.result ?? command.output ?? args?.result ?? null;
+      const result = gate.evaluatePostToolSpawn(tool, args, projectRoot, {
+        sessionId,
+        toolOutput,
+      });
       if (result.satisfied.length > 0) {
         logToActivity(
           logDir,
@@ -806,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,
@@ -823,7 +897,15 @@ async function handleDelegationGate(command, projectRoot, logDir) {
 
     return { phase: "pre", ...outcome };
   } catch (error) {
-    return { error: `delegation-gate failed: ${error.message || error}` };
+    const message = `delegation-gate failed: ${error.message || error}`;
+    logToActivity(logDir, `[delegation-gate] error ${message}`);
+    return {
+      allow: false,
+      phase: "pre",
+      gate: "delegation-gate-error",
+      reason: message,
+      error: message,
+    };
   }
 }
 
@@ -910,10 +992,6 @@ async function main() {
   const projectRoot = resolveBridgeProjectRoot();
   const logDir = ensureLogDir(projectRoot);
 
-  // Log session start for test verification
-  const sessionId = `bridge-${Date.now()}`;
-  logToActivity(logDir, `session-start: session=${sessionId} source=bridge`);
-
   // Lazy-load framework on first call
   if (!frameworkReady && !frameworkLoadAttempted) {
     await loadFramework(projectRoot);
@@ -956,6 +1034,9 @@ async function main() {
     case "skill-registry":
       response = await handleSkillRegistry(command, projectRoot, logDir);
       break;
+    case "session-start":
+      response = await handleSessionStart(command, projectRoot, logDir);
+      break;
     case "delegation-gate":
       response = await handleDelegationGate(command, projectRoot, logDir);
       break;

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

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+/**
+ * Lazy-load confer SSOT for Grok session-boot hints.
+ */
+import { createRequire } from 'node:module';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function resolvePackageRoot() {
+  let dir = __dirname;
+  for (let i = 0; i < 10; i++) {
+    const pkg = join(dir, 'package.json');
+    if (existsSync(pkg)) {
+      try {
+        const require = createRequire(join(dir, 'package.json'));
+        if (require('./package.json').name === '0xray') return dir;
+      } catch {
+        /* continue */
+      }
+    }
+    const nm = join(dir, 'node_modules', '0xray', 'package.json');
+    if (existsSync(nm)) return dirname(nm);
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(__dirname, '../../..');
+}
+
+function loadConfer() {
+  const root = resolvePackageRoot();
+  const candidates = [
+    join(__dirname, '../../nucleus/confer.js'),
+    join(root, 'dist/nucleus/confer.js'),
+    join(process.cwd(), 'node_modules/0xray/dist/nucleus/confer.js'),
+  ];
+  const found = candidates.find((p) => existsSync(p));
+  if (!found) return null;
+  return createRequire(import.meta.url)(found);
+}
+
+export function isConferPendingForSession(projectRoot, sessionId = null) {
+  const mod = loadConfer();
+  if (!mod?.isConferPending) return false;
+  return mod.isConferPending(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;