@qwen-code/qwen-code 0.19.9-nightly.20260714.9dd8389eb → 0.19.9-preview.0

package/chunks/{server-AF6LNFPK.js → server-VUHSYSUV.js}

@@ -4,7 +4,7 @@ import {
   openQwenAsrRealtimeStream,
   openVoiceStream,
   openVoiceStreamWithRetry
-} from "./chunk-B6ABUBYY.js";
+} from "./chunk-QUJOI7SR.js";
 import {
   MAX_REMEMBER_CONTENT_BYTES,
   createWorkspaceMemoryExtractionErrorLogger,
@@ -16,7 +16,7 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-K3PPUB46.js";
+} from "./chunk-HGG2RRXD.js";
 import {
   SetupGithubError,
   collectSessionData,
@@ -27,9 +27,9 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-7U7UIO5W.js";
-import "./chunk-DKXW66XA.js";
-import "./chunk-YWUK7OS7.js";
+} from "./chunk-BXT6PQ73.js";
+import "./chunk-2FMQQXMM.js";
+import "./chunk-QE2WJ7FS.js";
 import "./chunk-QHTIBUWB.js";
 import "./chunk-L573Z2QZ.js";
 import {
@@ -39,13 +39,17 @@ import {
   ClientMcpSenderRegistry,
   DeviceFlowRegistry,
   MAX_CLIENT_ID_LENGTH,
+  MAX_CONCURRENT_VOICE_SESSIONS,
   MAX_SERVER_NAME_LENGTH,
+  MAX_SKILL_NAME_LENGTH,
   MAX_TOOL_NAME_LENGTH,
   PathMutexRegistry,
   QWEN_CDP_MCP_COMMAND_ENV,
   TooManyActiveDeviceFlowsError,
   UnsupportedDeviceFlowProviderError,
   UpstreamDeviceFlowError,
+  VoiceLeaseAbortError,
+  WorkspaceVoiceCoordinator,
   allowOriginCors,
   bearerAuth,
   brandSecret,
@@ -81,29 +85,29 @@ import {
   setRateLimiter,
   unsafeRevealSecret,
   validateMcpRuntimeServerName
-} from "./chunk-4LJNI7MU.js";
+} from "./chunk-MO7O5722.js";
 import {
   isLoopbackBind
 } from "./chunk-RXFQM6FQ.js";
 import {
   createDaemonStatusProvider
-} from "./chunk-EUNRLYJG.js";
-import "./chunk-DMTQY5GY.js";
+} from "./chunk-X6ODDESK.js";
+import "./chunk-JGO6RFI2.js";
 import "./chunk-E5Z2AVNV.js";
 import {
   createWorkspaceProvidersStatusProvider
-} from "./chunk-CLTWL6HD.js";
+} from "./chunk-ADLYZJYZ.js";
 import {
   getAuthTypeFromEnv,
   resolveCliGenerationConfig
-} from "./chunk-CSACSGAW.js";
+} from "./chunk-ERTHKDKN.js";
 import {
   snapshotProcessEnv
-} from "./chunk-AAWKZ5R7.js";
+} from "./chunk-6JPDCEDB.js";
 import {
   createWorkspaceSkillsStatusProvider
-} from "./chunk-4FPUAYTT.js";
-import "./chunk-DPSWJWZI.js";
+} from "./chunk-KF5MMGG4.js";
+import "./chunk-2W3OOD4W.js";
 import {
   EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
   WorkspaceVoiceError,
@@ -114,14 +118,14 @@ import {
   transcribeWorkspaceVoiceAudio,
   validateWorkspaceVoiceState,
   voiceSettingsScopeToWire
-} from "./chunk-XHW5VUIQ.js";
+} from "./chunk-LHEOLOXU.js";
 import {
   PermissionRulesValidationError,
   buildPermissionSettings,
   isPermissionRuleType,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-S2QXYLUB.js";
+} from "./chunk-JW7OOJC6.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isStreamingVoiceModel,
@@ -129,17 +133,19 @@ import {
   resolveVoiceTranscriptionConfig,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-C4CXFRKY.js";
+} from "./chunk-EJ3KGYWL.js";
 import {
   isVoiceEnabled,
   isVoiceMode,
   readVoiceModel
-} from "./chunk-N7FCSERB.js";
+} from "./chunk-GN5HJJBO.js";
 import "./chunk-FSA7ERJ2.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
-  WorkspaceSettingsPartialPersistError
-} from "./chunk-WL4L7EZH.js";
+  WorkspaceSettingsPartialPersistError,
+  WorkspaceSkillNotFoundError,
+  WorkspaceSkillNotToggleableError
+} from "./chunk-OA4JVLSA.js";
 import {
   createTotalSessionAdmissionController
 } from "./chunk-7R4DPSRA.js";
@@ -152,7 +158,7 @@ import {
   SessionArtifactAuthorizationError,
   SessionArtifactValidationError,
   createAcpSessionBridge
-} from "./chunk-MBP3K324.js";
+} from "./chunk-HCJTURZD.js";
 import "./chunk-PZL23GTM.js";
 import {
   EVENT_SCHEMA_VERSION,
@@ -194,27 +200,27 @@ import {
 import "./chunk-WBL3FJEU.js";
 import {
   loadChannelsConfig
-} from "./chunk-GYGGUR4Q.js";
-import "./chunk-6HHAADP2.js";
+} from "./chunk-FEOBU3FA.js";
+import "./chunk-HRUGYOJN.js";
 import "./chunk-57OAHC2Y.js";
 import {
   parseChannelWebhookConfigLenient
-} from "./chunk-OATTJGPJ.js";
-import "./chunk-ZRKBI3DP.js";
+} from "./chunk-ZP4ZZJJG.js";
+import "./chunk-4QZADKJS.js";
 import "./chunk-V6WHFGST.js";
-import "./chunk-4QOPEEL2.js";
+import "./chunk-VEETSXYX.js";
 import "./chunk-TEGEBB2I.js";
 import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceMemoryStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-PMRH4YYW.js";
+} from "./chunk-FI2WSOWX.js";
 import {
   MAX_REGISTERED_WORKSPACES,
   WorkspaceRegistrationStoreCommittedError,
   WorkspaceRegistrationStoreLimitError,
   workspaceRegistrationId
-} from "./chunk-J2TDDOSM.js";
+} from "./chunk-WMC6HH7Y.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH,
   canonicalizeWorkspace,
@@ -234,7 +240,7 @@ import {
   isChannelWebhookEnqueueError
 } from "./chunk-OJAMDVF5.js";
 import "./chunk-T2NCM2ET.js";
-import "./chunk-SXU3KKNI.js";
+import "./chunk-AU4R7ACM.js";
 import "./chunk-UDXSXLER.js";
 import {
   getDialogSettingKeys,
@@ -245,18 +251,18 @@ import {
   getWritableScopes,
   loadSettings,
   validateSettingValue
-} from "./chunk-T2L6SGQY.js";
+} from "./chunk-7IDCQ35Q.js";
 import "./chunk-RKUWKYED.js";
 import {
   SUPPORTED_LANGUAGES
-} from "./chunk-SE74CIZD.js";
-import "./chunk-WN4D7YCI.js";
+} from "./chunk-AAUZBE5Y.js";
+import "./chunk-A7W4GQRW.js";
 import "./chunk-GOXKNSDZ.js";
 import "./chunk-IDS7MSUP.js";
 import "./chunk-QRUIS3DN.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-X7EBAABW.js";
