@serkanalgur/opencode-nexus 1.2.7 → 1.4.0

package/dist/index.js

@@ -9695,6 +9695,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 join4 } from "node:path";
+
+class WorktreeManager {
+  worktrees = new Map;
+  baseDir;
+  repoRoot;
+  constructor(repoRoot, baseDir) {
+    this.repoRoot = repoRoot;
+    this.baseDir = baseDir || join4(repoRoot, ".worktrees", "nexus-agents");
+  }
+  create(agentId) {
+    const branch = `nexus-agent-${agentId}`;
+    const path = join4(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 +9981,11 @@ class NexusOrchestrator {
   nodeRetryCounts = new Map;
   moduleRegistry;
   securityScanner;
+  performanceTracker;
+  executionHistory;
+  customRoles;
+  forecaster;
+  worktreeManager = null;
   onStateChange = null;
   stateChangeTimer = null;
   costHistory = [];
@@ -9740,6 +9994,7 @@ class NexusOrchestrator {
     return this._healthMonitor;
   }
   notifications = null;
+  modelCosts = new Map;
   constructor(config, messageStoreConfig, memoryStoreConfig) {
     this.config = this.mergeConfig(config);
     this.budget = this.config.budget;
@@ -9756,11 +10011,16 @@ 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;
     this.onStateChange = onStateChange ?? null;
     this.configManager.loadFromPath(process.cwd());
+    await this.loadModelCosts();
     this.cleanupInterval = setInterval(() => this.cleanupStaleData(), 300000);
     this._healthMonitor = new HealthMonitor({
       checkInterval: this.config.agents.healthCheckInterval
@@ -9776,6 +10036,56 @@ class NexusOrchestrator {
     };
     await this.moduleRegistry.setupAll(moduleCtx);
   }
+  async loadModelCosts() {
+    try {
+      if (!this.ctx)
+        return;
+      if (this.ctx.client?.model?.list) {
+        const result = await this.ctx.client.model.list();
+        const models = result?.data?.data ?? result?.data ?? [];
+        if (Array.isArray(models)) {
+          for (const model of models) {
+            if (model.cost && Array.isArray(model.cost) && model.cost.length > 0) {
+              const baseCost = model.cost[0];
+              this.modelCosts.set(model.id, {
+                input: baseCost.input || 0,
+                output: baseCost.output || 0,
+                cacheRead: baseCost.cache?.read || 0,
+                cacheWrite: baseCost.cache?.write || 0
+              });
+            }
+          }
+        }
+        return;
+      }
+      const location = this.ctx.location ?? this.ctx.data?.location?.default();
+      if (location && this.ctx.data?.location?.model) {
+        await this.ctx.data.location.model.sync(location);
+        const models = this.ctx.data.location.model.list(location) ?? [];
+        for (const model of models) {
+          if (model.cost && Array.isArray(model.cost) && model.cost.length > 0) {
+            const baseCost = model.cost[0];
+            this.modelCosts.set(model.id, {
+              input: baseCost.input || 0,
+              output: baseCost.output || 0,
+              cacheRead: baseCost.cache?.read || 0,
+              cacheWrite: baseCost.cache?.write || 0
+            });
+          }
+        }
+      }
+    } catch {}
+  }
+  setModelCosts(costs) {
+    for (const [model, cost] of Object.entries(costs)) {
+      this.modelCosts.set(model, {
+        input: cost.input,
+        output: cost.output,
+        cacheRead: cost.cacheRead || 0,
+        cacheWrite: cost.cacheWrite || 0
+      });
+    }
+  }
   initBroadcaster(opts) {
     this.broadcaster = new StateBroadcaster(this, opts);
     const previousOnStateChange = this.onStateChange;
@@ -9800,6 +10110,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,
@@ -10124,6 +10437,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` });
       }
@@ -10153,6 +10486,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));
       }
@@ -10163,6 +10517,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.",
@@ -10265,10 +10622,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"
     };
@@ -10354,6 +10711,10 @@ Please continue from where the previous agent left off.`;
     return this.selectBestModel(role, complexity);
   }
   estimateModelCost(model) {
+    const realCost = this.modelCosts.get(model);
+    if (realCost) {
+      return (realCost.input * 1000 + realCost.output * 1000) / 2;
+    }
     const costs = {
       "claude-sonnet-4-6": 0.15,
       "claude-opus-4-7": 15,
@@ -10905,6 +11266,43 @@ var src_default = define({
           return { content: "Dashboard stopped" };
         }
       });
+      editor.add({
+        name: "model.costs",
+        description: "Show real model pricing from OpenCode or set custom costs",
+        input: {
+          type: "object",
+          properties: {
+            model: { type: "string", description: "Model ID to show cost for (optional, shows all if omitted)" },
+            setInput: { type: "number", description: "Set input cost per token for a model" },
+            setOutput: { type: "number", description: "Set output cost per token for a model" }
+          },
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { model, setInput, setOutput } = input;
+          if (model && setInput !== undefined && setOutput !== undefined) {
+            orchestrator.setModelCosts({ [model]: { input: setInput, output: setOutput } });
+            return { content: `Set ${model}: input=$${setInput}/token, output=$${setOutput}/token` };
+          }
+          if (model) {
+            const cost = orchestrator.modelCosts.get(model);
+            if (cost) {
+              return { content: `${model}: input=$${cost.input}/token, output=$${cost.output}/token, cache_read=$${cost.cacheRead}/token, cache_write=$${cost.cacheWrite}/token` };
+            }
+            const estimate = orchestrator["estimateModelCost"](model);
+            return { content: `${model}: no real pricing data (estimated $${estimate}/1K tokens)` };
+          }
+          if (orchestrator.modelCosts.size > 0) {
+            const lines = ["\uD83D\uDCCA Model Pricing (from OpenCode):"];
+            for (const [id, cost] of orchestrator.modelCosts) {
+              lines.push(`  ${id}: $${cost.input}/token in, $${cost.output}/token out`);
+            }
+            return { content: lines.join(`
+`) };
+          }
+          return { content: "No real pricing data loaded. Using hardcoded estimates." };
+        }
+      });
       editor.add({
         name: "spawn",
         description: "Spawn a sub-agent for a task",
@@ -10981,6 +11379,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",
@@ -11000,6 +11434,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")) {
@@ -11013,6 +11578,8 @@ var src_default = define({
   }
 });
 export {
+  CostForecaster,
+  CustomRoleManager,
   DEFAULT_CONFIG,
   HealthMonitor,
   LearningModule,
@@ -11022,10 +11589,12 @@ export {
   NexusConfigManager,
   NexusOrchestrator,
   PRESETS,
+  PerformanceTracker,
   PersistentMemoryStore,
   SecurityScanner,
   StateBroadcaster,
   TEMPLATES,
+  WorktreeManager,
   src_default as default,
   detectCycles,
   getTemplate,

package/package.json

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