0xray 3.5.5 → 4.0.0

package/dist/integrations/openclaw/hooks/pre-tool-gate-runtime.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * OpenClaw host PreToolUse runtime — stdin JSON → stdout { action: block|allow }.
+ * Installed to ~/.openclaw/hooks/xray-pre-tool.mjs by `0xray openclaw install`.
+ */
+import { createRequire } from 'node:module';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { stdin } from 'node:process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+function resolveGate() {
+  const envRoot = process.env.XRAY_AI_PATH || process.env.XRAY_ROOT || '';
+  const candidates = [
+    envRoot ? join(envRoot, 'dist/nucleus/delegation-gate.js') : '',
+    join(__dirname, '../../../nucleus/delegation-gate.js'),
+    join(__dirname, '../../../../dist/nucleus/delegation-gate.js'),
+    join(process.cwd(), 'node_modules/0xray/dist/nucleus/delegation-gate.js'),
+    join(process.cwd(), 'dist/nucleus/delegation-gate.js'),
+  ].filter(Boolean);
+  const found = candidates.find((p) => existsSync(p));
+  if (!found) {
+    throw new Error('delegation-gate.js missing — build 0xray or npm install 0xray');
+  }
+  return require(found);
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stdin.setEncoding('utf8');
+    stdin.on('data', (c) => chunks.push(c));
+    stdin.on('end', () => {
+      const raw = chunks.join('').trim();
+      if (!raw) {
+        resolve({});
+        return;
+      }
+      try {
+        resolve(JSON.parse(raw));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    stdin.on('error', reject);
+  });
+}
+
+function decide(event, gate) {
+  const projectRoot =
+    event.cwd || event.workspaceRoot || event.projectRoot || process.cwd();
+  const sessionId = event.sessionId || event.session_id || 'openclaw';
+  const toolName = event.tool || event.toolName || event.name || 'unknown';
+  const args = event.args || event.toolInput || event.input || {};
+  const features = gate.loadDelegationGateFeatures(projectRoot, 'openclaw');
+  const outcome = gate.evaluatePreToolGate(toolName, args, {
+    projectRoot,
+    sessionId,
+    features,
+    host: 'openclaw',
+  });
+  if (!outcome.allow) {
+    return {
+      action: 'block',
+      allow: false,
+      reason: outcome.reason,
+      gate: outcome.gate,
+    };
+  }
+  return {
+    action: 'allow',
+    allow: true,
+    reason: outcome.reason,
+    gate: outcome.gate,
+    warn: Boolean(outcome.reason),
+  };
+}
+
+async function main() {
+  try {
+    const event = await readStdin();
+    const gate = resolveGate();
+    const decision = decide(event, gate);
+    console.log(JSON.stringify(decision));
+    process.exit(decision.action === 'block' ? 2 : 0);
+  } catch (err) {
+    console.log(
+      JSON.stringify({
+        action: 'block',
+        allow: false,
+        gate: 'openclaw-pre-tool-error',
+        reason: err instanceof Error ? err.message : String(err),
+      }),
+    );
+    process.exit(2);
+  }
+}
+
+main();

package/dist/integrations/openclaw/index.js

@@ -11,7 +11,9 @@ import { OpenClawClient } from './client.js';
 import { XrayAPIServer } from './api-server.js';
 import { initializeGovernanceIntegration } from '../governance/index.js';
 import { featuresConfigLoader } from '../../core/features-config.js';
+import { writeSuitSessionBoot } from '../../nucleus/suit-temperament.js';
 import { OpenClawHooksManager } from './hooks/xray-hooks.js';
