opencode-swarm-plugin 0.30.7 → 0.31.1

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
@@ -514,10 +587,10 @@ function formatCellForOutput(adapterCell: AdapterCell): Record<string, unknown>
     status: adapterCell.status,
     priority: adapterCell.priority,
     issue_type: adapterCell.type, // Adapter: type → Schema: issue_type
-    created_at: new Date(adapterCell.created_at).toISOString(),
-    updated_at: new Date(adapterCell.updated_at).toISOString(),
+    created_at: new Date(Number(adapterCell.created_at)).toISOString(),
+    updated_at: new Date(Number(adapterCell.updated_at)).toISOString(),
     closed_at: adapterCell.closed_at
-      ? new Date(adapterCell.closed_at).toISOString()
+      ? new Date(Number(adapterCell.closed_at)).toISOString()
       : undefined,
     parent_id: adapterCell.parent_id || undefined,
     dependencies: [], // TODO: fetch from adapter if needed
@@ -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()

package/src/swarm-orchestrate.ts

@@ -72,7 +72,7 @@ import {
   isToolAvailable,
   warnMissingTool,
 } from "./tool-availability";
-import { getHiveAdapter } from "./hive";
+import { getHiveAdapter, hive_sync, setHiveWorkingDirectory, getHiveWorkingDirectory } from "./hive";
 import { listSkills } from "./skills";
 import {
   canUseWorktreeIsolation,
@@ -1570,6 +1570,30 @@ This will be recorded as a negative learning signal.`;
         );
       }
 
+      // Sync cell to .hive/issues.jsonl (auto-sync on complete)
+      // This ensures the worker's completed work persists before process exits
+      let syncSuccess = false;
+      let syncError: string | undefined;
+      try {
+        // Save current working directory and set to project path
+        const previousWorkingDir = getHiveWorkingDirectory();
+        setHiveWorkingDirectory(args.project_key);
+        
+        try {
+          const syncResult = await hive_sync.execute({ auto_pull: false }, _ctx);
+          syncSuccess = !syncResult.includes("error");
+        } finally {
+          // Restore previous working directory
+          setHiveWorkingDirectory(previousWorkingDir);
+        }
+      } catch (error) {
+        // Non-fatal - log warning but don't block completion
+        syncError = error instanceof Error ? error.message : String(error);
+        console.warn(
+          `[swarm_complete] Auto-sync failed (non-fatal): ${syncError}`,
+        );
+      }
+
       // Emit SubtaskOutcomeEvent for learning system
       try {
         const epicId = args.bead_id.includes(".")
@@ -1709,6 +1733,8 @@ This will be recorded as a negative learning signal.`;
         bead_id: args.bead_id,
         closed: true,
         reservations_released: true,
+        synced: syncSuccess,
+        sync_error: syncError,
         message_sent: messageSent,
         message_error: messageError,
         agent_registration: {

package/src/swarm-prompts.ts

@@ -46,7 +46,7 @@ Agents MUST update their cell 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
@@ -123,7 +123,7 @@ Agents MUST update their cell 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
@@ -927,10 +927,9 @@ export const swarm_plan_prompt = 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()
@@ -943,7 +942,6 @@ export const swarm_plan_prompt = tool({
       .number()
       .int()
       .min(1)
-      .max(10)
       .optional()
       .describe("Max CASS results to include (default: 3)"),
     include_skills: tool.schema

package/src/swarm.integration.test.ts

@@ -2341,4 +2341,74 @@ describe("Contract Validation", () => {
       expect(parsed.error).toBeUndefined();
     });
   });
+
+  describe("swarm_complete auto-sync", () => {
+    it("calls hive_sync after closing cell on successful completion", async () => {
+      const testProjectPath = "/tmp/swarm-auto-sync-test-" + Date.now();
+      const { getHiveAdapter } = await import("./hive");
+      const adapter = await getHiveAdapter(testProjectPath);
+
+      // Create a task cell directly
+      const cell = await adapter.createCell(testProjectPath, {
+        title: "Test task for auto-sync",
+        type: "task",
+        priority: 2,
+      });
+
+      // Start the task
+      await adapter.updateCell(testProjectPath, cell.id, {
+        status: "in_progress",
+      });
+
+      // Complete with skip_review and skip_verification
+      const result = await swarm_complete.execute(
+        {
+          project_key: testProjectPath,
+          agent_name: "TestAgent",
+          bead_id: cell.id,
+          summary: "Done - testing auto-sync",
+          files_touched: [],
+          skip_verification: true,
+          skip_review: true,
+        },
+        mockContext,
+      );
+
+      const parsed = JSON.parse(result);
+
+      // Should complete successfully
+      expect(parsed.success).toBe(true);
+      expect(parsed.closed).toBe(true);
+
+      // Check that cell is actually closed in database
+      const closedCell = await adapter.getCell(testProjectPath, cell.id);
+      expect(closedCell?.status).toBe("closed");
+
+      // The sync should have flushed the cell to .hive/issues.jsonl
+      // We can verify the cell appears in the JSONL
+      const hivePath = `${testProjectPath}/.hive/issues.jsonl`;
+      const hiveFile = Bun.file(hivePath);
+      const exists = await hiveFile.exists();
+
+      // The file should exist after sync
+      expect(exists).toBe(true);
+
+      if (exists) {
+        const content = await hiveFile.text();
+        const lines = content.trim().split("\n");
+
+        // Should have at least one cell exported
+        expect(lines.length).toBeGreaterThan(0);
+
+        // Parse the exported cells to find our closed cell
+        const cells = lines.map((line) => JSON.parse(line));
+        const exportedCell = cells.find((c) => c.id === cell.id);
+
+        // Our cell should be in the export
+        expect(exportedCell).toBeDefined();
+        expect(exportedCell.status).toBe("closed");
+        expect(exportedCell.title).toBe("Test task for auto-sync");
+      }
+    });
+  });
 });