@intent-systems/nexus 2026.1.5-4 → 2026.1.5-8

package/dist/control-plane/broker/broker.js

@@ -19,7 +19,7 @@
 import crypto from "node:crypto";
 import { loadSession, writeSessionMetadata, } from "../../config/sessions.js";
 import { createSubsystemLogger } from "../../logging.js";
-import { normalizeAgentId, DEFAULT_AGENT_ID } from "../../routing/session-key.js";
+import { DEFAULT_AGENT_ID, normalizeAgentId, } from "../../routing/session-key.js";
 /**
  * Active Message Broker - manages agent lifecycle
  */
@@ -52,10 +52,9 @@ export class ActiveMessageBroker {
     collectMaxMessages = 10; // Default max messages before auto-flush
     // Logger
     logger;
-    // Config reference
     config;
     constructor(config) {
-        this.logger = createSubsystemLogger('broker');
+        this.logger = createSubsystemLogger("broker");
         this.config = config;
     }
     /**
@@ -65,7 +64,10 @@ export class ActiveMessageBroker {
     registerODU(oduName, sessionStorePath, agentFactory) {
         this.sessionStorePaths.set(oduName, sessionStorePath);
         this.agentFactories.set(oduName, agentFactory);
-        this.logger.info(`ODU registered: ${oduName}`, { oduName, sessionStorePath });
+        this.logger.info(`ODU registered: ${oduName}`, {
+            oduName,
+            sessionStorePath,
+        });
     }
     /**
      * Register an IA with the broker
@@ -80,7 +82,10 @@ export class ActiveMessageBroker {
      */
     setDeliveryMode(agentId, mode) {
         this.deliveryModes.set(agentId, mode);
-        this.logger.debug(`Delivery mode set for ${agentId}: ${mode}`, { agentId, mode });
+        this.logger.debug(`Delivery mode set for ${agentId}: ${mode}`, {
+            agentId,
+            mode,
+        });
     }
     /**
      * Set collection parameters (for 'collect' mode)
@@ -90,7 +95,10 @@ export class ActiveMessageBroker {
             this.collectDebounceMs = debounceMs;
         if (maxMessages !== undefined)
             this.collectMaxMessages = maxMessages;
-        this.logger.debug('Collection params updated', { debounceMs: this.collectDebounceMs, maxMessages: this.collectMaxMessages });
+        this.logger.debug("Collection params updated", {
+            debounceMs: this.collectDebounceMs,
+            maxMessages: this.collectMaxMessages,
+        });
     }
     /**
      * Handle collect mode: buffer messages and debounce delivery
@@ -101,13 +109,16 @@ export class ActiveMessageBroker {
         if (!this.collectionBuffers.has(agentId)) {
             this.collectionBuffers.set(agentId, []);
         }
-        this.collectionBuffers.get(agentId).push(message);
+        this.collectionBuffers.get(agentId)?.push(message);
         // Clear existing timer
-        if (this.collectionTimers.has(agentId)) {
-            clearTimeout(this.collectionTimers.get(agentId));
+        const existingTimer = this.collectionTimers.get(agentId);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
         }
         // Check if we've hit max messages
         const buffer = this.collectionBuffers.get(agentId);
+        if (!buffer)
+            return;
         if (buffer.length >= this.collectMaxMessages) {
             // Flush immediately
             this.flushCollectionBuffer(agentId);
@@ -126,10 +137,14 @@ export class ActiveMessageBroker {
         const buffer = this.collectionBuffers.get(agentId);
         if (!buffer || buffer.length === 0)
             return;
-        this.logger.debug(`Flushing collection buffer for ${agentId}`, { agentId, messageCount: buffer.length });
+        this.logger.debug(`Flushing collection buffer for ${agentId}`, {
+            agentId,
+            messageCount: buffer.length,
+        });
         // Clear timer and buffer
-        if (this.collectionTimers.has(agentId)) {
-            clearTimeout(this.collectionTimers.get(agentId));
+        const timer = this.collectionTimers.get(agentId);
+        if (timer) {
+            clearTimeout(timer);
             this.collectionTimers.delete(agentId);
         }
         this.collectionBuffers.delete(agentId);
@@ -163,25 +178,32 @@ export class ActiveMessageBroker {
             throw new Error(`Cannot wait for ack: ${message.to} is not a registered IA`);
         }
         // Track external caller if needed
-        if (message.from !== message.to && message.from !== 'user' && message.from !== 'system') {
+        if (message.from !== message.to &&
+            message.from !== "user" &&
+            message.from !== "system") {
             if (!this.externalCallers.has(message.to)) {
                 this.externalCallers.set(message.to, new Set());
             }
-            this.externalCallers.get(message.to).add(message.from);
+            this.externalCallers.get(message.to)?.add(message.from);
         }
         // Add to queue for tracking
         this.enqueue(message);
         // Queue message at IA
         if (ia.queueMessage) {
-            ia.queueMessage(message.content, message.priority || 'normal', message.from);
+            ia.queueMessage(message.content, message.priority || "normal", message.from);
         }
-        this.logger.debug(`Waiting for ack from ${message.to}...`, { to: message.to });
+        this.logger.debug(`Waiting for ack from ${message.to}...`, {
+            to: message.to,
+        });
         // Kick off processing and wait for acknowledgment
-        let ack = '';
+        let ack = "";
         if (ia.processQueue) {
             ack = await ia.processQueue();
         }
-        this.logger.debug(`Received ack from ${message.to}`, { to: message.to, ackLength: ack.length });
+        this.logger.debug(`Received ack from ${message.to}`, {
+            to: message.to,
+            ackLength: ack.length,
+        });
         return ack;
     }
     /**
@@ -204,25 +226,27 @@ export class ActiveMessageBroker {
         message.to = resolvedTo;
         this.logger.debug(`Routed to ${resolvedTo}`, { resolvedTo });
         // 1. Track external caller (if not self-message)
-        if (message.from !== message.to && message.from !== 'user' && message.from !== 'system') {
+        if (message.from !== message.to &&
+            message.from !== "user" &&
+            message.from !== "system") {
             if (!this.externalCallers.has(message.to)) {
                 this.externalCallers.set(message.to, new Set());
             }
-            this.externalCallers.get(message.to).add(message.from);
+            this.externalCallers.get(message.to)?.add(message.from);
         }
         // 2. Handle collect mode (buffer and debounce)
-        if (message.deliveryMode === 'collect') {
+        if (message.deliveryMode === "collect") {
             this.handleCollectMode(message);
             return; // Don't enqueue immediately
         }
         // 3. Handle steer mode (interrupt like urgent)
-        if (message.deliveryMode === 'steer') {
+        if (message.deliveryMode === "steer") {
             // Steer mode interrupts current work
-            message.priority = 'urgent';
-            message.deliveryMode = 'interrupt';
+            message.priority = "urgent";
+            message.deliveryMode = "interrupt";
         }
         // 4. Handle followup mode (queue without interrupting)
-        if (message.deliveryMode === 'followup') {
+        if (message.deliveryMode === "followup") {
             // Followup doesn't interrupt - just queues normally
             // No special handling needed, just enqueue
         }
@@ -233,23 +257,30 @@ export class ActiveMessageBroker {
         const ia = this.registeredIAs.get(message.to);
         if (ia) {
             // IA is always running - queue message and trigger processing
-            this.logger.debug(`Delivering to IA: ${message.to}`, { to: message.to, contentPreview: message.content.substring(0, 100) });
+            this.logger.debug(`Delivering to IA: ${message.to}`, {
+                to: message.to,
+                contentPreview: message.content.substring(0, 100),
+            });
             // Queue the message with sender information
             if (ia.queueMessage) {
-                ia.queueMessage(message.content, message.priority || 'normal', message.from);
+                ia.queueMessage(message.content, message.priority || "normal", message.from);
             }
             // Trigger processing by calling processQueue() if it exists, otherwise use chatSync
             if (ia.processQueue) {
-                this.logger.debug(`Calling processQueue() for ${message.to}`, { to: message.to });
+                this.logger.debug(`Calling processQueue() for ${message.to}`, {
+                    to: message.to,
+                });
                 ia.processQueue().catch((error) => {
                     this.logger.error(`IA ${message.to} processQueue error: ${error.message}`, { to: message.to, error: error.message });
                 });
             }
             else if (ia.chatSync) {
                 // Fallback: Call chatSync with empty string
-                this.logger.debug(`Calling chatSync('') for ${message.to} (fallback)`, { to: message.to });
+                this.logger.debug(`Calling chatSync('') for ${message.to} (fallback)`, {
+                    to: message.to,
+                });
                 setImmediate(() => {
-                    ia.chatSync('').catch((error) => {
+                    ia.chatSync?.("").catch((error) => {
                         this.logger.error(`IA ${message.to} chatSync error: ${error.message}`, { to: message.to, error: error.message });
                     });
                 });
@@ -261,13 +292,17 @@ export class ActiveMessageBroker {
         const running = this.runningAgents.get(message.to);
         if (shouldInterrupt && running) {
             // Interrupt and restart immediately
-            this.logger.info(`Interrupting ${message.to} for urgent message`, { agentId: message.to });
+            this.logger.info(`Interrupting ${message.to} for urgent message`, {
+                agentId: message.to,
+            });
             await this.interruptAndRestart(message.to);
         }
         else if (!running && !this.startingAgents.has(message.to)) {
             // Agent not running and not being started - mark as starting and process
             this.startingAgents.add(message.to);
-            this.logger.info(`Processing batch for ${message.to}`, { agentId: message.to });
+            this.logger.info(`Processing batch for ${message.to}`, {
+                agentId: message.to,
+            });
             try {
                 await this.processNextBatch(message.to);
             }
@@ -301,10 +336,10 @@ export class ActiveMessageBroker {
         // Rule 2: Short name - expand to caller's ODU EA
         // Special case: 'user' and 'system' default to primary ODU
         let callerODU;
-        if (from === 'user' || from === 'system') {
+        if (from === "user" || from === "system") {
             // Get first registered ODU (primary)
             const odus = Array.from(this.agentFactories.keys());
-            callerODU = odus[0] || 'nexus';
+            callerODU = odus[0] || "nexus";
         }
         else {
             callerODU = this.getODUName(from);
@@ -319,14 +354,14 @@ export class ActiveMessageBroker {
      * Examples: "toolbox-ea-worktrees", "meta-ia"
      */
     isFullyQualified(name) {
-        const parts = name.split('-');
+        const parts = name.split("-");
         // Must have at least 2 parts (oduName-ia) or 3+ parts (oduName-ea-identifier)
         if (parts.length < 2) {
             return false;
         }
         // Second part must be 'ia' or 'ea'
         const agentType = parts[1];
-        return agentType === 'ia' || agentType === 'ea';
+        return agentType === "ia" || agentType === "ea";
     }
     /**
      * Expand short agent name to fully-qualified ID
@@ -379,7 +414,7 @@ export class ActiveMessageBroker {
      * Returns 'idle' if agent never started or completed
      */
     getAgentStatus(agentId) {
-        return this.agentStatus.get(agentId) || 'idle';
+        return this.agentStatus.get(agentId) || "idle";
     }
     /**
      * Set session status for an agent
@@ -388,10 +423,13 @@ export class ActiveMessageBroker {
     setAgentStatus(agentId, status) {
         const oldStatus = this.agentStatus.get(agentId);
         this.agentStatus.set(agentId, status);
-        this.logger.debug(`Agent ${agentId} status: ${status}`, { agentId, status });
+        this.logger.debug(`Agent ${agentId} status: ${status}`, {
+            agentId,
+            status,
+        });
         // Emit status change event
         if (oldStatus !== status) {
-            this.emit('agent_status_changed', {
+            this.emit("agent_status_changed", {
                 agentId,
                 oldStatus,
                 newStatus: status,
@@ -403,7 +441,7 @@ export class ActiveMessageBroker {
      * Check if agent is currently active (processing messages)
      */
     isAgentActive(agentId) {
-        return this.getAgentStatus(agentId) === 'active';
+        return this.getAgentStatus(agentId) === "active";
     }
     /**
      * Get list of external agents that have sent messages to this agent
@@ -432,7 +470,7 @@ export class ActiveMessageBroker {
             if (!this.completionCallbacks.has(agentId)) {
                 this.completionCallbacks.set(agentId, []);
             }
-            this.completionCallbacks.get(agentId).push(resolve);
+            this.completionCallbacks.get(agentId)?.push(resolve);
         });
     }
     /**
@@ -440,24 +478,24 @@ export class ActiveMessageBroker {
      */
     shouldInterrupt(message) {
         // Rule 1: External → IA always interrupts
-        if (message.to.endsWith('-ia') && message.metadata?.source === 'user') {
+        if (message.to.endsWith("-ia") && message.metadata?.source === "user") {
             return true;
         }
         // Rule 2: EA → parent IA never interrupts
-        if (message.to.endsWith('-ia') && message.metadata?.source === 'ea') {
+        if (message.to.endsWith("-ia") && message.metadata?.source === "ea") {
             return false;
         }
         // Rule 3: Explicit interrupt mode
-        if (message.deliveryMode === 'interrupt') {
+        if (message.deliveryMode === "interrupt") {
             return true;
         }
         // Rule 4: Priority-based
-        if (message.priority === 'urgent') {
+        if (message.priority === "urgent") {
             return true;
         }
-        if (message.priority === 'high') {
+        if (message.priority === "high") {
             const running = this.runningAgents.get(message.to);
-            if (running && (Date.now() - running.startedAt > 30000)) {
+            if (running && Date.now() - running.startedAt > 30000) {
                 return true; // Running > 30s, interrupt
             }
         }
@@ -480,7 +518,10 @@ export class ActiveMessageBroker {
         const batch = [];
         // Take all consecutive messages from the same sender
         while (queue.length > 0 && queue[0].from === firstSender) {
-            batch.push(queue.shift());
+            const nextMessage = queue.shift();
+            if (!nextMessage)
+                break;
+            batch.push(nextMessage);
         }
         this.logger.info(`Batched ${batch.length} messages from ${firstSender} for ${agentId}`, {
             agentId,
@@ -523,8 +564,8 @@ export class ActiveMessageBroker {
             });
             // 4. Format batch messages
             let taskDescription;
-            const deliveryMode = this.deliveryModes.get(agentId) || 'batch';
-            if (deliveryMode === 'single' || batch.length === 1) {
+            const deliveryMode = this.deliveryModes.get(agentId) || "batch";
+            if (deliveryMode === "single" || batch.length === 1) {
                 // Single message
                 taskDescription = batch[0].content;
                 this.logger.debug(`Processing single message from ${this.getDisplayName(batch[0].from)}`, {
@@ -540,7 +581,7 @@ export class ActiveMessageBroker {
                 else {
                     taskDescription = batch
                         .map((m, i) => `Message ${i + 1}:\n${m.content}`)
-                        .join('\n\n---\n\n');
+                        .join("\n\n---\n\n");
                 }
                 this.logger.debug(`Batched ${batch.length} messages into prompt`, {
                     agentId,
@@ -552,9 +593,9 @@ export class ActiveMessageBroker {
             // 6. Start and track
             const promise = agent.execute();
             // Mark agent as active
-            this.setAgentStatus(agentId, 'active');
+            this.setAgentStatus(agentId, "active");
             // Emit agent started event
-            this.emit('agent_started', {
+            this.emit("agent_started", {
                 agentId,
                 oduName: this.getODUName(agentId),
                 timestamp: Date.now(),
@@ -565,7 +606,7 @@ export class ActiveMessageBroker {
                 instance: agent,
                 promise,
                 startedAt: Date.now(),
-                status: 'active',
+                status: "active",
             });
             this.logger.info(`Agent ${agentId} started (status: active)`, {
                 agentId,
@@ -592,10 +633,10 @@ export class ActiveMessageBroker {
      * meta-ia → meta-ia (keep IAs fully-qualified)
      */
     getDisplayName(agentId) {
-        const parts = agentId.split('-');
-        if (parts.length >= 3 && parts[1] === 'ea') {
+        const parts = agentId.split("-");
+        if (parts.length >= 3 && parts[1] === "ea") {
             // EA: return task name part
-            return parts.slice(2).join('-');
+            return parts.slice(2).join("-");
         }
         // IA or other: return full name
         return agentId;
@@ -606,11 +647,11 @@ export class ActiveMessageBroker {
     onAgentComplete(agentId) {
         this.logger.info(`Agent ${agentId} completed`, { agentId });
         // Mark agent as idle
-        this.setAgentStatus(agentId, 'idle');
+        this.setAgentStatus(agentId, "idle");
         // Remove from running agents
         this.runningAgents.delete(agentId);
         // Emit agent completed event
-        this.emit('agent_completed', {
+        this.emit("agent_completed", {
             agentId,
             oduName: this.getODUName(agentId),
             timestamp: Date.now(),
@@ -638,7 +679,9 @@ export class ActiveMessageBroker {
             });
         }
         else {
-            this.logger.debug(`Agent ${agentId} idle (no more messages)`, { agentId });
+            this.logger.debug(`Agent ${agentId} idle (no more messages)`, {
+                agentId,
+            });
         }
     }
     /**
@@ -650,7 +693,7 @@ export class ActiveMessageBroker {
             error: error.message,
         });
         // Mark agent as idle (failed, but can receive new messages)
-        this.setAgentStatus(agentId, 'idle');
+        this.setAgentStatus(agentId, "idle");
         // Remove from running
         this.runningAgents.delete(agentId);
         // Notify completion listeners with error
@@ -664,7 +707,9 @@ export class ActiveMessageBroker {
      */
     notifyCompletion(agentId, result) {
         const callbacks = this.completionCallbacks.get(agentId) || [];
-        callbacks.forEach(cb => cb(result));
+        callbacks.forEach((cb) => {
+            cb(result);
+        });
         this.completionCallbacks.delete(agentId); // One-time callbacks
         if (callbacks.length > 0) {
             this.logger.debug(`Notified ${callbacks.length} listener(s) for ${agentId}`, {
@@ -693,7 +738,9 @@ export class ActiveMessageBroker {
         }
         catch {
             // Interrupt causes early exit, that's expected
-            this.logger.debug(`Agent ${agentId} interrupted successfully`, { agentId });
+            this.logger.debug(`Agent ${agentId} interrupted successfully`, {
+                agentId,
+            });
         }
         // Remove from running
         this.runningAgents.delete(agentId);
@@ -715,16 +762,16 @@ export class ActiveMessageBroker {
         if (!this.queues.has(message.to)) {
             this.queues.set(message.to, []);
         }
-        this.queues.get(message.to).push(message);
+        this.queues.get(message.to)?.push(message);
         this.sortQueue(message.to);
         // Emit message queued event
-        this.emit('message_queued', {
+        this.emit("message_queued", {
             messageId: message.id,
             from: message.from,
             to: message.to,
             priority: message.priority,
             timestamp: message.timestamp,
-            queueSize: this.queues.get(message.to).length,
+            queueSize: this.queues.get(message.to)?.length,
         });
     }
     /**
@@ -752,7 +799,7 @@ export class ActiveMessageBroker {
      * - 'meta-ia' → 'meta'
      */
     getODUName(agentId) {
-        const parts = agentId.split('-');
+        const parts = agentId.split("-");
         if (parts.length < 2) {
             throw new Error(`Invalid agent ID format: ${agentId}`);
         }
@@ -762,7 +809,7 @@ export class ActiveMessageBroker {
     /**
      * Load session from Nexus session store (new format)
      */
-    async loadSessionFromStore(storePath, agentId) {
+    async loadSessionFromStore(_storePath, agentId) {
         try {
             const sessionKey = `agent:${agentId}`;
             const agentIdNormalized = normalizeAgentId(DEFAULT_AGENT_ID);
@@ -771,7 +818,7 @@ export class ActiveMessageBroker {
                 return null;
             }
             // Load history from new format
-            const history = session.history.map(turn => ({
+            const history = session.history.map((turn) => ({
                 role: turn.role,
                 content: turn.content,
                 timestamp: new Date(turn.timestamp).getTime(),
@@ -792,7 +839,7 @@ export class ActiveMessageBroker {
      * Register or update EA in session store (new format)
      * EAs persist forever once created
      */
-    async registerEA(storePath, agentId, taskName) {
+    async registerEA(_storePath, agentId, taskName) {
         try {
             const sessionKey = `agent:${agentId}`;
             const agentIdNormalized = normalizeAgentId(DEFAULT_AGENT_ID);
@@ -815,13 +862,17 @@ export class ActiveMessageBroker {
                     sessionId: crypto.randomUUID(),
                     updatedAt: now,
                     displayName: taskName || displayName,
-                    chatType: 'direct',
+                    chatType: "direct",
                 };
                 await writeSessionMetadata(agentIdNormalized, sessionKey, {
                     ...newEntry,
                     created: new Date().toISOString(),
                 });
-                this.logger.info(`Registered new EA: ${agentId}`, { agentId, oduName, displayName });
+                this.logger.info(`Registered new EA: ${agentId}`, {
+                    agentId,
+                    oduName,
+                    displayName,
+                });
             }
         }
         catch (error) {
@@ -887,7 +938,7 @@ export class ActiveMessageBroker {
         for (const [id] of this.registeredIAs.entries()) {
             agents.push({
                 agentId: id,
-                type: 'ia',
+                type: "ia",
                 status: this.getAgentStatus(id),
                 oduName: this.getODUName(id),
                 queueSize: this.getQueueSize(id),
@@ -898,7 +949,7 @@ export class ActiveMessageBroker {
         for (const [id, runningAgent] of this.runningAgents.entries()) {
             agents.push({
                 agentId: id,
-                type: 'ea',
+                type: "ea",
                 status: runningAgent.status,
                 oduName: this.getODUName(id),
                 queueSize: this.getQueueSize(id),
@@ -907,11 +958,13 @@ export class ActiveMessageBroker {
         }
         // Add queued agents that aren't running
         for (const [id, queue] of this.queues.entries()) {
-            if (!this.runningAgents.has(id) && !this.registeredIAs.has(id) && queue.length > 0) {
+            if (!this.runningAgents.has(id) &&
+                !this.registeredIAs.has(id) &&
+                queue.length > 0) {
                 agents.push({
                     agentId: id,
-                    type: 'ea',
-                    status: 'idle',
+                    type: "ea",
+                    status: "idle",
                     oduName: this.getODUName(id),
                     queueSize: queue.length,
                     isRunning: false,
@@ -933,7 +986,7 @@ export class ActiveMessageBroker {
         if (!this.eventListeners.has(event)) {
             this.eventListeners.set(event, []);
         }
-        this.eventListeners.get(event).push(callback);
+        this.eventListeners.get(event)?.push(callback);
     }
     /**
      * Unsubscribe from broker events

package/dist/control-plane/compaction.js

@@ -1,7 +1,7 @@
-import Anthropic from "@anthropic-ai/sdk";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import Anthropic from "@anthropic-ai/sdk";
 import { compactEmbeddedPiSession, } from "../agents/pi-embedded-runner.js";
 import { archiveHistory, loadHistory, resolveSessionDir, writeSummary, } from "../config/sessions.js";
 import { createSubsystemLogger } from "../logging.js";
@@ -133,9 +133,7 @@ function partitionHistory(history, keepRecentMessages, keepRecentTokens) {
         for (let i = history.length - 1; i >= 0; i--) {
             const turn = history[i];
             const estimatedTokens = Math.ceil((turn.content?.length ?? 0) / 4 +
-                (turn.tool_calls
-                    ? JSON.stringify(turn.tool_calls).length / 4
-                    : 0));
+                (turn.tool_calls ? JSON.stringify(turn.tool_calls).length / 4 : 0));
             tokenCount += estimatedTokens;
             if (tokenCount > keepRecentTokens) {
                 // Found the split point
@@ -251,7 +249,7 @@ ${summaryText}
             log.debug(`Cleaned up temp history file: ${tmpFilePath}`);
         }
         catch (error) {
-            log.warn(`Failed to clean up temp history file ${tmpFilePath}: ${error}`);
+            log.warn(`Failed to clean up temp history file ${tmpFilePath}: ${String(error)}`);
         }
     }
 }

package/dist/control-plane/factory.js

@@ -2,8 +2,8 @@
  * Factory for creating the appropriate AgentControlPlane implementation
  * based on configuration.
  */
-import { SingleAgentControlPlane } from "./single-agent.js";
 import { ODUControlPlane } from "./odu-control-plane.js";
+import { SingleAgentControlPlane } from "./single-agent.js";
 /**
  * Creates an AgentControlPlane instance based on the config.
  *
@@ -26,6 +26,6 @@ export function createControlPlane(options) {
                 workspaceDir: options?.workspaceDir,
             });
         default:
-            throw new Error(`Unknown control plane mode: ${mode}. Valid modes: 'single', 'odu'`);
+            throw new Error(`Unknown control plane mode: ${String(mode)}. Valid modes: 'single', 'odu'`);
     }
 }

package/dist/control-plane/index.js

@@ -5,6 +5,6 @@
  * and routing messages. It allows switching between different orchestration
  * strategies without changing the Gateway (Access Plane) code.
  */
-export { SingleAgentControlPlane } from "./single-agent.js";
+export { createControlPlane, } from "./factory.js";
 export { ODUControlPlane } from "./odu-control-plane.js";
-export { createControlPlane } from "./factory.js";
+export { SingleAgentControlPlane } from "./single-agent.js";