+import { evaluateOpenClawHostPreTool } from './pre-tool-gate.js';
 import { mcpClientManager } from '../../mcps/mcp-client.js';
 /**
  * Main OpenClaw Integration class
@@ -52,6 +54,12 @@ export class OpenClawIntegration extends BaseIntegration {
             return;
         }
         await this.log('info', 'Initializing...');
+        try {
+            writeSuitSessionBoot(process.cwd(), 'openclaw', { source: '0xray/openclaw-init' });
+        }
+        catch {
+            await this.log('warning', 'Failed to write suit session-boot');
+        }
         // Initialize API server if enabled
         if (config.apiServer?.enabled) {
             await this.log('info', 'Starting API server...');
@@ -123,6 +131,14 @@ export class OpenClawIntegration extends BaseIntegration {
         this.mcpToolBeforeUnsubscribe = await mcpClientManager.onToolEvent('tool.before', async (event) => {
             const toolEvent = event;
             try {
+                const gate = evaluateOpenClawHostPreTool(toolEvent.toolName, (toolEvent.args ?? {}), {
+                    projectRoot: process.cwd(),
+                    sessionId: String(toolEvent.sessionId ?? 'openclaw'),
+                });
+                if (!gate.allow) {
+                    await this.log('error', `OpenClaw PreToolUse blocked ${toolEvent.toolName}: ${gate.reason}`);
+                    throw new Error(`xray-openclaw-pre-tool:${gate.gate}:${gate.reason}`);
+                }
                 await this.hooksManager.onToolBefore({
                     toolName: toolEvent.toolName,
                     toolId: `${toolEvent.serverName}:${toolEvent.toolName}`,
@@ -134,6 +150,7 @@ export class OpenClawIntegration extends BaseIntegration {
             }
             catch (error) {
                 await this.log('error', `Error in tool.before handler: ${error}`);
+                throw error;
             }
         });
         // Subscribe to tool.after events and store unsubscribe function

package/dist/integrations/openclaw/plugin/xray-pre-tool/index.js

@@ -0,0 +1,75 @@
+import { createRequire } from 'node:module';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { definePluginEntry } from 'openclaw/plugin-sdk/plugin-entry';
+
+const require = createRequire(import.meta.url);
+const pluginDir = dirname(fileURLToPath(import.meta.url));
+
+function hasGate(root) {
+  return Boolean(root) && existsSync(join(root, 'dist/nucleus/delegation-gate.js'));
+}
+
+function resolveXrayRoot() {
+  if (hasGate(process.env.XRAY_AI_PATH || '')) {
+    return process.env.XRAY_AI_PATH;
+  }
+  const marker = join(homedir(), '.openclaw', 'xray-consumer-root.txt');
+  const marked = existsSync(marker) ? readFileSync(marker, 'utf8').trim() : '';
+  const candidates = [
+    marked,
+    marked ? join(marked, 'node_modules', '0xray') : '',
+    marked ? join(marked, '..', 'xray') : '',
+    // Linked plugin lives at src/integrations/openclaw/plugin/xray-pre-tool
+    join(pluginDir, '..', '..', '..', '..', '..'),
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    if (hasGate(candidate)) {
+      return candidate;
+    }
+  }
+  return '';
+}
+
+export default definePluginEntry({
+  id: 'xray-pre-tool',
+  name: '0xRay PreToolUse',
+  register(api) {
+    api.on(
+      'before_tool_call',
+      (event, ctx) => {
+        try {
+          const xrayRoot = resolveXrayRoot();
+          if (!xrayRoot) {
+            return { block: true, blockReason: '0xRay dist missing — set XRAY_AI_PATH' };
+          }
+          const gate = require(join(xrayRoot, 'dist/nucleus/delegation-gate.js'));
+          const projectRoot =
+            process.env.XRAY_ROOT ||
+            ctx?.workspaceDir ||
+            ctx?.cwd ||
+            process.cwd();
+          const features = gate.loadDelegationGateFeatures(projectRoot, 'openclaw');
+          const outcome = gate.evaluatePreToolGate(event.toolName, event.params || {}, {
+            projectRoot,
+            sessionId: ctx?.sessionId || ctx?.sessionKey || 'openclaw',
+            features,
+            host: 'openclaw',
+          });
+          if (!outcome.allow) {
+            return { block: true, blockReason: outcome.reason || '0xRay constitution' };
+          }
+          return undefined;
+        } catch (err) {
+          return {
+            block: true,
+            blockReason: err instanceof Error ? err.message : String(err),
+          };
+        }
+      },
+      { priority: 80 },
+    );
+  },
+});

package/dist/integrations/openclaw/plugin/xray-pre-tool/openclaw.plugin.json

@@ -0,0 +1,10 @@
+{
+  "id": "xray-pre-tool",
+  "name": "0xRay PreToolUse",
+  "description": "Constitution and temperament gate for OpenClaw tool calls (Codex 11/29/69, spawn plan).",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/dist/integrations/openclaw/plugin/xray-pre-tool/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "xray-pre-tool",
+  "version": "4.0.0",
+  "private": true,
+  "type": "module",
+  "description": "0xRay constitution + temperament PreToolUse for OpenClaw",
+  "openclaw": {
+    "extensions": ["./index.js"]
+  }
+}

package/dist/integrations/openclaw/pre-tool-gate.d.ts

@@ -0,0 +1,19 @@
+/**
+ * OpenClaw host-agent PreToolUse adapter.
+ * Platform still lacks a native consumer tool-block API; this SSOT is what
+ * install writes to ~/.openclaw/hooks and what the integration uses on tool.before.
+ */
+import { type ToolGateInput } from '../../nucleus/delegation-gate.js';
+export interface OpenClawPreToolContext {
+    projectRoot: string;
+    sessionId: string;
+}
+export interface OpenClawPreToolDecision {
+    action: 'block' | 'allow';
+    allow: boolean;
+    reason?: string;
+    gate?: string;
+    hint?: unknown;
+    warn?: boolean;
+}
+export declare function evaluateOpenClawHostPreTool(toolName: string, args: ToolGateInput, ctx: OpenClawPreToolContext): OpenClawPreToolDecision;

