0xray 3.5.1 → 3.5.2

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

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+/**
+ * Load compiled synthesis SSOT for Grok/Hermes hooks.
+ */
+import { createRequire } from 'node:module';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function resolvePackageRoot() {
+  let dir = __dirname;
+  for (let i = 0; i < 10; i++) {
+    const pkg = join(dir, 'package.json');
+    if (existsSync(pkg)) {
+      try {
+        const require = createRequire(join(dir, 'package.json'));
+        if (require('./package.json').name === '0xray') return dir;
+      } catch {
+        /* continue */
+      }
+    }
+    const nm = join(dir, 'node_modules', '0xray', 'package.json');
+    if (existsSync(nm)) return dirname(nm);
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(__dirname, '../../..');
+}
+
+function loadSynthesis() {
+  const root = resolvePackageRoot();
+  const candidates = [
+    join(__dirname, '../../nucleus/synthesis.js'),
+    join(root, 'dist/nucleus/synthesis.js'),
+    join(process.cwd(), 'node_modules/0xray/dist/nucleus/synthesis.js'),
+  ];
+  const found = candidates.find((p) => existsSync(p));
+  if (!found) return null;
+  return createRequire(import.meta.url)(found);
+}
+
+export function recordSynthesisTurnSlice(projectRoot, sessionId) {
+  if (!sessionId) return null;
+  const mod = loadSynthesis();
+  if (!mod?.recordExecutionSlice) return null;
+  return mod.recordExecutionSlice('turn', { projectRoot, sessionId });
+}

package/dist/mcps/orchestrator/handlers/complexity-handler.d.ts

@@ -27,11 +27,14 @@ export declare class ComplexityHandler {
     handleAnalyzeComplexity(args: {
         tasks: AnalyzeComplexityInput[];
         sessionId?: string;
+        synthesisCheckpoint?: boolean;
+        synthesisDueReason?: string | null;
     }, asideId?: string): Promise<{
         content: Array<{
             type: string;
             text: string;
         }>;
+        ok: boolean;
     }>;
     /**
      * Generate recommendations based on complexity analysis

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

@@ -4,7 +4,7 @@
  * Handles complexity analysis requests
  */
 import { frameworkLogger } from '../../../core/framework-logger.js';
-import { buildLeadDevPlan, isLeadDevModeActive, persistLeadDevPlan, } from '../../../nucleus/autonomy-kernel.js';
+import { buildLeadDevPlan, buildSynthesisCheckpointPlan, isLeadDevModeActive, persistLeadDevPlan, } from '../../../nucleus/autonomy-kernel.js';
 import { bindPlanToSession } from '../../../nucleus/lead-dev-plan-persistence.js';
 import { clearPendingDelegations } from '../../../nucleus/pending-delegations.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
@@ -60,38 +60,50 @@ export class ComplexityHandler {
             const planTaskInputs = tasks
                 .filter((t) => t.description?.trim())
                 .map((t) => ({ description: t.description, type: t.type }));
-            const leadDevPlan = isLeadDevModeActive() && (primaryDescription || planTaskInputs.length > 0)
-                ? buildLeadDevPlan(primaryDescription, taskTypes.length ? taskTypes : ['implement'], planTaskInputs, analysis.overallComplexity)
-                : null;
+            const synthesisCheckpoint = args.synthesisCheckpoint === true;
+            const leadDevPlan = synthesisCheckpoint
+                ? buildSynthesisCheckpointPlan(args.synthesisDueReason ?? null)
+                : isLeadDevModeActive() && (primaryDescription || planTaskInputs.length > 0)
+                    ? buildLeadDevPlan(primaryDescription, taskTypes.length ? taskTypes : ['implement'], planTaskInputs, analysis.overallComplexity)
+                    : null;
+            let planPersisted = synthesisCheckpoint ? leadDevPlan !== null : !leadDevPlan;
             if (leadDevPlan) {
                 try {
                     const sessionId = args.sessionId ?? `analyze-${Date.now()}`;
-                    clearPendingDelegations();
+                    if (!synthesisCheckpoint) {
+                        clearPendingDelegations();
+                    }
                     const planPath = persistLeadDevPlan(leadDevPlan);
                     const bound = bindPlanToSession(sessionId);
-                    await frameworkLogger.log('orchestrator.server', 'lead-dev-plan-persisted', 'info', {
+                    planPersisted = true;
+                    await frameworkLogger.log('orchestrator.server', synthesisCheckpoint ? 'synthesis-plan-persisted' : 'lead-dev-plan-persisted', 'info', {
                         planPath,
                         sessionId,
                         planGeneration: bound?.planGeneration,
                         phaseCount: leadDevPlan.phases.length,
                         todoCount: leadDevPlan.phases.reduce((n, p) => n + p.todos.length, 0),
+                        synthesisCheckpoint,
                     });
                 }
                 catch (err) {
-                    await frameworkLogger.log('orchestrator.server', 'lead-dev-plan-persist-failed', 'warning', { error: err instanceof Error ? err.message : String(err) });
+                    planPersisted = false;
+                    await frameworkLogger.log('orchestrator.server', synthesisCheckpoint ? 'synthesis-plan-persist-failed' : 'lead-dev-plan-persist-failed', 'warning', { error: err instanceof Error ? err.message : String(err) });
                 }
             }
+            const ok = planPersisted;
             return {
+                ok,
                 content: [
                     {
                         type: 'text',
-                        text: this.formatComplexityResponse(analysis, recommendations, tasks.length, leadDevPlan),
+                        text: this.formatComplexityResponse(analysis, recommendations, tasks.length, leadDevPlan, synthesisCheckpoint),
                     },
                 ],
             };
         }
         catch (error) {
             return {
+                ok: false,
                 content: [
                     {
                         type: 'text',
@@ -129,7 +141,7 @@ export class ComplexityHandler {
     /**
      * Format complexity response
      */
-    formatComplexityResponse(analysis, recommendations, taskCount, leadDevPlan = null) {
+    formatComplexityResponse(analysis, recommendations, taskCount, leadDevPlan = null, synthesisCheckpoint = false) {
         const leadDevSection = leadDevPlan
             ? `
 
@@ -146,7 +158,10 @@ ${leadDevPlan.phases
 ${JSON.stringify(leadDevPlan, null, 2)}
 \`\`\``
             : '';
-        return `🔍 Complexity Analysis Results
+        const header = synthesisCheckpoint
+            ? '🔄 Synthesis Checkpoint — Reflect & Realign'
+            : '🔍 Complexity Analysis Results';
+        return `${header}
 
 **Tasks Analyzed:** ${taskCount}
 **Overall Complexity:** ${analysis.overallComplexity}/100

package/dist/mcps/orchestrator/server.js

@@ -105,10 +105,14 @@ export class OrchestratorServer {
                     },
                     {
                         name: 'analyze-complexity',
-                        description: 'Analyze task complexity and recommend orchestration strategy. When lead_dev_mode is on (features.json), includes phased plan + todos + subagent routes.',
+                        description: 'Analyze task complexity and recommend orchestration strategy. When lead_dev_mode is on (features.json), includes phased plan + todos + subagent routes. During synthesis checkpoint, returns collocated context and mandatory-consult realignment plan — pass sessionId from the active session.',
                         inputSchema: {
                             type: 'object',
                             properties: {
+                                sessionId: {
+                                    type: 'string',
+                                    description: 'Active session id (required to clear synthesis checkpoint; inferred from checkpoint state when omitted)',
+                                },
                                 tasks: {
                                     type: 'array',
                                     items: {
@@ -229,11 +233,97 @@ export class OrchestratorServer {
                     }
                     case 'analyze-complexity': {
                         const complexityArgs = args;
+                        const projectRoot = process.cwd();
+                        const { isSynthesisCheckpointDue, getSynthesisDueReason, getSynthesisCheckpointSessionId, } = await import('../../nucleus/synthesis.js');
+                        const { appendSynthesisContextToResponse, prepareSynthesisCollocatedContext } = await import('../../nucleus/synthesis-context.js');
+                        const { loadPersistedLeadDevPlan, isSynthesisRealignmentPlan, areSynthesisConsultTodosComplete, getSynthesisConsultTodos, getNextRequiredTodo, } = await import('../../nucleus/lead-dev-plan-persistence.js');
+                        const checkpointSession = getSynthesisCheckpointSessionId(projectRoot);
+                        if (checkpointSession &&
+                            complexityArgs.sessionId &&
+                            complexityArgs.sessionId !== checkpointSession) {
+                            return {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: `❌ Synthesis sessionId mismatch — expected \`${checkpointSession}\` ` +
+                                            `(from synthesis-checkpoint.json), got \`${complexityArgs.sessionId}\`.`,
+                                    },
+                                ],
+                            };
+                        }
+                        const sessionId = checkpointSession ?? complexityArgs.sessionId ?? null;
+                        const synthesisDue = checkpointSession
+                            ? isSynthesisCheckpointDue(projectRoot, checkpointSession)
+                            : false;
+                        const dueReason = synthesisDue
+                            ? getSynthesisDueReason(projectRoot, sessionId)
+                            : null;
+                        if (synthesisDue && !sessionId) {
+                            return {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: '❌ Synthesis checkpoint due but sessionId could not be resolved. ' +
+                                            'Pass sessionId matching .xray/state/synthesis-checkpoint.json.',
+                                    },
+                                ],
+                            };
+                        }
+                        const existingPlan = loadPersistedLeadDevPlan(projectRoot);
+                        const realignmentInProgress = synthesisDue &&
+                            existingPlan &&
+                            isSynthesisRealignmentPlan(existingPlan) &&
+                            !areSynthesisConsultTodosComplete(existingPlan);
+                        if (realignmentInProgress) {
+                            const collocated = await prepareSynthesisCollocatedContext(projectRoot, dueReason);
+                            const nextTodo = getNextRequiredTodo(existingPlan);
+                            const consultTodos = getSynthesisConsultTodos(existingPlan);
+                            const todoList = consultTodos
+                                .map((t) => `- [${t.status === 'completed' ? 'x' : ' '}] ${t.id} (${t.subagent}): ${t.task}`)
+                                .join('\n');
+                            let text = '🔄 Synthesis realignment in progress — consult todos preserved (analyze-complexity no-op).\n\n' +
+                                `**Next required todo:** ${nextTodo?.id ?? 'none'} (${nextTodo?.subagent ?? ''})\n\n` +
+                                `${todoList}\n\n` +
+                                'Complete mandatory consult todos via Task spawns before other gated work.';
+                            if (collocated.collatedText) {
+                                text = appendSynthesisContextToResponse([{ type: 'text', text }], collocated.collatedText)[0].text;
+                            }
+                            return { content: [{ type: 'text', text }] };
+                        }
+                        const collocated = synthesisDue
+                            ? await prepareSynthesisCollocatedContext(projectRoot, dueReason)
+                            : null;
+                        const inheritedContext = synthesisDue && collocated
+                            ? { synthesis: true, ...collocated }
+                            : { taskCount: complexityArgs.tasks.length };
                         const aside = await spawnAside({
-                            description: `Complexity analysis: ${complexityArgs.tasks.length} tasks`,
+                            description: synthesisDue
+                                ? 'Synthesis checkpoint: reflect & realign'
+                                : `Complexity analysis: ${complexityArgs.tasks.length} tasks`,
+                            ...(sessionId ? { sessionId } : {}),
+                            inheritedContext,
                         });
                         try {
-                            return await this.complexityHandler.handleAnalyzeComplexity(complexityArgs, aside.asideId);
+                            const result = await this.complexityHandler.handleAnalyzeComplexity({
+                                ...complexityArgs,
+                                ...(sessionId ? { sessionId } : {}),
+                                ...(synthesisDue
+                                    ? { synthesisCheckpoint: true, synthesisDueReason: dueReason }
+                                    : {}),
+                            }, aside.asideId);
+                            let content = result.content;
+                            if (synthesisDue && collocated?.collatedText) {
+                                content = appendSynthesisContextToResponse(content, collocated.collatedText);
+                            }
+                            if (synthesisDue && result.ok) {
+                                content = content.map((block, index) => index === 0
+                                    ? {
+                                        ...block,
+                                        text: `${block.text}\n\n**Synthesis checkpoint remains active** until mandatory consult todos (s.1–s.3) are completed via Task spawns.`,
+                                    }
+                                    : block);
+                            }
+                            return { content };
                         }
                         finally {
                             closeAside(aside.asideId);
@@ -281,12 +371,38 @@ export class OrchestratorServer {
     }
     async handleGovernAndApply(args) {
         try {
+            const projectRoot = process.cwd();
+            const { isSynthesisCheckpointDue, getSynthesisDueReason, getSynthesisCheckpointSessionId, recordExecutionSlice, } = await import('../../nucleus/synthesis.js');
+            const { loadPersistedLeadDevPlan, isSynthesisRealignmentPlan, areSynthesisConsultTodosComplete, } = await import('../../nucleus/lead-dev-plan-persistence.js');
+            const checkpointSession = getSynthesisCheckpointSessionId(projectRoot);
+            const sessionId = checkpointSession ?? null;
+            if (sessionId && isSynthesisCheckpointDue(projectRoot, sessionId)) {
+                const dueReason = getSynthesisDueReason(projectRoot, sessionId);
+                const plan = loadPersistedLeadDevPlan(projectRoot);
+                const realignmentPending = plan && isSynthesisRealignmentPlan(plan) && !areSynthesisConsultTodosComplete(plan);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                blocked: true,
+                                gate: 'synthesis-checkpoint',
+                                dueReason,
+                                primitive: 'synthesis',
+                                realignmentPending,
+                                hint: realignmentPending
+                                    ? 'Complete mandatory consult todos (s.1–s.3) before govern-and-apply'
+                                    : 'Run analyze-complexity to reflect and realign before govern-and-apply',
+                            }, null, 2),
+                        }],
+                };
+            }
             const { InferenceCycle } = await import('../../inference/inference-cycle.js');
-            const cycle = InferenceCycle.getInstance(process.cwd(), {
+            const cycle = InferenceCycle.getInstance(projectRoot, {
                 skipApply: args.skipApply ?? false,
             });
             const aside = await spawnAside({
                 description: `Governance cycle: ${args.proposals.length} proposals`,
+                ...(sessionId ? { sessionId } : {}),
                 priorVerdictContext: { proposalCount: args.proposals.length },
             });
             let result;
@@ -299,12 +415,16 @@ export class OrchestratorServer {
             }
             const approved = result.votes.filter((v) => v.decision === 'approve').length;
             const rejected = result.votes.length - approved;
+            if (sessionId) {
+                recordExecutionSlice('gate', { projectRoot, sessionId });
+            }
             return {
                 content: [{
                         type: 'text',
                         text: JSON.stringify({
                             cycleId: result.cycleId,
                             asideId: aside.asideId,
+                            synthesisBridged: Boolean(sessionId),
                             approved,
                             rejected,
                             votes: result.votes,

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

@@ -95,6 +95,13 @@ export interface MemoryRoutingProvider {
     resolveThinDispatch(baseAgent: string, operation: string, complexityScore: number): MemoryThinDispatchResult;
     getTaskConfidence?(task: MemoryOrchestrationTask): MemoryTaskConfidence;
     ingestFeedback?(entry: OrchestratorFeedbackEntry): void;
+    buildSynthesisContext?(opts: {
+        projectRoot: string;
+        dueReason?: string | null;
+    }): Record<string, unknown> | null;
+    refreshMetaInference?(): Promise<{
+        refreshed: boolean;
+    }>;
 }
 export interface MemoryRoutingConfig {
     enabled: boolean;

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

@@ -3,6 +3,7 @@
  * Config: features.json → multi_agent_orchestration (lead_dev_mode), NOT a separate surface.
  */
 export declare const LEAD_DEV_RULES: readonly ["Phased plan + detailed todos; assign best subagent; monitor output; iterate fully", "Lead dev takes helm — loop test fix until complete; no permission pings", "Per-suite test triage after major changes; full suite only when individuals pass", "Lead stays main thread; subagents execute; update todos continuously", "Read all console and test output; triage fix rerun", "Never defer errors as pre-existing — add todo and resolve", "Resolve all errors before phase completion"];
+export declare const SYNTHESIS_REALIGNMENT_PHASE_ID = "phase-synthesis";
 export declare const MANDATORY_MAJOR_CONSULTS: readonly ["researcher", "architect-tools", "code-review"];
 export type SubagentRoute = 'strategist' | 'architect-tools' | 'researcher' | 'backend-engineer' | 'frontend-engineer' | 'bug-triage' | 'code-review' | 'security-audit' | 'enforcer';
 export interface LeadDevTodo {
@@ -41,6 +42,8 @@ export interface LeadDevPlan {
 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 buildSessionBootContext(): Record<string, unknown>;
 /** Persist plan for PreToolUse spawn_subagent gate */

package/dist/nucleus/autonomy-kernel.js

@@ -15,6 +15,7 @@ export const LEAD_DEV_RULES = [
     'Never defer errors as pre-existing — add todo and resolve',
     'Resolve all errors before phase completion',
 ];
+export const SYNTHESIS_REALIGNMENT_PHASE_ID = 'phase-synthesis';
 export const MANDATORY_MAJOR_CONSULTS = [
     'researcher',
     'architect-tools',
@@ -73,6 +74,45 @@ function buildImplementationTodos(description, taskTypes, taskInputs, idPrefix)
         status: 'pending',
     }));
 }
+/** Mandatory-consult plan for synthesis checkpoint realignment (no implementation phase). */
+export function buildSynthesisCheckpointPlan(dueReason) {
+    if (!isLeadDevModeActive())
+        return null;
+    const cfg = orchestrationConfig();
+    const mandatoryConsults = cfg.auto_consult_major_work !== false ? [...MANDATORY_MAJOR_CONSULTS] : [];
+    if (mandatoryConsults.length === 0)
+        return null;
+    const reasonSuffix = dueReason ? ` (${dueReason})` : '';
+    return {
+        active: true,
+        rules: LEAD_DEV_RULES,
+        codexTerms: [59, 67, 68, 69],
+        description: `Synthesis checkpoint: reflect and realign${reasonSuffix}`,
+        complexity: 30,
+        requiresPhasedPlan: true,
+        recommendedStrategy: 'sequential',
+        mandatoryConsults,
+        phases: [
+            {
+                id: SYNTHESIS_REALIGNMENT_PHASE_ID,
+                name: 'Reflect & realign',
+                goal: 'Review collocated context and mandatory consults before resuming execution',
+                definitionOfDone: 'researcher + architect-tools + code-review consulted; todos realigned',
+                todos: mandatoryConsults.map((subagent, i) => ({
+                    id: `s.${i + 1}`,
+                    task: `Synthesis consult ${subagent}: review checkpoint context and realign plan`,
+                    subagent: subagent,
+                    status: 'pending',
+                })),
+            },
+        ],
+        testProtocol: {
+            perSuiteFirst: cfg.per_suite_test_triage !== false,
+            fullSuiteGate: false,
+            hint: 'Synthesis checkpoint — consult mandatory agents before resuming gated work',
+        },
+    };
+}
 export function buildLeadDevPlan(description, taskTypes = ['implement'], taskInputs = [], mcpOverallComplexity) {
     if (!isLeadDevModeActive())
         return null;

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

@@ -1,7 +1,7 @@
 /**
  * Multi-host delegation gate SSOT — pending-delegations + spawn todo enforcement.
- * Grok / Hermes / OpenCode adapters call evaluatePreToolGate; Grok-only logic was
- * previously duplicated in grok-hook-utils.js.
+ * 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.
  */
 import { type PendingDelegation } from './pending-delegations.js';
 export { getActivePendingDelegations } from './pending-delegations.js';
@@ -68,11 +68,13 @@ export declare function isWriteTool(toolName: string, host?: DelegationGateHost)
 export declare function isReadOnlyTool(toolName: string): boolean;
 /** Spawn plan missing — applies before auto_chain opt-out for subagent tools. */
 export declare function evaluateSpawnPlanGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
+/** Block writes / spawns / shell while synthesis checkpoint is due. */
+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 — same order as Grok PreToolUse:
- * pending gate first, then spawn todo gate for subagent tools.
+ * Full pre-tool evaluation — synthesis gate first, slice recording, then
+ * pending gate, then spawn todo gate for subagent tools.
  */
 export declare function evaluatePreToolGate(toolName: string, toolInput: ToolGateInput, ctx: PreToolGateContext): PreToolGateResult;
 export declare function evaluatePostToolSpawn(toolName: string, toolInput: ToolGateInput, projectRoot: string): PostToolSpawnResult;

package/dist/nucleus/delegation-gate.js

@@ -1,13 +1,14 @@
 /**
  * Multi-host delegation gate SSOT — pending-delegations + spawn todo enforcement.
- * Grok / Hermes / OpenCode adapters call evaluatePreToolGate; Grok-only logic was
- * previously duplicated in grok-hook-utils.js.
+ * 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.
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import { getActivePendingDelegations, satisfyDelegation, } from './pending-delegations.js';
 export { getActivePendingDelegations } from './pending-delegations.js';
-import { allPlanTodos, hasValidLeadDevPlanForSpawn, loadPersistedLeadDevPlan, validateSpawnMatchesTodo, updatePlanTodoStatus, } from './lead-dev-plan-persistence.js';
+import { allPlanTodos, areSynthesisConsultTodosComplete, hasValidLeadDevPlanForSpawn, isSynthesisRealignmentPlan, loadPersistedLeadDevPlan, getNextRequiredTodo, validateSpawnMatchesTodo, updatePlanTodoStatus, } from './lead-dev-plan-persistence.js';
+import { getSynthesisDueReason, isSynthesisCheckpointDue, recordExecutionSlice, } from './synthesis.js';
 export { validateSpawnMatchesTodo, updatePlanTodoStatus, savePersistedLeadDevPlan, } from './lead-dev-plan-persistence.js';
 export const updatePlanTodoStatusInPlace = updatePlanTodoStatus;
 const READ_TOOLS = new Set([
@@ -30,11 +31,20 @@ const SUBAGENT_TOOLS = new Set(['spawn_subagent', 'task', 'Task', 'delegate_task
 const ORCHESTRATOR_CONSULT_TOOLS = new Set([
     'analyze-complexity',
     'analyze_complexity',
+    'govern-and-apply',
+    'govern_and_apply',
     'get-orchestration-status',
     'get_orchestration_status',
     'orchestrate-task',
     'orchestrate_task',
 ]);
+/** Allowed orchestrator MCP tools while synthesis checkpoint is due (govern-and-apply excluded). */
+const SYNTHESIS_ALLOWED_CONSULT_TOOLS = new Set([
+    'analyze-complexity',
+    'analyze_complexity',
+    'get-orchestration-status',
+    'get_orchestration_status',
+]);
 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()) {
@@ -122,6 +132,18 @@ function isOrchestratorConsultMcp(toolName, toolInput) {
     }
     return false;
 }
+function isSynthesisAllowedOrchestratorConsult(toolName, toolInput) {
+    if (!/mcp|CallMcpTool/i.test(toolName))
+        return false;
+    const inner = extractMcpToolName(toolInput).toLowerCase();
+    if (!inner)
+        return false;
+    for (const t of SYNTHESIS_ALLOWED_CONSULT_TOOLS) {
+        if (inner.includes(t) || inner.includes(t.replace(/-/g, '_')))
+            return true;
+    }
+    return false;
+}
 function isFocusedTestCommand(cmd) {
     const cmdText = (cmd || '').toLowerCase();
     return (/\b(npm\s+(run\s+)?test|vitest\s+run|pnpm\s+test|yarn\s+test)\b/.test(cmdText) &&
@@ -180,6 +202,44 @@ export function evaluateSpawnPlanGate(toolName, toolInput, ctx) {
     }
     return { allow: true };
 }
+/** Block writes / spawns / shell while synthesis checkpoint is due. */
+export function evaluateSynthesisGate(toolName, toolInput, ctx) {
+    if (!ctx.sessionId || !isSynthesisCheckpointDue(ctx.projectRoot, ctx.sessionId)) {
+        return { allow: true };
+    }
+    if (isReadOnlyTool(toolName))
+        return { allow: true };
+    if (isSynthesisAllowedOrchestratorConsult(toolName, toolInput))
+        return { allow: true };
+    const plan = loadPersistedLeadDevPlan(ctx.projectRoot);
+    if (plan &&
+        isSynthesisRealignmentPlan(plan) &&
+        !areSynthesisConsultTodosComplete(plan) &&
+        isSubagentTool(toolName)) {
+        const nextTodo = getNextRequiredTodo(plan);
+        const validation = validateSpawnMatchesTodo(normalizeHostToolInput(toolInput), ctx.projectRoot, nextTodo);
+        if (validation.valid)
+            return { allow: true };
+    }
+    const dueReason = getSynthesisDueReason(ctx.projectRoot, ctx.sessionId);
+    const realignmentPending = plan && isSynthesisRealignmentPlan(plan) && !areSynthesisConsultTodosComplete(plan);
+    return {
+        allow: false,
+        reason: realignmentPending
+            ? 'Synthesis realignment in progress — complete mandatory consult todos (s.1–s.3) before other work'
+            : 'Synthesis checkpoint due — call xray-orchestrator analyze-complexity to reflect and realign before continuing',
+        gate: 'synthesis-checkpoint',
+        hint: {
+            tool: realignmentPending ? 'Task' : 'analyze-complexity',
+            dueReason,
+            primitive: 'synthesis',
+            sessionId: ctx.sessionId,
+            ...(realignmentPending && plan
+                ? { nextTodoId: getNextRequiredTodo(plan)?.id }
+                : {}),
+        },
+    };
+}
 /** Block writes / unrelated work while pending delegations exist. */
 export function evaluatePendingDelegationGate(toolName, toolInput, ctx) {
     if (!ctx.features.lead_dev_mode || ctx.features.auto_chain_delegations === false) {
@@ -204,10 +264,19 @@ export function evaluatePendingDelegationGate(toolName, toolInput, ctx) {
     return denyFromPending(pending[0], pending.length);
 }
 /**
- * Full pre-tool evaluation — same order as Grok PreToolUse:
- * pending gate first, then spawn todo gate for subagent tools.
+ * Full pre-tool evaluation — synthesis gate first, slice recording, then
+ * pending gate, then spawn todo gate for subagent tools.
  */
 export function evaluatePreToolGate(toolName, toolInput, ctx) {
+    const synthesisBlock = evaluateSynthesisGate(toolName, toolInput, ctx);
+    if (!synthesisBlock.allow)
+        return synthesisBlock;
+    if (!isSynthesisCheckpointDue(ctx.projectRoot, ctx.sessionId)) {
+        recordExecutionSlice('gate', {
+            projectRoot: ctx.projectRoot,
+            sessionId: ctx.sessionId,
+        });
+    }
     const pendingBlock = evaluatePendingDelegationGate(toolName, toolInput, ctx);
     if (!pendingBlock.allow)
         return pendingBlock;
@@ -230,6 +299,9 @@ export function evaluatePostToolSpawn(toolName, toolInput, projectRoot) {
     if (normalized.planTodoId)
         satisfyInput.planTodoId = normalized.planTodoId;
     const result = satisfyDelegation(satisfyInput, projectRoot);
+    if (spawnCheck.valid && spawnCheck.expectedTodoId) {
+        updatePlanTodoStatus(spawnCheck.expectedTodoId, 'completed', projectRoot);
+    }
     return {
         ...result,
         expectedTodoId: spawnCheck.expectedTodoId ?? null,

package/dist/nucleus/lead-dev-plan-persistence.d.ts

@@ -28,6 +28,9 @@ export declare function getNextRequiredTodo(plan: PersistedLeadDevPlan): LeadDev
  * - all todos complete and persistedAt within TTL
  */
 export declare function hasValidLeadDevPlanForSpawn(projectRoot?: string, _sessionId?: string | null): boolean;
+export declare function isSynthesisRealignmentPlan(plan: PersistedLeadDevPlan): boolean;
+export declare function getSynthesisConsultTodos(plan: PersistedLeadDevPlan): LeadDevTodo[];
+export declare function areSynthesisConsultTodosComplete(plan: PersistedLeadDevPlan): boolean;
 export declare function updatePlanTodoStatus(todoId: string, status: LeadDevTodo['status'], projectRoot?: string): boolean;
 export declare function bindPlanToSession(sessionId: string, projectRoot?: string): PersistedLeadDevPlan | null;
 export interface SpawnToolInput {

package/dist/nucleus/lead-dev-plan-persistence.js

@@ -4,7 +4,9 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { SYNTHESIS_REALIGNMENT_PHASE_ID } from './autonomy-kernel.js';
 import { DEFAULT_PENDING_TTL_MS } from './pending-delegations.js';
+import { completeSynthesisCheckpoint, getSynthesisCheckpointSessionId, isSynthesisCheckpointDue, recordExecutionSlice, } from './synthesis.js';
 export function leadDevPlanStatePath(projectRoot = process.cwd()) {
     return path.join(projectRoot, '.xray', 'state', 'lead-dev-plan.json');
 }
@@ -64,6 +66,37 @@ export function hasValidLeadDevPlanForSpawn(projectRoot = process.cwd(), _sessio
     }
     return Date.now() - new Date(persistedAt).getTime() <= DEFAULT_PENDING_TTL_MS;
 }
+export function isSynthesisRealignmentPlan(plan) {
+    return (plan.phases ?? []).some((p) => p.id === SYNTHESIS_REALIGNMENT_PHASE_ID);
+}
+export function getSynthesisConsultTodos(plan) {
+    const phase = (plan.phases ?? []).find((p) => p.id === SYNTHESIS_REALIGNMENT_PHASE_ID);
+    return phase?.todos ?? [];
+}
+export function areSynthesisConsultTodosComplete(plan) {
+    const todos = getSynthesisConsultTodos(plan);
+    return todos.length > 0 && todos.every((t) => t.status === 'completed');
+}
+function shouldRecordGeneralTodoSlice(plan, todoId) {
+    if (!isSynthesisRealignmentPlan(plan))
+        return true;
+    const consultIds = new Set(getSynthesisConsultTodos(plan).map((t) => t.id));
+    return !consultIds.has(todoId);
+}
+function tryCompleteSynthesisCheckpointAfterTodo(projectRoot, sessionId) {
+    const sid = sessionId ?? getSynthesisCheckpointSessionId(projectRoot);
+    if (!sid || !isSynthesisCheckpointDue(projectRoot, sid))
+        return;
+    const plan = loadPersistedLeadDevPlan(projectRoot);
+    if (!plan || !isSynthesisRealignmentPlan(plan))
+        return;
+    if (!areSynthesisConsultTodosComplete(plan))
+        return;
+    const completed = completeSynthesisCheckpoint(projectRoot, sid);
+    if (completed) {
+        void import('./synthesis-completion.js').then(({ runSynthesisCheckpointSideEffects }) => runSynthesisCheckpointSideEffects(projectRoot, sid, plan, completed));
+    }
+}
 export function updatePlanTodoStatus(todoId, status, projectRoot = process.cwd()) {
     const plan = loadPersistedLeadDevPlan(projectRoot);
     if (!plan)
@@ -77,8 +110,18 @@ export function updatePlanTodoStatus(todoId, status, projectRoot = process.cwd()
             }
         }
     }
-    if (updated)
+    if (updated) {
         savePersistedLeadDevPlan(plan, projectRoot);
+        if (status === 'completed') {
+            if (shouldRecordGeneralTodoSlice(plan, todoId)) {
+                const sid = plan.sessionId ?? getSynthesisCheckpointSessionId(projectRoot);
+                if (sid) {
+                    recordExecutionSlice('todo_completed', { projectRoot, sessionId: sid });
+                }
+            }
+            tryCompleteSynthesisCheckpointAfterTodo(projectRoot, plan.sessionId);
+        }
+    }
     return updated;
 }
 export function bindPlanToSession(sessionId, projectRoot = process.cwd()) {