@hueyexe/opencode-ensemble 0.1.0

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@hueyexe/opencode-ensemble",
+  "version": "0.1.0",
+  "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",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hueyexe/opencode-ensemble"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "agent",
+    "team",
+    "multi-agent",
+    "parallel",
+    "orchestration"
+  ],
+  "files": [
+    "dist",
+    "src",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "build": "bun build src/index.ts --outdir dist --target bun",
+    "prepublishOnly": "bun run typecheck && bun test && bun run build"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.2.26",
+    "@opencode-ai/sdk": "^1.2.26"
+  }
+}

package/src/db.ts

@@ -0,0 +1,23 @@
+import { Database } from "bun:sqlite"
+import { applyMigrations } from "./schema"
+
+let instance: Database | undefined
+
+/**
+ * Create and initialize a SQLite database at the given path.
+ * Applies all pending migrations and enables WAL mode.
+ */
+export function createDb(path: string): Database {
+  const db = new Database(path)
+  db.exec("PRAGMA journal_mode=WAL")
+  db.exec("PRAGMA foreign_keys=ON")
+  applyMigrations(db)
+  instance = db
+  return db
+}
+
+/** Get the singleton database instance. Must call createDb first. */
+export function getDb(): Database {
+  if (!instance) throw new Error("Database not initialized. Call createDb() first.")
+  return instance
+}

package/src/hooks.ts

@@ -0,0 +1,96 @@
+import type { Database } from "bun:sqlite"
+import type { MemberRegistry, DescendantTracker } from "./state"
+
+const TEAM_TOOL_PREFIX = "team_"
+
+/** Result of a session status event — tells the caller what transition happened. */
+export interface StatusTransition {
+  memberName: string
+  teamId: string
+  from: string
+  to: string
+}
+
+/**
+ * Handle a session.status event. Updates member status and execution_status
+ * in SQLite based on the new session status.
+ * Ignores events for unknown sessions or archived teams.
+ * Returns the transition if one occurred, for toast notifications.
+ */
+export function handleSessionStatusEvent(
+  db: Database,
+  registry: MemberRegistry,
+  sessionId: string,
+  status: "idle" | "busy" | "retry",
+): StatusTransition | undefined {
+  const entry = registry.getBySession(sessionId)
+  if (!entry) return undefined
+
+  // Check if team is archived — if so, silently ignore
+  const team = db.query("SELECT status FROM team WHERE id = ?").get(entry.teamId) as { status: string } | null
+  if (!team || team.status === "archived") return undefined
+
+  const member = db.query("SELECT status, execution_status FROM team_member WHERE team_id = ? AND name = ?")
+    .get(entry.teamId, entry.memberName) as { status: string; execution_status: string } | null
+  if (!member) return undefined
+
+  if (status === "idle") {
+    const newStatus = member.status === "shutdown_requested" ? "shutdown" : "ready"
+    if (member.status === newStatus) return undefined
+    db.run(
+      "UPDATE team_member SET status = ?, execution_status = 'idle', time_updated = ? WHERE team_id = ? AND name = ?",
+      [newStatus, Date.now(), entry.teamId, entry.memberName]
+    )
+    return { memberName: entry.memberName, teamId: entry.teamId, from: member.status, to: newStatus }
+  } else if (status === "busy") {
+    if (member.status === "ready" || member.status === "error") {
+      db.run(
+        "UPDATE team_member SET status = 'busy', execution_status = 'running', time_updated = ? WHERE team_id = ? AND name = ?",
+        [Date.now(), entry.teamId, entry.memberName]
+      )
+      return { memberName: entry.memberName, teamId: entry.teamId, from: member.status, to: "busy" }
+    }
+  }
+  return undefined
+}
+
+/**
+ * Handle a session.created event. Tracks the parent-child relationship
+ * in the DescendantTracker for sub-agent isolation.
+ */
+export function handleSessionCreatedEvent(
+  tracker: DescendantTracker,
+  sessionId: string,
+  parentId: string | undefined,
+): void {
+  if (parentId) {
+    tracker.track(sessionId, parentId)
+  }
+}
+
+/**
+ * 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: assumes throwing inside tool.execute.before fails the tool call gracefully.
+ */
+export function checkToolIsolation(
+  registry: MemberRegistry,
+  tracker: DescendantTracker,
+  toolName: string,
+  sessionId: string,
+): void {
+  if (!toolName.startsWith(TEAM_TOOL_PREFIX)) return
+
+  // If the session is a registered team member or lead, allow it
+  if (registry.isTeamSession(sessionId)) return
+
+  // Check if this session is a descendant of any team member
+  const allTeamSessions = new Set<string>()
+  for (const entry of registry["bySession"].keys()) {
+    allTeamSessions.add(entry)
+  }
+
+  if (allTeamSessions.size > 0 && tracker.isDescendantOf(sessionId, allTeamSessions)) {
+    throw new Error("Team tools are not available to sub-agents. Report findings to your parent teammate via your normal output.")
+  }
+}