+} from "./chunk-HJCVNZLQ.js";
 import "./chunk-ALGGS7UH.js";
 import {
   isWithinRoot as isWithinRoot2
@@ -264,7 +270,7 @@ import {
 import {
   writeStderrLine
 } from "./chunk-YUZI3WAC.js";
-import "./chunk-UI3W56WF.js";
+import "./chunk-2J4ZWME4.js";
 import "./chunk-VJNBRRZG.js";
 import {
   ALL_PROVIDERS,
@@ -295,7 +301,6 @@ import {
   WorkspaceMemoryFileTooLargeError,
   WorkspaceMemoryWriteTimeoutError,
   buildUsageDashboard,
-  checkForExtensionUpdate,
   detectLineEnding,
   encodeTextFileContent,
   glob,
@@ -306,22 +311,22 @@ import {
   resolveBranchName,
   resolveProviderProtocol,
   shouldShowStep,
+  stripAnsiAndControl,
   stripTerminalControlSequences,
   watchRepoBranch,
   writeWorkspaceContextFile
-} from "./chunk-SSFDPGFN.js";
-import "./chunk-CU3L64TP.js";
+} from "./chunk-HJUDVNCO.js";
 import "./chunk-H6XPXXMH.js";
 import "./chunk-5M6IDOMF.js";
 import {
   MAX_JOBS,
   nextDurableFireMs
-} from "./chunk-E67NFMF4.js";
+} from "./chunk-BLPMRN4B.js";
 import "./chunk-RCEEXIOO.js";
 import "./chunk-KKRTYONM.js";
 import "./chunk-TV6K2FB4.js";
 import "./chunk-E2UVIFI2.js";
-import "./chunk-6OATMEYN.js";
+import "./chunk-7STBROEV.js";
 import {
   nextFireTime,
   parseCron
@@ -342,7 +347,7 @@ import {
   APPROVAL_MODES,
   SubagentError,
   SubagentErrorCode
-} from "./chunk-TXY2C3D2.js";
+} from "./chunk-F333XEAU.js";
 import "./chunk-6AM5D4ME.js";
 import "./chunk-2Z5UX4KI.js";
 import "./chunk-ARKANCNX.js";
@@ -361,15 +366,15 @@ import {
   recordDaemonHttpRequest,
   recordDaemonHttpResponse,
   withDaemonRequestSpan
-} from "./chunk-T7FSRWQ5.js";
+} from "./chunk-HWTL6MPR.js";
 import "./chunk-4WKAA4KS.js";
 import "./chunk-CR3C7WXL.js";
 import "./chunk-CARU2RR2.js";
 import "./chunk-VGC4I5JJ.js";
 import "./chunk-FBU7WRZI.js";
 import "./chunk-Y66VOBRP.js";
-import "./chunk-WX6SD4IQ.js";
-import "./chunk-2UUAIFQO.js";
+import "./chunk-WTNZ6DXB.js";
+import "./chunk-JGUT3LWZ.js";
 import {
   QwenOAuth2Client,
   QwenOAuthPollError,
@@ -3251,7 +3256,8 @@ async function persistVoiceUpdate(deps, settings, update, clientId, workspaceTru
     throw new Error("workspace voice settings persistence is not available");
   }
   const writes = buildWorkspaceVoiceSettingsWrites(settings, update, {
-    workspaceTrusted
+    workspaceTrusted,
+    ...deps.scopeOverride ? { scopeOverride: deps.scopeOverride } : {}
   });
   if (deps.persistSettings) {
     try {
@@ -3281,6 +3287,9 @@ async function persistVoiceUpdate(deps, settings, update, clientId, workspaceTru
         writeStderrLine(
           `qwen serve: POST /workspace/voice partial persist error (workspace=${deps.boundWorkspace}, committed=${committed.length}/${writes.length}, failedKey=${write.key}, failedScope=${voiceSettingsScopeToWire(write.scope)}): ${err instanceof Error ? err.message : String(err)}`
         );
+        for (const committedWrite of committed) {
+          broadcastVoiceWrite(deps, committedWrite, clientId);
+        }
         throw new WorkspaceSettingsPartialPersistError(
           `Voice settings partial persist failed: committed=${committed.length}/${writes.length}`,
           committed,
@@ -3309,6 +3318,75 @@ function requestAbortSignal2(req, res) {
   return controller.signal;
 }
 __name(requestAbortSignal2, "requestAbortSignal");
+function loadVoiceSettings(deps) {
+  return loadSettings(
+    deps.boundWorkspace,
+    deps.env ? { skipLoadEnvironment: true } : true
+  );
+}
+__name(loadVoiceSettings, "loadVoiceSettings");
+function admissionState(req) {
+  return req.voiceAdmissionState;
+}
+__name(admissionState, "admissionState");
+function admissionLease(req) {
+  return admissionState(req)?.lease;
+}
+__name(admissionLease, "admissionLease");
+function installAdmissionLease(req, res, deps) {
+  const result = deps.acquireVoiceLease?.();
+  if (!result) return true;
+  if (result.kind === "rejected") {
+    if (result.reason === "draining") {
+      sendWorkspaceDraining(res);
+    } else {
+      res.set("Retry-After", "5").status(503).json({
+        error: "Too many voice sessions in progress; try again shortly.",
+        code: "voice_capacity_exceeded"
+      });
+    }
+    return false;
+  }
+  let released = false;
+  const release = /* @__PURE__ */ __name(() => {
+    if (released) return;
+    released = true;
+    result.lease.release();
+  }, "release");
+  const state = {
+    lease: result.lease,
+    operationStarted: false,
+    release
+  };
+  req.voiceAdmissionState = state;
+  const releaseBeforeOperation = /* @__PURE__ */ __name(() => {
+    if (!state.operationStarted) release();
+  }, "releaseBeforeOperation");
+  res.once("finish", releaseBeforeOperation);
+  res.once("close", releaseBeforeOperation);
+  return true;
+}
+__name(installAdmissionLease, "installAdmissionLease");
+function beginVoiceOperation(req) {
+  const state = admissionState(req);
+  if (!state) return;
+  state.operationStarted = true;
+  return state.release;
+}
+__name(beginVoiceOperation, "beginVoiceOperation");
+function combinedAbortSignal(req, res) {
+  const requestSignal = requestAbortSignal2(req, res);
+  const leaseSignal = admissionLease(req)?.signal;
+  return leaseSignal ? AbortSignal.any([requestSignal, leaseSignal]) : requestSignal;
+}
+__name(combinedAbortSignal, "combinedAbortSignal");
+function sendWorkspaceDraining(res) {
+  res.set("Retry-After", "5").status(503).json({
+    error: "Workspace runtime is being removed",
+    code: "workspace_draining"
+  });
+}
+__name(sendWorkspaceDraining, "sendWorkspaceDraining");
 function isSupportedAudioContentType(contentType) {
   return typeof contentType === "string" && (contentType.startsWith("audio/") || contentType === "application/octet-stream");
 }
@@ -3324,164 +3402,326 @@ function readBinaryBody(req) {
   return void 0;
 }
 __name(readBinaryBody, "readBinaryBody");
-function registerWorkspaceVoiceRoutes(app, deps) {
-  const transcribe = deps.transcribe ?? transcribeWorkspaceVoiceAudio;
-  app.get("/workspace/voice", (_req, res) => {
+function sendUnsupportedVoiceContentType(res) {
+  res.status(415).json({
+    error: "Content-Type must be audio/* or application/octet-stream for voice transcription",
+    code: "unsupported_voice_content_type"
+  });
+}
+__name(sendUnsupportedVoiceContentType, "sendUnsupportedVoiceContentType");
+function handleVoiceStatus(res, deps, route) {
+  try {
+    res.status(200).json(
+      buildWorkspaceVoiceStatus(deps.boundWorkspace, loadVoiceSettings(deps))
+    );
+  } catch (err) {
+    writeStderrLine(
+      `qwen serve: ${route} error: ${err instanceof Error ? err.message : String(err)}`
+    );
+    res.status(500).json({
+      error: "Failed to load voice settings",
+      code: "internal_error"
+    });
+  }
+}
+__name(handleVoiceStatus, "handleVoiceStatus");
+async function handleVoiceUpdate(req, res, deps, route) {
+  if (!deps.persistSettings && !deps.persistSetting) {
+    res.status(501).json({
+      error: "Workspace voice settings persistence is not available",
+      code: "not_implemented"
+    });
+    return;
+  }
+  const parsed = parseWorkspaceVoiceUpdateParams(deps.safeBody(req));
+  if ("error" in parsed) {
+    res.status(400).json(parsed);
+    return;
+  }
+  const settings = loadVoiceSettings(deps);
+  try {
+    validateWorkspaceVoiceState(settings, parsed, { env: deps.env });
+  } catch (err) {
+    if (sendVoiceError(res, err)) return;
+    throw err;
+  }
+  const clientId = deps.parseAndValidateClientId(req, res);
+  if (clientId === null) return;
+  try {
+    const workspaceTrusted = getWorkspaceTrustStatus(settings.merged, deps.boundWorkspace).effective.state === "trusted";
+    await persistVoiceUpdate(
+      deps,
+      settings,
+      parsed,
+      clientId,
+      workspaceTrusted
+    );
+  } catch (err) {
+    writeStderrLine(
+      `qwen serve: ${route} persist error (workspace=${deps.boundWorkspace}): ${err instanceof Error ? err.message : String(err)}`
+    );
+    res.status(500).json({
+      error: "Failed to persist voice settings",
+      code: "persist_error"
+    });
+    return;
+  }
+  try {
+    res.status(200).json(
+      buildWorkspaceVoiceStatus(deps.boundWorkspace, loadVoiceSettings(deps))
+    );
+  } catch (err) {
+    writeStderrLine(
+      `qwen serve: ${route} reload error after persist (workspace=${deps.boundWorkspace}): ${err instanceof Error ? err.message : String(err)}`
+    );
+    res.status(500).json({
+      error: "Voice settings persisted but failed to reload",
+      code: "internal_error"
+    });
+  }
+}
+__name(handleVoiceUpdate, "handleVoiceUpdate");
+async function handleVoiceTranscription(req, res, deps, route) {
+  const contentType = normalizeContentType(req);
+  if (!isSupportedAudioContentType(contentType)) {
+    sendUnsupportedVoiceContentType(res);
+    return;
+  }
+  if (admissionLease(req)?.signal.aborted) {
+    sendWorkspaceDraining(res);
+    return;
+  }
+  const clientId = deps.parseAndValidateClientId(req, res);
+  if (clientId === null) return;
+  const data = readBinaryBody(req);
+  if (!data || data.byteLength === 0) {
+    res.status(400).json({
+      error: "Voice audio body must be non-empty binary data",
+      code: "invalid_voice_audio"
+    });
+    return;
+  }
+  const settings = loadVoiceSettings(deps);
+  if (!isVoiceEnabled(settings)) {
+    res.status(403).json({
+      error: "Voice transcription is disabled for this workspace",
+      code: "voice_disabled"
+    });
+    return;
+  }
+  const queryVoiceModel = req.query["voiceModel"];
+  if (queryVoiceModel !== void 0 && typeof queryVoiceModel !== "string") {
+    res.status(400).json({
+      error: "`voiceModel` query parameter must be a string",
+      code: "invalid_voice_model"
+    });
+    return;
+  }
+  const requestedVoiceModel = typeof queryVoiceModel === "string" ? queryVoiceModel.trim() : "";
+  if (requestedVoiceModel && requestedVoiceModel.length > MAX_VOICE_MODEL_LENGTH) {
+    res.status(400).json({
+      error: `\`voiceModel\` exceeds the ${MAX_VOICE_MODEL_LENGTH}-character limit`,
+      code: "invalid_voice_model"
+    });
+    return;
+  }
+  const voiceModel = requestedVoiceModel || readVoiceModel(settings);
+  if (!voiceModel) {
+    res.status(400).json({
+      error: "A valid voiceModel is required before transcription.",
+      code: "voice_model_required"
+    });
+    return;
+  }
+  try {
+    const releaseOperation = beginVoiceOperation(req);
+    let result;
     try {
-      res.status(200).json(
-        buildWorkspaceVoiceStatus(
-          deps.boundWorkspace,
-          loadSettings(deps.boundWorkspace)
-        )
-      );
-    } catch (err) {
-      writeStderrLine(
-        `qwen serve: GET /workspace/voice error: ${err instanceof Error ? err.message : String(err)}`
-      );
-      res.status(500).json({
-        error: "Failed to load voice settings",
-        code: "internal_error"
+      result = await (deps.transcribe ?? transcribeWorkspaceVoiceAudio)({
+        data,
+        mimeType: contentType,
+        voiceModel,
+        settings,
+        workspaceCwd: deps.boundWorkspace,
+        env: deps.env,
+        abortSignal: combinedAbortSignal(req, res)
       });
+    } finally {
+      releaseOperation?.();
+    }
+    if (admissionLease(req)?.signal.aborted) {
+      sendWorkspaceDraining(res);
+      return;
+    }
+    res.status(200).json({ v: 1, ...result });
+  } catch (err) {
+    if (admissionLease(req)?.signal.aborted) {
+      sendWorkspaceDraining(res);
+      return;
     }
+    if (sendVoiceError(res, err)) return;
+    const message = sanitizeVoiceErrorMessage(
+      err instanceof Error ? err.message : String(err)
+    );
+    writeStderrLine(
+      `qwen serve: ${route} error (workspace=${deps.boundWorkspace}): ${message}`
+    );
+    res.status(502).json({
+      error: "Voice transcription failed",
+      code: "voice_transcription_failed"
+    });
+  }
+}
+__name(handleVoiceTranscription, "handleVoiceTranscription");
+function admitVoiceTranscription(req, res, deps) {
+  if (!isSupportedAudioContentType(normalizeContentType(req))) {
+    sendUnsupportedVoiceContentType(res);
+    return false;
+  }
+  return installAdmissionLease(req, res, deps);
+}
+__name(admitVoiceTranscription, "admitVoiceTranscription");
+function voiceAudioBodyParser() {
+  const parse = import_express.default.raw({
+    type: /* @__PURE__ */ __name((req) => isSupportedAudioContentType(
+      req.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase()
+    ), "type"),
+    limit: "10mb"
   });
+  return (req, res, next) => {
+    const signal = admissionLease(req)?.signal;
+    let aborted = signal?.aborted === true;
+    const onAbort = /* @__PURE__ */ __name(() => {
+      aborted = true;
+      if (!res.headersSent) sendWorkspaceDraining(res);
+      const destroyRequest = /* @__PURE__ */ __name(() => {
+        if (!req.destroyed) req.destroy();
+      }, "destroyRequest");
+      if (res.writableFinished) destroyRequest();
+      else {
+        res.once("finish", destroyRequest);
+        res.once("close", destroyRequest);
+      }
+    }, "onAbort");
+    if (aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    parse(req, res, (err) => {
+      signal?.removeEventListener("abort", onAbort);
+      if (aborted || signal?.aborted) {
+        if (!res.headersSent) sendWorkspaceDraining(res);
+        return;
+      }
+      next(err);
+    });
+  };
+}
+__name(voiceAudioBodyParser, "voiceAudioBodyParser");
+function registerWorkspaceVoiceRoutes(app, deps) {
+  app.get(
+    "/workspace/voice",
+    (_req, res) => handleVoiceStatus(res, deps, "GET /workspace/voice")
+  );
   app.post(
     "/workspace/voice",
     deps.mutate({ strict: true }),
     async (req, res) => {
-      if (!deps.persistSettings && !deps.persistSetting) {
-        res.status(501).json({
-          error: "Workspace voice settings persistence is not available",
-          code: "not_implemented"
-        });
-        return;
-      }
-      const parsed = parseWorkspaceVoiceUpdateParams(deps.safeBody(req));
-      if ("error" in parsed) {
-        res.status(400).json(parsed);
-        return;
-      }
-      const settings = loadSettings(deps.boundWorkspace);
-      try {
-        validateWorkspaceVoiceState(settings, parsed);
-      } catch (err) {
-        if (sendVoiceError(res, err)) return;
-        throw err;
-      }
-      const clientId = deps.parseAndValidateClientId(req, res);
-      if (clientId === null) return;
-      try {
-        const workspaceTrusted = getWorkspaceTrustStatus(settings.merged, deps.boundWorkspace).effective.state === "trusted";
-        await persistVoiceUpdate(
-          deps,
-          settings,
-          parsed,
-          clientId,
-          workspaceTrusted
-        );
-      } catch (err) {
-        writeStderrLine(
-          `qwen serve: POST /workspace/voice persist error (workspace=${deps.boundWorkspace}): ${err instanceof Error ? err.message : String(err)}`
-        );
-        res.status(500).json({
-          error: "Failed to persist voice settings",
-          code: "persist_error"
-        });
-        return;
-      }
-      res.status(200).json(
-        buildWorkspaceVoiceStatus(
-          deps.boundWorkspace,
-          loadSettings(deps.boundWorkspace)
-        )
-      );
+      await handleVoiceUpdate(req, res, deps, "POST /workspace/voice");
     }
   );
   app.post(
     "/workspace/voice/transcribe",
     deps.mutate({ strict: true }),
-    import_express.default.raw({
-      type: /* @__PURE__ */ __name((req) => isSupportedAudioContentType(
-        req.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase()
-      ), "type"),
-      limit: "10mb"
-    }),
+    (req, res, next) => {
+      if (admitVoiceTranscription(req, res, deps)) next();
+    },
+    voiceAudioBodyParser(),
     async (req, res) => {
-      const contentType = normalizeContentType(req);
-      if (!isSupportedAudioContentType(contentType)) {
-        res.status(415).json({
-          error: "Content-Type must be audio/* or application/octet-stream for voice transcription",
-          code: "unsupported_voice_content_type"
-        });
-        return;
-      }
-      const audioContentType = contentType;
-      const clientId = deps.parseAndValidateClientId(req, res);
-      if (clientId === null) return;
-      const data = readBinaryBody(req);
-      if (!data || data.byteLength === 0) {
-        res.status(400).json({
-          error: "Voice audio body must be non-empty binary data",
-          code: "invalid_voice_audio"
-        });
-        return;
-      }
-      const settings = loadSettings(deps.boundWorkspace);
-      if (!isVoiceEnabled(settings)) {
-        res.status(403).json({
-          error: "Voice transcription is disabled for this workspace",
-          code: "voice_disabled"
-        });
-        return;
-      }
-      const queryVoiceModel = req.query["voiceModel"];
-      if (queryVoiceModel !== void 0 && typeof queryVoiceModel !== "string") {
-        res.status(400).json({
-          error: "`voiceModel` query parameter must be a string",
-          code: "invalid_voice_model"
-        });
-        return;
-      }
-      const requestedVoiceModel = typeof queryVoiceModel === "string" ? queryVoiceModel.trim() : "";
-      if (requestedVoiceModel && requestedVoiceModel.length > MAX_VOICE_MODEL_LENGTH) {
-        res.status(400).json({
-          error: `\`voiceModel\` exceeds the ${MAX_VOICE_MODEL_LENGTH}-character limit`,
-          code: "invalid_voice_model"
-        });
-        return;
-      }
-      const voiceModel = requestedVoiceModel || readVoiceModel(settings);
-      if (!voiceModel) {
-        res.status(400).json({
-          error: "A valid voiceModel is required before transcription.",
-          code: "voice_model_required"
-        });
-        return;
-      }
-      try {
-        const result = await transcribe({
-          data,
-          mimeType: audioContentType,
-          voiceModel,
-          settings,
-          workspaceCwd: deps.boundWorkspace,
-          abortSignal: requestAbortSignal2(req, res)
-        });
-        res.status(200).json({ v: 1, ...result });
-      } catch (err) {
-        if (sendVoiceError(res, err)) return;
-        const message = err instanceof Error ? sanitizeVoiceErrorMessage(err.message) : sanitizeVoiceErrorMessage(String(err));
-        writeStderrLine(
-          `qwen serve: POST /workspace/voice/transcribe error (workspace=${deps.boundWorkspace}): ${message}`
-        );
-        res.status(502).json({
-          error: "Voice transcription failed",
-          code: "voice_transcription_failed"
-        });
-      }
+      await handleVoiceTranscription(
+        req,
+        res,
+        deps,
+        "POST /workspace/voice/transcribe"
+      );
     }
   );
 }
 __name(registerWorkspaceVoiceRoutes, "registerWorkspaceVoiceRoutes");
+function createRuntimeVoiceDeps(runtime, deps) {
+  const env = runtime.env.mode === "runtime-overlay" ? runtime.env.effectiveEnv ?? {} : runtime.env.effectiveEnv;
+  return {
+    boundWorkspace: runtime.workspaceCwd,
+    mutate: deps.mutate,
+    safeBody: deps.safeBody,
+    persistSetting: deps.persistSetting,
+    persistSettings: deps.persistSettings,
+    transcribe: deps.transcribe,
+    ...env ? { env } : {},
+    scopeOverride: "Workspace" /* Workspace */,
+    acquireVoiceLease: /* @__PURE__ */ __name(() => deps.acquireVoiceLease(runtime), "acquireVoiceLease"),
+    broadcastSettingsChanged: /* @__PURE__ */ __name((key, value, scope, clientId) => {
+      if (runtime.primary) deps.invalidateServeFeaturesCache();
+      runtime.bridge.publishWorkspaceEvent({
+        type: "settings_changed",
+        data: { key, value, scope },
+        originatorClientId: clientId
+      });
+    }, "broadcastSettingsChanged"),
+    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => deps.parseAndValidateClientId(req, res, runtime), "parseAndValidateClientId")
+  };
+}
+__name(createRuntimeVoiceDeps, "createRuntimeVoiceDeps");
+function resolveQualifiedVoiceTarget(req, res, deps, includeDraining = false) {
+  const runtime = includeDraining ? resolveManagedWorkspaceRuntimeFromParam(deps.workspaceRegistry, req, res) : resolveWorkspaceRuntimeFromParam(deps.workspaceRegistry, req, res);
+  if (!runtime || !requireTrustedWorkspaceRuntime(runtime, res)) return;
+  return createRuntimeVoiceDeps(runtime, deps);
+}
+__name(resolveQualifiedVoiceTarget, "resolveQualifiedVoiceTarget");
+function registerWorkspaceQualifiedVoiceRoutes(app, deps) {
+  app.get("/workspaces/:workspace/voice", (req, res) => {
+    const target = resolveQualifiedVoiceTarget(req, res, deps);
+    if (!target) return;
+    handleVoiceStatus(res, target, "GET /workspaces/:workspace/voice");
+  });
+  app.post(
+    "/workspaces/:workspace/voice",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const target = resolveQualifiedVoiceTarget(req, res, deps);
+      if (!target) return;
+      await handleVoiceUpdate(
+        req,
+        res,
+        target,
+        "POST /workspaces/:workspace/voice"
+      );
+    }
+  );
+  app.post(
+    "/workspaces/:workspace/voice/transcribe",
+    deps.mutate({ strict: true }),
+    (req, res, next) => {
+      const target = resolveQualifiedVoiceTarget(req, res, deps, true);
+      if (!target) return;
+      req.voiceRouteDeps = target;
+      if (admitVoiceTranscription(req, res, target)) next();
+    },
+    voiceAudioBodyParser(),
+    async (req, res) => {
+      const target = req.voiceRouteDeps;
+      if (!target) return;
+      await handleVoiceTranscription(
+        req,
+        res,
+        target,
+        "POST /workspaces/:workspace/voice/transcribe"
+      );
+    }
+  );
+}
+__name(registerWorkspaceQualifiedVoiceRoutes, "registerWorkspaceQualifiedVoiceRoutes");
 
 // packages/cli/src/serve/workspace-remember.ts
 init_esbuild_shims();
@@ -5757,7 +5997,8 @@ function createDaemonSubagentManager(boundWorkspace, safeMode = false) {
     getSdkMode: /* @__PURE__ */ __name(() => false, "getSdkMode"),
     getProjectRoot: /* @__PURE__ */ __name(() => boundWorkspace, "getProjectRoot"),
     getActiveExtensions: /* @__PURE__ */ __name(() => [], "getActiveExtensions"),
-    isSafeMode: /* @__PURE__ */ __name(() => safeMode, "isSafeMode")
+    isSafeMode: /* @__PURE__ */ __name(() => safeMode, "isSafeMode"),
+    getAgentsSettings: /* @__PURE__ */ __name(() => ({}), "getAgentsSettings")
   };
   const guarded = new Proxy(stub, {
     get(target, prop) {
@@ -11454,8 +11695,9 @@ function isActiveDrainCorrelation(registry, conn, message) {
   return typeof params?.sessionId === "string" && conn.ownsSession(params.sessionId);
 }
 __name(isActiveDrainCorrelation, "isActiveDrainCorrelation");
-var PLURAL_ACP_WS_PREFIX = "/workspaces/";
+var PLURAL_WS_PREFIX = "/workspaces/";
 var PLURAL_ACP_WS_SUFFIX = "/acp";
+var PLURAL_VOICE_WS_SUFFIX = "/voice/stream";
 function rawRequestPathname(reqUrl) {
   const target = reqUrl ?? "/";
   const qIdx = target.indexOf("?");
@@ -11466,18 +11708,15 @@ function rawRequestPathname(reqUrl) {
   return target.slice(0, end);
 }
 __name(rawRequestPathname, "rawRequestPathname");
-function pluralAcpRawSelector(rawPath) {
+function pluralWorkspaceRawSelector(rawPath, suffix) {
   let p = rawPath;
-  if (p.endsWith(`${PLURAL_ACP_WS_SUFFIX}/`)) {
+  if (p.endsWith(`${suffix}/`)) {
     p = p.slice(0, -1);
   }
-  if (!p.startsWith(PLURAL_ACP_WS_PREFIX) || !p.endsWith(PLURAL_ACP_WS_SUFFIX) || p.length <= PLURAL_ACP_WS_PREFIX.length + PLURAL_ACP_WS_SUFFIX.length) {
+  if (!p.startsWith(PLURAL_WS_PREFIX) || !p.endsWith(suffix) || p.length <= PLURAL_WS_PREFIX.length + suffix.length) {
     return null;
   }
-  const selector = p.slice(
-    PLURAL_ACP_WS_PREFIX.length,
-    p.length - PLURAL_ACP_WS_SUFFIX.length
-  );
+  const selector = p.slice(PLURAL_WS_PREFIX.length, p.length - suffix.length);
   if (selector.length === 0 || selector.includes("/") || selector.includes("\\")) {
     return null;
   }
@@ -11487,7 +11726,7 @@ function pluralAcpRawSelector(rawPath) {
   }
   return selector;
 }
-__name(pluralAcpRawSelector, "pluralAcpRawSelector");
+__name(pluralWorkspaceRawSelector, "pluralWorkspaceRawSelector");
 var CDP_BRIDGE_CLIENT_NAME = "qwen-cdp-bridge";
 var CHROME_DEVTOOLS_MCP_SERVER_NAME = "chrome-devtools";
 var RUNTIME_MCP_RETRY_DELAY_MS = 250;
@@ -12216,9 +12455,11 @@ function mountAcpHttp(app, bridge, opts) {
       const extraRoute = opts.extraWsRoutes?.find(
         (route) => route.path === rawPath
       );
-      const pluralRawSelector = workspaceQualifiedAcpEnabled ? pluralAcpRawSelector(rawPath) : null;
+      const pluralRawSelector = workspaceQualifiedAcpEnabled ? pluralWorkspaceRawSelector(rawPath, PLURAL_ACP_WS_SUFFIX) : null;
       const isPluralAcpShape = pluralRawSelector !== null;
-      if (rawPath !== path15 && !isCdpPath && !extraRoute && !isPluralAcpShape) {
+      const pluralVoiceRawSelector = opts.workspaceVoiceConnection ? pluralWorkspaceRawSelector(rawPath, PLURAL_VOICE_WS_SUFFIX) : null;
+      const isPluralVoiceShape = pluralVoiceRawSelector !== null;
+      if (rawPath !== path15 && !isCdpPath && !extraRoute && !isPluralAcpShape && !isPluralVoiceShape) {
         logReject(`unknown-path ${logSafe(rawPath)}`);
         socket.destroy();
         return;
@@ -12288,6 +12529,42 @@ function mountAcpHttp(app, bridge, opts) {
         });
         return;
       }
+      if (isPluralVoiceShape) {
+        let selector;
+        try {
+          selector = decodeURIComponent(pluralVoiceRawSelector);
+        } catch {
+          logReject("workspace-selector-decode-error");
+          socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
+          socket.destroy();
+          return;
+        }
+        const wsRegistry = opts.workspaceRegistry;
+        const runtime = wsRegistry ? wsRegistry.getManagedByWorkspaceId(selector) ?? (isPortableAbsolutePath(selector) ? resolveManagedWorkspaceRuntimeByPathSelector(
+          wsRegistry,
+          selector
+        ) : void 0) : void 0;
+        if (!runtime) {
+          logReject(`workspace-mismatch ${logSafe(selector)}`);
+          socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
+          socket.destroy();
+          return;
+        }
+        if (!runtime.trusted) {
+          logReject(`untrusted-workspace ${runtime.workspaceId}`);
+          socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
+          socket.destroy();
+          return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => {
+          if (disposed) {
+            ws.close(1012, "Server shutting down");
+            return;
+          }
+          opts.workspaceVoiceConnection(runtime, ws, req);
+        });
+        return;
+      }
       let activeMount = primaryMount;
       if (isPluralAcpShape) {
         let selector;
@@ -12300,7 +12577,10 @@ function mountAcpHttp(app, bridge, opts) {
           return;
         }
         const wsRegistry = opts.workspaceRegistry;
-        const rt = wsRegistry ? wsRegistry.getManagedByWorkspaceId(selector) ?? resolveManagedWorkspaceRuntimeByPathSelector(wsRegistry, selector) : void 0;
+        const rt = wsRegistry ? wsRegistry.getManagedByWorkspaceId(selector) ?? (isPortableAbsolutePath(selector) ? resolveManagedWorkspaceRuntimeByPathSelector(
+          wsRegistry,
+          selector
+        ) : void 0) : void 0;
         if (!rt) {
           logReject(`workspace-mismatch ${logSafe(selector)}`);
           socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
@@ -12909,7 +13189,6 @@ var debugLogger3 = createDebugLogger("VOICE_WS");
 var MAX_BATCH_AUDIO_BYTES = 10 * 1024 * 1024;
 var MAX_QUEUED_AUDIO_BYTES = MAX_BATCH_AUDIO_BYTES * 2;
 var MAX_CONNECTION_MS = 6 * 6e4;
-var MAX_CONCURRENT_VOICE_SESSIONS = 8;
 var GENERIC_TRANSCRIPTION_ERROR = "Voice transcription failed. Please try again.";
 var NO_VOICE_MODEL_ERROR = "No voice model is configured for this workspace.";
 var SAMPLE_RATE = 16e3;
@@ -12932,7 +13211,7 @@ function encodeWav(pcm) {
   return Buffer.concat([header, Buffer.from(pcm)]);
 }
 __name(encodeWav, "encodeWav");
-async function defaultOpenStream(ctx, callbacks) {
+async function defaultOpenStream(ctx, callbacks, abortSignal) {
   try {
     const cfg = resolveVoiceStreamConfig({
       config: ctx.models,
@@ -12940,9 +13219,10 @@ async function defaultOpenStream(ctx, callbacks) {
       voiceModel: ctx.voiceModel,
       env: ctx.env
     });
-    await assertVoiceBaseUrlNetworkAllowed(cfg);
+    await assertVoiceBaseUrlNetworkAllowed(cfg, void 0, abortSignal);
     return await openVoiceStreamWithRetry(
-      () => cfg.transport === "qwen-asr-realtime" ? openQwenAsrRealtimeStream(cfg, callbacks) : openVoiceStream(cfg, callbacks)
+      () => cfg.transport === "qwen-asr-realtime" ? openQwenAsrRealtimeStream(cfg, callbacks, { abortSignal }) : openVoiceStream(cfg, callbacks, { abortSignal }),
+      { abortSignal }
     );
   } catch (error2) {
     debugLogger3.debug(`[voice-ws] stream open error: ${errMessage(error2)}`);
@@ -12950,14 +13230,15 @@ async function defaultOpenStream(ctx, callbacks) {
   }
 }
 __name(defaultOpenStream, "defaultOpenStream");
-function defaultTranscribe(ctx, pcm) {
+function defaultTranscribe(ctx, pcm, abortSignal) {
   return transcribeVoiceAudio(
     { data: encodeWav(pcm), mimeType: "audio/wav" },
     {
       config: ctx.models,
       settings: ctx.settings,
       voiceModel: ctx.voiceModel,
-      env: ctx.env
+      env: ctx.env,
+      abortSignal
     }
   ).catch((error2) => {
     debugLogger3.debug(
@@ -12971,6 +13252,10 @@ function errMessage(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
 __name(errMessage, "errMessage");
+function voiceLeaseCloseReason(signal) {
+  return signal.reason instanceof VoiceLeaseAbortError && signal.reason.kind === "daemon_shutdown" ? "Server shutting down" : "Workspace removed";
+}
+__name(voiceLeaseCloseReason, "voiceLeaseCloseReason");
 function voiceConfigErrorMessage(error2) {
   const message = errMessage(error2);
   return message === NO_VOICE_MODEL_ERROR ? message : GENERIC_TRANSCRIPTION_ERROR;
@@ -13001,15 +13286,35 @@ function createVoiceWsConnectionHandler(boundWorkspace, deps = {}) {
   const openStream = deps.openStream ?? defaultOpenStream;
   const transcribe = deps.transcribe ?? defaultTranscribe;
   let activeSessions = 0;
-  return (ws) => {
+  const acquireLocalLease = /* @__PURE__ */ __name(() => {
     if (activeSessions >= MAX_CONCURRENT_VOICE_SESSIONS) {
-      writeStderrLine(
-        `qwen serve: voice websocket rejected; activeSessions=${activeSessions}`
-      );
-      try {
-        ws.send(
-          JSON.stringify({
-            type: "error",
+      return { kind: "rejected", reason: "capacity" };
+    }
+    activeSessions++;
+    const controller = new AbortController();
+    let released = false;
+    const lease = {
+      signal: controller.signal,
+      release: /* @__PURE__ */ __name(() => {
+        if (released) return;
+        released = true;
+        activeSessions--;
+      }, "release")
+    };
+    return { kind: "admitted", lease };
+  }, "acquireLocalLease");
+  return (ws) => {
+    const admission = (deps.acquireVoiceLease ?? acquireLocalLease)();
+    if (admission.kind === "rejected") {
+      writeStderrLine("qwen serve: voice websocket rejected");
+      try {
+        if (admission.reason === "draining") {
+          ws.close(1012, "Workspace removed");
+          return;
+        }
+        ws.send(
+          JSON.stringify({
+            type: "error",
             message: "Too many voice sessions in progress; try again shortly."
           })
         );
@@ -13018,18 +13323,14 @@ function createVoiceWsConnectionHandler(boundWorkspace, deps = {}) {
       }
       return;
     }
-    activeSessions++;
-    writeStderrLine(
-      `qwen serve: voice websocket accepted; activeSessions=${activeSessions}`
-    );
+    const lease = admission.lease;
+    writeStderrLine("qwen serve: voice websocket accepted");
     let released = false;
     const releaseSlot = /* @__PURE__ */ __name(() => {
       if (!released) {
         released = true;
-        activeSessions--;
-        writeStderrLine(
-          `qwen serve: voice websocket slot released; activeSessions=${activeSessions}`
-        );
+        lease.release();
+        writeStderrLine("qwen serve: voice websocket slot released");
       }
     }, "releaseSlot");
     let state = "idle";
@@ -13040,6 +13341,7 @@ function createVoiceWsConnectionHandler(boundWorkspace, deps = {}) {
     let bufferedBytes = 0;
     let queuedBytes = 0;
     let pendingOperations = 0;
+    const operationController = new AbortController();
     let chain = Promise.resolve();
     const hardTimer = setTimeout(() => {
       if (state !== "closed") fail("Voice session exceeded the time limit.");
@@ -13060,6 +13362,9 @@ function createVoiceWsConnectionHandler(boundWorkspace, deps = {}) {
     function cleanup() {
       state = "closed";
       clearTimeout(hardTimer);
+      if (!operationController.signal.aborted) {
+        operationController.abort(new Error("Voice connection closed."));
+      }
       if (session) {
         try {
           session.abort();
@@ -13073,6 +13378,19 @@ function createVoiceWsConnectionHandler(boundWorkspace, deps = {}) {
       queuedBytes = 0;
     }
     __name(cleanup, "cleanup");
+    lease.signal.addEventListener(
+      "abort",
+      () => {
+        if (state === "closed") return;
+        cleanup();
+        try {
+          ws.close(1012, voiceLeaseCloseReason(lease.signal));
+        } catch {
+        }
+        releaseSlotWhenIdle();
+      },
+      { once: true }
+    );
     function fail(message) {
       if (state === "closed") return;
       writeStderrLine(`qwen serve: voice websocket failed: ${message}`);
@@ -13111,7 +13429,7 @@ function createVoiceWsConnectionHandler(boundWorkspace, deps = {}) {
             fail(GENERIC_TRANSCRIPTION_ERROR);
           }, "onError")
         };
-        const opening = openStream(ctx, callbacks);
+        const opening = openStream(ctx, callbacks, operationController.signal);
         sessionPromise = opening;
         const opened = await opening;
         if (state === "closed") {
@@ -13143,11 +13461,16 @@ function createVoiceWsConnectionHandler(boundWorkspace, deps = {}) {
           }
         }
       } else if (pcmChunks.length > 0) {
-        transcript = await transcribe(ctx, Buffer.concat(pcmChunks));
+        transcript = await transcribe(
+          ctx,
+          Buffer.concat(pcmChunks),
+          operationController.signal
+        );
       }
       sendJson({ type: "final", text: transcript });
       writeStderrLine("qwen serve: voice websocket finalized successfully");
       cleanup();
+      releaseSlotWhenIdle();
       try {
         ws.close(1e3, "done");
       } catch {
@@ -14627,76 +14950,148 @@ __name(registerWorkspaceAuthRoutes, "registerWorkspaceAuthRoutes");
 
 // packages/cli/src/serve/routes/workspace-extensions.ts
 init_esbuild_shims();
+import * as crypto2 from "node:crypto";
+
+// packages/cli/src/serve/extension-operation-scheduler.ts
+init_esbuild_shims();
+function abortReason(signal) {
+  return signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+__name(abortReason, "abortReason");
+function createFifoTaskQueue(limit) {
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new Error(
+      `Task queue limit must be a positive integer, got ${limit}.`
+    );
+  }
+  let active = 0;
+  const queued = [];
+  const pump = /* @__PURE__ */ __name(() => {
+    while (active < limit && queued.length > 0) {
+      const item = queued.shift();
+      const removeAbortListener = item.removeAbortListener;
+      item.removeAbortListener = void 0;
+      removeAbortListener?.();
+      if (item.signal?.aborted) {
+        item.reject(abortReason(item.signal));
+        continue;
+      }
+      active += 1;
+      try {
+        item.onStart?.();
+      } catch (error2) {
+        active -= 1;
+        item.reject(error2);
+        continue;
+      }
+      let released = false;
+      const release = /* @__PURE__ */ __name(() => {
+        if (released) return;
+        released = true;
+        active -= 1;
+        pump();
+      }, "release");
+      Promise.resolve().then(() => item.task(release)).then(item.resolve, item.reject).finally(release);
+    }
+  }, "pump");
+  const enqueue = /* @__PURE__ */ __name((task, options = {}) => new Promise((resolve5, reject) => {
+    if (options.signal?.aborted) {
+      reject(abortReason(options.signal));
+      return;
+    }
+    const item = {
+      task,
+      ...options.signal ? { signal: options.signal } : {},
+      ...options.onStart ? { onStart: options.onStart } : {},
+      resolve: resolve5,
+      reject
+    };
+    if (options.signal) {
+      const onAbort = /* @__PURE__ */ __name(() => {
+        const index = queued.indexOf(item);
+        if (index < 0) return;
+        queued.splice(index, 1);
+        item.removeAbortListener?.();
+        reject(abortReason(options.signal));
+      }, "onAbort");
+      options.signal.addEventListener("abort", onAbort, { once: true });
+      item.removeAbortListener = () => options.signal?.removeEventListener("abort", onAbort);
+    }
+    queued.push(item);
+    pump();
+  }), "enqueue");
+  const run = /* @__PURE__ */ __name((task, options) => enqueue(async () => await task(), options), "run");
+  return { run, runUntilReleased: enqueue };
+}
+__name(createFifoTaskQueue, "createFifoTaskQueue");
+
+// packages/cli/src/serve/routes/workspace-extensions-controller.ts
+init_esbuild_shims();
 import * as crypto from "node:crypto";
-function registerWorkspaceExtensionRoutes(app, deps) {
-  const {
-    boundWorkspace,
-    bridge,
-    workspace,
-    mutate,
-    safeBody: safeBody2,
-    sendBridgeError: sendBridgeError2
-  } = deps;
+var MAX_UNFINISHED_EXTENSION_OPERATIONS = 10;
+var sanitizeDaemonMessage = /* @__PURE__ */ __name((message) => redactUrlCredentials(stripAnsiAndControl(message)), "sanitizeDaemonMessage");
+var redactExtensionDisplaySource = /* @__PURE__ */ __name((source) => {
+  const redacted = redactUrlCredentials(source);
+  if (/^[A-Za-z]:[\\/]/.test(redacted)) return redacted;
+  try {
+    const url = new URL(redacted);
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return redacted;
+  }
+}, "redactExtensionDisplaySource");
+var EXTENSION_PREPARATION_CONCURRENCY = 2;
+var EXTENSION_REFRESH_TIMEOUT_MS = 3e4;
+var RECONCILE_SLOW_MS = 3e4;
+var EXTENSION_QUEUE_FULL_MESSAGE = "Extension operation queue is full";
+function createExtensionsController(deps) {
+  const { boundWorkspace, bridge, workspace } = deps;
   const maxExtensionOperationHistory = deps.maxExtensionOperationHistory ?? 100;
-  const buildWorkspaceCtx = createBuildWorkspaceCtx(boundWorkspace);
-  let extensionInstallQueue = Promise.resolve();
-  let extensionInstallQueueDepth = 0;
-  const MAX_EXTENSION_INSTALL_QUEUE_DEPTH = 10;
-  const enqueueExtensionInstall = /* @__PURE__ */ __name(async (run) => {
-    if (extensionInstallQueueDepth >= MAX_EXTENSION_INSTALL_QUEUE_DEPTH) {
-      throw new Error("Extension operation queue is full");
-    }
-    extensionInstallQueueDepth += 1;
-    const next = extensionInstallQueue.then(run, run).finally(() => {
-      extensionInstallQueueDepth -= 1;
-    });
-    extensionInstallQueue = next.catch(() => void 0);
-    return next;
-  }, "enqueueExtensionInstall");
-  const EXTENSION_MUTATION_TIMEOUT_MS = 10 * 6e4;
-  const EXTENSION_REFRESH_TIMEOUT_MS = 3e4;
-  const isExtensionQueueFullError = /* @__PURE__ */ __name((err) => err instanceof Error && err.message === "Extension operation queue is full", "isExtensionQueueFullError");
-  const sendExtensionQueueFull = /* @__PURE__ */ __name((res) => {
-    res.status(429).json({
-      error: "Extension operation queue is full",
-      code: "extension_queue_full"
-    });
-  }, "sendExtensionQueueFull");
-  const withExtensionTimeout = /* @__PURE__ */ __name(async (promise, timeoutMs, operation) => await new Promise((resolve5, reject) => {
-    const timeout = setTimeout(() => {
-      reject(new Error(`${operation} timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-    promise.then(
-      (value) => {
-        clearTimeout(timeout);
-        resolve5(value);
-      },
-      (err) => {
-        clearTimeout(timeout);
-        reject(err);
-      }
-    );
-  }), "withExtensionTimeout");
-  const createExtensionManager = /* @__PURE__ */ __name(() => new ExtensionManager({
-    workspaceDir: boundWorkspace,
-    isWorkspaceTrusted: getWorkspaceTrustStatus(
-      loadSettings(boundWorkspace).merged,
-      boundWorkspace
-    ).effective.state === "trusted",
+  const preparationQueue = createFifoTaskQueue(
+    EXTENSION_PREPARATION_CONCURRENCY
+  );
+  const commitQueue = createFifoTaskQueue(1);
+  let unfinishedOperationCount = 0;
+  const acquireOperationSlot = /* @__PURE__ */ __name((res) => {
+    if (unfinishedOperationCount >= MAX_UNFINISHED_EXTENSION_OPERATIONS) {
+      res.status(429).json({
+        error: EXTENSION_QUEUE_FULL_MESSAGE,
+        code: "extension_queue_full"
+      });
+      return void 0;
+    }
+    unfinishedOperationCount += 1;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      unfinishedOperationCount -= 1;
+    };
+  }, "acquireOperationSlot");
+  const createExtensionManager = /* @__PURE__ */ __name((workspaceDir = boundWorkspace, trustedOverride, interactions) => new ExtensionManager({
+    workspaceDir,
+    isWorkspaceTrusted: trustedOverride ?? getWorkspaceTrustStatus(loadSettings(workspaceDir).merged, workspaceDir).effective.state === "trusted",
     requestConsent: /* @__PURE__ */ __name(() => Promise.resolve(), "requestConsent"),
-    requestSetting: /* @__PURE__ */ __name(async (setting) => {
+    networkPolicy: "public",
+    requestSetting: interactions?.requestSetting ?? (async (setting) => {
       throw new Error(
         `Extension setting "${setting.envVar}" requires interactive configuration and is not supported over the daemon install endpoint.`
       );
-    }, "requestSetting"),
-    requestChoicePlugin: /* @__PURE__ */ __name(async () => {
+    }),
+    requestChoicePlugin: interactions?.requestChoicePlugin ?? (async () => {
       throw new Error(
         "Marketplace plugin selection is not supported over the daemon install endpoint. Specify a plugin name in the source."
       );
-    }, "requestChoicePlugin")
+    })
   }), "createExtensionManager");
-  const validateExtensionMutationClient = /* @__PURE__ */ __name((req, res, route, opts = {}) => {
-    const clientId = parseAndValidateWorkspaceClientId(req, res, bridge);
+  const validateExtensionMutationClient = /* @__PURE__ */ __name((req, res, opts = {}) => {
+    const clientId = parseAndValidateWorkspaceClientId(
+      req,
+      res,
+      opts.bridges ?? bridge
+    );
     if (clientId === null) return false;
     if (clientId === void 0 && opts.requireClientId !== false) {
       res.status(400).json({
@@ -14705,98 +15100,25 @@ function registerWorkspaceExtensionRoutes(app, deps) {
       });
       return false;
     }
-    buildWorkspaceCtx(route, clientId);
     return true;
   }, "validateExtensionMutationClient");
-  const parseExtensionScope = /* @__PURE__ */ __name((body, res) => {
-    const scope = body["scope"];
-    if (scope !== "user" && scope !== "workspace") {
-      res.status(400).json({ error: '`scope` must be either "user" or "workspace"' });
-      return null;
-    }
-    return scope === "user" ? "User" /* User */ : "Workspace" /* Workspace */;
-  }, "parseExtensionScope");
-  const parseExtensionRegistryUrl = /* @__PURE__ */ __name((value, res) => {
-    let parsed;
-    try {
-      parsed = new URL(value);
-    } catch {
-      res.status(400).json({ error: "`registry` must be a valid URL" });
-      return null;
-    }
-    if (parsed.protocol !== "https:") {
-      res.status(400).json({ error: "`registry` must use https" });
-      return null;
-    }
-    if (parsed.username || parsed.password) {
-      res.status(400).json({ error: "`registry` must not include credentials" });
-      return null;
-    }
-    if (isBlockedAuthProviderHost(parsed.hostname)) {
-      res.status(400).json({ error: "`registry` host is not allowed" });
-      return null;
-    }
-    return parsed.toString().replace(/\/$/, "");
-  }, "parseExtensionRegistryUrl");
-  const parsePotentialSourceUrl = /* @__PURE__ */ __name((source) => {
-    if (/^[a-zA-Z]:[\\/]/.test(source)) return null;
-    try {
-      return new URL(source);
-    } catch {
-      const sshMatch = /^(?:[^@]+@)?(\[[^\]]+\]|[^:]+):/.exec(source);
-      if (!sshMatch?.[1]) return null;
-      try {
-        return new URL(`ssh://${sshMatch[1]}`);
-      } catch {
-        return null;
-      }
-    }
-  }, "parsePotentialSourceUrl");
-  const validateExtensionSourceHost = /* @__PURE__ */ __name((source, res) => {
-    const parsed = parsePotentialSourceUrl(source);
-    if (!parsed) return true;
-    if (parsed.username || parsed.password) {
-      res.status(400).json({ error: "`source` must not include credentials" });
-      return false;
-    }
-    if (isBlockedAuthProviderHost(parsed.hostname)) {
-      res.status(400).json({ error: "`source` host is not allowed" });
-      return false;
-    }
-    if (parsed.protocol !== "https:" && parsed.protocol !== "ssh:") {
-      res.status(400).json({ error: "`source` must use https or ssh" });
-      return false;
-    }
-    return true;
-  }, "validateExtensionSourceHost");
-  const validateExtensionSourceMetadata = /* @__PURE__ */ __name((installMetadata) => {
-    if (installMetadata.type !== "git") return true;
-    const parsed = parsePotentialSourceUrl(installMetadata.source);
-    return !!parsed && (parsed.protocol === "https:" || parsed.protocol === "ssh:") && !isBlockedAuthProviderHost(parsed.hostname);
-  }, "validateExtensionSourceMetadata");
-  const findLoadedExtension = /* @__PURE__ */ __name((extensionManager, extensionName) => {
-    const requested = extensionName.toLowerCase();
-    const extensions = extensionManager.getLoadedExtensions();
-    const byName = extensions.find(
-      (extension) => extension.name.toLowerCase() === requested
-    );
-    if (byName) return byName;
-    if (!extensionName.includes("://") && !extensionName.includes("@")) {
-      return void 0;
-    }
-    return extensions.find(
-      (extension) => extension.installMetadata?.source?.toLowerCase() === requested
-    );
-  }, "findLoadedExtension");
   const extensionOperations = /* @__PURE__ */ new Map();
-  const isTerminalExtensionOperation = /* @__PURE__ */ __name((operation) => operation.status !== "queued" && operation.status !== "running", "isTerminalExtensionOperation");
+  const isTerminalExtensionOperation = /* @__PURE__ */ __name((operation) => operation.status !== "queued" && operation.status !== "running" && operation.status !== "waiting_for_input", "isTerminalExtensionOperation");
   const redactExtensionOperationResult = /* @__PURE__ */ __name((event) => ({
     ...event,
-    ...event.source ? { source: redactUrlCredentials(event.source) } : {}
+    ...event.source ? { source: redactExtensionDisplaySource(event.source) } : {}
   }), "redactExtensionOperationResult");
-  const rememberExtensionOperation = /* @__PURE__ */ __name((operation) => {
-    extensionOperations.set(operation.operationId, operation);
-    while (extensionOperations.size > maxExtensionOperationHistory) {
+  const bridgeMutationEvent = /* @__PURE__ */ __name((event) => {
+    const redacted = redactExtensionOperationResult(event);
+    if (event.status === "checked" || event.status === "refreshed") {
+      const { status: _status, states: _states, ...bridgeEvent } = redacted;
+      return bridgeEvent;
+    }
+    return redacted;
+  }, "bridgeMutationEvent");
+  const pruneExtensionOperations = /* @__PURE__ */ __name(() => {
+    const terminalCount = /* @__PURE__ */ __name(() => [...extensionOperations.values()].filter(isTerminalExtensionOperation).length, "terminalCount");
+    while (terminalCount() > maxExtensionOperationHistory) {
       let evicted = false;
       for (const [id, storedOperation] of extensionOperations) {
         if (!isTerminalExtensionOperation(storedOperation)) continue;
@@ -14806,6 +15128,10 @@ function registerWorkspaceExtensionRoutes(app, deps) {
       }
       if (!evicted) break;
     }
+  }, "pruneExtensionOperations");
+  const rememberExtensionOperation = /* @__PURE__ */ __name((operation) => {
+    extensionOperations.set(operation.operationId, operation);
+    pruneExtensionOperations();
   }, "rememberExtensionOperation");
   const updateExtensionOperation = /* @__PURE__ */ __name((operationId, patch) => {
     const current = extensionOperations.get(operationId);
@@ -14815,12 +15141,43 @@ function registerWorkspaceExtensionRoutes(app, deps) {
       ...patch,
       updatedAt: Date.now()
     });
+    pruneExtensionOperations();
   }, "updateExtensionOperation");
-  const runQueuedExtensionMutation = /* @__PURE__ */ __name((operation, failureContext, res, run) => {
-    if (extensionInstallQueueDepth >= MAX_EXTENSION_INSTALL_QUEUE_DEPTH) {
-      sendExtensionQueueFull(res);
-      return;
+  let extensionsStatusCache;
+  const refreshExtensionsForAllSessions = /* @__PURE__ */ __name(async () => {
+    const queueAbort = new AbortController();
+    let releaseCommitLane;
+    const refresh = commitQueue.runUntilReleased(
+      async (release) => {
+        releaseCommitLane = release;
+        extensionsStatusCache = void 0;
+        return await workspace.refreshExtensionsForAllSessions();
+      },
+      { signal: queueAbort.signal }
+    );
+    let timer;
+    try {
+      return await Promise.race([
+        refresh,
+        new Promise((_resolve, reject) => {
+          timer = setTimeout(() => {
+            const error2 = new Error(
+              `extension refresh timed out after ${EXTENSION_REFRESH_TIMEOUT_MS}ms`
+            );
+            releaseCommitLane?.();
+            queueAbort.abort(error2);
+            reject(error2);
+          }, EXTENSION_REFRESH_TIMEOUT_MS);
+          timer.unref?.();
+        })
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
     }
+  }, "refreshExtensionsForAllSessions");
+  const runQueuedExtensionMutation = /* @__PURE__ */ __name((operation, failureContext, res, run, options = {}) => {
+    const releaseOperationSlot = acquireOperationSlot(res);
+    if (!releaseOperationSlot) return;
     const operationId = crypto.randomUUID();
     const now = Date.now();
     rememberExtensionOperation({
@@ -14830,76 +15187,391 @@ function registerWorkspaceExtensionRoutes(app, deps) {
       status: "queued",
       createdAt: now,
       updatedAt: now,
-      ...failureContext.source ? { source: redactUrlCredentials(failureContext.source) } : {},
+      ...failureContext.source ? { source: redactExtensionDisplaySource(failureContext.source) } : {},
       ...failureContext.name ? { name: failureContext.name } : {}
     });
-    res.status(202).json({ accepted: true, operationId });
-    void enqueueExtensionInstall(async () => {
+    const operationBasePath = options.operationBasePath ?? "/workspace/extensions/operations";
+    try {
+      res.status(202).location(`${operationBasePath}/${operationId}`).set("Retry-After", "1").json({ accepted: true, operationId });
+    } catch {
+      extensionOperations.delete(operationId);
+      releaseOperationSlot();
+      return;
+    }
+    void (async () => {
+      let deadline;
+      let committedGeneration;
+      let reconciliationReservation;
+      let mutationEvent;
+      const commitWarnings = [];
+      const runReconciliation = /* @__PURE__ */ __name(async (task) => {
+        const reservation = reconciliationReservation;
+        reconciliationReservation = void 0;
+        return reservation ? await reservation.run(task) : await task();
+      }, "runReconciliation");
       try {
-        updateExtensionOperation(operationId, { status: "running" });
-        const extensionManager = createExtensionManager();
+        updateExtensionOperation(operationId, {
+          status: "running",
+          phase: "preparing"
+        });
+        const extensionManager = options.manager ?? options.createManager?.(operationId) ?? createExtensionManager();
+        const deadlineController = new AbortController();
+        let deadlineStarted = false;
+        const startDeadline = /* @__PURE__ */ __name(() => {
+          if (deadlineStarted) return;
+          deadlineStarted = true;
+          if (options.deadlineMs) {
+            deadline = setTimeout(() => {
+              const error2 = new Error(
+                `Extension ${operation} exceeded its ${options.deadlineMs}ms preparation deadline.`
+              );
+              error2.code = "extension_prepare_timeout";
+              deadlineController.abort(error2);
+            }, options.deadlineMs);
+            deadline.unref?.();
+          }
+        }, "startDeadline");
+        let pendingPreparations = 0;
+        let activePreparations = 0;
+        const updatePreparationState = /* @__PURE__ */ __name(() => {
+          if (activePreparations > 0) {
+            updateExtensionOperation(operationId, {
+              status: "running",
+              phase: "preparing"
+            });
+          } else if (pendingPreparations > 0) {
+            updateExtensionOperation(operationId, {
+              status: "queued",
+              phase: void 0
+            });
+          }
+        }, "updatePreparationState");
+        const context = {
+          prepare: /* @__PURE__ */ __name(async (task) => {
+            pendingPreparations += 1;
+            let started = false;
+            updatePreparationState();
+            try {
+              const prepared = await preparationQueue.run(
+                async () => {
+                  try {
+                    return await task(deadlineController.signal);
+                  } finally {
+                    activePreparations -= 1;
+                    updatePreparationState();
+                  }
+                },
+                {
+                  signal: deadlineController.signal,
+                  onStart: /* @__PURE__ */ __name(() => {
+                    startDeadline();
+                    started = true;
+                    pendingPreparations -= 1;
+                    activePreparations += 1;
+                    updatePreparationState();
+                  }, "onStart")
+                }
+              );
+              deadlineController.signal.throwIfAborted();
+              return prepared;
+            } catch (error2) {
+              if (!started) {
+                pendingPreparations -= 1;
+                updatePreparationState();
+              }
+              if (deadlineController.signal.aborted) {
+                throw deadlineController.signal.reason;
+              }
+              throw error2;
+            }
+          }, "prepare"),
+          commit: /* @__PURE__ */ __name(async (task) => {
+            updateExtensionOperation(operationId, {
+              status: "running",
+              phase: "committing"
+            });
+            const result = await commitQueue.runUntilReleased(
+              async (release) => await task((generation) => {
+                reconciliationReservation ??= options.reserveRuntimeReconciliation?.();
+                committedGeneration = generation;
+                release();
+              })
+            );
+            if (committedGeneration === void 0) {
+              reconciliationReservation ??= options.reserveRuntimeReconciliation?.();
+              committedGeneration = result.generation;
+            }
+            for (const warning of result.warnings ?? []) {
+              commitWarnings.push({
+                workspaceCwd: boundWorkspace,
+                code: warning.code,
+                error: sanitizeDaemonMessage(warning.error).slice(0, 500)
+              });
+            }
+            return result;
+          }, "commit")
+        };
         await extensionManager.refreshCache();
-        const event = await withExtensionTimeout(
-          run(extensionManager),
-          EXTENSION_MUTATION_TIMEOUT_MS,
-          `extension ${operation}`
+        const event = await run(
+          extensionManager,
+          deadlineController.signal,
+          context,
+          operationId
         );
+        mutationEvent = event;
+        if (deadline) clearTimeout(deadline);
         extensionsStatusCache = void 0;
-        workspace.invalidateWorkspaceSkillsStatus();
-        try {
-          const result = await bridge.refreshExtensionsForAllSessions(event);
+        if (options.skipRefresh || event.updated === false) {
+          reconciliationReservation?.release();
+          reconciliationReservation = void 0;
           updateExtensionOperation(operationId, {
-            status: "succeeded",
-            result: {
-              ...redactExtensionOperationResult(event),
-              refreshed: result.refreshed,
-              failed: result.failed
-            }
+            status: commitWarnings.length > 0 ? "succeeded_with_warnings" : "succeeded",
+            phase: void 0,
+            result: redactExtensionOperationResult(event),
+            ...commitWarnings.length > 0 ? { warnings: commitWarnings } : {}
           });
-          writeStderrLine(
-            `qwen serve: extensions ${operation}: refreshed ${result.refreshed} session(s), ${result.failed} failed`
-          );
-        } catch (refreshErr) {
-          const message = redactUrlCredentials(
-            refreshErr instanceof Error ? refreshErr.message : String(refreshErr)
+          return;
+        }
+        if (committedGeneration === void 0) {
+          committedGeneration = (await extensionManager.getExtensionStoreSnapshot()).generation;
+          reconciliationReservation ??= options.reserveRuntimeReconciliation?.();
+        }
+        updateExtensionOperation(operationId, {
+          status: "running",
+          phase: "reconciling"
+        });
+        const refreshTargets = typeof options.refreshRuntimes === "function" ? options.refreshRuntimes() : options.refreshRuntimes;
+        if (refreshTargets) {
+          const results = await runReconciliation(
+            async () => await Promise.all(
+              refreshTargets.map(async (runtime) => {
+                const startedAt = Date.now();
+                try {
+                  runtime.workspaceService.invalidateWorkspaceSkillsStatus();
+                  return {
+                    status: "fulfilled",
+                    result: await runtime.bridge.refreshExtensionsForAllSessions(
+                      bridgeMutationEvent(event)
+                    ),
+                    elapsedMs: Date.now() - startedAt
+                  };
+                } catch (reason) {
+                  return {
+                    status: "rejected",
+                    reason,
+                    elapsedMs: Date.now() - startedAt
+                  };
+                }
+              })
+            )
           );
+          let refreshed = 0;
+          let failed = 0;
+          const warnings = [
+            ...commitWarnings
+          ];
+          for (let index = 0; index < results.length; index += 1) {
+            const settled = results[index];
+            const runtime = refreshTargets[index];
+            if (settled.status === "fulfilled") {
+              refreshed += settled.result.refreshed;
+              failed += settled.result.failed;
+              if (settled.result.failed > 0) {
+                warnings.push({
+                  workspaceId: runtime.workspaceId,
+                  workspaceCwd: runtime.workspaceCwd,
+                  error: `${settled.result.failed} session refresh(es) failed`
+                });
+              } else {
+                options.onRuntimeReconciled?.(runtime, committedGeneration);
+              }
+            } else {
+              failed += 1;
+              const message = sanitizeDaemonMessage(
+                settled.reason instanceof Error ? settled.reason.message : String(settled.reason)
+              );
+              warnings.push({
+                workspaceId: runtime.workspaceId,
+                workspaceCwd: runtime.workspaceCwd,
+                error: message.slice(0, 500)
+              });
+              try {
+                runtime.bridge.broadcastExtensionsChanged({
+                  ...bridgeMutationEvent(event),
+                  refreshed: 0,
+                  failed: 1,
+                  error: message.slice(0, 500)
+                });
+              } catch {
+              }
+            }
+            if (settled.elapsedMs > RECONCILE_SLOW_MS) {
+              warnings.push({
+                workspaceId: runtime.workspaceId,
+                workspaceCwd: runtime.workspaceCwd,
+                code: "reconcile_slow",
+                error: `Runtime reconciliation took ${settled.elapsedMs}ms.`
+              });
+            }
+          }
           updateExtensionOperation(operationId, {
-            status: "succeeded_with_refresh_error",
+            status: warnings.length > 0 ? "succeeded_with_warnings" : "succeeded",
+            phase: void 0,
             result: {
               ...redactExtensionOperationResult(event),
-              refreshed: 0,
-              failed: 1,
-              error: message.slice(0, 500)
+              refreshed,
+              failed
+            },
+            ...warnings.length > 0 ? { warnings } : {}
+          });
+        } else {
+          try {
+            const { result, elapsedMs } = await runReconciliation(async () => {
+              workspace.invalidateWorkspaceSkillsStatus();
+              const startedAt = Date.now();
+              const result2 = await bridge.refreshExtensionsForAllSessions(
+                bridgeMutationEvent(event)
+              );
+              return { result: result2, elapsedMs: Date.now() - startedAt };
+            });
+            const warnings = [...commitWarnings];
+            if (result.failed > 0) {
+              warnings.push({
+                workspaceCwd: boundWorkspace,
+                error: `${result.failed} session refresh(es) failed`
+              });
+            }
+            if (elapsedMs > RECONCILE_SLOW_MS) {
+              warnings.push({
+                workspaceCwd: boundWorkspace,
+                code: "reconcile_slow",
+                error: `Runtime reconciliation took ${elapsedMs}ms.`
+              });
+            }
+            updateExtensionOperation(operationId, {
+              status: warnings.length > 0 ? "succeeded_with_warnings" : "succeeded",
+              phase: void 0,
+              result: {
+                ...redactExtensionOperationResult(event),
+                refreshed: result.refreshed,
+                failed: result.failed
+              },
+              ...warnings.length > 0 ? { warnings } : {}
+            });
+            writeStderrLine(
+              `qwen serve: [${boundWorkspace}] extensions ${operation}: refreshed ${result.refreshed} session(s), ${result.failed} failed`
+            );
+          } catch (refreshErr) {
+            const message = sanitizeDaemonMessage(
+              refreshErr instanceof Error ? refreshErr.message : String(refreshErr)
+            );
+            updateExtensionOperation(operationId, {
+              status: "succeeded_with_warnings",
+              phase: void 0,
+              result: {
+                ...redactExtensionOperationResult(event),
+                refreshed: 0,
+                failed: 1,
+                error: message.slice(0, 500)
+              },
+              warnings: [
+                ...commitWarnings,
+                {
+                  workspaceCwd: boundWorkspace,
+                  error: message.slice(0, 500)
+                }
+              ]
+            });
+            try {
+              bridge.broadcastExtensionsChanged({
+                ...bridgeMutationEvent(event),
+                refreshed: 0,
+                failed: 1,
+                error: message.slice(0, 500)
+              });
+            } catch (broadcastErr) {
+              writeStderrLine(
+                `qwen serve: [${boundWorkspace}] extensions ${operation}: failed to broadcast refresh failure: ${sanitizeDaemonMessage(
+                  broadcastErr instanceof Error ? broadcastErr.message : String(broadcastErr)
+                )}`
+              );
+            }
+            writeStderrLine(
+              `qwen serve: [${boundWorkspace}] extensions ${operation}: mutation succeeded but refresh failed: ${message}`
+            );
+          }
+        }
+      } catch (err) {
+        const message = sanitizeDaemonMessage(
+          err instanceof Error ? err.message : String(err)
+        );
+        const code = err && typeof err === "object" && typeof err.code === "string" ? err.code : void 0;
+        if (committedGeneration !== void 0) {
+          extensionsStatusCache = void 0;
+          const error2 = `Commit succeeded but post-commit work failed: ${message}`.slice(
+            0,
+            500
+          );
+          const warnings = [
+            ...commitWarnings,
+            {
+              workspaceCwd: boundWorkspace,
+              code: "post_commit_failed",
+              error: error2
             }
+          ];
+          try {
+            workspace.invalidateWorkspaceSkillsStatus();
+          } catch (invalidationError) {
+            warnings.push({
+              workspaceCwd: boundWorkspace,
+              code: "status_invalidation_failed",
+              error: sanitizeDaemonMessage(
+                invalidationError instanceof Error ? invalidationError.message : String(invalidationError)
+              ).slice(0, 500)
+            });
+          }
+          updateExtensionOperation(operationId, {
+            status: "succeeded_with_warnings",
+            phase: void 0,
+            ...mutationEvent ? { result: redactExtensionOperationResult(mutationEvent) } : {},
+            warnings
           });
           try {
             bridge.broadcastExtensionsChanged({
-              ...event,
+              ...mutationEvent ? bridgeMutationEvent(mutationEvent) : {
+                ...failureContext.source ? {
+                  source: redactExtensionDisplaySource(
+                    failureContext.source
+                  )
+                } : {},
+                ...failureContext.name ? { name: failureContext.name } : {}
+              },
               refreshed: 0,
               failed: 1,
-              error: message.slice(0, 500)
+              error: error2
             });
-          } catch (broadcastErr) {
+          } catch {
+          }
+          try {
             writeStderrLine(
-              `qwen serve: extensions ${operation}: failed to broadcast refresh failure: ${broadcastErr instanceof Error ? redactUrlCredentials(broadcastErr.message) : String(broadcastErr)}`
+              `qwen serve: [${boundWorkspace}] extensions ${operation}: ${error2}`
             );
+          } catch {
           }
-          writeStderrLine(
-            `qwen serve: extensions ${operation}: mutation succeeded but refresh failed: ${message}`
-          );
+          return;
         }
-      } catch (err) {
-        const message = redactUrlCredentials(
-          err instanceof Error ? err.message : String(err)
-        );
         updateExtensionOperation(operationId, {
           status: "failed",
-          error: message.slice(0, 500)
+          phase: void 0,
+          interaction: void 0,
+          error: message.slice(0, 500),
+          ...code ? { code } : {}
         });
         try {
           bridge.broadcastExtensionsChanged({
             status: "failed",
-            ...failureContext.source ? { source: redactUrlCredentials(failureContext.source) } : {},
+            ...failureContext.source ? { source: redactExtensionDisplaySource(failureContext.source) } : {},
             ...failureContext.name ? { name: failureContext.name } : {},
             refreshed: 0,
             failed: 0,
@@ -14907,33 +15579,25 @@ function registerWorkspaceExtensionRoutes(app, deps) {
           });
         } catch (broadcastErr) {
           writeStderrLine(
-            `qwen serve: extensions ${operation}: failed to broadcast failure: ${broadcastErr instanceof Error ? redactUrlCredentials(broadcastErr.message) : String(broadcastErr)}`
+            `qwen serve: [${boundWorkspace}] extensions ${operation}: failed to broadcast failure: ${sanitizeDaemonMessage(
+              broadcastErr instanceof Error ? broadcastErr.message : String(broadcastErr)
+            )}`
           );
         }
         try {
           writeStderrLine(
-            `qwen serve: extensions ${operation}: background task failed: ${message}`
+            `qwen serve: [${boundWorkspace}] extensions ${operation}: background task failed: ${message}`
           );
         } catch {
         }
+      } finally {
+        if (deadline) clearTimeout(deadline);
+        reconciliationReservation?.release();
+        options.onSettled?.(operationId);
+        releaseOperationSlot();
       }
-    }).catch((err) => {
-      const message = redactUrlCredentials(
-        err instanceof Error ? err.message : String(err)
-      );
-      updateExtensionOperation(operationId, {
-        status: "failed",
-        error: message.slice(0, 500)
-      });
-      try {
-        writeStderrLine(
-          `qwen serve: extensions ${operation}: queued task failed: ${message}`
-        );
-      } catch {
-      }
-    });
+    })();
   }, "runQueuedExtensionMutation");
-  let extensionsStatusCache;
   const buildLocalExtensionsStatus = /* @__PURE__ */ __name(async () => {
     const now = Date.now();
     if (extensionsStatusCache && extensionsStatusCache.expiresAt > now) {
@@ -14964,7 +15628,11 @@ function registerWorkspaceExtensionRoutes(app, deps) {
         version: ext.version,
         isActive: ext.isActive,
         path: ext.path,
-        ...ext.installMetadata?.source ? { source: redactUrlCredentials(ext.installMetadata.source) } : {},
+        ...ext.installMetadata?.source ? {
+          source: redactExtensionDisplaySource(
+            ext.installMetadata.source
+          )
+        } : {},
         ...ext.installMetadata?.type ? { installType: ext.installMetadata.type } : {},
         ...ext.installMetadata?.originSource ? { originSource: ext.installMetadata.originSource } : {},
         ...ext.installMetadata?.ref ? { ref: ext.installMetadata.ref } : {},
@@ -14988,52 +15656,470 @@ function registerWorkspaceExtensionRoutes(app, deps) {
       extensions: entries
     };
     extensionsStatusCache = {
-      expiresAt: now + 2e3,
+      expiresAt: Date.now() + 2e3,
       value: status
     };
     return status;
   }, "buildLocalExtensionsStatus");
-  app.get("/workspace/extensions", async (_req, res) => {
-    try {
-      buildWorkspaceCtx("GET /workspace/extensions");
-      res.status(200).json(await buildLocalExtensionsStatus());
-    } catch (err) {
-      sendBridgeError2(res, err, { route: "GET /workspace/extensions" });
-    }
-  });
-  app.get("/workspace/extensions/operations/:operationId", async (req, res) => {
-    try {
-      buildWorkspaceCtx("GET /workspace/extensions/operations/:operationId");
-      const operationId = req.params["operationId"];
-      if (!operationId) {
-        res.status(400).json({ error: "Missing extension operation id" });
-        return;
+  return {
+    boundWorkspace,
+    workspace,
+    createExtensionManager,
+    buildLocalExtensionsStatus,
+    refreshExtensionsForAllSessions,
+    getOperation: /* @__PURE__ */ __name((operationId) => extensionOperations.get(operationId), "getOperation"),
+    getActiveOperations: /* @__PURE__ */ __name(() => [...extensionOperations.values()].filter(
+      (operation) => !isTerminalExtensionOperation(operation)
+    ), "getActiveOperations"),
+    updateOperation: updateExtensionOperation,
+    preparationQueue,
+    acquireOperationSlot,
+    validateExtensionMutationClient,
+    runQueuedExtensionMutation
+  };
+}
+__name(createExtensionsController, "createExtensionsController");
+
+// packages/cli/src/serve/routes/workspace-extensions.ts
+var EXTENSION_PREPARE_DEADLINE_MS = 10 * 6e4;
+var EXTENSION_INTERACTION_DEADLINE_MS = 10 * 6e4;
+var EXTENSION_INTERACTIVE_PREPARE_DEADLINE_MS = EXTENSION_PREPARE_DEADLINE_MS + EXTENSION_INTERACTION_DEADLINE_MS;
+var EXTENSION_UPDATE_CHECK_DEADLINE_MS = 2 * 6e4;
+var parseExtensionScope = /* @__PURE__ */ __name((body, res) => {
+  const scope = body["scope"];
+  if (scope !== "user" && scope !== "workspace") {
+    res.status(400).json({ error: '`scope` must be either "user" or "workspace"' });
+    return null;
+  }
+  return scope === "user" ? "User" /* User */ : "Workspace" /* Workspace */;
+}, "parseExtensionScope");
+var parseExtensionRegistryUrl = /* @__PURE__ */ __name((value, res) => {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    res.status(400).json({ error: "`registry` must be a valid URL" });
+    return null;
+  }
+  if (parsed.protocol !== "https:") {
+    res.status(400).json({ error: "`registry` must use https" });
+    return null;
+  }
+  if (parsed.username || parsed.password) {
+    res.status(400).json({ error: "`registry` must not include credentials" });
+    return null;
+  }
+  if (isBlockedAuthProviderHost(parsed.hostname)) {
+    res.status(400).json({ error: "`registry` host is not allowed" });
+    return null;
+  }
+  return parsed.toString().replace(/\/$/, "");
+}, "parseExtensionRegistryUrl");
+var parsePotentialSourceUrl = /* @__PURE__ */ __name((source) => {
+  if (/^[a-zA-Z]:[\\/]/.test(source)) return null;
+  try {
+    return new URL(source);
+  } catch {
+    const colonIndex = source.indexOf(":");
+    if (colonIndex >= 0 && source.slice(0, colonIndex).includes("/")) {
+      return null;
+    }
+    const sshMatch = /^(?:[^@]+@)?(\[[^\]]+\]|[^:]+):/.exec(source);
+    if (!sshMatch?.[1]) return null;
+    try {
+      return new URL(`ssh://${sshMatch[1]}`);
+    } catch {
+      return null;
+    }
+  }
+}, "parsePotentialSourceUrl");
+var validateExtensionSourceHost = /* @__PURE__ */ __name((source, res) => {
+  const parsed = parsePotentialSourceUrl(source);
+  if (!parsed) return true;
+  if (parsed.username || parsed.password) {
+    res.status(400).json({ error: "`source` must not include credentials" });
+    return false;
+  }
+  if (isBlockedAuthProviderHost(parsed.hostname)) {
+    res.status(400).json({ error: "`source` host is not allowed" });
+    return false;
+  }
+  if (parsed.protocol !== "https:") {
+    res.status(400).json({ error: "`source` must use https" });
+    return false;
+  }
+  return true;
+}, "validateExtensionSourceHost");
+var validateExtensionSourceMetadata = /* @__PURE__ */ __name((installMetadata) => {
+  if (installMetadata.type !== "git") return true;
+  const parsed = parsePotentialSourceUrl(installMetadata.source);
+  return !!parsed && (installMetadata.networkPolicy === "public" ? parsed.protocol === "https:" : parsed.protocol === "https:" || parsed.protocol === "ssh:") && !isBlockedAuthProviderHost(parsed.hostname);
+}, "validateExtensionSourceMetadata");
+var findLoadedExtension = /* @__PURE__ */ __name((extensionManager, extensionName) => {
+  const requested = extensionName.toLowerCase();
+  const extensions = extensionManager.getLoadedExtensions();
+  const byName = extensions.find(
+    (extension) => extension.name.toLowerCase() === requested
+  );
+  if (byName) return byName;
+  if (!extensionName.includes("://") && !extensionName.includes("@")) {
+    return void 0;
+  }
+  return extensions.find(
+    (extension) => extension.installMetadata?.source?.toLowerCase() === requested
+  );
+}, "findLoadedExtension");
+function registerWorkspaceExtensionRoutes(app, deps) {
+  const {
+    boundWorkspace,
+    bridge,
+    workspace,
+    mutate,
+    safeBody: safeBody2,
+    sendBridgeError: sendBridgeError2,
+    workspaceRegistry
+  } = deps;
+  const maxExtensionOperationHistory = deps.maxExtensionOperationHistory;
+  const controllerDeps = /* @__PURE__ */ __name((ws, wsBridge, wsService) => ({
+    boundWorkspace: ws,
+    bridge: wsBridge,
+    workspace: wsService,
+    ...maxExtensionOperationHistory === void 0 ? {} : { maxExtensionOperationHistory }
+  }), "controllerDeps");
+  const primaryController = createExtensionsController(
+    controllerDeps(boundWorkspace, bridge, workspace)
+  );
+  const pendingExtensionInteractions = /* @__PURE__ */ new Map();
+  const supersededInstallOperations = /* @__PURE__ */ new Set();
+  const cancelPendingExtensionInteraction = /* @__PURE__ */ __name((operationId, reason) => {
+    const pending = pendingExtensionInteractions.get(operationId);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    pendingExtensionInteractions.delete(operationId);
+    pending.reject(new Error(reason));
+  }, "cancelPendingExtensionInteraction");
+  const supersedeActiveInstallOperations = /* @__PURE__ */ __name((controller, currentOperationId) => {
+    for (const operation of controller.getActiveOperations()) {
+      if (operation.operation !== "install" || operation.operationId === currentOperationId) {
+        continue;
       }
-      const operation = extensionOperations.get(operationId);
-      if (!operation) {
-        res.status(404).json({
-          error: `Extension operation "${operationId}" not found`,
-          code: "extension_operation_not_found"
+      supersededInstallOperations.add(operation.operationId);
+      cancelPendingExtensionInteraction(
+        operation.operationId,
+        "Extension installation cancelled by a new install request"
+      );
+    }
+  }, "supersedeActiveInstallOperations");
+  const waitForExtensionInteraction = /* @__PURE__ */ __name((controller, operationId, interaction) => {
+    if (supersededInstallOperations.delete(operationId)) {
+      return Promise.reject(
+        new Error("Extension installation superseded by a new install request")
+      );
+    }
+    const operation = controller.getOperation(operationId);
+    if (operation && operation.status !== "queued" && operation.status !== "running" && operation.status !== "waiting_for_input") {
+      return Promise.reject(new Error("Extension operation already completed"));
+    }
+    const pendingInteraction = {
+      ...interaction,
+      id: crypto2.randomUUID()
+    };
+    return new Promise((resolve5, reject) => {
+      const timeout = setTimeout(() => {
+        pendingExtensionInteractions.delete(operationId);
+        controller.updateOperation(operationId, {
+          status: "failed",
+          phase: void 0,
+          interaction: void 0,
+          error: "Extension interaction timed out"
         });
-        return;
+        reject(new Error("Extension interaction timed out"));
+      }, EXTENSION_INTERACTION_DEADLINE_MS);
+      timeout.unref?.();
+      pendingExtensionInteractions.set(operationId, {
+        interaction: pendingInteraction,
+        resolve: resolve5,
+        reject,
+        timeout
+      });
+      controller.updateOperation(operationId, {
+        status: "waiting_for_input",
+        phase: void 0,
+        interaction: pendingInteraction
+      });
+    });
+  }, "waitForExtensionInteraction");
+  const extensionInteractionHandlers = /* @__PURE__ */ __name((controller, operationId) => ({
+    requestSetting: /* @__PURE__ */ __name((setting) => waitForExtensionInteraction(controller, operationId, {
+      kind: "setting",
+      setting: {
+        name: setting.name,
+        description: setting.description,
+        sensitive: setting.sensitive === true
+      }
+    }), "requestSetting"),
+    requestChoicePlugin: /* @__PURE__ */ __name((marketplace) => {
+      if (marketplace.plugins.length === 0) {
+        return Promise.reject(
+          new Error(`Marketplace "${marketplace.name}" has no plugins`)
+        );
       }
-      res.status(200).json(operation);
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "GET /workspace/extensions/operations/:operationId"
+      return waitForExtensionInteraction(controller, operationId, {
+        kind: "marketplace_plugin",
+        marketplace: { name: marketplace.name },
+        plugins: marketplace.plugins.map((plugin) => ({
+          name: plugin.name,
+          ...plugin.description ? { description: plugin.description } : {},
+          source: redactExtensionDisplaySource(
+            typeof plugin.source === "string" ? plugin.source : plugin.source.source === "github" ? plugin.source.repo : plugin.source.url
+          ),
+          ...plugin.category ? { category: plugin.category } : {},
+          ...plugin.tags ? { tags: plugin.tags } : {}
+        }))
       });
-    }
-  });
-  app.post(
-    "/workspace/extensions/install",
-    mutate({ strict: true }),
-    async (req, res) => {
+    }, "requestChoicePlugin")
+  }), "extensionInteractionHandlers");
+  const runtimeReconciliationQueue = createFifoTaskQueue(1);
+  const reserveRuntimeReconciliation = /* @__PURE__ */ __name(() => {
+    let provideTask;
+    const task = new Promise(
+      (resolve5) => {
+        provideTask = resolve5;
+      }
+    );
+    const queued = runtimeReconciliationQueue.run(async () => {
+      const run = await task;
+      return run ? await run() : void 0;
+    });
+    let used = false;
+    return {
+      run: /* @__PURE__ */ __name(async (run) => {
+        if (used) throw new Error("Runtime reconciliation already released");
+        used = true;
+        provideTask(run);
+        return await queued;
+      }, "run"),
+      release: /* @__PURE__ */ __name(() => {
+        if (used) return;
+        used = true;
+        provideTask(void 0);
+      }, "release")
+    };
+  }, "reserveRuntimeReconciliation");
+  const appliedGenerationByWorkspaceId = /* @__PURE__ */ new Map();
+  const onRuntimeReconciled = /* @__PURE__ */ __name((runtime, generation) => {
+    appliedGenerationByWorkspaceId.set(runtime.workspaceId, generation);
+  }, "onRuntimeReconciled");
+  const globalReconciliationOptions = /* @__PURE__ */ __name(() => workspaceRegistry ? {
+    refreshRuntimes: /* @__PURE__ */ __name(() => workspaceRegistry.list(), "refreshRuntimes"),
+    reserveRuntimeReconciliation,
+    onRuntimeReconciled
+  } : {}, "globalReconciliationOptions");
+  const workspaceReconciliationOptions = /* @__PURE__ */ __name(() => workspaceRegistry ? {
+    refreshRuntimes: [workspaceRegistry.primary],
+    reserveRuntimeReconciliation,
+    onRuntimeReconciled
+  } : {}, "workspaceReconciliationOptions");
+  const mutationClientBridges = /* @__PURE__ */ __name((runtimes) => (typeof runtimes === "function" ? runtimes() : runtimes ?? workspaceRegistry?.list())?.map((runtime) => runtime.bridge) ?? [bridge], "mutationClientBridges");
+  if (workspaceRegistry) {
+    let observedGeneration;
+    let reconciling = false;
+    const reconcileExternalGeneration = /* @__PURE__ */ __name(async () => {
+      if (reconciling) return;
+      reconciling = true;
       try {
-        if (!validateExtensionMutationClient(
-          req,
-          res,
-          "POST /workspace/extensions/install"
-        )) {
+        const manager = primaryController.createExtensionManager(
+          boundWorkspace,
+          true
+        );
+        const generation = (await manager.getExtensionStoreSnapshot()).generation;
+        const pendingRuntimes = workspaceRegistry.list().filter(
+          (runtime) => (appliedGenerationByWorkspaceId.get(runtime.workspaceId) ?? 0) !== generation
+        );
+        if (generation === observedGeneration && pendingRuntimes.length === 0)
+          return;
+        const runtimes = pendingRuntimes;
+        if (runtimes.length === 0) return;
+        const results = await runtimeReconciliationQueue.run(
+          async () => await Promise.allSettled(
+            runtimes.map(async (runtime) => {
+              runtime.workspaceService.invalidateWorkspaceSkillsStatus();
+              const result = await runtime.bridge.refreshExtensionsForAllSessions();
+              if (result.failed > 0) {
+                throw new Error(
+                  `${result.failed} extension session refresh(es) failed`
+                );
+              }
+            })
+          )
+        );
+        results.forEach((result, index) => {
+          if (result.status === "fulfilled") {
+            const workspaceId = runtimes[index].workspaceId;
+            appliedGenerationByWorkspaceId.set(workspaceId, generation);
+          } else {
+            writeStderrLine(
+              `qwen serve: extension generation reconciliation failed for workspace ${runtimes[index].workspaceId}: ${redactUrlCredentials(
+                result.reason instanceof Error ? result.reason.message : String(result.reason)
+              )}`
+            );
+          }
+        });
+        if (runtimes.length === pendingRuntimes.length && results.every((result) => result.status === "fulfilled")) {
+          observedGeneration = generation;
+        }
+      } catch (error2) {
+        writeStderrLine(
+          `qwen serve: extension generation reconciliation failed: ${redactUrlCredentials(
+            error2 instanceof Error ? error2.message : String(error2)
+          )}`
+        );
+      } finally {
+        reconciling = false;
+      }
+    }, "reconcileExternalGeneration");
+    const generationPoller = setInterval(
+      () => void reconcileExternalGeneration(),
+      3e4
+    );
+    generationPoller.unref();
+    app.locals.stopExtensionGenerationReconciler = () => clearInterval(generationPoller);
+  }
+  const registerFor = /* @__PURE__ */ __name((base, resolve5) => {
+    app.get(base, async (req, res) => {
+      const ctrl = resolve5(req, res, false);
+      if (!ctrl) return;
+      try {
+        res.status(200).json(await ctrl.buildLocalExtensionsStatus());
+      } catch (err) {
+        sendBridgeError2(res, err, { route: `GET ${base}` });
+      }
+    });
+    app.get(`${base}/operations`, async (req, res) => {
+      const ctrl = resolve5(req, res, false);
+      if (!ctrl) return;
+      res.status(200).json({ v: 1, operations: ctrl.getActiveOperations() });
+    });
+    app.get(`${base}/operations/:operationId`, async (req, res) => {
+      const ctrl = resolve5(req, res, false);
+      if (!ctrl) return;
+      try {
+        const operationId = req.params["operationId"];
+        if (!operationId) {
+          res.status(400).json({ error: "Missing extension operation id" });
+          return;
+        }
+        const operation = ctrl.getOperation(operationId);
+        if (!operation) {
+          res.status(404).json({
+            error: `Extension operation "${operationId}" not found`,
+            code: "extension_operation_not_found"
+          });
+          return;
+        }
+        if (base === "/workspace/extensions" && operation.status === "succeeded_with_warnings") {
+          const warningError = operation.warnings?.find((warning) => warning.code === void 0)?.error ?? operation.warnings?.[0]?.error ?? operation.result?.error;
+          const legacyOperation = {
+            ...operation,
+            status: "succeeded_with_refresh_error"
+          };
+          if (operation.result && warningError) {
+            legacyOperation.result = {
+              ...operation.result,
+              error: warningError
+            };
+          } else if (warningError) {
+            legacyOperation.error = warningError;
+          }
+          res.status(200).json(legacyOperation);
+          return;
+        }
+        res.status(200).json(operation);
+      } catch (err) {
+        sendBridgeError2(res, err, {
+          route: `GET ${base}/operations/:operationId`
+        });
+      }
+    });
+    app.post(
+      `${base}/operations/:operationId/interactions/:interactionId`,
+      mutate({ strict: true }),
+      async (req, res) => {
+        const ctrl = resolve5(req, res, false);
+        if (!ctrl) return;
+        try {
+          if (!ctrl.validateExtensionMutationClient(req, res, {
+            requireClientId: false
+          })) {
+            return;
+          }
+          const operationId = req.params["operationId"];
+          const interactionId = req.params["interactionId"];
+          const pending = operationId ? pendingExtensionInteractions.get(operationId) : void 0;
+          if (!operationId || !interactionId || !pending) {
+            res.status(404).json({ error: "Extension interaction not found" });
+            return;
+          }
+          if (pending.interaction.id !== interactionId) {
+            res.status(404).json({ error: "Extension interaction not found" });
+            return;
+          }
+          const body = safeBody2(req);
+          let value;
+          if (body["cancelled"] === true) {
+            clearTimeout(pending.timeout);
+            pendingExtensionInteractions.delete(operationId);
+            ctrl.updateOperation(operationId, {
+              status: "failed",
+              phase: void 0,
+              interaction: void 0,
+              error: "Extension operation cancelled"
+            });
+            pending.reject(new Error("Extension operation cancelled"));
+            res.status(200).json({ accepted: true });
+            return;
+          }
+          if (pending.interaction.kind === "marketplace_plugin") {
+            const pluginName = body["pluginName"];
+            if (typeof pluginName !== "string" || !pending.interaction.plugins.some(
+              (plugin) => plugin.name === pluginName
+            )) {
+              res.status(400).json({ error: "Invalid marketplace plugin name" });
+              return;
+            }
+            value = pluginName;
+          } else {
+            const settingValue = body["value"];
+            if (typeof settingValue !== "string") {
+              res.status(400).json({ error: "Extension setting value must be a string" });
+              return;
+            }
+            value = settingValue;
+          }
+          clearTimeout(pending.timeout);
+          pendingExtensionInteractions.delete(operationId);
+          ctrl.updateOperation(operationId, {
+            status: "running",
+            phase: "preparing",
+            interaction: void 0,
+            error: void 0
+          });
+          pending.resolve(value);
+          res.status(200).json({ accepted: true });
+        } catch (err) {
+          sendBridgeError2(res, err, {
+            route: `POST ${base}/operations/:operationId/interactions/:interactionId`
+          });
+        }
+      }
+    );
+    app.post(`${base}/install`, mutate({ strict: true }), async (req, res) => {
+      const ctrl = resolve5(req, res, true);
+      if (!ctrl) return;
+      try {
+        if (!ctrl.validateExtensionMutationClient(req, res, {
+          requireClientId: false
+        })) {
           return;
         }
         const body = safeBody2(req);
@@ -15083,139 +16169,405 @@ function registerWorkspaceExtensionRoutes(app, deps) {
         if (!validateExtensionSourceHost(sourceValue, res)) {
           return;
         }
-        runQueuedExtensionMutation(
+        const localSource = /^[A-Za-z]:[\\/]/.test(sourceValue) || sourceValue.startsWith("/") || sourceValue.startsWith(".");
+        if (localSource) {
+          try {
+            const metadata = await parseInstallSource(sourceValue, {
+              networkPolicy: "public"
+            });
+            if (metadata.type !== "git" && metadata.type !== "github-release" && metadata.type !== "npm") {
+              res.status(400).json({
+                error: "Only GitHub, Git, and npm extension installs are supported over the daemon endpoint."
+              });
+              return;
+            }
+          } catch (error2) {
+            const message = error2 instanceof Error ? error2.message : "Invalid install source";
+            res.status(400).json({
+              error: redactUrlCredentials(
+                message.replaceAll(
+                  sourceValue,
+                  redactExtensionDisplaySource(sourceValue)
+                )
+              )
+            });
+            return;
+          }
+        }
+        const npmSource = sourceValue.startsWith("@");
+        const remoteSource = npmSource || sourceValue.startsWith("https://") || /^[^/\s]+\/[^/\s]+/.test(sourceValue);
+        if (!localSource && !remoteSource) {
+          res.status(400).json({
+            error: `Install source not found: ${redactExtensionDisplaySource(
+              sourceValue
+            )}`
+          });
+          return;
+        }
+        if (npmSource && refValue) {
+          res.status(400).json({ error: "--ref is not applicable for npm extensions." });
+          return;
+        }
+        if (!npmSource && registryValue) {
+          res.status(400).json({
+            error: "--registry is only applicable for npm extensions."
+          });
+          return;
+        }
+        ctrl.runQueuedExtensionMutation(
           "install",
           { source: sourceValue },
           res,
-          async (extensionManager) => {
-            const installMetadata = await parseInstallSource(sourceValue);
-            if (installMetadata.type !== "git" && installMetadata.type !== "github-release" && installMetadata.type !== "npm") {
-              throw new Error(
-                "Only GitHub, Git, and npm extension installs are supported over the daemon endpoint."
+          async (extensionManager, _signal, context, operationId) => {
+            const prepared = await context.prepare(async (signal) => {
+              const installMetadata = await parseInstallSource(sourceValue, {
+                networkPolicy: "public"
+              });
+              if (installMetadata.type !== "git" && installMetadata.type !== "github-release" && installMetadata.type !== "npm") {
+                throw new Error(
+                  "Only GitHub, Git, and npm extension installs are supported over the daemon endpoint."
+                );
+              }
+              if (installMetadata.type === "npm" && refValue) {
+                throw new Error("--ref is not applicable for npm extensions.");
+              }
+              if (installMetadata.type !== "npm" && registryValue) {
+                throw new Error(
+                  "--registry is only applicable for npm extensions."
+                );
+              }
+              if (!validateExtensionSourceMetadata(installMetadata)) {
+                throw new Error("`source` host is not allowed");
+              }
+              if (installMetadata.type === "npm" && registryUrl) {
+                installMetadata.registryUrl = registryUrl;
+              }
+              supersedeActiveInstallOperations(ctrl, operationId);
+              return await extensionManager.prepareExtensionInstall({
+                installMetadata: {
+                  ...installMetadata,
+                  ref: refValue,
+                  autoUpdate: autoUpdateValue,
+                  allowPreRelease: allowPreReleaseValue
+                },
+                initialActivation: { scope: "user" },
+                requestConsent: /* @__PURE__ */ __name(() => Promise.resolve(), "requestConsent"),
+                signal
+              });
+            });
+            try {
+              const committed = await context.commit(
+                async (onCommitted) => await extensionManager.commitPreparedExtension(
+                  prepared,
+                  onCommitted
+                )
               );
+              return {
+                status: "installed",
+                source: sourceValue,
+                name: committed.identity.name,
+                version: committed.version
+              };
+            } finally {
+              await extensionManager.disposePreparedExtension(prepared);
             }
-            if (installMetadata.type === "npm" && refValue) {
-              throw new Error("--ref is not applicable for npm extensions.");
-            }
-            if (installMetadata.type !== "npm" && registryValue) {
-              throw new Error(
-                "--registry is only applicable for npm extensions."
+          },
+          {
+            createManager: /* @__PURE__ */ __name((operationId) => ctrl.createExtensionManager(
+              void 0,
+              void 0,
+              extensionInteractionHandlers(ctrl, operationId)
+            ), "createManager"),
+            onSettled: /* @__PURE__ */ __name((operationId) => {
+              supersededInstallOperations.delete(operationId);
+              cancelPendingExtensionInteraction(
+                operationId,
+                "Extension operation ended"
               );
-            }
-            if (!validateExtensionSourceMetadata(installMetadata)) {
-              throw new Error("`source` host is not allowed");
-            }
-            if (installMetadata.type === "npm" && registryUrl) {
-              installMetadata.registryUrl = registryUrl;
-            }
-            const extension = await extensionManager.installExtension(
-              {
-                ...installMetadata,
-                ref: refValue,
-                autoUpdate: autoUpdateValue,
-                allowPreRelease: allowPreReleaseValue
-              },
-              () => Promise.resolve()
-            );
-            return {
-              status: "installed",
-              source: sourceValue,
-              name: extension.name,
-              version: extension.config.version
-            };
+            }, "onSettled"),
+            deadlineMs: EXTENSION_INTERACTIVE_PREPARE_DEADLINE_MS,
+            ...globalReconciliationOptions()
           }
         );
       } catch (err) {
-        sendBridgeError2(res, err, {
-          route: "POST /workspace/extensions/install"
-        });
+        sendBridgeError2(res, err, { route: `POST ${base}/install` });
       }
-    }
-  );
-  app.post(
-    "/workspace/extensions/check-updates",
-    mutate({ strict: true }),
-    async (req, res) => {
+    });
+    app.post(
+      `${base}/check-updates`,
+      mutate({ strict: true }),
+      async (req, res) => {
+        const ctrl = resolve5(req, res, true);
+        if (!ctrl) return;
+        let timer;
+        let releaseOperationSlot;
+        try {
+          if (!ctrl.validateExtensionMutationClient(req, res, {
+            requireClientId: false
+          })) {
+            return;
+          }
+          releaseOperationSlot = ctrl.acquireOperationSlot(res);
+          if (!releaseOperationSlot) return;
+          const extensionManager = ctrl.createExtensionManager();
+          const updateStates = /* @__PURE__ */ Object.create(null);
+          const deadline = new AbortController();
+          timer = setTimeout(() => {
+            const error2 = new Error(
+              "Extension update check exceeded its preparation deadline."
+            );
+            error2.code = "extension_prepare_timeout";
+            deadline.abort(error2);
+          }, EXTENSION_UPDATE_CHECK_DEADLINE_MS);
+          timer.unref();
+          let rejectRefreshOnAbort;
+          try {
+            await Promise.race([
+              extensionManager.refreshCache(),
+              new Promise((_resolve, reject) => {
+                rejectRefreshOnAbort = /* @__PURE__ */ __name(() => reject(deadline.signal.reason), "rejectRefreshOnAbort");
+                deadline.signal.addEventListener(
+                  "abort",
+                  rejectRefreshOnAbort,
+                  { once: true }
+                );
+              })
+            ]);
+          } finally {
+            if (rejectRefreshOnAbort) {
+              deadline.signal.removeEventListener(
+                "abort",
+                rejectRefreshOnAbort
+              );
+            }
+          }
+          await extensionManager.checkForAllExtensionUpdates(
+            (name, state) => {
+              updateStates[name] = state;
+            },
+            deadline.signal,
+            async (task) => await ctrl.preparationQueue.run(task, {
+              signal: deadline.signal
+            })
+          );
+          const states = updateStates;
+          res.status(200).json({ states });
+        } catch (err) {
+          sendBridgeError2(res, err, { route: `POST ${base}/check-updates` });
+        } finally {
+          if (timer) clearTimeout(timer);
+          releaseOperationSlot?.();
+        }
+      }
+    );
+    app.post(`${base}/refresh`, mutate({ strict: true }), async (req, res) => {
+      const ctrl = resolve5(req, res, true);
+      if (!ctrl) return;
       try {
-        if (!validateExtensionMutationClient(
-          req,
-          res,
-          "POST /workspace/extensions/check-updates"
-        )) {
+        if (!ctrl.validateExtensionMutationClient(req, res, {
+          requireClientId: false
+        })) {
           return;
         }
-        const states = await enqueueExtensionInstall(
-          async () => withExtensionTimeout(
-            (async () => {
-              const extensionManager = createExtensionManager();
-              await extensionManager.refreshCache();
-              const updateStates = {};
-              await extensionManager.checkForAllExtensionUpdates(
-                (name, state) => {
-                  updateStates[name] = state;
-                }
-              );
-              return updateStates;
-            })(),
-            EXTENSION_REFRESH_TIMEOUT_MS,
-            "extension update check"
-          )
-        );
-        res.status(200).json({ states });
-      } catch (err) {
-        if (isExtensionQueueFullError(err)) {
-          sendExtensionQueueFull(res);
-          return;
+        const releaseOperationSlot = ctrl.acquireOperationSlot(res);
+        if (!releaseOperationSlot) return;
+        try {
+          const result = await ctrl.refreshExtensionsForAllSessions();
+          res.status(200).json(result);
+        } finally {
+          releaseOperationSlot();
         }
-        sendBridgeError2(res, err, {
-          route: "POST /workspace/extensions/check-updates"
-        });
+      } catch (err) {
+        sendBridgeError2(res, err, { route: `POST ${base}/refresh` });
       }
-    }
-  );
-  app.post(
-    "/workspace/extensions/refresh",
-    mutate({ strict: true }),
-    async (req, res) => {
-      try {
-        if (!validateExtensionMutationClient(
-          req,
-          res,
-          "POST /workspace/extensions/refresh"
-        )) {
-          return;
+    });
+    app.post(
+      `${base}/:name/enable`,
+      mutate({ strict: true }),
+      async (req, res) => {
+        const ctrl = resolve5(req, res, true);
+        if (!ctrl) return;
+        try {
+          if (!ctrl.validateExtensionMutationClient(req, res, {
+            requireClientId: false
+          })) {
+            return;
+          }
+          const name = req.params["name"];
+          if (!name) {
+            res.status(400).json({ error: "Missing extension name" });
+            return;
+          }
+          const scope = parseExtensionScope(safeBody2(req), res);
+          if (scope === null) return;
+          ctrl.runQueuedExtensionMutation(
+            "enable",
+            { name },
+            res,
+            async (extensionManager, _signal, context) => {
+              const extension = findLoadedExtension(extensionManager, name);
+              if (!extension) {
+                throw new Error(`Extension "${name}" not found`);
+              }
+              await context.commit(
+                async (onCommitted) => await extensionManager.enableExtension(
+                  extension.name,
+                  scope,
+                  ctrl.boundWorkspace,
+                  onCommitted
+                )
+              );
+              return { status: "enabled", name: extension.name };
+            },
+            {
+              ...scope === "User" /* User */ ? globalReconciliationOptions() : workspaceReconciliationOptions()
+            }
+          );
+        } catch (err) {
+          sendBridgeError2(res, err, { route: `POST ${base}/:name/enable` });
         }
-        const result = await enqueueExtensionInstall(
-          async () => withExtensionTimeout(
-            workspace.refreshExtensionsForAllSessions(),
-            EXTENSION_REFRESH_TIMEOUT_MS,
-            "extension refresh"
-          )
-        );
-        extensionsStatusCache = void 0;
-        res.status(200).json(result);
-      } catch (err) {
-        if (isExtensionQueueFullError(err)) {
-          sendExtensionQueueFull(res);
-          return;
+      }
+    );
+    app.post(
+      `${base}/:name/disable`,
+      mutate({ strict: true }),
+      async (req, res) => {
+        const ctrl = resolve5(req, res, true);
+        if (!ctrl) return;
+        try {
+          if (!ctrl.validateExtensionMutationClient(req, res, {
+            requireClientId: false
+          })) {
+            return;
+          }
+          const name = req.params["name"];
+          if (!name) {
+            res.status(400).json({ error: "Missing extension name" });
+            return;
+          }
+          const scope = parseExtensionScope(safeBody2(req), res);
+          if (scope === null) return;
+          ctrl.runQueuedExtensionMutation(
+            "disable",
+            { name },
+            res,
+            async (extensionManager, _signal, context) => {
+              const extension = findLoadedExtension(extensionManager, name);
+              if (!extension) {
+                throw new Error(`Extension "${name}" not found`);
+              }
+              await context.commit(
+                async (onCommitted) => await extensionManager.disableExtension(
+                  extension.name,
+                  scope,
+                  ctrl.boundWorkspace,
+                  onCommitted
+                )
+              );
+              return { status: "disabled", name: extension.name };
+            },
+            {
+              ...scope === "User" /* User */ ? globalReconciliationOptions() : workspaceReconciliationOptions()
+            }
+          );
+        } catch (err) {
+          sendBridgeError2(res, err, { route: `POST ${base}/:name/disable` });
         }
-        sendBridgeError2(res, err, {
-          route: "POST /workspace/extensions/refresh"
-        });
       }
-    }
-  );
-  app.post(
-    "/workspace/extensions/:name/enable",
-    mutate({ strict: true }),
-    async (req, res) => {
+    );
+    app.post(
+      `${base}/:name/update`,
+      mutate({ strict: true }),
+      async (req, res) => {
+        const ctrl = resolve5(req, res, true);
+        if (!ctrl) return;
+        try {
+          if (!ctrl.validateExtensionMutationClient(req, res, {
+            requireClientId: false
+          })) {
+            return;
+          }
+          const name = req.params["name"];
+          if (!name) {
+            res.status(400).json({ error: "Missing extension name" });
+            return;
+          }
+          ctrl.runQueuedExtensionMutation(
+            "update",
+            { name },
+            res,
+            async (extensionManager, _signal, context) => {
+              const extension = findLoadedExtension(extensionManager, name);
+              if (!extension) {
+                throw new Error(`Extension "${name}" not found`);
+              }
+              let preparedResult;
+              try {
+                preparedResult = await context.prepare(
+                  async (signal) => await extensionManager.prepareExtensionUpdate({
+                    extension,
+                    signal
+                  })
+                );
+              } catch (error2) {
+                const wrapped = new Error(
+                  `Update check failed for extension "${extension.name}": ${error2 instanceof Error ? error2.message : String(error2)}`,
+                  { cause: error2 }
+                );
+                if (error2 && typeof error2 === "object" && typeof error2.code === "string") {
+                  wrapped.code = error2.code;
+                }
+                throw wrapped;
+              }
+              if (preparedResult.upToDate) {
+                throw new Error(`Extension "${extension.name}" has no update`);
+              }
+              try {
+                const committed = await context.commit(
+                  async (onCommitted) => await extensionManager.commitPreparedExtension(
+                    preparedResult.prepared,
+                    onCommitted
+                  )
+                );
+                return {
+                  status: "updated",
+                  name: extension.name,
+                  version: committed.version
+                };
+              } finally {
+                await extensionManager.disposePreparedExtension(
+                  preparedResult.prepared
+                );
+              }
+            },
+            {
+              createManager: /* @__PURE__ */ __name((operationId) => ctrl.createExtensionManager(
+                void 0,
+                void 0,
+                extensionInteractionHandlers(ctrl, operationId)
+              ), "createManager"),
+              onSettled: /* @__PURE__ */ __name((operationId) => {
+                cancelPendingExtensionInteraction(
+                  operationId,
+                  "Extension operation ended"
+                );
+              }, "onSettled"),
+              deadlineMs: EXTENSION_INTERACTIVE_PREPARE_DEADLINE_MS,
+              ...globalReconciliationOptions()
+            }
+          );
+        } catch (err) {
+          sendBridgeError2(res, err, { route: `POST ${base}/:name/update` });
+        }
+      }
+    );
+    app.delete(`${base}/:name`, mutate({ strict: true }), async (req, res) => {
+      const ctrl = resolve5(req, res, true);
+      if (!ctrl) return;
       try {
-        if (!validateExtensionMutationClient(
-          req,
-          res,
-          "POST /workspace/extensions/:name/enable",
-          { requireClientId: false }
-        )) {
+        if (!ctrl.validateExtensionMutationClient(req, res, {
+          requireClientId: false
+        })) {
           return;
         }
         const name = req.params["name"];
@@ -15223,184 +16575,604 @@ function registerWorkspaceExtensionRoutes(app, deps) {
           res.status(400).json({ error: "Missing extension name" });
           return;
         }
-        const scope = parseExtensionScope(safeBody2(req), res);
-        if (scope === null) return;
-        runQueuedExtensionMutation(
-          "enable",
+        ctrl.runQueuedExtensionMutation(
+          "uninstall",
           { name },
           res,
-          async (extensionManager) => {
+          async (extensionManager, _signal, context) => {
             const extension = findLoadedExtension(extensionManager, name);
             if (!extension) {
               throw new Error(`Extension "${name}" not found`);
             }
-            await extensionManager.enableExtension(
-              extension.name,
-              scope,
-              boundWorkspace
+            await context.commit(
+              async (onCommitted) => await extensionManager.uninstallExtension(
+                extension.name,
+                false,
+                ctrl.boundWorkspace,
+                onCommitted
+              )
             );
-            return { status: "enabled", name: extension.name };
+            return { status: "uninstalled", name: extension.name };
+          },
+          {
+            ...globalReconciliationOptions()
           }
         );
       } catch (err) {
-        sendBridgeError2(res, err, {
-          route: "POST /workspace/extensions/:name/enable"
+        sendBridgeError2(res, err, { route: `DELETE ${base}/:name` });
+      }
+    });
+  }, "registerFor");
+  registerFor("/workspace/extensions", () => primaryController);
+  const extensionById = /* @__PURE__ */ __name((manager, extensionId) => manager.getLoadedExtensions().find((extension) => extension.id === extensionId), "extensionById");
+  const parseExtensionId = /* @__PURE__ */ __name((req, res) => {
+    const extensionId = req.params["extensionId"];
+    if (!extensionId || !/^[a-f0-9]{64}$/.test(extensionId)) {
+      res.status(400).json({
+        error: "Invalid extension id",
+        code: "invalid_extension_id"
+      });
+      return null;
+    }
+    return extensionId;
+  }, "parseExtensionId");
+  const parseActivationState = /* @__PURE__ */ __name((req, res) => {
+    const state = safeBody2(req)["state"];
+    if (state !== "enabled" && state !== "disabled") {
+      res.status(400).json({
+        error: '`state` must be either "enabled" or "disabled"',
+        code: "invalid_extension_activation"
+      });
+      return null;
+    }
+    return state;
+  }, "parseActivationState");
+  const sendOperation = /* @__PURE__ */ __name((req, res, route, manager, operation, failureContext, run, options = {}) => {
+    if (!primaryController.validateExtensionMutationClient(req, res, {
+      requireClientId: false,
+      bridges: mutationClientBridges(options.refreshRuntimes)
+    })) {
+      return;
+    }
+    primaryController.runQueuedExtensionMutation(
+      operation,
+      failureContext,
+      res,
+      run,
+      {
+        manager,
+        operationBasePath: "/extensions/operations",
+        onRuntimeReconciled,
+        reserveRuntimeReconciliation,
+        ...options
+      }
+    );
+  }, "sendOperation");
+  app.get("/extensions", async (_req, res) => {
+    try {
+      const manager = primaryController.createExtensionManager(
+        boundWorkspace,
+        true
+      );
+      const snapshot = await manager.refreshCacheWithSnapshot();
+      res.status(200).json({
+        v: 1,
+        generation: snapshot.generation,
+        extensions: manager.getLoadedExtensions().map((extension) => {
+          const policy = snapshot.extensions[extension.id];
+          return {
+            id: extension.id,
+            name: extension.name,
+            version: extension.version,
+            ...extension.installMetadata?.type ? { installType: extension.installMetadata.type } : {},
+            defaultActivation: policy?.defaultActivation ?? "enabled",
+            workspaceOverrideCount: Object.values(
+              policy?.workspaceOverrides ?? {}
+            ).filter((activation) => activation !== "inherit").length
+          };
+        })
+      });
+    } catch (error2) {
+      sendBridgeError2(res, error2, { route: "GET /extensions" });
+    }
+  });
+  app.get("/extensions/operations/:operationId", (req, res) => {
+    const operationId = req.params["operationId"];
+    if (!operationId) {
+      res.status(400).json({ error: "Missing extension operation id" });
+      return;
+    }
+    const operation = primaryController.getOperation(operationId);
+    if (!operation) {
+      res.status(404).json({
+        error: `Extension operation "${operationId}" not found`,
+        code: "extension_operation_not_found"
+      });
+      return;
+    }
+    res.status(200).json(operation);
+  });
+  app.put(
+    "/extensions/:extensionId/activation",
+    mutate({ strict: true }),
+    async (req, res) => {
+      const extensionId = parseExtensionId(req, res);
+      if (!extensionId) return;
+      const state = parseActivationState(req, res);
+      if (!state) return;
+      const manager = primaryController.createExtensionManager(
+        boundWorkspace,
+        true
+      );
+      sendOperation(
+        req,
+        res,
+        "PUT /extensions/:extensionId/activation",
+        manager,
+        "activation",
+        { name: extensionId },
+        async (extensionManager, _signal, context) => {
+          const extension = extensionById(extensionManager, extensionId);
+          if (!extension)
+            throw new Error(`Extension "${extensionId}" not found`);
+          await context.commit(
+            async (onCommitted) => await extensionManager.setExtensionDefaultActivation(
+              extensionId,
+              state,
+              onCommitted
+            )
+          );
+          return {
+            status: state === "enabled" ? "enabled" : "disabled",
+            name: extension.name
+          };
+        },
+        {
+          ...workspaceRegistry ? { refreshRuntimes: /* @__PURE__ */ __name(() => workspaceRegistry.list(), "refreshRuntimes") } : {}
+        }
+      );
+    }
+  );
+  app.post("/extensions/install", mutate({ strict: true }), (req, res) => {
+    const body = safeBody2(req);
+    const source = body["source"];
+    const activation = body["activation"];
+    const ref = body["ref"];
+    const autoUpdate = body["autoUpdate"];
+    const allowPreRelease = body["allowPreRelease"];
+    const registry = body["registry"];
+    if (typeof source !== "string" || !source) {
+      res.status(400).json({ error: "Missing or invalid source" });
+      return;
+    }
+    if (ref !== void 0 && (typeof ref !== "string" || !ref)) {
+      res.status(400).json({ error: "`ref` must be a non-empty string" });
+      return;
+    }
+    if (typeof ref === "string" && ref.startsWith("-")) {
+      res.status(400).json({ error: '`ref` must not start with "-"' });
+      return;
+    }
+    if (autoUpdate !== void 0 && typeof autoUpdate !== "boolean") {
+      res.status(400).json({ error: "`autoUpdate` must be a boolean" });
+      return;
+    }
+    if (allowPreRelease !== void 0 && typeof allowPreRelease !== "boolean") {
+      res.status(400).json({ error: "`allowPreRelease` must be a boolean" });
+      return;
+    }
+    if (registry !== void 0 && typeof registry !== "string") {
+      res.status(400).json({ error: "`registry` must be a string" });
+      return;
+    }
+    const registryUrl = typeof registry === "string" ? parseExtensionRegistryUrl(registry, res) : void 0;
+    if (registryUrl === null) return;
+    if (body["consent"] !== true) {
+      res.status(400).json({
+        error: "Extension installation requires explicit consent"
+      });
+      return;
+    }
+    if (!validateExtensionSourceHost(source, res)) return;
+    if (!activation || typeof activation !== "object") {
+      res.status(400).json({ error: "Missing initial activation" });
+      return;
+    }
+    const activationRecord = activation;
+    let initialActivation;
+    if (activationRecord["scope"] === "user") {
+      initialActivation = { scope: "user" };
+    } else if (activationRecord["scope"] === "workspace" && typeof activationRecord["workspaceId"] === "string" && workspaceRegistry) {
+      const runtime = workspaceRegistry.getByWorkspaceId(
+        activationRecord["workspaceId"]
+      );
+      if (!runtime) {
+        res.status(400).json({
+          error: "Unknown activation workspace",
+          code: "workspace_mismatch"
         });
+        return;
       }
+      if (!requireTrustedWorkspaceRuntime(runtime, res)) return;
+      initialActivation = {
+        scope: "workspace",
+        workspacePath: runtime.workspaceCwd
+      };
+    } else {
+      res.status(400).json({ error: "Invalid initial activation" });
+      return;
+    }
+    const manager = primaryController.createExtensionManager(
+      boundWorkspace,
+      true
+    );
+    sendOperation(
+      req,
+      res,
+      "POST /extensions/install",
+      manager,
+      "install",
+      { source },
+      async (extensionManager, _signal, context) => {
+        const prepared = await context.prepare(async (signal) => {
+          const metadata = await parseInstallSource(source, {
+            networkPolicy: "public"
+          });
+          if (metadata.type !== "git" && metadata.type !== "github-release" && metadata.type !== "npm") {
+            throw new Error(
+              "Only GitHub, Git, and npm extension installs are supported over the daemon endpoint."
+            );
+          }
+          if (!validateExtensionSourceMetadata(metadata)) {
+            throw new Error("`source` host is not allowed");
+          }
+          if (metadata.type === "npm" && ref !== void 0) {
+            throw new Error("--ref is not applicable for npm extensions.");
+          }
+          if (metadata.type !== "npm" && registryUrl !== void 0) {
+            throw new Error(
+              "--registry is only applicable for npm extensions."
+            );
+          }
+          if (metadata.type === "npm" && registryUrl) {
+            metadata.registryUrl = registryUrl;
+          }
+          return await extensionManager.prepareExtensionInstall({
+            installMetadata: {
+              ...metadata,
+              ...typeof ref === "string" ? { ref } : {},
+              ...typeof autoUpdate === "boolean" ? { autoUpdate } : {},
+              ...typeof allowPreRelease === "boolean" ? { allowPreRelease } : {}
+            },
+            requestConsent: /* @__PURE__ */ __name(() => Promise.resolve(), "requestConsent"),
+            cwd: boundWorkspace,
+            initialActivation,
+            signal
+          });
+        });
+        try {
+          const committed = await context.commit(
+            async (onCommitted) => await extensionManager.commitPreparedExtension(
+              prepared,
+              onCommitted
+            )
+          );
+          return {
+            status: "installed",
+            source,
+            name: committed.identity.name,
+            version: committed.version
+          };
+        } finally {
+          await extensionManager.disposePreparedExtension(prepared);
+        }
+      },
+      {
+        deadlineMs: EXTENSION_PREPARE_DEADLINE_MS,
+        ...workspaceRegistry ? { refreshRuntimes: /* @__PURE__ */ __name(() => workspaceRegistry.list(), "refreshRuntimes") } : {}
+      }
+    );
+  });
+  app.post(
+    "/extensions/check-updates",
+    mutate({ strict: true }),
+    (req, res) => {
+      const manager = primaryController.createExtensionManager(
+        boundWorkspace,
+        true
+      );
+      sendOperation(
+        req,
+        res,
+        "POST /extensions/check-updates",
+        manager,
+        "check-updates",
+        {},
+        async (extensionManager, signal, context) => {
+          const states = /* @__PURE__ */ Object.create(null);
+          await extensionManager.checkForAllExtensionUpdates(
+            (name, state) => {
+              states[name] = state;
+            },
+            signal,
+            async (task) => await context.prepare(async () => await task())
+          );
+          return { status: "checked", states };
+        },
+        {
+          skipRefresh: true,
+          deadlineMs: EXTENSION_UPDATE_CHECK_DEADLINE_MS
+        }
+      );
     }
   );
   app.post(
-    "/workspace/extensions/:name/disable",
+    "/extensions/:extensionId/update",
+    mutate({ strict: true }),
+    (req, res) => {
+      const extensionId = parseExtensionId(req, res);
+      if (!extensionId) return;
+      const manager = primaryController.createExtensionManager(
+        boundWorkspace,
+        true
+      );
+      sendOperation(
+        req,
+        res,
+        "POST /extensions/:extensionId/update",
+        manager,
+        "update",
+        { name: extensionId },
+        async (extensionManager, _signal, context) => {
+          const extension = extensionById(extensionManager, extensionId);
+          if (!extension)
+            throw new Error(`Extension "${extensionId}" not found`);
+          if (extension.installMetadata?.type !== "git" && extension.installMetadata?.type !== "archive-url" && extension.installMetadata?.type !== "github-release" && extension.installMetadata?.type !== "npm") {
+            throw new Error(
+              `Extension "${extension.name}" is not remotely updatable.`
+            );
+          }
+          const preparedResult = await context.prepare(
+            async (signal) => await extensionManager.prepareExtensionUpdate({
+              extension,
+              signal
+            })
+          );
+          if (preparedResult.upToDate) {
+            return {
+              status: "checked",
+              name: extension.name,
+              updated: false,
+              reason: "up_to_date"
+            };
+          }
+          try {
+            const committed = await context.commit(
+              async (onCommitted) => await extensionManager.commitPreparedExtension(
+                preparedResult.prepared,
+                onCommitted
+              )
+            );
+            return {
+              status: "updated",
+              name: extension.name,
+              updated: true,
+              version: committed.version
+            };
+          } finally {
+            await extensionManager.disposePreparedExtension(
+              preparedResult.prepared
+            );
+          }
+        },
+        {
+          deadlineMs: EXTENSION_PREPARE_DEADLINE_MS,
+          ...workspaceRegistry ? { refreshRuntimes: /* @__PURE__ */ __name(() => workspaceRegistry.list(), "refreshRuntimes") } : {}
+        }
+      );
+    }
+  );
+  app.delete(
+    "/extensions/:extensionId",
     mutate({ strict: true }),
     async (req, res) => {
+      const extensionId = parseExtensionId(req, res);
+      if (!extensionId) return;
+      const route = "DELETE /extensions/:extensionId";
+      if (!primaryController.validateExtensionMutationClient(req, res, {
+        requireClientId: false,
+        bridges: mutationClientBridges()
+      })) {
+        return;
+      }
       try {
-        if (!validateExtensionMutationClient(
-          req,
-          res,
-          "POST /workspace/extensions/:name/disable",
-          { requireClientId: false }
-        )) {
-          return;
-        }
-        const name = req.params["name"];
-        if (!name) {
-          res.status(400).json({ error: "Missing extension name" });
+        const manager = primaryController.createExtensionManager(
+          boundWorkspace,
+          true
+        );
+        const snapshot = await manager.getExtensionStoreSnapshot();
+        const policy = snapshot.extensions[extensionId];
+        if (!policy) {
+          res.status(204).end();
           return;
         }
-        const scope = parseExtensionScope(safeBody2(req), res);
-        if (scope === null) return;
-        runQueuedExtensionMutation(
-          "disable",
-          { name },
+        sendOperation(
+          req,
           res,
-          async (extensionManager) => {
-            const extension = findLoadedExtension(extensionManager, name);
-            if (!extension) {
-              throw new Error(`Extension "${name}" not found`);
-            }
-            await extensionManager.disableExtension(
-              extension.name,
-              scope,
-              boundWorkspace
+          route,
+          manager,
+          "uninstall",
+          { name: policy.name },
+          async (extensionManager, _signal, context) => {
+            await context.commit(
+              async (onCommitted) => await extensionManager.uninstallExtensionById(
+                extensionId,
+                false,
+                void 0,
+                onCommitted
+              )
             );
-            return { status: "disabled", name: extension.name };
+            return { status: "uninstalled", name: policy.name };
+          },
+          {
+            ...workspaceRegistry ? { refreshRuntimes: /* @__PURE__ */ __name(() => workspaceRegistry.list(), "refreshRuntimes") } : {}
           }
         );
-      } catch (err) {
-        sendBridgeError2(res, err, {
-          route: "POST /workspace/extensions/:name/disable"
-        });
+      } catch (error2) {
+        sendBridgeError2(res, error2, { route });
       }
     }
   );
-  app.post(
-    "/workspace/extensions/:name/update",
-    mutate({ strict: true }),
-    async (req, res) => {
+  if (workspaceRegistry) {
+    const registry = workspaceRegistry;
+    app.get("/workspaces/:workspace/extensions", async (req, res) => {
+      const runtime = resolveWorkspaceRuntimeFromParam(registry, req, res);
+      if (!runtime) return;
       try {
-        if (!validateExtensionMutationClient(
-          req,
-          res,
-          "POST /workspace/extensions/:name/update"
-        )) {
-          return;
-        }
-        const name = req.params["name"];
-        if (!name) {
-          res.status(400).json({ error: "Missing extension name" });
-          return;
-        }
-        runQueuedExtensionMutation(
-          "update",
-          { name },
+        const manager = primaryController.createExtensionManager(
+          runtime.workspaceCwd,
+          runtime.trusted
+        );
+        const snapshot = await manager.refreshCacheWithSnapshot();
+        const extensions = manager.getLoadedExtensions().map((extension) => {
+          const activation = manager.getExtensionActivationFromSnapshot(
+            extension.id,
+            snapshot,
+            runtime.workspaceCwd
+          );
+          return {
+            extensionId: extension.id,
+            name: extension.name,
+            version: extension.version,
+            defaultActivation: activation.default,
+            workspaceActivation: activation.workspace === "inherit" ? null : activation.workspace,
+            effectiveActivation: activation.effective,
+            activationSource: activation.source
+          };
+        });
+        res.status(200).json({
+          v: 1,
+          workspaceId: runtime.workspaceId,
+          workspaceCwd: runtime.workspaceCwd,
+          trusted: runtime.trusted,
+          desiredGeneration: snapshot.generation,
+          appliedGeneration: appliedGenerationByWorkspaceId.get(runtime.workspaceId) ?? 0,
+          extensions
+        });
+      } catch (error2) {
+        sendBridgeError2(res, error2, {
+          route: "GET /workspaces/:workspace/extensions"
+        });
+      }
+    });
+    app.put(
+      "/workspaces/:workspace/extensions/:extensionId/activation",
+      mutate({ strict: true }),
+      (req, res) => {
+        const runtime = resolveWorkspaceRuntimeFromParam(registry, req, res);
+        if (!runtime || !requireTrustedWorkspaceRuntime(runtime, res)) return;
+        const extensionId = parseExtensionId(req, res);
+        if (!extensionId) return;
+        const state = parseActivationState(req, res);
+        if (!state) return;
+        const manager = primaryController.createExtensionManager(
+          runtime.workspaceCwd,
+          true
+        );
+        sendOperation(
+          req,
           res,
-          async (extensionManager) => {
-            const extension = findLoadedExtension(extensionManager, name);
+          "PUT /workspaces/:workspace/extensions/:extensionId/activation",
+          manager,
+          "activation",
+          { name: extensionId },
+          async (extensionManager, _signal, context) => {
+            const extension = extensionById(extensionManager, extensionId);
             if (!extension) {
-              throw new Error(`Extension "${name}" not found`);
-            }
-            let updateError;
-            const updateState = await withExtensionTimeout(
-              checkForExtensionUpdate(extension, extensionManager).catch(
-                (err) => {
-                  updateError = err;
-                  return "error" /* ERROR */;
-                }
-              ),
-              EXTENSION_REFRESH_TIMEOUT_MS,
-              "extension update check"
-            );
-            if (updateState === "error" /* ERROR */) {
-              const message = updateError === void 0 ? void 0 : redactUrlCredentials(
-                updateError instanceof Error ? updateError.message : String(updateError)
-              );
-              throw new Error(
-                `Update check failed for extension "${extension.name}"${message ? `: ${message}` : ""}`
-              );
+              throw new Error(`Extension "${extensionId}" not found`);
             }
-            if (updateState !== "update available" /* UPDATE_AVAILABLE */) {
-              throw new Error(`Extension "${extension.name}" has no update`);
-            }
-            const info = await extensionManager.updateExtension(
-              extension,
-              updateState,
-              () => void 0
+            await context.commit(
+              async (onCommitted) => await extensionManager.setExtensionWorkspaceActivation(
+                extensionId,
+                runtime.workspaceCwd,
+                state,
+                onCommitted
+              )
             );
             return {
-              status: "updated",
-              name: extension.name,
-              ...info?.updatedVersion ? { version: info.updatedVersion } : {}
+              status: state === "enabled" ? "enabled" : "disabled",
+              name: extension.name
             };
-          }
+          },
+          { refreshRuntimes: [runtime] }
         );
-      } catch (err) {
-        sendBridgeError2(res, err, {
-          route: "POST /workspace/extensions/:name/update"
-        });
       }
-    }
-  );
-  app.delete(
-    "/workspace/extensions/:name",
-    mutate({ strict: true }),
-    async (req, res) => {
-      try {
-        if (!validateExtensionMutationClient(
+    );
+    app.delete(
+      "/workspaces/:workspace/extensions/:extensionId/activation",
+      mutate({ strict: true }),
+      (req, res) => {
+        const runtime = resolveWorkspaceRuntimeFromParam(registry, req, res);
+        if (!runtime || !requireTrustedWorkspaceRuntime(runtime, res)) return;
+        const extensionId = parseExtensionId(req, res);
+        if (!extensionId) return;
+        const manager = primaryController.createExtensionManager(
+          runtime.workspaceCwd,
+          true
+        );
+        sendOperation(
           req,
           res,
-          "DELETE /workspace/extensions/:name"
-        )) {
-          return;
-        }
-        const name = req.params["name"];
-        if (!name) {
-          res.status(400).json({ error: "Missing extension name" });
-          return;
-        }
-        runQueuedExtensionMutation(
-          "uninstall",
-          { name },
-          res,
-          async (extensionManager) => {
-            const extension = findLoadedExtension(extensionManager, name);
+          "DELETE /workspaces/:workspace/extensions/:extensionId/activation",
+          manager,
+          "activation",
+          { name: extensionId },
+          async (extensionManager, _signal, context) => {
+            const extension = extensionById(extensionManager, extensionId);
             if (!extension) {
-              throw new Error(`Extension "${name}" not found`);
+              throw new Error(`Extension "${extensionId}" not found`);
             }
-            await extensionManager.uninstallExtension(
-              extension.name,
-              false,
-              boundWorkspace
+            const snapshot = await context.commit(
+              async (onCommitted) => await extensionManager.clearExtensionWorkspaceActivation(
+                extensionId,
+                runtime.workspaceCwd,
+                onCommitted
+              )
             );
-            return { status: "uninstalled", name: extension.name };
-          }
+            const activation = extensionManager.getExtensionActivationFromSnapshot(
+              extensionId,
+              snapshot,
+              runtime.workspaceCwd
+            );
+            return { status: activation.effective, name: extension.name };
+          },
+          { refreshRuntimes: [runtime] }
         );
-      } catch (err) {
-        sendBridgeError2(res, err, {
-          route: "DELETE /workspace/extensions/:name"
-        });
       }
-    }
-  );
+    );
+    app.post(
+      "/workspaces/:workspace/extensions/refresh",
+      mutate({ strict: true }),
+      (req, res) => {
+        const runtime = resolveWorkspaceRuntimeFromParam(registry, req, res);
+        if (!runtime || !requireTrustedWorkspaceRuntime(runtime, res)) return;
+        const manager = primaryController.createExtensionManager(
+          runtime.workspaceCwd,
+          true
+        );
+        sendOperation(
+          req,
+          res,
+          "POST /workspaces/:workspace/extensions/refresh",
+          manager,
+          "refresh",
+          {},
+          async () => ({ status: "refreshed" }),
+          { refreshRuntimes: [runtime] }
+        );
+      }
+    );
+  }
 }
 __name(registerWorkspaceExtensionRoutes, "registerWorkspaceExtensionRoutes");
 
@@ -16011,7 +17783,7 @@ __name(registerPermissionRoutes, "registerPermissionRoutes");
 
 // packages/cli/src/serve/routes/session.ts
 init_esbuild_shims();
-import * as crypto2 from "node:crypto";
+import * as crypto3 from "node:crypto";
 import * as path11 from "node:path";
 
 // packages/cli/src/serve/server/prompt-deadline.ts
@@ -16714,14 +18486,14 @@ function registerSessionRoutes(app, deps) {
     sessionShellCommandEnabled
   } = deps;
   const LANGUAGE_CODES = deps.languageCodes;
-  const transcriptCursorMasterKey = crypto2.randomBytes(32);
+  const transcriptCursorMasterKey = crypto3.randomBytes(32);
   const transcriptCursorCodecs = /* @__PURE__ */ new Map();
   const getTranscriptCursorCodec = /* @__PURE__ */ __name((runtime) => {
     const canonicalCwd = canonicalizeWorkspace(runtime.workspaceCwd);
     const cacheKey = `${runtime.workspaceId}\0${canonicalCwd}`;
     const cached = transcriptCursorCodecs.get(cacheKey);
     if (cached) return cached;
-    const derivedKey = crypto2.hkdfSync(
+    const derivedKey = crypto3.hkdfSync(
       "sha256",
       transcriptCursorMasterKey,
       Buffer.alloc(0),
@@ -16881,6 +18653,51 @@ function registerSessionRoutes(app, deps) {
     }
     return runtime;
   }, "requireTrustedRuntimeForWorkspaceRoute");
+  const handleSessionExport = /* @__PURE__ */ __name(async (req, res, target) => {
+    const sessionId = requireSessionId(req, res);
+    if (sessionId === null) return;
+    const rawFormat = req.query["format"];
+    const format = parseSessionExportFormat(rawFormat);
+    if (!format) {
+      res.status(400).json({
+        error: "Invalid export format",
+        code: "invalid_export_format",
+        format: typeof rawFormat === "string" ? rawFormat : String(rawFormat),
+        allowedFormats: sessionExportFormatValues()
+      });
+      return;
+    }
+    try {
+      const result = await archiveCoordinator.runSharedMany(
+        [sessionId],
+        async () => {
+          await assertSessionLoadable(target.workspaceCwd, sessionId);
+          return exportSessionTranscript({
+            workspaceCwd: target.workspaceCwd,
+            sessionId,
+            format,
+            config: { getChannel: /* @__PURE__ */ __name(() => "daemon", "getChannel") }
+          });
+        }
+      );
+      const filename = result.filename.replace(/["\\\r\n]/g, "_");
+      res.status(200).set("Cache-Control", "no-store").set("X-Content-Type-Options", "nosniff").set("Content-Type", result.mimeType).set("Content-Disposition", `attachment; filename="${filename}"`).send(result.content);
+    } catch (err) {
+      if (target.workspaceQualified && err instanceof SessionNotFoundError) {
+        res.status(404).json({
+          error: err.message,
+          code: "session_not_found",
+          sessionId: err.sessionId
+        });
+        return;
+      }
+      sendBridgeError2(res, err, {
+        route: target.route,
+        sessionId,
+        ...target.workspaceQualified ? { workspaceCwd: target.workspaceCwd } : {}
+      });
+    }
+  }, "handleSessionExport");
   const sendAmbiguousSessionOwner = /* @__PURE__ */ __name((res, route, sessionId, runtimes) => {
     const workspaceIds = runtimes.map((runtime) => runtime.workspaceId);
     logSessionRoutingFailure(route, "ambiguous", {
@@ -17447,40 +19264,20 @@ function registerSessionRoutes(app, deps) {
     }
   });
   app.get("/session/:id/export", async (req, res) => {
-    const sessionId = requireSessionId(req, res);
-    if (sessionId === null) return;
-    const rawFormat = req.query["format"];
-    const format = parseSessionExportFormat(rawFormat);
-    if (!format) {
-      res.status(400).json({
-        error: "Invalid export format",
-        code: "invalid_export_format",
-        format: typeof rawFormat === "string" ? rawFormat : String(rawFormat),
-        allowedFormats: sessionExportFormatValues()
-      });
-      return;
-    }
-    try {
-      const result = await archiveCoordinator.runSharedMany(
-        [sessionId],
-        async () => {
-          await assertSessionLoadable(boundWorkspace, sessionId);
-          return exportSessionTranscript({
-            workspaceCwd: boundWorkspace,
-            sessionId,
-            format,
-            config: { getChannel: /* @__PURE__ */ __name(() => "daemon", "getChannel") }
-          });
-        }
-      );
-      const filename = result.filename.replace(/["\\\r\n]/g, "_");
-      res.status(200).set("Cache-Control", "no-store").set("X-Content-Type-Options", "nosniff").set("Content-Type", result.mimeType).set("Content-Disposition", `attachment; filename="${filename}"`).send(result.content);
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "GET /session/:id/export",
-        sessionId
-      });
-    }
+    await handleSessionExport(req, res, {
+      route: "GET /session/:id/export",
+      workspaceCwd: boundWorkspace
+    });
+  });
+  app.get("/workspaces/:workspace/session/:id/export", async (req, res) => {
+    const route = "GET /workspaces/:workspace/session/:id/export";
+    const runtime = requireTrustedRuntimeForWorkspaceRoute(req, res, route);
+    if (!runtime) return;
+    await handleSessionExport(req, res, {
+      route,
+      workspaceCwd: runtime.workspaceCwd,
+      workspaceQualified: true
+    });
   });
   app.get("/session/:id/transcript", async (req, res) => {
     const route = "GET /session/:id/transcript";
@@ -17825,7 +19622,7 @@ function registerSessionRoutes(app, deps) {
       async (req, res, sessionId, runtime) => {
         const clientId = parseClientIdHeader(req, res);
         if (clientId === null) return;
-        const promptId = crypto2.randomUUID();
+        const promptId = crypto3.randomUUID();
         res.status(200).json(
           await runtime.bridge.continueSession(sessionId, {
             ...clientId !== void 0 ? { clientId } : {},
@@ -17872,7 +19669,7 @@ function registerSessionRoutes(app, deps) {
         }
         const clientId = parseClientIdHeader(req, res);
         if (clientId === null) return;
-        const promptId = crypto2.randomUUID();
+        const promptId = crypto3.randomUUID();
         const forwardedBody = { ...body };
         delete forwardedBody["deadlineMs"];
         const lastEventId = ownerBridge.getSessionLastEventId(sessionId);
@@ -20258,7 +22055,11 @@ function createServeFeatures(deps) {
     cachedVoiceTranscriptionAvailable = void 0;
   }, "invalidateServeFeaturesCache");
   const getCachedVoiceTranscriptionAvailable = /* @__PURE__ */ __name(() => {
-    cachedVoiceTranscriptionAvailable ??= isWorkspaceVoiceTranscriptionAvailable(boundWorkspace);
+    cachedVoiceTranscriptionAvailable ??= isWorkspaceVoiceTranscriptionAvailable(
+      boundWorkspace,
+      env,
+      deps.env !== void 0
+    );
     return cachedVoiceTranscriptionAvailable;
   }, "getCachedVoiceTranscriptionAvailable");
   return {
@@ -20297,10 +22098,11 @@ function createServeFeatures(deps) {
   };
 }
 __name(createServeFeatures, "createServeFeatures");
-function isWorkspaceVoiceTranscriptionAvailable(boundWorkspace) {
+function isWorkspaceVoiceTranscriptionAvailable(boundWorkspace, env, skipLoadEnvironment) {
   try {
     return hasConfiguredBatchVoiceTranscriptionModel(
-      loadSettings(boundWorkspace)
+      loadSettings(boundWorkspace, { skipLoadEnvironment }),
+      { env }
     );
   } catch (err) {
     writeStderrLine(
@@ -20344,15 +22146,13 @@ function registerCapabilitiesRoutes(app, deps) {
           maxTotalSessions: deps.maxTotalSessions === void 0 || deps.maxTotalSessions === 0 || deps.maxTotalSessions === Number.POSITIVE_INFINITY ? null : deps.maxTotalSessions
         } : {}
       },
-      ...multiWorkspace ? {
-        workspaces: runtimes.map((runtime) => ({
-          id: runtime.workspaceId,
-          cwd: runtime.workspaceCwd,
-          primary: runtime.primary,
-          trusted: runtime.trusted,
-          ...runtimeRemoval ? { removable: runtime.removable === true } : {}
-        }))
-      } : {},
+      workspaces: runtimes.map((runtime) => ({
+        id: runtime.workspaceId,
+        cwd: runtime.workspaceCwd,
+        primary: runtime.primary,
+        trusted: runtime.trusted,
+        ...runtimeRemoval ? { removable: runtime.removable === true } : {}
+      })),
       supportedLanguages: deps.languageCodes
     };
     res.status(200).json(envelope);
@@ -20942,6 +22742,24 @@ function sendPermissionVoteError(res, err, ctx, daemonLog) {
 }
 __name(sendPermissionVoteError, "sendPermissionVoteError");
 function sendBridgeError(res, err, ctx, daemonLog) {
+  if (err instanceof WorkspaceSkillNotFoundError) {
+    res.status(404).json({
+      error: err.message,
+      code: "skill_not_found",
+      skillName: err.skillName
+    });
+    return;
+  }
+  if (err instanceof WorkspaceSkillNotToggleableError) {
+    res.status(409).json({
+      error: err.message,
+      code: "skill_not_toggleable",
+      skillName: err.skillName,
+      reason: err.reason,
+      ...err.lockedScope ? { lockedScope: err.lockedScope } : {}
+    });
+    return;
+  }
   if (err instanceof InvalidSessionTranscriptCursorError) {
     res.status(400).json({
       error: err.message,
@@ -22221,11 +24039,20 @@ function resolveDaemonTelemetryRoute(req) {
       sessionId: workspaceTranscript[1]
     };
   }
+  const workspaceExport = path15.match(
+    /^\/workspaces\/[^/]+\/session\/([^/]+)\/export$/
+  );
+  if (workspaceExport?.[1] && req.method === "GET") {
+    return {
+      route: "GET /workspaces/:workspace/session/:id/export",
+      sessionId: workspaceExport[1]
+    };
+  }
   const pluralWorkspacePrefix = /^\/workspaces\/[^/]+/;
   if (pluralWorkspacePrefix.test(path15)) {
     const suffix = path15.replace(pluralWorkspacePrefix, "/workspace");
     if (req.method === "GET") {
-      if (suffix === "/workspace/mcp" || suffix === "/workspace/skills" || suffix === "/workspace/tools" || suffix === "/workspace/providers" || suffix === "/workspace/env" || suffix === "/workspace/preflight" || suffix === "/workspace/hooks" || suffix === "/workspace/settings" || suffix === "/workspace/permissions" || suffix === "/workspace/trust" || suffix === "/workspace/memory" || suffix === "/workspace/agents") {
+      if (suffix === "/workspace/mcp" || suffix === "/workspace/skills" || suffix === "/workspace/tools" || suffix === "/workspace/providers" || suffix === "/workspace/env" || suffix === "/workspace/preflight" || suffix === "/workspace/hooks" || suffix === "/workspace/settings" || suffix === "/workspace/voice" || suffix === "/workspace/permissions" || suffix === "/workspace/trust" || suffix === "/workspace/memory" || suffix === "/workspace/agents") {
         return { route: `GET ${suffix}` };
       }
       if (/^\/workspace\/agents\/[^/]+$/.test(suffix)) {
@@ -22246,7 +24073,7 @@ function resolveDaemonTelemetryRoute(req) {
       }
     }
     if (req.method === "POST") {
-      if (suffix === "/workspace/settings" || suffix === "/workspace/permissions" || suffix === "/workspace/trust/request" || suffix === "/workspace/init" || suffix === "/workspace/reload" || suffix === "/workspace/file/write" || suffix === "/workspace/file/edit" || suffix === "/workspace/mcp/servers" || suffix === "/workspace/memory" || suffix === "/workspace/agents" || suffix === "/workspace/sessions/delete" || suffix === "/workspace/sessions/archive" || suffix === "/workspace/sessions/unarchive" || suffix === "/workspace/session-groups") {
+      if (suffix === "/workspace/settings" || suffix === "/workspace/voice" || suffix === "/workspace/voice/transcribe" || suffix === "/workspace/permissions" || suffix === "/workspace/trust/request" || suffix === "/workspace/init" || suffix === "/workspace/reload" || suffix === "/workspace/file/write" || suffix === "/workspace/file/edit" || suffix === "/workspace/mcp/servers" || suffix === "/workspace/memory" || suffix === "/workspace/agents" || suffix === "/workspace/sessions/delete" || suffix === "/workspace/sessions/archive" || suffix === "/workspace/sessions/unarchive" || suffix === "/workspace/session-groups") {
         return { route: `POST ${suffix}` };
       }
       if (/^\/workspace\/tools\/[^/]+\/enable$/.test(suffix)) {
@@ -23265,7 +25092,8 @@ function registerWorkspaceManagementRoutes(app, deps) {
   const workspaceActivity = /* @__PURE__ */ __name((runtime) => {
     const controllerActivity = runtimeRemoval?.getActivity(runtime) ?? {
       pendingSessionStarts: 0,
-      channelWorkers: 0
+      channelWorkers: 0,
+      voiceSessions: 0
     };
     const acpActivity = getAcpHandle?.()?.getWorkspaceActivity(
       runtime.workspaceId
@@ -23276,7 +25104,8 @@ function registerWorkspaceManagementRoutes(app, deps) {
       activePrompts: runtime.bridge.activePromptCount,
       acpConnections: acpActivity.acpConnections,
       memoryTasks: acpActivity.memoryTasks,
-      channelWorkers: controllerActivity.channelWorkers
+      channelWorkers: controllerActivity.channelWorkers,
+      voiceSessions: controllerActivity.voiceSessions
     };
   }, "workspaceActivity");
   const isBusy = /* @__PURE__ */ __name((activity) => Object.values(activity).some((count) => count > 0), "isBusy");
@@ -24479,6 +26308,106 @@ function registerWorkspaceQualifiedToolsRoutes(app, deps) {
 }
 __name(registerWorkspaceQualifiedToolsRoutes, "registerWorkspaceQualifiedToolsRoutes");
 
+// packages/cli/src/serve/routes/workspace-skills.ts
+init_esbuild_shims();
+function parseSkillToggleRequest(req, res, safeBody2) {
+  const rawSkillName = req.params["name"];
+  if (!rawSkillName || typeof rawSkillName !== "string") {
+    res.status(400).json({
+      error: "Skill name path parameter is required",
+      code: "invalid_skill_name"
+    });
+    return void 0;
+  }
+  const skillName = rawSkillName.trim();
+  if (skillName.length === 0) {
+    res.status(400).json({
+      error: "Skill name path parameter is required",
+      code: "invalid_skill_name"
+    });
+    return void 0;
+  }
+  if (skillName.length > MAX_SKILL_NAME_LENGTH) {
+    res.status(400).json({
+      error: `Skill name exceeds ${MAX_SKILL_NAME_LENGTH}-character limit`,
+      code: "invalid_skill_name"
+    });
+    return void 0;
+  }
+  const enabled = safeBody2(req)["enabled"];
+  if (typeof enabled !== "boolean") {
+    res.status(400).json({
+      error: "`enabled` is required and must be a boolean",
+      code: "invalid_enabled_flag"
+    });
+    return void 0;
+  }
+  return { skillName, enabled };
+}
+__name(parseSkillToggleRequest, "parseSkillToggleRequest");
+function registerWorkspaceSkillsRoutes(app, deps) {
+  const buildWorkspaceCtx = createBuildWorkspaceCtx(
+    deps.workspaceRuntime.workspaceCwd
+  );
+  const route = "POST /workspace/skills/:name/enable";
+  app.post(
+    "/workspace/skills/:name/enable",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      if (!requireTrustedWorkspaceRuntime(deps.workspaceRuntime, res)) return;
+      const input = parseSkillToggleRequest(req, res, deps.safeBody);
+      if (!input) return;
+      const clientId = deps.parseAndValidateClientId(req, res);
+      if (clientId === null) return;
+      try {
+        const result = await deps.workspaceRuntime.workspaceService.setWorkspaceSkillEnabled(
+          buildWorkspaceCtx(route, clientId),
+          input.skillName,
+          input.enabled
+        );
+        res.status(200).json(result);
+      } catch (err) {
+        deps.sendBridgeError(res, err, { route });
+      }
+    }
+  );
+}
+__name(registerWorkspaceSkillsRoutes, "registerWorkspaceSkillsRoutes");
+function registerWorkspaceQualifiedSkillsRoutes(app, deps) {
+  const route = "POST /workspaces/:workspace/skills/:name/enable";
+  app.post(
+    "/workspaces/:workspace/skills/:name/enable",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const runtime = resolveWorkspaceRuntimeFromParam(
+        deps.workspaceRegistry,
+        req,
+        res
+      );
+      if (!runtime || !requireTrustedWorkspaceRuntime(runtime, res)) return;
+      const input = parseSkillToggleRequest(req, res, deps.safeBody);
+      if (!input) return;
+      const clientId = parseAndValidateWorkspaceClientId(
+        req,
+        res,
+        runtime.bridge
+      );
+      if (clientId === null) return;
+      try {
+        const result = await runtime.workspaceService.setWorkspaceSkillEnabled(
+          createBuildWorkspaceCtx(runtime.workspaceCwd)(route, clientId),
+          input.skillName,
+          input.enabled
+        );
+        res.status(200).json(result);
+      } catch (err) {
+        deps.sendBridgeError(res, err, { route });
+      }
+    }
+  );
+}
+__name(registerWorkspaceQualifiedSkillsRoutes, "registerWorkspaceQualifiedSkillsRoutes");
+
 // packages/cli/src/serve/routes/channel-webhooks.ts
 init_esbuild_shims();
 var import_express4 = __toESM(require_express(), 1);
@@ -24772,7 +26701,10 @@ function describeRegistryPrimaryForConflict(registry) {
 }
 __name(describeRegistryPrimaryForConflict, "describeRegistryPrimaryForConflict");
 function getRuntimeEffectiveEnv(metadata) {
-  return metadata?.effectiveEnv;
+  if (!metadata || metadata.mode === "parent-process") {
+    return metadata?.effectiveEnv;
+  }
+  return metadata.effectiveEnv ?? {};
 }
 __name(getRuntimeEffectiveEnv, "getRuntimeEffectiveEnv");
 var DEFAULT_SESSION_IDLE_TIMEOUT_MS = 30 * 6e4;
@@ -24788,6 +26720,11 @@ function computeKeepaliveIntervalMs(idleTimeoutMs) {
 }
 __name(computeKeepaliveIntervalMs, "computeKeepaliveIntervalMs");
 function createServeApp(opts, getPort = () => opts.port, deps = {}) {
+  if (deps.workspaceRuntimeRemoval && !deps.voiceCoordinator) {
+    throw new Error(
+      "createServeApp: deps.workspaceRuntimeRemoval requires the matching deps.voiceCoordinator."
+    );
+  }
   const app = (0, import_express5.default)();
   const injectedWorkspaceRegistry = deps.workspaceRegistry;
   const boundWorkspace = injectedWorkspaceRegistry?.primary.workspaceCwd ?? deps.boundWorkspace ?? canonicalizeWorkspace(opts.workspace ?? process.cwd());
@@ -24880,6 +26817,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     workspaceRuntimeRemovalAvailable: deps.workspaceRuntimeRemoval !== void 0,
     ...primaryEffectiveEnv ? { env: primaryEffectiveEnv } : {}
   });
+  app.locals.invalidateServeFeaturesCache = invalidateServeFeaturesCache;
   const statusProvider = deps.statusProvider ?? createDaemonStatusProvider(
     primaryEffectiveEnv ? { env: primaryEffectiveEnv } : {}
   );
@@ -24945,12 +26883,18 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       primaryEffectiveEnv ? { env: primaryEffectiveEnv } : {}
     ),
     workspaceSkillsStatusProvider: createWorkspaceSkillsStatusProvider(),
+    ...primaryEffectiveEnv ? { voiceEnv: primaryEffectiveEnv } : {},
     isChannelLive: /* @__PURE__ */ __name(() => bridge.isChannelLive(), "isChannelLive"),
     persistDisabledTools: deps.persistDisabledTools ?? (async () => {
       throw new Error(
         "setWorkspaceToolEnabled requires persistDisabledTools in ServeAppDeps"
       );
     }),
+    persistDisabledSkills: deps.persistDisabledSkills ?? (async () => {
+      throw new Error(
+        "setWorkspaceSkillEnabled requires persistDisabledSkills in ServeAppDeps"
+      );
+    }),
     queryWorkspaceStatus: /* @__PURE__ */ __name((method, idle) => bridge.queryWorkspaceStatus(method, idle), "queryWorkspaceStatus"),
     invokeWorkspaceCommand: /* @__PURE__ */ __name((method, params, invokeOpts) => bridge.invokeWorkspaceCommand(method, params, invokeOpts), "invokeWorkspaceCommand"),
     preheatAcpChild: /* @__PURE__ */ __name(() => bridge.preheat(), "preheatAcpChild"),
@@ -24983,6 +26927,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   );
   app.locals.workspaceRegistry = workspaceRegistry;
   const primaryRuntime = workspaceRegistry.primary;
+  const voiceCoordinator = deps.voiceCoordinator ?? new WorkspaceVoiceCoordinator();
   const primaryBoundWorkspace = primaryRuntime.workspaceCwd;
   const primaryBridge = primaryRuntime.bridge;
   const primaryWorkspace = primaryRuntime.workspaceService;
@@ -25218,6 +27163,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     mutate,
     safeBody,
     sendBridgeError: sendBridgeError2,
+    workspaceRegistry,
     ...deps.maxExtensionOperationHistory === void 0 ? {} : { maxExtensionOperationHistory: deps.maxExtensionOperationHistory }
   });
   registerWorkspaceFileReadRoutes(app, {
@@ -25319,9 +27265,22 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     persistSetting: deps.persistSetting,
     persistSettings: deps.persistSettings,
     transcribe: deps.voiceTranscriber,
+    env: getRuntimeEffectiveEnv(primaryRuntime.env),
+    acquireVoiceLease: /* @__PURE__ */ __name(() => voiceCoordinator.acquire(primaryRuntime), "acquireVoiceLease"),
     broadcastSettingsChanged,
     parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, primaryBridge), "parseAndValidateClientId")
   });
+  registerWorkspaceQualifiedVoiceRoutes(app, {
+    workspaceRegistry,
+    mutate,
+    safeBody,
+    persistSetting: deps.persistSetting,
+    persistSettings: deps.persistSettings,
+    transcribe: deps.voiceTranscriber,
+    acquireVoiceLease: /* @__PURE__ */ __name((runtime) => voiceCoordinator.acquire(runtime), "acquireVoiceLease"),
+    parseAndValidateClientId: /* @__PURE__ */ __name((req, res, runtime) => parseAndValidateWorkspaceClientId(req, res, runtime.bridge), "parseAndValidateClientId"),
+    invalidateServeFeaturesCache
+  });
   if (deps.persistSettings) {
     registerWorkspaceModelsRoutes(app, {
       boundWorkspace: primaryBoundWorkspace,
@@ -25435,6 +27394,19 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     safeBody,
     sendBridgeError: sendBridgeError2
   });
+  registerWorkspaceSkillsRoutes(app, {
+    workspaceRuntime: primaryRuntime,
+    mutate,
+    safeBody,
+    sendBridgeError: sendBridgeError2,
+    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, primaryBridge), "parseAndValidateClientId")
+  });
+  registerWorkspaceQualifiedSkillsRoutes(app, {
+    workspaceRegistry,
+    mutate,
+    safeBody,
+    sendBridgeError: sendBridgeError2
+  });
   registerScheduledTasksRoutes(app, {
     boundWorkspace: primaryBoundWorkspace,
     mutate,
@@ -25553,10 +27525,15 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       {
         path: "/voice/stream",
         onConnection: createVoiceWsConnectionHandler(primaryBoundWorkspace, {
-          env: getRuntimeEffectiveEnv(primaryRuntime.env)
+          env: getRuntimeEffectiveEnv(primaryRuntime.env),
+          acquireVoiceLease: /* @__PURE__ */ __name(() => voiceCoordinator.acquire(primaryRuntime), "acquireVoiceLease")
         })
       }
-    ]
+    ],
+    workspaceVoiceConnection: /* @__PURE__ */ __name((runtime, ws, req) => createVoiceWsConnectionHandler(runtime.workspaceCwd, {
+      env: getRuntimeEffectiveEnv(runtime.env),
+      acquireVoiceLease: /* @__PURE__ */ __name(() => voiceCoordinator.acquire(runtime), "acquireVoiceLease")
+    })(ws, req), "workspaceVoiceConnection")
   });
   if (acpHandleRef.current) {
     app.locals["acpHandle"] = acpHandleRef.current;