@qwen-code/qwen-code 0.19.3 → 0.19.4-nightly.20260702.46814e4f1

package/chunks/{chunk-VBZ452JT.js → chunk-MSNGFH6L.js}

@@ -2,12 +2,15 @@
 "use strict";
 import {
   MID_TURN_QUEUE_DRAIN_METHOD
-} from "./chunk-QBZ22PQX.js";
+} from "./chunk-EWALXUAD.js";
 import {
   DEFAULT_RING_SIZE,
   EVENT_SCHEMA_VERSION,
   EventBus
 } from "./chunk-ALX6BUYW.js";
+import {
+  defaultSpawnChannelFactory
+} from "./chunk-PSFDB5FZ.js";
 import {
   MCP_RESTART_SERVER_DEADLINE_MS
 } from "./chunk-P7M4GA57.js";
@@ -29,17 +32,11 @@ import {
   SessionShellClientRequiredError,
   SessionShellDisabledError,
   WorkspaceMismatchError,
-  canonicalizeWorkspace,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-JE5FVRPC.js";
-import {
-  defaultSpawnChannelFactory
-} from "./chunk-FXKVLFFY.js";
+} from "./chunk-T22H4V4R.js";
 import {
-  ClientSideConnection,
-  PROTOCOL_VERSION,
-  RequestError
-} from "./chunk-UFC57OYT.js";
+  canonicalizeWorkspace
+} from "./chunk-SEZC2725.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -48,15 +45,20 @@ import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-L7OKCI7T.js";
+} from "./chunk-M7BLWURA.js";
+import {
+  ClientSideConnection,
+  PROTOCOL_VERSION,
+  RequestError
+} from "./chunk-UFC57OYT.js";
 import {
   ShellExecutionService,
   TrustGateError
-} from "./chunk-YAINVQ3Q.js";
+} from "./chunk-A5OPLHFM.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-QNKBEJO2.js";
+} from "./chunk-UA6XBZT7.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -1098,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;
@@ -1107,6 +1109,7 @@ var BridgeClient = class {
     this.fileSystem = fileSystem;
     this.onModelPromoted = onModelPromoted;
     this.onModePromoted = onModePromoted;
+    this.clientMcpSender = clientMcpSender;
   }
   static {
     __name(this, "BridgeClient");
@@ -1253,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);
     }
