0xray 3.5.0 → 3.5.2

package/dist/integrations/hermes-agent/bridge.mjs

@@ -39,6 +39,7 @@ import {
 import { join, dirname, relative } from "path";
 import { fileURLToPath } from "url";
 import { homedir } from "os";
+import { findProjectRoot } from "../../../scripts/helpers/find-project-root.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -52,40 +53,19 @@ let frameworkReady = false;
 let frameworkLoadAttempted = false;
 
 // ── Project root detection ───────────────────────────────────
-function findProjectRoot() {
-  const envHome = process.env.XRAY_HOME || process.env.XRAY_ROOT;
-  if (envHome && existsSync(join(envHome, "package.json"))) return envHome;
-
+function resolveBridgeProjectRoot() {
   const consumerMarker = join(__dirname, "xray-consumer-root.txt");
   if (existsSync(consumerMarker)) {
     try {
       const marked = readFileSync(consumerMarker, "utf-8").trim();
-      if (marked && existsSync(join(marked, "package.json"))) return marked;
-    } catch {
-      // fall through
-    }
-  }
-
-  const candidates = [
-    process.cwd(),
-    join(homedir(), "dev", "xray"),
-    join(dirname(__dirname), "..", "..", "..", ".."), // plugin dir -> project root
-  ];
-
-  for (const dir of candidates) {
-    try {
-      const pkgPath = join(dir, "package.json");
-      if (existsSync(pkgPath)) {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (pkg.name === "0xray" || pkg.dependencies?.["0xray"] || pkg.name === "0xray" || pkg.dependencies?.["0xray"]) {
-          return dir;
-        }
+      if (marked && existsSync(join(marked, "package.json"))) {
+        return marked;
       }
     } catch {
-      continue;
+      // fall through to shared SSOT
     }
   }
-  return process.cwd();
+  return findProjectRoot([join(dirname(__dirname), "..", "..", "..", "..")]);
 }
 
 // ── Log directory ────────────────────────────────────────────
@@ -381,7 +361,7 @@ async function runProcessors(tool, args, phase, projectRoot, logDir) {
 // ── Command handlers ─────────────────────────────────────────
 
 async function handleHealth(input) {
-  const projectRoot = findProjectRoot();
+  const projectRoot = resolveBridgeProjectRoot();
   const loaded = await loadFramework(projectRoot);
 
   const components = {
@@ -738,7 +718,7 @@ function handleStats() {
     qualityGateAvailable: !!runQualityGateWithLogging,
     processorsAvailable: !!ProcessorManager,
     nodeVersion: process.version,
-    projectRoot: findProjectRoot(),
+    projectRoot: resolveBridgeProjectRoot(),
   };
 }
 
@@ -786,9 +766,67 @@ async function handleApply(input, projectRoot, logDir) {
 // ── Known commands for positional-arg mode ──────────────────
 const KNOWN_COMMANDS = new Set([
   "health", "stats", "pre-process", "post-process", "validate", "codex-check", "hooks", "govern", "apply",
-  "skill-install", "skill-registry",
+  "skill-install", "skill-registry", "delegation-gate",
 ]);
 
+async function recordHermesSynthesisTurn(projectRoot, sessionId) {
+  if (!sessionId) return;
+  try {
+    const { recordSynthesisTurnSlice } = await import("../hooks/synthesis-hook-runtime.mjs");
+    recordSynthesisTurnSlice(projectRoot, sessionId);
+  } catch {
+    /* optional */
+  }
+}
+
+async function handleDelegationGate(command, projectRoot, logDir) {
+  try {
+    const gate = await import("../hooks/delegation-gate-runtime.mjs");
+    const phase = command.phase || "pre";
+    const tool = command.tool || command.toolName || "unknown";
+    const args = command.args || command.toolInput || {};
+    const sessionId = command.sessionId || command.taskId || null;
+    const host = command.host || "hermes";
+
+    if (phase === "post") {
+      if (!gate.isSubagentTool(tool)) {
+        return { allow: true, phase: "post", skipped: true };
+      }
+      const result = gate.evaluatePostToolSpawn(tool, args, projectRoot);
+      if (result.satisfied.length > 0) {
+        logToActivity(
+          logDir,
+          `[delegation-gate-post] satisfied=${result.satisfied.map((d) => d.id).join(",")} clearedAll=${result.clearedAll}`,
+        );
+      }
+      return { allow: true, phase: "post", ...result };
+    }
+
+    if (command.recordTurn === true || command.event === 'user_prompt_submit') {
+      await recordHermesSynthesisTurn(projectRoot, sessionId);
+    }
+
+    const features = gate.loadDelegationGateFeatures(projectRoot);
+    const outcome = gate.evaluatePreToolGate(tool, args, {
+      projectRoot,
+      sessionId,
+      features,
+      host,
+    });
+
+    if (!outcome.allow) {
+      logToActivity(
+        logDir,
+        `[delegation-gate] deny tool=${tool} gate=${outcome.gate} reason=${outcome.reason}`,
+      );
+    }
+
+    return { phase: "pre", ...outcome };
+  } catch (error) {
+    return { error: `delegation-gate failed: ${error.message || error}` };
+  }
+}
+
 // ── Skill management ──────────────────────────────────────────
 
 async function handleSkillInstall(command, projectRoot, logDir) {
@@ -869,7 +907,7 @@ async function main() {
     }
   }
 
-  const projectRoot = findProjectRoot();
+  const projectRoot = resolveBridgeProjectRoot();
   const logDir = ensureLogDir(projectRoot);
 
   // Log session start for test verification
@@ -918,6 +956,9 @@ async function main() {
     case "skill-registry":
       response = await handleSkillRegistry(command, projectRoot, logDir);
       break;
+    case "delegation-gate":
+      response = await handleDelegationGate(command, projectRoot, logDir);
+      break;
     default:
       response = { error: `Unknown command: ${cmd}` };
   }

package/dist/integrations/hooks/delegation-gate-runtime.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+/**
+ * Load compiled delegation-gate SSOT from consumer or package dist.
+ * Used by Grok hooks, Hermes bridge, and verify fixtures.
+ */
+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));
+
+/** 0xray package root — never use consumer workspace env (GROK_WORKSPACE_ROOT / XRAY_ROOT). */
+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'));
+        const name = require('./package.json').name;
+        if (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 loadDelegationGate() {
+  const root = resolvePackageRoot();
+  const candidates = [
+    join(__dirname, '../../nucleus/delegation-gate.js'),
+    join(root, 'dist/nucleus/delegation-gate.js'),
+    join(process.cwd(), 'node_modules/0xray/dist/nucleus/delegation-gate.js'),
+  ];
+  const found = candidates.find((p) => existsSync(p));
+  if (!found) {
+    throw new Error(
+      'delegation-gate.js missing — run npm run build in 0xray or npm install 0xray@^3.5.1',
+    );
+  }
+  return createRequire(import.meta.url)(found);
+}
+
+const gate = loadDelegationGate();
+
+export const {
+  loadDelegationGateFeatures,
+  normalizeHostToolInput,
+  evaluatePreToolGate,
+  evaluatePendingDelegationGate,
+  evaluateSpawnPlanGate,
+  evaluatePostToolSpawn,
+  checkPendingDelegationGate,
+  checkSubagentGate,
+  satisfyDelegationsFromToolInput,
+  isSubagentTool,
+  isOrchestrateToolEvent,
+  isReadOnlyTool,
+  isWriteTool,
+  isShellTool,
+  getActivePendingDelegations,
+  validateSpawnMatchesTodo,
+  updatePlanTodoStatus,
+  updatePlanTodoStatusInPlace,
+} = gate;

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;