opencode-swarm-plugin 0.59.1 → 0.59.5

package/dist/swarm-prompts.js

@@ -17285,7 +17285,7 @@ import {
   sep as sep2
 } from "path";
 import { fileURLToPath } from "url";
-import { getSwarmMailLibSQL as getSwarmMailLibSQL3, createEvent as createEvent2 } from "swarm-mail";
+import { getSwarmMailLibSQL as getSwarmMailLibSQL3, createEvent as createEvent3 } from "swarm-mail";
 function resolveGuidanceModel(model) {
   if (!model)
     return "unknown";
@@ -17328,7 +17328,7 @@ async function emitSkillLoadedEvent(data) {
   try {
     const projectPath = skillsProjectDirectory;
     const swarmMail = await getSwarmMailLibSQL3(projectPath);
-    const event = createEvent2("skill_loaded", {
+    const event = createEvent3("skill_loaded", {
       project_key: projectPath,
       skill_name: data.skill_name,
       skill_source: data.skill_source,
@@ -17342,7 +17342,7 @@ async function emitSkillCreatedEvent(data) {
   try {
     const projectPath = skillsProjectDirectory;
     const swarmMail = await getSwarmMailLibSQL3(projectPath);
-    const event = createEvent2("skill_created", {
+    const event = createEvent3("skill_created", {
       project_key: projectPath,
       skill_name: data.skill_name,
       skill_scope: data.skill_scope,
@@ -19414,6 +19414,27 @@ var init_storage = __esm(() => {
   };
 });
 
+// src/utils/adapter-cache.ts
+class AdapterCache {
+  cached = null;
+  cachedPath = null;
+  async get(projectPath, factory) {
+    if (this.cached && this.cachedPath === projectPath) {
+      return this.cached;
+    }
+    this.cached = await factory(projectPath);
+    this.cachedPath = projectPath;
+    return this.cached;
+  }
+  clear() {
+    this.cached = null;
+    this.cachedPath = null;
+  }
+  getCachedPath() {
+    return this.cachedPath;
+  }
+}
+
 // ../../node_modules/.bun/effect@3.19.12/node_modules/effect/dist/esm/Function.js
 function pipe2(a, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
@@ -36740,6 +36761,9 @@ Linked to ${result.links.length} related memor${result.links.length === 1 ? "y"
       };
     },
     async find(args2) {
+      if (!args2.query || typeof args2.query !== "string") {
+        throw new Error("query is required for find operation");
+      }
       const limit = args2.limit ?? 10;
       let results;
       let usedFallback = false;
@@ -36858,22 +36882,20 @@ var init_memory = __esm(() => {
 });
 
 // src/memory-tools.ts
-import { getSwarmMailLibSQL as getSwarmMailLibSQL5, createEvent as createEvent4, appendEvent as appendEvent3 } from "swarm-mail";
+import { getSwarmMailLibSQL as getSwarmMailLibSQL5, createEvent as createEvent5, appendEvent as appendEvent4 } from "swarm-mail";
 async function getMemoryAdapter(projectPath) {
   const path3 = projectPath || process.cwd();
-  if (cachedAdapter && cachedProjectPath === path3) {
-    return cachedAdapter;
-  }
-  const swarmMail = await getSwarmMailLibSQL5(path3);
-  const dbAdapter = await swarmMail.getDatabase();
-  cachedAdapter = await createMemoryAdapter(dbAdapter);
-  cachedProjectPath = path3;
-  return cachedAdapter;
+  return memoryAdapterCache.get(path3, async (projectPath2) => {
+    const swarmMail = await getSwarmMailLibSQL5(projectPath2);
+    const dbAdapter = await swarmMail.getDatabase();
+    return await createMemoryAdapter(dbAdapter);
+  });
 }
-var cachedAdapter = null, cachedProjectPath = null, semantic_memory_store, semantic_memory_find, semantic_memory_get, semantic_memory_remove, semantic_memory_validate, semantic_memory_list, semantic_memory_stats, semantic_memory_check, semantic_memory_upsert;
+var memoryAdapterCache, semantic_memory_store, semantic_memory_find, semantic_memory_get, semantic_memory_remove, semantic_memory_validate, semantic_memory_list, semantic_memory_stats, semantic_memory_check, semantic_memory_upsert;
 var init_memory_tools = __esm(() => {
   init_dist();
   init_memory();
+  memoryAdapterCache = new AdapterCache;
   semantic_memory_store = tool({
     description: "Store a memory with semantic embedding. Memories are searchable by semantic similarity and can be organized into collections. Confidence affects decay rate: high confidence (1.0) = 135 day half-life, low confidence (0.0) = 45 day half-life. Supports auto-tagging, auto-linking, and entity extraction via LLM.",
     args: {
@@ -36890,9 +36912,9 @@ var init_memory_tools = __esm(() => {
       const adapter = await getMemoryAdapter();
       const result = await adapter.store(args2);
       try {
-        const projectKey = cachedProjectPath || process.cwd();
+        const projectKey = memoryAdapterCache.getCachedPath() || process.cwd();
         const tags = args2.tags ? args2.tags.split(",").map((t) => t.trim()) : [];
-        const event = createEvent4("memory_stored", {
+        const event = createEvent5("memory_stored", {
           project_key: projectKey,
           memory_id: result.id,
           content_preview: args2.information.slice(0, 100),
@@ -36900,7 +36922,7 @@ var init_memory_tools = __esm(() => {
           auto_tagged: args2.autoTag,
           collection: args2.collection
         });
-        await appendEvent3(event, projectKey);
+        await appendEvent4(event, projectKey);
       } catch (error45) {
         console.warn("[semantic_memory_store] Failed to emit memory_stored event:", error45);
       }
@@ -36922,9 +36944,9 @@ var init_memory_tools = __esm(() => {
       const result = await adapter.find(args2);
       const duration3 = Date.now() - startTime;
       try {
-        const projectKey = cachedProjectPath || process.cwd();
+        const projectKey = memoryAdapterCache.getCachedPath() || process.cwd();
         const topScore = result.results.length > 0 ? result.results[0].score : undefined;
-        const event = createEvent4("memory_found", {
+        const event = createEvent5("memory_found", {
           project_key: projectKey,
           query: args2.query,
           result_count: result.results.length,
@@ -36932,7 +36954,7 @@ var init_memory_tools = __esm(() => {
           search_duration_ms: duration3,
           used_fts: args2.fts
         });
-        await appendEvent3(event, projectKey);
+        await appendEvent4(event, projectKey);
       } catch (error45) {
         console.warn("[semantic_memory_find] Failed to emit memory_found event:", error45);
       }
@@ -36960,12 +36982,12 @@ var init_memory_tools = __esm(() => {
       const result = await adapter.remove(args2);
       if (result.success) {
         try {
-          const projectKey = cachedProjectPath || process.cwd();
-          const event = createEvent4("memory_deleted", {
+          const projectKey = memoryAdapterCache.getCachedPath() || process.cwd();
+          const event = createEvent5("memory_deleted", {
             project_key: projectKey,
             memory_id: args2.id
           });
-          await appendEvent3(event, projectKey);
+          await appendEvent4(event, projectKey);
         } catch (error45) {
           console.warn("[semantic_memory_remove] Failed to emit memory_deleted event:", error45);
         }
@@ -36983,13 +37005,13 @@ var init_memory_tools = __esm(() => {
       const result = await adapter.validate(args2);
       if (result.success) {
         try {
-          const projectKey = cachedProjectPath || process.cwd();
-          const event = createEvent4("memory_validated", {
+          const projectKey = memoryAdapterCache.getCachedPath() || process.cwd();
+          const event = createEvent5("memory_validated", {
             project_key: projectKey,
             memory_id: args2.id,
             decay_reset: true
           });
-          await appendEvent3(event, projectKey);
+          await appendEvent4(event, projectKey);
         } catch (error45) {
           console.warn("[semantic_memory_validate] Failed to emit memory_validated event:", error45);
         }
@@ -37042,14 +37064,14 @@ var init_memory_tools = __esm(() => {
       const adapter = await getMemoryAdapter();
       const result = await adapter.upsert(args2);
       try {
-        const projectKey = cachedProjectPath || process.cwd();
-        const event = createEvent4("memory_updated", {
+        const projectKey = memoryAdapterCache.getCachedPath() || process.cwd();
+        const event = createEvent5("memory_updated", {
           project_key: projectKey,
           memory_id: result.memoryId || "unknown",
           operation: result.operation,
           reason: result.reason
         });
-        await appendEvent3(event, projectKey);
+        await appendEvent4(event, projectKey);
       } catch (error45) {
         console.warn("[semantic_memory_upsert] Failed to emit memory_updated event:", error45);
       }
@@ -39961,8 +39983,8 @@ import {
   releaseSwarmFiles,
   sendSwarmMessage as sendSwarmMessage2,
   getAgent,
-  createEvent as createEvent3,
-  appendEvent as appendEvent2,
+  createEvent as createEvent4,
+  appendEvent as appendEvent3,
   getSwarmMailLibSQL as getSwarmMailLibSQL4
 } from "swarm-mail";
 
@@ -40261,7 +40283,24 @@ import {
 } from "swarm-mail";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { join as join2 } from "node:path";
+import { createEvent as createEvent2, appendEvent as appendEvent2 } from "swarm-mail";
+
+// src/utils/event-utils.ts
 import { createEvent, appendEvent } from "swarm-mail";
+async function safeEmitEvent(eventType, data, toolName, projectPath) {
+  try {
+    const effectiveProjectPath = projectPath || process.cwd();
+    const event = createEvent(eventType, {
+      project_key: effectiveProjectPath,
+      ...data
+    });
+    await appendEvent(event, effectiveProjectPath);
+  } catch (error45) {
+    console.warn(`[${toolName}] Failed to emit ${eventType} event:`, error45);
+  }
+}
+
+// src/hive.ts
 var hiveWorkingDirectory = null;
 function setHiveWorkingDirectory(directory) {
   hiveWorkingDirectory = directory;
@@ -40419,20 +40458,14 @@ var hive_create = tool({
         parent_id: validated.parent_id
       });
       await adapter.markDirty(projectKey, cell.id);
-      try {
-        const event = createEvent("cell_created", {
-          project_key: projectKey,
-          cell_id: cell.id,
-          title: validated.title,
-          description: validated.description,
-          issue_type: validated.type || "task",
-          priority: validated.priority ?? 2,
-          parent_id: validated.parent_id
-        });
-        await appendEvent(event, projectKey);
-      } catch (error45) {
-        console.warn("[hive_create] Failed to emit cell_created event:", error45);
-      }
+      await safeEmitEvent("cell_created", {
+        cell_id: cell.id,
+        title: validated.title,
+        description: validated.description,
+        issue_type: validated.type || "task",
+        priority: validated.priority ?? 2,
+        parent_id: validated.parent_id
+      }, "hive_create", projectKey);
       const formatted = formatCellForOutput(cell);
       return JSON.stringify(formatted, null, 2);
     } catch (error45) {
@@ -40514,53 +40547,35 @@ var hive_create_epic = tool({
         subtasks: created.slice(1).map((c) => formatCellForOutput(c))
       };
       const effectiveProjectKey = args.project_key || projectKey;
-      try {
-        const epicCreatedEvent = createEvent("epic_created", {
-          project_key: effectiveProjectKey,
-          epic_id: epic.id,
-          title: validated.epic_title,
-          description: validated.epic_description,
-          subtask_count: validated.subtasks.length,
-          subtask_ids: created.slice(1).map((c) => c.id)
-        });
-        await appendEvent(epicCreatedEvent, effectiveProjectKey);
-      } catch (error45) {
-        console.warn("[hive_create_epic] Failed to emit epic_created event:", error45);
-      }
-      try {
-        const event = createEvent("decomposition_generated", {
-          project_key: effectiveProjectKey,
-          epic_id: epic.id,
-          task: args.task || validated.epic_title,
-          context: validated.epic_description,
-          strategy: args.strategy || "feature-based",
-          epic_title: validated.epic_title,
-          subtasks: validated.subtasks.map((st) => ({
-            title: st.title,
-            files: st.files || [],
-            priority: st.priority
-          })),
-          recovery_context: args.recovery_context
-        });
-        await appendEvent(event, effectiveProjectKey);
-      } catch (error45) {
-        console.warn("[hive_create_epic] Failed to emit DecompositionGeneratedEvent:", error45);
-      }
-      try {
-        const totalFiles = validated.subtasks.reduce((count, st) => count + (st.files?.length || 0), 0);
-        const swarmStartedEvent = createEvent("swarm_started", {
-          project_key: effectiveProjectKey,
-          epic_id: epic.id,
-          epic_title: validated.epic_title,
-          strategy: args.strategy || "feature-based",
-          subtask_count: validated.subtasks.length,
-          total_files: totalFiles,
-          coordinator_agent: "coordinator"
-        });
-        await appendEvent(swarmStartedEvent, effectiveProjectKey);
-      } catch (error45) {
-        console.warn("[hive_create_epic] Failed to emit SwarmStartedEvent:", error45);
-      }
+      await safeEmitEvent("epic_created", {
+        epic_id: epic.id,
+        title: validated.epic_title,
+        description: validated.epic_description,
+        subtask_count: validated.subtasks.length,
+        subtask_ids: created.slice(1).map((c) => c.id)
+      }, "hive_create_epic", effectiveProjectKey);
+      await safeEmitEvent("decomposition_generated", {
+        epic_id: epic.id,
+        task: args.task || validated.epic_title,
+        context: validated.epic_description,
+        strategy: args.strategy || "feature-based",
+        epic_title: validated.epic_title,
+        subtasks: validated.subtasks.map((st) => ({
+          title: st.title,
+          files: st.files || [],
+          priority: st.priority
+        })),
+        recovery_context: args.recovery_context
+      }, "hive_create_epic", effectiveProjectKey);
+      const totalFiles = validated.subtasks.reduce((count, st) => count + (st.files?.length || 0), 0);
+      await safeEmitEvent("swarm_started", {
+        epic_id: epic.id,
+        epic_title: validated.epic_title,
+        strategy: args.strategy || "feature-based",
+        subtask_count: validated.subtasks.length,
+        total_files: totalFiles,
+        coordinator_agent: "coordinator"
+      }, "hive_create_epic", effectiveProjectKey);
       try {
         const { captureCoordinatorEvent: captureCoordinatorEvent2 } = await Promise.resolve().then(() => (init_eval_capture(), exports_eval_capture));
         const filesPerSubtask = {};
@@ -40691,23 +40706,17 @@ var hive_update = tool({
         cell = existingCell;
       }
       await adapter.markDirty(projectKey, cellId);
-      try {
-        const fieldsChanged = [];
-        if (validated.status)
-          fieldsChanged.push("status");
-        if (validated.description !== undefined)
-          fieldsChanged.push("description");
-        if (validated.priority !== undefined)
-          fieldsChanged.push("priority");
-        const event = createEvent("cell_updated", {
-          project_key: projectKey,
-          cell_id: cellId,
-          fields_changed: fieldsChanged
-        });
-        await appendEvent(event, projectKey);
-      } catch (error45) {
-        console.warn("[hive_update] Failed to emit cell_updated event:", error45);
-      }
+      const fieldsChanged = [];
+      if (validated.status)
+        fieldsChanged.push("status");
+      if (validated.description !== undefined)
+        fieldsChanged.push("description");
+      if (validated.priority !== undefined)
+        fieldsChanged.push("priority");
+      await safeEmitEvent("cell_updated", {
+        cell_id: cellId,
+        fields_changed: fieldsChanged
+      }, "hive_update", projectKey);
       const formatted = formatCellForOutput(cell);
       return JSON.stringify(formatted, null, 2);
     } catch (error45) {
@@ -40740,7 +40749,6 @@ var hive_close = tool({
       await adapter.markDirty(projectKey, cellId);
       if (isEpic && cellBeforeClose) {
         try {
-          const { createEvent: createEvent2, appendEvent: appendEvent2 } = await import("swarm-mail");
           const subtasks = await adapter.queryCells(projectKey, { parent_id: cellId });
           const completedSubtasks = subtasks.filter((st) => st.status === "closed");
           const failedSubtasks = subtasks.filter((st) => st.status === "blocked");
@@ -40778,8 +40786,7 @@ var hive_close = tool({
           } catch (error45) {
             console.warn("[hive_close] Failed to calculate duration:", error45);
           }
-          const swarmCompletedEvent = createEvent2("swarm_completed", {
-            project_key: projectKey,
+          await safeEmitEvent("swarm_completed", {
             epic_id: cellId,
             epic_title: cellBeforeClose.title,
             success: failedSubtasks.length === 0,
@@ -40787,8 +40794,7 @@ var hive_close = tool({
             subtasks_completed: completedSubtasks.length,
             subtasks_failed: failedSubtasks.length,
             total_files_touched: totalFilesTouched
-          });
-          await appendEvent2(swarmCompletedEvent, projectKey);
+          }, "hive_close", projectKey);
           try {
             const { runPostSwarmValidation: runPostSwarmValidation2 } = await Promise.resolve().then(() => (init_swarm_validation(), exports_swarm_validation));
             const { readEvents } = await import("swarm-mail");
@@ -40824,16 +40830,10 @@ var hive_close = tool({
           console.warn("[hive_close] Failed to emit SwarmCompletedEvent:", error45);
         }
       }
-      try {
-        const event = createEvent("cell_closed", {
-          project_key: projectKey,
-          cell_id: cellId,
-          reason: validated.reason
-        });
-        await appendEvent(event, projectKey);
-      } catch (error45) {
-        console.warn("[hive_close] Failed to emit cell_closed event:", error45);
-      }
+      await safeEmitEvent("cell_closed", {
+        cell_id: cellId,
+        reason: validated.reason
+      }, "hive_close", projectKey);
       return `Closed ${cell.id}: ${validated.reason}`;
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
@@ -40860,13 +40860,13 @@ var hive_start = tool({
       const cell = await adapter.changeCellStatus(projectKey, cellId, "in_progress");
       await adapter.markDirty(projectKey, cellId);
       try {
-        const event = createEvent("cell_status_changed", {
+        const event = createEvent2("cell_status_changed", {
           project_key: projectKey,
           cell_id: cellId,
           old_status: "open",
           new_status: "in_progress"
         });
-        await appendEvent(event, projectKey);
+        await appendEvent2(event, projectKey);
       } catch (error45) {
         console.warn("[hive_start] Failed to emit cell_status_changed event:", error45);
       }
@@ -41067,12 +41067,12 @@ var hive_sync = tool({
       pushSuccess = true;
     }
     try {
-      const event = createEvent("hive_synced", {
+      const event = createEvent2("hive_synced", {
         project_key: projectKey,
         cells_synced: flushResult.cellsExported,
         push_success: pushSuccess
       });
-      await appendEvent(event, projectKey);
+      await appendEvent2(event, projectKey);
     } catch (error45) {
       console.warn("[hive_sync] Failed to emit hive_synced event:", error45);
     }
@@ -41739,15 +41739,15 @@ var swarm_review = tool({
       downstream_tasks: downstreamTasks.length > 0 ? downstreamTasks : undefined
     });
     try {
-      const { createEvent: createEvent3, appendEvent: appendEvent2 } = await import("swarm-mail");
+      const { createEvent: createEvent4, appendEvent: appendEvent3 } = await import("swarm-mail");
       const attempt = getReviewStatus(args.task_id).attempt_count || 1;
-      const reviewStartedEvent = createEvent3("review_started", {
+      const reviewStartedEvent = createEvent4("review_started", {
         project_key: args.project_key,
         epic_id: args.epic_id,
         bead_id: args.task_id,
         attempt
       });
-      await appendEvent2(reviewStartedEvent, args.project_key);
+      await appendEvent3(reviewStartedEvent, args.project_key);
     } catch (error45) {
       console.warn("[swarm_review] Failed to emit ReviewStartedEvent:", error45);
     }
@@ -41830,16 +41830,16 @@ var swarm_review_feedback = tool({
         console.warn("[swarm_review_feedback] Failed to trace review_decision:", error45);
       }
       try {
-        const { createEvent: createEvent3, appendEvent: appendEvent2 } = await import("swarm-mail");
+        const { createEvent: createEvent4, appendEvent: appendEvent3 } = await import("swarm-mail");
         const attempt = getReviewStatus(args.task_id).attempt_count || 1;
-        const reviewCompletedEvent = createEvent3("review_completed", {
+        const reviewCompletedEvent = createEvent4("review_completed", {
           project_key: args.project_key,
           epic_id: epicId,
           bead_id: args.task_id,
           status: "approved",
           attempt
         });
-        await appendEvent2(reviewCompletedEvent, args.project_key);
+        await appendEvent3(reviewCompletedEvent, args.project_key);
       } catch (error45) {
         console.warn("[swarm_review_feedback] Failed to emit ReviewCompletedEvent:", error45);
       }
@@ -41901,16 +41901,16 @@ You may now complete the task with \`swarm_complete\`.`,
       console.warn("[swarm_review_feedback] Failed to trace review_decision:", error45);
     }
     try {
-      const { createEvent: createEvent3, appendEvent: appendEvent2 } = await import("swarm-mail");
+      const { createEvent: createEvent4, appendEvent: appendEvent3 } = await import("swarm-mail");
       const status = remaining <= 0 ? "blocked" : "needs_changes";
-      const reviewCompletedEvent = createEvent3("review_completed", {
+      const reviewCompletedEvent = createEvent4("review_completed", {
         project_key: args.project_key,
         epic_id: epicId,
         bead_id: args.task_id,
         status,
         attempt: attemptNumber
       });
-      await appendEvent2(reviewCompletedEvent, args.project_key);
+      await appendEvent3(reviewCompletedEvent, args.project_key);
     } catch (error45) {
       console.warn("[swarm_review_feedback] Failed to emit ReviewCompletedEvent:", error45);
     }
@@ -41966,6 +41966,181 @@ function getReviewStatus(taskId) {
 
 // src/swarm-orchestrate.ts
 init_eval_capture();
+
+// src/swarm-verify.ts
+init_dist();
+async function runTypecheckVerification() {
+  const step = {
+    name: "typecheck",
+    command: "tsc --noEmit",
+    passed: false,
+    exitCode: -1
+  };
+  try {
+    const tsconfigExists = await Bun.file("tsconfig.json").exists();
+    if (!tsconfigExists) {
+      step.skipped = true;
+      step.skipReason = "No tsconfig.json found";
+      step.passed = true;
+      return step;
+    }
+    const result = await Bun.$`tsc --noEmit`.quiet().nothrow();
+    step.exitCode = result.exitCode;
+    step.passed = result.exitCode === 0;
+    if (!step.passed) {
+      step.error = result.stderr.toString().slice(0, 1000);
+      step.output = result.stdout.toString().slice(0, 1000);
+    }
+  } catch (error45) {
+    step.skipped = true;
+    step.skipReason = `tsc not available: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    step.passed = true;
+  }
+  return step;
+}
+async function runTestVerification(filesTouched) {
+  const step = {
+    name: "tests",
+    command: "bun test <related-files>",
+    passed: false,
+    exitCode: -1
+  };
+  if (filesTouched.length === 0) {
+    step.skipped = true;
+    step.skipReason = "No files touched";
+    step.passed = true;
+    return step;
+  }
+  const testPatterns = [];
+  for (const file2 of filesTouched) {
+    if (file2.includes(".test.") || file2.includes(".spec.")) {
+      testPatterns.push(file2);
+      continue;
+    }
+    const baseName = file2.replace(/\.(ts|tsx|js|jsx)$/, "");
+    testPatterns.push(`${baseName}.test.ts`);
+    testPatterns.push(`${baseName}.test.tsx`);
+    testPatterns.push(`${baseName}.spec.ts`);
+  }
+  const existingTests = [];
+  for (const pattern of testPatterns) {
+    try {
+      const exists = await Bun.file(pattern).exists();
+      if (exists) {
+        existingTests.push(pattern);
+      }
+    } catch {}
+  }
+  if (existingTests.length === 0) {
+    step.skipped = true;
+    step.skipReason = "No related test files found";
+    step.passed = true;
+    return step;
+  }
+  try {
+    step.command = `bun test ${existingTests.join(" ")}`;
+    const result = await Bun.$`bun test ${existingTests}`.quiet().nothrow();
+    step.exitCode = result.exitCode;
+    step.passed = result.exitCode === 0;
+    if (!step.passed) {
+      step.error = result.stderr.toString().slice(0, 1000);
+      step.output = result.stdout.toString().slice(0, 1000);
+    }
+  } catch (error45) {
+    step.skipped = true;
+    step.skipReason = `Test runner failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    step.passed = true;
+  }
+  return step;
+}
+async function runVerificationGate(filesTouched, _skipUbs = false) {
+  const steps = [];
+  const blockers = [];
+  const typecheckStep = await runTypecheckVerification();
+  steps.push(typecheckStep);
+  if (!typecheckStep.passed && !typecheckStep.skipped) {
+    blockers.push(`Typecheck failed: ${typecheckStep.error?.slice(0, 100) || "type errors found"}. Try: Run 'tsc --noEmit' to see full errors, check tsconfig.json configuration, or fix reported type errors in modified files.`);
+  }
+  const testStep = await runTestVerification(filesTouched);
+  steps.push(testStep);
+  if (!testStep.passed && !testStep.skipped) {
+    blockers.push(`Tests failed: ${testStep.error?.slice(0, 100) || "test failures"}. Try: Run 'bun test ${testStep.command.split(" ").slice(2).join(" ")}' to see full output, check test assertions, or fix failing tests in modified files.`);
+  }
+  const passedCount = steps.filter((s) => s.passed).length;
+  const skippedCount = steps.filter((s) => s.skipped).length;
+  const failedCount = steps.filter((s) => !s.passed && !s.skipped).length;
+  const summary = failedCount === 0 ? `Verification passed: ${passedCount} checks passed, ${skippedCount} skipped` : `Verification FAILED: ${failedCount} checks failed, ${passedCount} passed, ${skippedCount} skipped`;
+  return {
+    passed: failedCount === 0,
+    steps,
+    summary,
+    blockers
+  };
+}
+var swarm_verify = tool({
+  description: "Run verification gate (typecheck + tests) for files. Returns verification results without blocking. Used by swarm_complete to verify worker output.",
+  args: {
+    files_touched: tool.schema.array(tool.schema.string()).describe("Files to verify (typecheck + test discovery)"),
+    skip_verification: tool.schema.boolean().optional().describe("Skip verification entirely (default: false)")
+  },
+  async execute(args) {
+    try {
+      if (args.skip_verification) {
+        return JSON.stringify({
+          success: true,
+          data: {
+            passed: true,
+            skipped: true,
+            reason: "skip_verification=true",
+            summary: "Verification skipped by request",
+            steps: [],
+            blockers: []
+          }
+        }, null, 2);
+      }
+      if (!args.files_touched || args.files_touched.length === 0) {
+        return JSON.stringify({
+          success: true,
+          data: {
+            passed: true,
+            skipped: true,
+            reason: "no files_touched provided",
+            summary: "No files to verify",
+            steps: [],
+            blockers: []
+          }
+        }, null, 2);
+      }
+      const result = await runVerificationGate(args.files_touched, false);
+      return JSON.stringify({
+        success: true,
+        data: {
+          passed: result.passed,
+          skipped: false,
+          summary: result.summary,
+          steps: result.steps.map((s) => ({
+            name: s.name,
+            command: s.command,
+            passed: s.passed,
+            exitCode: s.exitCode,
+            skipped: s.skipped,
+            skipReason: s.skipReason,
+            error: s.error?.slice(0, 200),
+            output: s.output?.slice(0, 200)
+          })),
+          blockers: result.blockers
+        }
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: `Verification failed: ${error45 instanceof Error ? error45.message : String(error45)}`
+      }, null, 2);
+    }
+  }
+});
+
+// src/swarm-orchestrate.ts
 function generateWorkerHandoff(params) {
   const handoff = {
     contract: {
@@ -42107,114 +42282,6 @@ ${progress.blockers.map((b) => `- ${b}`).join(`
 
 `);
 }
-async function runTypecheckVerification() {
-  const step = {
-    name: "typecheck",
-    command: "tsc --noEmit",
-    passed: false,
-    exitCode: -1
-  };
-  try {
-    const tsconfigExists = await Bun.file("tsconfig.json").exists();
-    if (!tsconfigExists) {
-      step.skipped = true;
-      step.skipReason = "No tsconfig.json found";
-      step.passed = true;
-      return step;
-    }
-    const result = await Bun.$`tsc --noEmit`.quiet().nothrow();
-    step.exitCode = result.exitCode;
-    step.passed = result.exitCode === 0;
-    if (!step.passed) {
-      step.error = result.stderr.toString().slice(0, 1000);
-      step.output = result.stdout.toString().slice(0, 1000);
-    }
-  } catch (error45) {
-    step.skipped = true;
-    step.skipReason = `tsc not available: ${error45 instanceof Error ? error45.message : String(error45)}`;
-    step.passed = true;
-  }
-  return step;
-}
-async function runTestVerification(filesTouched) {
-  const step = {
-    name: "tests",
-    command: "bun test <related-files>",
-    passed: false,
-    exitCode: -1
-  };
-  if (filesTouched.length === 0) {
-    step.skipped = true;
-    step.skipReason = "No files touched";
-    step.passed = true;
-    return step;
-  }
-  const testPatterns = [];
-  for (const file2 of filesTouched) {
-    if (file2.includes(".test.") || file2.includes(".spec.")) {
-      testPatterns.push(file2);
-      continue;
-    }
-    const baseName = file2.replace(/\.(ts|tsx|js|jsx)$/, "");
-    testPatterns.push(`${baseName}.test.ts`);
-    testPatterns.push(`${baseName}.test.tsx`);
-    testPatterns.push(`${baseName}.spec.ts`);
-  }
-  const existingTests = [];
-  for (const pattern of testPatterns) {
-    try {
-      const exists = await Bun.file(pattern).exists();
-      if (exists) {
-        existingTests.push(pattern);
-      }
-    } catch {}
-  }
-  if (existingTests.length === 0) {
-    step.skipped = true;
-    step.skipReason = "No related test files found";
-    step.passed = true;
-    return step;
-  }
-  try {
-    step.command = `bun test ${existingTests.join(" ")}`;
-    const result = await Bun.$`bun test ${existingTests}`.quiet().nothrow();
-    step.exitCode = result.exitCode;
-    step.passed = result.exitCode === 0;
-    if (!step.passed) {
-      step.error = result.stderr.toString().slice(0, 1000);
-      step.output = result.stdout.toString().slice(0, 1000);
-    }
-  } catch (error45) {
-    step.skipped = true;
-    step.skipReason = `Test runner failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
-    step.passed = true;
-  }
-  return step;
-}
-async function runVerificationGate(filesTouched, _skipUbs = false) {
-  const steps = [];
-  const blockers = [];
-  const typecheckStep = await runTypecheckVerification();
-  steps.push(typecheckStep);
-  if (!typecheckStep.passed && !typecheckStep.skipped) {
-    blockers.push(`Typecheck failed: ${typecheckStep.error?.slice(0, 100) || "type errors found"}. Try: Run 'tsc --noEmit' to see full errors, check tsconfig.json configuration, or fix reported type errors in modified files.`);
-  }
-  const testStep = await runTestVerification(filesTouched);
-  steps.push(testStep);
-  if (!testStep.passed && !testStep.skipped) {
-    blockers.push(`Tests failed: ${testStep.error?.slice(0, 100) || "test failures"}. Try: Run 'bun test ${testStep.command.split(" ").slice(2).join(" ")}' to see full output, check test assertions, or fix failing tests in modified files.`);
-  }
-  const passedCount = steps.filter((s) => s.passed).length;
-  const skippedCount = steps.filter((s) => s.skipped).length;
-  const failedCount = steps.filter((s) => !s.passed && !s.skipped).length;
-  const summary = failedCount === 0 ? `Verification passed: ${passedCount} checks passed, ${skippedCount} skipped` : `Verification FAILED: ${failedCount} checks failed, ${passedCount} passed, ${skippedCount} skipped`;
-  return {
-    passed: failedCount === 0,
-    steps,
-    summary,
-    blockers
-  };
-}
 function classifyFailure(error45) {
   const msg = (typeof error45 === "string" ? error45 : error45.message).toLowerCase();
   if (msg.includes("timeout"))
@@ -42476,15 +42543,15 @@ var swarm_progress = tool({
             }
           };
           const checkpointData = JSON.stringify(checkpoint);
-          const checkpointEvent = createEvent3("swarm_checkpointed", {
+          const checkpointEvent = createEvent4("swarm_checkpointed", {
             project_key: args.project_key,
             ...checkpoint,
             checkpoint_size_bytes: Buffer.byteLength(checkpointData, "utf8"),
             trigger: "progress"
           });
-          await appendEvent2(checkpointEvent, args.project_key);
+          await appendEvent3(checkpointEvent, args.project_key);
           const checkpointId = `ckpt-${Date.now()}-${args.bead_id}`;
-          const createdEvent = createEvent3("checkpoint_created", {
+          const createdEvent = createEvent4("checkpoint_created", {
             project_key: args.project_key,
             epic_id: epicId,
             bead_id: args.bead_id,
@@ -42494,7 +42561,7 @@ var swarm_progress = tool({
             progress_percent: args.progress_percent,
             files_snapshot: args.files_touched
           });
-          await appendEvent2(createdEvent, args.project_key);
+          await appendEvent3(createdEvent, args.project_key);
           checkpointCreated = true;
         } catch (error45) {
           console.warn(`[swarm_progress] Auto-checkpoint failed at ${args.progress_percent}%:`, error45);
@@ -42797,7 +42864,7 @@ This will be recorded as a negative learning signal.`;
       const eventEpicId = cell.parent_id || (args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id);
       let outcomeEventId;
       try {
-        const event = createEvent3("subtask_outcome", {
+        const event = createEvent4("subtask_outcome", {
           project_key: args.project_key,
           epic_id: eventEpicId,
           bead_id: args.bead_id,
@@ -42810,7 +42877,7 @@ This will be recorded as a negative learning signal.`;
           scope_violation: contractValidation ? !contractValidation.valid : undefined,
           violation_files: contractValidation?.violations
         });
-        const savedEvent = await appendEvent2(event, args.project_key);
+        const savedEvent = await appendEvent3(event, args.project_key);
         outcomeEventId = savedEvent.id;
       } catch (error45) {
         console.warn("[swarm_complete] Failed to emit SubtaskOutcomeEvent:", error45);
@@ -42828,7 +42895,7 @@ This will be recorded as a negative learning signal.`;
         }
       }
       try {
-        const workerCompletedEvent = createEvent3("worker_completed", {
+        const workerCompletedEvent = createEvent4("worker_completed", {
           project_key: args.project_key,
           epic_id: eventEpicId,
           bead_id: args.bead_id,
@@ -42837,7 +42904,7 @@ This will be recorded as a negative learning signal.`;
           duration_ms: completionDurationMs,
           files_touched: args.files_touched || []
         });
-        await appendEvent2(workerCompletedEvent, args.project_key);
+        await appendEvent3(workerCompletedEvent, args.project_key);
       } catch (error45) {
         console.warn("[swarm_complete] Failed to emit worker_completed event:", error45);
       }
@@ -43561,7 +43628,7 @@ var swarm_checkpoint = tool({
         }
       };
       const checkpointData = JSON.stringify(checkpoint);
-      const event = createEvent3("swarm_checkpointed", {
+      const event = createEvent4("swarm_checkpointed", {
         project_key: args.project_key,
         epic_id: args.epic_id,
         bead_id: args.bead_id,
@@ -43573,7 +43640,7 @@ var swarm_checkpoint = tool({
         checkpoint_size_bytes: Buffer.byteLength(checkpointData, "utf8"),
         trigger: args.error_context ? "error" : "manual"
       });
-      await appendEvent2(event, args.project_key);
+      await appendEvent3(event, args.project_key);
       const now = Date.now();
       return JSON.stringify({
         success: true,
@@ -43631,13 +43698,13 @@ var swarm_recover = tool({
         created_at: row.created_at,
         updated_at: row.updated_at
       };
-      const event = createEvent3("swarm_recovered", {
+      const event = createEvent4("swarm_recovered", {
         project_key: args.project_key,
         epic_id: args.epic_id,
         bead_id: context.bead_id,
         recovered_from_checkpoint: context.recovery.last_checkpoint
       });
-      await appendEvent2(event, args.project_key);
+      await appendEvent3(event, args.project_key);
       return JSON.stringify({
         found: true,
         context,
@@ -44109,6 +44176,27 @@ swarmmail_reserve(
 
 **Workers reserve their own files.** This prevents edit conflicts with other agents.
 
+### ⚠️ CRITICAL: File Path Handling (Next.js/Special Characters)
+
+**DO NOT escape brackets or parentheses in file paths!**
+
+When working with Next.js App Router or any codebase with special characters in paths:
+
+❌ **WRONG** (will fail):
+\`\`\`
+Read: app/\\(content\\)/events/\\[slug\\]/page.tsx
+Glob: src/**/\\[id\\]/**/*.ts
+\`\`\`
+
+✅ **CORRECT** (use raw paths):
+\`\`\`
+Read: app/(content)/events/[slug]/page.tsx
+Glob: src/**/[id]/**/*.ts
+\`\`\`
+
+**The Read and Glob tools handle special characters automatically.**
+Never add backslashes before \`[\`, \`]\`, \`(\`, or \`)\` in file paths.
+
 ### Step 5: Do the Work (TDD MANDATORY)
 
 **Follow RED → GREEN → REFACTOR. No exceptions.**
@@ -45319,9 +45407,9 @@ var swarm_spawn_subtask = tool({
     }
     if (args2.project_path) {
       try {
-        const { createEvent: createEvent5, appendEvent: appendEvent4 } = await import("swarm-mail");
+        const { createEvent: createEvent6, appendEvent: appendEvent5 } = await import("swarm-mail");
         const spawnOrder = 0;
-        const workerSpawnedEvent = createEvent5("worker_spawned", {
+        const workerSpawnedEvent = createEvent6("worker_spawned", {
           project_key: args2.project_path,
           epic_id: args2.epic_id,
           bead_id: args2.bead_id,
@@ -45331,7 +45419,7 @@ var swarm_spawn_subtask = tool({
           spawn_order: spawnOrder,
           is_parallel: false
         });
-        await appendEvent4(workerSpawnedEvent, args2.project_path);
+        await appendEvent5(workerSpawnedEvent, args2.project_path);
       } catch (error45) {
         console.warn("[swarm_spawn_subtask] Failed to emit WorkerSpawnedEvent:", error45);
       }