@serkanalgur/opencode-nexus 1.0.5 → 1.0.7

package/dist/index.js

@@ -8514,11 +8514,53 @@ class NexusOrchestrator {
   memory = new Map;
   eventHandlers = new Map;
   configManager;
+  ctx = null;
+  onStateChange = null;
   constructor(config) {
     this.config = this.mergeConfig(config);
     this.budget = this.config.budget;
     this.configManager = new NexusConfigManager;
   }
+  initialize(ctx, onStateChange) {
+    this.ctx = ctx;
+    this.onStateChange = onStateChange ?? null;
+  }
+  getState() {
+    const agents = Array.from(this.agents.values()).map((a) => ({
+      id: a.id,
+      name: a.name,
+      role: a.role,
+      status: a.status,
+      model: `${a.model.provider}/${a.model.model}`,
+      sessionID: a.sessionID,
+      spawnedAt: a.spawnedAt.toISOString(),
+      tasksCompleted: a.metrics.tasksCompleted,
+      tasksFailed: a.metrics.tasksFailed,
+      totalCost: a.metrics.totalCost
+    }));
+    const tasks = Array.from(this.tasks.values()).map((t) => ({
+      id: t.id,
+      name: t.name,
+      role: t.requiredRole,
+      status: t.status,
+      assignedAgent: t.assignedAgent,
+      result: t.result ? {
+        success: t.result.success,
+        output: t.result.output?.slice(0, 500),
+        error: t.result.error,
+        duration: t.result.duration
+      } : undefined
+    }));
+    return {
+      running: this.running,
+      paused: this.paused,
+      agents,
+      tasks,
+      totalSpent: this.totalSpent,
+      budgetRemaining: this.budget.maxTotalCost - this.totalSpent,
+      lastUpdated: new Date().toISOString()
+    };
+  }
   mergeConfig(partial) {
     const defaults = {
       maxConcurrency: 5,
@@ -8556,7 +8598,7 @@ class NexusOrchestrator {
         syncInterval: 5000
       },
       dashboard: {
-        enabled: false,
+        enabled: true,
         port: 4747,
         host: "127.0.0.1"
       },
@@ -8584,12 +8626,19 @@ class NexusOrchestrator {
       learning: { ...defaults.learning, ...partial?.learning }
     };
   }
+  notifyStateChange() {
+    this.onStateChange?.();
+  }
   async execute(request) {
     if (this.running) {
       throw new Error("Orchestrator is already running");
     }
+    if (!this.ctx) {
+      throw new Error("Orchestrator not initialized - call initialize(ctx) first");
+    }
     this.running = true;
     const startTime = Date.now();
+    this.notifyStateChange();
     try {
       this.dag = this.buildDAG(request.tasks);
       if (request.budget) {
@@ -8615,6 +8664,7 @@ class NexusOrchestrator {
       };
     } finally {
       this.running = false;
+      this.notifyStateChange();
     }
   }
   buildDAG(tasks) {
@@ -8692,11 +8742,13 @@ class NexusOrchestrator {
   async executeDAG() {
     while (!this.dag.isComplete() && !this.paused) {
       const readyNodes = this.dag.getReadyNodes();
+      const spawnPromises = [];
       for (const node of readyNodes) {
         if (this.agents.size < this.config.maxConcurrency) {
-          await this.spawnAndExecute(node);
+          spawnPromises.push(this.spawnAndExecute(node));
         }
       }
+      await Promise.all(spawnPromises);
       await this.sleep(this.config.schedulerInterval);
     }
   }
@@ -8710,86 +8762,150 @@ class NexusOrchestrator {
     });
     node.spawnedAgent = agent;
     node.status = "running";
-    this.monitorAgent(agent, node);
+    node.task.assignedAgent = agent.id;
+    this.notifyStateChange();
+    await this.executeTask(agent, node);
   }
-  async monitorAgent(agent, node) {
-    const timeout = node.task.timeout || this.config.defaultTimeout;
-    setTimeout(() => {
-      if (node.status === "running") {
-        this.handleAgentTimeout(agent, node);
-      }
-    }, timeout);
-  }
-  handleAgentTimeout(agent, node) {
-    if (this.config.selfHealing.enabled) {
-      this.handleFailure(agent, node, new Error("Agent timed out"));
-    } else {
+  async executeTask(agent, node) {
+    if (!this.ctx || !agent.sessionID) {
       node.status = "failed";
       node.result = {
         success: false,
-        error: "Agent timed out",
-        duration: node.task.timeout || this.config.defaultTimeout,
+        error: "No session available for agent",
+        duration: 0,
         tokensUsed: 0,
         cost: 0
       };
+      this.notifyStateChange();
+      return;
     }
+    const startTime = Date.now();
+    const timeout = node.task.timeout || this.config.defaultTimeout;
+    try {
+      const rolePrompt = this.buildRolePrompt(node.task.requiredRole);
+      const taskPrompt = `${rolePrompt}
+
+## Task
+${node.task.name}
+
+${node.task.description}
+
+## Scope
+Files: ${node.task.files.include.join(", ")}`;
+      await this.ctx.session.prompt({
+        sessionID: agent.sessionID,
+        text: taskPrompt
+      });
+      const waitPromise = this.ctx.session.wait({ sessionID: agent.sessionID });
+      const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Task timed out")), timeout));
+      await Promise.race([waitPromise, timeoutPromise]);
+      const messages = await this.ctx.session.context({ sessionID: agent.sessionID });
+      const lastAssistantMsg = messages.filter((m) => m.role === "assistant").pop();
+      const output = lastAssistantMsg?.content || "Task completed";
+      const duration = Date.now() - startTime;
+      const result = {
+        success: true,
+        output: typeof output === "string" ? output : JSON.stringify(output),
+        duration,
+        tokensUsed: 0,
+        cost: this.estimateModelCost(agent.model.model)
+      };
+      this.dag.markComplete(node.id, result);
+      agent.metrics.tasksCompleted++;
+      agent.metrics.totalCost += result.cost;
+      this.totalSpent += result.cost;
+      this.costByAgent.set(agent.id, (this.costByAgent.get(agent.id) || 0) + result.cost);
+      this.checkBudget();
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const result = {
+        success: false,
+        error: error.message || "Task failed",
+        duration,
+        tokensUsed: 0,
+        cost: 0
+      };
+      this.dag.markFailed(node.id, new Error(result.error));
+      agent.metrics.tasksFailed++;
+      if (this.config.selfHealing.enabled) {
+        await this.handleFailure(agent, node, new Error(result.error));
+      }
+    } finally {
+      agent.status = "idle";
+      node.task.status = node.status === "completed" ? "completed" : "failed";
+      this.notifyStateChange();
+    }
+  }
+  buildRolePrompt(role) {
+    const rolePrompts = {
+      architect: "You are a software architect. Focus on system design, architecture patterns, and high-level technical decisions. Analyze requirements and propose structured solutions.",
+      coder: "You are a senior software engineer. Write clean, efficient, well-documented code. Follow best practices and coding standards.",
+      reviewer: "You are a code reviewer. Review code for correctness, security, performance, and maintainability. Provide constructive feedback.",
+      tester: "You are a QA engineer. Write comprehensive tests, identify edge cases, and ensure code quality.",
+      explorer: "You are a code explorer. Navigate and analyze codebases, understand architecture, and provide detailed reports.",
+      documenter: "You are a technical writer. Create clear, comprehensive documentation for code and APIs."
+    };
+    return rolePrompts[role] || `You are a ${role}. Complete the assigned task professionally.`;
   }
   async handleFailure(agent, node, error) {
     const failureCount = agent.metrics.tasksFailed + 1;
-    agent.metrics.tasksFailed++;
     if (failureCount < this.config.selfHealing.maxRetries) {
       const delay = this.config.selfHealing.retryDelay * Math.pow(this.config.selfHealing.backoffMultiplier, failureCount - 1);
-      setTimeout(async () => {
-        await this.retryAgent(agent, node);
-      }, delay);
-    } else if (this.config.selfHealing.contextTransfer) {
-      await this.respawnAgent(agent, node);
+      await this.sleep(delay);
+      if (agent.sessionID) {
+        node.status = "running";
+        this.notifyStateChange();
+        await this.executeTask(agent, node);
+      }
     } else {
       node.status = "failed";
       node.result = {
         success: false,
-        error: error.message,
+        error: `Max retries (${this.config.selfHealing.maxRetries}) exceeded: ${error.message}`,
         duration: 0,
         tokensUsed: 0,
         cost: 0
       };
+      this.notifyStateChange();
     }
   }
-  async retryAgent(agent, node) {
-    agent.status = "working";
-    node.status = "running";
-    this.emit("agent:retry", { agent, node });
-  }
-  async respawnAgent(oldAgent, node) {
-    const newAgent = await this.spawnAgent({
-      role: oldAgent.role,
-      task: node.task,
-      model: oldAgent.model.model
-    });
-    if (this.config.selfHealing.contextTransfer) {
-      await this.transferContext(oldAgent, newAgent);
-    }
-    await this.terminateAgent(oldAgent.id);
-    node.spawnedAgent = newAgent;
-    node.status = "running";
-    this.monitorAgent(newAgent, node);
-  }
-  async transferContext(oldAgent, newAgent) {
-    this.emit("context:transfer", { from: oldAgent, to: newAgent });
-  }
   async spawnAgent(config) {
+    if (!this.ctx) {
+      throw new Error("Orchestrator not initialized");
+    }
     const agentId = `agent-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const displayName = `${config.role}-${agentId.slice(0, 8)}`;
+    const session = await this.ctx.session.create({
+      title: `[Nexus] ${displayName}`
+    });
+    const modelConfig = this.configManager.getModelForRole(config.role);
+    const [provider, ...modelParts] = modelConfig.split("/");
+    const modelName = modelParts.join("/");
+    try {
+      await this.ctx.session.switchAgent({
+        sessionID: session.id,
+        agent: config.role === "architect" ? "build" : config.role === "reviewer" ? "build" : "build"
+      });
+    } catch {}
+    if (modelName) {
+      try {
+        await this.ctx.session.switchModel({
+          sessionID: session.id,
+          model: { providerID: provider, id: modelName }
+        });
+      } catch {}
+    }
     const agent = {
       id: agentId,
-      name: `${config.role}-${agentId.slice(0, 8)}`,
+      name: displayName,
       role: config.role,
-      status: "spawning",
+      status: "idle",
       model: {
-        provider: "opencode",
-        model: config.model || "default",
+        provider,
+        model: modelName || "default",
         estimatedCost: 0,
         estimatedQuality: 0.5,
-        reasoning: "Default selection"
+        reasoning: `Configured for ${config.role}`
       },
       spawnedAt: new Date,
       lastActivity: new Date,
@@ -8800,12 +8916,12 @@ class NexusOrchestrator {
         totalCost: 0,
         averageResponseTime: 0,
         errorRate: 0
-      }
+      },
+      sessionID: session.id
     };
     this.agents.set(agentId, agent);
     this.emit("agent:spawned", agent);
-    await this.sleep(this.config.agents.spawnDelay);
-    agent.status = "idle";
+    this.notifyStateChange();
     return agent;
   }
   async terminateAgent(agentId) {
@@ -8814,53 +8930,34 @@ class NexusOrchestrator {
       agent.status = "terminated";
       this.agents.delete(agentId);
       this.emit("agent:terminated", agent);
+      this.notifyStateChange();
     }
   }
   analyzeComplexity(task) {
     const fileCount = task.files.include.length;
-    const codeLines = this.estimateCodeLines(task);
+    const codeLines = task.files.include.length * 50;
     const dependencyDepth = task.dependencies.length;
-    const domainKnowledge = this.estimateDomainKnowledge(task);
-    const riskLevel = this.estimateRiskLevel(task);
-    const overall = Math.min(100, fileCount * 10 + codeLines / 10 + dependencyDepth * 15 + domainKnowledge * 20 + (riskLevel === "high" ? 30 : riskLevel === "medium" ? 15 : 0));
-    return {
-      overall,
-      factors: {
-        fileCount,
-        codeLines,
-        dependencyDepth,
-        domainKnowledge,
-        riskLevel
-      }
-    };
-  }
-  estimateCodeLines(task) {
-    return task.files.include.length * 50;
-  }
-  estimateDomainKnowledge(task) {
+    let domainKnowledge = 0;
     const keywords = ["security", "auth", "payment", "crypto", "database"];
-    let score = 0;
     for (const keyword of keywords) {
       if (task.description.toLowerCase().includes(keyword)) {
-        score += 20;
+        domainKnowledge += 20;
       }
     }
-    return Math.min(100, score);
-  }
-  estimateRiskLevel(task) {
+    domainKnowledge = Math.min(100, domainKnowledge);
+    let riskLevel = "low";
     const highRiskKeywords = ["migration", "production", "security", "payment"];
-    const mediumRiskKeywords = ["refactor", "update", "modify"];
     for (const keyword of highRiskKeywords) {
       if (task.description.toLowerCase().includes(keyword)) {
-        return "high";
-      }
-    }
-    for (const keyword of mediumRiskKeywords) {
-      if (task.description.toLowerCase().includes(keyword)) {
-        return "medium";
+        riskLevel = "high";
+        break;
       }
     }
-    return "low";
+    const overall = Math.min(100, fileCount * 10 + codeLines / 10 + dependencyDepth * 15 + domainKnowledge * 20 + (riskLevel === "high" ? 30 : riskLevel === "medium" ? 15 : 0));
+    return {
+      overall,
+      factors: { fileCount, codeLines, dependencyDepth, domainKnowledge, riskLevel }
+    };
   }
   selectModel(role, complexity) {
     const configModel = this.configManager.getModelForRole(role);
@@ -8915,6 +9012,7 @@ class NexusOrchestrator {
     const modelCost = this.costByModel.get(model) || 0;
     this.costByModel.set(model, modelCost + cost);
     this.checkBudget();
+    this.notifyStateChange();
   }
   checkBudget() {
     const remaining = this.budget.maxTotalCost - this.totalSpent;
@@ -8943,21 +9041,10 @@ class NexusOrchestrator {
     this.subscribers.set(topic, handlers);
     return () => {
       const idx = handlers.indexOf(handler);
-      if (idx > -1) {
+      if (idx > -1)
         handlers.splice(idx, 1);
-      }
     };
   }
-  send(agentId, message) {
-    const fullMessage = {
-      ...message,
-      id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-      to: agentId,
-      timestamp: new Date
-    };
-    this.messageQueue.push(fullMessage);
-    this.emit("message:sent", fullMessage);
-  }
   setMemory(scope, key, value, author) {
     const entry = {
       id: `mem-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
@@ -8975,71 +9062,42 @@ class NexusOrchestrator {
   getMemory(scope, key) {
     return this.memory.get(`${scope}:${key}`);
   }
-  searchMemory(query, scope) {
-    const results = [];
-    this.memory.forEach((entry) => {
-      if (scope && entry.scope !== scope)
-        return;
-      if (entry.key.includes(query) || JSON.stringify(entry.value).includes(query)) {
-        results.push(entry);
-      }
-    });
-    return results;
-  }
   getStatus(detailed) {
-    const status = {
-      running: this.running,
-      paused: this.paused,
-      agents: this.agents.size,
-      tasks: this.tasks.size,
-      totalCost: this.totalSpent,
-      budgetRemaining: this.budget.maxTotalCost - this.totalSpent
-    };
-    if (detailed) {
-      return JSON.stringify({
-        ...status,
-        agentsByStatus: this.getAgentsByStatus(),
-        costByAgent: Object.fromEntries(this.costByAgent),
-        costByModel: Object.fromEntries(this.costByModel)
-      }, null, 2);
-    }
-    return JSON.stringify(status, null, 2);
+    const state = this.getState();
+    if (detailed)
+      return JSON.stringify(state, null, 2);
+    return JSON.stringify({
+      running: state.running,
+      paused: state.paused,
+      agents: state.agents.length,
+      tasks: state.tasks.length,
+      totalCost: state.totalSpent,
+      budgetRemaining: state.budgetRemaining
+    }, null, 2);
   }
   listAgents(filter) {
-    const agents = Array.from(this.agents.values());
-    const filtered = filter ? agents.filter((a) => a.status === filter) : agents;
+    const state = this.getState();
+    const filtered = filter ? state.agents.filter((a) => a.status === filter) : state.agents;
     return JSON.stringify(filtered, null, 2);
   }
   getCostReport() {
-    const report = {
-      totalSpent: this.totalSpent,
-      budgetRemaining: this.budget.maxTotalCost - this.totalSpent,
-      byAgent: new Map,
-      byModel: new Map,
-      timeline: []
-    };
-    this.agents.forEach((agent) => {
-      report.byAgent.set(agent.id, {
-        agentId: agent.id,
-        agentName: agent.name,
-        totalCost: agent.metrics.totalCost,
-        tokenCount: agent.metrics.totalTokens,
-        taskCount: agent.metrics.tasksCompleted
-      });
-    });
+    const state = this.getState();
     return JSON.stringify({
-      ...report,
-      byAgent: Object.fromEntries(report.byAgent),
-      byModel: Object.fromEntries(report.byModel)
+      totalSpent: state.totalSpent,
+      budgetRemaining: state.budgetRemaining,
+      byAgent: Object.fromEntries(this.costByAgent),
+      byModel: Object.fromEntries(this.costByModel)
     }, null, 2);
   }
   pause() {
     this.paused = true;
     this.emit("orchestrator:paused", {});
+    this.notifyStateChange();
   }
   resume() {
     this.paused = false;
     this.emit("orchestrator:resumed", {});
+    this.notifyStateChange();
   }
   shutdown() {
     this.agents.forEach((agent) => {
@@ -9048,25 +9106,18 @@ class NexusOrchestrator {
     this.agents.clear();
     this.running = false;
     this.emit("orchestrator:shutdown", {});
+    this.notifyStateChange();
   }
   collectResults() {
     const results = [];
     if (this.dag) {
       this.dag.nodes.forEach((node) => {
-        if (node.result) {
+        if (node.result)
           results.push(node.result);
-        }
       });
     }
     return results;
   }
-  getAgentsByStatus() {
-    const counts = {};
-    this.agents.forEach((agent) => {
-      counts[agent.status] = (counts[agent.status] || 0) + 1;
-    });
-    return counts;
-  }
   sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
@@ -9076,9 +9127,8 @@ class NexusOrchestrator {
     this.eventHandlers.set(event, handlers);
     return () => {
       const idx = handlers.indexOf(handler);
-      if (idx > -1) {
+      if (idx > -1)
         handlers.splice(idx, 1);
-      }
     };
   }
   emit(event, data) {
@@ -9090,22 +9140,21 @@ class NexusOrchestrator {
     const command = parts[1];
     switch (command) {
       case "status":
-        console.log(this.getStatus(true));
-        break;
+        return this.getStatus(true);
       case "agents":
-        console.log(this.listAgents(parts[2]));
-        break;
+        return this.listAgents(parts[2]);
       case "costs":
-        console.log(this.getCostReport());
-        break;
+        return this.getCostReport();
       case "pause":
         this.pause();
-        break;
+        return "Orchestrator paused";
       case "resume":
         this.resume();
-        break;
+        return "Orchestrator resumed";
+      case "dashboard":
+        return JSON.stringify(this.getState(), null, 2);
       default:
-        console.log("Unknown command. Use /nexus help");
+        return "Unknown command. Available: status, agents, costs, pause, resume, dashboard";
     }
   }
 }
@@ -9115,6 +9164,11 @@ var src_default = define({
   id: "nexus",
   async setup(ctx) {
     const orchestrator = new NexusOrchestrator;
+    orchestrator.initialize(ctx, () => {
+      const state = orchestrator.getState();
+      ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(state))).catch(() => {});
+    });
+    await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
     await ctx.tool.transform((editor) => {
       editor.namespace({
         name: "nexus",
@@ -9132,7 +9186,9 @@ var src_default = define({
         },
         execute: async (input) => {
           const { detailed } = input;
-          return { content: orchestrator.getStatus(detailed) };
+          const status = orchestrator.getStatus(detailed);
+          await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
+          return { content: status };
         }
       });
       editor.add({
@@ -9162,10 +9218,53 @@ var src_default = define({
           return { content: orchestrator.getCostReport() };
         }
       });
+      editor.add({
+        name: "dashboard",
+        description: "Get full orchestrator state for dashboard display",
+        input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        execute: async () => {
+          const state = orchestrator.getState();
+          await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(state)));
+          return { content: JSON.stringify(state, null, 2) };
+        }
+      });
+      editor.add({
+        name: "spawn",
+        description: "Spawn a sub-agent for a task",
+        input: {
+          type: "object",
+          properties: {
+            role: { type: "string", description: "Agent role (architect, coder, reviewer, tester, explorer, documenter)" },
+            task: { type: "string", description: "Task description" },
+            model: { type: "string", description: "Model override (optional)" }
+          },
+          required: ["role", "task"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { role, task, model } = input;
+          try {
+            const agent = await orchestrator.spawnAgent({ role, model });
+            await orchestrator.ctx.session.prompt({
+              sessionID: agent.sessionID,
+              text: task
+            });
+            await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
+            return { content: `Spawned ${role} agent (${agent.id}) on session ${agent.sessionID}. Task sent.` };
+          } catch (error) {
+            return { content: `Failed to spawn agent: ${error.message}` };
+          }
+        }
+      });
     });
     await ctx.session.hook("prompt", (event) => {
-      if (event.prompt.text.includes("/nexus")) {
-        orchestrator.handleCommand(event.prompt.text);
+      if (event.prompt.text.startsWith("/nexus")) {
+        const result = orchestrator.handleCommand(event.prompt.text);
+        event.metadata = { ...event.metadata, nexusResult: result };
       }
     });
     return () => {

package/dist/tui.js

@@ -34207,6 +34207,48 @@ var tui_default = define({
         variant: "success"
       });
     };
+    const handleDashboard = async () => {
+      const config = configManager.getConfig();
+      const lines = [
+        "⚡ Nexus Dashboard",
+        "═══════════════════════════════════",
+        "",
+        "\uD83E\uDD16 Agent Models:"
+      ];
+      for (const role of configManager.getRoles()) {
+        const model = config.models[role] || "(not set)";
+        const displayName = configManager.getRoleDisplayName(role);
+        lines.push(`  ${displayName}: ${model}`);
+      }
+      lines.push("");
+      lines.push("\uD83D\uDCB0 Budget:");
+      lines.push(`  Max Total: $${config.budget.maxTotalCost}`);
+      lines.push(`  Max Per Task: $${config.budget.maxCostPerTask}`);
+      lines.push(`  Alert Threshold: ${config.budget.alertThreshold * 100}%`);
+      lines.push("");
+      lines.push("\uD83D\uDEE1️ Self-Healing:");
+      lines.push(`  Enabled: ${config.selfHealing.enabled ? "✅" : "❌"}`);
+      lines.push(`  Max Retries: ${config.selfHealing.maxRetries}`);
+      lines.push("");
+      lines.push("\uD83D\uDCA1 Commands:");
+      lines.push("  /nexus status   - Show config summary");
+      lines.push("  /nexus config   - Configure models & budget");
+      lines.push("  /nexus model    - Select model for role");
+      lines.push("  /nexus reset    - Reset to defaults");
+      lines.push("");
+      lines.push("\uD83D\uDD27 Tools (use in agent prompt):");
+      lines.push("  nexus.status    - Orchestrator status");
+      lines.push("  nexus.agents    - List spawned agents");
+      lines.push("  nexus.costs     - Cost report");
+      lines.push("  nexus.spawn     - Spawn a sub-agent");
+      context.ui.toast.show({
+        title: "Nexus Dashboard",
+        message: lines.join(`
+`),
+        variant: "info",
+        duration: 15000
+      });
+    };
     context.ui.slot({
       append: "app",
       render: () => {
@@ -34241,6 +34283,10 @@ var tui_default = define({
                         duration: 8000
                       });
                       break;
+                    case "dashboard":
+                    case "d":
+                      await handleDashboard();
+                      break;
                     case "model":
                     case "m":
                       if (parts[1]) {
@@ -34277,7 +34323,7 @@ var tui_default = define({
                     default:
                       context.ui.toast.show({
                         title: "Nexus",
-                        message: "Commands: config, status, model <role>, reset",
+                        message: "Commands: config, status, dashboard, model <role>, reset",
                         variant: "info"
                       });
                   }
@@ -34298,6 +34344,18 @@ var tui_default = define({
                 await handleFullConfig();
               }
             },
+            {
+              id: "nexus.dashboard",
+              title: "Nexus Dashboard",
+              group: "Nexus",
+              palette: true,
+              slash: { name: "nexus-dashboard", aliases: ["nd"], arguments: true },
+              enabled: () => true,
+              suggested: true,
+              run: async () => {
+                await handleDashboard();
+              }
+            },
             {
               id: "nexus.model",
               title: "Select Agent Model",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serkanalgur/opencode-nexus",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Adaptive Multi-Agent Orchestration with Cost Intelligence for OpenCode V2",
   "keywords": [
     "opencode",