@serkanalgur/opencode-nexus 2.4.0 → 2.5.0

package/dist/index.js

@@ -8366,7 +8366,7 @@ var Event16 = { Updated: Updated12, Resolved, Definitions: inventory(Updated12,
 // src/config.ts
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, dirname } from "node:path";
+import { join, dirname, resolve as resolve2 } from "node:path";
 function stripJsonComments(jsonc) {
   const result = [];
   let i = 0;
@@ -8414,14 +8414,46 @@ function readJsoncFile(filePath) {
     const raw = readFileSync(filePath, "utf-8");
     const stripped = stripJsonComments(raw);
     const parsed = JSON.parse(stripped);
-    return parsed;
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      console.warn(`[nexus] Ignoring config from ${filePath}: expected a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`);
+      return { config: null, existed: true };
+    }
+    return { config: parsed, existed: true };
   } catch (err) {
-    if (err.code !== "ENOENT") {
-      console.warn(`[nexus] Failed to load config from ${filePath}: ${err.message}`);
+    const code = err.code;
+    const message = err instanceof Error ? err.message : String(err);
+    const absent = code === "ENOENT" || code === "ENOTDIR";
+    if (!absent) {
+      console.warn(`[nexus] Failed to load config from ${filePath}: ${message}`);
     }
-    return null;
+    return { config: null, existed: !absent };
   }
 }
+function nexusProjectConfigPath(basePath) {
+  return resolve2(join(basePath, ".opencode", "nexus.jsonc"));
+}
+function nexusGlobalConfigPath() {
+  return resolve2(join(homedir(), ".config", "opencode", "nexus.jsonc"));
+}
+function redactHome(filePath) {
+  const home = homedir();
+  if (filePath === home)
+    return "~";
+  const prefix = home.endsWith("/") ? home : `${home}/`;
+  return filePath.startsWith(prefix) ? `~${filePath.slice(home.length)}` : filePath;
+}
+function describeFile(file) {
+  if (file.parsed)
+    return "loaded";
+  if (file.existed)
+    return "unparseable";
+  return "absent";
+}
+function formatConfigLoadLog(info) {
+  const models = Object.entries(info.models).map(([role, model]) => `${role}=${model}`).join(" ");
+  const override = info.sessionOverride ? " (+session override: storage; disk edits to models are IGNORED while a preset is set — clear the preset in the TUI to hand control back to disk)" : "";
+  return `[nexus] config loaded (#${info.loadCount} trigger=${info.trigger} at=${info.loadedAt}) ` + `project=${info.project.path} [${describeFile(info.project)}] ` + `global=${info.global.path} [${describeFile(info.global)}] ` + `models:${override} ${models}`;
+}
 var DEFAULT_CONFIG = {
   models: {
     architect: "anthropic/claude-sonnet-4-6",
@@ -8448,19 +8480,51 @@ class NexusConfigManager {
   projectConfig = null;
   globalConfig = null;
   storageConfig = null;
+  loadInfo = null;
   constructor() {
     this.projectConfig = null;
     this.globalConfig = null;
   }
   loadConfigs(basePath) {
-    this.storageConfig = null;
-    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
-    this.projectConfig = readJsoncFile(projectPath);
-    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
-    this.globalConfig = readJsoncFile(globalPath);
+    if (this.loadInfo === null)
+      this.storageConfig = null;
+    const projectPath = nexusProjectConfigPath(basePath);
+    const project = readJsoncFile(projectPath);
+    this.projectConfig = project.config;
+    const globalPath = nexusGlobalConfigPath();
+    const global = readJsoncFile(globalPath);
+    this.globalConfig = global.config;
+    return {
+      project: { path: redactHome(projectPath), existed: project.existed, parsed: project.config !== null },
+      global: { path: redactHome(globalPath), existed: global.existed, parsed: global.config !== null }
+    };
+  }
+  loadFromPath(basePath, trigger = "initial") {
+    const sources = this.loadConfigs(basePath);
+    this.loadInfo = {
+      project: sources.project,
+      global: sources.global,
+      models: this.getResolvedModels(),
+      sessionOverride: this.hasSessionOverride(),
+      loadedAt: new Date().toISOString(),
+      loadCount: (this.loadInfo?.loadCount ?? 0) + 1,
+      trigger
+    };
+    console.log(formatConfigLoadLog(this.loadInfo));
+  }
+  getLoadInfo() {
+    return this.loadInfo;
   }
-  loadFromPath(basePath) {
-    this.loadConfigs(basePath);
+  getResolvedModels() {
+    const models = {};
+    for (const [role, model] of Object.entries(this.getConfig().models)) {
+      if (model)
+        models[role] = model;
+    }
+    return models;
+  }
+  hasSessionOverride() {
+    return this.storageConfig !== null;
   }
   getConfig() {
     return {
@@ -8563,17 +8627,17 @@ class NexusConfigManager {
 `, "utf-8");
   }
   saveProjectConfig(basePath) {
-    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
+    const projectPath = nexusProjectConfigPath(basePath);
     const config = this.getSaveableConfig();
     this.writeJsoncFile(projectPath, config);
   }
   saveGlobalConfig() {
-    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
+    const globalPath = nexusGlobalConfigPath();
     const config = this.getSaveableConfig();
     this.writeJsoncFile(globalPath, config);
   }
   initProjectConfig(basePath) {
-    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
+    const projectPath = nexusProjectConfigPath(basePath);
     try {
       readFileSync(projectPath, "utf-8");
       return;
@@ -8581,7 +8645,7 @@ class NexusConfigManager {
     this.writeJsoncFile(projectPath, { ...DEFAULT_CONFIG });
   }
   initGlobalConfig() {
-    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
+    const globalPath = nexusGlobalConfigPath();
     try {
       readFileSync(globalPath, "utf-8");
       return;
@@ -9856,33 +9920,86 @@ class CustomRoleManager {
 }
 
 // src/forecast.ts
+var CACHE_READ_MULTIPLE = 0.1;
+var CACHE_WRITE_MULTIPLE = 1.25;
+function per1kPricing(input, output) {
+  return {
+    input,
+    output,
+    cacheRead: input * CACHE_READ_MULTIPLE,
+    cacheWrite: input * CACHE_WRITE_MULTIPLE
+  };
+}
+var FALLBACK_PRICING_PER_1K = {
+  "claude-sonnet-4-6": per1kPricing(0.015, 0.075),
+  "claude-opus-4-7": per1kPricing(0.075, 0.375),
+  "claude-haiku-4-5": per1kPricing(0.001, 0.005),
+  "gpt-5-mini": per1kPricing(0.00015, 0.0006),
+  "gpt-5": per1kPricing(0.0025, 0.01),
+  "gemini-2.5-flash": per1kPricing(0.000075, 0.0003),
+  "minimax-m2.5-free": per1kPricing(0, 0)
+};
+var UNKNOWN_PRICING_PER_1K = per1kPricing(0.01, 0.05);
+var per1k = (rate, tokens) => rate * tokens / 1000;
+function bareModelId(ref) {
+  return ref.slice(ref.indexOf("/") + 1);
+}
+function totalTokens(usage) {
+  return usage.input + usage.output + usage.reasoning + usage.cache.read + usage.cache.write;
+}
+function priceTokens(usage, pricing) {
+  const inputCost = per1k(pricing.input, usage.input);
+  const outputCost = per1k(pricing.output, usage.output + usage.reasoning);
+  const cacheCost = per1k(pricing.cacheRead, usage.cache.read) + per1k(pricing.cacheWrite, usage.cache.write);
+  return { inputCost, outputCost, cacheCost, total: inputCost + outputCost + cacheCost };
+}
+
 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 });
+  resolvePricing;
+  constructor(pricing) {
+    this.resolvePricing = pricing;
+  }
+  priceFor(model, provider) {
+    const real = this.resolvePricing?.(model, provider);
+    if (real)
+      return { pricing: real, source: "model-costs" };
+    const bare = bareModelId(model);
+    const fallback = FALLBACK_PRICING_PER_1K[model] ?? FALLBACK_PRICING_PER_1K[bare];
+    if (fallback)
+      return { pricing: fallback, source: "fallback-table" };
+    return { pricing: UNKNOWN_PRICING_PER_1K, source: "unknown-model" };
+  }
+  measureCost(usage, model, provider) {
+    const { pricing, source } = this.priceFor(model, provider);
+    return {
+      cost: priceTokens(usage, pricing).total,
+      tokens: totalTokens(usage),
+      pricingSource: source,
+      ...source === "model-costs" ? { confidence: 1 } : {}
+    };
   }
-  updatePricing(modelId, input, output) {
-    this.modelPricing.set(modelId, { input, output });
+  costOf(usage, model, provider) {
+    return priceTokens(usage, this.priceFor(model, provider).pricing).total;
   }
-  estimateTokens(task, complexity) {
+  estimateTokensFor(complexity, fileCount) {
     const baseInput = 700;
     const complexityMultiplier = 1 + complexity.overall / 100 * 3;
-    const fileMultiplier = 1 + task.files.include.length * 0.2;
+    const fileMultiplier = 1 + fileCount * 0.2;
     const input = Math.round(baseInput * complexityMultiplier * fileMultiplier);
     const output = Math.round(input * 0.5);
     return { input, output };
   }
+  estimateTokens(task, complexity) {
+    return this.estimateTokensFor(complexity, task.files.include.length);
+  }
+  estimateCost(complexity, model, provider) {
+    const { input, output } = this.estimateTokensFor(complexity, 0);
+    return this.costOf({ input, output, reasoning: 0, cache: { read: 0, write: 0 } }, model, provider);
+  }
   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;
+    const { pricing, source } = this.priceFor(modelId);
+    const breakdown = priceTokens({ input, output, reasoning: 0, cache: { read: 0, write: 0 } }, pricing);
     return {
       taskId: task.id,
       taskName: task.name,
@@ -9890,9 +10007,15 @@ class CostForecaster {
       model: modelId,
       estimatedInputTokens: input,
       estimatedOutputTokens: output,
-      estimatedCost: inputCost + outputCost + overhead,
-      confidence: 0.6 + Math.random() * 0.3,
-      breakdown: { inputCost, outputCost, overhead }
+      estimatedCost: breakdown.total,
+      source: "estimated",
+      pricingSource: source,
+      confidence: undefined,
+      breakdown: {
+        inputCost: breakdown.inputCost,
+        outputCost: breakdown.outputCost,
+        cacheCost: breakdown.cacheCost
+      }
     };
   }
   forecastAll(tasks, budgetRemaining) {
@@ -10100,6 +10223,12 @@ function lastAssistantText(messages) {
   }
   return "";
 }
+function sumBy(records, select) {
+  let total = 0;
+  for (const record of records.values())
+    total += select(record);
+  return total;
+}
 var DEFAULT_ESCALATION = {
   maxRetries: 3,
   retryDelay: 1000,
@@ -10145,6 +10274,8 @@ class NexusOrchestrator {
   onStateChange = null;
   stateChangeTimer = null;
   costHistory = [];
+  tokensByModel = new Map;
+  costProvenance = new Map;
   cleanupInterval = null;
   get healthMonitor() {
     return this._healthMonitor;
@@ -10162,6 +10293,7 @@ class NexusOrchestrator {
     this.messageRouter = new MessageRouter;
     this.escalationPolicy = {
       ...DEFAULT_ESCALATION,
+      fallbackModels: [...DEFAULT_ESCALATION.fallbackModels],
       maxRetries: this.config.selfHealing.maxRetries,
       retryDelay: this.config.selfHealing.retryDelay,
       enableRespawn: this.config.selfHealing.contextTransfer
@@ -10171,7 +10303,7 @@ class NexusOrchestrator {
     this.performanceTracker = new PerformanceTracker;
     this.executionHistory = new ExecutionHistory;
     this.customRoles = new CustomRoleManager;
-    this.forecaster = new CostForecaster;
+    this.forecaster = new CostForecaster((model, provider) => this.getModelCost(model, provider));
   }
   async initialize(ctx, onStateChange) {
     this.ctx = ctx;
@@ -10362,6 +10494,21 @@ class NexusOrchestrator {
       this.onStateChange?.();
     }, 100);
   }
+  reloadConfigFromDisk(trigger = "event") {
+    const projectDir = this.ctx?.location.directory;
+    if (projectDir) {
+      this.configManager.loadFromPath(projectDir, trigger);
+    }
+    const info = this.configManager.getLoadInfo();
+    if (info) {
+      this.notifyStateChange();
+      this.emit("config:reloaded", info);
+    }
+    return info;
+  }
+  getConfigInfo() {
+    return this.configManager.getLoadInfo();
+  }
   async execute(request) {
     if (this.running) {
       throw new Error("Orchestrator is already running");
@@ -10394,6 +10541,7 @@ class NexusOrchestrator {
         agentsUsed: this.agents.size
       };
     } catch (error) {
+      console.error("[nexus] DAG execution failed:", error);
       return {
         success: false,
         tasks: [],
@@ -10489,26 +10637,48 @@ class NexusOrchestrator {
       const spawnPromises = [];
       for (const node of readyNodes) {
         if (this.agents.size < this.config.maxConcurrency) {
-          spawnPromises.push(this.spawnAndExecute(node));
+          spawnPromises.push(this.spawnAndExecute(node).catch((error) => {
+            const err = error instanceof Error ? error : new Error(String(error));
+            node.status = "failed";
+            node.task.status = "failed";
+            node.result = { success: false, error: err.message, duration: 0, tokensUsed: 0, cost: 0 };
+            this.dag.markFailed(node.id, err);
+            this.notifyStateChange();
+            this.emit("task:failed", {
+              taskId: node.id,
+              taskName: node.task.name,
+              role: node.task.requiredRole,
+              error: err.message,
+              duration: 0
+            });
+          }));
         }
       }
       await Promise.all(spawnPromises);
       await this.sleep(this.config.schedulerInterval);
     }
   }
-  async spawnAndExecute(node, transferContext) {
+  selectQualifiedModel(node) {
     const complexity = this.analyzeComplexity(node.task);
     const model = this.selectModel(node.task.requiredRole, complexity);
+    if (!model.provider || !model.model) {
+      const missing = !model.provider && !model.model ? "provider and model" : !model.provider ? "provider" : "model";
+      throw new Error(`Model selection for role "${node.task.requiredRole}" is missing its ${missing}: ` + `got { provider: ${JSON.stringify(model.provider)}, model: ${JSON.stringify(model.model)} }. ` + `Cannot build a "providerID/modelID" reference.`);
+    }
+    return `${model.provider}/${model.model}`;
+  }
+  async spawnAndExecute(node, options = {}) {
+    const qualifiedModel = options.modelOverride ?? this.selectQualifiedModel(node);
     const agent = await this.spawnAgent({
       role: node.task.requiredRole,
       task: node.task,
-      model: model.model
+      model: qualifiedModel
     });
     node.spawnedAgent = agent;
     node.status = "running";
     node.task.assignedAgent = agent.id;
     this.notifyStateChange();
-    await this.executeTask(agent, node, transferContext);
+    await this.executeTask(agent, node, options.transferContext);
   }
   async executeTask(agent, node, transferContext) {
     if (!this.ctx || !agent.sessionID) {
@@ -10562,20 +10732,21 @@ Please continue from where the previous agent left off.`;
       const messages = await this.ctx.session.context({ sessionID: agent.sessionID });
       const output = lastAssistantText(messages) || "Task completed (no output captured)";
       const duration = Date.now() - startTime;
+      const cost = await this.safeAccountTaskCost(agent, node.task);
       const result = {
         success: true,
         output,
         duration,
-        tokensUsed: 0,
-        cost: this.estimateModelCost(agent.model.model, agent.model.provider)
+        tokensUsed: cost.tokensUsed,
+        cost: cost.cost,
+        costProvenance: cost.provenance
       };
       this.dag.markComplete(node.id, result);
       this.todoEnforcer.completeTask(agent.id);
       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();
+      agent.metrics.totalTokens += result.tokensUsed;
+      this.trackCost(agent.id, `${agent.model.provider}/${agent.model.model}`, result.cost, result.tokensUsed, result.costProvenance);
       this.performanceTracker.record({
         model: agent.model.model,
         role: node.task.requiredRole,
@@ -10617,14 +10788,20 @@ Please continue from where the previous agent left off.`;
     } catch (error) {
       const duration = Date.now() - startTime;
       const errorMessage = error.message || "Task failed";
+      const cost = await this.safeAccountTaskCost(agent, node.task);
       const result = {
         success: false,
         error: errorMessage,
         duration,
-        tokensUsed: 0,
-        cost: 0
+        tokensUsed: cost.tokensUsed,
+        cost: cost.cost,
+        costProvenance: cost.provenance
       };
       this.dag.markFailed(node.id, new Error(errorMessage));
+      node.result = result;
+      this.trackCost(agent.id, `${agent.model.provider}/${agent.model.model}`, result.cost, result.tokensUsed, result.costProvenance);
+      agent.metrics.totalCost += result.cost;
+      agent.metrics.totalTokens += result.tokensUsed;
       this.todoEnforcer.completeTask(agent.id);
       agent.metrics.tasksFailed++;
       agent.status = "failed";
@@ -10735,7 +10912,7 @@ Please continue from where the previous agent left off.`;
       await this.terminateAgent(agent.id);
       node.status = "pending";
       this.notifyStateChange();
-      await this.spawnAndExecute(node, context);
+      await this.spawnAndExecute(node, { transferContext: context });
       return;
     }
     if (policy.fallbackModels.length > 0) {
@@ -10744,7 +10921,7 @@ Please continue from where the previous agent left off.`;
         await this.terminateAgent(agent.id);
         node.status = "pending";
         this.notifyStateChange();
-        await this.spawnAgent({ role: node.task.requiredRole, model: fallbackModel });
+        await this.spawnAndExecute(node, { modelOverride: fallbackModel });
         return;
       }
     }
@@ -10829,7 +11006,8 @@ Please continue from where the previous agent left off.`;
       if (match) {
         modelConfig = match;
       } else {
-        throw new Error(`Invalid model "${config.model}". Use "providerID/modelID" format (e.g. "opencode-go/mimo-v2.5")`);
+        const source = config.model ? "requested" : "configured for role";
+        throw new Error(`Invalid model "${modelConfig}" (${source} "${config.role}"). Use "providerID/modelID" format (e.g. "opencode-go/mimo-v2.5")`);
       }
     }
     const slashIndex = modelConfig.indexOf("/");
@@ -10977,10 +11155,10 @@ Please continue from where the previous agent left off.`;
       if (qualified)
         return qualified;
     }
-    const bare = model.slice(model.indexOf("/") + 1);
+    const bare = bareModelId(model);
     let best;
     for (const [key, cost] of this.modelCosts) {
-      if (key.slice(key.indexOf("/") + 1) !== bare)
+      if (bareModelId(key) !== bare)
         continue;
       if (!best || cost.input < best.input)
         best = cost;
@@ -11062,28 +11240,96 @@ Please continue from where the previous agent left off.`;
     const scored = unique.map((m) => this.scoreModel(m, role, complexity));
     const budgetRemaining = this.budget.maxTotalCost - this.totalSpent;
     const affordable = scored.filter((s) => {
-      const cost = this.estimateModelCost(s.model, s.provider);
-      return cost <= budgetRemaining || cost === 0;
+      const estimate = this.forecaster.estimateCost(complexity, s.model, s.provider);
+      return estimate <= budgetRemaining || estimate === 0;
     });
     const best = (affordable.length > 0 ? affordable : scored).sort((a, b) => b.overallScore - a.overallScore)[0];
     return {
       provider: best.provider,
       model: best.model,
-      estimatedCost: this.estimateModelCost(best.model, best.provider),
+      estimatedCost: this.forecaster.estimateCost(complexity, best.model, best.provider),
       estimatedQuality: best.qualityScore,
       reasoning: best.reasoning
     };
   }
-  trackCost(agentId, model, cost, tokens) {
+  trackCost(agentId, model, cost, tokens, provenance) {
     this.totalSpent += cost;
     const agentCost = this.costByAgent.get(agentId) || 0;
     this.costByAgent.set(agentId, agentCost + cost);
     const modelCost = this.costByModel.get(model) || 0;
     this.costByModel.set(model, modelCost + cost);
-    this.costHistory.push({ timestamp: Date.now(), cost, agentId });
+    this.tokensByModel.set(model, (this.tokensByModel.get(model) || 0) + tokens);
+    this.recordProvenance(model, cost, provenance);
+    this.costHistory.push({ timestamp: Date.now(), cost, agentId, model, tokens, provenance });
     this.checkBudget();
     this.notifyStateChange();
   }
+  recordProvenance(model, cost, provenance) {
+    const measured = provenance.usage === "measured";
+    const prior = this.costProvenance.get(model) ?? {
+      usage: provenance.usage,
+      pricing: provenance.pricing,
+      measuredEntries: 0,
+      estimatedEntries: 0,
+      measuredSpend: 0,
+      estimatedSpend: 0
+    };
+    prior.usage = provenance.usage;
+    prior.pricing = provenance.pricing;
+    if (measured) {
+      prior.measuredEntries++;
+      prior.measuredSpend += cost;
+    } else {
+      prior.estimatedEntries++;
+      prior.estimatedSpend += cost;
+    }
+    this.costProvenance.set(model, prior);
+  }
+  safeAccountTaskCost(agent, task) {
+    return this.accountTaskCost(agent, task).catch(() => ({
+      cost: 0,
+      tokensUsed: 0,
+      provenance: { usage: "estimated", pricing: "unknown-model" }
+    }));
+  }
+  async accountTaskCost(agent, task) {
+    const model = `${agent.model.provider}/${agent.model.model}`;
+    const read = agent.sessionID ? await this.readSessionTokens(agent.sessionID) : { read: false };
+    if (read.read) {
+      const measured = this.forecaster.measureCost(read.usage, model, agent.model.provider);
+      return {
+        cost: measured.cost,
+        tokensUsed: measured.tokens,
+        provenance: { usage: "measured", pricing: measured.pricingSource }
+      };
+    }
+    const predicted = this.forecaster.forecastTask(task, task.requiredRole, model, task.complexity);
+    return {
+      cost: predicted.estimatedCost,
+      tokensUsed: predicted.estimatedInputTokens + predicted.estimatedOutputTokens,
+      provenance: { usage: "estimated", pricing: predicted.pricingSource }
+    };
+  }
+  async readSessionTokens(sessionID) {
+    const finite = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+    try {
+      const session = await this.ctx?.session.get({ sessionID });
+      const tokens = session?.tokens;
+      if (!tokens)
+        return { read: false };
+      return {
+        read: true,
+        usage: {
+          input: finite(tokens.input),
+          output: finite(tokens.output),
+          reasoning: finite(tokens.reasoning),
+          cache: { read: finite(tokens.cache?.read), write: finite(tokens.cache?.write) }
+        }
+      };
+    } catch {
+      return { read: false };
+    }
+  }
   checkBudget() {
     const remaining = this.budget.maxTotalCost - this.totalSpent;
     const remainingPercent = remaining / this.budget.maxTotalCost;
@@ -11138,8 +11384,20 @@ Please continue from where the previous agent left off.`;
   }
   getStatus(detailed) {
     const state = this.getState();
+    const loadInfo = this.configManager.getLoadInfo();
+    const config = {
+      loaded: loadInfo !== null,
+      loadedAt: loadInfo?.loadedAt ?? null,
+      loadCount: loadInfo?.loadCount ?? 0,
+      sessionOverride: this.configManager.hasSessionOverride(),
+      diskModelsIgnored: this.configManager.hasSessionOverride(),
+      trigger: loadInfo?.trigger ?? null,
+      project: loadInfo?.project ?? null,
+      global: loadInfo?.global ?? null,
+      models: this.configManager.getResolvedModels()
+    };
     if (detailed)
-      return JSON.stringify({ ...state, budgetExceeded: this.budgetExceeded }, null, 2);
+      return JSON.stringify({ ...state, budgetExceeded: this.budgetExceeded, config }, null, 2);
     return JSON.stringify({
       running: state.running,
       paused: state.paused,
@@ -11147,7 +11405,8 @@ Please continue from where the previous agent left off.`;
       agents: state.agents.length,
       tasks: state.tasks.length,
       totalCost: state.totalSpent,
-      budgetRemaining: state.budgetRemaining
+      budgetRemaining: state.budgetRemaining,
+      config
     }, null, 2);
   }
   listAgents(filter) {
@@ -11161,7 +11420,11 @@ Please continue from where the previous agent left off.`;
       totalSpent: state.totalSpent,
       budgetRemaining: state.budgetRemaining,
       byAgent: Object.fromEntries(this.costByAgent),
-      byModel: Object.fromEntries(this.costByModel)
+      byModel: Object.fromEntries(this.costByModel),
+      tokensByModel: Object.fromEntries(this.tokensByModel),
+      provenance: Object.fromEntries(this.costProvenance),
+      measuredEntries: sumBy(this.costProvenance, (p) => p.measuredEntries),
+      estimatedEntries: sumBy(this.costProvenance, (p) => p.estimatedEntries)
     }, null, 2);
   }
   pause() {
@@ -11557,9 +11820,126 @@ class AstGrep {
 }
 
 // src/index.ts
-import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync3 } from "node:fs";
-import { join as join6 } from "node:path";
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync3, statSync } from "node:fs";
+import { join as join6, resolve as resolve3, basename, dirname as dirname4 } from "node:path";
 import { homedir as homedir2 } from "node:os";
+var CONFIG_RELOAD_DEBOUNCE_MS = 150;
+var CONFIG_POLL_INTERVAL_MS = 2000;
+function isNexusConfigFile(file, eventDirectory, projectDirectory, projectPath, globalPath) {
+  const resolved = resolve3(file);
+  if (resolved === projectPath || resolved === globalPath)
+    return true;
+  if (eventDirectory !== undefined && resolve3(eventDirectory) !== projectDirectory)
+    return false;
+  return basename(resolved) === "nexus.jsonc" && basename(dirname4(resolved)) === ".opencode";
+}
+var watchedContexts = new WeakSet;
+var MAX_RELOAD_WAIT_MS = 1000;
+var MIN_INTERVAL_MS = 25;
+var clampInterval = (ms, fallback) => Number.isFinite(ms) && ms >= MIN_INTERVAL_MS ? ms : fallback;
+function watchConfigFiles(ctx, orchestrator, debounceMs = CONFIG_RELOAD_DEBOUNCE_MS, pollMs = CONFIG_POLL_INTERVAL_MS) {
+  if (watchedContexts.has(ctx))
+    return () => {};
+  watchedContexts.add(ctx);
+  const debounce = clampInterval(debounceMs, CONFIG_RELOAD_DEBOUNCE_MS);
+  const pollEvery = clampInterval(pollMs, CONFIG_POLL_INTERVAL_MS);
+  const projectDirectory = resolve3(ctx.location.directory);
+  const projectPath = nexusProjectConfigPath(ctx.location.directory);
+  const globalPath = nexusGlobalConfigPath();
+  const watchedPaths = [projectPath, globalPath];
+  const controller = new AbortController;
+  let debounceTimer = null;
+  let firstScheduledAt = 0;
+  const clearPendingReload = () => {
+    if (debounceTimer === null)
+      return;
+    clearTimeout(debounceTimer);
+    debounceTimer = null;
+  };
+  const stampOf = (filePath) => {
+    try {
+      const stats = statSync(filePath);
+      if (!stats.isFile())
+        return "absent";
+      return `${stats.mtimeMs}:${stats.size}`;
+    } catch {
+      return "absent";
+    }
+  };
+  const lastSeen = new Map(watchedPaths.map((p) => [p, stampOf(p)]));
+  const runReload = (trigger) => {
+    for (const filePath of watchedPaths)
+      lastSeen.set(filePath, stampOf(filePath));
+    try {
+      orchestrator.reloadConfigFromDisk(trigger);
+    } catch (err) {
+      console.warn(`[nexus] config reload failed (${trigger}): ${String(err)}`);
+    }
+  };
+  const scheduleReload = (trigger) => {
+    const pending = debounceTimer !== null;
+    const waited = pending ? Date.now() - firstScheduledAt : 0;
+    clearPendingReload();
+    if (pending && waited >= MAX_RELOAD_WAIT_MS) {
+      runReload(trigger);
+      return;
+    }
+    if (!pending)
+      firstScheduledAt = Date.now();
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      runReload(trigger);
+    }, debounce);
+  };
+  const poll = () => {
+    let changed = false;
+    for (const filePath of watchedPaths) {
+      const current = stampOf(filePath);
+      if (lastSeen.get(filePath) === current)
+        continue;
+      lastSeen.set(filePath, current);
+      changed = true;
+    }
+    if (changed)
+      scheduleReload("poll");
+  };
+  const pollTimer = setInterval(poll, pollEvery);
+  pollTimer.unref();
+  const eventDomain = ctx.event;
+  if (typeof eventDomain?.subscribe !== "function") {
+    console.warn("[nexus] no config event stream on this context; polling is the only config reload trigger");
+    return () => {
+      clearInterval(pollTimer);
+      clearPendingReload();
+      controller.abort();
+    };
+  }
+  const consume = async () => {
+    try {
+      for await (const event of eventDomain.subscribe({ signal: controller.signal })) {
+        if (event.type !== "filesystem.changed")
+          continue;
+        const file = event.data?.file;
+        if (typeof file !== "string")
+          continue;
+        if (!isNexusConfigFile(file, event.location?.directory, projectDirectory, projectPath, globalPath))
+          continue;
+        scheduleReload("event");
+      }
+      if (!controller.signal.aborted) {
+        console.warn("[nexus] config event stream ended; polling remains the only config reload trigger");
+      }
+    } catch (err) {
+      console.warn(`[nexus] config event stream failed; polling remains the only config reload trigger: ${String(err)}`);
+    }
+  };
+  consume();
+  return () => {
+    clearInterval(pollTimer);
+    clearPendingReload();
+    controller.abort();
+  };
+}
 var NEXUS_AGENT_CONTENT = `---
 description: Nexus multi-agent orchestrator — decomposes tasks and delegates to specialized sub-agents
 mode: primary
@@ -12089,7 +12469,7 @@ You are a technical writer who creates documentation that developers actually wa
       });
       editor.add({
         name: "status",
-        description: "Get orchestrator status and metrics",
+        description: "Get orchestrator status, metrics, and the config files currently in effect (paths consulted, which existed, resolved role -> model map)",
         input: {
           type: "object",
           properties: {
@@ -12228,7 +12608,10 @@ You are a technical writer who creates documentation that developers actually wa
           const { name } = input;
           try {
             orchestrator.configManager.applyPreset(name);
-            return { content: `Applied preset: ${PRESETS[name]?.name || name}` };
+            return {
+              content: `Applied preset: ${PRESETS[name]?.name || name}
+` + `⚠️ This preset now overrides the \`models\` section of nexus.jsonc. ` + `Edits to models in the config file will NOT take effect until the preset is cleared. ` + `Clear it from the TUI (config manager) to hand control back to disk. ` + `Budget and self-healing values from the file still apply.`
+            };
           } catch (error) {
             return { content: `Error: ${error.message}` };
           }
@@ -13201,19 +13584,24 @@ ${lines.join(`
         event.metadata = { ...event.metadata, nexusResult: result };
       }
     });
+    const stopConfigWatch = watchConfigFiles(ctx, orchestrator);
     return () => {
+      stopConfigWatch();
       orchestrator.shutdown();
     };
   }
 });
 export {
   AstGrep,
+  CONFIG_POLL_INTERVAL_MS,
+  CONFIG_RELOAD_DEBOUNCE_MS,
   CostForecaster,
   CustomRoleManager,
   DEFAULT_CONFIG,
   GoalManager,
   HealthMonitor,
   LearningModule,
+  MAX_RELOAD_WAIT_MS,
   MessageRouter,
   MessageStore,
   ModuleRegistry,
@@ -13232,5 +13620,6 @@ export {
   detectCycles,
   getTemplate,
   instantiateTemplate,
-  listTemplates
+  listTemplates,
+  watchConfigFiles
 };

package/dist/tui.js

@@ -9,7 +9,7 @@ var PluginContext = createContext();
 // src/config.ts
 import { readFileSync, writeFileSync, mkdirSync } from "fs";
 import { homedir } from "os";
-import { join, dirname } from "path";
+import { join, dirname, resolve } from "path";
 function stripJsonComments(jsonc) {
   const result = [];
   let i = 0;
@@ -57,14 +57,46 @@ function readJsoncFile(filePath) {
     const raw = readFileSync(filePath, "utf-8");
     const stripped = stripJsonComments(raw);
     const parsed = JSON.parse(stripped);
-    return parsed;
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      console.warn(`[nexus] Ignoring config from ${filePath}: expected a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`);
+      return { config: null, existed: true };
+    }
+    return { config: parsed, existed: true };
   } catch (err) {
-    if (err.code !== "ENOENT") {
-      console.warn(`[nexus] Failed to load config from ${filePath}: ${err.message}`);
+    const code = err.code;
+    const message = err instanceof Error ? err.message : String(err);
+    const absent = code === "ENOENT" || code === "ENOTDIR";
+    if (!absent) {
+      console.warn(`[nexus] Failed to load config from ${filePath}: ${message}`);
     }
-    return null;
+    return { config: null, existed: !absent };
   }
 }
+function nexusProjectConfigPath(basePath) {
+  return resolve(join(basePath, ".opencode", "nexus.jsonc"));
+}
+function nexusGlobalConfigPath() {
+  return resolve(join(homedir(), ".config", "opencode", "nexus.jsonc"));
+}
+function redactHome(filePath) {
+  const home = homedir();
+  if (filePath === home)
+    return "~";
+  const prefix = home.endsWith("/") ? home : `${home}/`;
+  return filePath.startsWith(prefix) ? `~${filePath.slice(home.length)}` : filePath;
+}
+function describeFile(file) {
+  if (file.parsed)
+    return "loaded";
+  if (file.existed)
+    return "unparseable";
+  return "absent";
+}
+function formatConfigLoadLog(info) {
+  const models = Object.entries(info.models).map(([role, model]) => `${role}=${model}`).join(" ");
+  const override = info.sessionOverride ? " (+session override: storage; disk edits to models are IGNORED while a preset is set \u2014 clear the preset in the TUI to hand control back to disk)" : "";
+  return `[nexus] config loaded (#${info.loadCount} trigger=${info.trigger} at=${info.loadedAt}) ` + `project=${info.project.path} [${describeFile(info.project)}] ` + `global=${info.global.path} [${describeFile(info.global)}] ` + `models:${override} ${models}`;
+}
 var DEFAULT_CONFIG = {
   models: {
     architect: "anthropic/claude-sonnet-4-6",
@@ -91,19 +123,51 @@ class NexusConfigManager {
   projectConfig = null;
   globalConfig = null;
   storageConfig = null;
+  loadInfo = null;
   constructor() {
     this.projectConfig = null;
     this.globalConfig = null;
   }
   loadConfigs(basePath) {
-    this.storageConfig = null;
-    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
-    this.projectConfig = readJsoncFile(projectPath);
-    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
-    this.globalConfig = readJsoncFile(globalPath);
+    if (this.loadInfo === null)
+      this.storageConfig = null;
+    const projectPath = nexusProjectConfigPath(basePath);
+    const project = readJsoncFile(projectPath);
+    this.projectConfig = project.config;
+    const globalPath = nexusGlobalConfigPath();
+    const global = readJsoncFile(globalPath);
+    this.globalConfig = global.config;
+    return {
+      project: { path: redactHome(projectPath), existed: project.existed, parsed: project.config !== null },
+      global: { path: redactHome(globalPath), existed: global.existed, parsed: global.config !== null }
+    };
   }
-  loadFromPath(basePath) {
-    this.loadConfigs(basePath);
+  loadFromPath(basePath, trigger = "initial") {
+    const sources = this.loadConfigs(basePath);
+    this.loadInfo = {
+      project: sources.project,
+      global: sources.global,
+      models: this.getResolvedModels(),
+      sessionOverride: this.hasSessionOverride(),
+      loadedAt: new Date().toISOString(),
+      loadCount: (this.loadInfo?.loadCount ?? 0) + 1,
+      trigger
+    };
+    console.log(formatConfigLoadLog(this.loadInfo));
+  }
+  getLoadInfo() {
+    return this.loadInfo;
+  }
+  getResolvedModels() {
+    const models = {};
+    for (const [role, model] of Object.entries(this.getConfig().models)) {
+      if (model)
+        models[role] = model;
+    }
+    return models;
+  }
+  hasSessionOverride() {
+    return this.storageConfig !== null;
   }
   getConfig() {
     return {
@@ -206,17 +270,17 @@ class NexusConfigManager {
 `, "utf-8");
   }
   saveProjectConfig(basePath) {
-    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
+    const projectPath = nexusProjectConfigPath(basePath);
     const config = this.getSaveableConfig();
     this.writeJsoncFile(projectPath, config);
   }
   saveGlobalConfig() {
-    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
+    const globalPath = nexusGlobalConfigPath();
     const config = this.getSaveableConfig();
     this.writeJsoncFile(globalPath, config);
   }
   initProjectConfig(basePath) {
-    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
+    const projectPath = nexusProjectConfigPath(basePath);
     try {
       readFileSync(projectPath, "utf-8");
       return;
@@ -224,7 +288,7 @@ class NexusConfigManager {
     this.writeJsoncFile(projectPath, { ...DEFAULT_CONFIG });
   }
   initGlobalConfig() {
-    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
+    const globalPath = nexusGlobalConfigPath();
     try {
       readFileSync(globalPath, "utf-8");
       return;
@@ -390,6 +454,78 @@ var PRESETS = {
 
 // src/tui.tsx
 import { jsxDEV, Fragment } from "@opentui/solid/jsx-dev-runtime";
+var NEXUS_AGENT_PREFIX = "nexus-";
+function metadataString(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function roleFromAgent(agent) {
+  if (!agent)
+    return;
+  const role = agent.startsWith(NEXUS_AGENT_PREFIX) ? agent.slice(NEXUS_AGENT_PREFIX.length) : agent;
+  return role.length > 0 ? role : undefined;
+}
+function modelLabel(model) {
+  if (!model?.providerID || !model.id)
+    return;
+  return `${model.providerID}/${model.id}`;
+}
+function titleCase(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function sidebarAgentFor(session, status, now) {
+  const role = metadataString(session.metadata, "nexusRole") ?? roleFromAgent(session.agent);
+  return {
+    id: session.id,
+    name: role ? titleCase(role) : session.title || session.id.slice(0, 12),
+    role: role ?? "agent",
+    status,
+    model: metadataString(session.metadata, "nexusModel") ?? modelLabel(session.model) ?? "",
+    sessionID: session.id,
+    spawnedAt: now,
+    tasksCompleted: 0,
+    tasksFailed: 0
+  };
+}
+function sidebarChildSessionIDs(family, currentSessionID) {
+  if (!Array.isArray(family))
+    return [];
+  return family.filter((id) => id !== currentSessionID);
+}
+function collectSidebarAgents(source, currentSessionID, statusOf, now) {
+  const childIDs = sidebarChildSessionIDs(source.family(currentSessionID), currentSessionID);
+  if (childIDs.length === 0)
+    return [];
+  const agents = [];
+  for (const id of childIDs) {
+    try {
+      const session = source.get(id);
+      if (!session)
+        continue;
+      let status = "completed";
+      try {
+        status = statusOf(id);
+      } catch {}
+      agents.push(sidebarAgentFor(session, status, now));
+    } catch {}
+  }
+  return agents;
+}
+function mergeSidebarAgents(agents, polled, childIDs) {
+  const next = agents.map((agent) => ({ ...agent }));
+  for (const agent of polled) {
+    const existing = next.find((a) => a.sessionID === agent.sessionID);
+    if (existing) {
+      existing.status = agent.status;
+      existing.name = agent.name;
+      existing.role = agent.role;
+      existing.model = agent.model;
+    } else {
+      next.push(agent);
+    }
+  }
+  return next.filter((a) => a.sessionID && childIDs.includes(a.sessionID) || a.status === "completed" || a.status === "failed");
+}
 var tui_default = define({
   id: "nexus.cli",
   setup(context) {
@@ -784,69 +920,20 @@ var tui_default = define({
         const currentSessionID = currentRoute.sessionID;
         if (!currentSessionID)
           return;
-        const family = context.data.session.family(currentSessionID);
-        if (!family || !Array.isArray(family))
-          return;
-        const childIDs = family.filter((id) => id !== currentSessionID);
-        try {
-          const allSessions = context.data.session.list();
-          if (allSessions && Array.isArray(allSessions)) {
-            for (const s of allSessions) {
-              if (!s || !s.id)
-                continue;
-              const meta = s.metadata;
-              if (meta?.nexusRole && !childIDs.includes(s.id) && s.id !== currentSessionID) {
-                childIDs.push(s.id);
-              }
-            }
-          }
-        } catch {}
+        const source = context.data.session;
+        const childIDs = sidebarChildSessionIDs(source.family(currentSessionID), currentSessionID);
         if (childIDs.length === 0) {
           setSidebarState((draft) => {
-            draft.agents = draft.agents.filter((a) => a.status === "completed" || a.status === "failed");
+            draft.agents = mergeSidebarAgents(draft.agents, [], []);
           });
           return;
         }
-        const newAgents = childIDs.map((id) => {
-          try {
-            const session = context.data.session.get(id);
-            if (!session)
-              return null;
-            const meta = session.metadata || {};
-            let status = "completed";
-            try {
-              status = context.data.session.status(id) === "running" ? "working" : "completed";
-            } catch {}
-            return {
-              id,
-              name: meta.nexusRole ? `${meta.nexusRole.charAt(0).toUpperCase() + meta.nexusRole.slice(1)}` : session?.title || id.slice(0, 12),
-              role: meta.nexusRole || "agent",
-              status,
-              model: meta.nexusModel || "",
-              sessionID: id,
-              spawnedAt: new Date().toISOString(),
-              tasksCompleted: 0,
-              tasksFailed: 0
-            };
-          } catch {
-            return null;
-          }
-        }).filter(Boolean);
-        if (newAgents.length > 0) {
-          setSidebarState((draft) => {
-            for (const agent of newAgents) {
-              const existing = draft.agents.find((a) => a.sessionID === agent.sessionID);
-              if (existing) {
-                existing.status = agent.status;
-                existing.name = agent.name;
-                existing.model = agent.model;
-              } else {
-                draft.agents.push(agent);
-              }
-            }
-            draft.agents = draft.agents.filter((a) => a.sessionID && childIDs.includes(a.sessionID) || a.status === "completed" || a.status === "failed");
-          });
-        }
+        const newAgents = collectSidebarAgents(source, currentSessionID, (id) => context.data.session.status(id) === "running" ? "working" : "completed", new Date().toISOString());
+        if (newAgents.length === 0)
+          return;
+        setSidebarState((draft) => {
+          draft.agents = mergeSidebarAgents(draft.agents, newAgents, childIDs);
+        });
       } catch {}
     };
     const unsubSessionSucceeded = context.data.on("session.execution.succeeded", (event) => {
@@ -975,5 +1062,9 @@ var tui_default = define({
   }
 });
 export {
-  tui_default as default
+  collectSidebarAgents,
+  tui_default as default,
+  mergeSidebarAgents,
+  sidebarAgentFor,
+  sidebarChildSessionIDs
 };

package/package.json

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