@serkanalgur/opencode-nexus 1.5.0 → 1.6.0

package/dist/index.js

@@ -10012,6 +10012,7 @@ class NexusOrchestrator {
   }
   notifications = null;
   modelCosts = new Map;
+  parentSessionID = null;
   constructor(config, messageStoreConfig, memoryStoreConfig) {
     this.config = this.mergeConfig(config);
     this.budget = this.config.budget;
@@ -10650,7 +10651,8 @@ Please continue from where the previous agent left off.`;
     const session = await this.ctx.session.create({
       title,
       agent: agentType,
-      model: modelName ? { providerID: provider, id: modelName } : undefined
+      model: modelName ? { providerID: provider, id: modelName } : undefined,
+      parentID: this.parentSessionID || undefined
     });
     const agent = {
       id: agentId,
@@ -11397,25 +11399,54 @@ var src_default = define({
       });
       editor.add({
         name: "spawn",
-        description: "Spawn a sub-agent for a task",
+        description: "Spawn a sub-agent for a task. Use wait=true to wait for completion.",
         input: {
           type: "object",
           properties: {
             role: { type: "string", description: "Agent role (architect, coder, reviewer, tester, explorer, documenter)" },
             task: { type: "string", description: "Task description" },
-            model: { type: "string", description: "Model override (optional)" }
+            model: { type: "string", description: "Model override (optional)" },
+            wait: { type: "boolean", description: "Wait for completion (default: false)" },
+            timeout: { type: "number", description: "Timeout in ms when waiting (default: 120000)" }
           },
           required: ["role", "task"],
           additionalProperties: false
         },
         execute: async (input) => {
-          const { role, task, model } = input;
+          const { role, task, model, wait, timeout } = input;
           try {
+            orchestrator.parentSessionID = null;
             const agent = await orchestrator.spawnAgent({ role, model });
             await orchestrator.ctx.session.prompt({
               sessionID: agent.sessionID,
               text: task
             });
+            if (wait) {
+              const waitTimeout = timeout || 120000;
+              try {
+                await orchestrator.ctx.session.wait({ sessionID: agent.sessionID });
+              } catch {}
+              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)";
+                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;
+                return {
+                  content: [
+                    `${agent.name}`,
+                    `\uD83D\uDCCB Task: ${taskPreview}`,
+                    `✅ Status: completed`,
+                    `\uD83D\uDCCE Session: ${agent.sessionID}`,
+                    `
+--- Result ---`,
+                    result
+                  ].join(`
+`)
+                };
+              } catch {}
+            }
             const complexity = orchestrator.analyzeComplexity({
               id: `spawn-${Date.now()}`,
               name: task,
@@ -11436,7 +11467,8 @@ var src_default = define({
               `\uD83D\uDCCB Task: ${taskPreview}`,
               `\uD83D\uDCCA Complexity: ${complexity.overall}/100 (${complexity.factors.riskLevel} risk)`,
               `\uD83E\uDD16 Model reasoning: ${modelSelection.reasoning}`,
-              `\uD83D\uDCCE Session: ${agent.sessionID}`
+              `\uD83D\uDCCE Session: ${agent.sessionID}`,
+              `\uD83D\uDCA1 Use wait=true to wait for completion`
             ].join(`
 `);
             return { content: output };
@@ -11657,6 +11689,64 @@ Total: ~$${result.totalEstimatedCost.toFixed(4)}`);
           return { content: "Worktree isolation disabled." };
         }
       });
+      editor.add({
+        name: "sessions",
+        description: "List all active Nexus agent sessions",
+        input: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+          const agents = orchestrator.getState().agents;
+          if (agents.length === 0)
+            return { content: "No active agent sessions." };
+          const lines = agents.map((a) => {
+            const statusIcon = a.status === "working" ? "\uD83D\uDD04" : a.status === "idle" ? "⏸️" : a.status === "completed" ? "✅" : "❌";
+            return `${statusIcon} ${a.name} (${a.role}) — Session: ${a.sessionID}`;
+          });
+          return { content: `Active Sessions (${agents.length}):
+${lines.join(`
+`)}` };
+        }
+      });
+      editor.add({
+        name: "background",
+        description: "Move running agents to background (detach from current session)",
+        input: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+          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." };
+          for (const agent of agents) {
+            try {
+              await orchestrator.ctx.session.background({ sessionID: agent.sessionID });
+            } catch {}
+          }
+          return { content: `${agents.length} agent(s) moved to background. You can continue working while they run.` };
+        }
+      });
+      editor.add({
+        name: "result",
+        description: "Get the result of a completed agent session",
+        input: {
+          type: "object",
+          properties: {
+            sessionID: { type: "string", description: "Session ID of the agent" }
+          },
+          required: ["sessionID"]
+        },
+        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) {
+              return { content: `Session ${sessionID} result:
+${lastMsg.content}` };
+            }
+            return { content: `Session ${sessionID} has no assistant messages yet.` };
+          } catch (error) {
+            return { content: `Failed to get result: ${error.message}` };
+          }
+        }
+      });
     });
     await ctx.session.hook("prompt", (event) => {
       if (event.prompt.text.startsWith("/nexus")) {

package/package.json

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