opencode-swarm-plugin 0.20.0 → 0.22.0

package/dist/index.js

@@ -12675,7 +12675,7 @@ var init_zod = __esm(() => {
   init_external();
 });
 
-// node_modules/.pnpm/@opencode-ai+plugin@1.0.134/node_modules/@opencode-ai/plugin/dist/tool.js
+// node_modules/.pnpm/@opencode-ai+plugin@1.0.152/node_modules/@opencode-ai/plugin/dist/tool.js
 function tool(input) {
   return input;
 }
@@ -12684,7 +12684,7 @@ var init_tool = __esm(() => {
   tool.schema = exports_external;
 });
 
-// node_modules/.pnpm/@opencode-ai+plugin@1.0.134/node_modules/@opencode-ai/plugin/dist/index.js
+// node_modules/.pnpm/@opencode-ai+plugin@1.0.152/node_modules/@opencode-ai/plugin/dist/index.js
 var init_dist = __esm(() => {
   init_tool();
 });
@@ -12705,7 +12705,7 @@ function createEvent(type, data) {
 function isEventType(event, type) {
   return event.type === type;
 }
-var BaseEventSchema, AgentRegisteredEventSchema, AgentActiveEventSchema, MessageSentEventSchema, MessageReadEventSchema, MessageAckedEventSchema, FileReservedEventSchema, FileReleasedEventSchema, TaskStartedEventSchema, TaskProgressEventSchema, TaskCompletedEventSchema, TaskBlockedEventSchema, AgentEventSchema;
+var BaseEventSchema, AgentRegisteredEventSchema, AgentActiveEventSchema, MessageSentEventSchema, MessageReadEventSchema, MessageAckedEventSchema, FileReservedEventSchema, FileReleasedEventSchema, TaskStartedEventSchema, TaskProgressEventSchema, TaskCompletedEventSchema, TaskBlockedEventSchema, DecompositionGeneratedEventSchema, SubtaskOutcomeEventSchema, HumanFeedbackEventSchema, SwarmCheckpointedEventSchema, SwarmRecoveredEventSchema, AgentEventSchema;
 var init_events = __esm(() => {
   init_zod();
   BaseEventSchema = exports_external.object({
@@ -12791,6 +12791,68 @@ var init_events = __esm(() => {
     bead_id: exports_external.string(),
     reason: exports_external.string()
   });
+  DecompositionGeneratedEventSchema = BaseEventSchema.extend({
+    type: exports_external.literal("decomposition_generated"),
+    epic_id: exports_external.string(),
+    task: exports_external.string(),
+    context: exports_external.string().optional(),
+    strategy: exports_external.enum(["file-based", "feature-based", "risk-based"]),
+    epic_title: exports_external.string(),
+    subtasks: exports_external.array(exports_external.object({
+      title: exports_external.string(),
+      files: exports_external.array(exports_external.string()),
+      priority: exports_external.number().min(0).max(3).optional()
+    })),
+    recovery_context: exports_external.object({
+      shared_context: exports_external.string().optional(),
+      skills_to_load: exports_external.array(exports_external.string()).optional(),
+      coordinator_notes: exports_external.string().optional()
+    }).optional()
+  });
+  SubtaskOutcomeEventSchema = BaseEventSchema.extend({
+    type: exports_external.literal("subtask_outcome"),
+    epic_id: exports_external.string(),
+    bead_id: exports_external.string(),
+    planned_files: exports_external.array(exports_external.string()),
+    actual_files: exports_external.array(exports_external.string()),
+    duration_ms: exports_external.number().min(0),
+    error_count: exports_external.number().min(0).default(0),
+    retry_count: exports_external.number().min(0).default(0),
+    success: exports_external.boolean()
+  });
+  HumanFeedbackEventSchema = BaseEventSchema.extend({
+    type: exports_external.literal("human_feedback"),
+    epic_id: exports_external.string(),
+    accepted: exports_external.boolean(),
+    modified: exports_external.boolean().default(false),
+    notes: exports_external.string().optional()
+  });
+  SwarmCheckpointedEventSchema = BaseEventSchema.extend({
+    type: exports_external.literal("swarm_checkpointed"),
+    epic_id: exports_external.string(),
+    bead_id: exports_external.string(),
+    strategy: exports_external.enum(["file-based", "feature-based", "risk-based"]),
+    files: exports_external.array(exports_external.string()),
+    dependencies: exports_external.array(exports_external.string()),
+    directives: exports_external.object({
+      shared_context: exports_external.string().optional(),
+      skills_to_load: exports_external.array(exports_external.string()).optional(),
+      coordinator_notes: exports_external.string().optional()
+    }),
+    recovery: exports_external.object({
+      last_checkpoint: exports_external.number(),
+      files_modified: exports_external.array(exports_external.string()),
+      progress_percent: exports_external.number().min(0).max(100),
+      last_message: exports_external.string().optional(),
+      error_context: exports_external.string().optional()
+    })
+  });
+  SwarmRecoveredEventSchema = BaseEventSchema.extend({
+    type: exports_external.literal("swarm_recovered"),
+    epic_id: exports_external.string(),
+    bead_id: exports_external.string(),
+    recovered_from_checkpoint: exports_external.number()
+  });
   AgentEventSchema = exports_external.discriminatedUnion("type", [
     AgentRegisteredEventSchema,
     AgentActiveEventSchema,
@@ -12802,609 +12864,206 @@ var init_events = __esm(() => {
     TaskStartedEventSchema,
     TaskProgressEventSchema,
     TaskCompletedEventSchema,
-    TaskBlockedEventSchema
+    TaskBlockedEventSchema,
+    DecompositionGeneratedEventSchema,
+    SubtaskOutcomeEventSchema,
+    HumanFeedbackEventSchema,
+    SwarmCheckpointedEventSchema,
+    SwarmRecoveredEventSchema
   ]);
 });
 
-// src/streams/store.ts
-function parseTimestamp(timestamp) {
-  const ts = parseInt(timestamp, 10);
-  if (Number.isNaN(ts)) {
-    throw new Error(`[SwarmMail] Invalid timestamp: ${timestamp}`);
+// node_modules/.pnpm/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
+var balanced = (a, b, str2) => {
+  const ma = a instanceof RegExp ? maybeMatch(a, str2) : a;
+  const mb = b instanceof RegExp ? maybeMatch(b, str2) : b;
+  const r = ma !== null && mb != null && range(ma, mb, str2);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str2.slice(0, r[0]),
+    body: str2.slice(r[0] + ma.length, r[1]),
+    post: str2.slice(r[1] + mb.length)
+  };
+}, maybeMatch = (reg, str2) => {
+  const m = str2.match(reg);
+  return m ? m[0] : null;
+}, range = (a, b, str2) => {
+  let begs, beg, left, right = undefined, result;
+  let ai = str2.indexOf(a);
+  let bi = str2.indexOf(b, ai + 1);
+  let i = ai;
+  if (ai >= 0 && bi > 0) {
+    if (a === b) {
+      return [ai, bi];
+    }
+    begs = [];
+    left = str2.length;
+    while (i >= 0 && !result) {
+      if (i === ai) {
+        begs.push(i);
+        ai = str2.indexOf(a, i + 1);
+      } else if (begs.length === 1) {
+        const r = begs.pop();
+        if (r !== undefined)
+          result = [r, bi];
+      } else {
+        beg = begs.pop();
+        if (beg !== undefined && beg < left) {
+          left = beg;
+          right = bi;
+        }
+        bi = str2.indexOf(b, i + 1);
+      }
+      i = ai < bi && ai >= 0 ? ai : bi;
+    }
+    if (begs.length && right !== undefined) {
+      result = [left, right];
+    }
   }
-  if (ts > Number.MAX_SAFE_INTEGER) {
-    console.warn(`[SwarmMail] Timestamp ${timestamp} exceeds MAX_SAFE_INTEGER (year 2286+), precision may be lost`);
+  return result;
+};
+
+// node_modules/.pnpm/@isaacs+brace-expansion@5.0.0/node_modules/@isaacs/brace-expansion/dist/esm/index.js
+function numeric(str2) {
+  return !isNaN(str2) ? parseInt(str2, 10) : str2.charCodeAt(0);
+}
+function escapeBraces(str2) {
+  return str2.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str2) {
+  return str2.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+function parseCommaParts(str2) {
+  if (!str2) {
+    return [""];
   }
-  return ts;
+  const parts = [];
+  const m = balanced("{", "}", str2);
+  if (!m) {
+    return str2.split(",");
+  }
+  const { pre, body, post } = m;
+  const p = pre.split(",");
+  p[p.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    p[p.length - 1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+  parts.push.apply(parts, p);
+  return parts;
 }
-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)]);
-  const row = result.rows[0];
-  if (!row) {
-    throw new Error("Failed to insert event - no row returned");
+function expand(str2) {
+  if (!str2) {
+    return [];
   }
-  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 };
+  if (str2.slice(0, 2) === "{}") {
+    str2 = "\\{\\}" + str2.slice(2);
+  }
+  return expand_(escapeBraces(str2), true).map(unescapeBraces);
 }
-async function appendEvents(events, projectPath) {
-  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");
+function embrace(str2) {
+  return "{" + str2 + "}";
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+function expand_(str2, isTop) {
+  const expansions = [];
+  const m = balanced("{", "}", str2);
+  if (!m)
+    return [str2];
+  const pre = m.pre;
+  const post = m.post.length ? expand_(m.post, false) : [""];
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0;k < post.length; k++) {
+      const expansion = pre + "{" + m.body + "}" + post[k];
+      expansions.push(expansion);
+    }
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m.post.match(/,(?!,).*\}/)) {
+        str2 = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str2);
+      }
+      return [str2];
+    }
+    let n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
+    } else {
+      n = parseCommaParts(m.body);
+      if (n.length === 1 && n[0] !== undefined) {
+        n = expand_(n[0], false).map(embrace);
+        if (n.length === 1) {
+          return post.map((p) => m.pre + n[0] + p);
         }
-        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);
+    }
+    let N;
+    if (isSequence && n[0] !== undefined && n[1] !== undefined) {
+      const x = numeric(n[0]);
+      const y = numeric(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== undefined ? Math.abs(numeric(n[2])) : 1;
+      let test = lte;
+      const reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
       }
-      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;
+      const pad = n.some(isPadded);
+      N = [];
+      for (let i = x;test(i, y); i += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
+          }
+        } else {
+          c = String(i);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + c;
+              }
+            }
+          }
+        }
+        N.push(c);
+      }
+    } else {
+      N = [];
+      for (let j = 0;j < n.length; j++) {
+        N.push.apply(N, expand_(n[j], false));
       }
-      throw e;
     }
