opencode-swarm-plugin 0.30.4 → 0.30.6

package/CHANGELOG.md

@@ -1,5 +1,63 @@
 # opencode-swarm-plugin
 
+## 0.30.6
+
+### Patch Changes
+
+- [`32a2885`](https://github.com/joelhooks/swarm-tools/commit/32a2885115cc3e574e86d8e492f60ee189627488) Thanks [@joelhooks](https://github.com/joelhooks)! - chore: verify CI publish flow works
+
+## 0.30.5
+
+### Patch Changes
+
+- [`08e61ab`](https://github.com/joelhooks/swarm-tools/commit/08e61abd96ced0443a5ac5dca0e8f362ed869075) Thanks [@joelhooks](https://github.com/joelhooks)! - ## 🐝 Workers Now Choose Their Own Model
+
+  Added intelligent model selection for swarm workers based on task characteristics.
+
+  **What changed:**
+
+  - `swarm setup` now asks for a "lite model" preference (docs/tests/simple edits)
+  - New `selectWorkerModel()` function auto-selects based on file types
+  - `swarm_spawn_subtask` includes `recommended_model` in metadata
+  - `DecomposedSubtask` schema supports optional explicit `model` field
+
+  **Model selection priority:**
+
+  1. Explicit `model` field in subtask (if specified)
+  2. File-type inference:
+     - All `.md`/`.mdx` files → lite model
+     - All `.test.`/`.spec.` files → lite model
+  3. Mixed or implementation files → primary model
+
+  **Why it matters:**
+
+  - Cost savings: docs and tests don't need expensive models
+  - Faster execution: lite models are snappier for simple tasks
+  - Better defaults: right-sized models for each subtask type
+  - Still flexible: coordinators can override per-subtask
+
+  **Backward compatible:**
+
+  - Existing workflows continue to work
+  - Model selection is transparent to agents
+  - Defaults to primary model if lite model not configured
+
+  **Example:**
+
+  ```typescript
+  // Subtask with all markdown files
+  { files: ["README.md", "docs/guide.mdx"] }
+  // → selects lite model (haiku)
+
+  // Subtask with mixed files
+  { files: ["src/auth.ts", "README.md"] }
+  // → selects primary model (sonnet)
+
+  // Explicit override
+  { files: ["complex-refactor.ts"], model: "anthropic/claude-opus-4-5" }
+  // → uses opus as specified
+  ```
+
 ## 0.30.4
 
 ### Patch Changes

package/bin/swarm.ts

@@ -1889,9 +1889,43 @@ async function setup() {
     process.exit(0);
   }
 
+  // Lite model selection for simple tasks (docs, tests)
+  const liteModel = await p.select({
+    message: "Select lite model (for docs, tests, simple edits):",
+    options: [
+      {
+        value: "anthropic/claude-haiku-4-5",
+        label: "Claude Haiku 4.5",
+        hint: "Fast and cost-effective (recommended)",
+      },
+      {
+        value: "anthropic/claude-sonnet-4-5",
+        label: "Claude Sonnet 4.5",
+        hint: "More capable, slower",
+      },
+      {
+        value: "openai/gpt-4o-mini",
+        label: "GPT-4o Mini",
+        hint: "Fast and cheap",
+      },
+      {
+        value: "google/gemini-2.0-flash",
+        label: "Gemini 2.0 Flash",
+        hint: "Fast and capable",
+      },
+    ],
+    initialValue: "anthropic/claude-haiku-4-5",
+  });
+
+  if (p.isCancel(liteModel)) {
+    p.cancel("Setup cancelled");
+    process.exit(0);
+  }
+
   p.log.success("Selected models:");
   p.log.message(dim(`  Coordinator: ${coordinatorModel}`));
   p.log.message(dim(`  Worker: ${workerModel}`));
+  p.log.message(dim(`  Lite: ${liteModel}`));
 
   p.log.step("Setting up OpenCode integration...");
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.30.4",
+  "version": "0.30.6",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",

package/src/model-selection.test.ts

@@ -0,0 +1,188 @@
+/**
+ * Model Selection Tests
+ *
+ * Tests for selectWorkerModel function that determines which model
+ * a worker should use based on subtask characteristics.
+ */
+import { describe, test, expect } from "bun:test";
+import { selectWorkerModel } from "./model-selection";
+import type { DecomposedSubtask } from "./schemas/task";
+
+// Mock config type matching expected SwarmConfig structure
+interface TestConfig {
+  primaryModel: string;
+  liteModel?: string;
+}
+
+describe("selectWorkerModel", () => {
+  const mockConfig: TestConfig = {
+    primaryModel: "anthropic/claude-sonnet-4-5",
+    liteModel: "anthropic/claude-haiku-4-5",
+  };
+
+  test("uses explicit model field from subtask when provided", () => {
+    const subtask: DecomposedSubtask & { model?: string } = {
+      title: "Update docs",
+      description: "Update README",
+      files: ["README.md"],
+      estimated_effort: "trivial",
+      model: "anthropic/claude-opus-4-5", // Explicit override
+    };
+
+    const result = selectWorkerModel(subtask, mockConfig);
+    expect(result).toBe("anthropic/claude-opus-4-5");
+  });
+
+  test("uses liteModel for all markdown files", () => {
+    const subtask: DecomposedSubtask = {
+      title: "Update docs",
+      description: "Update all docs",
+      files: ["README.md", "CONTRIBUTING.md"],
+      estimated_effort: "small",
+    };
+
+    const result = selectWorkerModel(subtask, mockConfig);
+    expect(result).toBe("anthropic/claude-haiku-4-5");
+  });
+
+  test("uses liteModel for all MDX files", () => {
+    const subtask: DecomposedSubtask = {
+      title: "Update docs",
+      description: "Update content",
+      files: ["docs/intro.mdx", "docs/guide.mdx"],
+      estimated_effort: "small",
+    };
+
+    const result = selectWorkerModel(subtask, mockConfig);
+    expect(result).toBe("anthropic/claude-haiku-4-5");
+  });
+
+  test("uses liteModel for test files with .test. pattern", () => {
+    const subtask: DecomposedSubtask = {
+      title: "Write tests",
+      description: "Add unit tests",
+      files: ["src/auth.test.ts", "src/user.test.ts"],
+      estimated_effort: "small",
+    };
+
+    const result = selectWorkerModel(subtask, mockConfig);
+    expect(result).toBe("anthropic/claude-haiku-4-5");
+  });
+
+  test("uses liteModel for test files with .spec. pattern", () => {
+    const subtask: DecomposedSubtask = {
+      title: "Write specs",
+      description: "Add spec tests",
+      files: ["src/auth.spec.ts", "src/user.spec.ts"],
+      estimated_effort: "small",
+    };
+
+    const result = selectWorkerModel(subtask, mockConfig);
+    expect(result).toBe("anthropic/claude-haiku-4-5");
+  });
+
+  test("uses primaryModel when files are mixed (code + docs)", () => {
+    const subtask: DecomposedSubtask = {
+      title: "Implement feature with docs",
+      description: "Add feature and document it",
+      files: ["src/feature.ts", "README.md"],
+      estimated_effort: "medium",
+    };
+
+    const result = selectWorkerModel(subtask, mockConfig);
+    expect(result).toBe("anthropic/claude-sonnet-4-5");
+  });
+
+  test("uses primaryModel when files are mixed (code + tests)", () => {
+    const subtask: DecomposedSubtask = {
+      title: "Implement feature with tests",
+      description: "Add feature and tests",
+      files: ["src/feature.ts", "src/feature.test.ts"],
+      estimated_effort: "medium",
+    };
+
+    const result = selectWorkerModel(subtask, mockConfig);
+    expect(result).toBe("anthropic/claude-sonnet-4-5");
+  });
+
+  test("uses primaryModel for implementation files", () => {
+    const subtask: DecomposedSubtask = {
+      title: "Implement auth",
+      description: "Add authentication",
+      files: ["src/auth.ts", "src/middleware.ts"],
+      estimated_effort: "large",
+    };
+
+    const result = selectWorkerModel(subtask, mockConfig);
+    expect(result).toBe("anthropic/claude-sonnet-4-5");
+  });
+
+  test("defaults to primaryModel when liteModel not configured", () => {
+    const configWithoutLite: TestConfig = {
+      primaryModel: "anthropic/claude-sonnet-4-5",
+      // liteModel is undefined
+    };
+
+    const subtask: DecomposedSubtask = {
+      title: "Update docs",
+      description: "Update README",
+      files: ["README.md"],
+      estimated_effort: "trivial",
+    };
+
+    const result = selectWorkerModel(subtask, configWithoutLite);
+    expect(result).toBe("anthropic/claude-sonnet-4-5");
+  });
+
+  test("falls back to claude-haiku when liteModel not configured but primaryModel missing", () => {
+    const emptyConfig: TestConfig = {
+      primaryModel: "",
+    };
+
+    const subtask: DecomposedSubtask = {
+      title: "Update docs",
+      description: "Update README",
+      files: ["README.md"],
+      estimated_effort: "trivial",
+    };
+
+    const result = selectWorkerModel(subtask, emptyConfig);
+    expect(result).toBe("anthropic/claude-haiku-4-5");
+  });
+
+  test("handles empty files array by defaulting to primaryModel", () => {
+    const subtask: DecomposedSubtask = {
+      title: "Research task",
+      description: "Investigate options",
+      files: [],
+      estimated_effort: "small",
+    };
+
+    const result = selectWorkerModel(subtask, mockConfig);
+    expect(result).toBe("anthropic/claude-sonnet-4-5");
+  });
+
+  test("handles mixed markdown and mdx files", () => {
+    const subtask: DecomposedSubtask = {
+      title: "Update all docs",
+      description: "Update docs",
+      files: ["README.md", "docs/guide.mdx", "CHANGELOG.md"],
+      estimated_effort: "small",
+    };
+
+    const result = selectWorkerModel(subtask, mockConfig);
+    expect(result).toBe("anthropic/claude-haiku-4-5");
+  });
+
+  test("case insensitive file extension matching", () => {
+    const subtask: DecomposedSubtask = {
+      title: "Update docs",
+      description: "Update README",
+      files: ["README.MD", "CONTRIBUTING.MD"],
+      estimated_effort: "trivial",
+    };
+
+    const result = selectWorkerModel(subtask, mockConfig);
+    expect(result).toBe("anthropic/claude-haiku-4-5");
+  });
+});

package/src/model-selection.ts

@@ -0,0 +1,68 @@
+/**
+ * Model Selection Module
+ *
+ * Determines which model a worker agent should use based on subtask
+ * characteristics like file types and complexity.
+ *
+ * Priority:
+ * 1. Explicit model field in subtask
+ * 2. File-type inference (docs/tests → lite model)
+ * 3. Default to primary model
+ */
+
+import type { DecomposedSubtask } from "./schemas/task";
+
+/**
+ * Configuration interface for swarm models
+ */
+export interface SwarmConfig {
+  primaryModel: string;
+  liteModel?: string;
+}
+
+/**
+ * Select the appropriate model for a worker agent based on subtask characteristics
+ *
+ * Priority order:
+ * 1. Explicit `model` field in subtask (if present)
+ * 2. File-type inference:
+ *    - All .md/.mdx files → liteModel
+ *    - All .test./.spec. files → liteModel
+ * 3. Mixed files or implementation → primaryModel
+ *
+ * @param subtask - The subtask to evaluate
+ * @param config - Swarm configuration with model preferences
+ * @returns Model identifier string
+ */
+export function selectWorkerModel(
+  subtask: DecomposedSubtask & { model?: string },
+  config: SwarmConfig,
+): string {
+  // Priority 1: Explicit model in subtask
+  if (subtask.model) {
+    return subtask.model;
+  }
+
+  const files = subtask.files || [];
+
+  // Priority 2: File-type inference
+  if (files.length > 0) {
+    const allDocs = files.every((f) => {
+      const lower = f.toLowerCase();
+      return lower.endsWith(".md") || lower.endsWith(".mdx");
+    });
+
+    const allTests = files.every((f) => {
+      const lower = f.toLowerCase();
+      return lower.includes(".test.") || lower.includes(".spec.");
+    });
+
+    if (allDocs || allTests) {
+      // Use lite model if configured, otherwise fall back to primary
+      return config.liteModel || config.primaryModel || "anthropic/claude-haiku-4-5";
+    }
+  }
+
+  // Priority 3: Default to primary model
+  return config.primaryModel || "anthropic/claude-haiku-4-5";
+}

package/src/schemas/task.ts

@@ -43,6 +43,11 @@ export const DecomposedSubtaskSchema = z.object({
   estimated_effort: EffortLevelSchema,
   /** Potential risks or complications (e.g., 'tight coupling', 'data migration required', 'breaking change') */
   risks: z.array(z.string()).optional().default([]),
+  /** 
+   * Optional explicit model override for this subtask.
+   * If not specified, model will be selected based on file types.
+   */
+  model: z.string().optional(),
 });
 export type DecomposedSubtask = z.infer<typeof DecomposedSubtaskSchema>;
 

package/src/swarm-prompts.test.ts

@@ -0,0 +1,173 @@
+/**
+ * Tests for swarm-prompts.ts
+ *
+ * Validates that prompt templates contain required sections and emphasis
+ * for memory usage, coordination, and TDD workflow.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  formatSubtaskPromptV2,
+  SUBTASK_PROMPT_V2,
+} from "./swarm-prompts";
+
+describe("SUBTASK_PROMPT_V2", () => {
+  describe("memory query emphasis", () => {
+    test("Step 2 is semantic-memory_find and marked MANDATORY", () => {
+      expect(SUBTASK_PROMPT_V2).toContain("### Step 2:");
+      expect(SUBTASK_PROMPT_V2).toContain("semantic-memory_find");
+      // Must have MANDATORY in the step header
+      expect(SUBTASK_PROMPT_V2).toMatch(/### Step 2:.*MANDATORY/i);
+    });
+
+    test("memory query step has visual emphasis (emoji or caps)", () => {
+      // Should have emoji or CRITICAL/ALWAYS in caps
+      const step2Match = SUBTASK_PROMPT_V2.match(/### Step 2:[\s\S]*?### Step 3:/);
+      expect(step2Match).not.toBeNull();
+      if (!step2Match) return;
+      const step2Content = step2Match[0];
+      
+      // Must have at least one of: emoji, CRITICAL, ALWAYS, MANDATORY
+      const hasEmphasis = 
+        /🧠|⚠️|CRITICAL|ALWAYS|MANDATORY/.test(step2Content);
+      expect(hasEmphasis).toBe(true);
+    });
+
+    test("memory query step includes query examples by task type", () => {
+      const step2Match = SUBTASK_PROMPT_V2.match(/### Step 2:[\s\S]*?### Step 3:/);
+      expect(step2Match).not.toBeNull();
+      if (!step2Match) return;
+      const step2Content = step2Match[0];
+      
+      // Should have examples for different task types
+      expect(step2Content).toContain("Bug fix");
+      expect(step2Content).toContain("New feature");
+      expect(step2Content).toContain("Refactor");
+    });
+
+    test("memory query step explains WHY it's mandatory", () => {
+      const step2Match = SUBTASK_PROMPT_V2.match(/### Step 2:[\s\S]*?### Step 3:/);
+      expect(step2Match).not.toBeNull();
+      if (!step2Match) return;
+      const step2Content = step2Match[0];
+      
+      // Should explain consequences of skipping
+      expect(step2Content).toMatch(/skip|waste|repeat|already.solved/i);
+    });
+  });
+
+  describe("memory storage emphasis", () => {
+    test("has a dedicated section for storing learnings", () => {
+      // Should have a prominent section about storing memories
+      expect(SUBTASK_PROMPT_V2).toMatch(/##.*STORE.*LEARNING|### Step.*Store.*Learning/i);
+    });
+
+    test("storage section lists triggers for when to store", () => {
+      // Should mention triggers: bugs, gotchas, patterns, failed approaches
+      expect(SUBTASK_PROMPT_V2).toContain("bug");
+      expect(SUBTASK_PROMPT_V2).toMatch(/gotcha|quirk|workaround/i);
+      expect(SUBTASK_PROMPT_V2).toMatch(/pattern|domain/i);
+    });
+
+    test("storage section emphasizes WHY not just WHAT", () => {
+      expect(SUBTASK_PROMPT_V2).toMatch(/WHY.*not.*WHAT|why.*matters/i);
+    });
+
+    test("storage section warns against generic knowledge", () => {
+      expect(SUBTASK_PROMPT_V2).toMatch(/don't store.*generic|generic knowledge/i);
+    });
+  });
+
+  describe("checklist order", () => {
+    test("Step 1 is swarmmail_init", () => {
+      expect(SUBTASK_PROMPT_V2).toMatch(/### Step 1:[\s\S]*?swarmmail_init/);
+    });
+
+    test("Step 2 is semantic-memory_find (before skills)", () => {
+      const step2Pos = SUBTASK_PROMPT_V2.indexOf("### Step 2:");
+      const step3Pos = SUBTASK_PROMPT_V2.indexOf("### Step 3:");
+      const memoryFindPos = SUBTASK_PROMPT_V2.indexOf("semantic-memory_find");
+      const skillsPos = SUBTASK_PROMPT_V2.indexOf("skills_list");
+      
+      // Memory find should be in Step 2, before skills in Step 3
+      expect(memoryFindPos).toBeGreaterThan(step2Pos);
+      expect(memoryFindPos).toBeLessThan(step3Pos);
+      expect(skillsPos).toBeGreaterThan(step3Pos);
+    });
+
+    test("semantic-memory_store comes before swarm_complete", () => {
+      const storePos = SUBTASK_PROMPT_V2.indexOf("semantic-memory_store");
+      const completePos = SUBTASK_PROMPT_V2.lastIndexOf("swarm_complete");
+      
+      expect(storePos).toBeGreaterThan(0);
+      expect(storePos).toBeLessThan(completePos);
+    });
+
+    test("final step is swarm_complete (not hive_close)", () => {
+      // Find the last "### Step N:" pattern
+      const stepMatches = [...SUBTASK_PROMPT_V2.matchAll(/### Step (\d+):/g)];
+      expect(stepMatches.length).toBeGreaterThan(0);
+      
+      const lastStepNum = Math.max(...stepMatches.map(m => parseInt(m[1])));
+      const lastStepMatch = SUBTASK_PROMPT_V2.match(
+        new RegExp(`### Step ${lastStepNum}:[\\s\\S]*?(?=## \\[|$)`)
+      );
+      expect(lastStepMatch).not.toBeNull();
+      
+      const lastStepContent = lastStepMatch![0];
+      expect(lastStepContent).toContain("swarm_complete");
+      expect(lastStepContent).toMatch(/NOT.*hive_close|DO NOT.*hive_close/i);
+    });
+  });
+
+  describe("critical requirements section", () => {
+    test("lists memory query as non-negotiable", () => {
+      const criticalSection = SUBTASK_PROMPT_V2.match(/\[CRITICAL REQUIREMENTS\][\s\S]*?Begin now/);
+      expect(criticalSection).not.toBeNull();
+      
+      expect(criticalSection![0]).toMatch(/semantic-memory_find|memory.*MUST|Step 2.*MUST/i);
+    });
+
+    test("lists consequences of skipping memory steps", () => {
+      const criticalSection = SUBTASK_PROMPT_V2.match(/\[CRITICAL REQUIREMENTS\][\s\S]*?Begin now/);
+      expect(criticalSection).not.toBeNull();
+      
+      // Should mention consequences for skipping memory
+      expect(criticalSection![0]).toMatch(/repeat|waste|already.solved|mistakes/i);
+    });
+  });
+});
+
+describe("formatSubtaskPromptV2", () => {
+  test("substitutes all placeholders correctly", () => {
+    const result = formatSubtaskPromptV2({
+      bead_id: "test-bead-123",
+      epic_id: "test-epic-456",
+      subtask_title: "Test Subtask",
+      subtask_description: "Do the test thing",
+      files: ["src/test.ts", "src/test.test.ts"],
+      shared_context: "This is shared context",
+      project_path: "/path/to/project",
+    });
+
+    expect(result).toContain("test-bead-123");
+    expect(result).toContain("test-epic-456");
+    expect(result).toContain("Test Subtask");
+    expect(result).toContain("Do the test thing");
+    expect(result).toContain("src/test.ts");
+    expect(result).toContain("/path/to/project");
+  });
+
+  test("includes memory query step with MANDATORY emphasis", () => {
+    const result = formatSubtaskPromptV2({
+      bead_id: "test-bead",
+      epic_id: "test-epic",
+      subtask_title: "Test",
+      subtask_description: "",
+      files: [],
+    });
+
+    expect(result).toMatch(/Step 2:.*MANDATORY/i);
+    expect(result).toContain("semantic-memory_find");
+  });
+});

package/src/swarm-prompts.ts

@@ -291,18 +291,36 @@ swarmmail_init(project_path="{project_path}", task_description="{bead_id}: {subt
 
 **If you skip this step, your work will not be tracked and swarm_complete will fail.**
 
-### Step 2: Query Past Learnings (BEFORE starting work)
+### Step 2: 🧠 Query Past Learnings (MANDATORY - BEFORE starting work)
+
+**⚠️ CRITICAL: ALWAYS query semantic memory BEFORE writing ANY code.**
+
 \`\`\`
-semantic-memory_find(query="<keywords from your task>", limit=5)
+semantic-memory_find(query="<keywords from your task>", limit=5, expand=true)
 \`\`\`
 
-**Check if past agents solved similar problems.** Search for:
-- Error messages if debugging
-- Domain concepts (e.g., "authentication", "caching")
-- Technology stack (e.g., "Next.js", "React")
-- Patterns (e.g., "event sourcing", "validation")
+**Why this is MANDATORY:**
+- Past agents may have already solved your exact problem
+- Avoids repeating mistakes that wasted 30+ minutes before
+- Discovers project-specific patterns and gotchas
+- Finds known workarounds for tool/library quirks
+
+**Search Query Examples by Task Type:**
+
+- **Bug fix**: Use exact error message or "<symptom> <component>"
+- **New feature**: Search "<domain concept> implementation pattern"
+- **Refactor**: Query "<pattern name> migration approach"
+- **Integration**: Look for "<library name> gotchas configuration"
+- **Testing**: Find "testing <component type> characterization tests"
+- **Performance**: Search "<technology> performance optimization"
+
+**BEFORE you start coding:**
+1. Run semantic-memory_find with keywords from your task
+2. Read the results with expand=true for full content
+3. Check if any memory solves your problem or warns of pitfalls
+4. Adjust your approach based on past learnings
 
-**Past learnings save time and prevent repeating mistakes.**
+**If you skip this step, you WILL waste time solving already-solved problems.**
 
 ### Step 3: Load Relevant Skills (if available)
 \`\`\`
@@ -739,7 +757,7 @@ export const swarm_subtask_prompt = tool({
  */
 export const swarm_spawn_subtask = tool({
   description:
-    "Prepare a subtask for spawning. Returns prompt with Agent Mail/hive tracking instructions. IMPORTANT: Pass project_path for swarmmail_init.",
+    "Prepare a subtask for spawning. Returns prompt with Agent Mail/hive tracking instructions. IMPORTANT: Pass project_path for swarmmail_init. Automatically selects appropriate model based on file types.",
   args: {
     bead_id: tool.schema.string().describe("Subtask bead ID"),
     epic_id: tool.schema.string().describe("Parent epic bead ID"),
@@ -769,6 +787,10 @@ export const swarm_spawn_subtask = tool({
       })
       .optional()
       .describe("Recovery context from checkpoint compaction"),
+    model: tool.schema
+      .string()
+      .optional()
+      .describe("Optional explicit model override (auto-selected if not provided)"),
   },
   async execute(args) {
     const prompt = formatSubtaskPromptV2({
@@ -782,6 +804,28 @@ export const swarm_spawn_subtask = tool({
       recovery_context: args.recovery_context,
     });
 
+    // Import selectWorkerModel at function scope to avoid circular dependencies
+    const { selectWorkerModel } = await import("./model-selection.js");
+    
+    // Create a mock subtask for model selection
+    const subtask = {
+      title: args.subtask_title,
+      description: args.subtask_description || "",
+      files: args.files,
+      estimated_effort: "medium" as const,
+      risks: [],
+      model: args.model,
+    };
+    
+    // Use placeholder config - actual config should be passed from coordinator
+    // For now, we use reasonable defaults
+    const config = {
+      primaryModel: "anthropic/claude-sonnet-4-5",
+      liteModel: "anthropic/claude-haiku-4-5",
+    };
+    
+    const selectedModel = selectWorkerModel(subtask, config);
+
     return JSON.stringify(
       {
         prompt,
@@ -790,6 +834,7 @@ export const swarm_spawn_subtask = tool({
         files: args.files,
         project_path: args.project_path,
         recovery_context: args.recovery_context,
+        recommended_model: selectedModel,
       },
       null,
       2,