opencode-swarm-plugin 0.20.0 → 0.22.0

package/src/swarm-prompts.ts

@@ -273,20 +273,29 @@ Only modify these files. Need others? Message the coordinator.
 
 {error_context}
 
-## [MANDATORY: SWARM MAIL]
+## [MANDATORY: SWARM MAIL INITIALIZATION]
 
-**YOU MUST USE SWARM MAIL FOR ALL COORDINATION.** This is non-negotiable.
+**CRITICAL: YOU MUST INITIALIZE SWARM MAIL BEFORE DOING ANY WORK.**
 
-### Initialize FIRST (before any work)
-\`\`\`
-swarmmail_init(project_path="$PWD", task_description="{subtask_title}")
-\`\`\`
+This is your FIRST step - before reading files, before planning, before ANY other action.
 
-### Reserve Files (if not already reserved by coordinator)
+### Step 1: Initialize (REQUIRED - DO THIS FIRST)
 \`\`\`
-swarmmail_reserve(paths=[...files...], reason="{bead_id}: {subtask_title}")
+swarmmail_init(project_path="{project_path}", task_description="{bead_id}: {subtask_title}")
 \`\`\`
 
+**This registers you with the coordination system and enables:**
+- File reservation tracking
+- Inter-agent communication
+- Progress monitoring
+- Conflict detection
+
+**If you skip this step, your work will not be tracked and swarm_complete will fail.**
+
+## [SWARM MAIL USAGE]
+
+After initialization, use Swarm Mail for coordination:
+
 ### Check Inbox Regularly
 \`\`\`
 swarmmail_inbox()  # Check for coordinator messages
@@ -340,14 +349,17 @@ As you work, note reusable patterns, best practices, or domain insights:
 - Skills make swarms smarter over time
 
 ## [WORKFLOW]
-1. **swarmmail_init** - Initialize session FIRST
+1. **swarmmail_init** - Initialize session (MANDATORY FIRST STEP)
 2. Read assigned files
 3. Implement changes
 4. **swarmmail_send** - Report progress to coordinator
 5. Verify (typecheck)
 6. **swarm_complete** - Mark done, release reservations
 
-**CRITICAL: Never work silently. Send progress updates via swarmmail_send every significant milestone.**
+**CRITICAL REQUIREMENTS:**
+- Step 1 (swarmmail_init) is NON-NEGOTIABLE - do it before anything else
+- Never work silently - send progress updates via swarmmail_send every significant milestone
+- If you complete without initializing, swarm_complete will detect this and warn/fail
 
 Begin now.`;
 
