@hueyexe/opencode-ensemble 0.14.1 → 0.14.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hueyexe/opencode-ensemble",
-  "version": "0.14.1",
+  "version": "0.14.2",
   "description": "Agent teams for OpenCode — parallel agents with peer-to-peer communication, shared tasks, and coordinated execution",
   "module": "src/index.ts",
   "main": "dist/index.js",
@@ -30,9 +30,13 @@
     "lint": "bunx biome lint src/",
     "typecheck": "tsc --noEmit",
     "test": "bun test",
-    "build": "bun build src/index.ts --outdir dist --target bun",
+    "build": "bun build src/index.ts --outdir dist --target node",
     "prepublishOnly": "bun run typecheck && bun test && bun run build"
   },
+  "engines": {
+    "node": ">=24",
+    "bun": ">=1.0"
+  },
   "devDependencies": {
     "@biomejs/biome": "^2.4.9",
     "@types/bun": "latest"
@@ -41,7 +45,7 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "^1.14.45",
-    "@opencode-ai/sdk": "^1.14.45"
+    "@opencode-ai/plugin": "^1.15.1",
+    "@opencode-ai/sdk": "^1.15.1"
   }
 }

package/src/dashboard.ts

@@ -1,4 +1,6 @@
-import type { Database } from "bun:sqlite"
+import { createServer } from "node:http"
+import type { IncomingMessage, Server, ServerResponse } from "node:http"
+import type { Database } from "./db"
 import { DASHBOARD_HEAD } from "./dashboard-html"
 import { DASHBOARD_JS_PART1 } from "./dashboard-js-part1"
 import { DASHBOARD_JS_PART2 } from "./dashboard-js-part2"
@@ -51,13 +53,6 @@ interface MessageRow {
   time_created: number
 }
 
-function jsonResponse(data: unknown, status = 200): Response {
-  return new Response(JSON.stringify(data), {
-    status,
-    headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
-  })
-}
-
 function parseDependsOn(value: string | null): string[] {
   if (!value) return []
 
@@ -122,60 +117,100 @@ function buildState(db: Database): { teams: unknown[] } {
   }
 }
 
+/** Dashboard server handle returned by startDashboard. */
+export interface DashboardServer {
+  stop(force?: boolean): void
+}
+
+function sendJson(res: ServerResponse, data: unknown): void {
+  res.writeHead(200, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+  })
+  res.end(JSON.stringify(data))
+}
+
+function handleDashboardRequest(db: Database, port: number, req: IncomingMessage, res: ServerResponse): void {
+  const url = new URL(req.url ?? "/", `http://${req.headers.host ?? `localhost:${port}`}`)
+
+  if (url.pathname === "/api/health") {
+    sendJson(res, { ensemble: true, pid: process.pid })
+    return
+  }
+
+  if (url.pathname === "/api/state") {
+    sendJson(res, buildState(db))
+    return
+  }
+
+  if (url.pathname === "/") {
+    res.writeHead(200, { "Content-Type": "text/html" })
+    res.end(DASHBOARD_HTML)
+    return
+  }
+
+  res.writeHead(404, { "Content-Type": "text/plain" })
+  res.end("Not Found")
+}
+
+function toDashboardServer(server: Server): DashboardServer {
+  return {
+    stop(force?: boolean) {
+      server.close()
+      // server.close() only stops accepting new connections — under Node's
+      // node:http, idle keep-alive sockets keep the listener busy until the
+      // keep-alive timeout. closeAllConnections() (Node ≥ 18.2) terminates
+      // them promptly, matching the behaviour Bun.serve().stop(true) had.
+      if (force) {
+        const closeAll = (server as unknown as { closeAllConnections?: () => void }).closeAllConnections
+        if (typeof closeAll === "function") closeAll.call(server)
+      }
+    },
+  }
+}
+
 /**
  * Start the dashboard HTTP server.
  * Serves a JSON API for team state and the dashboard HTML.
  * Singleton: if the port is already in use by another ensemble instance, skips silently.
  * Returns the server instance, or null if skipped.
  */
