opencode-swarm-plugin 0.27.4 → 0.28.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 200 modules in 35ms
+Bundled 200 modules in 34ms
 
-  index.js  1.19 MB  (entry point)
+  index.js  1.20 MB  (entry point)
 
-Bundled 201 modules in 33ms
+Bundled 201 modules in 34ms
 
   plugin.js  1.16 MB  (entry point)
 

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # opencode-swarm-plugin
 
+## 0.28.1
+
+### Patch Changes
+
+- [`0ee4f65`](https://github.com/joelhooks/swarm-tools/commit/0ee4f656c2fb2cf62d3ef06d329d9e093d124c33) Thanks [@joelhooks](https://github.com/joelhooks)! - Add postinstall hint and update repo URL
+
+  - Show "Run swarm setup" hint after npm install
+  - Update repo URL to github.com/joelhooks/swarm-tools
+  - Add "Get started" commands to version output
+
+## 0.28.0
+
+### Minor Changes
+
+- [`de2fa62`](https://github.com/joelhooks/swarm-tools/commit/de2fa628524b88511e06164104ff7b5fb93d39e5) Thanks [@joelhooks](https://github.com/joelhooks)! - Add full beads→hive migration pipeline with JSONL import to PGLite
+
+  - Add `mergeHistoricBeads()` to merge beads.base.jsonl into issues.jsonl
+  - Add `importJsonlToPGLite()` to import JSONL records into PGLite database
+  - Wire both functions into `swarm setup` migration flow
+  - Fix closed_at constraint issue when importing closed cells
+  - TDD: 12 new integration tests for migration functions
+
 ## 0.27.4
 
 ### Patch Changes

package/bin/swarm.ts

@@ -30,6 +30,8 @@ import { fileURLToPath } from "url";
 import {
   checkBeadsMigrationNeeded,
   migrateBeadsToHive,
+  mergeHistoricBeads,
+  importJsonlToPGLite,
 } from "../src/hive";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -1581,6 +1583,18 @@ async function setup() {
         if (result.migrated) {
           migrateSpinner.stop("Migration complete");
           p.log.success("Renamed .beads/ → .hive/");
+          
+          // Merge historic beads into issues.jsonl
+          const mergeResult = await mergeHistoricBeads(cwd);
+          if (mergeResult.merged > 0) {
+            p.log.success(`Merged ${mergeResult.merged} historic beads (${mergeResult.skipped} already present)`);
+          }
+          
+          // Import JSONL into PGLite database
+          const importResult = await importJsonlToPGLite(cwd);
+          if (importResult.imported > 0 || importResult.updated > 0) {
+            p.log.success(`Database: ${importResult.imported} imported, ${importResult.updated} updated`);
+          }
         } else {
           migrateSpinner.stop("Migration skipped");
           p.log.warn(result.reason || "Unknown reason");
@@ -1952,7 +1966,11 @@ async function version() {
   console.log(dim("  " + TAGLINE));
   console.log();
   console.log("  Version: " + VERSION);
-  console.log("  Docs:    https://github.com/joelhooks/opencode-swarm-plugin");
+  console.log("  Docs:    https://github.com/joelhooks/swarm-tools");
+  console.log();
+  console.log(cyan("  Get started:"));
+  console.log("    swarm setup    " + dim("Configure OpenCode integration"));
+  console.log("    swarm doctor   " + dim("Check dependencies"));
   console.log();
 
   // Check for updates (non-blocking)

package/dist/hive.d.ts

@@ -80,6 +80,40 @@ export declare function migrateBeadsToHive(projectPath: string): Promise<Migrati
  * @param projectPath - Absolute path to the project root
  */
 export declare function ensureHiveDirectory(projectPath: string): void;
+/**
+ * Merge historic beads from beads.base.jsonl into issues.jsonl
+ *
+ * This function reads beads.base.jsonl (historic data) and issues.jsonl (current data),
+ * merges them by ID (issues.jsonl version wins for duplicates), and writes the result
+ * back to issues.jsonl.
+ *
+ * Use case: After migrating from .beads to .hive, you may have a beads.base.jsonl file
+ * containing old beads that should be merged into the current issues.jsonl.
+ *
+ * @param projectPath - Absolute path to the project root
+ * @returns Object with merged and skipped counts
+ */
+export declare function mergeHistoricBeads(projectPath: string): Promise<{
+    merged: number;
+    skipped: number;
+}>;
+/**
+ * Import cells from .hive/issues.jsonl into PGLite database
+ *
+ * Reads the JSONL file and upserts each record into the cells table
+ * using the HiveAdapter. Provides granular error reporting for invalid lines.
+ *
+ * This function manually parses JSONL line-by-line to gracefully handle
+ * invalid JSON without throwing. Each valid line is imported via the adapter.
+ *
+ * @param projectPath - Absolute path to the project root
+ * @returns Object with imported, updated, and error counts
+ */
+export declare function importJsonlToPGLite(projectPath: string): Promise<{
+    imported: number;
+    updated: number;
+    errors: number;
+}>;
 /**
  * Get or create a HiveAdapter instance for a project
  * Exported for testing - allows tests to verify state directly

package/dist/hive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hive.d.ts","sourceRoot":"","sources":["../src/hive.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"hive.d.ts","sourceRoot":"","sources":["../src/hive.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -27778,6 +27778,110 @@ function ensureHiveDirectory(projectPath) {
     mkdirSync(hiveDir, { recursive: true });
   }
 }
+async function mergeHistoricBeads(projectPath) {
+  const { readFileSync: readFileSync2, writeFileSync, existsSync: existsSync2 } = await import("node:fs");
+  const hiveDir = join(projectPath, ".hive");
+  const basePath = join(hiveDir, "beads.base.jsonl");
+  const issuesPath = join(hiveDir, "issues.jsonl");
+  if (!existsSync2(basePath)) {
+    return { merged: 0, skipped: 0 };
+  }
+  const baseContent = readFileSync2(basePath, "utf-8");
+  const baseLines = baseContent.trim().split(`
+`).filter((l) => l);
+  const baseBeads = baseLines.map((line) => JSON.parse(line));
+  let issuesBeads = [];
+  if (existsSync2(issuesPath)) {
+    const issuesContent = readFileSync2(issuesPath, "utf-8");
+    const issuesLines = issuesContent.trim().split(`
+`).filter((l) => l);
+    issuesBeads = issuesLines.map((line) => JSON.parse(line));
+  }
+  const existingIds = new Set(issuesBeads.map((b) => b.id));
+  let merged = 0;
+  let skipped = 0;
+  for (const baseBead of baseBeads) {
+    if (existingIds.has(baseBead.id)) {
+      skipped++;
+    } else {
+      issuesBeads.push(baseBead);
+      merged++;
+    }
+  }
+  const mergedContent = issuesBeads.map((b) => JSON.stringify(b)).join(`
+`) + `
+`;
+  writeFileSync(issuesPath, mergedContent, "utf-8");
+  return { merged, skipped };
+}
+async function importJsonlToPGLite(projectPath) {
+  const jsonlPath = join(projectPath, ".hive", "issues.jsonl");
+  if (!existsSync(jsonlPath)) {
+    return { imported: 0, updated: 0, errors: 0 };
+  }
+  const jsonlContent = readFileSync(jsonlPath, "utf-8");
+  if (!jsonlContent || jsonlContent.trim() === "") {
+    return { imported: 0, updated: 0, errors: 0 };
+  }
+  const adapter = await getHiveAdapter(projectPath);
+  const lines = jsonlContent.split(`
+`).filter((l) => l.trim());
+  let imported = 0;
+  let updated = 0;
+  let errors3 = 0;
+  for (const line of lines) {
+    try {
+      const cellData = JSON.parse(line);
+      const existing = await adapter.getCell(projectPath, cellData.id);
+      if (existing) {
+        try {
+          await adapter.updateCell(projectPath, cellData.id, {
+            title: cellData.title,
+            description: cellData.description,
+            priority: cellData.priority,
+            assignee: cellData.assignee
+          });
+          if (existing.status !== cellData.status) {
+            if (cellData.status === "closed") {
+              await adapter.closeCell(projectPath, cellData.id, "Imported from JSONL");
+            } else {
+              await adapter.changeCellStatus(projectPath, cellData.id, cellData.status);
+            }
+          }
+          updated++;
+        } catch (updateError) {
+          errors3++;
+        }
+      } else {
+        const db = await adapter.getDatabase();
+        const status = cellData.status === "tombstone" ? "closed" : cellData.status;
+        const isClosed = status === "closed";
+        const closedAt = isClosed ? cellData.closed_at ? new Date(cellData.closed_at).getTime() : new Date(cellData.updated_at).getTime() : null;
+        await db.query(`INSERT INTO cells (
+            id, project_key, type, status, title, description, priority,
+            parent_id, assignee, created_at, updated_at, closed_at
+          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`, [
+          cellData.id,
+          projectPath,
+          cellData.issue_type,
+          status,
+          cellData.title,
+          cellData.description || null,
+          cellData.priority,
+          cellData.parent_id || null,
+          cellData.assignee || null,
+          new Date(cellData.created_at).getTime(),
+          new Date(cellData.updated_at).getTime(),
+          closedAt
+        ]);
+        imported++;
+      }
+    } catch (error45) {
+      errors3++;
+    }
+  }
+  return { imported, updated, errors: errors3 };
+}
 var adapterCache = new Map;
 async function getHiveAdapter(projectKey) {
   if (adapterCache.has(projectKey)) {
@@ -35998,6 +36102,7 @@ export {
   repoCrawlTools,
   parseFrontmatter,
   migrateBeadsToHive,
+  mergeHistoricBeads,
   mcpCallWithAutoInit,
   mandateTools,
   mandateSchemas,
@@ -36012,6 +36117,7 @@ export {
   isAgentNotFoundError,
   isAgentEvent,
   invalidateSkillsCache,
+  importJsonlToPGLite,
   ifToolAvailable,
   hive_update,
   hive_sync,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.27.4",
+  "version": "0.28.1",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",
@@ -26,7 +26,8 @@
     "test:all": "bun test --timeout 60000 src/",
     "test:watch": "bun test --watch src/",
     "typecheck": "tsc --noEmit",
-    "publish:pkg": "npm publish --access public --provenance"
+    "publish:pkg": "npm publish --access public --provenance",
+    "postinstall": "node -e \"console.log('\\n\\x1b[33m  Run \\x1b[36mswarm setup\\x1b[33m to configure OpenCode integration\\x1b[0m\\n')\""
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
@@ -65,6 +66,6 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/joelhooks/opencode-swarm-plugin"
+    "url": "https://github.com/joelhooks/swarm-tools"
   }
 }

package/src/hive.integration.test.ts

@@ -830,4 +830,510 @@ describe("beads integration", () => {
       rmSync(tempProject, { recursive: true, force: true });
     });
   });
+
+  describe("importJsonlToPGLite", () => {
+    it("imports empty JSONL - no-op", async () => {
+      const { importJsonlToPGLite } = await import("./hive");
+      const { mkdirSync, rmSync, writeFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      // Create temp project with empty JSONL
+      const tempProject = join(tmpdir(), `hive-import-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      writeFileSync(join(hiveDir, "issues.jsonl"), "");
+
+      const result = await importJsonlToPGLite(tempProject);
+
+      expect(result.imported).toBe(0);
+      expect(result.updated).toBe(0);
+      expect(result.errors).toBe(0);
+
+      // Cleanup
+      rmSync(tempProject, { recursive: true, force: true });
+    });
+
+    it("imports new records - all inserted", async () => {
+      const { importJsonlToPGLite, getHiveAdapter } = await import("./hive");
+      const { mkdirSync, rmSync, writeFileSync, unlinkSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      // Create temp project with new cells
+      const tempProject = join(tmpdir(), `hive-import-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+
+      const cell1 = {
+        id: "bd-import-1",
+        title: "Import test 1",
+        status: "open" as const,
+        priority: 2,
+        issue_type: "task" as const,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        dependencies: [],
+        labels: [],
+        comments: [],
+      };
+
+      const cell2 = {
+        id: "bd-import-2",
+        title: "Import test 2",
+        status: "in_progress" as const,
+        priority: 1,
+        issue_type: "bug" as const,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        dependencies: [],
+        labels: [],
+        comments: [],
+      };
+
+      writeFileSync(
+        join(hiveDir, "issues.jsonl"),
+        JSON.stringify(cell1) + "\n" + JSON.stringify(cell2) + "\n"
+      );
+
+      // CRITICAL: Call importJsonlToPGLite() which will call getHiveAdapter()
+      // The auto-migration will import cells, so we expect 0 imported here
+      // because auto-migration already did it
+      const result = await importJsonlToPGLite(tempProject);
+
+      // Auto-migration runs on first getHiveAdapter() call and imports cells
+      // So when importJsonlToPGLite() runs, cells are already there
+      // This is expected behavior - the function is idempotent
+      expect(result.imported + result.updated).toBe(2);
+      expect(result.errors).toBe(0);
+
+      // Verify cells exist in database
+      const adapter = await getHiveAdapter(tempProject);
+      const importedCell1 = await adapter.getCell(tempProject, "bd-import-1");
+      const importedCell2 = await adapter.getCell(tempProject, "bd-import-2");
+
+      expect(importedCell1).toBeDefined();
+      expect(importedCell1!.title).toBe("Import test 1");
+      expect(importedCell2).toBeDefined();
+      expect(importedCell2!.title).toBe("Import test 2");
+
+      // Cleanup
+      rmSync(tempProject, { recursive: true, force: true });
+    });
+
+    it("updates existing records", async () => {
+      const { importJsonlToPGLite, getHiveAdapter } = await import("./hive");
+      const { mkdirSync, rmSync, writeFileSync, unlinkSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      // Create temp project
+      const tempProject = join(tmpdir(), `hive-import-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+
+      // Write JSONL FIRST (before getHiveAdapter to avoid auto-migration)
+      const originalCell = {
+        id: "bd-update-1",
+        title: "Original title",
+        status: "open",
+        priority: 2,
+        issue_type: "task",
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        dependencies: [],
+        labels: [],
+        comments: [],
+      };
+
+      writeFileSync(
+        join(hiveDir, "issues.jsonl"),
+        JSON.stringify(originalCell) + "\n"
+      );
+
+      // Get adapter - this will auto-migrate the original cell
+      const adapter = await getHiveAdapter(tempProject);
+
+      // Now update the JSONL with new data
+      const updatedCell = {
+        ...originalCell,
+        title: "Updated title",
+        description: "New description",
+        status: "in_progress" as const,
+        priority: 0,
+        updated_at: new Date().toISOString(),
+      };
+
+      writeFileSync(
+        join(hiveDir, "issues.jsonl"),
+        JSON.stringify(updatedCell) + "\n"
+      );
+
+      const result = await importJsonlToPGLite(tempProject);
+
+      expect(result.imported).toBe(0);
+      expect(result.updated).toBe(1);
+      expect(result.errors).toBe(0);
+
+      // Verify update
+      const cell = await adapter.getCell(tempProject, "bd-update-1");
+      expect(cell).toBeDefined();
+      expect(cell!.title).toBe("Updated title");
+      expect(cell!.description).toContain("New description");
+      expect(cell!.status).toBe("in_progress");
+
+      // Cleanup
+      rmSync(tempProject, { recursive: true, force: true });
+    });
+
+    it("handles mixed new and existing records", async () => {
+      const { importJsonlToPGLite, getHiveAdapter } = await import("./hive");
+      const { mkdirSync, rmSync, writeFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      // Create temp project with NO initial JSONL (avoid auto-migration)
+      const tempProject = join(tmpdir(), `hive-import-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+
+      // Get adapter first (no auto-migration since no JSONL exists)
+      const adapter = await getHiveAdapter(tempProject);
+
+      // Create existing cell directly via adapter
+      await adapter.createCell(tempProject, {
+        title: "Existing",
+        type: "task",
+        priority: 2,
+      });
+
+      // Get the created cell to find its ID
+      const cells = await adapter.queryCells(tempProject, { limit: 1 });
+      const existingId = cells[0].id;
+
+      // Now write JSONL with updated existing + new cell
+      const existingUpdated = {
+        id: existingId,
+        title: "Existing updated",
+        status: "closed" as const,
+        priority: 2,
+        issue_type: "task" as const,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        closed_at: new Date().toISOString(),
+        dependencies: [],
+        labels: [],
+        comments: [],
+      };
+
+      const newCell = {
+        id: "bd-new",
+        title: "Brand new",
+        status: "open" as const,
+        priority: 1,
+        issue_type: "feature" as const,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        dependencies: [],
+        labels: [],
+        comments: [],
+      };
+
+      writeFileSync(
+        join(hiveDir, "issues.jsonl"),
+        JSON.stringify(existingUpdated) + "\n" + JSON.stringify(newCell) + "\n"
+      );
+
+      const result = await importJsonlToPGLite(tempProject);
+
+      // importJsonlToPGLite() finds:
+      // - existingId already exists (updated)
+      // - bd-new is new (imported)
+      expect(result.imported).toBe(1); // bd-new
+      expect(result.updated).toBe(1); // existing cell
+      expect(result.errors).toBe(0);
+
+      // Cleanup
+      rmSync(tempProject, { recursive: true, force: true });
+    });
+
+    it("skips invalid JSON lines and counts errors", async () => {
+      const { importJsonlToPGLite } = await import("./hive");
+      const { mkdirSync, rmSync, writeFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      // Create temp project
+      const tempProject = join(tmpdir(), `hive-import-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+
+      const validCell = {
+        id: "bd-valid",
+        title: "Valid",
+        status: "open",
+        priority: 2,
+        issue_type: "task",
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        dependencies: [],
+        labels: [],
+        comments: [],
+      };
+
+      // Mix valid and invalid JSON
+      writeFileSync(
+        join(hiveDir, "issues.jsonl"),
+        JSON.stringify(validCell) + "\n" +
+        "{ invalid json \n" +
+        '{"id":"incomplete"\n'
+      );
+
+      const result = await importJsonlToPGLite(tempProject);
+
+      expect(result.imported).toBe(1); // Only the valid one
+      expect(result.errors).toBe(2); // Two invalid lines
+
+      // Cleanup
+      rmSync(tempProject, { recursive: true, force: true });
+    });
+
+    it("handles missing JSONL file gracefully", async () => {
+      const { importJsonlToPGLite } = await import("./hive");
+      const { mkdirSync, rmSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      // Create temp project without issues.jsonl
+      const tempProject = join(tmpdir(), `hive-import-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+
+      const result = await importJsonlToPGLite(tempProject);
+
+      expect(result.imported).toBe(0);
+      expect(result.updated).toBe(0);
+      expect(result.errors).toBe(0);
+
+      // Cleanup
+      rmSync(tempProject, { recursive: true, force: true });
+    });
+  });
+
+  describe("mergeHistoricBeads", () => {
+    it("merges empty base file - no changes", async () => {
+      const { mergeHistoricBeads } = await import("./hive");
+      const { mkdirSync, rmSync, writeFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+      
+      // Create temp project with .hive directory
+      const tempProject = join(tmpdir(), `hive-merge-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      
+      // Create empty base file
+      writeFileSync(join(hiveDir, "beads.base.jsonl"), "");
+      
+      // Create issues.jsonl with one bead
+      const existingBead = { id: "bd-existing", title: "Existing bead" };
+      writeFileSync(join(hiveDir, "issues.jsonl"), JSON.stringify(existingBead) + "\n");
+      
+      const result = await mergeHistoricBeads(tempProject);
+      
+      expect(result.merged).toBe(0);
+      expect(result.skipped).toBe(0);
+      
+      // Cleanup
+      rmSync(tempProject, { recursive: true, force: true });
+    });
+
+    it("merges empty issues file - all base records imported", async () => {
+      const { mergeHistoricBeads } = await import("./hive");
+      const { mkdirSync, rmSync, writeFileSync, readFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+      
+      // Create temp project
+      const tempProject = join(tmpdir(), `hive-merge-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      
+      // Create base file with 2 beads
+      const baseBead1 = { id: "bd-base-1", title: "Historic bead 1" };
+      const baseBead2 = { id: "bd-base-2", title: "Historic bead 2" };
+      writeFileSync(
+        join(hiveDir, "beads.base.jsonl"),
+        JSON.stringify(baseBead1) + "\n" + JSON.stringify(baseBead2) + "\n"
+      );
+      
+      // Empty issues file
+      writeFileSync(join(hiveDir, "issues.jsonl"), "");
+      
+      const result = await mergeHistoricBeads(tempProject);
+      
+      expect(result.merged).toBe(2);
+      expect(result.skipped).toBe(0);
+      
+      // Verify issues.jsonl now has both beads
+      const issuesContent = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+      const lines = issuesContent.trim().split("\n").filter(l => l);
+      expect(lines).toHaveLength(2);
+      
+      const beads = lines.map(line => JSON.parse(line));
+      expect(beads.find(b => b.id === "bd-base-1")).toBeDefined();
+      expect(beads.find(b => b.id === "bd-base-2")).toBeDefined();
+      
+      // Cleanup
+      rmSync(tempProject, { recursive: true, force: true });
+    });
+
+    it("overlapping IDs - issues.jsonl wins (more recent)", async () => {
+      const { mergeHistoricBeads } = await import("./hive");
+      const { mkdirSync, rmSync, writeFileSync, readFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+      
+      // Create temp project
+      const tempProject = join(tmpdir(), `hive-merge-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      
+      // Base has old version of bd-overlap
+      const baseOldVersion = { id: "bd-overlap", title: "Old title", status: "open" };
+      writeFileSync(
+        join(hiveDir, "beads.base.jsonl"),
+        JSON.stringify(baseOldVersion) + "\n"
+      );
+      
+      // Issues has new version (updated)
+      const issuesNewVersion = { id: "bd-overlap", title: "New title", status: "closed" };
+      writeFileSync(
+        join(hiveDir, "issues.jsonl"),
+        JSON.stringify(issuesNewVersion) + "\n"
+      );
+      
+      const result = await mergeHistoricBeads(tempProject);
+      
+      expect(result.merged).toBe(0); // Nothing new to merge
+      expect(result.skipped).toBe(1); // Skipped the old version
+      
+      // Verify issues.jsonl still has new version (unchanged)
+      const issuesContent = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+      const bead = JSON.parse(issuesContent.trim());
+      expect(bead.title).toBe("New title");
+      expect(bead.status).toBe("closed");
+      
+      // Cleanup
+      rmSync(tempProject, { recursive: true, force: true });
+    });
+
+    it("no overlap - all records combined", async () => {
+      const { mergeHistoricBeads } = await import("./hive");
+      const { mkdirSync, rmSync, writeFileSync, readFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+      
+      // Create temp project
+      const tempProject = join(tmpdir(), `hive-merge-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      
+      // Base has 2 beads
+      const baseBead1 = { id: "bd-base-1", title: "Historic 1" };
+      const baseBead2 = { id: "bd-base-2", title: "Historic 2" };
+      writeFileSync(
+        join(hiveDir, "beads.base.jsonl"),
+        JSON.stringify(baseBead1) + "\n" + JSON.stringify(baseBead2) + "\n"
+      );
+      
+      // Issues has 2 different beads
+      const issuesBead1 = { id: "bd-current-1", title: "Current 1" };
+      const issuesBead2 = { id: "bd-current-2", title: "Current 2" };
+      writeFileSync(
+        join(hiveDir, "issues.jsonl"),
+        JSON.stringify(issuesBead1) + "\n" + JSON.stringify(issuesBead2) + "\n"
+      );
+      
+      const result = await mergeHistoricBeads(tempProject);
+      
+      expect(result.merged).toBe(2); // Added 2 from base
+      expect(result.skipped).toBe(0);
+      
+      // Verify issues.jsonl now has all 4 beads
+      const issuesContent = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+      const lines = issuesContent.trim().split("\n").filter(l => l);
+      expect(lines).toHaveLength(4);
+      
+      const beads = lines.map(line => JSON.parse(line));
+      expect(beads.find(b => b.id === "bd-base-1")).toBeDefined();
+      expect(beads.find(b => b.id === "bd-base-2")).toBeDefined();
+      expect(beads.find(b => b.id === "bd-current-1")).toBeDefined();
+      expect(beads.find(b => b.id === "bd-current-2")).toBeDefined();
+      
+      // Cleanup
+      rmSync(tempProject, { recursive: true, force: true });
+    });
+
+    it("missing base file - graceful handling", async () => {
+      const { mergeHistoricBeads } = await import("./hive");
+      const { mkdirSync, rmSync, writeFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+      
+      // Create temp project with .hive but NO base file
+      const tempProject = join(tmpdir(), `hive-merge-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      
+      // Issues exists, base doesn't
+      const issuesBead = { id: "bd-current", title: "Current" };
+      writeFileSync(join(hiveDir, "issues.jsonl"), JSON.stringify(issuesBead) + "\n");
+      
+      const result = await mergeHistoricBeads(tempProject);
+      
+      // Should return zeros, not throw
+      expect(result.merged).toBe(0);
+      expect(result.skipped).toBe(0);
+      
+      // Cleanup
+      rmSync(tempProject, { recursive: true, force: true });
+    });
+
+    it("missing issues file - creates it from base", async () => {
+      const { mergeHistoricBeads } = await import("./hive");
+      const { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+      
+      // Create temp project with base but NO issues file
+      const tempProject = join(tmpdir(), `hive-merge-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      
+      // Base exists, issues doesn't
+      const baseBead = { id: "bd-base", title: "Historic" };
+      writeFileSync(
+        join(hiveDir, "beads.base.jsonl"),
+        JSON.stringify(baseBead) + "\n"
+      );
+      
+      const issuesPath = join(hiveDir, "issues.jsonl");
+      expect(existsSync(issuesPath)).toBe(false);
+      
+      const result = await mergeHistoricBeads(tempProject);
+      
+      expect(result.merged).toBe(1);
+      expect(result.skipped).toBe(0);
+      
+      // Verify issues.jsonl was created
+      expect(existsSync(issuesPath)).toBe(true);
+      const content = readFileSync(issuesPath, "utf-8");
+      const bead = JSON.parse(content.trim());
+      expect(bead.id).toBe("bd-base");
+      
+      // Cleanup
+      rmSync(tempProject, { recursive: true, force: true });
+    });
+  });
 });

package/src/hive.ts

@@ -235,6 +235,183 @@ export function ensureHiveDirectory(projectPath: string): void {
   }
 }
 
+/**
+ * Merge historic beads from beads.base.jsonl into issues.jsonl
+ * 
+ * This function reads beads.base.jsonl (historic data) and issues.jsonl (current data),
+ * merges them by ID (issues.jsonl version wins for duplicates), and writes the result
+ * back to issues.jsonl.
+ * 
+ * Use case: After migrating from .beads to .hive, you may have a beads.base.jsonl file
+ * containing old beads that should be merged into the current issues.jsonl.
+ * 
+ * @param projectPath - Absolute path to the project root
+ * @returns Object with merged and skipped counts
+ */
+export async function mergeHistoricBeads(projectPath: string): Promise<{merged: number, skipped: number}> {
+  const { readFileSync, writeFileSync, existsSync } = await import("node:fs");
+  const hiveDir = join(projectPath, ".hive");
+  const basePath = join(hiveDir, "beads.base.jsonl");
+  const issuesPath = join(hiveDir, "issues.jsonl");
+  
+  // If base file doesn't exist, nothing to merge
+  if (!existsSync(basePath)) {
+    return { merged: 0, skipped: 0 };
+  }
+  
+  // Read base file
+  const baseContent = readFileSync(basePath, "utf-8");
+  const baseLines = baseContent.trim().split("\n").filter(l => l);
+  const baseBeads = baseLines.map(line => JSON.parse(line));
+  
+  // Read issues file (or create empty if missing)
+  let issuesBeads: any[] = [];
+  if (existsSync(issuesPath)) {
+    const issuesContent = readFileSync(issuesPath, "utf-8");
+    const issuesLines = issuesContent.trim().split("\n").filter(l => l);
+    issuesBeads = issuesLines.map(line => JSON.parse(line));
+  }
+  
+  // Build set of existing IDs in issues.jsonl
+  const existingIds = new Set(issuesBeads.map(b => b.id));
+  
+  // Merge: add beads from base that aren't in issues
+  let merged = 0;
+  let skipped = 0;
+  
+  for (const baseBead of baseBeads) {
+    if (existingIds.has(baseBead.id)) {
+      skipped++;
+    } else {
+      issuesBeads.push(baseBead);
+      merged++;
+    }
+  }
+  
+  // Write merged result back to issues.jsonl
+  const mergedContent = issuesBeads.map(b => JSON.stringify(b)).join("\n") + "\n";
+  writeFileSync(issuesPath, mergedContent, "utf-8");
+  
+  return { merged, skipped };
+}
+
+/**
+ * Import cells from .hive/issues.jsonl into PGLite database
+ * 
+ * Reads the JSONL file and upserts each record into the cells table
+ * using the HiveAdapter. Provides granular error reporting for invalid lines.
+ * 
+ * This function manually parses JSONL line-by-line to gracefully handle
+ * invalid JSON without throwing. Each valid line is imported via the adapter.
+ * 
+ * @param projectPath - Absolute path to the project root
+ * @returns Object with imported, updated, and error counts
+ */
+export async function importJsonlToPGLite(projectPath: string): Promise<{
+  imported: number;
+  updated: number;
+  errors: number;
+}> {
+  const jsonlPath = join(projectPath, ".hive", "issues.jsonl");
+  
+  // Handle missing file gracefully
+  if (!existsSync(jsonlPath)) {
+    return { imported: 0, updated: 0, errors: 0 };
+  }
+  
+  // Read JSONL content
+  const jsonlContent = readFileSync(jsonlPath, "utf-8");
+  
+  // Handle empty file
+  if (!jsonlContent || jsonlContent.trim() === "") {
+    return { imported: 0, updated: 0, errors: 0 };
+  }
+  
+  // Get adapter - but we need to prevent auto-migration from running
+  // Auto-migration only runs if DB is empty, so we check first
+  const adapter = await getHiveAdapter(projectPath);
+  
+  // Parse JSONL line-by-line, tolerating invalid JSON
+  const lines = jsonlContent.split("\n").filter(l => l.trim());
+  let imported = 0;
+  let updated = 0;
+  let errors = 0;
+  
+  for (const line of lines) {
+    try {
+      const cellData = JSON.parse(line);
+      
+      // Check if cell exists
+      const existing = await adapter.getCell(projectPath, cellData.id);
+      
+      if (existing) {
+        // Update existing cell
+        try {
+          await adapter.updateCell(projectPath, cellData.id, {
+            title: cellData.title,
+            description: cellData.description,
+            priority: cellData.priority,
+            assignee: cellData.assignee,
+          });
+          
+          // Update status if needed - use closeCell for 'closed' status
+          if (existing.status !== cellData.status) {
+            if (cellData.status === "closed") {
+              await adapter.closeCell(projectPath, cellData.id, "Imported from JSONL");
+            } else {
+              await adapter.changeCellStatus(projectPath, cellData.id, cellData.status);
+            }
+          }
+          
+          updated++;
+        } catch (updateError) {
+          // Update failed - count as error
+          errors++;
+        }
+      } else {
+        // Create new cell - use direct DB insert to preserve ID
+        const db = await adapter.getDatabase();
+        
+        const status = cellData.status === "tombstone" ? "closed" : cellData.status;
+        const isClosed = status === "closed";
+        const closedAt = isClosed
+          ? (cellData.closed_at 
+              ? new Date(cellData.closed_at).getTime() 
+              : new Date(cellData.updated_at).getTime())
+          : null;
+        
+        await db.query(
+          `INSERT INTO cells (
+            id, project_key, type, status, title, description, priority,
+            parent_id, assignee, created_at, updated_at, closed_at
+          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`,
+          [
+            cellData.id,
+            projectPath,
+            cellData.issue_type,
+            status,
+            cellData.title,
+            cellData.description || null,
+            cellData.priority,
+            cellData.parent_id || null,
+            cellData.assignee || null,
+            new Date(cellData.created_at).getTime(),
+            new Date(cellData.updated_at).getTime(),
+            closedAt,
+          ]
+        );
+        
+        imported++;
+      }
+    } catch (error) {
+      // Invalid JSON or import error - count and continue
+      errors++;
+    }
+  }
+  
+  return { imported, updated, errors };
+}
+
 // ============================================================================
 // Adapter Singleton
 // ============================================================================