package/dist/integrations/openclaw/pre-tool-gate.js

@@ -0,0 +1,39 @@
+/**
+ * OpenClaw host-agent PreToolUse adapter.
+ * Platform still lacks a native consumer tool-block API; this SSOT is what
+ * install writes to ~/.openclaw/hooks and what the integration uses on tool.before.
+ */
+import { evaluatePreToolGate, loadDelegationGateFeatures, } from '../../nucleus/delegation-gate.js';
+export function evaluateOpenClawHostPreTool(toolName, args, ctx) {
+    const features = loadDelegationGateFeatures(ctx.projectRoot, 'openclaw');
+    const outcome = evaluatePreToolGate(toolName, args, {
+        projectRoot: ctx.projectRoot,
+        sessionId: ctx.sessionId,
+        features,
+        host: 'openclaw',
+    });
+    if (!outcome.allow) {
+        const blocked = {
+            action: 'block',
+            allow: false,
+            reason: outcome.reason,
+            gate: outcome.gate,
+        };
+        if ('hint' in outcome && outcome.hint)
+            blocked.hint = outcome.hint;
+        return blocked;
+    }
+    const allowed = {
+        action: 'allow',
+        allow: true,
+    };
+    if (outcome.reason) {
+        allowed.reason = outcome.reason;
+        allowed.warn = true;
+    }
+    if (outcome.gate)
+        allowed.gate = outcome.gate;
+    if ('hint' in outcome && outcome.hint)
+        allowed.hint = outcome.hint;
+    return allowed;
+}

package/dist/mcps/orchestrator/handlers/complexity-handler.js