package/src/index.ts

@@ -0,0 +1,282 @@
+import type { Plugin } from "@opencode-ai/plugin"
+import { tool } from "@opencode-ai/plugin"
+import path from "path"
+import { createDb } from "./db"
+import { recoverStaleMembers } from "./recovery"
+import { MemberRegistry, DescendantTracker } from "./state"
+import { handleSessionStatusEvent, handleSessionCreatedEvent, checkToolIsolation } from "./hooks"
+import { notifyTeamEvent } from "./notify"
+import { executeTeamCreate } from "./tools/team-create"
+import { executeTeamSpawn } from "./tools/team-spawn"
+import { executeTeamMessage } from "./tools/team-message"
+import { executeTeamBroadcast } from "./tools/team-broadcast"
+import { executeTeamShutdown } from "./tools/team-shutdown"
+import { executeTeamCleanup } from "./tools/team-cleanup"
+import { executeTeamTasksList } from "./tools/team-tasks-list"
+import { executeTeamTasksAdd } from "./tools/team-tasks-add"
+import { executeTeamTasksComplete } from "./tools/team-tasks-complete"
+import { executeTeamClaim } from "./tools/team-claim"
+import { executeTeamApprovePlan } from "./tools/team-approve-plan"
+import { executeTeamStatus } from "./tools/team-status"
+import { executeTeamView } from "./tools/team-view"
+import type { ToolDeps, PluginClient } from "./types"
+import { TokenBucket } from "./rate-limit"
+
+const DEFAULT_RATE_LIMIT_CAPACITY = 10
+const DEFAULT_RATE_LIMIT_REFILL = 2
+const DEFAULT_RATE_LIMIT_INTERVAL_MS = 1000
+
+/**
+ * opencode-ensemble plugin entry point.
+ * Enables agent teams: multiple agents running in parallel with
+ * peer-to-peer communication, shared task management, and coordinated execution.
+ */
+const plugin: Plugin = async (input) => {
+  // Initialize SQLite database in the project's .opencode directory
+  const dbPath = path.join(input.directory, ".opencode", "ensemble.db")
+  const db = createDb(dbPath)
+
+  // Initialize in-memory state
+  const registry = new MemberRegistry()
+  const tracker = new DescendantTracker()
+
+  // Run recovery on init — mark stale busy members as error
+  const recovery = recoverStaleMembers(db)
+  if (recovery.interrupted > 0) {
+    // Rebuild registry from DB for recovered members
+    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)
+    }
+  }
+
+  // Build shared tool dependencies
+  const client = input.client as unknown as PluginClient
+  const deps: ToolDeps = { db, registry, tracker, client }
+
+  // Initialize rate limiter
+  // OPENCODE_ENSEMBLE_RATE_LIMIT=0 disables it entirely
+  const rateLimitEnv = process.env.OPENCODE_ENSEMBLE_RATE_LIMIT
+  const rateLimitCapacity = rateLimitEnv === "0" ? 0 : (parseInt(rateLimitEnv ?? "", 10) || DEFAULT_RATE_LIMIT_CAPACITY)
+  const rateLimiter = new TokenBucket({
+    capacity: rateLimitCapacity,
+    refillRate: DEFAULT_RATE_LIMIT_REFILL,
+    refillIntervalMs: DEFAULT_RATE_LIMIT_INTERVAL_MS,
+  })
+
+  return {
+    // Event hook — drives state machine transitions + descendant tracking + toasts
+    async event({ event }) {
+      if (event.type === "session.status") {
+        const { sessionID, status } = event.properties
+        const statusType = status.type as "idle" | "busy" | "retry"
+        const transition = handleSessionStatusEvent(db, registry, sessionID, statusType)
+
+        // Fire toast notifications for meaningful transitions
+        if (transition) {
+          if (transition.to === "shutdown") {
+            notifyTeamEvent(client, "shutdown", { memberName: transition.memberName })
+          } else if (transition.to === "ready" && transition.from === "busy") {
+            notifyTeamEvent(client, "completed", { memberName: transition.memberName })
+          } else if (transition.to === "error") {
+            notifyTeamEvent(client, "error", { memberName: transition.memberName })
+          }
+        }
+      }
+
+      if (event.type === "session.created") {
+        const info = event.properties.info
+        if (info.parentID) {
+          handleSessionCreatedEvent(tracker, info.id, info.parentID)
+        }
+      }
+    },
+
+    // Sub-agent isolation + rate limiting hook
+    "tool.execute.before": async (input, _output) => {
+      checkToolIsolation(registry, tracker, input.tool, input.sessionID)
+      // Rate limit team tools that trigger LLM inference
+      if (input.tool.startsWith("team_")) {
+        if (!rateLimiter.tryConsume()) {
+          await rateLimiter.waitForToken()
+        }
+      }
+    },
+
+    // Register all team tools
+    tool: {
+      team_create: tool({
+        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)"),
+        },
+        async execute(args, ctx) {
+          const result = await executeTeamCreate(deps, args, ctx.sessionID)
+          ctx.metadata({ title: `Created team: ${args.name}` })
+          return result
+        },
+      }),
+
+      team_spawn: tool({
+        description: "Spawn a new teammate that works in parallel. The teammate starts immediately with the given prompt. " +
+          "Teammates work asynchronously and will message you when done. Do not poll for their status.",
+        args: {
+          name: tool.schema.string().describe("Teammate name (lowercase alphanumeric with hyphens)"),
+          agent: tool.schema.string().default("build").describe("Agent type (e.g. 'build', 'plan', 'explore')"),
+          prompt: tool.schema.string().describe("Task instructions for the teammate"),
+          model: tool.schema.string().optional().describe("Model in provider/model format (optional, uses default)"),
+          claim_task: tool.schema.string().optional().describe("Task ID to auto-claim for this teammate (optional)"),
+        },
+        async execute(args, ctx) {
+          const result = await executeTeamSpawn(deps, args, ctx.sessionID)
+          ctx.metadata({ title: `Spawned ${args.name} (${args.agent})` })
+          return result
+        },
+      }),
+
+      team_message: tool({
+        description: "Send a message to a specific teammate or to the lead. Use 'lead' to message the team lead.",
+        args: {
+          to: tool.schema.string().describe("Recipient name ('lead' or teammate name)"),
+          text: tool.schema.string().describe("Message content (max 10KB)"),
+        },
+        async execute(args, ctx) {
+          const result = await executeTeamMessage(deps, args, ctx.sessionID)
+          ctx.metadata({ title: `Message → ${args.to}` })
+          return result
+        },
+      }),
+
+      team_broadcast: tool({
+        description: "Send a message to all teammates and the lead (excluding yourself).",
+        args: {
+          text: tool.schema.string().describe("Message content (max 10KB)"),
+        },
+        async execute(args, ctx) {
+          const result = await executeTeamBroadcast(deps, args, ctx.sessionID)
+          ctx.metadata({ title: "Broadcast to team" })
+          return result
+        },
+      }),
+
+      team_tasks_list: tool({
+        description: "View the shared team task board. Use this to check task status, not to wait for teammates. Teammates will message you when done.",
+        args: {},
+        async execute(_args, ctx) {
+          const result = await executeTeamTasksList(deps, ctx.sessionID)
+          const count = result === "No tasks on the board." ? 0 : result.split("\n").length
+          ctx.metadata({ title: count > 0 ? `Task board (${count} tasks)` : "Task board (empty)" })
+          return result
+        },
+      }),
+
+      team_tasks_add: tool({
+        description: "Add tasks to the shared team task board so teammates can see what work is available and claim it.",
+        args: {
+          tasks: tool.schema.array(tool.schema.object({
+            content: tool.schema.string().describe("Task description"),
+            priority: tool.schema.enum(["high", "medium", "low"]).default("medium").describe("Task priority"),
+            depends_on: tool.schema.array(tool.schema.string()).optional().describe("Task IDs this depends on"),
+          })).describe("Tasks to add"),
+        },
+        async execute(args, ctx) {
+          const result = await executeTeamTasksAdd(deps, args, ctx.sessionID)
+          ctx.metadata({ title: `Added ${args.tasks.length} task${args.tasks.length !== 1 ? "s" : ""}` })
+          return result
+        },
+      }),
+
+      team_tasks_complete: tool({
+        description: "Mark a task as completed on the shared board. This unblocks any tasks that depend on it.",
+        args: {
+          task_id: tool.schema.string().describe("ID of the task to mark complete"),
+        },
+        async execute(args, ctx) {
+          const result = await executeTeamTasksComplete(deps, args, ctx.sessionID)
+          ctx.metadata({ title: `Completed task` })
+          return result
+        },
+      }),
+
+      team_claim: tool({
+        description: "Claim a pending task from the shared task list. Only unclaimed, unblocked tasks can be claimed.",
+        args: {
+          task_id: tool.schema.string().describe("ID of the task to claim"),
+        },
+        async execute(args, ctx) {
+          const result = await executeTeamClaim(deps, args, ctx.sessionID)
+          ctx.metadata({ title: `Claimed task` })
+          return result
+        },
+      }),
+
+      team_approve_plan: tool({
+        description: "Approve or reject a teammate's implementation plan. Only the team lead can use this.",
+        args: {
+          member: tool.schema.string().describe("Teammate name"),
+          approved: tool.schema.boolean().describe("true to approve, false to reject"),
+          feedback: tool.schema.string().optional().describe("Feedback message (optional)"),
+        },
+        async execute(args, ctx) {
+          const result = await executeTeamApprovePlan(deps, args, ctx.sessionID)
+          ctx.metadata({ title: `Plan ${args.approved ? "approved" : "rejected"}: ${args.member}` })
+          return result
+        },
+      }),
+
+      team_shutdown: tool({
+        description: "Request a teammate to shut down. The teammate finishes current work then stops.",
+        args: {
+          member: tool.schema.string().describe("Teammate name to shut down"),
+        },
+        async execute(args, ctx) {
+          const result = await executeTeamShutdown(deps, args, ctx.sessionID)
+          ctx.metadata({ title: `Shutdown → ${args.member}` })
+          return result
+        },
+      }),
+
+      team_cleanup: tool({
+        description: "Clean up the team. All teammates must be shut down first. Removes team data and frees resources.",
+        args: {
+          force: tool.schema.boolean().default(false).describe("Force cleanup even if members are active (will abort them)"),
+        },
+        async execute(args, ctx) {
+          const result = await executeTeamCleanup(deps, args, ctx.sessionID)
+          ctx.metadata({ title: "Team cleaned up" })
+          return result
+        },
+      }),
+
+      team_status: tool({
+        description: "View team members with their current status, agent type, and session IDs. " +
+          "Use this to check who is working, idle, or shut down. Includes a task summary.",
+        args: {},
+        async execute(_args, ctx) {
+          const result = await executeTeamStatus(deps, ctx.sessionID)
+          const members = deps.db.query("SELECT status FROM team_member WHERE team_id IN (SELECT id FROM team WHERE lead_session_id = ? OR id IN (SELECT team_id FROM team_member WHERE session_id = ?))").all(ctx.sessionID, ctx.sessionID) as Array<{ status: string }>
+          const busy = members.filter(m => m.status === "busy").length
+          ctx.metadata({ title: `Team: ${members.length} members (${busy} working)` })
+          return result
+        },
+      }),
+
+      team_view: tool({
+        description: "Navigate the TUI to a teammate's session so you can see what they are doing. " +
+          "Use the session picker (ctrl+p) to return to the lead session.",
+        args: {
+          member: tool.schema.string().describe("Teammate name to view"),
+        },
+        async execute(args, ctx) {
+          const result = await executeTeamView(deps, args, ctx.sessionID)
+          ctx.metadata({ title: `Viewing ${args.member}` })
+          return result
+        },
+      }),
+    },
+  }
+}
+
+export default plugin

