diff --git a/design/qwen-code-electron-desktop-implementation-plan.md b/design/qwen-code-electron-desktop-implementation-plan.md
index 350dd7786..d4b92239a 100644
--- a/design/qwen-code-electron-desktop-implementation-plan.md
+++ b/design/qwen-code-electron-desktop-implementation-plan.md
@@ -133,7 +133,7 @@ order, verification, decisions, and remaining work.
 
 ### Slice 6: Permission Bridge
 
-- Status: pending
+- Status: complete
 - Goal: route ACP permission and ask-user-question callbacks to renderer and
   resolve responses with timeout cancellation.
 - Files:
@@ -144,6 +144,12 @@ order, verification, decisions, and remaining work.
   - Permission requests are visible to the active session.
   - Closing a WS connection cancels pending requests.
   - Timeout defaults to deny/cancel.
+- Progress:
+  - 2026-04-25: added `PermissionBridge` for ACP `requestPermission`, including
+    `ask_user_question` detection from tool raw input, typed WS request/response
+    messages, timeout cancellation, and session-disconnect cancellation.
+  - 2026-04-25: renderer chat state now tracks pending permission/question
+    prompts and sends selected options back over the active session socket.
 - Verification:
   - `npm run test --workspace=packages/desktop`
   - renderer store tests for allow, deny, and timeout state
@@ -201,6 +207,10 @@ order, verification, decisions, and remaining work.
   needs WebSocket message shapes, while the VS Code handler is callback/UI
   oriented; shared extraction can happen after permission and settings slices
   stabilize the common surface.
+- 2026-04-25: Treat `ask_user_question` as a specialized ACP permission request
+  in desktop, matching the VS Code companion behavior. The bridge returns
+  `cancelled` for cancel/reject option ids and passes answer payloads through
+  for submit responses.
 
 ## Verification Log
 
@@ -267,6 +277,15 @@ order, verification, decisions, and remaining work.
   - `npm run lint --workspace=packages/desktop` passed.
   - `npm run typecheck --workspace=packages/desktop` passed.
   - `npm run build --workspace=packages/desktop` passed.
+- 2026-04-25 Slice 6:
+  - `npx prettier --check design/qwen-code-electron-desktop-implementation-plan.md packages/desktop` passed.
+  - `npm run test --workspace=packages/desktop` passed: 4 files, 31 tests.
+  - `npm run lint --workspace=packages/desktop` passed.
+  - `npm run typecheck --workspace=packages/desktop` passed.
+  - `npm run build --workspace=packages/desktop` passed.
+  - `npm run typecheck` passed across workspaces.
+  - `npm run build` passed across the configured build order. Existing VS Code
+    companion lint warnings were reported by its build script, with no errors.
 
 ## Self Review Notes
 
@@ -319,12 +338,20 @@ order, verification, decisions, and remaining work.
   - Main still does not auto-start a real ACP child process; the chat loop is
     verified with an injected fake ACP client and remains ready for the runtime
     integration slice.
+- 2026-04-25 Slice 6:
+  - Permission responses are accepted only for pending request ids; stale or
+    unknown responses produce a typed socket error instead of resolving any ACP
+    callback.
+  - Pending permission and ask-user-question callbacks are cancelled when a
+    session loses its last socket or the bridge closes, preventing ACP hangs.
+  - The renderer prompt UI is intentionally minimal for this slice; richer
+    answer collection can reuse `@qwen-code/webui` dialogs once the shared
+    desktop state surface is stable.
 
 ## Remaining Work
 
-- Commit Slice 5b.
-- Start Slice 6 permission bridge: route ACP permission and ask-user-question
-  callbacks through the existing per-session WebSocket channel with timeout
-  cancellation.
-- Continue through permission, settings/auth/model/mode, real ACP runtime
-  startup, and packaging slices until the architecture MVP is fully verified.
+- Commit Slice 6.
+- Start Slice 7 settings/auth/model/mode UI and supporting services while
+  preserving existing Qwen settings/auth semantics.
+- Continue through settings/auth/model/mode, real ACP runtime startup, and
+  packaging slices until the architecture MVP is fully verified.
diff --git a/packages/desktop/src/renderer/App.tsx b/packages/desktop/src/renderer/App.tsx
index 683f3e6c5..e6d69bd25 100644
--- a/packages/desktop/src/renderer/App.tsx
+++ b/packages/desktop/src/renderer/App.tsx
@@ -183,6 +183,22 @@ export function App() {
     socketRef.current?.stopGeneration();
   }, []);
 
