fix(queue): save queued edits on enter

Author: henry701

packages/app/e2e/regression/session-queue-controls.spec.ts

@@ -120,3 +120,62 @@ test("sends queued follow-ups with an explicit JSON body", async ({ page }) => {
     body: null,
   })
 })
+
+test("Enter saves a queued message edit without sending it", async ({ page }) => {
+  const updates: Array<{ sessionID: string; queueID: string; raw: string | null; body: unknown }> = []
+  const sends: unknown[] = []
+  const prompts: unknown[] = []
+
+  await mockOpenCodeServer(page, {
+    directory,
+    project: {
+      id: projectID,
+      worktree: directory,
+      vcs: "git",
+      name: "session-queue-controls-regression",
+      time: { created: 1700000000000, updated: 1700000000000 },
+      sandboxes: [],
+    },
+    provider: {
+      all: [
+        {
+          id: "opencode",
+          name: "OpenCode",
+          models: { "test-model": { id: "test-model", name: "Test Model", limit: { context: 200_000 } } },
+        },
+      ],
+      connected: ["opencode"],
+      default: model,
+    },
+    sessions: [session],
+    status: { [sessionID]: { type: "busy" } },
+    queue: { [sessionID]: [{ id: "pqu_edit", text: "queued draft" }] },
+    pageMessages: () => ({ items: [] }),
+    onQueueUpdate: (input) => updates.push(input),
+    onQueueSend: (input) => sends.push(input),
+    onPromptAsync: (input) => prompts.push(input),
+  })
+
+  await page.goto(`/${base64Encode(directory)}/session/${sessionID}`)
+  await expectSessionTitle(page, session.title)
+
+  const followupDock = page.locator('[data-component="session-followup-dock"]')
+  await expectAppVisible(followupDock)
+  await followupDock.getByRole("button", { name: "Edit" }).click()
+
+  const composer = page.locator('[data-component="session-composer"]')
+  const input = composer.locator('[data-component="prompt-input"]')
+  await expect(input).toContainText("queued draft")
+  await expect(followupDock.getByRole("button", { name: "Send now" })).toHaveCount(0)
+  await expect(composer.getByRole("button", { name: "Queue" })).toHaveCount(0)
+  await expect(composer.getByRole("button", { name: "Save" })).toBeVisible()
+
+  await input.fill("edited queued draft")
+  await input.press("Enter")
+
+  await expect.poll(() => updates.length).toBe(1)
+  expect(updates[0]).toMatchObject({ sessionID, queueID: "pqu_edit" })
+  expect(updates[0]?.raw).toContain("edited queued draft")
+  expect(sends).toHaveLength(0)
+  expect(prompts).toHaveLength(0)
+})

packages/app/e2e/utils/mock-server.ts

@@ -11,10 +11,12 @@ export interface MockServerConfig {
   createSession?: () => { id: string } & Record<string, unknown>
   onPromptAsync?: (input: { sessionID: string; body: unknown }) => void
   onQueueSend?: (input: { sessionID: string; queueID: string; raw: string | null; body: unknown }) => void
+  onQueueUpdate?: (input: { sessionID: string; queueID: string; raw: string | null; body: unknown }) => void
   agents?: unknown[]
   pageMessages: (sessionId: string, limit: number, before?: string) => { items: unknown[]; cursor?: string }
   status?: Record<string, unknown>
   queue?: Record<string, { id: string; text: string }[]>
+  queueDetails?: Record<string, Record<string, unknown>>
   vcsDiff?: unknown[]
   messageDelay?: number
   beforeMessagesResponse?: (input: { sessionID: string; before?: string }) => Promise<void>
@@ -96,7 +98,8 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
       })
     if (emptyObject.has(path)) return json(route, {})
     if (emptyList.has(path)) return json(route, [])
-    if (path === "/provider") return json(route, typeof config.provider === "function" ? config.provider() : config.provider)
+    if (path === "/provider")
+      return json(route, typeof config.provider === "function" ? config.provider() : config.provider)
 
     if (path === "/session" && route.request().method() === "POST") {
       const created = config.createSession?.()
@@ -143,6 +146,28 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
       return json(route, true)
     }
 
