@qwen-code/qwen-code 0.19.2 → 0.19.3-nightly.20260701.a974594d7

package/chunks/{chunk-VYFMN7C6.js → chunk-FV4SQ54H.js}

@@ -1,14 +1,12 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  MID_TURN_QUEUE_DRAIN_METHOD
-} from "./chunk-QBZ22PQX.js";
 import {
   MCP_RESTART_SERVER_DEADLINE_MS
 } from "./chunk-P7M4GA57.js";
 import {
   BranchWhilePromptActiveError,
   CancelSentinelCollisionError,
+  CdWhilePromptActiveError,
   InvalidClientIdError,
   InvalidPermissionOptionError,
   InvalidRewindTargetError,
@@ -24,7 +22,10 @@ import {
   SessionShellDisabledError,
   WorkspaceMismatchError,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-S566HKUS.js";
+} from "./chunk-DHXWNSJA.js";
+import {
+  MID_TURN_QUEUE_DRAIN_METHOD
+} from "./chunk-EWALXUAD.js";
 import {
   canonicalizeWorkspace
 } from "./chunk-SEZC2725.js";
@@ -35,7 +36,7 @@ import {
 } from "./chunk-ALX6BUYW.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-EXMX5YHG.js";
+} from "./chunk-KXVVXAAC.js";
 import {
   ClientSideConnection,
   PROTOCOL_VERSION,
@@ -49,15 +50,15 @@ import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-D5E5TMYH.js";
+} from "./chunk-VHRREANT.js";
 import {
   ShellExecutionService,
   TrustGateError
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-35FH347N.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-WA5OJGFL.js";
+} from "./chunk-B5MPZI4K.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -1099,7 +1100,7 @@ function sliceLineRange(content, startLine, endLine) {
 }
 __name(sliceLineRange, "sliceLineRange");
 var BridgeClient = class {
-  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted) {
+  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender) {
     this.resolveEntry = resolveEntry;
     this.resolvePendingRestoreEvents = resolvePendingRestoreEvents;
     this.mediator = mediator;
@@ -1108,6 +1109,7 @@ var BridgeClient = class {
     this.fileSystem = fileSystem;
     this.onModelPromoted = onModelPromoted;
     this.onModePromoted = onModePromoted;
+    this.clientMcpSender = clientMcpSender;
   }
   static {
     __name(this, "BridgeClient");
@@ -1254,6 +1256,9 @@ var BridgeClient = class {
    * treats that as "drain unsupported" and stops asking.
    */
   async extMethod(method, params) {
+    if (method === SERVE_CONTROL_EXT_METHODS.clientMcpMessage) {
+      return this.handleClientMcpMessage(params);
+    }
     if (method !== MID_TURN_QUEUE_DRAIN_METHOD) {
       throw RequestError.methodNotFound(method);
     }
@@ -1283,6 +1288,52 @@ var BridgeClient = class {
     }
     return { messages };
   }
+  /**
+   * Reverse tool channel (issue #5626, Phase 2) — answer the child's
+   * `qwen/control/client_mcp/message` ext-method. The child's session
+   * `McpClientManager` calls this when its agent drives a client-hosted
+   * (extension) MCP server: `params` carries the advertised `server` name and
+   * the JSON-RPC `payload` (initialize / tools/list / tools/call / a
+   * notification). We resolve the per-WS-connection sender via the injected
+   * `clientMcpSender` lookup, deliver the payload over the daemon WS, and
+   * return the correlated response as `{ payload }`.
+   *
+   * Rejects with ACP `methodNotFound` when no `clientMcpSender` is wired (Mode
+   * A / tests can't host a client MCP server), and `invalidParams` when the
+   * frame is malformed or the named server is no longer hosted (e.g. the
+   * extension disconnected mid-turn) — the agent's `SdkControlClientTransport`
+   * surfaces that as a transport error rather than hanging.
+   */
+  async handleClientMcpMessage(params) {
+    if (!this.clientMcpSender) {
+      throw RequestError.methodNotFound(
+        SERVE_CONTROL_EXT_METHODS.clientMcpMessage
+      );
+    }
+    const server = params["server"];
+    if (typeof server !== "string" || server.length === 0) {
+      throw RequestError.invalidParams(
+        void 0,
+        "`server` must be a non-empty string"
+      );
+    }
+    const payload = params["payload"];
+    if (payload === null || typeof payload !== "object") {
+      throw RequestError.invalidParams(
+        void 0,
+        "`payload` must be a JSON-RPC message object"
+      );
+    }
+    const send = this.clientMcpSender(server);
+    if (!send) {
+      throw RequestError.invalidParams(
+        void 0,
+        `client-hosted MCP server '${server}' is not currently connected`
+      );
+    }
+    const response = await send(payload);
+    return { payload: response };
+  }
   /**
    * Handle child->bridge ACP `extNotification` calls. Six methods are
    * recognized — `qwen/notify/session/model-update`,
@@ -1912,15 +1963,18 @@ function broadcastPromptCancelledOnce(entry, sessionId, originatorClientId, reas
 }
 __name(broadcastPromptCancelledOnce, "broadcastPromptCancelledOnce");
 function broadcastTurnComplete(entry, sessionId, promptResult, promptId, originatorClientId) {
-  entry.events.publish({
-    type: "turn_complete",
-    data: {
-      sessionId,
-      stopReason: promptResult.stopReason ?? "end_turn",
-      ...promptId ? { promptId } : {}
-    },
-    ...originatorClientId ? { originatorClientId } : {}
-  });
+  try {
+    entry.events.publish({
+      type: "turn_complete",
+      data: {
+        sessionId,
+        stopReason: promptResult.stopReason ?? "end_turn",
+        ...promptId ? { promptId } : {}
+      },
+      ...originatorClientId ? { originatorClientId } : {}
+    });
+  } catch {
+  }
 }
 __name(broadcastTurnComplete, "broadcastTurnComplete");
 function extractErrorMessage(err) {
@@ -1963,16 +2017,19 @@ function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId)
   const message = extractErrorMessage(err);
   const code = extractErrorCode(err);
   entry.retryAllowed = true;
-  entry.events.publish({
-    type: "turn_error",
-    data: {
-      sessionId,
-      message,
-      ...code ? { code } : {},
-      ...promptId ? { promptId } : {}
-    },
-    ...originatorClientId ? { originatorClientId } : {}
-  });
+  try {
+    entry.events.publish({
+      type: "turn_error",
+      data: {
+        sessionId,
+        message,
+        ...code ? { code } : {},
+        ...promptId ? { promptId } : {}
+      },
+      ...originatorClientId ? { originatorClientId } : {}
+    });
+  } catch {
+  }
 }
 __name(broadcastTurnError, "broadcastTurnError");
 function hasControlCharacter(value) {
@@ -1985,11 +2042,26 @@ function hasControlCharacter(value) {
   return false;
 }
 __name(hasControlCharacter, "hasControlCharacter");
+function extractPromptText(prompt) {
+  if (!Array.isArray(prompt)) return "";
+  let hasImage = false;
+  for (const block of prompt) {
+    if (block["type"] === "image") {
+      hasImage = true;
+    }
+    if (block["type"] === "text" && typeof block["text"] === "string" && block["text"].length > 0) {
+      return block["text"];
+    }
+  }
+  return hasImage ? "[image]" : "";
+}
+__name(extractPromptText, "extractPromptText");
 var DEFAULT_INIT_TIMEOUT_MS = 1e4;
 var PERSIST_TIMEOUT_MS = 5e3;
 var MCP_RESTART_TIMEOUT_MS = 3e5;
 var MCP_OAUTH_TIMEOUT_MS = 6e5;
 var DAEMON_RETRY_META_KEY = "qwen.daemon.retry";
+var DAEMON_CONTINUE_META_KEY = "qwen.daemon.continueLastTurn";
 var SESSION_RECAP_TIMEOUT_MS = 6e4;
 var SESSION_BTW_TIMEOUT_MS = 6e4;
 var SHELL_COMMAND_TIMEOUT_MS = 12e4;
@@ -2174,6 +2246,14 @@ function createAcpSessionBridge(opts) {
   const aliveChannels = /* @__PURE__ */ new Set();
   let inFlightChannelSpawn;
   const byId = /* @__PURE__ */ new Map();
+  const toSessionSummary = /* @__PURE__ */ __name((entry) => ({
+    sessionId: entry.sessionId,
+    workspaceCwd: entry.workspaceCwd,
+    createdAt: entry.createdAt,
+    displayName: entry.displayName,
+    clientCount: entry.clientIds.size,
+    hasActivePrompt: entry.promptActive
+  }), "toSessionSummary");
   const permissionConsensusQuorum = opts.permissionConsensusQuorum;
   if (permissionConsensusQuorum !== void 0 && (!Number.isInteger(permissionConsensusQuorum) || permissionConsensusQuorum < 1)) {
     throw new Error(
@@ -2294,7 +2374,14 @@ function createAcpSessionBridge(opts) {
             },
             originator
           );
-        }
+        },
+        // Reverse tool channel (issue #5626, Phase 2): forward the optional
+        // client-hosted-MCP sender lookup so `BridgeClient.extMethod` can
+        // answer `qwen/control/client_mcp/message` from the child by reaching
+        // the per-WS-connection `ClientMcpRegistrar`. Omitted callers (tests,
+        // Mode A) never host a client MCP server, so the method stays
+        // unreachable.
+        opts.clientMcpSender
       );
       const connection = new ClientSideConnection(() => client, channel.stream);
       const info = {
@@ -2750,6 +2837,7 @@ function createAcpSessionBridge(opts) {
       events,
       promptQueue: Promise.resolve(),
       pendingPromptCount: 0,
+      pendingPromptList: [],
       midTurnMessageQueue: [],
       modelChangeQueue: Promise.resolve(),
       approvalModeQueue: Promise.resolve(),
@@ -2828,6 +2916,7 @@ function createAcpSessionBridge(opts) {
         // Late attachers get the same ACP state the original restore
         // caller saw; spawn-only sessions don't carry a state payload.
         state: existing.restoreState ?? {},
+        hasActivePrompt: existing.promptActive,
         ...replayFieldsFor(existing, action)
       };
     }
@@ -2860,7 +2949,8 @@ function createAcpSessionBridge(opts) {
         ...restored,
         attached: true,
         clientId: registerClient(entry, req.clientId),
-        createdAt: entry.createdAt
+        createdAt: entry.createdAt,
+        hasActivePrompt: entry.promptActive
       };
     }
     if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
@@ -2948,6 +3038,7 @@ function createAcpSessionBridge(opts) {
           clientId: clientId2,
           createdAt: racedEntry.createdAt,
           state: racedEntry.restoreState ?? {},
+          hasActivePrompt: racedEntry.promptActive,
           ...replayFieldsFor(racedEntry, action)
         };
       }