@@ -1282,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`,
@@ -1857,6 +1909,24 @@ function extractPermissionResponseMetadata(response) {
   return void 0;
 }
 __name(extractPermissionResponseMetadata, "extractPermissionResponseMetadata");
+function parseWorkspaceMemoryRememberResult(response) {
+  if (response === null || typeof response !== "object" || Array.isArray(response)) {
+    throw new Error("Malformed workspace memory remember response");
+  }
+  const record = response;
+  const summary = record["summary"];
+  const filesTouched = record["filesTouched"];
+  const touchedScopes = record["touchedScopes"];
+  if (summary !== void 0 && typeof summary !== "string" || !Array.isArray(filesTouched) || !filesTouched.every((file) => typeof file === "string") || !Array.isArray(touchedScopes) || !touchedScopes.every((scope) => scope === "user" || scope === "project")) {
+    throw new Error("Malformed workspace memory remember response");
+  }
+  return {
+    ...summary === void 0 ? {} : { summary },
+    filesTouched,
+    touchedScopes
+  };
+}
+__name(parseWorkspaceMemoryRememberResult, "parseWorkspaceMemoryRememberResult");
 function echoPromptToSessionBus(entry, req, originatorClientId) {
   const prompt = req.prompt;
   if (!Array.isArray(prompt) || prompt.length === 0) return;
@@ -1911,15 +1981,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) {
@@ -1962,16 +2035,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) {
@@ -1984,11 +2060,27 @@ 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 WORKSPACE_MEMORY_REMEMBER_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;
@@ -2121,7 +2213,7 @@ function createAcpSessionBridge(opts) {
     cancelIdleTimer();
     idleTimer = setTimeout(() => {
       idleTimer = void 0;
-      if (ci.sessionIds.size === 0 && ci.pendingRestoreIds.size === 0) {
+      if (hasNoChannelWork(ci)) {
         writeStderrLine(
           `qwen serve: idle timeout (${timeoutMs}ms) expired, killing channel`
         );
@@ -2131,6 +2223,33 @@ function createAcpSessionBridge(opts) {
     idleTimer.unref();
   }
   __name(startIdleTimer, "startIdleTimer");
+  function hasNoChannelWork(ci, opts2) {
+    const inFlightSpawnCount = ci.sessionSpawnsInFlight - (opts2?.ignoreCurrentSessionSpawn === true ? 1 : 0);
+    const pendingRestoreCount = ci.pendingRestoreIds.size - (opts2?.ignoreRestoreId !== void 0 && ci.pendingRestoreIds.has(opts2.ignoreRestoreId) ? 1 : 0);
+    return ci.sessionIds.size === 0 && pendingRestoreCount === 0 && ci.workspaceControlInFlight === 0 && inFlightSpawnCount === 0;
+  }
+  __name(hasNoChannelWork, "hasNoChannelWork");
+  async function reapPendingEmptyChannel(ci) {
+    if (!ci.emptyReapPending || !hasNoChannelWork(ci)) return;
+    ci.emptyReapPending = false;
+    ci.isDying = true;
+    await ci.channel.kill().catch(() => {
+    });
+  }
+  __name(reapPendingEmptyChannel, "reapPendingEmptyChannel");
+  async function withWorkspaceControl(ci, fn) {
+    ci.workspaceControlInFlight++;
+    try {
+      return await fn();
+    } finally {
+      ci.workspaceControlInFlight = Math.max(
+        0,
+        ci.workspaceControlInFlight - 1
+      );
+      await reapPendingEmptyChannel(ci);
+    }
+  }
+  __name(withWorkspaceControl, "withWorkspaceControl");
   function startSessionReaper() {
     if (sessionReapIntervalMs <= 0 || sessionIdleTimeoutMs <= 0) {
       writeStderrLine("qwen serve: session reaper disabled");
@@ -2301,7 +2420,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 = {
@@ -2310,6 +2436,9 @@ function createAcpSessionBridge(opts) {
         client,
         sessionIds: /* @__PURE__ */ new Set(),
         pendingRestoreIds: /* @__PURE__ */ new Set(),
+        sessionSpawnsInFlight: 0,
+        workspaceControlInFlight: 0,
+        emptyReapPending: false,
         isDying: false,
         handshakeComplete: false
       };
@@ -2413,63 +2542,75 @@ function createAcpSessionBridge(opts) {
   __name(ensureChannel, "ensureChannel");
   async function doSpawn(modelServiceId, effectiveScope, requestedClientId) {
     const ci = await ensureChannel();
+    ci.sessionSpawnsInFlight++;
+    let sessionRegistered = false;
     let newSessionResp;
     try {
-      newSessionResp = await telemetry.withSpan(
-        "session.new",
-        {
-          "qwen-code.daemon.bridge.operation": "session.new",
-          "qwen-code.daemon.session_scope": effectiveScope
-        },
-        async () => await withTimeout(
-          ci.connection.newSession({
-            cwd: boundWorkspace,
-            mcpServers: []
-          }),
-          initTimeoutMs,
-          "newSession"
-        )
+      try {
+        newSessionResp = await telemetry.withSpan(
+          "session.new",
+          {
+            "qwen-code.daemon.bridge.operation": "session.new",
+            "qwen-code.daemon.session_scope": effectiveScope
+          },
+          async () => await withTimeout(
+            ci.connection.newSession({
+              cwd: boundWorkspace,
+              mcpServers: []
+            }),
+            initTimeoutMs,
+            "newSession"
+          )
+        );
+      } catch (err) {
+        if (hasNoChannelWork(ci, { ignoreCurrentSessionSpawn: true })) {
+          ci.isDying = true;
+          await ci.channel.kill().catch(() => {
+          });
+        } else {
+          ci.emptyReapPending = true;
+        }
+        throw err;
+      }
+      if (shuttingDown) {
+        throw new Error("AcpSessionBridge is shutting down");
+      }
+      const entry = createSessionEntry(
+        ci,
+        newSessionResp.sessionId,
+        boundWorkspace
       );
-    } catch (err) {
-      if (ci.sessionIds.size === 0) {
-        ci.isDying = true;
-        await ci.channel.kill().catch(() => {
+      sessionRegistered = true;
+      seedSnapshotCaches(entry, newSessionResp);
+      const clientId = registerClient(entry, requestedClientId);
+      if (effectiveScope === "single" && !defaultEntry) defaultEntry = entry;
+      if (modelServiceId) {
+        await applyModelServiceId(
+          entry,
+          modelServiceId,
+          initTimeoutMs,
+          clientId
+        ).catch(() => {
         });
       }
-      throw err;
-    }
-    if (shuttingDown) {
-      throw new Error("AcpSessionBridge is shutting down");
-    }
-    const entry = createSessionEntry(
-      ci,
-      newSessionResp.sessionId,
-      boundWorkspace
-    );
-    seedSnapshotCaches(entry, newSessionResp);
-    const clientId = registerClient(entry, requestedClientId);
-    if (effectiveScope === "single" && !defaultEntry) defaultEntry = entry;
-    if (modelServiceId) {
-      await applyModelServiceId(
-        entry,
-        modelServiceId,
-        initTimeoutMs,
-        clientId
-      ).catch(() => {
-      });
-    }
-    if (!byId.has(entry.sessionId)) {
-      throw new Error(
-        `Session ${entry.sessionId} died during model-switch initialization`
-      );
+      if (!byId.has(entry.sessionId)) {
+        throw new Error(
+          `Session ${entry.sessionId} died during model-switch initialization`
+        );
+      }
+      return {
+        sessionId: entry.sessionId,
+        workspaceCwd: entry.workspaceCwd,
+        attached: false,
+        clientId,
+        createdAt: entry.createdAt
+      };
+    } finally {
+      ci.sessionSpawnsInFlight = Math.max(0, ci.sessionSpawnsInFlight - 1);
+      if (!sessionRegistered) {
+        await reapPendingEmptyChannel(ci);
+      }
     }
-    return {
-      sessionId: entry.sessionId,
-      workspaceCwd: entry.workspaceCwd,
-      attached: false,
-      clientId,
-      createdAt: entry.createdAt
-    };
   }
   __name(doSpawn, "doSpawn");
   async function applyModelServiceId(entry, modelId, timeoutMs, originatorClientId) {
@@ -2608,13 +2749,24 @@ function createAcpSessionBridge(opts) {
     ]);
     return response;
   }, "requestSessionStatus");
-  const notifyAgentSessionClose = /* @__PURE__ */ __name(async (entry, ci, label) => {
-    if (!ci || ci.channel !== entry.channel) return;
+  const notifyAgentSessionClose = /* @__PURE__ */ __name(async (entry, ci, label, opts2) => {
+    if (!ci || ci.channel !== entry.channel) {
+      if (opts2?.throwOnFailure === true) {
+        writeStderrLine(
+          `qwen serve: ${label} ACP session close channel unavailable for session ${JSON.stringify(entry.sessionId)}; agent close skipped`
+        );
+        throw new Error(
+          `ACP session close channel unavailable for ${entry.sessionId}`
+        );
+      }
+      return;
+    }
     try {
       await Promise.race([
         withTimeout(
           entry.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionClose, {
-            sessionId: entry.sessionId
+            sessionId: entry.sessionId,
+            ...opts2?.requireFlush === true ? { requireFlush: true } : {}
           }),
           initTimeoutMs,
           SERVE_CONTROL_EXT_METHODS.sessionClose
@@ -2627,6 +2779,9 @@ function createAcpSessionBridge(opts) {
           err instanceof Error ? err.message : err
         )}`
       );
