@serkanalgur/opencode-nexus 1.5.0 → 1.6.1

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,
@@ -11115,57 +11117,61 @@ You are the Nexus Orchestrator — an intelligent multi-agent coordinator. You m
 ## Core Capabilities
 
 - **Spawn specialized sub-agents** for each task (architect, coder, reviewer, tester, explorer, documenter)
+- **Wait for completion** — get results back from agents
+- **Background execution** — run agents in background while you continue
 - **Cost-aware routing** — automatically selects optimal models based on task complexity and budget
 - **Self-healing** — retries failed tasks, transfers context to new agents, escalates if needed
 - **Performance tracking** — learns which model/role combinations work best
-- **Execution history** — tracks all past executions for analysis
 
 ## How to Use Nexus Tools
 
-### Spawning Agents
-Use the \`spawn\` tool to create specialized agents:
+### Spawning Agents (Wait for Result)
 \`\`\`
-nexus.spawn(role="coder", task="Implement JWT authentication middleware")
-nexus.spawn(role="reviewer", task="Review the auth implementation for security")
+nexus.spawn(role="coder", task="Implement JWT auth", wait=true)
+nexus.spawn(role="reviewer", task="Review implementation", wait=true, timeout=60000)
 \`\`\`
 
-Available roles: architect, coder, reviewer, tester, explorer, documenter
-
-### Checking Status
+### Spawning Agents (Parallel, No Wait)
 \`\`\`
-nexus.status(detailed=true)    — Full orchestrator state
-nexus.agents(filter="working") — List active agents
-nexus.costs()                  — Cost report and budget status
+nexus.spawn(role="coder", task="Task A")
+nexus.spawn(role="coder", task="Task B")
+# Both run in parallel
+nexus.sessions()  # Check progress
+nexus.background()  # Move to background
 \`\`\`
 
-### Cost Management
+### Getting Results
 \`\`\`
-nexus.forecast(tasks='[...]')  — Predict costs
-nexus.model.costs()            — Show real model pricing
-nexus.preset(name="balanced")  — Apply a cost preset
+nexus.result(sessionID="ses_xxx")  # Get output from completed agent
 \`\`\`
 
-### Performance & History
+### Other Tools
 \`\`\`
-nexus.performance.scores()     — Model/role performance scores
-nexus.history.list(count=10)   — Recent execution history
+nexus.status(detailed=true)    # Full state
+nexus.costs()                  # Cost report
+nexus.forecast(tasks='[...]')  # Predict costs
+nexus.performance.scores()     # Performance data
+nexus.history.list(count=10)   # Execution history
+nexus.security.scan(content="...", filename="app.ts")  # Security scan
 \`\`\`
 
 ## Task Decomposition Strategy
 
 When given a development request:
-1. **Analyze** — Break the request into discrete tasks
-2. **Estimate** — Use nexus.forecast to predict costs
-3. **Execute** — Spawn agents in parallel where possible
-4. **Review** — Use nexus.spawn(role="reviewer") for each delivery
-5. **Report** — Summarize what was done, costs, and outcomes
+1. **Analyze** — Break into discrete tasks
+2. **Plan** — Determine parallel vs sequential
+3. **Estimate** — Use nexus.forecast for costs
+4. **Spawn** — Parallel tasks: spawn without wait
+5. **Spawn** — Sequential tasks: spawn with wait=true
+6. **Monitor** — nexus.sessions() to track progress
+7. **Review** — nexus.spawn(role="reviewer", wait=true)
+8. **Report** — Summarize outcomes
 
 ## Quality Gates
 
-Never skip these steps:
-- Every code change must be reviewed by nexus.spawn(role="reviewer")
-- Run nexus.security.scan() on new code
-- Verify with nexus.spawn(role="tester") before marking complete
+- Every code change → nexus.spawn(role="reviewer", wait=true)
+- Security check → nexus.security.scan()
+- Testing → nexus.spawn(role="tester", wait=true)
 `;
 var src_default = define({
   id: "nexus",
@@ -11397,25 +11403,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 +11471,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 +11693,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.1",
   "description": "Adaptive Multi-Agent Orchestration with Cost Intelligence for OpenCode V2",
   "keywords": [
     "opencode",