opencode-swarm-plugin 0.17.1 → 0.18.0

package/dist/plugin.js

@@ -12810,6 +12810,11 @@ var init_events = __esm(() => {
 async function appendEvent(event, projectPath) {
   const db = await getDatabase(projectPath);
   const { type, project_key, timestamp, ...rest } = event;
+  console.log("[SwarmMail] Appending event", {
+    type,
+    projectKey: project_key,
+    timestamp
+  });
   const result = await db.query(`INSERT INTO events (type, project_key, timestamp, data)
      VALUES ($1, $2, $3, $4)
      RETURNING id, sequence`, [type, project_key, timestamp, JSON.stringify(rest)]);
@@ -12818,6 +12823,13 @@ async function appendEvent(event, projectPath) {
     throw new Error("Failed to insert event - no row returned");
   }
   const { id, sequence } = row;
+  console.log("[SwarmMail] Event appended", {
+    type,
+    id,
+    sequence,
+    projectKey: project_key
+  });
+  console.debug("[SwarmMail] Updating materialized views", { type, id });
   await updateMaterializedViews(db, { ...event, id, sequence });
   return { ...event, id, sequence };
 }
@@ -12841,9 +12853,13 @@ async function appendEvents(events, projectPath) {
       results.push(enrichedEvent);
     }
     await db.exec("COMMIT");
-  } catch (error45) {
-    await db.exec("ROLLBACK");
-    throw error45;
+  } catch (e) {
+    try {
+      await db.exec("ROLLBACK");
+    } catch (rollbackError) {
+      console.error("[SwarmMail] ROLLBACK failed:", rollbackError);
+    }
+    throw e;
   }
   return results;
 }
