opencode-swarm-plugin 0.30.3 → 0.30.5

package/dist/schemas/bead.d.ts

@@ -0,0 +1,255 @@
+/**
+ * Bead schemas for type-safe beads operations
+ *
+ * These schemas validate all data from the `bd` CLI to ensure
+ * type safety and catch malformed responses early.
+ */
+import { z } from "zod";
+/** Valid bead statuses */
+export declare const BeadStatusSchema: z.ZodEnum<{
+    open: "open";
+    in_progress: "in_progress";
+    blocked: "blocked";
+    closed: "closed";
+}>;
+export type BeadStatus = z.infer<typeof BeadStatusSchema>;
+/** Valid bead types */
+export declare const BeadTypeSchema: z.ZodEnum<{
+    bug: "bug";
+    feature: "feature";
+    task: "task";
+    epic: "epic";
+    chore: "chore";
+}>;
+export type BeadType = z.infer<typeof BeadTypeSchema>;
+/** Dependency relationship between beads */
+export declare const BeadDependencySchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        blocks: "blocks";
+        "blocked-by": "blocked-by";
+        related: "related";
+        "discovered-from": "discovered-from";
+    }>;
+}, z.core.$strip>;
+export type BeadDependency = z.infer<typeof BeadDependencySchema>;
+/**
+ * Core bead schema - validates bd CLI JSON output
+ *
+ * ID format:
+ * - Standard: `{project}-{hash}` (e.g., `opencode-swarm-plugin-1i8`)
+ * - Subtask: `{project}-{hash}.{index}` (e.g., `opencode-swarm-plugin-1i8.1`)
+ * - Custom: `{project}-{custom-id}` (e.g., `migrate-egghead-phase-0`)
+ * - Custom subtask: `{project}-{custom-id}.{suffix}` (e.g., `migrate-egghead-phase-0.e2e-test`)
+ */
+export declare const BeadSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    status: z.ZodDefault<z.ZodEnum<{
+        open: "open";
+        in_progress: "in_progress";
+        blocked: "blocked";
+        closed: "closed";
+    }>>;
+    priority: z.ZodDefault<z.ZodNumber>;
+    issue_type: z.ZodDefault<z.ZodEnum<{
+        bug: "bug";
+        feature: "feature";
+        task: "task";
+        epic: "epic";
+        chore: "chore";
+    }>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodOptional<z.ZodString>;
+    closed_at: z.ZodOptional<z.ZodString>;
+    parent_id: z.ZodOptional<z.ZodString>;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            blocks: "blocks";
+            "blocked-by": "blocked-by";
+            related: "related";
+            "discovered-from": "discovered-from";
+        }>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type Bead = z.infer<typeof BeadSchema>;
+/** Arguments for creating a bead */
+export declare const BeadCreateArgsSchema: z.ZodObject<{
+    title: z.ZodString;
+    type: z.ZodDefault<z.ZodEnum<{
+        bug: "bug";
+        feature: "feature";
+        task: "task";
+        epic: "epic";
+        chore: "chore";
+    }>>;
+    priority: z.ZodDefault<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+    parent_id: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BeadCreateArgs = z.infer<typeof BeadCreateArgsSchema>;
+/** Arguments for updating a bead */
+export declare const BeadUpdateArgsSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        in_progress: "in_progress";
+        blocked: "blocked";
+        closed: "closed";
+    }>>;
+    description: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type BeadUpdateArgs = z.infer<typeof BeadUpdateArgsSchema>;
+/** Arguments for closing a bead */
+export declare const BeadCloseArgsSchema: z.ZodObject<{
+    id: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type BeadCloseArgs = z.infer<typeof BeadCloseArgsSchema>;
+/** Arguments for querying beads */
+export declare const BeadQueryArgsSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        in_progress: "in_progress";
+        blocked: "blocked";
+        closed: "closed";
+    }>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        bug: "bug";
+        feature: "feature";
+        task: "task";
+        epic: "epic";
+        chore: "chore";
+    }>>;
+    ready: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type BeadQueryArgs = z.infer<typeof BeadQueryArgsSchema>;
+/**
+ * Subtask specification for epic decomposition
+ *
+ * Used when creating an epic with subtasks in one operation.
+ * The `files` array is used for Agent Mail file reservations.
+ */
+export declare const SubtaskSpecSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    estimated_complexity: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type SubtaskSpec = z.infer<typeof SubtaskSpecSchema>;
+/**
+ * Bead tree for swarm decomposition
+ *
+ * Represents an epic with its subtasks, ready for spawning agents.
+ */
+export declare const BeadTreeSchema: z.ZodObject<{
+    epic: z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>;
+    subtasks: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        estimated_complexity: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BeadTree = z.infer<typeof BeadTreeSchema>;
+/** Arguments for creating an epic with subtasks */
+export declare const EpicCreateArgsSchema: z.ZodObject<{
+    epic_title: z.ZodString;
+    epic_description: z.ZodOptional<z.ZodString>;
+    epic_id: z.ZodOptional<z.ZodString>;
+    subtasks: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        priority: z.ZodDefault<z.ZodNumber>;
+        files: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        id_suffix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type EpicCreateArgs = z.infer<typeof EpicCreateArgsSchema>;
+/**
+ * Result of epic creation
+ *
+ * Contains the created epic and all subtasks with their IDs.
+ */
+export declare const EpicCreateResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    epic: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        status: z.ZodDefault<z.ZodEnum<{
+            open: "open";
+            in_progress: "in_progress";
+            blocked: "blocked";
+            closed: "closed";
+        }>>;
+        priority: z.ZodDefault<z.ZodNumber>;
+        issue_type: z.ZodDefault<z.ZodEnum<{
+            bug: "bug";
+            feature: "feature";
+            task: "task";
+            epic: "epic";
+            chore: "chore";
+        }>>;
+        created_at: z.ZodString;
+        updated_at: z.ZodOptional<z.ZodString>;
+        closed_at: z.ZodOptional<z.ZodString>;
+        parent_id: z.ZodOptional<z.ZodString>;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                blocks: "blocks";
+                "blocked-by": "blocked-by";
+                related: "related";
+                "discovered-from": "discovered-from";
+            }>;
+        }, z.core.$strip>>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    subtasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        status: z.ZodDefault<z.ZodEnum<{
+            open: "open";
+            in_progress: "in_progress";
+            blocked: "blocked";
+            closed: "closed";
+        }>>;
+        priority: z.ZodDefault<z.ZodNumber>;
+        issue_type: z.ZodDefault<z.ZodEnum<{
+            bug: "bug";
+            feature: "feature";
+            task: "task";
+            epic: "epic";
+            chore: "chore";
+        }>>;
+        created_at: z.ZodString;
+        updated_at: z.ZodOptional<z.ZodString>;
+        closed_at: z.ZodOptional<z.ZodString>;
+        parent_id: z.ZodOptional<z.ZodString>;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                blocks: "blocks";
+                "blocked-by": "blocked-by";
+                related: "related";
+                "discovered-from": "discovered-from";
+            }>;
+        }, z.core.$strip>>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    rollback_hint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EpicCreateResult = z.infer<typeof EpicCreateResultSchema>;
+//# sourceMappingURL=bead.d.ts.map

