0xray 3.5.5 → 4.0.0

package/dist/nucleus/delegation-gate.js

@@ -1,7 +1,7 @@
 /**
  * Multi-host delegation gate SSOT — pending-delegations + spawn todo enforcement.
  * Grok / Hermes / OpenCode adapters call evaluatePreToolGate via delegation-gate-runtime.
- * Grok-only codex/surface checks remain in pre-tool-use.js after the SSOT gate.
+ * Constitution (11/29/69 + destructive shell) lives here. Grok may still extra-block Codex 2/7.
  */
 import * as fs from 'fs';
 import * as path from 'path';
@@ -13,6 +13,8 @@ import { isSynthesisConsultTodoId, tryRecordSynthesisConsultReceipt, } from './s
 import { resolveSpawnPlan, hasValidSpawnPlanContext } from './spawn-plan-resolution.js';
 import { isUserAsidesEnabled, isUserAsideTodoId, loadActiveAsidePointer, loadActiveUserAside, } from './user-aside.js';
 import { validateAsideWorktreeCwd, } from './aside-worktree.js';
+import { ceremonyForProfile, resolveSuitProfile, spawnPlanModeForProfile, writeSuitSessionBoot, maybeHeatHostStation, } from './suit-temperament.js';
+export { writeSuitSessionBoot, maybeHeatHostStation };
 export { extractSpawnCwd, validateAsideWorktreeCwd, provisionGitWorktree } from './aside-worktree.js';
 function denyAsideWorktreeCwd(cwdCheck) {
     const base = {
@@ -30,7 +32,7 @@ function asideWorktreeCwdDenyIfNeeded(activeAside, toolInput, projectRoot) {
         return denyAsideWorktreeCwd(cwdCheck);
     return undefined;
 }
-export { validateSpawnMatchesTodo, updatePlanTodoStatus, savePersistedLeadDevPlan, } from './lead-dev-plan-persistence.js';
+export { validateSpawnMatchesTodo, updatePlanTodoStatus, savePersistedLeadDevPlan, archiveStaleLeadDevPlan, findRecentStalePlanArchive, } from './lead-dev-plan-persistence.js';
 export { buildReceiptFromConsultOutput, hasValidSynthesisConsultReceipt, isSynthesisConsultTodoId, loadSynthesisConsultReceipt, parseConsultVerdictFromText, tryRecordSynthesisConsultReceipt, writeSynthesisConsultReceipt, } from './synthesis-consult-receipt.js';
 export const updatePlanTodoStatusInPlace = updatePlanTodoStatus;
 const READ_TOOLS = new Set([
@@ -69,21 +71,34 @@ const SYNTHESIS_ALLOWED_CONSULT_TOOLS = new Set([
 ]);
 const HERMES_WRITE_TOOLS = new Set(['write_file', 'patch', 'write', 'edit']);
 const OPENCODE_WRITE_TOOLS = new Set(['write', 'edit', 'multiedit']);
-export function loadDelegationGateFeatures(projectRoot = process.cwd()) {
+export function loadDelegationGateFeatures(projectRoot = process.cwd(), host = 'generic') {
+    const fallback = (profile) => ({
+        lead_dev_mode: true,
+        auto_chain_delegations: true,
+        spawn_plan_mode: spawnPlanModeForProfile(profile),
+        ceremony: ceremonyForProfile(profile),
+        suit_profile: profile,
+        no_new_surface: true,
+    });
     const featuresPath = path.join(projectRoot, '.xray', 'features.json');
     if (!fs.existsSync(featuresPath)) {
-        return { lead_dev_mode: true, auto_chain_delegations: true };
+        return fallback(resolveSuitProfile(undefined, host));
     }
     try {
         const data = JSON.parse(fs.readFileSync(featuresPath, 'utf8'));
         const orch = data.multi_agent_orchestration ?? {};
+        const profile = resolveSuitProfile(data.suit_temperament, host);
         return {
             lead_dev_mode: orch.enabled !== false && orch.lead_dev_mode !== false,
             auto_chain_delegations: orch.auto_chain_delegations !== false,
+            spawn_plan_mode: spawnPlanModeForProfile(profile),
+            ceremony: ceremonyForProfile(profile),
+            suit_profile: profile,
+            no_new_surface: profile === 'strict' ? true : orch.no_new_surface !== false,
         };
     }
     catch {
-        return { lead_dev_mode: true, auto_chain_delegations: true };
+        return fallback(resolveSuitProfile(undefined, host));
     }
 }
 export function normalizeHostToolInput(toolInput) {
@@ -197,40 +212,53 @@ function denyFromPending(primary, pendingCount) {
         delegationId: primary.id,
     };
 }
+function spawnPlanSoftAllow(gate, reason) {
+    return { allow: true, reason, gate };
+}
 /** Spawn plan missing — applies before auto_chain opt-out for subagent tools. */
 export function evaluateSpawnPlanGate(toolName, toolInput, ctx) {
     if (!ctx.features.lead_dev_mode || !isSubagentTool(toolName)) {
         return { allow: true };
     }
+    const spawnMode = ctx.features.spawn_plan_mode ?? 'deny';
+    if (spawnMode === 'off') {
+        return { allow: true };
+    }
     const activeAside = isUserAsidesEnabled(ctx.projectRoot)
         ? loadActiveUserAside(ctx.projectRoot, ctx.sessionId)
         : null;
     const plan = loadPersistedLeadDevPlan(ctx.projectRoot);
     if (!activeAside && plan && isLeadDevPlanStale(plan, ctx.projectRoot)) {
-        return {
-            allow: false,
+        const stale = {
             reason: 'Lead-dev plan is stale (unstarted todos exceeded TTL) — ' +
                 're-run xray-orchestrator analyze-complexity to refresh the plan',
             gate: 'spawn-plan-stale',
             hint: { tool: 'analyze-complexity', mcp: 'xray-orchestrator' },
         };
+        if (spawnMode === 'warn')
+            return spawnPlanSoftAllow(stale.gate, stale.reason);
+        return { allow: false, ...stale };
     }
     if (!hasValidSpawnPlanContext(ctx.projectRoot, ctx.sessionId)) {
         if (findRecentStalePlanArchive(ctx.projectRoot)) {
-            return {
-                allow: false,
+            const archived = {
                 reason: 'Lead-dev plan was stale and archived — ' +
                     're-run xray-orchestrator analyze-complexity to refresh the plan',
                 gate: 'spawn-plan-stale',
                 hint: { tool: 'analyze-complexity', mcp: 'xray-orchestrator' },
             };
+            if (spawnMode === 'warn')
+                return spawnPlanSoftAllow(archived.gate, archived.reason);
+            return { allow: false, ...archived };
         }
-        return {
-            allow: false,
+        const missing = {
             reason: 'Codex 59/67: call xray-orchestrator analyze-complexity first — ' +
                 'writes .xray/state/lead-dev-plan.json required before spawn_subagent',
             gate: 'spawn-plan-missing',
         };
+        if (spawnMode === 'warn')
+            return spawnPlanSoftAllow(missing.gate, missing.reason);
+        return { allow: false, ...missing };
     }
     if (ctx.features.auto_chain_delegations === false) {
         const cwdDeny = asideWorktreeCwdDenyIfNeeded(activeAside, toolInput, ctx.projectRoot);
@@ -246,13 +274,16 @@ export function evaluateSpawnPlanGate(toolName, toolInput, ctx) {
     const expectedTodo = pending[0]?.planTodoId && resolved.plan
         ? allPlanTodos(resolved.plan).find((t) => t.id === pending[0].planTodoId) ?? null
         : null;
+    const cwdDeny = asideWorktreeCwdDenyIfNeeded(activeAside, toolInput, ctx.projectRoot);
+    if (cwdDeny)
+        return cwdDeny;
     const validation = validateSpawnMatchesTodo(normalized, ctx.projectRoot, expectedTodo, ctx.sessionId);
     if (!validation.valid) {
+        if (spawnMode === 'warn') {
+            return spawnPlanSoftAllow(validation.gate ?? 'spawn-todo-persistence', validation.reason ?? 'Spawn did not match lead-dev plan todo (frontier: warn, not deny)');
+        }
         return denyFromSpawnValidation(validation);
     }
-    const cwdDeny = asideWorktreeCwdDenyIfNeeded(activeAside, toolInput, ctx.projectRoot);
-    if (cwdDeny)
-        return cwdDeny;
     return { allow: true };
 }
 /** Block writes / spawns / shell while synthesis checkpoint is due. */
@@ -346,8 +377,110 @@ export function evaluatePendingDelegationGate(toolName, toolInput, ctx) {
  * Full pre-tool evaluation — synthesis gate first, slice recording, then
  * pending gate, then spawn todo gate for subagent tools.
  */
+const CONSTITUTION_ANY = /:\s*any\b|as\s+any\b/;
+const CONSTITUTION_TS_IGNORE = /@ts-ignore|@ts-expect-error/;
+const CONSTITUTION_EVAL = /\beval\s*\(/;
+const CONSTITUTION_DESTRUCTIVE = /\brm\s+-rf\s+\/(?:\s|$)|\bmkfs\b|\bdd\s+if=|:()\s*\{\s*:\|&\s*\}\s*;:/i;
+const SURFACE_DENY = [
+    /(?:^|\/)src\/mcps\/[^/]+\.server\.(ts|js)$/i,
+    /(?:^|\/)src\/skills\/[^/]+\/SKILL\.md$/i,
+    /(?:^|\/)src\/mcps\/orchestrator\/handlers\/[^/]+-handler\.(ts|js)$/i,
+    /(?:^|\/)src\/nucleus\/autonomy-kernel\.(ts|js)$/i,
+    /(?:^|\/)src\/mcps\/[^/]+\/handlers\/autonomy-handler\.(ts|js)$/i,
+];
+function collectWriteContent(toolInput) {
+    return [
+        toolInput.new_string,
+        toolInput.contents,
+        toolInput.content,
+        toolInput.command,
+        toolInput.prompt,
+    ]
+        .filter((v) => v != null)
+        .map(String)
+        .join('\n');
+}
+function collectWritePaths(toolInput) {
+    const paths = [];
+    for (const key of ['path', 'file_path', 'filePath', 'target_notebook']) {
+        const v = toolInput[key];
+        if (typeof v === 'string' && v)
+            paths.push(v);
+    }
+    const extra = toolInput.paths;
+    if (Array.isArray(extra)) {
+        for (const p of extra) {
+            if (typeof p === 'string' && p)
+                paths.push(p);
+        }
+    }
+    return paths;
+}
+/** Codex 11 / 29 / 69 + destructive shell — always on, all hosts that call this SSOT. */
+export function evaluateConstitutionGate(toolName, toolInput, ctx) {
+    const content = collectWriteContent(toolInput);
+    const paths = collectWritePaths(toolInput);
+    const writing = isWriteTool(toolName, ctx.host ?? 'generic');
+    if (writing && ctx.features.no_new_surface !== false) {
+        for (const p of paths) {
+            const normalized = p.replace(/\\/g, '/');
+            const abs = path.isAbsolute(p) ? p : path.join(ctx.projectRoot, p);
+            if (fs.existsSync(abs))
+                continue;
+            if (SURFACE_DENY.some((re) => re.test(normalized))) {
+                return {
+                    allow: false,
+                    reason: 'Codex 69: new MCP/skill/handler surface — rewire existing',
+                    gate: 'no-new-surface',
+                };
+            }
+        }
+    }
+    if (writing && content) {
+        if (CONSTITUTION_ANY.test(content) || CONSTITUTION_TS_IGNORE.test(content)) {
+            return {
+                allow: false,
+                reason: 'Codex 11 Type Safety: no `any` / @ts-ignore / @ts-expect-error',
+                gate: 'codex-11',
+            };
+        }
+        if (CONSTITUTION_EVAL.test(content)) {
+            return {
+                allow: false,
+                reason: 'Codex 29 Security: eval() prohibited',
+                gate: 'codex-29',
+            };
+        }
+    }
+    if (isShellTool(toolName) && CONSTITUTION_DESTRUCTIVE.test(String(toolInput.command ?? ''))) {
+        return {
+            allow: false,
+            reason: 'Blocked destructive shell command',
+            gate: 'destructive-shell',
+        };
+    }
+    return { allow: true };
+}
 export function evaluatePreToolGate(toolName, toolInput, ctx) {
-    const synthesisBlock = evaluateSynthesisGate(toolName, toolInput, ctx);
+    if (ctx.host === 'openclaw') {
+        try {
+            maybeHeatHostStation(ctx.projectRoot, 'openclaw', {
+                source: '0xray/openclaw-pre-tool',
+                sessionId: ctx.sessionId || 'openclaw',
+                hookEvent: ctx.hookEvent || 'session_start',
+            });
+        }
+        catch {
+            /* station heat is best-effort — constitution still runs */
+        }
+    }
+    const constitution = evaluateConstitutionGate(toolName, toolInput, ctx);
+    if (!constitution.allow)
+        return constitution;
+    const lite = ctx.features.ceremony === 'lite';
+    const synthesisBlock = lite
+        ? { allow: true }
+        : evaluateSynthesisGate(toolName, toolInput, ctx);
     if (!synthesisBlock.allow)
         return synthesisBlock;
     if (!isSynthesisCheckpointDue(ctx.projectRoot, ctx.sessionId)) {
@@ -356,7 +489,9 @@ export function evaluatePreToolGate(toolName, toolInput, ctx) {
             sessionId: ctx.sessionId,
         });
     }
-    const pendingBlock = evaluatePendingDelegationGate(toolName, toolInput, ctx);
+    const pendingBlock = lite
+        ? { allow: true }
+        : evaluatePendingDelegationGate(toolName, toolInput, ctx);
     if (!pendingBlock.allow)
         return pendingBlock;
     const spawnBlock = evaluateSpawnPlanGate(toolName, toolInput, ctx);

package/dist/nucleus/suit-temperament.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 0xRay 4.0 suit temperament — how loudly the Autonomous Engine insists.
+ *
+ * v2 three-subsystem OS stays: Inference · External Governance · Autonomous Engine.
+ * This module does not replace thinDispatch or Codex. It only scales *ceremony*
+ * (spawn-plan deny, synthesis, confer) by host strength.
+ *
+ * Frontier (Grok 4.6 / Grok Build): engine available, spawn warns if no plan.
+ * Guided (OpenCode / Hermes / OpenClaw, including free models): full v2 ceremony.
+ * Missing config → guided (existing consumers unchanged).
+ */
+export type SuitHost = 'grok' | 'hermes' | 'opencode' | 'openclaw' | 'generic';
+export type SuitProfile = 'frontier' | 'guided' | 'strict';
+export type SuitProfileOrAuto = 'auto' | SuitProfile;
+export type CeremonyLevel = 'full' | 'lite';
+export type SpawnPlanMode = 'deny' | 'warn' | 'off';
+export interface SuitTemperamentConfig {
+    /** auto = pick from host_defaults */
+    profile?: SuitProfileOrAuto;
+    host_defaults?: Partial<Record<SuitHost, SuitProfile>>;
+}
+export declare const DEFAULT_HOST_PROFILES: Record<SuitHost, SuitProfile>;
+export declare function loadSuitTemperamentRaw(projectRoot: string): SuitTemperamentConfig | undefined;
+export declare function resolveSuitProfile(raw: SuitTemperamentConfig | undefined, host: SuitHost): SuitProfile;
+/**
+ * Host-aware when known. Kernel/MCP (`generic`) uses last session-boot profile.
+ * A Hermes/OpenCode host ignores a leftover Grok boot (and vice versa).
+ */
+export declare function resolveRuntimeSuitProfile(projectRoot: string, host?: SuitHost): SuitProfile;
+/**
+ * Write station heat when this host/session has no live card yet.
+ * OpenClaw has no SessionStart — PreToolUse is the session boundary.
+ * Install/init cards without a session id are not a live session.
+ */
+export declare function maybeHeatHostStation(projectRoot: string, host: SuitHost, extra?: Record<string, unknown>): string | null;
+/** Merge temperament fields into session-boot.json for the host that just started. */
+export declare function writeSuitSessionBoot(projectRoot: string, host: SuitHost, extra?: Record<string, unknown>): string;
+export declare function ceremonyForProfile(profile: SuitProfile): CeremonyLevel;
+export declare function spawnPlanModeForProfile(profile: SuitProfile): SpawnPlanMode;
+export declare function conferDefaultForProfile(profile: SuitProfile): boolean;

package/dist/nucleus/suit-temperament.js

@@ -0,0 +1,157 @@
+/**
+ * 0xRay 4.0 suit temperament — how loudly the Autonomous Engine insists.
+ *
+ * v2 three-subsystem OS stays: Inference · External Governance · Autonomous Engine.
+ * This module does not replace thinDispatch or Codex. It only scales *ceremony*
+ * (spawn-plan deny, synthesis, confer) by host strength.
+ *
+ * Frontier (Grok 4.6 / Grok Build): engine available, spawn warns if no plan.
+ * Guided (OpenCode / Hermes / OpenClaw, including free models): full v2 ceremony.
+ * Missing config → guided (existing consumers unchanged).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { createRequire } from 'node:module';
+const requireCjs = createRequire(import.meta.url);
+const stationHeat = requireCjs('../integrations/hooks/station-hook-runtime.cjs');
+export const DEFAULT_HOST_PROFILES = {
+    grok: 'frontier',
+    hermes: 'guided',
+    opencode: 'guided',
+    openclaw: 'guided',
+    generic: 'guided',
+};
+function isSuitProfile(value) {
+    return value === 'frontier' || value === 'guided' || value === 'strict';
+}
+export function loadSuitTemperamentRaw(projectRoot) {
+    const featuresPath = path.join(projectRoot, '.xray', 'features.json');
+    if (!fs.existsSync(featuresPath))
+        return undefined;
+    try {
+        const data = JSON.parse(fs.readFileSync(featuresPath, 'utf8'));
+        return data.suit_temperament;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isSuitHost(value) {
+    return (value === 'grok' ||
+        value === 'hermes' ||
+        value === 'opencode' ||
+        value === 'openclaw' ||
+        value === 'generic');
+}
+function readSessionBoot(projectRoot) {
+    try {
+        const bootPath = path.join(projectRoot, '.xray', 'state', 'session-boot.json');
+        if (!fs.existsSync(bootPath))
+            return null;
+        const boot = JSON.parse(fs.readFileSync(bootPath, 'utf8'));
+        return {
+            host: isSuitHost(boot.host) ? boot.host : null,
+            suit_profile: isSuitProfile(boot.suit_profile) ? boot.suit_profile : null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveSuitProfile(raw, host) {
+    // No key / empty object without profile → guided (existing consumers).
+    if (!raw || !raw.profile)
+        return 'guided';
+    if (raw.profile !== 'auto') {
+        return raw.profile;
+    }
+    const defaults = {
+        ...DEFAULT_HOST_PROFILES,
+        ...(raw.host_defaults ?? {}),
+    };
+    return defaults[host] ?? 'guided';
+}
+/**
+ * Host-aware when known. Kernel/MCP (`generic`) uses last session-boot profile.
+ * A Hermes/OpenCode host ignores a leftover Grok boot (and vice versa).
+ */
+export function resolveRuntimeSuitProfile(projectRoot, host = 'generic') {
+    const raw = loadSuitTemperamentRaw(projectRoot);
+    const boot = readSessionBoot(projectRoot);
+    if (raw?.profile === 'auto' && boot?.suit_profile) {
+        if (host === 'generic' || boot.host == null || boot.host === host) {
+            return boot.suit_profile;
+        }
+    }
+    return resolveSuitProfile(raw, host);
+}
+function concreteSessionId(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+/**
+ * Write station heat when this host/session has no live card yet.
+ * OpenClaw has no SessionStart — PreToolUse is the session boundary.
+ * Install/init cards without a session id are not a live session.
+ */
+export function maybeHeatHostStation(projectRoot, host, extra = {}) {
+    const bootPath = path.join(projectRoot, '.xray', 'state', 'session-boot.json');
+    const cardPath = path.join(projectRoot, '.xray', 'state', 'STATION.md');
+    let existing = {};
+    if (fs.existsSync(bootPath)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(bootPath, 'utf8'));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    const sessionId = concreteSessionId(extra.sessionId);
+    const existingSessionId = concreteSessionId(existing.sessionId);
+    const sameHost = existing.host === host;
+    const sameSession = existingSessionId !== null && sessionId !== null && existingSessionId === sessionId;
+    if (sameHost && sameSession && fs.existsSync(cardPath)) {
+        return bootPath;
+    }
+    return writeSuitSessionBoot(projectRoot, host, extra);
+}
+/** Merge temperament fields into session-boot.json for the host that just started. */
+export function writeSuitSessionBoot(projectRoot, host, extra = {}) {
+    const profile = resolveSuitProfile(loadSuitTemperamentRaw(projectRoot), host);
+    const stateDir = path.join(projectRoot, '.xray', 'state');
+    fs.mkdirSync(stateDir, { recursive: true });
+    const bootPath = path.join(stateDir, 'session-boot.json');
+    let existing = {};
+    if (fs.existsSync(bootPath)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(bootPath, 'utf8'));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    const heat = stationHeat.applyStationHeat(projectRoot, host, extra, existing);
+    const payload = {
+        ...existing,
+        ...extra,
+        ...heat,
+        host,
+        suit_profile: profile,
+        ceremony: ceremonyForProfile(profile),
+        spawn_plan_mode: spawnPlanModeForProfile(profile),
+        timestamp: new Date().toISOString(),
+    };
+    fs.writeFileSync(bootPath, JSON.stringify(payload, null, 2));
+    stationHeat.writeStationMarkdown(projectRoot, payload);
+    return bootPath;
+}
+export function ceremonyForProfile(profile) {
+    return profile === 'frontier' ? 'lite' : 'full';
+}
+export function spawnPlanModeForProfile(profile) {
+    if (profile === 'frontier')
+        return 'warn';
+    return 'deny';
+}
+export function conferDefaultForProfile(profile) {
+    return profile !== 'frontier';
+}

package/dist/nucleus/user-aside.js

@@ -119,7 +119,7 @@ export function buildUserAsidePlan(asideId, title, description, taskInputs = [],
         return null;
     const safeId = assertSafeAsideId(asideId);
     const taskTypes = taskInputs.map((t) => t.type ?? 'implement');
-    const basePlan = buildLeadDevPlan(description, taskTypes, taskInputs, mcpOverallComplexity);
+    const basePlan = buildLeadDevPlan(description, taskTypes, taskInputs, mcpOverallComplexity, projectRoot);
     if (!basePlan)
         return null;
     return {

package/dist/plugin/xray-codex-injection.js

@@ -7,7 +7,7 @@ import { getOrCreateLogger } from "./plugin-logger.js";
 import { resolveStateDir, importSystemPromptGenerator, loadXrayComponents, getProcessorManager, getXrayStateManager, getFeaturesConfigLoader, getDetectTaskType, getSystemPromptGenerator, } from "./plugin-modules.js";
 import { getFrameworkIdentity, classifyTaskType, isWriteEditOperation, isPublishOperation, resolveAgentName, registerAllProcessors, registerAfterPostProcessors, logPreProcessorResults, logPostProcessorResults, logTestAutoCreationResult, spawnPromise, } from "./plugin-helpers.js";
 import { runEnforcerQualityGate } from "./plugin-quality-gate.js";
-import { evaluatePostToolSpawn, evaluatePreToolGate, isSubagentTool, loadDelegationGateFeatures, } from "../nucleus/delegation-gate.js";
+import { evaluatePostToolSpawn, evaluatePreToolGate, isSubagentTool, loadDelegationGateFeatures, writeSuitSessionBoot, } from "../nucleus/delegation-gate.js";
 import { readFileSync } from "fs";
 import { join } from "path";
 // Re-export all public API for test compatibility
@@ -23,6 +23,15 @@ let _lastTuneToolCallCount = 0;
 export default async function xrayCodexPlugin(input) {
     const { directory: inputDirectory } = input;
     const directory = inputDirectory || process.cwd();
+    try {
+        writeSuitSessionBoot(directory, "opencode", {
+            source: "0xray/opencode-plugin",
+            hookEvent: process.env.XRAY_HOOK_EVENT || "session_start",
+        });
+    }
+    catch {
+        /* session-boot is best-effort */
+    }
     return {
         "experimental.chat.system.transform": async (_input, output) => {
             try {
@@ -40,7 +49,9 @@ export default async function xrayCodexPlugin(input) {
                     });
                 }
                 if (output.system && Array.isArray(output.system)) {
-                    output.system = [leanPrompt];
+                    const cardPath = path.join(directory, ".xray", "state", "STATION.md");
+                    const card = fs.existsSync(cardPath) ? fs.readFileSync(cardPath, "utf8").trim() : "";
+                    output.system = card ? [leanPrompt, card] : [leanPrompt];
                 }
             }
             catch (error) {
@@ -84,7 +95,7 @@ export default async function xrayCodexPlugin(input) {
                 throw new Error(`ENFORCER BLOCKED: ${qualityGateResult.violations.join("; ")}`);
             }
             logger.log(`✅ Quality gate passed for ${tool}`);
-            const features = loadDelegationGateFeatures(directory);
+            const features = loadDelegationGateFeatures(directory, "opencode");
             let sessionId = process.env.GROK_SESSION_ID ?? null;
             try {
                 const boot = JSON.parse(readFileSync(join(directory, ".xray", "state", "session-boot.json"), "utf8"));

package/dist/postprocessor/triggers/GitHookTrigger.js

@@ -397,10 +397,16 @@ fi
       (async () => {
         try {
           // Use dynamic import that works in both dev and consumer
-          const basePath = process.env.XRAY_BASE_PATH || '.';
-          const distPath = process.env.XRAY_DIST_PATH || 'dist';
-          // First archive logs (compress and rotate) before cleanup
-          const { archiveLogFiles } = await import(basePath + '/' + distPath + '/postprocessor/triggers/GitHookTrigger.js');
+          const { pathToFileURL } = await import('url');
+          const { existsSync } = await import('fs');
+          const { join } = await import('path');
+          const candidates = [
+            join(process.cwd(), 'node_modules/0xray/dist/postprocessor/triggers/GitHookTrigger.js'),
+            join(process.cwd(), 'dist/postprocessor/triggers/GitHookTrigger.js'),
+          ];
+          const triggerPath = candidates.find((p) => existsSync(p));
+          if (!triggerPath) return;
+          const { archiveLogFiles } = await import(pathToFileURL(triggerPath).href);
           const archiveResult = await archiveLogFiles({
             archiveDirectory: 'logs/framework',
             maxFileSizeMB: 10,  // Archive if > 10MB
@@ -415,7 +421,7 @@ fi
           }
 
           // Then cleanup old files
-          const { cleanupLogFiles } = await import(basePath + '/' + distPath + '/postprocessor/triggers/GitHookTrigger.js');
+          const { cleanupLogFiles } = await import(pathToFileURL(triggerPath).href);
           const result = await cleanupLogFiles({
             maxAgeHours: 24,
             excludePatterns: [

package/opencode.json

@@ -16,6 +16,94 @@
     },
     "global-git": {
       "enabled": false
+    },
+    "xray-governance": {
+      "type": "local",
+      "command": [
+        "npx",
+        "-y",
+        "0xray",
+        "mcp",
+        "governance"
+      ],
+      "enabled": true,
+      "environment": {
+        "XRAY_FORCE_MCP_GOVERNANCE": "true"
+      }
+    },
+    "xray-skills": {
+      "type": "local",
+      "command": [
+        "npx",
+        "-y",
+        "0xray",
+        "mcp",
+        "skills"
+      ],
+      "enabled": true
+    },
+    "xray-orchestrator": {
+      "type": "local",
+      "command": [
+        "npx",
+        "-y",
+        "0xray",
+        "mcp",
+        "orchestrator"
+      ],
+      "enabled": true
+    },
+    "xray-enforcer": {
+      "type": "local",
+      "command": [
+        "npx",
+        "-y",
+        "0xray",
+        "mcp",
+        "enforcer"
+      ],
+      "enabled": true
+    },
+    "xray-researcher": {
+      "type": "local",
+      "command": [
+        "npx",
+        "-y",
+        "0xray",
+        "mcp",
+        "researcher"
+      ],
+      "enabled": true
+    },
+    "xray-code-review": {
+      "type": "local",
+      "command": [
+        "npx",
+        "-y",
+        "0xray",
+        "mcp",
+        "code-review"
+      ],
+      "enabled": true
+    },
+    "xray-architect-tools": {
+      "type": "local",
+      "command": [
+        "npx",
+        "-y",
+        "0xray",
+        "mcp",
+        "architect-tools"
+      ],
+      "enabled": true
+    },
+    "repertoire": {
+      "type": "local",
+      "command": [
+        "node",
+        "/tmp/xray-v4-validate/node_modules/@0xray/repertoire/dist/mcp/server.js"
+      ],
+      "enabled": true
     }
   },
   "agent": {