opencode-queue 0.11.2 → 0.12.1

package/README.md

@@ -83,7 +83,7 @@ When the session is busy:
 - Queued entries replay in order after the session completes normally and becomes idle.
 - `/queue front ...` puts an entry before the existing queued entries.
 - Only one queued entry is sent per idle transition, so queued work runs one item at a time.
-- Queued entries are kept in place after an error or abort.
+- Queued entries are kept in place after an error, abort, crash, or restart.
 - `/queue stop` pauses automatic replay without clearing queued entries, and `/queue start` resumes it.
 - `/queue flush` sends all queued entries immediately in one batch, even before the session is idle.
 
@@ -113,7 +113,7 @@ When the session is idle:
 /queue clear 2 3
 ```
 
-The queue is in-memory and scoped to the current session.
+Queues are scoped to the current project and session. They are stored in OpenCode's user data directory and restored after OpenCode restarts or crashes. A send interrupted by a crash remains queued because the plugin cannot know whether OpenCode accepted it before exiting, so restored queues stay paused until explicitly started.
 
 ## Notes
 

package/index.ts

@@ -1,6 +1,10 @@
 import type { Plugin } from "@opencode-ai/plugin"
 import type { AgentPartInput, FilePart, FilePartInput, SubtaskPartInput, TextPart, TextPartInput } from "@opencode-ai/sdk"
 import { HttpServerResponse } from "effect/unstable/http"
+import { createHash, randomUUID } from "node:crypto"
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import { dirname, join } from "node:path"
 
 const QUEUE = /^\/queue(?:\s+([\s\S]*))?$/
 const SUFFIX = /^([\s\S]*?)\s+\/queue(?:\s+(front))?\s*$/
@@ -18,19 +22,22 @@ type Post = (input: { url: string; path?: Record<string, string>; body?: unknown
 type QueueInput = { body: string; front: boolean }
 
 type Item =
-  | { kind: "prompt"; info: Info; label: string; body: string; parts: InputPart[] }
+  | { kind: "prompt"; info: Info; body: string; parts: InputPart[] }
   | { kind: "command"; info: Info; source: string; cmd: string; args: string; files: FilePartInput[] }
   | { kind: "compact"; info: Info; source: string }
   | { kind: "shell"; info: Info; source: string; shell: string }
 
 type EntryOp =
-  | { kind: "prompt"; label: string; body: string }
+  | { kind: "prompt"; body: string }
   | { kind: "command"; source: string; cmd: string; args: string }
   | { kind: "compact"; source: string }
   | { kind: "shell"; source: string; shell: string }
 
-type Activity = { kind: "idle" } | { kind: "busy" } | { kind: "sending"; idle: boolean }
-type State = { items: Item[]; activity: Activity; stopped: boolean; failed: boolean }
+type Activity = { kind: "idle" } | { kind: "busy" } | { kind: "sending"; idle: boolean; items: Item[] }
+type State = { items: Item[]; activity: Activity; stopped: boolean; failed: boolean; hidden: Set<string> }
+type Durable = Pick<State, "items" | "stopped" | "hidden">
+type Store = { version: 1; projectID: string; sessions: Record<string, { items: Item[]; stopped: boolean; hidden: string[] }> }
+type Placeholder = { id: string; part: TextPart }
 
 type Op =
   | { kind: "list" }
@@ -43,11 +50,6 @@ type Op =
 
 type ControlOp = Extract<Op, { kind: "list" | "clear" | "flush" | "start" | "stop" }>
 
-const brief = (body: string, files: number) => {
-  const text = body.trim() || `${files} attachment${files === 1 ? "" : "s"}`
-  return text.length > 72 ? `${text.slice(0, 69)}...` : text
-}
-
 const parsePrefix = (body: string): QueueInput => {
   const match = body.trim().match(/^front(?:\s+([\s\S]*))?$/)
   return match ? { body: match[1] ?? "", front: true } : { body, front: false }
@@ -97,7 +99,7 @@ const parse = (input: QueueInput, files = 0): Op => {
     }
     return { kind: "command", source: text, cmd, args, front }
   }
-  return { kind: "prompt", label: brief(input.body, files), body: input.body, front }
+  return { kind: "prompt", body: input.body, front }
 }
 
 const parseSuffix = (text: string): QueueInput | undefined => {
@@ -125,9 +127,14 @@ const control = (op: Op): op is ControlOp => {
       return false
   }
 }
-const shouldQueue = (state?: State) => Boolean(state && (state.activity.kind !== "idle" || state.stopped))
+const shouldQueue = (state?: State) => Boolean(state && (state.activity.kind !== "idle" || state.stopped || state.items.length))
 const shouldDeclinePlan = (state?: State) => Boolean(state && (state.activity.kind === "sending" || (!state.stopped && state.items.length)))
-const itemText = (item: Item) => (item.kind === "prompt" ? item.body.trim() || item.label : item.source)
+const itemText = (item: Item) => {
+  if (item.kind !== "prompt") return item.source
+  const body = item.body.trim()
+  const count = item.parts.filter((part) => part.type === "file").length
+  return body || `${count} attachment${count === 1 ? "" : "s"}`
+}
 // OpenCode's command hook has no cancel/noReply output. Throwing a raw Effect
 // response is handled by OpenCode's HTTP layer as an empty successful command.
 const handled = (): never => {
@@ -139,20 +146,152 @@ const plan = (event: unknown): event is Ask => {
   return question?.header === "Build Agent" && question.question.includes("switch to the build agent")
 }
 
-export const QueuePlugin: Plugin = async ({ client, directory }) => {
+const record = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null
+const validInfo = (value: unknown): value is Info =>
+  record(value) &&
+  typeof value.agent === "string" &&
+  record(value.model) &&
+  typeof value.model.providerID === "string" &&
+  typeof value.model.modelID === "string" &&
+  (value.variant === undefined || typeof value.variant === "string")
+const validPart = (value: unknown): value is InputPart => {
+  if (!record(value)) return false
+  switch (value.type) {
+    case "text":
+      return typeof value.text === "string"
+    case "file":
+      return typeof value.mime === "string" && typeof value.url === "string"
+    case "agent":
+      return typeof value.name === "string"
+    case "subtask":
+      return typeof value.prompt === "string" && typeof value.description === "string" && typeof value.agent === "string"
+    default:
+      return false
+  }
+}
+const validItem = (value: unknown): value is Item => {
+  if (!record(value) || !validInfo(value.info)) return false
+  switch (value.kind) {
+    case "prompt":
+      return typeof value.body === "string" && Array.isArray(value.parts) && value.parts.length > 0 && value.parts.every(validPart)
+    case "command":
+      return typeof value.source === "string" && typeof value.cmd === "string" && typeof value.args === "string" && Array.isArray(value.files) && value.files.every((part) => validPart(part) && part.type === "file")
+    case "compact":
+      return typeof value.source === "string"
+    case "shell":
+      return typeof value.source === "string" && typeof value.shell === "string"
+    default:
+      return false
+  }
+}
+
+const dataHome = () => {
+  if (process.env.XDG_DATA_HOME) return process.env.XDG_DATA_HOME
+  if (process.platform === "win32" && process.env.LOCALAPPDATA) return process.env.LOCALAPPDATA
+  if (process.platform === "darwin") return join(homedir(), "Library", "Application Support")
+  return join(homedir(), ".local", "share")
+}
+
+export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
   const sessions = new Map<string, State>()
-  const hidden = new Set<string>()
+  const deleted = new Set<string>()
+  const enqueueTurns = new Map<string, Promise<unknown>>()
   const post = (client as unknown as { _client?: { post?: Post } })._client?.post
+  const path = join(dataHome(), "opencode", "opencode-queue", `${createHash("sha256").update(project.id).digest("hex")}.json`)
+  let writes = Promise.resolve()
+
+  try {
+    const parsed: unknown = JSON.parse(await readFile(path, "utf8"))
+    if (!record(parsed) || parsed.version !== 1 || parsed.projectID !== project.id || !record(parsed.sessions)) {
+      console.warn("QueuePlugin ignored invalid queue storage", path)
+    } else {
+      for (const [sid, value] of Object.entries(parsed.sessions)) {
+        if (!record(value) || typeof value.stopped !== "boolean" || !Array.isArray(value.items)) {
+          console.warn("QueuePlugin skipped invalid stored session", sid)
+          continue
+        }
+        const items = value.items.filter(validItem)
+        if (items.length !== value.items.length) console.warn("QueuePlugin skipped invalid stored queue items", sid)
+        const validHidden = Array.isArray(value.hidden) && value.hidden.every((id) => typeof id === "string")
+        if (!validHidden) console.warn("QueuePlugin skipped invalid stored hidden messages", sid)
+        const hidden = new Set(validHidden ? (value.hidden as string[]) : [])
+        const stopped = value.stopped || items.length > 0
+        if (items.length && !value.stopped) console.warn("QueuePlugin paused restored queued input to prevent duplicate replay after a restart", sid)
+        if (items.length || stopped || hidden.size) sessions.set(sid, { items, activity: { kind: "idle" }, stopped, failed: false, hidden })
+      }
+    }
+  } catch (error) {
+    if (!record(error) || error.code !== "ENOENT") console.error("QueuePlugin failed to load queue storage", error)
+  }
+
+  const save = async (sid?: string, draft?: Durable) => {
+    const stored: Store = { version: 1, projectID: project.id, sessions: {} }
+    for (const [id, current] of sessions) {
+      if (deleted.has(id) || (id === sid && !draft)) continue
+      const durable = id === sid ? draft! : current
+      const items = current.activity.kind === "sending" ? [...current.activity.items, ...durable.items] : durable.items
+      if (items.length || durable.stopped || durable.hidden.size) stored.sessions[id] = { items, stopped: durable.stopped, hidden: [...durable.hidden] }
+    }
+    const contents = `${JSON.stringify(stored, null, 2)}\n`
+    await mkdir(dirname(path), { recursive: true })
+    const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`
+    try {
+      await writeFile(temporary, contents, { mode: 0o600 })
+      await rename(temporary, path)
+    } finally {
+      await rm(temporary, { force: true }).catch((error) => console.warn("QueuePlugin failed to remove temporary queue storage", error))
+    }
+  }
+
+  const serialize = <T>(action: () => Promise<T>) => {
+    const transaction = writes.then(action)
+    writes = transaction.then(() => undefined, () => undefined)
+    return transaction
+  }
 
   const state = (sid: string) => {
     let current = sessions.get(sid)
     if (!current) {
-      current = { items: [], activity: { kind: "idle" }, stopped: false, failed: false }
+      current = { items: [], activity: { kind: "idle" }, stopped: false, failed: false, hidden: new Set() }
       sessions.set(sid, current)
     }
     return current
   }
 