package/dist/schemas/bead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bead.d.ts","sourceRoot":"","sources":["../../src/schemas/bead.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,0BAA0B;AAC1B,eAAO,MAAM,gBAAgB;;;;;EAK3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,uBAAuB;AACvB,eAAO,MAAM,cAAc;;;;;;EAMzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,4CAA4C;AAC5C,eAAO,MAAM,oBAAoB;;;;;;;;iBAG/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCrB,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAE9C,oCAAoC;AACpC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;iBAY/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,oCAAoC;AACpC,eAAO,MAAM,oBAAoB;;;;;;;;;;iBAK/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,mCAAmC;AACnC,eAAO,MAAM,mBAAmB;;;iBAG9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,mCAAmC;AACnC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAK9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;iBAc5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;iBAMzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,mDAAmD;AACnD,eAAO,MAAM,oBAAoB;;;;;;;;;;iBAwB/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.30.3",
+  "version": "0.30.5",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,6 +18,10 @@
       "types": "./dist/plugin.d.ts"
     }
   },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "scripts": {
     "build": "bun build ./src/index.ts --outdir ./dist --target node --external @electric-sql/pglite --external swarm-mail && bun build ./src/plugin.ts --outfile ./dist/plugin.js --target node --external @electric-sql/pglite --external swarm-mail && tsc",
     "dev": "bun --watch src/index.ts",
@@ -26,7 +30,6 @@
     "test:all": "bun test --timeout 60000 src/",
     "test:watch": "bun test --watch src/",
     "typecheck": "tsc --noEmit",
-    "publish:pkg": "npm publish --access public --provenance",
     "postinstall": "node -e \"console.log('\\n\\x1b[33m  Run \\x1b[36mswarm setup\\x1b[33m to configure OpenCode integration\\x1b[0m\\n')\""
   },
   "dependencies": {

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.ts

@@ -739,7 +739,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 +769,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 +786,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 +816,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,