@serkanalgur/opencode-nexus 2.3.5 → 2.4.1

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;
+  }
+  getResolvedModels() {
+    const models = {};
+    for (const [role, model] of Object.entries(this.getConfig().models)) {
+      if (model)
+        models[role] = model;
+    }
+    return models;
   }
-  loadFromPath(basePath) {
-    this.loadConfigs(basePath);
+  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;
@@ -10085,6 +10149,21 @@ ${lines.join(`
 }
 
 // src/orchestrator.ts
+function assistantMessageText(message) {
+  if (message.type !== "assistant")
+    return "";
+  return message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+function lastAssistantText(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    if (messages[i].type !== "assistant")
+      continue;
+    const text = assistantMessageText(messages[i]);
+    if (text)
+      return text;
+  }
+  return "";
+}
 var DEFAULT_ESCALATION = {
   maxRetries: 3,
   retryDelay: 1000,
@@ -10136,7 +10215,7 @@ class NexusOrchestrator {
   }
   notifications = null;
   modelCosts = new Map;
-  parentSessionID = null;
+  lastDegradedSpawn = null;
   constructor(config, messageStoreConfig, memoryStoreConfig) {
     this.config = this.mergeConfig(config);
     this.budget = this.config.budget;
@@ -10161,7 +10240,7 @@ class NexusOrchestrator {
   async initialize(ctx, onStateChange) {
     this.ctx = ctx;
     this.onStateChange = onStateChange ?? null;
-    const projectDir = ctx.location?.directory || process.cwd();
+    const projectDir = ctx.location.directory;
     this.configManager.loadFromPath(projectDir);
     await this.loadModelCosts();
     this.cleanupInterval = setInterval(() => this.cleanupStaleData(), 300000);
@@ -10181,41 +10260,22 @@ class NexusOrchestrator {
   }
   async loadModelCosts() {
     try {
-      if (!this.ctx)
+      if (!this.ctx?.model)
         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
-              });
-            }
-          }
-        }
+      const { data } = await this.ctx.model.list();
+      if (!Array.isArray(data) || data.length === 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
-            });
-          }
-        }
+      const per1k = (v) => (v || 0) / 1000;
+      for (const model of data) {
+        if (!model?.cost || !Array.isArray(model.cost) || model.cost.length === 0)
+          continue;
+        const baseCost = model.cost[0];
+        this.modelCosts.set(`${model.providerID}/${model.id}`, {
+          input: per1k(baseCost.input),
+          output: per1k(baseCost.output),
+          cacheRead: per1k(baseCost.cache?.read),
+          cacheWrite: per1k(baseCost.cache?.write)
+        });
       }
     } catch {}
   }
@@ -10366,6 +10426,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");
@@ -10398,6 +10473,7 @@ class NexusOrchestrator {
         agentsUsed: this.agents.size
       };
     } catch (error) {
+      console.error("[nexus] DAG execution failed:", error);
       return {
         success: false,
         tasks: [],
@@ -10493,7 +10569,21 @@ 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);
@@ -10503,10 +10593,15 @@ class NexusOrchestrator {
   async spawnAndExecute(node, transferContext) {
     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.`);
+    }
+    const qualifiedModel = `${model.provider}/${model.model}`;
     const agent = await this.spawnAgent({
       role: node.task.requiredRole,
       task: node.task,
-      model: model.model
+      model: qualifiedModel
     });
     node.spawnedAgent = agent;
     node.status = "running";
@@ -10564,15 +10659,14 @@ Please continue from where the previous agent left off.`;
       const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Task timed out")), timeout));
       await Promise.race([waitPromise, timeoutPromise]);
       const messages = await this.ctx.session.context({ sessionID: agent.sessionID });
-      const lastAssistantMsg = messages.filter((m) => m.role === "assistant").pop();
-      const output = lastAssistantMsg?.content || "Task completed";
+      const output = lastAssistantText(messages) || "Task completed (no output captured)";
       const duration = Date.now() - startTime;
       const result = {
         success: true,
-        output: typeof output === "string" ? output : JSON.stringify(output),
+        output,
         duration,
         tokensUsed: 0,
-        cost: this.estimateModelCost(agent.model.model)
+        cost: this.estimateModelCost(agent.model.model, agent.model.provider)
       };
       this.dag.markComplete(node.id, result);
       this.todoEnforcer.completeTask(agent.id);
@@ -10608,7 +10702,7 @@ Please continue from where the previous agent left off.`;
       if (priorPattern.length > 0) {
         this.learning.recordSuccess(priorPattern[0].entry.id);
       }
-      if (typeof output === "string" && output.length > 0) {
+      if (output.length > 0) {
         const securityIssues = this.securityScanner.scanContent(output, node.task.name);
         if (securityIssues.length > 0) {
           this.emit("security:issues-found", {
@@ -10769,7 +10863,57 @@ Please continue from where the previous agent left off.`;
     };
     this.notifyStateChange();
   }
-  async spawnAgent(config) {
+  async createChildSession(params) {
+    const { tool, agent, description, prompt, model, parent, callID } = params;
+    if (!parent.sessionID) {
+      throw new Error("Cannot spawn agent without a parent session ID");
+    }
+    if (!parent.agent) {
+      throw new Error("Cannot spawn agent without the calling agent id (tool context has no 'agent')");
+    }
+    let childSessionID;
+    let resolveChildSession = null;
+    let watchdog;
+    const childSessionReady = new Promise((resolve, reject) => {
+      resolveChildSession = resolve;
+      watchdog = setTimeout(() => reject(new Error(`subagent tool did not report a child session for ${agent}`)), 30000);
+    });
+    childSessionReady.catch(() => {});
+    const reportProgress = (p) => {
+      if (p?.sessionID && !childSessionID) {
+        childSessionID = p.sessionID;
+        resolveChildSession?.(p.sessionID);
+      }
+      return Promise.resolve();
+    };
+    const toolContext = {
+      sessionID: parent.sessionID,
+      agent: parent.agent,
+      messageID: parent.messageID || `msg_${callID}`,
+      id: `call_${callID}`,
+      progress: reportProgress,
+      signal: parent.signal ?? new AbortController().signal
+    };
+    const subagentCall = tool.execute({ agent, description, prompt, model, background: true }, toolContext);
+    let childSessionIDResolved;
+    try {
+      childSessionIDResolved = await Promise.race([
+        childSessionReady,
+        subagentCall.then(() => {
+          throw new Error(`subagent tool finished without reporting a child session for ${agent}`);
+        }, (err) => {
+          const message = err instanceof Error ? err.message : String(err);
+          throw new Error(`subagent tool failed for ${agent}: ${message}`);
+        })
+      ]);
+    } finally {
+      if (watchdog)
+        clearTimeout(watchdog);
+    }
+    subagentCall.catch(() => {});
+    return childSessionIDResolved;
+  }
+  async spawnAgent(config, options) {
     if (!this.ctx) {
       throw new Error("Orchestrator not initialized");
     }
@@ -10784,7 +10928,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("/");
@@ -10793,26 +10938,58 @@ 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: "architect",
-      coder: "build-orchestrator",
-      reviewer: "code-reviewer",
-      tester: "build-orchestrator",
-      explorer: "explore",
-      documenter: "doc-writer"
+      architect: "nexus-architect",
+      coder: "nexus-coder",
+      reviewer: "nexus-reviewer",
+      tester: "nexus-tester",
+      explorer: "nexus-explorer",
+      documenter: "nexus-documenter"
     };
-    const agentType = agentTypeMap[config.role] || "build";
-    const session = await this.ctx.session.create({
-      title,
-      agent: agentType,
-      model: modelName ? { providerID: provider, id: modelName } : undefined,
-      parentID: this.parentSessionID || undefined,
-      metadata: {
-        nexusRole: config.role,
-        nexusTask: config.task?.name || "direct-spawn",
-        nexusAgentId: agentId,
-        nexusModel: modelConfig
-      }
-    });
+    const agentType = agentTypeMap[config.role] || "nexus-coder";
+    const parent = options?.toolContext?.sessionID ? options.toolContext : undefined;
+    const toolList = parent && typeof this.ctx.tool?.list === "function" ? await this.ctx.tool.list() : undefined;
+    const subagentTool = Array.isArray(toolList) ? toolList.find((t) => t?.id === "subagent" && typeof t?.execute === "function") : undefined;
+    const taskText = options?.task || config.task?.description || config.task?.name || "";
+    let spawnPath = "session-create";
+    let childSessionID;
+    if (parent && subagentTool) {
+      if (!taskText) {
+        throw new Error("spawnAgent requires task text when using the subagent tool path");
+      }
+      spawnPath = "subagent-tool";
+      childSessionID = await this.createChildSession({
+        tool: subagentTool,
+        agent: agentType,
+        description: title,
+        prompt: taskText,
+        model: modelConfig,
+        parent,
+        callID: agentId
+      });
+    } else {
+      const created = await this.ctx.session.create({
+        title,
+        agent: agentType,
+        model: modelName ? { providerID: provider, id: modelName } : undefined,
+        metadata: {
+          nexusRole: config.role,
+          nexusTask: config.task?.name || "direct-spawn",
+          nexusAgentId: agentId,
+          nexusModel: modelConfig
+        }
+      });
+      childSessionID = created.id;
+    }
+    if (spawnPath === "session-create") {
+      this.lastDegradedSpawn = {
+        agentId,
+        role: config.role,
+        reason: parent ? "subagent-tool-unavailable" : "no-parent-context"
+      };
+      console.warn(`[nexus] spawn degraded for ${config.role}: child session ${childSessionID} was created via ` + `ctx.session.create (${this.lastDegradedSpawn.reason}) and is not linked to a parent session.`);
+    } else {
+      this.lastDegradedSpawn = null;
+    }
     const agent = {
       id: agentId,
       name: title,
@@ -10835,7 +11012,8 @@ Please continue from where the previous agent left off.`;
         averageResponseTime: 0,
         errorRate: 0
       },
-      sessionID: session.id
+      sessionID: childSessionID,
+      spawnPath
     };
     this.agents.set(agentId, agent);
     const taskDesc = config.task?.name || `Agent ${config.role} task`;
@@ -10890,10 +11068,29 @@ Please continue from where the previous agent left off.`;
   selectModel(role, complexity) {
     return this.selectBestModel(role, complexity);
   }
-  estimateModelCost(model) {
-    const realCost = this.modelCosts.get(model);
+  getModelCost(model, provider) {
+    const exact = this.modelCosts.get(model);
+    if (exact)
+      return exact;
+    if (provider) {
+      const qualified = this.modelCosts.get(`${provider}/${model}`);
+      if (qualified)
+        return qualified;
+    }
+    const bare = model.slice(model.indexOf("/") + 1);
+    let best;
+    for (const [key, cost] of this.modelCosts) {
+      if (key.slice(key.indexOf("/") + 1) !== bare)
+        continue;
+      if (!best || cost.input < best.input)
+        best = cost;
+    }
+    return best;
+  }
+  estimateModelCost(model, provider) {
+    const realCost = this.getModelCost(model, provider);
     if (realCost) {
-      return (realCost.input * 1000 + realCost.output * 1000) / 2;
+      return (realCost.input + realCost.output) / 2;
     }
     const costs = {
       "claude-sonnet-4-6": 0.15,
@@ -10933,7 +11130,7 @@ Please continue from where the previous agent left off.`;
   scoreModel(modelId, role, complexity) {
     const [provider, ...parts] = modelId.split("/");
     const model = parts.join("/");
-    const cost = this.estimateModelCost(model);
+    const cost = this.estimateModelCost(model, provider);
     const quality = this.estimateModelQuality(model);
     const maxCost = 15;
     const costScore = 1 - cost / maxCost;
@@ -10965,14 +11162,14 @@ 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);
+      const cost = this.estimateModelCost(s.model, s.provider);
       return cost <= budgetRemaining || cost === 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),
+      estimatedCost: this.estimateModelCost(best.model, best.provider),
       estimatedQuality: best.qualityScore,
       reasoning: best.reasoning
     };
@@ -11041,8 +11238,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,
@@ -11050,7 +11259,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) {
@@ -11460,12 +11670,151 @@ 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
+permissions:
+  - action: subagent
+    resource: "nexus-*"
+    effect: allow
+  - action: subagent
+    resource: "nexus-architect"
+    effect: allow
+  - action: subagent
+    resource: "nexus-coder"
+    effect: allow
+  - action: subagent
+    resource: "nexus-reviewer"
+    effect: allow
+  - action: subagent
+    resource: "nexus-tester"
+    effect: allow
+  - action: subagent
+    resource: "nexus-explorer"
+    effect: allow
+  - action: subagent
+    resource: "nexus-documenter"
+    effect: allow
 ---
 
 # Nexus Orchestrator
@@ -11629,8 +11978,10 @@ mode: subagent
 permissions:
   - action: edit
     resource: "*"
+    effect: allow
   - action: shell
     resource: "*"
+    effect: allow
 ---
 
 # Nexus Architect Agent
@@ -11671,8 +12022,10 @@ mode: subagent
 permissions:
   - action: edit
     resource: "*"
+    effect: allow
   - action: shell
     resource: "*"
+    effect: allow
 ---
 
 # Nexus Coder Agent
@@ -11758,8 +12111,10 @@ mode: subagent
 permissions:
   - action: edit
     resource: "*"
+    effect: allow
   - action: shell
     resource: "*"
+    effect: allow
 ---
 
 # Nexus Tester Agent
@@ -11857,8 +12212,10 @@ mode: subagent
 permissions:
   - action: edit
     resource: "*"
+    effect: allow
   - action: shell
     resource: "*"
+    effect: allow
 ---
 
 # Nexus Documenter Agent
@@ -11936,6 +12293,25 @@ You are a technical writer who creates documentation that developers actually wa
       totalCost: initialState.totalSpent,
       budgetRemaining: initialState.budgetRemaining
     })));
