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

package/dist/control-plane/odu/agents.js

@@ -4,7 +4,7 @@
  * Adapted from magic-toolbox for Nexus
  * Wraps Nexus pi-coding-agent session API
  */
-import { createSubsystemLogger } from '../../logging.js';
+import { createSubsystemLogger } from "../../logging.js";
 /**
  * Base Interaction Agent
  *
@@ -26,26 +26,26 @@ export class InteractionAgent {
     isProcessing = false;
     isStreaming = false;
     shouldInterrupt = false;
-    accumulatedResponse = '';
+    accumulatedResponse = "";
     constructor(config) {
         this.userId = config.userId;
-        this.agentId = config.agentId || `${config.oduPath || 'nexus'}-ia`;
+        this.agentId = config.agentId || `${config.oduPath || "nexus"}-ia`;
         this.sessionId = config.sessionId || this.agentId;
-        this.oduPath = config.oduPath || '~/nexus/home';
+        this.oduPath = config.oduPath || "~/nexus/home";
         this.config = config.config;
-        this.model = config.model || 'claude-sonnet-4-5-20250929';
+        this.model = config.model || "claude-sonnet-4-5-20250929";
         this.maxTurns = config.maxTurns || 20;
         // Initialize ODU config (will be set by subclass)
         this.oduConfig = {
-            name: 'nexus',
-            purpose: 'Nexus Interaction Agent',
+            name: "nexus",
+            purpose: "Nexus Interaction Agent",
         };
         this.log = createSubsystemLogger(`odu/${this.agentId}`);
     }
     /**
      * Queue a message for processing
      */