@@ -12946,33 +12962,42 @@ async function replayEvents(options2 = {}, projectPath) {
   };
 }
 async function updateMaterializedViews(db, event) {
-  switch (event.type) {
-    case "agent_registered":
-      await handleAgentRegistered(db, event);
-      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);
-      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);
-      break;
-    case "file_released":
-      await handleFileReleased(db, event);
-      break;
-    case "task_started":
-    case "task_progress":
-    case "task_completed":
-    case "task_blocked":
-      break;
+  try {
+    switch (event.type) {
+      case "agent_registered":
+        await handleAgentRegistered(db, event);
+        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);
+        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);
+        break;
+      case "file_released":
+        await handleFileReleased(db, event);
+        break;
+      case "task_started":
+      case "task_progress":
+      case "task_completed":
+      case "task_blocked":
+        break;
+    }
+  } catch (error45) {
+    console.error("[SwarmMail] Failed to update materialized views", {
+      eventType: event.type,
+      eventId: event.id,
+      error: error45
+    });
+    throw error45;
   }
 }
 async function handleAgentRegistered(db, event) {
@@ -12992,6 +13017,12 @@ async function handleAgentRegistered(db, event) {
   ]);
 }
 async function handleMessageSent(db, event) {
+  console.log("[SwarmMail] Handling message sent event", {
+    from: event.from_agent,
+    to: event.to_agents,
+    subject: event.subject,
+    projectKey: event.project_key
+  });
   const result = await db.query(`INSERT INTO messages (project_key, from_agent, subject, body, thread_id, importance, ack_required, created_at)
      VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
      RETURNING id`, [
@@ -13009,24 +13040,42 @@ async function handleMessageSent(db, event) {
     throw new Error("Failed to insert message - no row returned");
   }
   const messageId = msgRow.id;
-  for (const agent of event.to_agents) {
+  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)
-       ON CONFLICT DO NOTHING`, [messageId, agent]);
+       VALUES ${values}
+       ON CONFLICT DO NOTHING`, params);
+    console.log("[SwarmMail] Message recipients inserted", {
+      messageId,
+      recipientCount: event.to_agents.length
+    });
   }
 }
 async function handleFileReserved(db, event) {
-  for (const path of event.paths) {
-    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)`, [
+  console.log("[SwarmMail] Handling file reservation event", {
+    agent: event.agent_name,
+    paths: event.paths,
+    exclusive: event.exclusive,
+    projectKey: event.project_key
+  });
+  if (event.paths.length > 0) {
+    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,
       event.agent_name,
-      path,
+      ...event.paths,
       event.exclusive,
       event.reason || null,
       event.timestamp,
       event.expires_at
-    ]);
+    ];
+    await db.query(`INSERT INTO reservations (project_key, agent_name, path_pattern, exclusive, reason, created_at, expires_at)
+       VALUES ${values}`, params);
+    console.log("[SwarmMail] File reservations inserted", {
+      agent: event.agent_name,
+      reservationCount: event.paths.length
+    });
   }
 }
 async function handleFileReleased(db, event) {
@@ -14592,6 +14641,12 @@ async function checkConflicts(projectKey, agentName, paths, projectPath) {
     }
     for (const path2 of paths) {
       if (pathMatches(path2, reservation.path_pattern)) {
+        console.warn("[SwarmMail] Conflict detected", {
+          path: path2,
+          holder: reservation.agent_name,
+          pattern: reservation.path_pattern,
+          requestedBy: agentName
+        });
         conflicts.push({
           path: path2,
           holder: reservation.agent_name,
@@ -14601,6 +14656,13 @@ async function checkConflicts(projectKey, agentName, paths, projectPath) {
       }
     }
   }
+  if (conflicts.length > 0) {
+    console.warn("[SwarmMail] Total conflicts detected", {
+      count: conflicts.length,
+      requestedBy: agentName,
+      paths
+    });
+  }
   return conflicts;
 }
 function pathMatches(path2, pattern) {
@@ -15271,6 +15333,7 @@ var init_migrations = __esm(() => {
 // src/streams/index.ts
 var exports_streams = {};
 __export(exports_streams, {
+  withTimeout: () => withTimeout,
   sendSwarmMessage: () => sendSwarmMessage,
   sendMessage: () => sendMessage,
   sendAgentMessage: () => sendAgentMessage,
@@ -15343,6 +15406,10 @@ import { PGlite } from "@electric-sql/pglite";
 import { existsSync, mkdirSync, appendFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
+async function withTimeout(promise2, ms, operation) {
+  const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error(`${operation} timed out after ${ms}ms`)), ms));
+  return Promise.race([promise2, timeout]);
+}
 function debugLog(message, data) {
   const timestamp = new Date().toISOString();
   const logLine = data ? `[${timestamp}] ${message}: ${JSON.stringify(data, null, 2)}
@@ -30659,14 +30726,35 @@ class SqliteRateLimiter {
     }
     return { allowed, remaining, resetAt };
   }
+  cleanup() {
+    const BATCH_SIZE = 1000;
+    const MAX_BATCHES = 10;
+    const cutoff = Date.now() - 7200000;
+    let totalDeleted = 0;
+    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;
+      if (result.changes < BATCH_SIZE)
+        break;
+    }
+    if (totalDeleted > 0) {
+      console.log("[RateLimiter] Cleanup completed:", {
+        deletedRows: totalDeleted
+      });
+    }
+  }
   async recordRequest(agentName, endpoint) {
     const now = Date.now();
     const stmt = this.db.prepare(`INSERT INTO rate_limits (agent_name, endpoint, window, timestamp) VALUES (?, ?, ?, ?)`);
     stmt.run(agentName, endpoint, "minute", now);
     stmt.run(agentName, endpoint, "hour", now);
     if (Math.random() < 0.01) {
-      const cutoff = Date.now() - 7200000;
-      this.db.run(`DELETE FROM rate_limits WHERE timestamp < ?`, [cutoff]);
+      this.cleanup();
     }
   }
   async close() {
@@ -32593,6 +32681,36 @@ class ErrorAccumulator {
     };
   }
 }
+function formatMemoryStoreOnSuccess(beadId, summary, filesTouched, strategy) {
+  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"
+  };
+}
+function formatMemoryStoreOn3Strike(beadId, failures) {
+  const failuresList = failures.map((f, i) => `${i + 1}. ${f.attempt} - Failed: ${f.reason}`).join(`
+`);
+  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"
+  };
+}
+function formatMemoryQueryForDecomposition(task, limit = 3) {
+  return {
+    query: task,
+    limit,
+    instruction: "Query semantic-memory for relevant past learnings about similar tasks before decomposition"
+  };
+}
 
 // src/swarm.ts
 init_skills();