package/src/messaging.ts

@@ -0,0 +1,78 @@
+import type { Database } from "bun:sqlite"
+import { generateId } from "./util"
+
+const MAX_CONTENT_BYTES = 10 * 1024 // 10KB
+
+/** Input for sending a direct message. */
+export interface SendMessageInput {
+  teamId: string
+  from: string
+  to: string
+  content: string
+}
+
+/** Input for broadcasting a message. */
+export interface BroadcastMessageInput {
+  teamId: string
+  from: string
+  content: string
+}
+
+/** A message row from the database. */
+export interface MessageRow {
+  id: string
+  team_id: string
+  from_name: string
+  to_name: string | null
+  content: string
+  delivered: number
+  time_created: number
+}
+
+/**
+ * Insert a direct message into team_message. Returns the message ID.
+ * Throws if content exceeds 10KB.
+ */
+export function sendMessage(db: Database, input: SendMessageInput): string {
+  if (new TextEncoder().encode(input.content).length > MAX_CONTENT_BYTES) {
+    throw new Error("Message content exceeds 10KB limit")
+  }
+  const id = generateId("msg")
+  db.run(
+    "INSERT INTO team_message (id, team_id, from_name, to_name, content, delivered, time_created) VALUES (?, ?, ?, ?, ?, 0, ?)",
+    [id, input.teamId, input.from, input.to, input.content, Date.now()]
+  )
+  return id
+}
+
+/**
+ * Insert a broadcast message (to_name = NULL) into team_message. Returns the message ID.
+ * Throws if content exceeds 10KB.
+ */
+export function broadcastMessage(db: Database, input: BroadcastMessageInput): string {
+  if (new TextEncoder().encode(input.content).length > MAX_CONTENT_BYTES) {
+    throw new Error("Message content exceeds 10KB limit")
+  }
+  const id = generateId("msg")
+  db.run(
+    "INSERT INTO team_message (id, team_id, from_name, to_name, content, delivered, time_created) VALUES (?, ?, ?, NULL, ?, 0, ?)",
+    [id, input.teamId, input.from, input.content, Date.now()]
+  )
+  return id
+}
+
+/**
+ * Get all undelivered messages for a team.
+ */
+export function getUndeliveredMessages(db: Database, teamId: string): MessageRow[] {
+  return db.query(
+    "SELECT * FROM team_message WHERE team_id = ? AND delivered = 0 ORDER BY time_created ASC"
+  ).all(teamId) as MessageRow[]
+}
+
+/**
+ * Mark a message as delivered.
+ */
+export function markDelivered(db: Database, messageId: string): void {
+  db.run("UPDATE team_message SET delivered = 1 WHERE id = ?", [messageId])
+}

