opencode-swarm-plugin 0.23.6 → 0.25.0

package/src/swarm.integration.test.ts

@@ -20,6 +20,8 @@ import {
   swarm_plan_prompt,
   formatSubtaskPromptV2,
   SUBTASK_PROMPT_V2,
+  swarm_checkpoint,
+  swarm_recover,
 } from "./swarm";
 import { mcpCall, setState, clearState, AGENT_MAIL_URL } from "./agent-mail";
 
@@ -219,15 +221,18 @@ describe("swarm_select_strategy", () => {
 
     expect(parsed).toHaveProperty("alternatives");
     expect(parsed.alternatives).toBeInstanceOf(Array);
-    expect(parsed.alternatives.length).toBe(2); // 3 strategies - 1 selected = 2 alternatives
+    expect(parsed.alternatives.length).toBe(3); // 4 strategies - 1 selected = 3 alternatives
 
     for (const alt of parsed.alternatives) {
       expect(alt).toHaveProperty("strategy");
       expect(alt).toHaveProperty("description");
       expect(alt).toHaveProperty("score");
-      expect(["file-based", "feature-based", "risk-based"]).toContain(
-        alt.strategy,
-      );
+      expect([
+        "file-based",
+        "feature-based",
+        "risk-based",
+        "research-based",
+      ]).toContain(alt.strategy);
       expect(typeof alt.score).toBe("number");
     }
   });
@@ -338,38 +343,30 @@ describe("swarm_plan_prompt", () => {
     expect(parsed.schema_hint).toHaveProperty("subtasks");
   });
 
