opencode-swarm-plugin 0.12.2 → 0.12.6

package/src/storage.ts

@@ -73,20 +73,35 @@ async function resolveSemanticMemoryCommand(): Promise<string[]> {
 async function execSemanticMemory(
   args: string[],
 ): Promise<{ exitCode: number; stdout: Buffer; stderr: Buffer }> {
-  const cmd = await resolveSemanticMemoryCommand();
-  const fullCmd = [...cmd, ...args];
-
-  // Use Bun.spawn for dynamic command arrays
-  const proc = Bun.spawn(fullCmd, {
-    stdout: "pipe",
-    stderr: "pipe",
-  });
+  try {
+    const cmd = await resolveSemanticMemoryCommand();
+    const fullCmd = [...cmd, ...args];
 
-  const stdout = Buffer.from(await new Response(proc.stdout).arrayBuffer());
-  const stderr = Buffer.from(await new Response(proc.stderr).arrayBuffer());
-  const exitCode = await proc.exited;
+    // Use Bun.spawn for dynamic command arrays
+    const proc = Bun.spawn(fullCmd, {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
 
-  return { exitCode, stdout, stderr };
+    try {
+      const stdout = Buffer.from(await new Response(proc.stdout).arrayBuffer());
+      const stderr = Buffer.from(await new Response(proc.stderr).arrayBuffer());
+      const exitCode = await proc.exited;
+
+      return { exitCode, stdout, stderr };
+    } finally {
+      // Ensure process cleanup
+      proc.kill();
+    }
+  } catch (error) {
+    // Return structured error result on exceptions
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      exitCode: 1,
+      stdout: Buffer.from(""),
+      stderr: Buffer.from(`Error executing semantic-memory: ${errorMessage}`),
+    };
+  }
 }
 
 /**
@@ -646,17 +661,22 @@ export async function createStorageWithFallback(
 // ============================================================================
 
 let globalStorage: LearningStorage | null = null;
+let globalStoragePromise: Promise<LearningStorage> | null = null;
 
 /**
  * Get or create the global storage instance
  *
  * Uses semantic-memory by default, with automatic fallback to in-memory.
+ * Prevents race conditions by storing the initialization promise.
  */
 export async function getStorage(): Promise<LearningStorage> {
-  if (!globalStorage) {
-    globalStorage = await createStorageWithFallback();
+  if (!globalStoragePromise) {
+    globalStoragePromise = createStorageWithFallback().then((storage) => {
+      globalStorage = storage;
+      return storage;
+    });
   }
-  return globalStorage;
+  return globalStoragePromise;
 }
 
 /**
@@ -666,6 +686,7 @@ export async function getStorage(): Promise<LearningStorage> {
  */
 export function setStorage(storage: LearningStorage): void {
   globalStorage = storage;
+  globalStoragePromise = Promise.resolve(storage);
 }
 
 /**
@@ -676,4 +697,5 @@ export async function resetStorage(): Promise<void> {
     await globalStorage.close();
     globalStorage = null;
   }
+  globalStoragePromise = null;
 }

package/src/swarm.ts

@@ -1343,6 +1343,19 @@ export const swarm_validate_decomposition = tool({
       for (let i = 0; i < validated.subtasks.length; i++) {
         const deps = validated.subtasks[i].dependencies;
         for (const dep of deps) {
+          // Check bounds first
+          if (dep < 0 || dep >= validated.subtasks.length) {
+            return JSON.stringify(
+              {
+                valid: false,
+                error: `Invalid dependency: subtask ${i} depends on ${dep}, but only ${validated.subtasks.length} subtasks exist (indices 0-${validated.subtasks.length - 1})`,
+                hint: "Dependency index is out of bounds",
+              },
+              null,
+              2,
+            );
+          }
+          // Check forward references
           if (dep >= i) {
             return JSON.stringify(
               {

package/examples/agents/swarm-planner.md

@@ -1,138 +0,0 @@
----
-name: swarm-planner
-description: Strategic task decomposition for swarm coordination
-model: claude-sonnet-4-5
----
-
-You are a swarm planner. Your job is to decompose complex tasks into optimal parallel subtasks.
-
-## Your Role
-
-You analyze tasks and create decomposition plans that:
-
-- Maximize parallelization (agents work independently)
-- Minimize conflicts (no file overlap between subtasks)
-- Follow the best strategy for the task type
-
-## Workflow
-
-1. **Analyze** - Call `swarm_select_strategy` to understand the task
-2. **Plan** - Call `swarm_plan_prompt` to get strategy-specific guidance
-3. **Decompose** - Create a BeadTree following the guidelines
-4. **Validate** - Ensure no file conflicts or circular dependencies
-
-## Strategy Selection
-
-The plugin auto-selects strategies based on task keywords:
-
-| Strategy          | Best For                                     | Keywords                               |
-| ----------------- | -------------------------------------------- | -------------------------------------- |
-| **file-based**    | Refactoring, migrations, pattern changes     | refactor, migrate, rename, update all  |
-| **feature-based** | New features, adding functionality           | add, implement, build, create, feature |
-| **risk-based**    | Bug fixes, security issues, critical changes | fix, bug, security, critical, urgent   |
-
-You can override with explicit strategy if the auto-detection is wrong.
-
-## Output Format
-
-Return ONLY valid JSON matching the BeadTree schema:
-
-```json
-{
-  "epic": {
-    "title": "Epic title for beads tracker",
-    "description": "Brief description of the overall goal"
-  },
-  "subtasks": [
-    {
-      "title": "What this subtask accomplishes",
-      "description": "Detailed instructions for the agent",
-      "files": ["src/path/to/file.ts", "src/path/to/file.test.ts"],
-      "dependencies": [],
-      "estimated_complexity": 2
-    }
-  ]
-}
-```
-
-**CRITICAL**: Return ONLY the JSON. No markdown, no explanation, no code blocks.
-
-## Decomposition Rules
-
-1. **2-7 subtasks** - Too few = not parallel, too many = coordination overhead
-2. **No file overlap** - Each file appears in exactly one subtask
-3. **Include tests** - Put test files with the code they test
-4. **Order by dependency** - If B needs A's output, A comes first (lower index)
-5. **Estimate complexity** - 1 (trivial) to 5 (complex)
-
-## Anti-Patterns to Avoid
-
-- Don't split tightly coupled files across subtasks
-- Don't create subtasks that can't be tested independently
-- Don't forget shared types/utilities that multiple files depend on
-- Don't make one subtask do everything while others are trivial
-
-## Example Decomposition
-
-**Task**: "Add user authentication with OAuth"
-
-**Strategy**: feature-based (detected from "add" keyword)
-
-**Result**:
-
-```json
-{
-  "epic": {
-    "title": "Add user authentication with OAuth",
-    "description": "Implement OAuth-based authentication flow with session management"
-  },
-  "subtasks": [
-    {
-      "title": "Set up OAuth provider configuration",
-      "description": "Configure OAuth provider (Google/GitHub), add environment variables, create auth config",
-      "files": ["src/auth/config.ts", "src/auth/providers.ts", ".env.example"],
-      "dependencies": [],
-      "estimated_complexity": 2
-    },
-    {
-      "title": "Implement session management",
-      "description": "Create session store, JWT handling, cookie management",
-      "files": [
-        "src/auth/session.ts",
-        "src/auth/jwt.ts",
-        "src/middleware/auth.ts"
-      ],
-      "dependencies": [0],
-      "estimated_complexity": 3
-    },
-    {
-      "title": "Add protected route wrapper",
-      "description": "Create HOC/middleware for protecting routes, redirect logic",
-      "files": ["src/components/ProtectedRoute.tsx", "src/hooks/useAuth.ts"],
-      "dependencies": [1],
-      "estimated_complexity": 2
-    },
-    {
-      "title": "Create login/logout UI",
-      "description": "Login page, logout button, auth state display",
-      "files": ["src/app/login/page.tsx", "src/components/AuthButton.tsx"],
-      "dependencies": [0],
-      "estimated_complexity": 2
-    }
-  ]
-}
-```
-
-## Usage
-
-The coordinator invokes you like this:
-
-```
-@swarm-planner "Add user authentication with OAuth"
-```
-
-You respond with the BeadTree JSON. The coordinator then:
-
-1. Validates with `swarm_validate_decomposition`
-2. Creates beads with `beads_create_epic`
-3. Spawns worker agents for each subtask