package/src/notify.ts

@@ -0,0 +1,54 @@
+import type { PluginClient } from "./types"
+
+type TeamEventType = "spawn" | "message" | "completed" | "error" | "shutdown"
+
+interface SpawnEvent { memberName: string; agent: string }
+interface MessageEvent { from: string; to: string }
+interface MemberEvent { memberName: string }
+
+type TeamEventData =
+  | { type: "spawn"; data: SpawnEvent }
+  | { type: "message"; data: MessageEvent }
+  | { type: "completed"; data: MemberEvent }
+  | { type: "error"; data: MemberEvent }
+  | { type: "shutdown"; data: MemberEvent }
+
+const TOAST_CONFIG: Record<TeamEventType, { variant: "info" | "success" | "warning" | "error"; duration: number }> = {
+  spawn: { variant: "success", duration: 3000 },
+  message: { variant: "info", duration: 3000 },
+  completed: { variant: "info", duration: 4000 },
+  error: { variant: "error", duration: 5000 },
+  shutdown: { variant: "info", duration: 3000 },
+}
+
+function formatMessage(type: TeamEventType, data: Record<string, string>): string {
+  switch (type) {
+    case "spawn": return `Teammate ${data.memberName} spawned (${data.agent})`
+    case "message": return `Message from ${data.from}`
+    case "completed": return `${data.memberName} finished work`
+    case "error": return `${data.memberName} encountered an error`
+    case "shutdown": return `${data.memberName} shut down`
+  }
+}
+
+/**
+ * Fire a toast notification for a team event.
+ * Silently swallows errors — TUI may not be available.
+ */
+export async function notifyTeamEvent(
+  client: PluginClient,
+  type: TeamEventType,
+  data: Record<string, string>,
+): Promise<void> {
+  const config = TOAST_CONFIG[type]
+  try {
+    await client.tui.showToast({
+      title: "Team",
+      message: formatMessage(type, data),
+      variant: config.variant,
+      duration: config.duration,
+    })
+  } catch {
+    // TUI may not be available — silently ignore
+  }
+}

