@qwen-code/qwen-code 0.21.0 → 0.21.1-simplify-system-prompt.0

package/chunks/{server-4UMH7OIZ.js → server-HRZ23U7M.js}

@@ -16,7 +16,7 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-RIBKPMRP.js";
+} from "./chunk-J6D3VXCC.js";
 import {
   openQwenAsrRealtimeStream,
   openVoiceStream,
@@ -33,66 +33,17 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-EBJQ6AXW.js";
+} from "./chunk-DM22XS4K.js";
 import {
   OBSERVED_CONTACT_MAX_FRESH_WITHIN_SECONDS,
   ObservedChannelContactStore
 } from "./chunk-RHLZR4E5.js";
 import "./chunk-IPUUTYMV.js";
-import "./chunk-WCXCRJYB.js";
+import "./chunk-BRRAJXPA.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
 import "./chunk-QTERJVPZ.js";
 import "./chunk-3Z43GZUQ.js";
-import {
-  EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
-  MAX_WORKSPACE_SKILL_NAME_LENGTH,
-  WorkspaceSkillManagementError,
-  WorkspaceVoiceError,
-  buildWorkspaceVoiceSettingsWrites,
-  buildWorkspaceVoiceStatus,
-  createDaemonWorkspaceService,
-  hasConfiguredBatchVoiceTranscriptionModel,
-  transcribeWorkspaceVoiceAudio,
-  validateWorkspaceSkillName,
-  validateWorkspaceVoiceState,
-  voiceSettingsScopeToWire
-} from "./chunk-TGILQ3YH.js";
-import {
-  PermissionRulesValidationError,
-  buildPermissionSettings,
-  isPermissionRuleType,
-  normalizePermissionRules,
-  readPermissionRuleSet
-} from "./chunk-VRYUBFMC.js";
-import {
-  assertVoiceBaseUrlNetworkAllowed,
-  isStreamingVoiceModel,
-  resolveVoiceStreamConfig,
-  resolveVoiceTranscriptionConfig,
-  sanitizeVoiceErrorMessage,
-  transcribeVoiceAudio
-} from "./chunk-H4SBPHSA.js";
-import {
-  isVoiceEnabled,
-  isVoiceMode,
-  readVoiceModel
-} from "./chunk-YBL3QUDD.js";
-import "./chunk-ZD6UTE4A.js";
-import {
-  WorkspacePermissionRulesSessionRequiredError,
-  WorkspaceSettingsPartialPersistError,
-  WorkspaceSkillNotFoundError,
-  WorkspaceSkillNotToggleableError
-} from "./chunk-OA4JVLSA.js";
-import {
-  createTotalSessionAdmissionController
-} from "./chunk-VYPFXUCB.js";
-import {
-  createSingleWorkspaceRegistry,
-  createWorkspaceSessionOwnerIndex
-} from "./chunk-UGYMA4EI.js";
-import "./chunk-GRC5HGPI.js";
 import {
   CAPABILITIES_SCHEMA_VERSION,
   CLIENT_ID_HEADER,
@@ -150,33 +101,87 @@ import {
   setRateLimiter,
   unsafeRevealSecret,
   validateMcpRuntimeServerName
-} from "./chunk-IJTOWOD7.js";
+} from "./chunk-3JAQDSXN.js";
 import {
   isLoopbackBind
 } from "./chunk-RXFQM6FQ.js";
