@hueyexe/opencode-ensemble 0.14.1 → 0.15.0

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"
@@ -45,7 +45,7 @@ const DEFAULT_WATCHDOG_CHECK_MS = 60 * 1000 // 60 seconds
  * peer-to-peer communication, shared task management, and coordinated execution.
  */
 const plugin: Plugin = async (input) => {
-  // Initialize SQLite database in the global OpenCode config directory
+  // Initialize SQLite database in the global OpenCode config directory.
   const dbPath = getDbPath()
   mkdirSync(path.dirname(dbPath), { recursive: true })
   const db = createDb(dbPath)
@@ -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)}`)
     })
@@ -209,16 +212,14 @@ const plugin: Plugin = async (input) => {
               "SELECT worktree_branch, name, team_id FROM team_member WHERE session_id = ?"
             ).get(sessionID) as { worktree_branch: string | null; name: string; team_id: string } | null
             if (member?.worktree_branch && !member.worktree_branch.startsWith("ensemble/preserved/")) {
-              const teamRow = deps.db.query("SELECT name FROM team WHERE id = ?").get(member.team_id) as { name: string } | null
-              if (teamRow) {
-                const { preserveBranch: preserve, preservedBranchName: branchName } = await import("./tools/merge-helper")
-                const safeBranch = branchName(teamRow.name, member.name)
-                const ok = await preserve(member.worktree_branch, safeBranch, deps.directory)
-                if (ok) {
-                  deps.db.run("UPDATE team_member SET worktree_branch = ? WHERE team_id = ? AND name = ?",
-                    [safeBranch, member.team_id, member.name])
-                  log(`busy_while_shutdown:branch:preserved src=${member.worktree_branch} target=${safeBranch}`)
-                }
+              const { getTeamResourceParts, preserveBranch: preserve, preservedBranchName: branchName } = await import("./tools/merge-helper")
+              const resource = getTeamResourceParts(deps.db, member.team_id)
+              const safeBranch = branchName(resource.projectName, resource.teamName, resource.teamId, member.name)
+              const ok = await preserve(member.worktree_branch, safeBranch, deps.directory)
+              if (ok) {
+                deps.db.run("UPDATE team_member SET worktree_branch = ? WHERE team_id = ? AND name = ?",
+                  [safeBranch, member.team_id, member.name])
+                log(`busy_while_shutdown:branch:preserved src=${member.worktree_branch} target=${safeBranch}`)
               }
             }
             try {
@@ -285,6 +286,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 +308,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()) {
@@ -360,6 +370,7 @@ const plugin: Plugin = async (input) => {
         description: "Create a new agent team. You become the team lead. Use this before spawning teammates.",
         args: {
           name: tool.schema.string().describe("Team name (lowercase alphanumeric with hyphens, 1-64 chars)"),
+          project_name: tool.schema.string().optional().describe("Project display name for first use of this working directory. If omitted, a short random name is generated."),
         },
         async execute(args, ctx) {
           const result = await executeTeamCreate(deps, args, ctx.sessionID)

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 { preserveBranch, preservedBranchName, teamResourceSegment } from "./tools/merge-helper"
 import { log } from "./log"
+import { runCommand } from "./process"
 
 /**
  * Scan for team members stuck in 'busy' status (stale from a crash)
@@ -15,17 +16,19 @@ import { log } from "./log"
 export async function recoverStaleMembers(db: Database, client?: PluginClient, cwd?: string): Promise<{ interrupted: number }> {
   // Find stale members with branch info so we can preserve before aborting
   const stale = db.query(
-    `SELECT tm.session_id, tm.worktree_branch, tm.name, tm.team_id, t.name as team_name
-     FROM team_member tm
-     JOIN team t ON tm.team_id = t.id
-     WHERE tm.status = 'busy' AND t.status = 'active'`
-  ).all() as Array<{ session_id: string; worktree_branch: string | null; name: string; team_id: string; team_name: string }>
+    `SELECT tm.session_id, tm.worktree_branch, tm.name, tm.team_id, t.name as team_name, p.name as project_name
+      FROM team_member tm
+      JOIN team t ON tm.team_id = t.id
+      JOIN project p ON t.project_id = p.id
+      WHERE tm.status = 'busy' AND t.status = 'active'
+        AND (? IS NULL OR t.project_id = ? OR t.project_id = 'default')`
+  ).all(cwd ?? null, cwd ?? null) as Array<{ session_id: string; worktree_branch: string | null; name: string; team_id: string; team_name: string; project_name: string }>
 
   const result = db.run(
     `UPDATE team_member SET status = 'error', execution_status = 'idle', time_updated = ?
