0xray 3.4.1 → 3.4.3

package/dist/monitoring/advanced-profiler.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter } from "events";
+interface ProfileData {
+    agentName: string;
+    operation: string;
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    memoryUsage: {
+        before: NodeJS.MemoryUsage;
+        after?: NodeJS.MemoryUsage;
+    };
+    success: boolean;
+    error?: string;
+    metadata: Record<string, any>;
+}
+interface ProfilingMetrics {
+    totalOperations: number;
+    successfulOperations: number;
+    failedOperations: number;
+    averageDuration: number;
+    memoryDelta: number;
+    slowestOperation: string;
+    fastestOperation: string;
+}
+export declare class AdvancedProfiler extends EventEmitter {
+    private profiles;
+    private activeProfiles;
+    private profilingEnabled;
+    private profileStoragePath;
+    private reportTimer?;
+    private cleanupTimer?;
+    private isRunning;
+    constructor(storagePath?: string | undefined);
+    start(): void;
+    stop(): void;
+    private ensureStorageDirectory;
+    startProfiling(operationId: string, agentName: string, operation: string, metadata?: Record<string, any>): void;
+    endProfiling(operationId: string, success?: boolean, error?: string): void;
+    private detectAnomalies;
+    private calculateMemoryDelta;
+    getMetrics(agentName?: string): ProfilingMetrics;
+    private generatePerformanceReport;
+    private generateRecommendations;
+    private cleanupOldProfiles;
+    enableProfiling(): void;
+    disableProfiling(): void;
+    clearProfiles(): void;
+    exportProfiles(): Record<string, ProfileData[]>;
+}
+export declare const advancedProfiler: AdvancedProfiler;
+export {};

package/dist/monitoring/memory-monitor.d.ts

@@ -0,0 +1,113 @@
+import { EventEmitter } from "events";
+export interface MemoryStats {
+    heapUsed: number;
+    heapTotal: number;
+    external: number;
+    rss: number;
+    timestamp: number;
+    sessionId?: string;
+}
+export interface MemoryLeakAlert {
+    type: "leak_detected" | "high_usage" | "spike_detected";
+    severity: "low" | "medium" | "high" | "critical";
+    message: string;
+    details: {
+        currentUsage: number;
+        threshold: number;
+        trend: "increasing" | "stable" | "decreasing";
+        recommendations: string[];
+    };
+}
+export interface MemoryMonitorConfig {
+    checkInterval: number;
+    alertThresholds: {
+        warning: number;
+        critical: number;
+        leakDetection: {
+            growthRate: number;
+            sustainedPeriod: number;
+        };
+    };
+    enableFrameworkLogging: boolean;
+    sessionTracking: boolean;
+}
+export interface MemorySummary {
+    current: MemoryStats;
+    peak: MemoryStats;
+    average: number;
+    trend: "increasing" | "stable" | "decreasing";
+}
+export declare class MemoryMonitor extends EventEmitter {
+    private config;
+    private monitoringInterval;
+    private statsHistory;
+    private maxHistorySize;
+    private leakDetectionEnabled;
+    private lastLeakCheck;
+    private leakCheckInterval;
+    private listenersInitialized;
+    constructor(config?: Partial<MemoryMonitorConfig>);
+    /**
+     * Start memory monitoring
+     */
+    start(): void;
+    /**
+     * Stop memory monitoring
+     */
+    stop(): void;
+    /**
+     * Get current memory statistics
+     */
+    getCurrentStats(): MemoryStats;
+    /**
+     * Check memory usage and detect issues
+     */
+    private checkMemory;
+    /**
+     * Check memory usage against thresholds
+     */
+    private checkThresholds;
+    /**
+     * Detect potential memory leaks
+     */
+    private detectMemoryLeaks;
+    /**
+     * Calculate memory usage trend
+     */
+    private calculateTrend;
+    /**
+     * Emit memory alert
+     */
+    private emitAlert;
+    /**
+     * Log memory stats to framework log
+     */
+    private logFrameworkMemory;
+    /**
+     * Get memory usage history
+     */
+    getHistory(hours?: number): MemoryStats[];
+    /**
+     * Get memory usage summary
+     */
+    getSummary(): MemorySummary;
+    /**
+     * Force garbage collection (if available)
+     */
+    forceGC(): boolean;
+    /**
+     * Internal logging method - writes to framework log only
+     */
+    private log;
+    /**
+     * Safely add an alert listener, preventing duplicates
+     */
+    addAlertListener(callback: (alert: MemoryLeakAlert) => void): void;
+}
+export declare const memoryMonitor: MemoryMonitor;
+export declare function getMemoryUsage(): MemoryStats;
+export declare function logMemoryUsage(): MemoryStats;
+export declare function checkMemoryHealth(): {
+    healthy: boolean;
+    issues: string[];
+};