+import {
+  EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
+  MAX_WORKSPACE_SKILL_NAME_LENGTH,
+  WorkspaceSkillManagementError,
+  WorkspaceVoiceError,
+  buildWorkspaceVoiceSettingsWrites,
+  buildWorkspaceVoiceStatus,
+  createDaemonWorkspaceService,
+  hasConfiguredBatchVoiceTranscriptionModel,
+  transcribeWorkspaceVoiceAudio,
+  validateWorkspaceSkillName,
+  validateWorkspaceVoiceState,
+  voiceSettingsScopeToWire
+} from "./chunk-2Q3OT4OV.js";
+import {
+  PermissionRulesValidationError,
+  buildPermissionSettings,
+  isPermissionRuleType,
+  normalizePermissionRules,
+  readPermissionRuleSet
+} from "./chunk-LZEMEFKY.js";
+import {
+  assertVoiceBaseUrlNetworkAllowed,
+  isStreamingVoiceModel,
+  resolveVoiceStreamConfig,
+  resolveVoiceTranscriptionConfig,
+  sanitizeVoiceErrorMessage,
+  transcribeVoiceAudio
+} from "./chunk-2OM7GEXO.js";
+import {
+  isVoiceEnabled,
+  isVoiceMode,
+  readVoiceModel
+} from "./chunk-KIUFNBHR.js";
+import "./chunk-ZD6UTE4A.js";
+import {
+  WorkspacePermissionRulesSessionRequiredError,
+  WorkspaceSettingsPartialPersistError,
+  WorkspaceSkillNotFoundError,
+  WorkspaceSkillNotToggleableError
+} from "./chunk-OA4JVLSA.js";
+import {
+  createTotalSessionAdmissionController
+} from "./chunk-VYPFXUCB.js";
+import {
+  createSingleWorkspaceRegistry,
+  createWorkspaceSessionOwnerIndex
+} from "./chunk-UGYMA4EI.js";
+import "./chunk-GRC5HGPI.js";
+import {
+  assertValidChannelSecretUpdates
+} from "./chunk-TF2X2WCT.js";
 import {
   daemonObservedContactsPath,
   loadChannelsConfig
-} from "./chunk-PSOO6YXD.js";
-import "./chunk-PC6JANNU.js";
+} from "./chunk-XHRTVPG2.js";
+import "./chunk-2YZJCM5T.js";
 import "./chunk-57OAHC2Y.js";
 import {
   createDaemonStatusProvider
-} from "./chunk-J24WCGIN.js";
+} from "./chunk-E5WH5O3C.js";
 import "./chunk-LXXMOYPL.js";
-import "./chunk-MVSUYZDT.js";
+import "./chunk-SASBXAQL.js";
 import "./chunk-E5Z2AVNV.js";
 import {
   SessionArtifactAuthorizationError,
   SessionArtifactValidationError,
   createAcpSessionBridge,
   parseSessionSource
-} from "./chunk-KIM5GUMA.js";
+} from "./chunk-66RMLJHC.js";
 import {
   EVENT_SCHEMA_VERSION,
   EventBus,
   SubscriberLimitExceededError
 } from "./chunk-GLWP3FDB.js";
+import "./chunk-COH43MRJ.js";
+import "./chunk-3SJ43L4W.js";
 import {
   BranchWhilePromptActiveError,
   CancelSentinelCollisionError,
@@ -210,34 +215,35 @@ import {
   WorkspaceInitSymlinkError,
   WorkspaceMismatchError
 } from "./chunk-UH3WSE5L.js";
-import "./chunk-COH43MRJ.js";
-import "./chunk-3SJ43L4W.js";
-import "./chunk-7JURR4JT.js";
+import "./chunk-A6UO2C7C.js";
 import {
   createWorkspaceProvidersStatusProvider
-} from "./chunk-FSITMZJH.js";
+} from "./chunk-6PSLCFQ2.js";
 import {
   getAuthTypeFromEnv,
   resolveCliGenerationConfig
-} from "./chunk-KMQ33DO4.js";
+} from "./chunk-LG4GZIVV.js";
 import {
   snapshotProcessEnv
-} from "./chunk-ETSW4KLJ.js";
+} from "./chunk-WDSWXQU3.js";
 import {
   createWorkspaceSkillsStatusProvider
-} from "./chunk-ACY3A37B.js";
+} from "./chunk-7FZEBPKS.js";
 import "./chunk-2W3OOD4W.js";
 import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceMemoryStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-VIA5XA4U.js";
+} from "./chunk-KU5XMLDK.js";
 import "./chunk-WBL3FJEU.js";
 import "./chunk-T2NCM2ET.js";
 import {
   parseChannelWebhookConfigLenient
-} from "./chunk-4WIZGAH3.js";
-import "./chunk-7ZCNENPP.js";
+} from "./chunk-ER5LWJR6.js";
+import "./chunk-W4CQXHT6.js";
+import {
+  supportedChannelCatalog
+} from "./chunk-MK7VQDN3.js";
 import "./chunk-V6WHFGST.js";
 import {
   MAX_REGISTERED_WORKSPACES,
@@ -246,7 +252,7 @@ import {
   WorkspaceRegistrationStoreLimitError,
   normalizeWorkspaceDisplayName,
   workspaceRegistrationId
-} from "./chunk-Q4M4MDQ4.js";
+} from "./chunk-CC4N4M36.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH,
   canonicalizeWorkspace,
