opencode-swarm-plugin 0.29.0 → 0.30.2

package/examples/plugin-wrapper-template.ts

@@ -73,7 +73,11 @@ async function execTool(
             );
           } else if (!result.success && result.error) {
             // Tool returned an error in JSON format
-            reject(new Error(result.error.message || "Tool execution failed"));
+            // Handle both string errors and object errors with .message
+            const errorMsg = typeof result.error === "string" 
+              ? result.error 
+              : (result.error.message || "Tool execution failed");
+            reject(new Error(errorMsg));
           } else {
             resolve(stdout);
           }
@@ -89,11 +93,11 @@ async function execTool(
         try {
           const result = JSON.parse(stdout);
           if (!result.success && result.error) {
-            reject(
-              new Error(
-                result.error.message || `Tool failed with code ${code}`,
-              ),
-            );
+            // Handle both string errors and object errors with .message
+            const errorMsg = typeof result.error === "string"
+              ? result.error
+              : (result.error.message || `Tool failed with code ${code}`);
+            reject(new Error(errorMsg));
           } else {
             reject(
               new Error(stderr || stdout || `Tool failed with code ${code}`),
@@ -883,15 +887,33 @@ const skills_execute = tool({
 // Compaction Hook - Swarm Recovery Context
 // =============================================================================
 
+/**
+ * Detection result with confidence level
+ */
+interface SwarmDetection {
+  detected: boolean;
+  confidence: "high" | "medium" | "low" | "none";
+  reasons: string[];
+}
+
 /**
  * Check for swarm sign - evidence a swarm passed through
  *
- * Like deer scat on a trail, we look for traces:
- * - In-progress beads (active work)
- * - Open beads with parent_id (subtasks of an epic)
- * - Unclosed epics
+ * Uses multiple signals with different confidence levels:
+ * - HIGH: in_progress cells (active work)
+ * - MEDIUM: Open subtasks, unclosed epics, recently updated cells
+ * - LOW: Any cells exist
+ *
+ * Philosophy: Err on the side of continuation.
+ * False positive = extra context (low cost)
+ * False negative = lost swarm (high cost)
  */
-async function hasSwarmSign(): Promise<boolean> {
+async function detectSwarm(): Promise<SwarmDetection> {
+  const reasons: string[] = [];
+  let highConfidence = false;
+  let mediumConfidence = false;
+  let lowConfidence = false;
+
   try {
     const result = await new Promise<{ exitCode: number; stdout: string }>(
       (resolve) => {
@@ -909,24 +931,82 @@ async function hasSwarmSign(): Promise<boolean> {
       },
     );
 
-    if (result.exitCode !== 0) return false;
+    if (result.exitCode !== 0) {
+      return { detected: false, confidence: "none", reasons: ["hive_query failed"] };
+    }
 
-    const beads = JSON.parse(result.stdout);
-    if (!Array.isArray(beads)) return false;
+    const cells = JSON.parse(result.stdout);
+    if (!Array.isArray(cells) || cells.length === 0) {
+      return { detected: false, confidence: "none", reasons: ["no cells found"] };
+    }
 
-    // Look for swarm sign:
-    // 1. Any in_progress beads
-    // 2. Any open beads with a parent (subtasks)
-    // 3. Any epics that aren't closed
-    return beads.some(
-      (b: { status: string; parent_id?: string; type?: string }) =>
-        b.status === "in_progress" ||
-        (b.status === "open" && b.parent_id) ||
-        (b.type === "epic" && b.status !== "closed"),
+    // HIGH: Any in_progress cells
+    const inProgress = cells.filter(
+      (c: { status: string }) => c.status === "in_progress"
+    );
+    if (inProgress.length > 0) {
+      highConfidence = true;
+      reasons.push(`${inProgress.length} cells in_progress`);
+    }
+
+    // MEDIUM: Open subtasks (cells with parent_id)
+    const subtasks = cells.filter(
+      (c: { status: string; parent_id?: string }) =>
+        c.status === "open" && c.parent_id
+    );
+    if (subtasks.length > 0) {
+      mediumConfidence = true;
+      reasons.push(`${subtasks.length} open subtasks`);
+    }
+
+    // MEDIUM: Unclosed epics
+    const openEpics = cells.filter(
+      (c: { status: string; type?: string }) =>
+        c.type === "epic" && c.status !== "closed"
+    );
+    if (openEpics.length > 0) {
+      mediumConfidence = true;
+      reasons.push(`${openEpics.length} unclosed epics`);
+    }
+
+    // MEDIUM: Recently updated cells (last hour)
+    const oneHourAgo = Date.now() - 60 * 60 * 1000;
+    const recentCells = cells.filter(
+      (c: { updated_at?: number }) => c.updated_at && c.updated_at > oneHourAgo
     );
+    if (recentCells.length > 0) {
+      mediumConfidence = true;
+      reasons.push(`${recentCells.length} cells updated in last hour`);
+    }
+
+    // LOW: Any cells exist at all
+    if (cells.length > 0) {
+      lowConfidence = true;
+      reasons.push(`${cells.length} total cells in hive`);
+    }
   } catch {
-    return false;
+    // Detection failed, use fallback
+    lowConfidence = true;
+    reasons.push("Detection error, using fallback");
   }
+
+  // Determine overall confidence
+  let confidence: "high" | "medium" | "low" | "none";
+  if (highConfidence) {
+    confidence = "high";
+  } else if (mediumConfidence) {
+    confidence = "medium";
+  } else if (lowConfidence) {
+    confidence = "low";
+  } else {
+    confidence = "none";
+  }
+
+  return {
+    detected: confidence !== "none",
+    confidence,
+    reasons,
+  };
 }
 
 /**
@@ -992,6 +1072,47 @@ Extract from session context:
 **You are not waiting for instructions. You are the coordinator. Coordinate.**
 `;
 
+/**
+ * Fallback detection prompt - tells the compactor what to look for
+ * 
+ * Used when we can't definitively detect a swarm but want to be safe.
+ * The compactor can check the conversation context for these patterns.
+ */
+const SWARM_DETECTION_FALLBACK = `## 🐝 Swarm Detection - Check Your Context
+
+**IMPORTANT:** Before summarizing, check if this session involves an active swarm.
+
+Look for ANY of these patterns in the conversation:
+
+### Tool Calls (definite swarm sign)
+- \`swarm_decompose\`, \`swarm_spawn_subtask\`, \`swarm_status\`, \`swarm_complete\`
+- \`swarmmail_init\`, \`swarmmail_reserve\`, \`swarmmail_send\`
+- \`hive_create_epic\`, \`hive_start\`, \`hive_close\`
+
+### IDs and Names
+- Cell IDs: \`bd-xxx\`, \`bd-xxx.N\` (subtask format)
+- Agent names: BlueLake, RedMountain, GreenValley, etc.
+- Epic references: "epic", "subtask", "parent"
+
+### Coordination Language
+- "spawn", "worker", "coordinator"
+- "reserve", "reservation", "files"
+- "blocked", "unblock", "dependency"
+- "progress", "complete", "in_progress"
+
+### If You Find Swarm Evidence
+
+Include this in your summary:
+1. Epic ID and title
+2. Project path
+3. Subtask status (running/blocked/done/pending)
+4. Any blockers or issues
+5. What should happen next
+
+**Then tell the resumed session:**
+"This is an active swarm. Check swarm_status and swarmmail_inbox immediately."
+`;
+
 // Extended hooks type to include experimental compaction hook
 type ExtendedHooks = Hooks & {
   "experimental.session.compacting"?: (
@@ -1065,15 +1186,23 @@ export const SwarmPlugin: Plugin = async (
       skills_execute,
     },
 
-    // Swarm-aware compaction hook - only fires if there's an active swarm
+    // Swarm-aware compaction hook - injects context based on detection confidence
     "experimental.session.compacting": async (
       _input: { sessionID: string },
       output: { context: string[] },
     ) => {
-      const hasSign = await hasSwarmSign();
-      if (hasSign) {
-        output.context.push(SWARM_COMPACTION_CONTEXT);
+      const detection = await detectSwarm();
+
+      if (detection.confidence === "high" || detection.confidence === "medium") {
+        // Definite or probable swarm - inject full context
+        const header = `[Swarm detected: ${detection.reasons.join(", ")}]\n\n`;
+        output.context.push(header + SWARM_COMPACTION_CONTEXT);
+      } else if (detection.confidence === "low") {
+        // Possible swarm - inject fallback detection prompt
+        const header = `[Possible swarm: ${detection.reasons.join(", ")}]\n\n`;
+        output.context.push(header + SWARM_DETECTION_FALLBACK);
       }
+      // confidence === "none" - no injection, probably not a swarm
     },
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.29.0",
+  "version": "0.30.2",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",
@@ -32,8 +32,10 @@
   "dependencies": {
     "@clack/prompts": "^0.11.0",
     "@opencode-ai/plugin": "^1.0.134",
+    "effect": "^3.19.12",
     "gray-matter": "^4.0.3",
     "ioredis": "^5.4.1",
+    "minimatch": "^10.1.1",
     "swarm-mail": "0.4.0",
     "zod": "4.1.8"
   },

package/src/hive.integration.test.ts

@@ -16,9 +16,11 @@ import {
   hive_start,
   hive_ready,
   hive_link_thread,
+  hive_sync,
   HiveError,
   getHiveAdapter,
   setHiveWorkingDirectory,
+  getHiveWorkingDirectory,
   // Legacy aliases for backward compatibility tests
   beads_link_thread,
   BeadError,
@@ -1120,6 +1122,118 @@ describe("beads integration", () => {
     });
   });
 
+  describe("hive_sync", () => {
+    it("commits .hive changes before pulling (regression test for unstaged changes error)", async () => {
+      const { mkdirSync, rmSync, writeFileSync, existsSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+      const { execSync } = await import("node:child_process");
+
+      // Create a temp git repository
+      const tempProject = join(tmpdir(), `hive-sync-test-${Date.now()}`);
+      mkdirSync(tempProject, { recursive: true });
+
+      // Initialize git repo
+      execSync("git init", { cwd: tempProject });
+      execSync('git config user.email "test@example.com"', { cwd: tempProject });
+      execSync('git config user.name "Test User"', { cwd: tempProject });
+
+      // Create .hive directory and issues.jsonl
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      const issuesPath = join(hiveDir, "issues.jsonl");
+      writeFileSync(issuesPath, "");
+
+      // Initial commit
+      execSync("git add .", { cwd: tempProject });
+      execSync('git commit -m "initial commit"', { cwd: tempProject });
+
+      // Set working directory for hive commands
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create a cell (this will mark it dirty and flush will write to JSONL)
+        await hive_create.execute(
+          { title: "Sync test cell", type: "task" },
+          mockContext,
+        );
+
+        // Sync with auto_pull=false (skip pull since no remote configured)
+        const result = await hive_sync.execute(
+          { auto_pull: false },
+          mockContext,
+        );
+
+        // Should succeed
+        expect(result).toContain("successfully");
+
+        // Verify .hive changes were committed (working tree should be clean)
+        const status = execSync("git status --porcelain", {
+          cwd: tempProject,
+          encoding: "utf-8",
+        });
+        expect(status.trim()).toBe("");
+
+        // Verify commit exists
+        const log = execSync("git log --oneline", {
+          cwd: tempProject,
+          encoding: "utf-8",
+        });
+        expect(log).toContain("chore: sync hive");
+      } finally {
+        // Restore original working directory
+        setHiveWorkingDirectory(originalDir);
+
+        // Cleanup
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+
+    it("handles case with no changes to commit", async () => {
+      const { mkdirSync, rmSync, writeFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+      const { execSync } = await import("node:child_process");
+
+      // Create temp git repo
+      const tempProject = join(tmpdir(), `hive-sync-test-${Date.now()}`);
+      mkdirSync(tempProject, { recursive: true });
+
+      // Initialize git
+      execSync("git init", { cwd: tempProject });
+      execSync('git config user.email "test@example.com"', { cwd: tempProject });
+      execSync('git config user.name "Test User"', { cwd: tempProject });
+
+      // Create .hive directory with committed issues.jsonl
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      writeFileSync(join(hiveDir, "issues.jsonl"), "");
+
+      // Commit everything
+      execSync("git add .", { cwd: tempProject });
+      execSync('git commit -m "initial"', { cwd: tempProject });
+
+      // Set working directory
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Sync with no changes (should handle gracefully)
+        const result = await hive_sync.execute(
+          { auto_pull: false },
+          mockContext,
+        );
+
+        // Should return "No cells to sync" since no dirty cells
+        expect(result).toContain("No cells to sync");
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+  });
+
   describe("mergeHistoricBeads", () => {
     it("merges empty base file - no changes", async () => {
       const { mergeHistoricBeads } = await import("./hive");

package/src/hive.ts

@@ -1053,38 +1053,49 @@ export const hive_sync = tool({
       }
     }
 
-    // 6. Pull if requested
+    // 6. Pull if requested (check if remote exists first)
     if (autoPull) {
-      const pullResult = await withTimeout(
-        runGitCommand(["pull", "--rebase"]),
-        TIMEOUT_MS,
-        "git pull --rebase",
-      );
+      const remoteCheckResult = await runGitCommand(["remote"]);
+      const hasRemote = remoteCheckResult.stdout.trim() !== "";
 
-      if (pullResult.exitCode !== 0) {
-        throw new HiveError(
-          `Failed to pull: ${pullResult.stderr}`,
+      if (hasRemote) {
+        const pullResult = await withTimeout(
+          runGitCommand(["pull", "--rebase"]),
+          TIMEOUT_MS,
           "git pull --rebase",
-          pullResult.exitCode,
         );
+
+        if (pullResult.exitCode !== 0) {
+          throw new HiveError(
+            `Failed to pull: ${pullResult.stderr}`,
+            "git pull --rebase",
+            pullResult.exitCode,
+          );
+        }
       }
     }
 
-    // 7. Push
-    const pushResult = await withTimeout(
-      runGitCommand(["push"]),
-      TIMEOUT_MS,
-      "git push",
-    );
-    if (pushResult.exitCode !== 0) {
-      throw new HiveError(
-        `Failed to push: ${pushResult.stderr}`,
+    // 7. Push (check if remote exists first)
+    const remoteCheckResult = await runGitCommand(["remote"]);
+    const hasRemote = remoteCheckResult.stdout.trim() !== "";
+
+    if (hasRemote) {
+      const pushResult = await withTimeout(
+        runGitCommand(["push"]),
+        TIMEOUT_MS,
         "git push",
-        pushResult.exitCode,
       );
+      if (pushResult.exitCode !== 0) {
+        throw new HiveError(
+          `Failed to push: ${pushResult.stderr}`,
+          "git push",
+          pushResult.exitCode,
+        );
+      }
+      return "Hive synced and pushed successfully";
+    } else {
+      return "Hive synced successfully (no remote configured)";
     }
-
-    return "Hive synced and pushed successfully";
   },
 });
 

package/src/index.ts

@@ -46,6 +46,7 @@ import { reviewTools } from "./swarm-review";
 import { repoCrawlTools } from "./repo-crawl";
 import { skillsTools, setSkillsProjectDirectory } from "./skills";
 import { mandateTools } from "./mandates";
+import { memoryTools } from "./memory-tools";
 import {
   guardrailOutput,
   DEFAULT_GUARDRAIL_CONFIG,
@@ -69,6 +70,7 @@ import {
  * - repo-crawl:* - GitHub API tools for repository research
  * - skills:* - Agent skills discovery, activation, and execution
  * - mandate:* - Agent voting system for collaborative knowledge curation
+ * - semantic-memory:* - Semantic memory with vector embeddings (Ollama + PGLite)
  *
  * @param input - Plugin context from OpenCode
  * @returns Plugin hooks including tools, events, and tool execution hooks
@@ -148,9 +150,10 @@ export const SwarmPlugin: Plugin = async (
      * - beads:* - Legacy aliases (deprecated, use hive:* instead)
      * - agent-mail:init, agent-mail:send, agent-mail:reserve, etc. (legacy MCP)
      * - swarm-mail:init, swarm-mail:send, swarm-mail:reserve, etc. (embedded)
-     * - repo-crawl:readme, repo-crawl:structure, etc.
-     * - mandate:file, mandate:vote, mandate:query, etc.
-     */
+ * - repo-crawl:readme, repo-crawl:structure, etc.
+ * - mandate:file, mandate:vote, mandate:query, etc.
+ * - semantic-memory:store, semantic-memory:find, semantic-memory:get, etc.
+ */
     tool: {
       ...hiveTools,
       ...swarmMailTools,
@@ -161,6 +164,7 @@ export const SwarmPlugin: Plugin = async (
       ...repoCrawlTools,
       ...skillsTools,
       ...mandateTools,
+      ...memoryTools,
     },
 
     /**
@@ -249,11 +253,9 @@ export const SwarmPlugin: Plugin = async (
         await releaseReservations();
       }
 
-      // Auto-sync hive after closing (supports both hive_close and legacy hive_close)
-      if (toolName === "hive_close" || toolName === "hive_close") {
-        // Trigger async sync without blocking - fire and forget
-        void $`bd sync`.quiet().nothrow();
-      }
+      // Note: hive_sync should be called explicitly at session end
+      // Auto-sync was removed because bd CLI is deprecated
+      // The hive_sync tool handles flushing to JSONL and git commit/push
     },
   };
 };
@@ -419,6 +421,7 @@ export const allTools = {
   ...repoCrawlTools,
   ...skillsTools,
   ...mandateTools,
+  ...memoryTools,
 } as const;
 
 /**
@@ -646,3 +649,33 @@ export {
  * ```
  */
 export { SWARM_COMPACTION_CONTEXT, createCompactionHook } from "./compaction-hook";
+
+/**
+ * Re-export memory module
+ *
+ * Includes:
+ * - memoryTools - All semantic-memory tools (store, find, get, remove, validate, list, stats, check)
+ * - createMemoryAdapter - Factory function for memory adapter
+ * - resetMemoryCache - Cache management for testing
+ *
+ * Types:
+ * - MemoryAdapter - Memory adapter interface
+ * - StoreArgs, FindArgs, IdArgs, ListArgs - Tool argument types
+ * - StoreResult, FindResult, StatsResult, HealthResult, OperationResult - Result types
+ */
+export {
+  memoryTools,
+  createMemoryAdapter,
+  resetMemoryCache,
+  type MemoryAdapter,
+  type StoreArgs,
+  type FindArgs,
+  type IdArgs,
+  type ListArgs,
+  type StoreResult,
+  type FindResult,
+  type StatsResult,
+  type HealthResult,
+  type OperationResult,
+} from "./memory-tools";
+export type { Memory, SearchResult, SearchOptions } from "swarm-mail";

package/src/memory-tools.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Memory Tools Integration Tests
+ *
+ * Tests for semantic-memory_* tool registration and execution.
+ */
+
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { memoryTools, resetMemoryCache } from "./memory-tools";
+import { closeAllSwarmMail } from "swarm-mail";
+
+describe("memory tools integration", () => {
+	afterAll(async () => {
+		resetMemoryCache();
+		await closeAllSwarmMail();
+	});
+
+	test("all tools are registered with correct names", () => {
+		const toolNames = Object.keys(memoryTools);
+		expect(toolNames).toContain("semantic-memory_store");
+		expect(toolNames).toContain("semantic-memory_find");
+		expect(toolNames).toContain("semantic-memory_get");
+		expect(toolNames).toContain("semantic-memory_remove");
+		expect(toolNames).toContain("semantic-memory_validate");
+		expect(toolNames).toContain("semantic-memory_list");
+		expect(toolNames).toContain("semantic-memory_stats");
+		expect(toolNames).toContain("semantic-memory_check");
+	});
+
+	test("tools have execute functions", () => {
+		for (const [name, tool] of Object.entries(memoryTools)) {
+			expect(typeof tool.execute).toBe("function");
+		}
+	});
+
+	describe("semantic-memory_store", () => {
+		test("executes and returns JSON", async () => {
+			const tool = memoryTools["semantic-memory_store"];
+			const result = await tool.execute(
+				{
+					information: "Test memory for tools integration",
+					tags: "test",
+				},
+				{ sessionID: "test-session" } as any,
+			);
+
+			expect(typeof result).toBe("string");
+			const parsed = JSON.parse(result);
+			expect(parsed.id).toBeDefined();
+			expect(parsed.id).toMatch(/^mem_/);
+			expect(parsed.message).toContain("Stored memory");
+		});
+	});
+
+	describe("semantic-memory_find", () => {
+		test("executes and returns JSON array", async () => {
+			// Store a memory first
+			const storeTool = memoryTools["semantic-memory_store"];
+			await storeTool.execute(
+				{
+					information: "Findable test memory with unique keyword xyztest123",
+				},
+				{ sessionID: "test-session" } as any,
+			);
+
+			// Search for it
+			const findTool = memoryTools["semantic-memory_find"];
+			const result = await findTool.execute(
+				{
+					query: "xyztest123",
+					limit: 5,
+				},
+				{ sessionID: "test-session" } as any,
+			);
+
+			expect(typeof result).toBe("string");
+			const parsed = JSON.parse(result);
+			expect(parsed.results).toBeDefined();
+			expect(Array.isArray(parsed.results)).toBe(true);
+			expect(parsed.count).toBeGreaterThanOrEqual(0);
+		});
+	});
+
+	describe("semantic-memory_stats", () => {
+		test("returns memory and embedding counts", async () => {
+			const tool = memoryTools["semantic-memory_stats"];
+			const result = await tool.execute(
+				{},
+				{ sessionID: "test-session" } as any,
+			);
+
+			expect(typeof result).toBe("string");
+			const parsed = JSON.parse(result);
+			expect(typeof parsed.memories).toBe("number");
+			expect(typeof parsed.embeddings).toBe("number");
+		});
+	});
+
+	describe("semantic-memory_check", () => {
+		test("checks Ollama health", async () => {
+			const tool = memoryTools["semantic-memory_check"];
+			const result = await tool.execute(
+				{},
+				{ sessionID: "test-session" } as any,
+			);
+
+			expect(typeof result).toBe("string");
+			const parsed = JSON.parse(result);
+			expect(typeof parsed.ollama).toBe("boolean");
+		});
+	});
+});