@@ -70,11 +70,11 @@ export class ComplexityHandler {
                 isUserAsidesEnabled(projectRoot);
             let userAsideReport = '';
             let leadDevPlan = synthesisCheckpoint
-                ? buildSynthesisCheckpointPlan(args.synthesisDueReason ?? null)
+                ? buildSynthesisCheckpointPlan(args.synthesisDueReason ?? null, projectRoot)
                 : userAsideIntake
                     ? null
                     : isLeadDevModeActive() && (primaryDescription || planTaskInputs.length > 0)
-                        ? buildLeadDevPlan(primaryDescription, taskTypes.length ? taskTypes : ['implement'], planTaskInputs, analysis.overallComplexity)
+                        ? buildLeadDevPlan(primaryDescription, taskTypes.length ? taskTypes : ['implement'], planTaskInputs, analysis.overallComplexity, projectRoot)
                         : null;
             let planPersisted = synthesisCheckpoint
                 ? leadDevPlan !== null

package/dist/memory-routing/index.d.ts

@@ -1,6 +1,6 @@
 export type { MemoryRoutingProvider, MemoryRoutingContext, MemoryInheritedContext, MemoryAgentCapability, MemoryOrchestrationTask, MemoryThinDispatchResult, MemoryRoutingConfig, OrchestratorFeedbackEntry, } from './types.js';
 export { getMemoryRoutingProvider, getMemoryRoutingProviderSync, getMemoryRoutingConfig, resetMemoryRoutingProvider, initializeMemoryRouting, } from './provider-registry.js';
 export { NullMemoryRoutingProvider, createMemoryRoutingProvider } from './null-provider.js';
-export { loadMemoryRoutingProvider } from './provider-loader.js';
+export { loadMemoryRoutingProvider, isLeftoverMemoryRoutingOff, isExplicitMemoryRoutingOptOut, resolveLeftoverEnabledConfig, } from './provider-loader.js';
 export { validateMemoryRoutingConfig } from './validate-config.js';
 export type { MemoryRoutingValidation } from './validate-config.js';

package/dist/memory-routing/index.js

@@ -1,4 +1,4 @@
 export { getMemoryRoutingProvider, getMemoryRoutingProviderSync, getMemoryRoutingConfig, resetMemoryRoutingProvider, initializeMemoryRouting, } from './provider-registry.js';
 export { NullMemoryRoutingProvider, createMemoryRoutingProvider } from './null-provider.js';
-export { loadMemoryRoutingProvider } from './provider-loader.js';
+export { loadMemoryRoutingProvider, isLeftoverMemoryRoutingOff, isExplicitMemoryRoutingOptOut, resolveLeftoverEnabledConfig, } from './provider-loader.js';
 export { validateMemoryRoutingConfig } from './validate-config.js';

package/dist/memory-routing/provider-loader.d.ts

@@ -1,2 +1,6 @@
 import type { MemoryRoutingConfig, MemoryRoutingProvider } from './types.js';
+export declare function isExplicitMemoryRoutingOptOut(config: MemoryRoutingConfig): boolean;
+/** Leftover shipped default: enabled false + provider null. Not an explicit opt-out. */
+export declare function isLeftoverMemoryRoutingOff(config: MemoryRoutingConfig): boolean;
+export declare function resolveLeftoverEnabledConfig(config: MemoryRoutingConfig, cwd: string): MemoryRoutingConfig | null;
 export declare function loadMemoryRoutingProvider(config: MemoryRoutingConfig, cwd?: string): Promise<MemoryRoutingProvider>;

package/dist/memory-routing/provider-loader.js

@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
+import { resolve, dirname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { frameworkLogger } from '../core/framework-logger.js';
 import { createMemoryRoutingProvider as createNullProvider } from './null-provider.js';
@@ -20,6 +20,8 @@ function resolveUnavailableReason(provider) {
     }
 }
 const REPERTOIRE_CANDIDATE_PATHS = [
+    'node_modules/@0xray/repertoire/dist/provider/memory-routing-provider.js',
+    'vendor/@0xray/repertoire/dist/provider/memory-routing-provider.js',
     '../repertoire/dist/provider/memory-routing-provider.js',
     '../../repertoire/dist/provider/memory-routing-provider.js',
     '../../../repertoire/dist/provider/memory-routing-provider.js',
@@ -50,15 +52,55 @@ function defaultPathForProvider(provider, cwd) {
         if (existsSync(abs))
             return abs;
     }
+    const nm = join(cwd, 'node_modules', '@0xray', 'repertoire', 'dist', 'provider', 'memory-routing-provider.js');
+    return existsSync(nm) ? nm : null;
+}
+export function isExplicitMemoryRoutingOptOut(config) {
+    return config.enabled === false && config.provider === 'repertoire';
+}
+/** Leftover shipped default: enabled false + provider null. Not an explicit opt-out. */
+export function isLeftoverMemoryRoutingOff(config) {
+    if (config.enabled === true)
+        return false;
+    if (isExplicitMemoryRoutingOptOut(config))
+        return false;
+    return config.provider === 'null' || !config.provider;
+}
+function leftoverRepertoireModulePath(cwd) {
+    const nm = join(cwd, 'node_modules', '@0xray', 'repertoire', 'dist', 'provider', 'memory-routing-provider.js');
+    if (existsSync(nm))
+        return nm;
+    const vendor = join(cwd, 'vendor', '@0xray', 'repertoire', 'dist', 'provider', 'memory-routing-provider.js');
+    if (existsSync(vendor))
+        return vendor;
+    const sibling = resolve(cwd, '../repertoire/dist/provider/memory-routing-provider.js');
+    if (existsSync(sibling))
+        return sibling;
     return null;
 }
+export function resolveLeftoverEnabledConfig(config, cwd) {
+    if (!isLeftoverMemoryRoutingOff(config))
+        return null;
+    const modulePath = resolveModulePath(config.module_path, cwd) ?? leftoverRepertoireModulePath(cwd);
+    if (!modulePath)
+        return null;
+    const enabled = {
+        enabled: true,
+        provider: 'repertoire',
+        module_path: modulePath,
+    };
+    if (config.config)
+        enabled.config = config.config;
+    return enabled;
+}
 export async function loadMemoryRoutingProvider(config, cwd = process.cwd()) {
     const validation = validateMemoryRoutingConfig(config);
     if (!validation.valid) {
         await frameworkLogger.log('memory-routing', 'config-invalid', 'error', { errors: validation.errors, provider: config.provider });
         return createNullProvider();
     }
-    const effective = validation.normalized;
+    const leftover = resolveLeftoverEnabledConfig(validation.normalized, cwd);
+    const effective = leftover ?? validation.normalized;
     if (!effective.enabled || effective.provider === 'null') {
         return createNullProvider();
     }

package/dist/memory-routing/provider-registry.js

@@ -1,6 +1,6 @@
 import { featuresConfigLoader } from '../core/features-config.js';
 import { NullMemoryRoutingProvider } from './null-provider.js';
-import { loadMemoryRoutingProvider } from './provider-loader.js';
+import { loadMemoryRoutingProvider, resolveLeftoverEnabledConfig } from './provider-loader.js';
 import { validateMemoryRoutingConfig } from './validate-config.js';
 let cachedProvider = null;
 let loadPromise = null;
@@ -8,7 +8,8 @@ const nullProviderSingleton = new NullMemoryRoutingProvider();
 export function getMemoryRoutingConfig() {
     const raw = featuresConfigLoader.loadConfig().memory_routing;
     const validation = validateMemoryRoutingConfig(raw ?? { enabled: false, provider: 'null' });
-    return validation.normalized;
+    return (resolveLeftoverEnabledConfig(validation.normalized, process.cwd()) ??
+        validation.normalized);
 }
 export async function getMemoryRoutingProvider(forceReload = false) {
     if (!forceReload && cachedProvider)

package/dist/nucleus/autonomy-kernel.d.ts

@@ -43,8 +43,8 @@ export declare function isLeadDevModeActive(): boolean;
 export declare function routeSubagent(taskType: string): SubagentRoute;
 export declare function shouldFlagFullTestSuite(command: string): boolean;
 /** Mandatory-consult plan for synthesis checkpoint realignment (no implementation phase). */
-export declare function buildSynthesisCheckpointPlan(dueReason: string | null): LeadDevPlan | null;
-export declare function buildLeadDevPlan(description: string, taskTypes?: string[], taskInputs?: LeadDevPlanTaskInput[], mcpOverallComplexity?: number): LeadDevPlan | null;
+export declare function buildSynthesisCheckpointPlan(dueReason: string | null, projectRoot?: string): LeadDevPlan | null;
+export declare function buildLeadDevPlan(description: string, taskTypes?: string[], taskInputs?: LeadDevPlanTaskInput[], mcpOverallComplexity?: number, projectRoot?: string): LeadDevPlan | null;
 export declare function buildSessionBootContext(): Record<string, unknown>;
 /** Persist plan for PreToolUse spawn_subagent gate */
 export declare function persistLeadDevPlan(plan: LeadDevPlan, projectRoot?: string): string;

package/dist/nucleus/autonomy-kernel.js

@@ -6,6 +6,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { featuresConfigLoader } from '../core/features-config.js';
 import { scoreComplexity } from './thin-dispatch.js';
+import { conferDefaultForProfile, resolveRuntimeSuitProfile } from './suit-temperament.js';
 export const LEAD_DEV_RULES = [
     'Phased plan + detailed todos; assign best subagent; monitor output; iterate fully',
     'Lead dev takes helm — loop test fix until complete; no permission pings',
@@ -75,11 +76,17 @@ function buildImplementationTodos(description, taskTypes, taskInputs, idPrefix)
     }));
 }
 /** Mandatory-consult plan for synthesis checkpoint realignment (no implementation phase). */