-    return results;
-  });
-}
-async function readEvents(options2 = {}, projectPath) {
-  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) {
-  const db = await getDatabase(projectPath);
-  const query = projectKey ? "SELECT MAX(sequence) as seq FROM events WHERE project_key = $1" : "SELECT MAX(sequence) as seq FROM events";
-  const params = projectKey ? [projectKey] : [];
-  const result = await db.query(query, params);
-  return result.rows[0]?.seq ?? 0;
-}
-async function replayEvents(options2 = {}, projectPath) {
-  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
-        )`, [projectKey]);
-      await db.query(`DELETE FROM messages WHERE project_key = $1`, [
-        projectKey
-      ]);
-      await db.query(`DELETE FROM reservations WHERE project_key = $1`, [
-        projectKey
-      ]);
-      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;
-    }
-    return {
-      eventsReplayed: processed,
-      duration: Date.now() - startTime
-    };
-  });
-}
-async function updateMaterializedViews(db, event) {
-  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) {
-  await db.query(`INSERT INTO agents (project_key, name, program, model, task_description, registered_at, last_active_at)
-     VALUES ($1, $2, $3, $4, $5, $6, $6)
-     ON CONFLICT (project_key, name) DO UPDATE SET
-       program = EXCLUDED.program,
-       model = EXCLUDED.model,
-       task_description = EXCLUDED.task_description,
-       last_active_at = EXCLUDED.last_active_at`, [
-    event.project_key,
-    event.agent_name,
-    event.program,
-    event.model,
-    event.task_description || null,
-    event.timestamp
-  ]);
-}
-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`, [
-    event.project_key,
-    event.from_agent,
-    event.subject,
-    event.body,
-    event.thread_id || null,
-    event.importance,
-    event.ack_required,
-    event.timestamp
-  ]);
-  const msgRow = result.rows[0];
-  if (!msgRow) {
-    throw new Error("Failed to insert message - no row returned");
-  }
-  const messageId = msgRow.id;
-  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 ${values}
-       ON CONFLICT DO NOTHING`, params);
-    console.log("[SwarmMail] Message recipients inserted", {
-      messageId,
-      recipientCount: event.to_agents.length
-    });
-  }
-}
-async function handleFileReserved(db, event) {
-  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,
-      ...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) {
-  if (event.type !== "file_released")
-    return;
-  if (event.reservation_ids && event.reservation_ids.length > 0) {
-    await db.query(`UPDATE reservations SET released_at = $1 WHERE id = ANY($2)`, [event.timestamp, event.reservation_ids]);
-  } else if (event.paths && event.paths.length > 0) {
-    await db.query(`UPDATE reservations SET released_at = $1
-       WHERE project_key = $2 AND agent_name = $3 AND path_pattern = ANY($4) AND released_at IS NULL`, [event.timestamp, event.project_key, event.agent_name, event.paths]);
-  } else {
-    await db.query(`UPDATE reservations SET released_at = $1
-       WHERE project_key = $2 AND agent_name = $3 AND released_at IS NULL`, [event.timestamp, event.project_key, event.agent_name]);
-  }
-}
-async function registerAgent(projectKey, agentName, options2 = {}, projectPath) {
-  const event = createEvent("agent_registered", {
-    project_key: projectKey,
-    agent_name: agentName,
-    program: options2.program || "opencode",
-    model: options2.model || "unknown",
-    task_description: options2.taskDescription
-  });
-  return appendEvent(event, projectPath);
-}
-async function sendMessage(projectKey, fromAgent, toAgents, subject, body, options2 = {}, projectPath) {
-  const event = createEvent("message_sent", {
-    project_key: projectKey,
-    from_agent: fromAgent,
-    to_agents: toAgents,
-    subject,
-    body,
-    thread_id: options2.threadId,
-    importance: options2.importance || "normal",
-    ack_required: options2.ackRequired || false
-  });
-  return appendEvent(event, projectPath);
-}
-async function reserveFiles(projectKey, agentName, paths, options2 = {}, projectPath) {
-  const ttlSeconds = options2.ttlSeconds || 3600;
-  const event = createEvent("file_reserved", {
-    project_key: projectKey,
-    agent_name: agentName,
-    paths,
-    reason: options2.reason,
-    exclusive: options2.exclusive ?? true,
-    ttl_seconds: ttlSeconds,
-    expires_at: Date.now() + ttlSeconds * 1000
-  });
-  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
-var balanced = (a, b, str2) => {
-  const ma = a instanceof RegExp ? maybeMatch(a, str2) : a;
-  const mb = b instanceof RegExp ? maybeMatch(b, str2) : b;
-  const r = ma !== null && mb != null && range(ma, mb, str2);
-  return r && {
-    start: r[0],
-    end: r[1],
-    pre: str2.slice(0, r[0]),
-    body: str2.slice(r[0] + ma.length, r[1]),
-    post: str2.slice(r[1] + mb.length)
-  };
-}, maybeMatch = (reg, str2) => {
-  const m = str2.match(reg);
-  return m ? m[0] : null;
-}, range = (a, b, str2) => {
-  let begs, beg, left, right = undefined, result;
-  let ai = str2.indexOf(a);
-  let bi = str2.indexOf(b, ai + 1);
-  let i = ai;
-  if (ai >= 0 && bi > 0) {
-    if (a === b) {
-      return [ai, bi];
-    }
-    begs = [];
-    left = str2.length;
-    while (i >= 0 && !result) {
-      if (i === ai) {
-        begs.push(i);
-        ai = str2.indexOf(a, i + 1);
-      } else if (begs.length === 1) {
-        const r = begs.pop();
-        if (r !== undefined)
-          result = [r, bi];
-      } else {
-        beg = begs.pop();
-        if (beg !== undefined && beg < left) {
-          left = beg;
-          right = bi;
-        }
-        bi = str2.indexOf(b, i + 1);
-      }
-      i = ai < bi && ai >= 0 ? ai : bi;
-    }
-    if (begs.length && right !== undefined) {
-      result = [left, right];
-    }
-  }
-  return result;
-};
-
-// node_modules/.pnpm/@isaacs+brace-expansion@5.0.0/node_modules/@isaacs/brace-expansion/dist/esm/index.js
-function numeric(str2) {
-  return !isNaN(str2) ? parseInt(str2, 10) : str2.charCodeAt(0);
-}
-function escapeBraces(str2) {
-  return str2.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
-}
-function unescapeBraces(str2) {
-  return str2.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
-}
-function parseCommaParts(str2) {
-  if (!str2) {
-    return [""];
-  }
-  const parts = [];
-  const m = balanced("{", "}", str2);
-  if (!m) {
-    return str2.split(",");
-  }
-  const { pre, body, post } = m;
-  const p = pre.split(",");
-  p[p.length - 1] += "{" + body + "}";
-  const postParts = parseCommaParts(post);
-  if (post.length) {
-    p[p.length - 1] += postParts.shift();
-    p.push.apply(p, postParts);
-  }
-  parts.push.apply(parts, p);
-  return parts;
-}
-function expand(str2) {
-  if (!str2) {
-    return [];
-  }
-  if (str2.slice(0, 2) === "{}") {
-    str2 = "\\{\\}" + str2.slice(2);
-  }
-  return expand_(escapeBraces(str2), true).map(unescapeBraces);
-}
-function embrace(str2) {
-  return "{" + str2 + "}";
-}
-function isPadded(el) {
-  return /^-?0\d/.test(el);
-}
-function lte(i, y) {
-  return i <= y;
-}
-function gte(i, y) {
-  return i >= y;
-}
-function expand_(str2, isTop) {
-  const expansions = [];
-  const m = balanced("{", "}", str2);
-  if (!m)
-    return [str2];
-  const pre = m.pre;
-  const post = m.post.length ? expand_(m.post, false) : [""];
-  if (/\$$/.test(m.pre)) {
-    for (let k = 0;k < post.length; k++) {
-      const expansion = pre + "{" + m.body + "}" + post[k];
-      expansions.push(expansion);
-    }
-  } else {
-    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-    const isSequence = isNumericSequence || isAlphaSequence;
-    const isOptions = m.body.indexOf(",") >= 0;
-    if (!isSequence && !isOptions) {
-      if (m.post.match(/,(?!,).*\}/)) {
-        str2 = m.pre + "{" + m.body + escClose + m.post;
-        return expand_(str2);
-      }
-      return [str2];
-    }
-    let n;
-    if (isSequence) {
-      n = m.body.split(/\.\./);
-    } else {
-      n = parseCommaParts(m.body);
-      if (n.length === 1 && n[0] !== undefined) {
-        n = expand_(n[0], false).map(embrace);
-        if (n.length === 1) {
-          return post.map((p) => m.pre + n[0] + p);
-        }
-      }
-    }
-    let N;
-    if (isSequence && n[0] !== undefined && n[1] !== undefined) {
-      const x = numeric(n[0]);
-      const y = numeric(n[1]);
-      const width = Math.max(n[0].length, n[1].length);
-      let incr = n.length === 3 && n[2] !== undefined ? Math.abs(numeric(n[2])) : 1;
-      let test = lte;
-      const reverse = y < x;
-      if (reverse) {
-        incr *= -1;
-        test = gte;
-      }
-      const pad = n.some(isPadded);
-      N = [];
-      for (let i = x;test(i, y); i += incr) {
-        let c;
-        if (isAlphaSequence) {
-          c = String.fromCharCode(i);
-          if (c === "\\") {
-            c = "";
-          }
-        } else {
-          c = String(i);
-          if (pad) {
-            const need = width - c.length;
-            if (need > 0) {
-              const z = new Array(need + 1).join("0");
-              if (i < 0) {
-                c = "-" + z + c.slice(1);
-              } else {
-                c = z + c;
-              }
-            }
-          }
-        }
-        N.push(c);
-      }
-    } else {
-      N = [];
-      for (let j = 0;j < n.length; j++) {
-        N.push.apply(N, expand_(n[j], false));
-      }
-    }
-    for (let j = 0;j < N.length; j++) {
-      for (let k = 0;k < post.length; k++) {
-        const expansion = pre + N[j] + post[k];
-        if (!isTop || isSequence || expansion) {
-          expansions.push(expansion);
-        }
-      }
-    }
-  }
-  return expansions;
+    for (let j = 0;j < N.length; j++) {
+      for (let k = 0;k < post.length; k++) {
+        const expansion = pre + N[j] + post[k];
+        if (!isTop || isSequence || expansion) {
+          expansions.push(expansion);
+        }
+      }
+    }
+  }
+  return expansions;
 }
 var escSlash, escOpen, escClose, escComma, escPeriod, escSlashPattern, escOpenPattern, escClosePattern, escCommaPattern, escPeriodPattern, slashPattern, openPattern, closePattern, commaPattern, periodPattern;
 var init_esm = __esm(() => {
@@ -14753,6 +14412,79 @@ function pathMatches(path2, pattern) {
   }
   return minimatch(path2, pattern);
 }
+async function getEvalRecords(projectKey, options2, projectPath) {
+  const db = await getDatabase(projectPath);
+  const conditions = ["project_key = $1"];
+  const params = [projectKey];
+  let paramIndex = 2;
+  if (options2?.strategy) {
+    conditions.push(`strategy = $${paramIndex++}`);
+    params.push(options2.strategy);
+  }
+  const whereClause = conditions.join(" AND ");
+  let query = `
+    SELECT id, project_key, task, context, strategy, epic_title, subtasks,
+           outcomes, overall_success, total_duration_ms, total_errors,
+           human_accepted, human_modified, human_notes,
+           file_overlap_count, scope_accuracy, time_balance_ratio,
+           created_at, updated_at
+    FROM eval_records
+    WHERE ${whereClause}
+    ORDER BY created_at DESC
+  `;
+  if (options2?.limit) {
+    query += ` LIMIT $${paramIndex}`;
+    params.push(options2.limit);
+  }
+  const result = await db.query(query, params);
+  return result.rows.map((row) => ({
+    id: row.id,
+    project_key: row.project_key,
+    task: row.task,
+    context: row.context,
+    strategy: row.strategy,
+    epic_title: row.epic_title,
+    subtasks: typeof row.subtasks === "string" ? JSON.parse(row.subtasks) : row.subtasks,
+    outcomes: row.outcomes ? typeof row.outcomes === "string" ? JSON.parse(row.outcomes) : row.outcomes : undefined,
+    overall_success: row.overall_success,
+    total_duration_ms: row.total_duration_ms,
+    total_errors: row.total_errors,
+    human_accepted: row.human_accepted,
+    human_modified: row.human_modified,
+    human_notes: row.human_notes,
+    file_overlap_count: row.file_overlap_count,
+    scope_accuracy: row.scope_accuracy,
+    time_balance_ratio: row.time_balance_ratio,
+    created_at: parseInt(row.created_at),
+    updated_at: parseInt(row.updated_at)
+  }));
+}
+async function getEvalStats(projectKey, projectPath) {
+  const db = await getDatabase(projectPath);
+  const overallResult = await db.query(`SELECT 
+      COUNT(*) as total_records,
+      COUNT(*) FILTER (WHERE overall_success = true) as success_count,
+      AVG(total_duration_ms) as avg_duration
+    FROM eval_records
+    WHERE project_key = $1`, [projectKey]);
+  const totalRecords = parseInt(overallResult.rows[0]?.total_records || "0");
+  const successCount = parseInt(overallResult.rows[0]?.success_count || "0");
+  const avgDurationMs = parseFloat(overallResult.rows[0]?.avg_duration || "0");
+  const strategyResult = await db.query(`SELECT strategy, COUNT(*) as count
+    FROM eval_records
+    WHERE project_key = $1
+    GROUP BY strategy`, [projectKey]);
+  const byStrategy = {};
+  for (const row of strategyResult.rows) {
+    byStrategy[row.strategy] = parseInt(row.count);
+  }
+  return {
+    totalRecords,
+    successRate: totalRecords > 0 ? successCount / totalRecords : 0,
+    avgDurationMs,
+    byStrategy
+  };
+}
 var init_projections = __esm(() => {
   init_streams();
   init_esm2();
@@ -15476,10 +15208,279 @@ var init_migrations = __esm(() => {
       CREATE INDEX IF NOT EXISTS idx_deferred_resolved ON deferred(resolved);
     `,
       down: `DROP TABLE IF EXISTS deferred;`
+    },
+    {
+      version: 3,
+      description: "Add eval_records table for learning system",
+      up: `
+      CREATE TABLE IF NOT EXISTS eval_records (
+        id TEXT PRIMARY KEY,
+        project_key TEXT NOT NULL,
+        task TEXT NOT NULL,
+        context TEXT,
+        strategy TEXT NOT NULL,
+        epic_title TEXT NOT NULL,
+        subtasks JSONB NOT NULL,
+        outcomes JSONB,
+        overall_success BOOLEAN,
+        total_duration_ms INTEGER,
+        total_errors INTEGER,
+        human_accepted BOOLEAN,
+        human_modified BOOLEAN,
+        human_notes TEXT,
+        file_overlap_count INTEGER,
+        scope_accuracy REAL,
+        time_balance_ratio REAL,
+        created_at BIGINT NOT NULL,
+        updated_at BIGINT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_eval_records_project ON eval_records(project_key);
+      CREATE INDEX IF NOT EXISTS idx_eval_records_strategy ON eval_records(strategy);
+    `,
+      down: `DROP TABLE IF EXISTS eval_records;`
+    },
+    {
+      version: 4,
+      description: "Add swarm_contexts table for context recovery",
+      up: `
+      CREATE TABLE IF NOT EXISTS swarm_contexts (
+        id TEXT PRIMARY KEY,
+        epic_id TEXT NOT NULL,
+        bead_id TEXT NOT NULL,
+        strategy TEXT NOT NULL,
+        files JSONB NOT NULL,
+        dependencies JSONB NOT NULL,
+        directives JSONB NOT NULL,
+        recovery JSONB NOT NULL,
+        created_at BIGINT NOT NULL,
+        updated_at BIGINT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_swarm_contexts_epic ON swarm_contexts(epic_id);
+      CREATE INDEX IF NOT EXISTS idx_swarm_contexts_bead ON swarm_contexts(bead_id);
+    `,
+      down: `DROP TABLE IF EXISTS swarm_contexts;`
     }
   ];
 });
 
