opencode-swarm-plugin 0.30.7 → 0.31.0

package/dist/plugin.js

@@ -27084,7 +27084,8 @@ import {
   FlushManager,
   importFromJSONL,
   syncMemories,
-  getSwarmMail
+  getSwarmMail,
+  resolvePartialId
 } from "swarm-mail";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -27692,6 +27693,43 @@ function ensureHiveDirectory(projectPath) {
   }
 }
 var adapterCache = new Map;
+var exitHookRegistered = false;
+var exitHookRunning = false;
+function registerExitHook() {
+  if (exitHookRegistered) {
+    return;
+  }
+  exitHookRegistered = true;
+  process.on("beforeExit", async (code) => {
+    if (exitHookRunning) {
+      return;
+    }
+    exitHookRunning = true;
+    try {
+      const flushPromises = [];
+      for (const [projectKey, adapter] of adapterCache.entries()) {
+        const flushPromise = (async () => {
+          try {
+            ensureHiveDirectory(projectKey);
+            const flushManager = new FlushManager({
+              adapter,
+              projectKey,
+              outputPath: `${projectKey}/.hive/issues.jsonl`
+            });
+            await flushManager.flush();
+          } catch (error45) {
+            console.warn(`[hive exit hook] Failed to flush ${projectKey}:`, error45 instanceof Error ? error45.message : String(error45));
+          }
+        })();
+        flushPromises.push(flushPromise);
+      }
+      await Promise.all(flushPromises);
+    } finally {
+      exitHookRunning = false;
+    }
+  });
+}
+registerExitHook();
 async function getHiveAdapter(projectKey) {
   if (adapterCache.has(projectKey)) {
     return adapterCache.get(projectKey);
@@ -27845,6 +27883,17 @@ var hive_create_epic = tool({
           console.warn("[hive_create_epic] Failed to emit DecompositionGeneratedEvent:", error45);
         }
       }
+      try {
+        ensureHiveDirectory(projectKey);
+        const flushManager = new FlushManager({
+          adapter,
+          projectKey,
+          outputPath: `${projectKey}/.hive/issues.jsonl`
+        });
+        await flushManager.flush();
+      } catch (error45) {
+        console.warn("[hive_create_epic] Failed to sync to JSONL:", error45);
+      }
       return JSON.stringify(result, null, 2);
     } catch (error45) {
       const rollbackErrors = [];
@@ -27909,7 +27958,7 @@ var hive_query = tool({
 var hive_update = tool({
   description: "Update cell status/description",
   args: {
-    id: tool.schema.string().describe("Cell ID"),
+    id: tool.schema.string().describe("Cell ID or partial hash"),
     status: tool.schema.enum(["open", "in_progress", "blocked", "closed"]).optional().describe("New status"),
     description: tool.schema.string().optional().describe("New description"),
     priority: tool.schema.number().min(0).max(3).optional().describe("New priority")
@@ -27919,27 +27968,34 @@ var hive_update = tool({
     const projectKey = getHiveWorkingDirectory();
     const adapter = await getHiveAdapter(projectKey);
     try {
+      const cellId = await resolvePartialId(adapter, projectKey, validated.id) || validated.id;
       let cell;
       if (validated.status) {
-        cell = await adapter.changeCellStatus(projectKey, validated.id, validated.status);
+        cell = await adapter.changeCellStatus(projectKey, cellId, validated.status);
       }
       if (validated.description !== undefined || validated.priority !== undefined) {
-        cell = await adapter.updateCell(projectKey, validated.id, {
+        cell = await adapter.updateCell(projectKey, cellId, {
           description: validated.description,
           priority: validated.priority
         });
       } else if (!validated.status) {
-        const existingCell = await adapter.getCell(projectKey, validated.id);
+        const existingCell = await adapter.getCell(projectKey, cellId);
         if (!existingCell) {
           throw new HiveError(`Cell not found: ${validated.id}`, "hive_update");
         }
         cell = existingCell;
       }
-      await adapter.markDirty(projectKey, validated.id);
+      await adapter.markDirty(projectKey, cellId);
       const formatted = formatCellForOutput(cell);
       return JSON.stringify(formatted, null, 2);
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
+      if (message.includes("Ambiguous hash")) {
+        throw new HiveError(`Ambiguous ID '${validated.id}': multiple cells match. Please provide more characters.`, "hive_update");
+      }
+      if (message.includes("Bead not found") || message.includes("Cell not found")) {
+        throw new HiveError(`No cell found matching ID '${validated.id}'`, "hive_update");
+      }
       throw new HiveError(`Failed to update cell: ${message}`, "hive_update");
     }
   }
@@ -27947,7 +28003,7 @@ var hive_update = tool({
 var hive_close = tool({
   description: "Close a cell with reason",
   args: {
-    id: tool.schema.string().describe("Cell ID"),
+    id: tool.schema.string().describe("Cell ID or partial hash"),
     reason: tool.schema.string().describe("Completion reason")
   },
   async execute(args, ctx) {
@@ -27955,11 +28011,18 @@ var hive_close = tool({
     const projectKey = getHiveWorkingDirectory();
     const adapter = await getHiveAdapter(projectKey);
     try {
-      const cell = await adapter.closeCell(projectKey, validated.id, validated.reason);
-      await adapter.markDirty(projectKey, validated.id);
+      const cellId = await resolvePartialId(adapter, projectKey, validated.id) || validated.id;
+      const cell = await adapter.closeCell(projectKey, cellId, validated.reason);
+      await adapter.markDirty(projectKey, cellId);
       return `Closed ${cell.id}: ${validated.reason}`;
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
+      if (message.includes("Ambiguous hash")) {
+        throw new HiveError(`Ambiguous ID '${validated.id}': multiple cells match. Please provide more characters.`, "hive_close");
+      }
+      if (message.includes("Bead not found") || message.includes("Cell not found")) {
+        throw new HiveError(`No cell found matching ID '${validated.id}'`, "hive_close");
+      }
       throw new HiveError(`Failed to close cell: ${message}`, "hive_close");
     }
   }
@@ -27967,17 +28030,24 @@ var hive_close = tool({
 var hive_start = tool({
   description: "Mark a cell as in-progress (shortcut for update --status in_progress)",
   args: {
-    id: tool.schema.string().describe("Cell ID")
+    id: tool.schema.string().describe("Cell ID or partial hash")
   },
   async execute(args, ctx) {
     const projectKey = getHiveWorkingDirectory();
     const adapter = await getHiveAdapter(projectKey);
     try {
-      const cell = await adapter.changeCellStatus(projectKey, args.id, "in_progress");
-      await adapter.markDirty(projectKey, args.id);
+      const cellId = await resolvePartialId(adapter, projectKey, args.id) || args.id;
+      const cell = await adapter.changeCellStatus(projectKey, cellId, "in_progress");
+      await adapter.markDirty(projectKey, cellId);
       return `Started: ${cell.id}`;
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
+      if (message.includes("Ambiguous hash")) {
+        throw new HiveError(`Ambiguous ID '${args.id}': multiple cells match. Please provide more characters.`, "hive_start");
+      }
+      if (message.includes("Bead not found") || message.includes("Cell not found")) {
+        throw new HiveError(`No cell found matching ID '${args.id}'`, "hive_start");
+      }
       throw new HiveError(`Failed to start cell: ${message}`, "hive_start");
     }
   }
@@ -30303,7 +30373,7 @@ Agents MUST update their bead status as they work. No silent progress.
 
 ## Requirements
 
-1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel
+1. **Break into independent subtasks** that can run in parallel (as many as needed)
 2. **Assign files** - each subtask must specify which files it will modify
 3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)
 4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array
@@ -30376,7 +30446,7 @@ Agents MUST update their bead status as they work. No silent progress.
 
 ## Requirements
 
-1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel
+1. **Break into independent subtasks** that can run in parallel (as many as needed)
 2. **Assign files** - each subtask must specify which files it will modify
 3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)
 4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array
@@ -30542,10 +30612,10 @@ var swarm_decompose = tool({
   description: "Generate decomposition prompt for breaking task into parallelizable subtasks. Optionally queries CASS for similar past tasks.",
   args: {
     task: tool.schema.string().min(1).describe("Task description to decompose"),
-    max_subtasks: tool.schema.number().int().min(2).max(10).default(5).describe("Maximum number of subtasks (default: 5)"),
+    max_subtasks: tool.schema.number().int().min(1).optional().describe("Suggested max subtasks (optional - LLM decides if not specified)"),
     context: tool.schema.string().optional().describe("Additional context (codebase info, constraints, etc.)"),
     query_cass: tool.schema.boolean().optional().describe("Query CASS for similar past tasks (default: true)"),
-    cass_limit: tool.schema.number().int().min(1).max(10).optional().describe("Max CASS results to include (default: 3)")
+    cass_limit: tool.schema.number().int().min(1).optional().describe("Max CASS results to include (default: 3)")
   },
   async execute(args) {
     const { formatMemoryQueryForDecomposition: formatMemoryQueryForDecomposition2 } = await Promise.resolve().then(() => (init_learning(), exports_learning));
@@ -30673,7 +30743,7 @@ var swarm_delegate_planning = tool({
   args: {
     task: tool.schema.string().min(1).describe("The task to decompose"),
     context: tool.schema.string().optional().describe("Additional context to include"),
-    max_subtasks: tool.schema.number().int().min(2).max(10).optional().default(5).describe("Maximum number of subtasks (default: 5)"),
+    max_subtasks: tool.schema.number().int().min(1).optional().describe("Suggested max subtasks (optional - LLM decides if not specified)"),
     strategy: tool.schema.enum(["auto", "file-based", "feature-based", "risk-based"]).optional().default("auto").describe("Decomposition strategy (default: auto-detect)"),
     query_cass: tool.schema.boolean().optional().default(true).describe("Query CASS for similar past tasks (default: true)")
   },
@@ -33955,6 +34025,21 @@ This will be recorded as a negative learning signal.`;
           }
         }, null, 2);
       }
+      let syncSuccess = false;
+      let syncError;
+      try {
+        const previousWorkingDir = getHiveWorkingDirectory();
+        setHiveWorkingDirectory(args.project_key);
+        try {
+          const syncResult = await hive_sync.execute({ auto_pull: false }, _ctx);
+          syncSuccess = !syncResult.includes("error");
+        } finally {
+          setHiveWorkingDirectory(previousWorkingDir);
+        }
+      } catch (error45) {
+        syncError = error45 instanceof Error ? error45.message : String(error45);
+        console.warn(`[swarm_complete] Auto-sync failed (non-fatal): ${syncError}`);
+      }
       try {
         const epicId3 = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
         const durationMs2 = args.start_time ? Date.now() - args.start_time : 0;
@@ -34040,6 +34125,8 @@ This will be recorded as a negative learning signal.`;
         bead_id: args.bead_id,
         closed: true,
         reservations_released: true,
+        synced: syncSuccess,
+        sync_error: syncError,
         message_sent: messageSent,
         message_error: messageError,
         agent_registration: {
@@ -34716,7 +34803,7 @@ Agents MUST update their cell status as they work. No silent progress.
 
 ## Requirements
 
-1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel
+1. **Break into independent subtasks** that can run in parallel (as many as needed)
 2. **Assign files** - each subtask must specify which files it will modify
 3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)
 4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array
@@ -35344,10 +35431,10 @@ var swarm_plan_prompt = tool({
   args: {
     task: tool.schema.string().min(1).describe("Task description to decompose"),
     strategy: tool.schema.enum(["file-based", "feature-based", "risk-based", "auto"]).optional().describe("Decomposition strategy (default: auto-detect)"),
-    max_subtasks: tool.schema.number().int().min(2).max(10).default(5).describe("Maximum number of subtasks (default: 5)"),
+    max_subtasks: tool.schema.number().int().min(1).optional().describe("Suggested max subtasks (optional - LLM decides if not specified)"),
     context: tool.schema.string().optional().describe("Additional context (codebase info, constraints, etc.)"),
     query_cass: tool.schema.boolean().optional().describe("Query CASS for similar past tasks (default: true)"),
-    cass_limit: tool.schema.number().int().min(1).max(10).optional().describe("Max CASS results to include (default: 3)"),
+    cass_limit: tool.schema.number().int().min(1).optional().describe("Max CASS results to include (default: 3)"),
     include_skills: tool.schema.boolean().optional().describe("Include available skills in context (default: true)")
   },
   async execute(args) {

package/dist/swarm-decompose.d.ts

@@ -58,14 +58,14 @@ export declare const swarm_decompose: {
     description: string;
     args: {
         task: z.ZodString;
-        max_subtasks: z.ZodDefault<z.ZodNumber>;
+        max_subtasks: z.ZodOptional<z.ZodNumber>;
         context: z.ZodOptional<z.ZodString>;
         query_cass: z.ZodOptional<z.ZodBoolean>;
         cass_limit: z.ZodOptional<z.ZodNumber>;
     };
     execute(args: {
         task: string;
-        max_subtasks: number;
+        max_subtasks?: number | undefined;
         context?: string | undefined;
         query_cass?: boolean | undefined;
         cass_limit?: number | undefined;
@@ -122,7 +122,7 @@ export declare const swarm_delegate_planning: {
     args: {
         task: z.ZodString;
         context: z.ZodOptional<z.ZodString>;
-        max_subtasks: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_subtasks: z.ZodOptional<z.ZodNumber>;
         strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             "file-based": "file-based";
             "feature-based": "feature-based";
@@ -133,10 +133,10 @@ export declare const swarm_delegate_planning: {
     };
     execute(args: {
         task: string;
-        max_subtasks: number;
         strategy: "file-based" | "feature-based" | "risk-based" | "auto";
         query_cass: boolean;
         context?: string | undefined;
+        max_subtasks?: number | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
 export declare class SwarmError extends Error {
@@ -200,14 +200,14 @@ export declare const decomposeTools: {
         description: string;
         args: {
             task: z.ZodString;
-            max_subtasks: z.ZodDefault<z.ZodNumber>;
+            max_subtasks: z.ZodOptional<z.ZodNumber>;
             context: z.ZodOptional<z.ZodString>;
             query_cass: z.ZodOptional<z.ZodBoolean>;
             cass_limit: z.ZodOptional<z.ZodNumber>;
         };
         execute(args: {
             task: string;
-            max_subtasks: number;
+            max_subtasks?: number | undefined;
             context?: string | undefined;
             query_cass?: boolean | undefined;
             cass_limit?: number | undefined;
@@ -227,7 +227,7 @@ export declare const decomposeTools: {
         args: {
             task: z.ZodString;
             context: z.ZodOptional<z.ZodString>;
-            max_subtasks: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            max_subtasks: z.ZodOptional<z.ZodNumber>;
             strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 "file-based": "file-based";
                 "feature-based": "feature-based";
@@ -238,10 +238,10 @@ export declare const decomposeTools: {
         };
         execute(args: {
             task: string;
-            max_subtasks: number;
             strategy: "file-based" | "feature-based" | "risk-based" | "auto";
             query_cass: boolean;
             context?: string | undefined;
+            max_subtasks?: number | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
     swarm_plan_interactive: {

package/dist/swarm-decompose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm-decompose.d.ts","sourceRoot":"","sources":["../src/swarm-decompose.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwJxB;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,mBAAmB,GAAG,eAAe,CAAC;IACrD,WAAW,EAAE,MAAM,CAAC;CACrB;AA8CD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACvD,mBAAmB,EAAE,CAmDvB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,GACnC,MAAM,EAAE,CAgBV;AA+GD;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;CA0G1B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;CAkHvC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;CA6LlC,CAAC;AAMH,qBAAa,UAAW,SAAQ,KAAK;aAGjB,SAAS,EAAE,MAAM;aACjB,OAAO,CAAC,EAAE,OAAO;gBAFjC,OAAO,EAAE,MAAM,EACC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,OAAO,YAAA;CAKpC;AAED,qBAAa,kBAAmB,SAAQ,UAAU;aAG9B,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ;gBADrC,OAAO,EAAE,MAAM,EACC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,YAAA;CAIxC;AAkCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;CA0RjC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK1B,CAAC"}
+{"version":3,"file":"swarm-decompose.d.ts","sourceRoot":"","sources":["../src/swarm-decompose.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwJxB;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,mBAAmB,GAAG,eAAe,CAAC;IACrD,WAAW,EAAE,MAAM,CAAC;CACrB;AA8CD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACvD,mBAAmB,EAAE,CAmDvB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,GACnC,MAAM,EAAE,CAgBV;AA+GD;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;CAwG1B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;CAkHvC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;CA2LlC,CAAC;AAMH,qBAAa,UAAW,SAAQ,KAAK;aAGjB,SAAS,EAAE,MAAM;aACjB,OAAO,CAAC,EAAE,OAAO;gBAFjC,OAAO,EAAE,MAAM,EACC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,OAAO,YAAA;CAKpC;AAED,qBAAa,kBAAmB,SAAQ,UAAU;aAG9B,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ;gBADrC,OAAO,EAAE,MAAM,EACC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,YAAA;CAIxC;AAkCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;CA0RjC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK1B,CAAC"}

package/dist/swarm-orchestrate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm-orchestrate.d.ts","sourceRoot":"","sources":["../src/swarm-orchestrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,OAAO,EACL,KAAK,aAAa,EAEnB,MAAM,0BAA0B,CAAC;AAmDlC;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;IAClC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,GAAG,aAAa,CA4BhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,MAAM,EAAE,EACvB,WAAW,EAAE,MAAM,EAAE,GACpB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAqC1C;AA8hBD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;CA8JrB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;CAoFvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CAkHzB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CA6E1B,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8qBzB,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkJ/B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CA6CjC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;CAmClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;CAmB9B,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;CAoJ9B,CAAC;AA4BH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqG3B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;CAsGxB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgMtB,CAAC;AAMH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc5B,CAAC"}
+{"version":3,"file":"swarm-orchestrate.d.ts","sourceRoot":"","sources":["../src/swarm-orchestrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,OAAO,EACL,KAAK,aAAa,EAEnB,MAAM,0BAA0B,CAAC;AAmDlC;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;IAClC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,GAAG,aAAa,CA4BhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,MAAM,EAAE,EACvB,WAAW,EAAE,MAAM,EAAE,GACpB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAqC1C;AA8hBD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;CA8JrB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;CAoFvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CAkHzB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CA6E1B,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwsBzB,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkJ/B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CA6CjC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;CAmClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;CAmB9B,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;CAoJ9B,CAAC;AA4BH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqG3B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;CAsGxB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgMtB,CAAC;AAMH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc5B,CAAC"}

package/dist/swarm-prompts.d.ts

@@ -17,11 +17,11 @@
  * Used by swarm_decompose to instruct the agent on how to break down work.
  * The agent responds with a CellTree that gets validated.
  */
-export declare const DECOMPOSITION_PROMPT = "You are decomposing a task into parallelizable subtasks for a swarm of agents.\n\n## Task\n{task}\n\n{context_section}\n\n## MANDATORY: Hive Issue Tracking\n\n**Every subtask MUST become a cell.** This is non-negotiable.\n\nAfter decomposition, the coordinator will:\n1. Create an epic cell for the overall task\n2. Create child cells for each subtask\n3. Track progress through cell status updates\n4. Close cells with summaries when complete\n\nAgents MUST update their cell status as they work. No silent progress.\n\n## Requirements\n\n1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel\n2. **Assign files** - each subtask must specify which files it will modify\n3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)\n4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array\n5. **Estimate complexity** - 1 (trivial) to 5 (complex)\n6. **Plan aggressively** - break down more than you think necessary, smaller is better\n\n## Response Format\n\nRespond with a JSON object matching this schema:\n\n```typescript\n{\n  epic: {\n    title: string,        // Epic title for the hive tracker\n    description?: string  // Brief description of the overall goal\n  },\n  subtasks: [\n    {\n      title: string,              // What this subtask accomplishes\n      description?: string,       // Detailed instructions for the agent\n      files: string[],            // Files this subtask will modify (globs allowed)\n      dependencies: number[],     // Indices of subtasks this depends on (0-indexed)\n      estimated_complexity: 1-5   // Effort estimate\n    },\n    // ... more subtasks\n  ]\n}\n```\n\n## Guidelines\n\n- **Plan aggressively** - when in doubt, split further. 3 small tasks > 1 medium task\n- **Prefer smaller, focused subtasks** over large complex ones\n- **Include test files** in the same subtask as the code they test\n- **Consider shared types** - if multiple files share types, handle that first\n- **Think about imports** - changes to exported APIs affect downstream files\n- **Explicit > implicit** - spell out what each subtask should do, don't assume\n\n## File Assignment Examples\n\n- Schema change: `[\"src/schemas/user.ts\", \"src/schemas/index.ts\"]`\n- Component + test: `[\"src/components/Button.tsx\", \"src/components/Button.test.tsx\"]`\n- API route: `[\"src/app/api/users/route.ts\"]`\n\nNow decompose the task:";
+export declare const DECOMPOSITION_PROMPT = "You are decomposing a task into parallelizable subtasks for a swarm of agents.\n\n## Task\n{task}\n\n{context_section}\n\n## MANDATORY: Hive Issue Tracking\n\n**Every subtask MUST become a cell.** This is non-negotiable.\n\nAfter decomposition, the coordinator will:\n1. Create an epic cell for the overall task\n2. Create child cells for each subtask\n3. Track progress through cell status updates\n4. Close cells with summaries when complete\n\nAgents MUST update their cell status as they work. No silent progress.\n\n## Requirements\n\n1. **Break into independent subtasks** that can run in parallel (as many as needed)\n2. **Assign files** - each subtask must specify which files it will modify\n3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)\n4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array\n5. **Estimate complexity** - 1 (trivial) to 5 (complex)\n6. **Plan aggressively** - break down more than you think necessary, smaller is better\n\n## Response Format\n\nRespond with a JSON object matching this schema:\n\n```typescript\n{\n  epic: {\n    title: string,        // Epic title for the hive tracker\n    description?: string  // Brief description of the overall goal\n  },\n  subtasks: [\n    {\n      title: string,              // What this subtask accomplishes\n      description?: string,       // Detailed instructions for the agent\n      files: string[],            // Files this subtask will modify (globs allowed)\n      dependencies: number[],     // Indices of subtasks this depends on (0-indexed)\n      estimated_complexity: 1-5   // Effort estimate\n    },\n    // ... more subtasks\n  ]\n}\n```\n\n## Guidelines\n\n- **Plan aggressively** - when in doubt, split further. 3 small tasks > 1 medium task\n- **Prefer smaller, focused subtasks** over large complex ones\n- **Include test files** in the same subtask as the code they test\n- **Consider shared types** - if multiple files share types, handle that first\n- **Think about imports** - changes to exported APIs affect downstream files\n- **Explicit > implicit** - spell out what each subtask should do, don't assume\n\n## File Assignment Examples\n\n- Schema change: `[\"src/schemas/user.ts\", \"src/schemas/index.ts\"]`\n- Component + test: `[\"src/components/Button.tsx\", \"src/components/Button.test.tsx\"]`\n- API route: `[\"src/app/api/users/route.ts\"]`\n\nNow decompose the task:";
 /**
  * Strategy-specific decomposition prompt template
  */
-export declare const STRATEGY_DECOMPOSITION_PROMPT = "You are decomposing a task into parallelizable subtasks for a swarm of agents.\n\n## Task\n{task}\n\n{strategy_guidelines}\n\n{context_section}\n\n{cass_history}\n\n{skills_context}\n\n## MANDATORY: Hive Issue Tracking\n\n**Every subtask MUST become a cell.** This is non-negotiable.\n\nAfter decomposition, the coordinator will:\n1. Create an epic cell for the overall task\n2. Create child cells for each subtask\n3. Track progress through cell status updates\n4. Close cells with summaries when complete\n\nAgents MUST update their cell status as they work. No silent progress.\n\n## Requirements\n\n1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel\n2. **Assign files** - each subtask must specify which files it will modify\n3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)\n4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array\n5. **Estimate complexity** - 1 (trivial) to 5 (complex)\n6. **Plan aggressively** - break down more than you think necessary, smaller is better\n\n## Response Format\n\nRespond with a JSON object matching this schema:\n\n```typescript\n{\n  epic: {\n    title: string,        // Epic title for the hive tracker\n    description?: string  // Brief description of the overall goal\n  },\n  subtasks: [\n    {\n      title: string,              // What this subtask accomplishes\n      description?: string,       // Detailed instructions for the agent\n      files: string[],            // Files this subtask will modify (globs allowed)\n      dependencies: number[],     // Indices of subtasks this depends on (0-indexed)\n      estimated_complexity: 1-5   // Effort estimate\n    },\n    // ... more subtasks\n  ]\n}\n```\n\nNow decompose the task:";
+export declare const STRATEGY_DECOMPOSITION_PROMPT = "You are decomposing a task into parallelizable subtasks for a swarm of agents.\n\n## Task\n{task}\n\n{strategy_guidelines}\n\n{context_section}\n\n{cass_history}\n\n{skills_context}\n\n## MANDATORY: Hive Issue Tracking\n\n**Every subtask MUST become a cell.** This is non-negotiable.\n\nAfter decomposition, the coordinator will:\n1. Create an epic cell for the overall task\n2. Create child cells for each subtask\n3. Track progress through cell status updates\n4. Close cells with summaries when complete\n\nAgents MUST update their cell status as they work. No silent progress.\n\n## Requirements\n\n1. **Break into independent subtasks** that can run in parallel (as many as needed)\n2. **Assign files** - each subtask must specify which files it will modify\n3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)\n4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array\n5. **Estimate complexity** - 1 (trivial) to 5 (complex)\n6. **Plan aggressively** - break down more than you think necessary, smaller is better\n\n## Response Format\n\nRespond with a JSON object matching this schema:\n\n```typescript\n{\n  epic: {\n    title: string,        // Epic title for the hive tracker\n    description?: string  // Brief description of the overall goal\n  },\n  subtasks: [\n    {\n      title: string,              // What this subtask accomplishes\n      description?: string,       // Detailed instructions for the agent\n      files: string[],            // Files this subtask will modify (globs allowed)\n      dependencies: number[],     // Indices of subtasks this depends on (0-indexed)\n      estimated_complexity: 1-5   // Effort estimate\n    },\n    // ... more subtasks\n  ]\n}\n```\n\nNow decompose the task:";
 /**
  * Prompt template for spawned subtask agents.
  *
@@ -180,7 +180,7 @@ export declare const swarm_plan_prompt: {
             "risk-based": "risk-based";
             auto: "auto";
         }>>;
-        max_subtasks: import("zod").ZodDefault<import("zod").ZodNumber>;
+        max_subtasks: import("zod").ZodOptional<import("zod").ZodNumber>;
         context: import("zod").ZodOptional<import("zod").ZodString>;
         query_cass: import("zod").ZodOptional<import("zod").ZodBoolean>;
         cass_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -188,8 +188,8 @@ export declare const swarm_plan_prompt: {
     };
     execute(args: {
         task: string;
-        max_subtasks: number;
         strategy?: "file-based" | "feature-based" | "risk-based" | "auto" | undefined;
+        max_subtasks?: number | undefined;
         context?: string | undefined;
         query_cass?: boolean | undefined;
         cass_limit?: number | undefined;
@@ -276,7 +276,7 @@ export declare const promptTools: {
                 "risk-based": "risk-based";
                 auto: "auto";
             }>>;
-            max_subtasks: import("zod").ZodDefault<import("zod").ZodNumber>;
+            max_subtasks: import("zod").ZodOptional<import("zod").ZodNumber>;
             context: import("zod").ZodOptional<import("zod").ZodString>;
             query_cass: import("zod").ZodOptional<import("zod").ZodBoolean>;
             cass_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -284,8 +284,8 @@ export declare const promptTools: {
         };
         execute(args: {
             task: string;
-            max_subtasks: number;
             strategy?: "file-based" | "feature-based" | "risk-based" | "auto" | undefined;
+            max_subtasks?: number | undefined;
             context?: string | undefined;
             query_cass?: boolean | undefined;
             cass_limit?: number | undefined;

package/dist/swarm-prompts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm-prompts.d.ts","sourceRoot":"","sources":["../src/swarm-prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,m6EAkET,CAAC;AAEzB;;GAEG;AACH,eAAO,MAAM,6BAA6B,gxDAyDlB,CAAC;AAEzB;;;;;GAKG;AACH,eAAO,MAAM,cAAc,mkFAgFK,CAAC;AAEjC;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,mzSA0SnB,CAAC;AAEZ;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,8jCAmCU,CAAC;AAMzC;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE;QACjB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;QAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,CAAC;CACH,GAAG,MAAM,CA2ET;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,MAAM,CAUT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,GAAG,MAAM,CAMT;AAMD;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CAoC/B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqF9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;CAoClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;CA0I5B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvB,CAAC"}
+{"version":3,"file":"swarm-prompts.d.ts","sourceRoot":"","sources":["../src/swarm-prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,s6EAkET,CAAC;AAEzB;;GAEG;AACH,eAAO,MAAM,6BAA6B,mxDAyDlB,CAAC;AAEzB;;;;;GAKG;AACH,eAAO,MAAM,cAAc,mkFAgFK,CAAC;AAEjC;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,mzSA0SnB,CAAC;AAEZ;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,8jCAmCU,CAAC;AAMzC;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE;QACjB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;QAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,CAAC;CACH,GAAG,MAAM,CA2ET;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,MAAM,CAUT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,GAAG,MAAM,CAMT;AAMD;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CAoC/B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqF9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;CAoClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;CAwI5B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvB,CAAC"}

package/dist/swarm.d.ts

@@ -385,7 +385,7 @@ export declare const swarmTools: {
                 "risk-based": "risk-based";
                 auto: "auto";
             }>>;
-            max_subtasks: import("zod").ZodDefault<import("zod").ZodNumber>;
+            max_subtasks: import("zod").ZodOptional<import("zod").ZodNumber>;
             context: import("zod").ZodOptional<import("zod").ZodString>;
             query_cass: import("zod").ZodOptional<import("zod").ZodBoolean>;
             cass_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -393,8 +393,8 @@ export declare const swarmTools: {
         };
         execute(args: {
             task: string;
-            max_subtasks: number;
             strategy?: "file-based" | "feature-based" | "risk-based" | "auto" | undefined;
+            max_subtasks?: number | undefined;
             context?: string | undefined;
             query_cass?: boolean | undefined;
             cass_limit?: number | undefined;
@@ -405,14 +405,14 @@ export declare const swarmTools: {
         description: string;
         args: {
             task: import("zod").ZodString;
-            max_subtasks: import("zod").ZodDefault<import("zod").ZodNumber>;
+            max_subtasks: import("zod").ZodOptional<import("zod").ZodNumber>;
             context: import("zod").ZodOptional<import("zod").ZodString>;
             query_cass: import("zod").ZodOptional<import("zod").ZodBoolean>;
             cass_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
         };
         execute(args: {
             task: string;
-            max_subtasks: number;
+            max_subtasks?: number | undefined;
             context?: string | undefined;
             query_cass?: boolean | undefined;
             cass_limit?: number | undefined;
@@ -432,7 +432,7 @@ export declare const swarmTools: {
         args: {
             task: import("zod").ZodString;
             context: import("zod").ZodOptional<import("zod").ZodString>;
-            max_subtasks: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+            max_subtasks: import("zod").ZodOptional<import("zod").ZodNumber>;
             strategy: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
                 "file-based": "file-based";
                 "feature-based": "feature-based";
@@ -443,10 +443,10 @@ export declare const swarmTools: {
         };
         execute(args: {
             task: string;
-            max_subtasks: number;
             strategy: "file-based" | "feature-based" | "risk-based" | "auto";
             query_cass: boolean;
             context?: string | undefined;
+            max_subtasks?: number | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
     swarm_plan_interactive: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.30.7",
+  "version": "0.31.0",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "gray-matter": "^4.0.3",
     "ioredis": "^5.4.1",
     "minimatch": "^10.1.1",
-    "swarm-mail": "1.0.0",
+    "swarm-mail": "1.1.0",
     "zod": "4.1.8"
   },
   "devDependencies": {