opencode-swarm-plugin 0.31.7 → 0.32.0

package/dist/plugin.js

@@ -27084,7 +27084,7 @@ import {
   FlushManager,
   importFromJSONL,
   syncMemories,
-  getSwarmMail,
+  getSwarmMailLibSQL,
   resolvePartialId
 } from "swarm-mail";
 import { existsSync, readFileSync } from "node:fs";
@@ -27734,7 +27734,7 @@ async function getHiveAdapter(projectKey) {
   if (adapterCache.has(projectKey)) {
     return adapterCache.get(projectKey);
   }
-  const swarmMail = await getSwarmMail(projectKey);
+  const swarmMail = await getSwarmMailLibSQL(projectKey);
   const db = await swarmMail.getDatabase();
   const adapter = createHiveAdapter(db, projectKey);
   await adapter.runMigrations();
@@ -28101,7 +28101,7 @@ var hive_sync = tool({
       outputPath: `${projectKey}/.hive/issues.jsonl`
     });
     const flushResult = await withTimeout(flushManager.flush(), TIMEOUT_MS, "flush hive");
-    const swarmMail = await getSwarmMail(projectKey);
+    const swarmMail = await getSwarmMailLibSQL(projectKey);
     const db = await swarmMail.getDatabase();
     const hivePath = join(projectKey, ".hive");
     let memoriesSynced = 0;
@@ -28134,9 +28134,27 @@ var hive_sync = tool({
       const remoteCheckResult2 = await runGitCommand(["remote"]);
       const hasRemote2 = remoteCheckResult2.stdout.trim() !== "";
       if (hasRemote2) {
-        const pullResult = await withTimeout(runGitCommand(["pull", "--rebase"]), TIMEOUT_MS, "git pull --rebase");
-        if (pullResult.exitCode !== 0) {
-          throw new HiveError(`Failed to pull: ${pullResult.stderr}`, "git pull --rebase", pullResult.exitCode);
+        const statusResult = await runGitCommand(["status", "--porcelain"]);
+        const hasUnstagedChanges = statusResult.stdout.trim() !== "";
+        let didStash = false;
+        if (hasUnstagedChanges) {
+          const stashResult = await runGitCommand(["stash", "push", "-u", "-m", "hive_sync: auto-stash before pull"]);
+          if (stashResult.exitCode === 0) {
+            didStash = true;
+          }
+        }
+        try {
+          const pullResult = await withTimeout(runGitCommand(["pull", "--rebase"]), TIMEOUT_MS, "git pull --rebase");
+          if (pullResult.exitCode !== 0) {
+            throw new HiveError(`Failed to pull: ${pullResult.stderr}`, "git pull --rebase", pullResult.exitCode);
+          }
+        } finally {
+          if (didStash) {
+            const popResult = await runGitCommand(["stash", "pop"]);
+            if (popResult.exitCode !== 0) {
+              console.warn(`[hive_sync] Warning: stash pop failed. Your changes are in 'git stash list'. Error: ${popResult.stderr}`);
+            }
+          }
         }
       }
     }
@@ -32535,7 +32553,8 @@ import {
   sendSwarmMessage as sendSwarmMessage3,
   getAgent,
   createEvent as createEvent2,
-  appendEvent as appendEvent2
+  appendEvent as appendEvent2,
+  getSwarmMailLibSQL as getSwarmMailLibSQL2
 } from "swarm-mail";
 init_skills();
 
@@ -33339,60 +33358,6 @@ ${progress.blockers.map((b) => `- ${b}`).join(`
 
 `);
 }
-async function runUbsScan(files) {
-  if (files.length === 0) {
-    return null;
-  }
-  const ubsAvailable = await isToolAvailable("ubs");
-  if (!ubsAvailable) {
-    warnMissingTool("ubs");
-    return null;
-  }
-  try {
-    const result = await Bun.$`ubs scan ${files.join(" ")} --json`.quiet().nothrow();
-    const output = result.stdout.toString();
-    if (!output.trim()) {
-      return {
-        exitCode: result.exitCode,
-        bugs: [],
-        summary: { total: 0, critical: 0, high: 0, medium: 0, low: 0 }
-      };
-    }
-    try {
-      const parsed = JSON.parse(output);
-      if (typeof parsed !== "object" || parsed === null) {
-        throw new Error("UBS output is not an object");
-      }
-      if (!Array.isArray(parsed.bugs)) {
-        console.warn("[swarm] UBS output missing bugs array, using empty");
-      }
-      if (typeof parsed.summary !== "object" || parsed.summary === null) {
-        console.warn("[swarm] UBS output missing summary object, using empty");
-      }
-      return {
-        exitCode: result.exitCode,
-        bugs: Array.isArray(parsed.bugs) ? parsed.bugs : [],
-        summary: parsed.summary || {
-          total: 0,
-          critical: 0,
-          high: 0,
-          medium: 0,
-          low: 0
-        }
-      };
-    } catch (error45) {
-      console.error(`[swarm] CRITICAL: UBS scan failed to parse JSON output because output is malformed:`, error45);
-      console.error(`[swarm] Raw output: ${output}. Try: Run 'ubs doctor' to check installation, verify UBS version with 'ubs --version' (need v1.0.0+), or check if UBS supports --json flag.`);
-      return {
-        exitCode: result.exitCode,
-        bugs: [],
-        summary: { total: 0, critical: 0, high: 0, medium: 0, low: 0 }
-      };
-    }
-  } catch {
-    return null;
-  }
-}
 async function runTypecheckVerification() {
   const step = {
     name: "typecheck",
@@ -33477,34 +33442,9 @@ async function runTestVerification(filesTouched) {
   }
   return step;
 }
-async function runVerificationGate(filesTouched, skipUbs = false) {
+async function runVerificationGate(filesTouched, _skipUbs = false) {
   const steps = [];
   const blockers = [];
-  if (!skipUbs && filesTouched.length > 0) {
-    const ubsResult = await runUbsScan(filesTouched);
-    if (ubsResult) {
-      const ubsStep = {
-        name: "ubs_scan",
-        command: `ubs scan ${filesTouched.join(" ")}`,
-        passed: ubsResult.summary.critical === 0,
-        exitCode: ubsResult.exitCode
-      };
-      if (!ubsStep.passed) {
-        ubsStep.error = `Found ${ubsResult.summary.critical} critical bugs`;
-        blockers.push(`UBS found ${ubsResult.summary.critical} critical bug(s). Try: Run 'ubs scan ${filesTouched.join(" ")}' to see details, fix critical bugs in reported files, or use skip_ubs_scan=true to bypass (not recommended).`);
-      }
-      steps.push(ubsStep);
-    } else {
-      steps.push({
-        name: "ubs_scan",
-        command: "ubs scan",
-        passed: true,
-        exitCode: 0,
-        skipped: true,
-        skipReason: "UBS not available"
-      });
-    }
-  }
   const typecheckStep = await runTypecheckVerification();
   steps.push(typecheckStep);
   if (!typecheckStep.passed && !typecheckStep.skipped) {
@@ -33827,16 +33767,15 @@ ${args.files_affected.map((f) => `- \`${f}\``).join(`
   }
 });
 var swarm_complete = tool({
-  description: "Mark subtask complete with Verification Gate. Runs UBS scan, typecheck, and tests before allowing completion.",
+  description: "Mark subtask complete with Verification Gate. Runs typecheck and tests before allowing completion.",
   args: {
     project_key: tool.schema.string().describe("Project path"),
     agent_name: tool.schema.string().describe("Your Agent Mail name"),
     bead_id: tool.schema.string().describe("Subtask bead ID"),
     summary: tool.schema.string().describe("Brief summary of work done"),
     evaluation: tool.schema.string().optional().describe("Self-evaluation JSON (Evaluation schema)"),
-    files_touched: tool.schema.array(tool.schema.string()).optional().describe("Files modified - will be verified (UBS, typecheck, tests)"),
-    skip_ubs_scan: tool.schema.boolean().optional().describe("Skip UBS bug scan (default: false)"),
-    skip_verification: tool.schema.boolean().optional().describe("Skip ALL verification (UBS, typecheck, tests). Use sparingly! (default: false)"),
+    files_touched: tool.schema.array(tool.schema.string()).optional().describe("Files modified - will be verified (typecheck, tests)"),
+    skip_verification: tool.schema.boolean().optional().describe("Skip ALL verification (typecheck, tests). Use sparingly! (default: false)"),
     planned_files: tool.schema.array(tool.schema.string()).optional().describe("Files that were originally planned to be modified"),
     start_time: tool.schema.number().optional().describe("Task start timestamp (Unix ms) for duration calculation"),
     error_count: tool.schema.number().optional().describe("Number of errors encountered during task"),
@@ -33919,7 +33858,7 @@ Continuing with completion, but this should be fixed for future subtasks.`;
       }
       let verificationResult = null;
       if (!args.skip_verification && args.files_touched?.length) {
-        verificationResult = await runVerificationGate(args.files_touched, args.skip_ubs_scan ?? false);
+        verificationResult = await runVerificationGate(args.files_touched, false);
         if (!verificationResult.passed) {
           return JSON.stringify({
             success: false,
@@ -33941,21 +33880,6 @@ Continuing with completion, but this should be fixed for future subtasks.`;
           }, null, 2);
         }
       }
-      let ubsResult = null;
-      if (!args.skip_verification && !verificationResult && args.files_touched?.length && !args.skip_ubs_scan) {
-        ubsResult = await runUbsScan(args.files_touched);
-        if (ubsResult && ubsResult.summary.critical > 0) {
-          return JSON.stringify({
-            success: false,
-            error: `UBS found ${ubsResult.summary.critical} critical bug(s) that must be fixed before completing`,
-            ubs_scan: {
-              critical_count: ubsResult.summary.critical,
-              bugs: ubsResult.bugs.filter((b) => b.severity === "critical")
-            },
-            hint: `Fix these critical bugs: ${ubsResult.bugs.filter((b) => b.severity === "critical").map((b) => `${b.file}:${b.line} - ${b.message}`).slice(0, 3).join("; ")}. Try: Run 'ubs scan ${args.files_touched?.join(" ") || "."} --json' for full report, fix reported issues, or use skip_ubs_scan=true to bypass (not recommended).`
-          }, null, 2);
-        }
-      }
       let contractValidation = null;
       let contractWarning;
       if (args.files_touched && args.files_touched.length > 0) {
@@ -34025,6 +33949,23 @@ This will be recorded as a negative learning signal.`;
           }
         }, null, 2);
       }
+      let deferredResolved = false;
+      let deferredError;
+      try {
+        const swarmMail = await getSwarmMailLibSQL2(args.project_key);
+        const db = await swarmMail.getDatabase();
+        const deferredUrl = `deferred:${args.bead_id}`;
+        const checkResult = await db.query(`SELECT url, resolved FROM deferred WHERE url = ? AND resolved = 0`, [deferredUrl]);
+        if (checkResult.rows.length > 0) {
+          await db.query(`UPDATE deferred SET resolved = 1, value = ? WHERE url = ? AND resolved = 0`, [JSON.stringify({ completed: true, summary: args.summary }), deferredUrl]);
+          deferredResolved = true;
+        } else {
+          console.info(`[swarm_complete] No deferred found for ${args.bead_id} - task may not be part of active swarm`);
+        }
+      } catch (error45) {
+        deferredError = error45 instanceof Error ? error45.message : String(error45);
+        console.warn(`[swarm_complete] Failed to resolve deferred (non-fatal): ${deferredError}`);
+      }
       let syncSuccess = false;
       let syncError;
       try {
@@ -34129,6 +34070,8 @@ This will be recorded as a negative learning signal.`;
         sync_error: syncError,
         message_sent: messageSent,
         message_error: messageError,
+        deferred_resolved: deferredResolved,
+        deferred_error: deferredError,
         agent_registration: {
           verified: agentRegistered,
           warning: registrationWarning || undefined
@@ -34143,15 +34086,6 @@ This will be recorded as a negative learning signal.`;
             skipReason: s.skipReason
           }))
         } : args.skip_verification ? { skipped: true, reason: "skip_verification=true" } : { skipped: true, reason: "no files_touched provided" },
-        ubs_scan: ubsResult ? {
-          ran: true,
-          bugs_found: ubsResult.summary.total,
-          summary: ubsResult.summary,
-          warnings: ubsResult.bugs.filter((b) => b.severity !== "critical")
-        } : verificationResult ? { ran: true, included_in_verification_gate: true } : {
-          ran: false,
-          reason: args.skip_ubs_scan ? "skipped" : "no files or ubs unavailable"
-        },
         learning_prompt: `## Reflection
 
 Did you learn anything reusable during this subtask? Consider:
@@ -34189,9 +34123,7 @@ Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
       const errorStack = error45 instanceof Error ? error45.stack : undefined;
       let failedStep = "unknown";
       if (errorMessage.includes("verification")) {
-        failedStep = "Verification Gate (UBS/typecheck/tests)";
-      } else if (errorMessage.includes("UBS") || errorMessage.includes("ubs")) {
-        failedStep = "UBS scan";
+        failedStep = "Verification Gate (typecheck/tests)";
       } else if (errorMessage.includes("evaluation")) {
         failedStep = "Self-evaluation parsing";
       } else if (errorMessage.includes("bead") || errorMessage.includes("close")) {
@@ -34223,7 +34155,6 @@ ${errorStack.slice(0, 1000)}
         `### Context`,
         `- **Summary**: ${args.summary}`,
         `- **Files touched**: ${args.files_touched?.length ? args.files_touched.join(", ") : "none"}`,
-        `- **Skip UBS**: ${args.skip_ubs_scan ?? false}`,
         `- **Skip verification**: ${args.skip_verification ?? false}`,
         "",
         `### Recovery Actions`,
@@ -34261,7 +34192,6 @@ ${errorStack.slice(0, 1000)}
         context: {
           summary: args.summary,
           files_touched: args.files_touched || [],
-          skip_ubs_scan: args.skip_ubs_scan ?? false,
           skip_verification: args.skip_verification ?? false
         },
         recovery: {
@@ -34273,7 +34203,6 @@ ${errorStack.slice(0, 1000)}
           ],
           common_fixes: {
             "Verification Gate": "Use skip_verification=true to bypass (not recommended)",
-            "UBS scan": "Use skip_ubs_scan=true to bypass",
             "Cell close": "Check cell status with hive_query(), may need hive_update() first",
             "Self-evaluation": "Check evaluation JSON format matches EvaluationSchema"
           }
@@ -34579,8 +34508,9 @@ var swarm_recover = tool({
   },
   async execute(args) {
     try {
-      const { getDatabase } = await import("swarm-mail");
-      const db = await getDatabase(args.project_key);
+      const { getSwarmMailLibSQL: getSwarmMailLibSQL3 } = await import("swarm-mail");
+      const swarmMail = await getSwarmMailLibSQL3(args.project_key);
+      const db = await swarmMail.getDatabase();
       const result = await db.query(`SELECT * FROM swarm_contexts 
          WHERE epic_id = $1 
          ORDER BY updated_at DESC 
@@ -35214,6 +35144,58 @@ Other cell operations:
 **Memory is the swarm's collective intelligence. Query it. Feed it.**
 
 Begin now.`;
+var COORDINATOR_POST_WORKER_CHECKLIST = `
+## ⚠️ MANDATORY: Post-Worker Review (DO THIS IMMEDIATELY)
+
+**A worker just returned. Before doing ANYTHING else, complete this checklist:**
+
+### Step 1: Check Swarm Mail
+\`\`\`
+swarmmail_inbox()
+swarmmail_read_message(message_id=N)  // Read any messages from the worker
+\`\`\`
+
+### Step 2: Review the Work
+\`\`\`
+swarm_review(
+  project_key="{project_key}",
+  epic_id="{epic_id}",
+  task_id="{task_id}",
+  files_touched=[{files_touched}]
+)
+\`\`\`
+
+This generates a review prompt with:
+- Epic context (what we're trying to achieve)
+- Subtask requirements
+- Git diff of changes
+- Dependency status
+
+### Step 3: Evaluate Against Criteria
+- Does the work fulfill the subtask requirements?
+- Does it serve the overall epic goal?
+- Does it enable downstream tasks?
+- Type safety, no obvious bugs?
+
+### Step 4: Send Feedback
+\`\`\`
+swarm_review_feedback(
+  project_key="{project_key}",
+  task_id="{task_id}",
+  worker_id="{worker_id}",
+  status="approved",  // or "needs_changes"
+  summary="<brief summary>",
+  issues="[]"  // or "[{file, line, issue, suggestion}]"
+)
+\`\`\`
+
+### Step 5: ONLY THEN Continue
+- If approved: Close the cell, spawn next worker
+- If needs_changes: Worker gets feedback, retries (max 3 attempts)
+- If 3 failures: Mark blocked, escalate to human
+
+**⚠️ DO NOT spawn the next worker until review is complete.**
+`;
 var EVALUATION_PROMPT = `Evaluate the work completed for this subtask.
 
 ## Subtask
@@ -35385,6 +35367,8 @@ var swarm_spawn_subtask = tool({
       liteModel: "anthropic/claude-haiku-4-5"
     };
     const selectedModel = selectWorkerModel2(subtask, config2);
+    const filesJoined = args.files.map((f) => `"${f}"`).join(", ");
+    const postCompletionInstructions = COORDINATOR_POST_WORKER_CHECKLIST.replace(/{project_key}/g, args.project_path || "$PWD").replace(/{epic_id}/g, args.epic_id).replace(/{task_id}/g, args.bead_id).replace(/{files_touched}/g, filesJoined).replace(/{worker_id}/g, "worker");
     return JSON.stringify({
       prompt,
       bead_id: args.bead_id,
@@ -35392,7 +35376,8 @@ var swarm_spawn_subtask = tool({
       files: args.files,
       project_path: args.project_path,
       recovery_context: args.recovery_context,
-      recommended_model: selectedModel
+      recommended_model: selectedModel,
+      post_completion_instructions: postCompletionInstructions
     }, null, 2);
   }
 });
@@ -36559,7 +36544,7 @@ var mandateTools = {
 
 // src/memory-tools.ts
 init_dist();
-import { getSwarmMail as getSwarmMail2 } from "swarm-mail";
+import { getSwarmMailLibSQL as getSwarmMailLibSQL3 } from "swarm-mail";
 
 // ../../node_modules/.bun/effect@3.19.12/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
@@ -49980,7 +49965,8 @@ import {
   makeOllamaLive,
   Ollama,
   legacyDatabaseExists,
-  migrateLegacyMemories
+  migrateLegacyMemories,
+  toSwarmDb
 } from "swarm-mail";
 var migrationChecked = false;
 async function maybeAutoMigrate(db) {
@@ -50014,7 +50000,8 @@ async function createMemoryAdapter(db) {
     migrationChecked = true;
     await maybeAutoMigrate(db);
   }
-  const store = createMemoryStore(db);
+  const drizzleDb = toSwarmDb(db);
+  const store = createMemoryStore(drizzleDb);
   const config2 = getDefaultConfig();
   const ollamaLayer = makeOllamaLive(config2);
   const generateId = () => {
@@ -50159,9 +50146,9 @@ async function getMemoryAdapter(projectPath) {
   if (cachedAdapter && cachedProjectPath === path2) {
     return cachedAdapter;
   }
-  const swarmMail = await getSwarmMail2(path2);
-  const db = await swarmMail.getDatabase();
-  cachedAdapter = await createMemoryAdapter(db);
+  const swarmMail = await getSwarmMailLibSQL3(path2);
+  const dbAdapter = await swarmMail.getDatabase();
+  cachedAdapter = await createMemoryAdapter(dbAdapter);
   cachedProjectPath = path2;
   return cachedAdapter;
 }

package/dist/swarm-orchestrate.d.ts

@@ -183,7 +183,35 @@ export declare const swarm_broadcast: {
  * 4. VERIFY: All checks must pass
  * 5. ONLY THEN: Close the cell
  *
- * Closes cell, releases reservations, notifies coordinator.
+ * Closes cell, releases reservations, notifies coordinator, and resolves
+ * a DurableDeferred keyed by bead_id for cross-agent task completion signaling.
+ *
+ * ## DurableDeferred Integration
+ *
+ * When a coordinator spawns workers, it can create a deferred BEFORE spawning:
+ *
+ * ```typescript
+ * const swarmMail = await getSwarmMailLibSQL(projectPath);
+ * const db = await swarmMail.getDatabase();
+ *
+ * // Create deferred keyed by bead_id
+ * const deferredUrl = `deferred:${beadId}`;
+ * await db.query(
+ *   `INSERT INTO deferred (url, resolved, expires_at, created_at) VALUES (?, 0, ?, ?)`,
+ *   [deferredUrl, Date.now() + 3600000, Date.now()]
+ * );
+ *
+ * // Spawn worker (swarm_spawn_subtask...)
+ *
+ * // Await completion
+ * const result = await db.query<{ value: string }>(
+ *   `SELECT value FROM deferred WHERE url = ? AND resolved = 1`,
+ *   [deferredUrl]
+ * );
+ * ```
+ *
+ * When the worker calls swarm_complete, it resolves the deferred automatically.
+ * Coordinator can await without polling.
  */
 export declare const swarm_complete: {
     description: string;
@@ -194,7 +222,6 @@ export declare const swarm_complete: {
         summary: z.ZodString;
         evaluation: z.ZodOptional<z.ZodString>;
         files_touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        skip_ubs_scan: z.ZodOptional<z.ZodBoolean>;
         skip_verification: z.ZodOptional<z.ZodBoolean>;
         planned_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
         start_time: z.ZodOptional<z.ZodNumber>;
@@ -209,7 +236,6 @@ export declare const swarm_complete: {
         summary: string;
         evaluation?: string | undefined;
         files_touched?: string[] | undefined;
-        skip_ubs_scan?: boolean | undefined;
         skip_verification?: boolean | undefined;
         planned_files?: string[] | undefined;
         start_time?: number | undefined;
@@ -564,7 +590,6 @@ export declare const orchestrateTools: {
             summary: z.ZodString;
             evaluation: z.ZodOptional<z.ZodString>;
             files_touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            skip_ubs_scan: z.ZodOptional<z.ZodBoolean>;
             skip_verification: z.ZodOptional<z.ZodBoolean>;
             planned_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
             start_time: z.ZodOptional<z.ZodNumber>;
@@ -579,7 +604,6 @@ export declare const orchestrateTools: {
             summary: string;
             evaluation?: string | undefined;
             files_touched?: string[] | undefined;
-            skip_ubs_scan?: boolean | undefined;
             skip_verification?: boolean | undefined;
             planned_files?: string[] | undefined;
             start_time?: number | undefined;

package/dist/swarm-orchestrate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm-orchestrate.d.ts","sourceRoot":"","sources":["../src/swarm-orchestrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,OAAO,EACL,KAAK,aAAa,EAEnB,MAAM,0BAA0B,CAAC;AAmDlC;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;IAClC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,GAAG,aAAa,CA4BhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,MAAM,EAAE,EACvB,WAAW,EAAE,MAAM,EAAE,GACpB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAqC1C;AA8hBD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;CA8JrB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;CAoFvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CAkHzB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CA6E1B,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwsBzB,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkJ/B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CA6CjC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;CAmClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;CAmB9B,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;CAoJ9B,CAAC;AA4BH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqG3B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;CAsGxB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgMtB,CAAC;AAMH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc5B,CAAC"}
+{"version":3,"file":"swarm-orchestrate.d.ts","sourceRoot":"","sources":["../src/swarm-orchestrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,OAAO,EACL,KAAK,aAAa,EAEnB,MAAM,0BAA0B,CAAC;AAoDlC;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;IAClC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,GAAG,aAAa,CA4BhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,MAAM,EAAE,EACvB,WAAW,EAAE,MAAM,EAAE,GACpB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAqC1C;AAkaD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;CA8JrB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;CAoFvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CAkHzB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CA6E1B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6rBzB,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkJ/B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CA6CjC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;CAmClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;CAmB9B,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;CAoJ9B,CAAC;AA4BH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqG3B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;CAuGxB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgMtB,CAAC;AAMH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc5B,CAAC"}

package/dist/swarm-prompts.d.ts

@@ -38,6 +38,13 @@ export declare const SUBTASK_PROMPT = "You are a swarm agent working on a subtas
  * Supports {error_context} placeholder for retry prompts.
  */
 export declare const SUBTASK_PROMPT_V2 = "You are a swarm agent working on: **{subtask_title}**\n\n## [IDENTITY]\nAgent: (assigned at spawn)\nCell: {bead_id}\nEpic: {epic_id}\n\n## [TASK]\n{subtask_description}\n\n## [FILES]\nReserved (exclusive):\n{file_list}\n\nOnly modify these files. Need others? Message the coordinator.\n\n## [CONTEXT]\n{shared_context}\n\n{compressed_context}\n\n{error_context}\n\n## [MANDATORY SURVIVAL CHECKLIST]\n\n**CRITICAL: Follow this checklist IN ORDER. Each step builds on the previous.**\n\n### Step 1: Initialize Coordination (REQUIRED - DO THIS FIRST)\n```\nswarmmail_init(project_path=\"{project_path}\", task_description=\"{bead_id}: {subtask_title}\")\n```\n\n**This registers you with the coordination system and enables:**\n- File reservation tracking\n- Inter-agent communication\n- Progress monitoring\n- Conflict detection\n\n**If you skip this step, your work will not be tracked and swarm_complete will fail.**\n\n### Step 2: \uD83E\uDDE0 Query Past Learnings (MANDATORY - BEFORE starting work)\n\n**\u26A0\uFE0F CRITICAL: ALWAYS query semantic memory BEFORE writing ANY code.**\n\n```\nsemantic-memory_find(query=\"<keywords from your task>\", limit=5, expand=true)\n```\n\n**Why this is MANDATORY:**\n- Past agents may have already solved your exact problem\n- Avoids repeating mistakes that wasted 30+ minutes before\n- Discovers project-specific patterns and gotchas\n- Finds known workarounds for tool/library quirks\n\n**Search Query Examples by Task Type:**\n\n- **Bug fix**: Use exact error message or \"<symptom> <component>\"\n- **New feature**: Search \"<domain concept> implementation pattern\"\n- **Refactor**: Query \"<pattern name> migration approach\"\n- **Integration**: Look for \"<library name> gotchas configuration\"\n- **Testing**: Find \"testing <component type> characterization tests\"\n- **Performance**: Search \"<technology> performance optimization\"\n\n**BEFORE you start coding:**\n1. Run semantic-memory_find with keywords from your task\n2. Read the results with expand=true for full content\n3. Check if any memory solves your problem or warns of pitfalls\n4. Adjust your approach based on past learnings\n\n**If you skip this step, you WILL waste time solving already-solved problems.**\n\n### Step 3: Load Relevant Skills (if available)\n```\nskills_list()  # See what skills exist\nskills_use(name=\"<relevant-skill>\", context=\"<your task>\")  # Load skill\n```\n\n**Common skill triggers:**\n- Writing tests? \u2192 `skills_use(name=\"testing-patterns\")`\n- Breaking dependencies? \u2192 `skills_use(name=\"testing-patterns\")`\n- Multi-agent coordination? \u2192 `skills_use(name=\"swarm-coordination\")`\n- Building a CLI? \u2192 `skills_use(name=\"cli-builder\")`\n\n### Step 4: Reserve Your Files (YOU reserve, not coordinator)\n```\nswarmmail_reserve(\n  paths=[{file_list}],\n  reason=\"{bead_id}: {subtask_title}\",\n  exclusive=true\n)\n```\n\n**Workers reserve their own files.** This prevents edit conflicts with other agents.\n\n### Step 5: Do the Work (TDD MANDATORY)\n\n**Follow RED \u2192 GREEN \u2192 REFACTOR. No exceptions.**\n\n1. **RED**: Write a failing test that describes the expected behavior\n   - Test MUST fail before you write implementation\n   - If test passes immediately, your test is wrong\n   \n2. **GREEN**: Write minimal code to make the test pass\n   - Don't over-engineer - just make it green\n   - Hardcode if needed, refactor later\n   \n3. **REFACTOR**: Clean up while tests stay green\n   - Run tests after every change\n   - If tests break, undo and try again\n\n```bash\n# Run tests continuously\nbun test <your-test-file> --watch\n```\n\n**Why TDD?**\n- Catches bugs before they exist\n- Documents expected behavior\n- Enables fearless refactoring\n- Proves your code works\n\n### Step 6: Report Progress at Milestones\n```\nswarm_progress(\n  project_key=\"{project_path}\",\n  agent_name=\"<your-agent-name>\",\n  bead_id=\"{bead_id}\",\n  status=\"in_progress\",\n  progress_percent=25,  # or 50, 75\n  message=\"<what you just completed>\"\n)\n```\n\n**Report at 25%, 50%, 75% completion.** This:\n- Triggers auto-checkpoint (saves context)\n- Keeps coordinator informed\n- Prevents silent failures\n\n### Step 7: Manual Checkpoint BEFORE Risky Operations\n```\nswarm_checkpoint(\n  project_key=\"{project_path}\",\n  agent_name=\"<your-agent-name>\",\n  bead_id=\"{bead_id}\"\n)\n```\n\n**Call BEFORE:**\n- Large refactors\n- File deletions\n- Breaking API changes\n- Anything that might fail catastrophically\n\n**Checkpoints preserve context so you can recover if things go wrong.**\n\n### Step 8: \uD83D\uDCBE STORE YOUR LEARNINGS (if you discovered something)\n\n**If you learned it the hard way, STORE IT so the next agent doesn't have to.**\n\n```\nsemantic-memory_store(\n  information=\"<what you learned, WHY it matters, how to apply it>\",\n  tags=\"<domain, tech-stack, pattern-type>\"\n)\n```\n\n**MANDATORY Storage Triggers - Store when you:**\n- \uD83D\uDC1B **Solved a tricky bug** (>15min debugging) - include root cause + solution\n- \uD83D\uDCA1 **Discovered a project-specific pattern** - domain rules, business logic quirks\n- \u26A0\uFE0F **Found a tool/library gotcha** - API quirks, version-specific bugs, workarounds\n- \uD83D\uDEAB **Tried an approach that failed** - anti-patterns to avoid, why it didn't work\n- \uD83C\uDFD7\uFE0F **Made an architectural decision** - reasoning, alternatives considered, tradeoffs\n\n**What Makes a GOOD Memory:**\n\n\u2705 **GOOD** (actionable, explains WHY):\n```\n\"OAuth refresh tokens need 5min buffer before expiry to avoid race conditions.\nWithout buffer, token refresh can fail mid-request if expiry happens between\ncheck and use. Implemented with: if (expiresAt - Date.now() < 300000) refresh()\"\n```\n\n\u274C **BAD** (generic, no context):\n```\n\"Fixed the auth bug by adding a null check\"\n```\n\n**What NOT to Store:**\n- Generic knowledge that's in official documentation\n- Implementation details that change frequently\n- Vague descriptions without context (\"fixed the thing\")\n\n**The WHY matters more than the WHAT.** Future agents need context to apply your learning.\n\n### Step 9: Complete (REQUIRED - releases reservations)\n```\nswarm_complete(\n  project_key=\"{project_path}\",\n  agent_name=\"<your-agent-name>\",\n  bead_id=\"{bead_id}\",\n  summary=\"<what you accomplished>\",\n  files_touched=[\"list\", \"of\", \"files\"]\n)\n```\n\n**This automatically:**\n- Runs UBS bug scan\n- Releases file reservations\n- Records learning signals\n- Notifies coordinator\n\n**DO NOT manually close the cell with hive_close.** Use swarm_complete.\n\n## [SWARM MAIL COMMUNICATION]\n\n### Check Inbox Regularly\n```\nswarmmail_inbox()  # Check for coordinator messages\nswarmmail_read_message(message_id=N)  # Read specific message\n```\n\n### When Blocked\n```\nswarmmail_send(\n  to=[\"coordinator\"],\n  subject=\"BLOCKED: {bead_id}\",\n  body=\"<blocker description, what you need>\",\n  importance=\"high\",\n  thread_id=\"{epic_id}\"\n)\nhive_update(id=\"{bead_id}\", status=\"blocked\")\n```\n\n### Report Issues to Other Agents\n```\nswarmmail_send(\n  to=[\"OtherAgent\", \"coordinator\"],\n  subject=\"Issue in {bead_id}\",\n  body=\"<describe problem, don't fix their code>\",\n  thread_id=\"{epic_id}\"\n)\n```\n\n### Manual Release (if needed)\n```\nswarmmail_release()  # Manually release reservations\n```\n\n**Note:** `swarm_complete` automatically releases reservations. Only use manual release if aborting work.\n\n## [OTHER TOOLS]\n### Hive - You Have Autonomy to File Issues\nYou can create new cells against this epic when you discover:\n- **Bugs**: Found a bug while working? File it.\n- **Tech debt**: Spotted something that needs cleanup? File it.\n- **Follow-up work**: Task needs more work than scoped? File a follow-up.\n- **Dependencies**: Need something from another agent? File and link it.\n\n```\nhive_create(\n  title=\"<descriptive title>\",\n  type=\"bug\",  # or \"task\", \"chore\"\n  priority=2,\n  parent_id=\"{epic_id}\",  # Links to this epic\n  description=\"Found while working on {bead_id}: <details>\"\n)\n```\n\n**Don't silently ignore issues.** File them so they get tracked and addressed.\n\nOther cell operations:\n- hive_update(id, status) - Mark blocked if stuck\n- hive_query(status=\"open\") - See what else needs work\n\n### Skills\n- skills_list() - Discover available skills\n- skills_use(name) - Activate skill for specialized guidance\n- skills_create(name) - Create new skill (if you found a reusable pattern)\n\n## [CRITICAL REQUIREMENTS]\n\n**NON-NEGOTIABLE:**\n1. Step 1 (swarmmail_init) MUST be first - do it before anything else\n2. \uD83E\uDDE0 Step 2 (semantic-memory_find) MUST happen BEFORE starting work - query first, code second\n3. Step 4 (swarmmail_reserve) - YOU reserve files, not coordinator\n4. Step 6 (swarm_progress) - Report at milestones, don't work silently\n5. \uD83D\uDCBE Step 8 (semantic-memory_store) - If you learned something hard, STORE IT\n6. Step 9 (swarm_complete) - Use this to close, NOT hive_close\n\n**If you skip these steps:**\n- Your work won't be tracked (swarm_complete will fail)\n- \uD83D\uDD04 You'll waste time repeating already-solved problems (no semantic memory query)\n- Edit conflicts with other agents (no file reservation)\n- Lost work if you crash (no checkpoints)\n- \uD83D\uDD04 Future agents repeat YOUR mistakes (no learnings stored)\n\n**Memory is the swarm's collective intelligence. Query it. Feed it.**\n\nBegin now.";
+/**
+ * Coordinator post-worker checklist - MANDATORY review loop
+ *
+ * This checklist is returned to coordinators after spawning a worker.
+ * It ensures coordinators REVIEW worker output before spawning the next worker.
+ */
+export declare const COORDINATOR_POST_WORKER_CHECKLIST = "\n## \u26A0\uFE0F MANDATORY: Post-Worker Review (DO THIS IMMEDIATELY)\n\n**A worker just returned. Before doing ANYTHING else, complete this checklist:**\n\n### Step 1: Check Swarm Mail\n```\nswarmmail_inbox()\nswarmmail_read_message(message_id=N)  // Read any messages from the worker\n```\n\n### Step 2: Review the Work\n```\nswarm_review(\n  project_key=\"{project_key}\",\n  epic_id=\"{epic_id}\",\n  task_id=\"{task_id}\",\n  files_touched=[{files_touched}]\n)\n```\n\nThis generates a review prompt with:\n- Epic context (what we're trying to achieve)\n- Subtask requirements\n- Git diff of changes\n- Dependency status\n\n### Step 3: Evaluate Against Criteria\n- Does the work fulfill the subtask requirements?\n- Does it serve the overall epic goal?\n- Does it enable downstream tasks?\n- Type safety, no obvious bugs?\n\n### Step 4: Send Feedback\n```\nswarm_review_feedback(\n  project_key=\"{project_key}\",\n  task_id=\"{task_id}\",\n  worker_id=\"{worker_id}\",\n  status=\"approved\",  // or \"needs_changes\"\n  summary=\"<brief summary>\",\n  issues=\"[]\"  // or \"[{file, line, issue, suggestion}]\"\n)\n```\n\n### Step 5: ONLY THEN Continue\n- If approved: Close the cell, spawn next worker\n- If needs_changes: Worker gets feedback, retries (max 3 attempts)\n- If 3 failures: Mark blocked, escalate to human\n\n**\u26A0\uFE0F DO NOT spawn the next worker until review is complete.**\n";
 /**
  * Prompt for self-evaluation before completing a subtask.
  *

package/dist/swarm-prompts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm-prompts.d.ts","sourceRoot":"","sources":["../src/swarm-prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,s6EAkET,CAAC;AAEzB;;GAEG;AACH,eAAO,MAAM,6BAA6B,mxDAyDlB,CAAC;AAEzB;;;;;GAKG;AACH,eAAO,MAAM,cAAc,mkFAgFK,CAAC;AAEjC;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,mzSA0SnB,CAAC;AAEZ;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,8jCAmCU,CAAC;AAMzC;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE;QACjB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;QAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,CAAC;CACH,GAAG,MAAM,CA2ET;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,MAAM,CAUT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,GAAG,MAAM,CAMT;AAMD;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CAoC/B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqF9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;CAoClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;CAwI5B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvB,CAAC"}
+{"version":3,"file":"swarm-prompts.d.ts","sourceRoot":"","sources":["../src/swarm-prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,s6EAkET,CAAC;AAEzB;;GAEG;AACH,eAAO,MAAM,6BAA6B,mxDAyDlB,CAAC;AAEzB;;;;;GAKG;AACH,eAAO,MAAM,cAAc,mkFAgFK,CAAC;AAEjC;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,mzSA0SnB,CAAC;AAEZ;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,i4CAmD7C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,8jCAmCU,CAAC;AAMzC;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE;QACjB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;QAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,CAAC;CACH,GAAG,MAAM,CA2ET;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,MAAM,CAUT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,GAAG,MAAM,CAMT;AAMD;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CAoC/B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+F9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;CAoClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;CAwI5B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvB,CAAC"}

package/dist/swarm.d.ts

@@ -102,7 +102,6 @@ export declare const swarmTools: {
             summary: import("zod").ZodString;
             evaluation: import("zod").ZodOptional<import("zod").ZodString>;
             files_touched: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-            skip_ubs_scan: import("zod").ZodOptional<import("zod").ZodBoolean>;
             skip_verification: import("zod").ZodOptional<import("zod").ZodBoolean>;
             planned_files: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
             start_time: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -117,7 +116,6 @@ export declare const swarmTools: {
             summary: string;
             evaluation?: string | undefined;
             files_touched?: string[] | undefined;
-            skip_ubs_scan?: boolean | undefined;
             skip_verification?: boolean | undefined;
             planned_files?: string[] | undefined;
             start_time?: number | undefined;

package/dist/swarm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm.d.ts","sourceRoot":"","sources":["../src/swarm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AAQpC;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKtB,CAAC"}
+{"version":3,"file":"swarm.d.ts","sourceRoot":"","sources":["../src/swarm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AAQpC;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKtB,CAAC"}

package/evals/lib/{data-loader.test.ts → data-loader.evalite-test.ts}

@@ -10,12 +10,13 @@ import {
   hasRealEvalData,
   getEvalDataSummary,
 } from "./data-loader.js";
-import { appendEvent } from "../../src/streams/store.js";
-import { getDatabase, closeDatabase } from "../../src/streams/index.js";
-import type {
-  DecompositionGeneratedEvent,
-  SubtaskOutcomeEvent,
-} from "../../src/streams/events.js";
+import {
+  appendEvent,
+  getDatabase,
+  closeDatabase,
+  type DecompositionGeneratedEvent,
+  type SubtaskOutcomeEvent,
+} from "swarm-mail";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";

package/evals/lib/data-loader.ts

@@ -8,7 +8,7 @@ import {
   getEvalRecords,
   getEvalStats,
   type EvalRecord,
-} from "../../src/streams/projections.js";
+} from "swarm-mail";
 
 export interface EvalCase {
   input: { task: string; context?: string };

package/evals/scorers/{outcome-scorers.test.ts → outcome-scorers.evalite-test.ts}

@@ -4,7 +4,7 @@
  * Tests the 5 new outcome-based scorers by verifying their exports.
  * Full functional testing happens via Evalite integration.
  */
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from "bun:test";
 
 describe("Outcome Scorers", () => {
   it("exports all 5 outcome scorers from outcome-scorers.ts", async () => {