package/dist/monitoring/nudge-watchdog.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Nudge Watchdog - Detects and breaks stuck AI patterns
+ *
+ * Monitors agent actions and detects common failure patterns:
+ * - think-loop: AI keeps outputting thinking tags but no progress
+ * - syntax-loop: AI keeps trying to fix same file/error multiple times
+ * - death-spiral: AI re-explains instead of fixing
+ * - tool-loop: Same tool called with similar args repeatedly
+ * - repair-failure: Processor indicates fix but error persists
+ *
+ * @module monitoring/nudge-watchdog
+ */
+import { EventEmitter } from "events";
+export interface NudgeConfig {
+    enabled: boolean;
+    think_loop_threshold: number;
+    syntax_loop_threshold: number;
+    tool_loop_threshold: number;
+    death_spiral_threshold: number;
+    cooldown_ms: number;
+}
+export type NudgeType = "think-loop" | "syntax-loop" | "death-spiral" | "tool-loop" | "repair-failure";
+export interface StuckPattern {
+    type: NudgeType;
+    count: number;
+    firstSeen: number;
+    lastSeen: number;
+    details: Record<string, unknown>;
+}
+export interface NudgeAction {
+    type: NudgeType;
+    message: string;
+    suggestion: string;
+    priority: number;
+}
+declare class NudgeWatchdog extends EventEmitter {
+    private config;
+    private patterns;
+    private lastNudgeTime;
+    private thinkTagCount;
+    private lastThinkTagTime;
+    private toolCallHistory;
+    private fixAttempts;
+    private explanationCount;
+    private codeChangeCount;
+    private listenersInitialized;
+    constructor(config?: Partial<NudgeConfig>);
+    private loadConfigFromFeatures;
+    start(): void;
+    stop(): void;
+    recordThinkTag(): void;
+    recordCodeChange(): void;
+    recordToolCall(tool: string, args: string): void;
+    recordFixAttempt(filePath: string, error: string): void;
+    recordExplanation(): void;
+    recordProcessorFix(filePath: string, fixed: boolean, errorPersisted: boolean): void;
+    private checkThinkLoop;
+    private checkToolLoop;
+    private checkSyntaxLoop;
+    private checkDeathSpiral;
+    private checkRepairFailure;
+    private checkCooldownAndNudge;
+    private triggerNudge;
+    getNudgeSuggestion(type: NudgeType, context?: Record<string, unknown>): string;
+    private hashArgs;
+    private isSimilarError;
+    private cleanupOldToolCalls;
+    reset(): void;
+    getStats(): {
+        thinkTags: number;
+        codeChanges: number;
+        explanations: number;
+        activePatterns: number;
+        lastNudgeAgo: number;
+    };
+    private log;
+}
+export declare const nudgeWatchdog: NudgeWatchdog;
+export declare function recordThinkTag(): void;
+export declare function recordCodeChange(): void;
+export declare function recordToolCall(tool: string, args: string): void;
+export declare function recordFixAttempt(filePath: string, error: string): void;
+export declare function recordExplanation(): void;
+export declare function getNudgeSuggestion(type: NudgeType, context?: Record<string, unknown>): string;
+export declare function getNudgeWatchdog(): NudgeWatchdog;
+export declare function recordProcessorFix(filePath: string, fixed: boolean, errorPersisted: boolean): void;
+export {};