+  const store = async (sid: string, current: State, draft: Durable, placeholder?: Placeholder) => {
+    try {
+      await save(sid, draft)
+    } catch (error) {
+      console.error("QueuePlugin failed to persist queues", error)
+      throw error
+    }
+    current.items.splice(0, current.items.length, ...draft.items)
+    current.stopped = draft.stopped
+    current.hidden = draft.hidden
+    if (placeholder) Object.assign(placeholder.part, { text: "", synthetic: true, ignored: true })
+  }
+
+  const persist = <T>(sid: string, placeholder: Placeholder | undefined, mutate: (draft: Durable) => T) =>
+    serialize(async () => {
+      if (deleted.has(sid)) throw new Error(`QueuePlugin cannot persist queue state for deleted session ${sid}`)
+      const current = state(sid)
+      const draft: Durable = { items: [...current.items], stopped: current.stopped, hidden: new Set(current.hidden) }
+      if (placeholder) draft.hidden.add(placeholder.id)
+      const value = mutate(draft)
+      await store(sid, current, draft, placeholder)
+      return value
+    })
+
+  const orderedEnqueue = <T>(sid: string, action: () => Promise<T>) => {
+    const turn = (enqueueTurns.get(sid) ?? Promise.resolve()).catch(() => undefined).then(action)
+    enqueueTurns.set(sid, turn)
+    return turn.finally(() => {
+      if (enqueueTurns.get(sid) === turn) enqueueTurns.delete(sid)
+    })
+  }
+
+  const afterEnqueue = <T>(sid: string, action: () => Promise<T>) => (enqueueTurns.get(sid) ?? Promise.resolve()).catch(() => undefined).then(action)
+
   const toast = (message: string, variant: "info" | "error", duration = 2500) =>
     client.tui.showToast({ body: { message, variant, duration }, query: { directory } }).catch(() => undefined)
 