@@ -2969,6 +3060,7 @@ function createAcpSessionBridge(opts) {
         clientId,
         createdAt: entry.createdAt,
         state,
+        hasActivePrompt: entry.promptActive,
         ...replayFieldsFor(entry, action)
       };
     })().finally(() => {
@@ -3059,7 +3151,7 @@ function createAcpSessionBridge(opts) {
   }
   __name(closeSessionImpl, "closeSessionImpl");
   startSessionReaper();
-  return {
+  const bridgeApi = {
     getDaemonStatusSnapshot() {
       return {
         limits: {
@@ -3146,7 +3238,8 @@ function createAcpSessionBridge(opts) {
             workspaceCwd: existing.workspaceCwd,
             attached: true,
             clientId,
-            createdAt: existing.createdAt
+            createdAt: existing.createdAt,
+            hasActivePrompt: existing.promptActive
           };
         }
         const inFlight = inFlightSpawns.get(workspaceKey);
@@ -3170,7 +3263,12 @@ function createAcpSessionBridge(opts) {
             ).catch(() => {
             });
           }
-          return { ...session, attached: true, clientId };
+          return {
+            ...session,
+            attached: true,
+            clientId,
+            hasActivePrompt: attachedEntry.promptActive
+          };
         }
       }
       if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
@@ -3217,10 +3315,60 @@ function createAcpSessionBridge(opts) {
         promptSlotReleased = true;
         entry.pendingPromptCount = Math.max(0, entry.pendingPromptCount - 1);
       }, "releasePromptSlot");
+      const promptId = context?.promptId ?? randomUUID2();
+      const isQueued = entry.pendingPromptCount > 1;
+      const pendingAbort = new AbortController();
+      if (signal) {
+        if (signal.aborted) {
+          pendingAbort.abort(signal.reason);
+        } else {
+          signal.addEventListener(
+            "abort",
+            () => pendingAbort.abort(signal.reason),
+            { once: true }
+          );
+        }
+      }
+      const pendingEntry = {
+        promptId,
+        queuedAt,
+        ...originatorClientId !== void 0 ? { originatorClientId } : {},
+        text: extractPromptText(req.prompt),
+        abortController: pendingAbort,
+        state: isQueued ? "queued" : "running"
+      };
+      entry.pendingPromptList.push(pendingEntry);
+      if (isQueued) {
+        entry.events.publish({
+          type: "pending_prompt_added",
+          data: {
+            sessionId,
+            promptId: pendingEntry.promptId,
+            text: pendingEntry.text,
+            queuedAt: pendingEntry.queuedAt
+          },
+          ...originatorClientId ? { originatorClientId } : {}
+        });
+      }
       const result = entry.promptQueue.then(
         () => telemetry.runWithContext(capturedContext, async () => {
           const queueWaitMs = Date.now() - queuedAt;
           telemetry.metrics?.promptQueueWait(queueWaitMs);
+          if (pendingAbort.signal.aborted) {
+            throw new DOMException("Prompt aborted", "AbortError");
+          }
+          if (pendingEntry.state === "queued") {
+            pendingEntry.state = "running";
+            entry.events.publish({
+              type: "pending_prompt_started",
+              data: {
+                sessionId,
+                promptId: pendingEntry.promptId,
+                text: pendingEntry.text
+              },
+              ...originatorClientId ? { originatorClientId } : {}
+            });
+          }
           const dispatchStartMs = Date.now();
           try {
             return await telemetry.withSpan(
@@ -3238,13 +3386,11 @@ function createAcpSessionBridge(opts) {
                     sessionId
                   }
                 );
-                if (signal?.aborted) {
-                  throw new DOMException("Prompt aborted", "AbortError");
-                }
                 assertLivePromptEntry(sessionId, entry);
                 const requestedRetry = req.retry === true;
                 const isRetry = requestedRetry && entry.retryAllowed;
                 entry.retryAllowed = false;
+                const isContinue = context?.continue === true;
                 const promptRequest = (() => {
                   const copy = {
                     ...normalized
@@ -3252,9 +3398,13 @@ function createAcpSessionBridge(opts) {
                   delete copy.retry;
                   const meta = copy._meta && typeof copy._meta === "object" ? { ...copy._meta } : {};
                   delete meta[DAEMON_RETRY_META_KEY];
+                  delete meta[DAEMON_CONTINUE_META_KEY];
                   if (isRetry) {
                     meta[DAEMON_RETRY_META_KEY] = true;
                   }
+                  if (isContinue) {
+                    meta[DAEMON_CONTINUE_META_KEY] = true;
+                  }
                   if (Object.keys(meta).length > 0) {
                     copy._meta = meta;
                   } else {
@@ -3273,7 +3423,7 @@ function createAcpSessionBridge(opts) {
                 }
                 try {
                   entry.cancelBroadcast = false;
-                  if (!isRetry) {
+                  if (!isRetry && !isContinue) {
                     echoPromptToSessionBus(
                       entry,
                       promptRequest,
@@ -3315,6 +3465,12 @@ function createAcpSessionBridge(opts) {
                   () => {
                   },
                   (err) => {
+                    if (err instanceof DOMException && err.name === "AbortError" && pendingEntry.state === "queued") {
+                      writeStderrLine(
+                        `sendPrompt: queued prompt removed before agent forward for session ${sessionId}`
+                      );
+                      return;
+                    }
                     writeStderrLine(
                       `sendPrompt: forward failed for session ${sessionId}: ${extractErrorMessage(err)}`
                     );
@@ -3325,12 +3481,15 @@ function createAcpSessionBridge(opts) {
                       "forward_failed"
                     );
                     cancelPendingForSession(sessionId);
-                    entry.connection.cancel({ sessionId }).catch(() => {
+                    entry.connection.cancel({ sessionId }).catch((err2) => {
+                      writeStderrLine(
+                        `[pending-prompt] cancel forward failed after prompt abort session=${sessionId}: ${extractErrorMessage(err2)}`
+                      );
                     });
                   }
                 ).catch(() => {
                 });
-                if (!signal) return racedPromise;
+                const abortSignal = pendingAbort.signal;
                 const onAbort = /* @__PURE__ */ __name(() => {
                   broadcastPromptCancelledOnce(
                     entry,
@@ -3338,15 +3497,22 @@ function createAcpSessionBridge(opts) {
                     originatorClientId
                   );
                   cancelPendingForSession(sessionId);
-                  entry.connection.cancel({ sessionId }).catch(() => {
+                  entry.connection.cancel({ sessionId }).catch((err) => {
+                    writeStderrLine(
+                      `[pending-prompt] cancel forward failed after removePendingPrompt session=${sessionId}: ${extractErrorMessage(err)}`
+                    );
                   });
                 }, "onAbort");
-                if (signal.aborted) {
+                if (abortSignal.aborted) {
                   onAbort();
                 } else {
-                  signal.addEventListener("abort", onAbort, { once: true });
-                  if (signal.aborted) onAbort();
-                  racedPromise.finally(() => signal.removeEventListener("abort", onAbort)).catch(() => {
+                  abortSignal.addEventListener("abort", onAbort, {
+                    once: true
+                  });
+                  if (abortSignal.aborted) onAbort();
+                  racedPromise.finally(
+                    () => abortSignal.removeEventListener("abort", onAbort)
+                  ).catch(() => {
                   });
                 }
                 return racedPromise;
@@ -3357,14 +3523,13 @@ function createAcpSessionBridge(opts) {
           }
         })
       );
-      const promptId = context?.promptId;
       result.then(
         (promptResult) => {
           broadcastTurnComplete(
             entry,
             sessionId,
             promptResult,
-            promptId,
+            pendingEntry.promptId,
             originatorClientId
           );
         },
@@ -3374,7 +3539,7 @@ function createAcpSessionBridge(opts) {
             entry,
             sessionId,
             err,
-            promptId,
+            pendingEntry.promptId,
             originatorClientId
           );
         }
@@ -3384,6 +3549,24 @@ function createAcpSessionBridge(opts) {
         () => void 0
       );
       result.finally(() => {
+        const listIdx = entry.pendingPromptList.indexOf(pendingEntry);
+        if (listIdx !== -1) {
+          entry.pendingPromptList.splice(listIdx, 1);
+          if (isQueued) {
+            try {
+              entry.events.publish({
+                type: "pending_prompt_completed",
+                data: {
+                  sessionId,
+                  promptId: pendingEntry.promptId,
+                  state: "completed"
+                },
+                ...originatorClientId ? { originatorClientId } : {}
+              });
+            } catch {
+            }
+          }
+        }
         releasePromptSlot();
         if (entry.pendingPromptCount === 0 && entry.midTurnMessageQueue.length > 0) {
           writeStderrLine(
@@ -3616,6 +3799,59 @@ function createAcpSessionBridge(opts) {
       );
       return branchResult;
     },
+    async changeSessionCwd(sessionId, req, context) {
+      if (shuttingDown) throw new Error("AcpSessionBridge is shutting down");
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const originatorClientId = resolveTrustedClientId(
+        entry,
+        context?.clientId
+      );
+      const cdPromise = entry.promptQueue.then(async () => {
+        if (entry.promptActive) {
+          throw new CdWhilePromptActiveError(sessionId);
+        }
+        const ci = await ensureChannel();
+        const raw = await ci.connection.extMethod(
+          SERVE_CONTROL_EXT_METHODS.sessionCd,
+          {
+            sessionId,
+            path: req.path
+          }
+        );
+        const extResult = raw;
+        if (typeof extResult?.previousCwd !== "string" || typeof extResult?.newCwd !== "string" || !Array.isArray(extResult?.warnings)) {
+          throw new Error(
+            `changeSessionCwd: unexpected response shape from agent: ${JSON.stringify(raw)}`
+          );
+        }
+        if (extResult.previousCwd !== extResult.newCwd) {
+          entry.events.publish({
+            type: "session_cwd_changed",
+            data: {
+              sessionId,
+              previousCwd: extResult.previousCwd,
+              newCwd: extResult.newCwd
+            },
+            ...originatorClientId ? { originatorClientId } : {}
+          });
+        }
+        return extResult;
+      });
+      entry.promptQueue = cdPromise.then(
+        () => void 0,
+        () => void 0
+      );
+      const result = await withTimeout(
+        cdPromise,
+        Math.max(initTimeoutMs, 3e4),
+        "changeSessionCwd"
+      );
+      writeStderrLine(
+        `qwen serve: session ${sessionId} cwd changed: ${result.previousCwd} -> ${result.newCwd}` + (result.warnings.length > 0 ? ` (warnings: ${result.warnings.join("; ")})` : "")
+      );
+      return { sessionId, ...result };
+    },
     async closeSession(sessionId, context, closeOpts) {
       return closeSessionImpl(sessionId, context, closeOpts);
     },
@@ -3679,18 +3915,16 @@ function createAcpSessionBridge(opts) {
       const out = [];
       for (const entry of byId.values()) {
         if (entry.workspaceCwd === key) {
-          out.push({
-            sessionId: entry.sessionId,
-            workspaceCwd: entry.workspaceCwd,
-            createdAt: entry.createdAt,
-            displayName: entry.displayName,
-            clientCount: entry.clientIds.size,
-            hasActivePrompt: entry.promptActive
-          });
+          out.push(toSessionSummary(entry));
         }
       }
       return out;
     },
+    getSessionSummary(sessionId) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      return toSessionSummary(entry);
+    },
     recordHeartbeat(sessionId, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -3790,6 +4024,27 @@ function createAcpSessionBridge(opts) {
         { serverName }
       );
     },
+    async getWorkspaceMcpResourcesStatus(serverName) {
+      return requestWorkspaceStatus(
+        SERVE_STATUS_EXT_METHODS.workspaceMcpResources,
+        () => ({
+          v: STATUS_SCHEMA_VERSION,
+          workspaceCwd: boundWorkspace,
+          serverName,
+          initialized: false,
+          acpChannelLive: false,
+          resources: [],
+          errors: [
+            {
+              kind: "mcp_resources",
+              status: "not_started",
+              hint: "spawn a session to populate"
+            }
+          ]
+        }),
+        { serverName }
+      );
+    },
     async getWorkspaceToolsStatus() {
       return requestWorkspaceStatus(
         SERVE_STATUS_EXT_METHODS.workspaceTools,
@@ -3853,6 +4108,39 @@ function createAcpSessionBridge(opts) {
         SERVE_CONTROL_EXT_METHODS.sessionGoalClear
       );
     },
+    async continueSession(sessionId, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+      const decision = await requestSessionStatus(sessionId, SERVE_CONTROL_EXT_METHODS.sessionContinue);
+      if (!decision.accepted) {
+        return decision;
+      }
+      const liveEntry = byId.get(sessionId);
+      if (!liveEntry) throw new SessionNotFoundError(sessionId);
+      const lastEventId = liveEntry.events.lastEventId;
+      const promptId = context?.promptId;
+      const promptPromise = bridgeApi.sendPrompt(
+        sessionId,
+        { sessionId, prompt: [] },
+        void 0,
+        {
+          ...context?.clientId !== void 0 ? { clientId: context.clientId } : {},
+          ...promptId !== void 0 ? { promptId } : {},
+          continue: true
+        }
+      );
+      promptPromise.catch((err) => {
+        teeServeDebugLine(
+          `continueSession: continuation turn failed for ${sessionId}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      });
+      return {
+        ...decision,
+        ...promptId !== void 0 ? { promptId } : {},
+        lastEventId
+      };
+    },
     async getSessionStatsStatus(sessionId) {
       return requestSessionStatus(
         sessionId,
@@ -4177,6 +4465,44 @@ function createAcpSessionBridge(opts) {
         recap: response.recap ?? null
       };
     },
+    getPendingPrompts(sessionId, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+      return entry.pendingPromptList.map((p) => ({
+        promptId: p.promptId,
+        text: p.text,
+        queuedAt: p.queuedAt,
+        state: p.state,
+        ...p.originatorClientId !== void 0 ? { originatorClientId: p.originatorClientId } : {}
+      }));
+    },
+    removePendingPrompt(sessionId, promptId, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+      const idx = entry.pendingPromptList.findIndex(
+        (p) => p.promptId === promptId
+      );
+      if (idx === -1) return { removed: false };
+      const target = entry.pendingPromptList[idx];
+      writeStderrLine(
+        `[pending-prompt] session=${sessionId} removing promptId=${promptId} state=${target.state}`
+      );
+      target.abortController.abort(
+        new DOMException("Prompt removed by user", "AbortError")
+      );
+      entry.pendingPromptList.splice(idx, 1);
+      try {
+        entry.events.publish({
+          type: "pending_prompt_completed",
+          data: { sessionId, promptId, state: "removed" },
+          ...target.originatorClientId ? { originatorClientId: target.originatorClientId } : {}
+        });
+      } catch {
+      }
+      return { removed: true };
+    },
     enqueueMidTurnMessage(sessionId, message, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -4728,6 +5054,7 @@ function createAcpSessionBridge(opts) {
       }
     }
   };
+  return bridgeApi;
 }
 __name(createAcpSessionBridge, "createAcpSessionBridge");
 async function withTimeout(p, ms, label) {