package/dist/monitoring/test-auto-generation-monitor.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Test Auto-Generation Monitor
+ *
+ * Tracks and reports on test auto-generation activity.
+ * Provides metrics on test creation success/failure rates.
+ *
+ * @since 2026-02-22
+ */
+export interface TestGenerationMetrics {
+    totalFilesProcessed: number;
+    testsGenerated: number;
+    testsSkipped: number;
+    testsFailed: number;
+    startTime: number;
+    lastGenerationTime: number | null;
+}
+export interface TestGenerationEvent {
+    type: "generated" | "skipped" | "failed";
+    filePath: string;
+    testFile: string | null;
+    timestamp: number;
+    reason?: string;
+}
+declare class TestAutoGenerationMonitor {
+    private metrics;
+    private events;
+    private maxEvents;
+    private metricsFile;
+    constructor(metricsDir?: string);
+    /**
+     * Load metrics from disk if they exist
+     */
+    private loadMetrics;
+    /**
+     * Save metrics to disk
+     */
+    private saveMetrics;
+    /**
+     * Record a test generation event
+     */
+    recordEvent(event: TestGenerationEvent): void;
+    /**
+     * Get current metrics
+     */
+    getMetrics(): TestGenerationMetrics;
+    /**
+     * Get recent events
+     */
+    getRecentEvents(count?: number): TestGenerationEvent[];
+    /**
+     * Get success rate as percentage
+     */
+    getSuccessRate(): number;
+    /**
+     * Generate a status report
+     */
+    generateReport(): string;
+    /**
+     * Reset metrics (for testing)
+     */
+    reset(): void;
+}
+export declare const testAutoGenerationMonitor: TestAutoGenerationMonitor;
+export {};

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

@@ -0,0 +1,48 @@
+/**
+ * Lead-dev plan builder — internal implementation for orchestrator + hooks.
+ * 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 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 {
+    id: string;
+    task: string;
+    subagent: SubagentRoute;
+    status: 'pending' | 'in_progress' | 'completed';
+}
+export interface LeadDevPhase {
+    id: string;
+    name: string;
+    goal: string;
+    definitionOfDone: string;
+    todos: LeadDevTodo[];
+}
+export interface LeadDevPlan {
+    active: boolean;
+    rules: readonly string[];
+    codexTerms: [59, 67, 68, 69];
+    description: string;
+    complexity: number;
+    requiresPhasedPlan: boolean;
+    recommendedStrategy: string;
+    mandatoryConsults: string[];
+    phases: LeadDevPhase[];
+    testProtocol: {
+        perSuiteFirst: boolean;
+        fullSuiteGate: boolean;
+        hint: string;
+    };
+}
+export declare function isLeadDevModeActive(): boolean;
+export declare function routeSubagent(taskType: string): SubagentRoute;
+export declare function shouldFlagFullTestSuite(command: string): boolean;
+export declare function buildLeadDevPlan(description: string, taskTypes?: string[]): LeadDevPlan | null;
+export declare function buildSessionBootContext(): Record<string, unknown>;
+/** Persist plan for PreToolUse spawn_subagent gate */
+export declare function persistLeadDevPlan(plan: LeadDevPlan, projectRoot?: string): string;
+/** @deprecated Use isLeadDevModeActive */
+export declare const isAutonomyKernelActive: typeof isLeadDevModeActive;
+/** @deprecated Use buildLeadDevPlan */
+export declare const buildAutonomyIntake: typeof buildLeadDevPlan;
+export declare const AUTONOMY_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"];

package/dist/nucleus/autonomy-kernel.js

