opencode-swarm-plugin 0.30.5 → 0.30.6

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # opencode-swarm-plugin
 
+## 0.30.6
+
+### Patch Changes
+
+- [`32a2885`](https://github.com/joelhooks/swarm-tools/commit/32a2885115cc3e574e86d8e492f60ee189627488) Thanks [@joelhooks](https://github.com/joelhooks)! - chore: verify CI publish flow works
+
 ## 0.30.5
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.30.5",
+  "version": "0.30.6",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",

package/src/swarm-prompts.test.ts

@@ -0,0 +1,173 @@
+/**
+ * Tests for swarm-prompts.ts
+ *
+ * Validates that prompt templates contain required sections and emphasis
+ * for memory usage, coordination, and TDD workflow.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  formatSubtaskPromptV2,
+  SUBTASK_PROMPT_V2,
+} from "./swarm-prompts";
+
+describe("SUBTASK_PROMPT_V2", () => {
+  describe("memory query emphasis", () => {
+    test("Step 2 is semantic-memory_find and marked MANDATORY", () => {
+      expect(SUBTASK_PROMPT_V2).toContain("### Step 2:");
+      expect(SUBTASK_PROMPT_V2).toContain("semantic-memory_find");
+      // Must have MANDATORY in the step header
+      expect(SUBTASK_PROMPT_V2).toMatch(/### Step 2:.*MANDATORY/i);
+    });
+
+    test("memory query step has visual emphasis (emoji or caps)", () => {
+      // Should have emoji or CRITICAL/ALWAYS in caps
+      const step2Match = SUBTASK_PROMPT_V2.match(/### Step 2:[\s\S]*?### Step 3:/);
+      expect(step2Match).not.toBeNull();
+      if (!step2Match) return;
+      const step2Content = step2Match[0];
+      
+      // Must have at least one of: emoji, CRITICAL, ALWAYS, MANDATORY
+      const hasEmphasis = 
+        /🧠|⚠️|CRITICAL|ALWAYS|MANDATORY/.test(step2Content);
+      expect(hasEmphasis).toBe(true);
+    });
+
+    test("memory query step includes query examples by task type", () => {
+      const step2Match = SUBTASK_PROMPT_V2.match(/### Step 2:[\s\S]*?### Step 3:/);
+      expect(step2Match).not.toBeNull();
+      if (!step2Match) return;
+      const step2Content = step2Match[0];
+      
+      // Should have examples for different task types
+      expect(step2Content).toContain("Bug fix");
+      expect(step2Content).toContain("New feature");
+      expect(step2Content).toContain("Refactor");
+    });
+
+    test("memory query step explains WHY it's mandatory", () => {
+      const step2Match = SUBTASK_PROMPT_V2.match(/### Step 2:[\s\S]*?### Step 3:/);
+      expect(step2Match).not.toBeNull();
+      if (!step2Match) return;
+      const step2Content = step2Match[0];
+      
+      // Should explain consequences of skipping
+      expect(step2Content).toMatch(/skip|waste|repeat|already.solved/i);
+    });
+  });
+
+  describe("memory storage emphasis", () => {
+    test("has a dedicated section for storing learnings", () => {
+      // Should have a prominent section about storing memories
+      expect(SUBTASK_PROMPT_V2).toMatch(/##.*STORE.*LEARNING|### Step.*Store.*Learning/i);
+    });
+
+    test("storage section lists triggers for when to store", () => {
+      // Should mention triggers: bugs, gotchas, patterns, failed approaches
+      expect(SUBTASK_PROMPT_V2).toContain("bug");
+      expect(SUBTASK_PROMPT_V2).toMatch(/gotcha|quirk|workaround/i);
+      expect(SUBTASK_PROMPT_V2).toMatch(/pattern|domain/i);
+    });
+
+    test("storage section emphasizes WHY not just WHAT", () => {
+      expect(SUBTASK_PROMPT_V2).toMatch(/WHY.*not.*WHAT|why.*matters/i);
+    });
+
+    test("storage section warns against generic knowledge", () => {
+      expect(SUBTASK_PROMPT_V2).toMatch(/don't store.*generic|generic knowledge/i);
+    });
+  });
+
+  describe("checklist order", () => {
+    test("Step 1 is swarmmail_init", () => {
+      expect(SUBTASK_PROMPT_V2).toMatch(/### Step 1:[\s\S]*?swarmmail_init/);
+    });
+
+    test("Step 2 is semantic-memory_find (before skills)", () => {
+      const step2Pos = SUBTASK_PROMPT_V2.indexOf("### Step 2:");
+      const step3Pos = SUBTASK_PROMPT_V2.indexOf("### Step 3:");
+      const memoryFindPos = SUBTASK_PROMPT_V2.indexOf("semantic-memory_find");
+      const skillsPos = SUBTASK_PROMPT_V2.indexOf("skills_list");
+      
+      // Memory find should be in Step 2, before skills in Step 3
+      expect(memoryFindPos).toBeGreaterThan(step2Pos);
+      expect(memoryFindPos).toBeLessThan(step3Pos);
+      expect(skillsPos).toBeGreaterThan(step3Pos);
+    });
+
+    test("semantic-memory_store comes before swarm_complete", () => {
+      const storePos = SUBTASK_PROMPT_V2.indexOf("semantic-memory_store");
+      const completePos = SUBTASK_PROMPT_V2.lastIndexOf("swarm_complete");
+      
+      expect(storePos).toBeGreaterThan(0);
+      expect(storePos).toBeLessThan(completePos);
+    });
+
+    test("final step is swarm_complete (not hive_close)", () => {
+      // Find the last "### Step N:" pattern
+      const stepMatches = [...SUBTASK_PROMPT_V2.matchAll(/### Step (\d+):/g)];
+      expect(stepMatches.length).toBeGreaterThan(0);
+      
+      const lastStepNum = Math.max(...stepMatches.map(m => parseInt(m[1])));
+      const lastStepMatch = SUBTASK_PROMPT_V2.match(
+        new RegExp(`### Step ${lastStepNum}:[\\s\\S]*?(?=## \\[|$)`)
+      );
+      expect(lastStepMatch).not.toBeNull();
+      
+      const lastStepContent = lastStepMatch![0];
+      expect(lastStepContent).toContain("swarm_complete");
+      expect(lastStepContent).toMatch(/NOT.*hive_close|DO NOT.*hive_close/i);
+    });
+  });
+
+  describe("critical requirements section", () => {
+    test("lists memory query as non-negotiable", () => {
+      const criticalSection = SUBTASK_PROMPT_V2.match(/\[CRITICAL REQUIREMENTS\][\s\S]*?Begin now/);
+      expect(criticalSection).not.toBeNull();
+      
+      expect(criticalSection![0]).toMatch(/semantic-memory_find|memory.*MUST|Step 2.*MUST/i);
+    });
+
+    test("lists consequences of skipping memory steps", () => {
+      const criticalSection = SUBTASK_PROMPT_V2.match(/\[CRITICAL REQUIREMENTS\][\s\S]*?Begin now/);
+      expect(criticalSection).not.toBeNull();
+      
+      // Should mention consequences for skipping memory
+      expect(criticalSection![0]).toMatch(/repeat|waste|already.solved|mistakes/i);
+    });
+  });
+});
+
+describe("formatSubtaskPromptV2", () => {
+  test("substitutes all placeholders correctly", () => {
+    const result = formatSubtaskPromptV2({
+      bead_id: "test-bead-123",
+      epic_id: "test-epic-456",
+      subtask_title: "Test Subtask",
+      subtask_description: "Do the test thing",
+      files: ["src/test.ts", "src/test.test.ts"],
+      shared_context: "This is shared context",
+      project_path: "/path/to/project",
+    });
+
+    expect(result).toContain("test-bead-123");
+    expect(result).toContain("test-epic-456");
+    expect(result).toContain("Test Subtask");
+    expect(result).toContain("Do the test thing");
+    expect(result).toContain("src/test.ts");
+    expect(result).toContain("/path/to/project");
+  });
+
+  test("includes memory query step with MANDATORY emphasis", () => {
+    const result = formatSubtaskPromptV2({
+      bead_id: "test-bead",
+      epic_id: "test-epic",
+      subtask_title: "Test",
+      subtask_description: "",
+      files: [],
+    });
+
+    expect(result).toMatch(/Step 2:.*MANDATORY/i);
+    expect(result).toContain("semantic-memory_find");
+  });
+});

package/src/swarm-prompts.ts

@@ -291,18 +291,36 @@ swarmmail_init(project_path="{project_path}", task_description="{bead_id}: {subt
 
 **If you skip this step, your work will not be tracked and swarm_complete will fail.**
 
-### Step 2: Query Past Learnings (BEFORE starting work)
+### Step 2: 🧠 Query Past Learnings (MANDATORY - BEFORE starting work)
+
+**⚠️ CRITICAL: ALWAYS query semantic memory BEFORE writing ANY code.**
+
 \`\`\`
-semantic-memory_find(query="<keywords from your task>", limit=5)
+semantic-memory_find(query="<keywords from your task>", limit=5, expand=true)
 \`\`\`
 
-**Check if past agents solved similar problems.** Search for:
-- Error messages if debugging
-- Domain concepts (e.g., "authentication", "caching")
-- Technology stack (e.g., "Next.js", "React")
-- Patterns (e.g., "event sourcing", "validation")
+**Why this is MANDATORY:**
+- Past agents may have already solved your exact problem
+- Avoids repeating mistakes that wasted 30+ minutes before
+- Discovers project-specific patterns and gotchas
+- Finds known workarounds for tool/library quirks
+
+**Search Query Examples by Task Type:**
+
+- **Bug fix**: Use exact error message or "<symptom> <component>"
+- **New feature**: Search "<domain concept> implementation pattern"
+- **Refactor**: Query "<pattern name> migration approach"
+- **Integration**: Look for "<library name> gotchas configuration"
+- **Testing**: Find "testing <component type> characterization tests"
+- **Performance**: Search "<technology> performance optimization"
+
+**BEFORE you start coding:**
+1. Run semantic-memory_find with keywords from your task
+2. Read the results with expand=true for full content
+3. Check if any memory solves your problem or warns of pitfalls
+4. Adjust your approach based on past learnings
 
-**Past learnings save time and prevent repeating mistakes.**
+**If you skip this step, you WILL waste time solving already-solved problems.**
 
 ### Step 3: Load Relevant Skills (if available)
 \`\`\`