-     WHERE status = 'busy'
-       AND team_id IN (SELECT id FROM team WHERE status = 'active')`,
-    [Date.now()]
+      WHERE status = 'busy'
+        AND team_id IN (SELECT id FROM team WHERE status = 'active' AND (? IS NULL OR project_id = ? OR project_id = 'default'))`,
+    [Date.now(), cwd ?? null, cwd ?? null]
   )
 
   // Preserve branches then abort orphaned sessions
@@ -33,7 +36,7 @@ export async function recoverStaleMembers(db: Database, client?: PluginClient, c
     for (const member of stale) {
       // Preserve branch BEFORE abort — session.abort() may destroy the worktree + branch
       if (cwd && member.worktree_branch && !member.worktree_branch.startsWith("ensemble/preserved/")) {
-        const safeBranch = preservedBranchName(member.team_name, member.name)
+        const safeBranch = preservedBranchName(member.project_name, member.team_name, member.team_id, member.name)
         const ok = await preserveBranch(member.worktree_branch, safeBranch, cwd)
         if (ok) {
           db.run("UPDATE team_member SET worktree_branch = ? WHERE team_id = ? AND name = ?",
@@ -145,6 +148,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
@@ -153,39 +180,37 @@ export async function recoverUndeliveredMessages(
 export async function recoverOrphanedBranches(db: Database, cwd: string): Promise<{ removed: number }> {
   let removed = 0
 
-  // Get archived team names that have NO active members
+  // Get archived team namespaces for this project that have NO active members.
+  // The team id namespace is current; team names are kept for legacy preserved branches.
   const archivedTeams = db.query(
-    `SELECT t.name FROM team t
+    `SELECT t.id, t.name, p.name as project_name FROM team t
+     JOIN project p ON t.project_id = p.id
      WHERE t.status = 'archived'
+      AND t.project_id = ?
      AND NOT EXISTS (
-       SELECT 1 FROM team_member tm
-       WHERE tm.team_id = t.id AND tm.status NOT IN ('shutdown', 'error')
-     )`
-  ).all() as Array<{ name: string }>
+        SELECT 1 FROM team_member tm
+        WHERE tm.team_id = t.id AND tm.status NOT IN ('shutdown', 'error')
+      )`
+  ).all(cwd) as Array<{ id: string; name: string; project_name: string }>
 
   if (archivedTeams.length === 0) return { removed: 0 }
 
-  const archivedNames = new Set(archivedTeams.map(t => t.name))
+  const archivedPrefixes = archivedTeams.flatMap(t => [
+    `ensemble/preserved/${t.project_name}/${teamResourceSegment(t.name, t.id)}/`,
+    `ensemble/preserved/${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}
-    const parts = branch.split("/")
-    if (parts.length < 4) continue
-    const teamName = parts[2]
-    if (!teamName || !archivedNames.has(teamName)) continue
+    if (!archivedPrefixes.some(prefix => branch.startsWith(prefix))) 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[] = [
@@ -82,6 +82,110 @@ export const MIGRATIONS: string[] = [
   `ALTER TABLE team_member ADD COLUMN workspace_id TEXT;`,
   // Migration 7: Track whether teammate has reported to lead (completion loop prevention, issue #3)
   `ALTER TABLE team_member ADD COLUMN reported_to_lead INTEGER NOT NULL DEFAULT 0;`,
+  // Migration 8: Add project as the dashboard grouping level. For this initial
+  // project-first step, project_id is the team lead's working directory.
+  `PRAGMA foreign_keys=OFF;
+   ALTER TABLE team RENAME TO team_old_m8;
+   CREATE TABLE IF NOT EXISTS project (
+     id              TEXT PRIMARY KEY,
+     name            TEXT NOT NULL,
+     path            TEXT NOT NULL,
+     status          TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'archived')),
+     time_created    INTEGER NOT NULL,
+     time_updated    INTEGER NOT NULL
+   );
+   INSERT OR IGNORE INTO project (id, name, path, status, time_created, time_updated)
+     VALUES ('default', 'Default Project', '', 'active', strftime('%s','now') * 1000, strftime('%s','now') * 1000);
+   CREATE TABLE team (
+     id              TEXT PRIMARY KEY,
+     name            TEXT NOT NULL,
+     project_id      TEXT NOT NULL DEFAULT 'default' REFERENCES project(id) ON DELETE CASCADE,
+     lead_session_id TEXT NOT NULL,
+     status          TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'archived')),
+     delegate        INTEGER NOT NULL DEFAULT 0,
+     time_created    INTEGER NOT NULL,
+     time_updated    INTEGER NOT NULL,
+     lead_agent      TEXT
+   );
+   INSERT INTO team (id, name, project_id, lead_session_id, status, delegate, time_created, time_updated, lead_agent)
+     SELECT id, name, 'default', lead_session_id, status, delegate, time_created, time_updated, lead_agent FROM team_old_m8;
+   DROP TABLE team_old_m8;
+
+   ALTER TABLE team_member RENAME TO team_member_old_m8;
+   CREATE TABLE team_member (
+     team_id          TEXT NOT NULL REFERENCES team(id) ON DELETE CASCADE,
+     name             TEXT NOT NULL,
+     session_id       TEXT NOT NULL,
+     agent            TEXT NOT NULL,
+     status           TEXT NOT NULL DEFAULT 'ready'
+                        CHECK(status IN ('ready', 'busy', 'shutdown_requested', 'shutdown', 'error')),
+     execution_status TEXT NOT NULL DEFAULT 'idle'
+                        CHECK(execution_status IN ('idle', 'starting', 'running',
+                          'cancel_requested', 'cancelling', 'cancelled',
+                          'completing', 'completed', 'failed', 'timed_out')),
+     model            TEXT,
+     prompt           TEXT,
+     time_created     INTEGER NOT NULL,
+     time_updated     INTEGER NOT NULL,
+     worktree_dir     TEXT,
+     worktree_branch  TEXT,
+     plan_approval    TEXT NOT NULL DEFAULT 'none'
+                        CHECK(plan_approval IN ('none', 'pending', 'approved', 'rejected')),
+     workspace_id     TEXT,
+     reported_to_lead INTEGER NOT NULL DEFAULT 0,
+     PRIMARY KEY (team_id, name)
+   );
+   INSERT INTO team_member (team_id, name, session_id, agent, status, execution_status, model, prompt, time_created, time_updated, worktree_dir, worktree_branch, plan_approval, workspace_id, reported_to_lead)
+     SELECT team_id, name, session_id, agent, status, execution_status, model, prompt, time_created, time_updated, worktree_dir, worktree_branch, plan_approval, workspace_id, reported_to_lead FROM team_member_old_m8;
+   DROP TABLE team_member_old_m8;
+
+   ALTER TABLE team_task RENAME TO team_task_old_m8;
+   CREATE TABLE team_task (
+     id            TEXT PRIMARY KEY,
+     team_id       TEXT NOT NULL REFERENCES team(id) ON DELETE CASCADE,
+     content       TEXT NOT NULL,
+     status        TEXT NOT NULL DEFAULT 'pending'
+                     CHECK(status IN ('pending', 'in_progress', 'completed', 'cancelled', 'blocked')),
+     priority      TEXT NOT NULL DEFAULT 'medium'
+                     CHECK(priority IN ('high', 'medium', 'low')),
+     assignee      TEXT,
+     depends_on    TEXT,
+     time_created  INTEGER NOT NULL,
+     time_updated  INTEGER NOT NULL
+   );
+   INSERT INTO team_task (id, team_id, content, status, priority, assignee, depends_on, time_created, time_updated)
+     SELECT id, team_id, content, status, priority, assignee, depends_on, time_created, time_updated FROM team_task_old_m8;
+   DROP TABLE team_task_old_m8;
+
+   ALTER TABLE team_message RENAME TO team_message_old_m8;
+   CREATE TABLE team_message (
+     id            TEXT PRIMARY KEY,
+     team_id       TEXT NOT NULL REFERENCES team(id) ON DELETE CASCADE,
+     from_name     TEXT NOT NULL,
+     to_name       TEXT,
+     content       TEXT NOT NULL,
+     delivered     INTEGER NOT NULL DEFAULT 0,
+     time_created  INTEGER NOT NULL,
+     read          INTEGER NOT NULL DEFAULT 0
+   );
+   INSERT INTO team_message (id, team_id, from_name, to_name, content, delivered, time_created, read)
+     SELECT id, team_id, from_name, to_name, content, delivered, time_created, read FROM team_message_old_m8;
+   DROP TABLE team_message_old_m8;
+
+   CREATE INDEX IF NOT EXISTS team_lead_idx ON team(lead_session_id);
+   CREATE INDEX IF NOT EXISTS team_status_idx ON team(status);
+   CREATE INDEX IF NOT EXISTS team_project_idx ON team(project_id, status);
+   CREATE UNIQUE INDEX IF NOT EXISTS team_active_project_name_idx ON team(project_id, name) WHERE status = 'active';
+   CREATE INDEX IF NOT EXISTS team_member_session_idx ON team_member(session_id);
+   CREATE INDEX IF NOT EXISTS team_member_status_idx ON team_member(team_id, status);
+   CREATE INDEX IF NOT EXISTS team_task_team_idx ON team_task(team_id);
+   CREATE INDEX IF NOT EXISTS team_task_assignee_idx ON team_task(assignee);
+   CREATE INDEX IF NOT EXISTS team_task_status_idx ON team_task(team_id, status);
+   CREATE INDEX IF NOT EXISTS team_message_team_idx ON team_message(team_id);
+   CREATE INDEX IF NOT EXISTS team_message_to_idx ON team_message(to_name);
+   CREATE INDEX IF NOT EXISTS team_message_undelivered_idx ON team_message(team_id, delivered) WHERE delivered = 0;
+   CREATE INDEX IF NOT EXISTS team_message_unread_idx ON team_message(team_id, read) WHERE read = 0;
+   PRAGMA foreign_keys=ON;`,
 ]
 
 /**
@@ -91,9 +195,25 @@ export const MIGRATIONS: string[] = [
 export function applyMigrations(db: Database): void {
   const { user_version: current } = db.query("PRAGMA user_version").get() as { user_version: number }
 
+  if (current > MIGRATIONS.length) {
+    throw new Error(`Database schema version ${current} is newer than this plugin supports (${MIGRATIONS.length}). Upgrade opencode-ensemble before continuing.`)
+  }
+
   for (let i = current; i < MIGRATIONS.length; i++) {
     const migration = MIGRATIONS[i]
-    if (migration) db.exec(migration)
-    db.exec(`PRAGMA user_version = ${i + 1}`)
+    const { foreign_keys: foreignKeys } = db.query("PRAGMA foreign_keys").get() as { foreign_keys: number }
+
+    db.exec("PRAGMA foreign_keys = OFF")
+    db.exec("BEGIN IMMEDIATE")
+    try {
+      if (migration) db.exec(migration)
+      db.exec(`PRAGMA user_version = ${i + 1}`)
+      db.exec("COMMIT")
+    } catch (err) {
+      db.exec("ROLLBACK")
+      throw err
+    } finally {
+      db.exec(`PRAGMA foreign_keys = ${foreignKeys ? "ON" : "OFF"}`)
+    }
   }
 }

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"