@@ -0,0 +1,176 @@
+/**
+ * Lead-dev plan builder — internal implementation for orchestrator + hooks.
+ * Config: features.json → multi_agent_orchestration (lead_dev_mode), NOT a separate surface.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { featuresConfigLoader } from '../core/features-config.js';
+import { scoreComplexity } from './thin-dispatch.js';
+export const LEAD_DEV_RULES = [
+    'Phased plan + detailed todos; assign best subagent; monitor output; iterate fully',
+    'Lead dev takes helm — loop test fix until complete; no permission pings',
+    '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 const MANDATORY_MAJOR_CONSULTS = [
+    'researcher',
+    'architect-tools',
+    'code-review',
+];
+const TASK_TYPE_ROUTES = {
+    plan: 'strategist',
+    architecture: 'architect-tools',
+    research: 'researcher',
+    implement: 'backend-engineer',
+    frontend: 'frontend-engineer',
+    test: 'bug-triage',
+    review: 'code-review',
+    security: 'security-audit',
+    governance: 'enforcer',
+};
+function orchestrationConfig() {
+    try {
+        return featuresConfigLoader.loadConfig().multi_agent_orchestration;
+    }
+    catch {
+        return { enabled: true };
+    }
+}
+export function isLeadDevModeActive() {
+    const cfg = orchestrationConfig();
+    return cfg.enabled && cfg.lead_dev_mode !== false;
+}
+export function routeSubagent(taskType) {
+    return TASK_TYPE_ROUTES[taskType.toLowerCase().trim()] ?? 'backend-engineer';
+}
+export function shouldFlagFullTestSuite(command) {
+    const cfg = orchestrationConfig();
+    if (!cfg.enabled || cfg.per_suite_test_triage === false)
+        return false;
+    const cmd = command.toLowerCase();
+    const isTest = /\b(npm\s+(run\s+)?test|vitest\s+run|pnpm\s+test|yarn\s+test)\b/.test(cmd);
+    const hasFocusedTarget = /--\s+\S+\.test/.test(cmd) ||
+        /vitest\s+run\s+\S+\.test/.test(cmd) ||
+        /\btest:\w+/.test(cmd);
+    return isTest && !hasFocusedTarget;
+}
+export function buildLeadDevPlan(description, taskTypes = ['implement']) {
+    if (!isLeadDevModeActive())
+        return null;
+    const cfg = orchestrationConfig();
+    const threshold = cfg.phased_plan_threshold ?? 25;
+    const score = scoreComplexity(description, { taskTypes });
+    const complexity = score.score;
+    const requiresPhasedPlan = complexity > threshold;
+    const mandatoryConsults = cfg.auto_consult_major_work !== false && requiresPhasedPlan
+        ? [...MANDATORY_MAJOR_CONSULTS]
+        : [];
+    const phases = requiresPhasedPlan
+        ? [
+            {
+                id: 'phase-1',
+                name: 'Research & architecture',
+                goal: 'Understand scope before edits',
+                definitionOfDone: 'researcher + architect-tools + code-review consulted',
+                todos: mandatoryConsults.map((subagent, i) => ({
+                    id: `1.${i + 1}`,
+                    task: `Consult ${subagent} on: ${description.slice(0, 120)}`,
+                    subagent: subagent,
+                    status: 'pending',
+                })),
+            },
+            {
+                id: 'phase-2',
+                name: 'Implementation',
+                goal: 'Execute with best subagent per todo',
+                definitionOfDone: 'Affected per-suite tests green',
+                todos: taskTypes.map((type, i) => ({
+                    id: `2.${i + 1}`,
+                    task: description.slice(0, 200),
+                    subagent: routeSubagent(type),
+                    status: 'pending',
+                })),
+            },
+            {
+                id: 'phase-3',
+                name: 'Verification',
+                goal: 'Per-suite triage then full suite gate',
+                definitionOfDone: 'Full test suite green; zero open errors',
+                todos: [
+                    {
+                        id: '3.1',
+                        task: 'Run affected test files individually; triage and fix',
+                        subagent: 'bug-triage',
+                        status: 'pending',
+                    },
+                    {
+                        id: '3.2',
+                        task: 'Run full test suite gate',
+                        subagent: 'bug-triage',
+                        status: 'pending',
+                    },
+                ],
+            },
+        ]
+        : [
+            {
+                id: 'phase-1',
+                name: 'Direct execution',
+                goal: description.slice(0, 120),
+                definitionOfDone: 'Task complete with tests green',
+                todos: [
+                    {
+                        id: '1.1',
+                        task: description.slice(0, 200),
+                        subagent: routeSubagent(taskTypes[0] ?? 'implement'),
+                        status: 'pending',
+                    },
+                ],
+            },
+        ];
+    return {
+        active: true,
+        rules: LEAD_DEV_RULES,
+        codexTerms: [59, 67, 68, 69],
+        description,
+        complexity,
+        requiresPhasedPlan,
+        recommendedStrategy: score.recommendedStrategy,
+        mandatoryConsults,
+        phases,
+        testProtocol: {
+            perSuiteFirst: cfg.per_suite_test_triage !== false,
+            fullSuiteGate: true,
+            hint: 'After major changes: npm test -- path/to/file.test.ts → fix → repeat → full npm test last',
+        },
+    };
+}
+export function buildSessionBootContext() {
+    if (!isLeadDevModeActive()) {
+        return { lead_dev_mode: false, reason: 'multi_agent_orchestration.lead_dev_mode=false' };
+    }
+    return {
+        lead_dev_mode: true,
+        codexTerms: [67, 68],
+        rules: LEAD_DEV_RULES,
+        mcpBoot: 'xray-orchestrator → analyze-complexity (includes lead-dev plan when active)',
+        message: '[0xRay] Lead dev mode ON — phased todos, subagent dispatch, loop until green.',
+    };
+}
+/** Persist plan for PreToolUse spawn_subagent gate */
+export function persistLeadDevPlan(plan, projectRoot = process.cwd()) {
+    const stateDir = path.join(projectRoot, '.xray', 'state');
+    fs.mkdirSync(stateDir, { recursive: true });
+    const planPath = path.join(stateDir, 'lead-dev-plan.json');
+    const payload = { ...plan, persistedAt: new Date().toISOString() };
+    fs.writeFileSync(planPath, JSON.stringify(payload, null, 2));
+    return planPath;
+}
+/** @deprecated Use isLeadDevModeActive */
+export const isAutonomyKernelActive = isLeadDevModeActive;
+/** @deprecated Use buildLeadDevPlan */
+export const buildAutonomyIntake = buildLeadDevPlan;
+export const AUTONOMY_RULES = LEAD_DEV_RULES;