+    const spawnAndDeliver = async (opts, toolCtx) => {
+      const agent = await orchestrator.spawnAgent({ role: opts.role, model: opts.model }, {
+        toolContext: {
+          sessionID: toolCtx?.sessionID || "",
+          agent: toolCtx?.agent,
+          messageID: toolCtx?.messageID,
+          callID: toolCtx?.id,
+          signal: toolCtx?.signal
+        },
+        task: opts.task
+      });
+      if (agent.spawnPath !== "subagent-tool") {
+        await ctx.session.prompt({
+          sessionID: agent.sessionID,
+          text: opts.task
+        });
+      }
+      return agent;
+    };
     await ctx.tool.transform((editor) => {
       editor.namespace({
         name: "nexus",
@@ -11943,7 +12319,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: {
@@ -12082,7 +12458,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}` };
           }
@@ -12122,35 +12501,36 @@ You are a technical writer who creates documentation that developers actually wa
       });
       editor.add({
         name: "model.costs",
-        description: "Show real model pricing from OpenCode or set custom costs",
+        description: "Show real model pricing from OpenCode, or set custom costs. All prices are USD per 1K tokens.",
         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" }
+            model: { type: "string", description: "Model to show cost for, as 'provider/id' or a bare 'id' (optional, shows all if omitted)" },
+            setInput: { type: "number", description: "Set input cost in USD per 1K tokens for a model (e.g. 0.003 for $3 per million tokens)" },
+            setOutput: { type: "number", description: "Set output cost in USD per 1K tokens for a model (e.g. 0.015 for $15 per million tokens)" }
           },
           additionalProperties: false
         },
         options: { codemode: true },
         execute: async (input) => {
           const { model, setInput, setOutput } = input;
+          const per1k = (v) => `$${v}/1K tokens`;
           if (model && setInput !== undefined && setOutput !== undefined) {
             orchestrator.setModelCosts({ [model]: { input: setInput, output: setOutput } });
-            return { content: `Set ${model}: input=$${setInput}/token, output=$${setOutput}/token` };
+            return { content: `Set ${model}: input=${per1k(setInput)}, output=${per1k(setOutput)}` };
           }
           if (model) {
-            const cost = orchestrator.modelCosts.get(model);
+            const cost = orchestrator.getModelCost(model);
             if (cost) {
-              return { content: `${model}: input=$${cost.input}/token, output=$${cost.output}/token, cache_read=$${cost.cacheRead}/token, cache_write=$${cost.cacheWrite}/token` };
+              return { content: `${model}: input=${per1k(cost.input)}, output=${per1k(cost.output)}, cache_read=${per1k(cost.cacheRead)}, cache_write=${per1k(cost.cacheWrite)}` };
             }
             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):"];
+            const lines = ["\uD83D\uDCCA Model Pricing (from OpenCode, per 1K tokens):"];
             for (const [id, cost] of orchestrator.modelCosts) {
-              lines.push(`  ${id}: $${cost.input}/token in, $${cost.output}/token out`);
+              lines.push(`  ${id}: ${per1k(cost.input)} in, ${per1k(cost.output)} out`);
             }
             return { content: lines.join(`
 `) };
@@ -12174,27 +12554,15 @@ You are a technical writer who creates documentation that developers actually wa
           additionalProperties: false
         },
         options: { codemode: true },
-        execute: async (input) => {
+        execute: async (input, toolCtx) => {
           const { role, task, model, wait, timeout } = input;
           try {
-            if (!orchestrator.parentSessionID) {
-              try {
-                const currentSession = ctx.session?.current?.();
-                if (currentSession?.id) {
-                  orchestrator.parentSessionID = currentSession.id;
-                }
-              } catch {}
-            }
-            const agent = await orchestrator.spawnAgent({ role, model });
-            await orchestrator.ctx.session.prompt({
-              sessionID: agent.sessionID,
-              text: task
-            });
+            const agent = await spawnAndDeliver({ role, task, model }, toolCtx);
             agent.status = "working";
             orchestrator.notifyStateChange();
             if (wait) {
               const waitTimeout = timeout || 120000;
-              const waitPromise = orchestrator.ctx.session.wait({ sessionID: agent.sessionID });
+              const waitPromise = ctx.session.wait({ sessionID: agent.sessionID });
               const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Timed out after ${waitTimeout}ms`)), waitTimeout));
               try {
                 await Promise.race([waitPromise, timeoutPromise]);
@@ -12202,9 +12570,9 @@ You are a technical writer who creates documentation that developers actually wa
                 agent.status = "working";
                 orchestrator.notifyStateChange();
                 try {
-                  const messages = await orchestrator.ctx.session.context({ sessionID: agent.sessionID });
-                  const lastMsg = messages.filter((m) => m.role === "assistant").pop();
-                  if (lastMsg) {
+                  const messages = await ctx.session.context({ sessionID: agent.sessionID });
+                  const partialText = lastAssistantText(messages);
+                  if (partialText) {
                     agent.status = "completed";
                     await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
                     const taskPreview = task.length > 80 ? task.substring(0, 77) + "..." : task;
@@ -12216,7 +12584,7 @@ You are a technical writer who creates documentation that developers actually wa
                         `\uD83D\uDCCE Session: ${agent.sessionID}`,
                         `
 --- Partial Result ---`,
-                        typeof lastMsg.content === "string" ? lastMsg.content : JSON.stringify(lastMsg.content)
+                        partialText
                       ].join(`
 `)
                     };
@@ -12234,9 +12602,8 @@ You are a technical writer who creates documentation that developers actually wa
                 };
               }
               try {
-                const messages = await orchestrator.ctx.session.context({ sessionID: agent.sessionID });
-                const lastMsg = messages.filter((m) => m.role === "assistant").pop();
-                const result = lastMsg?.content || "Task completed (no output captured)";
+                const messages = await ctx.session.context({ sessionID: agent.sessionID });
+                const result = lastAssistantText(messages) || "Task completed (no output captured)";
                 agent.status = "completed";
                 await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
                 const taskPreview = task.length > 80 ? task.substring(0, 77) + "..." : task;
@@ -12311,24 +12678,19 @@ You are a technical writer who creates documentation that developers actually wa
           additionalProperties: false
         },
         options: { codemode: true },