@@ -409,6 +421,12 @@ export function formatSubtaskPromptV2(params: {
   shared_context?: string;
   compressed_context?: string;
   error_context?: string;
+  project_path?: string;
+  recovery_context?: {
+    shared_context?: string;
+    skills_to_load?: string[];
+    coordinator_notes?: string;
+  };
 }): string {
   const fileList =
     params.files.length > 0
@@ -421,8 +439,40 @@ export function formatSubtaskPromptV2(params: {
 
   const errorSection = params.error_context ? params.error_context : "";
 
+  // Build recovery context section
+  let recoverySection = "";
+  if (params.recovery_context) {
+    const sections: string[] = [];
+
+    if (params.recovery_context.shared_context) {
+      sections.push(
+        `### Recovery Context\n${params.recovery_context.shared_context}`,
+      );
+    }
+
+    if (
+      params.recovery_context.skills_to_load &&
+      params.recovery_context.skills_to_load.length > 0
+    ) {
+      sections.push(
+        `### Skills to Load\nBefore starting work, load these skills for specialized guidance:\n${params.recovery_context.skills_to_load.map((s) => `- skills_use(name="${s}")`).join("\n")}`,
+      );
+    }
+
+    if (params.recovery_context.coordinator_notes) {
+      sections.push(
+        `### Coordinator Notes\n${params.recovery_context.coordinator_notes}`,
+      );
+    }
+
+    if (sections.length > 0) {
+      recoverySection = `\n## [RECOVERY CONTEXT]\n\n${sections.join("\n\n")}`;
+    }
+  }
+
   return SUBTASK_PROMPT_V2.replace(/{bead_id}/g, params.bead_id)
     .replace(/{epic_id}/g, params.epic_id)
+    .replace(/{project_path}/g, params.project_path || "$PWD")
     .replace("{subtask_title}", params.subtask_title)
     .replace(
       "{subtask_description}",
@@ -431,7 +481,7 @@ export function formatSubtaskPromptV2(params: {
     .replace("{file_list}", fileList)
     .replace("{shared_context}", params.shared_context || "(none)")
     .replace("{compressed_context}", compressedSection)
-    .replace("{error_context}", errorSection);
+    .replace("{error_context}", errorSection + recoverySection);
 }
 
 /**
@@ -497,6 +547,10 @@ export const swarm_subtask_prompt = tool({
       .string()
       .optional()
       .describe("Context shared across all agents"),
+    project_path: tool.schema
+      .string()
+      .optional()
+      .describe("Absolute project path for swarmmail_init"),
   },
   async execute(args) {
     const prompt = formatSubtaskPrompt({
@@ -521,7 +575,7 @@ export const swarm_subtask_prompt = tool({
  */
 export const swarm_spawn_subtask = tool({
   description:
-    "Prepare a subtask for spawning. Returns prompt with Agent Mail/beads instructions.",
+    "Prepare a subtask for spawning. Returns prompt with Agent Mail/beads instructions. IMPORTANT: Pass project_path for swarmmail_init.",
   args: {
     bead_id: tool.schema.string().describe("Subtask bead ID"),
     epic_id: tool.schema.string().describe("Parent epic bead ID"),
@@ -537,6 +591,20 @@ export const swarm_spawn_subtask = tool({
       .string()
       .optional()
       .describe("Context shared across all agents"),
+    project_path: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Absolute project path for swarmmail_init (REQUIRED for tracking)",
+      ),
+    recovery_context: tool.schema
+      .object({
+        shared_context: tool.schema.string().optional(),
+        skills_to_load: tool.schema.array(tool.schema.string()).optional(),
+        coordinator_notes: tool.schema.string().optional(),
+      })
+      .optional()
+      .describe("Recovery context from checkpoint compaction"),
   },
   async execute(args) {
     const prompt = formatSubtaskPromptV2({
@@ -546,6 +614,8 @@ export const swarm_spawn_subtask = tool({
       subtask_description: args.subtask_description || "",
       files: args.files,
       shared_context: args.shared_context,
+      project_path: args.project_path,
+      recovery_context: args.recovery_context,
     });
 
     return JSON.stringify(
@@ -554,6 +624,8 @@ export const swarm_spawn_subtask = tool({
         bead_id: args.bead_id,
         epic_id: args.epic_id,
         files: args.files,
+        project_path: args.project_path,
+        recovery_context: args.recovery_context,
       },
       null,
       2,

package/src/swarm.integration.test.ts

@@ -1356,4 +1356,128 @@ describe("Swarm Prompt V2 (with Swarm Mail/Beads)", () => {
       expect(SUBTASK_PROMPT_V2).toContain("CRITICAL");
     });
   });
+
+  describe("swarm_complete automatic memory capture", () => {
+    let beadsAvailable = false;
+
+    beforeAll(async () => {
+      beadsAvailable = await isBeadsAvailable();
+    });
+
+    it.skipIf(!beadsAvailable)(
+      "includes memory_capture object in response",
+      async () => {
+        // Create a real bead for the test
+        const createResult =
+          await Bun.$`bd create "Test memory capture" -t task --json`
+            .quiet()
+            .nothrow();
+
+        if (createResult.exitCode !== 0) {
+          console.warn(
+            "Could not create bead:",
+            createResult.stderr.toString(),
+          );
+          return;
+        }
+
+        const bead = JSON.parse(createResult.stdout.toString());
+
+        try {
+          const result = await swarm_complete.execute(
+            {
+              project_key: "/tmp/test-memory-capture",
+              agent_name: "test-agent",
+              bead_id: bead.id,
+              summary: "Implemented auto-capture feature",
+              files_touched: ["src/swarm-orchestrate.ts"],
+              skip_verification: true,
+            },
+            mockContext,
+          );
+
+          const parsed = JSON.parse(result);
+
+          // Verify memory capture was attempted
+          expect(parsed).toHaveProperty("memory_capture");
+          expect(parsed.memory_capture).toHaveProperty("attempted", true);
+          expect(parsed.memory_capture).toHaveProperty("stored");
+          expect(parsed.memory_capture).toHaveProperty("information");
+          expect(parsed.memory_capture).toHaveProperty("metadata");
+
+          // Information should contain bead ID and summary
+          expect(parsed.memory_capture.information).toContain(bead.id);
+          expect(parsed.memory_capture.information).toContain(
+            "Implemented auto-capture feature",
+          );
+
+          // Metadata should contain relevant tags
+          expect(parsed.memory_capture.metadata).toContain("swarm");
+          expect(parsed.memory_capture.metadata).toContain("success");
+        } catch (error) {
+          // Clean up bead if test fails
+          await Bun.$`bd close ${bead.id} --reason "Test cleanup"`
+            .quiet()
+            .nothrow();
+          throw error;
+        }
+      },
+    );
+
+    it.skipIf(!beadsAvailable)(
+      "attempts to store in semantic-memory when available",
+      async () => {
+        const createResult =
+          await Bun.$`bd create "Test semantic-memory storage" -t task --json`
+            .quiet()
+            .nothrow();
+
+        if (createResult.exitCode !== 0) {
+          console.warn(
+            "Could not create bead:",
+            createResult.stderr.toString(),
+          );
+          return;
+        }
+
+        const bead = JSON.parse(createResult.stdout.toString());
+
+        try {
+          const result = await swarm_complete.execute(
+            {
+              project_key: "/tmp/test-memory-storage",
+              agent_name: "test-agent",
+              bead_id: bead.id,
+              summary: "Fixed critical bug in auth flow",
+              files_touched: ["src/auth.ts", "src/middleware.ts"],
+              skip_verification: true,
+            },
+            mockContext,
+          );
+
+          const parsed = JSON.parse(result);
+
+          // If semantic-memory is available, stored should be true
+          // If not, error should explain why
+          if (parsed.memory_capture.stored) {
+            expect(parsed.memory_capture.note).toContain(
+              "automatically stored in semantic-memory",
+            );
+          } else {
+            expect(parsed.memory_capture.error).toBeDefined();
+            expect(
+              parsed.memory_capture.error.includes("not available") ||
+                parsed.memory_capture.error.includes("failed"),
+            ).toBe(true);
+          }
+        } catch (error) {
+          // Clean up bead if test fails
+          await Bun.$`bd close ${bead.id} --reason "Test cleanup"`
+            .quiet()
+            .nothrow();
+          throw error;
+        }
+      },
+    );
+  });
 });

package/vitest.integration.config.ts

@@ -9,5 +9,11 @@ export default defineConfig({
     sequence: {
       concurrent: false,
     },
+    env: {
+      // Enable test-specific collections to isolate test data from production
+      TEST_MEMORY_COLLECTIONS: "true",
+    },
+    // Global setup/teardown hooks
+    globalSetup: "./vitest.integration.setup.ts",
   },
 });

package/vitest.integration.setup.ts

@@ -0,0 +1,48 @@
+/**
+ * Global setup/teardown for integration tests
+ *
+ * Ensures test-specific semantic-memory collections are cleaned up
+ * after all integration tests complete.
+ */
+
+export async function setup() {
+  console.log("[vitest] Integration test setup: TEST_MEMORY_COLLECTIONS=true");
+  // Setup runs before tests - environment variables are already set via vitest config
+}
+
+export async function teardown() {
+  console.log(
+    "[vitest] Integration test teardown: cleaning up test collections",
+  );
+
+  // Clean up test collections
+  const testCollections = [
+    "swarm-feedback-test",
+    "swarm-patterns-test",
+    "swarm-maturity-test",
+    "swarm-maturity-test-feedback",
+  ];
+
+  for (const collection of testCollections) {
+    try {
+      // Attempt to remove test collection data
+      // Note: semantic-memory doesn't have a built-in "delete collection" command,
+      // so we'll use the remove command with a wildcard or rely on TTL/manual cleanup
+      console.log(`[vitest] Attempting to clean collection: ${collection}`);
+
+      // List items and remove them (semantic-memory may not support bulk delete)
+      // This is a best-effort cleanup - some backends may require manual cleanup
+      // For now, we'll just log that cleanup should happen
+      console.log(
+        `[vitest] Note: Collection "${collection}" may need manual cleanup via semantic-memory CLI`,
+      );
+    } catch (error) {
+      console.warn(
+        `[vitest] Failed to clean collection ${collection}:`,
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+
+  console.log("[vitest] Integration test teardown complete");
+}