0xray 3.5.4 → 3.5.5

package/.xray/features.json

@@ -36,7 +36,11 @@
     "phased_plan_threshold": 25,
     "auto_consult_major_work": true,
     "no_new_surface": true,
-    "auto_chain_delegations": true
+    "auto_chain_delegations": true,
+    "user_asides": {
+      "enabled": true,
+      "auto_provision_worktree": false
+    }
   },
   "autonomous_reporting": {
     "enabled": true,

package/.xray/features.schema.json

@@ -28,6 +28,62 @@
         "required": ["module_path"]
       }
     },
+    "multi_agent_orchestration": {
+      "type": "object",
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "lead_dev_mode": { "type": "boolean" },
+        "plan_stale_hours": {
+          "type": "number",
+          "minimum": 1,
+          "description": "Archive lead-dev-plan when all todos still pending after N hours"
+        },
+        "plan_archive_marker_hours": {
+          "type": "number",
+          "minimum": 1,
+          "description": "How long spawn-plan-stale persists after a stale plan was archived (hours)"
+        },
+        "confer_on_synthesis": {
+          "type": "boolean",
+          "description": "Auto-run 3-agent confer quorum at synthesis checkpoint (default true)"
+        },
+        "confer": {
+          "type": "object",
+          "properties": {
+            "enabled": { "type": "boolean" },
+            "on_synthesis": { "type": "boolean" }
+          },
+          "description": "Mandatory researcher/architect-tools/code-review quorum"
+        },
+        "sibling_repos": {
+          "type": "array",
+          "items": {
+            "oneOf": [
+              { "type": "string" },
+              {
+                "type": "object",
+                "properties": {
+                  "path": { "type": "string" },
+                  "label": { "type": "string" }
+                },
+                "required": ["path"]
+              }
+            ]
+          },
+          "description": "Sibling workspace roots (e.g. UI repo when MCP host is cwd)"
+        },
+        "user_asides": {
+          "type": "object",
+          "properties": {
+            "enabled": { "type": "boolean" },
+            "auto_provision_worktree": {
+              "type": "boolean",
+              "description": "Run guarded git worktree add on analyze-complexity aside intake when worktree+branch set"
+            }
+          }
+        }
+      }
+    },
     "synthesis": {
       "type": "object",
       "properties": {

package/AGENTS-consumer.md

@@ -4,7 +4,7 @@
 
 Quick reference for the 0xRay AI orchestration framework (shipped to your project on `npm install 0xray`).
 
-**v3.5.3** — 7 MCP servers · 45 skills · 68 codex terms · 4 platform bridges
+**v3.5.5** — 7 MCP servers · 45 skills · 68 codex terms · 4 platform bridges
 
 ## Postinstall (automatic)
 

package/AGENTS.md

@@ -1,6 +1,6 @@
 # xray Agents
 
-Quick reference for the xray AI orchestration framework (**v3.5.3**).
+Quick reference for the xray AI orchestration framework (**v3.5.5**).
 
 **42 agents** · **45 skills** · **7 consumer MCP servers** · **68 codex terms** · **3,226 tests**
 
@@ -77,6 +77,16 @@ Governance deliberation: **code-review**, **security-audit**, **researcher** wit
 - Observation extractors: governance, orchestration, complexity
 - Repertoire context flows via `ExecutionPlan.memoryContext`
 
+## User asides (parallel work tracks)
+
+**Not** AsideContext — user-declared parallel tracks (worktree-like):
+
+- SSOT: `.xray/state/asides/{id}.json` + `_active.json`; todos use `{asideId}.a.*` (namespaced)
+- Intake: `analyze-complexity` with `userAsideId` (+ optional `worktree`, `branch`)
+- Activate / resume main: `orchestrate-task` with `userAsideId` or `clearActiveAside: true`
+- Spawn gate routes to active aside plan; session-boot exposes `activeAside`
+- Config: `features.json` → `multi_agent_orchestration.user_asides.enabled`
+
 ## Confidence gate (v3.3.1)
 
 `ExecutionPlanner.calculateTaskComplexity()` + `getTaskConfidence()` — complexity boost and ontological-trap routing.

package/README.md

@@ -1,6 +1,6 @@
 # xray — MCP-Centric AI Governance OS
 
-**v3.5.3** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
+**v3.5.5** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
 
 ## Your AI Power Suit
 

package/SKILLS.md

@@ -1,6 +1,6 @@
 # 0xray Skills
 
-**v3.5.3** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
+**v3.5.5** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
 
 xray ships 45 knowledge skills (`src/skills/<name>/SKILL.md`) across the full software lifecycle. Lead-dev operating model lives in **`orchestrator`** skill + `multi_agent_orchestration.lead_dev_mode` in features.json. Skills load on demand via the **xray-skills** MCP server (`npx -y 0xray mcp skills`), agent `@mentions`, or platform skill directories after postinstall.
 

package/dist/AGENTS.md

@@ -1,6 +1,6 @@
 # xray Agents
 
-Quick reference for the xray AI orchestration framework (**v3.5.3**).
+Quick reference for the xray AI orchestration framework (**v3.5.5**).
 
 **42 agents** · **45 skills** · **7 consumer MCP servers** · **68 codex terms** · **3,226 tests**
 
@@ -77,6 +77,16 @@ Governance deliberation: **code-review**, **security-audit**, **researcher** wit
 - Observation extractors: governance, orchestration, complexity
 - Repertoire context flows via `ExecutionPlan.memoryContext`
 
+## User asides (parallel work tracks)
+
+**Not** AsideContext — user-declared parallel tracks (worktree-like):
+
+- SSOT: `.xray/state/asides/{id}.json` + `_active.json`; todos use `{asideId}.a.*` (namespaced)
+- Intake: `analyze-complexity` with `userAsideId` (+ optional `worktree`, `branch`)
+- Activate / resume main: `orchestrate-task` with `userAsideId` or `clearActiveAside: true`
+- Spawn gate routes to active aside plan; session-boot exposes `activeAside`
+- Config: `features.json` → `multi_agent_orchestration.user_asides.enabled`
+
 ## Confidence gate (v3.3.1)
 
 `ExecutionPlanner.calculateTaskComplexity()` + `getTaskConfidence()` — complexity boost and ontological-trap routing.

package/dist/CHANGELOG.md

@@ -4,13 +4,57 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Conventional Commits](https://www.conventionalcommits.org/).
 
+## [3.5.5] - 2026-06-20
+
+### ✨ Features
+- **User-asides P0** — PreToolUse **denies** aside spawns without `cwd` / `working_directory` matching `aside.worktree`; `aside-worktree.ts` SSOT; synthesis-gate parity
+- **Worktree auto-provision** — `analyze-complexity` runs guarded `git worktree add` when `user_asides.auto_provision_worktree: true`
+- **Pipeline P3** — `verify:pipeline-facets` script; consumer `confirm:suit:full --pipeline-audit` wiring
+
+### 🐛 Fixes
+- **Worktree cwd enforce** — `auto_chain_delegations: false` no longer bypasses aside worktree cwd check; synthesis-gate parity retained
+- **`isAutoProvisionWorktreeEnabled`** — requires `user_asides.enabled` before honoring `auto_provision_worktree`
+- **`provisionGitWorktree`** — macOS `/var` vs `/private/var` path resolution for idempotent worktree detection
+
+### 🔄 Changes
+- **`verify:pipeline-facets --package-only`** — release-gate probes shipped artifacts without consumer feature matrix
+- **`release-gate.mjs`** — wires pipeline facet verify (package-only mode)
+
+### ✅ Tests
+- `aside-worktree.test.ts`; delegation-gate cwd deny/allow; auto_chain-off + synthesis worktree deny; `provisionGitWorktree` guards; `verify-user-aside-core` 10/10
+
+---
+
 ## [3.5.4] - 2026-06-19
 
 ### ✨ Features
 - **Synthesis consult receipt gate** — s.1–s.3 todos require `.xray/state/synthesis-consult-{id}.json` before completion; `evaluatePostToolSpawn` records receipts from subagent output; Grok post-tool hook wired
+- **User asides** — parallel work tracks (worktree-like) via `.xray/state/asides/{id}.json`; namespaced `{asideId}.a.*` todo routing; `analyze-complexity` + `orchestrate-task` rewire (no new MCP); session-boot hints; synthesis/pending bypass for aside spawns; `verify:user-aside` 9/9; docs `guides/user-asides.md`
+- **Confer quorum** — `confer.ts` SSOT; auto-runs at synthesis `analyze-complexity` (researcher → architect-tools → code-review); `verify:confer` 7/7; config `confer_on_synthesis` (default true); session-boot `conferPending` hint; emoji agent panel in quorum report
+- **Pipeline integration (P0–P2)** — enforcement-gate `{ proposals: [...] }` shape; `applyDecisionMatrix` + `calculateMetamorphosisScore` in `GovernanceService`; Grok `pipeline-hook-runtime.mjs` (reflection stubs, routing outcomes, reporting, inference-improvement light); `SelfProposalEngine` wired in PostProcessor; aside worktree cwd warn in delegation-gate; `autonomous_reporting` config key fix in SessionSummaryProcessor
+- **Stale lead-dev plan** — archive after `plan_stale_hours`; `spawn-plan-stale` persists after archival via recent archive marker; synthesis realignment (s.1–s.3) exempt until consult todos complete
+- **Hermes session-start parity** — `bridge.mjs` `session-start` command archives stale plans; lazy `plan-hook-runtime.mjs`; `verify-hermes-session-start.mjs` (4/4)
+- **Pre-commit / pre-push codex** — diff-hunk and commit-range scope verifiers (`verify:pre-commit-diff`, `verify:pre-push-diff`)
+- **Reflection noise** — minimal defaults 50 commits / `autoGenerate: false`; shell fallbacks synced
+- **Multi-repo boot** — `sibling_repos` in `session-boot.json`
+
+### 🔄 Changes
+- **autonomy-command.md** — SSOT is `analyze-complexity` + `multi_agent_orchestration`; removed stale `autonomy-intake` / `autonomy_kernel` references
 
 ### ✅ Tests
 - `synthesis-consult-receipt.test.ts`; E2E/outcome verifiers write fixture receipts
+- `governance-service-metamorphosis.test.ts`; `confer.test.ts` emoji panel
+
+---
+
+## [Unreleased]
+
+### Planned (iterate before next release)
+- **Configurable archive marker** — `plan_archive_marker_hours` controls `spawn-plan-stale` persistence after archival
+- **Verifier coverage** — `spawn-plan-stale` in `verify-delegation-gate-core` (5/5); wired into `release-gate`
+- **Post-commit log maintenance** — consumer path fix (`node_modules/0xray/dist`)
+- **grok_postprocessor_light** — opt-in marker + activity.log on Grok write tools (full PP subset deferred)
+- **P2 session capture** — git post-commit → `captureSessionInference` when threshold met
 
 ---
 

package/dist/README.md

@@ -1,6 +1,6 @@
 # xray — MCP-Centric AI Governance OS
 
-**v3.5.3** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
+**v3.5.5** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
 
 ## Your AI Power Suit
 

package/dist/SKILLS.md

@@ -1,6 +1,6 @@
 # 0xray Skills
 
-**v3.5.3** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
+**v3.5.5** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
 
 xray ships 45 knowledge skills (`src/skills/<name>/SKILL.md`) across the full software lifecycle. Lead-dev operating model lives in **`orchestrator`** skill + `multi_agent_orchestration.lead_dev_mode` in features.json. Skills load on demand via the **xray-skills** MCP server (`npx -y 0xray mcp skills`), agent `@mentions`, or platform skill directories after postinstall.
 

package/dist/cli/commands/hermes-install.js

@@ -6,7 +6,8 @@ import { frameworkLogger } from '../../core/framework-logger.js';
 import { syncBuiltinSkills } from './skill-install.js';
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
 const require = createRequire(import.meta.url);
-const wiring = require(path.join(__dirname, '..', '..', '..', 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
+const packageRoot = path.join(__dirname, '..', '..', '..');
+const wiring = require(path.join(packageRoot, 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
 export function registerHermesCommands(hermesCmd) {
     hermesCmd
         .command('install')
@@ -62,6 +63,7 @@ async function installForHermes(options = {}) {
             }
             frameworkLogger.log('hermes-integration', 'skills-synced', 'info', { count: skillsCopied });
         }
+        wiring.copyHermesFindProjectRootHelper(packageRoot, targetPluginDir);
         const wired = wiring.wireHermesBridge(targetDir);
         console.log(`\x1b[32m✓ Wired Hermes mcp_servers (${wired.count} servers)\x1b[0m`);
         console.log(`\x1b[32m✓ Consumer root → ${targetDir}\x1b[0m`);

package/dist/core/features-config.d.ts

@@ -65,6 +65,21 @@ export interface MultiAgentOrchestrationConfig {
     no_new_surface?: boolean;
     /** 3.5.0 — PreToolUse gate after delegate-deferred (default true when lead_dev_mode) */
     auto_chain_delegations?: boolean;
+    /** Hours before unstarted lead-dev plan is archived (default 8) */
+    plan_stale_hours?: number;
+    /** Hours spawn-plan-stale persists after archival (default 24) */
+    plan_archive_marker_hours?: number;
+    /** Sibling workspace roots for multi-repo session boot metadata */
+    sibling_repos?: Array<string | {
+        path: string;
+        label?: string;
+    }>;
+    /** Auto-run 3-agent confer at synthesis checkpoint */
+    confer_on_synthesis?: boolean;
+    confer?: {
+        enabled?: boolean;
+        on_synthesis?: boolean;
+    };
 }
 /** Reflection triggers merged from legacy auto_reflection when synthesis is configured */
 export interface SynthesisReflectionConfig {

package/dist/governance/governance-service.d.ts

@@ -29,6 +29,7 @@ export declare class GovernanceService {
      * Dynamo Solar SSOT is treated as a hard requirement by default.
      */
     govern(request: GovernanceRequest): Promise<GovernanceResponse>;
+    private resolveRequireExternalDynamo;
     private runGovernanceWithTimeout;
     private callSkillServer;
     private callExternalDynamo;

package/dist/governance/governance-service.js

@@ -18,8 +18,9 @@
 import { mcpClientManager } from '../mcps/mcp-client.js';
 import { callInProcessSkill } from '../mcps/in-process-skill-registry.js';
 import { getGovernanceIntegration, } from '../integrations/governance/index.js';
-import { mergeVotes } from './governance-core.js';
+import { applyDecisionMatrix, calculateMetamorphosisScore, mergeVotes, } from './governance-core.js';
 import { frameworkLogger } from '../core/framework-logger.js';
+import { featuresConfigLoader } from '../core/features-config.js';
 export class GovernanceService {
     constructor() {
         // We deliberately do *not* cache the integration here.
@@ -39,7 +40,7 @@ export class GovernanceService {
      */
     async govern(request) {
         const { proposals, context, options } = request;
-        const requireExternal = options?.requireExternalDynamo ?? true;
+        const requireExternal = this.resolveRequireExternalDynamo(options?.requireExternalDynamo);
         const timeoutMs = options?.timeoutMs ?? 90000;
         const maxAbstentionThreshold = options?.maxAbstentionThreshold ?? 1.0;
         frameworkLogger.log('governance-service', 'govern-start', 'info', {
@@ -59,7 +60,7 @@ export class GovernanceService {
             }
         }
         // Run governance with end-to-end timeout
-        const result = await this.runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs);
+        const result = await this.runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs, options?.metamorphosisThreshold);
         // Check abstention threshold
         if (result.results.length > 0 && maxAbstentionThreshold < 1.0) {
             const totalVotes = result.results.reduce((sum, r) => sum + r.votes.length, 0);
@@ -91,7 +92,26 @@ export class GovernanceService {
             },
         };
     }
-    async runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs) {
+    resolveRequireExternalDynamo(explicit) {
+        if (explicit !== undefined)
+            return explicit;
+        if (process.env.XRAY_LOCAL_MODE === '1' || process.env.XRAY_LOCAL_MODE === 'true') {
+            return false;
+        }
+        try {
+            const config = featuresConfigLoader.loadConfig();
+            const ig = config.inference_governance;
+            if (ig?.require_external_dynamo === false)
+                return false;
+            if (ig?.local_mode === true)
+                return false;
+        }
+        catch {
+            /* default strict */
+        }
+        return true;
+    }
+    async runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs, metamorphosisThreshold = 0.7) {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
         try {
@@ -112,12 +132,67 @@ export class GovernanceService {
                     ...(externalVotes[index] || []),
                 ];
                 const merged = mergeVotes(votes);
+                const externalVote = votes.find((v) => v.server === 'external-dynamo');
+                let finalDecision = merged.finalDecision;
+                let averageConfidence = merged.averageConfidence;
+                let moralOverride = 'none';
+                if (externalVote?.moralTension ||
+                    externalVote?.moralScore != null ||
+                    externalVote?.moralFusion != null) {
+                    const matrixInput = {
+                        resonance: averageConfidence,
+                        isotopicRatio: externalVote.moralFusion ?? 0.5,
+                    };
+                    if (externalVote.moralTension != null) {
+                        matrixInput.moralTension = externalVote.moralTension;
+                    }
+                    if (externalVote.moralScore != null) {
+                        matrixInput.moralScore = externalVote.moralScore;
+                    }
+                    if (externalVote.moralFusion != null) {
+                        matrixInput.moralFusion = externalVote.moralFusion;
+                    }
+                    const matrix = applyDecisionMatrix(matrixInput);
+                    moralOverride = matrix.moralOverride ?? 'none';
+                    if (matrix.recommendation === 'REJECT') {
+                        finalDecision = 'reject';
+                    }
+                    else if (matrix.recommendation === 'NEEDS_REVISION' && finalDecision === 'approve') {
+                        finalDecision = 'needs_revision';
+                    }
+                    else if (matrix.recommendation === 'PASS' && finalDecision !== 'reject') {
+                        finalDecision = 'approve';
+                    }
+                    averageConfidence = matrix.confidence;
+                }
+                let metamorphosisScore;
+                if (proposal.type === 'metamorphosis' || proposal.source === 'metamorphosis') {
+                    const proposalType = proposal.type === 'compliance'
+                        ? 'compliance'
+                        : proposal.type === 'automate' || proposal.type === 'codify'
+                            ? proposal.type
+                            : 'fix';
+                    const metamorphosisInput = {
+                        averageConfidence,
+                        proposalType,
+                        resonanceScore: averageConfidence,
+                    };
+                    if (externalVote?.moralFusion != null) {
+                        metamorphosisInput.historicalCoherence = externalVote.moralFusion;
+                    }
+                    metamorphosisScore = calculateMetamorphosisScore(metamorphosisInput);
+                    if (metamorphosisScore < metamorphosisThreshold) {
+                        finalDecision = 'needs_revision';
+                    }
+                }
                 return {
                     proposalId: proposal.id,
-                    finalDecision: merged.finalDecision,
-                    averageConfidence: merged.averageConfidence,
+                    finalDecision,
+                    averageConfidence,
                     votes,
                     reasoningSummary: merged.reasoningSummary,
+                    moralOverride,
+                    ...(metamorphosisScore != null ? { metamorphosisScore } : {}),
                 };
             });
             return { results };

package/dist/integrations/enforcement-gate.js

@@ -252,12 +252,22 @@ export async function afterToolHook(tool, args, _result, _error, _context) {
             const result = _result;
             if (result && typeof result === "object" && "title" in result && "description" in result) {
                 const { handleGovernRequest } = await import("../nucleus/index.js");
+                const localMode = process.env.XRAY_LOCAL_MODE === "1" || process.env.XRAY_LOCAL_MODE === "true";
                 const governanceResult = await handleGovernRequest({
-                    proposalId: `gate-${Date.now()}`,
-                    title: String(result.title || ""),
-                    description: String(result.description || ""),
-                    type: String(result.type || "fix"),
-                    content: result,
+                    proposals: [
+                        {
+                            id: `gate-${Date.now()}`,
+                            type: String(result.type || "fix"),
+                            title: String(result.title || ""),
+                            description: String(result.description || ""),
+                            evidence: [],
+                            source: "manual",
+                            metadata: result,
+                        },
+                    ],
+                    options: {
+                        requireExternalDynamo: localMode ? false : undefined,
+                    },
                 });
                 governanceTriggered = governanceResult?.overallDecision === 'approve';
                 if (governanceTriggered) {

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

@@ -25,16 +25,7 @@ const __dirname = path.dirname(new URL(import.meta.url).pathname);
 const packageRoot = path.resolve(__dirname, '..', '..', '..');
 const requireCjs = createRequire(import.meta.url);
 const { resolveConsumerTargetDir } = requireCjs(path.join(packageRoot, 'scripts/node/install-bridges.cjs'));
-/** Canonical 7-server MCP surface — matches install-bridges.cjs and package .mcp.json */
-const XRAY_MCP_SERVERS = [
-    { name: 'xray-governance', mcpCmd: 'governance', env: { XRAY_FORCE_MCP_GOVERNANCE: 'true' } },
-    { name: 'xray-skills', mcpCmd: 'skills', env: {} },
-    { name: 'xray-orchestrator', mcpCmd: 'orchestrator', env: {} },
-    { name: 'xray-enforcer', mcpCmd: 'enforcer', env: {} },
-    { name: 'xray-researcher', mcpCmd: 'researcher', env: {} },
-    { name: 'xray-code-review', mcpCmd: 'code-review', env: {} },
-    { name: 'xray-architect-tools', mcpCmd: 'architect-tools', env: {} },
-];
+const { XRAY_MCP_SERVERS } = requireCjs(path.join(packageRoot, 'scripts/node/bridge-mcp-wiring.cjs'));
 function registerGrokMcpServers(targetDir) {
     try {
         execSync('which grok', { stdio: 'ignore' });

package/dist/integrations/grok/hooks/grok-hook-utils.js

@@ -18,6 +18,8 @@ import {
   validateSpawnMatchesTodo,
   updatePlanTodoStatusInPlace,
 } from '../../hooks/delegation-gate-runtime.mjs';
+import { isConferPendingForSession } from '../../hooks/confer-hook-runtime.mjs';
+import { getActiveUserAsideBoot } from '../../hooks/user-aside-hook-runtime.mjs';
 
 export {
   checkPendingDelegationGate,
@@ -105,6 +107,30 @@ export function resolveCodexPath(root = workspaceRoot()) {
   return null;
 }
 
+export function resolveSiblingWorkspaceRoots(root = workspaceRoot()) {
+  const featuresPath = resolveFeaturesPath(root);
+  if (!featuresPath) return [];
+  try {
+    const data = JSON.parse(fs.readFileSync(featuresPath, 'utf8'));
+    const siblings = data.multi_agent_orchestration?.sibling_repos ?? [];
+    if (!Array.isArray(siblings)) return [];
+    const resolved = [];
+    for (const entry of siblings) {
+      const rel = typeof entry === 'string' ? entry : entry?.path;
+      if (!rel || typeof rel !== 'string') continue;
+      const abs = path.isAbsolute(rel) ? rel : path.resolve(root, rel);
+      if (!fs.existsSync(abs)) continue;
+      resolved.push({
+        path: abs,
+        label: typeof entry === 'object' && entry.label ? entry.label : path.basename(abs),
+      });
+    }
+    return resolved;
+  } catch {
+    return [];
+  }
+}
+
 export function loadFeatures(root = workspaceRoot()) {
   const featuresPath = resolveFeaturesPath(root);
   if (!featuresPath) return { lead_dev_mode: true, no_new_surface: true, per_suite_triage: true };
@@ -116,6 +142,7 @@ export function loadFeatures(root = workspaceRoot()) {
       no_new_surface: orch.no_new_surface !== false,
       per_suite_test_triage: orch.per_suite_test_triage !== false,
       auto_chain_delegations: orch.auto_chain_delegations !== false,
+      sibling_repos: resolveSiblingWorkspaceRoots(root),
     };
   } catch {
     return {
@@ -123,6 +150,7 @@ export function loadFeatures(root = workspaceRoot()) {
       no_new_surface: true,
       per_suite_triage: true,
       auto_chain_delegations: true,
+      sibling_repos: [],
     };
   }
 }
@@ -215,9 +243,22 @@ export function sessionBootPath(root = workspaceRoot()) {
   return path.join(root, '.xray', 'state', 'session-boot.json');
 }
 
+export function loadConferPending(root = workspaceRoot(), sessionId = null) {
+  try {
+    return isConferPendingForSession(root, sessionId);
+  } catch {
+    return false;
+  }
+}
+
 export function buildSessionBootPayload(root, source = '0xray/grok-session-start', extra = {}) {
-  const features = loadFeatures();
+  const features = loadFeatures(root);
   const blockingTerms = loadBlockingCodexTerms();
+  const siblingRoots = features.sibling_repos ?? resolveSiblingWorkspaceRoots(root);
+  const sessionId =
+    extra.sessionId || process.env.GROK_SESSION_ID || process.env.GROK_SESSION || null;
+  const conferPending = loadConferPending(root, sessionId);
+  const userAsideBoot = getActiveUserAsideBoot(root, sessionId);
   return {
     hook: source,
     lead_dev_mode: features.lead_dev_mode,
@@ -228,7 +269,10 @@ export function buildSessionBootPayload(root, source = '0xray/grok-session-start
     mcpIntake: 'xray-orchestrator → analyze-complexity (required before spawn_subagent)',
     enforcement: 'PreToolUse hook — codex patterns + surface area + spawn gate',
     workspaceRoot: root,
-    sessionId: process.env.GROK_SESSION_ID || null,
+    ...(siblingRoots.length > 0 ? { siblingWorkspaceRoots: siblingRoots } : {}),
+    ...(conferPending ? { conferPending: true, conferTrigger: 'analyze-complexity at synthesis checkpoint' } : {}),
+    ...(userAsideBoot ?? {}),
+    sessionId,
     timestamp: new Date().toISOString(),
     source,
     ...extra,

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

@@ -17,6 +17,7 @@ import {
   evaluatePostToolSpawn,
   isOrchestrateToolEvent as gateIsOrchestrateToolEvent,
 } from '../../hooks/delegation-gate-runtime.mjs';
+import { recordRoutingOutcome } from '../../hooks/pipeline-hook-runtime.mjs';
 
 function extractToolOutput(event) {
   return (
@@ -43,6 +44,16 @@ async function main() {
         sessionId,
         note: 'orchestrate-task completed — pending-delegations.json written by task-handler',
       });
+      try {
+        recordRoutingOutcome(eventRoot, {
+          tool: toolName,
+          agent: toolInput?.subagent_type ?? toolInput?.agent ?? 'orchestrate-task',
+          planTodoId: toolInput?.planTodoId ?? null,
+          sessionId,
+        });
+      } catch {
+        /* non-blocking */
+      }
     }
 
     if (isSubagentTool(toolName)) {
@@ -61,6 +72,16 @@ async function main() {
           todoCompleted: spawnResult.todoCompleted ?? false,
         });
       }
+      try {
+        recordRoutingOutcome(eventRoot, {
+          tool: toolName,
+          agent: toolInput?.subagent_type ?? toolInput?.agent ?? 'subagent',
+          planTodoId: toolInput?.planTodoId ?? spawnResult.expectedTodoId ?? null,
+          sessionId,
+        });
+      } catch {
+        /* non-blocking */
+      }
     }
 
     process.exit(0);

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

@@ -21,6 +21,7 @@ import {
   workspaceRoot,
 } from './grok-hook-utils.js';
 import { appendHookActivity } from './grok-hook-activity.js';
+import { runGrokPostprocessorLight } from '../../hooks/pipeline-hook-runtime.mjs';
 
 function finish(root, decision, reason, hint, toolName, extra = {}) {
   const out = { decision, ...extra };
@@ -69,6 +70,17 @@ async function main() {
       );
     }
 
+    if (gateBlock.reason) {
+      finish(
+        eventRoot,
+        'allow',
+        gateBlock.reason,
+        gateBlock.hint,
+        toolName,
+        { gate: gateBlock.gate, warn: true },
+      );
+    }
+
     if (features.no_new_surface && isWriteTool(toolName) && paths.length) {
       const surfaceBlock = checkSurfaceArea(paths, eventRoot);
       if (surfaceBlock) finish(eventRoot, 'deny', surfaceBlock, null, toolName);
@@ -88,6 +100,14 @@ async function main() {
       if (testHint) finish(eventRoot, 'allow', null, testHint, toolName);
     }
 
+    if (features.grok_postprocessor_light === true && isWriteTool(toolName)) {
+      try {
+        runGrokPostprocessorLight(eventRoot, { tool: toolName, paths });
+      } catch {
+        /* non-blocking */
+      }
+    }
+
     finish(eventRoot, 'allow', null, null, toolName);
   } catch (err) {
     appendHookActivity(root, 'grok-pre-tool-use', 'hook-error', 'error', {