-export function buildSynthesisCheckpointPlan(dueReason) {
+export function buildSynthesisCheckpointPlan(dueReason, projectRoot = process.cwd()) {
     if (!isLeadDevModeActive())
         return null;
     const cfg = orchestrationConfig();
-    const mandatoryConsults = cfg.auto_consult_major_work !== false ? [...MANDATORY_MAJOR_CONSULTS] : [];
+    const profile = resolveRuntimeSuitProfile(projectRoot);
+    const autoConsult = profile === 'frontier'
+        ? cfg.confer?.enabled === true || cfg.confer_on_synthesis === true
+        : profile === 'strict'
+            ? true
+            : cfg.auto_consult_major_work !== false;
+    const mandatoryConsults = autoConsult ? [...MANDATORY_MAJOR_CONSULTS] : [];
     if (mandatoryConsults.length === 0)
         return null;
     const reasonSuffix = dueReason ? ` (${dueReason})` : '';
@@ -113,10 +120,11 @@ export function buildSynthesisCheckpointPlan(dueReason) {
         },
     };
 }
-export function buildLeadDevPlan(description, taskTypes = ['implement'], taskInputs = [], mcpOverallComplexity) {
+export function buildLeadDevPlan(description, taskTypes = ['implement'], taskInputs = [], mcpOverallComplexity, projectRoot = process.cwd()) {
     if (!isLeadDevModeActive())
         return null;
     const cfg = orchestrationConfig();
+    const profile = resolveRuntimeSuitProfile(projectRoot);
     const threshold = cfg.phased_plan_threshold ?? 25;
     const score = scoreComplexity(description, { taskTypes });
     const mcpScore = mcpOverallComplexity !== undefined && Number.isFinite(mcpOverallComplexity)
@@ -124,9 +132,12 @@ export function buildLeadDevPlan(description, taskTypes = ['implement'], taskInp
         : 0;
     const complexity = Math.max(score.score, mcpScore);
     const requiresPhasedPlan = complexity > threshold || taskInputs.length > 1;
-    const mandatoryConsults = cfg.auto_consult_major_work !== false && requiresPhasedPlan
-        ? [...MANDATORY_MAJOR_CONSULTS]
-        : [];
+    const autoConsult = profile === 'frontier'
+        ? cfg.confer?.enabled === true || cfg.confer_on_synthesis === true
+        : profile === 'strict' || conferDefaultForProfile(profile)
+            ? cfg.auto_consult_major_work !== false
+            : false;
+    const mandatoryConsults = autoConsult && requiresPhasedPlan ? [...MANDATORY_MAJOR_CONSULTS] : [];
     const phases = requiresPhasedPlan
         ? [
             {

package/dist/nucleus/confer.js

@@ -8,6 +8,7 @@ import { MANDATORY_MAJOR_CONSULTS } from './autonomy-kernel.js';
 import { areSynthesisConsultTodosComplete, getNextRequiredTodo, getSynthesisConsultTodos, isSynthesisRealignmentPlan, loadPersistedLeadDevPlan, updatePlanTodoStatus, } from './lead-dev-plan-persistence.js';
 import { buildReceiptFromConsultOutput, tryRecordSynthesisConsultReceipt, parseConsultVerdictFromText, } from './synthesis-consult-receipt.js';
 import { isSynthesisCheckpointDue } from './synthesis.js';
+import { conferDefaultForProfile, resolveRuntimeSuitProfile } from './suit-temperament.js';
 export const CONFER_AGENTS = [...MANDATORY_MAJOR_CONSULTS];
 const STATE_VERSION = 1;
 export function conferCheckpointPath(projectRoot = process.cwd()) {
@@ -18,19 +19,32 @@ export function defaultConferConfig() {
 }
 export function loadConferConfig(projectRoot = process.cwd()) {
     const featuresPath = path.join(projectRoot, '.xray', 'features.json');
-    if (!fs.existsSync(featuresPath))
-        return defaultConferConfig();
+    const profile = resolveRuntimeSuitProfile(projectRoot);
+    if (profile === 'strict') {
+        return { enabled: true, on_synthesis: true };
+    }
+    if (!fs.existsSync(featuresPath)) {
+        return conferDefaultForProfile(profile)
+            ? defaultConferConfig()
+            : { enabled: false, on_synthesis: false };
+    }
     try {
         const data = JSON.parse(fs.readFileSync(featuresPath, 'utf8'));
         const orch = data.multi_agent_orchestration ?? {};
         const raw = orch.confer ?? {};
+        if (profile === 'frontier') {
+            const optedIn = raw.enabled === true || orch.confer_on_synthesis === true;
+            return { enabled: optedIn, on_synthesis: optedIn };
+        }
         return {
             enabled: raw.enabled !== false && orch.confer_on_synthesis !== false,
             on_synthesis: raw.on_synthesis !== false && orch.confer_on_synthesis !== false,
         };
     }
     catch {
-        return defaultConferConfig();
+        return conferDefaultForProfile(profile)
+            ? defaultConferConfig()
+            : { enabled: false, on_synthesis: false };
     }
 }
 export function isConferEnabled(projectRoot = process.cwd()) {

package/dist/nucleus/delegation-gate.d.ts

@@ -1,19 +1,26 @@
 /**
  * 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 { type PendingDelegation } from './pending-delegations.js';
 export { getActivePendingDelegations } from './pending-delegations.js';
 import { updatePlanTodoStatus, type SpawnToolInput } from './lead-dev-plan-persistence.js';
+import { writeSuitSessionBoot, maybeHeatHostStation, type CeremonyLevel, type SpawnPlanMode, type SuitHost, type SuitProfile } from './suit-temperament.js';
+export { writeSuitSessionBoot, maybeHeatHostStation };
 export { extractSpawnCwd, validateAsideWorktreeCwd, provisionGitWorktree } from './aside-worktree.js';
-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, type SynthesisConsultReceipt, type SynthesisConsultVerdict, } from './synthesis-consult-receipt.js';
 export declare const updatePlanTodoStatusInPlace: typeof updatePlanTodoStatus;
-export type DelegationGateHost = 'grok' | 'hermes' | 'opencode' | 'openclaw' | 'generic';
+export type DelegationGateHost = SuitHost;
 export interface DelegationGateFeatures {
     lead_dev_mode: boolean;
     auto_chain_delegations: boolean;
+    /** v3 — deny (guided/strict), warn (frontier), off */
+    spawn_plan_mode?: SpawnPlanMode;
+    ceremony?: CeremonyLevel;
+    suit_profile?: SuitProfile;
+    no_new_surface?: boolean;
 }
 export interface ToolGateInput {
     prompt?: string;
@@ -42,6 +49,7 @@ export interface PreToolGateContext {
     sessionId: string | null;
     features: DelegationGateFeatures;
     host?: DelegationGateHost;
+    hookEvent?: string;
 }
 export interface PreToolGateDeny {
     allow: false;
@@ -69,7 +77,7 @@ export interface PostToolSpawnOptions {
     toolOutput?: unknown;
     sessionId?: string | null;
 }
-export declare function loadDelegationGateFeatures(projectRoot?: string): DelegationGateFeatures;
+export declare function loadDelegationGateFeatures(projectRoot?: string, host?: DelegationGateHost): DelegationGateFeatures;
 export declare function normalizeHostToolInput(toolInput: ToolGateInput): SpawnToolInput & {
     command?: string;
 };
@@ -83,10 +91,8 @@ export declare function evaluateSpawnPlanGate(toolName: string, toolInput: ToolG
 export declare function evaluateSynthesisGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
 /** Block writes / unrelated work while pending delegations exist. */
 export declare function evaluatePendingDelegationGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
-/**
- * Full pre-tool evaluation — synthesis gate first, slice recording, then
- * pending gate, then spawn todo gate for subagent tools.
- */
+/** Codex 11 / 29 / 69 + destructive shell — always on, all hosts that call this SSOT. */
+export declare function evaluateConstitutionGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
 export declare function evaluatePreToolGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
 export declare function evaluatePostToolSpawn(toolName: string, toolInput: ToolGateInput, projectRoot: string, options?: PostToolSpawnOptions): PostToolSpawnResult;
 export declare function isOrchestrateToolEvent(toolName: string, toolInput?: ToolGateInput): boolean;