opencode-swarm-plugin 0.59.0 → 0.59.5

package/claude-plugin/dist/utils/adapter-cache.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Generic adapter cache for project-scoped singletons
+ *
+ * Caches expensive adapters (database connections, indexers, etc.)
+ * keyed by project path. Ensures one instance per project.
+ *
+ * @example
+ * ```ts
+ * const memoryCache = new AdapterCache<MemoryAdapter>();
+ * const adapter = await memoryCache.get(projectPath, async (path) => {
+ *   const db = await getDatabase(path);
+ *   return createMemoryAdapter(db);
+ * });
+ * ```
+ */
+export declare class AdapterCache<T> {
+    private cached;
+    private cachedPath;
+    /**
+     * Get cached adapter or create new one
+     *
+     * @param projectPath - Project path to scope the adapter to
+     * @param factory - Async factory function to create the adapter
+     * @returns Cached or newly created adapter instance
+     */
+    get(projectPath: string, factory: (path: string) => Promise<T>): Promise<T>;
+    /**
+     * Clear the cache (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Get the currently cached project path
+     */
+    getCachedPath(): string | null;
+}
+//# sourceMappingURL=adapter-cache.d.ts.map

package/claude-plugin/dist/utils/adapter-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-cache.d.ts","sourceRoot":"","sources":["../../src/utils/adapter-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,qBAAa,YAAY,CAAC,CAAC;IAC1B,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,UAAU,CAAuB;IAEzC;;;;;;OAMG;IACG,GAAG,CACR,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GACnC,OAAO,CAAC,CAAC,CAAC;IAUb;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,aAAa,IAAI,MAAM,GAAG,IAAI;CAG9B"}

package/claude-plugin/dist/utils/event-utils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Event Utilities - Safe event emission for swarm-mail
+ *
+ * Provides a standardized way to emit events with error handling across all tools.
+ * Events are emitted to the swarm-mail event store for observability and learning.
+ *
+ * Pattern extracted from 21+ identical try-catch blocks across tool files.
+ */
+/**
+ * Safely emit an event to the swarm-mail event store.
+ *
+ * Wraps event creation and emission in a try-catch to prevent tool failures
+ * from event system issues. Logs warnings on failure but continues execution.
+ *
+ * @param eventType - The type of event to emit (e.g., "cell_created", "memory_stored")
+ * @param data - Event data (project_key is added automatically if not present)
+ * @param toolName - Name of the calling tool for logging (e.g., "hive_create", "hivemind_store")
+ * @param projectPath - Project path for event storage (defaults to process.cwd())
+ *
+ * @example
+ * ```typescript
+ * await safeEmitEvent(
+ *   "cell_created",
+ *   { cell_id: cell.id, title: "Fix bug" },
+ *   "hive_create",
+ *   "/path/to/project"
+ * );
+ * ```
+ */
+export declare function safeEmitEvent(eventType: string, data: Record<string, unknown>, toolName: string, projectPath?: string): Promise<void>;
+//# sourceMappingURL=event-utils.d.ts.map

package/claude-plugin/dist/utils/event-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-utils.d.ts","sourceRoot":"","sources":["../../src/utils/event-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,aAAa,CAClC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAcf"}

package/claude-plugin/skills/swarm-coordination/SKILL.md

@@ -17,14 +17,19 @@ related_skills:
 
 This skill guides multi-agent coordination for OpenCode swarm workflows.
 
-## When to Use
+## When to Swarm
 
-- Tasks touching 3+ files
-- Parallelizable work (frontend/backend/tests)
-- Work requiring specialized agents
-- Time-to-completion matters
+**Always swarm when `/swarm` is invoked.** The user's explicit invocation overrides any heuristics.
 
-Avoid swarming for 1–2 file changes or tightly sequential work.
+Swarming serves multiple purposes beyond parallelization:
+- **Context preservation** - workers offload work from coordinator
+- **Session resilience** - workers persist if coordinator compacts
+- **Progress tracking** - hive cells track completion state
+- **Learning capture** - hivemind stores discoveries per subtask
+
+Even small tasks (1-2 files) benefit from swarming when context is precious.
+
+For sequential work, use dependencies between subtasks rather than refusing to swarm.
 
 ## Tool Access (Wildcard)
 
@@ -44,18 +49,47 @@ Claude Code auto-launches MCP servers from `mcpServers` configuration. Do **not*
 ## Coordinator Protocol (High-Level)
 
 1. Initialize Swarm Mail (`swarmmail_init`).
-2. Query past learnings (`hivemind_find`).
+2. **Query past learnings** (`hivemind_find`) - MANDATORY before decomposition.
 3. Decompose (`swarm_plan_prompt` + `swarm_validate_decomposition`).
 4. Spawn workers with explicit file lists.
 5. Review worker output (`swarm_review` + `swarm_review_feedback`).
 6. Record outcomes (`swarm_complete`).
+7. **Store learnings** (`hivemind_store`) - MANDATORY after swarm completion.
 
 ## Worker Protocol (High-Level)
 
 1. Initialize Swarm Mail (`swarmmail_init`).
 2. Reserve files (`swarmmail_reserve`).
 3. Work within scope and report progress.
-4. Complete with `swarm_complete`.
+4. **Store discoveries** (`hivemind_store`) - any gotchas, patterns, or decisions made.
+5. Complete with `swarm_complete`.
+
+## Hivemind Usage (MANDATORY)
+
+Agents MUST use hivemind to build collective memory:
+
+**Before work:**
+```
+hivemind_find({ query: "relevant topic or codebase pattern" })
+```
+
+**During work (when discovering something):**
+```
+hivemind_store({
+  information: "The auth module requires X before Y",
+  tags: "auth,gotcha,codebase-name"
+})
+```
+
+**After work:**
+```
+hivemind_store({
+  information: "Completed task X. Key learnings: ...",
+  tags: "swarm,completion,epic-id"
+})
+```
+
+Store liberally. Memory is cheap; re-discovering gotchas is expensive.
 
 ## File Reservations