-        execute: async (input) => {
+        execute: async (input, toolCtx) => {
           const { role, task, model, timeout } = input;
           try {
-            const agent = await orchestrator.spawnAgent({ role, model });
-            await orchestrator.ctx.session.prompt({
-              sessionID: agent.sessionID,
-              text: task
-            });
+            const agent = await spawnAndDeliver({ role, task, model }, toolCtx);
             agent.status = "working";
             orchestrator.notifyStateChange();
             const waitTimeout = timeout || 120000;
-            const waitPromise = orchestrator.ctx.session.wait({ sessionID: agent.sessionID });
+            const waitPromise = ctx.session.wait({ sessionID: agent.sessionID });
             const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve("timeout"), waitTimeout));
             const outcome = await Promise.race([waitPromise.then(() => "completed"), timeoutPromise]);
             try {
-              const messages = await orchestrator.ctx.session.context({ sessionID: agent.sessionID });
-              const lastMsg = messages.filter((m) => m.role === "assistant").pop();
-              const resultContent = lastMsg?.content || (outcome === "timeout" ? "Timed out — agent may still be running" : "Completed with no output");
+              const messages = await ctx.session.context({ sessionID: agent.sessionID });
+              const resultContent = lastAssistantText(messages) || (outcome === "timeout" ? "Timed out — agent may still be running" : "Completed with no output");
               agent.status = outcome === "timeout" ? "working" : "completed";
               orchestrator.notifyStateChange();
               await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
@@ -12630,12 +12992,20 @@ ${lines.join(`
           const agents = orchestrator.getState().agents.filter((a) => a.status === "working" || a.status === "idle");
           if (agents.length === 0)
             return { content: "No running agents to move to background." };
+          const background = ctx.session.background;
+          if (!background) {
+            return { content: "This OpenCode version does not expose session.background on the plugin context — nothing was detached." };
+          }
+          let detached = 0;
           for (const agent of agents) {
+            if (!agent.sessionID)
+              continue;
             try {
-              await orchestrator.ctx.session.background({ sessionID: agent.sessionID });
+              await background.call(ctx.session, { sessionID: agent.sessionID });
+              detached++;
             } catch {}
           }
-          return { content: `${agents.length} agent(s) moved to background. You can continue working while they run.` };
+          return { content: `${detached} agent(s) moved to background. You can continue working while they run.` };
         }
       });
       editor.add({
@@ -12652,11 +13022,11 @@ ${lines.join(`
         execute: async (input) => {
           const { sessionID } = input;
           try {
-            const messages = await orchestrator.ctx.session.context({ sessionID });
-            const lastMsg = messages.filter((m) => m.role === "assistant").pop();
-            if (lastMsg) {
+            const messages = await ctx.session.context({ sessionID });
+            const text = lastAssistantText(messages);
+            if (text) {
               return { content: `Session ${sessionID} result:
-${lastMsg.content}` };
+${text}` };
             }
             return { content: `Session ${sessionID} has no assistant messages yet.` };
           } catch (error) {
@@ -13064,19 +13434,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,
@@ -13095,5 +13470,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, 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;
   }
-  loadFromPath(basePath) {
-    this.loadConfigs(basePath);
+  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;

package/package.json

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