diff --git a/agent/agent_runtime_helpers.py b/agent/agent_runtime_helpers.py
index 96f7bb821a7cd..5d87894a65fdf 100644
--- a/agent/agent_runtime_helpers.py
+++ b/agent/agent_runtime_helpers.py
@@ -3200,6 +3200,7 @@ def _execute(next_args: dict) -> Any:
                     question=next_args.get("question", ""),
                     choices=next_args.get("choices"),
                     multi_select=next_args.get("multi_select", False),
+                    questions=next_args.get("questions"),
                     callback=agent.clarify_callback,
                 ),
                 next_args,
diff --git a/agent/tool_executor.py b/agent/tool_executor.py
index 381f1000e9bbc..4fedb6dc7d193 100644
--- a/agent/tool_executor.py
+++ b/agent/tool_executor.py
@@ -2120,6 +2120,7 @@ def _execute(next_args: dict) -> Any:
                     question=next_args.get("question", ""),
                     choices=next_args.get("choices"),
                     multi_select=next_args.get("multi_select", False),
+                    questions=next_args.get("questions"),
                     callback=agent.clarify_callback,
                 )
             function_result, function_args, middleware_trace, _execution_blocked, _execution_dispatched = _managed_values(_run_agent_tool_execution_middleware(
diff --git a/apps/desktop/e2e/batch-clarify.spec.ts b/apps/desktop/e2e/batch-clarify.spec.ts
new file mode 100644
index 0000000000000..8658bd3b1b5ce
--- /dev/null
+++ b/apps/desktop/e2e/batch-clarify.spec.ts
@@ -0,0 +1,86 @@
+/**
+ * E2E batch clarify test — the multi-question clarify card must mount ONCE.
+ *
+ * Regression coverage for the duplicated-card bug: `tool.start` carries the
+ * model's tool_call_id while `clarify.request` carries a gateway-generated
+ * request_id. A batch payload has no top-level `question`, so the two rows
+ * only merge when the correlation key comes from the question list
+ * (`batchClarifyMatchValue` in lib/chat-messages.ts). Before that fix this
+ * exact flow rendered two identical interactive cards.
+ *
+ * The flow runs the real chain: composer → gateway → agent → clarify tool →
+ * clarify.request event → renderer, against the mock inference server.
+ */
+
+import { expect, test } from './test'
+
+import { type MockBackendFixture, setupMockBackend, waitForAppReady } from './fixtures'
+import { BATCH_CLARIFY_QUESTIONS, BATCH_CLARIFY_TRIGGER } from './mock-server'
+
+let fixture: MockBackendFixture | null = null
+
+test.beforeAll(async () => {
+  fixture = await setupMockBackend()
+  await waitForAppReady(fixture!, 120_000)
+})
+
+test.afterAll(async () => {
+  await fixture?.cleanup()
+  fixture = null
+})
+
+test.describe('batch clarify card', () => {
+  test('renders exactly one card and completes via per-question locks', async () => {
+    const page = fixture!.page
+    const composer = page.locator('[contenteditable="true"]').first()
+    await composer.waitFor({ state: 'visible', timeout: 10_000 })
+
+    await composer.click()
+    await composer.type(BATCH_CLARIFY_TRIGGER, { delay: 20 })
+    await page.keyboard.press('Enter')
+
+    // The live batch form marks itself with data-clarify-batch=<count>.
+    const batchCard = page.locator('form[data-clarify-batch]')
+    await batchCard.first().waitFor({ state: 'visible', timeout: 60_000 })
+
+    // THE regression assertion: one card, not two.
+    await expect(batchCard).toHaveCount(1)
+    await expect(batchCard).toHaveAttribute('data-clarify-batch', String(BATCH_CLARIFY_QUESTIONS.length))
+
+    // Both questions render inside the single card.
+    for (const entry of BATCH_CLARIFY_QUESTIONS) {
+      await expect(batchCard.getByText(entry.question)).toHaveCount(1)
+    }
+
+    // Each question text also appears exactly once in the whole transcript —
+    // catches a duplicate that mounts outside a form[data-clarify-batch].
+    for (const entry of BATCH_CLARIFY_QUESTIONS) {
+      await expect(page.getByText(entry.question)).toHaveCount(1)
+    }
+
+    // Answer both questions: stage picks locally (no server traffic yet).
+    const confirmButton = batchCard.locator('button[type="submit"]')
+    await expect(confirmButton).toContainText('Confirm and continue')
+    await expect(confirmButton).toBeDisabled()
+
+    await batchCard.getByRole('button', { name: /Coffee/ }).click()
+    await expect(confirmButton).toBeDisabled()
+
+    await batchCard.getByRole('button', { name: /Morning/ }).click()
+    await expect(confirmButton).toBeEnabled()
+
+    // ONE confirm submits the whole batch.
+    await confirmButton.click()
+
+    // The settled card lists both questions with their locked answers.
+    const settled = page.locator('[data-clarify-settled]')
+    await settled.waitFor({ state: 'visible', timeout: 30_000 })
+    await expect(settled.getByText(BATCH_CLARIFY_QUESTIONS[0].question)).toBeVisible()
+    await expect(settled.getByText('Coffee', { exact: true })).toBeVisible()
+    await expect(settled.getByText(BATCH_CLARIFY_QUESTIONS[1].question)).toBeVisible()
+    await expect(settled.getByText('Morning', { exact: true })).toBeVisible()
+
+    // And still no duplicate live card lingering after settle.
+    await expect(page.locator('form[data-clarify-batch]')).toHaveCount(0)
+  })
+})
diff --git a/apps/desktop/e2e/mock-server.ts b/apps/desktop/e2e/mock-server.ts
index 8de1af8aa4f98..37b5d15af7646 100644
--- a/apps/desktop/e2e/mock-server.ts
+++ b/apps/desktop/e2e/mock-server.ts
@@ -339,6 +339,40 @@ const BLOCKING_CLARIFY_TURN: ScriptedTurn = {
   toolCalls: [{ name: 'clarify', args: { question: BLOCKING_CLARIFY_QUESTION, choices: ['Yes', 'No'] } }],
 }
 
+/**
+ * A marker that makes the mock emit a blocking BATCH clarify tool call
+ * (multi-question form). Regression coverage for the duplicated-card bug:
+ * the tool.start row and the clarify.request row carry different ids and a
+ * batch payload has no top-level question, so the correlation key must come
+ * from the question list or the card mounts twice.
+ */
+export const BATCH_CLARIFY_TRIGGER = 'E2E_BATCH_CLARIFY_TRIGGER'
+export const BATCH_CLARIFY_QUESTIONS = [
+  { question: 'Pick a batch drink?', choices: ['Coffee', 'Tea'] },
+  { question: 'Pick a batch time?', choices: ['Morning', 'Night'] },
+]
+
+const BATCH_CLARIFY_TURN: ScriptedTurn = {
+  text: '',
+  toolCalls: [{ name: 'clarify', args: { questions: BATCH_CLARIFY_QUESTIONS } }],
+}
+
+function includesBatchClarifyTrigger(value: unknown): boolean {
+  if (typeof value === 'string') {
+    return value.includes(BATCH_CLARIFY_TRIGGER)
+  }
+
+  if (Array.isArray(value)) {
+    return value.some(includesBatchClarifyTrigger)
+  }
+
+  if (value && typeof value === 'object') {
+    return Object.values(value).some(includesBatchClarifyTrigger)
+  }
+
+  return false
+}
+
 function includesBlockingClarifyTrigger(value: unknown): boolean {
   if (typeof value === 'string') {
     return value.includes(BLOCKING_CLARIFY_TRIGGER)
@@ -484,6 +518,24 @@ export function startMockServer(options: MockServerOptions = {}): Promise<MockSe
             return
           }
 
+          if (includesBatchClarifyTrigger(parsed.messages)) {
+            // Only the FIRST completion of the conversation scripts the batch
+            // clarify. The trigger text stays in message history, so once the
+            // answered tool result is present the turn falls through to the
+            // canned reply — otherwise the mock loops the quiz forever.
+            const hasToolResult = Array.isArray(parsed.messages)
+              && parsed.messages.some((message: { role?: string }) => message?.role === 'tool')
+
+            if (!hasToolResult) {
+              if (stream) {
+                streamScriptedTurn(res, model, BATCH_CLARIFY_TURN)
+              } else {
+                nonStreamingScriptedTurn(res, model, BATCH_CLARIFY_TURN)
+              }
+              return
+            }
+          }
+
           if (includesBlockingClarifyTrigger(parsed.messages)) {
             if (stream) {
               streamScriptedTurn(res, model, BLOCKING_CLARIFY_TURN)
diff --git a/apps/desktop/src/app/session/hooks/use-message-stream/clarify-hydration.test.tsx b/apps/desktop/src/app/session/hooks/use-message-stream/clarify-hydration.test.tsx
index 306c460a5607e..b64171cc7ec25 100644
--- a/apps/desktop/src/app/session/hooks/use-message-stream/clarify-hydration.test.tsx
+++ b/apps/desktop/src/app/session/hooks/use-message-stream/clarify-hydration.test.tsx
@@ -169,4 +169,45 @@ describe('clarify.request stream hydration', () => {
 
     expect(clarifyParts()).toHaveLength(1)
   })
+
+  it('merges a BATCH tool.start row with its clarify.request (no top-level question)', async () => {
+    await mountStream()
+
+    // The batch shape: tool args carry `questions`, no top-level `question`.
+    // The correlation key must come from the question list, or the two ids
+    // mount two cards (the duplicate seen in the field).
+    toolStart({
+      args: { questions: [{ question: 'Drink?' }, { question: 'Productive when?' }] },
+      name: 'clarify',
+      tool_id: 'call-batch'
+    })
+    clarifyRequest({
+      questions: [
+        { qid: 'q0', question: 'Drink?' },
+        { qid: 'q1', question: 'Productive when?' }
+      ],
+      request_id: 'req-batch'
+    })
+
+    expect(clarifyParts()).toHaveLength(1)
+  })
+
+  it('does not duplicate when the batch clarify.request arrives before tool.start', async () => {
+    await mountStream()
+
+    clarifyRequest({
+      questions: [
+        { qid: 'q0', question: 'Drink?' },
+        { qid: 'q1', question: 'Productive when?' }
+      ],
+      request_id: 'req-batch-2'
+    })
+    toolStart({
+      args: { questions: [{ question: 'Drink?' }, { question: 'Productive when?' }] },
+      name: 'clarify',
+      tool_id: 'call-batch-2'
+    })
+
+    expect(clarifyParts()).toHaveLength(1)
+  })
 })
diff --git a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts
index 8ce770e3b281a..a4d00bb0a7673 100644
--- a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts
+++ b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts
@@ -25,7 +25,7 @@ import { invalidateSlashCompletions } from '@/lib/slash-completion-cache'
 import { type AgentNoticePayload, clearAgentNotice, nativeNoticeInput, showAgentNotice } from '@/store/agent-notices'
 import { reconcileApprovalModeForProfile } from '@/store/approval-mode'
 import { billingCtaLabel, clearBillingBlock, runBillingRecovery, setBillingBlock } from '@/store/billing-block'
-import { clearClarifyRequest, normalizeChoices, setClarifyRequest, warnDroppedChoices } from '@/store/clarify'
+import { clearClarifyRequest, normalizeChoices, normalizeQuestions, setClarifyRequest, warnDroppedChoices } from '@/store/clarify'
 import { setSessionCompacting } from '@/store/compaction'
 import { refreshBackgroundProcesses } from '@/store/composer-status'
 import { $gateway, activeGatewayConnectionId } from '@/store/gateway'
@@ -1165,8 +1165,65 @@ export function useGatewayEventHandler(deps: GatewayEventDeps) {
         const rawChoices = payload?.choices
         const choices = normalizeChoices(rawChoices)
         const multiSelect = payload?.multi_select === true
+        // Batch (multi-question) clarify: `questions` replaces question/choices
+        // on the wire. `answers` rides along only on reconnect replay, carrying
+        // the per-question locks the server already accepted.
+        const questions = normalizeQuestions(payload?.questions)
+        const lockedAnswers =
+          typeof payload?.answers === 'object' && payload?.answers !== null
+            ? Object.fromEntries(
+                Object.entries(payload.answers as Record<string, unknown>).filter(
+                  (entry): entry is [string, string] => typeof entry[1] === 'string'
+                )
+              )
+            : undefined
+
+        if (requestId && questions.length > 0) {
+          setClarifyRequest({
+            choices: null,
+            lockedAnswers,
+            multiSelect: false,
+            question: '',
+            questions,
+            requestId,
+            sessionId: sessionId ?? null
+          })
+
+          if (sessionId) {
+            // Same hydration-race guard as the single-question path below: the
+            // form mounts from the tool row, so upsert a stable one keyed by
+            // the request id in case tool.start was missed.
+            upsertToolCall(
+              sessionId,
+              {
+                args: {
+                  questions: questions.map(q => ({
+                    choices: q.choices ?? undefined,
+                    multi_select: q.multiSelect || undefined,
+                    question: q.question
+                  }))
+                },
+                name: 'clarify',
+                tool_id: requestId
+              },
+              'running',
+              event.type,
+              occurredAt
+            )
+            updateSessionState(sessionId, state => ({ ...state, needsInput: true }))
 
-        if (requestId && question) {
+            if (sessionId === activeSessionIdRef.current) {
+              requestScrollToBottom()
+            }
+          }
+
+          dispatchNativeNotification({
+            body: questions.map(q => q.question).join(' · '),
+            kind: 'input',
+            sessionId,
+            title: translateNow('notifications.native.inputTitle')
+          })
+        } else if (requestId && question) {
           if (rawChoices != null && choices.length === 0) {
             warnDroppedChoices('gateway', question, rawChoices)
           }
diff --git a/apps/desktop/src/components/assistant-ui/clarify-tool.test.tsx b/apps/desktop/src/components/assistant-ui/clarify-tool.test.tsx
index a0d616633cdf9..0da12eba13186 100644
--- a/apps/desktop/src/components/assistant-ui/clarify-tool.test.tsx
+++ b/apps/desktop/src/components/assistant-ui/clarify-tool.test.tsx
@@ -9,7 +9,7 @@ import { clearClarifyRequest, setClarifyRequest } from '@/store/clarify'
 import { $gateway } from '@/store/gateway'
 import { $activeSessionId } from '@/store/session'
 
-import { ClarifyTool, readClarifyResult } from './clarify-tool'
+import { ClarifyTool, readClarifyBatchResult, readClarifyResult } from './clarify-tool'
 
 // The live pending card only renders while its message is running. Force that so
 // keyboard-navigation tests can exercise ClarifyToolPending directly.
@@ -448,3 +448,189 @@ describe('ClarifyTool pending marker', () => {
     expect(document.querySelector('[data-clarify-choices]')).toBeNull()
   })
 })
+
+// ─── Batch (multi-question) clarify ─────────────────────────────────────────
+
+function batchArgs(): { questions: { question: string; choices?: string[] }[] } {
+  return {
+    questions: [
+      { choices: ['red', 'blue'], question: 'Color?' },
+      { question: 'Name?' }
+    ]
+  }
+}
+
+function liveBatchProps(): ToolCallMessagePartProps {
+  const args = batchArgs()
+
+  return {
+    addResult: vi.fn(),
+    args,
+    argsText: JSON.stringify(args),
+    isError: false,
+    respondToApproval: vi.fn(),
+    result: undefined,
+    resume: vi.fn(),
+    status: { type: 'running' },
+    toolCallId: 'clarify-batch',
+    toolName: 'clarify',
+    type: 'tool-call'
+  }
+}
+
+function renderLiveBatch(lockedAnswers?: Record<string, string>) {
+  const request = vi.fn().mockResolvedValue({ ok: true, remaining: [] })
+
+  $activeSessionId.set('session-1')
+  $gateway.set({ request } as never)
+  setClarifyRequest({
+    choices: null,
+    lockedAnswers,
+    multiSelect: false,
+    question: '',
+    questions: [
+      { choices: ['red', 'blue'], multiSelect: false, qid: 'q0', question: 'Color?' },
+      { choices: null, multiSelect: false, qid: 'q1', question: 'Name?' }
+    ],
+    requestId: 'request-batch',
+    sessionId: 'session-1'
+  })
+  renderClarify(<ClarifyTool {...liveBatchProps()} />)
+
+  return request
+}
+
+describe('readClarifyBatchResult', () => {
+  it('parses responses with string and list answers plus timed_out', () => {
+    const parsed = readClarifyBatchResult(
+      JSON.stringify({
+        responses: [
+          { question: 'Color?', user_response: 'red' },
+          { question: 'Tools?', user_response: ['a', 'b'] },
+          { question: 'Name?', user_response: '' }
+        ],
+        timed_out: true
+      })
+    )
+
+    expect(parsed.timedOut).toBe(true)
+    expect(parsed.responses).toHaveLength(3)
+    expect(parsed.responses[1]?.answer).toEqual(['a', 'b'])
+    expect(parsed.responses[2]?.answer).toBe('')
+  })
+
+  it('returns empty responses for single-question payloads', () => {
+    expect(readClarifyBatchResult({ question: 'Q?', user_response: 'a' }).responses).toEqual([])
+  })
+})
+
+describe('ClarifyTool batch card', () => {
+  it('renders every question at once', () => {
+    renderLiveBatch()
+
+    expect(screen.getByText('Color?')).toBeTruthy()
+    expect(screen.getByText('Name?')).toBeTruthy()
+    expect(screen.getByText('0 of 2 answered')).toBeTruthy()
+  })
+
+  it('stages locally and keeps the single confirm disabled until all answered', async () => {
+    const request = renderLiveBatch()
+    const confirm = screen.getByRole('button', { name: /Confirm and continue/ })
+
+    expect((confirm as HTMLButtonElement).disabled).toBe(true)
+
+    // Staging a pick sends NOTHING to the server.
+    fireEvent.click(screen.getByRole('button', { name: /red/ }))
+    expect(screen.getByText('1 of 2 answered')).toBeTruthy()
+    expect(request).not.toHaveBeenCalled()
+    expect((confirm as HTMLButtonElement).disabled).toBe(true)
+
+    fireEvent.change(screen.getByPlaceholderText('Type your answer…'), { target: { value: 'packet' } })
+    expect(screen.getByText('2 of 2 answered')).toBeTruthy()
+    expect(request).not.toHaveBeenCalled()
+    expect((confirm as HTMLButtonElement).disabled).toBe(false)
+  })
+
+  it('confirm sends every per-question lock in order and completes the batch', async () => {
+    const request = renderLiveBatch()
+
+    fireEvent.click(screen.getByRole('button', { name: /red/ }))
+    fireEvent.change(screen.getByPlaceholderText('Type your answer…'), { target: { value: 'packet' } })
+    fireEvent.submit(document.querySelector('form') as HTMLFormElement)
+
+    await waitFor(() => {
+      expect(request).toHaveBeenCalledTimes(2)
+    })
+    expect(request).toHaveBeenNthCalledWith(1, 'clarify.respond', {
+      answer: 'red',
+      question_id: 'q0',
+      request_id: 'request-batch'
+    })
+    expect(request).toHaveBeenNthCalledWith(2, 'clarify.respond', {
+      answer: 'packet',
+      question_id: 'q1',
+      request_id: 'request-batch'
+    })
+  })
+
+  it('a staged answer stays editable before confirm', async () => {
+    const request = renderLiveBatch()
+
+    fireEvent.click(screen.getByRole('button', { name: /red/ }))
+    fireEvent.click(screen.getByRole('button', { name: /blue/ }))
+    fireEvent.change(screen.getByPlaceholderText('Type your answer…'), { target: { value: 'packet' } })
+    fireEvent.submit(document.querySelector('form') as HTMLFormElement)
+
+    await waitFor(() => {
+      expect(request).toHaveBeenCalledTimes(2)
+    })
+    // The re-pick won: blue, not red.
+    expect(request).toHaveBeenNthCalledWith(1, 'clarify.respond', {
+      answer: 'blue',
+      question_id: 'q0',
+      request_id: 'request-batch'
+    })
+  })
+
+  it('pre-stages replayed locked answers from a reconnect', () => {
+    renderLiveBatch({ q0: 'red' })
+
+    // The replayed answer counts as staged: one question left to answer.
+    expect(screen.getByText('1 of 2 answered')).toBeTruthy()
+  })
+
+  it('Skip cancels the whole batch without a question_id', async () => {
+    const request = renderLiveBatch()
+
+    fireEvent.click(screen.getByRole('button', { name: 'Skip' }))
+
+    await waitFor(() => {
+      expect(request).toHaveBeenCalledWith('clarify.respond', {
+        answer: '',
+        request_id: 'request-batch'
+      })
+    })
+  })
+
+  it('renders the settled batch with all questions and answers', () => {
+    renderClarify(
+      <ClarifyTool
+        {...settledClarifyProps(
+          batchArgs(),
+          JSON.stringify({
+            responses: [
+              { choices_offered: ['red', 'blue'], question: 'Color?', user_response: 'red' },
+              { choices_offered: null, question: 'Name?', user_response: '' }
+            ]
+          }),
+          'clarify-batch-settled'
+        )}
+      />
+    )
+
+    expect(screen.getByText('Color?')).toBeTruthy()
+    expect(screen.getByText('red')).toBeTruthy()
+    expect(screen.getByText('Name?')).toBeTruthy()
+    expect(screen.getByText('Skipped')).toBeTruthy()
+  })
+})
diff --git a/apps/desktop/src/components/assistant-ui/clarify-tool.tsx b/apps/desktop/src/components/assistant-ui/clarify-tool.tsx
index 27dd58fa5375c..b7f0fabd97c8c 100644
--- a/apps/desktop/src/components/assistant-ui/clarify-tool.tsx
+++ b/apps/desktop/src/components/assistant-ui/clarify-tool.tsx
@@ -27,6 +27,8 @@ import { CircleLetterA, Loader2, MessageQuestion } from '@/lib/icons'
 import { cn } from '@/lib/utils'
 import {
   bareChoice,
+  type ClarifyQuestion,
+  type ClarifyRequest,
   clearClarifyRequest,
   normalizeChoices,
   RECOMMENDED_LABEL,
@@ -43,6 +45,7 @@ interface ClarifyArgs {
   question?: string
   choices?: string[] | null
   multiSelect?: boolean
+  questions?: { question: string; choices?: string[] | null; multiSelect?: boolean }[]
 }
 
 interface ClarifyResult {
@@ -72,13 +75,74 @@ function readClarifyArgs(args: unknown): ClarifyArgs {
     warnDroppedChoices('tool_args', question, rawChoices)
   }
 
+  // Batch form: tool args carry the model's questions array. Entries are
+  // normalized leniently here (qid comes from the gateway request, not args).
+  let questions: ClarifyArgs['questions']
+
+  if (Array.isArray(row.questions)) {
+    const parsed = row.questions
+      .map(entry => {
+        const item = parseMaybeObject(entry)
+        const text = stringField(item, 'question')
+
+        if (!text) {
+          return null
+        }
+
+        const itemChoices = normalizeChoices(item.choices)
+
+        return {
+          choices: itemChoices.length > 0 ? itemChoices : null,
+          multiSelect: item.multi_select === true && itemChoices.length > 0,
+          question: text
+        }
+      })
+      .filter((entry): entry is NonNullable<typeof entry> => entry !== null)
+
+    if (parsed.length > 0) {
+      questions = parsed
+    }
+  }
+
   return {
     question,
     choices: choices.length > 0 ? choices : null,
-    multiSelect: row.multi_select === true
+    multiSelect: row.multi_select === true,
+    questions
   }
 }
 
+interface ClarifyBatchResponse {
+  id?: string
+  question?: string
+  answer?: string | string[]
+}
+
+/** Parse batch clarify tool JSON (`responses` array + optional timed_out). */
+export function readClarifyBatchResult(result: unknown): {
+  responses: ClarifyBatchResponse[]
+  timedOut: boolean
+} {
+  const row = parseMaybeObject(result)
+
+  if (!Array.isArray(row.responses)) {
+    return { responses: [], timedOut: false }
+  }
+
+  const responses = row.responses.map((entry): ClarifyBatchResponse => {
+    const item = parseMaybeObject(entry)
+    const answer = item.user_response
+
+    return {
+      answer: Array.isArray(answer) ? answer.map(String) : typeof answer === 'string' ? answer : undefined,
+      id: stringField(item, 'id'),
+      question: stringField(item, 'question')
+    }
+  })
+
+  return { responses, timedOut: row.timed_out === true }
+}
+
 /** Parse clarify tool JSON (`question` + `user_response`). */
 export function readClarifyResult(result: unknown): ClarifyResult {
   const row = parseMaybeObject(result)
@@ -236,7 +300,17 @@ function ClarifyToolLive(props: ToolCallMessagePartProps) {
   return <ClarifyToolPending {...props} />
 }
 
-function ClarifyToolSettled({ args, result }: ToolCallMessagePartProps) {
+function ClarifyToolSettled(props: ToolCallMessagePartProps) {
+  const batch = readClarifyBatchResult(props.result)
+
+  if (batch.responses.length > 0) {
+    return <ClarifyToolBatchSettled responses={batch.responses} />
+  }
+
+  return <ClarifyToolSingleSettled {...props} />
+}
+
+function ClarifyToolSingleSettled({ args, result }: ToolCallMessagePartProps) {
   const { t } = useI18n()
   const copy = t.assistant.clarify
   const fromArgs = useMemo(() => readClarifyArgs(args), [args])
@@ -303,19 +377,36 @@ function ClarifyToolSettled({ args, result }: ToolCallMessagePartProps) {
   )
 }
 
-function ClarifyToolPending({ args }: ToolCallMessagePartProps) {
-  const { t } = useI18n()
-  const copy = t.assistant.clarify
+function ClarifyToolPending(props: ToolCallMessagePartProps) {
   // The tool row is in whichever session's transcript rendered it — read THAT
   // session's clarify (primary or tile), not the globally-active one.
   const sessionId = useStore(useSessionView().$runtimeId)
   const $request = useMemo(() => sessionClarifyRequest(sessionId), [sessionId])
   const request = useStore($request)
+  const fromArgs = useMemo(() => readClarifyArgs(props.args), [props.args])
+
+  // Batch: the gateway request carries qid-keyed questions. Args alone can't
+  // drive the form (no qids to respond with), so batch waits for the request.
+  if (request?.questions?.length || fromArgs.questions) {
+    return <ClarifyToolBatchPending request={request} />
+  }
+
+  return <ClarifyToolSinglePending fromArgs={fromArgs} request={request} />
+}
+
+function ClarifyToolSinglePending({
+  fromArgs,
+  request
+}: {
+  fromArgs: ClarifyArgs
+  request: ClarifyRequest | null
+}) {
+  const { t } = useI18n()
+  const copy = t.assistant.clarify
   const gateway = useStore($gateway)
-  const fromArgs = useMemo(() => readClarifyArgs(args), [args])
 
   const matchingRequest = useMemo(() => {
-    if (!request) {
+    if (!request || request.questions?.length) {
       return null
     }
 
@@ -699,3 +790,313 @@ function ClarifyToolPending({ args }: ToolCallMessagePartProps) {
     </form>
   )
 }
+
+// ─── Batch (multi-question) clarify ─────────────────────────────────────────
+
+/** Settled batch card: every question with its locked (or absent) answer. */
+function ClarifyToolBatchSettled({ responses }: { responses: { question?: string; answer?: string | string[] }[] }) {
+  const { t } = useI18n()
+  const copy = t.assistant.clarify
+
+  return (
+    <ClarifyShell className="my-1.5 grid gap-2.5" data-clarify-settled="">
+      {responses.map((row, index) => {
+        const answer = Array.isArray(row.answer) ? row.answer.join(', ') : (row.answer ?? '')
+        const blank = !answer.trim()
+
+        return (
+          <div className="grid gap-1" key={`${index}-${row.question ?? ''}`}>
+            {row.question ? (
+              <ClarifyLine icon={MessageQuestion}>
+                <span className="whitespace-pre-wrap font-medium leading-(--conversation-line-height)">
+                  {row.question}
+                </span>
+              </ClarifyLine>
+            ) : null}
+            <ClarifyLine icon={CircleLetterA}>
+              <p
+                className={cn(
+                  'whitespace-pre-wrap leading-(--conversation-line-height)',
+                  blank ? 'italic text-(--ui-text-tertiary)' : 'text-(--ui-text-secondary)'
+                )}
+                data-clarify-answer=""
+              >
+                {blank ? copy.skipped : answer}
+              </p>
+            </ClarifyLine>
+          </div>
+        )
+      })}
+    </ClarifyShell>
+  )
+}
+
+/** One question's interactive block inside the live batch card. */
+function BatchQuestionBlock({
+  disabled,
+  locked,
+  onDraft,
+  onToggle,
+  question,
+  staged
+}: {
+  disabled: boolean
+  locked: boolean
+  onDraft: (value: string) => void
+  onToggle: (choice: string) => void
+  question: ClarifyQuestion
+  staged: { choices: string[]; draft: string }
+}) {
+  const { t } = useI18n()
+  const copy = t.assistant.clarify
+  const choices = question.choices ?? []
+
+  return (
+    <div className="grid gap-1" data-clarify-batch-question={question.qid} data-locked={locked || undefined}>
+      <div className="flex items-start gap-2">
+        <span className="flex-1 whitespace-pre-wrap font-medium leading-(--conversation-line-height)">
+          {question.question}
+        </span>
+        {locked ? (
+          <span className="shrink-0 rounded-sm bg-(--chrome-action-hover) px-1 py-px text-[0.625rem] text-(--ui-text-tertiary)">
+            ✓ {copy.answeredBadge}
+          </span>
+        ) : null}
+      </div>
+
+      {choices.length > 0 ? (
+        <div className="grid gap-px" role="group">
+          {choices.map((choice, index) => (
+            <ChoiceButton
+              char={letterFor(index)}
+              choice={choice}
+              disabled={disabled}
+              key={`${index}-${choice}`}
+              onClick={() => onToggle(choice)}
+              selected={staged.choices.includes(choice)}
+            />
+          ))}
+          <label className={cn(OPTION_ROW_CLASS, 'items-center')}>
+            <KeyBadge char={letterFor(choices.length)} selected={Boolean(staged.draft.trim())} />
+            <Textarea
+              className={CLARIFY_TEXTAREA_CLASS}
+              disabled={disabled}
+              onChange={event => onDraft(event.target.value)}
+              placeholder={copy.other}
+              rows={1}
+              size="sm"
+              value={staged.draft}
+            />
+          </label>
+        </div>
+      ) : (
+        <Textarea
+          className={CLARIFY_TEXTAREA_CLASS}
+          disabled={disabled}
+          onChange={event => onDraft(event.target.value)}
+          placeholder={copy.placeholder}
+          rows={1}
+          size="sm"
+          value={staged.draft}
+        />
+      )}
+    </div>
+  )
+}
+
+const emptyStage = { choices: [] as string[], draft: '' }
+
+/** Live batch card: all questions at once, staged locally, ONE confirm.
+ * Picks and drafts stay in component state — nothing reaches the server
+ * until every question has a staged answer and the user presses the single
+ * "Confirm and continue" button, which sends the per-question locks
+ * back-to-back and completes the batch. Staged answers stay editable up to
+ * that moment. The per-question wire protocol is unchanged (the TUI/CLI
+ * still lock incrementally); this card just batches its locks at the end. */
+function ClarifyToolBatchPending({ request }: { request: ClarifyRequest | null }) {
+  const { t } = useI18n()
+  const copy = t.assistant.clarify
+  const gateway = useStore($gateway)
+
+  // qids only exist on the gateway request — args are a hydration-race
+  // fallback for display, never answerable (no ids to respond with).
+  const questions = request?.questions ?? []
+  const ready = Boolean(request?.requestId) && questions.length > 0
+
+  const [staged, setStaged] = useState<Record<string, { choices: string[]; draft: string }>>({})
+  const [submitting, setSubmitting] = useState(false)
+
+  // Reconnect replay: answers the server already locked (an earlier window's
+  // partial progress) pre-stage their questions so the restored card shows
+  // them selected instead of blank.
+  useEffect(() => {
+    const lockedAnswers = request?.lockedAnswers
+
+    if (!lockedAnswers) {
+      return
+    }
+
+    setStaged(current => {
+      const next = { ...current }
+
+      for (const question of questions) {
+        const answer = lockedAnswers[question.qid]
+
+        if (answer === undefined || next[question.qid]) {
+          continue
+        }
+
+        const asChoice = (question.choices ?? []).find(choice => bareChoice(choice) === answer)
+        next[question.qid] = asChoice ? { choices: [asChoice], draft: '' } : { choices: [], draft: answer }
+      }
+
+      return next
+    })
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- keyed by the replay map only
+  }, [request?.lockedAnswers])
+
+  const stageFor = (qid: string) => staged[qid] ?? emptyStage
+
+  const stagedAnswer = useCallback(
+    (question: ClarifyQuestion): string | null => {
+      const stage = staged[question.qid] ?? emptyStage
+
+      if (stage.choices.length > 0) {
+        return question.multiSelect ? JSON.stringify(stage.choices.map(bareChoice)) : bareChoice(stage.choices[0])
+      }
+
+      const draft = stage.draft.trim()
+
+      return draft ? draft : null
+    },
+    [staged]
+  )
+
+  const answeredCount = questions.filter(q => stagedAnswer(q) !== null).length
+  const allStaged = answeredCount === questions.length
+
+  const confirmAll = useCallback(async () => {
+    if (!request || !gateway) {
+      notifyError(new Error(request ? copy.gatewayDisconnected : copy.notReady), copy.sendFailed)
+
+      return
+    }
+
+    setSubmitting(true)
+
+    try {
+      // Sequential, not Promise.all: the LAST lock resolves the blocked tool
+      // server-side, so every earlier lock must already be accepted when it
+      // lands — a reordered burst could complete the batch with a missing
+      // answer.
+      for (const question of questions) {
+        const answer = stagedAnswer(question)
+
+        await gateway.request<{ ok?: boolean }>('clarify.respond', {
+          answer: answer ?? '',
+          question_id: question.qid,
+          request_id: request.requestId
+        })
+      }
+
+      triggerHaptic('submit')
+      // tool.complete lands next → ClarifyToolBatchSettled.
+      clearClarifyRequest(request.requestId, request.sessionId)
+    } catch (error) {
+      notifyError(error, copy.sendFailed)
+      setSubmitting(false)
+    }
+  }, [copy, gateway, questions, request, stagedAnswer])
+
+  const toggleChoice = useCallback((question: ClarifyQuestion, choice: string) => {
+    setStaged(current => {
+      const stage = current[question.qid] ?? emptyStage
+      const next = question.multiSelect
+        ? stage.choices.includes(choice)
+          ? stage.choices.filter(value => value !== choice)
+          : [...stage.choices, choice]
+        : [choice]
+
+      return { ...current, [question.qid]: { choices: next, draft: '' } }
+    })
+  }, [])
+
+  const draftFor = useCallback((question: ClarifyQuestion, value: string) => {
+    setStaged(current => ({ ...current, [question.qid]: { choices: [], draft: value } }))
+  }, [])
+
+  const cancelAll = useCallback(async () => {
+    if (!request) {
+      return
+    }
+
+    clearClarifyRequest(request.requestId, request.sessionId)
+
+    try {
+      await gateway?.request('clarify.respond', { answer: '', request_id: request.requestId })
+    } catch {
+      // The tool times out on its own; a failed skip must never block the UI.
+    }
+  }, [gateway, request])
+
+  const handleSubmit = useCallback(
+    (event: FormEvent<HTMLFormElement>) => {
+      event.preventDefault()
+
+      if (allStaged) {
+        void confirmAll()
+      }
+    },
+    [allStaged, confirmAll]
+  )
+
+  if (!ready) {
+    return (
+      <ClarifyShell aria-label={copy.loadingQuestion} className="my-1.5 grid min-h-12 place-items-center" role="status">
+        <Loader2 aria-hidden className="size-4 animate-spin text-(--ui-text-tertiary)" />
+      </ClarifyShell>
+    )
+  }
+
+  return (
+    <form className="my-1.5 grid gap-4" data-clarify-batch={questions.length} onSubmit={handleSubmit}>
+      <ClarifyShell className="grid gap-3">
+        <div className="flex items-start gap-2">
+          <span className="flex-1 text-[0.6875rem] leading-4 text-(--ui-text-tertiary)">
+            {copy.questionProgress(answeredCount, questions.length)}
+          </span>
+          <MessageQuestion aria-hidden className={CLARIFY_ICON_CLASS} />
+        </div>
+        {questions.map(question => (
+          <BatchQuestionBlock
+            disabled={submitting}
+            key={question.qid}
+            locked={false}
+            onDraft={value => draftFor(question, value)}
+            onToggle={choice => toggleChoice(question, choice)}
+            question={question}
+            staged={stageFor(question.qid)}
+          />
+        ))}
+      </ClarifyShell>
+
+      <div className="flex items-center justify-end gap-1">
+        <Button disabled={submitting} onClick={() => void cancelAll()} size="xs" type="button" variant="text">
+          {copy.skip}
+        </Button>
+        <Button disabled={submitting || !allStaged} size="xs" type="submit">
+          {submitting ? (
+            <Loader2 className="size-3 animate-spin" />
+          ) : (
+            <>
+              {copy.confirmAndContinueLabel}
+              <span aria-hidden className="ml-0.5 text-[0.625rem] opacity-70">
+                ⏎
+              </span>
+            </>
+          )}
+        </Button>
+      </div>
+    </form>
+  )
+}
diff --git a/apps/desktop/src/i18n/ar.ts b/apps/desktop/src/i18n/ar.ts
index 075865128a379..3dd1ee8b9e419 100644
--- a/apps/desktop/src/i18n/ar.ts
+++ b/apps/desktop/src/i18n/ar.ts
@@ -2433,7 +2433,10 @@ export const ar = defineLocale({
       other: 'غير ذلك',
       placeholder: 'اكتب إجابتك...',
       skip: 'تخطي',
-      continueLabel: 'متابعة'
+      continueLabel: 'متابعة',
+      confirmAndContinueLabel: 'تأكيد ومتابعة',
+      answeredBadge: 'تمت الإجابة',
+      questionProgress: (answered, total) => `تمت الإجابة على ${answered} من ${total}`
     },
     tool: {
       copyCode: 'نسخ الكود',
diff --git a/apps/desktop/src/i18n/en.ts b/apps/desktop/src/i18n/en.ts
index 25f122255c0c9..7bb35b33133e7 100644
--- a/apps/desktop/src/i18n/en.ts
+++ b/apps/desktop/src/i18n/en.ts
@@ -3072,6 +3072,9 @@ export const en: Translations = {
       skip: 'Skip',
       skipped: 'Skipped',
       continueLabel: 'Continue',
+      confirmAndContinueLabel: 'Confirm and continue',
+      answeredBadge: 'Answered',
+      questionProgress: (answered, total) => `${answered} of ${total} answered`,
       lateAnswer: (question, choice) => `Re: "${question}" — my answer: ${choice}`,
       lateAnswerTip: 'Draft this answer as a follow-up message',
       lateAnswerHint: 'This prompt is no longer waiting. Pick an option to draft it as a follow-up message.'
diff --git a/apps/desktop/src/i18n/ja.ts b/apps/desktop/src/i18n/ja.ts
index e54902a919b48..443039f8eaba9 100644
--- a/apps/desktop/src/i18n/ja.ts
+++ b/apps/desktop/src/i18n/ja.ts
@@ -2726,6 +2726,9 @@ export const ja = defineLocale({
       skip: 'スキップ',
       skipped: 'スキップ済み',
       continueLabel: '続行',
+      confirmAndContinueLabel: '確定して続行',
+      answeredBadge: '回答済み',
+      questionProgress: (answered, total) => `${total}問中${answered}問回答済み`,
       lateAnswer: (question, choice) => `「${question}」について — 私の回答: ${choice}`,
       lateAnswerTip: 'この回答をフォローアップメッセージとして下書きします',
       lateAnswerHint: 'この質問はもう回答を待っていません。選択肢を選ぶとフォローアップメッセージとして下書きされます。'
diff --git a/apps/desktop/src/i18n/types.ts b/apps/desktop/src/i18n/types.ts
index e162fa0d9cda9..55f2a5af5670f 100644
--- a/apps/desktop/src/i18n/types.ts
+++ b/apps/desktop/src/i18n/types.ts
@@ -2638,6 +2638,9 @@ export interface Translations {
       skip: string
       skipped: string
       continueLabel: string
+      confirmAndContinueLabel: string
+      answeredBadge: string
+      questionProgress: (answered: number, total: number) => string
       lateAnswer: (question: string, choice: string) => string
       lateAnswerTip: string
       lateAnswerHint: string
diff --git a/apps/desktop/src/i18n/zh-hant.ts b/apps/desktop/src/i18n/zh-hant.ts
index 3cfe280c28c02..622e3f74fa0a8 100644
--- a/apps/desktop/src/i18n/zh-hant.ts
+++ b/apps/desktop/src/i18n/zh-hant.ts
@@ -2637,6 +2637,9 @@ export const zhHant = defineLocale({
       skip: '略過',
       skipped: '已略過',
       continueLabel: '繼續',
+      confirmAndContinueLabel: '確認並繼續',
+      answeredBadge: '已回答',
+      questionProgress: (answered, total) => `已回答 ${answered}/${total}`,
       lateAnswer: (question, choice) => `關於「${question}」 — 我的回答: ${choice}`,
       lateAnswerTip: '將此回答起草為後續訊息',
       lateAnswerHint: '此問題已不再等待回答。選擇一個選項會將其起草為後續訊息。'
diff --git a/apps/desktop/src/i18n/zh.ts b/apps/desktop/src/i18n/zh.ts
index e803a2cde61a4..900102aa7497a 100644
--- a/apps/desktop/src/i18n/zh.ts
+++ b/apps/desktop/src/i18n/zh.ts
@@ -3234,6 +3234,9 @@ export const zh: Translations = {
       skip: '跳过',
       skipped: '已跳过',
       continueLabel: '继续',
+      confirmAndContinueLabel: '确认并继续',
+      answeredBadge: '已回答',
+      questionProgress: (answered, total) => `已回答 ${answered}/${total}`,
       lateAnswer: (question, choice) => `关于"${question}" — 我的回答: ${choice}`,
       lateAnswerTip: '将此回答起草为后续消息',
       lateAnswerHint: '此问题已不再等待回答。选择一个选项会将其起草为后续消息。'
diff --git a/apps/desktop/src/lib/chat-messages.ts b/apps/desktop/src/lib/chat-messages.ts
index 3f6fd28b62863..937a1024344e4 100644
--- a/apps/desktop/src/lib/chat-messages.ts
+++ b/apps/desktop/src/lib/chat-messages.ts
@@ -91,6 +91,10 @@ export type GatewayEventPayload = {
   question?: string
   choices?: string[] | null
   multi_select?: boolean
+  // clarify.request batch form: questions replaces question/choices, and
+  // answers (qid → locked answer) rides along on reconnect replay only.
+  questions?: unknown
+  answers?: Record<string, unknown>
   // mcp.setup.request (setup_mcp tool — inline MCP consent card)
   server?: string
   action?: string
@@ -620,20 +624,53 @@ function toolPayloadMatchValues(payload: GatewayEventPayload | undefined): strin
   // row (the model's tool_call_id) so the two ids don't produce a duplicate
   // clarify card — same correlation ClarifyToolPending uses for request↔args.
   // `server` is setup_mcp's identifying arg, for the identical reason.
-  const query = firstStringField(payloadArgs, ['search_term', 'query', 'question', 'server', 'command', 'code', 'path'])
+  const query =
+    firstStringField(payloadArgs, ['search_term', 'query', 'question', 'server', 'command', 'code', 'path']) ||
+    batchClarifyMatchValue(payloadArgs.questions)
   const context = typeof payload?.context === 'string' ? payload.context.trim() : ''
   const preview = typeof payload?.preview === 'string' ? payload.preview.trim() : ''
 
   return collectToolMatchValues(query, context, preview)
 }
 
+/**
+ * The batch-clarify counterpart of the `question` correlation key: a batch
+ * payload has no top-level `question`, only `questions[]`, so without this
+ * the request row and the tool.start row never match and the card mounts
+ * twice. The joined per-question texts identify the batch the same way one
+ * question text identifies a single prompt. The `\u0000` separator cannot
+ * appear in real question text, so a batch key can never collide with a
+ * single-question key.
+ */
+function batchClarifyMatchValue(questions: unknown): string {
+  if (!Array.isArray(questions)) {
+    return ''
+  }
+
+  const texts = questions
+    .map(entry => {
+      if (!entry || typeof entry !== 'object') {
+        return ''
+      }
+
+      const question = (entry as Record<string, unknown>).question
+
+      return typeof question === 'string' ? question.trim() : ''
+    })
+    .filter(Boolean)
+
+  return texts.length > 0 ? texts.join('\u0000') : ''
+}
+
 function toolPartMatchValues(part: ChatMessagePart): string[] {
   if (part.type !== 'tool-call' || !part.args || typeof part.args !== 'object') {
     return []
   }
 
   const args = part.args as Record<string, unknown>
-  const query = firstStringField(args, ['search_term', 'query', 'question', 'server', 'command', 'code', 'path'])
+  const query =
+    firstStringField(args, ['search_term', 'query', 'question', 'server', 'command', 'code', 'path']) ||
+    batchClarifyMatchValue(args.questions)
   const context = typeof args.context === 'string' ? args.context.trim() : ''
   const preview = typeof args.preview === 'string' ? args.preview.trim() : ''
 
diff --git a/apps/desktop/src/store/clarify.test.ts b/apps/desktop/src/store/clarify.test.ts
index 072fd0c3f90a7..c234b7961b696 100644
--- a/apps/desktop/src/store/clarify.test.ts
+++ b/apps/desktop/src/store/clarify.test.ts
@@ -7,6 +7,7 @@ import {
   clearClarifyRequest,
   hasClarifyRequest,
   normalizeChoices,
+  normalizeQuestions,
   setClarifyRequest,
   skipClarifyRequest
 } from './clarify'
@@ -165,3 +166,50 @@ describe('normalizeChoices', () => {
     expect(normalizeChoices([])).toEqual([])
   })
 })
+
+describe('normalizeQuestions', () => {
+  it('returns empty array for non-array input', () => {
+    expect(normalizeQuestions(null)).toEqual([])
+    expect(normalizeQuestions('x')).toEqual([])
+    expect(normalizeQuestions({})).toEqual([])
+  })
+
+  it('normalizes a valid batch and keys by qid', () => {
+    const result = normalizeQuestions([
+      { choices: ['a', 'b'], qid: 'q0', question: 'One?' },
+      { qid: 'q1', question: 'Two?' }
+    ])
+
+    expect(result).toEqual([
+      { choices: ['a', 'b'], multiSelect: false, qid: 'q0', question: 'One?' },
+      { choices: null, multiSelect: false, qid: 'q1', question: 'Two?' }
+    ])
+  })
+
+  it('drops entries missing qid or question text', () => {
+    const result = normalizeQuestions([
+      { qid: '', question: 'no qid' },
+      { qid: 'q1', question: '   ' },
+      'not-an-object',
+      { qid: 'q2', question: 'kept' }
+    ])
+
+    expect(result.map(q => q.qid)).toEqual(['q2'])
+  })
+
+  it('degrades all-blank choices to open-ended per question', () => {
+    const result = normalizeQuestions([{ choices: ['', '  '], qid: 'q0', question: 'Q?' }])
+
+    expect(result[0]?.choices).toBeNull()
+  })
+
+  it('only honors multi_select when choices survive', () => {
+    const result = normalizeQuestions([
+      { choices: ['a', 'b'], multi_select: true, qid: 'q0', question: 'A?' },
+      { multi_select: true, qid: 'q1', question: 'B?' }
+    ])
+
+    expect(result[0]?.multiSelect).toBe(true)
+    expect(result[1]?.multiSelect).toBe(false)
+  })
+})
diff --git a/apps/desktop/src/store/clarify.ts b/apps/desktop/src/store/clarify.ts
index 2bf13d516ded6..e318dc2a91528 100644
--- a/apps/desktop/src/store/clarify.ts
+++ b/apps/desktop/src/store/clarify.ts
@@ -3,12 +3,24 @@ import { atom, computed } from 'nanostores'
 import { $gateway } from './gateway'
 import { $activeSessionId } from './session'
 
+export interface ClarifyQuestion {
+  /** Server-generated wire id (q0..qN) — clarify.respond keys answers by it. */
+  qid: string
+  question: string
+  choices: string[] | null
+  multiSelect: boolean
+}
+
 export interface ClarifyRequest {
   requestId: string
   question: string
   choices: string[] | null
   multiSelect: boolean
   sessionId: string | null
+  /** Batch (multi-question) clarify: present instead of question/choices. */
+  questions?: ClarifyQuestion[]
+  /** Answers already locked server-side (reconnect replay): qid → answer. */
+  lockedAnswers?: Record<string, string>
 }
 
 /**
@@ -52,6 +64,48 @@ export function warnDroppedChoices(source: 'gateway' | 'tool_args', question: st
   })
 }
 
+/**
+ * Validate and normalize a batch clarify payload's `questions` array.
+ *
+ * Keeps entries with a non-blank string `qid` and `question`; per-question
+ * choices go through `normalizeChoices` (all-blank → open-ended) and
+ * multi_select is only honored alongside surviving choices. Returns an empty
+ * array when nothing usable remains — the caller treats that as "not a
+ * batch" instead of rendering an unanswerable form.
+ */
+export function normalizeQuestions(questions: unknown): ClarifyQuestion[] {
+  if (!Array.isArray(questions)) {
+    return []
+  }
+
+  const normalized: ClarifyQuestion[] = []
+
+  for (const entry of questions) {
+    if (typeof entry !== 'object' || entry === null) {
+      continue
+    }
+
+    const row = entry as Record<string, unknown>
+    const qid = typeof row.qid === 'string' ? row.qid.trim() : ''
+    const question = typeof row.question === 'string' ? row.question.trim() : ''
+
+    if (!qid || !question) {
+      continue
+    }
+
+    const choices = normalizeChoices(row.choices)
+
+    normalized.push({
+      choices: choices.length > 0 ? choices : null,
+      multiSelect: row.multi_select === true && choices.length > 0,
+      qid,
+      question
+    })
+  }
+
+  return normalized
+}
+
 // Pending clarify requests keyed by the runtime session id that raised them.
 // Storing per-session (instead of one shared slot) lets a *background* session
 // park its clarify request while the user is looking at a different chat, then
diff --git a/cli.py b/cli.py
index 5467c52299043..09ea295745cb0 100644
--- a/cli.py
+++ b/cli.py
@@ -5339,6 +5339,7 @@ def __init__(
         self._clarify_freetext = False
         self._clarify_deadline = 0
         self._clarify_multi_base = None
+        self._clarify_prefill = ""
         self._sudo_state = None
         self._sudo_deadline = 0
         self._modal_input_snapshot = None
@@ -14852,7 +14853,7 @@ def _persist_prompt_summary(self, icon: str, label: str, detail: str, outcome: s
             outcome = outcome[:119] + "…"
         _cprint(f"\n{_DIM}{icon} {label}: {detail} → {outcome}{_RST}")
 
-    def _clarify_callback(self, question, choices, multi_select=False):
+    def _clarify_callback(self, question, choices, multi_select=False, questions=None):
         """
         Platform callback for the clarify tool. Called from the agent thread.
 
@@ -14863,11 +14864,20 @@ def _clarify_callback(self, question, choices, multi_select=False):
 
         When ``multi_select`` is True, shows checkboxes and the user can
         select multiple options with Space, confirming with Enter.
+
+        When ``questions`` is a non-empty list (batch clarify, issue #18450),
+        the panel switches to the A-compact multi-question layout and the
+        return value is a dict ``{"answers": {qid: raw_answer}}`` (plus
+        ``"timed_out": True`` when the deadline expired with only partial
+        answers). The single-question path below is unchanged.
         """
         import time as _time
 
         from tools.clarify_gateway import resolve_clarify_timeout
 
+        if questions:
+            return self._clarify_callback_batch(questions)
+
         # Canonical clarify timeout, shared with the gateway/TUI path. `<= 0`
         # means unlimited (never auto-skip mid-think) → a null deadline.
         timeout = resolve_clarify_timeout(CLI_CONFIG)
@@ -14929,6 +14939,190 @@ def _clarify_callback(self, question, choices, multi_select=False):
             "Use your best judgement to make the choice and proceed."
         )
 
+    # --- Batch clarify (multi-question, issue #18450) -----------------------
+
+    def _clarify_batch_set_active(self, state, index) -> None:
+        """Point the batch clarify panel at question ``index``.
+
+        Mirrors the active question's data into the flat keys the existing
+        single-question keybindings and renderer read (``question``,
+        ``choices``, ``selected``, ``multi_select``, ``selected_indices``),
+        so ↑/↓/Space/number keys operate on the active question unchanged.
+        Open-ended questions drop straight into freetext, matching the
+        single-question path. Re-visiting an answered question restores the
+        cursor to the earlier selection (choice answers highlight their row,
+        an "Other" answer highlights the Other row) so the user can see and
+        edit what they picked.
+        """
+        questions_list = state["questions"]
+        index = max(0, min(index, len(questions_list) - 1))
+        entry = questions_list[index]
+        state["active"] = index
+        state["question"] = entry["question"]
+        state["choices"] = entry["choices"] or []
+        state["selected"] = 0
+        state["multi_select"] = bool(entry["multi_select"])
+        state["selected_indices"] = set() if entry["multi_select"] else None
+        self._clarify_freetext = not entry["choices"]
+        self._clarify_multi_base = None
+        # Restore the earlier answer's cursor/checkbox position on re-visit.
+        meta = (state.get("answer_meta") or {}).get(entry["qid"])
+        choices = entry["choices"] or []
+        if meta is None:
+            return
+        if meta.get("kind") == "choice":
+            answer = state["answers"].get(entry["qid"])
+            if answer in choices:
+                state["selected"] = choices.index(answer)
+        elif meta.get("kind") == "other":
+            state["selected"] = len(choices)
+        elif meta.get("kind") == "multi":
+            checked = set()
+            for label in meta.get("choices") or []:
+                if label in choices:
+                    checked.add(choices.index(label))
+            if meta.get("other_text"):
+                checked.add(len(choices))
+            state["selected_indices"] = checked
+
+    def _clarify_batch_lock(self, state, answer, meta=None) -> None:
+        """Lock ``answer`` for the active batch question and advance.
+
+        Overwrites any earlier answer for the same question (locked answers
+        stay editable until the batch completes). ``meta`` records how the
+        answer was produced ({"kind": "choice"|"other"|"multi", ...}) so a
+        re-visit can restore the cursor and prefill an "Other" edit. Advances
+        ``active`` to the next unanswered question; when every question has
+        an answer, puts the answers dict on the response queue and tears down
+        the panel.
+        """
+        entry = state["questions"][state["active"]]
+        state["answers"][entry["qid"]] = answer
+        state.setdefault("answer_meta", {})[entry["qid"]] = meta or {"kind": "choice"}
+        self._persist_prompt_summary("?", "Clarify", entry["question"], str(answer))
+        total = len(state["questions"])
+        for offset in range(1, total + 1):
+            candidate = (state["active"] + offset) % total
+            if state["questions"][candidate]["qid"] not in state["answers"]:
+                self._clarify_batch_set_active(state, candidate)
+                return
+        # Every question answered — resolve the batch.
+        try:
+            state["response_queue"].put(dict(state["answers"]))
+        except Exception:
+            pass
+        self._clarify_state = None
+        self._clarify_freetext = False
+        self._clarify_multi_base = None
+
+    def _clarify_batch_enter(self, state) -> None:
+        """Enter in batch choice mode: lock the active question's selection.
+
+        Multi-select questions lock a JSON array string of the checked
+        labels (the tool core parses it via ``_parse_multi_select_response``).
+        Selecting "Other" switches to freetext; the freetext submit path
+        locks the typed answer. Entering "Other" on a question whose earlier
+        answer was typed prefills the composer with that text for editing.
+        """
+        choices = state.get("choices") or []
+        selected = state.get("selected", 0)
+        entry = state["questions"][state["active"]]
+        meta = (state.get("answer_meta") or {}).get(entry["qid"]) or {}
+        if state.get("multi_select"):
+            indices = state.get("selected_indices") or set()
+            sorted_idx = sorted(indices)
+            selected_choices = [choices[i] for i in sorted_idx if i < len(choices)]
+            other_checked = len(choices) in sorted_idx
+            if other_checked:
+                # Stash the checked real choices (possibly none) so the
+                # freetext submit appends the typed answer to the array.
+                self._clarify_multi_base = selected_choices
+                self._clarify_freetext = True
+                self._clarify_prefill = meta.get("other_text") or ""
+                return
+            self._clarify_batch_lock(
+                state,
+                json.dumps(selected_choices, ensure_ascii=False),
+                meta={"kind": "multi", "choices": selected_choices, "other_text": ""},
+            )
+            return
+        if selected < len(choices):
+            self._clarify_batch_lock(
+                state, choices[selected], meta={"kind": "choice"}
+            )
+            return
+        # "Other" highlighted → switch to freetext; prefill an earlier typed
+        # answer so Enter on an answered Other edits instead of retyping.
+        self._clarify_freetext = True
+        self._clarify_prefill = (
+            meta.get("other_text") or "" if meta.get("kind") == "other" else ""
+        )
+
+    def _clarify_callback_batch(self, questions):
+        """Batch clarify panel (A-compact): all questions, one active.
+
+        Blocks on the response queue like the single-question path. Returns
+        ``{"answers": {qid: raw_answer}}`` when every question is locked, the
+        same dict plus ``"timed_out": True`` when the deadline expires with
+        partial (or zero) answers, and passes a cancel string through
+        unchanged so the tool core resolves the batch empty.
+        """
+        import time as _time
+
+        from tools.clarify_gateway import resolve_clarify_timeout
+
+        timeout = resolve_clarify_timeout(CLI_CONFIG)
+        response_queue = queue.Queue()
+
+        state = {
+            "questions": list(questions),
+            "answers": {},
+            "answer_meta": {},
+            "active": 0,
+            "response_queue": response_queue,
+            # Flat keys mirroring the active question — filled by
+            # _clarify_batch_set_active below.
+            "question": "",
+            "choices": [],
+            "selected": 0,
+            "multi_select": False,
+            "selected_indices": None,
+        }
+        self._clarify_state = state
+        self._clarify_batch_set_active(state, 0)
+        self._clarify_deadline = None if timeout <= 0 else _time.monotonic() + timeout
+        self._paint_now()
+
+        _last_countdown_refresh = _time.monotonic()
+        while True:
+            try:
+                result = response_queue.get(timeout=1)
+                self._clarify_deadline = None
+                if isinstance(result, dict):
+                    return {"answers": result}
+                # Cancel path (Ctrl+C teardown) posts a plain string — pass
+                # it through so the tool core resolves the batch empty.
+                return result
+            except queue.Empty:
+                if self._clarify_deadline is not None:
+                    remaining = self._clarify_deadline - _time.monotonic()
+                    if remaining <= 0:
+                        break
+                now = _time.monotonic()
+                if now - _last_countdown_refresh >= 1.0:
+                    _last_countdown_refresh = now
+                    self._paint_now()
+
+        # Timed out — keep the answers locked so far and flag the timeout.
+        partial = dict(state["answers"])
+        self._clarify_state = None
+        self._clarify_freetext = False
+        self._clarify_deadline = None
+        self._clarify_multi_base = None
+        self._paint_now()
+        _cprint(f"\n{_DIM}(clarify timed out after {timeout}s — locked answers returned){_RST}")
+        return {"answers": partial, "timed_out": True}
+
     def _sudo_password_callback(self) -> str:
         """
         Prompt for sudo password through the prompt_toolkit UI.
@@ -17032,6 +17226,25 @@ def handle_enter(event):
             if self._clarify_freetext and self._clarify_state:
                 text = event.app.current_buffer.text.strip()
                 if text:
+                    state = self._clarify_state
+                    # Batch mode: lock the typed answer for the active question
+                    if state.get("questions"):
+                        base = getattr(self, '_clarify_multi_base', None)
+                        if base is not None:
+                            # Multi-select "Other": append the typed answer to
+                            # the checked labels as a JSON array string.
+                            answer = json.dumps(base + [text], ensure_ascii=False)
+                            meta = {"kind": "multi", "choices": list(base), "other_text": text}
+                            self._clarify_multi_base = None
+                        else:
+                            answer = text
+                            meta = {"kind": "other", "other_text": text}
+                        self._clarify_freetext = False
+                        self._clarify_prefill = ""
+                        self._clarify_batch_lock(state, answer, meta=meta)
+                        event.app.current_buffer.reset()
+                        event.app.invalidate()
+                        return
                     # multi-select: prepend previously checked real choices
                     base = getattr(self, '_clarify_multi_base', None)
                     if base:
@@ -17047,6 +17260,18 @@ def handle_enter(event):
             # --- Clarify choice mode: confirm the highlighted selection ---
             if self._clarify_state and not self._clarify_freetext:
                 state = self._clarify_state
+                # Batch mode: Enter locks the active question's answer and
+                # advances to the next unanswered question.
+                if state.get("questions"):
+                    self._clarify_batch_enter(state)
+                    # Editing an earlier "Other" answer: prefill the composer
+                    # with the previously typed text.
+                    if self._clarify_freetext and self._clarify_prefill:
+                        event.app.current_buffer.text = self._clarify_prefill
+                        event.app.current_buffer.cursor_position = len(self._clarify_prefill)
+                        self._clarify_prefill = ""
+                    event.app.invalidate()
+                    return
                 selected = state["selected"]
                 choices = state.get("choices") or []
                 # multi-select support: submit comma-joined list of checked choices
@@ -17461,6 +17686,29 @@ def clarify_toggle(event):
                     indices.add(selected)
                 event.app.invalidate()
 
+        # Batch clarify: Tab cycles the active question (any-order answering;
+        # moving onto an answered question lets the user re-answer it before
+        # the batch completes). Registered after the generic tab handler so
+        # this filtered binding wins while the batch panel is open.
+        @kb.add('tab', filter=Condition(lambda: bool(self._clarify_state) and bool(self._clarify_state.get("questions")) and not self._clarify_freetext), eager=True)
+        def clarify_batch_tab(event):
+            state = self._clarify_state
+            if state and state.get("questions"):
+                self._clarify_batch_set_active(
+                    state, (state["active"] + 1) % len(state["questions"])
+                )
+                event.app.invalidate()
+
+        # Shift-Tab walks backwards through the questions.
+        @kb.add('s-tab', filter=Condition(lambda: bool(self._clarify_state) and bool(self._clarify_state.get("questions")) and not self._clarify_freetext), eager=True)
+        def clarify_batch_backtab(event):
+            state = self._clarify_state
+            if state and state.get("questions"):
+                self._clarify_batch_set_active(
+                    state, (state["active"] - 1) % len(state["questions"])
+                )
+                event.app.invalidate()
+
         # Number keys for quick clarify selection (1-9, 0 for 10th item)
         def _make_clarify_number_handler(idx):
             def handler(event):
@@ -17487,6 +17735,12 @@ def handler(event):
                     # Original single-select: number keys submit directly
                     # Map index to choice (treating "Other" as the last option)
                     if idx < len(choices):
+                        # Batch mode: lock the numbered choice for the active
+                        # question instead of resolving the whole prompt.
+                        if self._clarify_state.get("questions"):
+                            self._clarify_batch_lock(self._clarify_state, choices[idx])
+                            event.app.invalidate()
+                            return
                         # Select a numbered choice
                         self._clarify_state["response_queue"].put(choices[idx])
                         self._clarify_state = None
@@ -18321,6 +18575,11 @@ def get_hint_text():
                         ('class:hint', '  type your answer and press Enter'),
                         ('class:clarify-countdown', countdown),
                     ]
+                if cli_ref._clarify_state.get("questions"):
+                    return [
+                        ('class:hint', '  ↑/↓ to select, Enter to lock, Tab next question'),
+                        ('class:clarify-countdown', countdown),
+                    ]
                 return [
                     ('class:hint', '  ↑/↓ to select, Enter to confirm'),
                     ('class:clarify-countdown', countdown),
@@ -18400,6 +18659,111 @@ def _append_panel_line(lines, border_style: str, content_style: str, text: str,
         def _append_blank_panel_line(lines, border_style: str, box_width: int) -> None:
             lines.append((border_style, "│" + (" " * box_width) + "│\n"))
 
+        def _get_clarify_batch_display(state):
+            """Build styled text for the batch (multi-question) clarify panel.
+
+            A-compact layout mirroring the TUI: a "N questions" header, one
+            status line per question (✓ answered → answer / ▸ active /
+            · pending), and the active question's numbered choices (+ Other)
+            expanded directly beneath its status line.
+            """
+            questions_list = state.get("questions") or []
+            answers = state.get("answers") or {}
+            active = state.get("active", 0)
+            choices = state.get("choices") or []
+            selected = state.get("selected", 0)
+            multi_select = state.get("multi_select", False)
+            selected_indices = state.get("selected_indices", set()) if multi_select else set()
+
+            title = "Hermes needs your input"
+            header = f"{len(questions_list)} questions"
+
+            def _status_rows(width):
+                """(style, text) rows for the status list + expanded active question."""
+                rows = []
+                answer_meta = state.get("answer_meta") or {}
+                for idx, entry in enumerate(questions_list):
+                    answered = entry["qid"] in answers
+                    if answered:
+                        marker = "✓"
+                    elif idx == active:
+                        marker = "▸"
+                    else:
+                        marker = "·"
+                    label = f"{marker} {entry['question']}"
+                    row_style = 'class:clarify-selected' if idx == active else 'class:clarify-choice'
+                    for wrapped in _wrap_panel_text(label, width, subsequent_indent="  "):
+                        rows.append((row_style, wrapped))
+                    if answered:
+                        # The locked answer on its own line, in its own color,
+                        # so the current answer stays readable while walking
+                        # the list with Tab/Shift-Tab.
+                        for wrapped in _wrap_panel_text(
+                            f"    {answers[entry['qid']]}", width, subsequent_indent="    "
+                        ):
+                            rows.append(('class:clarify-answer', wrapped))
+                    if idx != active:
+                        continue
+                    # Expanded active question: numbered choices + Other.
+                    for i, choice in enumerate(choices):
+                        num_prefix = str(i + 1) if i < 9 else ('0' if i == 9 else ' ')
+                        if multi_select:
+                            cb = "[x]" if i in selected_indices else "[ ]"
+                            cursor = "❯" if i == selected and not cli_ref._clarify_freetext else " "
+                            prefix = f"  {cursor} {cb} {num_prefix}. "
+                        else:
+                            cursor = "❯" if i == selected and not cli_ref._clarify_freetext else " "
+                            prefix = f"  {cursor} {num_prefix}. "
+                        style = 'class:clarify-selected' if i == selected and not cli_ref._clarify_freetext else 'class:clarify-choice'
+                        for wrapped in _wrap_panel_text(f"{prefix}{choice}", width, subsequent_indent="      "):
+                            rows.append((style, wrapped))
+                    if choices:
+                        other_idx = len(choices)
+                        other_num = other_idx + 1
+                        other_num_prefix = str(other_num) if other_num < 10 else ('0' if other_num == 10 else ' ')
+                        if multi_select:
+                            cb = "[x]" if other_idx in selected_indices else "[ ]"
+                            mid = f"{cb} {other_num_prefix}"
+                        else:
+                            mid = other_num_prefix
+                        # An earlier typed answer stays visible next to Other;
+                        # Enter on it edits (the composer is prefilled).
+                        meta = answer_meta.get(entry["qid"]) or {}
+                        other_text = meta.get("other_text") or ""
+                        other_suffix = f"Other: {other_text}" if other_text else None
+                        if cli_ref._clarify_freetext:
+                            other_label = f"  ❯ {mid}. " + (other_suffix or "Other (type below)")
+                            other_style = 'class:clarify-active-other'
+                        elif selected == other_idx:
+                            other_label = f"  ❯ {mid}. " + (other_suffix or "Other (type your answer)")
+                            other_style = 'class:clarify-selected'
+                        else:
+                            other_label = f"    {mid}. " + (other_suffix or "Other (type your answer)")
+                            other_style = 'class:clarify-choice'
+                        for wrapped in _wrap_panel_text(other_label, width, subsequent_indent="      "):
+                            rows.append((other_style, wrapped))
+                    elif cli_ref._clarify_freetext:
+                        for wrapped in _wrap_panel_text(
+                            "  Type your answer in the prompt below, then press Enter.", width
+                        ):
+                            rows.append(('class:clarify-active-other', wrapped))
+                return rows
+
+            preview_rows = _status_rows(60)
+            box_width = _panel_box_width(title, [header] + [text for _, text in preview_rows])
+            inner_text_width = max(8, box_width - 2)
+            rows = _status_rows(inner_text_width)
+
+            lines = []
+            lines.append(('class:clarify-border', '╭─ '))
+            lines.append(('class:clarify-title', title))
+            lines.append(('class:clarify-border', ' ' + ('─' * max(0, box_width - len(title) - 3)) + '╮\n'))
+            _append_panel_line(lines, 'class:clarify-border', 'class:clarify-question', header, box_width)
+            for style, text in rows:
+                _append_panel_line(lines, 'class:clarify-border', style, text, box_width)
+            lines.append(('class:clarify-border', '╰' + ('─' * box_width) + '╯\n'))
+            return lines
+
         def _get_clarify_display():
             """Build styled text for the clarify question/choices panel.
 
@@ -18411,6 +18775,8 @@ def _get_clarify_display():
             state = cli_ref._clarify_state
             if not state:
                 return []
+            if state.get("questions"):
+                return _get_clarify_batch_display(state)
 
             question = state["question"]
             choices = state.get("choices") or []
@@ -18941,6 +19307,7 @@ def _get_stash_panel_display():
             'clarify-choice': '#AAAAAA',
             'clarify-selected': '#FFD700 bold',
             'clarify-active-other': '#FFD700 italic',
+            'clarify-answer': '#98FB98',
             'clarify-countdown': '#CD7F32',
             # Sudo password panel
             'sudo-prompt': '#FF6B6B bold',
diff --git a/tests/cli/test_cli_clarify_batch.py b/tests/cli/test_cli_clarify_batch.py
new file mode 100644
index 0000000000000..c839780bbb18f
--- /dev/null
+++ b/tests/cli/test_cli_clarify_batch.py
@@ -0,0 +1,343 @@
+"""Batch (multi-question) clarify panel state machine — CLI side.
+
+Drives ``_clarify_callback`` with a ``questions`` list on a background
+thread (the way the agent thread calls it) and simulates the keybinding
+handlers by calling the same helper methods they call
+(``_clarify_batch_set_active`` for Tab, ``_clarify_batch_enter`` for
+Enter, ``_clarify_batch_lock`` for the freetext submit path). No real
+terminal needed — mirrors tests/cli/test_cli_approval_ui.py.
+"""
+
+import json
+import threading
+import time
+from unittest.mock import MagicMock, patch
+
+from cli import HermesCLI
+
+
+def _make_cli_stub():
+    cli = HermesCLI.__new__(HermesCLI)
+    cli._clarify_state = None
+    cli._clarify_freetext = False
+    cli._clarify_multi_base = None
+    cli._clarify_prefill = ""
+    cli._clarify_deadline = None
+    cli._paint_now = MagicMock()
+    cli._persist_prompt_summary = MagicMock()
+    return cli
+
+
+def _q(index, question, choices=None, multi_select=False):
+    """One normalized batch entry, shaped like _normalize_questions output."""
+    return {
+        "qid": f"q{index}",
+        "id": None,
+        "question": question,
+        "choices": list(choices) if choices else None,
+        "choices_offered": list(choices) if choices else None,
+        "multi_select": bool(multi_select) and bool(choices),
+    }
+
+
+def _start_batch(cli, questions):
+    """Run the batch callback on a thread; wait for the panel state."""
+    result = {}
+
+    def _run():
+        result["value"] = cli._clarify_callback("", None, questions=questions)
+
+    thread = threading.Thread(target=_run, daemon=True)
+    thread.start()
+
+    deadline = time.time() + 2
+    while cli._clarify_state is None and time.time() < deadline:
+        time.sleep(0.01)
+    assert cli._clarify_state is not None
+    return thread, result
+
+
+class TestClarifyBatchPanel:
+    def test_all_locked_returns_answers_dict_keyed_by_qid(self):
+        cli = _make_cli_stub()
+        questions = [
+            _q(0, "Color?", ["red", "blue"]),
+            _q(1, "Size?", ["small", "large"]),
+        ]
+        thread, result = _start_batch(cli, questions)
+        state = cli._clarify_state
+
+        assert state["active"] == 0
+        assert state["choices"] == ["red", "blue"]
+
+        # Enter locks the active question's highlighted choice, then the
+        # cursor advances to the next unanswered question.
+        cli._clarify_batch_enter(state)
+        assert state["answers"] == {"q0": "red"}
+        assert state["active"] == 1
+
+        state["selected"] = 1
+        cli._clarify_batch_enter(state)
+
+        thread.join(timeout=2)
+        assert result["value"] == {"answers": {"q0": "red", "q1": "large"}}
+        assert cli._clarify_state is None
+
+    def test_any_order_answering_via_tab_cycle(self):
+        cli = _make_cli_stub()
+        questions = [
+            _q(0, "First?", ["a", "b"]),
+            _q(1, "Second?", ["c", "d"]),
+            _q(2, "Third?", ["e", "f"]),
+        ]
+        thread, result = _start_batch(cli, questions)
+        state = cli._clarify_state
+
+        # Tab twice: q0 -> q1 -> q2 (what the tab keybinding does).
+        cli._clarify_batch_set_active(state, (state["active"] + 1) % 3)
+        cli._clarify_batch_set_active(state, (state["active"] + 1) % 3)
+        assert state["active"] == 2
+
+        cli._clarify_batch_enter(state)  # lock q2 = "e"
+        # Advance wraps to the next unanswered question (q0).
+        assert state["active"] == 0
+
+        state["selected"] = 1
+        cli._clarify_batch_enter(state)  # lock q0 = "b"
+        assert state["active"] == 1
+
+        cli._clarify_batch_enter(state)  # lock q1 = "c"
+
+        thread.join(timeout=2)
+        assert result["value"] == {
+            "answers": {"q0": "b", "q1": "c", "q2": "e"}
+        }
+
+    def test_reanswer_overwrites_before_completion(self):
+        cli = _make_cli_stub()
+        questions = [
+            _q(0, "Approach?", ["quick", "thorough"]),
+            _q(1, "Scope?", ["narrow", "wide"]),
+        ]
+        thread, result = _start_batch(cli, questions)
+        state = cli._clarify_state
+
+        cli._clarify_batch_enter(state)  # lock q0 = "quick"
+        assert state["answers"]["q0"] == "quick"
+        assert state["active"] == 1
+
+        # Tab back to the answered question and change the answer.
+        cli._clarify_batch_set_active(state, 0)
+        state["selected"] = 1
+        cli._clarify_batch_enter(state)  # overwrite q0 = "thorough"
+        assert state["answers"]["q0"] == "thorough"
+        # Advance lands on the still-unanswered q1.
+        assert state["active"] == 1
+
+        cli._clarify_batch_enter(state)  # lock q1 = "narrow"
+
+        thread.join(timeout=2)
+        assert result["value"] == {
+            "answers": {"q0": "thorough", "q1": "narrow"}
+        }
+
+    def test_timeout_returns_partials_with_timed_out_flag(self):
+        cli = _make_cli_stub()
+        questions = [
+            _q(0, "Answered?", ["yes", "no"]),
+            _q(1, "Never answered?", ["x", "y"]),
+        ]
+        with patch(
+            "tools.clarify_gateway.resolve_clarify_timeout", return_value=1
+        ):
+            thread, result = _start_batch(cli, questions)
+            state = cli._clarify_state
+            cli._clarify_batch_enter(state)  # lock q0 only
+            thread.join(timeout=5)
+
+        assert not thread.is_alive()
+        assert result["value"] == {"answers": {"q0": "yes"}, "timed_out": True}
+        assert cli._clarify_state is None
+
+    def test_multi_select_lock_produces_json_array_string(self):
+        cli = _make_cli_stub()
+        questions = [
+            _q(0, "Toppings?", ["ham", "olives", "basil"], multi_select=True),
+        ]
+        thread, result = _start_batch(cli, questions)
+        state = cli._clarify_state
+
+        assert state["multi_select"] is True
+        state["selected_indices"].update({0, 2})
+        cli._clarify_batch_enter(state)
+
+        thread.join(timeout=2)
+        answer = result["value"]["answers"]["q0"]
+        assert isinstance(answer, str)
+        assert json.loads(answer) == ["ham", "basil"]
+
+    def test_open_ended_question_locks_typed_answer(self):
+        cli = _make_cli_stub()
+        questions = [
+            _q(0, "Anything else?"),
+            _q(1, "Pick one", ["a", "b"]),
+        ]
+        thread, result = _start_batch(cli, questions)
+        state = cli._clarify_state
+
+        # Open-ended active question drops straight into freetext.
+        assert cli._clarify_freetext is True
+        # The Enter freetext submit path locks the typed text.
+        cli._clarify_freetext = False
+        cli._clarify_batch_lock(state, "custom words")
+        assert state["active"] == 1
+
+        cli._clarify_batch_enter(state)
+
+        thread.join(timeout=2)
+        assert result["value"] == {
+            "answers": {"q0": "custom words", "q1": "a"}
+        }
+
+    def test_locked_question_persists_scrollback_summary(self):
+        cli = _make_cli_stub()
+        questions = [
+            _q(0, "Color?", ["red", "blue"]),
+            _q(1, "Size?", ["small", "large"]),
+        ]
+        thread, result = _start_batch(cli, questions)
+        state = cli._clarify_state
+
+        cli._clarify_batch_enter(state)
+        cli._clarify_batch_enter(state)
+        thread.join(timeout=2)
+
+        calls = cli._persist_prompt_summary.call_args_list
+        assert len(calls) == 2
+        assert calls[0].args == ("?", "Clarify", "Color?", "red")
+        assert calls[1].args == ("?", "Clarify", "Size?", "small")
+
+    def test_single_question_path_returns_plain_string(self):
+        cli = _make_cli_stub()
+        result = {}
+
+        def _run():
+            result["value"] = cli._clarify_callback("Pick?", ["a", "b"])
+
+        thread = threading.Thread(target=_run, daemon=True)
+        thread.start()
+
+        deadline = time.time() + 2
+        while cli._clarify_state is None and time.time() < deadline:
+            time.sleep(0.01)
+        assert cli._clarify_state is not None
+        assert "questions" not in cli._clarify_state
+
+        cli._clarify_state["response_queue"].put("a")
+        thread.join(timeout=2)
+        assert result["value"] == "a"
+
+
+class TestClarifyBatchNavigation:
+    """Shift-Tab, answer restore on re-visit, and Other edit-prefill."""
+
+    def test_backward_navigation_wraps(self):
+        cli = _make_cli_stub()
+        questions = [
+            _q(0, "Color?", ["red", "blue"]),
+            _q(1, "Size?", ["small", "large"]),
+            _q(2, "Speed?", ["slow", "fast"]),
+        ]
+        thread, result = _start_batch(cli, questions)
+        state = cli._clarify_state
+
+        # Shift-Tab from question 0 wraps to the last question.
+        cli._clarify_batch_set_active(state, (state["active"] - 1) % 3)
+        assert state["active"] == 2
+        cli._clarify_batch_set_active(state, (state["active"] - 1) % 3)
+        assert state["active"] == 1
+
+        state["response_queue"].put("cancel")
+        thread.join(timeout=2)
+
+    def test_revisit_choice_answer_restores_cursor(self):
+        cli = _make_cli_stub()
+        questions = [
+            _q(0, "Color?", ["red", "blue"]),
+            _q(1, "Size?", ["small", "large"]),
+        ]
+        thread, result = _start_batch(cli, questions)
+        state = cli._clarify_state
+
+        # Lock "blue" (index 1) on q0; the cursor advances to q1.
+        state["selected"] = 1
+        cli._clarify_batch_enter(state)
+        assert state["active"] == 1
+
+        # Tab back to q0: the cursor sits on the earlier answer, not row 0.
+        cli._clarify_batch_set_active(state, 0)
+        assert state["selected"] == 1
+
+        state["response_queue"].put("cancel")
+        thread.join(timeout=2)
+
+    def test_revisit_other_answer_highlights_other_and_prefills_edit(self):
+        cli = _make_cli_stub()
+        questions = [
+            _q(0, "Color?", ["red", "blue"]),
+            _q(1, "Size?", ["small", "large"]),
+        ]
+        thread, result = _start_batch(cli, questions)
+        state = cli._clarify_state
+
+        # Answer q0 via Other: select the Other row, then the freetext
+        # submit path locks the typed text with its meta.
+        state["selected"] = 2
+        cli._clarify_batch_enter(state)
+        assert cli._clarify_freetext is True
+        cli._clarify_freetext = False
+        cli._clarify_batch_lock(
+            state, "chartreuse", meta={"kind": "other", "other_text": "chartreuse"}
+        )
+        assert state["active"] == 1
+
+        # Tab back to q0: the cursor highlights the Other row.
+        cli._clarify_batch_set_active(state, 0)
+        assert state["selected"] == 2
+
+        # Enter on the answered Other switches to freetext and prefills the
+        # earlier text for editing.
+        cli._clarify_batch_enter(state)
+        assert cli._clarify_freetext is True
+        assert cli._clarify_prefill == "chartreuse"
+
+        state["response_queue"].put("cancel")
+        thread.join(timeout=2)
+
+    def test_reanswer_overwrites_and_updates_meta(self):
+        cli = _make_cli_stub()
+        questions = [
+            _q(0, "Color?", ["red", "blue"]),
+            _q(1, "Size?", ["small", "large"]),
+        ]
+        thread, result = _start_batch(cli, questions)
+        state = cli._clarify_state
+
+        # First answer via Other.
+        cli._clarify_batch_lock(
+            state, "teal", meta={"kind": "other", "other_text": "teal"}
+        )
+        # Re-visit and overwrite with a plain choice.
+        cli._clarify_batch_set_active(state, 0)
+        assert state["selected"] == 2
+        state["selected"] = 0
+        cli._clarify_batch_enter(state)
+        assert state["answers"]["q0"] == "red"
+        assert state["answer_meta"]["q0"] == {"kind": "choice"}
+
+        # Finish q1 so the batch resolves with the overwritten answer.
+        cli._clarify_batch_set_active(state, 1)
+        cli._clarify_batch_enter(state)
+        thread.join(timeout=2)
+        assert result["value"] == {"answers": {"q0": "red", "q1": "small"}}
+
diff --git a/tests/tools/test_clarify_tool.py b/tests/tools/test_clarify_tool.py
index de721981dfd0b..4d1c9d9908012 100644
--- a/tests/tools/test_clarify_tool.py
+++ b/tests/tools/test_clarify_tool.py
@@ -8,6 +8,7 @@
     clarify_tool,
     check_clarify_requirements,
     MAX_CHOICES,
+    MAX_QUESTIONS,
     CLARIFY_SCHEMA,
     _flatten_choice,
 )
@@ -158,6 +159,27 @@ def test_schema_multi_select_default_false(self):
         assert "multi_select" not in CLARIFY_SCHEMA["parameters"]["required"]
 
 
+    def test_schema_description_advertises_batching(self):
+        """The top-level description must tell the model it can batch.
+
+        The `questions` parameter description alone is not enough — the
+        model decides HOW to call from the tool description, so the batch
+        capability has to be surfaced there or it keeps asking one
+        question per call.
+        """
+        description = CLARIFY_SCHEMA["description"]
+        assert "questions" in description
+        assert "one call" in description.lower()
+
+
+    def test_schema_questions_param_is_optional_and_capped(self):
+        """`questions` stays optional (single-question calls unchanged) and
+        carries the batch cap so the model sees the limit."""
+        params = CLARIFY_SCHEMA["parameters"]
+        assert "questions" not in params["required"]
+        assert params["properties"]["questions"]["maxItems"] == MAX_QUESTIONS
+
+
 class TestClarifyToolMultiSelect:
     """Tests for multi_select (checkbox) support added to clarify_tool."""
 
@@ -360,3 +382,291 @@ def cb(question, choices, multi_select=False):
         ))
         assert seen["multi"] is False
         assert result["user_response"] == "a"
+
+
+class TestClarifyBatchValidation:
+    """Validation of the `questions` batch parameter (issue #18450)."""
+
+    def test_batch_takes_precedence_over_question(self):
+        """When both are present, `questions` wins and `question` is ignored."""
+        seen = {}
+
+        def cb(question, choices, multi_select=False, questions=None):
+            seen["questions"] = questions
+            return {"answers": {"q0": "blue"}}
+
+        result = json.loads(clarify_tool(
+            "ignored single question",
+            questions=[{"question": "What color?"}],
+            callback=cb,
+        ))
+        assert "responses" in result
+        assert len(result["responses"]) == 1
+        assert result["responses"][0]["question"] == "What color?"
+        assert seen["questions"][0]["question"] == "What color?"
+
+    def test_batch_rejects_more_than_five(self):
+        result = json.loads(clarify_tool(
+            "",
+            questions=[{"question": f"Q{i}?"} for i in range(6)],
+            callback=lambda *a, **k: "",
+        ))
+        assert "error" in result
+
+    def test_batch_rejects_blank_question_text(self):
+        result = json.loads(clarify_tool(
+            "",
+            questions=[{"question": "Real?"}, {"question": "   "}],
+            callback=lambda *a, **k: "",
+        ))
+        assert "error" in result
+
+    def test_batch_rejects_non_list(self):
+        result = json.loads(clarify_tool(
+            "", questions={"question": "Q?"}, callback=lambda *a, **k: "",
+        ))
+        assert "error" in result
+
+    def test_batch_empty_list_falls_back_to_single_question(self):
+        """An empty questions array degrades to the single-question path."""
+        def cb(question, choices):
+            assert question == "Single?"
+            return "yes"
+
+        result = json.loads(clarify_tool("Single?", questions=[], callback=cb))
+        assert result["user_response"] == "yes"
+        assert "responses" not in result
+
+    def test_batch_choices_flattened_capped_and_labelled_per_question(self):
+        """Each question gets the full choice pipeline: flatten, cap, label."""
+        seen = {}
+
+        def cb(question, choices, multi_select=False, questions=None):
+            seen["questions"] = questions
+            return {"answers": {"q0": "a", "q1": "Loose layout"}}
+
+        clarify_tool(
+            "",
+            questions=[
+                {"question": "Pick letter", "choices": ["a", "b", "c", "d", "e", "f"]},
+                {"question": "Pick layout", "choices": [
+                    {"description": "Loose layout"}, "Tight",
+                ]},
+            ],
+            callback=cb,
+        )
+        q0, q1 = seen["questions"]
+        assert len(q0["choices"]) == MAX_CHOICES
+        assert q0["choices"][0] == "a (Recommended)"
+        assert q1["choices"] == ["Loose layout (Recommended)", "Tight"]
+
+    def test_batch_internal_ids_are_stable_and_model_id_echoed(self):
+        """Wire ids are q0..qN. A model-supplied id only shows in results."""
+        seen = {}
+
+        def cb(question, choices, multi_select=False, questions=None):
+            seen["questions"] = questions
+            return {"answers": {"q0": "A", "q1": "B"}}
+
+        result = json.loads(clarify_tool(
+            "",
+            questions=[
+                {"id": "approach", "question": "Which approach?"},
+                {"question": "Timeline?"},
+            ],
+            callback=cb,
+        ))
+        assert [q["qid"] for q in seen["questions"]] == ["q0", "q1"]
+        assert result["responses"][0]["id"] == "approach"
+        assert "id" not in result["responses"][1]
+
+    def test_batch_multi_select_needs_choices(self):
+        """multi_select is only honored when the question has choices."""
+        seen = {}
+
+        def cb(question, choices, multi_select=False, questions=None):
+            seen["questions"] = questions
+            return {"answers": {"q0": "free text"}}
+
+        clarify_tool(
+            "",
+            questions=[{"question": "Thoughts?", "multi_select": True}],
+            callback=cb,
+        )
+        assert seen["questions"][0]["multi_select"] is False
+
+
+class TestClarifyBatchDispatch:
+    """Batch-capable callbacks get the list once. Legacy callbacks loop."""
+
+    def test_batch_callback_receives_list_once(self):
+        calls = []
+
+        def cb(question, choices, multi_select=False, questions=None):
+            calls.append(questions)
+            return {"answers": {"q0": "x", "q1": "y"}}
+
+        result = json.loads(clarify_tool(
+            "",
+            questions=[{"question": "One?"}, {"question": "Two?"}],
+            callback=cb,
+        ))
+        assert len(calls) == 1
+        assert [r["user_response"] for r in result["responses"]] == ["x", "y"]
+
+    def test_batch_callback_json_string_response(self):
+        """A _block-style bridge returns the answers as a JSON string."""
+        def cb(question, choices, multi_select=False, questions=None):
+            return json.dumps({"answers": {"q0": "picked"}})
+
+        result = json.loads(clarify_tool(
+            "", questions=[{"question": "One?"}], callback=cb,
+        ))
+        assert result["responses"][0]["user_response"] == "picked"
+
+    def test_batch_recommended_label_stripped_per_question(self):
+        def cb(question, choices, multi_select=False, questions=None):
+            return {"answers": {"q0": questions[0]["choices"][0]}}
+
+        result = json.loads(clarify_tool(
+            "",
+            questions=[{"question": "Pick", "choices": ["Rebase", "Merge"]}],
+            callback=cb,
+        ))
+        assert result["responses"][0]["user_response"] == "Rebase"
+        assert result["responses"][0]["choices_offered"] == ["Rebase", "Merge"]
+
+    def test_batch_multi_select_answer_parsed_to_list(self):
+        def cb(question, choices, multi_select=False, questions=None):
+            return {"answers": {"q0": '["red", "blue"]'}}
+
+        result = json.loads(clarify_tool(
+            "",
+            questions=[{
+                "question": "Colors?",
+                "choices": ["red", "blue", "green"],
+                "multi_select": True,
+            }],
+            callback=cb,
+        ))
+        assert result["responses"][0]["user_response"] == ["red", "blue"]
+
+    def test_batch_timed_out_flag_passthrough_with_partials(self):
+        """Timeout keeps the locked answers and sets the top-level flag."""
+        def cb(question, choices, multi_select=False, questions=None):
+            return {"answers": {"q0": "kept"}, "timed_out": True}
+
+        result = json.loads(clarify_tool(
+            "",
+            questions=[{"question": "One?"}, {"question": "Two?"}],
+            callback=cb,
+        ))
+        assert result["timed_out"] is True
+        assert result["responses"][0]["user_response"] == "kept"
+        assert result["responses"][1]["user_response"] == ""
+
+    def test_batch_empty_response_is_skip_not_timeout(self):
+        """A cancel-all resolves every answer empty with no timed_out flag."""
+        def cb(question, choices, multi_select=False, questions=None):
+            return ""
+
+        result = json.loads(clarify_tool(
+            "", questions=[{"question": "One?"}], callback=cb,
+        ))
+        assert result["responses"][0]["user_response"] == ""
+        assert "timed_out" not in result
+
+    def test_legacy_callback_gets_sequential_calls_in_order(self):
+        """A callback without `questions` support is looped per question."""
+        calls = []
+
+        def legacy_cb(question, choices, multi_select=False):
+            calls.append((question, tuple(choices or []) or None, multi_select))
+            return f"answer to {question}"
+
+        result = json.loads(clarify_tool(
+            "",
+            questions=[
+                {"question": "One?", "choices": ["a", "b"]},
+                {"question": "Two?"},
+            ],
+            callback=legacy_cb,
+        ))
+        assert [c[0] for c in calls] == ["One?", "Two?"]
+        assert calls[0][1] == ("a (Recommended)", "b")
+        assert calls[1][1] is None
+        assert [r["user_response"] for r in result["responses"]] == [
+            "answer to One?", "answer to Two?",
+        ]
+        assert "timed_out" not in result
+
+    def test_legacy_loop_aborts_on_timeout_and_keeps_partials(self):
+        """The loop stops on the first timeout. Collected answers survive."""
+        from tools.clarify_tool import TIMEOUT_RESPONSE
+        calls = []
+
+        def legacy_cb(question, choices):
+            calls.append(question)
+            if len(calls) == 2:
+                return TIMEOUT_RESPONSE
+            return "answered"
+
+        result = json.loads(clarify_tool(
+            "",
+            questions=[
+                {"question": "One?"}, {"question": "Two?"}, {"question": "Three?"},
+            ],
+            callback=legacy_cb,
+        ))
+        assert calls == ["One?", "Two?"]
+        assert result["timed_out"] is True
+        assert [r["user_response"] for r in result["responses"]] == [
+            "answered", "", "",
+        ]
+
+    def test_legacy_loop_skip_continues(self):
+        """An explicit empty answer is a skip. The loop continues."""
+        calls = []
+
+        def legacy_cb(question, choices):
+            calls.append(question)
+            return "" if len(calls) == 1 else "second"
+
+        result = json.loads(clarify_tool(
+            "",
+            questions=[{"question": "One?"}, {"question": "Two?"}],
+            callback=legacy_cb,
+        ))
+        assert calls == ["One?", "Two?"]
+        assert [r["user_response"] for r in result["responses"]] == ["", "second"]
+        assert "timed_out" not in result
+
+    def test_single_question_result_shape_unchanged(self):
+        """No `questions` arg keeps the historic result keys exactly."""
+        def cb(question, choices):
+            return "blue"
+
+        result = json.loads(clarify_tool(
+            "Color?", choices=["red", "blue"], callback=cb,
+        ))
+        assert set(result.keys()) == {"question", "choices_offered", "user_response"}
+
+
+class TestRegistryBatchPassThrough:
+    """The registered handler forwards `questions` from tool args."""
+
+    def test_handler_passes_questions(self):
+        from tools.registry import registry
+        entry = registry.get_entry("clarify")
+        seen = {}
+
+        def cb(question, choices, multi_select=False, questions=None):
+            seen["questions"] = questions
+            return {"answers": {"q0": "yes"}}
+
+        result = json.loads(entry.handler(
+            {"questions": [{"question": "Go?"}]},
+            callback=cb,
+        ))
+        assert seen["questions"][0]["question"] == "Go?"
+        assert result["responses"][0]["user_response"] == "yes"
diff --git a/tests/tui_gateway/test_protocol.py b/tests/tui_gateway/test_protocol.py
index 7b27ae6253029..c2cc8095914ea 100644
--- a/tests/tui_gateway/test_protocol.py
+++ b/tests/tui_gateway/test_protocol.py
@@ -354,6 +354,210 @@ def test_late_prompt_response_is_idempotent(server, method, value_key):
     assert response["result"] == {"status": "expired"}
 
 
+# ── clarify batch (multi-question) bridge ────────────────────────────
+
+
+def _drain_batch_block(server, qids, timeout=5, payload=None):
+    """Run a batch _block on a worker thread and return (thread, result box,
+    emitted request payload). The caller resolves questions via
+    handle_request and then joins."""
+    box = {}
+
+    def run():
+        box["answer"] = server._block(
+            "clarify.request",
+            "s1",
+            dict(payload or {"questions": [{"qid": q, "question": q} for q in qids]}),
+            timeout=timeout,
+            batch_qids=list(qids),
+        )
+
+    thread = threading.Thread(target=run, daemon=True)
+    thread.start()
+    # Wait for the request to be registered so respond calls can find it.
+    deadline = time.monotonic() + 2
+    while time.monotonic() < deadline:
+        with server._prompt_lock:
+            if server._batch_clarify:
+                rid = next(iter(server._batch_clarify))
+                return thread, box, rid
+        time.sleep(0.01)
+    raise AssertionError("batch clarify request never registered")
+
+
+def test_clarify_batch_resolves_when_all_questions_locked(capture):
+    server, buf = capture
+    thread, box, rid = _drain_batch_block(server, ["q0", "q1"])
+
+    first = server.handle_request({
+        "id": "a1", "method": "clarify.respond",
+        "params": {"request_id": rid, "question_id": "q1", "answer": "beta"},
+    })
+    assert first["result"]["status"] == "ok"
+    assert first["result"]["remaining"] == ["q0"]
+    assert thread.is_alive()  # one question left — still blocking
+
+    second = server.handle_request({
+        "id": "a2", "method": "clarify.respond",
+        "params": {"request_id": rid, "question_id": "q0", "answer": "alpha"},
+    })
+    assert second["result"]["status"] == "ok"
+    assert second["result"]["remaining"] == []
+
+    thread.join(timeout=5)
+    assert not thread.is_alive()
+    assert json.loads(box["answer"]) == {"answers": {"q0": "alpha", "q1": "beta"}}
+
+
+def test_clarify_batch_answer_update_overwrites_before_completion(server):
+    thread, box, rid = _drain_batch_block(server, ["q0", "q1"])
+
+    server.handle_request({
+        "id": "a1", "method": "clarify.respond",
+        "params": {"request_id": rid, "question_id": "q0", "answer": "first"},
+    })
+    server.handle_request({
+        "id": "a2", "method": "clarify.respond",
+        "params": {"request_id": rid, "question_id": "q0", "answer": "changed"},
+    })
+    server.handle_request({
+        "id": "a3", "method": "clarify.respond",
+        "params": {"request_id": rid, "question_id": "q1", "answer": "done"},
+    })
+
+    thread.join(timeout=5)
+    assert json.loads(box["answer"])["answers"]["q0"] == "changed"
+
+
+def test_clarify_batch_empty_answer_is_a_locked_skip(server):
+    """Skipping one question locks an empty answer — it counts toward
+    completion instead of leaving the batch waiting."""
+    thread, box, rid = _drain_batch_block(server, ["q0", "q1"])
+
+    server.handle_request({
+        "id": "a1", "method": "clarify.respond",
+        "params": {"request_id": rid, "question_id": "q0", "answer": ""},
+    })
+    server.handle_request({
+        "id": "a2", "method": "clarify.respond",
+        "params": {"request_id": rid, "question_id": "q1", "answer": "kept"},
+    })
+
+    thread.join(timeout=5)
+    assert json.loads(box["answer"]) == {"answers": {"q0": "", "q1": "kept"}}
+
+
+def test_clarify_batch_unknown_question_id_rejected(server):
+    thread, box, rid = _drain_batch_block(server, ["q0"])
+
+    response = server.handle_request({
+        "id": "bad", "method": "clarify.respond",
+        "params": {"request_id": rid, "question_id": "q9", "answer": "x"},
+    })
+    assert response["error"]["code"] == 4002
+
+    server.handle_request({
+        "id": "ok", "method": "clarify.respond",
+        "params": {"request_id": rid, "question_id": "q0", "answer": "fine"},
+    })
+    thread.join(timeout=5)
+
+
+def test_clarify_batch_timeout_keeps_locked_answers(capture):
+    """Locked answers survive the deadline: the tool sees the partials plus
+    timed_out instead of an empty string."""
+    server, buf = capture
+    thread, box, rid = _drain_batch_block(server, ["q0", "q1"], timeout=1)
+
+    server.handle_request({
+        "id": "a1", "method": "clarify.respond",
+        "params": {"request_id": rid, "question_id": "q0", "answer": "kept"},
+    })
+
+    thread.join(timeout=10)
+    assert not thread.is_alive()
+    result = json.loads(box["answer"])
+    assert result == {"answers": {"q0": "kept"}, "timed_out": True}
+    # The expire notification still fires for the un-finished batch.
+    messages = [json.loads(line) for line in buf.getvalue().splitlines()]
+    assert any(m["params"]["type"] == "clarify.expire" for m in messages)
+
+
+def test_clarify_batch_cancel_all_returns_empty(server):
+    """A respond without question_id cancels the whole batch (Esc path)."""
+    thread, box, rid = _drain_batch_block(server, ["q0", "q1"])
+
+    server.handle_request({
+        "id": "cancel", "method": "clarify.respond",
+        "params": {"request_id": rid, "answer": ""},
+    })
+
+    thread.join(timeout=5)
+    assert box["answer"] == ""
+
+
+def test_clarify_batch_late_question_respond_is_idempotent(server):
+    response = server.handle_request({
+        "id": "late", "method": "clarify.respond",
+        "params": {"request_id": "gone", "question_id": "q0", "answer": "x"},
+    })
+    assert response["result"] == {"status": "expired"}
+
+
+def test_clarify_batch_state_cleared_after_resolution(server):
+    thread, box, rid = _drain_batch_block(server, ["q0"])
+    server.handle_request({
+        "id": "a", "method": "clarify.respond",
+        "params": {"request_id": rid, "question_id": "q0", "answer": "x"},
+    })
+    thread.join(timeout=5)
+    with server._prompt_lock:
+        assert rid not in server._batch_clarify
+        assert rid not in server._pending
+
+
+def test_clarify_block_helper_builds_batch_payload(capture):
+    """_clarify_block forwards only wire fields (qid/question/choices/
+    multi_select) — the tool-side normalized entries carry extra keys the
+    renderer must not see."""
+    server, buf = capture
+    normalized = [
+        {
+            "qid": "q0", "id": "approach", "question": "Which?",
+            "choices": ["a (Recommended)", "b"], "choices_offered": ["a", "b"],
+            "multi_select": False,
+        },
+    ]
+
+    box = {}
+
+    def run():
+        box["answer"] = server._clarify_block("s1", "", None, questions=normalized)
+
+    thread = threading.Thread(target=run, daemon=True)
+    thread.start()
+    deadline = time.monotonic() + 2
+    rid = None
+    while time.monotonic() < deadline and rid is None:
+        with server._prompt_lock:
+            rid = next(iter(server._batch_clarify), None)
+        time.sleep(0.01)
+    assert rid
+
+    server.handle_request({
+        "id": "a", "method": "clarify.respond",
+        "params": {"request_id": rid, "question_id": "q0", "answer": "a"},
+    })
+    thread.join(timeout=5)
+
+    messages = [json.loads(line) for line in buf.getvalue().splitlines()]
+    request = messages[0]["params"]
+    assert request["type"] == "clarify.request"
+    sent = request["payload"]["questions"][0]
+    assert set(sent) == {"qid", "question", "choices", "multi_select"}
+    assert "id" not in sent and "choices_offered" not in sent
+
+
 def test_approval_pending_replays_unresolved_requests(server, monkeypatch):
     from tools import approval
 
diff --git a/tools/clarify_tool.py b/tools/clarify_tool.py
index d4bc8abeb13e6..b065d6d59af0d 100644
--- a/tools/clarify_tool.py
+++ b/tools/clarify_tool.py
@@ -15,13 +15,25 @@
 """
 
 import json
-from typing import List, Optional, Callable
+from typing import Dict, List, Optional, Callable
 
 
 # Maximum number of predefined choices the agent can offer.
 # A 5th "Other (type your answer)" option is always appended by the UI.
 MAX_CHOICES = 4
 
+# Maximum number of independent questions in one batch clarify call.
+MAX_QUESTIONS = 5
+
+# Canonical timeout sentinel returned to the agent when the user never
+# answers. The CLI has always returned this exact text; the batch fallback
+# loop also recognises it (alongside ``None``) as "the user walked away",
+# which aborts the remaining questions instead of pestering one by one.
+TIMEOUT_RESPONSE = (
+    "The user did not provide a response within the time limit. "
+    "Use your best judgement to make the choice and proceed."
+)
+
 # Suffix appended to the first choice so the user can see, at a glance, which
 # option the agent actually recommends. Applied here rather than per-surface so
 # CLI, TUI, desktop, and messaging adapters all render the same label.
@@ -150,10 +162,175 @@ def _parse_multi_select_response(raw_response) -> List[str]:
     return [s.strip() for s in raw.split(",") if s.strip()]
 
 
+# =============================================================================
+# Batch (multi-question) support — issue #18450
+# =============================================================================
+
+def _normalize_questions(questions) -> tuple:
+    """Validate and normalize the ``questions`` batch parameter.
+
+    Returns ``(normalized, error)`` where exactly one is non-None, except the
+    empty-list case which returns ``(None, None)`` — an empty array is not an
+    error, it just means "no batch here" and the caller falls back to the
+    single-question path.
+
+    Each normalized entry carries:
+      - ``qid``: stable wire id (``q0``..``qN``, index order). Surfaces key
+        their per-question answers by this; a model-supplied ``id`` is NOT
+        used on the wire (it's unvalidated text) and only echoed in results.
+      - ``id``: the model's optional identifier, or None.
+      - ``question``: stripped question text.
+      - ``choices``: decorated choice list (recommended label applied), or
+        None for open-ended.
+      - ``choices_offered``: the bare list as offered, for the result JSON.
+      - ``multi_select``: honored only when choices exist.
+    """
+    if not isinstance(questions, list):
+        return None, "questions must be an array of question objects."
+    if not questions:
+        return None, None
+    if len(questions) > MAX_QUESTIONS:
+        return None, f"questions supports at most {MAX_QUESTIONS} items."
+
+    normalized = []
+    for index, item in enumerate(questions):
+        if isinstance(item, str):
+            # Tolerate bare-string items: LLMs sometimes send ["Q1?", "Q2?"].
+            item = {"question": item}
+        if not isinstance(item, dict):
+            return None, f"questions[{index}] must be an object with a 'question'."
+
+        text = str(item.get("question") or "").strip()
+        if not text:
+            return None, f"questions[{index}].question must be non-empty text."
+
+        choices = item.get("choices")
+        if choices is not None:
+            if not isinstance(choices, list):
+                return None, f"questions[{index}].choices must be a list."
+            choices = [s for s in (_flatten_choice(c) for c in choices) if s]
+            if len(choices) > MAX_CHOICES:
+                choices = choices[:MAX_CHOICES]
+            if not choices:
+                choices = None
+
+        model_id = str(item.get("id") or "").strip() or None
+
+        normalized.append({
+            "qid": f"q{index}",
+            "id": model_id,
+            "question": text,
+            "choices": mark_recommended(list(choices)) if choices else None,
+            "choices_offered": list(choices) if choices else None,
+            "multi_select": bool(item.get("multi_select")) and bool(choices),
+        })
+
+    return normalized, None
+
+
+def _callback_accepts_questions(callback) -> bool:
+    """True when the platform callback understands the ``questions`` kwarg.
+
+    Same signature-inspection approach as ``_invoke_callback`` (never a
+    TypeError retry — that would re-prompt the user on an internal bug).
+    """
+    import inspect
+
+    try:
+        params = inspect.signature(callback).parameters
+        return "questions" in params or any(
+            p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values()
+        )
+    except (TypeError, ValueError):
+        return False
+
+
+def _clean_batch_answer(entry: dict, raw) -> object:
+    """Strip presentation from one locked answer (label, multi-select JSON)."""
+    if entry["multi_select"]:
+        return [strip_recommended(r) for r in _parse_multi_select_response(raw)]
+    return strip_recommended(raw)
+
+
+def _batch_result(normalized: List[dict], answers: dict, timed_out: bool) -> str:
+    """Assemble the batch result JSON from per-qid answers.
+
+    Unanswered questions surface as empty ``user_response`` — with the
+    top-level ``timed_out`` flag (present only when true) telling the agent
+    whether those blanks are deliberate skips or the user walking away.
+    """
+    responses = []
+    for entry in normalized:
+        row = {}
+        if entry["id"]:
+            row["id"] = entry["id"]
+        row["question"] = entry["question"]
+        row["choices_offered"] = entry["choices_offered"]
+        raw = answers.get(entry["qid"])
+        row["user_response"] = _clean_batch_answer(entry, raw) if raw else ""
+        responses.append(row)
+
+    result: Dict[str, object] = {"responses": responses}
+    if timed_out:
+        result["timed_out"] = True
+    return json.dumps(result, ensure_ascii=False)
+
+
+def _run_batch(normalized: List[dict], callback, question: str) -> str:
+    """Dispatch a validated batch to the platform callback.
+
+    Batch-capable callbacks (a ``questions`` kwarg, detected by signature)
+    get the whole list once and reply with ``{"answers": {qid: raw}}`` plus
+    an optional ``timed_out`` flag — as a dict or a JSON string (the
+    tui_gateway ``_block`` bridge can only carry strings).
+
+    Legacy callbacks are looped one question at a time (messaging adapters,
+    older plugins). An explicit empty answer is a skip and the loop
+    continues; a timeout (``None`` or the ``TIMEOUT_RESPONSE`` sentinel)
+    means the user walked away, so the loop aborts instead of pestering
+    them with the remaining questions. Answers collected before the abort
+    are kept either way.
+    """
+    if _callback_accepts_questions(callback):
+        raw = callback(question, None, questions=normalized)
+
+        answers: dict = {}
+        timed_out = False
+        if raw is None or (isinstance(raw, str) and raw.strip() == TIMEOUT_RESPONSE):
+            timed_out = True
+        elif isinstance(raw, dict):
+            answers = dict(raw.get("answers") or {})
+            timed_out = bool(raw.get("timed_out"))
+        elif isinstance(raw, str) and raw.strip():
+            try:
+                parsed = json.loads(raw)
+            except json.JSONDecodeError:
+                parsed = None
+            if isinstance(parsed, dict):
+                answers = dict(parsed.get("answers") or {})
+                timed_out = bool(parsed.get("timed_out"))
+        # Any other falsy/unparseable reply is a cancel-all: every answer
+        # empty, no timeout flag (mirrors the single-question skip).
+        return _batch_result(normalized, answers, timed_out)
+
+    answers = {}
+    timed_out = False
+    for entry in normalized:
+        raw = _invoke_callback(
+            callback, entry["question"], entry["choices"], entry["multi_select"],
+        )
+        if raw is None or (isinstance(raw, str) and raw.strip() == TIMEOUT_RESPONSE):
+            timed_out = True
+            break
+        answers[entry["qid"]] = raw
+    return _batch_result(normalized, answers, timed_out)
+
+
 def clarify_tool(
     question: str,
     choices: Optional[List[str]] = None,
     multi_select: bool = False,
+    questions: Optional[List[dict]] = None,
     callback: Optional[Callable] = None,
 ) -> str:
     """
@@ -167,16 +344,40 @@ def clarify_tool(
                       (checkboxes).  The ``user_response`` in the output JSON
                       will be a list of strings instead of a single string.
                       Has no effect when ``choices`` is omitted.
+        questions:    Up to 5 independent questions asked as one batch
+                      (issue #18450). Each item: ``{id?, question, choices?,
+                      multi_select?}``. When present (non-empty), the single
+                      ``question``/``choices``/``multi_select`` parameters
+                      are ignored and the result JSON is ``{"responses":
+                      [...]}`` (plus ``"timed_out": true`` when the user
+                      stopped answering partway).
         callback:     Platform-provided function that handles the actual UI
                       interaction.  Signature:
                       ``callback(question, choices, multi_select=False) -> str``.
-                      The optional ``multi_select`` keyword is passed so the
-                      platform can render checkboxes instead of radio buttons.
+                      Batch-capable platforms additionally accept a
+                      ``questions`` keyword and receive the normalized list
+                      in one call; platforms without it are looped one
+                      question at a time.
                       Injected by the agent runner (cli.py / gateway).
 
     Returns:
-        JSON string with the user's response.
+        JSON string with the user's response(s).
     """
+    if questions is not None:
+        normalized, error = _normalize_questions(questions)
+        if error:
+            return tool_error(error)
+        if normalized:
+            if callback is None:
+                return tool_error(
+                    "Clarify tool is not available in this execution context."
+                )
+            try:
+                return _run_batch(normalized, callback, str(question or "").strip())
+            except Exception as exc:
+                return tool_error(f"Failed to get user input: {exc}")
+        # Empty questions array → fall through to the single-question path.
+
     if not question or not question.strip():
         return tool_error("Question text is required.")
 
@@ -245,6 +446,11 @@ def check_clarify_requirements() -> bool:
         "multiple options via checkboxes. user_response will be a list of selected choices.\n"
         "3. **Open-ended** — omit choices entirely. The user types a free-form "
         "response.\n\n"
+        "You can also ask SEVERAL questions in ONE call: pass "
+        "questions in the `questions` array (each with its own choices/"
+        "multi_select, any mix of the three modes). The user answers them all "
+        "on a single form, in any order. STRONGLY preferred over a chain of "
+        "single-question clarify calls when you need several independent answers.\n"
         "CRITICAL: when you are offering options, put each option ONLY in the "
         "`choices` array — NEVER enumerate the options inside the `question` "
         "text. The UI renders `choices` as selectable rows; options written "
@@ -296,6 +502,44 @@ def check_clarify_requirements() -> bool:
                     "Has no effect when choices is omitted (open-ended question)."
                 ),
             },
+            "questions": {
+                "type": "array",
+                "maxItems": MAX_QUESTIONS,
+                "description": (
+                    "Ask 2-5 INDEPENDENT questions in one call instead of "
+                    "several sequential clarify calls — the user answers them "
+                    "on one form, in any order. Each item has its own "
+                    "question/choices/multi_select (same rules as the "
+                    "top-level parameters); optional `id` is echoed back in "
+                    "the matching response. When set, the top-level question/"
+                    "choices are ignored. put a short batch title in the "
+                    "top-level `question` The result is {responses: [...]}, "
+                    "with `timed_out: true` added if the user stopped part-way "
+                    "(unanswered entries have an empty user_response). Only "
+                    "batch questions that are truly independent — if one "
+                    "answer would change another question, ask separately."
+                ),
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "id": {
+                            "type": "string",
+                            "description": (
+                                "Optional short identifier echoed in the "
+                                "matching response (e.g. 'approach')."
+                            ),
+                        },
+                        "question": {"type": "string"},
+                        "choices": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "maxItems": MAX_CHOICES,
+                        },
+                        "multi_select": {"type": "boolean"},
+                    },
+                    "required": ["question"],
+                },
+            },
         },
         "required": ["question"],
     },
@@ -313,6 +557,7 @@ def check_clarify_requirements() -> bool:
         question=args.get("question", ""),
         choices=args.get("choices"),
         multi_select=args.get("multi_select", False),
+        questions=args.get("questions"),
         callback=kw.get("callback")),
     check_fn=check_clarify_requirements,
     emoji="❓",
diff --git a/tui_gateway/server.py b/tui_gateway/server.py
index 70213607c7077..d024c7e411088 100644
--- a/tui_gateway/server.py
+++ b/tui_gateway/server.py
@@ -145,6 +145,10 @@ def _thread_panic_hook(args):
 _pending: dict[str, tuple[str, threading.Event]] = {}
 _pending_prompt_payloads: dict[str, tuple[str, dict]] = {}
 _answers: dict[str, str] = {}
+# Batch clarify accumulators: rid → {"qids": [...], "answers": {qid: answer}}.
+# Written by clarify.respond (per-question lock, update-in-place), read out by
+# _block on resolution/timeout so locked answers survive the deadline.
+_batch_clarify: dict[str, dict] = {}
 _db = None
 _db_error: str | None = None
 _stdout_lock = threading.Lock()
@@ -1952,7 +1956,14 @@ def _pending_clarify_request_payload(sid: str) -> dict | None:
                 continue
             event, prompt_payload = _pending_prompt_payloads.get(rid, ("", {}))
             if event == "clarify.request":
-                return dict(prompt_payload)
+                snapshot = dict(prompt_payload)
+                # Batch clarify: replay the answers locked so far, so a
+                # reconnecting client restores its per-question ✓ state
+                # instead of presenting every question as unanswered.
+                batch = _batch_clarify.get(rid)
+                if batch is not None and batch["answers"]:
+                    snapshot["answers"] = dict(batch["answers"])
+                return snapshot
     return None
 
 
@@ -3469,16 +3480,28 @@ def _enable_gateway_prompts() -> None:
 # ── Blocking prompt factory ──────────────────────────────────────────
 
 
-def _block(event: str, sid: str, payload: dict, timeout: float | None = 300) -> str:
+def _block(
+    event: str,
+    sid: str,
+    payload: dict,
+    timeout: float | None = 300,
+    batch_qids: list[str] | None = None,
+) -> str:
     rid = uuid.uuid4().hex[:8]
     ev = threading.Event()
     with _prompt_lock:
         _pending[rid] = (sid, ev)
         payload["request_id"] = rid
         _pending_prompt_payloads[rid] = (event, dict(payload))
+        if batch_qids:
+            # Multi-question clarify: per-question answers accumulate here
+            # (update-in-place until every qid is locked). Locked answers
+            # survive a timeout — see the batch read-out below.
+            _batch_clarify[rid] = {"qids": list(batch_qids), "answers": {}}
     answered = False
     answer = ""
     answer_present = False
+    batch_answers: dict | None = None
     try:
         _emit(event, sid, payload)
         # Natural Event semantics: None → wait forever (clarify configured with
@@ -3491,6 +3514,27 @@ def _block(event: str, sid: str, payload: dict, timeout: float | None = 300) ->
             _pending_prompt_payloads.pop(rid, None)
             answer_present = rid in _answers
             answer = _answers.pop(rid, "")
+            batch_state = _batch_clarify.pop(rid, None)
+            if batch_state is not None:
+                batch_answers = dict(batch_state["answers"])
+
+    if batch_qids is not None:
+        # Cancel-all (respond with no question_id) resolves via _answers with
+        # an empty string — that stays a plain cancel, not a partial result.
+        if answer_present:
+            return answer
+        result: dict[str, object] = {"answers": batch_answers or {}}
+        if not answered:
+            # Deadline hit: keep whatever was locked, tell the tool the rest
+            # are absences (not skips), and still fire the expire
+            # notification so live cards tear down.
+            result["timed_out"] = True
+            _emit(
+                f"{event.removesuffix('.request')}.expire",
+                sid,
+                {"request_id": rid},
+            )
+        return json.dumps(result, ensure_ascii=False)
 
     # Emit an `.expire` notification on timeout for every blocking request type
     # whose `*.respond` handler tolerates a late reply (allow_expired=True).
@@ -3529,6 +3573,50 @@ def _clarify_timeout_seconds() -> float | None:
         return 300
 
 
+def _clarify_block(sid: str, q, c, multi_select=False, questions=None) -> str:
+    """Bridge the clarify tool callback onto _block.
+
+    Single-question calls keep the exact historical payload shape (older
+    renderers never see a new field). Batch calls emit one clarify.request
+    carrying the question list — only wire fields (qid/question/choices/
+    multi_select) are forwarded; the tool-side normalized entries also carry
+    result-assembly keys (id, choices_offered) the renderer must not see.
+    The tool decodes the JSON reply via its batch answer parser.
+    """
+    if questions:
+        wire = [
+            {
+                "qid": entry["qid"],
+                "question": entry["question"],
+                "choices": entry["choices"],
+                "multi_select": bool(entry["multi_select"]),
+            }
+            for entry in questions
+        ]
+        return _block(
+            "clarify.request",
+            sid,
+            {"questions": wire},
+            timeout=_clarify_timeout_seconds(),
+            batch_qids=[entry["qid"] for entry in questions],
+        )
+    # multi_select is a pass-through hint: renderers with checkbox
+    # support can honor it; older renderers ignore the extra field
+    # and stay single-select (a single answer still parses as a
+    # one-element list on the tool side). Only emitted when True so
+    # single-select payloads keep the exact pre-multi-select shape.
+    return _block(
+        "clarify.request",
+        sid,
+        (
+            {"question": q, "choices": c, "multi_select": True}
+            if multi_select
+            else {"question": q, "choices": c}
+        ),
+        timeout=_clarify_timeout_seconds(),
+    )
+
+
 def _clear_pending(sid: str | None = None) -> None:
     """Release pending prompts with an empty answer.
 
@@ -6176,20 +6264,8 @@ def _agent_cbs(sid: str) -> dict:
         "notice_clear_callback": lambda key: _emit(
             "notification.clear", sid, {"key": key}
         ),
-        "clarify_callback": lambda q, c, multi_select=False: _block(
-            "clarify.request",
-            sid,
-            # multi_select is a pass-through hint: renderers with checkbox
-            # support can honor it; older renderers ignore the extra field
-            # and stay single-select (a single answer still parses as a
-            # one-element list on the tool side). Only emitted when True so
-            # single-select payloads keep the exact pre-multi-select shape.
-            (
-                {"question": q, "choices": c, "multi_select": True}
-                if multi_select
-                else {"question": q, "choices": c}
-            ),
-            timeout=_clarify_timeout_seconds(),
+        "clarify_callback": lambda q, c, multi_select=False, questions=None: (
+            _clarify_block(sid, q, c, multi_select=multi_select, questions=questions)
         ),
         # read_terminal tool (desktop GUI): same blocking bridge as clarify — the
         # renderer answers terminal.read.respond with the serialized buffer.
@@ -11711,6 +11787,7 @@ def _stage_session_file_attachment(
 
 def _respond(rid, params, key, *, allow_expired=False):
     r = params.get("request_id", "")
+    question_id = str(params.get("question_id") or "")
     with _prompt_lock:
         entry = _pending.get(r)
         if not entry:
@@ -11718,6 +11795,21 @@ def _respond(rid, params, key, *, allow_expired=False):
                 return _ok(rid, {"status": "expired"})
             return _err(rid, 4009, f"no pending {key} request")
         _, ev = entry
+        batch = _batch_clarify.get(r)
+        if batch is not None and question_id:
+            # Per-question lock (multi-question clarify). Update-in-place is
+            # deliberate: a locked answer stays editable until the batch
+            # completes, and completion is exactly "every qid locked" — the
+            # final lock is the Confirm-and-continue click.
+            if question_id not in batch["qids"]:
+                return _err(rid, 4002, f"unknown question_id {question_id!r}")
+            batch["answers"][question_id] = params.get(key, "")
+            remaining = [
+                qid for qid in batch["qids"] if qid not in batch["answers"]
+            ]
+            if not remaining:
+                ev.set()
+            return _ok(rid, {"status": "ok", "remaining": remaining})
         _answers[r] = params.get(key, "")
         ev.set()
     return _ok(rid, {"status": "ok"})
diff --git a/ui-tui/src/__tests__/createGatewayEventHandler.test.ts b/ui-tui/src/__tests__/createGatewayEventHandler.test.ts
index 2b8fc76184db4..3ff7615d005ec 100644
--- a/ui-tui/src/__tests__/createGatewayEventHandler.test.ts
+++ b/ui-tui/src/__tests__/createGatewayEventHandler.test.ts
@@ -1597,6 +1597,93 @@ describe('createGatewayEventHandler', () => {
     expect(getOverlayState().sudo).toBeNull()
   })
 
+  // ── Batch (multi-question) clarify ─────────────────────────────────
+
+  it('parses a batch clarify.request into a questions overlay', () => {
+    const onEvent = createGatewayEventHandler(buildCtx([]))
+
+    onEvent({
+      payload: {
+        questions: [
+          { choices: ['a', 'b'], qid: 'q0', question: 'One?' },
+          { choices: null, qid: 'q1', question: 'Two?' }
+        ],
+        request_id: 'req-batch'
+      },
+      type: 'clarify.request'
+    } as any)
+
+    const clarify = getOverlayState().clarify
+    expect(clarify?.requestId).toBe('req-batch')
+    expect(clarify?.questions).toHaveLength(2)
+    expect(clarify?.questions?.[0]?.qid).toBe('q0')
+    expect(clarify?.questions?.[1]?.choices).toBeNull()
+    expect(clarify?.answers).toEqual({})
+  })
+
+  it('seeds locked answers from a reconnect-replay batch clarify.request', () => {
+    const onEvent = createGatewayEventHandler(buildCtx([]))
+
+    onEvent({
+      payload: {
+        answers: { q0: 'a' },
+        questions: [
+          { choices: ['a', 'b'], qid: 'q0', question: 'One?' },
+          { choices: null, qid: 'q1', question: 'Two?' }
+        ],
+        request_id: 'req-replay'
+      },
+      type: 'clarify.request'
+    } as any)
+
+    expect(getOverlayState().clarify?.answers).toEqual({ q0: 'a' })
+  })
+
+  it('drops malformed batch entries and falls back to single-question shape when none survive', () => {
+    const onEvent = createGatewayEventHandler(buildCtx([]))
+
+    onEvent({
+      payload: {
+        choices: ['x', 'y'],
+        question: 'Fallback?',
+        questions: [{ qid: '', question: 'no qid' }, { qid: 'q1', question: '   ' }],
+        request_id: 'req-bad'
+      },
+      type: 'clarify.request'
+    } as any)
+
+    const clarify = getOverlayState().clarify
+    expect(clarify?.questions).toBeUndefined()
+    expect(clarify?.question).toBe('Fallback?')
+    expect(clarify?.choices).toEqual(['x', 'y'])
+  })
+
+  it('persists an abandoned batch clarify with its locked partials on tool.complete', () => {
+    const appended: Msg[] = []
+    const onEvent = createGatewayEventHandler(buildCtx(appended))
+
+    patchOverlayState({
+      clarify: {
+        answers: { q0: 'alpha' },
+        choices: null,
+        question: '',
+        questions: [
+          { choices: ['alpha', 'beta'], qid: 'q0', question: 'One?' },
+          { choices: null, qid: 'q1', question: 'Two?' }
+        ],
+        requestId: 'req-batch-timeout'
+      }
+    })
+
+    onEvent({ payload: { name: 'clarify', tool_id: 'clar-b' }, type: 'tool.complete' } as any)
+
+    const record = appended.find(msg => msg.role === 'system' && msg.text.startsWith('ask (2 questions)'))
+    expect(record).toBeDefined()
+    expect(record?.text).toContain('✓ One? → alpha')
+    expect(record?.text).toContain('· Two? (no answer)')
+    expect(getOverlayState().clarify).toBeNull()
+  })
+
   // ── Credits notice (Strategy B) ──────────────────────────────────────
   describe('credits notice', () => {
     it('shows a notice immediately when idle (no turn in flight)', () => {
diff --git a/ui-tui/src/app/createGatewayEventHandler.ts b/ui-tui/src/app/createGatewayEventHandler.ts
index 798c6e4726391..78fb1ed5c33f6 100644
--- a/ui-tui/src/app/createGatewayEventHandler.ts
+++ b/ui-tui/src/app/createGatewayEventHandler.ts
@@ -20,7 +20,7 @@ import { openExternalUrl } from '../lib/openExternalUrl.js'
 import { rpcErrorMessage } from '../lib/rpc.js'
 import { topLevelSubagents } from '../lib/subagentTree.js'
 import { isPaintableHex, setTerminalBackground, setTerminalForeground } from '../lib/terminalModes.js'
-import { formatAbandonedClarify, formatToolCall, stripAnsi } from '../lib/text.js'
+import { formatAbandonedClarify, formatAbandonedClarifyBatch, formatToolCall, stripAnsi } from '../lib/text.js'
 import { bootSeededPin, invalidateBootBackground, writeBootTheme } from '../lib/themeBoot.js'
 import { defaultThemeForCurrentBackground, fromSkin, skinIsLight, type Theme, themeToneHex } from '../theme.js'
 import type { Msg, SubagentProgress, SubagentStatus, Usage } from '../types.js'
@@ -454,7 +454,9 @@ export function createGatewayEventHandler(ctx: GatewayEventHandlerContext): (ev:
     persistedAbandonedClarify.add(clarify.requestId)
     appendMessage({
       role: 'system',
-      text: formatAbandonedClarify(clarify.question, clarify.choices, 'timed out')
+      text: clarify.questions?.length
+        ? formatAbandonedClarifyBatch(clarify.questions, clarify.answers ?? {}, 'timed out')
+        : formatAbandonedClarify(clarify.question, clarify.choices, 'timed out')
     })
     patchOverlayState({ clarify: null })
   }
@@ -1213,13 +1215,36 @@ export function createGatewayEventHandler(ctx: GatewayEventHandlerContext): (ev:
         return
       }
 
-      case 'clarify.request':
+      case 'clarify.request': {
+        const batch = (ev.payload.questions ?? [])
+          .filter(q => typeof q?.qid === 'string' && q.qid && typeof q?.question === 'string' && q.question.trim())
+          .map(q => ({
+            choices: q.choices && q.choices.length > 0 ? q.choices : null,
+            multiSelect: q.multi_select === true,
+            qid: q.qid,
+            question: q.question.trim()
+          }))
+
         patchOverlayState({
-          clarify: { choices: ev.payload.choices, question: ev.payload.question, requestId: ev.payload.request_id }
+          clarify: batch.length
+            ? {
+                answers: ev.payload.answers ?? {},
+                choices: null,
+                question: '',
+                questions: batch,
+                requestId: ev.payload.request_id
+              }
+            : {
+                choices: ev.payload.choices ?? null,
+                question: ev.payload.question ?? '',
+                requestId: ev.payload.request_id
+              }
         })
         setStatus('waiting for input…')
 
         return
+      }
+
       case 'approval.request': {
         const description = String(ev.payload.description ?? 'dangerous command')
         // Only an explicit false (tirith warning) drops the permanent-allow option.
diff --git a/ui-tui/src/app/interfaces.ts b/ui-tui/src/app/interfaces.ts
index dffa3aeb50da8..1a4cfbc5657ce 100644
--- a/ui-tui/src/app/interfaces.ts
+++ b/ui-tui/src/app/interfaces.ts
@@ -552,6 +552,7 @@ export interface SlashHandlerContext {
 export interface AppLayoutActions {
   answerApproval: (choice: string) => void
   answerClarify: (answer: string) => void
+  answerClarifyQuestion: (qid: string, answer: string) => void
   answerSecret: (value: string) => void
   answerSudo: (pw: string) => void
   clearSelection: () => void
@@ -619,6 +620,7 @@ export interface AppOverlaysProps {
   completions: CompletionItem[]
   onApprovalChoice: (choice: string) => void
   onClarifyAnswer: (value: string) => void
+  onClarifyQuestionAnswer: (qid: string, value: string) => void
   onActiveSessionSelect: (sessionId: string) => void
   onActiveSessionClose: (sessionId: string) => Promise<null | SessionCloseResponse>
   onModelSelect: (value: string) => void
diff --git a/ui-tui/src/app/useMainApp.ts b/ui-tui/src/app/useMainApp.ts
index 555d66f073fff..cb931e55c101c 100644
--- a/ui-tui/src/app/useMainApp.ts
+++ b/ui-tui/src/app/useMainApp.ts
@@ -35,7 +35,7 @@ import { DEFAULT_VOICE_RECORD_KEY, isMac, type ParsedVoiceRecordKey } from '../l
 import { createResizeCoalescer } from '../lib/resizeCoalescer.js'
 import { asRpcResult, rpcErrorMessage } from '../lib/rpc.js'
 import { terminalParityHints } from '../lib/terminalParity.js'
-import { buildToolTrailLine, formatAbandonedClarify, sameToolTrailGroup, toolTrailLabel } from '../lib/text.js'
+import { buildToolTrailLine, formatAbandonedClarify, formatAbandonedClarifyBatch, sameToolTrailGroup, toolTrailLabel } from '../lib/text.js'
 import { estimatedMsgHeight, messageHeightKey } from '../lib/virtualHeights.js'
 import { onUserWidgets } from '../sdk/userWidgets.js'
 import type { Msg, PanelSection, SlashCatalog } from '../types.js'
@@ -705,7 +705,9 @@ export function useMainApp(gw: GatewayClient) {
           // survives on screen as standard output, matching the timeout path.
           appendMessage({
             role: 'system',
-            text: formatAbandonedClarify(clarify.question, clarify.choices, 'cancelled')
+            text: clarify.questions?.length
+              ? formatAbandonedClarifyBatch(clarify.questions, clarify.answers ?? {}, 'cancelled')
+              : formatAbandonedClarify(clarify.question, clarify.choices, 'cancelled')
           })
         }
 
@@ -715,6 +717,60 @@ export function useMainApp(gw: GatewayClient) {
     [appendMessage, overlay.clarify, rpc]
   )
 
+  // Lock one answer of a batch clarify (clarify.respond + question_id). The
+  // overlay stays up until the server reports no remaining questions — the
+  // final lock resolves the tool and the turn continues.
+  const answerClarifyQuestion = useCallback(
+    (qid: string, answer: string) => {
+      const clarify = overlay.clarify
+
+      if (!clarify?.questions?.length) {
+        return
+      }
+
+      rpc<ClarifyRespondResponse & { remaining?: string[] }>('clarify.respond', {
+        answer,
+        question_id: qid,
+        request_id: clarify.requestId
+      }).then(r => {
+        if (!r) {
+          return
+        }
+
+        const answers = { ...(clarify.answers ?? {}), [qid]: answer }
+
+        if ((r.remaining ?? []).length > 0) {
+          patchOverlayState({ clarify: { ...clarify, answers } })
+
+          return
+        }
+
+        // Batch complete: persist the whole Q&A set as one user-visible
+        // block (mirrors the single-question trail + answer lines).
+        const label = toolTrailLabel('clarify')
+
+        turnController.turnTools = turnController.turnTools.filter(line => !sameToolTrailGroup(label, line))
+        patchTurnState({ turnTrail: turnController.turnTools })
+        turnController.persistedToolLabels.add(label)
+        appendMessage({
+          kind: 'trail',
+          role: 'system',
+          text: '',
+          tools: [buildToolTrailLine('clarify', `${clarify.questions!.length} questions`)]
+        })
+        appendMessage({
+          role: 'user',
+          text: clarify
+            .questions!.map(q => `${q.question} → ${answers[q.qid]?.trim() ? answers[q.qid] : '(skipped)'}`)
+            .join('\n')
+        })
+        patchUiState({ status: 'running…' })
+        patchOverlayState({ clarify: null })
+      })
+    },
+    [appendMessage, overlay.clarify, rpc]
+  )
+
   sysRef.current = sys
 
   const { dispatchSubmission, send, sendQueued, submit } = useSubmission({
@@ -1091,6 +1147,7 @@ export function useMainApp(gw: GatewayClient) {
       closeLiveSession,
       answerApproval,
       answerClarify,
+      answerClarifyQuestion,
       answerSecret,
       answerSudo,
       clearSelection,
@@ -1113,6 +1170,7 @@ export function useMainApp(gw: GatewayClient) {
     [
       answerApproval,
       answerClarify,
+      answerClarifyQuestion,
       answerSecret,
       answerSudo,
       clearSelection,
diff --git a/ui-tui/src/components/appLayout.tsx b/ui-tui/src/components/appLayout.tsx
index 3b5ef135c0961..f358097699671 100644
--- a/ui-tui/src/components/appLayout.tsx
+++ b/ui-tui/src/components/appLayout.tsx
@@ -561,6 +561,7 @@ export const AppLayout = memo(function AppLayout({
                 cols={composer.cols}
                 onApprovalChoice={actions.answerApproval}
                 onClarifyAnswer={actions.answerClarify}
+                onClarifyQuestionAnswer={actions.answerClarifyQuestion}
                 onSecretSubmit={actions.answerSecret}
                 onSudoSubmit={actions.answerSudo}
               />
diff --git a/ui-tui/src/components/appOverlays.tsx b/ui-tui/src/components/appOverlays.tsx
index aa9fcd6547363..f96be36ba4d59 100644
--- a/ui-tui/src/components/appOverlays.tsx
+++ b/ui-tui/src/components/appOverlays.tsx
@@ -59,9 +59,13 @@ export function PromptZone({
   cols,
   onApprovalChoice,
   onClarifyAnswer,
+  onClarifyQuestionAnswer,
   onSecretSubmit,
   onSudoSubmit
-}: Pick<AppOverlaysProps, 'cols' | 'onApprovalChoice' | 'onClarifyAnswer' | 'onSecretSubmit' | 'onSudoSubmit'>) {
+}: Pick<
+  AppOverlaysProps,
+  'cols' | 'onApprovalChoice' | 'onClarifyAnswer' | 'onClarifyQuestionAnswer' | 'onSecretSubmit' | 'onSudoSubmit'
+>) {
   const overlay = useStore($overlayState)
   const theme = useStore($uiTheme)
 
@@ -129,6 +133,7 @@ export function PromptZone({
           cols={cols}
           onAnswer={onClarifyAnswer}
           onCancel={() => onClarifyAnswer('')}
+          onQuestionAnswer={onClarifyQuestionAnswer}
           req={overlay.clarify}
           t={theme}
         />
diff --git a/ui-tui/src/components/prompts.tsx b/ui-tui/src/components/prompts.tsx
index 78fade0d2c1fc..e1d4744880934 100644
--- a/ui-tui/src/components/prompts.tsx
+++ b/ui-tui/src/components/prompts.tsx
@@ -1,7 +1,8 @@
 import { Box, Text, useInput, wrapAnsi } from '@hermes/ink'
-import { useState } from 'react'
+import { useEffect, useState } from 'react'
 
 import { isMac } from '../lib/platform.js'
+import { clarifyBatchRevisitState } from '../lib/text.js'
 import type { Theme } from '../theme.js'
 import type { ApprovalReq, ClarifyReq, ConfirmReq } from '../types.js'
 
@@ -142,27 +143,145 @@ export function ApprovalPrompt({ cols = 80, onChoice, req, t }: ApprovalPromptPr
   )
 }
 
-export function ClarifyPrompt({ cols = 80, onAnswer, onCancel, req, t }: ClarifyPromptProps) {
+export function ClarifyPrompt({ cols = 80, onAnswer, onCancel, onQuestionAnswer, req, t }: ClarifyPromptProps) {
   const [sel, setSel] = useState(0)
   const [custom, setCustom] = useState('')
   const [typing, setTyping] = useState(false)
   const choices = req.choices ?? []
+  const batch = req.questions ?? []
+  const isBatch = batch.length > 0
+
+  // ── Batch (A-compact) state: status list + one expanded active question.
+  // `active` walks the QUESTION list (Tab/Shift-Tab cycle it, any order);
+  // `sel` is reused as the cursor within the active question's choice rows.
+  const answers = req.answers ?? {}
+  const firstUnanswered = batch.findIndex(q => answers[q.qid] === undefined)
+  const [active, setActive] = useState(Math.max(0, firstUnanswered))
+
+  const moveActive = (delta: number) => {
+    const next = (active + delta + batch.length) % batch.length
+    const question = batch[next]
+    // Re-visit restore, same model as the CLI panel: a choice answer puts
+    // the cursor back on its row; a typed answer lands on Other with the
+    // text staged so Enter edits it instead of retyping.
+    const restored = clarifyBatchRevisitState(question?.choices ?? [], question ? answers[question.qid] : undefined)
+
+    setActive(next)
+    setSel(restored.sel)
+    setCustom(restored.custom)
+    setTyping(false)
+  }
+
+  // After a lock the overlay is re-patched with the new answers map — jump
+  // the cursor to the next unanswered question (stay put when editing).
+  useEffect(() => {
+    if (!isBatch) {
+      return
+    }
+
+    const current = batch[active]
+
+    if (current && answers[current.qid] === undefined) {
+      return
+    }
+
+    const next = batch.findIndex(q => answers[q.qid] === undefined)
+
+    if (next >= 0) {
+      setActive(next)
+      setSel(0)
+      setCustom('')
+      setTyping(false)
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- keyed by the answers map only
+  }, [req.answers])
 
   const heading = (
     <Text bold>
       <Text color={t.color.accent}>ask</Text>
-      <Text color={t.color.text}> {req.question}</Text>
+      <Text color={t.color.text}> {isBatch ? `${batch.length} questions` : req.question}</Text>
     </Text>
   )
 
+  const activeQuestion = isBatch ? batch[active] : undefined
+  const activeChoices = activeQuestion ? (activeQuestion.choices ?? []) : choices
+  const answeredCount = isBatch ? batch.filter(q => answers[q.qid] !== undefined).length : 0
+  const remainingCount = isBatch ? batch.length - answeredCount : 0
+
+  const lockActive = (value: string) => {
+    if (activeQuestion) {
+      onQuestionAnswer?.(activeQuestion.qid, value)
+      setSel(0)
+      setCustom('')
+      setTyping(false)
+    }
+  }
+
   useInput((ch, key) => {
     if (key.escape) {
-      typing && choices.length ? setTyping(false) : onCancel()
+      if (typing) {
+        setTyping(false)
+
+        return
+      }
+
+      onCancel()
+
+      return
+    }
+
+    if (typing) {
+      return
+    }
+
+    if (isBatch) {
+      // Tab / Shift-Tab cycle the active question (with wrap) — the
+      // selected question is always the expanded one, like the CLI panel.
+      if (key.tab) {
+        moveActive(key.shift ? -1 : 1)
+
+        return
+      }
+
+      if (!activeQuestion) {
+        return
+      }
+
+      if (activeChoices.length === 0) {
+        // Open-ended question: any keypress starts typing (TextInput below).
+        setTyping(true)
+
+        return
+      }
+
+      if (key.upArrow && sel > 0) {
+        setSel(s => s - 1)
+      }
+
+      if (key.downArrow && sel < activeChoices.length) {
+        setSel(s => s + 1)
+      }
+
+      if (key.return) {
+        if (sel === activeChoices.length) {
+          setTyping(true)
+        } else if (activeChoices[sel]) {
+          lockActive(activeChoices[sel]!)
+        }
+
+        return
+      }
+
+      const n = parseInt(ch)
+
+      if (n >= 1 && n <= activeChoices.length) {
+        lockActive(activeChoices[n - 1]!)
+      }
 
       return
     }
 
-    if (typing || !choices.length) {
+    if (!choices.length) {
       return
     }
 
@@ -185,6 +304,74 @@ export function ClarifyPrompt({ cols = 80, onAnswer, onCancel, req, t }: Clarify
     }
   })
 
+  if (isBatch) {
+    const hint = typing
+      ? `Enter ${remainingCount === 1 ? 'confirm and continue' : 'lock answer'} · Esc back`
+      : `↑/↓ select · Enter ${remainingCount === 1 ? 'confirm and continue' : 'lock answer'} · Tab/Shift+Tab switch question · Esc/Ctrl+C cancel`
+
+    return (
+      <Box flexDirection="column">
+        {heading}
+
+        {batch.map((q, i) => {
+          const answer = answers[q.qid]
+          const isActive = i === active
+          const marker = answer !== undefined ? '✓' : isActive ? '▸' : '·'
+
+          return (
+            <Box flexDirection="column" key={q.qid}>
+              <Text>
+                <Text bold={isActive} color={isActive ? t.color.text : t.color.muted}>
+                  {marker} {q.question}
+                </Text>
+              </Text>
+
+              {answer !== undefined ? (
+                // The locked answer on its own line, in the ok color, so the
+                // current answers stay readable while Tab walks the list.
+                <Box paddingLeft={2}>
+                  <Text color={answer ? t.color.ok : t.color.muted} italic={!answer}>
+                    {answer || '(skipped)'}
+                  </Text>
+                </Box>
+              ) : null}
+
+              {isActive ? (
+                typing || activeChoices.length === 0 ? (
+                  <Box paddingLeft={2}>
+                    <Text color={t.color.label}>{'> '}</Text>
+                    <TextInput
+                      color={t.color.text}
+                      columns={Math.max(20, cols - 8)}
+                      onChange={setCustom}
+                      onSubmit={lockActive}
+                      value={custom}
+                    />
+                  </Box>
+                ) : (
+                  <Box flexDirection="column" paddingLeft={2}>
+                    {[...activeChoices, 'Other (type your answer)'].map((c, ci) => (
+                      <Text key={ci}>
+                        <Text color={t.color.muted} {...chipRowProps(t, sel === ci)}>
+                          {sel === ci ? '▸ ' : '  '}
+                          {ci + 1}. {c}
+                        </Text>
+                      </Text>
+                    ))}
+                  </Box>
+                )
+              ) : null}
+            </Box>
+          )
+        })}
+
+        <Text color={t.color.muted}>
+          {answeredCount}/{batch.length} answered · {hint}
+        </Text>
+      </Box>
+    )
+  }
+
   if (typing || !choices.length) {
     return (
       <Box flexDirection="column">
@@ -300,6 +487,8 @@ interface ClarifyPromptProps {
   cols?: number
   onAnswer: (s: string) => void
   onCancel: () => void
+  /** Batch mode: lock one question's answer (clarify.respond + question_id). */
+  onQuestionAnswer?: (qid: string, s: string) => void
   req: ClarifyReq
   t: Theme
 }
diff --git a/ui-tui/src/gatewayTypes.ts b/ui-tui/src/gatewayTypes.ts
index fcd634206f5d1..427af8badece3 100644
--- a/ui-tui/src/gatewayTypes.ts
+++ b/ui-tui/src/gatewayTypes.ts
@@ -703,7 +703,13 @@ export type GatewayEvent =
       type: 'tool.complete'
     }
   | {
-      payload: { choices: string[] | null; question: string; request_id: string }
+      payload: {
+        answers?: Record<string, string>
+        choices?: string[] | null
+        question?: string
+        questions?: { choices?: string[] | null; multi_select?: boolean; qid: string; question: string }[]
+        request_id: string
+      }
       session_id?: string
       type: 'clarify.request'
     }
diff --git a/ui-tui/src/lib/text.test.ts b/ui-tui/src/lib/text.test.ts
index 7117e1f44af6c..6c3b87e6903b0 100644
--- a/ui-tui/src/lib/text.test.ts
+++ b/ui-tui/src/lib/text.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
-import { formatAbandonedClarify, stripTrailingPasteNewlines } from './text.js'
+import { clarifyBatchRevisitState, formatAbandonedClarify, formatAbandonedClarifyBatch, stripTrailingPasteNewlines } from './text.js'
 
 describe('stripTrailingPasteNewlines', () => {
   it('removes trailing newline runs from pasted text', () => {
@@ -51,3 +51,45 @@ describe('formatAbandonedClarify', () => {
     expect(out).not.toContain('  0.')
   })
 })
+
+describe('formatAbandonedClarifyBatch', () => {
+  it('shows locked answers and marks unanswered questions', () => {
+    const out = formatAbandonedClarifyBatch(
+      [
+        { qid: 'q0', question: 'One?' },
+        { qid: 'q1', question: 'Two?' }
+      ],
+      { q0: 'alpha' },
+      'timed out'
+    )
+
+    expect(out).toBe(
+      ['ask (2 questions)', '  ✓ One? → alpha', '  · Two? (no answer)', '  (timed out)'].join('\n')
+    )
+  })
+
+  it('treats an empty locked answer as unanswered in the record', () => {
+    const out = formatAbandonedClarifyBatch([{ qid: 'q0', question: 'One?' }], { q0: '' }, 'cancelled')
+
+    expect(out).toContain('· One? (no answer)')
+  })
+})
+
+describe('clarifyBatchRevisitState', () => {
+  it('restores the cursor onto a choice answer', () => {
+    expect(clarifyBatchRevisitState(['red', 'blue'], 'blue')).toEqual({ custom: '', sel: 1 })
+  })
+
+  it('stages a typed answer on the Other row for editing', () => {
+    expect(clarifyBatchRevisitState(['red', 'blue'], 'chartreuse')).toEqual({ custom: 'chartreuse', sel: 2 })
+  })
+
+  it('stages a typed answer for an open-ended question (no choices)', () => {
+    expect(clarifyBatchRevisitState([], 'free text')).toEqual({ custom: 'free text', sel: 0 })
+  })
+
+  it('resets cleanly for unanswered and empty answers', () => {
+    expect(clarifyBatchRevisitState(['red'], undefined)).toEqual({ custom: '', sel: 0 })
+    expect(clarifyBatchRevisitState(['red'], '')).toEqual({ custom: '', sel: 0 })
+  })
+})
diff --git a/ui-tui/src/lib/text.ts b/ui-tui/src/lib/text.ts
index 64b5b311176e6..003930dbe2806 100644
--- a/ui-tui/src/lib/text.ts
+++ b/ui-tui/src/lib/text.ts
@@ -365,6 +365,49 @@ export const formatAbandonedClarify = (question: string, choices: string[] | nul
   return [head, ...opts, `  (${reason} — no selection)`].join('\n')
 }
 
+/**
+ * Batch counterpart of `formatAbandonedClarify`: every question on its own
+ * line, answered ones keeping their locked answer (partials survive a
+ * timeout server-side, so the record must show what was actually sent).
+ */
+export const formatAbandonedClarifyBatch = (
+  questions: { qid: string; question: string }[],
+  answers: Record<string, string>,
+  reason: string
+) => {
+  const lines = questions.map(q => {
+    const answer = answers[q.qid]
+
+    return answer ? `  ✓ ${q.question} → ${answer}` : `  · ${q.question} (no answer)`
+  })
+
+  return [`ask (${questions.length} questions)`, ...lines, `  (${reason})`].join('\n')
+}
+
+/**
+ * Cursor/draft restore for re-visiting an answered batch clarify question
+ * (Tab/Shift-Tab): a choice answer puts the cursor back on its row; an
+ * answer that matches no choice was typed via Other, so the cursor lands on
+ * the Other row (index = choices.length) with the text staged for editing.
+ * Unanswered questions restore to a clean cursor.
+ */
+export const clarifyBatchRevisitState = (
+  choices: readonly string[],
+  answer: string | undefined
+): { custom: string; sel: number } => {
+  if (answer === undefined || answer === '') {
+    return { custom: '', sel: 0 }
+  }
+
+  const choiceIndex = choices.indexOf(answer)
+
+  if (choiceIndex >= 0) {
+    return { custom: '', sel: choiceIndex }
+  }
+
+  return { custom: answer, sel: choices.length > 0 ? choices.length : 0 }
+}
+
 export const flat = (r: Record<string, string[]>) => Object.values(r).flat()
 
 const COMPACT_NUMBER = new Intl.NumberFormat('en-US', { maximumFractionDigits: 1, notation: 'compact' })
diff --git a/ui-tui/src/types.ts b/ui-tui/src/types.ts
index f90d3b9c45763..6e225363cb2ff 100644
--- a/ui-tui/src/types.ts
+++ b/ui-tui/src/types.ts
@@ -107,10 +107,22 @@ export interface ConfirmReq {
   title: string
 }
 
+export interface ClarifyBatchQuestion {
+  choices: string[] | null
+  multiSelect?: boolean
+  qid: string
+  question: string
+}
+
 export interface ClarifyReq {
   choices: string[] | null
   question: string
   requestId: string
+  /** Batch (multi-question) clarify: present instead of question/choices. */
+  questions?: ClarifyBatchQuestion[]
+  /** Answers already locked server-side (qid → answer): seeded from the
+   *  reconnect replay, updated as the user locks each question. */
+  answers?: Record<string, string>
 }
 
 export interface Msg {
diff --git a/website/docs/reference/tools-reference.md b/website/docs/reference/tools-reference.md
index d63ad0f14f42f..4851c2edada0e 100644
--- a/website/docs/reference/tools-reference.md
+++ b/website/docs/reference/tools-reference.md
@@ -44,6 +44,18 @@ These two tools live in the `browser` toolset but only register when a Chrome De
 |------|-------------|----------------------|
 | `clarify` | Ask the user a question when you need clarification, feedback, or a decision before proceeding. Supports three modes: 1. **Single-select multiple choice** — up to 4 choices; the user picks one or types their own answer via a 5th 'Other' option. 2. **Multi-select multiple choice** — `multi_select=true` renders checkboxes and returns a list of selected choices. 3. **Open-ended** — no choices; the user types a free-form response. Choices are ordered best-first, so the first one is labelled `(Recommended)` on every surface and is the default highlight; the label is presentation only and is stripped from the answer the agent reads. On the classic CLI multi-select uses Space-to-toggle checkboxes; on messaging platforms without native checkbox UIs the user replies with comma/space-separated numbers (e.g. "1, 3") or the option text. | — |
 
+### Asking multiple questions at once
+
+The `clarify` tool also accepts a `questions` array (2–5 independent questions, each with its own `choices` and `multi_select`) so the agent can batch several clarification needs into a single prompt instead of asking sequentially. The result is a `responses` array in the same order, with each question's `id` (when supplied) echoed back.
+
+Per-surface behavior:
+
+- **Desktop** shows every question on one card. Picks and typed answers stage locally, and one **Confirm and continue** button (enabled once every question has an answer) submits the whole batch. Staged answers stay editable until that confirm. Skip cancels the whole batch.
+- **TUI and CLI** show a compact status list (`✓` answered / `▸` active / `·` pending) with only the active question's choices expanded. Enter locks the active answer and jumps to the next unanswered question; Tab moves between questions to answer in any order; Esc cancels the batch.
+- **Messaging platforms** (Telegram, Discord, …) fall back to asking the questions one at a time through the existing single-question prompt. If the user stops responding, the remaining questions are not sent.
+
+If the prompt times out part-way, answers the user already locked are kept: the tool result carries them plus `"timed_out": true`, with the unanswered entries left blank, so the agent can distinguish a deliberate skip from an absent user.
+
 ## `code_execution` toolset
 
 | Tool | Description | Requires environment |