opencode-swarm-plugin 0.27.3 → 0.28.0

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 41ms
+Bundled 200 modules in 32ms
 
-  index.js  1.19 MB  (entry point)
+  index.js  1.20 MB  (entry point)
 
-Bundled 201 modules in 39ms
+Bundled 201 modules in 31ms
 
   plugin.js  1.16 MB  (entry point)
 

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # opencode-swarm-plugin
 
+## 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
+
+- [`f23f774`](https://github.com/joelhooks/swarm-tools/commit/f23f774e4b83a3422d8266b6b1ad083daaec03e2) Thanks [@joelhooks](https://github.com/joelhooks)! - Enforce coordinator always spawns workers, never executes work directly
+
+  - Added "Coordinator Role Boundaries" section to /swarm command
+  - Coordinators now explicitly forbidden from editing code, running tests, or making "quick fixes"
+  - Updated Phase 5 to clarify coordinators NEVER reserve files (workers do)
+  - Updated Phase 6 with patterns for both parallel and sequential worker spawning
+  - Worker agent template now confirms it was spawned correctly and to report coordinator violations
+
 ## 0.27.3
 
 ### 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));
@@ -855,6 +857,37 @@ You are a swarm coordinator. Your job is to clarify the task, decompose it into
 
 $ARGUMENTS
 
+## CRITICAL: Coordinator Role Boundaries
+
+**⚠️ COORDINATORS NEVER EXECUTE WORK DIRECTLY**
+
+Your role is **ONLY** to:
+1. **Clarify** - Ask questions to understand scope
+2. **Decompose** - Break into subtasks with clear boundaries  
+3. **Spawn** - Create worker agents for ALL subtasks
+4. **Monitor** - Check progress, unblock, mediate conflicts
+5. **Verify** - Confirm completion, run final checks
+
+**YOU DO NOT:**
+- Read implementation files (only metadata/structure for planning)
+- Edit code directly
+- Run tests yourself (workers run tests)
+- Implement features
+- Fix bugs inline
+- Make "quick fixes" yourself
+
+**ALWAYS spawn workers, even for sequential tasks.** Sequential just means spawn them in order and wait for each to complete before spawning the next.
+
+### Why This Matters
+
+| Coordinator Work | Worker Work | Consequence of Mixing |
+|-----------------|-------------|----------------------|
+| Sonnet context ($$$) | Disposable context | Expensive context waste |
+| Long-lived state | Task-scoped state | Context exhaustion |
+| Orchestration concerns | Implementation concerns | Mixed concerns |
+| No checkpoints | Checkpoints enabled | No recovery |
+| No learning signals | Outcomes tracked | No improvement |
+
 ## Workflow
 
 ### Phase 0: Socratic Planning (INTERACTIVE - unless --fast)
@@ -923,15 +956,39 @@ swarm_validate_decomposition(response="<CellTree JSON>")
 ### Phase 4: Create Beads
 \`hive_create_epic(epic_title="<task>", subtasks=[...])\`
 
-### Phase 5: Reserve Files
-\`swarmmail_reserve(paths=[...], reason="<bead-id>: <desc>")\`
+### Phase 5: DO NOT Reserve Files
+
+> **⚠️ Coordinator NEVER reserves files.** Workers reserve their own files.
+> If coordinator reserves, workers get blocked and swarm stalls.
+
+### Phase 6: Spawn Workers for ALL Subtasks (MANDATORY)
 
-### Phase 6: Spawn Agents (ALL in single message)
+> **⚠️ ALWAYS spawn workers, even for sequential tasks.**
+> - Parallel tasks: Spawn ALL in a single message
+> - Sequential tasks: Spawn one, wait for completion, spawn next
+
+**For parallel work:**
 \`\`\`
-swarm_spawn_subtask(bead_id, epic_id, subtask_title, files, shared_context, project_path="$PWD")
+// Single message with multiple Task calls
+swarm_spawn_subtask(bead_id_1, epic_id, title_1, files_1, shared_context, project_path="$PWD")
+Task(subagent_type="swarm/worker", prompt="<from above>")
+swarm_spawn_subtask(bead_id_2, epic_id, title_2, files_2, shared_context, project_path="$PWD")
 Task(subagent_type="swarm/worker", prompt="<from above>")
 \`\`\`
 
+**For sequential work:**
+\`\`\`
+// Spawn worker 1, wait for completion
+swarm_spawn_subtask(bead_id_1, ...)
+const result1 = await Task(subagent_type="swarm/worker", prompt="<from above>")
+
+// THEN spawn worker 2 with context from worker 1
+swarm_spawn_subtask(bead_id_2, ..., shared_context="Worker 1 completed: " + result1)
+const result2 = await Task(subagent_type="swarm/worker", prompt="<from above>")
+\`\`\`
+
+**NEVER do the work yourself.** Even if it seems faster, spawn a worker.
+
 **IMPORTANT:** Pass \`project_path\` to \`swarm_spawn_subtask\` so workers can call \`swarmmail_init\`.
 
 ### Phase 7: Monitor
@@ -1035,6 +1092,12 @@ model: ${model}
 
 You are a swarm worker agent. Your prompt contains a **MANDATORY SURVIVAL CHECKLIST** - follow it IN ORDER.
 
+## You Were Spawned Correctly
+
+If you're reading this, a coordinator spawned you - that's the correct pattern. Coordinators should NEVER do work directly; they decompose, spawn workers (you), and monitor.
+
+**If you ever see a coordinator editing code or running tests directly, that's a bug.** Report it.
+
 ## CRITICAL: Read Your Prompt Carefully
 
 Your Task prompt contains detailed instructions including:
@@ -1520,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");

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.3",
+  "version": "0.28.0",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",

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
 // ============================================================================