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

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

@@ -4,13 +4,13 @@
  * Convention-driven agent runtime that works for any ODU.
  * Adapted from magic-toolbox for Nexus.
  */
-import path from 'node:path';
-import { InteractionAgent, ExecutionAgent } from './agents.js';
-import { loadHistory, appendToHistory, } from '../../config/sessions.js';
-import { resolveUserPath } from '../../utils.js';
-import { DEFAULT_AGENT_ID } from '../../routing/session-key.js';
-import { loadPrompt } from './prompt-loader.js';
-import { DEFAULT_MODEL } from '../../agents/defaults.js';
+import path from "node:path";
+import { DEFAULT_MODEL } from "../../agents/defaults.js";
+import { appendToHistory, loadHistory, } from "../../config/sessions.js";
+import { DEFAULT_AGENT_ID } from "../../routing/session-key.js";
+import { resolveUserPath } from "../../utils.js";
+import { ExecutionAgent, InteractionAgent } from "./agents.js";
+import { loadPrompt } from "./prompt-loader.js";
 /**
  * Unified Interaction Agent Runtime
  *
@@ -20,16 +20,21 @@ import { DEFAULT_MODEL } from '../../agents/defaults.js';
 export class ODUInteractionAgent extends InteractionAgent {
     // Static registry of all ODU IA singletons (fractal architecture support)
     static instances = new Map();
-    conversationHistory = [];
-    broker;
-    constructor(config) {
-        // Singleton key: oduPath + userId (supports nested ODUs)
+    static getOrCreate(config) {
         const key = `${config.oduPath}:${config.userId}`;
-        // Return existing instance if already created
         const existing = ODUInteractionAgent.instances.get(key);
         if (existing) {
             return existing;
         }
+        const instance = new ODUInteractionAgent(config);
+        ODUInteractionAgent.instances.set(key, instance);
+        return instance;
+    }
+    conversationHistory = [];
+    broker;
+    constructor(config) {
+        // Singleton key: oduPath + userId (supports nested ODUs)
+        const key = `${config.oduPath}:${config.userId}`;
         // Create new instance
         super(config);
         this.oduConfig = config.oduConfig;
@@ -40,7 +45,7 @@ export class ODUInteractionAgent extends InteractionAgent {
         // (constructors can't be async, so we do this in the background)
         if (config.sessionId) {
             this.loadConversationHistory(config.sessionId).catch((error) => {
-                this.log.warn('Failed to load conversation history', { error });
+                this.log.warn("Failed to load conversation history", { error });
             });
         }
         // Register ODU with broker
@@ -61,11 +66,11 @@ export class ODUInteractionAgent extends InteractionAgent {
             });
         };
         // Register ODU (EA factory) with broker
-        this.broker.registerODU(this.oduConfig.name, path.join(resolveUserPath(this.oduPath), '../state'), agentFactory);
+        this.broker.registerODU(this.oduConfig.name, path.join(resolveUserPath(this.oduPath), "../state"), agentFactory);
         // Register THIS IA with broker so it can receive messages
         const iaId = `${this.oduConfig.name}-ia`;
         this.broker.registerIA(iaId, this);
-        this.log.info('IA registered with broker', { iaId });
+        this.log.info("IA registered with broker", { iaId });
     }
     /**
      * Resolve the model to use for IA from config
@@ -77,12 +82,12 @@ export class ODUInteractionAgent extends InteractionAgent {
         // Check ODU-specific IA model first
         if (oduConfig?.iaModel?.primary) {
             // Extract just the model name from provider/model format
-            const parts = oduConfig.iaModel.primary.split('/');
+            const parts = oduConfig.iaModel.primary.split("/");
             return parts.length > 1 ? parts[1] : parts[0];
         }
         // Fall back to agent.model
         if (agentConfig?.model?.primary) {
-            const parts = agentConfig.model.primary.split('/');
+            const parts = agentConfig.model.primary.split("/");
             return parts.length > 1 ? parts[1] : parts[0];
         }
         // Default to opus
@@ -101,19 +106,20 @@ export class ODUInteractionAgent extends InteractionAgent {
             if (history && history.length > 0) {
                 // Convert HistoryTurn[] to conversation history format
                 this.conversationHistory = history.map((turn) => ({
+                    turn_id: turn.turn_id,
                     role: turn.role,
                     content: turn.content,
                     tool_calls: turn.tool_calls,
                     tool_call_id: turn.tool_call_id,
                     timestamp: turn.timestamp,
                 }));
-                this.log.info('Loaded conversation history', {
+                this.log.info("Loaded conversation history", {
                     turns: this.conversationHistory.length,
                 });
             }
         }
         catch (error) {
-            this.log.error('Failed to load conversation history', { error });
+            this.log.error("Failed to load conversation history", { error });
         }
     }
     /**
@@ -122,7 +128,7 @@ export class ODUInteractionAgent extends InteractionAgent {
     async chatSync(userMessage) {
         // ALWAYS interrupt if currently streaming
         if (this.isStreaming) {
-            this.log.info('New message received while streaming, interrupting');
+            this.log.info("New message received while streaming, interrupting");
             this.interrupt();
             // Wait a tiny bit for stream to stop
             await new Promise((resolve) => setTimeout(resolve, 50));
@@ -131,11 +137,11 @@ export class ODUInteractionAgent extends InteractionAgent {
         this.queueMessage(userMessage);
         // If already processing (but not streaming), return queued message
         if (this.isProcessing && !this.isStreaming) {
-            return 'Message queued. Processing...';
+            return "Message queued. Processing...";
         }
         this.isProcessing = true;
         try {
-            let finalResponse = '';
+            let finalResponse = "";
             // Process all queued messages
             while (this.messageQueue.length > 0) {
                 // Dequeue all current messages
@@ -154,7 +160,9 @@ export class ODUInteractionAgent extends InteractionAgent {
                 // Combine messages into single prompt
                 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 for new processing
                 this.shouldInterrupt = false;
                 // Process the combined message with sender context (with streaming + interrupt support)
@@ -174,20 +182,20 @@ export class ODUInteractionAgent extends InteractionAgent {
      */
     async processSingleMessage(userMessage, from) {
         // If message from another agent, prepend context so IA knows who to respond to
-        if (from && from !== 'user' && from !== 'system') {
+        if (from && from !== "user" && from !== "system") {
             userMessage = `[Message from agent: ${from}]\n\n${userMessage}`;
         }
-        this.log.info('Processing message', {
+        this.log.info("Processing message", {
             messageLength: userMessage.length,
             from,
         });
         // Import dependencies dynamically
-        const { default: Anthropic } = await import('@anthropic-ai/sdk');
-        const { createInteractionTools, handleToolInvocation } = await import('./interaction-tools.js');
+        const { default: Anthropic } = await import("@anthropic-ai/sdk");
+        const { createInteractionTools, handleToolInvocation } = await import("./interaction-tools.js");
         // Get API key from environment
         const apiKey = process.env.ANTHROPIC_API_KEY;
         if (!apiKey) {
-            throw new Error('ANTHROPIC_API_KEY environment variable is required for ODU interaction agent');
+            throw new Error("ANTHROPIC_API_KEY environment variable is required for ODU interaction agent");
         }
         // Create Anthropic client
         const client = new Anthropic({ apiKey });
@@ -207,35 +215,32 @@ export class ODUInteractionAgent extends InteractionAgent {
         const messages = [];
         // Add conversation history
         for (const turn of this.conversationHistory) {
-            if (turn.role === 'user') {
-                messages.push({ role: 'user', content: turn.content });
+            if (turn.role === "user") {
+                messages.push({ role: "user", content: turn.content });
             }
-            else if (turn.role === 'assistant') {
+            else if (turn.role === "assistant") {
                 // Build assistant message with tool calls if present
                 const content = [];
                 if (turn.content) {
-                    content.push({ type: 'text', text: turn.content });
+                    content.push({ type: "text", text: turn.content });
                 }
                 if (turn.tool_calls && turn.tool_calls.length > 0) {
                     for (const toolCall of turn.tool_calls) {
                         content.push({
-                            type: 'tool_use',
+                            type: "tool_use",
                             id: toolCall.id,
                             name: toolCall.function.name,
                             input: JSON.parse(toolCall.function.arguments),
                         });
                     }
                 }
-                messages.push({ role: 'assistant', content });
+                messages.push({ role: "assistant", content });
             }
-            else if (turn.role === 'tool') {
-                // Tool results must be in the previous assistant message's content
-                // For now, we'll skip them as they should already be recorded
-                continue;
+            else if (turn.role === "tool") {
             }
         }
         // Add current user message
-        messages.push({ role: 'user', content: userMessage });
+        messages.push({ role: "user", content: userMessage });
         // Resolve model from config (IA uses controlPlane.odu.iaModel or agent.model)
         const iaModel = this.resolveIAModel();
         // Call Claude API with tool support
@@ -243,23 +248,24 @@ export class ODUInteractionAgent extends InteractionAgent {
             model: iaModel,
             max_tokens: 4096,
             system: systemPrompt,
-            messages,
+            messages: messages,
             tools,
         });
         // Handle tool calls in a loop (agent may make multiple tool calls)
         let iterationCount = 0;
         const maxIterations = 10; // Prevent infinite loops
-        while (response.stop_reason === 'tool_use' && iterationCount < maxIterations) {
+        while (response.stop_reason === "tool_use" &&
+            iterationCount < maxIterations) {
             iterationCount++;
             // Extract tool calls from response
-            const toolUseBlocks = response.content.filter((block) => block.type === 'tool_use');
+            const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
             // Execute each tool and collect results
             const toolResults = [];
             for (const toolBlock of toolUseBlocks) {
                 try {
                     const result = await handleToolInvocation(toolBlock.name, toolBlock.input, toolsContext);
                     toolResults.push({
-                        type: 'tool_result',
+                        type: "tool_result",
                         tool_use_id: toolBlock.id,
                         content: result,
                     });
@@ -267,7 +273,7 @@ export class ODUInteractionAgent extends InteractionAgent {
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     toolResults.push({
-                        type: 'tool_result',
+                        type: "tool_result",
                         tool_use_id: toolBlock.id,
                         content: `Error: ${errorMessage}`,
                         is_error: true,
@@ -275,31 +281,31 @@ export class ODUInteractionAgent extends InteractionAgent {
                 }
             }
             // Add assistant response to messages
-            messages.push({ role: 'assistant', content: response.content });
+            messages.push({ role: "assistant", content: response.content });
             // Add tool results as user message
-            messages.push({ role: 'user', content: toolResults });
+            messages.push({ role: "user", content: toolResults });
             // Continue conversation
             response = await client.messages.create({
-                model: 'claude-sonnet-4-20250514',
+                model: "claude-sonnet-4-20250514",
                 max_tokens: 4096,
                 system: systemPrompt,
-                messages,
+                messages: messages,
                 tools,
             });
         }
         // Extract final text response
-        const textBlocks = response.content.filter((block) => block.type === 'text');
-        const finalResponse = textBlocks.map((block) => block.text).join('\n');
+        const textBlocks = response.content.filter((block) => block.type === "text");
+        const finalResponse = textBlocks.map((block) => block.text).join("\n");
         // Save conversation history (both in-memory and to disk)
         const userTurn = {
             turn_id: `turn-${Date.now()}-user`,
-            role: 'user',
+            role: "user",
             content: userMessage,
             timestamp: new Date().toISOString(),
         };
         const assistantTurn = {
             turn_id: `turn-${Date.now()}-assistant`,
-            role: 'assistant',
+            role: "assistant",
             content: finalResponse,
             timestamp: new Date().toISOString(),
         };
@@ -312,10 +318,13 @@ export class ODUInteractionAgent extends InteractionAgent {
         try {
             await appendToHistory(agentId, sessionKey, userTurn);
             await appendToHistory(agentId, sessionKey, assistantTurn);
-            this.log.debug('Persisted conversation to history.jsonl', { sessionKey });
+            this.log.debug("Persisted conversation to history.jsonl", { sessionKey });
         }
         catch (error) {
-            this.log.warn('Failed to persist conversation history', { error, sessionKey });
+            this.log.warn("Failed to persist conversation history", {
+                error,
+                sessionKey,
+            });
         }
         return finalResponse;
     }
@@ -324,7 +333,7 @@ export class ODUInteractionAgent extends InteractionAgent {
      */
     async buildSystemPrompt() {
         // Load InteractionAgent.md prompt with template variables
-        const prompt = await loadPrompt('InteractionAgent.md', {
+        const prompt = await loadPrompt("InteractionAgent.md", {
             oduName: this.oduConfig.name,
             oduPurpose: this.oduConfig.purpose,
             oduPath: this.oduPath,
@@ -348,7 +357,7 @@ export class ODUExecutionAgent extends ExecutionAgent {
         }
         else {
             // Derive ODU name from path
-            const oduName = path.basename(resolveUserPath(config.oduPath || '~/nexus/home'));
+            const oduName = path.basename(resolveUserPath(config.oduPath || "~/nexus/home"));
             this.oduConfig = {
                 name: oduName,
                 purpose: `Execute tasks for ${oduName} ODU`,
@@ -359,17 +368,17 @@ export class ODUExecutionAgent extends ExecutionAgent {
      * Execute the task using Nexus embedded agent
      */
     async execute() {
-        this.log.info('Starting EA execution', {
+        this.log.info("Starting EA execution", {
             taskType: this.task.type,
-            taskDescription: (this.task.description || '').substring(0, 200),
+            taskDescription: (this.task.description || "").substring(0, 200),
             historyLength: this.history.length,
         });
         try {
             // Import runEmbeddedPiAgent dynamically
-            const { runEmbeddedPiAgent } = await import('../../agents/pi-embedded-runner.js');
-            const { resolveNexusAgentDir } = await import('../../agents/agent-paths.js');
-            const { randomUUID } = await import('node:crypto');
-            const path = await import('node:path');
+            const { runEmbeddedPiAgent } = await import("../../agents/pi-embedded-runner.js");
+            const { resolveNexusAgentDir } = await import("../../agents/agent-paths.js");
+            const { randomUUID } = await import("node:crypto");
+            const path = await import("node:path");
             // Build initial task prompt
             const taskPrompt = this.buildInitialPrompt();
             // Resolve workspace directory for this EA
@@ -378,7 +387,7 @@ export class ODUExecutionAgent extends ExecutionAgent {
             const workspaceDir = resolveUserPath(this.oduPath);
             // Resolve session file path
             const agentDir = resolveNexusAgentDir();
-            const sessionFile = path.join(workspaceDir, '.agent-session.json');
+            const sessionFile = path.join(workspaceDir, ".agent-session.json");
             // Build system prompt with EA template
             const systemPrompt = await this.buildSystemPrompt();
             // Run embedded pi-agent with full coding tools
@@ -400,8 +409,11 @@ export class ODUExecutionAgent extends ExecutionAgent {
                 extraSystemPrompt: systemPrompt,
             });
             // Extract final response from payloads
-            const finalResponse = result.payloads?.map((p) => p.text).filter(Boolean).join('\n\n') || 'Task completed';
-            this.log.info('EA execution complete', {
+            const finalResponse = result.payloads
+                ?.map((p) => p.text)
+                .filter(Boolean)
+                .join("\n\n") || "Task completed";
+            this.log.info("EA execution complete", {
                 responseLength: finalResponse.length,
                 usage: result.meta.agentMeta?.usage,
             });
@@ -413,10 +425,10 @@ export class ODUExecutionAgent extends ExecutionAgent {
                 from: this.agentId,
                 to: iaId,
                 content: finalResponse,
-                priority: 'normal',
+                priority: "normal",
                 timestamp: Date.now(),
                 metadata: {
-                    source: 'ea',
+                    source: "ea",
                     completionResult: true,
                     usage: result.meta.agentMeta?.usage,
                 },
@@ -424,7 +436,7 @@ export class ODUExecutionAgent extends ExecutionAgent {
             return finalResponse;
         }
         catch (error) {
-            this.log.error('EA execution failed', { error });
+            this.log.error("EA execution failed", { error });
             // Send error back to IA
             const oduName = this.oduConfig.name;
             const iaId = `${oduName}-ia`;
@@ -434,10 +446,10 @@ export class ODUExecutionAgent extends ExecutionAgent {
                 from: this.agentId,
                 to: iaId,
                 content: `Task failed: ${errorMessage}`,
-                priority: 'normal',
+                priority: "normal",
                 timestamp: Date.now(),
                 metadata: {
-                    source: 'ea',
+                    source: "ea",
                     completionResult: true,
                     error: true,
                 },
@@ -450,17 +462,17 @@ export class ODUExecutionAgent extends ExecutionAgent {
      */
     async buildSystemPrompt() {
         // Load ExecutionAgent.md prompt with template variables
-        const prompt = await loadPrompt('ExecutionAgent.md', {
+        const prompt = await loadPrompt("ExecutionAgent.md", {
             oduName: this.oduConfig.name,
             oduPurpose: this.oduConfig.purpose,
             oduPath: this.oduPath,
-            task: this.task.description || 'Execute the assigned task',
-            taskName: this.task.taskName || 'task',
+            task: this.task.description || "Execute the assigned task",
+            taskName: this.task.taskName || "task",
             agentId: this.agentId,
             // For now, leave skills and capabilities empty
             // These will be populated when we implement skill/capability loading
-            availableSkills: '(Skills will be listed here)',
-            availableCapabilities: '(Capabilities will be listed here)',
+            availableSkills: "(Skills will be listed here)",
+            availableCapabilities: "(Capabilities will be listed here)",
         });
         return prompt;
     }

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

@@ -10,14 +10,14 @@
  * - EAs complete and respond → IA
  * - IA responds → User
  */
-import { loadSession, writeSessionMetadata, listAgentSessions, resolveSessionDir, } from "../config/sessions.js";
-import { normalizeAgentId, parseAgentSessionKey, DEFAULT_AGENT_ID, } from "../routing/session-key.js";
-import { ActiveMessageBroker } from "./broker/broker.js";
-import { ODUInteractionAgent } from "./odu/runtime.js";
-import { loadConfig } from "../config/config.js";
-import { createSubsystemLogger } from "../logging.js";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
+import { loadConfig } from "../config/config.js";
+import { listAgentSessions, loadSession, resolveSessionDir, writeSessionMetadata, } from "../config/sessions.js";
+import { createSubsystemLogger } from "../logging.js";
+import { DEFAULT_AGENT_ID, normalizeAgentId, parseAgentSessionKey, } from "../routing/session-key.js";
+import { ActiveMessageBroker } from "./broker/broker.js";
+import { ODUInteractionAgent } from "./odu/runtime.js";
 /**
  * ODUControlPlane implements AgentControlPlane using the broker pattern.
  *
@@ -57,7 +57,7 @@ export class ODUControlPlane {
         let ia = this.interactionAgents.get(userId);
         if (!ia) {
             this.logger.info("Creating new IA for user", { userId, sessionId });
-            ia = new ODUInteractionAgent({
+            ia = ODUInteractionAgent.getOrCreate({
                 userId,
                 sessionId,
                 oduPath: this.workspaceDir,
@@ -78,7 +78,7 @@ export class ODUControlPlane {
         return sessionKey;
     }
     async sendMessage(options) {
-        const { sessionKey, message, agentId: optAgentId, thinkingLevel, verboseLevel, isHeartbeat, streaming, onChunk, onComplete, onError, } = options;
+        const { sessionKey, message, agentId: optAgentId, thinkingLevel, verboseLevel, isHeartbeat, streaming, onChunk: _onChunk, onComplete, onError, } = options;
         try {
             // Parse session key to get agentId
             const parsed = parseAgentSessionKey(sessionKey);
@@ -86,7 +86,7 @@ export class ODUControlPlane {
             // Convert session key to userId for ODU
             const userId = this.sessionKeyToUserId(sessionKey);
             // Load or create session
-            let session = await loadSession(agentId, sessionKey);
+            const session = await loadSession(agentId, sessionKey);
             let sessionId;
             if (!session) {
                 // Create new session
@@ -108,7 +108,7 @@ export class ODUControlPlane {
                 await writeSessionMetadata(agentId, sessionKey, session.metadata);
             }
             // Get or create IA for this user
-            const ia = this.getOrCreateIA(userId, sessionId);
+            const _ia = this.getOrCreateIA(userId, sessionId);
             // Build broker message
             const brokerMessage = {
                 id: crypto.randomUUID(),
@@ -192,7 +192,8 @@ export class ODUControlPlane {
                 return null;
             }
             // Session metadata has 'updated' (ISO string) from new format
-            const updated = session.metadata.updated || new Date().toISOString();
+            const updated = session.metadata.updated ||
+                new Date().toISOString();
             return {
                 key: sessionKey,
                 sessionId: session.metadata.sessionId,
@@ -222,7 +223,8 @@ export class ODUControlPlane {
                 const session = await loadSession(agentId, sessionKey);
                 if (session) {
                     // Session metadata has 'updated' (ISO string) from new format
-                    const updated = session.metadata.updated || new Date().toISOString();
+                    const updated = session.metadata.updated ||
+                        new Date().toISOString();
                     sessions.push({
                         key: sessionKey,
                         sessionId: session.metadata.sessionId,

package/dist/control-plane/single-agent.js

@@ -4,16 +4,16 @@
  * This implementation maintains the existing single-agent-per-session pattern.
  * No behavior changes - just adapting the existing code to the AgentControlPlane interface.
  */
-import { runEmbeddedPiAgent, } from "../agents/pi-embedded-runner.js";
-import { queueEmbeddedPiMessage } from "../agents/pi-embedded.js";
-import { loadConfig } from "../config/config.js";
-import { loadSession, writeSessionMetadata, listAgentSessions, resolveSessionDir, } from "../config/sessions.js";
-import { normalizeAgentId, parseAgentSessionKey, DEFAULT_AGENT_ID, } from "../routing/session-key.js";
-import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { buildWorkspaceSkillSnapshot } from "../agents/skills.js";
-import { resolveNexusAgentDir } from "../agents/agent-paths.js";
 import fs from "node:fs";
+import path from "node:path";
+import { resolveNexusAgentDir } from "../agents/agent-paths.js";
+import { queueEmbeddedPiMessage } from "../agents/pi-embedded.js";
+import { runEmbeddedPiAgent, } from "../agents/pi-embedded-runner.js";
+import { buildWorkspaceSkillSnapshot } from "../agents/skills.js";
+import { loadConfig } from "../config/config.js";
+import { listAgentSessions, loadSession, resolveSessionDir, writeSessionMetadata, } from "../config/sessions.js";
+import { DEFAULT_AGENT_ID, normalizeAgentId, parseAgentSessionKey, } from "../routing/session-key.js";
 /**
  * SingleAgentControlPlane wraps the existing runEmbeddedPiAgent function
  * to implement the AgentControlPlane interface.
@@ -32,7 +32,7 @@ export class SingleAgentControlPlane {
         this.agentDir = options?.agentDir ?? resolveNexusAgentDir();
     }
     async sendMessage(options) {
-        const { sessionKey, message, agentId: optAgentId, thinkingLevel, verboseLevel, isHeartbeat, streaming, onChunk, onComplete, onError, } = options;
+        const { sessionKey, message, agentId: optAgentId, thinkingLevel, verboseLevel, isHeartbeat: _isHeartbeat, streaming, onChunk, onComplete, onError, } = options;
         try {
             // Parse session key to get agentId and sessionId
             const parsed = parseAgentSessionKey(sessionKey);
@@ -72,11 +72,11 @@ export class SingleAgentControlPlane {
                 };
             }
             // Load skills snapshot
-            const skillsSnapshot = await buildWorkspaceSkillSnapshot(this.workspaceDir, {
+            const skillsSnapshot = buildWorkspaceSkillSnapshot(this.workspaceDir, {
                 config: this.config,
             });
             // Build callbacks for streaming/chunks
-            let partialPayloads = [];
+            const partialPayloads = [];
             const onPartialReply = async (payload) => {
                 if (onChunk) {
                     onChunk({
@@ -169,7 +169,7 @@ export class SingleAgentControlPlane {
                 entry,
             };
         }
-        catch (error) {
+        catch {
             return null;
         }
     }
@@ -203,7 +203,7 @@ export class SingleAgentControlPlane {
             sessions.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
             return sessions;
         }
-        catch (error) {
+        catch {
             return [];
         }
     }