@serkanalgur/opencode-nexus 1.3.0 → 1.4.1

package/README.md

@@ -147,14 +147,14 @@ await ctx.session.prompt({ sessionID: session.id, text: 'You are a senior softwa
 
 Each agent role gets a specialized prompt:
 
-| Role | Focus |
-|------|-------|
-| **Architect** | System design, architecture patterns, high-level decisions |
-| **Coder** | Clean, efficient code following best practices |
-| **Reviewer** | Code review for correctness, security, performance |
-| **Tester** | Comprehensive tests, edge cases, quality assurance |
-| **Explorer** | Codebase navigation, architecture analysis |
-| **Documenter** | Clear technical documentation |
+| Role | OpenCode Agent | Focus |
+|------|----------------|-------|
+| **Architect** | `architect` | System design, architecture patterns, high-level decisions |
+| **Coder** | `build-orchestrator` | Clean, efficient code following best practices |
+| **Reviewer** | `code-reviewer` | Code review for correctness, security, performance |
+| **Tester** | `build-orchestrator` | Comprehensive tests, edge cases, quality assurance |
+| **Explorer** | `explore` | Codebase navigation, architecture analysis |
+| **Documenter** | `doc-writer` | Clear technical documentation |
 
 ### Cost-Aware Model Selection
 
@@ -278,6 +278,68 @@ NexusPlugin.register({
 })
 ```
 
+### Custom Agent Roles
+
+Define your own agent roles with custom prompts:
+
+```jsonc
+// .opencode/nexus.jsonc
+{
+  "customRoles": [
+    {
+      "name": "security-auditor",
+      "displayName": "Security Auditor",
+      "emoji": "🔐",
+      "prompt": "You are a security auditor. Focus on OWASP Top 10, vulnerability scanning, and security best practices.",
+      "model": "anthropic/claude-sonnet-4-6"
+    }
+  ]
+}
+```
+
+Or register dynamically via tools: `nexus.roles.add(name="security-auditor", displayName="Security Auditor", prompt="...")`
+
+### Execution History
+
+Track all task executions with costs, durations, and outcomes:
+
+```
+nexus.history.list(count=10)  — Recent executions
+nexus.history.stats()         — Success rate, avg cost, breakdown by role
+```
+
+### Cost Forecasting
+
+Predict costs before executing tasks:
+
+```typescript
+const forecast = orchestrator.forecaster.forecastAll([
+  { task: myTask, role: 'coder', model: 'claude-sonnet-4-6', complexity: score }
+], budgetRemaining)
+// → { totalEstimatedCost: 0.0234, withinBudget: true }
+```
+
+### Agent Performance Scoring
+
+Track which model/role combinations work best:
+
+```
+nexus.performance.scores()           — All model/role scores
+nexus.performance.best(role="coder") — Best model for a role
+```
+
+Score = 40% success rate + 30% speed + 30% cost efficiency.
+
+### Git Worktree Per Agent
+
+Each agent works in its own isolated git worktree:
+
+```
+nexus.worktree.enable()   — Enable isolation
+nexus.worktree.list()     — List active worktrees
+nexus.worktree.disable()  — Clean up all
+```
+
 ---
 
 ## TUI Commands
@@ -313,6 +375,18 @@ Register these tools in your agent prompts:
 | `nexus.dashboard.stop` | Stop web dashboard | `{}` |
 | `nexus.preset` | Apply preset config | `{ name: string }` |
 | `nexus.template` | List/instantiate templates | `{ name?: string, baseDir?: string }` |
+| `nexus.model.costs` | Show/set model pricing | `{ model?: string, setInput?: number, setOutput?: number }` |
+| `nexus.security.scan` | Scan code for security issues | `{ content: string, filename?: string }` |
+| `nexus.roles.list` | List custom agent roles | `{}` |
+| `nexus.roles.add` | Add a custom role | `{ name, displayName, prompt, emoji?, model? }` |
+| `nexus.history.list` | List execution history | `{ count?: number }` |
+| `nexus.history.stats` | Execution statistics | `{}` |
+| `nexus.forecast` | Predict costs before execution | `{ tasks: string }` |
+| `nexus.performance.scores` | Model/role performance scores | `{}` |
+| `nexus.performance.best` | Best model for a role | `{ role: string }` |
+| `nexus.worktree.enable` | Enable git worktree isolation | `{ repoRoot?: string }` |
+| `nexus.worktree.list` | List active worktrees | `{}` |
+| `nexus.worktree.disable` | Disable and clean up | `{}` |
 
 ### Tool Examples
 

package/dist/index.js

@@ -8817,6 +8817,7 @@ class StateBroadcaster {
 }
 
 // src/dashboard.ts
+import { join as join2 } from "node:path";
 var CORS_HEADERS = {
   "Access-Control-Allow-Origin": "*",
   "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
@@ -8871,6 +8872,16 @@ class DashboardModule {
           if (url.pathname === "/api/health") {
             return jsonResponse({ ok: true, uptime: process.uptime() });
           }
+          try {
+            const spaPath = join2(process.cwd(), "dashboard", "index.html");
+            const spaFile = Bun.file(spaPath);
+            const exists = spaFile.size > 0;
+            if (exists) {
+              return new Response(spaFile, {
+                headers: { "Content-Type": "text/html; charset=utf-8", ...CORS_HEADERS }
+              });
+            }
+          } catch {}
           return new Response("Nexus Dashboard API", {
             headers: {
               "Content-Type": "text/plain",
@@ -8973,9 +8984,9 @@ function detectCycles(nodes) {
 
 // src/message-store.ts
 import { appendFileSync, readFileSync as readFileSync2, existsSync, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join2, dirname as dirname2 } from "node:path";
+import { join as join3, dirname as dirname2 } from "node:path";
 var DEFAULT_CONFIG2 = {
-  storagePath: join2(process.env.HOME || "~", ".local", "share", "opencode-nexus", "messages.jsonl"),
+  storagePath: join3(process.env.HOME || "~", ".local", "share", "opencode-nexus", "messages.jsonl"),
   maxMessages: 1e4,
   rotationSize: 1000
 };
@@ -9063,10 +9074,10 @@ class MessageStore {
 
 // src/memory-store.ts
 import { Database } from "bun:sqlite";
-import { join as join3, dirname as dirname3 } from "node:path";
+import { join as join4, dirname as dirname3 } from "node:path";
 import { mkdirSync as mkdirSync3 } from "node:fs";
 var DEFAULT_CONFIG3 = {
-  dbPath: join3(process.env.HOME || "~", ".local", "share", "opencode-nexus", "memory.db"),
+  dbPath: join4(process.env.HOME || "~", ".local", "share", "opencode-nexus", "memory.db"),
   defaultTTL: 0,
   maxEntries: 1e4
 };
@@ -9695,6 +9706,255 @@ class SecurityScanner {
   }
 }
 
+// src/performance.ts
+class PerformanceTracker {
+  entries = [];
+  maxEntries;
+  constructor(maxEntries = 1000) {
+    this.maxEntries = maxEntries;
+  }
+  record(entry) {
+    this.entries.push({ ...entry, timestamp: new Date });
+    if (this.entries.length > this.maxEntries) {
+      this.entries = this.entries.slice(-this.maxEntries);
+    }
+  }
+  getScores() {
+    const groups = new Map;
+    for (const entry of this.entries) {
+      const key = `${entry.model}::${entry.role}`;
+      const group = groups.get(key) || [];
+      group.push(entry);
+      groups.set(key, group);
+    }
+    const scores = [];
+    for (const [key, entries] of groups) {
+      const [model, role] = key.split("::");
+      const total = entries.length;
+      const successful = entries.filter((e) => e.success).length;
+      const successRate = total > 0 ? successful / total : 0;
+      const avgDuration = entries.reduce((s, e) => s + e.duration, 0) / total;
+      const avgCost = entries.reduce((s, e) => s + e.cost, 0) / total;
+      const costEfficiency = avgCost > 0 ? successRate / avgCost : 0;
+      const speedScore = Math.max(0, 1 - avgDuration / 30000);
+      const costScore = Math.min(1, costEfficiency * 100);
+      const overallScore = successRate * 40 + speedScore * 30 + costScore * 30;
+      scores.push({ model, role, totalTasks: total, successRate, avgDuration, avgCost, costEfficiency, overallScore });
+    }
+    return scores.sort((a, b) => b.overallScore - a.overallScore);
+  }
+  getBestModel(role) {
+    const scores = this.getScores().filter((s) => s.role === role);
+    return scores[0] || null;
+  }
+  getStats() {
+    const unique = new Set(this.entries.map((e) => `${e.model}::${e.role}`));
+    const successRate = this.entries.length > 0 ? this.entries.filter((e) => e.success).length / this.entries.length : 0;
+    return { totalEntries: this.entries.length, uniqueCombinations: unique.size, avgSuccessRate: successRate };
+  }
+  clear() {
+    this.entries = [];
+  }
+}
+
+// src/history.ts
+class ExecutionHistory {
+  records = [];
+  maxRecords;
+  constructor(maxRecords = 500) {
+    this.maxRecords = maxRecords;
+  }
+  record(entry) {
+    const full = {
+      ...entry,
+      id: `exec-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`
+    };
+    this.records.push(full);
+    if (this.records.length > this.maxRecords) {
+      this.records = this.records.slice(-this.maxRecords);
+    }
+    return full;
+  }
+  getAll() {
+    return [...this.records];
+  }
+  getRecent(count) {
+    return this.records.slice(-count);
+  }
+  getByRole(role) {
+    return this.records.filter((r) => r.role === role);
+  }
+  getByStatus(status) {
+    return this.records.filter((r) => r.status === status);
+  }
+  getStats() {
+    const total = this.records.length;
+    const successful = this.records.filter((r) => r.status === "success").length;
+    const totalCost = this.records.reduce((sum, r) => sum + r.cost, 0);
+    const avgDuration = total > 0 ? this.records.reduce((sum, r) => sum + r.duration, 0) / total : 0;
+    const byRole = {};
+    for (const r of this.records) {
+      byRole[r.role] = (byRole[r.role] || 0) + 1;
+    }
+    return { total, successRate: total > 0 ? successful / total : 0, totalCost, avgDuration, byRole };
+  }
+  clear() {
+    this.records = [];
+  }
+}
+
+// src/custom-roles.ts
+class CustomRoleManager {
+  roles = new Map;
+  register(role) {
+    this.roles.set(role.name, role);
+  }
+  unregister(name) {
+    return this.roles.delete(name);
+  }
+  get(name) {
+    return this.roles.get(name);
+  }
+  list() {
+    return [...this.roles.values()];
+  }
+  getPrompt(name) {
+    return this.roles.get(name)?.prompt ?? null;
+  }
+  getEmoji(name) {
+    return this.roles.get(name)?.emoji ?? "\uD83E\uDD16";
+  }
+  has(name) {
+    return this.roles.has(name);
+  }
+  loadFromConfig(config) {
+    if (config.customRoles && Array.isArray(config.customRoles)) {
+      for (const role of config.customRoles) {
+        this.register(role);
+      }
+    }
+  }
+}
+
+// src/forecast.ts
+class CostForecaster {
+  modelPricing = new Map;
+  constructor() {
+    this.modelPricing.set("claude-sonnet-4-6", { input: 0.000015, output: 0.000075 });
+    this.modelPricing.set("claude-opus-4-7", { input: 0.000075, output: 0.000375 });
+    this.modelPricing.set("claude-haiku-4-5", { input: 0.000001, output: 0.000005 });
+    this.modelPricing.set("gpt-5-mini", { input: 0.00000015, output: 0.0000006 });
+    this.modelPricing.set("gpt-5", { input: 0.0000025, output: 0.00001 });
+    this.modelPricing.set("gemini-2.5-flash", { input: 0.000000075, output: 0.0000003 });
+  }
+  updatePricing(modelId, input, output) {
+    this.modelPricing.set(modelId, { input, output });
+  }
+  estimateTokens(task, complexity) {
+    const baseInput = 700;
+    const complexityMultiplier = 1 + complexity.overall / 100 * 3;
+    const fileMultiplier = 1 + task.files.include.length * 0.2;
+    const input = Math.round(baseInput * complexityMultiplier * fileMultiplier);
+    const output = Math.round(input * 0.5);
+    return { input, output };
+  }
+  forecastTask(task, role, modelId, complexity) {
+    const { input, output } = this.estimateTokens(task, complexity);
+    const pricing = this.modelPricing.get(modelId) || { input: 0.00001, output: 0.00005 };
+    const inputCost = input * pricing.input;
+    const outputCost = output * pricing.output;
+    const overhead = 0.0001;
+    return {
+      taskId: task.id,
+      taskName: task.name,
+      role,
+      model: modelId,
+      estimatedInputTokens: input,
+      estimatedOutputTokens: output,
+      estimatedCost: inputCost + outputCost + overhead,
+      confidence: 0.6 + Math.random() * 0.3,
+      breakdown: { inputCost, outputCost, overhead }
+    };
+  }
+  forecastAll(tasks, budgetRemaining) {
+    const estimates = tasks.map((t) => this.forecastTask(t.task, t.role, t.model, t.complexity));
+    const totalEstimatedCost = estimates.reduce((sum, e) => sum + e.estimatedCost, 0);
+    return {
+      estimates,
+      totalEstimatedCost,
+      budgetRemaining,
+      withinBudget: totalEstimatedCost <= budgetRemaining
+    };
+  }
+}
+
+// src/worktree.ts
+import { execSync } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+
+class WorktreeManager {
+  worktrees = new Map;
+  baseDir;
+  repoRoot;
+  constructor(repoRoot, baseDir) {
+    this.repoRoot = repoRoot;
+    this.baseDir = baseDir || join5(repoRoot, ".worktrees", "nexus-agents");
+  }
+  create(agentId) {
+    const branch = `nexus-agent-${agentId}`;
+    const path = join5(this.baseDir, agentId);
+    try {
+      if (!existsSync2(this.baseDir)) {
+        execSync(`mkdir -p "${this.baseDir}"`, { cwd: this.repoRoot });
+      }
+      execSync(`git worktree add "${path}" -b "${branch}" 2>/dev/null || git worktree add "${path}" "${branch}" 2>/dev/null || echo "Worktree exists"`, {
+        cwd: this.repoRoot,
+        timeout: 1e4
+      });
+      const wt = { agentId, branch, path, createdAt: new Date };
+      this.worktrees.set(agentId, wt);
+      return wt;
+    } catch (error) {
+      throw new Error(`Failed to create worktree for ${agentId}: ${error.message}`);
+    }
+  }
+  remove(agentId) {
+    const wt = this.worktrees.get(agentId);
+    if (!wt)
+      return false;
+    try {
+      execSync(`git worktree remove "${wt.path}" --force 2>/dev/null`, {
+        cwd: this.repoRoot,
+        timeout: 1e4
+      });
+      execSync(`git branch -D "${wt.branch}" 2>/dev/null`, {
+        cwd: this.repoRoot,
+        timeout: 5000
+      });
+      this.worktrees.delete(agentId);
+      return true;
+    } catch {
+      this.worktrees.delete(agentId);
+      return false;
+    }
+  }
+  get(agentId) {
+    return this.worktrees.get(agentId);
+  }
+  list() {
+    return [...this.worktrees.values()];
+  }
+  cleanupAll() {
+    for (const [id] of this.worktrees) {
+      this.remove(id);
+    }
+  }
+  getPath(agentId) {
+    return this.worktrees.get(agentId)?.path ?? null;
+  }
+}
+
 // src/orchestrator.ts
 var DEFAULT_ESCALATION = {
   maxRetries: 3,
@@ -9732,6 +9992,11 @@ class NexusOrchestrator {
   nodeRetryCounts = new Map;
   moduleRegistry;
   securityScanner;
+  performanceTracker;
+  executionHistory;
+  customRoles;
+  forecaster;
+  worktreeManager = null;
   onStateChange = null;
   stateChangeTimer = null;
   costHistory = [];
@@ -9757,6 +10022,10 @@ class NexusOrchestrator {
     };
     this.learning = new LearningModule(this.config.learning.minConfidence);
     this.securityScanner = new SecurityScanner;
+    this.performanceTracker = new PerformanceTracker;
+    this.executionHistory = new ExecutionHistory;
+    this.customRoles = new CustomRoleManager;
+    this.forecaster = new CostForecaster;
   }
   async initialize(ctx, onStateChange) {
     this.ctx = ctx;
@@ -9852,6 +10121,9 @@ class NexusOrchestrator {
       this.dashboard = null;
     }
   }
+  enableWorktrees(repoRoot) {
+    this.worktreeManager = new WorktreeManager(repoRoot || process.cwd());
+  }
   getState() {
     const agents = Array.from(this.agents.values()).map((a) => ({
       id: a.id,
@@ -10176,6 +10448,26 @@ Please continue from where the previous agent left off.`;
       this.totalSpent += result.cost;
       this.costByAgent.set(agent.id, (this.costByAgent.get(agent.id) || 0) + result.cost);
       this.checkBudget();
+      this.performanceTracker.record({
+        model: agent.model.model,
+        role: node.task.requiredRole,
+        success: result.success,
+        duration: result.duration,
+        cost: result.cost,
+        tokensUsed: result.tokensUsed
+      });
+      this.executionHistory.record({
+        taskId: node.id,
+        taskName: node.task.name,
+        role: node.task.requiredRole,
+        model: agent.model.model,
+        status: "success",
+        cost: result.cost,
+        duration: result.duration,
+        tokensUsed: result.tokensUsed,
+        startedAt: new Date(startTime),
+        completedAt: new Date
+      });
       if (this.notifications?.isEnabled()) {
         this.notifications.notify({ title: "Nexus: Task Complete", body: `${node.task.name} completed successfully` });
       }
@@ -10205,6 +10497,27 @@ Please continue from where the previous agent left off.`;
       };
       this.dag.markFailed(node.id, new Error(result.error));
       agent.metrics.tasksFailed++;
+      this.performanceTracker.record({
+        model: agent.model.model,
+        role: node.task.requiredRole,
+        success: result.success,
+        duration: result.duration,
+        cost: result.cost,
+        tokensUsed: result.tokensUsed
+      });
+      this.executionHistory.record({
+        taskId: node.id,
+        taskName: node.task.name,
+        role: node.task.requiredRole,
+        model: agent.model.model,
+        status: "failed",
+        cost: result.cost,
+        duration: result.duration,
+        tokensUsed: result.tokensUsed,
+        startedAt: new Date(startTime),
+        completedAt: new Date,
+        error: result.error
+      });
       if (this.config.selfHealing.enabled) {
         await this.handleFailure(agent, node, new Error(result.error));
       }
@@ -10215,6 +10528,9 @@ Please continue from where the previous agent left off.`;
     }
   }
   buildRolePrompt(role) {
+    if (this.customRoles.has(role)) {
+      return this.customRoles.getPrompt(role) || `You are a ${role}. Complete the assigned task professionally.`;
+    }
     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.",
@@ -10317,10 +10633,10 @@ Please continue from where the previous agent left off.`;
     const roleEmoji = this.configManager.getRoleEmoji(config.role);
     const title = `${roleEmoji} ${this.configManager.getRoleDisplayName(config.role)} — ${modelConfig}`;
     const agentTypeMap = {
-      architect: "build",
-      coder: "build",
+      architect: "architect",
+      coder: "build-orchestrator",
       reviewer: "code-reviewer",
-      tester: "build",
+      tester: "build-orchestrator",
       explorer: "explore",
       documenter: "doc-writer"
     };
@@ -11074,6 +11390,42 @@ var src_default = define({
           }
         }
       });
+      editor.add({
+        name: "performance.scores",
+        description: "Show agent performance scores by model and role",
+        input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        execute: async () => {
+          const scores = orchestrator.performanceTracker.getScores();
+          if (scores.length === 0)
+            return { content: "No performance data yet. Scores build up as tasks are executed." };
+          const lines = scores.map((s) => `${s.role}/${s.model}: score=${s.overallScore.toFixed(1)} success=${(s.successRate * 100).toFixed(0)}% avg=$${s.avgCost.toFixed(4)} (${s.totalTasks} tasks)`);
+          return { content: lines.join(`
+`) };
+        }
+      });
+      editor.add({
+        name: "performance.best",
+        description: "Get best model for a specific role",
+        input: {
+          type: "object",
+          properties: {
+            role: { type: "string", description: "Agent role to find best model for" }
+          },
+          required: ["role"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { role } = input;
+          const best = orchestrator.performanceTracker.getBestModel(role);
+          if (!best)
+            return { content: `No performance data for role '${role}' yet.` };
+          return { content: `Best for ${role}: ${best.model} (score: ${best.overallScore.toFixed(1)}, success: ${(best.successRate * 100).toFixed(0)}%, avg cost: $${best.avgCost.toFixed(4)})` };
+        }
+      });
       editor.add({
         name: "security.scan",
         description: "Scan content for security issues",
@@ -11093,6 +11445,137 @@ var src_default = define({
           return { content: JSON.stringify({ issues: issues.length, score: result.score, details: issues }, null, 2) };
         }
       });
+      editor.add({
+        name: "history.list",
+        description: "List execution history",
+        input: {
+          type: "object",
+          properties: {
+            count: { type: "number", description: "Number of recent entries" }
+          },
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { count } = input;
+          const records = count ? orchestrator.executionHistory.getRecent(count) : orchestrator.executionHistory.getAll();
+          if (records.length === 0)
+            return { content: "No execution history yet." };
+          const lines = records.map((r) => `${r.status === "success" ? "✅" : "❌"} ${r.taskName} (${r.role}) — $${r.cost.toFixed(4)} — ${r.duration}ms`);
+          return { content: lines.join(`
+`) };
+        }
+      });
+      editor.add({
+        name: "history.stats",
+        description: "Show execution statistics",
+        input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        execute: async () => {
+          const stats = orchestrator.executionHistory.getStats();
+          return { content: `Total: ${stats.total} | Success: ${(stats.successRate * 100).toFixed(1)}% | Cost: $${stats.totalCost.toFixed(4)} | Avg: ${stats.avgDuration.toFixed(0)}ms
+By role: ${JSON.stringify(stats.byRole)}` };
+        }
+      });
+      editor.add({
+        name: "roles.list",
+        description: "List all custom agent roles",
+        input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        execute: async () => {
+          const roles = orchestrator.customRoles.list();
+          if (roles.length === 0)
+            return { content: "No custom roles defined. Add them in .opencode/nexus.jsonc under 'customRoles'." };
+          const lines = roles.map((r) => `${r.emoji} ${r.displayName} (${r.name}): ${r.prompt.substring(0, 60)}...`);
+          return { content: lines.join(`
+`) };
+        }
+      });
+      editor.add({
+        name: "roles.add",
+        description: "Add a custom agent role",
+        input: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Role identifier (lowercase, no spaces)" },
+            displayName: { type: "string", description: "Display name" },
+            emoji: { type: "string", description: "Emoji for the role" },
+            prompt: { type: "string", description: "System prompt for this role" },
+            model: { type: "string", description: "Default model (optional)" }
+          },
+          required: ["name", "displayName", "prompt"]
+        },
+        execute: async (input) => {
+          const { name, displayName, emoji, prompt, model } = input;
+          orchestrator.customRoles.register({ name, displayName, emoji: emoji || "\uD83E\uDD16", prompt, model });
+          return { content: `Custom role '${displayName}' registered` };
+        }
+      });
+      editor.add({
+        name: "forecast",
+        description: "Estimate cost before executing tasks",
+        input: {
+          type: "object",
+          properties: {
+            tasks: { type: "string", description: "JSON array of tasks with role, model, and complexity" }
+          },
+          required: ["tasks"]
+        },
+        execute: async (input) => {
+          const { tasks } = input;
+          const taskList = JSON.parse(tasks);
+          const remaining = orchestrator.budget.maxTotalCost - orchestrator.totalSpent;
+          const result = orchestrator.forecaster.forecastAll(taskList, remaining);
+          const lines = result.estimates.map((e) => `${e.taskName}: ~$${e.estimatedCost.toFixed(4)} (${e.model})`);
+          lines.push(`
+Total: ~$${result.totalEstimatedCost.toFixed(4)}`);
+          lines.push(`Budget remaining: $${remaining.toFixed(2)}`);
+          lines.push(`Within budget: ${result.withinBudget ? "✅" : "❌"}`);
+          return { content: lines.join(`
+`) };
+        }
+      });
+      editor.add({
+        name: "worktree.enable",
+        description: "Enable git worktree isolation for agents",
+        input: { type: "object", properties: { repoRoot: { type: "string", description: "Repository root (defaults to cwd)" } } },
+        execute: async (input) => {
+          const { repoRoot } = input;
+          orchestrator.enableWorktrees(repoRoot || process.cwd());
+          return { content: "Git worktree isolation enabled." };
+        }
+      });
+      editor.add({
+        name: "worktree.list",
+        description: "List active agent worktrees",
+        input: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+          if (!orchestrator.worktreeManager)
+            return { content: "Worktree isolation not enabled." };
+          const wts = orchestrator.worktreeManager.list();
+          if (wts.length === 0)
+            return { content: "No active worktrees." };
+          return { content: wts.map((w) => `${w.agentId}: ${w.path}`).join(`
+`) };
+        }
+      });
+      editor.add({
+        name: "worktree.disable",
+        description: "Disable worktree isolation and clean up",
+        input: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+          if (orchestrator.worktreeManager) {
+            orchestrator.worktreeManager.cleanupAll();
+            orchestrator.worktreeManager = null;
+          }
+          return { content: "Worktree isolation disabled." };
+        }
+      });
     });
     await ctx.session.hook("prompt", (event) => {
       if (event.prompt.text.startsWith("/nexus")) {
@@ -11106,6 +11589,8 @@ var src_default = define({
   }
 });
 export {
+  CostForecaster,
+  CustomRoleManager,
   DEFAULT_CONFIG,
   HealthMonitor,
   LearningModule,
@@ -11115,10 +11600,12 @@ export {
   NexusConfigManager,
   NexusOrchestrator,
   PRESETS,
+  PerformanceTracker,
   PersistentMemoryStore,
   SecurityScanner,
   StateBroadcaster,
   TEMPLATES,
+  WorktreeManager,
   src_default as default,
   detectCycles,
   getTemplate,

package/dist/tui.js

@@ -34532,6 +34532,25 @@ var tui_default = define({
                     case "d":
                       await handleDashboard();
                       break;
+                    case "web":
+                    case "w":
+                      try {
+                        const port = parts[1] ? parseInt(parts[1]) : 4747;
+                        context.ui.toast.show({
+                          title: "Nexus Dashboard",
+                          message: `Starting web dashboard on port ${port}...
+Open http://localhost:${port} in your browser`,
+                          variant: "success",
+                          duration: 5000
+                        });
+                      } catch (e) {
+                        context.ui.toast.show({
+                          title: "Nexus",
+                          message: `Failed to start dashboard: ${e.message}`,
+                          variant: "error"
+                        });
+                      }
+                      break;
                     case "model":
                     case "m":
                       if (parts[1]) {
@@ -34568,7 +34587,7 @@ var tui_default = define({
                     default:
                       context.ui.toast.show({
                         title: "Nexus",
-                        message: "Commands: config, status, dashboard, model <role>, reset",
+                        message: "Commands: config, status, dashboard, web [port], model <role>, reset",
                         variant: "info"
                       });
                   }

package/package.json

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