-export async function startDashboard(db: Database, port: number): Promise<ReturnType<typeof Bun.serve> | null> {
-  try {
-    const server = Bun.serve({
-      port,
-      fetch(req) {
-        const url = new URL(req.url)
-
-        if (url.pathname === "/api/health") {
-          return jsonResponse({ ensemble: true, pid: process.pid })
-        }
-
-        if (url.pathname === "/api/state") {
-          return jsonResponse(buildState(db))
-        }
-
-        if (url.pathname === "/") {
-          return new Response(DASHBOARD_HTML, {
-            headers: { "Content-Type": "text/html" },
-          })
-        }
-
-        return new Response("Not Found", { status: 404 })
-      },
-    })
-    log(`dashboard:started port=${port} url=http://localhost:${port}`)
-    return server
-  } catch (err) {
-    if (err && typeof err === "object" && "code" in err && err.code === "EADDRINUSE") {
-      try {
-        const res = await fetch(`http://localhost:${port}/api/health`)
-        const data = await res.json() as { ensemble?: boolean; pid?: number }
-        if (data.ensemble && data.pid) {
-          // Check if the other process is still alive
-          let alive = false
-          try { process.kill(data.pid, 0); alive = true } catch { /* process is dead */ }
-          if (alive && data.pid !== process.pid) {
-            log(`dashboard:already-running port=${port} pid=${data.pid}`)
-            return null
+export async function startDashboard(db: Database, port: number): Promise<DashboardServer | null> {
+  return new Promise((resolve) => {
+    const server = createServer((req, res) => handleDashboardRequest(db, port, req, res))
+
+    server.once("error", async (err: NodeJS.ErrnoException) => {
+      if (err.code === "EADDRINUSE") {
+        try {
+          const res = await fetch(`http://localhost:${port}/api/health`)
+          const data = await res.json() as { ensemble?: boolean; pid?: number }
+          if (data.ensemble && data.pid) {
+            // Check if the other process is still alive
+            let alive = false
+            try { process.kill(data.pid, 0); alive = true } catch { /* process is dead */ }
+            if (alive && data.pid !== process.pid) {
+              log(`dashboard:already-running port=${port} pid=${data.pid}`)
+              resolve(null)
+              return
+            }
+            // Stale server from a dead process — warn the user
+            log(`dashboard:stale-server port=${port} stale-pid=${data.pid} — run: kill -9 ${data.pid} || lsof -ti:${port} | xargs kill -9`)
+            resolve(null)
+            return
           }
-          // Stale server from a dead process — warn the user
-          log(`dashboard:stale-server port=${port} stale-pid=${data.pid} — run: kill -9 ${data.pid} || lsof -ti:${port} | xargs kill -9`)
-          return null
-        }
-      } catch { /* health check failed — port held by something else */ }
-      log(`dashboard:port-in-use port=${port} (not an ensemble instance)`)
-      return null
-    }
-    log(`dashboard:failed err=${err instanceof Error ? err.message : String(err)}`)
-    return null
-  }
+        } catch { /* health check failed — port held by something else */ }
+        log(`dashboard:port-in-use port=${port} (not an ensemble instance)`)
+        resolve(null)
+        return
+      }
+
+      log(`dashboard:failed err=${err.message}`)
+      resolve(null)
+    })
+
+    server.listen(port, () => {
+      log(`dashboard:started port=${port} url=http://localhost:${port}`)
+      resolve(toDashboardServer(server))
+    })
+  })
 }

package/src/db.ts

@@ -1,9 +1,93 @@
-import { Database } from "bun:sqlite"
+import { createRequire } from "node:module"
 import path from "node:path"
 import { applyMigrations } from "./schema"
 
+interface SqliteStatement {
+  get(...params: unknown[]): unknown
+  all(...params: unknown[]): unknown[]
+  run(...params: unknown[]): unknown
+}
+
+interface SqliteRunResult {
+  changes: number
+}
+
+/** Minimal synchronous SQLite database interface used by Ensemble. */
+export interface Database {
+  exec(sql: string): void
+  query(sql: string): SqliteStatement
+  run(sql: string, ...params: unknown[]): SqliteRunResult
+  transaction<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => TResult): (...args: TArgs) => TResult
+  close(): void
+}
+
+interface BunSqliteModule {
+  Database: new (filename: string) => Database
+}
+
+interface NodeSqliteDatabase {
+  exec(sql: string): void
+  prepare(sql: string): SqliteStatement
+  close(): void
+}
+
+interface NodeSqliteModule {
+  DatabaseSync: new (filename: string) => NodeSqliteDatabase
+}
+
+const requireRuntimeModule = createRequire(import.meta.url)
+
 let instance: Database | undefined
 
+class NodeSqliteAdapter implements Database {
+  private readonly db: NodeSqliteDatabase
+
+  constructor(filename: string) {
+    const sqlite = requireRuntimeModule("node:sqlite") as NodeSqliteModule
+    this.db = new sqlite.DatabaseSync(filename)
+  }
+
+  exec(sql: string): void {
+    this.db.exec(sql)
+  }
+
+  query(sql: string): SqliteStatement {
+    return this.db.prepare(sql)
+  }
+
+  run(sql: string, ...params: unknown[]): SqliteRunResult {
+    const bindings = params.length === 1 && Array.isArray(params[0]) ? params[0] : params
+    return this.db.prepare(sql).run(...bindings) as SqliteRunResult
+  }
+
+  transaction<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => TResult): (...args: TArgs) => TResult {
+    return (...args: TArgs): TResult => {
+      this.exec("BEGIN")
+      try {
+        const result = fn(...args)
+        this.exec("COMMIT")
+        return result
+      } catch (err) {
+        this.exec("ROLLBACK")
+        throw err
+      }
+    }
+  }
+
+  close(): void {
+    this.db.close()
+  }
+}
+
+function openDatabase(filename: string): Database {
+  if (typeof process.versions.bun === "string") {
+    const sqlite = requireRuntimeModule(["bun", "sqlite"].join(":")) as BunSqliteModule
+    return new sqlite.Database(filename)
+  }
+
+  return new NodeSqliteAdapter(filename)
+}
+
 /**
  * Resolve the path for the ensemble SQLite database.
  * Always uses the global ~/.config/opencode/ directory, never the project directory.
@@ -19,7 +103,7 @@ export function getDbPath(env: Record<string, string | undefined> = process.env)
  * Applies all pending migrations and enables WAL mode.
  */
 export function createDb(path: string): Database {
-  const db = new Database(path)
+  const db = openDatabase(path)
   db.exec("PRAGMA journal_mode=WAL")
   db.exec("PRAGMA foreign_keys=ON")
   applyMigrations(db)

package/src/hooks.ts

@@ -1,5 +1,7 @@
-import type { Database } from "bun:sqlite"
+import type { Database } from "./db"
 import type { MemberRegistry, DescendantTracker } from "./state"
+import { sendMessage } from "./messaging"
+import { findTeamBySession } from "./types"
 
 const TEAM_TOOL_PREFIX = "team_"
 
@@ -94,22 +96,51 @@ export function handleSessionCreatedEvent(
  * Check whether a tool call should be blocked for sub-agent isolation.
  * Throws if the tool is a team tool and the session is a descendant of a team member.
  * OQ-11: confirmed — throwing inside tool.execute.before fails the tool call gracefully (verified in live testing).
+ *
+ * The optional `db` parameter enables a SQLite fallback so the check works
+ * across multi-Plugin-instance scenarios where the in-memory registry may
+ * not have the parent teammate's session. SQLite is the canonical source.
+ *
+ * Order:
+ *   1. Registry fast-path: if the caller is itself a registered teammate, allow.
+ *   2. Otherwise enumerate active teammate session IDs from registry + SQLite.
+ *   3. If the caller is among them, allow.
+ *   4. If the caller is a descendant of any teammate, block.
+ *
+ * The fast-path skips the SQL query entirely when the registry already
+ * has the caller. Lead sessions are NOT in the MemberRegistry by design
+ * (only teammates are), so a lead's team_* call always misses the
+ * fast-path and does the SQLite enumeration. That's acceptable — the
+ * scan is bounded by total active members and runs once per tool call.
  */
 export function checkToolIsolation(
   registry: MemberRegistry,
   tracker: DescendantTracker,
   toolName: string,
   sessionId: string,
+  db?: Database,
 ): void {
   if (!toolName.startsWith(TEAM_TOOL_PREFIX)) return
 
-  // If the session is a registered team member or lead, allow it
+  // Fast path: registry hit on the caller — skip SQL altogether.
   if (registry.isTeamSession(sessionId)) return
 
-  // Check if this session is a descendant of any team member
-  const allTeamSessions = registry.allSessionIds()
+  // Collect every session ID that is a teammate, from the registry first
+  // (fast path) and SQLite second (covers multi-instance / cross-plugin state).
+  const teammateSessionIds = new Set(registry.allSessionIds())
+  if (db) {
+    const dbRows = db.query(
+      `SELECT tm.session_id FROM team_member tm
+       JOIN team t ON tm.team_id = t.id
+       WHERE t.status = 'active' AND tm.status NOT IN ('shutdown', 'error')`
+    ).all() as Array<{ session_id: string }>
+    for (const row of dbRows) teammateSessionIds.add(row.session_id)
+  }
+
+  // The caller may be a teammate registered in another Plugin instance — allow.
+  if (teammateSessionIds.has(sessionId)) return
 
-  if (allTeamSessions.size > 0 && tracker.isDescendantOf(sessionId, allTeamSessions)) {
+  if (teammateSessionIds.size > 0 && tracker.isDescendantOf(sessionId, teammateSessionIds)) {
     throw new Error("Team tools are not available to sub-agents. Report findings to your parent teammate via your normal output.")
   }
 }
@@ -127,3 +158,39 @@ export function shouldNudgeIdleMember(db: Database, teamId: string, memberName:
     .get(teamId, memberName) as { id: string } | null
   return !msg
 }
+
+/** Shape of an error attached to a session.error event. Subset of the SDK's union. */
+export interface SessionErrorPayload {
+  name?: string
+  data?: { message?: string }
+}
+
+/**
+ * Handle a session.error event. Surfaces tool/model failures from a teammate
+ * as a system message to the lead, so otherwise-silent failures are visible.
+ *
+ * Ignored when:
+ * - sessionID is undefined
+ * - the session is not a registered teammate (leads are not in the registry)
+ */
+export function handleSessionErrorEvent(
+  db: Database,
+  registry: MemberRegistry,
+  sessionId: string | undefined,
+  error: SessionErrorPayload | undefined,
+): void {
+  if (!sessionId) return
+  // Use findTeamBySession so the SQLite fallback fires when this Plugin
+  // instance's in-memory registry doesn't have the teammate (multi-instance
+  // scenario — see findTeamBySession in src/types.ts).
+  const teamInfo = findTeamBySession(db, registry, sessionId)
+  if (!teamInfo || teamInfo.role !== "member" || !teamInfo.memberName) return
+
+  const errMsg = error?.data?.message ?? error?.name ?? "unknown error"
+  sendMessage(db, {
+    teamId: teamInfo.teamId,
+    from: "system",
+    to: "lead",
+    content: `Teammate "${teamInfo.memberName}" had a session error: ${errMsg}. Check their session for details. They may be stuck and need investigation or shutdown.`,
+  })
+}

package/src/index.ts

@@ -5,10 +5,10 @@ import path from "node:path"
 import { mkdirSync } from "node:fs"
 import { createDb, getDbPath } from "./db"
 import { wrapThrowingClient } from "./client"
-import { recoverStaleMembers, recoverUndeliveredMessages, recoverOrphanedWorktrees, recoverOrphanedBranches } from "./recovery"
+import { recoverStaleMembers, recoverUndeliveredMessages, recoverOrphanedWorktrees, recoverOrphanedBranches, rehydrateRegistry } from "./recovery"
 import { MemberRegistry, DescendantTracker, PendingPurgeApprovals } from "./state"
 import { isWorktreeInstance } from "./util"
-import { handleSessionStatusEvent, handleSessionCreatedEvent, checkToolIsolation, shouldNudgeIdleMember } from "./hooks"
+import { handleSessionStatusEvent, handleSessionCreatedEvent, checkToolIsolation, shouldNudgeIdleMember, handleSessionErrorEvent } from "./hooks"
 import { notifyTeamEvent, notifyWorkingProgress } from "./notify"
 import { sendMessage, hasReportedCompletion } from "./messaging"
 import { buildLeadSystemPrompt, buildTeammateSystemPrompt, buildTeamCompactionContext } from "./system-prompt"
@@ -80,14 +80,17 @@ const plugin: Plugin = async (input) => {
     const recovery = await recoverStaleMembers(db, client, input.directory)
     if (recovery.interrupted > 0) {
       log(`init:recovery:interrupted=${recovery.interrupted}`)
-      const members = db.query(
-        "SELECT tm.team_id, tm.name, tm.session_id FROM team_member tm JOIN team t ON tm.team_id = t.id WHERE t.status = 'active'"
-      ).all() as Array<{ team_id: string; name: string; session_id: string }>
-      for (const m of members) {
-        registry.register(m.team_id, m.name, m.session_id)
-      }
     }
 
+    // Always rehydrate the in-memory registry from SQLite. The registry is
+    // in-memory only and is wiped on every plugin restart. Without this,
+    // teammates from a previous lifetime become invisible — every team_*
+    // tool call from them throws "This session is not in a team." This is
+    // the bug that surfaced on Desktop, where the Electron sidecar restarts
+    // far more often than the CLI.
+    const rehydrated = rehydrateRegistry(db, registry)
+    if (rehydrated > 0) log(`init:registry:rehydrated members=${rehydrated}`)
+
     recoverUndeliveredMessages(db, client, registry).catch((err) => {
       log(`init:recover-messages:failed err=${err instanceof Error ? err.message : String(err)}`)
     })
@@ -285,6 +288,15 @@ const plugin: Plugin = async (input) => {
         }
       }
 
+      // Surface teammate session errors as system messages to the lead.
+      // Without this, errors during a teammate's prompt loop (auth failure,
+      // tool failure, model error, etc.) are invisible to the lead — the
+      // teammate just appears stuck.
+      if (event.type === "session.error") {
+        const props = event.properties as { sessionID?: string; error?: { name?: string; data?: { message?: string } } }
+        handleSessionErrorEvent(db, registry, props.sessionID, props.error)
+      }
+
       // Track per-step output tokens for stall detection
       if (event.type === "message.part.updated") {
         const part = (event.properties as { part?: { type?: string; sessionID?: string; tokens?: { output?: number } } }).part
@@ -298,7 +310,7 @@ const plugin: Plugin = async (input) => {
 
     // Sub-agent isolation + rate limiting hook
     "tool.execute.before": async (input, _output) => {
-      checkToolIsolation(registry, tracker, input.tool, input.sessionID)
+      checkToolIsolation(registry, tracker, input.tool, input.sessionID, db)
       // Rate limit team tools that trigger LLM inference
       if (input.tool.startsWith("team_")) {
         if (!rateLimiter.tryConsume()) {

package/src/messaging.ts

@@ -1,4 +1,4 @@
-import type { Database } from "bun:sqlite"
+import type { Database } from "./db"
 import { generateId } from "./util"
 
 const MAX_CONTENT_BYTES = 10 * 1024 // 10KB

package/src/notify.ts

@@ -1,4 +1,4 @@
-import type { Database } from "bun:sqlite"
+import type { Database } from "./db"
 import type { PluginClient } from "./types"
 
 type TeamEventType = "spawn" | "message" | "completed" | "error" | "shutdown"

package/src/process.ts

@@ -0,0 +1,55 @@
+import { Buffer } from "node:buffer"
+import { spawn } from "node:child_process"
+import type { Readable } from "node:stream"
+
+export interface CommandResult {
+  exitCode: number
+  stdout: string
+  stderr: string
+}
+
+export interface CommandOptions {
+  cwd?: string
+}
+
+function collect(stream: Readable | null, chunks: Buffer[]): void {
+  stream?.on("data", (chunk: Buffer | string) => {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))
+  })
+}
+
+/** Run a subprocess with Node-compatible APIs and capture stdout/stderr. */
+export function runCommand(args: string[], options: CommandOptions = {}): Promise<CommandResult> {
+  const [command, ...commandArgs] = args
+  if (!command) return Promise.resolve({ exitCode: 1, stdout: "", stderr: "No command provided" })
+
+  return new Promise((resolve) => {
+    const stdout: Buffer[] = []
+    const stderr: Buffer[] = []
+    let settled = false
+    const finish = (result: CommandResult) => {
+      if (settled) return
+      settled = true
+      resolve(result)
+    }
+
+    const child = spawn(command, commandArgs, {
+      cwd: options.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+    })
+
+    collect(child.stdout, stdout)
+    collect(child.stderr, stderr)
+
+    child.on("error", (error) => {
+      finish({ exitCode: 1, stdout: Buffer.concat(stdout).toString("utf8"), stderr: error.message })
+    })
+    child.on("close", (code) => {
+      finish({
+        exitCode: code ?? 1,
+        stdout: Buffer.concat(stdout).toString("utf8"),
+        stderr: Buffer.concat(stderr).toString("utf8"),
+      })
+    })
+  })
+}

package/src/recovery.ts

@@ -1,9 +1,10 @@
-import type { Database } from "bun:sqlite"
+import type { Database } from "./db"
 import type { PluginClient } from "./types"
 import type { MemberRegistry } from "./state"
 import { getUndeliveredMessages, markDelivered, hasReportedCompletion } from "./messaging"
 import { preserveBranch, preservedBranchName } from "./tools/merge-helper"
 import { log } from "./log"
+import { runCommand } from "./process"
 
 /**
  * Scan for team members stuck in 'busy' status (stale from a crash)
@@ -145,6 +146,30 @@ export async function recoverUndeliveredMessages(
   return { redelivered }
 }
 
+/**
+ * Repopulate the in-memory MemberRegistry from SQLite for all active members.
+ * MUST be called on every plugin init — the registry is in-memory only,
+ * and without rehydration, every team_* tool call from an existing
+ * teammate fails with "This session is not in a team." after a plugin restart.
+ *
+ * Skips members in terminal states (shutdown, error) — they should not
+ * receive future messages.
+ *
+ * Returns the number of members rehydrated.
+ */
+export function rehydrateRegistry(db: Database, registry: MemberRegistry): number {
+  const members = db.query(
+    `SELECT tm.team_id, tm.name, tm.session_id
+     FROM team_member tm
+     JOIN team t ON tm.team_id = t.id
+     WHERE t.status = 'active' AND tm.status NOT IN ('shutdown', 'error')`
+  ).all() as Array<{ team_id: string; name: string; session_id: string }>
+  for (const m of members) {
+    registry.register(m.team_id, m.name, m.session_id)
+  }
+  return members.length
+}
+
 /**
  * Clean up orphaned ensemble/preserved/* branches that belong to archived teams
  * with no active members. Scoped carefully to avoid interfering with other
@@ -168,12 +193,9 @@ export async function recoverOrphanedBranches(db: Database, cwd: string): Promis
   const archivedNames = new Set(archivedTeams.map(t => t.name))
 
   // List all local branches matching ensemble/preserved/*
-  const proc = Bun.spawn(["git", "branch", "--list", "ensemble/preserved/*"], { cwd, stdout: "pipe", stderr: "pipe" })
-  const stdoutPromise = new Response(proc.stdout).text()
-  await proc.exited
-  const stdout = await stdoutPromise
+  const result = await runCommand(["git", "branch", "--list", "ensemble/preserved/*"], { cwd })
 
-  const branches = stdout.split("\n").map(b => b.trim().replace(/^\* /, "")).filter(Boolean)
+  const branches = result.stdout.split("\n").map(b => b.trim().replace(/^\* /, "")).filter(Boolean)
 
   for (const branch of branches) {
     // Parse team name from branch: ensemble/preserved/{teamName}/{memberName}
@@ -183,9 +205,8 @@ export async function recoverOrphanedBranches(db: Database, cwd: string): Promis
     if (!teamName || !archivedNames.has(teamName)) continue
 
     try {
-      const del = Bun.spawn(["git", "branch", "-D", branch], { cwd, stdout: "pipe", stderr: "pipe" })
-      const exitCode = await del.exited
-      if (exitCode === 0) {
+      const deleteResult = await runCommand(["git", "branch", "-D", branch], { cwd })
+      if (deleteResult.exitCode === 0) {
         removed++
         log(`recovery:branch:deleted branch=${branch}`)
       }

package/src/schema.ts

@@ -1,4 +1,4 @@
-import type { Database } from "bun:sqlite"
+import type { Database } from "./db"
 
 /** Migration SQL statements, applied in order. Version = index + 1. */
 export const MIGRATIONS: string[] = [

package/src/system-prompt.ts

@@ -1,4 +1,4 @@
-import type { Database } from "bun:sqlite"
+import type { Database } from "./db"
 import { markDelivered } from "./messaging"
 import { parseTaskResult, formatTaskResult } from "./result-parser"
 import type { EnsembleConfig } from "./config"