opencode-swarm-plugin 0.17.0 → 0.18.0

package/src/learning.ts

@@ -956,6 +956,112 @@ export class ErrorAccumulator {
   }
 }
 
+// ============================================================================
+// Semantic Memory Integration Helpers
+// ============================================================================
+
+/**
+ * Format memory store instruction for successful task completion
+ *
+ * @param beadId - Bead ID that completed
+ * @param summary - Completion summary
+ * @param filesTouched - Files modified
+ * @param strategy - Decomposition strategy used (if applicable)
+ * @returns Memory store instruction object
+ */
+export function formatMemoryStoreOnSuccess(
+  beadId: string,
+  summary: string,
+  filesTouched: string[],
+  strategy?: DecompositionStrategy,
+): {
+  information: string;
+  metadata: string;
+  instruction: string;
+} {
+  const strategyInfo = strategy ? ` using ${strategy} strategy` : "";
+
+  return {
+    information: `Task "${beadId}" completed successfully${strategyInfo}.
+Key insight: ${summary}
+Files touched: ${filesTouched.join(", ") || "none"}`,
+    metadata: `swarm, success, ${beadId}, ${strategy || "completion"}`,
+    instruction:
+      "Store this successful completion in semantic-memory for future reference",
+  };
+}
+
+/**
+ * Format memory store instruction for architectural problems (3-strike)
+ *
+ * @param beadId - Bead ID that struck out
+ * @param failures - Array of failure attempts
+ * @returns Memory store instruction object
+ */
+export function formatMemoryStoreOn3Strike(
+  beadId: string,
+  failures: Array<{ attempt: string; reason: string }>,
+): {
+  information: string;
+  metadata: string;
+  instruction: string;
+} {
+  const failuresList = failures
+    .map((f, i) => `${i + 1}. ${f.attempt} - Failed: ${f.reason}`)
+    .join("\n");
+
+  return {
+    information: `Architecture problem detected in ${beadId}: Task failed after 3 attempts.
+Attempts:
+${failuresList}
+
+This indicates a structural issue requiring human decision, not another fix attempt.`,
+    metadata: `architecture, 3-strike, ${beadId}, failure`,
+    instruction:
+      "Store this architectural problem in semantic-memory to avoid similar patterns in future",
+  };
+}
+
+/**
+ * Format memory query instruction for task decomposition
+ *
+ * @param task - Task description
+ * @param limit - Max results to return
+ * @returns Memory query instruction object
+ */
+export function formatMemoryQueryForDecomposition(
+  task: string,
+  limit: number = 3,
+): {
+  query: string;
+  limit: number;
+  instruction: string;
+} {
+  return {
+    query: task,
+    limit,
+    instruction:
+      "Query semantic-memory for relevant past learnings about similar tasks before decomposition",
+  };
+}
+
+/**
+ * Format memory validation hint when CASS history helped
+ *
+ * @param beadId - Bead ID that benefited from CASS
+ * @returns Memory validation hint
+ */
+export function formatMemoryValidationHint(beadId: string): {
+  instruction: string;
+  context: string;
+} {
+  return {
+    instruction:
+      "If any semantic-memory entries helped with this task, validate them to reset decay timer",
+    context: `Task ${beadId} completed successfully with assistance from past learnings`,
+  };
+}
+
 // ============================================================================
 // Exports
 // ============================================================================

package/src/rate-limiter.ts

@@ -35,12 +35,15 @@ import { homedir } from "node:os";
 // SQLite is optional - only available in Bun runtime
 // We use dynamic import to avoid breaking Node.js environments
 interface BunDatabase {
-  run(sql: string, params?: unknown[]): void;
+  run(
+    sql: string,
+    params?: unknown[],
+  ): { changes: number; lastInsertRowid: number };
   query<T>(sql: string): {
     get(...params: unknown[]): T | null;
   };
   prepare(sql: string): {
-    run(...params: unknown[]): void;
+    run(...params: unknown[]): { changes: number; lastInsertRowid: number };
   };
   close(): void;
 }
@@ -453,6 +456,47 @@ export class SqliteRateLimiter implements RateLimiter {
     return { allowed, remaining, resetAt };
   }
 
