opencode-swarm-plugin 0.25.3 → 0.26.1

package/.turbo/turbo-build.log

@@ -1,9 +1,9 @@
 $ bun build ./src/index.ts --outdir ./dist --target node --external @electric-sql/pglite --external swarm-mail && bun build ./src/plugin.ts --outfile ./dist/plugin.js --target node --external @electric-sql/pglite --external swarm-mail && tsc
-Bundled 197 modules in 32ms
+Bundled 197 modules in 35ms
 
   index.js  1.16 MB  (entry point)
 
-Bundled 198 modules in 32ms
+Bundled 198 modules in 33ms
 
   plugin.js  1.13 MB  (entry point)
 

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # opencode-swarm-plugin
 
+## 0.26.1
+
+### Patch Changes
+
+- [`b2d4a84`](https://github.com/joelhooks/swarm-tools/commit/b2d4a84748cdef4b9dbca7666dd3d313b6cd2b24) Thanks [@joelhooks](https://github.com/joelhooks)! - Add automatic JSONL migration for beads on first use
+
+  - Auto-migrate from `.beads/issues.jsonl` when database is empty
+  - Fix import to handle missing dependencies/labels/comments arrays
+  - Fix closed bead import to satisfy check constraint (status + closed_at)
+  - Migrates 500+ historical beads seamlessly on first adapter initialization
+
+- Updated dependencies [[`b2d4a84`](https://github.com/joelhooks/swarm-tools/commit/b2d4a84748cdef4b9dbca7666dd3d313b6cd2b24)]:
+  - swarm-mail@0.2.1
+
+## 0.26.0
+
+### Minor Changes
+
+- [`1a7b02f`](https://github.com/joelhooks/swarm-tools/commit/1a7b02f707a1490f14465467c6024331d5064878) Thanks [@joelhooks](https://github.com/joelhooks)! - Add PGLite socket server adapter with hybrid daemon management and move streams storage to $TMPDIR.
+
+  **Socket Server Adapter:**
+
+  - New `createSocketAdapter()` wrapping postgres.js for DatabaseAdapter interface
+  - Daemon lifecycle: `startDaemon()`, `stopDaemon()`, `isDaemonRunning()`, `healthCheck()`
+  - Auto-start daemon on first use with `SWARM_MAIL_SOCKET=true` env var
+  - Graceful fallback to embedded PGLite on failure
+  - CLI: `swarm-mail-daemon start|stop|status`
+
+  **$TMPDIR Storage (BREAKING):**
+
+  - Streams now stored in `$TMPDIR/opencode-<project-name>-<hash>/streams`
+  - Eliminates git pollution from `.opencode/streams/`
+  - Auto-cleaned on reboot (ephemeral coordination state)
+  - New exports: `getProjectTempDirName()`, `hashProjectPath()`
+
+  This fixes the multi-agent PGLite corruption issue by having all agents connect to a single pglite-server daemon via PostgreSQL wire protocol.
+
+### Patch Changes
+
+- Updated dependencies [[`1a7b02f`](https://github.com/joelhooks/swarm-tools/commit/1a7b02f707a1490f14465467c6024331d5064878)]:
+  - swarm-mail@0.2.0
+
 ## 0.25.3
 
 ### Patch Changes

package/dist/beads.d.ts

@@ -31,6 +31,9 @@ export declare class BeadValidationError extends Error {
 /**
  * Get or create a BeadsAdapter instance for a project
  * Exported for testing - allows tests to verify state directly
+ *
+ * On first initialization, checks for .beads/issues.jsonl and imports
+ * historical beads if the database is empty.
  */
 export declare function getBeadsAdapter(projectKey: string): Promise<BeadsAdapter>;
 /**

package/dist/beads.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"beads.d.ts","sourceRoot":"","sources":["../src/beads.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAGL,KAAK,YAAY,EAGlB,MAAM,YAAY,CAAC;AAapB;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAEhE;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAuCD;;GAEG;AACH,qBAAa,SAAU,SAAQ,KAAK;aAGhB,OAAO,EAAE,MAAM;aACf,QAAQ,CAAC,EAAE,MAAM;aACjB,MAAM,CAAC,EAAE,MAAM;gBAH/B,OAAO,EAAE,MAAM,EACC,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,YAAA,EACjB,MAAM,CAAC,EAAE,MAAM,YAAA;CAKlC;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;aAG1B,QAAQ,EAAE,CAAC,CAAC,QAAQ;gBADpC,OAAO,EAAE,MAAM,EACC,QAAQ,EAAE,CAAC,CAAC,QAAQ;CAKvC;AAYD;;;GAGG;AACH,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAc/E;AA8BD;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;CA+CvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgJ5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAiDtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;CA+DvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;CA6BtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;CA4BtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;CAwBtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;CAqIrB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;CA8C5B,CAAC;AAMH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUtB,CAAC"}
+{"version":3,"file":"beads.d.ts","sourceRoot":"","sources":["../src/beads.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAIL,KAAK,YAAY,EAGlB,MAAM,YAAY,CAAC;AAepB;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAEhE;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAuCD;;GAEG;AACH,qBAAa,SAAU,SAAQ,KAAK;aAGhB,OAAO,EAAE,MAAM;aACf,QAAQ,CAAC,EAAE,MAAM;aACjB,MAAM,CAAC,EAAE,MAAM;gBAH/B,OAAO,EAAE,MAAM,EACC,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,YAAA,EACjB,MAAM,CAAC,EAAE,MAAM,YAAA;CAKlC;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;aAG1B,QAAQ,EAAE,CAAC,CAAC,QAAQ;gBADpC,OAAO,EAAE,MAAM,EACC,QAAQ,EAAE,CAAC,CAAC,QAAQ;CAKvC;AAYD;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAiB/E;AA+ED;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;CA+CvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgJ5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAiDtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;CA+DvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;CA6BtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;CA4BtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;CAwBtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;CAqIrB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;CA8C5B,CAAC;AAMH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUtB,CAAC"}

package/dist/index.js

@@ -26166,7 +26166,7 @@ __export(exports_skills, {
 });
 import { readdir, readFile, stat, mkdir, writeFile, rm } from "fs/promises";
 import {
-  join as join4,
+  join as join5,
   basename,
   dirname as dirname2,
   resolve,
@@ -26214,19 +26214,19 @@ function validateSkillMetadata(raw, filePath) {
 }
 function getGlobalSkillsDir() {
   const home = process.env.HOME || process.env.USERPROFILE || "~";
-  return join4(home, ".config", "opencode", "skills");
+  return join5(home, ".config", "opencode", "skills");
 }
 function getClaudeGlobalSkillsDir() {
   const home = process.env.HOME || process.env.USERPROFILE || "~";
-  return join4(home, ".claude", "skills");
+  return join5(home, ".claude", "skills");
 }
 function getPackageSkillsDir() {
   try {
     const currentFilePath = fileURLToPath(import.meta.url);
-    return join4(dirname2(currentFilePath), "..", "global-skills");
+    return join5(dirname2(currentFilePath), "..", "global-skills");
   } catch {
     const currentDir = decodeURIComponent(new URL(".", import.meta.url).pathname);
-    return join4(currentDir, "..", "global-skills");
+    return join5(currentDir, "..", "global-skills");
   }
 }
 async function findSkillFiles(baseDir) {
@@ -26235,7 +26235,7 @@ async function findSkillFiles(baseDir) {
     const entries = await readdir(baseDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const skillPath = join4(baseDir, entry.name, "SKILL.md");
+        const skillPath = join5(baseDir, entry.name, "SKILL.md");
         try {
           const s = await stat(skillPath);
           if (s.isFile()) {
@@ -26249,7 +26249,7 @@ async function findSkillFiles(baseDir) {
 }
 async function findSkillScripts(skillDir) {
   const scripts = [];
-  const scriptsDir = join4(skillDir, "scripts");
+  const scriptsDir = join5(skillDir, "scripts");
   try {
     const entries = await readdir(scriptsDir, { withFileTypes: true });
     for (const entry of entries) {
@@ -26297,7 +26297,7 @@ async function discoverSkills(projectDir) {
     }
   }
   for (const relPath of PROJECT_SKILL_DIRECTORIES) {
-    await loadSkillsFromDir(join4(dir, relPath));
+    await loadSkillsFromDir(join5(dir, relPath));
   }
   await loadSkillsFromDir(getGlobalSkillsDir());
   await loadSkillsFromDir(getClaudeGlobalSkillsDir());
@@ -26653,7 +26653,7 @@ Scripts run in the skill's directory with the project directory as an argument.`
       if (!skill.scripts.includes(args.script)) {
         return `Script '${args.script}' not found in skill '${args.skill}'. Available: ${skill.scripts.join(", ") || "none"}`;
       }
-      const scriptPath = join4(skill.directory, "scripts", args.script);
+      const scriptPath = join5(skill.directory, "scripts", args.script);
       const scriptArgs = args.args || [];
       try {
         const TIMEOUT_MS = 60000;
@@ -26761,14 +26761,14 @@ Good skills have:
       const csoWarnings = validateCSOCompliance(args.name, args.description);
       let skillDir;
       if (args.directory === "global") {
-        skillDir = join4(getGlobalSkillsDir(), args.name);
+        skillDir = join5(getGlobalSkillsDir(), args.name);
       } else if (args.directory === "global-claude") {
-        skillDir = join4(getClaudeGlobalSkillsDir(), args.name);
+        skillDir = join5(getClaudeGlobalSkillsDir(), args.name);
       } else {
         const baseDir = args.directory || DEFAULT_SKILLS_DIR;
-        skillDir = join4(skillsProjectDirectory, baseDir, args.name);
+        skillDir = join5(skillsProjectDirectory, baseDir, args.name);
       }
-      const skillPath = join4(skillDir, "SKILL.md");
+      const skillPath = join5(skillDir, "SKILL.md");
       try {
         await mkdir(skillDir, { recursive: true });
         const content = generateSkillContent(args.name, args.description, args.body, { tags: args.tags, tools: args.tools });
@@ -26919,8 +26919,8 @@ executed with skills_execute. Use for:
       if (isAbsolute(args.script_name) || args.script_name.includes("..") || args.script_name.includes("/") || args.script_name.includes("\\") || basename(args.script_name) !== args.script_name) {
         return "Invalid script name. Use simple filenames without paths.";
       }
-      const scriptsDir = join4(skill.directory, "scripts");
-      const scriptPath = join4(scriptsDir, args.script_name);
+      const scriptsDir = join5(skill.directory, "scripts");
+      const scriptPath = join5(scriptsDir, args.script_name);
       try {
         await mkdir(scriptsDir, { recursive: true });
         await writeFile(scriptPath, args.content, {
@@ -26969,20 +26969,20 @@ Perfect for learning to create effective skills.`,
       }
       let skillDir;
       if (args.directory === "global") {
-        skillDir = join4(getGlobalSkillsDir(), args.name);
+        skillDir = join5(getGlobalSkillsDir(), args.name);
       } else {
         const baseDir = args.directory || DEFAULT_SKILLS_DIR;
-        skillDir = join4(skillsProjectDirectory, baseDir, args.name);
+        skillDir = join5(skillsProjectDirectory, baseDir, args.name);
       }
       const createdFiles = [];
       try {
         await mkdir(skillDir, { recursive: true });
-        const skillPath = join4(skillDir, "SKILL.md");
+        const skillPath = join5(skillDir, "SKILL.md");
         const skillContent = generateSkillTemplate(args.name, args.description);
         await writeFile(skillPath, skillContent, "utf-8");
         createdFiles.push("SKILL.md");
         if (args.include_example_script !== false) {
-          const scriptsDir = join4(skillDir, "scripts");
+          const scriptsDir = join5(skillDir, "scripts");
           await mkdir(scriptsDir, { recursive: true });
           const exampleScript = `#!/usr/bin/env bash
 # Example helper script for ${args.name}
@@ -26996,15 +26996,15 @@ echo "Project directory: $1"
 
 # TODO: Add actual script logic
 `;
-          const scriptPath = join4(scriptsDir, "example.sh");
+          const scriptPath = join5(scriptsDir, "example.sh");
           await writeFile(scriptPath, exampleScript, { mode: 493 });
           createdFiles.push("scripts/example.sh");
         }
         if (args.include_reference !== false) {
-          const refsDir = join4(skillDir, "references");
+          const refsDir = join5(skillDir, "references");
           await mkdir(refsDir, { recursive: true });
           const refContent = generateReferenceTemplate(args.name);
-          const refPath = join4(refsDir, "guide.md");
+          const refPath = join5(refsDir, "guide.md");
           await writeFile(refPath, refContent, "utf-8");
           createdFiles.push("references/guide.md");
         }
@@ -27056,8 +27056,11 @@ init_dist();
 import {
   createBeadsAdapter,
   FlushManager,
+  importFromJSONL,
   getSwarmMail
 } from "swarm-mail";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 
 // src/schemas/bead.ts
 init_zod();
@@ -27710,9 +27713,34 @@ async function getBeadsAdapter(projectKey) {
   const db = await swarmMail.getDatabase();
   const adapter = createBeadsAdapter(db, projectKey);
   await adapter.runMigrations();
+  await autoMigrateFromJSONL(adapter, projectKey);
   adapterCache.set(projectKey, adapter);
   return adapter;
 }
+async function autoMigrateFromJSONL(adapter, projectKey) {
+  const jsonlPath = join(projectKey, ".beads", "issues.jsonl");
+  if (!existsSync(jsonlPath)) {
+    return;
+  }
+  const existingBeads = await adapter.queryBeads(projectKey, { limit: 1 });
+  if (existingBeads.length > 0) {
+    return;
+  }
+  try {
+    const jsonlContent = readFileSync(jsonlPath, "utf-8");
+    const result = await importFromJSONL(adapter, projectKey, jsonlContent, {
+      skipExisting: true
+    });
+    if (result.created > 0 || result.updated > 0) {
+      console.log(`[beads] Auto-migrated ${result.created} beads from ${jsonlPath} (${result.skipped} skipped, ${result.errors.length} errors)`);
+    }
+    if (result.errors.length > 0) {
+      console.warn(`[beads] Migration errors:`, result.errors.slice(0, 5).map((e) => `${e.beadId}: ${e.error}`));
+    }
+  } catch (error45) {
+    console.warn(`[beads] Failed to auto-migrate from ${jsonlPath}:`, error45 instanceof Error ? error45.message : String(error45));
+  }
+}
 function formatBeadForOutput(adapterBead) {
   return {
     id: adapterBead.id,
@@ -28355,8 +28383,8 @@ function formatToolAvailability(availability) {
 
 // src/rate-limiter.ts
 var import_ioredis = __toESM(require_built3(), 1);
-import { mkdirSync, existsSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { mkdirSync, existsSync as existsSync2 } from "node:fs";
+import { dirname, join as join2 } from "node:path";
 import { homedir } from "node:os";
 var sqliteAvailable = false;
 var createDatabase = null;
@@ -28472,7 +28500,7 @@ class SqliteRateLimiter {
       throw new Error("SQLite is not available in this runtime (requires Bun)");
     }
     const dir = dirname(dbPath);
-    if (!existsSync(dir)) {
+    if (!existsSync2(dir)) {
       mkdirSync(dir, { recursive: true });
     }
     this.db = createDatabase(dbPath);
@@ -28617,7 +28645,7 @@ async function createRateLimiter(options2) {
   const {
     backend,
     redisUrl = process.env.OPENCODE_RATE_LIMIT_REDIS_URL || "redis://localhost:6379",
-    sqlitePath = process.env.OPENCODE_RATE_LIMIT_SQLITE_PATH || join(homedir(), ".config", "opencode", "rate-limits.db")
+    sqlitePath = process.env.OPENCODE_RATE_LIMIT_SQLITE_PATH || join2(homedir(), ".config", "opencode", "rate-limits.db")
   } = options2 || {};
   if (backend === "memory") {
     return new InMemoryRateLimiter;
@@ -28677,13 +28705,13 @@ async function getRateLimiter() {
 
 // src/agent-mail.ts
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   mkdirSync as mkdirSync2,
-  readFileSync,
+  readFileSync as readFileSync2,
   writeFileSync,
   unlinkSync
 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { tmpdir } from "os";
 var AGENT_MAIL_URL = "http://127.0.0.1:8765";
 var DEFAULT_TTL_SECONDS = 3600;
@@ -28707,16 +28735,16 @@ var RECOVERY_CONFIG = {
   restartCooldownMs: 1e4,
   enabled: process.env.OPENCODE_AGENT_MAIL_AUTO_RESTART !== "false"
 };
-var SESSION_STATE_DIR = process.env.SWARM_STATE_DIR || join2(tmpdir(), "swarm-sessions");
+var SESSION_STATE_DIR = process.env.SWARM_STATE_DIR || join3(tmpdir(), "swarm-sessions");
 function getSessionStatePath(sessionID) {
   const safeID = sessionID.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join2(SESSION_STATE_DIR, `${safeID}.json`);
+  return join3(SESSION_STATE_DIR, `${safeID}.json`);
 }
 function loadSessionState(sessionID) {
   const path = getSessionStatePath(sessionID);
   try {
-    if (existsSync2(path)) {
-      const data = readFileSync(path, "utf-8");
+    if (existsSync3(path)) {
+      const data = readFileSync2(path, "utf-8");
       return JSON.parse(data);
     }
   } catch (error45) {
@@ -28726,7 +28754,7 @@ function loadSessionState(sessionID) {
 }
 function saveSessionState(sessionID, state) {
   try {
-    if (!existsSync2(SESSION_STATE_DIR)) {
+    if (!existsSync3(SESSION_STATE_DIR)) {
       mkdirSync2(SESSION_STATE_DIR, { recursive: true });
     }
     const path = getSessionStatePath(sessionID);
@@ -29507,13 +29535,13 @@ import {
   getActiveReservations
 } from "swarm-mail";
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   writeFileSync as writeFileSync2,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 var MAX_INBOX_LIMIT2 = 5;
 var swarmMailProjectDirectory = null;
@@ -29523,16 +29551,16 @@ function setSwarmMailProjectDirectory(directory) {
 function getSwarmMailProjectDirectory() {
   return swarmMailProjectDirectory ?? undefined;
 }
-var SESSION_STATE_DIR2 = process.env.SWARM_STATE_DIR || join3(tmpdir2(), "swarm-sessions");
+var SESSION_STATE_DIR2 = process.env.SWARM_STATE_DIR || join4(tmpdir2(), "swarm-sessions");
 function getSessionStatePath2(sessionID) {
   const safeID = sessionID.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join3(SESSION_STATE_DIR2, `${safeID}.json`);
+  return join4(SESSION_STATE_DIR2, `${safeID}.json`);
 }
 function loadSessionState2(sessionID) {
   const path = getSessionStatePath2(sessionID);
   try {
-    if (existsSync3(path)) {
-      const data = readFileSync2(path, "utf-8");
+    if (existsSync4(path)) {
+      const data = readFileSync3(path, "utf-8");
       return JSON.parse(data);
     }
   } catch (error45) {
@@ -29542,7 +29570,7 @@ function loadSessionState2(sessionID) {
 }
 function saveSessionState2(sessionID, state) {
   try {
-    if (!existsSync3(SESSION_STATE_DIR2)) {
+    if (!existsSync4(SESSION_STATE_DIR2)) {
       mkdirSync3(SESSION_STATE_DIR2, { recursive: true });
     }
     const path = getSessionStatePath2(sessionID);
@@ -29556,7 +29584,7 @@ function saveSessionState2(sessionID, state) {
 function clearSessionState(sessionID) {
   const path = getSessionStatePath2(sessionID);
   try {
-    if (existsSync3(path)) {
+    if (existsSync4(path)) {
       unlinkSync2(path);
     }
   } catch {}
@@ -32974,7 +33002,7 @@ ${args.files_context.map((f) => `- \`${f}\``).join(`
 *Learned from swarm execution on ${new Date().toISOString().split("T")[0]}*`;
       const { getSkill: getSkill2, invalidateSkillsCache: invalidateSkillsCache2 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
       const { mkdir: mkdir2, writeFile: writeFile2 } = await import("node:fs/promises");
-      const { join: join5 } = await import("node:path");
+      const { join: join6 } = await import("node:path");
       const existing = await getSkill2(args.skill_name);
       if (existing) {
         return JSON.stringify({
@@ -32985,8 +33013,8 @@ ${args.files_context.map((f) => `- \`${f}\``).join(`
           suggestion: "Use skills_update to add to existing skill, or choose a different name"
         }, null, 2);
       }
-      const skillDir = join5(process.cwd(), ".opencode", "skills", args.skill_name);
-      const skillPath = join5(skillDir, "SKILL.md");
+      const skillDir = join6(process.cwd(), ".opencode", "skills", args.skill_name);
+      const skillPath = join6(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${args.skill_name}`,

package/dist/plugin.js

@@ -26166,7 +26166,7 @@ __export(exports_skills, {
 });
 import { readdir, readFile, stat, mkdir, writeFile, rm } from "fs/promises";
 import {
-  join as join4,
+  join as join5,
   basename,
   dirname as dirname2,
   resolve,
@@ -26214,19 +26214,19 @@ function validateSkillMetadata(raw, filePath) {
 }
 function getGlobalSkillsDir() {
   const home = process.env.HOME || process.env.USERPROFILE || "~";
-  return join4(home, ".config", "opencode", "skills");
+  return join5(home, ".config", "opencode", "skills");
 }
 function getClaudeGlobalSkillsDir() {
   const home = process.env.HOME || process.env.USERPROFILE || "~";
-  return join4(home, ".claude", "skills");
+  return join5(home, ".claude", "skills");
 }
 function getPackageSkillsDir() {
   try {
     const currentFilePath = fileURLToPath(import.meta.url);
-    return join4(dirname2(currentFilePath), "..", "global-skills");
+    return join5(dirname2(currentFilePath), "..", "global-skills");
   } catch {
     const currentDir = decodeURIComponent(new URL(".", import.meta.url).pathname);
-    return join4(currentDir, "..", "global-skills");
+    return join5(currentDir, "..", "global-skills");
   }
 }
 async function findSkillFiles(baseDir) {
@@ -26235,7 +26235,7 @@ async function findSkillFiles(baseDir) {
     const entries = await readdir(baseDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const skillPath = join4(baseDir, entry.name, "SKILL.md");
+        const skillPath = join5(baseDir, entry.name, "SKILL.md");
         try {
           const s = await stat(skillPath);
           if (s.isFile()) {
@@ -26249,7 +26249,7 @@ async function findSkillFiles(baseDir) {
 }
 async function findSkillScripts(skillDir) {
   const scripts = [];
-  const scriptsDir = join4(skillDir, "scripts");
+  const scriptsDir = join5(skillDir, "scripts");
   try {
     const entries = await readdir(scriptsDir, { withFileTypes: true });
     for (const entry of entries) {
@@ -26297,7 +26297,7 @@ async function discoverSkills(projectDir) {
     }
   }
   for (const relPath of PROJECT_SKILL_DIRECTORIES) {
-    await loadSkillsFromDir(join4(dir, relPath));
+    await loadSkillsFromDir(join5(dir, relPath));
   }
   await loadSkillsFromDir(getGlobalSkillsDir());
   await loadSkillsFromDir(getClaudeGlobalSkillsDir());
@@ -26653,7 +26653,7 @@ Scripts run in the skill's directory with the project directory as an argument.`
       if (!skill.scripts.includes(args.script)) {
         return `Script '${args.script}' not found in skill '${args.skill}'. Available: ${skill.scripts.join(", ") || "none"}`;
       }
-      const scriptPath = join4(skill.directory, "scripts", args.script);
+      const scriptPath = join5(skill.directory, "scripts", args.script);
       const scriptArgs = args.args || [];
       try {
         const TIMEOUT_MS = 60000;
@@ -26761,14 +26761,14 @@ Good skills have:
       const csoWarnings = validateCSOCompliance(args.name, args.description);
       let skillDir;
       if (args.directory === "global") {
-        skillDir = join4(getGlobalSkillsDir(), args.name);
+        skillDir = join5(getGlobalSkillsDir(), args.name);
       } else if (args.directory === "global-claude") {
-        skillDir = join4(getClaudeGlobalSkillsDir(), args.name);
+        skillDir = join5(getClaudeGlobalSkillsDir(), args.name);
       } else {
         const baseDir = args.directory || DEFAULT_SKILLS_DIR;
-        skillDir = join4(skillsProjectDirectory, baseDir, args.name);
+        skillDir = join5(skillsProjectDirectory, baseDir, args.name);
       }
-      const skillPath = join4(skillDir, "SKILL.md");
+      const skillPath = join5(skillDir, "SKILL.md");
       try {
         await mkdir(skillDir, { recursive: true });
         const content = generateSkillContent(args.name, args.description, args.body, { tags: args.tags, tools: args.tools });
@@ -26919,8 +26919,8 @@ executed with skills_execute. Use for:
       if (isAbsolute(args.script_name) || args.script_name.includes("..") || args.script_name.includes("/") || args.script_name.includes("\\") || basename(args.script_name) !== args.script_name) {
         return "Invalid script name. Use simple filenames without paths.";
       }
-      const scriptsDir = join4(skill.directory, "scripts");
-      const scriptPath = join4(scriptsDir, args.script_name);
+      const scriptsDir = join5(skill.directory, "scripts");
+      const scriptPath = join5(scriptsDir, args.script_name);
       try {
         await mkdir(scriptsDir, { recursive: true });
         await writeFile(scriptPath, args.content, {
@@ -26969,20 +26969,20 @@ Perfect for learning to create effective skills.`,
       }
       let skillDir;
       if (args.directory === "global") {
-        skillDir = join4(getGlobalSkillsDir(), args.name);
+        skillDir = join5(getGlobalSkillsDir(), args.name);
       } else {
         const baseDir = args.directory || DEFAULT_SKILLS_DIR;
-        skillDir = join4(skillsProjectDirectory, baseDir, args.name);
+        skillDir = join5(skillsProjectDirectory, baseDir, args.name);
       }
       const createdFiles = [];
       try {
         await mkdir(skillDir, { recursive: true });
-        const skillPath = join4(skillDir, "SKILL.md");
+        const skillPath = join5(skillDir, "SKILL.md");
         const skillContent = generateSkillTemplate(args.name, args.description);
         await writeFile(skillPath, skillContent, "utf-8");
         createdFiles.push("SKILL.md");
         if (args.include_example_script !== false) {
-          const scriptsDir = join4(skillDir, "scripts");
+          const scriptsDir = join5(skillDir, "scripts");
           await mkdir(scriptsDir, { recursive: true });
           const exampleScript = `#!/usr/bin/env bash
 # Example helper script for ${args.name}
@@ -26996,15 +26996,15 @@ echo "Project directory: $1"
 
 # TODO: Add actual script logic
 `;
-          const scriptPath = join4(scriptsDir, "example.sh");
+          const scriptPath = join5(scriptsDir, "example.sh");
           await writeFile(scriptPath, exampleScript, { mode: 493 });
           createdFiles.push("scripts/example.sh");
         }
         if (args.include_reference !== false) {
-          const refsDir = join4(skillDir, "references");
+          const refsDir = join5(skillDir, "references");
           await mkdir(refsDir, { recursive: true });
           const refContent = generateReferenceTemplate(args.name);
-          const refPath = join4(refsDir, "guide.md");
+          const refPath = join5(refsDir, "guide.md");
           await writeFile(refPath, refContent, "utf-8");
           createdFiles.push("references/guide.md");
         }
@@ -27056,8 +27056,11 @@ init_dist();
 import {
   createBeadsAdapter,
   FlushManager,
+  importFromJSONL,
   getSwarmMail
 } from "swarm-mail";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 
 // src/schemas/bead.ts
 init_zod();
@@ -27638,9 +27641,34 @@ async function getBeadsAdapter(projectKey) {
   const db = await swarmMail.getDatabase();
   const adapter = createBeadsAdapter(db, projectKey);
   await adapter.runMigrations();
+  await autoMigrateFromJSONL(adapter, projectKey);
   adapterCache.set(projectKey, adapter);
   return adapter;
 }
+async function autoMigrateFromJSONL(adapter, projectKey) {
+  const jsonlPath = join(projectKey, ".beads", "issues.jsonl");
+  if (!existsSync(jsonlPath)) {
+    return;
+  }
+  const existingBeads = await adapter.queryBeads(projectKey, { limit: 1 });
+  if (existingBeads.length > 0) {
+    return;
+  }
+  try {
+    const jsonlContent = readFileSync(jsonlPath, "utf-8");
+    const result = await importFromJSONL(adapter, projectKey, jsonlContent, {
+      skipExisting: true
+    });
+    if (result.created > 0 || result.updated > 0) {
+      console.log(`[beads] Auto-migrated ${result.created} beads from ${jsonlPath} (${result.skipped} skipped, ${result.errors.length} errors)`);
+    }
+    if (result.errors.length > 0) {
+      console.warn(`[beads] Migration errors:`, result.errors.slice(0, 5).map((e) => `${e.beadId}: ${e.error}`));
+    }
+  } catch (error45) {
+    console.warn(`[beads] Failed to auto-migrate from ${jsonlPath}:`, error45 instanceof Error ? error45.message : String(error45));
+  }
+}
 function formatBeadForOutput(adapterBead) {
   return {
     id: adapterBead.id,
@@ -28257,8 +28285,8 @@ function formatToolAvailability(availability) {
 
 // src/rate-limiter.ts
 var import_ioredis = __toESM(require_built3(), 1);
-import { mkdirSync, existsSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { mkdirSync, existsSync as existsSync2 } from "node:fs";
+import { dirname, join as join2 } from "node:path";
 import { homedir } from "node:os";
 var sqliteAvailable = false;
 var createDatabase = null;
@@ -28374,7 +28402,7 @@ class SqliteRateLimiter {
       throw new Error("SQLite is not available in this runtime (requires Bun)");
     }
     const dir = dirname(dbPath);
-    if (!existsSync(dir)) {
+    if (!existsSync2(dir)) {
       mkdirSync(dir, { recursive: true });
     }
     this.db = createDatabase(dbPath);
@@ -28519,7 +28547,7 @@ async function createRateLimiter(options2) {
   const {
     backend,
     redisUrl = process.env.OPENCODE_RATE_LIMIT_REDIS_URL || "redis://localhost:6379",
-    sqlitePath = process.env.OPENCODE_RATE_LIMIT_SQLITE_PATH || join(homedir(), ".config", "opencode", "rate-limits.db")
+    sqlitePath = process.env.OPENCODE_RATE_LIMIT_SQLITE_PATH || join2(homedir(), ".config", "opencode", "rate-limits.db")
   } = options2 || {};
   if (backend === "memory") {
     return new InMemoryRateLimiter;
@@ -28579,13 +28607,13 @@ async function getRateLimiter() {
 
 // src/agent-mail.ts
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   mkdirSync as mkdirSync2,
-  readFileSync,
+  readFileSync as readFileSync2,
   writeFileSync,
   unlinkSync
 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { tmpdir } from "os";
 var AGENT_MAIL_URL = "http://127.0.0.1:8765";
 var DEFAULT_TTL_SECONDS = 3600;
@@ -28609,16 +28637,16 @@ var RECOVERY_CONFIG = {
   restartCooldownMs: 1e4,
   enabled: process.env.OPENCODE_AGENT_MAIL_AUTO_RESTART !== "false"
 };
-var SESSION_STATE_DIR = process.env.SWARM_STATE_DIR || join2(tmpdir(), "swarm-sessions");
+var SESSION_STATE_DIR = process.env.SWARM_STATE_DIR || join3(tmpdir(), "swarm-sessions");
 function getSessionStatePath(sessionID) {
   const safeID = sessionID.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join2(SESSION_STATE_DIR, `${safeID}.json`);
+  return join3(SESSION_STATE_DIR, `${safeID}.json`);
 }
 function loadSessionState(sessionID) {
   const path = getSessionStatePath(sessionID);
   try {
-    if (existsSync2(path)) {
-      const data = readFileSync(path, "utf-8");
+    if (existsSync3(path)) {
+      const data = readFileSync2(path, "utf-8");
       return JSON.parse(data);
     }
   } catch (error45) {
@@ -28628,7 +28656,7 @@ function loadSessionState(sessionID) {
 }
 function saveSessionState(sessionID, state) {
   try {
-    if (!existsSync2(SESSION_STATE_DIR)) {
+    if (!existsSync3(SESSION_STATE_DIR)) {
       mkdirSync2(SESSION_STATE_DIR, { recursive: true });
     }
     const path = getSessionStatePath(sessionID);
@@ -29316,13 +29344,13 @@ import {
   getActiveReservations
 } from "swarm-mail";
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   writeFileSync as writeFileSync2,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 var MAX_INBOX_LIMIT2 = 5;
 var swarmMailProjectDirectory = null;
@@ -29332,16 +29360,16 @@ function setSwarmMailProjectDirectory(directory) {
 function getSwarmMailProjectDirectory() {
   return swarmMailProjectDirectory ?? undefined;
 }
-var SESSION_STATE_DIR2 = process.env.SWARM_STATE_DIR || join3(tmpdir2(), "swarm-sessions");
+var SESSION_STATE_DIR2 = process.env.SWARM_STATE_DIR || join4(tmpdir2(), "swarm-sessions");
 function getSessionStatePath2(sessionID) {
   const safeID = sessionID.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join3(SESSION_STATE_DIR2, `${safeID}.json`);
+  return join4(SESSION_STATE_DIR2, `${safeID}.json`);
 }
 function loadSessionState2(sessionID) {
   const path = getSessionStatePath2(sessionID);
   try {
-    if (existsSync3(path)) {
-      const data = readFileSync2(path, "utf-8");
+    if (existsSync4(path)) {
+      const data = readFileSync3(path, "utf-8");
       return JSON.parse(data);
     }
   } catch (error45) {
@@ -29351,7 +29379,7 @@ function loadSessionState2(sessionID) {
 }
 function saveSessionState2(sessionID, state) {
   try {
-    if (!existsSync3(SESSION_STATE_DIR2)) {
+    if (!existsSync4(SESSION_STATE_DIR2)) {
       mkdirSync3(SESSION_STATE_DIR2, { recursive: true });
     }
     const path = getSessionStatePath2(sessionID);
@@ -32756,7 +32784,7 @@ ${args.files_context.map((f) => `- \`${f}\``).join(`
 *Learned from swarm execution on ${new Date().toISOString().split("T")[0]}*`;
       const { getSkill: getSkill2, invalidateSkillsCache: invalidateSkillsCache2 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
       const { mkdir: mkdir2, writeFile: writeFile2 } = await import("node:fs/promises");
-      const { join: join5 } = await import("node:path");
+      const { join: join6 } = await import("node:path");
       const existing = await getSkill2(args.skill_name);
       if (existing) {
         return JSON.stringify({
@@ -32767,8 +32795,8 @@ ${args.files_context.map((f) => `- \`${f}\``).join(`
           suggestion: "Use skills_update to add to existing skill, or choose a different name"
         }, null, 2);
       }
-      const skillDir = join5(process.cwd(), ".opencode", "skills", args.skill_name);
-      const skillPath = join5(skillDir, "SKILL.md");
+      const skillDir = join6(process.cwd(), ".opencode", "skills", args.skill_name);
+      const skillPath = join6(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${args.skill_name}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.25.3",
+  "version": "0.26.1",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",
@@ -33,7 +33,7 @@
     "@opencode-ai/plugin": "^1.0.134",
     "gray-matter": "^4.0.3",
     "ioredis": "^5.4.1",
-    "swarm-mail": "0.1.4",
+    "swarm-mail": "0.2.1",
     "zod": "4.1.8"
   },
   "devDependencies": {

package/src/beads.ts

@@ -18,10 +18,13 @@ import { z } from "zod";
 import {
   createBeadsAdapter,
   FlushManager,
+  importFromJSONL,
   type BeadsAdapter,
   type Bead as AdapterBead,
   getSwarmMail,
 } from "swarm-mail";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 
 // ============================================================================
 // Working Directory Configuration
@@ -130,6 +133,9 @@ const adapterCache = new Map<string, BeadsAdapter>();
 /**
  * Get or create a BeadsAdapter instance for a project
  * Exported for testing - allows tests to verify state directly
+ * 
+ * On first initialization, checks for .beads/issues.jsonl and imports
+ * historical beads if the database is empty.
  */
 export async function getBeadsAdapter(projectKey: string): Promise<BeadsAdapter> {
   if (adapterCache.has(projectKey)) {
@@ -143,10 +149,62 @@ export async function getBeadsAdapter(projectKey: string): Promise<BeadsAdapter>
   // Run migrations to ensure schema exists
   await adapter.runMigrations();
 
+  // Auto-migrate from JSONL if database is empty and file exists
+  await autoMigrateFromJSONL(adapter, projectKey);
+
   adapterCache.set(projectKey, adapter);
   return adapter;
 }
 
+/**
+ * Auto-migrate beads from .beads/issues.jsonl if:
+ * 1. The JSONL file exists
+ * 2. The database has no beads for this project
+ * 
+ * This enables seamless migration from the old bd CLI to the new PGLite-based system.
+ */
+async function autoMigrateFromJSONL(adapter: BeadsAdapter, projectKey: string): Promise<void> {
+  const jsonlPath = join(projectKey, ".beads", "issues.jsonl");
+  
+  // Check if JSONL file exists
+  if (!existsSync(jsonlPath)) {
+    return;
+  }
+
+  // Check if database already has beads
+  const existingBeads = await adapter.queryBeads(projectKey, { limit: 1 });
+  if (existingBeads.length > 0) {
+    return; // Already have beads, skip migration
+  }
+
+  // Read and import JSONL
+  try {
+    const jsonlContent = readFileSync(jsonlPath, "utf-8");
+    const result = await importFromJSONL(adapter, projectKey, jsonlContent, {
+      skipExisting: true, // Safety: don't overwrite if somehow beads exist
+    });
+
+    if (result.created > 0 || result.updated > 0) {
+      console.log(
+        `[beads] Auto-migrated ${result.created} beads from ${jsonlPath} (${result.skipped} skipped, ${result.errors.length} errors)`
+      );
+    }
+
+    if (result.errors.length > 0) {
+      console.warn(
+        `[beads] Migration errors:`,
+        result.errors.slice(0, 5).map((e) => `${e.beadId}: ${e.error}`)
+      );
+    }
+  } catch (error) {
+    // Non-fatal - log and continue
+    console.warn(
+      `[beads] Failed to auto-migrate from ${jsonlPath}:`,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+
 /**
  * Format adapter bead for output (map field names)
  * Adapter uses: type, created_at/updated_at (timestamps)