+// src/streams/swarm-mail.ts
+function generateSwarmAgentName() {
+  const adj = ADJECTIVES2[Math.floor(Math.random() * ADJECTIVES2.length)];
+  const noun = NOUNS2[Math.floor(Math.random() * NOUNS2.length)];
+  return `${adj}${noun}`;
+}
+async function initSwarmAgent(options2) {
+  const {
+    projectPath,
+    agentName = generateSwarmAgentName(),
+    program = "opencode",
+    model = "unknown",
+    taskDescription
+  } = options2;
+  await registerAgent(projectPath, agentName, { program, model, taskDescription }, projectPath);
+  return {
+    projectKey: projectPath,
+    agentName
+  };
+}
+async function sendSwarmMessage(options2) {
+  const {
+    projectPath,
+    fromAgent,
+    toAgents,
+    subject,
+    body,
+    threadId,
+    importance = "normal",
+    ackRequired = false
+  } = options2;
+  await sendMessage(projectPath, fromAgent, toAgents, subject, body, { threadId, importance, ackRequired }, projectPath);
+  const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_streams(), exports_streams));
+  const db = await getDatabase2(projectPath);
+  const result = await db.query(`SELECT id FROM messages 
+     WHERE project_key = $1 AND from_agent = $2 AND subject = $3
+     ORDER BY created_at DESC LIMIT 1`, [projectPath, fromAgent, subject]);
+  const messageId = result.rows[0]?.id ?? 0;
+  return {
+    success: true,
+    messageId,
+    threadId,
+    recipientCount: toAgents.length
+  };
+}
+async function getSwarmInbox(options2) {
+  const {
+    projectPath,
+    agentName,
+    limit = MAX_INBOX_LIMIT2,
+    urgentOnly = false,
+    unreadOnly = false,
+    includeBodies = false
+  } = options2;
+  const effectiveLimit = Math.min(limit, MAX_INBOX_LIMIT2);
+  const messages = await getInbox(projectPath, agentName, {
+    limit: effectiveLimit,
+    urgentOnly,
+    unreadOnly,
+    includeBodies
+  }, projectPath);
+  return {
+    messages: messages.map((m) => ({
+      id: m.id,
+      from_agent: m.from_agent,
+      subject: m.subject,
+      body: includeBodies ? m.body : undefined,
+      thread_id: m.thread_id,
+      importance: m.importance,
+      created_at: m.created_at
+    })),
+    total: messages.length
+  };
+}
+async function readSwarmMessage(options2) {
+  const { projectPath, messageId, agentName, markAsRead = false } = options2;
+  const message = await getMessage(projectPath, messageId, projectPath);
+  if (!message) {
+    return null;
+  }
+  if (markAsRead && agentName) {
+    await appendEvent(createEvent("message_read", {
+      project_key: projectPath,
+      message_id: messageId,
+      agent_name: agentName
+    }), projectPath);
+  }
+  return {
+    id: message.id,
+    from_agent: message.from_agent,
+    subject: message.subject,
+    body: message.body,
+    thread_id: message.thread_id,
+    importance: message.importance,
+    created_at: message.created_at
+  };
+}
+async function reserveSwarmFiles(options2) {
+  const {
+    projectPath,
+    agentName,
+    paths,
+    reason,
+    exclusive = true,
+    ttlSeconds = DEFAULT_TTL_SECONDS2
+  } = options2;
+  const conflicts = await checkConflicts(projectPath, agentName, paths, projectPath);
+  await reserveFiles(projectPath, agentName, paths, { reason, exclusive, ttlSeconds }, projectPath);
+  const reservations = await getActiveReservations(projectPath, projectPath, agentName);
+  const granted = reservations.filter((r) => paths.includes(r.path_pattern)).map((r) => ({
+    id: r.id,
+    path_pattern: r.path_pattern,
+    exclusive: r.exclusive,
+    expiresAt: r.expires_at
+  }));
+  return {
+    granted,
+    conflicts: conflicts.map((c) => ({
+      path: c.path,
+      holder: c.holder,
+      pattern: c.pattern
+    }))
+  };
+}
+async function releaseSwarmFiles(options2) {
+  const { projectPath, agentName, paths, reservationIds } = options2;
+  const currentReservations = await getActiveReservations(projectPath, projectPath, agentName);
+  let releaseCount = 0;
+  if (paths && paths.length > 0) {
+    releaseCount = currentReservations.filter((r) => paths.includes(r.path_pattern)).length;
+  } else if (reservationIds && reservationIds.length > 0) {
+    releaseCount = currentReservations.filter((r) => reservationIds.includes(r.id)).length;
+  } else {
+    releaseCount = currentReservations.length;
+  }
+  await appendEvent(createEvent("file_released", {
+    project_key: projectPath,
+    agent_name: agentName,
+    paths,
+    reservation_ids: reservationIds
+  }), projectPath);
+  return {
+    released: releaseCount,
+    releasedAt: Date.now()
+  };
+}
+async function acknowledgeSwarmMessage(options2) {
+  const { projectPath, messageId, agentName } = options2;
+  const timestamp = Date.now();
+  await appendEvent(createEvent("message_acked", {
+    project_key: projectPath,
+    message_id: messageId,
+    agent_name: agentName
+  }), projectPath);
+  return {
+    acknowledged: true,
+    acknowledgedAt: new Date(timestamp).toISOString()
+  };
+}
+async function checkSwarmHealth(projectPath) {
+  const healthy = await isDatabaseHealthy(projectPath);
+  if (!healthy) {
+    return {
+      healthy: false,
+      database: "disconnected"
+    };
+  }
+  const stats = await getDatabaseStats(projectPath);
+  return {
+    healthy: true,
+    database: "connected",
+    stats
+  };
+}
+var MAX_INBOX_LIMIT2 = 5, DEFAULT_TTL_SECONDS2 = 3600, ADJECTIVES2, NOUNS2;
+var init_swarm_mail = __esm(() => {
+  init_events();
+  init_streams();
+  init_projections();
+  init_store();
+  ADJECTIVES2 = [
+    "Blue",
+    "Red",
+    "Green",
+    "Gold",
+    "Silver",
+    "Swift",
+    "Bright",
+    "Dark",
+    "Calm",
+    "Bold",
+    "Wise",
+    "Quick",
+    "Warm",
+    "Cool",
+    "Pure",
+    "Wild"
+  ];
+  NOUNS2 = [
+    "Lake",
+    "Stone",
+    "River",
+    "Mountain",
+    "Forest",
+    "Ocean",
+    "Star",
+    "Moon",
+    "Wind",
+    "Fire",
+    "Cloud",
+    "Storm",
+    "Dawn",
+    "Dusk",
+    "Hawk",
+    "Wolf"
+  ];
+});
+
 // src/streams/index.ts
 var exports_streams = {};
 __export(exports_streams, {
@@ -15494,7 +15495,7 @@ __export(exports_streams, {
   reserveSwarmFiles: () => reserveSwarmFiles,
   reserveFiles: () => reserveFiles,
   reserveAgentFiles: () => reserveAgentFiles,
-  replayEventsBatched: () => replayEventsBatched,
+  replayEventsBatched: () => replayEventsBatched2,
   replayEvents: () => replayEvents,
   releaseSwarmFiles: () => releaseSwarmFiles,
   releaseAgentFiles: () => releaseAgentFiles,
@@ -15516,6 +15517,8 @@ __export(exports_streams, {
   getLatestSequence: () => getLatestSequence,
   getInbox: () => getInbox,
   getEventTimeline: () => getEventTimeline,
+  getEvalStats: () => getEvalStats,
+  getEvalRecords: () => getEvalRecords,
   getDatabaseStats: () => getDatabaseStats,
   getDatabasePath: () => getDatabasePath,
   getDatabase: () => getDatabase,
@@ -15543,12 +15546,17 @@ __export(exports_streams, {
   TaskProgressEventSchema: () => TaskProgressEventSchema,
   TaskCompletedEventSchema: () => TaskCompletedEventSchema,
   TaskBlockedEventSchema: () => TaskBlockedEventSchema,
+  SwarmRecoveredEventSchema: () => SwarmRecoveredEventSchema,
+  SwarmCheckpointedEventSchema: () => SwarmCheckpointedEventSchema,
+  SubtaskOutcomeEventSchema: () => SubtaskOutcomeEventSchema,
   PGlite: () => PGlite,
   MessageSentEventSchema: () => MessageSentEventSchema,
   MessageReadEventSchema: () => MessageReadEventSchema,
   MessageAckedEventSchema: () => MessageAckedEventSchema,
+  HumanFeedbackEventSchema: () => HumanFeedbackEventSchema,
   FileReservedEventSchema: () => FileReservedEventSchema,
   FileReleasedEventSchema: () => FileReleasedEventSchema,
+  DecompositionGeneratedEventSchema: () => DecompositionGeneratedEventSchema,
   BaseEventSchema: () => BaseEventSchema,
   AgentRegisteredEventSchema: () => AgentRegisteredEventSchema,
   AgentEventSchema: () => AgentEventSchema,
@@ -15829,271 +15837,627 @@ async function isDatabaseHealthy(projectPath) {
     return false;
   }
 }
-async function getDatabaseStats(projectPath) {
+async function getDatabaseStats(projectPath) {
+  const db = await getDatabase(projectPath);
+  const [events2, agents, messages, reservations] = await Promise.all([
+    db.query("SELECT COUNT(*) as count FROM events"),
+    db.query("SELECT COUNT(*) as count FROM agents"),
+    db.query("SELECT COUNT(*) as count FROM messages"),
+    db.query("SELECT COUNT(*) as count FROM reservations WHERE released_at IS NULL")
+  ]);
+  return {
+    events: parseInt(events2.rows[0]?.count || "0"),
+    agents: parseInt(agents.rows[0]?.count || "0"),
+    messages: parseInt(messages.rows[0]?.count || "0"),
+    reservations: parseInt(reservations.rows[0]?.count || "0")
+  };
+}
+function handleExit() {
+  const dbsToClose = Array.from(instances.values());
+  for (const db of dbsToClose) {
+    try {
+      db.close().catch(() => {});
+    } catch {}
+  }
+}
+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();
+  init_events();
+  init_migrations();
+  init_projections();
+  init_store();
+  init_swarm_mail();
+  DEBUG_LOG_PATH = join(homedir(), ".opencode", "streams-debug.log");
+  instances = new Map;
+  pendingInstances = new Map;
+  schemaInitialized = new Map;
+  degradedInstances = new Map;
+  lastAccess = new Map;
+  process.on("exit", handleExit);
+  process.on("SIGINT", () => {
+    handleExit();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    handleExit();
+    process.exit(0);
+  });
+});
+
+// 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)]);
+  const row = result.rows[0];
+  if (!row) {
+    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(events2, projectPath) {
+  return withTiming("appendEvents", async () => {
+    const db = await getDatabase(projectPath);
+    const results = [];
+    await db.exec("BEGIN");
+    try {
+      for (const event of events2) {
+        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) {
+  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) {
   const db = await getDatabase(projectPath);
-  const [events2, agents, messages, reservations] = await Promise.all([
-    db.query("SELECT COUNT(*) as count FROM events"),
-    db.query("SELECT COUNT(*) as count FROM agents"),
-    db.query("SELECT COUNT(*) as count FROM messages"),
-    db.query("SELECT COUNT(*) as count FROM reservations WHERE released_at IS NULL")
-  ]);
-  return {
-    events: parseInt(events2.rows[0]?.count || "0"),
-    agents: parseInt(agents.rows[0]?.count || "0"),
-    messages: parseInt(messages.rows[0]?.count || "0"),
-    reservations: parseInt(reservations.rows[0]?.count || "0")
-  };
-}
-function handleExit() {
-  const dbsToClose = Array.from(instances.values());
-  for (const db of dbsToClose) {
-    try {
-      db.close().catch(() => {});
-    } catch {}
-  }
+  const query = projectKey ? "SELECT MAX(sequence) as seq FROM events WHERE project_key = $1" : "SELECT MAX(sequence) as seq FROM events";
+  const params = projectKey ? [projectKey] : [];
+  const result = await db.query(query, params);
+  return result.rows[0]?.seq ?? 0;
 }
-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();
-  init_events();
-  init_migrations();
-  init_projections();
-  init_store();
-  init_swarm_mail();
-  DEBUG_LOG_PATH = join(homedir(), ".opencode", "streams-debug.log");
-  instances = new Map;
-  pendingInstances = new Map;
-  schemaInitialized = new Map;
-  degradedInstances = new Map;
-  lastAccess = new Map;
-  process.on("exit", handleExit);
-  process.on("SIGINT", () => {
-    handleExit();
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    handleExit();
-    process.exit(0);
+async function replayEvents(options2 = {}, projectPath) {
+  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 events2 = await readEvents({
+      projectKey: options2.projectKey,
+      afterSequence: options2.fromSequence
+    }, projectPath);
+    for (const event of events2) {
+      await updateMaterializedViews(db, event);
+    }
+    return {
+      eventsReplayed: events2.length,
+      duration: Date.now() - startTime
+    };
   });
-});
-
-// src/streams/swarm-mail.ts
-function generateSwarmAgentName() {
-  const adj = ADJECTIVES2[Math.floor(Math.random() * ADJECTIVES2.length)];
-  const noun = NOUNS2[Math.floor(Math.random() * NOUNS2.length)];
-  return `${adj}${noun}`;
 }
-async function initSwarmAgent(options2) {
-  const {
-    projectPath,
-    agentName = generateSwarmAgentName(),
-    program = "opencode",
-    model = "unknown",
-    taskDescription
-  } = options2;
-  await registerAgent(projectPath, agentName, { program, model, taskDescription }, projectPath);
-  return {
-    projectKey: projectPath,
-    agentName
-  };
+async function replayEventsBatched2(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
+        )`, [projectKey]);
+      await db.query(`DELETE FROM messages WHERE project_key = $1`, [
+        projectKey
+      ]);
+      await db.query(`DELETE FROM reservations WHERE project_key = $1`, [
+        projectKey
+      ]);
+      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 events2 = await readEvents({
+        projectKey,
+        afterSequence: fromSequence,
+        limit: batchSize,
+        offset
+      }, projectPath);
+      if (events2.length === 0)
+        break;
+      for (const event of events2) {
+        await updateMaterializedViews(db, event);
+      }
+      processed += events2.length;
+      const percent = Math.round(processed / total * 100);
+      await onBatch(events2, { processed, total, percent });
+      console.log(`[SwarmMail] Replaying events: ${processed}/${total} (${percent}%)`);
+      offset += batchSize;
+    }
+    return {
+      eventsReplayed: processed,
+      duration: Date.now() - startTime
+    };
+  });
 }
-async function sendSwarmMessage(options2) {
-  const {
-    projectPath,
-    fromAgent,
-    toAgents,
-    subject,
-    body,
-    threadId,
-    importance = "normal",
-    ackRequired = false
-  } = options2;
-  await sendMessage(projectPath, fromAgent, toAgents, subject, body, { threadId, importance, ackRequired }, projectPath);
-  const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_streams(), exports_streams));
-  const db = await getDatabase2(projectPath);
-  const result = await db.query(`SELECT id FROM messages 
-     WHERE project_key = $1 AND from_agent = $2 AND subject = $3
-     ORDER BY created_at DESC LIMIT 1`, [projectPath, fromAgent, subject]);
-  const messageId = result.rows[0]?.id ?? 0;
-  return {
-    success: true,
-    messageId,
-    threadId,
-    recipientCount: toAgents.length
-  };
+async function updateMaterializedViews(db, event) {
+  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;
+      case "decomposition_generated":
+        await handleDecompositionGenerated(db, event);
+        break;
+      case "subtask_outcome":
+        await handleSubtaskOutcome(db, event);
+        break;
+      case "human_feedback":
+        await handleHumanFeedback(db, event);
+        break;
+      case "swarm_checkpointed":
+        await handleSwarmCheckpointed(db, event);
+        break;
+      case "swarm_recovered":
+        await handleSwarmRecovered(db, event);
+        break;
+    }
+  } catch (error45) {
+    console.error("[SwarmMail] Failed to update materialized views", {
+      eventType: event.type,
+      eventId: event.id,
+      error: error45
+    });
+    throw error45;
+  }
 }
-async function getSwarmInbox(options2) {
-  const {
-    projectPath,
-    agentName,
-    limit = MAX_INBOX_LIMIT2,
-    urgentOnly = false,
-    unreadOnly = false,
-    includeBodies = false
-  } = options2;
-  const effectiveLimit = Math.min(limit, MAX_INBOX_LIMIT2);
-  const messages = await getInbox(projectPath, agentName, {
-    limit: effectiveLimit,
-    urgentOnly,
-    unreadOnly,
-    includeBodies
-  }, projectPath);
-  return {
-    messages: messages.map((m) => ({
-      id: m.id,
-      from_agent: m.from_agent,
-      subject: m.subject,
-      body: includeBodies ? m.body : undefined,
-      thread_id: m.thread_id,
-      importance: m.importance,
-      created_at: m.created_at
-    })),
-    total: messages.length
-  };
+async function handleAgentRegistered(db, event) {
+  await db.query(`INSERT INTO agents (project_key, name, program, model, task_description, registered_at, last_active_at)
+     VALUES ($1, $2, $3, $4, $5, $6, $6)
+     ON CONFLICT (project_key, name) DO UPDATE SET
+       program = EXCLUDED.program,
+       model = EXCLUDED.model,
+       task_description = EXCLUDED.task_description,
+       last_active_at = EXCLUDED.last_active_at`, [
+    event.project_key,
+    event.agent_name,
+    event.program,
+    event.model,
+    event.task_description || null,
+    event.timestamp
+  ]);
 }
-async function readSwarmMessage(options2) {
-  const { projectPath, messageId, agentName, markAsRead = false } = options2;
-  const message = await getMessage(projectPath, messageId, projectPath);
-  if (!message) {
-    return null;
+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`, [
+    event.project_key,
+    event.from_agent,
+    event.subject,
+    event.body,
+    event.thread_id || null,
+    event.importance,
+    event.ack_required,
+    event.timestamp
+  ]);
+  const msgRow = result.rows[0];
+  if (!msgRow) {
+    throw new Error("Failed to insert message - no row returned");
   }
-  if (markAsRead && agentName) {
-    await appendEvent(createEvent("message_read", {
-      project_key: projectPath,
-      message_id: messageId,
-      agent_name: agentName
-    }), projectPath);
+  const messageId = msgRow.id;
+  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 ${values}
+       ON CONFLICT DO NOTHING`, params);
+    console.log("[SwarmMail] Message recipients inserted", {
+      messageId,
+      recipientCount: event.to_agents.length
+    });
   }
-  return {
-    id: message.id,
-    from_agent: message.from_agent,
-    subject: message.subject,
-    body: message.body,
-    thread_id: message.thread_id,
-    importance: message.importance,
-    created_at: message.created_at
-  };
 }
-async function reserveSwarmFiles(options2) {
-  const {
-    projectPath,
-    agentName,
-    paths,
-    reason,
-    exclusive = true,
-    ttlSeconds = DEFAULT_TTL_SECONDS2
-  } = options2;
-  const conflicts = await checkConflicts(projectPath, agentName, paths, projectPath);
-  await reserveFiles(projectPath, agentName, paths, { reason, exclusive, ttlSeconds }, projectPath);
-  const reservations = await getActiveReservations(projectPath, projectPath, agentName);
-  const granted = reservations.filter((r) => paths.includes(r.path_pattern)).map((r) => ({
-    id: r.id,
-    path_pattern: r.path_pattern,
-    exclusive: r.exclusive,
-    expiresAt: r.expires_at
-  }));
-  return {
-    granted,
-    conflicts: conflicts.map((c) => ({
-      path: c.path,
-      holder: c.holder,
-      pattern: c.pattern
-    }))
-  };
+async function handleFileReserved(db, event) {
+  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,
+      ...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 releaseSwarmFiles(options2) {
-  const { projectPath, agentName, paths, reservationIds } = options2;
-  const currentReservations = await getActiveReservations(projectPath, projectPath, agentName);
-  let releaseCount = 0;
-  if (paths && paths.length > 0) {
-    releaseCount = currentReservations.filter((r) => paths.includes(r.path_pattern)).length;
-  } else if (reservationIds && reservationIds.length > 0) {
-    releaseCount = currentReservations.filter((r) => reservationIds.includes(r.id)).length;
+async function handleFileReleased(db, event) {
+  if (event.type !== "file_released")
+    return;
+  if (event.reservation_ids && event.reservation_ids.length > 0) {
+    await db.query(`UPDATE reservations SET released_at = $1 WHERE id = ANY($2)`, [event.timestamp, event.reservation_ids]);
+  } else if (event.paths && event.paths.length > 0) {
+    await db.query(`UPDATE reservations SET released_at = $1
+       WHERE project_key = $2 AND agent_name = $3 AND path_pattern = ANY($4) AND released_at IS NULL`, [event.timestamp, event.project_key, event.agent_name, event.paths]);
   } else {
-    releaseCount = currentReservations.length;
+    await db.query(`UPDATE reservations SET released_at = $1
+       WHERE project_key = $2 AND agent_name = $3 AND released_at IS NULL`, [event.timestamp, event.project_key, event.agent_name]);
   }
-  await appendEvent(createEvent("file_released", {
-    project_key: projectPath,
-    agent_name: agentName,
-    paths,
-    reservation_ids: reservationIds
-  }), projectPath);
-  return {
-    released: releaseCount,
-    releasedAt: Date.now()
-  };
 }
-async function acknowledgeSwarmMessage(options2) {
-  const { projectPath, messageId, agentName } = options2;
-  const timestamp = Date.now();
-  await appendEvent(createEvent("message_acked", {
-    project_key: projectPath,
-    message_id: messageId,
-    agent_name: agentName
-  }), projectPath);
-  return {
-    acknowledged: true,
-    acknowledgedAt: new Date(timestamp).toISOString()
-  };
+async function handleDecompositionGenerated(db, event) {
+  if (event.type !== "decomposition_generated")
+    return;
+  await db.query(`INSERT INTO eval_records (
+      id, project_key, task, context, strategy, epic_title, subtasks, 
+      created_at, updated_at
+    ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $8)
+    ON CONFLICT (id) DO NOTHING`, [
+    event.epic_id,
+    event.project_key,
+    event.task,
+    event.context || null,
+    event.strategy,
+    event.epic_title,
+    JSON.stringify(event.subtasks),
+    event.timestamp
+  ]);
 }
-async function checkSwarmHealth(projectPath) {
-  const healthy = await isDatabaseHealthy(projectPath);
-  if (!healthy) {
-    return {
-      healthy: false,
-      database: "disconnected"
-    };
+async function handleSubtaskOutcome(db, event) {
+  if (event.type !== "subtask_outcome")
+    return;
+  const result = await db.query(`SELECT outcomes, subtasks FROM eval_records WHERE id = $1`, [
+    event.epic_id
+  ]);
+  if (!result.rows[0]) {
+    console.warn(`[SwarmMail] No eval_record found for epic_id ${event.epic_id}`);
+    return;
   }
-  const stats = await getDatabaseStats(projectPath);
-  return {
-    healthy: true,
-    database: "connected",
-    stats
-  };
+  const row = result.rows[0];
+  const subtasks = typeof row.subtasks === "string" ? JSON.parse(row.subtasks) : row.subtasks;
+  const outcomes = row.outcomes ? typeof row.outcomes === "string" ? JSON.parse(row.outcomes) : row.outcomes : [];
+  const newOutcome = {
+    bead_id: event.bead_id,
+    planned_files: event.planned_files,
+    actual_files: event.actual_files,
+    duration_ms: event.duration_ms,
+    error_count: event.error_count,
+    retry_count: event.retry_count,
+    success: event.success
+  };
+  const updatedOutcomes = [...outcomes, newOutcome];
+  const fileOverlapCount = computeFileOverlap(subtasks);
+  const scopeAccuracy = computeScopeAccuracy(event.planned_files, event.actual_files);
+  const timeBalanceRatio = computeTimeBalanceRatio(updatedOutcomes);
+  const overallSuccess = updatedOutcomes.every((o) => o.success);
+  const totalDurationMs = updatedOutcomes.reduce((sum, o) => sum + o.duration_ms, 0);
+  const totalErrors = updatedOutcomes.reduce((sum, o) => sum + o.error_count, 0);
+  await db.query(`UPDATE eval_records SET
+      outcomes = $1,
+      file_overlap_count = $2,
+      scope_accuracy = $3,
+      time_balance_ratio = $4,
+      overall_success = $5,
+      total_duration_ms = $6,
+      total_errors = $7,
+      updated_at = $8
+    WHERE id = $9`, [
+    JSON.stringify(updatedOutcomes),
+    fileOverlapCount,
+    scopeAccuracy,
+    timeBalanceRatio,
+    overallSuccess,
+    totalDurationMs,
+    totalErrors,
+    event.timestamp,
+    event.epic_id
+  ]);
 }
-var MAX_INBOX_LIMIT2 = 5, DEFAULT_TTL_SECONDS2 = 3600, ADJECTIVES2, NOUNS2;
-var init_swarm_mail = __esm(() => {
-  init_events();
-  init_streams();
-  init_projections();
-  init_store();
-  ADJECTIVES2 = [
-    "Blue",
-    "Red",
-    "Green",
-    "Gold",
-    "Silver",
-    "Swift",
-    "Bright",
-    "Dark",
-    "Calm",
-    "Bold",
-    "Wise",
-    "Quick",
-    "Warm",
-    "Cool",
-    "Pure",
-    "Wild"
-  ];
-  NOUNS2 = [
-    "Lake",
-    "Stone",
-    "River",
-    "Mountain",
-    "Forest",
-    "Ocean",
-    "Star",
-    "Moon",
-    "Wind",
-    "Fire",
-    "Cloud",
-    "Storm",
-    "Dawn",
-    "Dusk",
-    "Hawk",
-    "Wolf"
-  ];
+async function handleHumanFeedback(db, event) {
+  if (event.type !== "human_feedback")
+    return;
+  await db.query(`UPDATE eval_records SET
+      human_accepted = $1,
+      human_modified = $2,
+      human_notes = $3,
+      updated_at = $4
+    WHERE id = $5`, [
+    event.accepted,
+    event.modified,
+    event.notes || null,
+    event.timestamp,
+    event.epic_id
+  ]);
+}
+async function handleSwarmCheckpointed(db, event) {
+  if (event.type !== "swarm_checkpointed")
+    return;
+  await db.query(`INSERT INTO swarm_contexts (
+      project_key, epic_id, bead_id, strategy, files, dependencies, 
+      directives, recovery, checkpointed_at, updated_at
+    ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $9)
+    ON CONFLICT (project_key, epic_id, bead_id) DO UPDATE SET
+      strategy = EXCLUDED.strategy,
+      files = EXCLUDED.files,
+      dependencies = EXCLUDED.dependencies,
+      directives = EXCLUDED.directives,
+      recovery = EXCLUDED.recovery,
+      checkpointed_at = EXCLUDED.checkpointed_at,
+      updated_at = EXCLUDED.updated_at`, [
+    event.project_key,
+    event.epic_id,
+    event.bead_id,
+    event.strategy,
+    JSON.stringify(event.files),
+    JSON.stringify(event.dependencies),
+    JSON.stringify(event.directives),
+    JSON.stringify(event.recovery),
+    event.timestamp
+  ]);
+}
+async function handleSwarmRecovered(db, event) {
+  if (event.type !== "swarm_recovered")
+    return;
+  await db.query(`UPDATE swarm_contexts SET
+      recovered_at = $1,
+      recovered_from_checkpoint = $2,
+      updated_at = $1
+    WHERE project_key = $3 AND epic_id = $4 AND bead_id = $5`, [
+    event.timestamp,
+    event.recovered_from_checkpoint,
+    event.project_key,
+    event.epic_id,
+    event.bead_id
+  ]);
+}
+function computeFileOverlap(subtasks) {
+  const fileCount = new Map;
+  for (const subtask of subtasks) {
+    for (const file2 of subtask.files) {
+      fileCount.set(file2, (fileCount.get(file2) || 0) + 1);
+    }
+  }
+  return Array.from(fileCount.values()).filter((count) => count > 1).length;
+}
+function computeScopeAccuracy(planned, actual) {
+  if (planned.length === 0)
+    return 1;
+  const plannedSet = new Set(planned);
+  const intersection2 = actual.filter((file2) => plannedSet.has(file2));
+  return intersection2.length / planned.length;
+}
+function computeTimeBalanceRatio(outcomes) {
+  if (outcomes.length === 0)
+    return null;
+  const durations = outcomes.map((o) => o.duration_ms);
+  const max = Math.max(...durations);
+  const min = Math.min(...durations);
+  if (min === 0)
+    return null;
+  return max / min;
+}
+async function registerAgent(projectKey, agentName, options2 = {}, projectPath) {
+  const event = createEvent("agent_registered", {
+    project_key: projectKey,
+    agent_name: agentName,
+    program: options2.program || "opencode",
+    model: options2.model || "unknown",
+    task_description: options2.taskDescription
+  });
+  return appendEvent(event, projectPath);
+}
+async function sendMessage(projectKey, fromAgent, toAgents, subject, body, options2 = {}, projectPath) {
+  const event = createEvent("message_sent", {
+    project_key: projectKey,
+    from_agent: fromAgent,
+    to_agents: toAgents,
+    subject,
+    body,
+    thread_id: options2.threadId,
+    importance: options2.importance || "normal",
+    ack_required: options2.ackRequired || false
+  });
+  return appendEvent(event, projectPath);
+}
+async function reserveFiles(projectKey, agentName, paths, options2 = {}, projectPath) {
+  const ttlSeconds = options2.ttlSeconds || 3600;
+  const event = createEvent("file_reserved", {
+    project_key: projectKey,
+    agent_name: agentName,
+    paths,
+    reason: options2.reason,
+    exclusive: options2.exclusive ?? true,
+    ttl_seconds: ttlSeconds,
+    expires_at: Date.now() + ttlSeconds * 1000
+  });
+  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/@ioredis+commands@1.4.0/node_modules/@ioredis/commands/built/commands.json
@@ -30780,7 +31144,58 @@ var mandateSchemas = {
   QueryMandatesArgsSchema,
   ScoreCalculationResultSchema
 };
+// src/schemas/swarm-context.ts
+init_zod();
+var SwarmStrategySchema = exports_external.enum([
+  "file-based",
+  "feature-based",
+  "risk-based"
+]);
+var SwarmDirectivesSchema = exports_external.object({
+  shared_context: exports_external.string(),
+  skills_to_load: exports_external.array(exports_external.string()).default([]),
+  coordinator_notes: exports_external.string().default("")
+});
+var SwarmRecoverySchema = exports_external.object({
+  last_checkpoint: exports_external.string(),
+  files_modified: exports_external.array(exports_external.string()).default([]),
+  progress_percent: exports_external.number().min(0).max(100).default(0),
+  last_message: exports_external.string().default(""),
+  error_context: exports_external.string().optional()
+});
+var SwarmBeadContextSchema = exports_external.object({
+  id: exports_external.string(),
+  epic_id: exports_external.string(),
+  bead_id: exports_external.string(),
+  strategy: SwarmStrategySchema,
+  files: exports_external.array(exports_external.string()),
+  dependencies: exports_external.array(exports_external.string()).default([]),
+  directives: SwarmDirectivesSchema,
+  recovery: SwarmRecoverySchema,
+  created_at: exports_external.number().int().positive(),
+  updated_at: exports_external.number().int().positive()
+});
+var CreateSwarmContextArgsSchema = SwarmBeadContextSchema.omit({
+  id: true,
+  created_at: true,
+  updated_at: true
+});
+var UpdateSwarmContextArgsSchema = exports_external.object({
+  id: exports_external.string(),
+  recovery: SwarmRecoverySchema.partial().optional(),
+  files: exports_external.array(exports_external.string()).optional(),
+  dependencies: exports_external.array(exports_external.string()).optional(),
+  directives: SwarmDirectivesSchema.partial().optional()
+});
+var QuerySwarmContextsArgsSchema = exports_external.object({
+  epic_id: exports_external.string().optional(),
+  bead_id: exports_external.string().optional(),
+  strategy: SwarmStrategySchema.optional(),
+  has_errors: exports_external.boolean().optional()
+});
 // src/beads.ts
+init_events();
+init_store();
 var beadsWorkingDirectory = null;
 function setBeadsWorkingDirectory(directory) {
   beadsWorkingDirectory = directory;
@@ -30925,7 +31340,15 @@ var beads_create_epic = tool({
       priority: tool.schema.number().min(0).max(3).optional(),
       files: tool.schema.array(tool.schema.string()).optional(),
       id_suffix: tool.schema.string().optional().describe("Custom ID suffix (e.g., 'e2e-test' becomes 'phase-0.e2e-test')")
-    })).describe("Subtasks to create under the epic")
+    })).describe("Subtasks to create under the epic"),
+    strategy: tool.schema.enum(["file-based", "feature-based", "risk-based"]).optional().describe("Decomposition strategy used (default: feature-based)"),
+    task: tool.schema.string().optional().describe("Original task description that was decomposed"),
+    project_key: tool.schema.string().optional().describe("Project path for event emission"),
+    recovery_context: tool.schema.object({
+      shared_context: tool.schema.string().optional(),
+      skills_to_load: tool.schema.array(tool.schema.string()).optional(),
+      coordinator_notes: tool.schema.string().optional()
+    }).optional().describe("Recovery context from checkpoint compaction")
   },
   async execute(args, ctx) {
     const validated = EpicCreateArgsSchema.parse(args);
@@ -30968,6 +31391,27 @@ var beads_create_epic = tool({
         epic,
         subtasks: created.slice(1)
       };
+      if (args.project_key) {
+        try {
+          const event = createEvent("decomposition_generated", {
+            project_key: args.project_key,
+            epic_id: epic.id,
+            task: args.task || validated.epic_title,
+            context: validated.epic_description,
+            strategy: args.strategy || "feature-based",
+            epic_title: validated.epic_title,
+            subtasks: validated.subtasks.map((st) => ({
+              title: st.title,
+              files: st.files || [],
+              priority: st.priority
+            })),
+            recovery_context: args.recovery_context
+          });
+          await appendEvent(event, args.project_key);
+        } catch (error45) {
+          console.warn("[beads_create_epic] Failed to emit DecompositionGeneratedEvent:", error45);
+        }
+      }
       return JSON.stringify(result, null, 2);
     } catch (error45) {
       const rollbackCommands = [];
@@ -31146,7 +31590,7 @@ var beads_sync = tool({
   async execute(args, ctx) {
     const autoPull = args.auto_pull ?? true;
     const TIMEOUT_MS = 30000;
-    const withTimeout = async (promise2, timeoutMs, operation) => {
+    const withTimeout2 = async (promise2, timeoutMs, operation) => {
       let timeoutId;
       const timeoutPromise = new Promise((_, reject) => {
         timeoutId = setTimeout(() => reject(new BeadError(`Operation timed out after ${timeoutMs}ms`, operation)), timeoutMs);
@@ -31159,7 +31603,7 @@ var beads_sync = tool({
         }
       }
     };
-    const flushResult = await withTimeout(runBdCommand(["sync", "--flush-only"]), TIMEOUT_MS, "bd sync --flush-only");
+    const flushResult = await withTimeout2(runBdCommand(["sync", "--flush-only"]), TIMEOUT_MS, "bd sync --flush-only");
     if (flushResult.exitCode !== 0) {
       throw new BeadError(`Failed to flush beads because bd sync failed: ${flushResult.stderr}. Try: Check if .beads/ directory is writable, verify no corrupted JSONL files, or run 'bd list' to test basic beads functionality.`, "bd sync --flush-only", flushResult.exitCode);
     }
@@ -31174,7 +31618,7 @@ var beads_sync = tool({
       if (addResult.exitCode !== 0) {
         throw new BeadError(`Failed to stage beads because git add failed: ${addResult.stderr}. Try: Check if .beads/ directory exists, verify git is initialized with 'git status', or check for .gitignore patterns blocking .beads/.`, "git add .beads/", addResult.exitCode);
       }
-      const commitResult = await withTimeout(runGitCommand(["commit", "-m", "chore: sync beads"]), TIMEOUT_MS, "git commit");
+      const commitResult = await withTimeout2(runGitCommand(["commit", "-m", "chore: sync beads"]), TIMEOUT_MS, "git commit");
       if (commitResult.exitCode !== 0 && !commitResult.stdout.includes("nothing to commit")) {
         throw new BeadError(`Failed to commit beads because git commit failed: ${commitResult.stderr}. Try: Check git config (user.name, user.email) with 'git config --list', verify working tree is clean, or check for pre-commit hooks blocking commit.`, "git commit", commitResult.exitCode);
       }
@@ -31203,7 +31647,7 @@ var beads_sync = tool({
           console.warn(`[beads] Stash failed (${stashResult.stderr}), attempting pull anyway...`);
         }
       }
-      const pullResult = await withTimeout(runGitCommand(["pull", "--rebase"]), TIMEOUT_MS, "git pull --rebase");
+      const pullResult = await withTimeout2(runGitCommand(["pull", "--rebase"]), TIMEOUT_MS, "git pull --rebase");
       if (didStash) {
         console.warn("[beads] Restoring stashed changes...");
         const unstashResult = await runGitCommand(["stash", "pop"]);
@@ -31217,12 +31661,12 @@ var beads_sync = tool({
       if (pullResult.exitCode !== 0) {
         throw new BeadError(`Failed to pull because git pull --rebase failed: ${pullResult.stderr}. Try: Resolve merge conflicts manually with 'git status', check if remote is accessible with 'git remote -v', or use skip_verification to bypass automatic pull.`, "git pull --rebase", pullResult.exitCode);
       }
-      const importResult = await withTimeout(runBdCommand(["sync", "--import-only"]), TIMEOUT_MS, "bd sync --import-only");
+      const importResult = await withTimeout2(runBdCommand(["sync", "--import-only"]), TIMEOUT_MS, "bd sync --import-only");
       if (importResult.exitCode !== 0) {
         console.warn(`[beads] Import warning: ${importResult.stderr}`);
       }
     }
-    const pushResult = await withTimeout(runGitCommand(["push"]), TIMEOUT_MS, "git push");
+    const pushResult = await withTimeout2(runGitCommand(["push"]), TIMEOUT_MS, "git push");
     if (pushResult.exitCode !== 0) {
       throw new BeadError(`Failed to push because git push failed: ${pushResult.stderr}. Try: Check if remote branch is up to date with 'git pull --rebase', verify push permissions, check remote URL with 'git remote -v', or force push with 'git push --force-with-lease' if safe.`, "git push", pushResult.exitCode);
     }
@@ -34182,20 +34626,29 @@ Only modify these files. Need others? Message the coordinator.
 
 {error_context}
 
-## [MANDATORY: SWARM MAIL]
+## [MANDATORY: SWARM MAIL INITIALIZATION]
 
-**YOU MUST USE SWARM MAIL FOR ALL COORDINATION.** This is non-negotiable.
+**CRITICAL: YOU MUST INITIALIZE SWARM MAIL BEFORE DOING ANY WORK.**
 
-### Initialize FIRST (before any work)
-\`\`\`
-swarmmail_init(project_path="$PWD", task_description="{subtask_title}")
-\`\`\`
+This is your FIRST step - before reading files, before planning, before ANY other action.
 
-### Reserve Files (if not already reserved by coordinator)
+### Step 1: Initialize (REQUIRED - DO THIS FIRST)
 \`\`\`
-swarmmail_reserve(paths=[...files...], reason="{bead_id}: {subtask_title}")
+swarmmail_init(project_path="{project_path}", task_description="{bead_id}: {subtask_title}")
 \`\`\`
 
+**This registers you with the coordination system and enables:**
+- File reservation tracking
+- Inter-agent communication
+- Progress monitoring
+- Conflict detection
+
+**If you skip this step, your work will not be tracked and swarm_complete will fail.**
+
+## [SWARM MAIL USAGE]
+
+After initialization, use Swarm Mail for coordination:
+
 ### Check Inbox Regularly
 \`\`\`
 swarmmail_inbox()  # Check for coordinator messages
@@ -34249,14 +34702,17 @@ As you work, note reusable patterns, best practices, or domain insights:
 - Skills make swarms smarter over time
 
 ## [WORKFLOW]
-1. **swarmmail_init** - Initialize session FIRST
+1. **swarmmail_init** - Initialize session (MANDATORY FIRST STEP)
 2. Read assigned files
 3. Implement changes
 4. **swarmmail_send** - Report progress to coordinator
 5. Verify (typecheck)
 6. **swarm_complete** - Mark done, release reservations
 
-**CRITICAL: Never work silently. Send progress updates via swarmmail_send every significant milestone.**
+**CRITICAL REQUIREMENTS:**
+- Step 1 (swarmmail_init) is NON-NEGOTIABLE - do it before anything else
+- Never work silently - send progress updates via swarmmail_send every significant milestone
+- If you complete without initializing, swarm_complete will detect this and warn/fail
 
 Begin now.`;
 var EVALUATION_PROMPT = `Evaluate the work completed for this subtask.
@@ -34300,7 +34756,33 @@ function formatSubtaskPromptV2(params) {
 `) : "(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);
+  let recoverySection = "";
+  if (params.recovery_context) {
+    const sections = [];
+    if (params.recovery_context.shared_context) {
+      sections.push(`### Recovery Context
+${params.recovery_context.shared_context}`);
+    }
+    if (params.recovery_context.skills_to_load && params.recovery_context.skills_to_load.length > 0) {
+      sections.push(`### Skills to Load
+Before starting work, load these skills for specialized guidance:
+${params.recovery_context.skills_to_load.map((s) => `- skills_use(name="${s}")`).join(`
+`)}`);
+    }
+    if (params.recovery_context.coordinator_notes) {
+      sections.push(`### Coordinator Notes
+${params.recovery_context.coordinator_notes}`);
+    }
+    if (sections.length > 0) {
+      recoverySection = `
+## [RECOVERY CONTEXT]
+
+${sections.join(`
+
+`)}`;
+    }
+  }
+  return SUBTASK_PROMPT_V2.replace(/{bead_id}/g, params.bead_id).replace(/{epic_id}/g, params.epic_id).replace(/{project_path}/g, params.project_path || "$PWD").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 + recoverySection);
 }
 function formatSubtaskPrompt(params) {
   const fileList = params.files.map((f) => `- \`${f}\``).join(`
@@ -34321,7 +34803,8 @@ var swarm_subtask_prompt = tool({
     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")
+    shared_context: tool.schema.string().optional().describe("Context shared across all agents"),
+    project_path: tool.schema.string().optional().describe("Absolute project path for swarmmail_init")
   },
   async execute(args) {
     const prompt = formatSubtaskPrompt({
@@ -34337,14 +34820,20 @@ var swarm_subtask_prompt = tool({
   }
 });
 var swarm_spawn_subtask = tool({
-  description: "Prepare a subtask for spawning. Returns prompt with Agent Mail/beads instructions.",
+  description: "Prepare a subtask for spawning. Returns prompt with Agent Mail/beads instructions. IMPORTANT: Pass project_path for swarmmail_init.",
   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")
+    shared_context: tool.schema.string().optional().describe("Context shared across all agents"),
+    project_path: tool.schema.string().optional().describe("Absolute project path for swarmmail_init (REQUIRED for tracking)"),
+    recovery_context: tool.schema.object({
+      shared_context: tool.schema.string().optional(),
+      skills_to_load: tool.schema.array(tool.schema.string()).optional(),
+      coordinator_notes: tool.schema.string().optional()
+    }).optional().describe("Recovery context from checkpoint compaction")
   },
   async execute(args) {
     const prompt = formatSubtaskPromptV2({
@@ -34353,13 +34842,17 @@ var swarm_spawn_subtask = tool({
       subtask_title: args.subtask_title,
       subtask_description: args.subtask_description || "",
       files: args.files,
-      shared_context: args.shared_context
+      shared_context: args.shared_context,
+      project_path: args.project_path,
+      recovery_context: args.recovery_context
     });
     return JSON.stringify({
       prompt,
       bead_id: args.bead_id,
       epic_id: args.epic_id,
-      files: args.files
+      files: args.files,
+      project_path: args.project_path,
+      recovery_context: args.recovery_context
     }, null, 2);
   }
 });
@@ -34481,6 +34974,9 @@ var promptTools = {
 init_dist();
 init_zod();
 init_swarm_mail();
+init_projections();
+init_events();
+init_store();
 init_learning();
 init_skills();
 async function queryEpicSubtasks(epicId) {
@@ -34910,7 +35406,57 @@ var swarm_progress = tool({
       threadId: epicId,
       importance: args.status === "blocked" ? "high" : "normal"
     });
-    return `Progress reported: ${args.status}${args.progress_percent !== undefined ? ` (${args.progress_percent}%)` : ""}`;
+    let checkpointCreated = false;
+    if (args.progress_percent !== undefined && args.files_touched && args.files_touched.length > 0) {
+      const milestones = [25, 50, 75];
+      if (milestones.includes(args.progress_percent)) {
+        try {
+          const checkpoint = {
+            epic_id: epicId,
+            bead_id: args.bead_id,
+            strategy: "file-based",
+            files: args.files_touched,
+            dependencies: [],
+            directives: {},
+            recovery: {
+              last_checkpoint: Date.now(),
+              files_modified: args.files_touched,
+              progress_percent: args.progress_percent,
+              last_message: args.message
+            }
+          };
+          const event = createEvent("swarm_checkpointed", {
+            project_key: args.project_key,
+            ...checkpoint
+          });
+          await appendEvent(event, args.project_key);
+          const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_streams(), exports_streams));
+          const db = await getDatabase2(args.project_key);
+          const now = Date.now();
+          await db.query(`INSERT INTO swarm_contexts (id, epic_id, bead_id, strategy, files, dependencies, directives, recovery, created_at, updated_at)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+             ON CONFLICT (id) DO UPDATE SET
+               files = EXCLUDED.files,
+               recovery = EXCLUDED.recovery,
+               updated_at = EXCLUDED.updated_at`, [
+            args.bead_id,
+            epicId,
+            args.bead_id,
+            checkpoint.strategy,
+            JSON.stringify(checkpoint.files),
+            JSON.stringify(checkpoint.dependencies),
+            JSON.stringify(checkpoint.directives),
+            JSON.stringify(checkpoint.recovery),
+            now,
+            now
+          ]);
+          checkpointCreated = true;
+        } catch (error45) {
+          console.warn(`[swarm_progress] Auto-checkpoint failed at ${args.progress_percent}%:`, error45);
+        }
+      }
+    }
+    return `Progress reported: ${args.status}${args.progress_percent !== undefined ? ` (${args.progress_percent}%)` : ""}${checkpointCreated ? " [checkpoint created]" : ""}`;
   }
 });
 var swarm_broadcast = tool({
@@ -34970,125 +35516,205 @@ var swarm_complete = tool({
     evaluation: tool.schema.string().optional().describe("Self-evaluation JSON (Evaluation schema)"),
     files_touched: tool.schema.array(tool.schema.string()).optional().describe("Files modified - will be verified (UBS, typecheck, tests)"),
     skip_ubs_scan: tool.schema.boolean().optional().describe("Skip UBS bug scan (default: false)"),
-    skip_verification: tool.schema.boolean().optional().describe("Skip ALL verification (UBS, typecheck, tests). Use sparingly! (default: false)")
+    skip_verification: tool.schema.boolean().optional().describe("Skip ALL verification (UBS, typecheck, tests). Use sparingly! (default: false)"),
+    planned_files: tool.schema.array(tool.schema.string()).optional().describe("Files that were originally planned to be modified"),
+    start_time: tool.schema.number().optional().describe("Task start timestamp (Unix ms) for duration calculation"),
+    error_count: tool.schema.number().optional().describe("Number of errors encountered during task"),
+    retry_count: tool.schema.number().optional().describe("Number of retry attempts during task")
   },
   async execute(args) {
-    let verificationResult = null;
-    if (!args.skip_verification && args.files_touched?.length) {
-      verificationResult = await runVerificationGate(args.files_touched, args.skip_ubs_scan ?? false);
-      if (!verificationResult.passed) {
-        return JSON.stringify({
-          success: false,
-          error: "Verification Gate FAILED - fix issues before completing",
-          verification: {
-            passed: false,
-            summary: verificationResult.summary,
-            blockers: verificationResult.blockers,
-            steps: verificationResult.steps.map((s) => ({
-              name: s.name,
-              passed: s.passed,
-              skipped: s.skipped,
-              skipReason: s.skipReason,
-              error: s.error?.slice(0, 200)
-            }))
-          },
-          hint: verificationResult.blockers.length > 0 ? `Fix these issues: ${verificationResult.blockers.map((b, i) => `${i + 1}. ${b}`).join(", ")}. Use skip_verification=true only as last resort.` : "Fix the failing checks and try again. Use skip_verification=true only as last resort.",
-          gate_function: "IDENTIFY → RUN → READ → VERIFY → CLAIM (you are at VERIFY, claim blocked)"
-        }, null, 2);
+    const epicId = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
+    try {
+      const projectKey = args.project_key.replace(/\//g, "-").replace(/\\/g, "-");
+      let agentRegistered = false;
+      let registrationWarning = "";
+      try {
+        const agent = await getAgent(projectKey, args.agent_name, args.project_key);
+        agentRegistered = agent !== null;
+        if (!agentRegistered) {
+          registrationWarning = `⚠️  WARNING: Agent '${args.agent_name}' was NOT registered in swarm-mail for project '${projectKey}'.
+
+This usually means you skipped the MANDATORY swarmmail_init step.
+
+**Impact:**
+- Your work was not tracked in the coordination system
+- File reservations may not have been managed
+- Other agents couldn't coordinate with you
+- Learning/eval data may be incomplete
+
+**Next time:** Run swarmmail_init(project_path="${args.project_key}", task_description="<task>") FIRST, before any other work.
+
+Continuing with completion, but this should be fixed for future subtasks.`;
+          console.warn(`[swarm_complete] ${registrationWarning}`);
+        }
+      } catch (error45) {
+        console.warn(`[swarm_complete] Could not verify agent registration:`, error45);
+        registrationWarning = `ℹ️  Could not verify swarm-mail registration (database may not be available). Consider running swarmmail_init next time.`;
       }
-    }
-    let ubsResult = null;
-    if (!args.skip_verification && !verificationResult && args.files_touched?.length && !args.skip_ubs_scan) {
-      ubsResult = await runUbsScan(args.files_touched);
-      if (ubsResult && ubsResult.summary.critical > 0) {
-        return JSON.stringify({
-          success: false,
-          error: `UBS found ${ubsResult.summary.critical} critical bug(s) that must be fixed before completing`,
-          ubs_scan: {
-            critical_count: ubsResult.summary.critical,
-            bugs: ubsResult.bugs.filter((b) => b.severity === "critical")
-          },
-          hint: `Fix these critical bugs: ${ubsResult.bugs.filter((b) => b.severity === "critical").map((b) => `${b.file}:${b.line} - ${b.message}`).slice(0, 3).join("; ")}. Try: Run 'ubs scan ${args.files_touched?.join(" ") || "."} --json' for full report, fix reported issues, or use skip_ubs_scan=true to bypass (not recommended).`
-        }, null, 2);
+      let verificationResult = null;
+      if (!args.skip_verification && args.files_touched?.length) {
+        verificationResult = await runVerificationGate(args.files_touched, args.skip_ubs_scan ?? false);
+        if (!verificationResult.passed) {
+          return JSON.stringify({
+            success: false,
+            error: "Verification Gate FAILED - fix issues before completing",
+            verification: {
+              passed: false,
+              summary: verificationResult.summary,
+              blockers: verificationResult.blockers,
+              steps: verificationResult.steps.map((s) => ({
+                name: s.name,
+                passed: s.passed,
+                skipped: s.skipped,
+                skipReason: s.skipReason,
+                error: s.error?.slice(0, 200)
+              }))
+            },
+            hint: verificationResult.blockers.length > 0 ? `Fix these issues: ${verificationResult.blockers.map((b, i) => `${i + 1}. ${b}`).join(", ")}. Use skip_verification=true only as last resort.` : "Fix the failing checks and try again. Use skip_verification=true only as last resort.",
+            gate_function: "IDENTIFY → RUN → READ → VERIFY → CLAIM (you are at VERIFY, claim blocked)"
+          }, null, 2);
+        }
+      }
+      let ubsResult = null;
+      if (!args.skip_verification && !verificationResult && args.files_touched?.length && !args.skip_ubs_scan) {
+        ubsResult = await runUbsScan(args.files_touched);
+        if (ubsResult && ubsResult.summary.critical > 0) {
+          return JSON.stringify({
+            success: false,
+            error: `UBS found ${ubsResult.summary.critical} critical bug(s) that must be fixed before completing`,
+            ubs_scan: {
+              critical_count: ubsResult.summary.critical,
+              bugs: ubsResult.bugs.filter((b) => b.severity === "critical")
+            },
+            hint: `Fix these critical bugs: ${ubsResult.bugs.filter((b) => b.severity === "critical").map((b) => `${b.file}:${b.line} - ${b.message}`).slice(0, 3).join("; ")}. Try: Run 'ubs scan ${args.files_touched?.join(" ") || "."} --json' for full report, fix reported issues, or use skip_ubs_scan=true to bypass (not recommended).`
+          }, null, 2);
+        }
+      }
+      let parsedEvaluation;
+      if (args.evaluation) {
+        try {
+          parsedEvaluation = EvaluationSchema.parse(JSON.parse(args.evaluation));
+        } catch (error45) {
+          return JSON.stringify({
+            success: false,
+            error: "Invalid evaluation format",
+            details: error45 instanceof exports_external.ZodError ? error45.issues : String(error45)
+          }, null, 2);
+        }
+        if (!parsedEvaluation.passed) {
+          return JSON.stringify({
+            success: false,
+            error: "Self-evaluation failed",
+            retry_suggestion: parsedEvaluation.retry_suggestion,
+            feedback: parsedEvaluation.overall_feedback
+          }, null, 2);
+        }
+      }
+      const closeResult = await Bun.$`bd close ${args.bead_id} --reason ${args.summary} --json`.quiet().nothrow();
+      if (closeResult.exitCode !== 0) {
+        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.`);
       }
-    }
-    let parsedEvaluation;
-    if (args.evaluation) {
       try {
-        parsedEvaluation = EvaluationSchema.parse(JSON.parse(args.evaluation));
+        const epicId3 = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
+        const durationMs2 = args.start_time ? Date.now() - args.start_time : 0;
+        const event = createEvent("subtask_outcome", {
+          project_key: args.project_key,
+          epic_id: epicId3,
+          bead_id: args.bead_id,
+          planned_files: args.planned_files || [],
+          actual_files: args.files_touched || [],
+          duration_ms: durationMs2,
+          error_count: args.error_count || 0,
+          retry_count: args.retry_count || 0,
+          success: true
+        });
+        await appendEvent(event, args.project_key);
       } catch (error45) {
-        return JSON.stringify({
-          success: false,
-          error: "Invalid evaluation format",
-          details: error45 instanceof exports_external.ZodError ? error45.issues : String(error45)
-        }, null, 2);
+        console.warn("[swarm_complete] Failed to emit SubtaskOutcomeEvent:", error45);
       }
-      if (!parsedEvaluation.passed) {
-        return JSON.stringify({
-          success: false,
-          error: "Self-evaluation failed",
-          retry_suggestion: parsedEvaluation.retry_suggestion,
-          feedback: parsedEvaluation.overall_feedback
-        }, null, 2);
+      let capturedStrategy;
+      const durationMs = args.start_time ? Date.now() - args.start_time : 0;
+      const memoryInfo = formatMemoryStoreOnSuccess(args.bead_id, args.summary, args.files_touched || [], capturedStrategy);
+      let memoryStored = false;
+      let memoryError;
+      try {
+        const memoryAvailable = await isToolAvailable("semantic-memory");
+        if (memoryAvailable) {
+          const storeResult = await Bun.$`semantic-memory store ${memoryInfo.information} --metadata ${memoryInfo.metadata}`.quiet().nothrow();
+          if (storeResult.exitCode === 0) {
+            memoryStored = true;
+            console.log(`[swarm_complete] Stored learning for ${args.bead_id} in semantic-memory`);
+          } else {
+            memoryError = `semantic-memory store failed: ${storeResult.stderr.toString().slice(0, 200)}`;
+            console.warn(`[swarm_complete] ${memoryError}`);
+          }
+        } else {
+          memoryError = "semantic-memory not available - learning stored in-memory only";
+          warnMissingTool("semantic-memory");
+        }
+      } catch (error45) {
+        memoryError = `Failed to store memory: ${error45 instanceof Error ? error45.message : String(error45)}`;
+        console.warn(`[swarm_complete] ${memoryError}`);
       }
-    }
-    const closeResult = await Bun.$`bd close ${args.bead_id} --reason ${args.summary} --json`.quiet().nothrow();
-    if (closeResult.exitCode !== 0) {
-      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({
+      try {
+        await releaseSwarmFiles({
+          projectPath: args.project_key,
+          agentName: args.agent_name
+        });
+      } catch (error45) {
+        console.warn(`[swarm] Failed to release file reservations for ${args.agent_name}:`, error45);
+      }
+      const epicId2 = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
+      const completionBody = [
+        `## Subtask Complete: ${args.bead_id}`,
+        "",
+        `**Summary**: ${args.summary}`,
+        "",
+        parsedEvaluation ? `**Self-Evaluation**: ${parsedEvaluation.passed ? "PASSED" : "FAILED"}` : "",
+        parsedEvaluation?.overall_feedback ? `**Feedback**: ${parsedEvaluation.overall_feedback}` : "",
+        "",
+        `**Memory Capture**: ${memoryStored ? "✓ Stored in semantic-memory" : `✗ ${memoryError || "Failed"}`}`
+      ].filter(Boolean).join(`
+`);
+      await sendSwarmMessage({
         projectPath: args.project_key,
-        agentName: args.agent_name
+        fromAgent: args.agent_name,
+        toAgents: [],
+        subject: `Complete: ${args.bead_id}`,
+        body: completionBody,
+        threadId: epicId2,
+        importance: "normal"
       });
-    } catch (error45) {
-      console.warn(`[swarm] Failed to release file reservations for ${args.agent_name}:`, error45);
-    }
-    const epicId = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
-    const completionBody = [
-      `## Subtask Complete: ${args.bead_id}`,
-      "",
-      `**Summary**: ${args.summary}`,
-      "",
-      parsedEvaluation ? `**Self-Evaluation**: ${parsedEvaluation.passed ? "PASSED" : "FAILED"}` : "",
-      parsedEvaluation?.overall_feedback ? `**Feedback**: ${parsedEvaluation.overall_feedback}` : ""
-    ].filter(Boolean).join(`
-`);
-    await sendSwarmMessage({
-      projectPath: args.project_key,
-      fromAgent: args.agent_name,
-      toAgents: [],
-      subject: `Complete: ${args.bead_id}`,
-      body: completionBody,
-      threadId: epicId,
-      importance: "normal"
-    });
-    const response = {
-      success: true,
-      bead_id: args.bead_id,
-      closed: true,
-      reservations_released: true,
-      message_sent: true,
-      verification_gate: verificationResult ? {
-        passed: true,
-        summary: verificationResult.summary,
-        steps: verificationResult.steps.map((s) => ({
-          name: s.name,
-          passed: s.passed,
-          skipped: s.skipped,
-          skipReason: s.skipReason
-        }))
-      } : args.skip_verification ? { skipped: true, reason: "skip_verification=true" } : { skipped: true, reason: "no files_touched provided" },
-      ubs_scan: ubsResult ? {
-        ran: true,
-        bugs_found: ubsResult.summary.total,
-        summary: ubsResult.summary,
-        warnings: ubsResult.bugs.filter((b) => b.severity !== "critical")
-      } : verificationResult ? { ran: true, included_in_verification_gate: true } : {
-        ran: false,
-        reason: args.skip_ubs_scan ? "skipped" : "no files or ubs unavailable"
-      },
-      learning_prompt: `## Reflection
+      const response = {
+        success: true,
+        bead_id: args.bead_id,
+        closed: true,
+        reservations_released: true,
+        message_sent: true,
+        agent_registration: {
+          verified: agentRegistered,
+          warning: registrationWarning || undefined
+        },
+        verification_gate: verificationResult ? {
+          passed: true,
+          summary: verificationResult.summary,
+          steps: verificationResult.steps.map((s) => ({
+            name: s.name,
+            passed: s.passed,
+            skipped: s.skipped,
+            skipReason: s.skipReason
+          }))
+        } : args.skip_verification ? { skipped: true, reason: "skip_verification=true" } : { skipped: true, reason: "no files_touched provided" },
+        ubs_scan: ubsResult ? {
+          ran: true,
+          bugs_found: ubsResult.summary.total,
+          summary: ubsResult.summary,
+          warnings: ubsResult.bugs.filter((b) => b.severity !== "critical")
+        } : verificationResult ? { ran: true, included_in_verification_gate: true } : {
+          ran: false,
+          reason: args.skip_ubs_scan ? "skipped" : "no files or ubs unavailable"
+        },
+        learning_prompt: `## Reflection
 
 Did you learn anything reusable during this subtask? Consider:
 
@@ -35100,9 +35726,81 @@ 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"}`,
-      memory_store: formatMemoryStoreOnSuccess(args.bead_id, args.summary, args.files_touched || [])
-    };
-    return JSON.stringify(response, null, 2);
+        memory_capture: {
+          attempted: true,
+          stored: memoryStored,
+          error: memoryError,
+          information: memoryInfo.information,
+          metadata: memoryInfo.metadata,
+          note: memoryStored ? "Learning automatically stored in semantic-memory" : `Failed to store: ${memoryError}. Learning lost unless semantic-memory is available.`
+        }
+      };
+      return JSON.stringify(response, null, 2);
+    } catch (error45) {
+      const errorMessage = error45 instanceof Error ? error45.message : String(error45);
+      const errorStack = error45 instanceof Error ? error45.stack : undefined;
+      let failedStep = "unknown";
+      if (errorMessage.includes("verification")) {
+        failedStep = "Verification Gate (UBS/typecheck/tests)";
+      } else if (errorMessage.includes("UBS") || errorMessage.includes("ubs")) {
+        failedStep = "UBS scan";
+      } else if (errorMessage.includes("evaluation")) {
+        failedStep = "Self-evaluation parsing";
+      } else if (errorMessage.includes("bead") || errorMessage.includes("close")) {
+        failedStep = "Bead close";
+      } else if (errorMessage.includes("memory") || errorMessage.includes("semantic")) {
+        failedStep = "Memory storage (non-fatal)";
+      } else if (errorMessage.includes("reservation") || errorMessage.includes("release")) {
+        failedStep = "File reservation release";
+      } else if (errorMessage.includes("message") || errorMessage.includes("mail")) {
+        failedStep = "Swarm mail notification";
+      }
+      const errorBody = [
+        `## ⚠️ SWARM_COMPLETE FAILED`,
+        "",
+        `**Bead**: ${args.bead_id}`,
+        `**Agent**: ${args.agent_name}`,
+        `**Failed Step**: ${failedStep}`,
+        "",
+        `### Error Message`,
+        "```",
+        errorMessage,
+        "```",
+        "",
+        errorStack ? `### Stack Trace
+\`\`\`
+${errorStack.slice(0, 1000)}
+\`\`\`
+` : "",
+        `### Context`,
+        `- **Summary**: ${args.summary}`,
+        `- **Files touched**: ${args.files_touched?.length ? args.files_touched.join(", ") : "none"}`,
+        `- **Skip UBS**: ${args.skip_ubs_scan ?? false}`,
+        `- **Skip verification**: ${args.skip_verification ?? false}`,
+        "",
+        `### Recovery Actions`,
+        "1. Check error message for specific issue",
+        "2. Review failed step (UBS scan, typecheck, bead close, etc.)",
+        "3. Fix underlying issue or use skip flags if appropriate",
+        "4. Retry swarm_complete after fixing"
+      ].filter(Boolean).join(`
+`);
+      try {
+        await sendSwarmMessage({
+          projectPath: args.project_key,
+          fromAgent: args.agent_name,
+          toAgents: [],
+          subject: `FAILED: swarm_complete for ${args.bead_id}`,
+          body: errorBody,
+          threadId: epicId,
+          importance: "urgent"
+        });
+      } catch (mailError) {
+        console.error(`[swarm_complete] CRITICAL: Failed to notify coordinator of failure for ${args.bead_id}:`, mailError);
+        console.error(`[swarm_complete] Original error:`, error45);
+      }
+      throw error45;
+    }
   }
 });
 var swarm_record_outcome = tool({
@@ -35330,6 +36028,147 @@ var swarm_check_strikes = tool({
     }
   }
 });
+var swarm_checkpoint = tool({
+  description: "Checkpoint swarm context for recovery. Records current state for crash recovery. Non-fatal errors.",
+  args: {
+    project_key: tool.schema.string().describe("Project path"),
+    agent_name: tool.schema.string().describe("Agent name"),
+    bead_id: tool.schema.string().describe("Subtask bead ID"),
+    epic_id: tool.schema.string().describe("Epic bead ID"),
+    files_modified: tool.schema.array(tool.schema.string()).describe("Files modified so far"),
+    progress_percent: tool.schema.number().min(0).max(100).describe("Current progress"),
+    directives: tool.schema.object({
+      shared_context: tool.schema.string().optional(),
+      skills_to_load: tool.schema.array(tool.schema.string()).optional(),
+      coordinator_notes: tool.schema.string().optional()
+    }).optional().describe("Coordinator directives for this subtask"),
+    error_context: tool.schema.string().optional().describe("Error context if checkpoint is during error handling")
+  },
+  async execute(args) {
+    try {
+      const checkpoint = {
+        epic_id: args.epic_id,
+        bead_id: args.bead_id,
+        strategy: "file-based",
+        files: args.files_modified,
+        dependencies: [],
+        directives: args.directives || {},
+        recovery: {
+          last_checkpoint: Date.now(),
+          files_modified: args.files_modified,
+          progress_percent: args.progress_percent,
+          error_context: args.error_context
+        }
+      };
+      const event = createEvent("swarm_checkpointed", {
+        project_key: args.project_key,
+        epic_id: args.epic_id,
+        bead_id: args.bead_id,
+        strategy: checkpoint.strategy,
+        files: checkpoint.files,
+        dependencies: checkpoint.dependencies,
+        directives: checkpoint.directives,
+        recovery: checkpoint.recovery
+      });
+      await appendEvent(event, args.project_key);
+      const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_streams(), exports_streams));
+      const db = await getDatabase2(args.project_key);
+      const now = Date.now();
+      await db.query(`INSERT INTO swarm_contexts (id, epic_id, bead_id, strategy, files, dependencies, directives, recovery, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+         ON CONFLICT (id) DO UPDATE SET
+           files = EXCLUDED.files,
+           recovery = EXCLUDED.recovery,
+           updated_at = EXCLUDED.updated_at`, [
+        args.bead_id,
+        args.epic_id,
+        args.bead_id,
+        checkpoint.strategy,
+        JSON.stringify(checkpoint.files),
+        JSON.stringify(checkpoint.dependencies),
+        JSON.stringify(checkpoint.directives),
+        JSON.stringify(checkpoint.recovery),
+        now,
+        now
+      ]);
+      return JSON.stringify({
+        success: true,
+        checkpoint_timestamp: now,
+        summary: `Checkpoint saved for ${args.bead_id} at ${args.progress_percent}%`,
+        bead_id: args.bead_id,
+        epic_id: args.epic_id,
+        files_tracked: args.files_modified.length
+      }, null, 2);
+    } catch (error45) {
+      console.warn(`[swarm_checkpoint] Failed to checkpoint ${args.bead_id}:`, error45);
+      return JSON.stringify({
+        success: false,
+        warning: "Checkpoint failed but continuing",
+        error: error45 instanceof Error ? error45.message : String(error45),
+        bead_id: args.bead_id,
+        note: "This is non-fatal. Work can continue without checkpoint."
+      }, null, 2);
+    }
+  }
+});
+var swarm_recover = tool({
+  description: "Recover swarm context from last checkpoint. Returns context or null if not found.",
+  args: {
+    project_key: tool.schema.string().describe("Project path"),
+    epic_id: tool.schema.string().describe("Epic bead ID to recover")
+  },
+  async execute(args) {
+    try {
+      const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_streams(), exports_streams));
+      const db = await getDatabase2(args.project_key);
+      const result = await db.query(`SELECT * FROM swarm_contexts 
+         WHERE epic_id = $1 
+         ORDER BY updated_at DESC 
+         LIMIT 1`, [args.epic_id]);
+      if (result.rows.length === 0) {
+        return JSON.stringify({
+          found: false,
+          message: `No checkpoint found for epic ${args.epic_id}`,
+          epic_id: args.epic_id
+        }, null, 2);
+      }
+      const row = result.rows[0];
+      const context = {
+        id: row.id,
+        epic_id: row.epic_id,
+        bead_id: row.bead_id,
+        strategy: row.strategy,
+        files: JSON.parse(row.files),
+        dependencies: JSON.parse(row.dependencies),
+        directives: JSON.parse(row.directives),
+        recovery: JSON.parse(row.recovery),
+        created_at: row.created_at,
+        updated_at: row.updated_at
+      };
+      const event = createEvent("swarm_recovered", {
+        project_key: args.project_key,
+        epic_id: args.epic_id,
+        bead_id: context.bead_id,
+        recovered_from_checkpoint: context.recovery.last_checkpoint
+      });
+      await appendEvent(event, args.project_key);
+      return JSON.stringify({
+        found: true,
+        context,
+        summary: `Recovered checkpoint from ${new Date(context.updated_at).toISOString()}`,
+        age_seconds: Math.round((Date.now() - context.updated_at) / 1000)
+      }, null, 2);
+    } catch (error45) {
+      console.warn(`[swarm_recover] Failed to recover context for ${args.epic_id}:`, error45);
+      return JSON.stringify({
+        found: false,
+        error: error45 instanceof Error ? error45.message : String(error45),
+        message: `Recovery failed for epic ${args.epic_id}`,
+        epic_id: args.epic_id
+      }, null, 2);
+    }
+  }
+});
 var swarm_learn = tool({
   description: `Analyze completed work and optionally create a skill from learned patterns.
 
@@ -35470,6 +36309,8 @@ var orchestrateTools = {
   swarm_get_error_context,
   swarm_resolve_error,
   swarm_check_strikes,
+  swarm_checkpoint,
+  swarm_recover,
   swarm_learn
 };
 
@@ -36564,6 +37405,172 @@ var mandateTools = {
   mandate_list,
   mandate_stats
 };
+
+// src/output-guardrails.ts
+var DEFAULT_GUARDRAIL_CONFIG = {
+  defaultMaxChars: 32000,
+  toolLimits: {
+    "repo-autopsy_file": 64000,
+    "repo-autopsy_search": 64000,
+    "repo-autopsy_exports_map": 64000,
+    "context7_get-library-docs": 64000,
+    cass_view: 64000,
+    cass_search: 48000,
+    skills_read: 48000,
+    "repo-autopsy_structure": 24000,
+    "repo-autopsy_stats": 16000,
+    cass_stats: 8000
+  },
+  skipTools: [
+    "beads_create",
+    "beads_create_epic",
+    "beads_query",
+    "beads_update",
+    "beads_close",
+    "beads_start",
+    "beads_ready",
+    "beads_sync",
+    "agentmail_init",
+    "agentmail_send",
+    "agentmail_inbox",
+    "agentmail_read_message",
+    "agentmail_summarize_thread",
+    "agentmail_reserve",
+    "agentmail_release",
+    "agentmail_ack",
+    "swarmmail_init",
+    "swarmmail_send",
+    "swarmmail_inbox",
+    "swarmmail_read_message",
+    "swarmmail_reserve",
+    "swarmmail_release",
+    "swarmmail_ack",
+    "structured_extract_json",
+    "structured_validate",
+    "structured_parse_evaluation",
+    "structured_parse_decomposition",
+    "structured_parse_bead_tree",
+    "swarm_select_strategy",
+    "swarm_plan_prompt",
+    "swarm_decompose",
+    "swarm_validate_decomposition",
+    "swarm_status",
+    "swarm_progress",
+    "swarm_complete",
+    "swarm_record_outcome",
+    "swarm_subtask_prompt",
+    "swarm_spawn_subtask",
+    "swarm_complete_subtask",
+    "swarm_evaluation_prompt",
+    "mandate_file",
+    "mandate_vote",
+    "mandate_query",
+    "mandate_list",
+    "mandate_stats"
+  ]
+};
+function findMatchingBrace(text, startIdx) {
+  const openChar = text[startIdx];
+  const closeChar = openChar === "{" ? "}" : "]";
+  let depth = 1;
+  for (let i = startIdx + 1;i < text.length; i++) {
+    if (text[i] === openChar) {
+      depth++;
+    } else if (text[i] === closeChar) {
+      depth--;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function truncateWithBoundaries(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  let truncateAt = maxChars;
+  const beforeTruncate = text.slice(0, maxChars);
+  const lastOpenBrace = Math.max(beforeTruncate.lastIndexOf("{"), beforeTruncate.lastIndexOf("["));
+  const lastCloseBrace = Math.max(beforeTruncate.lastIndexOf("}"), beforeTruncate.lastIndexOf("]"));
+  if (lastOpenBrace > lastCloseBrace) {
+    const matchingClose = findMatchingBrace(text, lastOpenBrace);
+    if (matchingClose !== -1 && matchingClose < maxChars * 1.2) {
+      truncateAt = matchingClose + 1;
+    } else {
+      truncateAt = lastOpenBrace;
+    }
+  }
+  const codeBlockMarker = "```";
+  const beforeTruncateForCode = text.slice(0, truncateAt);
+  const codeBlockCount = (beforeTruncateForCode.match(/```/g) || []).length;
+  if (codeBlockCount % 2 === 1) {
+    const closeMarkerIdx = text.indexOf(codeBlockMarker, truncateAt);
+    if (closeMarkerIdx !== -1 && closeMarkerIdx < maxChars * 1.2) {
+      truncateAt = closeMarkerIdx + codeBlockMarker.length;
+    } else {
+      const lastOpenMarker = beforeTruncateForCode.lastIndexOf(codeBlockMarker);
+      if (lastOpenMarker !== -1) {
+        truncateAt = lastOpenMarker;
+      }
+    }
+  }
+  const headerMatch = text.slice(0, truncateAt).match(/\n#{1,6}\s/g);
+  if (headerMatch && headerMatch.length > 0) {
+    const lastHeaderIdx = beforeTruncateForCode.lastIndexOf(`
+##`);
+    if (lastHeaderIdx !== -1 && lastHeaderIdx > maxChars * 0.8) {
+      truncateAt = lastHeaderIdx;
+    }
+  }
+  while (truncateAt > 0 && !/\s/.test(text[truncateAt])) {
+    truncateAt--;
+  }
+  const truncated = text.slice(0, truncateAt).trimEnd();
+  const charsRemoved = text.length - truncated.length;
+  return `${truncated}
+
+[TRUNCATED - ${charsRemoved.toLocaleString()} chars removed]`;
+}
+function getToolLimit(toolName, config2 = DEFAULT_GUARDRAIL_CONFIG) {
+  return config2.toolLimits[toolName] ?? config2.defaultMaxChars;
+}
+function guardrailOutput(toolName, output, config2 = DEFAULT_GUARDRAIL_CONFIG) {
+  const originalLength = output.length;
+  if (config2.skipTools.includes(toolName)) {
+    return {
+      output,
+      truncated: false,
+      originalLength,
+      truncatedLength: originalLength
+    };
+  }
+  const limit = getToolLimit(toolName, config2);
+  if (originalLength <= limit) {
+    return {
+      output,
+      truncated: false,
+      originalLength,
+      truncatedLength: originalLength
+    };
+  }
+  const truncatedOutput = truncateWithBoundaries(output, limit);
+  const truncatedLength = truncatedOutput.length;
+  return {
+    output: truncatedOutput,
+    truncated: true,
+    originalLength,
+    truncatedLength
+  };
+}
+function createMetrics(result, toolName) {
+  return {
+    toolName,
+    originalLength: result.originalLength,
+    truncatedLength: result.truncatedLength,
+    timestamp: Date.now()
+  };
+}
 // src/storage.ts
 init_learning();
 
@@ -36696,20 +37703,47 @@ async function execSemanticMemory2(args) {
     };
   }
 }
-var DEFAULT_STORAGE_CONFIG = {
-  backend: "semantic-memory",
-  collections: {
+function getCollectionNames() {
+  const base = {
     feedback: "swarm-feedback",
     patterns: "swarm-patterns",
     maturity: "swarm-maturity"
-  },
+  };
+  if (process.env.TEST_MEMORY_COLLECTIONS === "true") {
+    return {
+      feedback: `${base.feedback}-test`,
+      patterns: `${base.patterns}-test`,
+      maturity: `${base.maturity}-test`
+    };
+  }
+  return base;
+}
+var DEFAULT_STORAGE_CONFIG = {
+  backend: "semantic-memory",
+  collections: getCollectionNames(),
   useSemanticSearch: true
 };
-
+var sessionStats = {
+  storesCount: 0,
+  queriesCount: 0,
+  sessionStart: Date.now(),
+  lastAlertCheck: Date.now()
+};
 class SemanticMemoryStorage {
   config;
   constructor(config2 = {}) {
     this.config = { ...DEFAULT_STORAGE_CONFIG, ...config2 };
+    console.log(`[storage] SemanticMemoryStorage initialized with collections:`, this.config.collections);
+  }
+  async checkLowUsageAlert() {
+    const TEN_MINUTES = 10 * 60 * 1000;
+    const now = Date.now();
+    const sessionDuration = now - sessionStats.sessionStart;
+    const timeSinceLastAlert = now - sessionStats.lastAlertCheck;
+    if (sessionDuration >= TEN_MINUTES && sessionStats.storesCount < 1 && timeSinceLastAlert >= TEN_MINUTES) {
+      console.warn(`[storage] LOW USAGE ALERT: ${sessionStats.storesCount} stores after ${Math.floor(sessionDuration / 60000)} minutes`);
+      sessionStats.lastAlertCheck = now;
+    }
   }
   async store(collection, data, metadata) {
     const content = typeof data === "string" ? data : JSON.stringify(data);
@@ -36717,7 +37751,13 @@ class SemanticMemoryStorage {
     if (metadata) {
       args.push("--metadata", JSON.stringify(metadata));
     }
-    await execSemanticMemory2(args);
+    console.log(`[storage] store() -> collection="${collection}"`);
+    sessionStats.storesCount++;
+    const result = await execSemanticMemory2(args);
+    if (result.exitCode !== 0) {
+      console.warn(`[storage] semantic-memory store() failed with exit code ${result.exitCode}: ${result.stderr.toString().trim()}`);
+    }
+    await this.checkLowUsageAlert();
   }
   async find(collection, query, limit = 10, useFts = false) {
     const args = [
@@ -36732,6 +37772,8 @@ class SemanticMemoryStorage {
     if (useFts) {
       args.push("--fts");
     }
+    console.log(`[storage] find() -> collection="${collection}", query="${query.slice(0, 50)}${query.length > 50 ? "..." : ""}", limit=${limit}, fts=${useFts}`);
+    sessionStats.queriesCount++;
     const result = await execSemanticMemory2(args);
     if (result.exitCode !== 0) {
       console.warn(`[storage] semantic-memory find() failed with exit code ${result.exitCode}: ${result.stderr.toString().trim()}`);
@@ -36757,6 +37799,8 @@ class SemanticMemoryStorage {
     }
   }
   async list(collection) {
+    console.log(`[storage] list() -> collection="${collection}"`);
+    sessionStats.queriesCount++;
     const result = await execSemanticMemory2([
       "list",
       "--collection",
@@ -37037,6 +38081,13 @@ var SwarmPlugin = async (input) => {
     },
     "tool.execute.after": async (input2, output) => {
       const toolName = input2.tool;
+      if (output.output && typeof output.output === "string") {
+        const guardrailResult = guardrailOutput(toolName, output.output);
+        if (guardrailResult.truncated) {
+          output.output = guardrailResult.output;
+          console.log(`[swarm-plugin] Guardrail truncated ${toolName}: ${guardrailResult.originalLength} → ${guardrailResult.truncatedLength} chars`);
+        }
+      }
       if (toolName === "agentmail_init" && output.output) {
         try {
           const result = JSON.parse(output.output);
@@ -37083,6 +38134,7 @@ export {
   warnMissingTool,
   updateMandateStatus,
   updateAllMandateStatuses,
+  truncateWithBoundaries,
   swarmTools,
   swarmMailTools,
   structuredTools,
@@ -37111,6 +38163,7 @@ export {
   isAgentNotFoundError,
   invalidateSkillsCache,
   ifToolAvailable,
+  guardrailOutput,
   groupByTransition,
   getToolAvailability,
   getSwarmMailProjectDirectory,
@@ -37137,6 +38190,7 @@ export {
   src_default as default,
   createStorageWithFallback,
   createStorage,
+  createMetrics,
   createMandateStorage,
   createAgentMailError,
   clearSessionState,
@@ -37159,12 +38213,17 @@ export {
   VoteTypeSchema,
   VoteSchema,
   ValidationResultSchema,
+  UpdateSwarmContextArgsSchema,
   TaskDecompositionSchema,
+  SwarmStrategySchema,
   SwarmStatusSchema,
   SwarmSpawnResultSchema,
+  SwarmRecoverySchema,
   SwarmPlugin,
   SwarmEvaluationResultSchema,
   SwarmError,
+  SwarmDirectivesSchema,
+  SwarmBeadContextSchema,
   SubtaskSpecSchema,
   SubtaskDependencySchema,
   SpawnedAgentSchema,
@@ -37174,6 +38233,7 @@ export {
   SUBTASK_PROMPT_V2,
   STRATEGIES,
   RepoCrawlError,
+  QuerySwarmContextsArgsSchema,
   QueryMandatesArgsSchema,
   MandateStatusSchema,
   MandateScoreSchema,
@@ -37195,8 +38255,10 @@ export {
   DEFAULT_STORAGE_CONFIG,
   DEFAULT_MANDATE_STORAGE_CONFIG,
   DEFAULT_MANDATE_DECAY_CONFIG,
+  DEFAULT_GUARDRAIL_CONFIG,
   DEFAULT_CRITERIA,
   CriterionEvaluationSchema,
+  CreateSwarmContextArgsSchema,
   CreateMandateArgsSchema,
   CastVoteArgsSchema,
   BeadValidationError,