feat: add session continuation support to launch_opencode tool

- Add continueSession() and getTaskBySessionId() methods to TaskManager
- Add spawnContinueProcess() helper to opencode.tool.ts for --session flag
- Add sessionId parameter to launch_opencode with mixed array support
- Support mixing new tasks and continuations in single call
- Default continuation message to "continue" when no task provided

Author: RhizomaticRobin

src/tasks/taskManager.ts

@@ -340,6 +340,56 @@ export class TaskManager {
     return Array.from(this.tasks.values()).map(state => ({ ...state.metadata }));
   }
 
+  /**
+   * Gets a task by its session ID.
+   * Useful for session continuation when only the sessionId is known.
+   *
+   * @param sessionId - The OpenCode session ID to look up
+   * @returns The taskId, or undefined if session not found
+   */
+  getTaskBySessionId(sessionId: string): string | undefined {
+    for (const [taskId, state] of this.tasks) {
+      if (state.metadata.sessionId === sessionId) {
+        return taskId;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Continues an existing task for a session.
+   * Reuses the existing task ID and metadata, but updates to working status.
+   *
+   * @param sessionId - The OpenCode session ID to continue
+   * @returns The existing taskId for the session
+   * @throws Error if session not found or task is already terminal
+   */
+  async continueSession(sessionId: string): Promise<string> {
+    // Find the task with this session ID
+    const taskId = this.getTaskBySessionId(sessionId);
+    if (!taskId) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    const state = this.tasks.get(taskId);
+    if (!state) {
+      throw new Error(`Task ${taskId} not found (internal error)`);
+    }
+
+    // Check if task is already terminal
+    if (this.isTerminalStatus(state.status)) {
+      throw new Error(`Cannot continue session ${sessionId}: task is already ${state.status}`);
+    }
+
+    // Reset to working status and clear any pending timers
+    this.clearInputRequiredTimer(taskId);
+    this.updateStatus(taskId, "working");
+
+    Logger.debug(`Continuing session ${sessionId} with task ${taskId}`);
+
+    return taskId;
+  }
+
   /**
    * Removes a task from the manager.
    * Useful for cleanup after tasks complete.

src/tools/index.ts

@@ -1,18 +1,14 @@
 // Tool Registry Index - Registers all tools
 import { toolRegistry } from './registry.js';
-import { pingTool, helpTool } from './simple-tools.js';
-import { opencodeTool } from './opencode.tool.js';
+import { launchOpencodeTool } from './launch-opencode.tool.js';
 import { opencodeSessionsTool } from './opencode-sessions.tool.js';
-import { opencodeRespondTool } from './opencode-respond.tool.js';
+import { waitForCompletionTool } from './wait-for-completion.tool.js';
 
 toolRegistry.push(
-  // Async OpenCode tools
-  opencodeTool,
+  // OpenCode tools
+  launchOpencodeTool,
   opencodeSessionsTool,
-  opencodeRespondTool,
-  // Simple utility tools
-  pingTool,
-  helpTool
+  waitForCompletionTool,
 );
 
-export * from './registry.js';
+export * from './registry.js';

src/tools/launch-opencode.tool.ts

@@ -0,0 +1,292 @@
+/**
+ * Launch OpenCode Tool - Launches 1 or more OpenCode tasks in parallel.
+ * Returns immediately with task IDs for all launched tasks.
+ * @module launch-opencode.tool
+ */
+
+import { z } from "zod";
+import { UnifiedTool } from "./registry.js";
+import { getTaskManager } from "../tasks/sharedTaskManager.js";
+import { getServerConfig } from "../config.js";
+import { Logger } from "../utils/logger.js";
+
+// Import spawnOpenCodeProcess and spawnContinueProcess from opencode.tool
+import {
+  spawnOpenCodeProcess,
+  spawnContinueProcess,
+} from "./opencode.tool.js";
+
+// ============================================================================
+// Schema - Task OR session continuation
+// ============================================================================
+
+// New task definition schema
+const newTaskSchema = z.object({
+  task: z
+    .string()
+    .min(1)
+    .describe("The task/prompt to send to OpenCode for autonomous execution"),
+  agent: z
+    .enum(["explore", "plan", "build"])
+    .optional()
+    .describe("OpenCode agent mode: 'explore' for investigation, 'plan' for structured analysis, 'build' for immediate execution"),
+  outputGuidance: z
+    .string()
+    .optional()
+    .describe("Instructions for how OpenCode should format its output"),
+  model: z
+    .string()
+    .optional()
+    .describe("Override default model (e.g., 'google/gemini-2.5-pro')"),
+  sessionTitle: z
+    .string()
+    .optional()
+    .describe("Human-readable session name for tracking"),
+});
+
+// Session continuation definition schema
+const continueSessionSchema = z.object({
+  sessionId: z
+    .string()
+    .min(1)
+    .describe("Existing OpenCode session ID to continue"),
+  task: z
+    .string()
+    .optional()
+    .describe("Follow-up message/instruction for the session"),
+  model: z
+    .string()
+    .optional()
+    .describe("Override default model for continuation"),
+});
+
+// Discriminated union: either a new task OR a session continuation
+const taskOrContinueSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("new"),
+    ...newTaskSchema.shape,
+  }),
+  z.object({
+    type: z.literal("continue"),
+    ...continueSessionSchema.shape,
+  }),
+]);
+
+// Main args schema
+const launchOpencodeArgsSchema = z.object({
+  // Convenience: single new task (type inferred)
+  task: z.string().min(1).optional().describe("Launch a single new task - what you want OpenCode to do"),
+  agent: z.enum(["explore", "plan", "build"]).optional().describe("Agent mode for single new task"),
+  outputGuidance: z.string().optional().describe("Output guidance for single new task"),
+  model: z.string().optional().describe("Model override for single new task"),
+  sessionTitle: z.string().optional().describe("Session title for single new task"),
+
+  // Convenience: single session continuation
+  sessionId: z.string().optional().describe("Continue existing OpenCode session ID (single continuation mode)"),
+
+  // Generic: mixed array of new tasks and/or continuations
+  tasks: z.array(taskOrContinueSchema).optional().describe("Launch multiple tasks - array mixing new tasks (type:'new') and continuations (type:'continue')"),
+}).refine(
+  (data) => {
+    // Valid patterns:
+    // 1. Single new task: task set, tasks and sessionId not set
+    // 2. Single continuation: sessionId set, tasks not set
+    // 3. Multiple tasks: tasks set, task and sessionId not set
+    const hasTask = data.task !== undefined && typeof data.task === 'string';
+    const hasTasks = data.tasks !== undefined && Array.isArray(data.tasks);
+    const hasSessionId = data.sessionId !== undefined && typeof data.sessionId === 'string';
+
+    const setCount = [hasTask, hasTasks, hasSessionId].filter(Boolean).length;
+    return setCount === 1;
+  },
+  {
+    message: "Must provide exactly one of: 'task' (single new task), 'sessionId' (single continuation), or 'tasks' (array mixing new tasks and continuations)",
+  }
+);
+
+// ============================================================================
+// Types
+// ============================================================================
+
+type NewTaskDef = z.infer<typeof newTaskSchema>;
+type ContinueSessionDef = z.infer<typeof continueSessionSchema>;
+type TaskOrContinueDef = z.infer<typeof taskOrContinueSchema>;
+
+// ============================================================================
+// Tool Implementation
+// ============================================================================
+
+export const launchOpencodeTool: UnifiedTool = {
+  name: "launch_opencode",
+  description: `Launch OpenCode tasks (1 or more) for autonomous execution. Returns immediately with task IDs.
+
+USE THIS TOOL when you need to:
+- Run code analysis, generation, or modification tasks
+- Delegate work to another model for parallel processing
+- Execute long-running operations asynchronously
+- Launch multiple independent tasks concurrently
+- Continue an existing OpenCode session with follow-up instructions
+- Mix new tasks and session continuations in a single call
+
+WORKFLOW:
+1. Call launch_opencode with task definition(s) or sessionId
+2. Receive task ID(s) immediately (status: "working")
+3. Monitor progress with opencode_sessions tool
+4. Call wait_for_completion to get results
+
+INPUTS (single new task):
+- task: What you want OpenCode to do (required)
+- agent: "explore", "plan", or "build" (optional)
+- model: Override default model (optional)
+- outputGuidance: Instructions for output formatting (optional)
+- sessionTitle: Human-readable name (optional)
+
+INPUTS (single continuation):
+- sessionId: Existing OpenCode session ID (required)
+- task: Follow-up message (optional)
+- model: Override default model (optional)
+
+INPUTS (mixed array):
+- tasks: Array of items, each with type:'new' (new task) or type:'continue' (continuation)
+  For type:'new': same fields as single new task above
+  For type:'continue': sessionId (required), task (optional), model (optional)
+
+RETURNS: { results: [{taskId, sessionId, status}], count: number }
+
+NOTE: This is an async operation. Tasks continue running after this tool returns. Use opencode_sessions to check completion status, and wait_for_completion to get final results.`,
+  zodSchema: launchOpencodeArgsSchema,
+  category: "opencode",
+
+  execute: async (args): Promise<string> => {
+    const taskManager = getTaskManager();
+    const config = getServerConfig();
+    const input = args as any;
+
+    const results: Array<{
+      taskId: string;
+      sessionId: string;
+      status: "working";
+    }> = [];
+
+    // Handle single continuation mode
+    if (input.sessionId && typeof input.sessionId === 'string') {
+      const sessionId = input.sessionId;
+      const message = input.task || "continue";
+      const model = input.model;
+
+      const taskId = await taskManager.continueSession(sessionId);
+      Logger.debug(`Continuing session ${sessionId} with task ${taskId}`);
+
+      spawnContinueProcess(taskId, sessionId, message, model);
+
+      const metadata = taskManager.getTaskMetadata(taskId);
+      results.push({
+        taskId,
+        sessionId: metadata?.sessionId || sessionId,
+        status: "working",
+      });
+    }
+    // Handle single new task mode
+    else if (input.task && typeof input.task === 'string') {
+      const taskDef: NewTaskDef = {
+        task: input.task,
+        agent: input.agent,
+        outputGuidance: input.outputGuidance,
+        model: input.model,
+        sessionTitle: input.sessionTitle,
+      };
+
+      if (!taskDef.task?.trim()) {
+        Logger.warn("Skipping task with empty task description");
+        return JSON.stringify({ results: [], count: 0 }, null, 2);
+      }
+
+      const effectiveModel = taskDef.model || config.primaryModel;
+      const title = taskDef.sessionTitle || `OpenCode task: ${taskDef.task.slice(0, 50)}${taskDef.task.length > 50 ? "..." : ""}`;
+
+      const taskId = await taskManager.createTask({
+        title,
+        model: effectiveModel,
+        agent: taskDef.agent,
+      });
+
+      Logger.debug(`Created task ${taskId}: ${title}`);
+      spawnOpenCodeProcess(taskId, taskDef.task, effectiveModel, taskDef.agent, taskDef.outputGuidance);
+
+      const metadata = taskManager.getTaskMetadata(taskId);
+      results.push({
+        taskId,
+        sessionId: metadata?.sessionId || "",
+        status: "working",
+      });
+    }
+    // Handle mixed array mode
+    else if (input.tasks && Array.isArray(input.tasks)) {
+      for (const item of input.tasks) {
+        const validated = taskOrContinueSchema.safeParse(item);
+        if (!validated.success) {
+          Logger.warn(`Skipping invalid task item: ${validated.error.message}`);
+          continue;
+        }
+
+        if (validated.data.type === "continue") {
+          // Handle continuation
+          const { sessionId, task: message, model } = validated.data;
+
+          try {
+            const taskId = await taskManager.continueSession(sessionId);
+            Logger.debug(`Continuing session ${sessionId} with task ${taskId}`);
+
+            spawnContinueProcess(taskId, sessionId, message || "continue", model);
+
+            const metadata = taskManager.getTaskMetadata(taskId);
+            results.push({
+              taskId,
+              sessionId: metadata?.sessionId || sessionId,
+              status: "working",
+            });
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            Logger.error(`Failed to continue session ${sessionId}: ${message}`);
+          }
+        } else {
+          // Handle new task
+          const taskDef = validated.data;
+
+          if (!taskDef.task?.trim()) {
+            Logger.warn("Skipping task with empty task description");
+            continue;
+          }
+
+          const effectiveModel = taskDef.model || config.primaryModel;
+          const title = taskDef.sessionTitle || `OpenCode task: ${taskDef.task.slice(0, 50)}${taskDef.task.length > 50 ? "..." : ""}`;
+
+          const taskId = await taskManager.createTask({
+            title,
+            model: effectiveModel,
+            agent: taskDef.agent,
+          });
+
+          Logger.debug(`Created task ${taskId}: ${title}`);
+          spawnOpenCodeProcess(taskId, taskDef.task, effectiveModel, taskDef.agent, taskDef.outputGuidance);
+
+          const metadata = taskManager.getTaskMetadata(taskId);
+          results.push({
+            taskId,
+            sessionId: metadata?.sessionId || "",
+            status: "working",
+          });
+        }
+      }
+    }
+
+    const result = {
+      results,
+      count: results.length,
+    };
+
+    Logger.debug(`Launched ${results.length} tasks in parallel`);
+
+    return JSON.stringify(result, null, 2);
+  },
+};