@@ -261,19 +267,21 @@ import {
   MAX_CHANNEL_STARTUP_FAILURE_MESSAGE_LENGTH,
   QWEN_SERVER_TOKEN_ENV,
   isChannelDeliveryError,
-  isChannelWebhookEnqueueError,
+  isChannelWebhookEnqueueError
+} from "./chunk-U4VTUMMK.js";
+import {
   normalizeWorkerDiagnostic
-} from "./chunk-LK7CHLVP.js";
+} from "./chunk-HV3G62R6.js";
 import {
   normalizeServeChannelSelection
-} from "./chunk-JLU636DO.js";
+} from "./chunk-ALMR3E6Q.js";
 import "./chunk-BK2UNYWD.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
 import {
   sanitizeLogText
-} from "./chunk-RWTEFFPU.js";
+} from "./chunk-ML52PL6O.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-5HBA2Z7V.js";
 import {
@@ -285,7 +293,7 @@ import {
   getWritableScopes,
   loadSettings,
   validateSettingValue
-} from "./chunk-TEHGS6UP.js";
+} from "./chunk-JALU3ZDU.js";
 import "./chunk-RKUWKYED.js";
 import "./chunk-GOXKNSDZ.js";
 import "./chunk-IDS7MSUP.js";
@@ -294,14 +302,14 @@ import {
   detectSystemLanguage,
   resolveLanguageSetting,
   resolveSupportedLanguage
-} from "./chunk-LKEJ26GS.js";
-import "./chunk-LH2BYDQ5.js";
+} from "./chunk-VV6XU5L7.js";
+import "./chunk-PANH4R3B.js";
 import "./chunk-6PEXNQTX.js";
-import "./chunk-YX324OPW.js";
+import "./chunk-I7XZ3RY5.js";
 import "./chunk-VJNBRRZG.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-Z2BC6UJ5.js";