-    queueMessage(content, priority = 'normal', from) {
+    queueMessage(content, priority = "normal", from) {
         this.messageQueue.push({
             id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
             content,
@@ -61,26 +61,26 @@ export class InteractionAgent {
      * Returns IMMEDIATE acknowledgment, then processes async in background
      */
     async processQueue() {
-        this.log.info('processQueue() called', {
+        this.log.info("processQueue() called", {
             queueLength: this.messageQueue.length,
             isProcessing: this.isProcessing,
         });
         // If already processing, return early
         if (this.isProcessing) {
-            return 'IA is currently processing another request';
+            return "IA is currently processing another request";
         }
         // If no messages queued, return early
         if (this.messageQueue.length === 0) {
-            return 'No messages to process';
+            return "No messages to process";
         }
         // Peek at first message to generate acknowledgment
         const firstMessage = this.messageQueue[0];
         const ackMessage = firstMessage.from
             ? `Acknowledged request from ${firstMessage.from}. Processing now...`
-            : 'Acknowledged. Processing...';
+            : "Acknowledged. Processing...";
         // Start processing in background (don't await!)
         this.processQueueAsync().catch((error) => {
-            this.log.error('Background processing error', { error });
+            this.log.error("Background processing error", { error });
         });
         // Return acknowledgment immediately
         return ackMessage;
@@ -91,7 +91,7 @@ export class InteractionAgent {
     async processQueueAsync() {
         this.isProcessing = true;
         try {
-            let finalResponse = '';
+            let finalResponse = "";
             // Process all queued messages
             while (this.messageQueue.length > 0) {
                 // Dequeue all current messages
@@ -110,13 +110,15 @@ export class InteractionAgent {
                 // Combine messages
                 const combinedMessage = messages.length === 1
                     ? messages[0].content
-                    : messages.map((m, i) => `Message ${i + 1}:\n${m.content}`).join('\n\n---\n\n');
+                    : messages
+                        .map((m, i) => `Message ${i + 1}:\n${m.content}`)
+                        .join("\n\n---\n\n");
                 // Reset interrupt flag
                 this.shouldInterrupt = false;
                 // Process the combined message with sender context
                 finalResponse = await this.processSingleMessage(combinedMessage, from);
             }
-            this.log.info('Async processing complete', {
+            this.log.info("Async processing complete", {
                 responseLength: finalResponse.length,
             });
         }
@@ -130,7 +132,7 @@ export class InteractionAgent {
      */
     interrupt() {
         if (this.isStreaming) {
-            this.log.info('Interrupting mid-stream', {
+            this.log.info("Interrupting mid-stream", {
                 accumulatedLength: this.accumulatedResponse.length,
             });
             this.shouldInterrupt = true;
@@ -164,17 +166,20 @@ export class ExecutionAgent {
     constructor(config) {
         this.userId = config.userId;
         this.task = config.task;
-        this.agentId = config.agentId || `${config.oduPath || 'nexus'}-ea-${this.task.taskName || 'task'}`;
-        this.oduPath = config.oduPath || '~/nexus/home';
+        this.agentId =
+            config.agentId ||
+                `${config.oduPath || "nexus"}-ea-${this.task.taskName || "task"}`;
+        this.oduPath = config.oduPath || "~/nexus/home";
         this.config = config.config;
         // Support model override: task.model > config.model > default Haiku 4.5
-        this.model = config.task.model || config.model || 'claude-haiku-4-5-20251001';
+        this.model =
+            config.task.model || config.model || "claude-haiku-4-5-20251001";
         this.maxTurns = config.maxTurns || 50;
         this.history = config.history || [];
         // Initialize ODU config (will be set by subclass)
         this.oduConfig = {
-            name: 'nexus',
-            purpose: 'Nexus Execution Agent',
+            name: "nexus",
+            purpose: "Nexus Execution Agent",
         };
         this.log = createSubsystemLogger(`odu/${this.agentId}`);
     }
@@ -182,6 +187,6 @@ export class ExecutionAgent {
      * Build initial prompt for the task
      */
     buildInitialPrompt() {
-        return this.task.description || 'Complete the task';
+        return this.task.description || "Complete the task";
     }
 }

package/dist/control-plane/odu/interaction-tools.js

@@ -4,63 +4,63 @@
  * Creates tools for IAs to delegate to EAs and manage specialist agents.
  * Ported from magic-toolbox/agentkit/tools/interaction-tools.ts
  */
-import { listAgentSessions, loadSessionMetadata } from '../../config/sessions.js';
+import { listAgentSessions, loadSessionMetadata, } from "../../config/sessions.js";
 /**
  * Create all interaction agent tools
  *
  * Returns tool definitions in the format expected by pi-coding-agent
  */
-export function createInteractionTools(context) {
+export function createInteractionTools(_context) {
     return [
         {
-            name: 'list_my_agents',
-            description: 'List all agents you can message: your own specialist agents (by short name) and external agents that have contacted you (by full name).',
+            name: "list_my_agents",
+            description: "List all agents you can message: your own specialist agents (by short name) and external agents that have contacted you (by full name).",
             input_schema: {
-                type: 'object',
+                type: "object",
                 properties: {
                     limit: {
-                        type: 'number',
-                        description: 'Maximum number of agents to return (default: 20)',
+                        type: "number",
+                        description: "Maximum number of agents to return (default: 20)",
                     },
                 },
             },
         },
         {
-            name: 'send_message_to_agent',
+            name: "send_message_to_agent",
             description: 'Send a message to an EA. If task_name matches an existing EA, it will be resumed with full history. If not, a new EA will be created with that name. Use priority to control urgency: "urgent"/"high" will interrupt running EA immediately, "normal" will queue the message.',
             input_schema: {
-                type: 'object',
+                type: "object",
                 properties: {
                     task_name: {
-                        type: 'string',
+                        type: "string",
                         description: 'Unique descriptive name for the EA (e.g., "magic-toolbox-worktrees", "merge-feature-branches")',
                     },
                     task: {
-                        type: 'string',
-                        description: 'Task description or message for the EA',
+                        type: "string",
+                        description: "Task description or message for the EA",
                     },
                     priority: {
-                        type: 'string',
-                        enum: ['normal', 'high', 'urgent'],
+                        type: "string",
+                        enum: ["normal", "high", "urgent"],
                         description: 'Message priority: "normal" = queue (default), "high"/"urgent" = interrupt running EA immediately. Use high/urgent when: user says "stop/wait", new info invalidates current work, critical correction needed.',
-                        default: 'normal',
+                        default: "normal",
                     },
                 },
-                required: ['task_name', 'task'],
+                required: ["task_name", "task"],
             },
         },
         {
-            name: 'inspect_agent',
-            description: 'Get detailed info about a specific agent (for tie-breaking when multiple agents might match)',
+            name: "inspect_agent",
+            description: "Get detailed info about a specific agent (for tie-breaking when multiple agents might match)",
             input_schema: {
-                type: 'object',
+                type: "object",
                 properties: {
                     task_name: {
-                        type: 'string',
-                        description: 'The task_name of the EA to inspect',
+                        type: "string",
+                        description: "The task_name of the EA to inspect",
                     },
                 },
-                required: ['task_name'],
+                required: ["task_name"],
             },
         },
     ];
@@ -71,13 +71,14 @@ export function createInteractionTools(context) {
  * Called when a tool is invoked by the IA
  */
 export async function handleToolInvocation(toolName, args, context) {
+    const payload = args && typeof args === "object" ? args : {};
     switch (toolName) {
-        case 'list_my_agents':
-            return await handleListMyAgents(args, context);
-        case 'send_message_to_agent':
-            return await handleSendMessageToAgent(args, context);
-        case 'inspect_agent':
-            return await handleInspectAgent(args, context);
+        case "list_my_agents":
+            return await handleListMyAgents(payload, context);
+        case "send_message_to_agent":
+            return await handleSendMessageToAgent(payload, context);
+        case "inspect_agent":
+            return await handleInspectAgent(payload, context);
         default:
             throw new Error(`Unknown tool: ${toolName}`);
     }
@@ -86,16 +87,18 @@ export async function handleToolInvocation(toolName, args, context) {
  * Handle list_my_agents tool
  */
 async function handleListMyAgents(args, context) {
-    const limit = args.limit || 20;
+    const limit = typeof args.limit === "number" && Number.isFinite(args.limit)
+        ? Math.max(1, Math.trunc(args.limit))
+        : 20;
     // Get own EAs from session storage
     // EAs are stored as sessions with agentType: "execution" and parentSession set
-    const agentId = context.agentId.replace('-ia', ''); // Convert 'toolbox-ia' to 'toolbox'
+    const agentId = context.agentId.replace("-ia", ""); // Convert 'toolbox-ia' to 'toolbox'
     const allSessions = await listAgentSessions(agentId);
     // Load metadata for each session to check agentType
     const eaSessions = [];
     for (const sessionKey of allSessions.slice(0, limit)) {
         const metadata = await loadSessionMetadata(agentId, sessionKey);
-        if (metadata && metadata.agentType === 'execution') {
+        if (metadata && metadata.agentType === "execution") {
             eaSessions.push({
                 sessionKey,
                 metadata,
@@ -108,36 +111,39 @@ async function handleListMyAgents(args, context) {
     const ownFormatted = eaSessions
         .map((ea) => {
         const updated = ea.metadata.updated; // New format uses 'updated' (ISO string)
-        const lastActiveDate = updated ? new Date(updated).toLocaleString() : 'Never';
+        const lastActiveDate = updated
+            ? new Date(updated).toLocaleString()
+            : "Never";
         const taskName = ea.sessionKey; // sessionKey is the task name
         const displayName = ea.metadata.displayName || taskName;
         const isActive = context.broker.isAgentActive(`${context.oduName}-ea-${taskName}`);
-        const status = isActive ? '🟢 active' : '⚪ idle';
+        const status = isActive ? "🟢 active" : "⚪ idle";
         return `• ${displayName} (${status})\n  Last active: ${lastActiveDate}`;
     })
-        .join('\n\n');
+        .join("\n\n");
     // Format external callers (show full names)
     const externalFormatted = externalAgentIds.length > 0
         ? externalAgentIds
             .map((agentId) => {
             const isActive = context.broker.isAgentActive(agentId);
-            const status = isActive ? '🟢 active' : '⚪ idle';
+            const status = isActive ? "🟢 active" : "⚪ idle";
             return `• ${agentId} (${status})\n  External agent - has sent you messages`;
         })
-            .join('\n\n')
-        : '';
+            .join("\n\n")
+        : "";
     // Build response
-    let text = '';
+    let text = "";
     if (eaSessions.length > 0) {
         text += `Your Specialist Agents (${eaSessions.length}):\n\n${ownFormatted}`;
     }
     if (externalFormatted) {
         if (text)
-            text += '\n\n---\n\n';
+            text += "\n\n---\n\n";
         text += `External Agents (${externalAgentIds.length}):\n\n${externalFormatted}`;
     }
     if (!text) {
-        text = 'No agents found. You can create a new one with send_message_to_agent.';
+        text =
+            "No agents found. You can create a new one with send_message_to_agent.";
     }
     return text;
 }
@@ -145,9 +151,12 @@ async function handleListMyAgents(args, context) {
  * Handle send_message_to_agent tool
  */
 async function handleSendMessageToAgent(args, context) {
-    const taskName = args.task_name;
-    const task = args.task;
-    const priority = args.priority || 'normal';
+    const taskName = typeof args.task_name === "string" ? args.task_name : "";
+    const task = typeof args.task === "string" ? args.task : "";
+    if (!taskName || !task) {
+        throw new Error("Invalid arguments: task_name and task are required.");
+    }
+    const priority = typeof args.priority === "string" ? args.priority : "normal";
     // Convert task_name to fully-qualified EA agent ID
     const eaId = `${context.oduName}-ea-${taskName}`;
     // Send message via broker
@@ -159,7 +168,7 @@ async function handleSendMessageToAgent(args, context) {
         priority: priority,
         timestamp: Date.now(),
         metadata: {
-            source: 'ia',
+            source: "ia",
             taskName,
         },
     });
@@ -169,8 +178,11 @@ async function handleSendMessageToAgent(args, context) {
  * Handle inspect_agent tool
  */
 async function handleInspectAgent(args, context) {
-    const taskName = args.task_name;
-    const agentId = context.agentId.replace('-ia', ''); // Convert 'toolbox-ia' to 'toolbox'
+    const taskName = typeof args.task_name === "string" ? args.task_name : "";
+    if (!taskName) {
+        throw new Error("Invalid arguments: task_name is required.");
+    }
+    const agentId = context.agentId.replace("-ia", ""); // Convert 'toolbox-ia' to 'toolbox'
     // Load session metadata
     const metadata = await loadSessionMetadata(agentId, taskName);
     if (!metadata) {
@@ -178,13 +190,13 @@ async function handleInspectAgent(args, context) {
     }
     const updated = metadata.updated; // New format uses 'updated' (ISO string)
     const created = metadata.created; // New format uses 'created' (ISO string)
-    const lastActiveDate = updated ? new Date(updated).toLocaleString() : 'Never';
-    const createdDate = created ? new Date(created).toLocaleString() : 'Unknown';
+    const lastActiveDate = updated ? new Date(updated).toLocaleString() : "Never";
+    const createdDate = created ? new Date(created).toLocaleString() : "Unknown";
     const displayName = metadata.displayName || taskName;
     // Check if agent is currently active
     const eaId = `${context.oduName}-ea-${taskName}`;
     const isActive = context.broker.isAgentActive(eaId);
-    const status = isActive ? '🟢 active' : '⚪ idle';
+    const status = isActive ? "🟢 active" : "⚪ idle";
     return `EA: ${displayName} (${status})
 
 Task Name: ${taskName}
@@ -192,5 +204,5 @@ Created: ${createdDate}
 Last Active: ${lastActiveDate}
 Compactions: ${metadata.compactionCount || 0}
 
-This EA specializes in: ${metadata.displayName || 'general tasks'}`;
+This EA specializes in: ${metadata.displayName || "general tasks"}`;
 }

package/dist/control-plane/odu/prompt-loader.js

@@ -4,9 +4,9 @@
  * Loads prompt templates from files and substitutes {{variable}} patterns.
  * Similar to magic-toolbox/agentkit/prompts/loader.ts
  */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { resolveUserPath } from '../../utils.js';
+import fs from "node:fs/promises";
+import path from "node:path";
+import { resolveUserPath } from "../../utils.js";
 /**
  * Cache for loaded prompts (performance optimization)
  */
@@ -29,7 +29,7 @@ export async function loadPrompt(promptPath, variables = {}) {
     let template = promptCache.get(cacheKey);
     if (!template) {
         // Load from file
-        template = await fs.readFile(resolvedPath, 'utf-8');
+        template = await fs.readFile(resolvedPath, "utf-8");
         // Cache the template
         promptCache.set(cacheKey, template);
     }
@@ -51,7 +51,7 @@ async function resolvePromptPath(promptPath) {
         return promptPath;
     }
     // Try workspace prompts/ directory first
-    const workspacePath = path.join(resolveUserPath('~/nexus/home'), 'prompts', promptPath);
+    const workspacePath = path.join(resolveUserPath("~/nexus/home"), "prompts", promptPath);
     try {
         await fs.access(workspacePath);
         return workspacePath;
@@ -61,8 +61,8 @@ async function resolvePromptPath(promptPath) {
     }
     // Try nexus bundled prompts/ directory
     // (Resolve relative to this file's directory)
-    const nexusRootPath = path.resolve(new URL(import.meta.url).pathname, '../../../..');
-    const bundledPath = path.join(nexusRootPath, 'prompts', promptPath);
+    const nexusRootPath = path.resolve(new URL(import.meta.url).pathname, "../../../..");
+    const bundledPath = path.join(nexusRootPath, "prompts", promptPath);
     try {
         await fs.access(bundledPath);
         return bundledPath;
@@ -82,7 +82,7 @@ function substituteVariables(template, variables) {
     let result = template;
     // Replace all {{variable}} patterns
     for (const [key, value] of Object.entries(variables)) {
-        const pattern = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+        const pattern = new RegExp(`\\{\\{${key}\\}\\}`, "g");
         result = result.replace(pattern, value);
     }
     return result;