opencode-swarm-plugin 0.25.1 → 0.25.3

package/dist/plugin.js

@@ -27053,7 +27053,11 @@ echo "Project directory: $1"
 
 // src/beads.ts
 init_dist();
-init_zod();
+import {
+  createBeadsAdapter,
+  FlushManager,
+  getSwarmMail
+} from "swarm-mail";
 
 // src/schemas/bead.ts
 init_zod();
@@ -27598,20 +27602,6 @@ function setBeadsWorkingDirectory(directory) {
 function getBeadsWorkingDirectory() {
   return beadsWorkingDirectory || process.cwd();
 }
-async function runBdCommand(args) {
-  const cwd = getBeadsWorkingDirectory();
-  const proc = Bun.spawn(["bd", ...args], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const [stdout, stderr] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text()
-  ]);
-  const exitCode = await proc.exited;
-  return { exitCode, stdout, stderr };
-}
 async function runGitCommand(args) {
   const cwd = getBeadsWorkingDirectory();
   const proc = Bun.spawn(["git", ...args], {
@@ -27639,63 +27629,33 @@ class BeadError extends Error {
     this.name = "BeadError";
   }
 }
-
-class BeadValidationError extends Error {
-  zodError;
-  constructor(message, zodError) {
-    super(message);
-    this.zodError = zodError;
-    this.name = "BeadValidationError";
+var adapterCache = new Map;
+async function getBeadsAdapter(projectKey) {
+  if (adapterCache.has(projectKey)) {
+    return adapterCache.get(projectKey);
   }
+  const swarmMail = await getSwarmMail(projectKey);
+  const db = await swarmMail.getDatabase();
+  const adapter = createBeadsAdapter(db, projectKey);
+  await adapter.runMigrations();
+  adapterCache.set(projectKey, adapter);
+  return adapter;
 }
-function buildCreateCommand(args) {
-  const parts = ["bd", "create", args.title];
-  if (args.type && args.type !== "task") {
-    parts.push("-t", args.type);
-  }
-  if (args.priority !== undefined && args.priority !== 2) {
-    parts.push("-p", args.priority.toString());
-  }
-  if (args.description) {
-    parts.push("-d", args.description);
-  }
-  if (args.parent_id) {
-    parts.push("--parent", args.parent_id);
-  }
-  if (args.id) {
-    parts.push("--id", args.id);
-  }
-  parts.push("--json");
-  return parts;
-}
-function parseBead(output) {
-  try {
-    const parsed = JSON.parse(output);
-    const data = Array.isArray(parsed) ? parsed[0] : parsed;
-    if (!data) {
-      throw new BeadError("No bead data in response. The bd CLI may not be installed or returned unexpected output. Try: Run 'bd --version' to verify installation, or check if .beads/ directory exists in project.", "parse");
-    }
-    return BeadSchema.parse(data);
-  } catch (error45) {
-    if (error45 instanceof exports_external.ZodError) {
-      throw new BeadValidationError(`Invalid bead data: ${error45.message}`, error45);
-    }
-    if (error45 instanceof BeadError) {
-      throw error45;
-    }
-    throw new BeadError(`Failed to parse bead JSON because output is malformed. Try: Check if bd CLI is up to date with 'bd --version' (need v1.0.0+), or inspect output: ${output.slice(0, 100)}`, "parse");
-  }
-}
-function parseBeads(output) {
-  try {
-    const parsed = JSON.parse(output);
-    return exports_external.array(BeadSchema).parse(parsed);
-  } catch (error45) {
-    if (error45 instanceof exports_external.ZodError) {
-      throw new BeadValidationError(`Invalid beads data: ${error45.message}`, error45);
-    }
-    throw new BeadError(`Failed to parse beads JSON because output is malformed. Try: Check if bd CLI is up to date with 'bd --version' (need v1.0.0+), or inspect output: ${output.slice(0, 100)}`, "parse");
-  }
+function formatBeadForOutput(adapterBead) {
+  return {
+    id: adapterBead.id,
+    title: adapterBead.title,
+    description: adapterBead.description || "",
+    status: adapterBead.status,
+    priority: adapterBead.priority,
+    issue_type: adapterBead.type,
+    created_at: new Date(adapterBead.created_at).toISOString(),
+    updated_at: new Date(adapterBead.updated_at).toISOString(),
+    closed_at: adapterBead.closed_at ? new Date(adapterBead.closed_at).toISOString() : undefined,
+    parent_id: adapterBead.parent_id || undefined,
+    dependencies: [],
+    metadata: {}
+  };
 }
 var beads_create = tool({
   description: "Create a new bead with type-safe validation",
@@ -27708,20 +27668,23 @@ var beads_create = tool({
   },
   async execute(args, ctx) {
     const validated = BeadCreateArgsSchema.parse(args);
-    const cmdParts = buildCreateCommand(validated);
-    const result = await runBdCommand(cmdParts.slice(1));
-    if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to create bead because bd command exited with code ${result.exitCode}. Error: ${result.stderr}. Try: Check if beads initialized with 'bd init' in project root, or verify .beads/ directory exists.`, cmdParts.join(" "), result.exitCode, result.stderr);
-    }
-    const stdout = result.stdout.trim();
-    if (!stdout) {
-      throw new BeadError("bd create returned empty output because command produced no response. Try: Check if bd is properly installed with 'bd --version', or run 'bd list' to test basic functionality.", cmdParts.join(" "), 0, "Empty stdout");
-    }
-    if (stdout.startsWith("error:") || stdout.startsWith("Error:")) {
-      throw new BeadError(`bd create failed because command returned error in stdout: ${stdout}. Try: Check error message above, verify beads initialized with 'bd init', or check .beads/issues.jsonl for corruption.`, cmdParts.join(" "), 0, stdout);
+    const projectKey = getBeadsWorkingDirectory();
+    const adapter = await getBeadsAdapter(projectKey);
+    try {
+      const bead = await adapter.createBead(projectKey, {
+        title: validated.title,
+        type: validated.type || "task",
+        priority: validated.priority ?? 2,
+        description: validated.description,
+        parent_id: validated.parent_id
+      });
+      await adapter.markDirty(projectKey, bead.id);
+      const formatted = formatBeadForOutput(bead);
+      return JSON.stringify(formatted, null, 2);
+    } catch (error45) {
+      const message = error45 instanceof Error ? error45.message : String(error45);
+      throw new BeadError(`Failed to create bead: ${message}`, "beads_create");
     }
-    const bead = parseBead(stdout);
-    return JSON.stringify(bead, null, 2);
   }
 });
 var beads_create_epic = tool({
@@ -27747,44 +27710,32 @@ var beads_create_epic = tool({
   },
   async execute(args, ctx) {
     const validated = EpicCreateArgsSchema.parse(args);
+    const projectKey = getBeadsWorkingDirectory();
+    const adapter = await getBeadsAdapter(projectKey);
     const created = [];
     try {
-      const epicCmd = buildCreateCommand({
+      const epic = await adapter.createBead(projectKey, {
         title: validated.epic_title,
         type: "epic",
         priority: 1,
-        description: validated.epic_description,
-        id: validated.epic_id
+        description: validated.epic_description
       });
-      const epicResult = await runBdCommand(epicCmd.slice(1));
-      if (epicResult.exitCode !== 0) {
-        throw new BeadError(`Failed to create epic because bd command failed: ${epicResult.stderr}. Try: Verify beads initialized with 'bd init', check if .beads/ directory is writable, or run 'bd list' to test basic functionality.`, epicCmd.join(" "), epicResult.exitCode);
-      }
-      const epic = parseBead(epicResult.stdout);
+      await adapter.markDirty(projectKey, epic.id);
       created.push(epic);
       for (const subtask of validated.subtasks) {
-        let subtaskId;
-        if (validated.epic_id && subtask.id_suffix) {
-          subtaskId = `${validated.epic_id}.${subtask.id_suffix}`;
-        }
-        const subtaskCmd = buildCreateCommand({
+        const subtaskBead = await adapter.createBead(projectKey, {
           title: subtask.title,
           type: "task",
           priority: subtask.priority ?? 2,
-          parent_id: epic.id,
-          id: subtaskId
+          parent_id: epic.id
         });
-        const subtaskResult = await runBdCommand(subtaskCmd.slice(1));
-        if (subtaskResult.exitCode !== 0) {
-          throw new BeadError(`Failed to create subtask because bd command failed: ${subtaskResult.stderr}. Try: Check if parent epic exists with 'bd show ${epic.id}', verify .beads/issues.jsonl is not corrupted, or check for invalid characters in title.`, subtaskCmd.join(" "), subtaskResult.exitCode);
-        }
-        const subtaskBead = parseBead(subtaskResult.stdout);
+        await adapter.markDirty(projectKey, subtaskBead.id);
         created.push(subtaskBead);
       }
       const result = {
         success: true,
-        epic,
-        subtasks: created.slice(1)
+        epic: formatBeadForOutput(epic),
+        subtasks: created.slice(1).map((b) => formatBeadForOutput(b))
       };
       if (args.project_key) {
         try {
@@ -27809,23 +27760,12 @@ var beads_create_epic = tool({
       }
       return JSON.stringify(result, null, 2);
     } catch (error45) {
-      const rollbackCommands = [];
       const rollbackErrors = [];
       for (const bead of created) {
         try {
-          const closeArgs = [
-            "close",
-            bead.id,
-            "--reason",
-            "Rollback partial epic",
-            "--json"
-          ];
-          const rollbackResult = await runBdCommand(closeArgs);
-          if (rollbackResult.exitCode === 0) {
-            rollbackCommands.push(`bd close ${bead.id} --reason "Rollback partial epic"`);
-          } else {
-            rollbackErrors.push(`${bead.id}: exit ${rollbackResult.exitCode} - ${rollbackResult.stderr.trim()}`);
-          }
+          await adapter.deleteBead(projectKey, bead.id, {
+            reason: "Rollback partial epic"
+          });
         } catch (rollbackError) {
           const errMsg = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
           console.error(`Failed to rollback bead ${bead.id}:`, rollbackError);
@@ -27833,14 +27773,9 @@ var beads_create_epic = tool({
         }
       }
       const errorMsg = error45 instanceof Error ? error45.message : String(error45);
-      let rollbackInfo = "";
-      if (rollbackCommands.length > 0) {
-        rollbackInfo += `
+      let rollbackInfo = `
 
-Rolled back ${rollbackCommands.length} bead(s):
-${rollbackCommands.join(`
-`)}`;
-      }
+Rolled back ${created.length - rollbackErrors.length} bead(s)`;
       if (rollbackErrors.length > 0) {
         rollbackInfo += `
 
@@ -27848,12 +27783,7 @@ Rollback failures (${rollbackErrors.length}):
 ${rollbackErrors.join(`
 `)}`;
       }
-      if (!rollbackInfo) {
-        rollbackInfo = `
-
-No beads to rollback.`;
-      }
-      throw new BeadError(`Epic creation failed: ${errorMsg}${rollbackInfo}. Try: If rollback failed, manually close beads with 'bd close <id> --reason "Rollback"', check .beads/issues.jsonl for partial state, or re-run beads_create_epic with corrected parameters.`, "beads_create_epic", 1);
+      throw new BeadError(`Epic creation failed: ${errorMsg}${rollbackInfo}`, "beads_create_epic", 1);
     }
   }
 });
@@ -27867,25 +27797,26 @@ var beads_query = tool({
   },
   async execute(args, ctx) {
     const validated = BeadQueryArgsSchema.parse(args);
-    let cmd;
-    if (validated.ready) {
-      cmd = ["bd", "ready", "--json"];
-    } else {
-      cmd = ["bd", "list", "--json"];
-      if (validated.status) {
-        cmd.push("--status", validated.status);
-      }
-      if (validated.type) {
-        cmd.push("--type", validated.type);
+    const projectKey = getBeadsWorkingDirectory();
+    const adapter = await getBeadsAdapter(projectKey);
+    try {
+      let beads;
+      if (validated.ready) {
+        const readyBead = await adapter.getNextReadyBead(projectKey);
+        beads = readyBead ? [readyBead] : [];
+      } else {
+        beads = await adapter.queryBeads(projectKey, {
+          status: validated.status,
+          type: validated.type,
+          limit: validated.limit || 20
+        });
       }
+      const formatted = beads.map((b) => formatBeadForOutput(b));
+      return JSON.stringify(formatted, null, 2);
+    } catch (error45) {
+      const message = error45 instanceof Error ? error45.message : String(error45);
+      throw new BeadError(`Failed to query beads: ${message}`, "beads_query");
     }
-    const result = await runBdCommand(cmd.slice(1));
-    if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to query beads because bd command failed: ${result.stderr}. Try: Check if beads initialized with 'bd init', verify .beads/ directory exists, or run 'bd --version' to check CLI version.`, cmd.join(" "), result.exitCode);
-    }
-    const beads = parseBeads(result.stdout);
-    const limited = beads.slice(0, validated.limit);
-    return JSON.stringify(limited, null, 2);
   }
 });
 var beads_update = tool({
@@ -27898,23 +27829,32 @@ var beads_update = tool({
   },
   async execute(args, ctx) {
     const validated = BeadUpdateArgsSchema.parse(args);
-    const cmd = ["bd", "update", validated.id];
-    if (validated.status) {
-      cmd.push("--status", validated.status);
-    }
-    if (validated.description) {
-      cmd.push("-d", validated.description);
-    }
-    if (validated.priority !== undefined) {
-      cmd.push("-p", validated.priority.toString());
-    }
-    cmd.push("--json");
-    const result = await runBdCommand(cmd.slice(1));
-    if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to update bead because bd command failed: ${result.stderr}. Try: Verify bead exists with 'bd show ${validated.id}', check for invalid status values, or inspect .beads/issues.jsonl for corruption.`, cmd.join(" "), result.exitCode);
+    const projectKey = getBeadsWorkingDirectory();
+    const adapter = await getBeadsAdapter(projectKey);
+    try {
+      let bead;
+      if (validated.status) {
+        bead = await adapter.changeBeadStatus(projectKey, validated.id, validated.status);
+      }
+      if (validated.description !== undefined || validated.priority !== undefined) {
+        bead = await adapter.updateBead(projectKey, validated.id, {
+          description: validated.description,
+          priority: validated.priority
+        });
+      } else if (!validated.status) {
+        const existingBead = await adapter.getBead(projectKey, validated.id);
+        if (!existingBead) {
+          throw new BeadError(`Bead not found: ${validated.id}`, "beads_update");
+        }
+        bead = existingBead;
+      }
+      await adapter.markDirty(projectKey, validated.id);
+      const formatted = formatBeadForOutput(bead);
+      return JSON.stringify(formatted, null, 2);
+    } catch (error45) {
+      const message = error45 instanceof Error ? error45.message : String(error45);
+      throw new BeadError(`Failed to update bead: ${message}`, "beads_update");
     }
-    const bead = parseBead(result.stdout);
-    return JSON.stringify(bead, null, 2);
   }
 });
 var beads_close = tool({
@@ -27925,20 +27865,16 @@ var beads_close = tool({
   },
   async execute(args, ctx) {
     const validated = BeadCloseArgsSchema.parse(args);
-    const cmd = [
-      "bd",
-      "close",
-      validated.id,
-      "--reason",
-      validated.reason,
-      "--json"
-    ];
-    const result = await runBdCommand(cmd.slice(1));
-    if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to close bead because bd command failed: ${result.stderr}. Try: Verify bead exists and is not already closed with 'beads_query(status="closed")' or 'bd show ${validated.id}', check if bead ID is correct.`, cmd.join(" "), result.exitCode);
+    const projectKey = getBeadsWorkingDirectory();
+    const adapter = await getBeadsAdapter(projectKey);
+    try {
+      const bead = await adapter.closeBead(projectKey, validated.id, validated.reason);
+      await adapter.markDirty(projectKey, validated.id);
+      return `Closed ${bead.id}: ${validated.reason}`;
+    } catch (error45) {
+      const message = error45 instanceof Error ? error45.message : String(error45);
+      throw new BeadError(`Failed to close bead: ${message}`, "beads_close");
     }
-    const bead = parseBead(result.stdout);
-    return `Closed ${bead.id}: ${validated.reason}`;
   }
 });
 var beads_start = tool({
@@ -27947,34 +27883,35 @@ var beads_start = tool({
     id: tool.schema.string().describe("Bead ID")
   },
   async execute(args, ctx) {
-    const result = await runBdCommand([
-      "update",
-      args.id,
-      "--status",
-      "in_progress",
-      "--json"
-    ]);
-    if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to start bead because bd update command failed: ${result.stderr}. Try: Verify bead exists with 'bd show ${args.id}', check if already in_progress with 'beads_query(status="in_progress")', or use beads_update directly.`, `bd update ${args.id} --status in_progress --json`, result.exitCode);
+    const projectKey = getBeadsWorkingDirectory();
+    const adapter = await getBeadsAdapter(projectKey);
+    try {
+      const bead = await adapter.changeBeadStatus(projectKey, args.id, "in_progress");
+      await adapter.markDirty(projectKey, args.id);
+      return `Started: ${bead.id}`;
+    } catch (error45) {
+      const message = error45 instanceof Error ? error45.message : String(error45);
+      throw new BeadError(`Failed to start bead: ${message}`, "beads_start");
     }
-    const bead = parseBead(result.stdout);
-    return `Started: ${bead.id}`;
   }
 });
 var beads_ready = tool({
   description: "Get the next ready bead (unblocked, highest priority)",
   args: {},
   async execute(args, ctx) {
-    const result = await runBdCommand(["ready", "--json"]);
-    if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to get ready beads because bd ready command failed: ${result.stderr}. Try: Check if beads initialized with 'bd init', verify .beads/ directory is readable, or run 'bd list --json' to test basic query.`, "bd ready --json", result.exitCode);
-    }
-    const beads = parseBeads(result.stdout);
-    if (beads.length === 0) {
-      return "No ready beads";
+    const projectKey = getBeadsWorkingDirectory();
+    const adapter = await getBeadsAdapter(projectKey);
+    try {
+      const bead = await adapter.getNextReadyBead(projectKey);
+      if (!bead) {
+        return "No ready beads";
+      }
+      const formatted = formatBeadForOutput(bead);
+      return JSON.stringify(formatted, null, 2);
+    } catch (error45) {
+      const message = error45 instanceof Error ? error45.message : String(error45);
+      throw new BeadError(`Failed to get ready beads: ${message}`, "beads_ready");
     }
-    const next = beads[0];
-    return JSON.stringify(next, null, 2);
   }
 });
 var beads_sync = tool({
@@ -27984,6 +27921,8 @@ var beads_sync = tool({
   },
   async execute(args, ctx) {
     const autoPull = args.auto_pull ?? true;
+    const projectKey = getBeadsWorkingDirectory();
+    const adapter = await getBeadsAdapter(projectKey);
     const TIMEOUT_MS = 30000;
     const withTimeout = async (promise2, timeoutMs, operation) => {
       let timeoutId;
@@ -27998,9 +27937,14 @@ var beads_sync = tool({
         }
       }
     };
-    const flushResult = await withTimeout(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);
+    const flushManager = new FlushManager({
+      adapter,
+      projectKey,
+      outputPath: `${projectKey}/.beads/issues.jsonl`
+    });
+    const flushResult = await withTimeout(flushManager.flush(), TIMEOUT_MS, "flush beads");
+    if (flushResult.beadsExported === 0) {
+      return "No beads to sync";
     }
     const beadsStatusResult = await runGitCommand([
       "status",
@@ -28011,65 +27955,22 @@ var beads_sync = tool({
     if (hasChanges) {
       const addResult = await runGitCommand(["add", ".beads/"]);
       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);
+        throw new BeadError(`Failed to stage beads: ${addResult.stderr}`, "git add .beads/", addResult.exitCode);
       }
       const commitResult = await withTimeout(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);
+        throw new BeadError(`Failed to commit beads: ${commitResult.stderr}`, "git commit", commitResult.exitCode);
       }
     }
     if (autoPull) {
-      const dirtyCheckResult = await runGitCommand([
-        "status",
-        "--porcelain",
-        "--untracked-files=no"
-      ]);
-      const hasDirtyFiles = dirtyCheckResult.stdout.trim() !== "";
-      let didStash = false;
-      if (hasDirtyFiles) {
-        console.warn("[beads] Detected unstaged changes, stashing before pull...");
-        const stashResult = await runGitCommand([
-          "stash",
-          "push",
-          "-m",
-          "beads_sync: auto-stash before pull",
-          "--include-untracked"
-        ]);
-        if (stashResult.exitCode === 0) {
-          didStash = true;
-          console.warn("[beads] Changes stashed successfully");
-        } else {
-          console.warn(`[beads] Stash failed (${stashResult.stderr}), attempting pull anyway...`);
-        }
-      }
       const pullResult = await withTimeout(runGitCommand(["pull", "--rebase"]), TIMEOUT_MS, "git pull --rebase");
-      if (didStash) {
-        console.warn("[beads] Restoring stashed changes...");
-        const unstashResult = await runGitCommand(["stash", "pop"]);
-        if (unstashResult.exitCode !== 0) {
-          console.error(`[beads] WARNING: Failed to restore stashed changes: ${unstashResult.stderr}`);
-          console.error("[beads] Your changes are in 'git stash list' - run 'git stash pop' manually");
-        } else {
-          console.warn("[beads] Stashed changes restored");
-        }
-      }
       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");
-      if (importResult.exitCode !== 0) {
-        console.warn(`[beads] Import warning: ${importResult.stderr}`);
+        throw new BeadError(`Failed to pull: ${pullResult.stderr}`, "git pull --rebase", pullResult.exitCode);
       }
     }
     const pushResult = await withTimeout(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);
-    }
-    const statusResult = await runGitCommand(["status", "--porcelain"]);
-    const status = statusResult.stdout.trim();
-    if (status !== "") {
-      return `Beads synced and pushed, but working directory not clean:
-${status}`;
+      throw new BeadError(`Failed to push: ${pushResult.stderr}`, "git push", pushResult.exitCode);
     }
     return "Beads synced and pushed successfully";
   }
@@ -28081,30 +27982,30 @@ var beads_link_thread = tool({
     thread_id: tool.schema.string().describe("Agent Mail thread ID")
   },
   async execute(args, ctx) {
-    const queryResult = await runBdCommand(["show", args.bead_id, "--json"]);
-    if (queryResult.exitCode !== 0) {
-      throw new BeadError(`Failed to get bead because bd show command failed: ${queryResult.stderr}. Try: Verify bead ID is correct with 'beads_query()', check if bead exists with 'bd list --json', or check .beads/issues.jsonl for valid entries.`, `bd show ${args.bead_id} --json`, queryResult.exitCode);
-    }
-    const bead = parseBead(queryResult.stdout);
-    const existingDesc = bead.description || "";
-    const threadMarker = `[thread:${args.thread_id}]`;
-    if (existingDesc.includes(threadMarker)) {
-      return `Bead ${args.bead_id} already linked to thread ${args.thread_id}`;
-    }
-    const newDesc = existingDesc ? `${existingDesc}
+    const projectKey = getBeadsWorkingDirectory();
+    const adapter = await getBeadsAdapter(projectKey);
+    try {
+      const bead = await adapter.getBead(projectKey, args.bead_id);
+      if (!bead) {
+        throw new BeadError(`Bead not found: ${args.bead_id}`, "beads_link_thread");
+      }
+      const existingDesc = bead.description || "";
+      const threadMarker = `[thread:${args.thread_id}]`;
+      if (existingDesc.includes(threadMarker)) {
+        return `Bead ${args.bead_id} already linked to thread ${args.thread_id}`;
+      }
+      const newDesc = existingDesc ? `${existingDesc}
 
 ${threadMarker}` : threadMarker;
-    const updateResult = await runBdCommand([
-      "update",
-      args.bead_id,
-      "-d",
-      newDesc,
-      "--json"
-    ]);
-    if (updateResult.exitCode !== 0) {
-      throw new BeadError(`Failed to update bead because bd update command failed: ${updateResult.stderr}. Try: Verify bead exists with 'bd show ${args.bead_id}', check for invalid characters in description, or inspect .beads/issues.jsonl for corruption.`, `bd update ${args.bead_id} -d ...`, updateResult.exitCode);
+      await adapter.updateBead(projectKey, args.bead_id, {
+        description: newDesc
+      });
+      await adapter.markDirty(projectKey, args.bead_id);
+      return `Linked bead ${args.bead_id} to thread ${args.thread_id}`;
+    } catch (error45) {
+      const message = error45 instanceof Error ? error45.message : String(error45);
+      throw new BeadError(`Failed to link thread: ${message}`, "beads_link_thread");
     }
-    return `Linked bead ${args.bead_id} to thread ${args.thread_id}`;
   }
 });
 var beadsTools = {
@@ -28550,11 +28451,6 @@ class SqliteRateLimiter {
       if (result.changes < BATCH_SIZE)
         break;
     }
-    if (totalDeleted > 0) {
-      console.log("[RateLimiter] Cleanup completed:", {
-        deletedRows: totalDeleted
-      });
-    }
   }
   async recordRequest(agentName, endpoint) {
     const now = Date.now();
@@ -31261,9 +31157,28 @@ swarmmail_release()  # Manually release reservations
 **Note:** \`swarm_complete\` automatically releases reservations. Only use manual release if aborting work.
 
 ## [OTHER TOOLS]
-### Beads
+### Beads - You Have Autonomy to File Issues
+You can create new beads against this epic when you discover:
+- **Bugs**: Found a bug while working? File it.
+- **Tech debt**: Spotted something that needs cleanup? File it.
+- **Follow-up work**: Task needs more work than scoped? File a follow-up.
+- **Dependencies**: Need something from another agent? File and link it.
+
+\`\`\`
+beads_create(
+  title="<descriptive title>",
+  type="bug",  # or "task", "chore"
+  priority=2,
+  parent_id="{epic_id}",  # Links to this epic
+  description="Found while working on {bead_id}: <details>"
+)
+\`\`\`
+
+**Don't silently ignore issues.** File them so they get tracked and addressed.
+
+Other bead operations:
 - beads_update(id, status) - Mark blocked if stuck
-- beads_create(title, type) - Log new bugs found
+- beads_query(status="open") - See what else needs work
 
 ### Skills
 - skills_list() - Discover available skills
@@ -32078,7 +31993,7 @@ var swarm_complete = tool({
     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) {
+  async execute(args, _ctx) {
     const epicId = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
     try {
       const projectKey = args.project_key.replace(/\//g, "-").replace(/\\/g, "-");
@@ -32224,7 +32139,6 @@ Continuing with completion, but this should be fixed for future subtasks.`;
           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}`);
@@ -32257,21 +32171,30 @@ Continuing with completion, but this should be fixed for future subtasks.`;
         `**Memory Capture**: ${memoryStored ? "✓ Stored in semantic-memory" : `✗ ${memoryError || "Failed"}`}`
       ].filter(Boolean).join(`
 `);
-      await sendSwarmMessage2({
-        projectPath: args.project_key,
-        fromAgent: args.agent_name,
-        toAgents: [],
-        subject: `Complete: ${args.bead_id}`,
-        body: completionBody,
-        threadId: epicId2,
-        importance: "normal"
-      });
+      let messageSent = false;
+      let messageError;
+      try {
+        await sendSwarmMessage2({
+          projectPath: args.project_key,
+          fromAgent: args.agent_name,
+          toAgents: [],
+          subject: `Complete: ${args.bead_id}`,
+          body: completionBody,
+          threadId: epicId2,
+          importance: "normal"
+        });
+        messageSent = true;
+      } catch (error45) {
+        messageError = error45 instanceof Error ? error45.message : String(error45);
+        console.warn(`[swarm_complete] Failed to send completion message: ${messageError}`);
+      }
       const response = {
         success: true,
         bead_id: args.bead_id,
         closed: true,
         reservations_released: true,
-        message_sent: true,
+        message_sent: messageSent,
+        message_error: messageError,
         agent_registration: {
           verified: agentRegistered,
           warning: registrationWarning || undefined
@@ -34353,7 +34276,6 @@ var SwarmPlugin = async (input) => {
         })
       });
       if (response.ok) {
-        console.log(`[swarm-plugin] Auto-released ${activeAgentMailState.reservations.length} file reservation(s)`);
         activeAgentMailState.reservations = [];
       }
     } catch (error45) {
@@ -34390,7 +34312,6 @@ var SwarmPlugin = async (input) => {
         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) {
@@ -34414,12 +34335,9 @@ var SwarmPlugin = async (input) => {
       }
       if (toolName === "swarm_complete" && activeAgentMailState) {
         await releaseReservations();
-        console.log("[swarm-plugin] Auto-released reservations after swarm:complete");
       }
       if (toolName === "beads_close") {
-        $`bd sync`.quiet().nothrow().then(() => {
-          console.log("[swarm-plugin] Auto-synced beads after close");
-        });
+        $`bd sync`.quiet().nothrow();
       }
     }
   };