opencode-swarm-plugin 0.32.0 → 0.33.0

package/src/swarm-prompts.test.ts

@@ -8,7 +8,9 @@
 import { describe, expect, test } from "bun:test";
 import {
   formatSubtaskPromptV2,
+  formatResearcherPrompt,
   SUBTASK_PROMPT_V2,
+  RESEARCHER_PROMPT,
 } from "./swarm-prompts";
 
 describe("SUBTASK_PROMPT_V2", () => {
@@ -266,3 +268,390 @@ describe("swarm_spawn_subtask tool", () => {
     expect(instructions).toContain("DO THIS IMMEDIATELY");
   });
 });
+
+describe("RESEARCHER_PROMPT", () => {
+  describe("required sections", () => {
+    test("includes IDENTITY section with research_id and epic_id", () => {
+      expect(RESEARCHER_PROMPT).toContain("## [IDENTITY]");
+      expect(RESEARCHER_PROMPT).toContain("{research_id}");
+      expect(RESEARCHER_PROMPT).toContain("{epic_id}");
+    });
+
+    test("includes MISSION section explaining the role", () => {
+      expect(RESEARCHER_PROMPT).toContain("## [MISSION]");
+      expect(RESEARCHER_PROMPT).toMatch(/gather.*documentation/i);
+    });
+
+    test("includes WORKFLOW section with numbered steps", () => {
+      expect(RESEARCHER_PROMPT).toContain("## [WORKFLOW]");
+      expect(RESEARCHER_PROMPT).toContain("### Step 1:");
+      expect(RESEARCHER_PROMPT).toContain("### Step 2:");
+    });
+
+    test("includes CRITICAL REQUIREMENTS section", () => {
+      expect(RESEARCHER_PROMPT).toContain("## [CRITICAL REQUIREMENTS]");
+      expect(RESEARCHER_PROMPT).toMatch(/NON-NEGOTIABLE/i);
+    });
+  });
+
+  describe("workflow steps", () => {
+    test("Step 1 is swarmmail_init (MANDATORY FIRST)", () => {
+      expect(RESEARCHER_PROMPT).toMatch(/### Step 1:.*Initialize/i);
+      expect(RESEARCHER_PROMPT).toContain("swarmmail_init");
+      expect(RESEARCHER_PROMPT).toContain("project_path");
+    });
+
+    test("Step 2 is discovering available documentation tools", () => {
+      const step2Match = RESEARCHER_PROMPT.match(/### Step 2:[\s\S]*?### Step 3:/);
+      expect(step2Match).not.toBeNull();
+      if (!step2Match) return;
+      
+      const step2Content = step2Match[0];
+      expect(step2Content).toMatch(/discover.*tools/i);
+      expect(step2Content).toContain("nextjs_docs");
+      expect(step2Content).toContain("context7");
+      expect(step2Content).toContain("fetch");
+      expect(step2Content).toContain("pdf-brain");
+    });
+
+    test("Step 3 is reading installed versions", () => {
+      const step3Match = RESEARCHER_PROMPT.match(/### Step 3:[\s\S]*?### Step 4:/);
+      expect(step3Match).not.toBeNull();
+      if (!step3Match) return;
+      
+      const step3Content = step3Match[0];
+      expect(step3Content).toMatch(/read.*installed.*version/i);
+      expect(step3Content).toContain("package.json");
+    });
+
+    test("Step 4 is fetching documentation", () => {
+      const step4Match = RESEARCHER_PROMPT.match(/### Step 4:[\s\S]*?### Step 5:/);
+      expect(step4Match).not.toBeNull();
+      if (!step4Match) return;
+      
+      const step4Content = step4Match[0];
+      expect(step4Content).toMatch(/fetch.*documentation/i);
+      expect(step4Content).toContain("INSTALLED version");
+    });
+
+    test("Step 5 is storing detailed findings in semantic-memory", () => {
+      const step5Match = RESEARCHER_PROMPT.match(/### Step 5:[\s\S]*?### Step 6:/);
+      expect(step5Match).not.toBeNull();
+      if (!step5Match) return;
+      
+      const step5Content = step5Match[0];
+      expect(step5Content).toContain("semantic-memory_store");
+      expect(step5Content).toMatch(/store.*individually/i);
+    });
+
+    test("Step 6 is broadcasting summary to coordinator", () => {
+      const step6Match = RESEARCHER_PROMPT.match(/### Step 6:[\s\S]*?### Step 7:/);
+      expect(step6Match).not.toBeNull();
+      if (!step6Match) return;
+      
+      const step6Content = step6Match[0];
+      expect(step6Content).toContain("swarmmail_send");
+      expect(step6Content).toContain("coordinator");
+    });
+
+    test("Step 7 is returning structured JSON output", () => {
+      const step7Match = RESEARCHER_PROMPT.match(/### Step 7:[\s\S]*?(?=## \[|$)/);
+      expect(step7Match).not.toBeNull();
+      if (!step7Match) return;
+      
+      const step7Content = step7Match[0];
+      expect(step7Content).toContain("JSON");
+      expect(step7Content).toContain("technologies");
+      expect(step7Content).toContain("summary");
+    });
+  });
+
+  describe("coordinator-provided tech stack", () => {
+    test("emphasizes that coordinator provides the tech list", () => {
+      expect(RESEARCHER_PROMPT).toMatch(/COORDINATOR PROVIDED.*TECHNOLOGIES/i);
+      expect(RESEARCHER_PROMPT).toContain("{tech_stack}");
+    });
+
+    test("clarifies researcher does NOT discover what to research", () => {
+      expect(RESEARCHER_PROMPT).toMatch(/NOT discover what to research/i);
+      expect(RESEARCHER_PROMPT).toMatch(/DO discover.*TOOLS/i);
+    });
+  });
+
+  describe("upgrade comparison mode", () => {
+    test("includes placeholder for check_upgrades mode", () => {
+      expect(RESEARCHER_PROMPT).toContain("{check_upgrades}");
+    });
+
+    test("mentions comparing installed vs latest when in upgrade mode", () => {
+      expect(RESEARCHER_PROMPT).toMatch(/check-upgrades/i);
+      expect(RESEARCHER_PROMPT).toMatch(/compare|latest.*version/i);
+    });
+  });
+
+  describe("output requirements", () => {
+    test("specifies TWO output destinations: semantic-memory and return JSON", () => {
+      expect(RESEARCHER_PROMPT).toMatch(/TWO places/i);
+      expect(RESEARCHER_PROMPT).toContain("semantic-memory");
+      expect(RESEARCHER_PROMPT).toContain("Return JSON");
+    });
+
+    test("explains semantic-memory is for detailed findings", () => {
+      expect(RESEARCHER_PROMPT).toMatch(/semantic-memory.*detailed/i);
+    });
+
+    test("explains return JSON is for condensed summary", () => {
+      expect(RESEARCHER_PROMPT).toMatch(/return.*condensed.*summary/i);
+    });
+  });
+});
+
+describe("formatResearcherPrompt", () => {
+  test("substitutes research_id placeholder", () => {
+    const result = formatResearcherPrompt({
+      research_id: "research-abc123",
+      epic_id: "epic-xyz789",
+      tech_stack: ["Next.js", "React"],
+      project_path: "/path/to/project",
+      check_upgrades: false,
+    });
+
+    expect(result).toContain("research-abc123");
+    expect(result).not.toContain("{research_id}");
+  });
+
+  test("substitutes epic_id placeholder", () => {
+    const result = formatResearcherPrompt({
+      research_id: "research-abc123",
+      epic_id: "epic-xyz789",
+      tech_stack: ["Next.js"],
+      project_path: "/path/to/project",
+      check_upgrades: false,
+    });
+
+    expect(result).toContain("epic-xyz789");
+    expect(result).not.toContain("{epic_id}");
+  });
+
+  test("formats tech_stack as bulleted list", () => {
+    const result = formatResearcherPrompt({
+      research_id: "research-abc123",
+      epic_id: "epic-xyz789",
+      tech_stack: ["Next.js", "React", "TypeScript"],
+      project_path: "/path/to/project",
+      check_upgrades: false,
+    });
+
+    expect(result).toContain("- Next.js");
+    expect(result).toContain("- React");
+    expect(result).toContain("- TypeScript");
+  });
+
+  test("substitutes project_path placeholder", () => {
+    const result = formatResearcherPrompt({
+      research_id: "research-abc123",
+      epic_id: "epic-xyz789",
+      tech_stack: ["Next.js"],
+      project_path: "/Users/joel/Code/my-project",
+      check_upgrades: false,
+    });
+
+    expect(result).toContain("/Users/joel/Code/my-project");
+    expect(result).not.toContain("{project_path}");
+  });
+
+  test("includes DEFAULT MODE text when check_upgrades=false", () => {
+    const result = formatResearcherPrompt({
+      research_id: "research-abc123",
+      epic_id: "epic-xyz789",
+      tech_stack: ["Next.js"],
+      project_path: "/path/to/project",
+      check_upgrades: false,
+    });
+
+    expect(result).toContain("DEFAULT MODE");
+    expect(result).toContain("INSTALLED versions only");
+  });
+
+  test("includes UPGRADE COMPARISON MODE text when check_upgrades=true", () => {
+    const result = formatResearcherPrompt({
+      research_id: "research-abc123",
+      epic_id: "epic-xyz789",
+      tech_stack: ["Next.js"],
+      project_path: "/path/to/project",
+      check_upgrades: true,
+    });
+
+    expect(result).toContain("UPGRADE COMPARISON MODE");
+    expect(result).toContain("BOTH installed AND latest");
+    expect(result).toContain("breaking changes");
+  });
+});
+
+describe("on-demand research section", () => {
+  test("includes ON-DEMAND RESEARCH section after Step 9", () => {
+    // Find Step 9 and the section after it
+    const step9Pos = SUBTASK_PROMPT_V2.indexOf("### Step 9:");
+    const swarmMailPos = SUBTASK_PROMPT_V2.indexOf("## [SWARM MAIL COMMUNICATION]");
+    
+    expect(step9Pos).toBeGreaterThan(0);
+    expect(swarmMailPos).toBeGreaterThan(step9Pos);
+    
+    // Extract the section between Step 9 and SWARM MAIL
+    const betweenSection = SUBTASK_PROMPT_V2.substring(step9Pos, swarmMailPos);
+    
+    expect(betweenSection).toContain("## [ON-DEMAND RESEARCH]");
+  });
+
+  test("research section instructs to check semantic-memory first", () => {
+    const researchMatch = SUBTASK_PROMPT_V2.match(/## \[ON-DEMAND RESEARCH\][\s\S]*?## \[SWARM MAIL/);
+    expect(researchMatch).not.toBeNull();
+    if (!researchMatch) return;
+    
+    const researchContent = researchMatch[0];
+    expect(researchContent).toContain("semantic-memory_find");
+    expect(researchContent).toMatch(/check.*semantic-memory.*first/i);
+  });
+
+  test("research section includes swarm_spawn_researcher tool usage", () => {
+    const researchMatch = SUBTASK_PROMPT_V2.match(/## \[ON-DEMAND RESEARCH\][\s\S]*?## \[SWARM MAIL/);
+    expect(researchMatch).not.toBeNull();
+    if (!researchMatch) return;
+    
+    const researchContent = researchMatch[0];
+    expect(researchContent).toContain("swarm_spawn_researcher");
+  });
+
+  test("research section lists specific research triggers", () => {
+    const researchMatch = SUBTASK_PROMPT_V2.match(/## \[ON-DEMAND RESEARCH\][\s\S]*?## \[SWARM MAIL/);
+    expect(researchMatch).not.toBeNull();
+    if (!researchMatch) return;
+    
+    const researchContent = researchMatch[0];
+    
+    // Should list when TO research
+    expect(researchContent).toMatch(/triggers|when to research/i);
+    expect(researchContent).toMatch(/API.*works|breaking changes|outdated/i);
+  });
+
+  test("research section lists when NOT to research", () => {
+    const researchMatch = SUBTASK_PROMPT_V2.match(/## \[ON-DEMAND RESEARCH\][\s\S]*?## \[SWARM MAIL/);
+    expect(researchMatch).not.toBeNull();
+    if (!researchMatch) return;
+    
+    const researchContent = researchMatch[0];
+    
+    // Should list when to SKIP research
+    expect(researchContent).toMatch(/don't research|skip research/i);
+    expect(researchContent).toMatch(/standard patterns|well-documented|obvious/i);
+  });
+
+  test("research section includes 3-step workflow", () => {
+    const researchMatch = SUBTASK_PROMPT_V2.match(/## \[ON-DEMAND RESEARCH\][\s\S]*?## \[SWARM MAIL/);
+    expect(researchMatch).not.toBeNull();
+    if (!researchMatch) return;
+    
+    const researchContent = researchMatch[0];
+    
+    // Should have numbered steps
+    expect(researchContent).toMatch(/1\.\s*.*Check semantic-memory/i);
+    expect(researchContent).toMatch(/2\.\s*.*spawn researcher/i);
+    expect(researchContent).toMatch(/3\.\s*.*wait.*continue/i);
+  });
+});
+
+describe("swarm_spawn_researcher tool", () => {
+  test("returns JSON with prompt field", async () => {
+    const { swarm_spawn_researcher } = await import("./swarm-prompts");
+    
+    const result = await swarm_spawn_researcher.execute({
+      research_id: "research-abc123",
+      epic_id: "epic-xyz789",
+      tech_stack: ["Next.js", "React"],
+      project_path: "/Users/joel/Code/project",
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed).toHaveProperty("prompt");
+    expect(typeof parsed.prompt).toBe("string");
+    expect(parsed.prompt.length).toBeGreaterThan(100);
+  });
+
+  test("returns subagent_type field as 'swarm/researcher'", async () => {
+    const { swarm_spawn_researcher } = await import("./swarm-prompts");
+    
+    const result = await swarm_spawn_researcher.execute({
+      research_id: "research-abc123",
+      epic_id: "epic-xyz789",
+      tech_stack: ["Next.js"],
+      project_path: "/Users/joel/Code/project",
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed.subagent_type).toBe("swarm/researcher");
+  });
+
+  test("returns expected_output schema", async () => {
+    const { swarm_spawn_researcher } = await import("./swarm-prompts");
+    
+    const result = await swarm_spawn_researcher.execute({
+      research_id: "research-abc123",
+      epic_id: "epic-xyz789",
+      tech_stack: ["Next.js"],
+      project_path: "/Users/joel/Code/project",
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed).toHaveProperty("expected_output");
+    expect(parsed.expected_output).toHaveProperty("technologies");
+    expect(parsed.expected_output).toHaveProperty("summary");
+  });
+
+  test("defaults check_upgrades to false when not provided", async () => {
+    const { swarm_spawn_researcher } = await import("./swarm-prompts");
+    
+    const result = await swarm_spawn_researcher.execute({
+      research_id: "research-abc123",
+      epic_id: "epic-xyz789",
+      tech_stack: ["Next.js"],
+      project_path: "/Users/joel/Code/project",
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed.check_upgrades).toBe(false);
+  });
+
+  test("respects check_upgrades when provided as true", async () => {
+    const { swarm_spawn_researcher } = await import("./swarm-prompts");
+    
+    const result = await swarm_spawn_researcher.execute({
+      research_id: "research-abc123",
+      epic_id: "epic-xyz789",
+      tech_stack: ["Next.js"],
+      project_path: "/Users/joel/Code/project",
+      check_upgrades: true,
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed.check_upgrades).toBe(true);
+  });
+
+  test("includes all input parameters in returned JSON", async () => {
+    const { swarm_spawn_researcher } = await import("./swarm-prompts");
+    
+    const result = await swarm_spawn_researcher.execute({
+      research_id: "research-abc123",
+      epic_id: "epic-xyz789",
+      tech_stack: ["Next.js", "React", "TypeScript"],
+      project_path: "/Users/joel/Code/project",
+      check_upgrades: true,
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed.research_id).toBe("research-abc123");
+    expect(parsed.epic_id).toBe("epic-xyz789");
+    expect(parsed.tech_stack).toEqual(["Next.js", "React", "TypeScript"]);
+    expect(parsed.project_path).toBe("/Users/joel/Code/project");
+    expect(parsed.check_upgrades).toBe(true);
+  });
+});

package/src/swarm-prompts.ts

@@ -464,6 +464,29 @@ swarm_complete(
 
 **DO NOT manually close the cell with hive_close.** Use swarm_complete.
 
+## [ON-DEMAND RESEARCH]
+
+If you encounter unknown API behavior or version-specific issues:
+
+1. **Check semantic-memory first:**
+   \`semantic-memory_find(query="<library> <version> <topic>", limit=3, expand=true)\`
+
+2. **If not found, spawn researcher:**
+   \`swarm_spawn_researcher(research_id="{bead_id}-research", epic_id="{epic_id}", tech_stack=["<library>"], project_path="{project_path}")\`
+   Then spawn with Task tool: \`Task(subagent_type="swarm/researcher", prompt="<from above>")\`
+
+3. **Wait for research, then continue**
+
+**Research triggers:**
+- "I'm not sure how this API works in version X"
+- "This might have breaking changes"
+- "The docs I remember might be outdated"
+
+**Don't research:**
+- Standard patterns you're confident about
+- Well-documented, stable APIs
+- Obvious implementations
+
 ## [SWARM MAIL COMMUNICATION]
 
 ### Check Inbox Regularly
@@ -551,6 +574,124 @@ Other cell operations:
 
 Begin now.`;
 
+/**
+ * Researcher prompt template for documentation discovery
+ *
+ * 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.
+ * Output: condensed summary for shared_context + detailed findings in semantic-memory.
+ */
+export const RESEARCHER_PROMPT = `You are a swarm researcher gathering documentation for: **{research_id}**
+
+## [IDENTITY]
+Agent: (assigned at spawn)
+Research Task: {research_id}
+Epic: {epic_id}
+
+## [MISSION]
+Gather comprehensive documentation for the specified technologies to inform task decomposition.
+
+**COORDINATOR PROVIDED THESE TECHNOLOGIES TO RESEARCH:**
+{tech_stack}
+
+You do NOT discover what to research - the coordinator already decided that.
+You DO discover what TOOLS are available to fetch documentation.
+
+## [OUTPUT MODE]
+{check_upgrades}
+
+## [WORKFLOW]
+
+### Step 1: Initialize (MANDATORY FIRST)
+\`\`\`
+swarmmail_init(project_path="{project_path}", task_description="{research_id}: Documentation research")
+\`\`\`
+
+### Step 2: Discover Available Documentation Tools
+Check what's available for fetching docs:
+- **next-devtools**: \`nextjs_docs\` for Next.js documentation
+- **context7**: Library documentation lookup (\`use context7\` in prompts)
+- **fetch**: General web fetching for official docs sites
+- **pdf-brain**: Internal knowledge base search
+
+**Don't assume** - check which tools exist in your environment.
+
+### Step 3: Read Installed Versions
+For each technology in the tech stack:
+1. Check package.json (or equivalent) for installed version
+2. Record exact version numbers
+3. Note any version constraints (^, ~, etc.)
+
+### Step 4: Fetch Documentation
+For EACH technology in the list:
+- Use the most appropriate tool (Next.js → nextjs_docs, libraries → context7, others → fetch)
+- Fetch documentation for the INSTALLED version (not latest, unless --check-upgrades)
+- Focus on: API changes, breaking changes, migration guides, best practices
+- Extract key patterns, gotchas, and compatibility notes
+
+**If --check-upgrades mode:**
+- ALSO fetch docs for the LATEST version
+- Compare installed vs latest
+- Note breaking changes, new features, migration complexity
+
+### Step 5: Store Detailed Findings
+For EACH technology, store in semantic-memory:
+\`\`\`
+semantic-memory_store(
+  information="<technology-name> <version>: <key patterns, gotchas, API changes, compatibility notes>",
+  tags="research, <tech-name>, documentation, {epic_id}"
+)
+\`\`\`
+
+**Why store individually?** Future agents can search by technology name.
+
+### Step 6: Broadcast Summary
+Send condensed findings to coordinator:
+\`\`\`
+swarmmail_send(
+  to=["coordinator"],
+  subject="Research Complete: {research_id}",
+  body="<brief summary - see semantic-memory for details>",
+  thread_id="{epic_id}"
+)
+\`\`\`
+
+### Step 7: Return Structured Output
+Output JSON with:
+\`\`\`json
+{
+  "technologies": [
+    {
+      "name": "string",
+      "installed_version": "string",
+      "latest_version": "string | null",  // Only if --check-upgrades
+      "key_patterns": ["string"],
+      "gotchas": ["string"],
+      "breaking_changes": ["string"],  // Only if --check-upgrades
+      "memory_id": "string"  // ID of semantic-memory entry
+    }
+  ],
+  "summary": "string"  // Condensed summary for shared_context
+}
+\`\`\`
+
+## [CRITICAL REQUIREMENTS]
+
+**NON-NEGOTIABLE:**
+1. Step 1 (swarmmail_init) MUST be first
+2. Research ONLY the technologies the coordinator specified
+3. Fetch docs for INSTALLED versions (unless --check-upgrades)
+4. Store detailed findings in semantic-memory (one per technology)
+5. Return condensed summary for coordinator (full details in memory)
+6. Use appropriate doc tools (nextjs_docs for Next.js, context7 for libraries, etc.)
+
+**Output goes TWO places:**
+- **semantic-memory**: Detailed findings (searchable by future agents)
+- **Return JSON**: Condensed summary (for coordinator's shared_context)
+
+Begin research now.`;
+
 /**
  * Coordinator post-worker checklist - MANDATORY review loop
  *
@@ -656,6 +797,30 @@ should describe what needs to be fixed.`;
 // Helper Functions
 // ============================================================================
 
+/**
+ * Format the researcher prompt for a documentation research task
+ */
+export function formatResearcherPrompt(params: {
+  research_id: string;
+  epic_id: string;
+  tech_stack: string[];
+  project_path: string;
+  check_upgrades: boolean;
+}): string {
+  const techList = params.tech_stack.map((t) => `- ${t}`).join("\n");
+  
+  const upgradesMode = params.check_upgrades
+    ? "**UPGRADE COMPARISON MODE**: Fetch docs for BOTH installed AND latest versions. Compare and note breaking changes."
+    : "**DEFAULT MODE**: Fetch docs for INSTALLED versions only (from lockfiles).";
+
+  return RESEARCHER_PROMPT
+    .replace(/{research_id}/g, params.research_id)
+    .replace(/{epic_id}/g, params.epic_id)
+    .replace("{tech_stack}", techList)
+    .replace("{project_path}", params.project_path)
+    .replace("{check_upgrades}", upgradesMode);
+}
+
 /**
  * Format the V2 subtask prompt for a specific agent
  */
@@ -937,6 +1102,68 @@ export const swarm_spawn_subtask = tool({
   },
 });
 
+/**
+ * Prepare a researcher task for spawning with Task tool
+ * 
+ * Generates a prompt that tells the researcher to fetch documentation for specific technologies.
+ * Returns JSON that can be directly used with Task tool.
+ */
+export const swarm_spawn_researcher = tool({
+  description:
+    "Prepare a research task for spawning. Returns prompt for gathering technology documentation. Researcher fetches docs and stores findings in semantic-memory.",
+  args: {
+    research_id: tool.schema.string().describe("Unique ID for this research task"),
+    epic_id: tool.schema.string().describe("Parent epic ID"),
+    tech_stack: tool.schema
+      .array(tool.schema.string())
+      .describe("Explicit list of technologies to research (from coordinator)"),
+    project_path: tool.schema
+      .string()
+      .describe("Absolute project path for swarmmail_init"),
+    check_upgrades: tool.schema
+      .boolean()
+      .optional()
+      .describe("If true, compare installed vs latest versions (default: false)"),
+  },
+  async execute(args) {
+    const prompt = formatResearcherPrompt({
+      research_id: args.research_id,
+      epic_id: args.epic_id,
+      tech_stack: args.tech_stack,
+      project_path: args.project_path,
+      check_upgrades: args.check_upgrades ?? false,
+    });
+
+    return JSON.stringify(
+      {
+        prompt,
+        research_id: args.research_id,
+        epic_id: args.epic_id,
+        tech_stack: args.tech_stack,
+        project_path: args.project_path,
+        check_upgrades: args.check_upgrades ?? false,
+        subagent_type: "swarm/researcher",
+        expected_output: {
+          technologies: [
+            {
+              name: "string",
+              installed_version: "string",
+              latest_version: "string | null",
+              key_patterns: ["string"],
+              gotchas: ["string"],
+              breaking_changes: ["string"],
+              memory_id: "string",
+            },
+          ],
+          summary: "string",
+        },
+      },
+      null,
+      2,
+    );
+  },
+});
+
 /**
  * Generate self-evaluation prompt
  */
@@ -1125,6 +1352,7 @@ export const swarm_plan_prompt = tool({
 export const promptTools = {
   swarm_subtask_prompt,
   swarm_spawn_subtask,
+  swarm_spawn_researcher,
   swarm_evaluation_prompt,
   swarm_plan_prompt,
 };