+  const respondToPermission = useCallback(
+    (requestId: string, optionId: string) => {
+      socketRef.current?.respondToPermission(requestId, optionId);
+      dispatchChat({ type: 'clear_permission_request', requestId });
+    },
+    [],
+  );
+
+  const respondToAskUserQuestion = useCallback(
+    (requestId: string, optionId: string) => {
+      socketRef.current?.respondToAskUserQuestion(requestId, optionId, {});
+      dispatchChat({ type: 'clear_ask_user_question', requestId });
+    },
+    [],
+  );
+
   const statusLabel = useMemo(() => {
     if (loadState.state === 'ready') {
       return 'Connected';
@@ -253,6 +269,11 @@ export function App() {
               </span>
             </div>
             <ChatTimeline state={chatState} activeSessionId={activeSessionId} />
+            <PermissionPrompts
+              state={chatState}
+              onAskUserQuestionResponse={respondToAskUserQuestion}
+              onPermissionResponse={respondToPermission}
+            />
             <form className="composer" onSubmit={sendMessage}>
               <textarea
                 aria-label="Message"
@@ -395,6 +416,97 @@ function TimelineItem({ item }: { item: ChatTimelineItem }) {
   return <div className="chat-event">{item.label}</div>;
 }
 
+function PermissionPrompts({
+  onAskUserQuestionResponse,
+  onPermissionResponse,
+  state,
+}: {
+  onAskUserQuestionResponse: (requestId: string, optionId: string) => void;
+  onPermissionResponse: (requestId: string, optionId: string) => void;
+  state: ChatState;
+}) {
+  const permission = state.pendingPermission;
+  const question = state.pendingAskUserQuestion;
+  if (!permission && !question) {
+    return null;
+  }
+
+  return (
+    <div className="permission-strip">
+      {permission ? (
+        <section className="permission-panel">
+          <div>
+            <span className="message-role">
+              {permission.request.toolCall.kind || 'permission'}
+            </span>
+            <strong>
+              {permission.request.toolCall.title ||
+                permission.request.toolCall.toolCallId}
+            </strong>
+          </div>
+          <div className="permission-actions">
+            {permission.request.options.map((option) => (
+              <button
+                className={
+                  option.kind.startsWith('reject')
+                    ? 'secondary-button'
+                    : 'primary-button'
+                }
+                key={option.optionId}
+                onClick={() =>
+                  onPermissionResponse(permission.requestId, option.optionId)
+                }
+                type="button"
+              >
+                {option.name}
+              </button>
+            ))}
+          </div>
+        </section>
+      ) : null}
+      {question ? (
+        <section className="permission-panel">
+          {question.request.questions.map((item) => (
+            <div key={`${item.header}-${item.question}`}>
+              <span className="message-role">{item.header}</span>
+              <strong>{item.question}</strong>
+              {item.options.length > 0 ? (
+                <ul className="question-options">
+                  {item.options.map((option) => (
+                    <li key={`${option.label}-${option.description}`}>
+                      {option.label}
+                    </li>
+                  ))}
+                </ul>
+              ) : null}
+            </div>
+          ))}
+          <div className="permission-actions">
+            <button
+              className="secondary-button"
+              onClick={() =>
+                onAskUserQuestionResponse(question.requestId, 'cancel')
+              }
+              type="button"
+            >
+              Cancel
+            </button>
+            <button
+              className="primary-button"
+              onClick={() =>
+                onAskUserQuestionResponse(question.requestId, 'proceed_once')
+              }
+              type="button"
+            >
+              Submit
+            </button>
+          </div>
+        </section>
+      ) : null}
+    </div>
+  );
+}
+
 function StatusPill({ state }: { state: LoadState['state'] }) {
   return <span className={`status-pill status-pill-${state}`}>{state}</span>;
 }
diff --git a/packages/desktop/src/renderer/api/websocket.ts b/packages/desktop/src/renderer/api/websocket.ts
index b2c8749ca..f1c0a243d 100644
--- a/packages/desktop/src/renderer/api/websocket.ts
+++ b/packages/desktop/src/renderer/api/websocket.ts
@@ -19,6 +19,12 @@ export interface SessionSocketHandlers {
 
 export interface SessionSocketClient {
   sendUserMessage(content: string): void;
+  respondToPermission(requestId: string, optionId: string): void;
+  respondToAskUserQuestion(
+    requestId: string,
+    optionId: string,
+    answers?: Record<string, string>,
+  ): void;
   stopGeneration(): void;
   ping(): void;
   close(): void;
@@ -45,6 +51,25 @@ export function connectSessionSocket(
     sendUserMessage(content: string): void {
       sendClientMessage(socket, { type: 'user_message', content });
     },
+    respondToPermission(requestId: string, optionId: string): void {
+      sendClientMessage(socket, {
+        type: 'permission_response',
+        requestId,
+        optionId,
+      });
+    },
+    respondToAskUserQuestion(
+      requestId: string,
+      optionId: string,
+      answers?: Record<string, string>,
+    ): void {
+      sendClientMessage(socket, {
+        type: 'ask_user_question_response',
+        requestId,
+        optionId,
+        answers,
+      });
+    },
     stopGeneration(): void {
       sendClientMessage(socket, { type: 'stop_generation' });
     },
diff --git a/packages/desktop/src/renderer/stores/chatStore.ts b/packages/desktop/src/renderer/stores/chatStore.ts
index f47f69165..6630f902b 100644
--- a/packages/desktop/src/renderer/stores/chatStore.ts
+++ b/packages/desktop/src/renderer/stores/chatStore.ts
@@ -6,7 +6,9 @@
 
 import type {
   DesktopAvailableCommand,
+  DesktopAskUserQuestionRequest,
   DesktopPlanEntry,
+  DesktopPermissionRequest,
   DesktopServerMessage,
   DesktopToolCallUpdate,
   DesktopUsageStats,
@@ -49,6 +51,14 @@ export interface ChatState {
   latestUsage: DesktopUsageStats | null;
   availableCommands: DesktopAvailableCommand[];
   availableSkills: string[];
+  pendingPermission: {
+    requestId: string;
+    request: DesktopPermissionRequest;
+  } | null;
+  pendingAskUserQuestion: {
+    requestId: string;
+    request: DesktopAskUserQuestionRequest;
+  } | null;
   mode: string | null;
   error: string | null;
 }
@@ -57,6 +67,8 @@ export type ChatAction =
   | { type: 'connect' }
   | { type: 'disconnect' }
   | { type: 'append_user_message'; content: string }
+  | { type: 'clear_permission_request'; requestId: string }
+  | { type: 'clear_ask_user_question'; requestId: string }
   | { type: 'server_message'; message: DesktopServerMessage };
 
 export function createInitialChatState(): ChatState {
@@ -67,6 +79,8 @@ export function createInitialChatState(): ChatState {
     latestUsage: null,
     availableCommands: [],
     availableSkills: [],
+    pendingPermission: null,
+    pendingAskUserQuestion: null,
     mode: null,
     error: null,
   };
@@ -99,6 +113,16 @@ export function chatReducer(state: ChatState, action: ChatAction): ChatState {
         ],
       };
 
+    case 'clear_permission_request':
+      return state.pendingPermission?.requestId === action.requestId
+        ? { ...state, pendingPermission: null }
+        : state;
+
+    case 'clear_ask_user_question':
+      return state.pendingAskUserQuestion?.requestId === action.requestId
+        ? { ...state, pendingAskUserQuestion: null }
+        : state;
+
     case 'server_message':
       return applyServerMessage(state, action.message);
 
@@ -164,6 +188,34 @@ function applyServerMessage(
         availableSkills: message.skills,
       };
 
+    case 'permission_request':
+      return {
+        ...state,
+        pendingPermission: {
+          requestId: message.requestId,
+          request: message.request,
+        },
+        items: [
+          ...state.items,
+          createEventItem(
+            `Permission requested: ${
+              message.request.toolCall.title ||
+              message.request.toolCall.toolCallId
+            }`,
+          ),
+        ],
+      };
+
+    case 'ask_user_question':
+      return {
+        ...state,
+        pendingAskUserQuestion: {
+          requestId: message.requestId,
+          request: message.request,
+        },
+        items: [...state.items, createEventItem('Question requested')],
+      };
+
     case 'message_complete':
       return {
         ...state,
diff --git a/packages/desktop/src/renderer/styles.css b/packages/desktop/src/renderer/styles.css
index 4fb58da86..00b31060e 100644
--- a/packages/desktop/src/renderer/styles.css
+++ b/packages/desktop/src/renderer/styles.css
@@ -386,6 +386,53 @@ textarea:disabled {
   font-size: 12px;
 }
 
+.permission-strip {
+  display: grid;
+  gap: 10px;
+  padding: 0 14px 14px;
+}
+
+.permission-panel {
+  display: grid;
+  gap: 12px;
+  padding: 12px;
+  border: 1px solid rgba(231, 189, 115, 0.42);
+  background: rgba(231, 189, 115, 0.08);
+}
+
+.permission-panel > div {
+  display: grid;
+  gap: 6px;
+}
+
+.permission-panel strong {
+  color: #eef0ed;
+  font-size: 14px;
+}
+
+.permission-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  justify-content: flex-end;
+}
+
+.question-options {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.question-options li {
+  padding: 4px 7px;
+  border: 1px solid rgba(238, 240, 237, 0.1);
+  color: #d8dcd6;
+  font-size: 12px;
+}
+
 .composer {
   display: grid;
   gap: 10px;
diff --git a/packages/desktop/src/server/acp/permissionBridge.test.ts b/packages/desktop/src/server/acp/permissionBridge.test.ts
new file mode 100644
index 000000000..d5bcc1163
--- /dev/null
+++ b/packages/desktop/src/server/acp/permissionBridge.test.ts
@@ -0,0 +1,154 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import type { RequestPermissionRequest } from '@agentclientprotocol/sdk';
+import { PermissionBridge } from './permissionBridge.js';
+import type { DesktopServerMessage } from '../../shared/desktopProtocol.js';
+
+describe('PermissionBridge', () => {
+  it('broadcasts permission requests and resolves selected options', async () => {
+    const messages: DesktopServerMessage[] = [];
+    const bridge = new PermissionBridge({
+      timeoutMs: 1000,
+      broadcast: (_sessionId, message) => messages.push(message),
+    });
+
+    const permission = bridge.requestPermission(createPermissionRequest());
+    expect(messages[0]).toMatchObject({
+      type: 'permission_request',
+      request: {
+        sessionId: 'session-1',
+        toolCall: {
+          toolCallId: 'tool-1',
+          title: 'Run command',
+        },
+      },
+    });
+
+    const requestId = getRequestId(messages[0]);
+    expect(
+      bridge.handleClientMessage({
+        type: 'permission_response',
+        requestId,
+        optionId: 'proceed_once',
+      }),
+    ).toBe(true);
+
+    await expect(permission).resolves.toEqual({
+      outcome: {
+        outcome: 'selected',
+        optionId: 'proceed_once',
+      },
+    });
+  });
+
+  it('normalizes ask-user-question requests and preserves answers', async () => {
+    const messages: DesktopServerMessage[] = [];
+    const bridge = new PermissionBridge({
+      timeoutMs: 1000,
+      broadcast: (_sessionId, message) => messages.push(message),
+    });
+
+    const permission = bridge.requestPermission({
+      ...createPermissionRequest(),
+      toolCall: {
+        toolCallId: 'tool-question',
+        title: 'Ask question',
+        rawInput: {
+          questions: [
+            {
+              header: 'Choice',
+              question: 'Pick one',
+              multiSelect: false,
+              options: [{ label: 'A', description: 'Option A' }],
+            },
+          ],
+          metadata: { source: 'test' },
+        },
+      },
+    });
+
+    expect(messages[0]).toMatchObject({
+      type: 'ask_user_question',
+      request: {
+        sessionId: 'session-1',
+        questions: [
+          {
+            header: 'Choice',
+            question: 'Pick one',
+            multiSelect: false,
+          },
+        ],
+        metadata: { source: 'test' },
+      },
+    });
+
+    const requestId = getRequestId(messages[0]);
+    bridge.handleClientMessage({
+      type: 'ask_user_question_response',
+      requestId,
+      optionId: 'proceed_once',
+      answers: { Choice: 'A' },
+    });
+
+    await expect(permission).resolves.toEqual({
+      outcome: {
+        outcome: 'selected',
+        optionId: 'proceed_once',
+      },
+      answers: { Choice: 'A' },
+    });
+  });
+
+  it('cancels pending permission requests on timeout and session close', async () => {
+    vi.useFakeTimers();
+    const bridge = new PermissionBridge({
+      timeoutMs: 50,
+      broadcast: () => {},
+    });
+
+    const timedOut = bridge.requestPermission(createPermissionRequest());
+    await vi.advanceTimersByTimeAsync(50);
+    await expect(timedOut).resolves.toEqual({
+      outcome: { outcome: 'cancelled' },
+    });
+
+    const cancelled = bridge.requestPermission(createPermissionRequest());
+    bridge.cancelSession('session-1');
+    await expect(cancelled).resolves.toEqual({
+      outcome: { outcome: 'cancelled' },
+    });
+    vi.useRealTimers();
+  });
+});
+
+function createPermissionRequest(): RequestPermissionRequest {
+  return {
+    sessionId: 'session-1',
+    options: [
+      { optionId: 'proceed_once', name: 'Allow', kind: 'allow_once' },
+      { optionId: 'cancel', name: 'Reject', kind: 'reject_once' },
+    ],
+    toolCall: {
+      toolCallId: 'tool-1',
+      title: 'Run command',
+      kind: 'execute',
+      status: 'pending',
+    },
+  };
+}
+
+function getRequestId(message: DesktopServerMessage | undefined): string {
+  if (
+    message?.type !== 'permission_request' &&
+    message?.type !== 'ask_user_question'
+  ) {
+    throw new Error('Expected permission request message.');
+  }
+
+  return message.requestId;
+}
diff --git a/packages/desktop/src/server/acp/permissionBridge.ts b/packages/desktop/src/server/acp/permissionBridge.ts
new file mode 100644
index 000000000..beab6958b
--- /dev/null
+++ b/packages/desktop/src/server/acp/permissionBridge.ts
@@ -0,0 +1,255 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { randomUUID } from 'node:crypto';
+import type {
+  PermissionOption,
+  RequestPermissionRequest,
+  RequestPermissionResponse,
+} from '@agentclientprotocol/sdk';
+import type {
+  DesktopAskUserQuestion,
+  DesktopAskUserQuestionRequest,
+  DesktopClientMessage,
+  DesktopPermissionRequest,
+  DesktopServerMessage,
+  DesktopToolCallUpdate,
+} from '../../shared/desktopProtocol.js';
+
+const DEFAULT_PERMISSION_TIMEOUT_MS = 120_000;
+
+type PendingKind = 'permission' | 'ask_user_question';
+
+interface PendingRequest {
+  kind: PendingKind;
+  sessionId: string;
+  timeout: NodeJS.Timeout;
+  resolve(response: RequestPermissionResponse): void;
+}
+
+export interface PermissionBridgeOptions {
+  timeoutMs?: number;
+  broadcast(sessionId: string, message: DesktopServerMessage): void;
+}
+
+export class PermissionBridge {
+  private readonly pending = new Map<string, PendingRequest>();
+  private readonly timeoutMs: number;
+
+  constructor(private readonly options: PermissionBridgeOptions) {
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_PERMISSION_TIMEOUT_MS;
+  }
+
+  async requestPermission(
+    request: RequestPermissionRequest,
+  ): Promise<RequestPermissionResponse> {
+    if (isAskUserQuestionRequest(request)) {
+      return this.requestAskUserQuestion(request);
+    }
+
+    const requestId = randomUUID();
+    const response = this.waitForResponse(
+      requestId,
+      request.sessionId,
+      'permission',
+    );
+    this.options.broadcast(request.sessionId, {
+      type: 'permission_request',
+      requestId,
+      request: normalizePermissionRequest(request),
+    });
+    return response;
+  }
+
+  handleClientMessage(message: DesktopClientMessage): boolean {
+    if (message.type === 'permission_response') {
+      return this.resolvePending(message.requestId, {
+        outcome: toPermissionOutcome(message.optionId),
+      });
+    }
+
+    if (message.type === 'ask_user_question_response') {
+      return this.resolvePending(message.requestId, {
+        outcome: toPermissionOutcome(message.optionId),
+        answers: message.answers,
+      } as RequestPermissionResponse);
+    }
+
+    return false;
+  }
+
+  cancelSession(sessionId: string): void {
+    for (const [requestId, pending] of this.pending) {
+      if (pending.sessionId === sessionId) {
+        this.resolvePending(requestId, createCancelledResponse());
+      }
+    }
+  }
+
+  close(): void {
+    for (const requestId of this.pending.keys()) {
+      this.resolvePending(requestId, createCancelledResponse());
+    }
+  }
+
+  private async requestAskUserQuestion(
+    request: RequestPermissionRequest,
+  ): Promise<RequestPermissionResponse> {
+    const requestId = randomUUID();
+    const response = this.waitForResponse(
+      requestId,
+      request.sessionId,
+      'ask_user_question',
+    );
+    this.options.broadcast(request.sessionId, {
+      type: 'ask_user_question',
+      requestId,
+      request: normalizeAskUserQuestionRequest(request),
+    });
+    return response;
+  }
+
+  private waitForResponse(
+    requestId: string,
+    sessionId: string,
+    kind: PendingKind,
+  ): Promise<RequestPermissionResponse> {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this.resolvePending(requestId, createCancelledResponse());
+      }, this.timeoutMs);
+      this.pending.set(requestId, {
+        kind,
+        sessionId,
+        timeout,
+        resolve,
+      });
+    });
+  }
+
+  private resolvePending(
+    requestId: string,
+    response: RequestPermissionResponse,
+  ): boolean {
+    const pending = this.pending.get(requestId);
+    if (!pending) {
+      return false;
+    }
+
+    clearTimeout(pending.timeout);
+    this.pending.delete(requestId);
+    pending.resolve(response);
+    return true;
+  }
+}
+
+function normalizePermissionRequest(
+  request: RequestPermissionRequest,
+): DesktopPermissionRequest {
+  return {
+    sessionId: request.sessionId,
+    options: request.options.map(normalizePermissionOption),
+    toolCall: normalizePermissionToolCall(request.toolCall),
+  };
+}
+
+function normalizePermissionOption(option: PermissionOption) {
+  return {
+    optionId: option.optionId,
+    name: option.name,
+    kind: option.kind,
+  };
+}
+
+function normalizePermissionToolCall(
+  toolCall: RequestPermissionRequest['toolCall'],
+): DesktopToolCallUpdate {
+  return {
+    toolCallId: toolCall.toolCallId,
+    kind: toolCall.kind ?? undefined,
+    title: toolCall.title ?? undefined,
+    status: toolCall.status ?? undefined,
+    rawInput: toolCall.rawInput,
+    rawOutput: toolCall.rawOutput,
+    content: toolCall.content ?? undefined,
+    locations: toolCall.locations ?? undefined,
+  };
+}
+
+function normalizeAskUserQuestionRequest(
+  request: RequestPermissionRequest,
+): DesktopAskUserQuestionRequest {
+  const rawInput = getRecord(request.toolCall.rawInput);
+  return {
+    sessionId: request.sessionId,
+    questions: getQuestions(rawInput?.['questions']),
+    metadata: getRecord(rawInput?.['metadata']),
+  };
+}
+
+function isAskUserQuestionRequest(request: RequestPermissionRequest): boolean {
+  const rawInput = getRecord(request.toolCall.rawInput);
+  return Array.isArray(rawInput?.['questions']);
+}
+
+function getQuestions(value: unknown): DesktopAskUserQuestion[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value.map((question) => {
+    const record = getRecord(question);
+    return {
+      question: getString(record?.['question']),
+      header: getString(record?.['header']),
+      options: getQuestionOptions(record?.['options']),
+      multiSelect: record?.['multiSelect'] === true,
+    };
+  });
+}
+
+function getQuestionOptions(value: unknown) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value.map((option) => {
+    const record = getRecord(option);
+    return {
+      label: getString(record?.['label']),
+      description: getString(record?.['description']),
+    };
+  });
+}
+
+function toPermissionOutcome(
+  optionId: string,
+): RequestPermissionResponse['outcome'] {
+  if (optionId === 'cancel' || optionId.includes('reject')) {
+    return { outcome: 'cancelled' };
+  }
+
+  return {
+    outcome: 'selected',
+    optionId,
+  };
+}
+
+function createCancelledResponse(): RequestPermissionResponse {
+  return { outcome: { outcome: 'cancelled' } };
+}
+
+function getRecord(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+
+  return value as Record<string, unknown>;
+}
+
+function getString(value: unknown): string {
+  return typeof value === 'string' ? value : '';
+}
diff --git a/packages/desktop/src/server/index.test.ts b/packages/desktop/src/server/index.test.ts
index 1cced4f5a..e408cd8c5 100644
--- a/packages/desktop/src/server/index.test.ts
+++ b/packages/desktop/src/server/index.test.ts
@@ -6,7 +6,10 @@
 
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { WebSocket } from 'ws';
-import type { SessionNotification } from '@agentclientprotocol/sdk';
+import type {
+  RequestPermissionRequest,
+  SessionNotification,
+} from '@agentclientprotocol/sdk';
 import { startDesktopServer } from './index.js';
 import type { DesktopServer } from './types.js';
 import type { AcpSessionClient } from './services/sessionService.js';
@@ -344,6 +347,96 @@ describe('DesktopServer', () => {
     otherSocket.socket.close();
   });
 
+  it('routes ACP permission requests through the session WebSocket', async () => {
+    const acpClient = createAcpClient();
+    const server = await createTestServer(acpClient);
+    const testSocket = await connectSocket(server, '/ws/session-1');
+    await testSocket.readMessage();
+
+    const permission = acpClient.requestPermissionFromBridge(
+      createPermissionRequest(),
+    );
+    const requestMessage = await testSocket.readMessage();
+    expect(requestMessage).toMatchObject({
+      type: 'permission_request',
+      request: {
+        sessionId: 'session-1',
+        options: [{ optionId: 'proceed_once' }, { optionId: 'cancel' }],
+        toolCall: {
+          toolCallId: 'tool-1',
+          title: 'Run command',
+        },
+      },
+    });
+
+    testSocket.socket.send(
+      JSON.stringify({
+        type: 'permission_response',
+        requestId: getPermissionRequestId(requestMessage),
+        optionId: 'proceed_once',
+      }),
+    );
+
+    await expect(permission).resolves.toEqual({
+      outcome: {
+        outcome: 'selected',
+        optionId: 'proceed_once',
+      },
+    });
+    testSocket.socket.close();
+  });
+
+  it('routes ask-user-question permission requests through the session WebSocket', async () => {
+    const acpClient = createAcpClient();
+    const server = await createTestServer(acpClient);
+    const testSocket = await connectSocket(server, '/ws/session-1');
+    await testSocket.readMessage();
+
+    const permission = acpClient.requestPermissionFromBridge({
+      ...createPermissionRequest(),
+      toolCall: {
+        toolCallId: 'tool-question',
+        title: 'Ask question',
+        rawInput: {
+          questions: [
+            {
+              header: 'Choice',
+              question: 'Pick one',
+              multiSelect: false,
+              options: [{ label: 'A', description: 'Option A' }],
+            },
+          ],
+        },
+      },
+    });
+    const requestMessage = await testSocket.readMessage();
+    expect(requestMessage).toMatchObject({
+      type: 'ask_user_question',
+      request: {
+        sessionId: 'session-1',
+        questions: [{ header: 'Choice', question: 'Pick one' }],
+      },
+    });
+
+    testSocket.socket.send(
+      JSON.stringify({
+        type: 'ask_user_question_response',
+        requestId: getPermissionRequestId(requestMessage),
+        optionId: 'proceed_once',
+        answers: { Choice: 'A' },
+      }),
+    );
+
+    await expect(permission).resolves.toEqual({
+      outcome: {
+        outcome: 'selected',
+        optionId: 'proceed_once',
+      },
+      answers: { Choice: 'A' },
+    });
+    testSocket.socket.close();
+  });
+
   it('cancels generation over WebSocket', async () => {
     const acpClient = createAcpClient();
     const server = await createTestServer(acpClient);
@@ -461,6 +554,9 @@ async function writeJson(
 
 interface TestAcpClient extends AcpSessionClient {
   emitSessionUpdate(notification: SessionNotification): void;
+  requestPermissionFromBridge(
+    request: RequestPermissionRequest,
+  ): Promise<unknown>;
 }
 
 function createAcpClient(): TestAcpClient {
@@ -470,6 +566,13 @@ function createAcpClient(): TestAcpClient {
     emitSessionUpdate(notification: SessionNotification): void {
       client.onSessionUpdate?.(notification);
     },
+    requestPermissionFromBridge(request: RequestPermissionRequest) {
+      if (!client.onPermissionRequest) {
+        return Promise.reject(new Error('Permission bridge is not attached.'));
+      }
+
+      return client.onPermissionRequest(request);
+    },
     listSessions: vi.fn().mockResolvedValue({
       sessions: [{ sessionId: 'session-1', title: 'Test session' }],
       nextCursor: '3',
@@ -483,6 +586,35 @@ function createAcpClient(): TestAcpClient {
   return client;
 }
 
+function createPermissionRequest(): RequestPermissionRequest {
+  return {
+    sessionId: 'session-1',
+    options: [
+      { optionId: 'proceed_once', name: 'Allow', kind: 'allow_once' },
+      { optionId: 'cancel', name: 'Reject', kind: 'reject_once' },
+    ],
+    toolCall: {
+      toolCallId: 'tool-1',
+      title: 'Run command',
+      kind: 'execute',
+      status: 'pending',
+    },
+  };
+}
+
+function getPermissionRequestId(message: unknown): string {
+  if (
+    !message ||
+    typeof message !== 'object' ||
+    !('requestId' in message) ||
+    typeof message.requestId !== 'string'
+  ) {
+    throw new Error('Expected permission request id.');
+  }
+
+  return message.requestId;
+}
+
 async function connectSocket(
   server: DesktopServer,
   path: string,
diff --git a/packages/desktop/src/server/index.ts b/packages/desktop/src/server/index.ts
index 548913bea..e5d39362b 100644
--- a/packages/desktop/src/server/index.ts
+++ b/packages/desktop/src/server/index.ts
@@ -18,6 +18,7 @@ import {
   isAuthorized,
 } from './http/auth.js';
 import { AcpEventRouter } from './acp/AcpEventRouter.js';
+import { PermissionBridge } from './acp/permissionBridge.js';
 import { isDesktopHttpError, DesktopHttpError } from './http/errors.js';
 import { getRuntimeInfo } from './services/runtimeService.js';
 import { DesktopSessionService } from './services/sessionService.js';
@@ -42,10 +43,19 @@ export async function startDesktopServer(
   const now = options.now ?? (() => new Date());
   const startedAt = now().getTime();
   const sessionService = new DesktopSessionService(options.acpClient);
+  const socketHubRef: { current: SessionSocketHub | null } = { current: null };
+  const permissionBridge = new PermissionBridge({
+    timeoutMs: options.permissionRequestTimeoutMs,
+    broadcast: (sessionId, message) => {
+      socketHubRef.current?.broadcast(sessionId, message);
+    },
+  });
   const socketHub = new SessionSocketHub({
     token,
     acpClient: options.acpClient,
+    permissionBridge,
   });
+  socketHubRef.current = socketHub;
   const acpEventRouter = new AcpEventRouter({
     broadcast: (sessionId, message) => socketHub.broadcast(sessionId, message),
   });
@@ -55,6 +65,8 @@ export async function startDesktopServer(
       previousSessionUpdateHandler?.(notification);
       acpEventRouter.handleSessionUpdate(notification);
     };
+    options.acpClient.onPermissionRequest = (request) =>
+      permissionBridge.requestPermission(request);
   }
   const server = createServer((request, response) => {
     void handleRequest(request, response, {
@@ -114,6 +126,7 @@ export async function startDesktopServer(
       token,
     },
     close: async () => {
+      permissionBridge.close();
       socketHub.close();
       await closeHttpServer(server);
     },
diff --git a/packages/desktop/src/server/services/sessionService.ts b/packages/desktop/src/server/services/sessionService.ts
index b8715e8cc..7f19aa718 100644
--- a/packages/desktop/src/server/services/sessionService.ts
+++ b/packages/desktop/src/server/services/sessionService.ts
@@ -9,6 +9,8 @@ import type {
   LoadSessionResponse,
   NewSessionResponse,
   PromptResponse,
+  RequestPermissionRequest,
+  RequestPermissionResponse,
   SessionNotification,
 } from '@agentclientprotocol/sdk';
 import { DesktopHttpError } from '../http/errors.js';
@@ -16,6 +18,9 @@ import { DesktopHttpError } from '../http/errors.js';
 export interface AcpSessionClient {
   readonly isConnected?: boolean;
   onSessionUpdate?: (notification: SessionNotification) => void;
+  onPermissionRequest?: (
+    request: RequestPermissionRequest,
+  ) => Promise<RequestPermissionResponse>;
   connect?(): Promise<unknown>;
   listSessions(options?: {
     cwd?: string;
diff --git a/packages/desktop/src/server/types.ts b/packages/desktop/src/server/types.ts
index bdaba5f7f..7e191b99e 100644
--- a/packages/desktop/src/server/types.ts
+++ b/packages/desktop/src/server/types.ts
@@ -18,6 +18,7 @@ export interface DesktopServerOptions {
   token?: string;
   now?: () => Date;
   acpClient?: AcpSessionClient;
+  permissionRequestTimeoutMs?: number;
 }
 
 export interface DesktopHealthResponse {
diff --git a/packages/desktop/src/server/ws/SessionSocketHub.ts b/packages/desktop/src/server/ws/SessionSocketHub.ts
index 66084190f..4b13087f9 100644
--- a/packages/desktop/src/server/ws/SessionSocketHub.ts
+++ b/packages/desktop/src/server/ws/SessionSocketHub.ts
@@ -13,10 +13,12 @@ import type {
   DesktopClientMessage,
   DesktopServerMessage,
 } from '../../shared/desktopProtocol.js';
+import type { PermissionBridge } from '../acp/permissionBridge.js';
 
 interface SessionSocketHubOptions {
   token: string;
   acpClient?: AcpSessionClient;
+  permissionBridge?: PermissionBridge;
 }
 
 export class SessionSocketHub {
@@ -104,6 +106,7 @@ export class SessionSocketHub {
       sockets.delete(socket);
       if (sockets.size === 0) {
         this.socketsBySession.delete(sessionId);
+        this.options.permissionBridge?.cancelSession(sessionId);
       }
     });
   }
@@ -124,6 +127,16 @@ export class SessionSocketHub {
     }
 
     switch (message.type) {
+      case 'permission_response':
+      case 'ask_user_question_response':
+        if (!this.options.permissionBridge?.handleClientMessage(message)) {
+          sendMessage(socket, {
+            type: 'error',
+            code: 'permission_request_not_found',
+            message: 'Permission request is no longer pending.',
+          });
+        }
+        return;
       case 'ping':
         sendMessage(socket, { type: 'pong' });
         return;
@@ -235,6 +248,32 @@ function parseClientMessage(
     return { type: candidate.type };
   }
 
+  if (
+    candidate.type === 'permission_response' &&
+    typeof candidate.requestId === 'string' &&
+    typeof candidate.optionId === 'string'
+  ) {
+    return {
+      type: 'permission_response',
+      requestId: candidate.requestId,
+      optionId: candidate.optionId,
+    };
+  }
+
+  if (
+    candidate.type === 'ask_user_question_response' &&
+    typeof candidate.requestId === 'string' &&
+    typeof candidate.optionId === 'string' &&
+    (candidate.answers === undefined || isStringRecord(candidate.answers))
+  ) {
+    return {
+      type: 'ask_user_question_response',
+      requestId: candidate.requestId,
+      optionId: candidate.optionId,
+      answers: candidate.answers,
+    };
+  }
+
   if (
     candidate.type === 'user_message' &&
     typeof candidate.content === 'string'
@@ -245,6 +284,14 @@ function parseClientMessage(
   return null;
 }
 
+function isStringRecord(value: unknown): value is Record<string, string> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+
+  return Object.values(value).every((item) => typeof item === 'string');
+}
+
 function sendMessage(socket: WebSocket, message: DesktopServerMessage): void {
   if (socket.readyState === WebSocket.OPEN) {
     socket.send(JSON.stringify(message));
diff --git a/packages/desktop/src/shared/desktopProtocol.ts b/packages/desktop/src/shared/desktopProtocol.ts
index ca9386317..bd3a161cc 100644
--- a/packages/desktop/src/shared/desktopProtocol.ts
+++ b/packages/desktop/src/shared/desktopProtocol.ts
@@ -7,7 +7,14 @@
 export type DesktopClientMessage =
   | { type: 'ping' }
   | { type: 'stop_generation' }
-  | { type: 'user_message'; content: string };
+  | { type: 'user_message'; content: string }
+  | { type: 'permission_response'; requestId: string; optionId: string }
+  | {
+      type: 'ask_user_question_response';
+      requestId: string;
+      optionId: string;
+      answers?: Record<string, string>;
+    };
 
 export interface DesktopPlanEntry {
   content: string;
@@ -51,6 +58,36 @@ export interface DesktopAvailableCommand {
   input?: unknown;
 }
 
+export interface DesktopPermissionOption {
+  optionId: string;
+  name: string;
+  kind: 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
+}
+
+export interface DesktopPermissionRequest {
+  sessionId: string;
+  options: DesktopPermissionOption[];
+  toolCall: DesktopToolCallUpdate;
+}
+
+export interface DesktopAskUserQuestionOption {
+  label: string;
+  description: string;
+}
+
+export interface DesktopAskUserQuestion {
+  question: string;
+  header: string;
+  options: DesktopAskUserQuestionOption[];
+  multiSelect: boolean;
+}
+
+export interface DesktopAskUserQuestionRequest {
+  sessionId: string;
+  questions: DesktopAskUserQuestion[];
+  metadata?: Record<string, unknown>;
+}
+
 export type DesktopServerMessage =
   | { type: 'connected'; sessionId: string }
   | { type: 'pong' }
@@ -68,5 +105,15 @@ export type DesktopServerMessage =
       commands: DesktopAvailableCommand[];
       skills: string[];
     }
+  | {
+      type: 'permission_request';
+      requestId: string;
+      request: DesktopPermissionRequest;
+    }
+  | {
+      type: 'ask_user_question';
+      requestId: string;
+      request: DesktopAskUserQuestionRequest;
+    }
   | { type: 'message_complete'; stopReason?: string }
   | { type: 'error'; code: string; message: string; retryable?: boolean };