opencode-swarm-plugin 0.17.1 → 0.19.0

package/dist/plugin.js

@@ -12807,9 +12807,24 @@ var init_events = __esm(() => {
 });
 
 // src/streams/store.ts
+function parseTimestamp(timestamp) {
+  const ts = parseInt(timestamp, 10);
+  if (Number.isNaN(ts)) {
+    throw new Error(`[SwarmMail] Invalid timestamp: ${timestamp}`);
+  }
+  if (ts > Number.MAX_SAFE_INTEGER) {
+    console.warn(`[SwarmMail] Timestamp ${timestamp} exceeds MAX_SAFE_INTEGER (year 2286+), precision may be lost`);
+  }
+  return ts;
+}
 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,86 +12833,109 @@ 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 };
 }
 async function appendEvents(events, projectPath) {
-  const db = await getDatabase(projectPath);
-  const results = [];
-  await db.exec("BEGIN");
-  try {
-    for (const event of events) {
-      const { type, project_key, timestamp, ...rest } = event;
-      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)]);
-      const row = result.rows[0];
-      if (!row) {
-        throw new Error("Failed to insert event - no row returned");
-      }
-      const { id, sequence } = row;
-      const enrichedEvent = { ...event, id, sequence };
-      await updateMaterializedViews(db, enrichedEvent);
-      results.push(enrichedEvent);
-    }
-    await db.exec("COMMIT");
-  } catch (error45) {
-    await db.exec("ROLLBACK");
-    throw error45;
-  }
-  return results;
+  return withTiming("appendEvents", async () => {
+    const db = await getDatabase(projectPath);
+    const results = [];
+    await db.exec("BEGIN");
+    try {
+      for (const event of events) {
+        const { type, project_key, timestamp, ...rest } = event;
+        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)]);
+        const row = result.rows[0];
+        if (!row) {
+          throw new Error("Failed to insert event - no row returned");
+        }
+        const { id, sequence } = row;
+        const enrichedEvent = { ...event, id, sequence };
+        await updateMaterializedViews(db, enrichedEvent);
+        results.push(enrichedEvent);
+      }
+      await db.exec("COMMIT");
+    } catch (e) {
+      let rollbackError = null;
+      try {
+        await db.exec("ROLLBACK");
+      } catch (rbErr) {
+        rollbackError = rbErr;
+        console.error("[SwarmMail] ROLLBACK failed:", rbErr);
+      }
+      if (rollbackError) {
+        const compositeError = new Error(`Transaction failed: ${e instanceof Error ? e.message : String(e)}. ` + `ROLLBACK also failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}. ` + `Database may be in inconsistent state.`);
+        compositeError.originalError = e;
+        compositeError.rollbackError = rollbackError;
+        throw compositeError;
+      }
+      throw e;
+    }
+    return results;
+  });
 }
 async function readEvents(options2 = {}, projectPath) {
-  const db = await getDatabase(projectPath);
-  const conditions = [];
-  const params = [];
-  let paramIndex = 1;
-  if (options2.projectKey) {
-    conditions.push(`project_key = $${paramIndex++}`);
-    params.push(options2.projectKey);
-  }
-  if (options2.types && options2.types.length > 0) {
-    conditions.push(`type = ANY($${paramIndex++})`);
-    params.push(options2.types);
-  }
-  if (options2.since !== undefined) {
-    conditions.push(`timestamp >= $${paramIndex++}`);
-    params.push(options2.since);
-  }
-  if (options2.until !== undefined) {
-    conditions.push(`timestamp <= $${paramIndex++}`);
-    params.push(options2.until);
-  }
-  if (options2.afterSequence !== undefined) {
-    conditions.push(`sequence > $${paramIndex++}`);
-    params.push(options2.afterSequence);
-  }
-  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  let query = `
-    SELECT id, type, project_key, timestamp, sequence, data
-    FROM events
-    ${whereClause}
-    ORDER BY sequence ASC
-  `;
-  if (options2.limit) {
-    query += ` LIMIT $${paramIndex++}`;
-    params.push(options2.limit);
-  }
-  if (options2.offset) {
-    query += ` OFFSET $${paramIndex++}`;
-    params.push(options2.offset);
-  }
-  const result = await db.query(query, params);
-  return result.rows.map((row) => {
-    const data = typeof row.data === "string" ? JSON.parse(row.data) : row.data;
-    return {
-      id: row.id,
-      type: row.type,
-      project_key: row.project_key,
-      timestamp: parseInt(row.timestamp),
-      sequence: row.sequence,
-      ...data
-    };
+  return withTiming("readEvents", async () => {
+    const db = await getDatabase(projectPath);
+    const conditions = [];
+    const params = [];
+    let paramIndex = 1;
+    if (options2.projectKey) {
+      conditions.push(`project_key = $${paramIndex++}`);
+      params.push(options2.projectKey);
+    }
+    if (options2.types && options2.types.length > 0) {
+      conditions.push(`type = ANY($${paramIndex++})`);
+      params.push(options2.types);
+    }
+    if (options2.since !== undefined) {
+      conditions.push(`timestamp >= $${paramIndex++}`);
+      params.push(options2.since);
+    }
+    if (options2.until !== undefined) {
+      conditions.push(`timestamp <= $${paramIndex++}`);
+      params.push(options2.until);
+    }
+    if (options2.afterSequence !== undefined) {
+      conditions.push(`sequence > $${paramIndex++}`);
+      params.push(options2.afterSequence);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    let query = `
+      SELECT id, type, project_key, timestamp, sequence, data
+      FROM events
+      ${whereClause}
+      ORDER BY sequence ASC
+    `;
+    if (options2.limit) {
+      query += ` LIMIT $${paramIndex++}`;
+      params.push(options2.limit);
+    }
+    if (options2.offset) {
+      query += ` OFFSET $${paramIndex++}`;
+      params.push(options2.offset);
+    }
+    const result = await db.query(query, params);
+    return result.rows.map((row) => {
+      const data = typeof row.data === "string" ? JSON.parse(row.data) : row.data;
+      return {
+        id: row.id,
+        type: row.type,
+        project_key: row.project_key,
+        timestamp: parseTimestamp(row.timestamp),
+        sequence: row.sequence,
+        ...data
+      };
+    });
   });
 }
 async function getLatestSequence(projectKey, projectPath) {
@@ -12908,71 +12946,131 @@ async function getLatestSequence(projectKey, projectPath) {
   return result.rows[0]?.seq ?? 0;
 }
 async function replayEvents(options2 = {}, projectPath) {
-  const startTime = Date.now();
-  const db = await getDatabase(projectPath);
-  if (options2.clearViews) {
-    if (options2.projectKey) {
+  return withTiming("replayEvents", async () => {
+    const startTime = Date.now();
+    const db = await getDatabase(projectPath);
+    if (options2.clearViews) {
+      if (options2.projectKey) {
+        await db.query(`DELETE FROM message_recipients WHERE message_id IN (
+            SELECT id FROM messages WHERE project_key = $1
+          )`, [options2.projectKey]);
+        await db.query(`DELETE FROM messages WHERE project_key = $1`, [
+          options2.projectKey
+        ]);
+        await db.query(`DELETE FROM reservations WHERE project_key = $1`, [
+          options2.projectKey
+        ]);
+        await db.query(`DELETE FROM agents WHERE project_key = $1`, [
+          options2.projectKey
+        ]);
+      } else {
+        await db.exec(`
+          DELETE FROM message_recipients;
+          DELETE FROM messages;
+          DELETE FROM reservations;
+          DELETE FROM agents;
+        `);
+      }
+    }
+    const events = await readEvents({
+      projectKey: options2.projectKey,
+      afterSequence: options2.fromSequence
+    }, projectPath);
+    for (const event of events) {
+      await updateMaterializedViews(db, event);
+    }
+    return {
+      eventsReplayed: events.length,
+      duration: Date.now() - startTime
+    };
+  });
+}
+async function replayEventsBatched(projectKey, onBatch, options2 = {}, projectPath) {
+  return withTiming("replayEventsBatched", async () => {
+    const startTime = Date.now();
+    const batchSize = options2.batchSize ?? 1000;
+    const fromSequence = options2.fromSequence ?? 0;
+    const db = await getDatabase(projectPath);
+    if (options2.clearViews) {
       await db.query(`DELETE FROM message_recipients WHERE message_id IN (
           SELECT id FROM messages WHERE project_key = $1
-        )`, [options2.projectKey]);
+        )`, [projectKey]);
       await db.query(`DELETE FROM messages WHERE project_key = $1`, [
-        options2.projectKey
+        projectKey
       ]);
       await db.query(`DELETE FROM reservations WHERE project_key = $1`, [
-        options2.projectKey
-      ]);
-      await db.query(`DELETE FROM agents WHERE project_key = $1`, [
-        options2.projectKey
+        projectKey
       ]);
-    } else {
-      await db.exec(`
-        DELETE FROM message_recipients;
-        DELETE FROM messages;
-        DELETE FROM reservations;
-        DELETE FROM agents;
-      `);
+      await db.query(`DELETE FROM agents WHERE project_key = $1`, [projectKey]);
+    }
+    const countResult = await db.query(`SELECT COUNT(*) as count FROM events WHERE project_key = $1 AND sequence > $2`, [projectKey, fromSequence]);
+    const total = parseInt(countResult.rows[0]?.count ?? "0");
+    if (total === 0) {
+      return { eventsReplayed: 0, duration: Date.now() - startTime };
+    }
+    let processed = 0;
+    let offset = 0;
+    while (processed < total) {
+      const events = await readEvents({
+        projectKey,
+        afterSequence: fromSequence,
+        limit: batchSize,
+        offset
+      }, projectPath);
+      if (events.length === 0)
+        break;
+      for (const event of events) {
+        await updateMaterializedViews(db, event);
+      }
+      processed += events.length;
+      const percent = Math.round(processed / total * 100);
+      await onBatch(events, { processed, total, percent });
+      console.log(`[SwarmMail] Replaying events: ${processed}/${total} (${percent}%)`);
+      offset += batchSize;
     }
-  }
-  const events = await readEvents({
-    projectKey: options2.projectKey,
-    afterSequence: options2.fromSequence
-  }, projectPath);
-  for (const event of events) {
-    await updateMaterializedViews(db, event);
-  }
-  return {
-    eventsReplayed: events.length,
-    duration: Date.now() - startTime
-  };
+    return {
+      eventsReplayed: processed,
+      duration: Date.now() - startTime
+    };
+  });
 }
 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 +13090,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 +13113,49 @@ 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
-    ]);
+    ];
+    if (event.paths.length > 0) {
+      await db.query(`DELETE FROM reservations 
+         WHERE project_key = $1 
+           AND agent_name = $2 
+           AND path_pattern = ANY($3)
+           AND released_at IS NULL`, [event.project_key, event.agent_name, event.paths]);
+    }
+    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) {
@@ -13078,9 +13207,11 @@ async function reserveFiles(projectKey, agentName, paths, options2 = {}, project
   });
   return appendEvent(event, projectPath);
 }
+var TIMESTAMP_SAFE_UNTIL;
 var init_store = __esm(() => {
   init_streams();
   init_events();
+  TIMESTAMP_SAFE_UNTIL = new Date("2286-01-01").getTime();
 });
 
 // node_modules/.pnpm/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
@@ -14592,6 +14723,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 +14738,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) {
@@ -14892,7 +15036,18 @@ function getAgentFromEvent(event) {
   return "unknown";
 }
 async function debugEvents(options2) {
-  const { projectPath, types: types2, agentName, limit = 50, since, until } = options2;
+  const {
+    projectPath,
+    types: types2,
+    agentName,
+    limit = 50,
+    since,
+    until,
+    batchSize
+  } = options2;
+  if (batchSize && batchSize > 0) {
+    return await debugEventsPaginated({ ...options2, batchSize });
+  }
   const allEvents = await readEvents({
     projectKey: projectPath,
     types: types2,
@@ -14929,6 +15084,63 @@ async function debugEvents(options2) {
     total: filteredEvents.length
   };
 }
+async function debugEventsPaginated(options2) {
+  const {
+    projectPath,
+    types: types2,
+    agentName,
+    limit = 50,
+    since,
+    until,
+    batchSize
+  } = options2;
+  const allEvents = [];
+  let offset = 0;
+  let hasMore = true;
+  while (hasMore && allEvents.length < limit) {
+    const batch = await readEvents({
+      projectKey: projectPath,
+      types: types2,
+      since,
+      until,
+      limit: batchSize,
+      offset
+    }, projectPath);
+    if (batch.length === 0) {
+      hasMore = false;
+      break;
+    }
+    const filtered = agentName ? batch.filter((e) => {
+      if ("agent_name" in e && e.agent_name === agentName)
+        return true;
+      if ("from_agent" in e && e.from_agent === agentName)
+        return true;
+      if ("to_agents" in e && e.to_agents?.includes(agentName))
+        return true;
+      return false;
+    }) : batch;
+    allEvents.push(...filtered);
+    offset += batchSize;
+    console.log(`[SwarmMail] Fetched ${allEvents.length} events (batch size: ${batchSize})`);
+  }
+  allEvents.sort((a, b) => b.sequence - a.sequence);
+  const limitedEvents = allEvents.slice(0, limit);
+  const events = limitedEvents.map((e) => {
+    const { id, sequence, type, timestamp, project_key, ...rest } = e;
+    return {
+      id,
+      sequence,
+      type,
+      timestamp,
+      timestamp_human: formatTimestamp(timestamp),
+      ...rest
+    };
+  });
+  return {
+    events,
+    total: allEvents.length
+  };
+}
 async function debugAgent(options2) {
   const { projectPath, agentName, includeEvents = false } = options2;
   const agent = await getAgent(projectPath, agentName, projectPath);
@@ -15271,6 +15483,8 @@ var init_migrations = __esm(() => {
 // src/streams/index.ts
 var exports_streams = {};
 __export(exports_streams, {
+  withTiming: () => withTiming,
+  withTimeout: () => withTimeout,
   sendSwarmMessage: () => sendSwarmMessage,
   sendMessage: () => sendMessage,
   sendAgentMessage: () => sendAgentMessage,
@@ -15280,6 +15494,7 @@ __export(exports_streams, {
   reserveSwarmFiles: () => reserveSwarmFiles,
   reserveFiles: () => reserveFiles,
   reserveAgentFiles: () => reserveAgentFiles,
+  replayEventsBatched: () => replayEventsBatched,
   replayEvents: () => replayEvents,
   releaseSwarmFiles: () => releaseSwarmFiles,
   releaseAgentFiles: () => releaseAgentFiles,
@@ -15343,6 +15558,21 @@ 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]);
+}
+async function withTiming(operation, fn) {
+  const start = performance.now();
+  try {
+    return await fn();
+  } finally {
+    const duration3 = performance.now() - start;
+    if (duration3 > SLOW_QUERY_THRESHOLD_MS) {
+      console.warn(`[SwarmMail] Slow operation: ${operation} took ${duration3.toFixed(1)}ms`);
+    }
+  }
+}
 function debugLog(message, data) {
   const timestamp = new Date().toISOString();
   const logLine = data ? `[${timestamp}] ${message}: ${JSON.stringify(data, null, 2)}
@@ -15622,7 +15852,7 @@ function handleExit() {
     } catch {}
   }
 }
-var DEBUG_LOG_PATH, instances, pendingInstances, schemaInitialized, degradedInstances, lastAccess, MAX_CACHE_SIZE = 10;
+var SLOW_QUERY_THRESHOLD_MS = 100, DEBUG_LOG_PATH, instances, pendingInstances, schemaInitialized, degradedInstances, lastAccess, MAX_CACHE_SIZE = 10;
 var init_streams = __esm(() => {
   init_agent_mail();
   init_debug();
@@ -25060,93 +25290,878 @@ var require_built3 = __commonJS((exports, module) => {
   exports.print = print;
 });
 
-// node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js
-var require_kind_of = __commonJS((exports, module) => {
-  var toString = Object.prototype.toString;
-  module.exports = function kindOf(val) {
-    if (val === undefined)
-      return "undefined";
-    if (val === null)
-      return "null";
-    var type = typeof val;
-    if (type === "boolean")
-      return "boolean";
-    if (type === "string")
-      return "string";
-    if (type === "number")
-      return "number";
-    if (type === "symbol")
-      return "symbol";
-    if (type === "function") {
-      return isGeneratorFn(val) ? "generatorfunction" : "function";
-    }
-    if (isArray(val))
-      return "array";
-    if (isBuffer(val))
-      return "buffer";
-    if (isArguments(val))
-      return "arguments";
-    if (isDate(val))
-      return "date";
-    if (isError(val))
-      return "error";
-    if (isRegexp(val))
-      return "regexp";
-    switch (ctorName(val)) {
-      case "Symbol":
-        return "symbol";
-      case "Promise":
-        return "promise";
-      case "WeakMap":
-        return "weakmap";
-      case "WeakSet":
-        return "weakset";
-      case "Map":
-        return "map";
-      case "Set":
-        return "set";
-      case "Int8Array":
-        return "int8array";
-      case "Uint8Array":
-        return "uint8array";
-      case "Uint8ClampedArray":
-        return "uint8clampedarray";
-      case "Int16Array":
-        return "int16array";
-      case "Uint16Array":
-        return "uint16array";
-      case "Int32Array":
-        return "int32array";
-      case "Uint32Array":
-        return "uint32array";
-      case "Float32Array":
-        return "float32array";
-      case "Float64Array":
-        return "float64array";
-    }
-    if (isGeneratorObj(val)) {
-      return "generator";
-    }
-    type = toString.call(val);
-    switch (type) {
-      case "[object Object]":
-        return "object";
-      case "[object Map Iterator]":
-        return "mapiterator";
-      case "[object Set Iterator]":
-        return "setiterator";
-      case "[object String Iterator]":
-        return "stringiterator";
-      case "[object Array Iterator]":
-        return "arrayiterator";
-    }
-    return type.slice(8, -1).toLowerCase().replace(/\s/g, "");
+// src/swarm-strategies.ts
+var exports_swarm_strategies = {};
+__export(exports_swarm_strategies, {
+  swarm_select_strategy: () => swarm_select_strategy,
+  strategyTools: () => strategyTools,
+  selectStrategy: () => selectStrategy,
+  formatStrategyGuidelines: () => formatStrategyGuidelines,
+  STRATEGIES: () => STRATEGIES,
+  POSITIVE_MARKERS: () => POSITIVE_MARKERS,
+  NEGATIVE_MARKERS: () => NEGATIVE_MARKERS,
+  DecompositionStrategySchema: () => DecompositionStrategySchema
+});
+function selectStrategy(task) {
+  const taskLower = task.toLowerCase();
+  const scores = {
+    "file-based": 0,
+    "feature-based": 0,
+    "risk-based": 0,
+    "research-based": 0
   };
-  function ctorName(val) {
-    return typeof val.constructor === "function" ? val.constructor.name : null;
-  }
-  function isArray(val) {
-    if (Array.isArray)
+  for (const [strategyName, definition] of Object.entries(STRATEGIES)) {
+    const name = strategyName;
+    for (const keyword of definition.keywords) {
+      if (keyword.includes(" ")) {
+        if (taskLower.includes(keyword)) {
+          scores[name] += 1;
+        }
+      } else {
+        const regex = new RegExp(`\\b${keyword}\\b`, "i");
+        if (regex.test(taskLower)) {
+          scores[name] += 1;
+        }
+      }
+    }
+  }
+  const entries = Object.entries(scores);
+  entries.sort((a, b) => b[1] - a[1]);
+  const [winner, winnerScore] = entries[0];
+  const [, runnerUpScore] = entries[1] || [null, 0];
+  const totalScore = entries.reduce((sum, [, score]) => sum + score, 0);
+  const confidence = totalScore > 0 ? Math.min(0.95, 0.5 + (winnerScore - runnerUpScore) / totalScore) : 0.5;
+  let reasoning;
+  if (winnerScore === 0) {
+    reasoning = `No strong keyword signals. Defaulting to feature-based as it's most versatile.`;
+  } else {
+    const matchedKeywords = STRATEGIES[winner].keywords.filter((k) => taskLower.includes(k));
+    reasoning = `Matched keywords: ${matchedKeywords.join(", ")}. ${STRATEGIES[winner].description}`;
+  }
+  const finalStrategy = winnerScore === 0 ? "feature-based" : winner;
+  return {
+    strategy: finalStrategy,
+    confidence,
+    reasoning,
+    alternatives: entries.filter(([s]) => s !== finalStrategy).map(([strategy, score]) => ({ strategy, score }))
+  };
+}
+function formatStrategyGuidelines(strategy) {
+  const def = STRATEGIES[strategy];
+  const guidelines = def.guidelines.map((g) => `- ${g}`).join(`
+`);
+  const antiPatterns = def.antiPatterns.map((a) => `- ${a}`).join(`
+`);
+  const examples = def.examples.map((e) => `- ${e}`).join(`
+`);
+  return `## Strategy: ${strategy}
+
+${def.description}
+
+### Guidelines
+${guidelines}
+
+### Anti-Patterns (Avoid These)
+${antiPatterns}
+
+### Examples
+${examples}`;
+}
+var DecompositionStrategySchema, POSITIVE_MARKERS, NEGATIVE_MARKERS, STRATEGIES, swarm_select_strategy, strategyTools;
+var init_swarm_strategies = __esm(() => {
+  init_dist();
+  init_zod();
+  DecompositionStrategySchema = exports_external.enum([
+    "file-based",
+    "feature-based",
+    "risk-based",
+    "research-based",
+    "auto"
+  ]);
+  POSITIVE_MARKERS = [
+    "always",
+    "must",
+    "required",
+    "ensure",
+    "use",
+    "prefer"
+  ];
+  NEGATIVE_MARKERS = [
+    "never",
+    "dont",
+    "don't",
+    "avoid",
+    "forbid",
+    "no ",
+    "not "
+  ];
+  STRATEGIES = {
+    "file-based": {
+      name: "file-based",
+      description: "Group by file type or directory. Best for refactoring, migrations, and pattern changes across codebase.",
+      keywords: [
+        "refactor",
+        "migrate",
+        "update all",
+        "rename",
+        "replace",
+        "convert",
+        "upgrade",
+        "deprecate",
+        "remove",
+        "cleanup",
+        "lint",
+        "format"
+      ],
+      guidelines: [
+        "Group files by directory or type (e.g., all components, all tests)",
+        "Minimize cross-directory dependencies within a subtask",
+        "Handle shared types/utilities first if they change",
+        "Each subtask should be a complete transformation of its file set",
+        "Consider import/export relationships when grouping"
+      ],
+      antiPatterns: [
+        "Don't split tightly coupled files across subtasks",
+        "Don't group files that have no relationship",
+        "Don't forget to update imports when moving/renaming"
+      ],
+      examples: [
+        "Migrate all components to new API → split by component directory",
+        "Rename userId to accountId → split by module (types first, then consumers)",
+        "Update all tests to use new matcher → split by test directory"
+      ]
+    },
+    "feature-based": {
+      name: "feature-based",
+      description: "Vertical slices with UI + API + data. Best for new features and adding functionality.",
+      keywords: [
+        "add",
+        "implement",
+        "build",
+        "create",
+        "feature",
+        "new",
+        "integrate",
+        "connect",
+        "enable",
+        "support"
+      ],
+      guidelines: [
+        "Each subtask is a complete vertical slice (UI + logic + data)",
+        "Start with data layer/types, then logic, then UI",
+        "Keep related components together (form + validation + submission)",
+        "Separate concerns that can be developed independently",
+        "Consider user-facing features as natural boundaries"
+      ],
+      antiPatterns: [
+        "Don't split a single feature across multiple subtasks",
+        "Don't create subtasks that can't be tested independently",
+        "Don't forget integration points between features"
+      ],
+      examples: [
+        "Add user auth → [OAuth setup, Session management, Protected routes]",
+        "Build dashboard → [Data fetching, Chart components, Layout/navigation]",
+        "Add search → [Search API, Search UI, Results display]"
+      ]
+    },
+    "risk-based": {
+      name: "risk-based",
+      description: "Isolate high-risk changes, add tests first. Best for bug fixes, security issues, and critical changes.",
+      keywords: [
+        "fix",
+        "bug",
+        "security",
+        "vulnerability",
+        "critical",
+        "urgent",
+        "hotfix",
+        "patch",
+        "audit",
+        "review"
+      ],
+      guidelines: [
+        "Write tests FIRST to capture expected behavior",
+        "Isolate the risky change to minimize blast radius",
+        "Add monitoring/logging around the change",
+        "Create rollback plan as part of the task",
+        "Audit similar code for the same issue"
+      ],
+      antiPatterns: [
+        "Don't make multiple risky changes in one subtask",
+        "Don't skip tests for 'simple' fixes",
+        "Don't forget to check for similar issues elsewhere"
+      ],
+      examples: [
+        "Fix auth bypass → [Add regression test, Fix vulnerability, Audit similar endpoints]",
+        "Fix race condition → [Add test reproducing issue, Implement fix, Add concurrency tests]",
+        "Security audit → [Scan for vulnerabilities, Fix critical issues, Document remaining risks]"
+      ]
+    },
+    "research-based": {
+      name: "research-based",
+      description: "Parallel search across multiple sources, then synthesize. Best for investigation, learning, and discovery tasks.",
+      keywords: [
+        "research",
+        "investigate",
+        "explore",
+        "find out",
+        "discover",
+        "understand",
+        "learn about",
+        "analyze",
+        "what is",
+        "what are",
+        "how does",
+        "how do",
+        "why does",
+        "why do",
+        "compare",
+        "evaluate",
+        "study",
+        "look up",
+        "look into",
+        "search for",
+        "dig into",
+        "figure out",
+        "debug options",
+        "debug levers",
+        "configuration options",
+        "environment variables",
+        "available options",
+        "documentation"
+      ],
+      guidelines: [
+        "Split by information source (PDFs, repos, history, web)",
+        "Each agent searches with different query angles",
+        "Include a synthesis subtask that depends on all search subtasks",
+        "Use pdf-brain for documentation/books if available",
+        "Use repo-crawl for GitHub repos if URL provided",
+        "Use cass for past agent session history",
+        "Assign NO files to research subtasks (read-only)"
+      ],
+      antiPatterns: [
+        "Don't have one agent search everything sequentially",
+        "Don't skip synthesis - raw search results need consolidation",
+        "Don't forget to check tool availability before assigning sources"
+      ],
+      examples: [
+        "Research auth patterns → [Search PDFs, Search repos, Search history, Synthesize]",
+        "Investigate error → [Search cass for similar errors, Search repo for error handling, Synthesize]",
+        "Learn about library → [Search docs, Search examples, Search issues, Synthesize findings]"
+      ]
+    }
+  };
+  swarm_select_strategy = tool({
+    description: "Analyze task and recommend decomposition strategy (file-based, feature-based, or risk-based)",
+    args: {
+      task: tool.schema.string().min(1).describe("Task description to analyze"),
+      codebase_context: tool.schema.string().optional().describe("Optional codebase context (file structure, tech stack, etc.)")
+    },
+    async execute(args) {
+      const result = selectStrategy(args.task);
+      let enhancedReasoning = result.reasoning;
+      if (args.codebase_context) {
+        enhancedReasoning += `
+
+Codebase context considered: ${args.codebase_context.slice(0, 200)}...`;
+      }
+      return JSON.stringify({
+        strategy: result.strategy,
+        confidence: Math.round(result.confidence * 100) / 100,
+        reasoning: enhancedReasoning,
+        description: STRATEGIES[result.strategy].description,
+        guidelines: STRATEGIES[result.strategy].guidelines,
+        anti_patterns: STRATEGIES[result.strategy].antiPatterns,
+        alternatives: result.alternatives.map((alt) => ({
+          strategy: alt.strategy,
+          description: STRATEGIES[alt.strategy].description,
+          score: alt.score
+        }))
+      }, null, 2);
+    }
+  });
+  strategyTools = {
+    swarm_select_strategy
+  };
+});
+
+// src/learning.ts
+var exports_learning = {};
+__export(exports_learning, {
+  shouldDeprecateCriterion: () => shouldDeprecateCriterion,
+  scoreImplicitFeedback: () => scoreImplicitFeedback,
+  outcomeToFeedback: () => outcomeToFeedback,
+  learningSchemas: () => learningSchemas,
+  isStrikedOut: () => isStrikedOut,
+  getStrikes: () => getStrikes,
+  getArchitecturePrompt: () => getArchitecturePrompt,
+  formatMemoryValidationHint: () => formatMemoryValidationHint,
+  formatMemoryStoreOnSuccess: () => formatMemoryStoreOnSuccess,
+  formatMemoryStoreOn3Strike: () => formatMemoryStoreOn3Strike,
+  formatMemoryQueryForDecomposition: () => formatMemoryQueryForDecomposition,
+  clearStrikes: () => clearStrikes,
+  calculateDecayedValue: () => calculateDecayedValue,
+  calculateCriterionWeight: () => calculateCriterionWeight,
+  applyWeights: () => applyWeights,
+  addStrike: () => addStrike,
+  StrikeRecordSchema: () => StrikeRecordSchema,
+  ScoredOutcomeSchema: () => ScoredOutcomeSchema,
+  OutcomeSignalsSchema: () => OutcomeSignalsSchema,
+  InMemoryStrikeStorage: () => InMemoryStrikeStorage,
+  InMemoryFeedbackStorage: () => InMemoryFeedbackStorage,
+  InMemoryErrorStorage: () => InMemoryErrorStorage,
+  FeedbackTypeSchema: () => FeedbackTypeSchema,
+  FeedbackEventSchema: () => FeedbackEventSchema,
+  FailureModeSchema: () => FailureModeSchema2,
+  ErrorTypeSchema: () => ErrorTypeSchema,
+  ErrorEntrySchema: () => ErrorEntrySchema,
+  ErrorAccumulator: () => ErrorAccumulator,
+  DecompositionStrategySchema: () => DecompositionStrategySchema2,
+  DEFAULT_LEARNING_CONFIG: () => DEFAULT_LEARNING_CONFIG,
+  CriterionWeightSchema: () => CriterionWeightSchema
+});
+function calculateDecayedValue(timestamp, now = new Date, halfLifeDays = 90) {
+  const safeHalfLife = halfLifeDays <= 0 ? 1 : halfLifeDays;
+  const eventTime = new Date(timestamp).getTime();
+  const nowTime = now.getTime();
+  const ageDays = Math.max(0, (nowTime - eventTime) / (24 * 60 * 60 * 1000));
+  return Math.pow(0.5, ageDays / safeHalfLife);
+}
+function calculateCriterionWeight(events2, config2 = DEFAULT_LEARNING_CONFIG) {
+  if (events2.length === 0) {
+    return {
+      criterion: "unknown",
+      weight: 1,
+      helpful_count: 0,
+      harmful_count: 0,
+      last_validated: undefined,
+      half_life_days: config2.halfLifeDays
+    };
+  }
+  const now = new Date;
+  let helpfulSum = 0;
+  let harmfulSum = 0;
+  let helpfulCount = 0;
+  let harmfulCount = 0;
+  let lastValidated;
+  for (const event of events2) {
+    const decayed = calculateDecayedValue(event.timestamp, now, config2.halfLifeDays);
+    const value = event.raw_value * decayed;
+    if (event.type === "helpful") {
+      helpfulSum += value;
+      helpfulCount++;
+      if (!lastValidated || event.timestamp > lastValidated) {
+        lastValidated = event.timestamp;
+      }
+    } else if (event.type === "harmful") {
+      harmfulSum += value;
+      harmfulCount++;
+    }
+  }
+  const total = helpfulSum + harmfulSum;
+  const weight = total > 0 ? Math.max(0.1, helpfulSum / total) : 1;
+  return {
+    criterion: events2[0].criterion,
+    weight,
+    helpful_count: helpfulCount,
+    harmful_count: harmfulCount,
+    last_validated: lastValidated,
+    half_life_days: config2.halfLifeDays
+  };
+}
+function scoreImplicitFeedback(signals, config2 = DEFAULT_LEARNING_CONFIG) {
+  const now = new Date;
+  const decayed = calculateDecayedValue(signals.timestamp, now, config2.halfLifeDays);
+  const durationScore = signals.duration_ms < config2.fastCompletionThresholdMs ? 1 : signals.duration_ms > config2.slowCompletionThresholdMs ? 0.2 : 0.6;
+  const errorScore = signals.error_count === 0 ? 1 : signals.error_count <= config2.maxErrorsForHelpful ? 0.6 : 0.2;
+  const retryScore = signals.retry_count === 0 ? 1 : signals.retry_count === 1 ? 0.7 : 0.3;
+  const successScore = signals.success ? 1 : 0;
+  const rawScore = successScore * 0.4 + durationScore * 0.2 + errorScore * 0.2 + retryScore * 0.2;
+  let type;
+  let reasoning;
+  if (rawScore >= 0.7) {
+    type = "helpful";
+    reasoning = `Fast completion (${Math.round(signals.duration_ms / 1000)}s), ` + `${signals.error_count} errors, ${signals.retry_count} retries, ` + `${signals.success ? "succeeded" : "failed"}`;
+  } else if (rawScore <= 0.4) {
+    type = "harmful";
+    reasoning = `Slow completion (${Math.round(signals.duration_ms / 1000)}s), ` + `${signals.error_count} errors, ${signals.retry_count} retries, ` + `${signals.success ? "succeeded" : "failed"}`;
+  } else {
+    type = "neutral";
+    reasoning = `Mixed signals: ${Math.round(signals.duration_ms / 1000)}s, ` + `${signals.error_count} errors, ${signals.retry_count} retries`;
+  }
+  return {
+    signals,
+    type,
+    decayed_value: rawScore * decayed,
+    reasoning
+  };
+}
+function outcomeToFeedback(outcome, criterion) {
+  return {
+    id: `${outcome.signals.bead_id}-${criterion}-${Date.now()}`,
+    criterion,
+    type: outcome.type,
+    timestamp: outcome.signals.timestamp,
+    context: outcome.reasoning,
+    bead_id: outcome.signals.bead_id,
+    raw_value: outcome.decayed_value
+  };
+}
+function applyWeights(criteria, weights) {
+  const result = {};
+  for (const [name, rawScore] of Object.entries(criteria)) {
+    const weight = weights[name]?.weight ?? 1;
+    result[name] = {
+      raw: rawScore,
+      weighted: rawScore * weight,
+      weight
+    };
+  }
+  return result;
+}
+function shouldDeprecateCriterion(weight, config2 = DEFAULT_LEARNING_CONFIG) {
+  const total = weight.helpful_count + weight.harmful_count;
+  if (total < config2.minFeedbackForAdjustment) {
+    return false;
+  }
+  const harmfulRatio = weight.harmful_count / total;
+  return harmfulRatio > config2.maxHarmfulRatio;
+}
+
+class InMemoryFeedbackStorage {
+  events = [];
+  maxSize;
+  constructor(maxSize = 1e4) {
+    this.maxSize = maxSize;
+  }
+  async store(event) {
+    this.events.push(event);
+    if (this.events.length > this.maxSize) {
+      this.events = this.events.slice(this.events.length - this.maxSize);
+    }
+  }
+  async getByCriterion(criterion) {
+    return this.events.filter((e) => e.criterion === criterion);
+  }
+  async getByBead(beadId) {
+    return this.events.filter((e) => e.bead_id === beadId);
+  }
+  async getAll() {
+    return [...this.events];
+  }
+}
+
+class InMemoryStrikeStorage {
+  strikes = new Map;
+  async store(record2) {
+    this.strikes.set(record2.bead_id, record2);
+  }
+  async get(beadId) {
+    return this.strikes.get(beadId) ?? null;
+  }
+  async getAll() {
+    return Array.from(this.strikes.values());
+  }
+  async clear(beadId) {
+    this.strikes.delete(beadId);
+  }
+}
+async function addStrike(beadId, attempt, reason, storage = new InMemoryStrikeStorage) {
+  const existing = await storage.get(beadId);
+  const now = new Date().toISOString();
+  const record2 = existing ?? {
+    bead_id: beadId,
+    strike_count: 0,
+    failures: []
+  };
+  record2.strike_count = Math.min(3, record2.strike_count + 1);
+  record2.failures.push({ attempt, reason, timestamp: now });
+  record2.last_strike_at = now;
+  if (!record2.first_strike_at) {
+    record2.first_strike_at = now;
+  }
+  await storage.store(record2);
+  return record2;
+}
+async function getStrikes(beadId, storage = new InMemoryStrikeStorage) {
+  const record2 = await storage.get(beadId);
+  return record2?.strike_count ?? 0;
+}
+async function isStrikedOut(beadId, storage = new InMemoryStrikeStorage) {
+  const count = await getStrikes(beadId, storage);
+  return count >= 3;
+}
+async function getArchitecturePrompt(beadId, storage = new InMemoryStrikeStorage) {
+  const record2 = await storage.get(beadId);
+  if (!record2 || record2.strike_count < 3) {
+    return "";
+  }
+  const failuresList = record2.failures.map((f, i) => `${i + 1}. **${f.attempt}** - Failed: ${f.reason}`).join(`
+`);
+  return `## Architecture Review Required
+
+This bead (\`${beadId}\`) has failed 3 consecutive fix attempts:
+
+${failuresList}
+
+This pattern suggests an **architectural problem**, not a bug.
+
+**Questions to consider:**
+- Is the current approach fundamentally sound?
+- Should we refactor the architecture instead?
+- Are we fixing symptoms instead of root cause?
+
+**Options:**
+1. **Refactor architecture** (describe new approach)
+2. **Continue with Fix #4** (explain why this time is different)
+3. **Abandon this approach entirely**
+
+**DO NOT attempt Fix #4 without answering these questions.**
+`;
+}
+async function clearStrikes(beadId, storage = new InMemoryStrikeStorage) {
+  await storage.clear(beadId);
+}
+
+class InMemoryErrorStorage {
+  errors = [];
+  async store(entry) {
+    this.errors.push(entry);
+  }
+  async getByBead(beadId) {
+    return this.errors.filter((e) => e.bead_id === beadId);
+  }
+  async getUnresolvedByBead(beadId) {
+    return this.errors.filter((e) => e.bead_id === beadId && !e.resolved);
+  }
+  async markResolved(id) {
+    const error45 = this.errors.find((e) => e.id === id);
+    if (error45) {
+      error45.resolved = true;
+    }
+  }
+  async getAll() {
+    return [...this.errors];
+  }
+}
+
+class ErrorAccumulator {
+  storage;
+  constructor(storage) {
+    this.storage = storage ?? new InMemoryErrorStorage;
+  }
+  async recordError(beadId, errorType, message, options2) {
+    const entry = {
+      id: `${beadId}-${errorType}-${Date.now()}`,
+      bead_id: beadId,
+      error_type: errorType,
+      message,
+      stack_trace: options2?.stack_trace,
+      tool_name: options2?.tool_name,
+      timestamp: new Date().toISOString(),
+      resolved: false,
+      context: options2?.context
+    };
+    const validated = ErrorEntrySchema.parse(entry);
+    await this.storage.store(validated);
+    return validated;
+  }
+  async getErrors(beadId) {
+    return this.storage.getByBead(beadId);
+  }
+  async getUnresolvedErrors(beadId) {
+    return this.storage.getUnresolvedByBead(beadId);
+  }
+  async resolveError(errorId) {
+    await this.storage.markResolved(errorId);
+  }
+  async getErrorContext(beadId, includeResolved = false) {
+    const errors3 = includeResolved ? await this.getErrors(beadId) : await this.getUnresolvedErrors(beadId);
+    if (errors3.length === 0) {
+      return "";
+    }
+    const byType = errors3.reduce((acc, err) => {
+      const type = err.error_type;
+      if (!acc[type]) {
+        acc[type] = [];
+      }
+      acc[type].push(err);
+      return acc;
+    }, {});
+    const lines = [
+      "## Previous Errors",
+      "",
+      "The following errors were encountered during execution:",
+      ""
+    ];
+    for (const [type, typeErrors] of Object.entries(byType)) {
+      lines.push(`### ${type} (${typeErrors.length} error${typeErrors.length > 1 ? "s" : ""})`);
+      lines.push("");
+      for (const err of typeErrors) {
+        lines.push(`- **${err.message}**`);
+        if (err.context) {
+          lines.push(`  - Context: ${err.context}`);
+        }
+        if (err.tool_name) {
+          lines.push(`  - Tool: ${err.tool_name}`);
+        }
+        if (err.stack_trace) {
+          lines.push(`  - Stack: \`${err.stack_trace.slice(0, 100)}...\``);
+        }
+        lines.push(`  - Time: ${new Date(err.timestamp).toLocaleString()}${err.resolved ? " (resolved)" : ""}`);
+        lines.push("");
+      }
+    }
+    lines.push("**Action Required**: Address these errors before proceeding. Consider:");
+    lines.push("- What caused each error?");
+    lines.push("- How can you prevent similar errors?");
+    lines.push("- Are there patterns across error types?");
+    lines.push("");
+    return lines.join(`
+`);
+  }
+  async getErrorStats(beadId) {
+    const allErrors = await this.getErrors(beadId);
+    const unresolved = await this.getUnresolvedErrors(beadId);
+    const byType = allErrors.reduce((acc, err) => {
+      acc[err.error_type] = (acc[err.error_type] || 0) + 1;
+      return acc;
+    }, {});
+    return {
+      total: allErrors.length,
+      unresolved: unresolved.length,
+      by_type: byType
+    };
+  }
+}
+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"
+  };
+}
+function formatMemoryValidationHint(beadId) {
+  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`
+  };
+}
+var FeedbackTypeSchema, FeedbackEventSchema, CriterionWeightSchema, ErrorTypeSchema, ErrorEntrySchema, DecompositionStrategySchema2, FailureModeSchema2, OutcomeSignalsSchema, ScoredOutcomeSchema, DEFAULT_LEARNING_CONFIG, StrikeRecordSchema, learningSchemas;
+var init_learning = __esm(() => {
+  init_zod();
+  FeedbackTypeSchema = exports_external.enum(["helpful", "harmful", "neutral"]);
+  FeedbackEventSchema = exports_external.object({
+    id: exports_external.string(),
+    criterion: exports_external.string(),
+    type: FeedbackTypeSchema,
+    timestamp: exports_external.string(),
+    context: exports_external.string().optional(),
+    bead_id: exports_external.string().optional(),
+    raw_value: exports_external.number().min(0).max(1).default(1)
+  });
+  CriterionWeightSchema = exports_external.object({
+    criterion: exports_external.string(),
+    weight: exports_external.number().min(0).max(1),
+    helpful_count: exports_external.number().int().min(0),
+    harmful_count: exports_external.number().int().min(0),
+    last_validated: exports_external.string().optional(),
+    half_life_days: exports_external.number().positive().default(90)
+  });
+  ErrorTypeSchema = exports_external.enum([
+    "validation",
+    "timeout",
+    "conflict",
+    "tool_failure",
+    "unknown"
+  ]);
+  ErrorEntrySchema = exports_external.object({
+    id: exports_external.string(),
+    bead_id: exports_external.string(),
+    error_type: ErrorTypeSchema,
+    message: exports_external.string(),
+    stack_trace: exports_external.string().optional(),
+    tool_name: exports_external.string().optional(),
+    timestamp: exports_external.string(),
+    resolved: exports_external.boolean().default(false),
+    context: exports_external.string().optional()
+  });
+  DecompositionStrategySchema2 = exports_external.enum([
+    "file-based",
+    "feature-based",
+    "risk-based",
+    "research-based"
+  ]);
+  FailureModeSchema2 = exports_external.enum([
+    "timeout",
+    "conflict",
+    "validation",
+    "tool_failure",
+    "context_overflow",
+    "dependency_blocked",
+    "user_cancelled",
+    "unknown"
+  ]);
+  OutcomeSignalsSchema = exports_external.object({
+    bead_id: exports_external.string(),
+    duration_ms: exports_external.number().int().min(0),
+    error_count: exports_external.number().int().min(0),
+    retry_count: exports_external.number().int().min(0),
+    success: exports_external.boolean(),
+    files_touched: exports_external.array(exports_external.string()).default([]),
+    timestamp: exports_external.string(),
+    strategy: DecompositionStrategySchema2.optional(),
+    failure_mode: FailureModeSchema2.optional(),
+    failure_details: exports_external.string().optional()
+  });
+  ScoredOutcomeSchema = exports_external.object({
+    signals: OutcomeSignalsSchema,
+    type: FeedbackTypeSchema,
+    decayed_value: exports_external.number().min(0).max(1),
+    reasoning: exports_external.string()
+  });
+  DEFAULT_LEARNING_CONFIG = {
+    halfLifeDays: 90,
+    minFeedbackForAdjustment: 3,
+    maxHarmfulRatio: 0.3,
+    fastCompletionThresholdMs: 5 * 60 * 1000,
+    slowCompletionThresholdMs: 30 * 60 * 1000,
+    maxErrorsForHelpful: 2
+  };
+  StrikeRecordSchema = exports_external.object({
+    bead_id: exports_external.string(),
+    strike_count: exports_external.number().int().min(0).max(3),
+    failures: exports_external.array(exports_external.object({
+      attempt: exports_external.string(),
+      reason: exports_external.string(),
+      timestamp: exports_external.string()
+    })),
+    first_strike_at: exports_external.string().optional(),
+    last_strike_at: exports_external.string().optional()
+  });
+  learningSchemas = {
+    FeedbackTypeSchema,
+    FeedbackEventSchema,
+    CriterionWeightSchema,
+    OutcomeSignalsSchema,
+    ScoredOutcomeSchema,
+    DecompositionStrategySchema: DecompositionStrategySchema2,
+    ErrorTypeSchema,
+    ErrorEntrySchema,
+    StrikeRecordSchema
+  };
+});
+
+// node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js
+var require_kind_of = __commonJS((exports, module) => {
+  var toString = Object.prototype.toString;
+  module.exports = function kindOf(val) {
+    if (val === undefined)
+      return "undefined";
+    if (val === null)
+      return "null";
+    var type = typeof val;
+    if (type === "boolean")
+      return "boolean";
+    if (type === "string")
+      return "string";
+    if (type === "number")
+      return "number";
+    if (type === "symbol")
+      return "symbol";
+    if (type === "function") {
+      return isGeneratorFn(val) ? "generatorfunction" : "function";
+    }
+    if (isArray(val))
+      return "array";
+    if (isBuffer(val))
+      return "buffer";
+    if (isArguments(val))
+      return "arguments";
+    if (isDate(val))
+      return "date";
+    if (isError(val))
+      return "error";
+    if (isRegexp(val))
+      return "regexp";
+    switch (ctorName(val)) {
+      case "Symbol":
+        return "symbol";
+      case "Promise":
+        return "promise";
+      case "WeakMap":
+        return "weakmap";
+      case "WeakSet":
+        return "weakset";
+      case "Map":
+        return "map";
+      case "Set":
+        return "set";
+      case "Int8Array":
+        return "int8array";
+      case "Uint8Array":
+        return "uint8array";
+      case "Uint8ClampedArray":
+        return "uint8clampedarray";
+      case "Int16Array":
+        return "int16array";
+      case "Uint16Array":
+        return "uint16array";
+      case "Int32Array":
+        return "int32array";
+      case "Uint32Array":
+        return "uint32array";
+      case "Float32Array":
+        return "float32array";
+      case "Float64Array":
+        return "float64array";
+    }
+    if (isGeneratorObj(val)) {
+      return "generator";
+    }
+    type = toString.call(val);
+    switch (type) {
+      case "[object Object]":
+        return "object";
+      case "[object Map Iterator]":
+        return "mapiterator";
+      case "[object Set Iterator]":
+        return "setiterator";
+      case "[object String Iterator]":
+        return "stringiterator";
+      case "[object Array Iterator]":
+        return "arrayiterator";
+    }
+    return type.slice(8, -1).toLowerCase().replace(/\s/g, "");
+  };
+  function ctorName(val) {
+    return typeof val.constructor === "function" ? val.constructor.name : null;
+  }
+  function isArray(val) {
+    if (Array.isArray)
       return Array.isArray(val);
     return val instanceof Array;
   }
@@ -29459,17 +30474,23 @@ var BeadDependencySchema = exports_external.object({
   type: exports_external.enum(["blocks", "blocked-by", "related", "discovered-from"])
 });
 var BeadSchema = exports_external.object({
-  id: exports_external.string().regex(/^[a-z0-9]+(-[a-z0-9]+)+(\.[\w-]+)?$/, "Invalid bead ID format"),
+  id: exports_external.string().regex(/^[a-z0-9]+(-[a-z0-9]+)+(\.[\w-]+)?$/, "Invalid bead ID format (expected: project-slug-hash or project-slug-hash.N)"),
   title: exports_external.string().min(1, "Title required"),
   description: exports_external.string().optional().default(""),
   status: BeadStatusSchema.default("open"),
   priority: exports_external.number().int().min(0).max(3).default(2),
   issue_type: BeadTypeSchema.default("task"),
-  created_at: exports_external.string().datetime({ offset: true }),
-  updated_at: exports_external.string().datetime({ offset: true }).optional(),
+  created_at: exports_external.string().datetime({
+    offset: true,
+    message: "Must be ISO-8601 datetime with timezone (e.g., 2024-01-15T10:30:00Z)"
+  }),
+  updated_at: exports_external.string().datetime({
+    offset: true,
+    message: "Must be ISO-8601 datetime with timezone (e.g., 2024-01-15T10:30:00Z)"
+  }).optional(),
   closed_at: exports_external.string().datetime({ offset: true }).optional(),
   parent_id: exports_external.string().optional(),
-  dependencies: exports_external.array(BeadDependencySchema).optional().default([]),
+  dependencies: exports_external.array(BeadDependencySchema).default([]),
   metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
 });
 var BeadCreateArgsSchema = exports_external.object({
@@ -29546,16 +30567,11 @@ var EvaluationSchema = exports_external.object({
   retry_suggestion: exports_external.string().nullable(),
   timestamp: exports_external.string().datetime({ offset: true }).optional()
 });
-var DEFAULT_CRITERIA = [
-  "type_safe",
-  "no_bugs",
-  "patterns",
-  "readable"
-];
 var EvaluationRequestSchema = exports_external.object({
-  subtask_id: exports_external.string(),
-  criteria: exports_external.array(exports_external.string()).default([...DEFAULT_CRITERIA]),
-  context: exports_external.string().optional()
+  bead_id: exports_external.string(),
+  subtask_title: exports_external.string(),
+  files_touched: exports_external.array(exports_external.string()),
+  requested_at: exports_external.string().datetime().optional()
 });
 var WeightedEvaluationSchema = exports_external.object({
   passed: exports_external.boolean(),
@@ -29657,7 +30673,7 @@ var AgentProgressSchema = exports_external.object({
   files_touched: exports_external.array(exports_external.string()).optional(),
   blockers: exports_external.array(exports_external.string()).optional(),
   timestamp: exports_external.string().datetime({ offset: true })
-});
+}).refine((data) => data.status !== "blocked" || data.blockers && data.blockers.length > 0, { message: "blockers array required when status is 'blocked'" });
 var SwarmStatusSchema = exports_external.object({
   epic_id: exports_external.string(),
   total_agents: exports_external.number().int().min(0),
@@ -30251,6 +31267,8 @@ init_dist();
 
 // src/tool-availability.ts
 init_swarm_mail();
+var DEFAULT_URL_TIMEOUT_MS = 2000;
+var BUNX_TIMEOUT_MS = 1e4;
 var toolCache = new Map;
 var warningsLogged = new Set;
 async function commandExists(cmd) {
@@ -30261,7 +31279,7 @@ async function commandExists(cmd) {
     return false;
   }
 }
-async function urlReachable(url2, timeoutMs = 2000) {
+async function urlReachable(url2, timeoutMs = DEFAULT_URL_TIMEOUT_MS) {
   try {
     const controller = new AbortController;
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
@@ -30299,7 +31317,7 @@ var toolCheckers = {
         stdout: "pipe",
         stderr: "pipe"
       });
-      const timeout = setTimeout(() => proc.kill(), 1e4);
+      const timeout = setTimeout(() => proc.kill(), BUNX_TIMEOUT_MS);
       const exitCode = await proc.exited;
       clearTimeout(timeout);
       return {
@@ -30659,14 +31677,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() {
@@ -31947,6 +32986,7 @@ function extractJsonFromText(text) {
   }
   throw new JsonExtractionError("Could not extract valid JSON from response", text, strategies);
 }
+var MAX_BRACE_DEPTH = 100;
 function findBalancedBraces(text, open, close) {
   const startIdx = text.indexOf(open);
   if (startIdx === -1)
@@ -31972,8 +33012,14 @@ function findBalancedBraces(text, open, close) {
       continue;
     if (char === open) {
       depth++;
+      if (depth > MAX_BRACE_DEPTH) {
+        return null;
+      }
     } else if (char === close) {
       depth--;
+      if (depth < 0) {
+        return null;
+      }
       if (depth === 0) {
         return text.slice(startIdx, i + 1);
       }
@@ -31992,6 +33038,7 @@ function attemptJsonRepair(text) {
   repaired = repaired.replace(/"([^"]*)\n([^"]*)"/g, (_, before, after) => `"${before}\\n${after}"`);
   return repaired;
 }
+var RAW_INPUT_PREVIEW_LENGTH = 200;
 var structured_extract_json = tool({
   description: "Extract JSON from markdown/text response. Tries multiple strategies: direct parse, code blocks, brace matching, JSON repair.",
   args: {
@@ -32011,7 +33058,7 @@ var structured_extract_json = tool({
           success: false,
           error: error45.message,
           attempted_strategies: error45.attemptedStrategies,
-          raw_input_preview: args.text.slice(0, 200)
+          raw_input_preview: args.text.slice(0, RAW_INPUT_PREVIEW_LENGTH)
         }, null, 2);
       }
       throw error45;
@@ -32022,7 +33069,7 @@ var structured_validate = tool({
   description: "Validate agent response against a schema. Extracts JSON and validates with Zod. Returns structured errors for retry feedback.",
   args: {
     response: tool.schema.string().describe("Agent response to validate"),
-    schema_name: tool.schema.enum(["evaluation", "task_decomposition", "bead_tree"]).describe("Schema to validate against"),
+    schema_name: tool.schema.enum(["evaluation", "task_decomposition", "bead_tree"]).describe("Schema to validate against: " + "evaluation = agent self-eval with criteria, " + "task_decomposition = swarm task breakdown, " + "bead_tree = epic with subtasks"),
     max_retries: tool.schema.number().min(1).max(5).optional().describe("Max retries (for tracking - actual retry logic is external)")
   },
   async execute(args, ctx) {
@@ -32032,6 +33079,13 @@ var structured_validate = tool({
       attempts: 1,
       errors: []
     };
+    if (!args.response || args.response.trim().length === 0) {
+      return JSON.stringify({
+        valid: false,
+        error: "Response is empty or contains only whitespace",
+        raw_input: "(empty)"
+      });
+    }
     let extracted;
     let extractionMethod;
     try {
@@ -32041,7 +33095,7 @@ var structured_validate = tool({
       if (error45 instanceof JsonExtractionError) {
         result.errors = [
           `JSON extraction failed after trying: ${error45.attemptedStrategies.join(", ")}`,
-          `Input preview: ${args.response.slice(0, 100)}...`
+          `Input preview: ${args.response.slice(0, RAW_INPUT_PREVIEW_LENGTH)}...`
         ];
         return JSON.stringify(result, null, 2);
       }
@@ -32084,7 +33138,10 @@ var structured_parse_evaluation = tool({
         summary: {
           passed: validated.passed,
           criteria_count: Object.keys(validated.criteria).length,
-          failed_criteria: Object.entries(validated.criteria).filter(([_, v]) => !v.passed).map(([k]) => k)
+          failed_criteria: Object.entries(validated.criteria).filter(([_, v]) => {
+            const criterion = v;
+            return !criterion.passed;
+          }).map(([k]) => k)
         }
       }, null, 2);
     } catch (error45) {
@@ -32269,350 +33326,137 @@ var structuredTools = {
 };
 
 // src/swarm.ts
+init_swarm_strategies();
+
+// src/swarm-decompose.ts
 init_dist();
 init_zod();
-init_swarm_mail();
+init_swarm_strategies();
+var DECOMPOSITION_PROMPT = `You are decomposing a task into parallelizable subtasks for a swarm of agents.
 
-// src/learning.ts
-init_zod();
-var FeedbackTypeSchema = exports_external.enum(["helpful", "harmful", "neutral"]);
-var FeedbackEventSchema = exports_external.object({
-  id: exports_external.string(),
-  criterion: exports_external.string(),
-  type: FeedbackTypeSchema,
-  timestamp: exports_external.string(),
-  context: exports_external.string().optional(),
-  bead_id: exports_external.string().optional(),
-  raw_value: exports_external.number().min(0).max(1).default(1)
-});
-var CriterionWeightSchema = exports_external.object({
-  criterion: exports_external.string(),
-  weight: exports_external.number().min(0).max(1),
-  helpful_count: exports_external.number().int().min(0),
-  harmful_count: exports_external.number().int().min(0),
-  last_validated: exports_external.string().optional(),
-  half_life_days: exports_external.number().positive().default(90)
-});
-var ErrorTypeSchema = exports_external.enum([
-  "validation",
-  "timeout",
-  "conflict",
-  "tool_failure",
-  "unknown"
-]);
-var ErrorEntrySchema = exports_external.object({
-  id: exports_external.string(),
-  bead_id: exports_external.string(),
-  error_type: ErrorTypeSchema,
-  message: exports_external.string(),
-  stack_trace: exports_external.string().optional(),
-  tool_name: exports_external.string().optional(),
-  timestamp: exports_external.string(),
-  resolved: exports_external.boolean().default(false),
-  context: exports_external.string().optional()
-});
-var DecompositionStrategySchema = exports_external.enum([
-  "file-based",
-  "feature-based",
-  "risk-based",
-  "research-based"
-]);
-var FailureModeSchema2 = exports_external.enum([
-  "timeout",
-  "conflict",
-  "validation",
-  "tool_failure",
-  "context_overflow",
-  "dependency_blocked",
-  "user_cancelled",
-  "unknown"
-]);
-var OutcomeSignalsSchema = exports_external.object({
-  bead_id: exports_external.string(),
-  duration_ms: exports_external.number().int().min(0),
-  error_count: exports_external.number().int().min(0),
-  retry_count: exports_external.number().int().min(0),
-  success: exports_external.boolean(),
-  files_touched: exports_external.array(exports_external.string()).default([]),
-  timestamp: exports_external.string(),
-  strategy: DecompositionStrategySchema.optional(),
-  failure_mode: FailureModeSchema2.optional(),
-  failure_details: exports_external.string().optional()
-});
-var ScoredOutcomeSchema = exports_external.object({
-  signals: OutcomeSignalsSchema,
-  type: FeedbackTypeSchema,
-  decayed_value: exports_external.number().min(0).max(1),
-  reasoning: exports_external.string()
-});
-var DEFAULT_LEARNING_CONFIG = {
-  halfLifeDays: 90,
-  minFeedbackForAdjustment: 3,
-  maxHarmfulRatio: 0.3,
-  fastCompletionThresholdMs: 5 * 60 * 1000,
-  slowCompletionThresholdMs: 30 * 60 * 1000,
-  maxErrorsForHelpful: 2
-};
-function calculateDecayedValue(timestamp, now = new Date, halfLifeDays = 90) {
-  const safeHalfLife = halfLifeDays <= 0 ? 1 : halfLifeDays;
-  const eventTime = new Date(timestamp).getTime();
-  const nowTime = now.getTime();
-  const ageDays = Math.max(0, (nowTime - eventTime) / (24 * 60 * 60 * 1000));
-  return Math.pow(0.5, ageDays / safeHalfLife);
-}
-function scoreImplicitFeedback(signals, config2 = DEFAULT_LEARNING_CONFIG) {
-  const now = new Date;
-  const decayed = calculateDecayedValue(signals.timestamp, now, config2.halfLifeDays);
-  const durationScore = signals.duration_ms < config2.fastCompletionThresholdMs ? 1 : signals.duration_ms > config2.slowCompletionThresholdMs ? 0.2 : 0.6;
-  const errorScore = signals.error_count === 0 ? 1 : signals.error_count <= config2.maxErrorsForHelpful ? 0.6 : 0.2;
-  const retryScore = signals.retry_count === 0 ? 1 : signals.retry_count === 1 ? 0.7 : 0.3;
-  const successScore = signals.success ? 1 : 0;
-  const rawScore = successScore * 0.4 + durationScore * 0.2 + errorScore * 0.2 + retryScore * 0.2;
-  let type;
-  let reasoning;
-  if (rawScore >= 0.7) {
-    type = "helpful";
-    reasoning = `Fast completion (${Math.round(signals.duration_ms / 1000)}s), ` + `${signals.error_count} errors, ${signals.retry_count} retries, ` + `${signals.success ? "succeeded" : "failed"}`;
-  } else if (rawScore <= 0.4) {
-    type = "harmful";
-    reasoning = `Slow completion (${Math.round(signals.duration_ms / 1000)}s), ` + `${signals.error_count} errors, ${signals.retry_count} retries, ` + `${signals.success ? "succeeded" : "failed"}`;
-  } else {
-    type = "neutral";
-    reasoning = `Mixed signals: ${Math.round(signals.duration_ms / 1000)}s, ` + `${signals.error_count} errors, ${signals.retry_count} retries`;
-  }
-  return {
-    signals,
-    type,
-    decayed_value: rawScore * decayed,
-    reasoning
-  };
-}
-function outcomeToFeedback(outcome, criterion) {
-  return {
-    id: `${outcome.signals.bead_id}-${criterion}-${Date.now()}`,
-    criterion,
-    type: outcome.type,
-    timestamp: outcome.signals.timestamp,
-    context: outcome.reasoning,
-    bead_id: outcome.signals.bead_id,
-    raw_value: outcome.decayed_value
-  };
-}
-var StrikeRecordSchema = exports_external.object({
-  bead_id: exports_external.string(),
-  strike_count: exports_external.number().int().min(0).max(3),
-  failures: exports_external.array(exports_external.object({
-    attempt: exports_external.string(),
-    reason: exports_external.string(),
-    timestamp: exports_external.string()
-  })),
-  first_strike_at: exports_external.string().optional(),
-  last_strike_at: exports_external.string().optional()
-});
+## Task
+{task}
 
-class InMemoryStrikeStorage {
-  strikes = new Map;
-  async store(record2) {
-    this.strikes.set(record2.bead_id, record2);
-  }
-  async get(beadId) {
-    return this.strikes.get(beadId) ?? null;
-  }
-  async getAll() {
-    return Array.from(this.strikes.values());
-  }
-  async clear(beadId) {
-    this.strikes.delete(beadId);
-  }
-}
-async function addStrike(beadId, attempt, reason, storage = new InMemoryStrikeStorage) {
-  const existing = await storage.get(beadId);
-  const now = new Date().toISOString();
-  const record2 = existing ?? {
-    bead_id: beadId,
-    strike_count: 0,
-    failures: []
-  };
-  record2.strike_count = Math.min(3, record2.strike_count + 1);
-  record2.failures.push({ attempt, reason, timestamp: now });
-  record2.last_strike_at = now;
-  if (!record2.first_strike_at) {
-    record2.first_strike_at = now;
-  }
-  await storage.store(record2);
-  return record2;
-}
-async function getStrikes(beadId, storage = new InMemoryStrikeStorage) {
-  const record2 = await storage.get(beadId);
-  return record2?.strike_count ?? 0;
-}
-async function isStrikedOut(beadId, storage = new InMemoryStrikeStorage) {
-  const count = await getStrikes(beadId, storage);
-  return count >= 3;
+{context_section}
+
+## MANDATORY: Beads Issue Tracking
+
+**Every subtask MUST become a bead.** This is non-negotiable.
+
+After decomposition, the coordinator will:
+1. Create an epic bead for the overall task
+2. Create child beads for each subtask
+3. Track progress through bead status updates
+4. Close beads with summaries when complete
+
+Agents MUST update their bead status as they work. No silent progress.
+
+## Requirements
+
+1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel
+2. **Assign files** - each subtask must specify which files it will modify
+3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)
+4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array
+5. **Estimate complexity** - 1 (trivial) to 5 (complex)
+6. **Plan aggressively** - break down more than you think necessary, smaller is better
+
+## Response Format
+
+Respond with a JSON object matching this schema:
+
+\`\`\`typescript
+{
+  epic: {
+    title: string,        // Epic title for the beads tracker
+    description?: string  // Brief description of the overall goal
+  },
+  subtasks: [
+    {
+      title: string,              // What this subtask accomplishes
+      description?: string,       // Detailed instructions for the agent
+      files: string[],            // Files this subtask will modify (globs allowed)
+      dependencies: number[],     // Indices of subtasks this depends on (0-indexed)
+      estimated_complexity: 1-5   // Effort estimate
+    },
+    // ... more subtasks
+  ]
 }
-async function getArchitecturePrompt(beadId, storage = new InMemoryStrikeStorage) {
-  const record2 = await storage.get(beadId);
-  if (!record2 || record2.strike_count < 3) {
-    return "";
-  }
-  const failuresList = record2.failures.map((f, i) => `${i + 1}. **${f.attempt}** - Failed: ${f.reason}`).join(`
-`);
-  return `## Architecture Review Required
+\`\`\`
 
-This bead (\`${beadId}\`) has failed 3 consecutive fix attempts:
+## Guidelines
 
-${failuresList}
+- **Plan aggressively** - when in doubt, split further. 3 small tasks > 1 medium task
+- **Prefer smaller, focused subtasks** over large complex ones
+- **Include test files** in the same subtask as the code they test
+- **Consider shared types** - if multiple files share types, handle that first
+- **Think about imports** - changes to exported APIs affect downstream files
+- **Explicit > implicit** - spell out what each subtask should do, don't assume
 
-This pattern suggests an **architectural problem**, not a bug.
+## File Assignment Examples
 
-**Questions to consider:**
-- Is the current approach fundamentally sound?
-- Should we refactor the architecture instead?
-- Are we fixing symptoms instead of root cause?
+- Schema change: \`["src/schemas/user.ts", "src/schemas/index.ts"]\`
+- Component + test: \`["src/components/Button.tsx", "src/components/Button.test.tsx"]\`
+- API route: \`["src/app/api/users/route.ts"]\`
 
-**Options:**
-1. **Refactor architecture** (describe new approach)
-2. **Continue with Fix #4** (explain why this time is different)
-3. **Abandon this approach entirely**
+Now decompose the task:`;
+var STRATEGY_DECOMPOSITION_PROMPT = `You are decomposing a task into parallelizable subtasks for a swarm of agents.
+
+## Task
+{task}
+
+{strategy_guidelines}
+
+{context_section}
+
+{cass_history}
+
+{skills_context}
+
+## MANDATORY: Beads Issue Tracking
+
+**Every subtask MUST become a bead.** This is non-negotiable.
+
+After decomposition, the coordinator will:
+1. Create an epic bead for the overall task
+2. Create child beads for each subtask
+3. Track progress through bead status updates
+4. Close beads with summaries when complete
+
+Agents MUST update their bead status as they work. No silent progress.
+
+## Requirements
+
+1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel
+2. **Assign files** - each subtask must specify which files it will modify
+3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)
+4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array
+5. **Estimate complexity** - 1 (trivial) to 5 (complex)
+6. **Plan aggressively** - break down more than you think necessary, smaller is better
 
-**DO NOT attempt Fix #4 without answering these questions.**
-`;
-}
-async function clearStrikes(beadId, storage = new InMemoryStrikeStorage) {
-  await storage.clear(beadId);
-}
+## Response Format
 
-class InMemoryErrorStorage {
-  errors = [];
-  async store(entry) {
-    this.errors.push(entry);
-  }
-  async getByBead(beadId) {
-    return this.errors.filter((e) => e.bead_id === beadId);
-  }
-  async getUnresolvedByBead(beadId) {
-    return this.errors.filter((e) => e.bead_id === beadId && !e.resolved);
-  }
-  async markResolved(id) {
-    const error45 = this.errors.find((e) => e.id === id);
-    if (error45) {
-      error45.resolved = true;
-    }
-  }
-  async getAll() {
-    return [...this.errors];
-  }
-}
+Respond with a JSON object matching this schema:
 
-class ErrorAccumulator {
-  storage;
-  constructor(storage) {
-    this.storage = storage ?? new InMemoryErrorStorage;
-  }
-  async recordError(beadId, errorType, message, options2) {
-    const entry = {
-      id: `${beadId}-${errorType}-${Date.now()}`,
-      bead_id: beadId,
-      error_type: errorType,
-      message,
-      stack_trace: options2?.stack_trace,
-      tool_name: options2?.tool_name,
-      timestamp: new Date().toISOString(),
-      resolved: false,
-      context: options2?.context
-    };
-    const validated = ErrorEntrySchema.parse(entry);
-    await this.storage.store(validated);
-    return validated;
-  }
-  async getErrors(beadId) {
-    return this.storage.getByBead(beadId);
-  }
-  async getUnresolvedErrors(beadId) {
-    return this.storage.getUnresolvedByBead(beadId);
-  }
-  async resolveError(errorId) {
-    await this.storage.markResolved(errorId);
-  }
-  async getErrorContext(beadId, includeResolved = false) {
-    const errors3 = includeResolved ? await this.getErrors(beadId) : await this.getUnresolvedErrors(beadId);
-    if (errors3.length === 0) {
-      return "";
-    }
-    const byType = errors3.reduce((acc, err) => {
-      const type = err.error_type;
-      if (!acc[type]) {
-        acc[type] = [];
-      }
-      acc[type].push(err);
-      return acc;
-    }, {});
-    const lines = [
-      "## Previous Errors",
-      "",
-      "The following errors were encountered during execution:",
-      ""
-    ];
-    for (const [type, typeErrors] of Object.entries(byType)) {
-      lines.push(`### ${type} (${typeErrors.length} error${typeErrors.length > 1 ? "s" : ""})`);
-      lines.push("");
-      for (const err of typeErrors) {
-        lines.push(`- **${err.message}**`);
-        if (err.context) {
-          lines.push(`  - Context: ${err.context}`);
-        }
-        if (err.tool_name) {
-          lines.push(`  - Tool: ${err.tool_name}`);
-        }
-        if (err.stack_trace) {
-          lines.push(`  - Stack: \`${err.stack_trace.slice(0, 100)}...\``);
-        }
-        lines.push(`  - Time: ${new Date(err.timestamp).toLocaleString()}${err.resolved ? " (resolved)" : ""}`);
-        lines.push("");
-      }
-    }
-    lines.push("**Action Required**: Address these errors before proceeding. Consider:");
-    lines.push("- What caused each error?");
-    lines.push("- How can you prevent similar errors?");
-    lines.push("- Are there patterns across error types?");
-    lines.push("");
-    return lines.join(`
-`);
-  }
-  async getErrorStats(beadId) {
-    const allErrors = await this.getErrors(beadId);
-    const unresolved = await this.getUnresolvedErrors(beadId);
-    const byType = allErrors.reduce((acc, err) => {
-      acc[err.error_type] = (acc[err.error_type] || 0) + 1;
-      return acc;
-    }, {});
-    return {
-      total: allErrors.length,
-      unresolved: unresolved.length,
-      by_type: byType
-    };
-  }
+\`\`\`typescript
+{
+  epic: {
+    title: string,        // Epic title for the beads tracker
+    description?: string  // Brief description of the overall goal
+  },
+  subtasks: [
+    {
+      title: string,              // What this subtask accomplishes
+      description?: string,       // Detailed instructions for the agent
+      files: string[],            // Files this subtask will modify (globs allowed)
+      dependencies: number[],     // Indices of subtasks this depends on (0-indexed)
+      estimated_complexity: 1-5   // Effort estimate
+    },
+    // ... more subtasks
+  ]
 }
+\`\`\`
 
-// src/swarm.ts
-init_skills();
-var POSITIVE_MARKERS = [
-  "always",
-  "must",
-  "required",
-  "ensure",
-  "use",
-  "prefer"
-];
-var NEGATIVE_MARKERS = [
-  "never",
-  "dont",
-  "don't",
-  "avoid",
-  "forbid",
-  "no ",
-  "not "
-];
+Now decompose the task:`;
 function extractDirectives(text) {
   const sentences = text.split(/[.!?\n]+/).map((s) => s.trim().toLowerCase());
   const positive = [];
@@ -32659,254 +33503,372 @@ function detectInstructionConflicts(subtasks) {
               description: `Subtask ${i} says "${posA}" but subtask ${j} says "${negB}"`
             });
           }
-        }
+        }
+      }
+      for (const posB of b.positive) {
+        for (const negA of a.negative) {
+          if (directivesConflict(posB, negA)) {
+            conflicts.push({
+              subtask_a: j,
+              subtask_b: i,
+              directive_a: posB,
+              directive_b: negA,
+              conflict_type: "positive_negative",
+              description: `Subtask ${j} says "${posB}" but subtask ${i} says "${negA}"`
+            });
+          }
+        }
+      }
+    }
+  }
+  return conflicts;
+}
+function detectFileConflicts(subtasks) {
+  const allFiles = new Map;
+  const conflicts = [];
+  for (const subtask of subtasks) {
+    for (const file2 of subtask.files) {
+      const count = allFiles.get(file2) || 0;
+      allFiles.set(file2, count + 1);
+      if (count === 1) {
+        conflicts.push(file2);
+      }
+    }
+  }
+  return conflicts;
+}
+async function queryCassHistory(task, limit = 3) {
+  try {
+    const result = await Bun.$`cass search ${task} --limit ${limit} --json`.quiet().nothrow();
+    if (result.exitCode !== 0) {
+      const error45 = result.stderr.toString();
+      console.warn(`[swarm] CASS search failed (exit ${result.exitCode}):`, error45);
+      return { status: "failed", error: error45 };
+    }
+    const output = result.stdout.toString();
+    if (!output.trim()) {
+      return { status: "empty", query: task };
+    }
+    try {
+      const parsed = JSON.parse(output);
+      const searchResult = {
+        query: task,
+        results: Array.isArray(parsed) ? parsed : parsed.results || []
+      };
+      if (searchResult.results.length === 0) {
+        return { status: "empty", query: task };
+      }
+      return { status: "success", data: searchResult };
+    } catch (error45) {
+      console.warn(`[swarm] Failed to parse CASS output:`, error45);
+      return { status: "failed", error: String(error45) };
+    }
+  } catch (error45) {
+    console.error(`[swarm] CASS query error:`, error45);
+    return { status: "unavailable" };
+  }
+}
+function formatCassHistoryForPrompt(history) {
+  if (history.results.length === 0) {
+    return "";
+  }
+  const lines = [
+    "## Similar Past Tasks",
+    "",
+    "These similar tasks were found in agent history:",
+    "",
+    ...history.results.slice(0, 3).map((r, i) => {
+      const preview = r.preview.slice(0, 200).replace(/\n/g, " ");
+      return `${i + 1}. [${r.agent}] ${preview}...`;
+    }),
+    "",
+    "Consider patterns that worked in these past tasks.",
+    ""
+  ];
+  return lines.join(`
+`);
+}
+var swarm_decompose = tool({
+  description: "Generate decomposition prompt for breaking task into parallelizable subtasks. Optionally queries CASS for similar past tasks.",
+  args: {
+    task: tool.schema.string().min(1).describe("Task description to decompose"),
+    max_subtasks: tool.schema.number().int().min(2).max(10).default(5).describe("Maximum number of subtasks (default: 5)"),
+    context: tool.schema.string().optional().describe("Additional context (codebase info, constraints, etc.)"),
+    query_cass: tool.schema.boolean().optional().describe("Query CASS for similar past tasks (default: true)"),
+    cass_limit: tool.schema.number().int().min(1).max(10).optional().describe("Max CASS results to include (default: 3)")
+  },
+  async execute(args) {
+    const { formatMemoryQueryForDecomposition: formatMemoryQueryForDecomposition2 } = await Promise.resolve().then(() => (init_learning(), exports_learning));
+    let cassContext = "";
+    let cassResultInfo;
+    if (args.query_cass !== false) {
+      const cassResult = await queryCassHistory(args.task, args.cass_limit ?? 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" };
+    }
+    const fullContext = [args.context, cassContext].filter(Boolean).join(`
+
+`);
+    const contextSection = fullContext ? `## Additional Context
+${fullContext}` : `## Additional Context
+(none provided)`;
+    const prompt = DECOMPOSITION_PROMPT.replace("{task}", args.task).replace("{max_subtasks}", (args.max_subtasks ?? 5).toString()).replace("{context_section}", contextSection);
+    return JSON.stringify({
+      prompt,
+      expected_schema: "BeadTree",
+      schema_hint: {
+        epic: { title: "string", description: "string?" },
+        subtasks: [
+          {
+            title: "string",
+            description: "string?",
+            files: "string[]",
+            dependencies: "number[]",
+            estimated_complexity: "1-5"
+          }
+        ]
+      },
+      validation_note: "Parse agent response as JSON and validate with BeadTreeSchema from schemas/bead.ts",
+      cass_history: cassResultInfo,
+      memory_query: formatMemoryQueryForDecomposition2(args.task, 3)
+    }, null, 2);
+  }
+});
+var swarm_validate_decomposition = tool({
+  description: "Validate a decomposition response against BeadTreeSchema",
+  args: {
+    response: tool.schema.string().describe("JSON response from agent (BeadTree format)")
+  },
+  async execute(args) {
+    try {
+      const parsed = JSON.parse(args.response);
+      const validated = BeadTreeSchema.parse(parsed);
+      const conflicts = detectFileConflicts(validated.subtasks);
+      if (conflicts.length > 0) {
+        return JSON.stringify({
+          valid: false,
+          error: `File conflicts detected: ${conflicts.join(", ")}`,
+          hint: "Each file can only be assigned to one subtask"
+        }, null, 2);
       }
-      for (const posB of b.positive) {
-        for (const negA of a.negative) {
-          if (directivesConflict(posB, negA)) {
-            conflicts.push({
-              subtask_a: j,
-              subtask_b: i,
-              directive_a: posB,
-              directive_b: negA,
-              conflict_type: "positive_negative",
-              description: `Subtask ${j} says "${posB}" but subtask ${i} says "${negA}"`
-            });
+      for (let i = 0;i < validated.subtasks.length; i++) {
+        const deps = validated.subtasks[i].dependencies;
+        for (const dep of deps) {
+          if (dep < 0 || dep >= validated.subtasks.length) {
+            return JSON.stringify({
+              valid: false,
+              error: `Invalid dependency: subtask ${i} depends on ${dep}, but only ${validated.subtasks.length} subtasks exist (indices 0-${validated.subtasks.length - 1})`,
+              hint: "Dependency index is out of bounds"
+            }, null, 2);
+          }
+          if (dep >= i) {
+            return JSON.stringify({
+              valid: false,
+              error: `Invalid dependency: subtask ${i} depends on ${dep}, but dependencies must be earlier in the array`,
+              hint: "Reorder subtasks so dependencies come before dependents"
+            }, null, 2);
           }
         }
       }
+      const instructionConflicts = detectInstructionConflicts(validated.subtasks);
+      return JSON.stringify({
+        valid: true,
+        bead_tree: validated,
+        stats: {
+          subtask_count: validated.subtasks.length,
+          total_files: new Set(validated.subtasks.flatMap((s) => s.files)).size,
+          total_complexity: validated.subtasks.reduce((sum, s) => sum + s.estimated_complexity, 0)
+        },
+        warnings: instructionConflicts.length > 0 ? {
+          instruction_conflicts: instructionConflicts,
+          hint: "Review these potential conflicts between subtask instructions"
+        } : undefined
+      }, null, 2);
+    } catch (error45) {
+      if (error45 instanceof exports_external.ZodError) {
+        return JSON.stringify({
+          valid: false,
+          error: "Schema validation failed",
+          details: error45.issues
+        }, null, 2);
+      }
+      if (error45 instanceof SyntaxError) {
+        return JSON.stringify({
+          valid: false,
+          error: "Invalid JSON",
+          details: error45.message
+        }, null, 2);
+      }
+      throw error45;
     }
   }
-  return conflicts;
-}
-var STRATEGIES = {
-  "file-based": {
-    name: "file-based",
-    description: "Group by file type or directory. Best for refactoring, migrations, and pattern changes across codebase.",
-    keywords: [
-      "refactor",
-      "migrate",
-      "update all",
-      "rename",
-      "replace",
-      "convert",
-      "upgrade",
-      "deprecate",
-      "remove",
-      "cleanup",
-      "lint",
-      "format"
-    ],
-    guidelines: [
-      "Group files by directory or type (e.g., all components, all tests)",
-      "Minimize cross-directory dependencies within a subtask",
-      "Handle shared types/utilities first if they change",
-      "Each subtask should be a complete transformation of its file set",
-      "Consider import/export relationships when grouping"
-    ],
-    antiPatterns: [
-      "Don't split tightly coupled files across subtasks",
-      "Don't group files that have no relationship",
-      "Don't forget to update imports when moving/renaming"
-    ],
-    examples: [
-      "Migrate all components to new API → split by component directory",
-      "Rename userId to accountId → split by module (types first, then consumers)",
-      "Update all tests to use new matcher → split by test directory"
-    ]
-  },
-  "feature-based": {
-    name: "feature-based",
-    description: "Vertical slices with UI + API + data. Best for new features and adding functionality.",
-    keywords: [
-      "add",
-      "implement",
-      "build",
-      "create",
-      "feature",
-      "new",
-      "integrate",
-      "connect",
-      "enable",
-      "support"
-    ],
-    guidelines: [
-      "Each subtask is a complete vertical slice (UI + logic + data)",
-      "Start with data layer/types, then logic, then UI",
-      "Keep related components together (form + validation + submission)",
-      "Separate concerns that can be developed independently",
-      "Consider user-facing features as natural boundaries"
-    ],
-    antiPatterns: [
-      "Don't split a single feature across multiple subtasks",
-      "Don't create subtasks that can't be tested independently",
-      "Don't forget integration points between features"
-    ],
-    examples: [
-      "Add user auth → [OAuth setup, Session management, Protected routes]",
-      "Build dashboard → [Data fetching, Chart components, Layout/navigation]",
-      "Add search → [Search API, Search UI, Results display]"
-    ]
-  },
-  "risk-based": {
-    name: "risk-based",
-    description: "Isolate high-risk changes, add tests first. Best for bug fixes, security issues, and critical changes.",
-    keywords: [
-      "fix",
-      "bug",
-      "security",
-      "vulnerability",
-      "critical",
-      "urgent",
-      "hotfix",
-      "patch",
-      "audit",
-      "review"
-    ],
-    guidelines: [
-      "Write tests FIRST to capture expected behavior",
-      "Isolate the risky change to minimize blast radius",
-      "Add monitoring/logging around the change",
-      "Create rollback plan as part of the task",
-      "Audit similar code for the same issue"
-    ],
-    antiPatterns: [
-      "Don't make multiple risky changes in one subtask",
-      "Don't skip tests for 'simple' fixes",
-      "Don't forget to check for similar issues elsewhere"
-    ],
-    examples: [
-      "Fix auth bypass → [Add regression test, Fix vulnerability, Audit similar endpoints]",
-      "Fix race condition → [Add test reproducing issue, Implement fix, Add concurrency tests]",
-      "Security audit → [Scan for vulnerabilities, Fix critical issues, Document remaining risks]"
-    ]
+});
+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)")
   },
-  "research-based": {
-    name: "research-based",
-    description: "Parallel search across multiple sources, then synthesize. Best for investigation, learning, and discovery tasks.",
-    keywords: [
-      "research",
-      "investigate",
-      "explore",
-      "find out",
-      "discover",
-      "understand",
-      "learn about",
-      "analyze",
-      "what is",
-      "what are",
-      "how does",
-      "how do",
-      "why does",
-      "why do",
-      "compare",
-      "evaluate",
-      "study",
-      "look up",
-      "look into",
-      "search for",
-      "dig into",
-      "figure out",
-      "debug options",
-      "debug levers",
-      "configuration options",
-      "environment variables",
-      "available options",
-      "documentation"
-    ],
-    guidelines: [
-      "Split by information source (PDFs, repos, history, web)",
-      "Each agent searches with different query angles",
-      "Include a synthesis subtask that depends on all search subtasks",
-      "Use pdf-brain for documentation/books if available",
-      "Use repo-crawl for GitHub repos if URL provided",
-      "Use cass for past agent session history",
-      "Assign NO files to research subtasks (read-only)"
-    ],
-    antiPatterns: [
-      "Don't have one agent search everything sequentially",
-      "Don't skip synthesis - raw search results need consolidation",
-      "Don't forget to check tool availability before assigning sources"
-    ],
-    examples: [
-      "Research auth patterns → [Search PDFs, Search repos, Search history, Synthesize]",
-      "Investigate error → [Search cass for similar errors, Search repo for error handling, Synthesize]",
-      "Learn about library → [Search docs, Search examples, Search issues, Synthesize findings]"
-    ]
-  }
-};
-function selectStrategy(task) {
-  const taskLower = task.toLowerCase();
-  const scores = {
-    "file-based": 0,
-    "feature-based": 0,
-    "risk-based": 0,
-    "research-based": 0
-  };
-  for (const [strategyName, definition] of Object.entries(STRATEGIES)) {
-    const name = strategyName;
-    for (const keyword of definition.keywords) {
-      if (keyword.includes(" ")) {
-        if (taskLower.includes(keyword)) {
-          scores[name] += 1;
-        }
+  async execute(args) {
+    const { selectStrategy: selectStrategy2, formatStrategyGuidelines: formatStrategyGuidelines2 } = await Promise.resolve().then(() => (init_swarm_strategies(), exports_swarm_strategies));
+    const { formatMemoryQueryForDecomposition: formatMemoryQueryForDecomposition2 } = await Promise.resolve().then(() => (init_learning(), exports_learning));
+    const { listSkills: listSkills2, getSkillsContextForSwarm: getSkillsContextForSwarm2, findRelevantSkills: findRelevantSkills2 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
+    let selectedStrategy;
+    let strategyReasoning;
+    if (args.strategy && args.strategy !== "auto") {
+      selectedStrategy = args.strategy;
+      strategyReasoning = `User-specified strategy: ${selectedStrategy}`;
+    } else {
+      const selection = selectStrategy2(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 {
-        const regex = new RegExp(`\\b${keyword}\\b`, "i");
-        if (regex.test(taskLower)) {
-          scores[name] += 1;
-        }
+        cassResultInfo = {
+          queried: true,
+          results_found: 0,
+          included_in_context: false,
+          reason: cassResult.status
+        };
       }
+    } else {
+      cassResultInfo = { queried: false, reason: "disabled" };
     }
-  }
-  const entries = Object.entries(scores);
-  entries.sort((a, b) => b[1] - a[1]);
-  const [winner, winnerScore] = entries[0];
-  const [runnerUp, runnerUpScore] = entries[1] || [null, 0];
-  const totalScore = entries.reduce((sum, [, score]) => sum + score, 0);
-  const confidence = totalScore > 0 ? Math.min(0.95, 0.5 + (winnerScore - runnerUpScore) / totalScore) : 0.5;
-  let reasoning;
-  if (winnerScore === 0) {
-    reasoning = `No strong keyword signals. Defaulting to feature-based as it's most versatile.`;
-  } else {
-    const matchedKeywords = STRATEGIES[winner].keywords.filter((k) => taskLower.includes(k));
-    reasoning = `Matched keywords: ${matchedKeywords.join(", ")}. ${STRATEGIES[winner].description}`;
-  }
-  const finalStrategy = winnerScore === 0 ? "feature-based" : winner;
-  return {
-    strategy: finalStrategy,
-    confidence,
-    reasoning,
-    alternatives: entries.filter(([s]) => s !== finalStrategy).map(([strategy, score]) => ({ strategy, score }))
-  };
-}
-function formatStrategyGuidelines(strategy) {
-  const def = STRATEGIES[strategy];
-  const guidelines = def.guidelines.map((g) => `- ${g}`).join(`
-`);
-  const antiPatterns = def.antiPatterns.map((a) => `- ${a}`).join(`
-`);
-  const examples = def.examples.map((e) => `- ${e}`).join(`
-`);
-  return `## Strategy: ${strategy}
+    let skillsContext = "";
+    let skillsInfo = {
+      included: false
+    };
+    const allSkills = await listSkills2();
+    if (allSkills.length > 0) {
+      skillsContext = await getSkillsContextForSwarm2();
+      const relevantSkills = await findRelevantSkills2(args.task);
+      skillsInfo = {
+        included: true,
+        count: allSkills.length,
+        relevant: relevantSkills
+      };
+      if (relevantSkills.length > 0) {
+        skillsContext += `
 
-${def.description}
+**Suggested skills for this task**: ${relevantSkills.join(", ")}`;
+      }
+    }
+    const strategyGuidelines = formatStrategyGuidelines2(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
 
-### Guidelines
-${guidelines}
+You are a planner subagent. Your ONLY output must be valid JSON matching the BeadTree schema.
 
-### Anti-Patterns (Avoid These)
-${antiPatterns}
+DO NOT include:
+- Explanatory text before or after the JSON
+- Markdown code fences (\`\`\`json)
+- Commentary or reasoning
 
-### Examples
-${examples}`;
+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
+    }
+  ]
 }
-var DECOMPOSITION_PROMPT = `You are decomposing a task into parallelizable subtasks for a swarm of agents.
+
+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: formatMemoryQueryForDecomposition2(args.task, 3)
+    }, null, 2);
+  }
+});
+var decomposeTools = {
+  swarm_decompose,
+  swarm_validate_decomposition,
+  swarm_delegate_planning
+};
+// src/swarm-prompts.ts
+init_dist();
+var STRATEGY_DECOMPOSITION_PROMPT2 = `You are decomposing a task into parallelizable subtasks for a swarm of agents.
 
 ## Task
 {task}
 
+{strategy_guidelines}
+
 {context_section}
 
+{cass_history}
+
+{skills_context}
+
 ## MANDATORY: Beads Issue Tracking
 
 **Every subtask MUST become a bead.** This is non-negotiable.
@@ -32951,21 +33913,6 @@ Respond with a JSON object matching this schema:
 }
 \`\`\`
 
-## Guidelines
-
-- **Plan aggressively** - when in doubt, split further. 3 small tasks > 1 medium task
-- **Prefer smaller, focused subtasks** over large complex ones
-- **Include test files** in the same subtask as the code they test
-- **Consider shared types** - if multiple files share types, handle that first
-- **Think about imports** - changes to exported APIs affect downstream files
-- **Explicit > implicit** - spell out what each subtask should do, don't assume
-
-## File Assignment Examples
-
-- Schema change: \`["src/schemas/user.ts", "src/schemas/index.ts"]\`
-- Component + test: \`["src/components/Button.tsx", "src/components/Button.test.tsx"]\`
-- API route: \`["src/app/api/users/route.ts"]\`
-
 Now decompose the task:`;
 var SUBTASK_PROMPT = `You are a swarm agent working on a subtask of a larger epic.
 
@@ -33148,13 +34095,6 @@ As you work, note reusable patterns, best practices, or domain insights:
 **CRITICAL: Never work silently. Send progress updates via swarmmail_send every significant milestone.**
 
 Begin now.`;
-function formatSubtaskPromptV2(params) {
-  const fileList = params.files.length > 0 ? params.files.map((f) => `- \`${f}\``).join(`
-`) : "(no specific files - use judgment)";
-  const compressedSection = params.compressed_context ? params.compressed_context : "";
-  const errorSection = params.error_context ? params.error_context : "";
-  return SUBTASK_PROMPT_V2.replace(/{bead_id}/g, params.bead_id).replace(/{epic_id}/g, params.epic_id).replace("{subtask_title}", params.subtask_title).replace("{subtask_description}", params.subtask_description || "(see title)").replace("{file_list}", fileList).replace("{shared_context}", params.shared_context || "(none)").replace("{compressed_context}", compressedSection).replace("{error_context}", errorSection);
-}
 var EVALUATION_PROMPT = `Evaluate the work completed for this subtask.
 
 ## Subtask
@@ -33191,22 +34131,12 @@ For each criterion, assess passed/failed and provide brief feedback:
 
 If any criterion fails, the overall evaluation fails and retry_suggestion 
 should describe what needs to be fixed.`;
-
-class SwarmError extends Error {
-  operation;
-  details;
-  constructor(message, operation, details) {
-    super(message);
-    this.operation = operation;
-    this.details = details;
-    this.name = "SwarmError";
-  }
-}
-function formatDecompositionPrompt(task, maxSubtasks, context) {
-  const contextSection = context ? `## Additional Context
-${context}` : `## Additional Context
-(none provided)`;
-  return DECOMPOSITION_PROMPT.replace("{task}", task).replace("{max_subtasks}", maxSubtasks.toString()).replace("{context_section}", contextSection);
+function formatSubtaskPromptV2(params) {
+  const fileList = params.files.length > 0 ? params.files.map((f) => `- \`${f}\``).join(`
+`) : "(no specific files - use judgment)";
+  const compressedSection = params.compressed_context ? params.compressed_context : "";
+  const errorSection = params.error_context ? params.error_context : "";
+  return SUBTASK_PROMPT_V2.replace(/{bead_id}/g, params.bead_id).replace(/{epic_id}/g, params.epic_id).replace("{subtask_title}", params.subtask_title).replace("{subtask_description}", params.subtask_description || "(see title)").replace("{file_list}", fileList).replace("{shared_context}", params.shared_context || "(none)").replace("{compressed_context}", compressedSection).replace("{error_context}", errorSection);
 }
 function formatSubtaskPrompt(params) {
   const fileList = params.files.map((f) => `- \`${f}\``).join(`
@@ -33218,260 +34148,121 @@ function formatEvaluationPrompt(params) {
 `);
   return EVALUATION_PROMPT.replace("{bead_id}", params.bead_id).replace("{subtask_title}", params.subtask_title).replace("{files_touched}", filesList || "(no files recorded)");
 }
-async function queryEpicSubtasks(epicId) {
-  const beadsAvailable = await isToolAvailable("beads");
-  if (!beadsAvailable) {
-    warnMissingTool("beads");
-    return [];
-  }
-  const result = await Bun.$`bd list --parent ${epicId} --json`.quiet().nothrow();
-  if (result.exitCode !== 0) {
-    console.error(`[swarm] ERROR: Failed to query subtasks for epic ${epicId}:`, result.stderr.toString());
-    return [];
-  }
-  try {
-    const parsed = JSON.parse(result.stdout.toString());
-    return exports_external.array(BeadSchema).parse(parsed);
-  } catch (error45) {
-    if (error45 instanceof exports_external.ZodError) {
-      console.error(`[swarm] ERROR: Invalid bead data for epic ${epicId}:`, error45.message);
-      return [];
-    }
-    console.error(`[swarm] ERROR: Failed to parse beads for epic ${epicId}:`, error45);
-    throw error45;
-  }
-}
-async function querySwarmMessages(projectKey, threadId) {
-  const agentMailAvailable2 = await isToolAvailable("agent-mail");
-  if (!agentMailAvailable2) {
-    return 0;
-  }
-  try {
-    const inbox = await getSwarmInbox({
-      projectPath: projectKey,
-      agentName: "coordinator",
-      limit: 5,
-      includeBodies: false
+var swarm_subtask_prompt = tool({
+  description: "Generate the prompt for a spawned subtask agent",
+  args: {
+    agent_name: tool.schema.string().describe("Agent Mail name for the agent"),
+    bead_id: tool.schema.string().describe("Subtask bead ID"),
+    epic_id: tool.schema.string().describe("Epic bead ID"),
+    subtask_title: tool.schema.string().describe("Subtask title"),
+    subtask_description: tool.schema.string().optional().describe("Detailed subtask instructions"),
+    files: tool.schema.array(tool.schema.string()).describe("Files assigned to this subtask"),
+    shared_context: tool.schema.string().optional().describe("Context shared across all agents")
+  },
+  async execute(args) {
+    const prompt = formatSubtaskPrompt({
+      agent_name: args.agent_name,
+      bead_id: args.bead_id,
+      epic_id: args.epic_id,
+      subtask_title: args.subtask_title,
+      subtask_description: args.subtask_description || "",
+      files: args.files,
+      shared_context: args.shared_context
     });
-    const threadMessages = inbox.messages.filter((m) => m.thread_id === threadId);
-    return threadMessages.length;
-  } catch (error45) {
-    console.warn(`[swarm] Failed to query swarm messages for thread ${threadId}:`, error45);
-    return 0;
-  }
-}
-function formatProgressMessage(progress) {
-  const lines = [
-    `**Status**: ${progress.status}`,
-    progress.progress_percent !== undefined ? `**Progress**: ${progress.progress_percent}%` : null,
-    progress.message ? `**Message**: ${progress.message}` : null,
-    progress.files_touched && progress.files_touched.length > 0 ? `**Files touched**:
-${progress.files_touched.map((f) => `- \`${f}\``).join(`
-`)}` : null,
-    progress.blockers && progress.blockers.length > 0 ? `**Blockers**:
-${progress.blockers.map((b) => `- ${b}`).join(`
-`)}` : null
-  ];
-  return lines.filter(Boolean).join(`
-
-`);
-}
-async function queryCassHistory(task, limit = 3) {
-  const cassAvailable = await isToolAvailable("cass");
-  if (!cassAvailable) {
-    warnMissingTool("cass");
-    return { status: "unavailable" };
-  }
-  try {
-    const result = await Bun.$`cass search ${task} --limit ${limit} --json`.quiet().nothrow();
-    if (result.exitCode !== 0) {
-      const error45 = result.stderr.toString();
-      console.warn(`[swarm] CASS search failed (exit ${result.exitCode}):`, error45);
-      return { status: "failed", error: error45 };
-    }
-    const output = result.stdout.toString();
-    if (!output.trim()) {
-      return { status: "empty", query: task };
-    }
-    try {
-      const parsed = JSON.parse(output);
-      const searchResult = {
-        query: task,
-        results: Array.isArray(parsed) ? parsed : parsed.results || []
-      };
-      if (searchResult.results.length === 0) {
-        return { status: "empty", query: task };
-      }
-      return { status: "success", data: searchResult };
-    } catch (error45) {
-      console.warn(`[swarm] Failed to parse CASS output:`, error45);
-      return { status: "failed", error: String(error45) };
-    }
-  } catch (error45) {
-    console.error(`[swarm] CASS query error:`, error45);
-    return { status: "failed", error: String(error45) };
-  }
-}
-function formatCassHistoryForPrompt(history) {
-  if (history.results.length === 0) {
-    return "";
+    return prompt;
   }
-  const lines = [
-    "## Similar Past Tasks",
-    "",
-    "These similar tasks were found in agent history:",
-    "",
-    ...history.results.slice(0, 3).map((r, i) => {
-      const preview = r.preview.slice(0, 200).replace(/\n/g, " ");
-      return `${i + 1}. [${r.agent}] ${preview}...`;
-    }),
-    "",
-    "Consider patterns that worked in these past tasks.",
-    ""
-  ];
-  return lines.join(`
-`);
-}
-var swarm_select_strategy = tool({
-  description: "Analyze task and recommend decomposition strategy (file-based, feature-based, or risk-based)",
+});
+var swarm_spawn_subtask = tool({
+  description: "Prepare a subtask for spawning. Returns prompt with Agent Mail/beads instructions.",
   args: {
-    task: tool.schema.string().min(1).describe("Task description to analyze"),
-    codebase_context: tool.schema.string().optional().describe("Optional codebase context (file structure, tech stack, etc.)")
+    bead_id: tool.schema.string().describe("Subtask bead ID"),
+    epic_id: tool.schema.string().describe("Parent epic bead ID"),
+    subtask_title: tool.schema.string().describe("Subtask title"),
+    subtask_description: tool.schema.string().optional().describe("Detailed subtask instructions"),
+    files: tool.schema.array(tool.schema.string()).describe("Files assigned to this subtask"),
+    shared_context: tool.schema.string().optional().describe("Context shared across all agents")
   },
   async execute(args) {
-    const result = selectStrategy(args.task);
-    let enhancedReasoning = result.reasoning;
-    if (args.codebase_context) {
-      enhancedReasoning += `
-
-Codebase context considered: ${args.codebase_context.slice(0, 200)}...`;
-    }
+    const prompt = formatSubtaskPromptV2({
+      bead_id: args.bead_id,
+      epic_id: args.epic_id,
+      subtask_title: args.subtask_title,
+      subtask_description: args.subtask_description || "",
+      files: args.files,
+      shared_context: args.shared_context
+    });
     return JSON.stringify({
-      strategy: result.strategy,
-      confidence: Math.round(result.confidence * 100) / 100,
-      reasoning: enhancedReasoning,
-      description: STRATEGIES[result.strategy].description,
-      guidelines: STRATEGIES[result.strategy].guidelines,
-      anti_patterns: STRATEGIES[result.strategy].antiPatterns,
-      alternatives: result.alternatives.map((alt) => ({
-        strategy: alt.strategy,
-        description: STRATEGIES[alt.strategy].description,
-        score: alt.score
-      }))
+      prompt,
+      bead_id: args.bead_id,
+      epic_id: args.epic_id,
+      files: args.files
     }, null, 2);
   }
 });
-var STRATEGY_DECOMPOSITION_PROMPT = `You are decomposing a task into parallelizable subtasks for a swarm of agents.
-
-## Task
-{task}
-
-{strategy_guidelines}
-
-{context_section}
-
-{cass_history}
-
-{skills_context}
-
-## MANDATORY: Beads Issue Tracking
-
-**Every subtask MUST become a bead.** This is non-negotiable.
-
-After decomposition, the coordinator will:
-1. Create an epic bead for the overall task
-2. Create child beads for each subtask
-3. Track progress through bead status updates
-4. Close beads with summaries when complete
-
-Agents MUST update their bead status as they work. No silent progress.
-
-## Requirements
-
-1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel
-2. **Assign files** - each subtask must specify which files it will modify
-3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)
-4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array
-5. **Estimate complexity** - 1 (trivial) to 5 (complex)
-6. **Plan aggressively** - break down more than you think necessary, smaller is better
-
-## Response Format
-
-Respond with a JSON object matching this schema:
-
-\`\`\`typescript
-{
-  epic: {
-    title: string,        // Epic title for the beads tracker
-    description?: string  // Brief description of the overall goal
+var swarm_evaluation_prompt = tool({
+  description: "Generate self-evaluation prompt for a completed subtask",
+  args: {
+    bead_id: tool.schema.string().describe("Subtask bead ID"),
+    subtask_title: tool.schema.string().describe("Subtask title"),
+    files_touched: tool.schema.array(tool.schema.string()).describe("Files that were modified")
   },
-  subtasks: [
-    {
-      title: string,              // What this subtask accomplishes
-      description?: string,       // Detailed instructions for the agent
-      files: string[],            // Files this subtask will modify (globs allowed)
-      dependencies: number[],     // Indices of subtasks this depends on (0-indexed)
-      estimated_complexity: 1-5   // Effort estimate
-    },
-    // ... more subtasks
-  ]
-}
-\`\`\`
-
-Now decompose the task:`;
+  async execute(args) {
+    const prompt = formatEvaluationPrompt({
+      bead_id: args.bead_id,
+      subtask_title: args.subtask_title,
+      files_touched: args.files_touched
+    });
+    return JSON.stringify({
+      prompt,
+      expected_schema: "Evaluation",
+      schema_hint: {
+        passed: "boolean",
+        criteria: {
+          type_safe: { passed: "boolean", feedback: "string" },
+          no_bugs: { passed: "boolean", feedback: "string" },
+          patterns: { passed: "boolean", feedback: "string" },
+          readable: { passed: "boolean", feedback: "string" }
+        },
+        overall_feedback: "string",
+        retry_suggestion: "string | null"
+      }
+    }, null, 2);
+  }
+});
 var swarm_plan_prompt = tool({
   description: "Generate strategy-specific decomposition prompt. Auto-selects strategy or uses provided one. Queries CASS for similar tasks.",
   args: {
     task: tool.schema.string().min(1).describe("Task description to decompose"),
     strategy: tool.schema.enum(["file-based", "feature-based", "risk-based", "auto"]).optional().describe("Decomposition strategy (default: auto-detect)"),
-    max_subtasks: tool.schema.number().int().min(2).default(5).describe("Maximum number of subtasks (default: 5)"),
+    max_subtasks: tool.schema.number().int().min(2).max(10).default(5).describe("Maximum number of subtasks (default: 5)"),
     context: tool.schema.string().optional().describe("Additional context (codebase info, constraints, etc.)"),
     query_cass: tool.schema.boolean().optional().describe("Query CASS for similar past tasks (default: true)"),
-    cass_limit: tool.schema.number().int().min(1).optional().describe("Max CASS results to include (default: 3)"),
+    cass_limit: tool.schema.number().int().min(1).max(10).optional().describe("Max CASS results to include (default: 3)"),
     include_skills: tool.schema.boolean().optional().describe("Include available skills in context (default: true)")
   },
   async execute(args) {
+    const { selectStrategy: selectStrategy2, formatStrategyGuidelines: formatStrategyGuidelines2, STRATEGIES: STRATEGIES2 } = await Promise.resolve().then(() => (init_swarm_strategies(), exports_swarm_strategies));
+    const { formatMemoryQueryForDecomposition: formatMemoryQueryForDecomposition2 } = await Promise.resolve().then(() => (init_learning(), exports_learning));
+    const { listSkills: listSkills2, getSkillsContextForSwarm: getSkillsContextForSwarm2, findRelevantSkills: findRelevantSkills2 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
     let selectedStrategy;
     let strategyReasoning;
     if (args.strategy && args.strategy !== "auto") {
       selectedStrategy = args.strategy;
       strategyReasoning = `User-specified strategy: ${selectedStrategy}`;
     } else {
-      const selection = selectStrategy(args.task);
+      const selection = selectStrategy2(args.task);
       selectedStrategy = selection.strategy;
       strategyReasoning = selection.reasoning;
     }
-    let cassContext = "";
-    let cassResultInfo;
-    if (args.query_cass !== false) {
-      const cassResult = await queryCassHistory(args.task, args.cass_limit ?? 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
     };
     if (args.include_skills !== false) {
-      const allSkills = await listSkills();
+      const allSkills = await listSkills2();
       if (allSkills.length > 0) {
-        skillsContext = await getSkillsContextForSwarm();
-        const relevantSkills = await findRelevantSkills(args.task);
+        skillsContext = await getSkillsContextForSwarm2();
+        const relevantSkills = await findRelevantSkills2(args.task);
         skillsInfo = {
           included: true,
           count: allSkills.length,
@@ -33484,18 +34275,18 @@ var swarm_plan_prompt = tool({
         }
       }
     }
-    const strategyGuidelines = formatStrategyGuidelines(selectedStrategy);
+    const strategyGuidelines = formatStrategyGuidelines2(selectedStrategy);
     const contextSection = args.context ? `## Additional Context
 ${args.context}` : `## Additional Context
 (none provided)`;
-    const prompt = 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 prompt = STRATEGY_DECOMPOSITION_PROMPT2.replace("{task}", args.task).replace("{strategy_guidelines}", strategyGuidelines).replace("{context_section}", contextSection).replace("{cass_history}", "").replace("{skills_context}", skillsContext || "").replace("{max_subtasks}", (args.max_subtasks ?? 5).toString());
     return JSON.stringify({
       prompt,
       strategy: {
         selected: selectedStrategy,
         reasoning: strategyReasoning,
-        guidelines: STRATEGIES[selectedStrategy].guidelines,
-        anti_patterns: STRATEGIES[selectedStrategy].antiPatterns
+        guidelines: STRATEGIES2[selectedStrategy].guidelines,
+        anti_patterns: STRATEGIES2[selectedStrategy].antiPatterns
       },
       expected_schema: "BeadTree",
       schema_hint: {
@@ -33511,243 +34302,135 @@ ${args.context}` : `## Additional Context
         ]
       },
       validation_note: "Parse agent response as JSON and validate with swarm_validate_decomposition",
-      cass_history: cassResultInfo,
-      skills: skillsInfo
-    }, null, 2);
-  }
-});
-var swarm_decompose = tool({
-  description: "Generate decomposition prompt for breaking task into parallelizable subtasks. Optionally queries CASS for similar past tasks.",
-  args: {
-    task: tool.schema.string().min(1).describe("Task description to decompose"),
-    max_subtasks: tool.schema.number().int().min(2).default(5).describe("Maximum number of subtasks (default: 5)"),
-    context: tool.schema.string().optional().describe("Additional context (codebase info, constraints, etc.)"),
-    query_cass: tool.schema.boolean().optional().describe("Query CASS for similar past tasks (default: true)"),
-    cass_limit: tool.schema.number().int().min(1).optional().describe("Max CASS results to include (default: 3)")
-  },
-  async execute(args) {
-    let cassContext = "";
-    let cassResultInfo;
-    if (args.query_cass !== false) {
-      const cassResult = await queryCassHistory(args.task, args.cass_limit ?? 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" };
-    }
-    const fullContext = [args.context, cassContext].filter(Boolean).join(`
-
-`);
-    const prompt = formatDecompositionPrompt(args.task, args.max_subtasks ?? 5, fullContext || undefined);
-    return JSON.stringify({
-      prompt,
-      expected_schema: "BeadTree",
-      schema_hint: {
-        epic: { title: "string", description: "string?" },
-        subtasks: [
-          {
-            title: "string",
-            description: "string?",
-            files: "string[]",
-            dependencies: "number[]",
-            estimated_complexity: "1-5"
-          }
-        ]
-      },
-      validation_note: "Parse agent response as JSON and validate with BeadTreeSchema from schemas/bead.ts",
-      cass_history: cassResultInfo
+      skills: skillsInfo,
+      memory_query: formatMemoryQueryForDecomposition2(args.task, 3)
     }, null, 2);
   }
 });
-var swarm_validate_decomposition = tool({
-  description: "Validate a decomposition response against BeadTreeSchema",
-  args: {
-    response: tool.schema.string().describe("JSON response from agent (BeadTree format)")
-  },
-  async execute(args) {
-    try {
-      const parsed = JSON.parse(args.response);
-      const validated = BeadTreeSchema.parse(parsed);
-      const allFiles = new Set;
-      const conflicts = [];
-      for (const subtask of validated.subtasks) {
-        for (const file2 of subtask.files) {
-          if (allFiles.has(file2)) {
-            conflicts.push(file2);
-          }
-          allFiles.add(file2);
-        }
-      }
-      if (conflicts.length > 0) {
-        return JSON.stringify({
-          valid: false,
-          error: `File conflicts detected: ${conflicts.join(", ")}`,
-          hint: "Each file can only be assigned to one subtask"
-        }, null, 2);
-      }
-      for (let i = 0;i < validated.subtasks.length; i++) {
-        const deps = validated.subtasks[i].dependencies;
-        for (const dep of deps) {
-          if (dep < 0 || dep >= validated.subtasks.length) {
-            return JSON.stringify({
-              valid: false,
-              error: `Invalid dependency: subtask ${i} depends on ${dep}, but only ${validated.subtasks.length} subtasks exist (indices 0-${validated.subtasks.length - 1})`,
-              hint: "Dependency index is out of bounds"
-            }, null, 2);
-          }
-          if (dep >= i) {
-            return JSON.stringify({
-              valid: false,
-              error: `Invalid dependency: subtask ${i} depends on ${dep}, but dependencies must be earlier in the array`,
-              hint: "Reorder subtasks so dependencies come before dependents"
-            }, null, 2);
-          }
-        }
-      }
-      const instructionConflicts = detectInstructionConflicts(validated.subtasks);
-      return JSON.stringify({
-        valid: true,
-        bead_tree: validated,
-        stats: {
-          subtask_count: validated.subtasks.length,
-          total_files: allFiles.size,
-          total_complexity: validated.subtasks.reduce((sum, s) => sum + s.estimated_complexity, 0)
-        },
-        warnings: instructionConflicts.length > 0 ? {
-          instruction_conflicts: instructionConflicts,
-          hint: "Review these potential conflicts between subtask instructions"
-        } : undefined
-      }, null, 2);
-    } catch (error45) {
-      if (error45 instanceof exports_external.ZodError) {
-        return JSON.stringify({
-          valid: false,
-          error: "Schema validation failed",
-          details: error45.issues
-        }, null, 2);
-      }
-      if (error45 instanceof SyntaxError) {
-        return JSON.stringify({
-          valid: false,
-          error: "Invalid JSON",
-          details: error45.message
-        }, null, 2);
-      }
-      throw error45;
-    }
+var promptTools = {
+  swarm_subtask_prompt,
+  swarm_spawn_subtask,
+  swarm_evaluation_prompt,
+  swarm_plan_prompt
+};
+// src/swarm-orchestrate.ts
+init_dist();
+init_zod();
+init_swarm_mail();
+init_learning();
+init_skills();
+async function queryEpicSubtasks(epicId) {
+  const beadsAvailable = await isToolAvailable("beads");
+  if (!beadsAvailable) {
+    warnMissingTool("beads");
+    return [];
   }
-});
-var swarm_status = tool({
-  description: "Get status of a swarm by epic ID",
-  args: {
-    epic_id: tool.schema.string().describe("Epic bead ID (e.g., bd-abc123)"),
-    project_key: tool.schema.string().describe("Project path (for Agent Mail queries)")
-  },
-  async execute(args) {
-    const subtasks = await queryEpicSubtasks(args.epic_id);
-    const statusCounts = {
-      running: 0,
-      completed: 0,
-      failed: 0,
-      blocked: 0
-    };
-    const agents = [];
-    for (const bead of subtasks) {
-      let agentStatus = "pending";
-      switch (bead.status) {
-        case "in_progress":
-          agentStatus = "running";
-          statusCounts.running++;
-          break;
-        case "closed":
-          agentStatus = "completed";
-          statusCounts.completed++;
-          break;
-        case "blocked":
-          agentStatus = "pending";
-          statusCounts.blocked++;
-          break;
-        default:
-          break;
-      }
-      agents.push({
-        bead_id: bead.id,
-        agent_name: "",
-        status: agentStatus,
-        files: []
-      });
-    }
-    const messageCount = await querySwarmMessages(args.project_key, args.epic_id);
-    const status = {
-      epic_id: args.epic_id,
-      total_agents: subtasks.length,
-      running: statusCounts.running,
-      completed: statusCounts.completed,
-      failed: statusCounts.failed,
-      blocked: statusCounts.blocked,
-      agents,
-      last_update: new Date().toISOString()
-    };
-    const validated = SwarmStatusSchema.parse(status);
-    return JSON.stringify({
-      ...validated,
-      message_count: messageCount,
-      progress_percent: subtasks.length > 0 ? Math.round(statusCounts.completed / subtasks.length * 100) : 0
-    }, null, 2);
+  const result = await Bun.$`bd list --parent ${epicId} --json`.quiet().nothrow();
+  if (result.exitCode !== 0) {
+    console.error(`[swarm] ERROR: Failed to query subtasks for epic ${epicId}:`, result.stderr.toString());
+    return [];
   }
-});
-var swarm_progress = tool({
-  description: "Report progress on a subtask to coordinator",
-  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"),
-    status: tool.schema.enum(["in_progress", "blocked", "completed", "failed"]).describe("Current status"),
-    message: tool.schema.string().optional().describe("Progress message or blockers"),
-    progress_percent: tool.schema.number().min(0).max(100).optional().describe("Completion percentage"),
-    files_touched: tool.schema.array(tool.schema.string()).optional().describe("Files modified so far")
-  },
-  async execute(args) {
-    const progress = {
-      bead_id: args.bead_id,
-      agent_name: args.agent_name,
-      status: args.status,
-      progress_percent: args.progress_percent,
-      message: args.message,
-      files_touched: args.files_touched,
-      timestamp: new Date().toISOString()
-    };
-    const validated = AgentProgressSchema.parse(progress);
-    if (args.status === "blocked" || args.status === "in_progress") {
-      const beadStatus = args.status === "blocked" ? "blocked" : "in_progress";
-      await Bun.$`bd update ${args.bead_id} --status ${beadStatus} --json`.quiet().nothrow();
+  try {
+    const parsed = JSON.parse(result.stdout.toString());
+    return exports_external.array(BeadSchema).parse(parsed);
+  } catch (error45) {
+    if (error45 instanceof exports_external.ZodError) {
+      console.error(`[swarm] ERROR: Invalid bead data for epic ${epicId}:`, error45.message);
+      return [];
     }
-    const epicId = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
-    await sendSwarmMessage({
-      projectPath: args.project_key,
-      fromAgent: args.agent_name,
-      toAgents: [],
-      subject: `Progress: ${args.bead_id} - ${args.status}`,
-      body: formatProgressMessage(validated),
-      threadId: epicId,
-      importance: args.status === "blocked" ? "high" : "normal"
+    console.error(`[swarm] ERROR: Failed to parse beads for epic ${epicId}:`, error45);
+    throw error45;
+  }
+}
+async function querySwarmMessages(projectKey, threadId) {
+  const agentMailAvailable2 = await isToolAvailable("agent-mail");
+  if (!agentMailAvailable2) {
+    return 0;
+  }
+  try {
+    const inbox = await getSwarmInbox({
+      projectPath: projectKey,
+      agentName: "coordinator",
+      limit: 5,
+      includeBodies: false
     });
-    return `Progress reported: ${args.status}${args.progress_percent !== undefined ? ` (${args.progress_percent}%)` : ""}`;
+    const threadMessages = inbox.messages.filter((m) => m.thread_id === threadId);
+    return threadMessages.length;
+  } catch (error45) {
+    console.warn(`[swarm] Failed to query swarm messages for thread ${threadId}:`, error45);
+    return 0;
   }
-});
+}
+function formatProgressMessage(progress) {
+  const lines = [
+    `**Status**: ${progress.status}`,
+    progress.progress_percent !== undefined ? `**Progress**: ${progress.progress_percent}%` : null,
+    progress.message ? `**Message**: ${progress.message}` : null,
+    progress.files_touched && progress.files_touched.length > 0 ? `**Files touched**:
+${progress.files_touched.map((f) => `- \`${f}\``).join(`
+`)}` : null,
+    progress.blockers && progress.blockers.length > 0 ? `**Blockers**:
+${progress.blockers.map((b) => `- ${b}`).join(`
+`)}` : null
+  ];
+  return lines.filter(Boolean).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",
@@ -33881,60 +34564,191 @@ async function runVerificationGate(filesTouched, skipUbs = false) {
     blockers
   };
 }
-async function runUbsScan(files) {
-  if (files.length === 0) {
-    return null;
-  }
-  const ubsAvailable = await isToolAvailable("ubs");
-  if (!ubsAvailable) {
-    warnMissingTool("ubs");
-    return null;
+function classifyFailure(error45) {
+  const msg = (typeof error45 === "string" ? error45 : error45.message).toLowerCase();
+  if (msg.includes("timeout"))
+    return "timeout";
+  if (msg.includes("conflict") || msg.includes("reservation"))
+    return "conflict";
+  if (msg.includes("validation") || msg.includes("schema"))
+    return "validation";
+  if (msg.includes("context") || msg.includes("token"))
+    return "context_overflow";
+  if (msg.includes("blocked") || msg.includes("dependency"))
+    return "dependency_blocked";
+  if (msg.includes("cancel"))
+    return "user_cancelled";
+  if (msg.includes("tool") || msg.includes("command") || msg.includes("failed to execute")) {
+    return "tool_failure";
   }
-  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 }
-      };
+  return "unknown";
+}
+var globalErrorAccumulator = new ErrorAccumulator;
+var globalStrikeStorage = new InMemoryStrikeStorage;
+var swarm_init = tool({
+  description: "Initialize swarm session: discovers available skills, checks tool availability. ALWAYS call at swarm start.",
+  args: {
+    project_path: tool.schema.string().optional().describe("Project path (for Agent Mail init)")
+  },
+  async execute(args) {
+    const availability = await checkAllTools();
+    const report = formatToolAvailability(availability);
+    const beadsAvailable = availability.get("beads")?.status.available ?? false;
+    const agentMailAvailable2 = availability.get("agent-mail")?.status.available ?? false;
+    const warnings = [];
+    const degradedFeatures = [];
+    if (!beadsAvailable) {
+      warnings.push("⚠️  beads (bd) not available - issue tracking disabled, swarm coordination will be limited");
+      degradedFeatures.push("issue tracking", "progress persistence");
     }
-    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
+    if (!agentMailAvailable2) {
+      warnings.push("⚠️  agent-mail not available - multi-agent communication disabled");
+      degradedFeatures.push("agent communication", "file reservations");
+    }
+    if (!availability.get("cass")?.status.available) {
+      degradedFeatures.push("historical context from past sessions");
+    }
+    if (!availability.get("ubs")?.status.available) {
+      degradedFeatures.push("pre-completion bug scanning");
+    }
+    if (!availability.get("semantic-memory")?.status.available) {
+      degradedFeatures.push("persistent learning (using in-memory fallback)");
+    }
+    const availableSkills = await listSkills();
+    const skillsInfo = {
+      count: availableSkills.length,
+      available: availableSkills.length > 0,
+      skills: availableSkills.map((s) => ({
+        name: s.name,
+        description: s.description,
+        hasScripts: s.hasScripts
+      }))
+    };
+    let skillsGuidance;
+    if (availableSkills.length > 0) {
+      skillsGuidance = `Found ${availableSkills.length} skill(s). Use skills_list to see details, skills_use to activate.`;
+    } else {
+      skillsGuidance = "No skills found. Add skills to .opencode/skills/ or .claude/skills/ for specialized guidance.";
+    }
+    return JSON.stringify({
+      ready: true,
+      tool_availability: Object.fromEntries(Array.from(availability.entries()).map(([k, v]) => [
+        k,
+        {
+          available: v.status.available,
+          fallback: v.status.available ? null : v.fallbackBehavior
         }
-      };
-    } 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 }
-      };
+      ])),
+      skills: skillsInfo,
+      warnings: warnings.length > 0 ? warnings : undefined,
+      degraded_features: degradedFeatures.length > 0 ? degradedFeatures : undefined,
+      recommendations: {
+        skills: skillsGuidance,
+        beads: beadsAvailable ? "✓ Use beads for all task tracking" : "Install beads: npm i -g @joelhooks/beads",
+        agent_mail: agentMailAvailable2 ? "✓ Use Agent Mail for coordination" : "Start Agent Mail: agent-mail serve"
+      },
+      report
+    }, null, 2);
+  }
+});
+var swarm_status = tool({
+  description: "Get status of a swarm by epic ID",
+  args: {
+    epic_id: tool.schema.string().describe("Epic bead ID (e.g., bd-abc123)"),
+    project_key: tool.schema.string().describe("Project path (for Agent Mail queries)")
+  },
+  async execute(args) {
+    const subtasks = await queryEpicSubtasks(args.epic_id);
+    const statusCounts = {
+      running: 0,
+      completed: 0,
+      failed: 0,
+      blocked: 0
+    };
+    const agents = [];
+    for (const bead of subtasks) {
+      let agentStatus = "pending";
+      switch (bead.status) {
+        case "in_progress":
+          agentStatus = "running";
+          statusCounts.running++;
+          break;
+        case "closed":
+          agentStatus = "completed";
+          statusCounts.completed++;
+          break;
+        case "blocked":
+          agentStatus = "pending";
+          statusCounts.blocked++;
+          break;
+        default:
+          break;
+      }
+      agents.push({
+        bead_id: bead.id,
+        agent_name: "",
+        status: agentStatus,
+        files: []
+      });
     }
-  } catch {
-    return null;
+    const messageCount = await querySwarmMessages(args.project_key, args.epic_id);
+    const status = {
+      epic_id: args.epic_id,
+      total_agents: subtasks.length,
+      running: statusCounts.running,
+      completed: statusCounts.completed,
+      failed: statusCounts.failed,
+      blocked: statusCounts.blocked,
+      agents,
+      last_update: new Date().toISOString()
+    };
+    const validated = SwarmStatusSchema.parse(status);
+    return JSON.stringify({
+      ...validated,
+      message_count: messageCount,
+      progress_percent: subtasks.length > 0 ? Math.round(statusCounts.completed / subtasks.length * 100) : 0
+    }, null, 2);
   }
-}
+});
+var swarm_progress = tool({
+  description: "Report progress on a subtask to coordinator",
+  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"),
+    status: tool.schema.enum(["in_progress", "blocked", "completed", "failed"]).describe("Current status"),
+    message: tool.schema.string().optional().describe("Progress message or blockers"),
+    progress_percent: tool.schema.number().min(0).max(100).optional().describe("Completion percentage"),
+    files_touched: tool.schema.array(tool.schema.string()).optional().describe("Files modified so far")
+  },
+  async execute(args) {
+    const progress = {
+      bead_id: args.bead_id,
+      agent_name: args.agent_name,
+      status: args.status,
+      progress_percent: args.progress_percent,
+      message: args.message,
+      files_touched: args.files_touched,
+      timestamp: new Date().toISOString()
+    };
+    const validated = AgentProgressSchema.parse(progress);
+    if (args.status === "blocked" || args.status === "in_progress") {
+      const beadStatus = args.status === "blocked" ? "blocked" : "in_progress";
+      await Bun.$`bd update ${args.bead_id} --status ${beadStatus} --json`.quiet().nothrow();
+    }
+    const epicId = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
+    await sendSwarmMessage({
+      projectPath: args.project_key,
+      fromAgent: args.agent_name,
+      toAgents: [],
+      subject: `Progress: ${args.bead_id} - ${args.status}`,
+      body: formatProgressMessage(validated),
+      threadId: epicId,
+      importance: args.status === "blocked" ? "high" : "normal"
+    });
+    return `Progress reported: ${args.status}${args.progress_percent !== undefined ? ` (${args.progress_percent}%)` : ""}`;
+  }
+});
 var swarm_broadcast = tool({
   description: "Broadcast context update to all agents working on the same epic",
   args: {
@@ -33945,8 +34759,8 @@ var swarm_broadcast = tool({
     importance: tool.schema.enum(["info", "warning", "blocker"]).default("info").describe("Priority level (default: info)"),
     files_affected: tool.schema.array(tool.schema.string()).optional().describe("Files this context relates to")
   },
-  async execute(args, ctx) {
-    const beadId = ctx.beadId || "unknown";
+  async execute(args) {
+    const beadId = "unknown";
     const body = [
       `## Context Update`,
       "",
@@ -34056,7 +34870,7 @@ var swarm_complete = tool({
     }
     const closeResult = await Bun.$`bd close ${args.bead_id} --reason ${args.summary} --json`.quiet().nothrow();
     if (closeResult.exitCode !== 0) {
-      throw new SwarmError(`Failed to close bead because bd close command failed: ${closeResult.stderr.toString()}. Try: Verify bead exists and is not already closed with 'bd show ${args.bead_id}', check if bead ID is correct with 'beads_query()', or use beads_close tool directly.`, "complete");
+      throw new Error(`Failed to close bead because bd close command failed: ${closeResult.stderr.toString()}. Try: Verify bead exists and is not already closed with 'bd show ${args.bead_id}', check if bead ID is correct with 'beads_query()', or use beads_close tool directly.`);
     }
     try {
       await releaseSwarmFiles({
@@ -34085,7 +34899,7 @@ var swarm_complete = tool({
       threadId: epicId,
       importance: "normal"
     });
-    return JSON.stringify({
+    const response = {
       success: true,
       bead_id: args.bead_id,
       closed: true,
@@ -34121,29 +34935,12 @@ 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) {
-  const msg = (typeof error45 === "string" ? error45 : error45.message).toLowerCase();
-  if (msg.includes("timeout"))
-    return "timeout";
-  if (msg.includes("conflict") || msg.includes("reservation"))
-    return "conflict";
-  if (msg.includes("validation") || msg.includes("schema"))
-    return "validation";
-  if (msg.includes("context") || msg.includes("token"))
-    return "context_overflow";
-  if (msg.includes("blocked") || msg.includes("dependency"))
-    return "dependency_blocked";
-  if (msg.includes("cancel"))
-    return "user_cancelled";
-  if (msg.includes("tool") || msg.includes("command") || msg.includes("failed to execute")) {
-    return "tool_failure";
-  }
-  return "unknown";
-}
 var swarm_record_outcome = tool({
   description: "Record subtask outcome for implicit feedback scoring. Tracks duration, errors, retries to learn decomposition quality.",
   args: {
@@ -34181,7 +34978,8 @@ var swarm_record_outcome = tool({
       failure_details: args.failure_details
     };
     if (!args.success && !args.failure_mode && args.failure_details) {
-      signals.failure_mode = classifyFailure(args.failure_details);
+      const classified = classifyFailure(args.failure_details);
+      signals.failure_mode = classified;
     }
     const validated = OutcomeSignalsSchema.parse(signals);
     const scored = scoreImplicitFeedback(validated, DEFAULT_LEARNING_CONFIG);
@@ -34231,168 +35029,141 @@ var swarm_record_outcome = tool({
     }, null, 2);
   }
 });
-var swarm_subtask_prompt = tool({
-  description: "Generate the prompt for a spawned subtask agent",
+var swarm_accumulate_error = tool({
+  description: "Record an error during subtask execution. Errors feed into retry prompts.",
   args: {
-    agent_name: tool.schema.string().describe("Agent Mail name for the agent"),
-    bead_id: tool.schema.string().describe("Subtask bead ID"),
-    epic_id: tool.schema.string().describe("Epic bead ID"),
-    subtask_title: tool.schema.string().describe("Subtask title"),
-    subtask_description: tool.schema.string().optional().describe("Detailed subtask instructions"),
-    files: tool.schema.array(tool.schema.string()).describe("Files assigned to this subtask"),
-    shared_context: tool.schema.string().optional().describe("Context shared across all agents")
+    bead_id: tool.schema.string().describe("Bead ID where error occurred"),
+    error_type: tool.schema.enum(["validation", "timeout", "conflict", "tool_failure", "unknown"]).describe("Category of error"),
+    message: tool.schema.string().describe("Human-readable error message"),
+    stack_trace: tool.schema.string().optional().describe("Stack trace for debugging"),
+    tool_name: tool.schema.string().optional().describe("Tool that failed"),
+    context: tool.schema.string().optional().describe("What was happening when error occurred")
   },
   async execute(args) {
-    const prompt = formatSubtaskPrompt({
-      agent_name: args.agent_name,
-      bead_id: args.bead_id,
-      epic_id: args.epic_id,
-      subtask_title: args.subtask_title,
-      subtask_description: args.subtask_description || "",
-      files: args.files,
-      shared_context: args.shared_context
+    const entry = await globalErrorAccumulator.recordError(args.bead_id, args.error_type, args.message, {
+      stack_trace: args.stack_trace,
+      tool_name: args.tool_name,
+      context: args.context
     });
-    return prompt;
+    return JSON.stringify({
+      success: true,
+      error_id: entry.id,
+      bead_id: entry.bead_id,
+      error_type: entry.error_type,
+      message: entry.message,
+      timestamp: entry.timestamp,
+      note: "Error recorded for retry context. Use swarm_get_error_context to retrieve accumulated errors."
+    }, null, 2);
   }
 });
-var swarm_spawn_subtask = tool({
-  description: "Prepare a subtask for spawning. Returns prompt with Agent Mail/beads instructions.",
+var swarm_get_error_context = tool({
+  description: "Get accumulated errors for a bead. Returns formatted context for retry prompts.",
   args: {
-    bead_id: tool.schema.string().describe("Subtask bead ID"),
-    epic_id: tool.schema.string().describe("Parent epic bead ID"),
-    subtask_title: tool.schema.string().describe("Subtask title"),
-    subtask_description: tool.schema.string().optional().describe("Detailed subtask instructions"),
-    files: tool.schema.array(tool.schema.string()).describe("Files assigned to this subtask"),
-    shared_context: tool.schema.string().optional().describe("Context shared across all agents")
+    bead_id: tool.schema.string().describe("Bead ID to get errors for"),
+    include_resolved: tool.schema.boolean().optional().describe("Include resolved errors (default: false)")
   },
   async execute(args) {
-    const prompt = formatSubtaskPromptV2({
-      bead_id: args.bead_id,
-      epic_id: args.epic_id,
-      subtask_title: args.subtask_title,
-      subtask_description: args.subtask_description || "",
-      files: args.files,
-      shared_context: args.shared_context
-    });
+    const errorContext = await globalErrorAccumulator.getErrorContext(args.bead_id, args.include_resolved ?? false);
+    const stats = await globalErrorAccumulator.getErrorStats(args.bead_id);
     return JSON.stringify({
-      prompt,
       bead_id: args.bead_id,
-      epic_id: args.epic_id,
-      files: args.files
+      error_context: errorContext,
+      stats: {
+        total_errors: stats.total,
+        unresolved: stats.unresolved,
+        by_type: stats.by_type
+      },
+      has_errors: errorContext.length > 0,
+      usage: "Inject error_context into retry prompt using {error_context} placeholder"
     }, null, 2);
   }
 });
-var TaskResultSchema = exports_external.object({
-  success: exports_external.boolean(),
-  summary: exports_external.string(),
-  files_modified: exports_external.array(exports_external.string()).optional().default([]),
-  files_created: exports_external.array(exports_external.string()).optional().default([]),
-  issues_found: exports_external.array(exports_external.string()).optional().default([]),
-  tests_passed: exports_external.boolean().optional(),
-  notes: exports_external.string().optional(),
-  blocker: exports_external.string().optional(),
-  suggestions: exports_external.array(exports_external.string()).optional()
-});
-var swarm_complete_subtask = tool({
-  description: "Handle subtask completion after Task agent returns. Parses result JSON, closes bead on success, creates new beads for issues found.",
+var swarm_resolve_error = tool({
+  description: "Mark an error as resolved after fixing it. Updates error accumulator state.",
   args: {
-    bead_id: exports_external.string().describe("Subtask bead ID to close"),
-    task_result: exports_external.string().describe("JSON result from the Task agent (TaskResult schema)"),
-    files_touched: exports_external.array(exports_external.string()).optional().describe("Override files touched (uses task_result.files_modified if not provided)")
+    error_id: tool.schema.string().describe("Error ID to mark as resolved")
   },
   async execute(args) {
-    let result;
-    try {
-      const parsed = JSON.parse(args.task_result);
-      result = TaskResultSchema.parse(parsed);
-    } catch (error45) {
-      const errorMessage = error45 instanceof SyntaxError ? `Invalid JSON: ${error45.message}` : error45 instanceof exports_external.ZodError ? `Schema validation failed: ${error45.issues.map((i) => i.message).join(", ")}` : String(error45);
-      return JSON.stringify({
-        success: false,
-        error: "Failed to parse task result",
-        details: errorMessage,
-        hint: "Task agent should return JSON matching TaskResult schema: { success, summary, files_modified?, issues_found?, ... }"
-      }, null, 2);
-    }
-    const filesTouched = args.files_touched ?? [
-      ...result.files_modified,
-      ...result.files_created
-    ];
-    const issuesCreated = [];
-    if (!result.success) {
-      return JSON.stringify({
-        success: false,
-        bead_id: args.bead_id,
-        task_failed: true,
-        summary: result.summary,
-        blocker: result.blocker,
-        suggestions: result.suggestions,
-        files_touched: filesTouched,
-        action_needed: "Task failed - review blocker and decide whether to retry or close as failed"
-      }, null, 2);
-    }
-    const closeReason = result.summary.slice(0, 200);
-    await Bun.$`bd close ${args.bead_id} -r "${closeReason}"`.quiet().nothrow();
-    if (result.issues_found.length > 0) {
-      for (const issue2 of result.issues_found) {
-        const issueTitle = issue2.slice(0, 100);
-        const createResult = await Bun.$`bd create "${issueTitle}" -t bug`.quiet().nothrow();
-        if (createResult.exitCode === 0) {
-          const output = createResult.stdout.toString();
-          const idMatch = output.match(/bd-[a-z0-9]+/);
-          issuesCreated.push({
-            title: issueTitle,
-            id: idMatch?.[0]
-          });
-        } else {
-          issuesCreated.push({
-            title: issueTitle,
-            id: undefined
-          });
+    await globalErrorAccumulator.resolveError(args.error_id);
+    return JSON.stringify({
+      success: true,
+      error_id: args.error_id,
+      resolved: true
+    }, null, 2);
+  }
+});
+var swarm_check_strikes = tool({
+  description: "Check 3-strike status for a bead. Records failures, detects architectural problems, generates architecture review prompts.",
+  args: {
+    bead_id: tool.schema.string().describe("Bead ID to check"),
+    action: tool.schema.enum(["check", "add_strike", "clear", "get_prompt"]).describe("Action: check count, add strike, clear strikes, or get prompt"),
+    attempt: tool.schema.string().optional().describe("Description of fix attempt (required for add_strike)"),
+    reason: tool.schema.string().optional().describe("Why the fix failed (required for add_strike)")
+  },
+  async execute(args) {
+    switch (args.action) {
+      case "check": {
+        const count = await getStrikes(args.bead_id, globalStrikeStorage);
+        const strikedOut = await isStrikedOut(args.bead_id, globalStrikeStorage);
+        return JSON.stringify({
+          bead_id: args.bead_id,
+          strike_count: count,
+          is_striked_out: strikedOut,
+          message: strikedOut ? "⚠️ STRUCK OUT: 3 strikes reached. Use get_prompt action for architecture review." : count === 0 ? "No strikes. Clear to proceed." : `${count} strike${count > 1 ? "s" : ""}. ${3 - count} remaining before architecture review required.`,
+          next_action: strikedOut ? "Call with action=get_prompt to get architecture review questions" : "Continue with fix attempt"
+        }, null, 2);
+      }
+      case "add_strike": {
+        if (!args.attempt || !args.reason) {
+          return JSON.stringify({
+            error: "add_strike requires 'attempt' and 'reason' parameters"
+          }, null, 2);
+        }
+        const record2 = await addStrike(args.bead_id, args.attempt, args.reason, globalStrikeStorage);
+        const strikedOut = record2.strike_count >= 3;
+        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
+        };
+        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);
+        return JSON.stringify({
+          bead_id: args.bead_id,
+          strike_count: 0,
+          is_striked_out: false,
+          message: "Strikes cleared. Fresh start."
+        }, null, 2);
+      }
+      case "get_prompt": {
+        const prompt = await getArchitecturePrompt(args.bead_id, globalStrikeStorage);
+        if (!prompt) {
+          return JSON.stringify({
+            bead_id: args.bead_id,
+            has_prompt: false,
+            message: "No architecture prompt (not struck out yet)"
+          }, null, 2);
         }
+        return JSON.stringify({
+          bead_id: args.bead_id,
+          has_prompt: true,
+          architecture_review_prompt: prompt,
+          message: "Architecture review required. Present this prompt to the human partner."
+        }, null, 2);
       }
+      default:
+        return JSON.stringify({
+          error: `Unknown action: ${args.action}`
+        }, null, 2);
     }
-    return JSON.stringify({
-      success: true,
-      bead_id: args.bead_id,
-      bead_closed: true,
-      summary: result.summary,
-      files_touched: filesTouched,
-      tests_passed: result.tests_passed,
-      notes: result.notes,
-      issues_created: issuesCreated.length > 0 ? issuesCreated : undefined,
-      issues_count: issuesCreated.length
-    }, null, 2);
-  }
-});
-var swarm_evaluation_prompt = tool({
-  description: "Generate self-evaluation prompt for a completed subtask",
-  args: {
-    bead_id: tool.schema.string().describe("Subtask bead ID"),
-    subtask_title: tool.schema.string().describe("Subtask title"),
-    files_touched: tool.schema.array(tool.schema.string()).describe("Files that were modified")
-  },
-  async execute(args) {
-    const prompt = formatEvaluationPrompt({
-      bead_id: args.bead_id,
-      subtask_title: args.subtask_title,
-      files_touched: args.files_touched
-    });
-    return JSON.stringify({
-      prompt,
-      expected_schema: "Evaluation",
-      schema_hint: {
-        passed: "boolean",
-        criteria: {
-          type_safe: { passed: "boolean", feedback: "string" },
-          no_bugs: { passed: "boolean", feedback: "string" },
-          patterns: { passed: "boolean", feedback: "string" },
-          readable: { passed: "boolean", feedback: "string" }
-        },
-        overall_feedback: "string",
-        retry_suggestion: "string | null"
-      }
-    }, null, 2);
   }
 });
 var swarm_learn = tool({
@@ -34465,8 +35236,8 @@ ${args.files_context.map((f) => `- \`${f}\``).join(`
 ---
 *Learned from swarm execution on ${new Date().toISOString().split("T")[0]}*`;
       const { getSkill: getSkill2, invalidateSkillsCache: invalidateSkillsCache2 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
-      const { mkdir: mkdir2, writeFile: writeFile2 } = await import("fs/promises");
-      const { join: join6 } = await import("path");
+      const { mkdir: mkdir2, writeFile: writeFile2 } = await import("node:fs/promises");
+      const { join: join6 } = await import("node:path");
       const existing = await getSkill2(args.skill_name);
       if (existing) {
         return JSON.stringify({
@@ -34524,227 +35295,28 @@ ${skillBody}`, "utf-8");
     }, null, 2);
   }
 });
-var globalErrorAccumulator = new ErrorAccumulator;
-var swarm_accumulate_error = tool({
-  description: "Record an error during subtask execution. Errors feed into retry prompts.",
-  args: {
-    bead_id: tool.schema.string().describe("Bead ID where error occurred"),
-    error_type: tool.schema.enum(["validation", "timeout", "conflict", "tool_failure", "unknown"]).describe("Category of error"),
-    message: tool.schema.string().describe("Human-readable error message"),
-    stack_trace: tool.schema.string().optional().describe("Stack trace for debugging"),
-    tool_name: tool.schema.string().optional().describe("Tool that failed"),
-    context: tool.schema.string().optional().describe("What was happening when error occurred")
-  },
-  async execute(args) {
-    const entry = await globalErrorAccumulator.recordError(args.bead_id, args.error_type, args.message, {
-      stack_trace: args.stack_trace,
-      tool_name: args.tool_name,
-      context: args.context
-    });
-    return JSON.stringify({
-      success: true,
-      error_id: entry.id,
-      bead_id: entry.bead_id,
-      error_type: entry.error_type,
-      message: entry.message,
-      timestamp: entry.timestamp,
-      note: "Error recorded for retry context. Use swarm_get_error_context to retrieve accumulated errors."
-    }, null, 2);
-  }
-});
-var swarm_get_error_context = tool({
-  description: "Get accumulated errors for a bead. Returns formatted context for retry prompts.",
-  args: {
-    bead_id: tool.schema.string().describe("Bead ID to get errors for"),
-    include_resolved: tool.schema.boolean().optional().describe("Include resolved errors (default: false)")
-  },
-  async execute(args) {
-    const errorContext = await globalErrorAccumulator.getErrorContext(args.bead_id, args.include_resolved ?? false);
-    const stats = await globalErrorAccumulator.getErrorStats(args.bead_id);
-    return JSON.stringify({
-      bead_id: args.bead_id,
-      error_context: errorContext,
-      stats: {
-        total_errors: stats.total,
-        unresolved: stats.unresolved,
-        by_type: stats.by_type
-      },
-      has_errors: errorContext.length > 0,
-      usage: "Inject error_context into retry prompt using {error_context} placeholder"
-    }, null, 2);
-  }
-});
-var swarm_resolve_error = tool({
-  description: "Mark an error as resolved after fixing it. Updates error accumulator state.",
-  args: {
-    error_id: tool.schema.string().describe("Error ID to mark as resolved")
-  },
-  async execute(args) {
-    await globalErrorAccumulator.resolveError(args.error_id);
-    return JSON.stringify({
-      success: true,
-      error_id: args.error_id,
-      resolved: true
-    }, null, 2);
-  }
-});
-var swarm_init = tool({
-  description: "Initialize swarm session: discovers available skills, checks tool availability. ALWAYS call at swarm start.",
-  args: {
-    project_path: tool.schema.string().optional().describe("Project path (for Agent Mail init)")
-  },
-  async execute(args) {
-    const availability = await checkAllTools();
-    const report = formatToolAvailability(availability);
-    const beadsAvailable = availability.get("beads")?.status.available ?? false;
-    const agentMailAvailable2 = availability.get("agent-mail")?.status.available ?? false;
-    const warnings = [];
-    const degradedFeatures = [];
-    if (!beadsAvailable) {
-      warnings.push("⚠️  beads (bd) not available - issue tracking disabled, swarm coordination will be limited");
-      degradedFeatures.push("issue tracking", "progress persistence");
-    }
-    if (!agentMailAvailable2) {
-      warnings.push("⚠️  agent-mail not available - multi-agent communication disabled");
-      degradedFeatures.push("agent communication", "file reservations");
-    }
-    if (!availability.get("cass")?.status.available) {
-      degradedFeatures.push("historical context from past sessions");
-    }
-    if (!availability.get("ubs")?.status.available) {
-      degradedFeatures.push("pre-completion bug scanning");
-    }
-    if (!availability.get("semantic-memory")?.status.available) {
-      degradedFeatures.push("persistent learning (using in-memory fallback)");
-    }
-    const availableSkills = await listSkills();
-    const skillsInfo = {
-      count: availableSkills.length,
-      available: availableSkills.length > 0,
-      skills: availableSkills.map((s) => ({
-        name: s.name,
-        description: s.description,
-        hasScripts: s.hasScripts
-      }))
-    };
-    let skillsGuidance;
-    if (availableSkills.length > 0) {
-      skillsGuidance = `Found ${availableSkills.length} skill(s). Use skills_list to see details, skills_use to activate.`;
-    } else {
-      skillsGuidance = "No skills found. Add skills to .opencode/skills/ or .claude/skills/ for specialized guidance.";
-    }
-    return JSON.stringify({
-      ready: true,
-      tool_availability: Object.fromEntries(Array.from(availability.entries()).map(([k, v]) => [
-        k,
-        {
-          available: v.status.available,
-          fallback: v.status.available ? null : v.fallbackBehavior
-        }
-      ])),
-      skills: skillsInfo,
-      warnings: warnings.length > 0 ? warnings : undefined,
-      degraded_features: degradedFeatures.length > 0 ? degradedFeatures : undefined,
-      recommendations: {
-        skills: skillsGuidance,
-        beads: beadsAvailable ? "✓ Use beads for all task tracking" : "Install beads: npm i -g @joelhooks/beads",
-        agent_mail: agentMailAvailable2 ? "✓ Use Agent Mail for coordination" : "Start Agent Mail: agent-mail serve"
-      },
-      report
-    }, null, 2);
-  }
-});
-var swarmTools = {
+var orchestrateTools = {
   swarm_init,
-  swarm_select_strategy,
-  swarm_plan_prompt,
-  swarm_decompose,
-  swarm_validate_decomposition,
   swarm_status,
   swarm_progress,
   swarm_broadcast,
   swarm_complete,
-  swarm_learn,
   swarm_record_outcome,
-  swarm_subtask_prompt,
-  swarm_spawn_subtask,
-  swarm_complete_subtask,
-  swarm_evaluation_prompt,
   swarm_accumulate_error,
   swarm_get_error_context,
-  swarm_resolve_error
+  swarm_resolve_error,
+  swarm_check_strikes,
+  swarm_learn
+};
+
+// src/swarm.ts
+init_swarm_strategies();
+var swarmTools = {
+  ...strategyTools,
+  ...decomposeTools,
+  ...promptTools,
+  ...orchestrateTools
 };
-var globalStrikeStorage = new InMemoryStrikeStorage;
-var swarm_check_strikes = tool({
-  description: "Check 3-strike status for a bead. Records failures, detects architectural problems, generates architecture review prompts.",
-  args: {
-    bead_id: tool.schema.string().describe("Bead ID to check"),
-    action: tool.schema.enum(["check", "add_strike", "clear", "get_prompt"]).describe("Action: check count, add strike, clear strikes, or get prompt"),
-    attempt: tool.schema.string().optional().describe("Description of fix attempt (required for add_strike)"),
-    reason: tool.schema.string().optional().describe("Why the fix failed (required for add_strike)")
-  },
-  async execute(args) {
-    switch (args.action) {
-      case "check": {
-        const count = await getStrikes(args.bead_id, globalStrikeStorage);
-        const strikedOut = await isStrikedOut(args.bead_id, globalStrikeStorage);
-        return JSON.stringify({
-          bead_id: args.bead_id,
-          strike_count: count,
-          is_striked_out: strikedOut,
-          message: strikedOut ? "⚠️ STRUCK OUT: 3 strikes reached. Use get_prompt action for architecture review." : count === 0 ? "No strikes. Clear to proceed." : `${count} strike${count > 1 ? "s" : ""}. ${3 - count} remaining before architecture review required.`,
-          next_action: strikedOut ? "Call with action=get_prompt to get architecture review questions" : "Continue with fix attempt"
-        }, null, 2);
-      }
-      case "add_strike": {
-        if (!args.attempt || !args.reason) {
-          return JSON.stringify({
-            error: "add_strike requires 'attempt' and 'reason' parameters"
-          }, null, 2);
-        }
-        const record2 = await addStrike(args.bead_id, args.attempt, args.reason, globalStrikeStorage);
-        const strikedOut = record2.strike_count >= 3;
-        return JSON.stringify({
-          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);
-      }
-      case "clear": {
-        await clearStrikes(args.bead_id, globalStrikeStorage);
-        return JSON.stringify({
-          bead_id: args.bead_id,
-          strike_count: 0,
-          is_striked_out: false,
-          message: "Strikes cleared. Fresh start."
-        }, null, 2);
-      }
-      case "get_prompt": {
-        const prompt = await getArchitecturePrompt(args.bead_id, globalStrikeStorage);
-        if (!prompt) {
-          return JSON.stringify({
-            bead_id: args.bead_id,
-            has_prompt: false,
-            message: "No architecture prompt (not struck out yet)"
-          }, null, 2);
-        }
-        return JSON.stringify({
-          bead_id: args.bead_id,
-          has_prompt: true,
-          architecture_review_prompt: prompt,
-          message: "Architecture review required. Present this prompt to the human partner."
-        }, null, 2);
-      }
-      default:
-        return JSON.stringify({
-          error: `Unknown action: ${args.action}`
-        }, null, 2);
-    }
-  }
-});
 
 // src/repo-crawl.ts
 init_dist();
@@ -35075,6 +35647,7 @@ init_skills();
 init_dist();
 
 // src/mandate-storage.ts
+init_learning();
 var cachedCommand = null;
 async function resolveSemanticMemoryCommand() {
   if (cachedCommand)
@@ -35781,6 +36354,9 @@ var mandateTools = {
   mandate_list,
   mandate_stats
 };
+// src/storage.ts
+init_learning();
+
 // src/anti-patterns.ts
 init_zod();
 var PatternKindSchema = exports_external.enum(["pattern", "anti_pattern"]);
@@ -35827,6 +36403,7 @@ class InMemoryPatternStorage {
 
 // src/pattern-maturity.ts
 init_zod();
+init_learning();
 var MaturityStateSchema = exports_external.enum([
   "candidate",
   "established",