opencode-swarm-plugin 0.37.0 → 0.39.1

package/src/swarm-orchestrate.ts

@@ -83,7 +83,8 @@ import {
   isReviewApproved,
   getReviewStatus,
 } from "./swarm-review";
-import { captureCoordinatorEvent } from "./eval-capture.js";
+import { captureCoordinatorEvent, type EvalRecord } from "./eval-capture.js";
+import { formatResearcherPrompt } from "./swarm-prompts";
 
 // ============================================================================
 // Helper Functions
@@ -1710,11 +1711,36 @@ Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
             },
       };
 
+      // Capture subtask completion outcome for eval data
+      try {
+        const { captureSubtaskOutcome } = await import("./eval-capture.js");
+        const durationMs = args.start_time ? Date.now() - args.start_time : 0;
+        
+        // Determine epic ID: use parent_id if available, otherwise fall back to extracting from bead_id
+        const evalEpicId = cell.parent_id || epicId;
+        
+        captureSubtaskOutcome({
+          epicId: evalEpicId,
+          projectPath: args.project_key,
+          beadId: args.bead_id,
+          title: cell.title,
+          plannedFiles: args.planned_files || [],
+          actualFiles: args.files_touched || [],
+          durationMs,
+          errorCount: args.error_count || 0,
+          retryCount: args.retry_count || 0,
+          success: true,
+        });
+      } catch (error) {
+        // Non-fatal - don't block completion if capture fails
+        console.warn("[swarm_complete] Failed to capture subtask outcome:", error);
+      }
+
       // Capture subtask completion outcome
       try {
         const durationMs = args.start_time ? Date.now() - args.start_time : 0;
         captureCoordinatorEvent({
-          session_id: process.env.OPENCODE_SESSION_ID || "unknown",
+          session_id: _ctx.sessionID || "unknown",
           epic_id: epicId,
           timestamp: new Date().toISOString(),
           event_type: "OUTCOME",
@@ -1823,7 +1849,7 @@ Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
       try {
         const durationMs = args.start_time ? Date.now() - args.start_time : 0;
         captureCoordinatorEvent({
-          session_id: process.env.OPENCODE_SESSION_ID || "unknown",
+          session_id: _ctx.sessionID || "unknown",
           epic_id: epicId,
           timestamp: new Date().toISOString(),
           event_type: "OUTCOME",
@@ -1946,6 +1972,14 @@ export const swarm_record_outcome = tool({
       .string()
       .optional()
       .describe("Detailed failure context (error message, stack trace, etc.)"),
+    project_path: tool.schema
+      .string()
+      .optional()
+      .describe("Project path (for finalizing eval records when all subtasks complete)"),
+    epic_id: tool.schema
+      .string()
+      .optional()
+      .describe("Epic ID (for finalizing eval records when all subtasks complete)"),
   },
   async execute(args) {
     // Build outcome signals
@@ -1980,6 +2014,21 @@ export const swarm_record_outcome = tool({
     // Get error patterns from accumulator
     const errorStats = await globalErrorAccumulator.getErrorStats(args.bead_id);
 
+    // Finalize eval record if project_path and epic_id provided
+    let finalizedRecord: EvalRecord | null = null;
+    if (args.project_path && args.epic_id) {
+      try {
+        const { finalizeEvalRecord } = await import("./eval-capture.js");
+        finalizedRecord = finalizeEvalRecord({
+          epicId: args.epic_id,
+          projectPath: args.project_path,
+        });
+      } catch (error) {
+        // Non-fatal - log and continue
+        console.warn("[swarm_record_outcome] Failed to finalize eval record:", error);
+      }
+    }
+
     // Generate feedback events for each criterion
     const criteriaToScore = args.criteria ?? [
       "type_safe",
@@ -2030,6 +2079,7 @@ export const swarm_record_outcome = tool({
           accumulated_errors: errorStats.total,
           unresolved_errors: errorStats.unresolved,
         },
+        finalized_eval_record: finalizedRecord || undefined,
         note: "Feedback events should be stored for criterion weight calculation. Use learning.ts functions to apply weights.",
       },
       null,
@@ -2087,12 +2137,28 @@ export function extractTechStack(task: string): string[] {
   return Array.from(detected);
 }
 
+/**
+ * Spawn instruction for a researcher worker
+ */
+export interface ResearchSpawnInstruction {
+  /** Unique ID for this research task */
+  research_id: string;
+  /** Technology being researched */
+  tech: string;
+  /** Full prompt for the researcher agent */
+  prompt: string;
+  /** Agent type for the Task tool */
+  subagent_type: "swarm/researcher";
+}
+
 /**
  * Research result from documentation discovery phase
  */
 export interface ResearchResult {
   /** Technologies identified and researched */
   tech_stack: string[];
+  /** Spawn instructions for researcher workers */
+  spawn_instructions: ResearchSpawnInstruction[];
   /** Summaries keyed by technology name */
   summaries: Record<string, string>;
   /** Semantic-memory IDs where research is stored */
@@ -2154,24 +2220,45 @@ export async function runResearchPhase(
   if (techStack.length === 0) {
     return {
       tech_stack: [],
+      spawn_instructions: [],
       summaries: {},
       memory_ids: [],
     };
   }
 
-  // Step 2: For each technology, spawn a researcher
-  // TODO: Implement researcher spawning using swarm_spawn_researcher
-  // and Task tool. This requires coordination logic that will be
-  // added in a future iteration.
-
-  // For now, return empty summaries (GREEN phase - make tests pass)
-  // The full implementation will spawn researchers in parallel and
-  // collect their findings.
+  // Step 2: Generate spawn instructions for each technology
+  // The coordinator will use these to spawn researcher workers via Task()
+  const spawnInstructions: ResearchSpawnInstruction[] = [];
+  
+  for (const tech of techStack) {
+    // Generate unique research ID
+    const researchId = `research-${tech}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    
+    // Generate researcher prompt
+    const prompt = formatResearcherPrompt({
+      research_id: researchId,
+      epic_id: "standalone-research", // No epic context for standalone research
+      tech_stack: [tech], // Single tech per researcher
+      project_path: projectPath,
+      check_upgrades: options?.checkUpgrades ?? false,
+    });
+    
+    spawnInstructions.push({
+      research_id: researchId,
+      tech,
+      prompt,
+      subagent_type: "swarm/researcher",
+    });
+  }
 
+  // Step 3: Return spawn instructions for coordinator
+  // The coordinator will spawn Task() agents using these instructions
+  // and collect results from swarm mail after completion
   return {
     tech_stack: techStack,
-    summaries: {},
-    memory_ids: [],
+    spawn_instructions: spawnInstructions,
+    summaries: {}, // Will be populated by coordinator after researchers complete
+    memory_ids: [], // Will be populated by coordinator after researchers store in semantic-memory
   };
 }
 

package/src/swarm-prompts.test.ts

@@ -9,8 +9,10 @@ import { describe, expect, test } from "bun:test";
 import {
   formatSubtaskPromptV2,
   formatResearcherPrompt,
+  formatCoordinatorPrompt,
   SUBTASK_PROMPT_V2,
   RESEARCHER_PROMPT,
+  COORDINATOR_PROMPT,
 } from "./swarm-prompts";
 
 describe("SUBTASK_PROMPT_V2", () => {
@@ -818,3 +820,122 @@ describe("swarm_spawn_retry tool", () => {
     expect(parsed.prompt).toMatch(/preserve.*working|fix.*while preserving/i);
   });
 });
+
+describe("COORDINATOR_PROMPT", () => {
+  test("constant exists and is exported", () => {
+    expect(COORDINATOR_PROMPT).toBeDefined();
+    expect(typeof COORDINATOR_PROMPT).toBe("string");
+    expect(COORDINATOR_PROMPT.length).toBeGreaterThan(100);
+  });
+
+  test("contains all phase headers (0-8)", () => {
+    expect(COORDINATOR_PROMPT).toContain("Phase 0:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 1:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 2:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 3:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 4:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 5:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 6:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 7:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 8:");
+  });
+
+  test("contains Phase 1.5: Research Phase section", () => {
+    expect(COORDINATOR_PROMPT).toContain("Phase 1.5:");
+    expect(COORDINATOR_PROMPT).toMatch(/Phase 1\.5:.*Research/i);
+  });
+
+  test("Phase 1.5 documents swarm_spawn_researcher usage", () => {
+    // Extract Phase 1.5 section
+    const phase15Match = COORDINATOR_PROMPT.match(/Phase 1\.5:[\s\S]*?Phase 2:/);
+    expect(phase15Match).not.toBeNull();
+    if (!phase15Match) return;
+    const phase15Content = phase15Match[0];
+
+    expect(phase15Content).toContain("swarm_spawn_researcher");
+    expect(phase15Content).toContain("Task(subagent_type=\"swarm/researcher\"");
+  });
+
+  test("has section explicitly forbidding direct research tool calls", () => {
+    expect(COORDINATOR_PROMPT).toMatch(/NEVER.*direct|forbidden.*tools|do not call directly/i);
+  });
+
+  test("forbidden tools section lists all prohibited tools", () => {
+    const forbiddenTools = [
+      "repo-crawl_",
+      "repo-autopsy_",
+      "webfetch",
+      "fetch_fetch",
+      "context7_",
+      "pdf-brain_search",
+      "pdf-brain_read"
+    ];
+
+    for (const tool of forbiddenTools) {
+      expect(COORDINATOR_PROMPT).toContain(tool);
+    }
+  });
+
+  test("forbidden tools section explains to use swarm_spawn_researcher instead", () => {
+    // Find the forbidden tools section
+    const forbiddenMatch = COORDINATOR_PROMPT.match(/(FORBIDDEN.*for coordinators|NEVER.*FETCH.*DIRECTLY)[\s\S]{0,500}swarm_spawn_researcher/i);
+    expect(forbiddenMatch).not.toBeNull();
+  });
+
+  test("contains coordinator role boundaries section", () => {
+    expect(COORDINATOR_PROMPT).toContain("Coordinator Role Boundaries");
+    expect(COORDINATOR_PROMPT).toMatch(/COORDINATORS NEVER.*EXECUTE.*WORK/i);
+  });
+
+  test("contains MANDATORY review loop section", () => {
+    expect(COORDINATOR_PROMPT).toContain("MANDATORY Review Loop");
+    expect(COORDINATOR_PROMPT).toContain("swarm_review");
+    expect(COORDINATOR_PROMPT).toContain("swarm_review_feedback");
+  });
+
+  test("Phase 1.5 positioned between Phase 1 (Initialize) and Phase 2 (Knowledge)", () => {
+    const phase1Pos = COORDINATOR_PROMPT.indexOf("Phase 1:");
+    const phase15Pos = COORDINATOR_PROMPT.indexOf("Phase 1.5:");
+    const phase2Pos = COORDINATOR_PROMPT.indexOf("Phase 2:");
+
+    expect(phase15Pos).toBeGreaterThan(phase1Pos);
+    expect(phase15Pos).toBeLessThan(phase2Pos);
+  });
+});
+
+describe("formatCoordinatorPrompt", () => {
+  test("function exists and returns string", () => {
+    expect(formatCoordinatorPrompt).toBeDefined();
+    const result = formatCoordinatorPrompt({ task: "test task", projectPath: "/test" });
+    expect(typeof result).toBe("string");
+  });
+
+  test("substitutes {task} placeholder", () => {
+    const result = formatCoordinatorPrompt({ 
+      task: "Implement auth", 
+      projectPath: "/test" 
+    });
+    expect(result).toContain("Implement auth");
+  });
+
+  test("substitutes {project_path} placeholder", () => {
+    const result = formatCoordinatorPrompt({ 
+      task: "test", 
+      projectPath: "/Users/joel/my-project" 
+    });
+    expect(result).toContain("/Users/joel/my-project");
+  });
+
+  test("returns complete prompt with all phases", () => {
+    const result = formatCoordinatorPrompt({ 
+      task: "test", 
+      projectPath: "/test" 
+    });
+    
+    // Should contain all phase headers
+    for (let i = 0; i <= 8; i++) {
+      expect(result).toContain(`Phase ${i}:`);
+    }
+    expect(result).toContain("Phase 1.5:");
+  });
+});

package/src/swarm-prompts.ts

@@ -576,8 +576,289 @@ Other cell operations:
 Begin now.`;
 
 /**
- * Researcher prompt template for documentation discovery
- *
+ * Coordinator Agent Prompt Template
+ * 
+ * Used by the /swarm command to instruct coordinators on their role.
+ * Coordinators NEVER execute work directly - they clarify, decompose, spawn workers, and review.
+ * 
+ * Key sections:
+ * - Role boundaries (what coordinators NEVER do)
+ * - Phase 1.5: Research Phase (spawn researchers, DON'T fetch docs directly)
+ * - Forbidden tools (repo-crawl, webfetch, context7, pdf-brain_search)
+ * - MANDATORY review loop after each worker completes
+ * 
+ * Placeholders:
+ * - {task} - The task description from user
+ * - {project_path} - Absolute path to project root
+ */
+export const COORDINATOR_PROMPT = `You are a swarm coordinator. Your job is to clarify the task, decompose it into cells, and spawn parallel agents.
+
+## Task
+
+{task}
+
+## CRITICAL: Coordinator Role Boundaries
+
+**⚠️ COORDINATORS NEVER EXECUTE WORK DIRECTLY**
+
+Your role is **ONLY** to:
+1. **Clarify** - Ask questions to understand scope
+2. **Decompose** - Break into subtasks with clear boundaries  
+3. **Spawn** - Create worker agents for ALL subtasks
+4. **Monitor** - Check progress, unblock, mediate conflicts
+5. **Verify** - Confirm completion, run final checks
+
+**YOU DO NOT:**
+- Read implementation files (only metadata/structure for planning)
+- Edit code directly
+- Run tests yourself (workers run tests)
+- Implement features
+- Fix bugs inline
+- Make "quick fixes" yourself
+
+**ALWAYS spawn workers, even for sequential tasks.** Sequential just means spawn them in order and wait for each to complete before spawning the next.
+
+### Why This Matters
+
+| Coordinator Work | Worker Work | Consequence of Mixing |
+|-----------------|-------------|----------------------|
+| Sonnet context ($$$) | Disposable context | Expensive context waste |
+| Long-lived state | Task-scoped state | Context exhaustion |
+| Orchestration concerns | Implementation concerns | Mixed concerns |
+| No checkpoints | Checkpoints enabled | No recovery |
+| No learning signals | Outcomes tracked | No improvement |
+
+## CRITICAL: NEVER Fetch Documentation Directly
+
+**⚠️ COORDINATORS DO NOT CALL RESEARCH TOOLS DIRECTLY**
+
+The following tools are **FORBIDDEN** for coordinators to call:
+
+- \`repo-crawl_file\`, \`repo-crawl_readme\`, \`repo-crawl_search\`, \`repo-crawl_structure\`, \`repo-crawl_tree\`
+- \`repo-autopsy_*\` (all variants)
+- \`webfetch\`, \`fetch_fetch\`
+- \`context7_resolve-library-id\`, \`context7_get-library-docs\`
+- \`pdf-brain_search\`, \`pdf-brain_read\`
+
+**WHY?** These tools dump massive context that exhausts your expensive Sonnet context. Your job is orchestration, not research.
+
+**INSTEAD:** Use \`swarm_spawn_researcher\` (see Phase 1.5 below) to spawn a researcher worker who:
+- Fetches documentation in disposable context
+- Stores full details in semantic-memory
+- Returns a condensed summary for shared_context
+
+## Workflow
+
+### Phase 0: Socratic Planning (INTERACTIVE - unless --fast)
+
+**Before decomposing, clarify the task with the user.**
+
+Check for flags in the task:
+- \`--fast\` → Skip questions, use reasonable defaults
+- \`--auto\` → Zero interaction, heuristic decisions
+- \`--confirm-only\` → Show plan, get yes/no only
+
+**Default (no flags): Full Socratic Mode**
+
+1. **Analyze task for ambiguity:**
+   - Scope unclear? (what's included/excluded)
+   - Strategy unclear? (file-based vs feature-based)
+   - Dependencies unclear? (what needs to exist first)
+   - Success criteria unclear? (how do we know it's done)
+
+2. **If clarification needed, ask ONE question at a time:**
+   \`\`\`
+   The task "<task>" needs clarification before I can decompose it.
+
+   **Question:** <specific question>
+
+   Options:
+   a) <option 1> - <tradeoff>
+   b) <option 2> - <tradeoff>
+   c) <option 3> - <tradeoff>
+
+   I'd recommend (b) because <reason>. Which approach?
+   \`\`\`
+
+3. **Wait for user response before proceeding**
+
+4. **Iterate if needed** (max 2-3 questions)
+
+**Rules:**
+- ONE question at a time - don't overwhelm
+- Offer concrete options - not open-ended
+- Lead with recommendation - save cognitive load
+- Wait for answer - don't assume
+
+### Phase 1: Initialize
+\`swarmmail_init(project_path="{project_path}", task_description="Swarm: {task}")\`
+
+### Phase 1.5: Research Phase (FOR COMPLEX TASKS)
+
+**⚠️ If the task requires understanding unfamiliar technologies, APIs, or libraries, spawn a researcher FIRST.**
+
+**DO NOT call documentation tools directly.** Instead:
+
+\`\`\`
+// 1. Spawn researcher with explicit tech stack
+swarm_spawn_researcher(
+  research_id="research-nextjs-cache-components",
+  epic_id="<epic-id>",
+  tech_stack=["Next.js 16 Cache Components", "React Server Components"],
+  project_path="{project_path}"
+)
+
+// 2. Spawn researcher as Task subagent
+const researchFindings = await Task(subagent_type="swarm/researcher", prompt="<from above>")
+
+// 3. Researcher returns condensed summary
+// Use this summary in shared_context for workers
+\`\`\`
+
+**When to spawn a researcher:**
+- Task involves unfamiliar framework versions (e.g., Next.js 16 vs 14)
+- Need to compare installed vs latest library APIs
+- Working with experimental/preview features
+- Need architectural guidance from documentation
+
+**When NOT to spawn a researcher:**
+- Using well-known stable APIs (React hooks, Express middleware)
+- Task is purely refactoring existing code
+- You already have relevant findings from semantic-memory or CASS
+
+**Researcher output:**
+- Full findings stored in semantic-memory (searchable by future agents)
+- Condensed 3-5 bullet summary returned for shared_context
+
+### Phase 2: Knowledge Gathering (MANDATORY)
+
+**Before decomposing, query ALL knowledge sources:**
+
+\`\`\`
+semantic-memory_find(query="<task keywords>", limit=5)   # Past learnings
+cass_search(query="<task description>", limit=5)         # Similar past tasks  
+skills_list()                                            # Available skills
+\`\`\`
+
+Synthesize findings into shared_context for workers.
+
+### Phase 3: Decompose
+\`\`\`
+swarm_select_strategy(task="<task>")
+swarm_plan_prompt(task="<task>", context="<synthesized knowledge>")
+swarm_validate_decomposition(response="<CellTree JSON>")
+\`\`\`
+
+### Phase 4: Create Cells
+\`hive_create_epic(epic_title="<task>", subtasks=[...])\`
+
+### Phase 5: DO NOT Reserve Files
+
+> **⚠️ Coordinator NEVER reserves files.** Workers reserve their own files.
+> If coordinator reserves, workers get blocked and swarm stalls.
+
+### Phase 6: Spawn Workers for ALL Subtasks (MANDATORY)
+
+> **⚠️ ALWAYS spawn workers, even for sequential tasks.**
+> - Parallel tasks: Spawn ALL in a single message
+> - Sequential tasks: Spawn one, wait for completion, spawn next
+
+**For parallel work:**
+\`\`\`
+// Single message with multiple Task calls
+swarm_spawn_subtask(bead_id_1, epic_id, title_1, files_1, shared_context, project_path="{project_path}")
+Task(subagent_type="swarm/worker", prompt="<from above>")
+swarm_spawn_subtask(bead_id_2, epic_id, title_2, files_2, shared_context, project_path="{project_path}")
+Task(subagent_type="swarm/worker", prompt="<from above>")
+\`\`\`
+
+**For sequential work:**
+\`\`\`
+// Spawn worker 1, wait for completion
+swarm_spawn_subtask(bead_id_1, ...)
+const result1 = await Task(subagent_type="swarm/worker", prompt="<from above>")
+
+// THEN spawn worker 2 with context from worker 1
+swarm_spawn_subtask(bead_id_2, ..., shared_context="Worker 1 completed: " + result1)
+const result2 = await Task(subagent_type="swarm/worker", prompt="<from above>")
+\`\`\`
+
+**NEVER do the work yourself.** Even if it seems faster, spawn a worker.
+
+**IMPORTANT:** Pass \`project_path\` to \`swarm_spawn_subtask\` so workers can call \`swarmmail_init\`.
+
+### Phase 7: MANDATORY Review Loop (NON-NEGOTIABLE)
+
+**⚠️ AFTER EVERY Task() RETURNS, YOU MUST:**
+
+1. **CHECK INBOX** - Worker may have sent messages
+   \`swarmmail_inbox()\`
+   \`swarmmail_read_message(message_id=N)\`
+
+2. **REVIEW WORK** - Generate review with diff
+   \`swarm_review(project_key, epic_id, task_id, files_touched)\`
+
+3. **EVALUATE** - Does it meet epic goals?
+   - Fulfills subtask requirements?
+   - Serves overall epic goal?
+   - Enables downstream tasks?
+   - Type safety, no obvious bugs?
+
+4. **SEND FEEDBACK** - Approve or request changes
+   \`swarm_review_feedback(project_key, task_id, worker_id, status, issues)\`
+   
+   **If approved:**
+   - Close cell, spawn next worker
+   
+   **If needs_changes:**
+   - \`swarm_review_feedback\` returns \`retry_context\` (NOT sends message - worker is dead)
+   - Generate retry prompt: \`swarm_spawn_retry(retry_context)\`
+   - Spawn NEW worker with Task() using retry prompt
+   - Max 3 attempts before marking task blocked
+   
+   **If 3 failures:**
+   - Mark task blocked, escalate to human
+
+5. **ONLY THEN** - Spawn next worker or complete
+
+**DO NOT skip this. DO NOT batch reviews. Review EACH worker IMMEDIATELY after return.**
+
+**Intervene if:**
+- Worker blocked >5min → unblock or reassign
+- File conflicts → mediate between workers
+- Scope creep → approve or reject expansion
+- Review fails 3x → mark task blocked, escalate to human
+
+### Phase 8: Complete
+\`\`\`
+# After all workers complete and reviews pass:
+hive_sync()                                    # Sync all cells to git
+# Coordinator does NOT call swarm_complete - workers do that
+\`\`\`
+
+## Strategy Reference
+
+| Strategy       | Best For                 | Keywords                               |
+| -------------- | ------------------------ | -------------------------------------- |
+| file-based     | Refactoring, migrations  | refactor, migrate, rename, update all  |
+| feature-based  | New features             | add, implement, build, create, feature |
+| risk-based     | Bug fixes, security      | fix, bug, security, critical, urgent   |
+| research-based | Investigation, discovery | research, investigate, explore, learn  |
+
+## Flag Reference
+
+| Flag | Effect |
+|------|--------|
+| \`--fast\` | Skip Socratic questions, use defaults |
+| \`--auto\` | Zero interaction, heuristic decisions |
+| \`--confirm-only\` | Show plan, get yes/no only |
+
+Begin with Phase 0 (Socratic Planning) unless \`--fast\` or \`--auto\` flag is present.
+`;
+
+/**
+ * Researcher Agent Prompt Template
+ * 
  * Spawned BEFORE decomposition to gather technology documentation.
  * Researchers receive an EXPLICIT list of technologies to research from the coordinator.
  * They dynamically discover WHAT TOOLS are available to fetch docs.
@@ -844,6 +1125,18 @@ export function formatResearcherPrompt(params: {
     .replace("{check_upgrades}", upgradesMode);
 }
 
+/**
+ * Format the coordinator prompt with task and project path substitution
+ */
+export function formatCoordinatorPrompt(params: {
+  task: string;
+  projectPath: string;
+}): string {
+  return COORDINATOR_PROMPT
+    .replace(/{task}/g, params.task)
+    .replace(/{project_path}/g, params.projectPath);
+}
+
 /**
  * Format the V2 subtask prompt for a specific agent
  */
@@ -1065,7 +1358,7 @@ export const swarm_spawn_subtask = tool({
       .optional()
       .describe("Optional explicit model override (auto-selected if not provided)"),
   },
-  async execute(args) {
+  async execute(args, _ctx) {
     const prompt = formatSubtaskPromptV2({
       bead_id: args.bead_id,
       epic_id: args.epic_id,
@@ -1111,7 +1404,7 @@ export const swarm_spawn_subtask = tool({
     // Capture worker spawn decision
     try {
       captureCoordinatorEvent({
-        session_id: process.env.OPENCODE_SESSION_ID || "unknown",
+        session_id: _ctx.sessionID || "unknown",
         epic_id: args.epic_id,
         timestamp: new Date().toISOString(),
         event_type: "DECISION",