+      if (opts2?.throwOnFailure === true) {
+        throw err;
+      }
     }
   }, "notifyAgentSessionClose");
   const broadcastWorkspaceEvent = /* @__PURE__ */ __name((envelope, skipSessionId) => {
@@ -2757,6 +2912,7 @@ function createAcpSessionBridge(opts) {
       events,
       promptQueue: Promise.resolve(),
       pendingPromptCount: 0,
+      pendingPromptList: [],
       midTurnMessageQueue: [],
       modelChangeQueue: Promise.resolve(),
       approvalModeQueue: Promise.resolve(),
@@ -2928,10 +3084,11 @@ function createAcpSessionBridge(opts) {
         if (isAcpSessionResourceNotFound(err, req.sessionId)) {
           throw new SessionNotFoundError(req.sessionId);
         }
-        if (ci.sessionIds.size === 0 && ci.pendingRestoreIds.size === 1 && ci.pendingRestoreIds.has(req.sessionId)) {
+        ci.emptyReapPending = hasNoChannelWork(ci, {
+          ignoreRestoreId: req.sessionId
+        });
+        if (ci.emptyReapPending) {
           ci.isDying = true;
-          await ci.channel.kill().catch(() => {
-          });
         }
         throw err;
       }
@@ -2982,7 +3139,7 @@ function createAcpSessionBridge(opts) {
         hasActivePrompt: entry.promptActive,
         ...replayFieldsFor(entry, action)
       };
-    })().finally(() => {
+    })().finally(async () => {
       ci?.pendingRestoreIds.delete(req.sessionId);
       ci?.client.clearRestoreInFlight(req.sessionId);
       pendingRestoreEvents.delete(req.sessionId);
@@ -2990,6 +3147,9 @@ function createAcpSessionBridge(opts) {
         restoreEvents.close();
         ci?.client.markSessionClosed(req.sessionId);
       }
+      if (ci) {
+        await reapPendingEmptyChannel(ci);
+      }
     });
     inFlightRestores.set(req.sessionId, { action, promise, coalesceState });
     try {
@@ -3022,6 +3182,13 @@ function createAcpSessionBridge(opts) {
         `qwen serve: closeSession channelInfoForEntry returned undefined for session ${JSON.stringify(sessionId)} \u2014 channel cleanup skipped (entry's channel already torn down)`
       );
     }
+    const requireAgentClose = closeOpts?.requireAgentClose === true;
+    if (requireAgentClose) {
+      await notifyAgentSessionClose(entry, ci, "closeSession", {
+        throwOnFailure: true,
+        requireFlush: true
+      });
+    }
     if (ci && ci.channel === entry.channel) {
       ci.sessionIds.delete(sessionId);
     }
@@ -3052,7 +3219,9 @@ function createAcpSessionBridge(opts) {
     } catch {
     }
     entry.events.close();
-    await notifyAgentSessionClose(entry, ci, "closeSession");
+    if (!requireAgentClose) {
+      await notifyAgentSessionClose(entry, ci, "closeSession");
+    }
     try {
       await telemetry.withSpan(
         "session.close.cancel_active_prompt",
@@ -3064,13 +3233,16 @@ function createAcpSessionBridge(opts) {
       );
     } catch {
     }
-    if (ci && ci.sessionIds.size === 0 && ci.pendingRestoreIds.size === 0) {
-      await startIdleTimer(ci, `closeSession "${sessionId}"`);
+    if (ci && hasNoChannelWork(ci)) {
+      await reapPendingEmptyChannel(ci);
+      if (!ci.isDying) {
+        await startIdleTimer(ci, `closeSession "${sessionId}"`);
+      }
     }
   }
   __name(closeSessionImpl, "closeSessionImpl");
   startSessionReaper();
-  return {
+  const bridgeApi = {
     getDaemonStatusSnapshot() {
       return {
         limits: {
@@ -3234,10 +3406,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(
@@ -3255,13 +3477,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
@@ -3269,9 +3489,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 {
@@ -3290,7 +3514,7 @@ function createAcpSessionBridge(opts) {
                 }
                 try {
                   entry.cancelBroadcast = false;
-                  if (!isRetry) {
+                  if (!isRetry && !isContinue) {
                     echoPromptToSessionBus(
                       entry,
                       promptRequest,
@@ -3332,6 +3556,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)}`
                     );
@@ -3342,12 +3572,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,
@@ -3355,15 +3588,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;
@@ -3374,14 +3614,13 @@ function createAcpSessionBridge(opts) {
           }
         })
       );
-      const promptId = context?.promptId;
       result.then(
         (promptResult) => {
           broadcastTurnComplete(
             entry,
             sessionId,
             promptResult,
-            promptId,
+            pendingEntry.promptId,
             originatorClientId
           );
         },
@@ -3391,7 +3630,7 @@ function createAcpSessionBridge(opts) {
             entry,
             sessionId,
             err,
-            promptId,
+            pendingEntry.promptId,
             originatorClientId
           );
         }
@@ -3401,6 +3640,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(
@@ -3837,6 +4094,54 @@ function createAcpSessionBridge(opts) {
       );
       return response;
     },
+    async isWorkspaceMemoryRememberAvailable() {
+      const info = await ensureChannel();
+      try {
+        const response = await withWorkspaceControl(
+          info,
+          () => withTimeout(
+            Promise.race([
+              info.connection.extMethod(
+                SERVE_CONTROL_EXT_METHODS.workspaceMemoryRememberAvailability,
+                { cwd: boundWorkspace }
+              ),
+              getChannelClosedReject(info)
+            ]),
+            initTimeoutMs,
+            SERVE_CONTROL_EXT_METHODS.workspaceMemoryRememberAvailability
+          )
+        );
+        return response !== null && typeof response === "object" && response["available"] === true;
+      } finally {
+        if (hasNoChannelWork(info)) {
+          await startIdleTimer(info, "workspace memory remember availability");
+        }
+      }
+    },
+    async runWorkspaceMemoryRemember(request) {
+      const info = await ensureChannel();
+      try {
+        const response = await withWorkspaceControl(
+          info,
+          () => withTimeout(
+            Promise.race([
+              info.connection.extMethod(
+                SERVE_CONTROL_EXT_METHODS.workspaceMemoryRemember,
+                { ...request, cwd: boundWorkspace }
+              ),
+              getChannelClosedReject(info)
+            ]),
+            WORKSPACE_MEMORY_REMEMBER_TIMEOUT_MS,
+            SERVE_CONTROL_EXT_METHODS.workspaceMemoryRemember
+          )
+        );
+        return parseWorkspaceMemoryRememberResult(response);
+      } finally {
+        if (hasNoChannelWork(info)) {
+          await startIdleTimer(info, "workspace memory remember");
+        }
+      }
+    },
     async getWorkspaceMcpToolsStatus(serverName) {
       return requestWorkspaceStatus(
         SERVE_STATUS_EXT_METHODS.workspaceMcpTools,
@@ -3942,6 +4247,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,
@@ -4266,6 +4604,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);
@@ -4724,8 +5100,11 @@ function createAcpSessionBridge(opts) {
       } catch {
       }
       entry.events.close();
-      if (ci && ci.sessionIds.size === 0 && ci.pendingRestoreIds.size === 0) {
-        await startIdleTimer(ci, `killSession "${sessionId}"`);
+      if (ci && hasNoChannelWork(ci)) {
+        await reapPendingEmptyChannel(ci);
+        if (!ci.isDying) {
+          await startIdleTimer(ci, `killSession "${sessionId}"`);
+        }
       }
     },
     async detachClient(sessionId, clientId) {
@@ -4812,11 +5191,12 @@ function createAcpSessionBridge(opts) {
       if (shuttingDown) return;
       const ci = await ensureChannel();
       const idleMs = resolvedChannelIdleTimeoutMs();
-      if (idleMs > 0 && ci.sessionIds.size === 0 && ci.pendingRestoreIds.size === 0) {
+      if (idleMs > 0 && hasNoChannelWork(ci)) {
         await startIdleTimer(ci);
       }
     }
   };
+  return bridgeApi;
 }
 __name(createAcpSessionBridge, "createAcpSessionBridge");
 async function withTimeout(p, ms, label) {