@@ -174,15 +313,9 @@ export const QueuePlugin: Plugin = async ({ client, directory }) => {
     if (!result?.response?.ok) console.warn("QueuePlugin failed to answer plan prompt", result?.error ?? result?.response?.status)
   }
 
-  const hide = (id: string, part: TextPart) => {
-    hidden.add(id)
-    Object.assign(part, { text: "", synthetic: true, ignored: true })
-  }
-
   const files = (parts: { type: string }[]) => parts.filter((part): part is FilePart => part.type === "file").map((part) => ({ ...part }))
 
-  const clear = (current: State, indices: number[]) => {
-    const list = current.items
+  const clear = (list: Item[], indices: number[]) => {
     if (!list.length) return "Queue is empty"
 
     if (!indices.length) {
@@ -223,7 +356,7 @@ export const QueuePlugin: Plugin = async ({ client, directory }) => {
 
   const opts = (info: Info) => ({ agent: info.agent, model: info.model, variant: info.variant })
 
-  const shell = (sid: string, command: string, info: Run) => client.session.shell({ path: { id: sid }, body: { agent: info.agent, model: info.model, command } })
+  const shell = (sid: string, command: string, info: Run) => client.session.shell({ path: { id: sid }, body: { agent: info.agent, model: info.model, command }, throwOnError: true })
   // TUI command events target the focused session; queued replay must target the original session.
   const compact = (sid: string, info: Info) =>
     client.session.summarize({
@@ -248,34 +381,23 @@ export const QueuePlugin: Plugin = async ({ client, directory }) => {
             arguments: item.args,
             parts: item.files,
           } as any,
+          throwOnError: true,
         })
       case "prompt": {
-        if (!item.parts.length) {
-          console.warn("QueuePlugin skipped queued item without replayable content")
-          return
-        }
-
         const parts = item.parts.map((part) => ({ ...part, id: undefined }))
-        return client.session.prompt({ path: { id: sid }, body: { ...opts(item.info), parts } as any })
+        return client.session.prompt({ path: { id: sid }, body: { ...opts(item.info), parts } as any, throwOnError: true })
       }
     }
   }
 
   const advance = (sid: string) => {
+    if (deleted.has(sid)) return
     const current = state(sid)
-    if (current.activity.kind !== "idle" || current.stopped || !current.items.length) return
-    void flush(sid, 1)
-  }
-
-  const settle = (sid: string, resume: boolean) => {
-    const current = state(sid)
-    current.activity = { kind: "idle" }
-    if (current.failed) {
-      current.failed = false
-      return
-    }
-
-    if (resume) advance(sid)
+    if (current.activity.kind !== "idle" || current.stopped || current.failed || !current.items.length) return
+    void flush(sid, 1).catch(async (error) => {
+      console.error("QueuePlugin could not advance the persisted queue", error)
+      await toast(`Queue persistence failed: ${error instanceof Error ? error.message : String(error)}`, "error", 5000)
+    })
   }
 
   const idle = (sid: string) => {
@@ -284,69 +406,113 @@ export const QueuePlugin: Plugin = async ({ client, directory }) => {
       current.activity.idle = true
       return
     }
-    if (current.activity.kind === "busy") settle(sid, true)
+    if (current.activity.kind !== "busy") return
+    current.activity = { kind: "idle" }
+    if (!current.failed) advance(sid)
   }
 
-  const flush = async (sid: string, count = Infinity) => {
-    const current = state(sid)
-    const items = current.items.splice(0, count)
-    if (!items.length) return { sent: 0, failed: 0 }
+  const flush = async (sid: string, count = Infinity, placeholder?: Placeholder) => {
+    type Reservation = "active" | undefined | { current: State; items: Item[]; sending: Extract<Activity, { kind: "sending" }> }
 
-    current.activity = { kind: "sending", idle: false }
-    let retry: Item[] = []
-    try {
-      const results = await Promise.all(
-        items.map(async (item) => {
-          try {
-            await replay(sid, item)
-            return { item, failed: false }
-          } catch (error) {
-            console.error("QueuePlugin failed to flush queued input", error)
-            await toast(`Queue failed: ${error instanceof Error ? error.message : String(error)}`, "error")
-            return { item, failed: true }
-          }
-        }),
-      )
-      retry = results.flatMap((result) => (result.failed ? [result.item] : []))
-    } finally {
-      if (retry.length) current.items.unshift(...retry)
-      const failed = retry.length
-      const replayCompleted = current.activity.kind === "sending" && current.activity.idle
-      if (replayCompleted) settle(sid, count === 1 && failed === 0)
-      else current.activity = failed ? { kind: "idle" } : { kind: "busy" }
+    const reservation = await serialize<Reservation>(async () => {
+      if (deleted.has(sid)) return undefined
+      const current = state(sid)
+      if (count === 1 && !placeholder && (current.activity.kind !== "idle" || current.stopped || !current.items.length)) return undefined
+
+      const items = current.items.slice(0, count)
+      if (placeholder) {
+        const draft: Durable = { items: [...current.items], stopped: current.stopped, hidden: new Set(current.hidden).add(placeholder.id) }
+        await store(sid, current, draft, placeholder)
+        if (deleted.has(sid)) return undefined
+      }
+      if (current.activity.kind === "sending") return "active"
+      if (!items.length) return undefined
+
+      const sending: Extract<Activity, { kind: "sending" }> = { kind: "sending", idle: false, items }
+      current.items.splice(0, items.length)
+      current.activity = sending
+      return { current, items, sending }
+    })
+
+    if (reservation === "active") {
+      console.warn("QueuePlugin ignored a concurrent queue flush", sid)
+      return undefined
     }
+    if (!reservation) return { sent: 0, failed: 0 }
+
+    const { current, items, sending } = reservation
+    const results = await Promise.all(
+      items.map(async (item) => {
+        try {
+          await replay(sid, item)
+          return { item, failed: false }
+        } catch (error) {
+          console.error("QueuePlugin failed to flush queued input", error)
+          await toast(`Queue failed: ${error instanceof Error ? error.message : String(error)}`, "error")
+          return { item, failed: true }
+        }
+      }),
+    )
+    const retry = results.flatMap((result) => (result.failed ? [result.item] : []))
+    const resume = await serialize(async () => {
+      if (sessions.get(sid) !== current) return false
+      if (current.activity !== sending) throw new Error(`QueuePlugin lost track of in-flight queued items for session ${sid}`)
+
+      sending.items = retry
+      try {
+        await save()
+      } catch (error) {
+        sending.items = items
+        current.items.unshift(...items)
+        current.activity = sending.idle ? { kind: "idle" } : { kind: "busy" }
+        console.error("QueuePlugin failed to persist queues", error)
+        throw error
+      }
+
+      const failed = current.failed
+      if (retry.length) current.items.unshift(...retry)
+      if (sending.idle) {
+        current.activity = { kind: "idle" }
+      } else current.activity = retry.length ? { kind: "idle" } : { kind: "busy" }
+      return sending.idle && !failed && count === 1 && !retry.length
+    })
+    if (resume) advance(sid)
     return { sent: items.length - retry.length, failed: retry.length }
   }
 
-  const manage = async (sid: string, op: ControlOp) => {
-    const current = state(sid)
-
-    switch (op.kind) {
-      case "list": {
-        const list = current.items.map((item, i) => `${i + 1}. ${itemText(item)}`).join("\n") || "Queue is empty"
-        return current.stopped ? `${list}\nQueue is stopped` : list
-      }
-      case "clear":
-        return clear(current, op.indices)
-      case "stop":
-        current.stopped = true
-        return "Queue stopped"
-      case "start":
-        current.stopped = false
-        current.failed = false
-        advance(sid)
-        return "Queue started"
-      case "flush": {
-        const result = await flush(sid)
-        if (!result.sent && !result.failed) return "Queue is empty"
+  const manage = async (sid: string, op: ControlOp, placeholder?: Placeholder) => {
+    if (op.kind === "flush") {
+      const result = await flush(sid, Infinity, placeholder)
+      if (!result) return "Queue is already flushing"
+      if (!result.sent && !result.failed) return "Queue is empty"
+      const message = `Flushed ${result.sent} queued item${result.sent === 1 ? "" : "s"}`
+      return result.failed ? `${message}; ${result.failed} failed` : message
+    }
 
-        const message = `Flushed ${result.sent} queued item${result.sent === 1 ? "" : "s"}`
-        return result.failed ? `${message}; ${result.failed} failed` : message
+    const message = await persist(sid, placeholder, (draft) => {
+      switch (op.kind) {
+        case "list": {
+          const list = draft.items.map((item, i) => `${i + 1}. ${itemText(item)}`).join("\n") || "Queue is empty"
+          return draft.stopped ? `${list}\nQueue is stopped` : list
+        }
+        case "clear":
+          return clear(draft.items, op.indices)
+        case "stop":
+          draft.stopped = true
+          return "Queue stopped"
+        case "start":
+          draft.stopped = false
+          return "Queue started"
       }
+    })
+    if (op.kind === "start") {
+      state(sid).failed = false
+      advance(sid)
     }
+    return message
   }
 
-  return {
+  const hooks: Awaited<ReturnType<Plugin>> = {
     config: async (cfg) => {
       cfg.command ??= {}
       cfg.command.queue = { template: "", description: "Queue input until the session is idle" }
@@ -366,11 +532,29 @@ export const QueuePlugin: Plugin = async ({ client, directory }) => {
           console.warn("QueuePlugin could not suppress queued replay after session.error because the event has no sessionID")
           return
         }
+        if (deleted.has(sid)) return
         state(sid).failed = true
         return
       }
 
+      if (event.type === "session.deleted") {
+        const sid = event.properties.info.id
+        if (deleted.has(sid) && !sessions.has(sid)) return
+        deleted.add(sid)
+        await serialize(async () => {
+          try {
+            await save(sid)
+          } catch (error) {
+            console.error("QueuePlugin failed to persist queues", error)
+            throw error
+          }
+          sessions.delete(sid)
+        })
+        return
+      }
+
       if (event.type === "session.idle") {
+        if (deleted.has(event.properties.sessionID)) return
         idle(event.properties.sessionID)
         return
       }
@@ -378,6 +562,7 @@ export const QueuePlugin: Plugin = async ({ client, directory }) => {
       if (event.type !== "session.status") return
 
       const sid = event.properties.sessionID
+      if (deleted.has(sid)) return
       const current = state(sid)
       if (event.properties.status.type !== "idle") {
         if (current.activity.kind !== "sending") current.activity = { kind: "busy" }
@@ -407,7 +592,7 @@ export const QueuePlugin: Plugin = async ({ client, directory }) => {
 
       const op = parse(parsePrefix(body), parts.length)
 
-      if (control(op)) return stop(await manage(sid, op))
+      if (control(op)) return stop(await afterEnqueue(sid, () => manage(sid, op)))
       if (op.kind === "invalid") return stop(op.message, "error")
 
       if (!shouldQueue(sessions.get(sid))) {
@@ -434,6 +619,10 @@ export const QueuePlugin: Plugin = async ({ client, directory }) => {
     },
     "chat.message": async (input, output) => {
       const sid = input.sessionID
+      if (deleted.has(sid)) {
+        console.warn("QueuePlugin ignored input for a deleted session", sid)
+        return
+      }
       const text = output.parts.find((part): part is TextPart => part.type === "text" && !part.synthetic)
       if (!text) return
 
@@ -444,28 +633,28 @@ export const QueuePlugin: Plugin = async ({ client, directory }) => {
       const parts = files(output.parts)
       const op = parse(request, parts.length)
       const info = { agent: input.agent ?? output.message.agent, model: input.model ?? output.message.model, variant: input.variant }
+      const placeholder = { id: output.message.id, part: text }
 
       if (control(op)) {
-        hide(output.message.id, text)
-        await toast(await manage(sid, op), "info", 5000)
+        await toast(await afterEnqueue(sid, () => manage(sid, op, placeholder)), "info", 5000)
         return
       }
 
       if (op.kind === "invalid") {
-        hide(output.message.id, text)
+        await persist(sid, placeholder, () => undefined)
         await toast(op.message, "error", 5000)
         return
       }
 
-      if (current.activity.kind === "idle" && !current.stopped) {
+      if (!shouldQueue(current)) {
         if (op.kind === "command") return
         if (op.kind === "compact") {
-          hide(output.message.id, text)
+          await persist(sid, placeholder, () => undefined)
           await compact(sid, info)
           return
         }
         if (op.kind === "shell") {
-          hide(output.message.id, text)
+          await persist(sid, placeholder, () => undefined)
           await shell(sid, op.shell, info)
           return
         }
@@ -473,37 +662,54 @@ export const QueuePlugin: Plugin = async ({ client, directory }) => {
         return
       }
 
-      const prior = await latest(sid)
-      if (prior) Object.assign(output.message, opts(prior))
-      else console.warn("QueuePlugin could not neutralize queued placeholder metadata because the session has no previous message context")
-      let item: Item
-      if (op.kind === "shell") item = { kind: "shell", info, source: op.source, shell: op.shell }
-      else if (op.kind === "compact") item = { kind: "compact", info, source: op.source }
-      else if (op.kind === "command") item = { kind: "command", info, source: op.source, cmd: op.cmd, args: op.args, files: parts }
-      else {
-        item = {
-          kind: "prompt",
-          info,
-          label: op.label,
-          body: op.body,
-          parts: output.parts.flatMap((part): InputPart[] => {
-            if (part.type === "text") return part.id === text.id ? (request.body ? [{ ...part, text: request.body }] : []) : [{ ...part }]
-            if (part.type === "file" || part.type === "agent" || part.type === "subtask") return [{ ...part }]
-            console.warn("QueuePlugin skipped unexpected part", part.type)
-            return []
-          }),
+      return orderedEnqueue(sid, async () => {
+        if (deleted.has(sid)) {
+          console.warn("QueuePlugin stopped queueing input for a deleted session", sid)
+          return
+        }
+        const prior = await latest(sid)
+        if (deleted.has(sid)) {
+          console.warn("QueuePlugin stopped queueing input for a deleted session", sid)
+          return
+        }
+        if (prior) Object.assign(output.message, opts(prior))
+        else console.warn("QueuePlugin could not neutralize queued placeholder metadata because the session has no previous message context")
+        let item: Item
+        if (op.kind === "shell") item = { kind: "shell", info, source: op.source, shell: op.shell }
+        else if (op.kind === "compact") item = { kind: "compact", info, source: op.source }
+        else if (op.kind === "command") item = { kind: "command", info, source: op.source, cmd: op.cmd, args: op.args, files: parts }
+        else {
+          item = {
+            kind: "prompt",
+            info,
+            body: op.body,
+            parts: output.parts.flatMap((part): InputPart[] => {
+              if (part.type === "text") return part.id === text.id ? (request.body ? [{ ...part, text: request.body }] : []) : [{ ...part }]
+              if (part.type === "file" || part.type === "agent" || part.type === "subtask") return [{ ...part }]
+              console.warn("QueuePlugin skipped unexpected part", part.type)
+              return []
+            }),
+          }
         }
-      }
 
-      if (op.front) current.items.unshift(item)
-      else current.items.push(item)
-      hide(output.message.id, text)
-      await toast(`${op.front ? "Queued first" : "Queued"}: ${itemText(item)}`, "info")
+        await persist(sid, placeholder, (draft) => {
+          if (op.front) draft.items.unshift(item)
+          else draft.items.push(item)
+        })
+        advance(sid)
+        await toast(`${op.front ? "Queued first" : "Queued"}: ${itemText(item)}`, "info")
+      })
     },
     "experimental.chat.messages.transform": async (_, output) => {
-      output.messages = output.messages.filter((msg) => !hidden.has(msg.info.id))
+      output.messages = output.messages.filter((msg) => {
+        for (const current of sessions.values()) if (current.hidden.has(msg.info.id)) return false
+        return true
+      })
     },
   }
+
+  for (const [sid, current] of sessions) if (current.items.length && !current.stopped) setTimeout(() => advance(sid), 0)
+  return hooks
 }
 
 export default QueuePlugin

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-queue",
-  "version": "0.11.2",
+  "version": "0.12.1",
   "type": "module",
   "description": "Queue OpenCode prompts and slash commands until the agent is idle",
   "main": "./index.ts",
@@ -29,12 +29,13 @@
     ".": "./index.ts"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=20.17.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
+    "test": "tsx --test index.test.js",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
@@ -43,6 +44,8 @@
   "devDependencies": {
     "@opencode-ai/plugin": "^1.14.37",
     "@opencode-ai/sdk": "^1.14.37",
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
     "typescript": "^6.0.3"
   },
   "overrides": {