+    const queueItemMatch = path.match(/^\/session\/([^/]+)\/queue\/([^/]+)$/)
+    if (queueItemMatch && route.request().method() === "GET") {
+      const item = config.queue?.[queueItemMatch[1]!]?.find((entry) => entry.id === queueItemMatch[2])
+      return json(
+        route,
+        config.queueDetails?.[queueItemMatch[1]!]?.[queueItemMatch[2]!] ?? {
+          id: queueItemMatch[2],
+          parts: item ? [{ type: "text", text: item.text }] : [],
+        },
+      )
+    }
+    if (queueItemMatch && route.request().method() === "PATCH") {
+      const raw = route.request().postData()
+      config.onQueueUpdate?.({
+        sessionID: queueItemMatch[1]!,
+        queueID: queueItemMatch[2]!,
+        raw,
+        body: raw ? JSON.parse(raw) : undefined,
+      })
+      return json(route, true)
+    }
+
     const promptAsyncMatch = path.match(/^\/session\/([^/]+)\/prompt_async$/)
     if (promptAsyncMatch && route.request().method() === "POST") {
       const raw = route.request().postData()

packages/app/src/components/prompt-input.tsx

@@ -385,6 +385,15 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
   })
   const stopping = createMemo(() => working() && blank())
   const tip = () => {
+    if (editingQueueID()) {
+      return (
+        <div class="flex items-center gap-2">
+          <span>{language.t("common.save")}</span>
+          <Icon name="enter" size="small" class="text-icon-base" />
+        </div>
+      )
+    }
+
     if (stopping()) {
       return (
         <div class="flex items-center gap-2">
@@ -403,7 +412,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
   }
 
   const queueToggle = () => (
-    <Show when={store.mode === "normal" && !!props.controls.session.id}>
+    <Show when={store.mode === "normal" && !!props.controls.session.id && !editingQueueID()}>
       <TooltipV2
         placement="top"
         value={
@@ -1893,7 +1902,13 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                       "background-image":
                         "linear-gradient(180deg,var(--v2-alpha-light-20) 0%,var(--v2-alpha-light-0) 100%),linear-gradient(90deg,var(--v2-background-bg-contrast) 0%,var(--v2-background-bg-contrast) 100%)",
                     }}
-                    aria-label={stopping() ? language.t("prompt.action.stop") : language.t("prompt.action.send")}
+                    aria-label={
+                      stopping()
+                        ? language.t("prompt.action.stop")
+                        : editingQueueID()
+                          ? language.t("common.save")
+                          : language.t("prompt.action.send")
+                    }
                   />
                 </TooltipV2>
               </div>
@@ -2036,7 +2051,13 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                       }
                       variant="primary"
                       class="size-8"
-                      aria-label={stopping() ? language.t("prompt.action.stop") : language.t("prompt.action.send")}
+                      aria-label={
+                        stopping()
+                          ? language.t("prompt.action.stop")
+                          : editingQueueID()
+                            ? language.t("common.save")
+                            : language.t("prompt.action.send")
+                      }
                     />
                   </Tooltip>
                 </div>

packages/app/src/components/prompt-input/submit.test.ts

@@ -653,6 +653,42 @@ describe("prompt submit queue mode", () => {
     expect(queuedDrafts[0]).toMatchObject({ queueID: "pqu_edit" })
   })
 
+  test("editingQueueID commits through onQueue when queue mode is inactive", async () => {
+    params = { id: "session-1" }
+
+    const submit = createPromptSubmit({
+      prompt,
+      info: () => ({ id: "session-1" }),
+      imageAttachments: () => [],
+      commentCount: () => 0,
+      autoAccept: () => false,
+      mode: () => "normal",
+      working: () => false,
+      editor: () => undefined,
+      queueScroll: () => undefined,
+      promptLength: (value) => value.reduce((sum, part) => sum + ("content" in part ? part.content.length : 0), 0),
+      addToHistory: () => undefined,
+      resetHistoryNavigation: () => undefined,
+      setMode: () => undefined,
+      setPopover: () => undefined,
+      shouldQueue: () => false,
+      editingQueueID: () => "pqu_edit",
+      resetEditingQueueID: () => undefined,
+      onQueue: (draft) => {
+        queuedDrafts.push(draft)
+      },
+      onSubmit: () => undefined,
+    })
+
+    const event = { preventDefault: () => undefined } as unknown as Event
+
+    await submit.handleSubmit(event)
+
+    expect(queuedDrafts).toHaveLength(1)
+    expect(queuedDrafts[0]).toMatchObject({ queueID: "pqu_edit" })
+    expect(promptAsyncCalls).toHaveLength(0)
+  })
+
   test("shouldQueue routes existing sessions through onQueue", async () => {
     params = { id: "session-1" }
 

packages/app/src/components/prompt-input/submit.ts

@@ -455,7 +455,7 @@ export function createPromptSubmit(input: PromptSubmitInput) {
       return true
     }
 
-    if (!isNewSession && mode === "normal" && (input.shouldQueue?.() || queueMode)) {
+    if (!isNewSession && mode === "normal" && (draft.queueID || input.shouldQueue?.() || queueMode)) {
       input.onQueue?.(draft)
       input.resetQueueMode?.()
       if (draft.queueID) input.resetEditingQueueID?.()

packages/app/src/pages/session/composer/session-followup-dock.tsx

@@ -125,15 +125,17 @@ export function SessionFollowupDock(props: {
                     when={active()}
                     fallback={
                       <>
-                        <Button
-                          size="small"
-                          variant="secondary"
-                          class="shrink-0"
-                          disabled={!!props.sending}
-                          onClick={() => props.onSend(item.id)}
-                        >
-                          {language.t("session.followupDock.sendNow")}
-                        </Button>
+                        <Show when={!editing()}>
+                          <Button
+                            size="small"
+                            variant="secondary"
+                            class="shrink-0"
+                            disabled={!!props.sending}
+                            onClick={() => props.onSend(item.id)}
+                          >
+                            {language.t("session.followupDock.sendNow")}
+                          </Button>
+                        </Show>
                         <Button
                           size="small"
                           variant="ghost"

packages/opencode/scripts/adhoc-queue-qa-smoke.py

@@ -266,6 +266,10 @@ def send_queue_key(child: pexpect.spawn) -> None:
     child.send("\x1b[27;6;13~")
 
 
+def send_edit_queue_key(child: pexpect.spawn) -> None:
+    child.send("\x1b[1;3A")
+
+
 def send_submit(child: pexpect.spawn) -> None:
     child.send("\r")
 
@@ -657,6 +661,17 @@ def test_tui_attach_queue(
             )
             save_screen("tui-attach-queue-dock", snapshot(child))
             report.ok("TUI attach shows queued prompts in UI")
+
+            send_edit_queue_key(child)
+            wait_pattern(child, re.compile(r"Editing queued message|save edit", re.I), 15, "TUI queued edit mode")
+            child.send("-edited")
+            send_submit(child)
+            time.sleep(0.8)
+
+            edited = curl_json("GET", f"{base_url}/session/{sid}/queue", str(ws))
+            if not isinstance(edited, list) or len(edited) != 3 or "-edited" not in edited[0].get("text", ""):
+                raise RuntimeError(f"Enter did not save queued edit in place: {edited!r}")
+            report.ok("TUI Enter saves queued edit without sending it")
         except Exception as exc:
             save_screen("tui-attach-queue-dock-error", snapshot(child))
             if "timed out" in str(exc).lower():

packages/opencode/test/cli/tui/prompt-queue-tui-smoke.cli.test.ts

@@ -79,8 +79,8 @@ describe("prompt queue TUI smoke (serve + script)", () => {
 
         yield* Effect.sleep("150 millis")
 
-        const script = yield* Effect.tryPromise(() =>
-          Bun.spawn(["bash", scriptPath], {
+        const script = yield* Effect.tryPromise(async () => {
+          const child = Bun.spawn(["bash", scriptPath], {
             cwd: home,
             env: {
               ...process.env,
@@ -89,13 +89,21 @@ describe("prompt queue TUI smoke (serve + script)", () => {
               OPENCODE_SESSION_ID: sessionID,
               OPENCODE_ARTIFACT_DIR: artifactDir,
               OPENCODE_QUEUE_ONLY: "1",
+              OPENCODE_EDIT_FIRST: "1",
               OPENCODE_CLI_ENTRY: path.join(opencodeRoot, "src/index.ts"),
             },
             stdout: "pipe",
             stderr: "pipe",
-          }).exited,
-        )
-        expect(script).toBe(0)
+          })
+          const [exitCode, stdout, stderr] = await Promise.all([
+            child.exited,
+            new Response(child.stdout).text(),
+            new Response(child.stderr).text(),
+          ])
+          return { exitCode, stdout, stderr }
+        })
+        if (script.exitCode !== 0) throw new Error(`queue smoke failed\n${script.stderr}\n${script.stdout}`)
+        expect(script.exitCode).toBe(0)
 
         yield* Deferred.succeed(gate, void 0)
 
@@ -107,7 +115,7 @@ describe("prompt queue TUI smoke (serve + script)", () => {
 
         const inputs = yield* llm.inputs
         expect(inputs).toHaveLength(4)
-        expect(JSON.stringify(inputs[1]?.messages)).toContain("queue-one")
+        expect(JSON.stringify(inputs[1]?.messages)).toContain("queue-one-edited")
         expect(JSON.stringify(inputs[1]?.messages)).not.toContain("queue-two")
         expect(JSON.stringify(inputs[2]?.messages)).toContain("queue-two")
         expect(JSON.stringify(inputs[2]?.messages)).not.toContain("queue-three")
@@ -116,6 +124,9 @@ describe("prompt queue TUI smoke (serve + script)", () => {
         const queued = yield* Effect.tryPromise(() => readFile(path.join(artifactDir, "queued.txt"), "utf8"))
         expect(queued.trim()).toBe("queued")
 
+        const edited = yield* Effect.tryPromise(() => readFile(path.join(artifactDir, "edited.txt"), "utf8"))
+        expect(edited.trim()).toBe("queue-one-edited")
+
         const attach = yield* Effect.tryPromise(() =>
           readFile(path.join(artifactDir, "tui-attach.txt"), "utf8").catch(() => "attach skipped"),
         )

packages/opencode/test/lib/cli-process.ts

@@ -319,9 +319,8 @@ export function withCliFixture<A, E>(
       if (opts?.hostname) argv.push("--hostname", opts.hostname)
       if (opts?.extraArgs) argv.push(...opts.extraArgs)
 
-      // Acquire the subprocess; release sends SIGTERM and awaits exit on
-      // scope close. Wrapped in Effect.ignore so a flaky kill doesn't surface
-      // as a finalizer error during test teardown.
+      // Acquire the subprocess; release sends SIGTERM and escalates to SIGKILL
+      // if an active server drain prevents graceful shutdown.
       const proc = yield* Effect.acquireRelease(
         Effect.sync(() =>
           Bun.spawn(["bun", "run", "--conditions=browser", cliEntry, ...argv], {
@@ -332,9 +331,15 @@ export function withCliFixture<A, E>(
           }),
         ),
         (p) =>
-          Effect.promise(() => {
-            p.kill()
-            return p.exited
+          Effect.gen(function* () {
+            yield* Effect.sync(() => p.kill())
+            yield* Effect.promise(() => p.exited).pipe(
+              Effect.timeoutOrElse({
+                duration: Duration.seconds(2),
+                orElse: () => Effect.sync(() => p.kill("SIGKILL")),
+              }),
+            )
+            yield* Effect.promise(() => p.exited)
           }).pipe(Effect.ignore),
       )