-  it("reports CASS status in output (queried flag)", async () => {
-    // Test with CASS disabled
-    const resultDisabled = await swarm_plan_prompt.execute(
+  it("includes strategy and skills info in output", async () => {
+    // Test swarm_plan_prompt output structure
+    const result = await swarm_plan_prompt.execute(
       {
         task: "Add feature",
         max_subtasks: 3,
-        query_cass: false,
       },
       mockContext,
     );
-    const parsedDisabled = JSON.parse(resultDisabled);
+    const parsed = JSON.parse(result);
 
-    expect(parsedDisabled).toHaveProperty("cass_history");
-    expect(parsedDisabled.cass_history.queried).toBe(false);
+    // Should have strategy info
+    expect(parsed).toHaveProperty("strategy");
+    expect(parsed.strategy).toHaveProperty("selected");
+    expect(parsed.strategy).toHaveProperty("reasoning");
+    expect(parsed.strategy).toHaveProperty("guidelines");
+    expect(parsed.strategy).toHaveProperty("anti_patterns");
 
-    // Test with CASS enabled (may or may not be available)
-    const resultEnabled = await swarm_plan_prompt.execute(
-      {
-        task: "Add feature",
-        max_subtasks: 3,
-        query_cass: true,
-      },
-      mockContext,
-    );
-    const parsedEnabled = JSON.parse(resultEnabled);
+    // Should have skills info
+    expect(parsed).toHaveProperty("skills");
+    expect(parsed.skills).toHaveProperty("included");
 
-    expect(parsedEnabled).toHaveProperty("cass_history");
-    expect(parsedEnabled.cass_history).toHaveProperty("queried");
-    // If CASS is unavailable, queried will be false with reason
-    if (!parsedEnabled.cass_history.queried) {
-      expect(parsedEnabled.cass_history).toHaveProperty("reason");
-    }
+    // Should have memory query instruction
+    expect(parsed).toHaveProperty("memory_query");
   });
 
   it("includes context in prompt when provided", async () => {
@@ -1088,11 +1085,12 @@ describe("Tool Availability", () => {
 
   it("checks all tools at once", async () => {
     const availability = await checkAllTools();
-    expect(availability.size).toBe(5);
+    expect(availability.size).toBe(6); // semantic-memory, cass, ubs, beads, swarm-mail, agent-mail
     expect(availability.has("semantic-memory")).toBe(true);
     expect(availability.has("cass")).toBe(true);
     expect(availability.has("ubs")).toBe(true);
     expect(availability.has("beads")).toBe(true);
+    expect(availability.has("swarm-mail")).toBe(true);
     expect(availability.has("agent-mail")).toBe(true);
   });
 
@@ -1325,7 +1323,7 @@ describe("Swarm Prompt V2 (with Swarm Mail/Beads)", () => {
       expect(SUBTASK_PROMPT_V2).toContain("[CONTEXT]");
       expect(SUBTASK_PROMPT_V2).toContain("{shared_context}");
 
-      expect(SUBTASK_PROMPT_V2).toContain("[WORKFLOW]");
+      expect(SUBTASK_PROMPT_V2).toContain("[MANDATORY SURVIVAL CHECKLIST]");
     });
 
     it("DOES contain Swarm Mail instructions (MANDATORY)", () => {
@@ -1337,7 +1335,7 @@ describe("Swarm Prompt V2 (with Swarm Mail/Beads)", () => {
       expect(SUBTASK_PROMPT_V2).toContain("swarmmail_reserve");
       expect(SUBTASK_PROMPT_V2).toContain("swarmmail_release");
       expect(SUBTASK_PROMPT_V2).toContain("thread_id");
-      expect(SUBTASK_PROMPT_V2).toContain("non-negotiable");
+      expect(SUBTASK_PROMPT_V2).toContain("NON-NEGOTIABLE");
     });
 
     it("DOES contain beads instructions", () => {
@@ -1350,11 +1348,74 @@ describe("Swarm Prompt V2 (with Swarm Mail/Beads)", () => {
     });
 
     it("instructs agents to communicate via swarmmail", () => {
-      expect(SUBTASK_PROMPT_V2).toContain("Never work silently");
+      expect(SUBTASK_PROMPT_V2).toContain("don't work silently");
       expect(SUBTASK_PROMPT_V2).toContain("progress");
       expect(SUBTASK_PROMPT_V2).toContain("coordinator");
       expect(SUBTASK_PROMPT_V2).toContain("CRITICAL");
     });
+
+    it("contains survival checklist: semantic-memory_find", () => {
+      // Step 2: Query past learnings BEFORE starting work
+      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");
+    });
+
+    it("contains survival checklist: skills discovery and loading", () => {
+      // Step 3: Load relevant skills if available
+      expect(SUBTASK_PROMPT_V2).toContain("skills_list");
+      expect(SUBTASK_PROMPT_V2).toContain("skills_use");
+      expect(SUBTASK_PROMPT_V2).toContain("Load Relevant Skills");
+      expect(SUBTASK_PROMPT_V2).toContain("Common skill triggers");
+    });
+
+    it("contains survival checklist: worker reserves files (not coordinator)", () => {
+      // Step 4: Worker reserves their own files
+      expect(SUBTASK_PROMPT_V2).toContain("swarmmail_reserve");
+      expect(SUBTASK_PROMPT_V2).toContain("Reserve Your Files");
+      expect(SUBTASK_PROMPT_V2).toContain("YOU reserve, not coordinator");
+      expect(SUBTASK_PROMPT_V2).toContain("Workers reserve their own files");
+    });
+
+    it("contains survival checklist: swarm_progress at milestones", () => {
+      // Step 6: Report progress at 25/50/75%
+      expect(SUBTASK_PROMPT_V2).toContain("swarm_progress");
+      expect(SUBTASK_PROMPT_V2).toContain("Report Progress at Milestones");
+      expect(SUBTASK_PROMPT_V2).toContain("progress_percent");
+      expect(SUBTASK_PROMPT_V2).toContain("25%, 50%, 75%");
+      expect(SUBTASK_PROMPT_V2).toContain("auto-checkpoint");
+    });
+
+    it("contains survival checklist: swarm_checkpoint before risky ops", () => {
+      // Step 7: Manual checkpoint before risky operations
+      expect(SUBTASK_PROMPT_V2).toContain("swarm_checkpoint");
+      expect(SUBTASK_PROMPT_V2).toContain("Manual Checkpoint BEFORE Risky Operations");
+      expect(SUBTASK_PROMPT_V2).toContain("Large refactors");
+      expect(SUBTASK_PROMPT_V2).toContain("preserve context");
+    });
+
+    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");
+    });
+
+    it("does NOT mention coordinator reserving files", () => {
+      // Coordinator no longer reserves files - workers do it themselves
+      const lowerPrompt = SUBTASK_PROMPT_V2.toLowerCase();
+      expect(lowerPrompt).not.toContain("coordinator reserves");
+      expect(lowerPrompt).not.toContain("coordinator will reserve");
+    });
+
+    it("enforces swarm_complete over manual beads_close", () => {
+      // Step 9: Use swarm_complete, not beads_close
+      expect(SUBTASK_PROMPT_V2).toContain("swarm_complete");
+      expect(SUBTASK_PROMPT_V2).toContain("DO NOT manually close the bead");
+      expect(SUBTASK_PROMPT_V2).toContain("Use swarm_complete");
+    });
   });
 
   describe("swarm_complete automatic memory capture", () => {
@@ -1481,3 +1542,492 @@ describe("Swarm Prompt V2 (with Swarm Mail/Beads)", () => {
     );
   });
 });
+
+// ============================================================================
+// Checkpoint/Recovery Flow Integration Tests
+// ============================================================================
+
+describe("Checkpoint/Recovery Flow (integration)", () => {
+  describe("swarm_checkpoint", () => {
+    it("creates swarm_checkpointed event and updates swarm_contexts table", async () => {
+      const uniqueProjectKey = `${TEST_PROJECT_PATH}-checkpoint-${Date.now()}`;
+      const sessionID = `checkpoint-session-${Date.now()}`;
+
+      // Initialize swarm-mail database directly (no Agent Mail needed)
+      const { getDatabase, closeDatabase } = await import("swarm-mail");
+      const db = await getDatabase(uniqueProjectKey);
+
+      try {
+        const ctx = {
+          ...mockContext,
+          sessionID,
+        };
+
+        const epicId = "bd-test-epic-123";
+        const beadId = "bd-test-epic-123.1";
+        const agentName = "TestAgent";
+
+        // Execute checkpoint
+        const result = await swarm_checkpoint.execute(
+          {
+            project_key: uniqueProjectKey,
+            agent_name: agentName,
+            bead_id: beadId,
+            epic_id: epicId,
+            files_modified: ["src/test.ts", "src/test2.ts"],
+            progress_percent: 50,
+            directives: {
+              shared_context: "Testing checkpoint functionality",
+              skills_to_load: ["testing-patterns"],
+              coordinator_notes: "Mid-task checkpoint",
+            },
+          },
+          ctx,
+        );
+
+        const parsed = JSON.parse(result);
+
+        // Verify checkpoint was created
+        expect(parsed.success).toBe(true);
+        expect(parsed.bead_id).toBe(beadId);
+        expect(parsed.epic_id).toBe(epicId);
+        expect(parsed.files_tracked).toBe(2);
+        expect(parsed.summary).toContain("50%");
+        expect(parsed).toHaveProperty("checkpoint_timestamp");
+
+        // Verify swarm_contexts table was updated
+        const dbResult = await db.query<{
+          id: string;
+          epic_id: string;
+          bead_id: string;
+          strategy: string;
+          files: string;
+          recovery: string;
+        }>(
+          `SELECT id, epic_id, bead_id, strategy, files, recovery 
+           FROM swarm_contexts 
+           WHERE bead_id = $1`,
+          [beadId],
+        );
+
+        expect(dbResult.rows.length).toBe(1);
+        const row = dbResult.rows[0];
+        expect(row.epic_id).toBe(epicId);
+        expect(row.bead_id).toBe(beadId);
+        expect(row.strategy).toBe("file-based");
+
+        // PGLite auto-parses JSON columns, so we get objects directly
+        const files =
+          typeof row.files === "string" ? JSON.parse(row.files) : row.files;
+        expect(files).toEqual(["src/test.ts", "src/test2.ts"]);
+
+        const recovery =
+          typeof row.recovery === "string"
+            ? JSON.parse(row.recovery)
+            : row.recovery;
+        expect(recovery.progress_percent).toBe(50);
+        expect(recovery.files_modified).toEqual(["src/test.ts", "src/test2.ts"]);
+        expect(recovery).toHaveProperty("last_checkpoint");
+      } finally {
+        await closeDatabase(uniqueProjectKey);
+      }
+    });
+
+    it("handles checkpoint with error_context", async () => {
+      const uniqueProjectKey = `${TEST_PROJECT_PATH}-checkpoint-error-${Date.now()}`;
+      const sessionID = `checkpoint-error-session-${Date.now()}`;
+
+      const { getDatabase, closeDatabase } = await import("swarm-mail");
+      const db = await getDatabase(uniqueProjectKey);
+
+      try {
+        const ctx = {
+          ...mockContext,
+          sessionID,
+        };
+
+        const result = await swarm_checkpoint.execute(
+          {
+            project_key: uniqueProjectKey,
+            agent_name: "TestAgent",
+            bead_id: "bd-error-test.1",
+            epic_id: "bd-error-test",
+            files_modified: ["src/buggy.ts"],
+            progress_percent: 75,
+            error_context:
+              "Hit type error on line 42, need to add explicit types",
+          },
+          ctx,
+        );
+
+        const parsed = JSON.parse(result);
+        expect(parsed.success).toBe(true);
+
+        // Verify error_context was stored
+        const dbResult = await db.query<{ recovery: string }>(
+          `SELECT recovery FROM swarm_contexts WHERE bead_id = $1`,
+          ["bd-error-test.1"],
+        );
+
+        const recoveryRaw = dbResult.rows[0].recovery;
+        const recovery =
+          typeof recoveryRaw === "string" ? JSON.parse(recoveryRaw) : recoveryRaw;
+        expect(recovery.error_context).toBe(
+          "Hit type error on line 42, need to add explicit types",
+        );
+      } finally {
+        await closeDatabase(uniqueProjectKey);
+      }
+    });
+  });
+
+  describe("swarm_recover", () => {
+    it("retrieves checkpoint data from swarm_contexts table", async () => {
+      const uniqueProjectKey = `${TEST_PROJECT_PATH}-recover-${Date.now()}`;
+      const sessionID = `recover-session-${Date.now()}`;
+
+      const { getDatabase, closeDatabase } = await import("swarm-mail");
+      const db = await getDatabase(uniqueProjectKey);
+
+      try {
+        const ctx = {
+          ...mockContext,
+          sessionID,
+        };
+
+        const epicId = "bd-recover-epic-456";
+        const beadId = "bd-recover-epic-456.1";
+        const agentName = "TestAgent";
+
+        // First create a checkpoint
+        await swarm_checkpoint.execute(
+          {
+            project_key: uniqueProjectKey,
+            agent_name: agentName,
+            bead_id: beadId,
+            epic_id: epicId,
+            files_modified: ["src/auth.ts", "src/middleware.ts"],
+            progress_percent: 75,
+            directives: {
+              shared_context: "OAuth implementation in progress",
+              skills_to_load: ["testing-patterns", "swarm-coordination"],
+            },
+          },
+          ctx,
+        );
+
+        // Now recover it
+        const result = await swarm_recover.execute(
+          {
+            project_key: uniqueProjectKey,
+            epic_id: epicId,
+          },
+          ctx,
+        );
+
+        const parsed = JSON.parse(result);
+
+        // Verify recovery succeeded
+        expect(parsed.found).toBe(true);
+        expect(parsed).toHaveProperty("context");
+        expect(parsed).toHaveProperty("summary");
+        expect(parsed).toHaveProperty("age_seconds");
+
+        const { context } = parsed;
+        expect(context.epic_id).toBe(epicId);
+        expect(context.bead_id).toBe(beadId);
+        expect(context.strategy).toBe("file-based");
+        expect(context.files).toEqual(["src/auth.ts", "src/middleware.ts"]);
+        expect(context.recovery.progress_percent).toBe(75);
+        expect(context.directives.shared_context).toBe(
+          "OAuth implementation in progress",
+        );
+        expect(context.directives.skills_to_load).toEqual([
+          "testing-patterns",
+          "swarm-coordination",
+        ]);
+      } finally {
+        await closeDatabase(uniqueProjectKey);
+      }
+    });
+
+    it("returns found:false when no checkpoint exists", async () => {
+      const uniqueProjectKey = `${TEST_PROJECT_PATH}-recover-notfound-${Date.now()}`;
+      const sessionID = `recover-notfound-session-${Date.now()}`;
+
+      const { getDatabase, closeDatabase } = await import("swarm-mail");
+      await getDatabase(uniqueProjectKey);
+
+      try {
+        const ctx = {
+          ...mockContext,
+          sessionID,
+        };
+
+        // Try to recover non-existent checkpoint
+        const result = await swarm_recover.execute(
+          {
+            project_key: uniqueProjectKey,
+            epic_id: "bd-nonexistent-epic",
+          },
+          ctx,
+        );
+
+        const parsed = JSON.parse(result);
+
+        expect(parsed.found).toBe(false);
+        expect(parsed.message).toContain("No checkpoint found");
+        expect(parsed.epic_id).toBe("bd-nonexistent-epic");
+      } finally {
+        await closeDatabase(uniqueProjectKey);
+      }
+    });
+  });
+
+  describe("Auto-checkpoint at progress milestones", () => {
+    it("creates checkpoint at 25% progress", async () => {
+      const uniqueProjectKey = `${TEST_PROJECT_PATH}-auto25-${Date.now()}`;
+      const sessionID = `auto25-session-${Date.now()}`;
+
+      const { getDatabase, closeDatabase } = await import("swarm-mail");
+      const db = await getDatabase(uniqueProjectKey);
+
+      try {
+        const ctx = {
+          ...mockContext,
+          sessionID,
+        };
+
+        const beadId = "bd-auto-test.1";
+        const agentName = "TestAgent";
+
+        // Report progress at 25% - should trigger auto-checkpoint
+        const result = await swarm_progress.execute(
+          {
+            project_key: uniqueProjectKey,
+            agent_name: agentName,
+            bead_id: beadId,
+            status: "in_progress",
+            progress_percent: 25,
+            message: "Quarter done",
+            files_touched: ["src/component.tsx"],
+          },
+          ctx,
+        );
+
+        // Verify checkpoint was created (indicated in response)
+        expect(result).toContain("Progress reported");
+        expect(result).toContain("25%");
+        expect(result).toContain("[checkpoint created]");
+
+        // Verify checkpoint exists in database
+        const dbResult = await db.query<{ recovery: string }>(
+          `SELECT recovery FROM swarm_contexts WHERE bead_id = $1`,
+          [beadId],
+        );
+
+        expect(dbResult.rows.length).toBe(1);
+        const recoveryRaw = dbResult.rows[0].recovery;
+        const recovery =
+          typeof recoveryRaw === "string" ? JSON.parse(recoveryRaw) : recoveryRaw;
+        expect(recovery.progress_percent).toBe(25);
+        expect(recovery.files_modified).toEqual(["src/component.tsx"]);
+      } finally {
+        await closeDatabase(uniqueProjectKey);
+      }
+    });
+
+    it("creates checkpoint at 50% progress", async () => {
+      const uniqueProjectKey = `${TEST_PROJECT_PATH}-auto50-${Date.now()}`;
+      const sessionID = `auto50-session-${Date.now()}`;
+
+      const { getDatabase, closeDatabase } = await import("swarm-mail");
+      const db = await getDatabase(uniqueProjectKey);
+
+      try {
+        const ctx = {
+          ...mockContext,
+          sessionID,
+        };
+
+        const beadId = "bd-auto50-test.1";
+        const agentName = "TestAgent";
+
+        // Report progress at 50%
+        const result = await swarm_progress.execute(
+          {
+            project_key: uniqueProjectKey,
+            agent_name: agentName,
+            bead_id: beadId,
+            status: "in_progress",
+            progress_percent: 50,
+            message: "Halfway there",
+            files_touched: ["src/api.ts", "src/types.ts"],
+          },
+          ctx,
+        );
+
+        expect(result).toContain("[checkpoint created]");
+
+        // Verify checkpoint
+        const dbResult = await db.query<{ recovery: string }>(
+          `SELECT recovery FROM swarm_contexts WHERE bead_id = $1`,
+          [beadId],
+        );
+
+        const recoveryRaw50 = dbResult.rows[0].recovery;
+        const recovery =
+          typeof recoveryRaw50 === "string"
+            ? JSON.parse(recoveryRaw50)
+            : recoveryRaw50;
+        expect(recovery.progress_percent).toBe(50);
+      } finally {
+        await closeDatabase(uniqueProjectKey);
+      }
+    });
+
+    it("creates checkpoint at 75% progress", async () => {
+      const uniqueProjectKey = `${TEST_PROJECT_PATH}-auto75-${Date.now()}`;
+      const sessionID = `auto75-session-${Date.now()}`;
+
+      const { getDatabase, closeDatabase } = await import("swarm-mail");
+      const db = await getDatabase(uniqueProjectKey);
+
+      try {
+        const ctx = {
+          ...mockContext,
+          sessionID,
+        };
+
+        const beadId = "bd-auto75-test.1";
+        const agentName = "TestAgent";
+
+        // Report progress at 75%
+        const result = await swarm_progress.execute(
+          {
+            project_key: uniqueProjectKey,
+            agent_name: agentName,
+            bead_id: beadId,
+            status: "in_progress",
+            progress_percent: 75,
+            message: "Almost done",
+            files_touched: ["src/final.ts"],
+          },
+          ctx,
+        );
+
+        expect(result).toContain("[checkpoint created]");
+
+        // Verify checkpoint
+        const dbResult = await db.query<{ recovery: string }>(
+          `SELECT recovery FROM swarm_contexts WHERE bead_id = $1`,
+          [beadId],
+        );
+
+        const recoveryRaw75 = dbResult.rows[0].recovery;
+        const recovery =
+          typeof recoveryRaw75 === "string"
+            ? JSON.parse(recoveryRaw75)
+            : recoveryRaw75;
+        expect(recovery.progress_percent).toBe(75);
+      } finally {
+        await closeDatabase(uniqueProjectKey);
+      }
+    });
+
+    it("does NOT create checkpoint at non-milestone progress", async () => {
+      const uniqueProjectKey = `${TEST_PROJECT_PATH}-auto-nomilestone-${Date.now()}`;
+      const sessionID = `auto-nomilestone-session-${Date.now()}`;
+
+      const { getDatabase, closeDatabase } = await import("swarm-mail");
+      const db = await getDatabase(uniqueProjectKey);
+
+      try {
+        const ctx = {
+          ...mockContext,
+          sessionID,
+        };
+
+        const beadId = "bd-auto-nomilestone.1";
+        const agentName = "TestAgent";
+
+        // Report progress at 30% (not a milestone)
+        const result = await swarm_progress.execute(
+          {
+            project_key: uniqueProjectKey,
+            agent_name: agentName,
+            bead_id: beadId,
+            status: "in_progress",
+            progress_percent: 30,
+            message: "Not a milestone",
+            files_touched: ["src/random.ts"],
+          },
+          ctx,
+        );
+
+        // Should NOT contain checkpoint indicator
+        expect(result).not.toContain("[checkpoint created]");
+        expect(result).toContain("30%");
+
+        // Verify NO checkpoint was created
+        const dbResult = await db.query(
+          `SELECT * FROM swarm_contexts WHERE bead_id = $1`,
+          [beadId],
+        );
+
+        expect(dbResult.rows.length).toBe(0);
+      } finally {
+        await closeDatabase(uniqueProjectKey);
+      }
+    });
+
+    it("checkpoint includes message from progress report", async () => {
+      const uniqueProjectKey = `${TEST_PROJECT_PATH}-auto-message-${Date.now()}`;
+      const sessionID = `auto-message-session-${Date.now()}`;
+
+      const { getDatabase, closeDatabase } = await import("swarm-mail");
+      const db = await getDatabase(uniqueProjectKey);
+
+      try {
+        const ctx = {
+          ...mockContext,
+          sessionID,
+        };
+
+        const beadId = "bd-auto-message.1";
+        const testMessage =
+          "Implemented auth service, working on JWT tokens";
+        const agentName = "TestAgent";
+
+        // Report progress with message
+        await swarm_progress.execute(
+          {
+            project_key: uniqueProjectKey,
+            agent_name: agentName,
+            bead_id: beadId,
+            status: "in_progress",
+            progress_percent: 50,
+            message: testMessage,
+            files_touched: ["src/auth.ts"],
+          },
+          ctx,
+        );
+
+        // Verify message was stored in checkpoint
+        const dbResult = await db.query<{ recovery: string }>(
+          `SELECT recovery FROM swarm_contexts WHERE bead_id = $1`,
+          [beadId],
+        );
+
+        const recoveryRawMsg = dbResult.rows[0].recovery;
+        const recovery =
+          typeof recoveryRawMsg === "string"
+            ? JSON.parse(recoveryRawMsg)
+            : recoveryRawMsg;
+        expect(recovery.last_message).toBe(testMessage);
+      } finally {
+        await closeDatabase(uniqueProjectKey);
+      }
+    });
+  });
+});