opencode-swarm-plugin 0.30.5 → 0.30.7

package/src/swarm-prompts.test.ts

@@ -0,0 +1,176 @@
+/**
+ * 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();
+      if (!lastStepMatch) return;
+      
+      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();
+      if (!criticalSection) return;
+      
+      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();
+      if (!criticalSection) return;
+      
+      // 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-project-abc123-bead456",
+      epic_id: "test-project-abc123-epic789",
+      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-project-abc123-bead456");
+    expect(result).toContain("test-project-abc123-epic789");
+    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-project-abc123-def456",
+      epic_id: "test-project-abc123-ghi789",
+      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"
 
-**Past learnings save time and prevent repeating mistakes.**
+**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
+
+**If you skip this step, you WILL waste time solving already-solved problems.**
 
 ### Step 3: Load Relevant Skills (if available)
 \`\`\`
@@ -388,21 +406,44 @@ swarm_checkpoint(
 
 **Checkpoints preserve context so you can recover if things go wrong.**
 
-### Step 8: Store Learnings (if you discovered something)
+### Step 8: 💾 STORE YOUR LEARNINGS (if you discovered something)
+
+**If you learned it the hard way, STORE IT so the next agent doesn't have to.**
+
 \`\`\`
 semantic-memory_store(
   information="<what you learned, WHY it matters, how to apply it>",
-  metadata="<tags: domain, tech-stack, pattern-type>"
+  tags="<domain, tech-stack, pattern-type>"
 )
 \`\`\`
 
-**Store:**
-- Tricky bugs you solved (root cause + solution)
-- Project-specific patterns or domain rules
-- Tool/library gotchas and workarounds
-- Failed approaches (anti-patterns to avoid)
+**MANDATORY Storage Triggers - Store when you:**
+- 🐛 **Solved a tricky bug** (>15min debugging) - include root cause + solution
+- 💡 **Discovered a project-specific pattern** - domain rules, business logic quirks
+- ⚠️ **Found a tool/library gotcha** - API quirks, version-specific bugs, workarounds
+- 🚫 **Tried an approach that failed** - anti-patterns to avoid, why it didn't work
+- 🏗️ **Made an architectural decision** - reasoning, alternatives considered, tradeoffs
+
+**What Makes a GOOD Memory:**
+
+✅ **GOOD** (actionable, explains WHY):
+\`\`\`
+"OAuth refresh tokens need 5min buffer before expiry to avoid race conditions.
+Without buffer, token refresh can fail mid-request if expiry happens between
+check and use. Implemented with: if (expiresAt - Date.now() < 300000) refresh()"
+\`\`\`
+
+❌ **BAD** (generic, no context):
+\`\`\`
+"Fixed the auth bug by adding a null check"
+\`\`\`
 
-**Don't store generic knowledge.** Store the WHY, not just the WHAT.
+**What NOT to Store:**
+- Generic knowledge that's in official documentation
+- Implementation details that change frequently
+- Vague descriptions without context ("fixed the thing")
+
+**The WHY matters more than the WHAT.** Future agents need context to apply your learning.
 
 ### Step 9: Complete (REQUIRED - releases reservations)
 \`\`\`
@@ -493,17 +534,20 @@ Other cell operations:
 
 **NON-NEGOTIABLE:**
 1. Step 1 (swarmmail_init) MUST be first - do it before anything else
-2. Step 2 (semantic-memory_find) MUST happen before starting work
+2. 🧠 Step 2 (semantic-memory_find) MUST happen BEFORE starting work - query first, code second
 3. Step 4 (swarmmail_reserve) - YOU reserve files, not coordinator
 4. Step 6 (swarm_progress) - Report at milestones, don't work silently
-5. Step 9 (swarm_complete) - Use this to close, NOT hive_close
+5. 💾 Step 8 (semantic-memory_store) - If you learned something hard, STORE IT
+6. Step 9 (swarm_complete) - Use this to close, NOT hive_close
 
 **If you skip these steps:**
 - Your work won't be tracked (swarm_complete will fail)
-- You'll waste time repeating solved problems (no semantic memory query)
+- 🔄 You'll waste time repeating already-solved problems (no semantic memory query)
 - Edit conflicts with other agents (no file reservation)
 - Lost work if you crash (no checkpoints)
-- Future agents repeat your mistakes (no learnings stored)
+- 🔄 Future agents repeat YOUR mistakes (no learnings stored)
+
+**Memory is the swarm's collective intelligence. Query it. Feed it.**
 
 Begin now.`;
 

package/src/swarm.integration.test.ts

@@ -1426,7 +1426,7 @@ describe("Swarm Prompt V2 (with Swarm Mail/Beads)", () => {
       expect(SUBTASK_PROMPT_V2).toContain("semantic-memory_find");
       expect(SUBTASK_PROMPT_V2).toContain("Query Past Learnings");
       expect(SUBTASK_PROMPT_V2).toContain("BEFORE starting work");
-      expect(SUBTASK_PROMPT_V2).toContain("Past learnings save time");
+      expect(SUBTASK_PROMPT_V2).toContain("If you skip this step, you WILL waste time solving already-solved problems");
     });
 
     it("contains survival checklist: skills discovery and loading", () => {
@@ -1465,9 +1465,9 @@ describe("Swarm Prompt V2 (with Swarm Mail/Beads)", () => {
     it("contains survival checklist: semantic-memory_store for learnings", () => {
       // Step 8: Store discoveries and learnings
       expect(SUBTASK_PROMPT_V2).toContain("semantic-memory_store");
-      expect(SUBTASK_PROMPT_V2).toContain("Store Learnings");
-      expect(SUBTASK_PROMPT_V2).toContain("Tricky bugs you solved");
-      expect(SUBTASK_PROMPT_V2).toContain("Store the WHY, not just the WHAT");
+      expect(SUBTASK_PROMPT_V2).toContain("STORE YOUR LEARNINGS");
+      expect(SUBTASK_PROMPT_V2).toContain("Solved a tricky bug");
+      expect(SUBTASK_PROMPT_V2).toContain("The WHY matters more than the WHAT");
     });
 
     it("does NOT mention coordinator reserving files", () => {