package/src/rate-limit.ts

@@ -0,0 +1,76 @@
+/**
+ * Token bucket rate limiter for controlling concurrent LLM inference.
+ * Capacity 0 disables the limiter (all calls pass immediately).
+ */
+export class TokenBucket {
+  private tokens: number
+  private readonly capacity: number
+  private readonly refillRate: number
+  private readonly refillIntervalMs: number
+  private lastRefill: number
+  private readonly disabled: boolean
+
+  constructor(opts: { capacity: number; refillRate: number; refillIntervalMs: number }) {
+    this.disabled = opts.capacity === 0
+    this.capacity = opts.capacity
+    this.tokens = opts.capacity
+    this.refillRate = opts.refillRate
+    this.refillIntervalMs = opts.refillIntervalMs
+    this.lastRefill = Date.now()
+  }
+
+  /** Refill tokens based on elapsed time. */
+  private refill(): void {
+    if (this.disabled) return
+    const now = Date.now()
+    const elapsed = now - this.lastRefill
+    if (elapsed < this.refillIntervalMs) return
+    const intervals = Math.floor(elapsed / this.refillIntervalMs)
+    this.tokens = Math.min(this.capacity, this.tokens + intervals * this.refillRate)
+    this.lastRefill += intervals * this.refillIntervalMs
+  }
+
+  /**
+   * Try to consume one token. Returns true if a token was available,
+   * false if the bucket is empty. Disabled buckets always return true.
+   */
+  tryConsume(): boolean {
+    if (this.disabled) return true
+    this.refill()
+    if (this.tokens > 0) {
+      this.tokens--
+      return true
+    }
+    return false
+  }
+
+  /**
+   * Wait until a token is available, then consume it.
+   * Respects an optional AbortSignal.
+   */
+  async waitForToken(signal?: AbortSignal): Promise<void> {
+    if (this.disabled) return
+    if (this.tryConsume()) return
+
+    return new Promise((resolve, reject) => {
+      const checkInterval = Math.max(10, Math.floor(this.refillIntervalMs / 2))
+
+      const timer = setInterval(() => {
+        if (signal?.aborted) {
+          clearInterval(timer)
+          reject(new Error("Rate limit wait aborted"))
+          return
+        }
+        if (this.tryConsume()) {
+          clearInterval(timer)
+          resolve()
+        }
+      }, checkInterval)
+
+      signal?.addEventListener("abort", () => {
+        clearInterval(timer)
+        reject(new Error("Rate limit wait aborted"))
+      }, { once: true })
+    })
+  }
+}