package/dist/nucleus/default-plugins.d.ts

@@ -0,0 +1,17 @@
+/**
+ * DefaultPlugins — Phase 2C: centralized bootstrap for all knowledge-skill
+ * servers as SkillToolPlugin registrations.
+ *
+ * Exports registerDefaultPlugins() which is called once at boot to register
+ * all 24 knowledge-skill MCP servers (plus the researcher) as in-process
+ * plugin tools, making them dispatchable without MCP transport.
+ */
+export interface DefaultPluginsResult {
+    registered: number;
+    failed: string[];
+}
+/**
+ * Register all knowledge-skill servers as SkillToolPlugins.
+ * Called once at boot. Returns counts of registered and failed servers.
+ */
+export declare function registerDefaultPlugins(): Promise<DefaultPluginsResult>;

package/dist/nucleus/govern-http.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Nucleus HTTP Adapter — semantic convenience surface (Phase 0)
+ *
+ * IMPORTANT: MCP is the new standard (just as Dynamo is the established standard
+ * for the external governance signal). The canonical way for agents to call the
+ * nucleus is the first-class MCP tools (`govern_proposals`, `govern_reflection`)
+ * exposed by the governance MCP server (which already supports stdio + Streamable
+ * HTTP transport on /mcp and already delegates to the same GovernanceService).
+ *
+ * This module provides the *direct semantic convenience adapter*:
+ * - Pure `handleGovernRequest(body)` → returns the raw GovernanceResponse object.
+ * - Optional tiny Express app with `POST /govern` (and /health).
+ * - No full MCP JSON-RPC protocol overhead — ideal for curl, CI, simple bridges,
+ *   or anything that just wants the decision without speaking MCP.
+ *
+ * It reuses the exact same kernel (getGovernanceService + types) as the MCP path.
+ * Zero impact on the federation or existing MCP surfaces.
+ *
+ * Design goals:
+ * - Framework-agnostic pure handler (usable by Express, Fastify, raw http, tests, or in-process).
+ * - Only frameworkLogger.
+ * - Follows the thin-wrapper style of APITrigger.
+ *
+ * Usage (embeddable / in-process):
+ *   import { handleGovernRequest } from './nucleus/govern-http.js';
+ *   const result = await handleGovernRequest(req.body);
+ *
+ * Usage (standalone):
+ *   NUCLEUS_PORT=8787 node dist/nucleus/govern-http.js
+ */
+import express from 'express';
+import type { GovernanceResponse } from '../governance/governance-types.js';
+export interface GovernHTTPConfig {
+    path?: string;
+    apiKey?: string;
+    enabled?: boolean;
+    port?: number;
+}
+/**
+ * Pure handler. Can be used by any HTTP server (Express, Fastify, raw http, etc.)
+ * or called directly in tests / in-process.
+ */
+export declare function handleGovernRequest(body: unknown, options?: {
+    requireExternalDynamo?: boolean;
+}): Promise<GovernanceResponse>;
+/**
+ * Minimal Express app (prototype only).
+ * Mirrors the shape and logging discipline of APITrigger.
+ */
+export declare class GovernHTTPAdapter {
+    private app;
+    private config;
+    private initialized;
+    constructor(config?: GovernHTTPConfig);
+    initialize(): Promise<void>;
+    getApp(): express.Application;
+    listen(): Promise<void>;
+    shutdown(): void;
+}

