@serkanalgur/opencode-nexus 2.3.4 → 2.4.0

package/dist/index.js

@@ -8486,7 +8486,11 @@ class NexusConfigManager {
   }
   getModelForRole(role) {
     const config = this.getConfig();
-    return config.models[role] || config.models.coder || DEFAULT_CONFIG.models.coder;
+    const model = config.models[role] || config.models.coder || DEFAULT_CONFIG.models.coder;
+    if (!model.includes("/")) {
+      console.warn(`[nexus] Model "${model}" for role "${role}" is missing provider prefix. Expected "providerID/modelID" format.`);
+    }
+    return model;
   }
   updateStorageConfig(update) {
     this.storageConfig = {
@@ -8570,10 +8574,18 @@ class NexusConfigManager {
   }
   initProjectConfig(basePath) {
     const projectPath = join(basePath, ".opencode", "nexus.jsonc");
+    try {
+      readFileSync(projectPath, "utf-8");
+      return;
+    } catch {}
     this.writeJsoncFile(projectPath, { ...DEFAULT_CONFIG });
   }
   initGlobalConfig() {
     const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
+    try {
+      readFileSync(globalPath, "utf-8");
+      return;
+    } catch {}
     this.writeJsoncFile(globalPath, { ...DEFAULT_CONFIG });
   }
   saveConfig(level, basePath) {
@@ -10073,6 +10085,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,
@@ -10124,7 +10151,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;
@@ -10149,7 +10176,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);
@@ -10169,41 +10196,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 {}
   }
@@ -10552,15 +10560,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);
@@ -10596,7 +10603,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", {
@@ -10757,7 +10764,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");
     }
@@ -10765,33 +10822,74 @@ Please continue from where the previous agent left off.`;
       throw new Error("Budget exceeded — cannot spawn new agents");
     }
     const agentId = `agent-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    const modelConfig = config.model || this.configManager.getModelForRole(config.role);
+    let modelConfig = config.model || this.configManager.getModelForRole(config.role);
+    if (!modelConfig.includes("/")) {
+      const allModels = this.configManager.getConfig().models;
+      const match = Object.values(allModels).find((m) => m?.split("/")[1] === modelConfig);
+      if (match) {
+        modelConfig = match;
+      } else {
+        throw new Error(`Invalid model "${config.model}". Use "providerID/modelID" format (e.g. "opencode-go/mimo-v2.5")`);
+      }
+    }
     const slashIndex = modelConfig.indexOf("/");
-    const provider = slashIndex > -1 ? modelConfig.slice(0, slashIndex) : modelConfig;
-    const modelName = slashIndex > -1 ? modelConfig.slice(slashIndex + 1) : modelConfig;
+    const provider = modelConfig.slice(0, slashIndex);
+    const modelName = modelConfig.slice(slashIndex + 1);
     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,
@@ -10814,7 +10912,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`;
@@ -10869,10 +10968,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,
@@ -10912,7 +11030,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;
@@ -10944,14 +11062,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
     };
@@ -11445,6 +11563,28 @@ import { homedir as homedir2 } from "node:os";
 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
@@ -11608,8 +11748,10 @@ mode: subagent
 permissions:
   - action: edit
     resource: "*"
+    effect: allow
   - action: shell
     resource: "*"
+    effect: allow
 ---
 
 # Nexus Architect Agent
@@ -11650,8 +11792,10 @@ mode: subagent
 permissions:
   - action: edit
     resource: "*"
+    effect: allow
   - action: shell
     resource: "*"
+    effect: allow
 ---
 
 # Nexus Coder Agent
@@ -11737,8 +11881,10 @@ mode: subagent
 permissions:
   - action: edit
     resource: "*"
+    effect: allow
   - action: shell
     resource: "*"
+    effect: allow
 ---
 
 # Nexus Tester Agent
@@ -11836,8 +11982,10 @@ mode: subagent
 permissions:
   - action: edit
     resource: "*"
+    effect: allow
   - action: shell
     resource: "*"
+    effect: allow
 ---
 
 # Nexus Documenter Agent
@@ -11915,6 +12063,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",
@@ -12101,35 +12268,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(`
 `) };
@@ -12153,27 +12321,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]);
@@ -12181,9 +12337,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;
@@ -12195,7 +12351,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(`
 `)
                     };
@@ -12213,9 +12369,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;
@@ -12290,24 +12445,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())));
@@ -12609,12 +12759,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({
@@ -12631,11 +12789,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) {

package/dist/tui.js

@@ -129,7 +129,11 @@ class NexusConfigManager {
   }
   getModelForRole(role) {
     const config = this.getConfig();
-    return config.models[role] || config.models.coder || DEFAULT_CONFIG.models.coder;
+    const model = config.models[role] || config.models.coder || DEFAULT_CONFIG.models.coder;
+    if (!model.includes("/")) {
+      console.warn(`[nexus] Model "${model}" for role "${role}" is missing provider prefix. Expected "providerID/modelID" format.`);
+    }
+    return model;
   }
   updateStorageConfig(update) {
     this.storageConfig = {
@@ -213,10 +217,18 @@ class NexusConfigManager {
   }
   initProjectConfig(basePath) {
     const projectPath = join(basePath, ".opencode", "nexus.jsonc");
+    try {
+      readFileSync(projectPath, "utf-8");
+      return;
+    } catch {}
     this.writeJsoncFile(projectPath, { ...DEFAULT_CONFIG });
   }
   initGlobalConfig() {
     const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
+    try {
+      readFileSync(globalPath, "utf-8");
+      return;
+    } catch {}
     this.writeJsoncFile(globalPath, { ...DEFAULT_CONFIG });
   }
   saveConfig(level, basePath) {
@@ -382,6 +394,12 @@ var tui_default = define({
   id: "nexus.cli",
   setup(context) {
     const configManager = new NexusConfigManager;
+    try {
+      const loc = context.location ?? context.data.location.default();
+      if (loc?.directory) {
+        configManager.loadFromPath(loc.directory);
+      }
+    } catch {}
     let configSaveScope = "global";
     const handleModelSelect = async (role) => {
       if (!configManager.getRoles().includes(role)) {

package/package.json

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