opencode-swarm-plugin 0.30.7 → 0.31.0

package/src/hive.integration.test.ts

@@ -406,7 +406,7 @@ describe("beads integration", () => {
   });
 
   describe("hive_create_epic", () => {
-    it("creates an epic with subtasks", async () => {
+    it("creates an epic with subtasks and syncs to JSONL", async () => {
       const result = await hive_create_epic.execute(
         {
           epic_title: "Integration test epic",
@@ -438,6 +438,28 @@ describe("beads integration", () => {
         expect(subtaskBead).toBeDefined();
         expect(subtaskBead!.parent_id).toBe(epicResult.epic.id);
       }
+      
+      // NEW TEST: Verify cells are synced to JSONL immediately
+      const { readFileSync, existsSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const jsonlPath = join(TEST_PROJECT_KEY, ".hive", "issues.jsonl");
+      
+      expect(existsSync(jsonlPath)).toBe(true);
+      
+      const jsonlContent = readFileSync(jsonlPath, "utf-8");
+      const lines = jsonlContent.trim().split("\n").filter(l => l);
+      const cells = lines.map(line => JSON.parse(line));
+      
+      // Epic and all subtasks should be in JSONL
+      const epicInJsonl = cells.find(c => c.id === epicResult.epic.id);
+      expect(epicInJsonl).toBeDefined();
+      expect(epicInJsonl!.title).toBe("Integration test epic");
+      
+      for (const subtask of epicResult.subtasks) {
+        const subtaskInJsonl = cells.find(c => c.id === subtask.id);
+        expect(subtaskInJsonl).toBeDefined();
+        expect(subtaskInJsonl!.parent_id).toBe(epicResult.epic.id);
+      }
     });
 
     it("creates an epic with files metadata in subtasks", async () => {
@@ -601,6 +623,181 @@ describe("beads integration", () => {
     });
   });
 
+  describe("partial ID resolution", () => {
+    let fullId: string;
+    let hash: string;
+
+    beforeEach(async () => {
+      // Create a test cell to resolve
+      const result = await hive_create.execute(
+        { title: "Partial ID test cell" },
+        mockContext,
+      );
+      const cell = parseResponse<Cell>(result);
+      fullId = cell.id;
+      createdBeadIds.push(fullId);
+
+      // Extract hash from ID (format: {prefix}-{hash}-{timestamp}{random})
+      // The last segment is always timestamp+random (11 chars)
+      // The hash is the 6-char segment before that
+      // Examples:
+      //   "opencode-swarm-monorepo-lf2p4u-mjd2h5v4wdt" -> hash is "lf2p4u"
+      //   "cell--gcel4-mjd2h5v4wdt" -> hash is "-gcel4" (negative hash creates consecutive hyphens)
+      
+      // Find the last hyphen, then work backwards to find the second-to-last hyphen
+      const lastHyphenIndex = fullId.lastIndexOf("-");
+      if (lastHyphenIndex === -1) {
+        hash = "";
+      } else {
+        // Get everything before the last hyphen
+        const beforeLast = fullId.substring(0, lastHyphenIndex);
+        // Find the second-to-last hyphen
+        const secondLastHyphenIndex = beforeLast.lastIndexOf("-");
+        if (secondLastHyphenIndex === -1) {
+          hash = "";
+        } else {
+          // Hash is between second-to-last and last hyphen
+          hash = fullId.substring(secondLastHyphenIndex + 1, lastHyphenIndex);
+        }
+      }
+    });
+
+    describe("hive_update", () => {
+      it("accepts full cell ID (no resolution needed)", async () => {
+        const result = await hive_update.execute(
+          { id: fullId, description: "Updated via full ID" },
+          mockContext,
+        );
+
+        const updated = parseResponse<Cell>(result);
+        expect(updated.id).toBe(fullId);
+        expect(updated.description).toContain("Updated via full ID");
+      });
+
+      it("resolves hash to full ID (or shows helpful error if ambiguous)", async () => {
+        try {
+          const result = await hive_update.execute(
+            { id: hash, priority: 1 },
+            mockContext,
+          );
+
+          const updated = parseResponse<Cell>(result);
+          expect(updated.id).toBe(fullId);
+          expect(updated.priority).toBe(1);
+        } catch (error) {
+          // In test environment with many cells, hash may be ambiguous
+          // Verify we get a helpful error message
+          if (error instanceof Error && error.message.includes("Ambiguous")) {
+            expect(error.message).toMatch(/ambiguous.*multiple/i);
+            expect(error.message).toContain(hash);
+          } else {
+            throw error; // Re-throw if not ambiguity error
+          }
+        }
+      });
+
+      it("throws helpful error for non-existent hash", async () => {
+        await expect(
+          hive_update.execute({ id: "zzzzzz", status: "closed" }, mockContext),
+        ).rejects.toThrow(/not found|no cell|zzzzzz/i);
+      });
+
+      it("throws helpful error for ambiguous hash", async () => {
+        // Create another cell with potentially similar hash
+        // (in practice, hashes are unique, but we simulate ambiguity by using a short partial)
+        // This test verifies the error message is helpful
+        try {
+          // Use a single char which might match multiple cells in larger datasets
+          await hive_update.execute({ id: "a", status: "closed" }, mockContext);
+          // If it succeeds, it means only one cell matched - that's fine
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          // Error should mention ambiguity if multiple matches
+          if (message.includes("ambiguous") || message.includes("multiple")) {
+            expect(message).toMatch(/ambiguous|multiple/i);
+          }
+        }
+      });
+    });
+
+    describe("hive_close", () => {
+      it("accepts full cell ID", async () => {
+        const result = await hive_close.execute(
+          { id: fullId, reason: "Closed via full ID" },
+          mockContext,
+        );
+
+        expect(result).toContain("Closed");
+        expect(result).toContain(fullId);
+
+        const closed = await adapter.getCell(TEST_PROJECT_KEY, fullId);
+        expect(closed?.status).toBe("closed");
+      });
+
+      it("resolves hash to full ID (or shows helpful error if ambiguous)", async () => {
+        try {
+          const result = await hive_close.execute(
+            { id: hash, reason: "Close via hash" },
+            mockContext,
+          );
+
+          expect(result).toContain("Closed");
+          expect(result).toContain(fullId);
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("Ambiguous")) {
+            expect(error.message).toMatch(/ambiguous.*multiple/i);
+            expect(error.message).toContain(hash);
+          } else {
+            throw error;
+          }
+        }
+      });
+
+      it("throws helpful error for non-existent hash", async () => {
+        await expect(
+          hive_close.execute({ id: "nonono", reason: "Test" }, mockContext),
+        ).rejects.toThrow(/not found|no cell|nonono/i);
+      });
+    });
+
+    describe("hive_start", () => {
+      it("accepts full cell ID", async () => {
+        const result = await hive_start.execute({ id: fullId }, mockContext);
+
+        expect(result).toContain("Started");
+        expect(result).toContain(fullId);
+
+        const started = await adapter.getCell(TEST_PROJECT_KEY, fullId);
+        expect(started?.status).toBe("in_progress");
+      });
+
+      it("resolves hash to full ID (or shows helpful error if ambiguous)", async () => {
+        try {
+          const result = await hive_start.execute(
+            { id: hash },
+            mockContext,
+          );
+
+          expect(result).toContain("Started");
+          expect(result).toContain(fullId);
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("Ambiguous")) {
+            expect(error.message).toMatch(/ambiguous.*multiple/i);
+            expect(error.message).toContain(hash);
+          } else {
+            throw error;
+          }
+        }
+      });
+
+      it("throws helpful error for non-existent hash", async () => {
+        await expect(
+          hive_start.execute({ id: "nope99" }, mockContext),
+        ).rejects.toThrow(/not found|no cell|nope99/i);
+      });
+    });
+  });
+
   describe("workflow integration", () => {
     it("complete bead lifecycle: create -> start -> update -> close", async () => {
       // 1. Create
@@ -1225,8 +1422,8 @@ describe("beads integration", () => {
           mockContext,
         );
 
-        // Should return "No cells to sync" since no dirty cells
-        expect(result).toContain("No cells to sync");
+        // Should return "No cells or memories to sync" since no dirty cells
+        expect(result).toContain("No cells or memories to sync");
       } finally {
         setHiveWorkingDirectory(originalDir);
         rmSync(tempProject, { recursive: true, force: true });
@@ -1450,4 +1647,136 @@ describe("beads integration", () => {
       rmSync(tempProject, { recursive: true, force: true });
     });
   });
+
+  describe("process exit hook", () => {
+    it("registers beforeExit hook that syncs dirty cells", async () => {
+      const { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+      const { execSync } = await import("node:child_process");
+
+      // Create temp project
+      const tempProject = join(tmpdir(), `hive-exit-hook-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+
+      // Initialize git repo
+      execSync("git init", { cwd: tempProject });
+      execSync('git config user.email "test@example.com"', { cwd: tempProject });
+      execSync('git config user.name "Test User"', { cwd: tempProject });
+
+      // Initial commit with empty issues.jsonl
+      writeFileSync(join(hiveDir, "issues.jsonl"), "");
+      execSync("git add .", { cwd: tempProject });
+      execSync('git commit -m "initial"', { cwd: tempProject });
+
+      // Set working directory
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create a cell (marks it dirty but don't sync)
+        await hive_create.execute(
+          { title: "Exit hook test cell", type: "task" },
+          mockContext,
+        );
+
+        // Verify cell is NOT in JSONL yet (only in PGLite)
+        const beforeContent = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+        expect(beforeContent.trim()).toBe("");
+
+        // Simulate process exit by triggering beforeExit event
+        process.emit("beforeExit", 0);
+
+        // Wait for async flush to complete
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        // Verify cell was synced to JSONL by the exit hook
+        const afterContent = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+        expect(afterContent.trim()).not.toBe("");
+
+        const cells = afterContent.trim().split("\n").map(line => JSON.parse(line));
+        expect(cells).toHaveLength(1);
+        expect(cells[0].title).toBe("Exit hook test cell");
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+
+    it("exit hook is idempotent - safe to call multiple times", async () => {
+      const { mkdirSync, rmSync, writeFileSync, readFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      // Create temp project
+      const tempProject = join(tmpdir(), `hive-exit-hook-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      writeFileSync(join(hiveDir, "issues.jsonl"), "");
+
+      // Set working directory
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create a cell
+        await hive_create.execute(
+          { title: "Idempotent test cell", type: "task" },
+          mockContext,
+        );
+
+        // Trigger exit hook multiple times
+        process.emit("beforeExit", 0);
+        await new Promise(resolve => setTimeout(resolve, 50));
+        
+        process.emit("beforeExit", 0);
+        await new Promise(resolve => setTimeout(resolve, 50));
+
+        // Verify cell is written only once (no duplication)
+        const content = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+        const lines = content.trim().split("\n").filter(l => l);
+        
+        // Should have exactly one cell (even though we triggered hook twice)
+        expect(lines.length).toBeGreaterThanOrEqual(1);
+        
+        // All cells should have unique IDs
+        const cells = lines.map(line => JSON.parse(line));
+        const uniqueIds = new Set(cells.map(c => c.id));
+        expect(uniqueIds.size).toBe(cells.length);
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+
+    it("exit hook handles case with no dirty cells gracefully", async () => {
+      const { mkdirSync, rmSync, writeFileSync, readFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      // Create temp project with empty JSONL
+      const tempProject = join(tmpdir(), `hive-exit-hook-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      writeFileSync(join(hiveDir, "issues.jsonl"), "");
+
+      // Set working directory
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Trigger exit hook with no dirty cells (should not throw)
+        process.emit("beforeExit", 0);
+        await new Promise(resolve => setTimeout(resolve, 50));
+
+        // JSONL should still be empty (no error thrown)
+        const content = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+        expect(content.trim()).toBe("");
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+  });
 });

package/src/hive.ts

@@ -23,6 +23,7 @@ import {
   type HiveAdapter,
   type Cell as AdapterCell,
   getSwarmMail,
+  resolvePartialId,
 } from "swarm-mail";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -423,6 +424,78 @@ export async function importJsonlToPGLite(projectPath: string): Promise<{
  */
 const adapterCache = new Map<string, HiveAdapter>();
 
+// ============================================================================
+// Process Exit Hook - Safety Net for Dirty Cells
+// ============================================================================
+
+/**
+ * Track if exit hook is already registered (prevent duplicate registrations)
+ */
+let exitHookRegistered = false;
+
+/**
+ * Track if exit hook is currently running (prevent re-entry)
+ */
+let exitHookRunning = false;
+
+/**
+ * Register process.on('beforeExit') handler to flush dirty cells
+ * This is a safety net - catches any dirty cells that weren't explicitly synced
+ * 
+ * Idempotent - safe to call multiple times (only registers once)
+ */
+function registerExitHook(): void {
+  if (exitHookRegistered) {
+    return; // Already registered
+  }
+  
+  exitHookRegistered = true;
+  
+  process.on('beforeExit', async (code) => {
+    // Prevent re-entry if already flushing
+    if (exitHookRunning) {
+      return;
+    }
+    
+    exitHookRunning = true;
+    
+    try {
+      // Flush all projects that have adapters (and potentially dirty cells)
+      const flushPromises: Promise<void>[] = [];
+      
+      for (const [projectKey, adapter] of adapterCache.entries()) {
+        const flushPromise = (async () => {
+          try {
+            ensureHiveDirectory(projectKey);
+            const flushManager = new FlushManager({
+              adapter,
+              projectKey,
+              outputPath: `${projectKey}/.hive/issues.jsonl`,
+            });
+            await flushManager.flush();
+          } catch (error) {
+            // Non-fatal - log and continue
+            console.warn(
+              `[hive exit hook] Failed to flush ${projectKey}:`,
+              error instanceof Error ? error.message : String(error)
+            );
+          }
+        })();
+        
+        flushPromises.push(flushPromise);
+      }
+      
+      // Wait for all flushes to complete
+      await Promise.all(flushPromises);
+    } finally {
+      exitHookRunning = false;
+    }
+  });
+}
+
+// Register exit hook immediately when module is imported
+registerExitHook();
+
 /**
  * Get or create a HiveAdapter instance for a project
  * Exported for testing - allows tests to verify state directly
@@ -694,6 +767,23 @@ export const hive_create_epic = tool({
         }
       }
 
+      // Sync cells to JSONL so spawned workers can see them immediately
+      try {
+        ensureHiveDirectory(projectKey);
+        const flushManager = new FlushManager({
+          adapter,
+          projectKey,
+          outputPath: `${projectKey}/.hive/issues.jsonl`,
+        });
+        await flushManager.flush();
+      } catch (error) {
+        // Non-fatal - log and continue
+        console.warn(
+          "[hive_create_epic] Failed to sync to JSONL:",
+          error,
+        );
+      }
+
       return JSON.stringify(result, null, 2);
     } catch (error) {
       // Partial failure - rollback via deleteCell
@@ -790,7 +880,7 @@ export const hive_query = tool({
 export const hive_update = tool({
   description: "Update cell status/description",
   args: {
-    id: tool.schema.string().describe("Cell ID"),
+    id: tool.schema.string().describe("Cell ID or partial hash"),
     status: tool.schema
       .enum(["open", "in_progress", "blocked", "closed"])
       .optional()
@@ -809,26 +899,29 @@ export const hive_update = tool({
     const adapter = await getHiveAdapter(projectKey);
 
     try {
+      // Resolve partial ID to full ID
+      const cellId = await resolvePartialId(adapter, projectKey, validated.id) || validated.id;
+      
       let cell: AdapterCell;
 
       // Status changes use changeCellStatus, other fields use updateCell
       if (validated.status) {
         cell = await adapter.changeCellStatus(
           projectKey,
-          validated.id,
+          cellId,
           validated.status,
         );
       }
 
       // Update other fields if provided
       if (validated.description !== undefined || validated.priority !== undefined) {
-        cell = await adapter.updateCell(projectKey, validated.id, {
+        cell = await adapter.updateCell(projectKey, cellId, {
           description: validated.description,
           priority: validated.priority,
         });
       } else if (!validated.status) {
         // No changes requested
-        const existingCell = await adapter.getCell(projectKey, validated.id);
+        const existingCell = await adapter.getCell(projectKey, cellId);
         if (!existingCell) {
           throw new HiveError(
             `Cell not found: ${validated.id}`,
@@ -838,12 +931,27 @@ export const hive_update = tool({
         cell = existingCell;
       }
 
-      await adapter.markDirty(projectKey, validated.id);
+      await adapter.markDirty(projectKey, cellId);
 
       const formatted = formatCellForOutput(cell!);
       return JSON.stringify(formatted, null, 2);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
+      
+      // Provide helpful error messages
+      if (message.includes("Ambiguous hash")) {
+        throw new HiveError(
+          `Ambiguous ID '${validated.id}': multiple cells match. Please provide more characters.`,
+          "hive_update",
+        );
+      }
+      if (message.includes("Bead not found") || message.includes("Cell not found")) {
+        throw new HiveError(
+          `No cell found matching ID '${validated.id}'`,
+          "hive_update",
+        );
+      }
+      
       throw new HiveError(
         `Failed to update cell: ${message}`,
         "hive_update",
@@ -858,7 +966,7 @@ export const hive_update = tool({
 export const hive_close = tool({
   description: "Close a cell with reason",
   args: {
-    id: tool.schema.string().describe("Cell ID"),
+    id: tool.schema.string().describe("Cell ID or partial hash"),
     reason: tool.schema.string().describe("Completion reason"),
   },
   async execute(args, ctx) {
@@ -867,17 +975,35 @@ export const hive_close = tool({
     const adapter = await getHiveAdapter(projectKey);
 
     try {
+      // Resolve partial ID to full ID
+      const cellId = await resolvePartialId(adapter, projectKey, validated.id) || validated.id;
+      
       const cell = await adapter.closeCell(
         projectKey,
-        validated.id,
+        cellId,
         validated.reason,
       );
 
-      await adapter.markDirty(projectKey, validated.id);
+      await adapter.markDirty(projectKey, cellId);
 
       return `Closed ${cell.id}: ${validated.reason}`;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
+      
+      // Provide helpful error messages
+      if (message.includes("Ambiguous hash")) {
+        throw new HiveError(
+          `Ambiguous ID '${validated.id}': multiple cells match. Please provide more characters.`,
+          "hive_close",
+        );
+      }
+      if (message.includes("Bead not found") || message.includes("Cell not found")) {
+        throw new HiveError(
+          `No cell found matching ID '${validated.id}'`,
+          "hive_close",
+        );
+      }
+      
       throw new HiveError(
         `Failed to close cell: ${message}`,
         "hive_close",
@@ -893,24 +1019,42 @@ export const hive_start = tool({
   description:
     "Mark a cell as in-progress (shortcut for update --status in_progress)",
   args: {
-    id: tool.schema.string().describe("Cell ID"),
+    id: tool.schema.string().describe("Cell ID or partial hash"),
   },
   async execute(args, ctx) {
     const projectKey = getHiveWorkingDirectory();
     const adapter = await getHiveAdapter(projectKey);
 
     try {
+      // Resolve partial ID to full ID
+      const cellId = await resolvePartialId(adapter, projectKey, args.id) || args.id;
+      
       const cell = await adapter.changeCellStatus(
         projectKey,
-        args.id,
+        cellId,
         "in_progress",
       );
 
-      await adapter.markDirty(projectKey, args.id);
+      await adapter.markDirty(projectKey, cellId);
 
       return `Started: ${cell.id}`;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
+      
+      // Provide helpful error messages
+      if (message.includes("Ambiguous hash")) {
+        throw new HiveError(
+          `Ambiguous ID '${args.id}': multiple cells match. Please provide more characters.`,
+          "hive_start",
+        );
+      }
+      if (message.includes("Bead not found") || message.includes("Cell not found")) {
+        throw new HiveError(
+          `No cell found matching ID '${args.id}'`,
+          "hive_start",
+        );
+      }
+      
       throw new HiveError(
         `Failed to start cell: ${message}`,
         "hive_start",

package/src/swarm-decompose.ts

@@ -52,7 +52,7 @@ Agents MUST update their bead status as they work. No silent progress.
 
 ## Requirements
 
-1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel
+1. **Break into independent subtasks** that can run in parallel (as many as needed)
 2. **Assign files** - each subtask must specify which files it will modify
 3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)
 4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array
@@ -129,7 +129,7 @@ Agents MUST update their bead status as they work. No silent progress.
 
 ## Requirements
 
-1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel
+1. **Break into independent subtasks** that can run in parallel (as many as needed)
 2. **Assign files** - each subtask must specify which files it will modify
 3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)
 4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array
@@ -437,10 +437,9 @@ export const swarm_decompose = tool({
     max_subtasks: tool.schema
       .number()
       .int()
-      .min(2)
-      .max(10)
-      .default(5)
-      .describe("Maximum number of subtasks (default: 5)"),
+      .min(1)
+      .optional()
+      .describe("Suggested max subtasks (optional - LLM decides if not specified)"),
     context: tool.schema
       .string()
       .optional()
@@ -453,7 +452,6 @@ export const swarm_decompose = tool({
       .number()
       .int()
       .min(1)
-      .max(10)
       .optional()
       .describe("Max CASS results to include (default: 3)"),
   },
@@ -702,11 +700,9 @@ export const swarm_delegate_planning = tool({
     max_subtasks: tool.schema
       .number()
       .int()
-      .min(2)
-      .max(10)
+      .min(1)
       .optional()
-      .default(5)
-      .describe("Maximum number of subtasks (default: 5)"),
+      .describe("Suggested max subtasks (optional - LLM decides if not specified)"),
     strategy: tool.schema
       .enum(["auto", "file-based", "feature-based", "risk-based"])
       .optional()