package/dist/nucleus/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * xray Nucleus — barrel export
+ *
+ * Import from here for the stable nucleus surface:
+ *   import { handleGovernRequest, governSingle } from './nucleus/index.js';
+ */
+export { handleGovernRequest, governSingle, getGovernanceService, GovernHTTPAdapter, NUCLEUS_VERSION, NUCLEUS_DESCRIPTION, } from './kernel.js';
+export type { GovernHTTPConfig } from './govern-http.js';
+export type { GovernanceRequest, GovernanceResponse, GovernanceProposal, GovernanceVote, GovernanceResult, GovernanceContext, GovernOptions, ProposalType, } from '../governance/governance-types.js';
+export { pluginRegistry, } from './plugin-registry.js';
+export type { SkillPlugin, SkillToolPlugin, SkillProposalArgs, SkillPluginResult, ToolDefinition, } from './plugin-registry.js';
+export { scoreComplexity, routeToAgent, scoreAndRoute } from './thin-dispatch.js';
+export type { ComplexityMetrics, ComplexityScore, ComplexityLevel, ComplexityThresholds, } from './thin-dispatch.js';
+export { NUCLEUS_THIN_DISPATCH_VERSION } from './thin-dispatch.js';
+export { LEAD_DEV_RULES, isLeadDevModeActive, buildLeadDevPlan, buildSessionBootContext, shouldFlagFullTestSuite, } from './autonomy-kernel.js';
+export { registerDefaultPlugins } from './default-plugins.js';
+export type { DefaultPluginsResult } from './default-plugins.js';

package/dist/nucleus/index.js

@@ -8,4 +8,5 @@ export { handleGovernRequest, governSingle, getGovernanceService, GovernHTTPAdap
 export { pluginRegistry, } from './plugin-registry.js';
 export { scoreComplexity, routeToAgent, scoreAndRoute } from './thin-dispatch.js';
 export { NUCLEUS_THIN_DISPATCH_VERSION } from './thin-dispatch.js';
+export { LEAD_DEV_RULES, isLeadDevModeActive, buildLeadDevPlan, buildSessionBootContext, shouldFlagFullTestSuite, } from './autonomy-kernel.js';
 export { registerDefaultPlugins } from './default-plugins.js';