opencode-swarm-plugin 0.37.0 → 0.39.1

package/src/compaction-hook.test.ts

@@ -64,7 +64,7 @@ describe("Compaction Hook", () => {
   describe("SWARM_COMPACTION_CONTEXT", () => {
     it("contains coordinator instructions", () => {
       expect(SWARM_COMPACTION_CONTEXT).toContain("COORDINATOR");
-      expect(SWARM_COMPACTION_CONTEXT).toContain("You Are The COORDINATOR");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("YOU ARE THE COORDINATOR");
     });
 
     it("contains prohibition-first anti-patterns", () => {
@@ -85,6 +85,48 @@ describe("Compaction Hook", () => {
       expect(SWARM_COMPACTION_CONTEXT).toContain("Blocked:");
       expect(SWARM_COMPACTION_CONTEXT).toContain("Completed:");
     });
+
+    // NEW: Full coordinator workflow must be present post-compaction
+    it("contains FULL coordinator workflow phases", () => {
+      // Phase 1.5: Research Phase
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_spawn_researcher");
+      
+      // Phase 3: Decompose
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_select_strategy");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_plan_prompt");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_validate_decomposition");
+      
+      // Phase 4: Create Cells
+      expect(SWARM_COMPACTION_CONTEXT).toContain("hive_create_epic");
+      
+      // Phase 6: Spawn Workers
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_spawn_subtask");
+      
+      // Phase 7: Review Loop
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_review");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_review_feedback");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_spawn_retry");
+    });
+
+    it("contains forbidden tools section with ALL forbidden tools", () => {
+      // Repository fetching
+      expect(SWARM_COMPACTION_CONTEXT).toContain("repo-crawl_file");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("repo-autopsy");
+      
+      // Web/documentation fetching
+      expect(SWARM_COMPACTION_CONTEXT).toContain("webfetch");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("fetch_fetch");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("context7");
+      
+      // Knowledge base
+      expect(SWARM_COMPACTION_CONTEXT).toContain("pdf-brain");
+    });
+
+    it("contains strategy reference table", () => {
+      expect(SWARM_COMPACTION_CONTEXT).toContain("file-based");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("feature-based");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("risk-based");
+    });
   });
 
   describe("SWARM_DETECTION_FALLBACK", () => {
@@ -136,7 +178,7 @@ describe("Compaction Hook", () => {
     it("HIGH confidence triggers full context", async () => {
       // This would need proper mocking of active reservations
       // For now, just verify the context strings exist
-      expect(SWARM_COMPACTION_CONTEXT).toContain("SWARM ACTIVE");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("YOU ARE THE COORDINATOR");
     });
 
     it("LOW confidence triggers fallback prompt", async () => {
@@ -145,6 +187,101 @@ describe("Compaction Hook", () => {
     });
   });
 
+  describe("Forbidden tools anti-pattern (TDD red phase)", () => {
+    it("SWARM_COMPACTION_CONTEXT includes 'NEVER fetch directly' rule", () => {
+      // Should warn against direct fetching
+      expect(SWARM_COMPACTION_CONTEXT).toContain("NEVER");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("repo-crawl");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("webfetch");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("fetch_fetch");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("context7");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("pdf-brain");
+    });
+
+    it("SWARM_COMPACTION_CONTEXT instructs to spawn researcher instead", () => {
+      expect(SWARM_COMPACTION_CONTEXT).toContain("SPAWN A RESEARCHER");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_spawn_researcher");
+    });
+
+    it("lists all forbidden repo-crawl tools", () => {
+      const forbiddenTools = [
+        "repo-crawl_file",
+        "repo-crawl_readme", 
+        "repo-crawl_search",
+        "repo-crawl_structure",
+        "repo-crawl_tree"
+      ];
+      
+      for (const tool of forbiddenTools) {
+        expect(SWARM_COMPACTION_CONTEXT).toContain(tool);
+      }
+    });
+
+    it("lists all forbidden repo-autopsy tools", () => {
+      expect(SWARM_COMPACTION_CONTEXT).toContain("repo-autopsy");
+    });
+
+    it("lists all forbidden context7 tools", () => {
+      const forbiddenTools = [
+        "context7_resolve-library-id",
+        "context7_get-library-docs"
+      ];
+      
+      for (const tool of forbiddenTools) {
+        expect(SWARM_COMPACTION_CONTEXT).toContain(tool);
+      }
+    });
+
+    it("lists all forbidden pdf-brain tools", () => {
+      const forbiddenTools = [
+        "pdf-brain_search",
+        "pdf-brain_read"
+      ];
+      
+      for (const tool of forbiddenTools) {
+        expect(SWARM_COMPACTION_CONTEXT).toContain(tool);
+      }
+    });
+  });
+
+  describe("Coordinator identity reinforcement (TDD red phase)", () => {
+    it("includes ASCII header for coordinator identity", () => {
+      // Should have prominent visual indicator
+      expect(SWARM_COMPACTION_CONTEXT).toMatch(/[╔═╗║╚╝]|[┌─┐│└┘]|[█▀▄]/);
+    });
+
+    it("repeats 'YOU ARE THE COORDINATOR' multiple times", () => {
+      const matches = SWARM_COMPACTION_CONTEXT.match(/YOU ARE THE COORDINATOR/gi);
+      expect(matches).toBeDefined();
+      expect(matches!.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it("uses strong imperative language NEVER/ALWAYS/NON-NEGOTIABLE", () => {
+      expect(SWARM_COMPACTION_CONTEXT).toContain("NEVER");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("ALWAYS");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("NON-NEGOTIABLE");
+    });
+
+    it("makes role unmistakable with multiple strong statements", () => {
+      // Check for strong coordinator identity statements
+      const identityPatterns = [
+        /YOU ARE THE COORDINATOR/i,
+        /NOT A WORKER/i,
+        /ORCHESTRATE/i,
+        /DO NOT IMPLEMENT/i
+      ];
+
+      let matchCount = 0;
+      for (const pattern of identityPatterns) {
+        if (pattern.test(SWARM_COMPACTION_CONTEXT)) {
+          matchCount++;
+        }
+      }
+
+      expect(matchCount).toBeGreaterThanOrEqual(3);
+    });
+  });
+
   describe("Specific swarm state injection (TDD red phase)", () => {
     it("includes specific epic ID when in_progress epic exists", async () => {
       // Mock hive with an in_progress epic

package/src/compaction-hook.ts

@@ -68,9 +68,21 @@ function getLog() {
  * This is NOT about preserving state for a human - it's about the swarm continuing
  * autonomously after context compression.
  */
-export const SWARM_COMPACTION_CONTEXT = `## 🐝 SWARM ACTIVE - You Are The COORDINATOR
+export const SWARM_COMPACTION_CONTEXT = `
+┌─────────────────────────────────────────────────────────────┐
+│                                                             │
+│             🐝  YOU ARE THE COORDINATOR  🐝                 │
+│                                                             │
+│             NOT A WORKER. NOT AN IMPLEMENTER.               │
+│                  YOU ORCHESTRATE.                           │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
 
-Context was compacted but the swarm is still running. You are the **COORDINATOR**.
+## 🎯 NON-NEGOTIABLE: YOU ARE THE COORDINATOR
+
+Context was compacted but the swarm is still running. **YOU ARE THE COORDINATOR.**
+
+Your role is ORCHESTRATION, not implementation. When you catch yourself about to do work directly, STOP.
 
 ### ⛔ NEVER DO THESE (Coordinator Anti-Patterns)
 
@@ -81,9 +93,27 @@ Context was compacted but the swarm is still running. You are the **COORDINATOR*
 - ❌ **NEVER** implement features yourself - SPAWN A WORKER
 - ❌ **NEVER** "just do it myself to save time" - NO. SPAWN A WORKER.
 - ❌ **NEVER** reserve files with \`swarmmail_reserve\` - Workers reserve files
+- ❌ **NEVER** fetch files/docs directly - SPAWN A RESEARCHER
 
 **If you catch yourself about to edit a file, STOP. Use \`swarm_spawn_subtask\` instead.**
 
+### 🚫 FORBIDDEN TOOLS (Coordinators MUST delegate these)
+
+**NEVER use these tools directly. ALWAYS spawn a researcher worker via \`swarm_spawn_researcher\`:**
+
+**Repository fetching:**
+- \`repo-crawl_file\`, \`repo-crawl_readme\`, \`repo-crawl_search\`, \`repo-crawl_structure\`, \`repo-crawl_tree\`
+- \`repo-autopsy_*\` (all repo-autopsy tools)
+
+**Web/documentation fetching:**
+- \`webfetch\`, \`fetch_fetch\`
+- \`context7_resolve-library-id\`, \`context7_get-library-docs\`
+
+**Knowledge base:**
+- \`pdf-brain_search\`, \`pdf-brain_read\`
+
+**If you need external data:** Use \`swarm_spawn_researcher\` with a clear research task. The researcher will fetch, summarize, and return findings.
+
 ### ✅ ALWAYS DO THESE (Coordinator Checklist)
 
 On resume, execute this checklist IN ORDER:
@@ -133,6 +163,87 @@ Extract from session context:
 - **Review work** - Use \`swarm_review\` and \`swarm_review_feedback\` for completed work
 - **Close the loop** - When all subtasks done, verify and close the epic
 
+**You are the COORDINATOR. You orchestrate. You do NOT implement. Spawn workers.**
+
+---
+
+## 📋 FULL COORDINATOR WORKFLOW (Reference)
+
+You are ALWAYS swarming. Here is the complete workflow for any new work:
+
+### Phase 1.5: Research Phase (FOR COMPLEX TASKS)
+
+**If the task requires understanding unfamiliar technologies, spawn a researcher FIRST:**
+
+\`\`\`
+swarm_spawn_researcher(
+  research_id="research-<topic>",
+  epic_id="<epic-id>",
+  tech_stack=["<technology>"],
+  project_path="<path>"
+)
+// Then spawn with Task(subagent_type="swarm/researcher", prompt="<from above>")
+\`\`\`
+
+### Phase 2: Knowledge Gathering
+
+\`\`\`
+semantic-memory_find(query="<task keywords>", limit=5)   # Past learnings
+cass_search(query="<task description>", limit=5)         # Similar past tasks  
+skills_list()                                            # Available skills
+\`\`\`
+
+### Phase 3: Decompose
+
+\`\`\`
+swarm_select_strategy(task="<task>")
+swarm_plan_prompt(task="<task>", context="<synthesized knowledge>")
+swarm_validate_decomposition(response="<CellTree JSON>")
+\`\`\`
+
+### Phase 4: Create Cells
+
+\`hive_create_epic(epic_title="<task>", subtasks=[...])\`
+
+### Phase 5: DO NOT Reserve Files
+
+> **⚠️ Coordinator NEVER reserves files.** Workers reserve their own files.
+
+### Phase 6: Spawn Workers
+
+\`\`\`
+swarm_spawn_subtask(bead_id, epic_id, title, files, shared_context, project_path)
+Task(subagent_type="swarm/worker", prompt="<from above>")
+\`\`\`
+
+### Phase 7: MANDATORY Review Loop
+
+**AFTER EVERY Task() RETURNS:**
+
+1. \`swarmmail_inbox()\` - Check for messages
+2. \`swarm_review(project_key, epic_id, task_id, files_touched)\` - Generate review
+3. Evaluate against epic goals
+4. \`swarm_review_feedback(project_key, task_id, worker_id, status, issues)\`
+
+**If needs_changes:**
+\`\`\`
+swarm_spawn_retry(bead_id, epic_id, original_prompt, attempt, issues, diff, files, project_path)
+// Spawn NEW worker with Task() using retry prompt
+// Max 3 attempts before marking task blocked
+\`\`\`
+
+### Phase 8: Complete
+
+\`hive_sync()\` - Sync all cells to git
+
+## Strategy Reference
+
+| Strategy       | Best For                 | Keywords                               |
+| -------------- | ------------------------ | -------------------------------------- |
+| file-based     | Refactoring, migrations  | refactor, migrate, rename, update all  |
+| feature-based  | New features             | add, implement, build, create, feature |
+| risk-based     | Bug fixes, security      | fix, bug, security, critical, urgent   |
+
 **You are the COORDINATOR. You orchestrate. You do NOT implement. Spawn workers.**
 `;
 

package/src/compaction-prompt-scorers.test.ts

@@ -0,0 +1,299 @@
+/**
+ * Tests for compaction prompt quality scorers
+ *
+ * TDD approach - tests written FIRST to define scorer behavior
+ * Tests the PURE scoring functions (not evalite wrappers)
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { CompactionPrompt } from "./compaction-prompt-scoring.js";
+import {
+	scoreActionability,
+	scoreCoordinatorIdentity,
+	scoreEpicIdSpecificity,
+	scoreForbiddenToolsPresent,
+	scorePostCompactionDiscipline,
+} from "./compaction-prompt-scoring.js";
+
+describe("epicIdSpecificity scorer", () => {
+	test("scores 1.0 for real epic IDs", () => {
+		const prompt: CompactionPrompt = {
+			content: "Continue coordinating epic mjkw81rkq4c",
+		};
+
+		const result = scoreEpicIdSpecificity(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("real epic ID");
+	});
+
+	test("scores 0.0 for placeholder IDs like <epic-id>", () => {
+		const prompt: CompactionPrompt = {
+			content: "Continue coordinating epic <epic-id>",
+		};
+
+		const result = scoreEpicIdSpecificity(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("placeholder");
+	});
+
+	test("scores 0.0 for bd-xxx placeholders", () => {
+		const prompt: CompactionPrompt = {
+			content: "Check status of bd-xxx",
+		};
+
+		const result = scoreEpicIdSpecificity(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("placeholder");
+	});
+
+	test("scores 0.0 for generic <path> placeholders", () => {
+		const prompt: CompactionPrompt = {
+			content: "Project at <path>",
+		};
+
+		const result = scoreEpicIdSpecificity(prompt);
+
+		expect(result.score).toBe(0.0);
+	});
+
+	test("scores 0.0 when no epic ID found", () => {
+		const prompt: CompactionPrompt = {
+			content: "Continue working on the task",
+		};
+
+		const result = scoreEpicIdSpecificity(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("No epic ID");
+	});
+});
+
+describe("actionability scorer", () => {
+	test("scores 1.0 when swarm_status has real epic ID", () => {
+		const prompt: CompactionPrompt = {
+			content: `First action:
+swarm_status(epic_id='mjkw81rkq4c', project_key='/path/to/project')`,
+		};
+
+		const result = scoreActionability(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("actionable tool call");
+	});
+
+	test("scores 1.0 when swarmmail_inbox is present", () => {
+		const prompt: CompactionPrompt = {
+			content: `Check messages:
+swarmmail_inbox()`,
+		};
+
+		const result = scoreActionability(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("actionable tool call");
+	});
+
+	test("scores 0.0 for generic instructions without tool calls", () => {
+		const prompt: CompactionPrompt = {
+			content: "Check the status of workers and review progress",
+		};
+
+		const result = scoreActionability(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("No actionable");
+	});
+
+	test("scores 0.0 for swarm_status with placeholders", () => {
+		const prompt: CompactionPrompt = {
+			content: `swarm_status(epic_id='<epic-id>', project_key='<path>')`,
+		};
+
+		const result = scoreActionability(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("placeholder");
+	});
+});
+
+describe("coordinatorIdentity scorer", () => {
+	test("scores 1.0 with ASCII header and strong mandates", () => {
+		const prompt: CompactionPrompt = {
+			content: `┌─────────────────────────────────────────┐
+│     YOU ARE THE COORDINATOR             │
+│                                         │
+│  NEVER spawn workers yourself           │
+│  ALWAYS review worker output            │
+└─────────────────────────────────────────┘
+
+Continue coordinating the swarm.`,
+		};
+
+		const result = scoreCoordinatorIdentity(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("ASCII header");
+		expect(result.message).toContain("strong mandates");
+	});
+
+	test("scores 0.5 with ASCII header but weak language", () => {
+		const prompt: CompactionPrompt = {
+			content: `┌─────────────────────────────────────────┐
+│     COORDINATOR MODE                    │
+└─────────────────────────────────────────┘
+
+You should consider delegating work.`,
+		};
+
+		const result = scoreCoordinatorIdentity(prompt);
+
+		expect(result.score).toBe(0.5);
+		expect(result.message).toContain("weak language");
+	});
+
+	test("scores 0.0 without ASCII header", () => {
+		const prompt: CompactionPrompt = {
+			content: `You are the coordinator. NEVER do work directly. ALWAYS delegate.`,
+		};
+
+		const result = scoreCoordinatorIdentity(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("No ASCII header");
+	});
+});
+
+describe("forbiddenToolsPresent scorer", () => {
+	test("scores 1.0 when all forbidden tools listed", () => {
+		const prompt: CompactionPrompt = {
+			content: `🚫 FORBIDDEN TOOLS - NEVER call these:
+- Edit (use swarm_spawn_subtask)
+- Write (use swarm_spawn_subtask)
+- swarmmail_reserve (only workers reserve)
+- bash with git commit (workers commit)`,
+		};
+
+		const result = scoreForbiddenToolsPresent(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("All 4 forbidden tools");
+	});
+
+	test("scores 0.75 when 3 out of 4 tools listed", () => {
+		const prompt: CompactionPrompt = {
+			content: `🚫 FORBIDDEN TOOLS:
+- Edit
+- Write
+- swarmmail_reserve`,
+		};
+
+		const result = scoreForbiddenToolsPresent(prompt);
+
+		expect(result.score).toBe(0.75);
+		expect(result.message).toContain("3/4");
+	});
+
+	test("scores 0.5 when 2 out of 4 tools listed", () => {
+		const prompt: CompactionPrompt = {
+			content: `Don't use Edit or Write directly.`,
+		};
+
+		const result = scoreForbiddenToolsPresent(prompt);
+
+		expect(result.score).toBe(0.5);
+		expect(result.message).toContain("2/4");
+	});
+
+	test("scores 0.0 when no forbidden tools listed", () => {
+		const prompt: CompactionPrompt = {
+			content: "Continue coordinating the epic",
+		};
+
+		const result = scoreForbiddenToolsPresent(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("0/4");
+	});
+});
+
+describe("postCompactionDiscipline scorer", () => {
+	test("scores 1.0 when first tool is swarm_status", () => {
+		const prompt: CompactionPrompt = {
+			content: `Resume coordination:
+
+1. swarm_status(epic_id='mjkw81rkq4c')
+2. Check inbox
+3. Review progress`,
+		};
+
+		const result = scorePostCompactionDiscipline(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("swarm_status");
+		expect(result.message).toContain("correct");
+	});
+
+	test("scores 1.0 when first tool is swarmmail_inbox", () => {
+		const prompt: CompactionPrompt = {
+			content: `Next steps:
+1. swarmmail_inbox()
+2. Review messages`,
+		};
+
+		const result = scorePostCompactionDiscipline(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("inbox");
+		expect(result.message).toContain("correct");
+	});
+
+	test("scores 0.0 when first tool is Edit", () => {
+		const prompt: CompactionPrompt = {
+			content: `Resume:
+1. Edit(file='src/auth.ts', ...)
+2. Check status`,
+		};
+
+		const result = scorePostCompactionDiscipline(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("Edit");
+	});
+
+	test("scores 0.0 when first tool is Write", () => {
+		const prompt: CompactionPrompt = {
+			content: `1. Write(file='README.md', ...)`,
+		};
+
+		const result = scorePostCompactionDiscipline(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("Write");
+	});
+
+	test("scores 0.0 when first tool is Read", () => {
+		const prompt: CompactionPrompt = {
+			content: `1. Read(file='src/index.ts')
+2. swarm_status()`,
+		};
+
+		const result = scorePostCompactionDiscipline(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("Read");
+	});
+
+	test("scores 0.0 when no tool calls mentioned", () => {
+		const prompt: CompactionPrompt = {
+			content: "Continue coordinating the epic",
+		};
+
+		const result = scorePostCompactionDiscipline(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("No tool");
+	});
+});