+} from "./chunk-VCBZUOSI.js";
 import "./chunk-ALGGS7UH.js";
 import {
   isWithinRoot as isWithinRoot2
@@ -317,6 +325,7 @@ import {
   ClientMcpRegistrar,
   DEFAULT_LOG_LIMIT,
   ExtensionManager,
+  GITHUB_PR_ERROR_MESSAGE_MAX,
   GROUP_COLOR_OPTIONS,
   GitWorktreeService,
   IMAGE_CAPABILITY,
@@ -350,6 +359,7 @@ import {
   fetchGitCommitDetail,
   fetchGitDiff,
   fetchGitDiffHunksForFile,
+  fetchGitHubPullRequests,
   fetchGitLog,
   getGitWorkingTreeStatus,
   getSubagentSessionDir,
@@ -369,7 +379,7 @@ import {
   writeWorkspaceContextFile,
   writeWorktreeSession,
   writeWorktreeSessionMarker
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-DM4Q4JJH.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
@@ -395,7 +405,7 @@ import "./chunk-ZOIFNCKL.js";
 import "./chunk-PWTZEM3C.js";
 import "./chunk-KRXPRVGL.js";
 import "./chunk-6PVPNMXU.js";
-import "./chunk-MZAXJAUM.js";
+import "./chunk-PSWQZHEA.js";
 import "./chunk-SZRN75WQ.js";
 import "./chunk-HTO4JFDZ.js";
 import "./chunk-CPBF7KYF.js";
@@ -427,7 +437,7 @@ import "./chunk-XVNQMZ2I.js";
 import "./chunk-FODK6UMO.js";
 import "./chunk-GLNBDYUX.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-ZJHVAS7M.js";
+import "./chunk-YAF5VNU7.js";
 import {
   addDaemonRequestAttribute,
   emitDaemonLog,
@@ -437,11 +447,12 @@ import {
   recordDaemonHttpRequest,
   recordDaemonHttpResponse,
   withDaemonRequestSpan
-} from "./chunk-NIBLUX3Y.js";
+} from "./chunk-BO4XCS7P.js";
 import "./chunk-BPJSQIJX.js";
 import "./chunk-P3QQPMQA.js";
 import "./chunk-6FGBXPWM.js";
 import "./chunk-LS77BEZP.js";
+import "./chunk-SQBYH7PX.js";
 import "./chunk-CR3C7WXL.js";
 import {
   decodeBufferWithEncodingInfo,
@@ -450,10 +461,10 @@ import {
   isWithinRoot,
   parseLineTolerant,
   read
-} from "./chunk-CIKQ7KKO.js";
+} from "./chunk-RWS5VYWC.js";
 import "./chunk-VGC4I5JJ.js";
 import "./chunk-MUP3T3AD.js";
-import "./chunk-IKCX4CCL.js";
+import "./chunk-U7TXFVUN.js";
 import "./chunk-46UV252V.js";
 import "./chunk-A4UCTEB5.js";
 import "./chunk-XWRJCPHC.js";
@@ -461,9 +472,9 @@ import "./chunk-UW5EOVUN.js";
 import "./chunk-2JZBVYTU.js";
 import "./chunk-5I2IWRSH.js";
 import "./chunk-A5L3JMUA.js";
-import "./chunk-MB4MZHMJ.js";
-import "./chunk-HTR4WV6U.js";
-import "./chunk-BULDBTYC.js";
+import "./chunk-SRZ6DXVG.js";
+import "./chunk-W4RQUHY3.js";
+import "./chunk-INADJJGW.js";
 import "./chunk-U7ZFW55U.js";
 import "./chunk-UUUTRMI2.js";
 import "./chunk-PR75REBZ.js";
@@ -23903,14 +23914,14 @@ __name(canonicalCron, "canonicalCron");
 function registerScheduledTaskCrudRoutes(app, deps) {
   const {
     prefix,
-    resolveTarget,
+    resolveTarget: resolveTarget2,
     mutate,
     safeBody: safeBody2,
     channelDeliveryAuthorizations
   } = deps;
   const base = `${prefix}/scheduled-tasks`;
   app.get(base, async (req, res) => {
-    const target = resolveTarget(req, res);
+    const target = resolveTarget2(req, res);
     if (!target) return;
     try {
       const tasks = await readCronTasks(target.workspaceCwd);
@@ -23926,7 +23937,7 @@ function registerScheduledTaskCrudRoutes(app, deps) {
     }
   });
   app.post(base, mutate(), async (req, res) => {
-    const target = resolveTarget(req, res);
+    const target = resolveTarget2(req, res);
     if (!target) return;
     const { workspaceCwd, bridge } = target;
     const body = safeBody2(req);
@@ -24102,7 +24113,7 @@ function registerScheduledTaskCrudRoutes(app, deps) {
     res.status(201).json(toView(task));
   });
   app.patch(`${base}/:id`, mutate(), async (req, res) => {
-    const target = resolveTarget(req, res);
+    const target = resolveTarget2(req, res);
     if (!target) return;
     const { workspaceCwd, bridge } = target;
     const id = typeof req.params["id"] === "string" ? req.params["id"] : "";
@@ -24292,7 +24303,7 @@ function registerScheduledTaskCrudRoutes(app, deps) {
     res.status(200).json(toView(updated));
   });
   app.delete(`${base}/:id`, mutate(), async (req, res) => {
-    const target = resolveTarget(req, res);
+    const target = resolveTarget2(req, res);
     if (!target) return;
     const { workspaceCwd, bridge } = target;
     const id = typeof req.params["id"] === "string" ? req.params["id"] : "";
@@ -24341,7 +24352,7 @@ function registerScheduledTaskCrudRoutes(app, deps) {
     res.status(200).json({ deleted: true, id });
   });
   app.post(`${base}/:id/run`, mutate(), async (req, res) => {
-    const target = resolveTarget(req, res);
+    const target = resolveTarget2(req, res);
     if (!target) return;
     const { workspaceCwd } = target;
     const id = typeof req.params["id"] === "string" ? req.params["id"] : "";
@@ -25332,6 +25343,7 @@ function createServeFeatures(deps) {
     reloadAvailable,
     channelReloadAvailable,
     channelControlAvailable,
+    channelManagementAvailable,
     sessionShellCommandEnabled,
     multiWorkspaceSessionsEnabled,
     dynamicWorkspaceRegistrationAvailable,
@@ -25370,6 +25382,7 @@ function createServeFeatures(deps) {
       reloadAvailable,
       channelReloadAvailable: channelReloadAvailable(),
       channelControlAvailable,
+      channelManagementAvailable,
       multiWorkspaceSessionsEnabled: multiWorkspaceSessionsEnabled(),
       dynamicWorkspaceRegistrationAvailable,
       persistentWorkspaceRegistrationAvailable,
@@ -29437,6 +29450,73 @@ function registerWorkspaceQualifiedGitLogRoutes(app, deps) {
 }
 __name(registerWorkspaceQualifiedGitLogRoutes, "registerWorkspaceQualifiedGitLogRoutes");
 
+// packages/cli/src/serve/routes/workspace-github-prs.ts
+init_esbuild_shims();
+function sanitizeMessage(message, workspaceCwd) {
+  return message.split(workspaceCwd).join("<workspace>");
+}
+__name(sanitizeMessage, "sanitizeMessage");
+function registerWorkspaceQualifiedGitHubPrsRoutes(app, deps) {
+  app.get("/workspaces/:workspace/github/prs", async (req, res) => {
+    const route = "GET /workspaces/:workspace/github/prs";
+    const runtime = resolveWorkspaceRuntimeFromParam(
+      deps.workspaceRegistry,
+      req,
+      res
+    );
+    if (!runtime) return;
+    if (!requireTrustedWorkspaceRuntime(runtime, res)) return;
+    applyReadHeaders(res);
+    try {
+      const result = await fetchGitHubPullRequests(runtime.workspaceCwd);
+      switch (result.kind) {
+        case "ok":
+          res.status(200).json({
+            v: 1,
+            workspaceCwd: runtime.workspaceCwd,
+            available: true,
+            pullRequests: result.pullRequests
+          });
+          return;
+        case "not_a_repo":
+          res.status(200).json({
+            v: 1,
+            workspaceCwd: runtime.workspaceCwd,
+            available: false,
+            pullRequests: []
+          });
+          return;
+        case "cli_unavailable":
+          res.status(502).json({
+            error: "The GitHub CLI (gh) is not installed on the daemon host; install it and run `gh auth login`.",
+            code: "github_cli_unavailable",
+            status: 502
+          });
+          return;
+        case "failed": {
+          const error2 = sanitizeMessage(
+            sanitizeMessage(result.message, runtime.workspaceCwd),
+            result.gitRoot
+          ).slice(0, GITHUB_PR_ERROR_MESSAGE_MAX);
+          res.status(502).json({
+            error: error2,
+            code: "github_prs_failed",
+            status: 502
+          });
+          return;
+        }
+        default:
+          throw new Error(
+            `unexpected fetchGitHubPullRequests result: ${JSON.stringify(result)}`
+          );
+      }
+    } catch (err) {
+      deps.sendBridgeError(res, err, { route });
+    }
+  });
+}
+__name(registerWorkspaceQualifiedGitHubPrsRoutes, "registerWorkspaceQualifiedGitHubPrsRoutes");
+
 // packages/cli/src/serve/workspace-git-state.ts
 init_esbuild_shims();
 var WorkspaceGitState = class {
@@ -30275,6 +30355,317 @@ function registerWorkspaceChannelControlRoutes(app, deps) {
 }
 __name(registerWorkspaceChannelControlRoutes, "registerWorkspaceChannelControlRoutes");
 
+// packages/cli/src/serve/routes/workspace-channel-management.ts
+init_esbuild_shims();
+var MAX_ERROR_LENGTH = 512;
+var MAX_INSTANCE_NAME_BYTES = 255;
+var WINDOWS_DEVICE_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/iu;
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function isWellFormed(value) {
+  try {
+    encodeURIComponent(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isWellFormed, "isWellFormed");
+function isPortableInstanceName(name, allowReservedAll = false) {
+  if (allowReservedAll && name.trim() === "all") return true;
+  const baseName = name.split(".", 1)[0].trimEnd();
+  return isWellFormed(name) && name.trim().length > 0 && name !== "." && name !== ".." && name.trim() !== "all" && !name.includes("/") && !name.includes("\\") && !/[:*?"<>|\p{Cc}]/u.test(name) && !name.endsWith(".") && !name.endsWith(" ") && !WINDOWS_DEVICE_NAME.test(baseName) && Buffer.byteLength(name, "utf8") <= MAX_INSTANCE_NAME_BYTES;
+}
+__name(isPortableInstanceName, "isPortableInstanceName");
+function parseInstanceName(req, res, allowReservedAll = false) {
+  const name = req.params["name"] ?? "";
+  if (!isPortableInstanceName(name, allowReservedAll)) {
+    res.status(400).json({
+      error: `Channel instance names must be portable path components, differ from the reserved name "all", and be at most ${MAX_INSTANCE_NAME_BYTES} UTF-8 bytes.`,
+      code: "invalid_channel_instance_name"
+    });
+    return void 0;
+  }
+  return name;
+}
+__name(parseInstanceName, "parseInstanceName");
+function parseRevision(body, res) {
+  const expectedRevision = body["expectedRevision"];
+  if (typeof expectedRevision !== "string" || expectedRevision.length === 0) {
+    res.status(400).json({
+      error: "`expectedRevision` must be a non-empty string.",
+      code: "invalid_channel_management_request"
+    });
+    return void 0;
+  }
+  return { expectedRevision };
+}
+__name(parseRevision, "parseRevision");
+function parseUpsert(body, res) {
+  const revision = parseRevision(body, res);
+  if (!revision) return void 0;
+  const config = body["config"];
+  if (!isRecord(config) || typeof config["type"] !== "string" || config["type"].length === 0) {
+    res.status(400).json({
+      error: "`config` must contain a non-empty Channel type.",
+      code: "invalid_channel_management_request"
+    });
+    return void 0;
+  }
+  const secrets = body["secrets"];
+  if (secrets !== void 0) {
+    try {
+      assertValidChannelSecretUpdates(secrets);
+    } catch {
+      res.status(400).json({
+        error: "Secret updates are invalid.",
+        code: "channel_settings_invalid_secret"
+      });
+      return void 0;
+    }
+  }
+  return {
+    ...revision,
+    config,
+    ...secrets === void 0 ? {} : { secrets }
+  };
+}
+__name(parseUpsert, "parseUpsert");
+function parseStartup(body, res) {
+  const revision = parseRevision(body, res);
+  if (!revision) return void 0;
+  if (typeof body["enabled"] !== "boolean") {
+    res.status(400).json({
+      error: "`enabled` must be a boolean.",
+      code: "invalid_channel_management_request"
+    });
+    return void 0;
+  }
+  return { ...revision, enabled: body["enabled"] };
+}
+__name(parseStartup, "parseStartup");
+function parsePairingCode(body, res) {
+  const code = body["code"];
+  if (typeof code !== "string" || !/^[A-HJ-NP-Z2-9]{8}$/iu.test(code.trim())) {
+    res.status(400).json({
+      error: "`code` must be an 8-character pairing code.",
+      code: "invalid_channel_pairing_code"
+    });
+    return void 0;
+  }
+  return code.trim().toUpperCase();
+}
+__name(parsePairingCode, "parsePairingCode");
+function errorCode2(error2) {
+  if (!error2 || typeof error2 !== "object") return void 0;
+  try {
+    const code = Reflect.get(error2, "code");
+    return typeof code === "string" ? code : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(errorCode2, "errorCode");
+var ERROR_STATUS = /* @__PURE__ */ new Map([
+  ["invalid_channel_instance_name", 400],
+  ["channel_settings_invalid_name", 400],
+  ["channel_settings_invalid_config", 400],
+  ["channel_settings_invalid_secret", 400],
+  ["channel_settings_unmanageable", 400],
+  ["channel_workspace_mismatch", 400],
+  ["ambiguous_channel_workspace", 400],
+  ["untrusted_workspace", 403],
+  ["channel_instance_not_found", 404],
+  ["channel_pairing_request_not_found", 404],
+  ["channel_pairing_not_enabled", 409],
+  ["channel_settings_conflict", 409],
+  ["channel_runtime_owner_mismatch", 409],
+  ["channel_worker_not_enabled", 409],
+  ["channel_service_conflict", 409],
+  ["channel_worker_start_failed", 502],
+  ["channel_worker_stop_failed", 500],
+  ["daemon_draining", 503],
+  ["channel_worker_unavailable", 503]
+]);
+function sendManagementError(res, error2) {
+  const code = errorCode2(error2);
+  const status = code ? ERROR_STATUS.get(code) : void 0;
+  if (code && status !== void 0) {
+    const raw = error2 instanceof Error ? error2.message : String(error2);
+    res.status(status).json({
+      error: sanitizeLogText(redactLogCredentials(raw), MAX_ERROR_LENGTH),
+      code
+    });
+    return;
+  }
+  res.status(500).json({
+    error: "Channel management operation failed.",
+    code: "channel_management_failed"
+  });
+}
+__name(sendManagementError, "sendManagementError");
+function noStore(res) {
+  res.set("Cache-Control", "no-store");
+}
+__name(noStore, "noStore");
+async function resolveTarget(req, res, resolveRuntime, resolveService) {
+  const runtime = resolveRuntime(req, res);
+  if (!runtime || !requireTrustedWorkspaceRuntime(runtime, res)) return;
+  try {
+    const service = await resolveService(runtime);
+    if (!service) {
+      res.status(503).json({
+        error: "Channel management is unavailable.",
+        code: "channel_management_unavailable"
+      });
+      return;
+    }
+    return { runtime, service };
+  } catch (error2) {
+    sendManagementError(res, error2);
+    return;
+  }
+}
+__name(resolveTarget, "resolveTarget");
+function registerWorkspaceChannelManagementRoutes(app, deps) {
+  const primary = /* @__PURE__ */ __name(() => deps.primaryRuntime, "primary");
+  const qualified = /* @__PURE__ */ __name((req, res) => resolveWorkspaceRuntimeFromParam(deps.workspaceRegistry, req, res), "qualified");
+  const register = /* @__PURE__ */ __name((prefix, resolveRuntime) => {
+    const pairingRead = deps.mutate({ strict: true });
+    const pairingApprove = deps.mutate({ strict: true });
+    const upsert = deps.mutate({ strict: true });
+    const remove = deps.mutate({ strict: true });
+    const startup = deps.mutate({ strict: true });
+    const start = deps.mutate({ strict: true });
+    const stop = deps.mutate({ strict: true });
+    const restart = deps.mutate({ strict: true });
+    const target = /* @__PURE__ */ __name((req, res) => resolveTarget(req, res, resolveRuntime, deps.resolveService), "target");
+    const validateClient = /* @__PURE__ */ __name((req, res, runtime) => deps.parseAndValidateClientId(req, res, runtime) !== null, "validateClient");
+    app.get(`${prefix}/channel-types`, async (req, res) => {
+      const runtime = resolveRuntime(req, res);
+      if (!runtime || !requireTrustedWorkspaceRuntime(runtime, res)) return;
+      try {
+        noStore(res);
+        res.status(200).json(await supportedChannelCatalog());
+      } catch (error2) {
+        sendManagementError(res, error2);
+      }
+    });
+    app.get(`${prefix}/channels`, async (req, res) => {
+      const resolved = await target(req, res);
+      if (!resolved || !validateClient(req, res, resolved.runtime)) return;
+      try {
+        noStore(res);
+        res.status(200).json(await resolved.service.list());
+      } catch (error2) {
+        sendManagementError(res, error2);
+      }
+    });
+    app.get(
+      `${prefix}/channels/:name/pairing-requests`,
+      pairingRead,
+      async (req, res) => {
+        const resolved = await target(req, res);
+        if (!resolved || !validateClient(req, res, resolved.runtime)) return;
+        const name = parseInstanceName(req, res);
+        if (!name) return;
+        try {
+          noStore(res);
+          res.status(200).json(await resolved.service.pairingRequests(name));
+        } catch (error2) {
+          sendManagementError(res, error2);
+        }
+      }
+    );
+    app.post(
+      `${prefix}/channels/:name/pairing-requests/approve`,
+      pairingApprove,
+      async (req, res) => {
+        const resolved = await target(req, res);
+        if (!resolved || !validateClient(req, res, resolved.runtime)) return;
+        const name = parseInstanceName(req, res);
+        if (!name) return;
+        const code = parsePairingCode(deps.safeBody(req), res);
+        if (!code) return;
+        try {
+          noStore(res);
+          res.status(200).json(await resolved.service.approvePairing(name, code));
+        } catch (error2) {
+          sendManagementError(res, error2);
+        }
+      }
+    );
+    app.put(`${prefix}/channels/:name`, upsert, async (req, res) => {
+      const resolved = await target(req, res);
+      if (!resolved || !validateClient(req, res, resolved.runtime)) return;
+      const name = parseInstanceName(req, res);
+      if (!name) return;
+      const request2 = parseUpsert(deps.safeBody(req), res);
+      if (!request2) return;
+      try {
+        noStore(res);
+        res.status(200).json(await resolved.service.upsert(name, request2));
+      } catch (error2) {
+        sendManagementError(res, error2);
+      }
+    });
+    app.delete(`${prefix}/channels/:name`, remove, async (req, res) => {
+      const resolved = await target(req, res);
+      if (!resolved || !validateClient(req, res, resolved.runtime)) return;
+      const name = parseInstanceName(req, res);
+      if (!name) return;
+      const request2 = parseRevision(deps.safeBody(req), res);
+      if (!request2) return;
+      try {
+        noStore(res);
+        res.status(200).json(await resolved.service.remove(name, request2));
+      } catch (error2) {
+        sendManagementError(res, error2);
+      }
+    });
+    app.put(`${prefix}/channels/:name/startup`, startup, async (req, res) => {
+      const resolved = await target(req, res);
+      if (!resolved || !validateClient(req, res, resolved.runtime)) return;
+      const name = parseInstanceName(req, res);
+      if (!name) return;
+      const request2 = parseStartup(deps.safeBody(req), res);
+      if (!request2) return;
+      try {
+        noStore(res);
+        res.status(200).json(await resolved.service.setStartup(name, request2));
+      } catch (error2) {
+        sendManagementError(res, error2);
+      }
+    });
+    const action = /* @__PURE__ */ __name((operation, middleware) => {
+      app.post(
+        `${prefix}/channels/:name/${operation}`,
+        middleware,
+        async (req, res) => {
+          const resolved = await target(req, res);
+          if (!resolved || !validateClient(req, res, resolved.runtime)) return;
+          const name = parseInstanceName(req, res);
+          if (!name) return;
+          try {
+            noStore(res);
+            res.status(200).json(await resolved.service[operation](name));
+          } catch (error2) {
+            sendManagementError(res, error2);
+          }
+        }
+      );
+    }, "action");
+    action("start", start);
+    action("stop", stop);
+    action("restart", restart);
+  }, "register");
+  register("/workspace", primary);
+  register("/workspaces/:workspace", qualified);
+}
+__name(registerWorkspaceChannelManagementRoutes, "registerWorkspaceChannelManagementRoutes");
+
 // packages/cli/src/serve/routes/workspace-channel-observed-contacts.ts
 init_esbuild_shims();
 var DEFAULT_FRESH_WITHIN_SECONDS = 7 * 24 * 60 * 60;
@@ -31171,6 +31562,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     // runtime, so it has the same reload surface as legacy deps.workspace.
     reloadAvailable: deps.workspace !== void 0 || injectedWorkspaceRegistry !== void 0,
     channelControlAvailable: deps.getChannelWorkerControl !== void 0 && deps.setChannelWorkerSelection !== void 0 && deps.stopChannelWorker !== void 0,
+    channelManagementAvailable: deps.channelManagementService !== void 0,
     channelReloadAvailable: /* @__PURE__ */ __name(() => {
       if (deps.reloadChannelWorker === void 0) return false;
       const control = deps.getChannelWorkerControl?.();
@@ -31505,6 +31897,10 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     workspaceRegistry,
     sendBridgeError: sendBridgeError2
   });
+  registerWorkspaceQualifiedGitHubPrsRoutes(app, {
+    workspaceRegistry,
+    sendBridgeError: sendBridgeError2
+  });
   mountWorkspaceMemoryRoutes(app, {
     bridge: primaryBridge,
     boundWorkspace: primaryBoundWorkspace,
@@ -31768,6 +32164,16 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, primaryBridge), "parseAndValidateClientId")
     });
   }
+  if (deps.channelManagementService) {
+    registerWorkspaceChannelManagementRoutes(app, {
+      primaryRuntime,
+      workspaceRegistry,
+      resolveService: deps.channelManagementService,
+      mutate,
+      safeBody,
+      parseAndValidateClientId: /* @__PURE__ */ __name((req, res, runtime) => parseAndValidateWorkspaceClientId(req, res, runtime.bridge), "parseAndValidateClientId")
+    });
+  }
   registerWorkspaceChannelObservedContactRoutes(app, {
     primaryWorkspace: primaryBoundWorkspace,
     workspaceRegistry