+  /**
+   * Clean up old rate limit entries in bounded batches
+   *
+   * Limits cleanup to prevent blocking recordRequest on large datasets:
+   * - BATCH_SIZE: 1000 rows per iteration
+   * - MAX_BATCHES: 10 (max 10k rows per cleanup invocation)
+   *
+   * Stops early if fewer than BATCH_SIZE rows deleted (no more to clean).
+   */
+  private cleanup(): void {
+    const BATCH_SIZE = 1000;
+    const MAX_BATCHES = 10;
+    const cutoff = Date.now() - 7_200_000; // 2 hours
+
+    let totalDeleted = 0;
+
+    // Run bounded batches
+    for (let i = 0; i < MAX_BATCHES; i++) {
+      const result = this.db.run(
+        `DELETE FROM rate_limits 
+         WHERE rowid IN (
+           SELECT rowid FROM rate_limits 
+           WHERE timestamp < ? 
+           LIMIT ?
+         )`,
+        [cutoff, BATCH_SIZE],
+      );
+
+      totalDeleted += result.changes;
+
+      // Stop if we deleted less than batch size (no more to delete)
+      if (result.changes < BATCH_SIZE) break;
+    }
+
+    if (totalDeleted > 0) {
+      console.log("[RateLimiter] Cleanup completed:", {
+        deletedRows: totalDeleted,
+      });
+    }
+  }
+
   async recordRequest(agentName: string, endpoint: string): Promise<void> {
     const now = Date.now();
 
@@ -465,9 +509,9 @@ export class SqliteRateLimiter implements RateLimiter {
     stmt.run(agentName, endpoint, "hour", now);
 
     // Opportunistic cleanup of old entries (1% chance to avoid overhead)
+    // Now bounded to prevent blocking on large datasets
     if (Math.random() < 0.01) {
-      const cutoff = Date.now() - 7_200_000;
-      this.db.run(`DELETE FROM rate_limits WHERE timestamp < ?`, [cutoff]);
+      this.cleanup();
     }
   }
 

package/src/streams/index.ts

@@ -12,6 +12,35 @@ import { existsSync, mkdirSync, appendFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 
+// ============================================================================
+// Query Timeout Wrapper
+// ============================================================================
+
+const DEFAULT_QUERY_TIMEOUT_MS = 30000; // 30 seconds
+
+/**
+ * Wrap a promise with a timeout
+ *
+ * @param promise - The promise to wrap
+ * @param ms - Timeout in milliseconds
+ * @param operation - Operation name for error message
+ * @returns The result of the promise
+ * @throws Error if timeout is reached
+ */
+export async function withTimeout<T>(
+  promise: Promise<T>,
+  ms: number,
+  operation: string,
+): Promise<T> {
+  const timeout = new Promise<never>((_, reject) =>
+    setTimeout(
+      () => reject(new Error(`${operation} timed out after ${ms}ms`)),
+      ms,
+    ),
+  );
+  return Promise.race([promise, timeout]);
+}
+
 // ============================================================================
 // Debug Logging
 // ============================================================================

package/src/streams/projections.ts

@@ -275,6 +275,13 @@ export async function checkConflicts(
     // Check each requested path against the reservation pattern
     for (const path of paths) {
       if (pathMatches(path, reservation.path_pattern)) {
+        console.warn("[SwarmMail] Conflict detected", {
+          path,
+          holder: reservation.agent_name,
+          pattern: reservation.path_pattern,
+          requestedBy: agentName,
+        });
+
         conflicts.push({
           path,
           holder: reservation.agent_name,
@@ -285,6 +292,14 @@ export async function checkConflicts(
     }
   }
 
+  if (conflicts.length > 0) {
+    console.warn("[SwarmMail] Total conflicts detected", {
+      count: conflicts.length,
+      requestedBy: agentName,
+      paths,
+    });
+  }
+
   return conflicts;
 }
 

package/src/streams/store.ts

@@ -35,6 +35,12 @@ export async function appendEvent(
   // Extract common fields
   const { type, project_key, timestamp, ...rest } = event;
 
+  console.log("[SwarmMail] Appending event", {
+    type,
+    projectKey: project_key,
+    timestamp,
+  });
+
   // Insert event
   const result = await db.query<{ id: number; sequence: number }>(
     `INSERT INTO events (type, project_key, timestamp, data)
@@ -49,7 +55,15 @@ export async function appendEvent(
   }
   const { id, sequence } = row;
 
+  console.log("[SwarmMail] Event appended", {
+    type,
+    id,
+    sequence,
+    projectKey: project_key,
+  });
+
   // Update materialized views based on event type
+  console.debug("[SwarmMail] Updating materialized views", { type, id });
   await updateMaterializedViews(db, { ...event, id, sequence });
 
   return { ...event, id, sequence };
@@ -88,9 +102,14 @@ export async function appendEvents(
       results.push(enrichedEvent);
     }
     await db.exec("COMMIT");
-  } catch (error) {
-    await db.exec("ROLLBACK");
-    throw error;
+  } catch (e) {
+    // FIX: Log rollback failures (connection lost, etc)
+    try {
+      await db.exec("ROLLBACK");
+    } catch (rollbackError) {
+      console.error("[SwarmMail] ROLLBACK failed:", rollbackError);
+    }
+    throw e;
   }
 
   return results;
@@ -285,60 +304,69 @@ async function updateMaterializedViews(
   db: Awaited<ReturnType<typeof getDatabase>>,
   event: AgentEvent & { id: number; sequence: number },
 ): Promise<void> {
-  switch (event.type) {
-    case "agent_registered":
-      await handleAgentRegistered(
-        db,
-        event as AgentRegisteredEvent & { id: number; sequence: number },
-      );
-      break;
-
-    case "agent_active":
-      await db.query(
-        `UPDATE agents SET last_active_at = $1 WHERE project_key = $2 AND name = $3`,
-        [event.timestamp, event.project_key, event.agent_name],
-      );
-      break;
-
-    case "message_sent":
-      await handleMessageSent(
-        db,
-        event as MessageSentEvent & { id: number; sequence: number },
-      );
-      break;
-
-    case "message_read":
-      await db.query(
-        `UPDATE message_recipients SET read_at = $1 WHERE message_id = $2 AND agent_name = $3`,
-        [event.timestamp, event.message_id, event.agent_name],
-      );
-      break;
-
-    case "message_acked":
-      await db.query(
-        `UPDATE message_recipients SET acked_at = $1 WHERE message_id = $2 AND agent_name = $3`,
-        [event.timestamp, event.message_id, event.agent_name],
-      );
-      break;
-
-    case "file_reserved":
-      await handleFileReserved(
-        db,
-        event as FileReservedEvent & { id: number; sequence: number },
-      );
-      break;
-
-    case "file_released":
-      await handleFileReleased(db, event);
-      break;
-
-    // Task events don't need materialized views (query events directly)
-    case "task_started":
-    case "task_progress":
-    case "task_completed":
-    case "task_blocked":
-      // No-op for now - could add task tracking table later
-      break;
+  try {
+    switch (event.type) {
+      case "agent_registered":
+        await handleAgentRegistered(
+          db,
+          event as AgentRegisteredEvent & { id: number; sequence: number },
+        );
+        break;
+
+      case "agent_active":
+        await db.query(
+          `UPDATE agents SET last_active_at = $1 WHERE project_key = $2 AND name = $3`,
+          [event.timestamp, event.project_key, event.agent_name],
+        );
+        break;
+
+      case "message_sent":
+        await handleMessageSent(
+          db,
+          event as MessageSentEvent & { id: number; sequence: number },
+        );
+        break;
+
+      case "message_read":
+        await db.query(
+          `UPDATE message_recipients SET read_at = $1 WHERE message_id = $2 AND agent_name = $3`,
+          [event.timestamp, event.message_id, event.agent_name],
+        );
+        break;
+
+      case "message_acked":
+        await db.query(
+          `UPDATE message_recipients SET acked_at = $1 WHERE message_id = $2 AND agent_name = $3`,
+          [event.timestamp, event.message_id, event.agent_name],
+        );
+        break;
+
+      case "file_reserved":
+        await handleFileReserved(
+          db,
+          event as FileReservedEvent & { id: number; sequence: number },
+        );
+        break;
+
+      case "file_released":
+        await handleFileReleased(db, event);
+        break;
+
+      // Task events don't need materialized views (query events directly)
+      case "task_started":
+      case "task_progress":
+      case "task_completed":
+      case "task_blocked":
+        // No-op for now - could add task tracking table later
+        break;
+    }
+  } catch (error) {
+    console.error("[SwarmMail] Failed to update materialized views", {
+      eventType: event.type,
+      eventId: event.id,
+      error,
+    });
+    throw error;
   }
 }
 
@@ -369,6 +397,13 @@ async function handleMessageSent(
   db: Awaited<ReturnType<typeof getDatabase>>,
   event: MessageSentEvent & { id: number; sequence: number },
 ): Promise<void> {
+  console.log("[SwarmMail] Handling message sent event", {
+    from: event.from_agent,
+    to: event.to_agents,
+    subject: event.subject,
+    projectKey: event.project_key,
+  });
+
   // Insert message
   const result = await db.query<{ id: number }>(
     `INSERT INTO messages (project_key, from_agent, subject, body, thread_id, importance, ack_required, created_at)
@@ -392,14 +427,22 @@ async function handleMessageSent(
   }
   const messageId = msgRow.id;
 
-  // Insert recipients
-  for (const agent of event.to_agents) {
+  // FIX: Bulk insert recipients to avoid N+1 queries
+  if (event.to_agents.length > 0) {
+    const values = event.to_agents.map((_, i) => `($1, $${i + 2})`).join(", ");
+    const params = [messageId, ...event.to_agents];
+
     await db.query(
       `INSERT INTO message_recipients (message_id, agent_name)
-       VALUES ($1, $2)
+       VALUES ${values}
        ON CONFLICT DO NOTHING`,
-      [messageId, agent],
+      params,
     );
+
+    console.log("[SwarmMail] Message recipients inserted", {
+      messageId,
+      recipientCount: event.to_agents.length,
+    });
   }
 }
 
@@ -407,20 +450,46 @@ async function handleFileReserved(
   db: Awaited<ReturnType<typeof getDatabase>>,
   event: FileReservedEvent & { id: number; sequence: number },
 ): Promise<void> {
-  for (const path of event.paths) {
+  console.log("[SwarmMail] Handling file reservation event", {
+    agent: event.agent_name,
+    paths: event.paths,
+    exclusive: event.exclusive,
+    projectKey: event.project_key,
+  });
+
+  // FIX: Bulk insert reservations to avoid N+1 queries
+  if (event.paths.length > 0) {
+    // Each path gets its own VALUES clause with placeholders:
+    // ($1=project_key, $2=agent_name, $3=path1, $4=exclusive, $5=reason, $6=created_at, $7=expires_at)
+    // ($1=project_key, $2=agent_name, $8=path2, $4=exclusive, $5=reason, $6=created_at, $7=expires_at)
+    // etc.
+    const values = event.paths
+      .map(
+        (_, i) =>
+          `($1, $2, $${i + 3}, $${event.paths.length + 3}, $${event.paths.length + 4}, $${event.paths.length + 5}, $${event.paths.length + 6})`,
+      )
+      .join(", ");
+
+    const params = [
+      event.project_key, // $1
+      event.agent_name, // $2
+      ...event.paths, // $3, $4, ... (one per path)
+      event.exclusive, // $N+3
+      event.reason || null, // $N+4
+      event.timestamp, // $N+5
+      event.expires_at, // $N+6
+    ];
+
     await db.query(
       `INSERT INTO reservations (project_key, agent_name, path_pattern, exclusive, reason, created_at, expires_at)
-       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
-      [
-        event.project_key,
-        event.agent_name,
-        path,
-        event.exclusive,
-        event.reason || null,
-        event.timestamp,
-        event.expires_at,
-      ],
+       VALUES ${values}`,
+      params,
     );
+
+    console.log("[SwarmMail] File reservations inserted", {
+      agent: event.agent_name,
+      reservationCount: event.paths.length,
+    });
   }
 }