0xray 3.5.5 → 4.0.1

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;

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 {