@@ -33512,7 +33630,136 @@ ${args.context}` : `## Additional Context
       },
       validation_note: "Parse agent response as JSON and validate with swarm_validate_decomposition",
       cass_history: cassResultInfo,
-      skills: skillsInfo
+      skills: skillsInfo,
+      memory_query: formatMemoryQueryForDecomposition(args.task, 3)
+    }, null, 2);
+  }
+});
+var swarm_delegate_planning = tool({
+  description: "Delegate task decomposition to a swarm/planner subagent. Returns a prompt to spawn the planner. Use this to keep coordinator context lean - all planning reasoning happens in the subagent.",
+  args: {
+    task: tool.schema.string().min(1).describe("The task to decompose"),
+    context: tool.schema.string().optional().describe("Additional context to include"),
+    max_subtasks: tool.schema.number().int().min(2).max(10).optional().default(5).describe("Maximum number of subtasks (default: 5)"),
+    strategy: tool.schema.enum(["auto", "file-based", "feature-based", "risk-based"]).optional().default("auto").describe("Decomposition strategy (default: auto-detect)"),
+    query_cass: tool.schema.boolean().optional().default(true).describe("Query CASS for similar past tasks (default: true)")
+  },
+  async execute(args) {
+    let selectedStrategy;
+    let strategyReasoning;
+    if (args.strategy && args.strategy !== "auto") {
+      selectedStrategy = args.strategy;
+      strategyReasoning = `User-specified strategy: ${selectedStrategy}`;
+    } else {
+      const selection = selectStrategy(args.task);
+      selectedStrategy = selection.strategy;
+      strategyReasoning = selection.reasoning;
+    }
+    let cassContext = "";
+    let cassResultInfo;
+    if (args.query_cass !== false) {
+      const cassResult = await queryCassHistory(args.task, 3);
+      if (cassResult.status === "success") {
+        cassContext = formatCassHistoryForPrompt(cassResult.data);
+        cassResultInfo = {
+          queried: true,
+          results_found: cassResult.data.results.length,
+          included_in_context: true
+        };
+      } else {
+        cassResultInfo = {
+          queried: true,
+          results_found: 0,
+          included_in_context: false,
+          reason: cassResult.status
+        };
+      }
+    } else {
+      cassResultInfo = { queried: false, reason: "disabled" };
+    }
+    let skillsContext = "";
+    let skillsInfo = {
+      included: false
+    };
+    const allSkills = await listSkills();
+    if (allSkills.length > 0) {
+      skillsContext = await getSkillsContextForSwarm();
+      const relevantSkills = await findRelevantSkills(args.task);
+      skillsInfo = {
+        included: true,
+        count: allSkills.length,
+        relevant: relevantSkills
+      };
+      if (relevantSkills.length > 0) {
+        skillsContext += `
+
+**Suggested skills for this task**: ${relevantSkills.join(", ")}`;
+      }
+    }
+    const strategyGuidelines = formatStrategyGuidelines(selectedStrategy);
+    const contextSection = args.context ? `## Additional Context
+${args.context}` : `## Additional Context
+(none provided)`;
+    const planningPrompt = STRATEGY_DECOMPOSITION_PROMPT.replace("{task}", args.task).replace("{strategy_guidelines}", strategyGuidelines).replace("{context_section}", contextSection).replace("{cass_history}", cassContext || "").replace("{skills_context}", skillsContext || "").replace("{max_subtasks}", (args.max_subtasks ?? 5).toString());
+    const subagentInstructions = `
+## CRITICAL: Output Format
+
+You are a planner subagent. Your ONLY output must be valid JSON matching the BeadTree schema.
+
+DO NOT include:
+- Explanatory text before or after the JSON
+- Markdown code fences (\`\`\`json)
+- Commentary or reasoning
+
+OUTPUT ONLY the raw JSON object.
+
+## Example Output
+
+{
+  "epic": {
+    "title": "Add user authentication",
+    "description": "Implement OAuth-based authentication system"
+  },
+  "subtasks": [
+    {
+      "title": "Set up OAuth provider",
+      "description": "Configure OAuth client credentials and redirect URLs",
+      "files": ["src/auth/oauth.ts", "src/config/auth.ts"],
+      "dependencies": [],
+      "estimated_complexity": 2
+    },
+    {
+      "title": "Create auth routes",
+      "description": "Implement login, logout, and callback routes",
+      "files": ["src/app/api/auth/[...nextauth]/route.ts"],
+      "dependencies": [0],
+      "estimated_complexity": 3
+    }
+  ]
+}
+
+Now generate the BeadTree for the given task.`;
+    const fullPrompt = `${planningPrompt}
+
+${subagentInstructions}`;
+    return JSON.stringify({
+      prompt: fullPrompt,
+      subagent_type: "swarm/planner",
+      description: "Task decomposition planning",
+      strategy: {
+        selected: selectedStrategy,
+        reasoning: strategyReasoning
+      },
+      expected_output: "BeadTree JSON (raw JSON, no markdown)",
+      next_steps: [
+        "1. Spawn subagent with Task tool using returned prompt",
+        "2. Parse subagent response as JSON",
+        "3. Validate with swarm_validate_decomposition",
+        "4. Create beads with beads_create_epic"
+      ],
+      cass_history: cassResultInfo,
+      skills: skillsInfo,
+      memory_query: formatMemoryQueryForDecomposition(args.task, 3)
     }, null, 2);
   }
 });
