@serkanalgur/opencode-nexus 1.0.3 → 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

@@ -62,9 +62,6 @@ function createContext(defaultValue) {
     defaultValue
   };
 }
-function useContext(context) {
-  return Owner && Owner.context && Owner.context[context.id] !== undefined ? Owner.context[context.id] : context.defaultValue;
-}
 function children(fn) {
   const memo = createMemo(() => resolveChildren(fn()));
   memo.toArray = () => {
@@ -109,12 +106,6 @@ var SuspenseContext = createContext();
 
 // node_modules/@opencode/plugin/dist/tui/solid.js
 var PluginContext = createContext();
-function usePlugin() {
-  const context = useContext(PluginContext);
-  if (!context)
-    throw new Error("PluginContextProvider is missing");
-  return context;
-}
 // src/config.ts
 var DEFAULT_CONFIG = {
   models: {
@@ -34140,113 +34131,242 @@ function jsx(type, props = {}) {
 function jsxDEV(type, props = {}) {
   return jsx(type, props);
 }
+function Fragment(props) {
+  return props.children ?? null;
+}
 // src/tui.tsx
-function NexusKeymapSlot() {
-  const context = usePlugin();
-  const configManager = new NexusConfigManager;
-  const handleModelSelect = async (role) => {
-    if (!configManager.getRoles().includes(role)) {
-      context.ui.toast.show({
-        title: "Nexus",
-        message: `Unknown role: ${role}. Valid: ${configManager.getRoles().join(", ")}`,
-        variant: "error"
+var tui_default = define({
+  id: "nexus.cli",
+  setup(context) {
+    const configManager = new NexusConfigManager;
+    const handleModelSelect = async (role) => {
+      if (!configManager.getRoles().includes(role)) {
+        context.ui.toast.show({
+          title: "Nexus",
+          message: `Unknown role: ${role}. Valid: ${configManager.getRoles().join(", ")}`,
+          variant: "error"
+        });
+        return;
+      }
+      const location = context.location ?? context.data.location.default();
+      await context.data.location.model.sync(location);
+      const availableModels = context.data.location.model.list(location) ?? [];
+      const options = availableModels.map((m) => ({
+        title: m.name || m.id,
+        value: `${m.providerID}/${m.id}`,
+        description: m.providerID
+      }));
+      options.push({
+        title: "Use default",
+        value: "",
+        description: "Reset to default model"
       });
-      return;
-    }
-    const location = context.location ?? context.data.location.default();
-    await context.data.location.model.sync(location);
-    const availableModels = context.data.location.model.list(location) ?? [];
-    const options = availableModels.map((m) => ({
-      title: m.name || m.id,
-      value: `${m.providerID}/${m.id}`,
-      description: m.providerID
-    }));
-    options.push({
-      title: "Use default",
-      value: "",
-      description: "Reset to default model"
-    });
-    const current = configManager.getModelForRole(role);
-    const selected = await context.ui.dialog.select({
-      title: `${configManager.getRoleDisplayName(role)} Model`,
-      current: current || "",
-      options
-    });
-    if (selected !== null && selected !== undefined) {
-      configManager.setModel(role, selected);
-      context.ui.toast.show({
-        title: "Nexus",
-        message: `${role} → ${selected || "default"}`,
-        variant: "success"
+      const current = configManager.getModelForRole(role);
+      const selected = await context.ui.dialog.select({
+        title: `${configManager.getRoleDisplayName(role)} Model`,
+        current: current || "",
+        options
       });
-    }
-  };
-  const handleConfigDialog = async () => {
-    const config = configManager.getConfig();
-    const budgetStr = await context.ui.dialog.prompt({
-      title: "Max Total Budget ($)",
-      placeholder: String(config.budget.maxTotalCost)
-    });
-    if (budgetStr !== null && budgetStr !== undefined) {
-      const budget = parseFloat(budgetStr);
-      if (!isNaN(budget) && budget > 0) {
-        configManager.updateStorageConfig({
-          budget: { ...config.budget, maxTotalCost: budget }
-        });
+      if (selected !== null && selected !== undefined) {
+        configManager.setModel(role, selected);
         context.ui.toast.show({
           title: "Nexus",
-          message: `Budget updated: $${budget}`,
+          message: `${role} → ${selected || "default"}`,
           variant: "success"
         });
       }
-    }
-  };
-  const handleFullConfig = async () => {
-    for (const role of configManager.getRoles()) {
-      await handleModelSelect(role);
-    }
-    await handleConfigDialog();
-    context.ui.toast.show({
-      title: "Nexus",
-      message: "Configuration complete!",
-      variant: "success"
-    });
-  };
-  context.keymap.layer(() => ({
-    mode: "global",
-    priority: 10,
-    commands: [
-      {
-        id: "nexus",
-        title: "Nexus Configuration",
-        group: "Nexus",
-        bind: "ctrl+n",
-        palette: true,
-        slash: { name: "nexus", aliases: [], arguments: true },
-        enabled: () => true,
-        suggested: true,
-        run: async (input) => {
-          if (input) {
-            const parts = input.split(" ");
-            const cmd = parts[0];
-            switch (cmd) {
-              case "config":
-              case "c":
+    };
+    const handleConfigDialog = async () => {
+      const config = configManager.getConfig();
+      const budgetStr = await context.ui.dialog.prompt({
+        title: "Max Total Budget ($)",
+        placeholder: String(config.budget.maxTotalCost)
+      });
+      if (budgetStr !== null && budgetStr !== undefined) {
+        const budget = parseFloat(budgetStr);
+        if (!isNaN(budget) && budget > 0) {
+          configManager.updateStorageConfig({
+            budget: { ...config.budget, maxTotalCost: budget }
+          });
+          context.ui.toast.show({
+            title: "Nexus",
+            message: `Budget updated: $${budget}`,
+            variant: "success"
+          });
+        }
+      }
+    };
+    const handleFullConfig = async () => {
+      for (const role of configManager.getRoles()) {
+        await handleModelSelect(role);
+      }
+      await handleConfigDialog();
+      context.ui.toast.show({
+        title: "Nexus",
+        message: "Configuration complete!",
+        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: () => {
+        context.keymap.layer(() => ({
+          mode: "global",
+          priority: 10,
+          commands: [
+            {
+              id: "nexus",
+              title: "Nexus Configuration",
+              group: "Nexus",
+              bind: "ctrl+n",
+              palette: true,
+              slash: { name: "nexus", aliases: [], arguments: true },
+              enabled: () => true,
+              suggested: true,
+              run: async (input) => {
+                if (input) {
+                  const parts = input.split(" ");
+                  const cmd = parts[0];
+                  switch (cmd) {
+                    case "config":
+                    case "c":
+                      await handleFullConfig();
+                      break;
+                    case "status":
+                    case "s":
+                      context.ui.toast.show({
+                        title: "Nexus Status",
+                        message: configManager.getSummary(),
+                        variant: "info",
+                        duration: 8000
+                      });
+                      break;
+                    case "dashboard":
+                    case "d":
+                      await handleDashboard();
+                      break;
+                    case "model":
+                    case "m":
+                      if (parts[1]) {
+                        await handleModelSelect(parts[1]);
+                      } else {
+                        const role = await context.ui.dialog.select({
+                          title: "Select Agent Role",
+                          options: configManager.getRoles().map((r) => ({
+                            title: configManager.getRoleDisplayName(r),
+                            value: r,
+                            description: `Current: ${configManager.getModelForRole(r)}`
+                          }))
+                        });
+                        if (role) {
+                          await handleModelSelect(role);
+                        }
+                      }
+                      break;
+                    case "reset":
+                      const confirmed = await context.ui.dialog.confirm({
+                        title: "Reset Configuration",
+                        message: "Reset all Nexus settings to defaults?",
+                        label: { confirm: "Reset", cancel: "Cancel" }
+                      });
+                      if (confirmed) {
+                        configManager.resetToDefaults();
+                        context.ui.toast.show({
+                          title: "Nexus",
+                          message: "Configuration reset to defaults",
+                          variant: "success"
+                        });
+                      }
+                      break;
+                    default:
+                      context.ui.toast.show({
+                        title: "Nexus",
+                        message: "Commands: config, status, dashboard, model <role>, reset",
+                        variant: "info"
+                      });
+                  }
+                } else {
+                  await handleFullConfig();
+                }
+              }
+            },
+            {
+              id: "nexus.config",
+              title: "Nexus Configuration",
+              group: "Nexus",
+              palette: true,
+              slash: { name: "nexus-config", aliases: ["nc"], arguments: true },
+              enabled: () => true,
+              suggested: true,
+              run: async () => {
                 await handleFullConfig();
-                break;
-              case "status":
-              case "s":
-                context.ui.toast.show({
-                  title: "Nexus Status",
-                  message: configManager.getSummary(),
-                  variant: "info",
-                  duration: 8000
-                });
-                break;
-              case "model":
-              case "m":
-                if (parts[1]) {
-                  await handleModelSelect(parts[1]);
+              }
+            },
+            {
+              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",
+              group: "Nexus",
+              palette: true,
+              slash: { name: "nexus-model", aliases: ["nm"], arguments: true },
+              enabled: () => true,
+              suggested: true,
+              run: async (input) => {
+                if (input) {
+                  await handleModelSelect(input);
                 } else {
                   const role = await context.ui.dialog.select({
                     title: "Select Agent Role",
@@ -34260,8 +34380,33 @@ function NexusKeymapSlot() {
                     await handleModelSelect(role);
                   }
                 }
-                break;
-              case "reset":
+              }
+            },
+            {
+              id: "nexus.status",
+              title: "Nexus Status",
+              group: "Nexus",
+              palette: true,
+              slash: { name: "nexus-status", aliases: ["ns"], arguments: true },
+              enabled: () => true,
+              suggested: true,
+              run: async () => {
+                context.ui.toast.show({
+                  title: "Nexus Status",
+                  message: configManager.getSummary(),
+                  variant: "info",
+                  duration: 8000
+                });
+              }
+            },
+            {
+              id: "nexus.reset",
+              title: "Reset Nexus Config",
+              group: "Nexus",
+              palette: true,
+              slash: { name: "nexus-reset", aliases: [], arguments: true },
+              enabled: () => true,
+              run: async () => {
                 const confirmed = await context.ui.dialog.confirm({
                   title: "Reset Configuration",
                   message: "Reset all Nexus settings to defaults?",
@@ -34275,108 +34420,13 @@ function NexusKeymapSlot() {
                     variant: "success"
                   });
                 }
-                break;
-              default:
-                context.ui.toast.show({
-                  title: "Nexus",
-                  message: "Commands: config, status, model <role>, reset",
-                  variant: "info"
-                });
-            }
-          } else {
-            await handleFullConfig();
-          }
-        }
-      },
-      {
-        id: "nexus.config",
-        title: "Nexus Configuration",
-        group: "Nexus",
-        palette: true,
-        slash: { name: "nexus-config", aliases: ["nc"], arguments: true },
-        enabled: () => true,
-        suggested: true,
-        run: async () => {
-          await handleFullConfig();
-        }
-      },
-      {
-        id: "nexus.model",
-        title: "Select Agent Model",
-        group: "Nexus",
-        palette: true,
-        slash: { name: "nexus-model", aliases: ["nm"], arguments: true },
-        enabled: () => true,
-        suggested: true,
-        run: async (input) => {
-          if (input) {
-            await handleModelSelect(input);
-          } else {
-            const role = await context.ui.dialog.select({
-              title: "Select Agent Role",
-              options: configManager.getRoles().map((r) => ({
-                title: configManager.getRoleDisplayName(r),
-                value: r,
-                description: `Current: ${configManager.getModelForRole(r)}`
-              }))
-            });
-            if (role) {
-              await handleModelSelect(role);
+              }
             }
-          }
-        }
-      },
-      {
-        id: "nexus.status",
-        title: "Nexus Status",
-        group: "Nexus",
-        palette: true,
-        slash: { name: "nexus-status", aliases: ["ns"], arguments: true },
-        enabled: () => true,
-        suggested: true,
-        run: async () => {
-          context.ui.toast.show({
-            title: "Nexus Status",
-            message: configManager.getSummary(),
-            variant: "info",
-            duration: 8000
-          });
-        }
-      },
-      {
-        id: "nexus.reset",
-        title: "Reset Nexus Config",
-        group: "Nexus",
-        palette: true,
-        slash: { name: "nexus-reset", aliases: [], arguments: true },
-        enabled: () => true,
-        run: async () => {
-          const confirmed = await context.ui.dialog.confirm({
-            title: "Reset Configuration",
-            message: "Reset all Nexus settings to defaults?",
-            label: { confirm: "Reset", cancel: "Cancel" }
-          });
-          if (confirmed) {
-            configManager.resetToDefaults();
-            context.ui.toast.show({
-              title: "Nexus",
-              message: "Configuration reset to defaults",
-              variant: "success"
-            });
-          }
-        }
+          ],
+          bindings: ["nexus"]
+        }));
+        return /* @__PURE__ */ jsxDEV(Fragment, {}, undefined, false, undefined, this);
       }
-    ],
-    bindings: ["nexus"]
-  }));
-  return null;
-}
-var tui_default = define({
-  id: "nexus.cli",
-  setup(context) {
-    context.ui.slot({
-      append: "app",
-      render: () => /* @__PURE__ */ jsxDEV(NexusKeymapSlot, {}, undefined, false, undefined, this)
     });
     context.ui.toast.show({
       title: "⚡ Nexus Loaded",

package/package.json

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