@@ -33568,7 +33815,8 @@ var swarm_decompose = tool({
         ]
       },
       validation_note: "Parse agent response as JSON and validate with BeadTreeSchema from schemas/bead.ts",
-      cass_history: cassResultInfo
+      cass_history: cassResultInfo,
+      memory_query: formatMemoryQueryForDecomposition(args.task, 3)
     }, null, 2);
   }
 });
@@ -34085,7 +34333,7 @@ var swarm_complete = tool({
       threadId: epicId,
       importance: "normal"
     });
-    return JSON.stringify({
+    const response = {
       success: true,
       bead_id: args.bead_id,
       closed: true,
@@ -34121,8 +34369,10 @@ Did you learn anything reusable during this subtask? Consider:
 
 If you discovered something valuable, use \`swarm_learn\` or \`skills_create\` to preserve it as a skill for future swarms.
 
-Files touched: ${args.files_touched?.join(", ") || "none recorded"}`
-    }, null, 2);
+Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
+      memory_store: formatMemoryStoreOnSuccess(args.bead_id, args.summary, args.files_touched || [])
+    };
+    return JSON.stringify(response, null, 2);
   }
 });
 function classifyFailure(error45) {
@@ -34658,6 +34908,7 @@ var swarmTools = {
   swarm_init,
   swarm_select_strategy,
   swarm_plan_prompt,
+  swarm_delegate_planning,
   swarm_decompose,
   swarm_validate_decomposition,
   swarm_status,
@@ -34704,14 +34955,18 @@ var swarm_check_strikes = tool({
         }
         const record2 = await addStrike(args.bead_id, args.attempt, args.reason, globalStrikeStorage);
         const strikedOut = record2.strike_count >= 3;
-        return JSON.stringify({
+        const response = {
           bead_id: args.bead_id,
           strike_count: record2.strike_count,
           is_striked_out: strikedOut,
           failures: record2.failures,
           message: strikedOut ? "⚠️ STRUCK OUT: 3 strikes reached. STOP and question the architecture." : `Strike ${record2.strike_count} recorded. ${3 - record2.strike_count} remaining.`,
           warning: strikedOut ? "DO NOT attempt Fix #4. Call with action=get_prompt for architecture review." : undefined
-        }, null, 2);
+        };
+        if (strikedOut) {
+          response.memory_store = formatMemoryStoreOn3Strike(args.bead_id, record2.failures);
+        }
+        return JSON.stringify(response, null, 2);
       }
       case "clear": {
         await clearStrikes(args.bead_id, globalStrikeStorage);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "dist/index.js",

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();
     }
   }