@qwen-code/qwen-code 0.21.0-nightly.20260727.c003e1718 → 0.21.0-preview.0

package/chunks/{server-GJFU7OZ6.js → server-T4C6UGPM.js}

@@ -1,5 +1,10 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  openQwenAsrRealtimeStream,
+  openVoiceStream,
+  openVoiceStreamWithRetry
+} from "./chunk-BCZFQXWK.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
   MAX_REMEMBER_CONTENT_BYTES,
@@ -16,12 +21,7 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-N7U3LRNS.js";
-import {
-  openQwenAsrRealtimeStream,
-  openVoiceStream,
-  openVoiceStreamWithRetry
-} from "./chunk-JJY7H2ZU.js";
+} from "./chunk-DDKAZLZ7.js";
 import {
   SetupGithubError,
   collectSessionData,
@@ -33,13 +33,13 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-TH6TQR5Y.js";
+} from "./chunk-IZO36O6O.js";
 import {
   OBSERVED_CONTACT_MAX_FRESH_WITHIN_SECONDS,
   ObservedChannelContactStore
-} from "./chunk-DEKCAHRS.js";
-import "./chunk-IPUUTYMV.js";
-import "./chunk-6K2CPEAB.js";
+} from "./chunk-LGAOC3ZS.js";
+import "./chunk-HKFEPLKW.js";
+import "./chunk-YDLJGZHL.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
 import "./chunk-QTERJVPZ.js";
@@ -101,14 +101,14 @@ import {
   setRateLimiter,
   unsafeRevealSecret,
   validateMcpRuntimeServerName
-} from "./chunk-H6YTFKW7.js";
+} from "./chunk-YGF33UXG.js";
 import {
   isLoopbackBind
 } from "./chunk-RXFQM6FQ.js";
 import {
   evaluateDaemonWorkspaceTrust,
   readDaemonTrustPolicySnapshot
-} from "./chunk-4IQSPE3A.js";
+} from "./chunk-DNDETPES.js";
 import {
   EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
   MAX_WORKSPACE_SKILL_NAME_LENGTH,
@@ -122,14 +122,14 @@ import {
   validateWorkspaceSkillName,
   validateWorkspaceVoiceState,
   voiceSettingsScopeToWire
-} from "./chunk-TD665TIY.js";
+} from "./chunk-KFPFJAR3.js";
 import {
   PermissionRulesValidationError,
   buildPermissionSettings,
   isPermissionRuleType,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-2XORP6RV.js";
+} from "./chunk-UEDIRTKG.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isStreamingVoiceModel,
@@ -137,44 +137,95 @@ import {
   resolveVoiceTranscriptionConfig,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-G2W6OP2O.js";
+} from "./chunk-V5AWXXVA.js";
 import {
   isVoiceEnabled,
   isVoiceMode,
   readVoiceModel
-} from "./chunk-FZP2GLM4.js";
-import "./chunk-GBJUC5ZL.js";
+} from "./chunk-QQLCYEN2.js";
+import "./chunk-ZHBO7WVX.js";
+import {
+  WorkspacePermissionRulesSessionRequiredError,
+  WorkspaceSettingsPartialPersistError,
+  WorkspaceSkillNotFoundError,
+  WorkspaceSkillNotToggleableError
+} from "./chunk-OA4JVLSA.js";
 import {
   createTotalSessionAdmissionController
-} from "./chunk-VYPFXUCB.js";
+} from "./chunk-SZ3KHTDR.js";
 import {
   WorkspaceGenerationClosedError,
   createSingleWorkspaceRegistry,
   createWorkspaceSessionOwnerIndex
-} from "./chunk-CX2KLDRX.js";
+} from "./chunk-JYBU6YUE.js";
 import "./chunk-GRC5HGPI.js";
 import {
   assertValidChannelSecretUpdates
-} from "./chunk-6ENJ2DGB.js";
+} from "./chunk-Y6RATHM5.js";
 import {
   createDaemonStatusProvider
-} from "./chunk-LI4HGDLZ.js";
-import "./chunk-LXXMOYPL.js";
-import "./chunk-WTCKVXNT.js";
+} from "./chunk-5FNROPXI.js";
+import "./chunk-VXZBKKQR.js";
+import "./chunk-WUNZAP5I.js";
 import "./chunk-E5Z2AVNV.js";
 import {
   SessionArtifactAuthorizationError,
   SessionArtifactValidationError,
   createAcpSessionBridge,
   parseSessionSource
-} from "./chunk-FOT6JBY5.js";
+} from "./chunk-XRYM3MCI.js";
 import {
   EVENT_SCHEMA_VERSION,
   EventBus,
   SubscriberLimitExceededError
 } from "./chunk-GLWP3FDB.js";
 import "./chunk-XCGIMOLN.js";
-import "./chunk-3SJ43L4W.js";
+import "./chunk-OCPBI7J5.js";
+import "./chunk-3MGBLIXX.js";
+import {
+  createWorkspaceProvidersStatusProvider
+} from "./chunk-DABQX74H.js";
+import {
+  getAuthTypeFromEnv,
+  resolveCliGenerationConfig
+} from "./chunk-KBNDRM4U.js";
+import {
+  snapshotProcessEnv
+} from "./chunk-A2APC6HM.js";
+import {
+  createWorkspaceSkillsStatusProvider
+} from "./chunk-UFI5GRDS.js";
+import "./chunk-L55JWS76.js";
+import {
+  STATUS_SCHEMA_VERSION,
+  createIdleWorkspaceMemoryStatus,
+  mapDomainErrorToErrorKind
+} from "./chunk-R7ZITH3J.js";
+import "./chunk-Z4X5MTRT.js";
+import "./chunk-WBL3FJEU.js";
+import {
+  daemonObservedContactsPath,
+  loadChannelsConfig
+} from "./chunk-HWNLU2HC.js";
+import "./chunk-XR2NFLNQ.js";
+import "./chunk-57OAHC2Y.js";
+import {
+  parseChannelWebhookConfigLenient
+} from "./chunk-2XSLTRFZ.js";
+import "./chunk-TFRMVU6R.js";
+import {
+  supportedChannelCatalog
+} from "./chunk-XBYYDKAZ.js";
+import "./chunk-V6WHFGST.js";
+import {
+  MAX_REGISTERED_WORKSPACES,
+  WorkspaceDisplayNameValidationError,
+  WorkspaceRegistrationStoreCommittedError,
+  WorkspaceRegistrationStoreLimitError,
+  normalizeWorkspaceDisplayName,
+  workspaceRegistrationId
+} from "./chunk-XH7E5IGP.js";
+import "./chunk-XZC5VLBZ.js";
 import {
   BranchWhilePromptActiveError,
   CancelSentinelCollisionError,
@@ -207,48 +258,13 @@ import {
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError,
   WorkspaceMismatchError
-} from "./chunk-UH3WSE5L.js";
-import "./chunk-2KHUM3TN.js";
-import {
-  createWorkspaceProvidersStatusProvider
-} from "./chunk-55PWRVIR.js";
-import {
-  getAuthTypeFromEnv,
-  resolveCliGenerationConfig
-} from "./chunk-PAJNXBXO.js";
-import {
-  snapshotProcessEnv
-} from "./chunk-HAZMIZP7.js";
-import {
-  createWorkspaceSkillsStatusProvider
-} from "./chunk-VOTXHGKJ.js";
-import "./chunk-L55JWS76.js";
-import {
-  STATUS_SCHEMA_VERSION,
-  createIdleWorkspaceMemoryStatus,
-  mapDomainErrorToErrorKind
-} from "./chunk-WZOPR2ZP.js";
-import "./chunk-Z4X5MTRT.js";
-import {
-  WorkspacePermissionRulesSessionRequiredError,
-  WorkspaceSettingsPartialPersistError,
-  WorkspaceSkillNotFoundError,
-  WorkspaceSkillNotToggleableError
-} from "./chunk-OA4JVLSA.js";
+} from "./chunk-B4AJNNOL.js";
 import {
-  daemonObservedContactsPath,
-  loadChannelsConfig
-} from "./chunk-RRNQGWR4.js";
-import "./chunk-B5DJFAHN.js";
-import "./chunk-57OAHC2Y.js";
-import {
-  parseChannelWebhookConfigLenient
-} from "./chunk-EDEO3ZXU.js";
-import "./chunk-7VOUXBKJ.js";
-import {
-  supportedChannelCatalog
-} from "./chunk-ZEVUICUF.js";
-import "./chunk-V6WHFGST.js";
+  MAX_WORKSPACE_PATH_LENGTH,
+  canonicalizeWorkspace,
+  canonicalizeWorkspaces,
+  translateAndCheckAbsoluteWorkspacePath
+} from "./chunk-2RFKHEXL.js";
 import {
   ChannelDeliveryError,
   MAX_CHANNEL_STARTUP_FAILURES,
@@ -261,7 +277,7 @@ import {
 } from "./chunk-U4VTUMMK.js";
 import {
   normalizeWorkerDiagnostic
-} from "./chunk-4AVIERNE.js";
+} from "./chunk-GZ3RCT54.js";
 import {
   normalizeServeChannelSelection
 } from "./chunk-ALMR3E6Q.js";
@@ -269,11 +285,11 @@ import "./chunk-BK2UNYWD.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
-import "./chunk-WBL3FJEU.js";
+import "./chunk-5HBA2Z7V.js";
 import "./chunk-T2NCM2ET.js";
 import {
   sanitizeLogText
-} from "./chunk-BJHP755Z.js";
+} from "./chunk-7I5GTCT4.js";
 import "./chunk-UDXSXLER.js";
 import {
   getDialogSettingKeys,
@@ -284,38 +300,23 @@ import {
   getWritableScopes,
   loadSettings,
   validateSettingValue
-} from "./chunk-VCBKBEU7.js";
+} from "./chunk-7A4ZDITM.js";
 import "./chunk-RKUWKYED.js";
 import {
   SUPPORTED_LANGUAGES,
   detectSystemLanguage,
   resolveLanguageSetting,
   resolveSupportedLanguage
-} from "./chunk-C6U6ZR65.js";
-import "./chunk-ZAJIOSFI.js";
+} from "./chunk-ATZOB5Y2.js";
+import "./chunk-NNERMV7T.js";
 import "./chunk-GOXKNSDZ.js";
-import "./chunk-6PEXNQTX.js";
-import {
-  MAX_REGISTERED_WORKSPACES,
-  WorkspaceDisplayNameValidationError,
-  WorkspaceRegistrationStoreCommittedError,
-  WorkspaceRegistrationStoreLimitError,
-  normalizeWorkspaceDisplayName,
-  workspaceRegistrationId
-} from "./chunk-DC2Y3JSV.js";
-import {
-  MAX_WORKSPACE_PATH_LENGTH,
-  canonicalizeWorkspace,
-  canonicalizeWorkspaces,
-  translateAndCheckAbsoluteWorkspacePath
-} from "./chunk-2RFKHEXL.js";
-import "./chunk-5HBA2Z7V.js";
 import "./chunk-IDS7MSUP.js";
-import "./chunk-NZYXKNSZ.js";
+import "./chunk-6PEXNQTX.js";
+import "./chunk-AOAYOH3R.js";
 import "./chunk-VJNBRRZG.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-IUYFCE34.js";
+} from "./chunk-4WSL256B.js";
 import "./chunk-ALGGS7UH.js";
 import {
   isWithinRoot as isWithinRoot2
@@ -361,16 +362,27 @@ import {
   WorkspaceMemoryFileTooLargeError,
   WorkspaceMemoryWriteTimeoutError,
   buildUsageDashboard,
+  createGitHubPullRequest,
   detectLineEnding,
   encodeTextFileContentAsync,
+  fetchGitBranches,
   fetchGitCommitDetail,
   fetchGitDiff,
   fetchGitDiffHunksForFile,
   fetchGitHubPullRequests,
   fetchGitLog,
+  findGitRoot,
+  getDefaultBranch,
   getGitWorkingTreeStatus,
   getSubagentSessionDir,
+  gitCheckout,
+  gitCommit,
+  gitCreateBranch,
+  gitPull,
+  gitPush,
   glob,
+  isValidCheckoutRef,
+  isValidRefName,
   loadIgnoreRules,
   loadUsageHistoryWithLive,
   parseInstallSource,
@@ -386,18 +398,19 @@ import {
   writeWorkspaceContextFile,
   writeWorktreeSession,
   writeWorktreeSessionMarker
-} from "./chunk-G3RJEBAA.js";
+} from "./chunk-HUK2P4RS.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
 import "./chunk-5M6IDOMF.js";
-import "./chunk-2WVVMSPB.js";
-import "./chunk-IUNB6SUW.js";
-import "./chunk-ECBKZ7SV.js";
+import "./chunk-UPUG4GXM.js";
+import "./chunk-64LQLPL7.js";
+import "./chunk-2LQTH543.js";
 import "./chunk-KRXPRVGL.js";
+import "./chunk-DJGYJDYR.js";
 import {
   MAX_JOBS,
   nextDurableFireMs
-} from "./chunk-3FNJBOF7.js";
+} from "./chunk-CVHIL5IG.js";
 import {
   nextFireTime,
   parseCron
@@ -410,23 +423,22 @@ import {
   readCronTasks,
   taskHasLegacyCondition,
   updateCronTasks
-} from "./chunk-6LOSXNKO.js";
+} from "./chunk-PONHVBRT.js";
 import "./chunk-T26EAKDL.js";
 import "./chunk-6PVPNMXU.js";
-import "./chunk-3YAW4B2W.js";
 import "./chunk-CPBF7KYF.js";
-import "./chunk-7R4YENCL.js";
-import "./chunk-IJDXG4RL.js";
-import "./chunk-IM6PC55H.js";
-import "./chunk-YF7TVSQK.js";
+import "./chunk-6QIGFD5W.js";
+import "./chunk-XWWKIXVD.js";
+import "./chunk-75GFAX4R.js";
+import "./chunk-OKF7JF3R.js";
 import {
   APPROVAL_MODES,
   SubagentError,
   SubagentErrorCode
-} from "./chunk-DMEKUQ5Z.js";
+} from "./chunk-JSD33JG6.js";
 import "./chunk-S6LOFUVP.js";
 import "./chunk-JCW2R7WC.js";
-import "./chunk-2PHWA4IO.js";
+import "./chunk-2DN4J57Y.js";
 import "./chunk-ZPJWUGCS.js";
 import {
   QwenOAuth2Client,
@@ -436,15 +448,15 @@ import {
   isDeviceAuthorizationSuccess,
   isDeviceTokenPending,
   isDeviceTokenSuccess
-} from "./chunk-HHYPUCUF.js";
+} from "./chunk-2LKVPASC.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-2LFSPVBC.js";
-import "./chunk-67ZRSECV.js";
+import "./chunk-LW3RFMG7.js";
+import "./chunk-W4MIWP6M.js";
 import "./chunk-DGEIYUC3.js";
 import "./chunk-MPHPFVKK.js";
 import "./chunk-GLNBDYUX.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-EWYICJNY.js";
+import "./chunk-P2YNZWXZ.js";
 import {
   addDaemonRequestAttribute,
   emitDaemonLog,
@@ -454,12 +466,12 @@ import {
   recordDaemonHttpRequest,
   recordDaemonHttpResponse,
   withDaemonRequestSpan
-} from "./chunk-IXNNGTUI.js";
+} from "./chunk-75MIQ3LV.js";
 import "./chunk-2J3OJGTL.js";
 import "./chunk-P3QQPMQA.js";
-import "./chunk-ACPMPDKQ.js";
+import "./chunk-RPLGZJV2.js";
 import "./chunk-GLCZKT5V.js";
-import "./chunk-4CCAX23S.js";
+import "./chunk-DZLYR4U3.js";
 import "./chunk-CR3C7WXL.js";
 import "./chunk-XWRJCPHC.js";
 import {
@@ -468,18 +480,18 @@ import {
   isWithinRoot,
   parseLineTolerant,
   read
-} from "./chunk-6PQHZ4YW.js";
+} from "./chunk-BWKCTLEJ.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-MFBM3CQZ.js";
-import "./chunk-ZWL7SSVL.js";
-import "./chunk-MB3M2BFP.js";
-import "./chunk-2WUAKFCQ.js";
+import "./chunk-SGFT55XI.js";
+import "./chunk-Y4IHBGBP.js";
+import "./chunk-Y6AXW2OG.js";
+import "./chunk-LNHZ3A4I.js";
 import "./chunk-46UV252V.js";
-import "./chunk-WDMODYUC.js";
-import "./chunk-XM5V2A2E.js";
-import "./chunk-ZYD3KZPB.js";
-import "./chunk-BOWYL27T.js";
-import "./chunk-FUFNINKB.js";
+import "./chunk-ZBVS26BY.js";
+import "./chunk-WZRWHXFE.js";
+import "./chunk-A3NDJ5SB.js";
+import "./chunk-7XATOOE7.js";
+import "./chunk-BGTQCTQW.js";
 import "./chunk-W4RQUHY3.js";
 import "./chunk-S7W2GKIO.js";
 import {
@@ -487,7 +499,7 @@ import {
   Storage,
   createDebugLogger,
   runWithoutDebugLogSession
-} from "./chunk-ATIV6G7N.js";
+} from "./chunk-UHUSJ6X7.js";
 import "./chunk-VOQXFAY5.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
@@ -2625,6 +2637,26 @@ function resolveContainedCwd(req, workspaceCwd) {
   return workspaceCwd;
 }
 __name(resolveContainedCwd, "resolveContainedCwd");
+function resolveContainedCwdOrFail(req, workspaceCwd) {
+  const rawCwd = req.query["cwd"];
+  if (rawCwd === void 0) {
+    return workspaceCwd;
+  }
+  if (typeof rawCwd !== "string" || rawCwd.length === 0) {
+    return null;
+  }
+  try {
+    const resolved = fs.realpathSync(path5.resolve(rawCwd));
+    const root = fs.realpathSync(workspaceCwd);
+    const rel = path5.relative(root, resolved);
+    if (!rel.startsWith("..") && !path5.isAbsolute(rel)) {
+      return resolved;
+    }
+  } catch {
+  }
+  return null;
+}
+__name(resolveContainedCwdOrFail, "resolveContainedCwdOrFail");
 
 // packages/cli/src/serve/routes/workspace-file-read.ts
 var MAX_LIST_ENTRIES = 2e3;
@@ -29206,6 +29238,84 @@ init_esbuild_shims();
 import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
 import { realpathSync as realpathSync3 } from "node:fs";
 import { basename as basename4, dirname as dirname4, isAbsolute as isAbsolute7, join as join8, resolve as resolve4, sep as sep3 } from "node:path";
+
+// packages/cli/src/serve/native-directory-picker.ts
+init_esbuild_shims();
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
+var PICKER_TIMEOUT_MS = 3e5;
+var NativeDirectoryPickerUnavailableError = class extends Error {
+  static {
+    __name(this, "NativeDirectoryPickerUnavailableError");
+  }
+};
+async function pickNativeDirectory(signal) {
+  try {
+    if (process.platform === "darwin") {
+      const script = [
+        "const app = Application.currentApplication();",
+        "app.includeStandardAdditions = true;",
+        "app.chooseFolder({",
+        'withPrompt: "Select a workspace folder",',
+        "}).toString();"
+      ].join(" ");
+      const { stdout } = await execFileAsync2(
+        "osascript",
+        ["-l", "JavaScript", "-e", script],
+        { timeout: PICKER_TIMEOUT_MS, signal }
+      );
+      return stdout.trim() || void 0;
+    }
+    if (process.platform === "win32") {
+      const script = [
+        "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8;",
+        "Add-Type -AssemblyName System.Windows.Forms;",
+        "$dialog = New-Object System.Windows.Forms.FolderBrowserDialog;",
+        "if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {",
+        "[Console]::Out.Write($dialog.SelectedPath)",
+        "}"
+      ].join(" ");
+      const { stdout } = await execFileAsync2(
+        "powershell.exe",
+        ["-NoProfile", "-STA", "-Command", script],
+        { timeout: PICKER_TIMEOUT_MS, signal }
+      );
+      return stdout.trim() || void 0;
+    }
+    if (process.platform === "linux") {
+      const { stdout } = await execFileAsync2(
+        "zenity",
+        [
+          "--file-selection",
+          "--directory",
+          "--title=Select a workspace folder"
+        ],
+        { timeout: PICKER_TIMEOUT_MS, signal }
+      );
+      return stdout.trim() || void 0;
+    }
+  } catch (error2) {
+    const result = error2;
+    if (result.killed) {
+      return void 0;
+    }
+    if (process.platform === "darwin" && (result.stderr?.includes("(-128)") || result.stderr?.includes("User canceled")) || // Zenity exits 1 both for a deliberate cancel and for "cannot open
+    // display" on headless Linux; only the former is a silent cancel.
+    process.platform === "linux" && result.code === 1 && !result.stderr?.includes("cannot open display")) {
+      return void 0;
+    }
+    throw new NativeDirectoryPickerUnavailableError(
+      error2 instanceof Error ? error2.message : String(error2)
+    );
+  }
+  throw new NativeDirectoryPickerUnavailableError(
+    `Native directory picker is not supported on ${process.platform}`
+  );
+}
+__name(pickNativeDirectory, "pickNativeDirectory");
+
+// packages/cli/src/serve/routes/workspace-management.ts
 var MAX_PATH_SUGGESTIONS = 50;
 function registerWorkspaceManagementRoutes(app, deps) {
   const {
@@ -29218,8 +29328,10 @@ function registerWorkspaceManagementRoutes(app, deps) {
     runWorkspaceTrustOperation,
     workspaceRegistrationStore,
     getAcpHandle,
-    runtimeRemoval
+    runtimeRemoval,
+    pickWorkspaceDirectory: pickWorkspaceDirectoryOverride
   } = deps;
+  const pickWorkspaceDirectory = pickWorkspaceDirectoryOverride ?? pickNativeDirectory;
   const inFlight = /* @__PURE__ */ new Map();
   let sealed = false;
   let activeOperations = 0;
@@ -29460,6 +29572,41 @@ function registerWorkspaceManagementRoutes(app, deps) {
       });
     }
   );
+  app.post(
+    "/workspace-directory-picker",
+    mutate(),
+    async (req, res) => {
+      const controller = new AbortController();
+      res.on("close", () => controller.abort());
+      try {
+        const path14 = await pickWorkspaceDirectory(controller.signal);
+        res.status(200).json({
+          kind: "workspace-directory-picker",
+          selected: path14 !== void 0,
+          ...path14 === void 0 ? {} : { path: path14 }
+        });
+      } catch (error2) {
+        const detail = error2 instanceof Error ? error2.message : String(error2);
+        if (error2 instanceof NativeDirectoryPickerUnavailableError) {
+          writeStderrLine(
+            `qwen serve: native directory picker unavailable: ${detail}`
+          );
+          res.status(501).json({
+            error: "Native directory picker is unavailable",
+            code: "directory_picker_unavailable"
+          });
+          return;
+        }
+        writeStderrLine(
+          `qwen serve: native directory picker failed: ${detail}`
+        );
+        res.status(500).json({
+          error: "Failed to open native directory picker",
+          code: "directory_picker_failed"
+        });
+      }
+    }
+  );
   app.post(
     "/workspaces",
     mutate({ strict: true }),
@@ -30717,7 +30864,9 @@ async function handleLogList(req, res, workspaceCwd, sendBridgeError2, route) {
   try {
     applyReadHeaders(res);
     const { limit, skip } = parsePagination(req);
-    const result = await fetchGitLog(workspaceCwd, { limit, skip });
+    const rawRange = req.query["range"];
+    const range = typeof rawRange === "string" && rawRange.trim() ? rawRange.trim() : void 0;
+    const result = await fetchGitLog(workspaceCwd, { limit, skip, range });
     res.status(200).json(buildLogList(workspaceCwd, result));
   } catch (err) {
     sendBridgeError2(res, err, { route });
@@ -30797,6 +30946,502 @@ function registerWorkspaceQualifiedGitLogRoutes(app, deps) {
 }
 __name(registerWorkspaceQualifiedGitLogRoutes, "registerWorkspaceQualifiedGitLogRoutes");
 
+// packages/cli/src/serve/routes/workspace-git-branches.ts
+init_esbuild_shims();
+var GIT_ERROR_MESSAGE_MAX = 512;
+function resolveTrustedRuntime5(registry, req, res) {
+  const runtime = resolveWorkspaceRuntimeFromParam(registry, req, res);
+  if (!runtime) return null;
+  return requireTrustedWorkspaceRuntime(runtime, res) ? runtime : null;
+}
+__name(resolveTrustedRuntime5, "resolveTrustedRuntime");
+function sendGitError(res, err, route, sendBridgeError2, cwd) {
+  let detail;
+  if (err && typeof err === "object" && ("stdout" in err || "stderr" in err)) {
+    const e = err;
+    detail = `${e.stdout ?? ""}
+${e.stderr ?? ""}`;
+  } else {
+    detail = err instanceof Error ? err.message : String(err);
+  }
+  const gitRoot = findGitRoot(cwd);
+  let message = detail.split(cwd).join("<workspace>");
+  if (gitRoot && gitRoot !== cwd) {
+    message = message.split(gitRoot).join("<workspace>");
+  }
+  message = message.slice(0, GIT_ERROR_MESSAGE_MAX);
+  if (/not a git repository/i.test(message) || /invalid reference/i.test(message)) {
+    res.status(404).json({ error: "not_a_git_repository", message });
+    return;
+  }
+  if (/dirty|uncommitted|would be overwritten/i.test(message)) {
+    res.status(409).json({ error: "dirty_working_tree", message });
+    return;
+  }
+  if (/already exists/i.test(message)) {
+    res.status(409).json({ error: "branch_already_exists", message });
+    return;
+  }
+  if (/nothing to commit/i.test(message)) {
+    res.status(400).json({ error: "nothing_to_commit", message });
+    return;
+  }
+  if (/detached HEAD/i.test(message)) {
+    res.status(409).json({ error: "detached_head", message });
+    return;
+  }
+  if (/no upstream|no tracking information/i.test(message)) {
+    res.status(400).json({ error: "no_upstream", message });
+    return;
+  }
+  sendBridgeError2(res, new Error(message), { route });
+}
+__name(sendGitError, "sendGitError");
+async function handleBranches(res, cwd, sendBridgeError2, route, assertGenerationOpen, env) {
+  try {
+    assertGenerationOpen?.();
+    const result = await fetchGitBranches(cwd, env);
+    assertGenerationOpen?.();
+    res.status(200).json({
+      v: 1,
+      workspaceCwd: cwd,
+      available: true,
+      local: result.local,
+      remote: result.remote,
+      tags: result.tags,
+      recent: result.recent,
+      head: result.head,
+      detached: result.detached
+    });
+  } catch (err) {
+    if (sendGenerationClosedError(res, err)) return;
+    sendGitError(res, err, route, sendBridgeError2, cwd);
+  }
+}
+__name(handleBranches, "handleBranches");
+async function handleCheckout(req, res, cwd, sendBridgeError2, route, env) {
+  const body = safeBody(req);
+  const ref = body["ref"];
+  if (typeof ref !== "string" || !ref.trim()) {
+    res.status(400).json({ error: "missing_ref", message: "ref is required" });
+    return;
+  }
+  if (!isValidCheckoutRef(ref)) {
+    res.status(400).json({ error: "invalid_ref", message: "Invalid checkout ref" });
+    return;
+  }
+  try {
+    const result = await gitCheckout(cwd, ref.trim(), env);
+    res.status(200).json(result);
+  } catch (err) {
+    sendGitError(res, err, route, sendBridgeError2, cwd);
+  }
+}
+__name(handleCheckout, "handleCheckout");
+async function handleCreateBranch(req, res, cwd, sendBridgeError2, route, env) {
+  const body = safeBody(req);
+  const name = body["name"];
+  if (typeof name !== "string" || !isValidRefName(name) || name.startsWith("-")) {
+    res.status(400).json({ error: "invalid_branch_name", message: "Invalid branch name" });
+    return;
+  }
+  const rawStartPoint = body["startPoint"];
+  if (rawStartPoint !== void 0 && typeof rawStartPoint !== "string") {
+    res.status(400).json({
+      error: "invalid_start_point",
+      message: "startPoint must be a string"
+    });
+    return;
+  }
+  const startPoint = typeof rawStartPoint === "string" ? rawStartPoint.trim() || void 0 : void 0;
+  if (startPoint !== void 0 && !isValidCheckoutRef(startPoint)) {
+    res.status(400).json({ error: "invalid_start_point", message: "Invalid start point" });
+    return;
+  }
+  try {
+    const result = await gitCreateBranch(cwd, name, startPoint, env);
+    res.status(200).json(result);
+  } catch (err) {
+    sendGitError(res, err, route, sendBridgeError2, cwd);
+  }
+}
+__name(handleCreateBranch, "handleCreateBranch");
+async function handlePush(req, res, cwd, sendBridgeError2, route, env) {
+  const body = safeBody(req);
+  if (body["setUpstream"] !== void 0 && typeof body["setUpstream"] !== "boolean") {
+    res.status(400).json({
+      error: "invalid_set_upstream",
+      message: "setUpstream must be a boolean"
+    });
+    return;
+  }
+  if (body["force"] !== void 0 && typeof body["force"] !== "boolean") {
+    res.status(400).json({ error: "invalid_force", message: "force must be a boolean" });
+    return;
+  }
+  const setUpstream = body["setUpstream"] === true;
+  const force = body["force"] === true;
+  try {
+    const result = await gitPush(cwd, { setUpstream, force }, env);
+    res.status(200).json(result);
+  } catch (err) {
+    sendGitError(res, err, route, sendBridgeError2, cwd);
+  }
+}
+__name(handlePush, "handlePush");
+async function handlePull(req, res, cwd, sendBridgeError2, route, env) {
+  const body = safeBody(req);
+  if (body["rebase"] !== void 0 && typeof body["rebase"] !== "boolean") {
+    res.status(400).json({ error: "invalid_rebase", message: "rebase must be a boolean" });
+    return;
+  }
+  if (body["fetchOnly"] !== void 0 && typeof body["fetchOnly"] !== "boolean") {
+    res.status(400).json({
+      error: "invalid_fetch_only",
+      message: "fetchOnly must be a boolean"
+    });
+    return;
+  }
+  const rebase = body["rebase"] === true;
+  const fetchOnly = body["fetchOnly"] === true;
+  try {
+    const result = await gitPull(cwd, { rebase, fetchOnly }, env);
+    res.status(200).json(result);
+  } catch (err) {
+    sendGitError(res, err, route, sendBridgeError2, cwd);
+  }
+}
+__name(handlePull, "handlePull");
+async function handleCommit(req, res, cwd, sendBridgeError2, route, env) {
+  const body = safeBody(req);
+  const message = body["message"];
+  if (typeof message !== "string" || !message.trim()) {
+    res.status(400).json({ error: "missing_message", message: "message is required" });
+    return;
+  }
+  if (body["all"] !== void 0 && typeof body["all"] !== "boolean") {
+    res.status(400).json({ error: "invalid_all", message: "all must be a boolean" });
+    return;
+  }
+  const all = body["all"] === true;
+  try {
+    const result = await gitCommit(cwd, message.trim(), { all }, env);
+    res.status(200).json(result);
+  } catch (err) {
+    sendGitError(res, err, route, sendBridgeError2, cwd);
+  }
+}
+__name(handleCommit, "handleCommit");
+function registerWorkspaceGitBranchRoutes(app, deps) {
+  app.get("/workspace/git/branches", (_req, res) => {
+    if (deps.isWorkspaceTrusted?.() === false) {
+      sendUntrustedWorkspaceResponse(res);
+      return;
+    }
+    void handleBranches(
+      res,
+      deps.boundWorkspace,
+      deps.sendBridgeError,
+      "GET /workspace/git/branches",
+      deps.captureGenerationAssertion?.()
+    );
+  });
+  app.post(
+    "/workspace/git/checkout",
+    deps.mutate({ strict: true }),
+    (req, res) => {
+      if (deps.isWorkspaceTrusted?.() === false) {
+        sendUntrustedWorkspaceResponse(res);
+        return;
+      }
+      try {
+        deps.captureGenerationAssertion?.()?.();
+      } catch (err) {
+        deps.sendBridgeError(res, err, {
+          route: "POST /workspace/git/checkout"
+        });
+        return;
+      }
+      void handleCheckout(
+        req,
+        res,
+        deps.boundWorkspace,
+        deps.sendBridgeError,
+        "POST /workspace/git/checkout"
+      );
+    }
+  );
+  app.post(
+    "/workspace/git/branch",
+    deps.mutate({ strict: true }),
+    (req, res) => {
+      if (deps.isWorkspaceTrusted?.() === false) {
+        sendUntrustedWorkspaceResponse(res);
+        return;
+      }
+      try {
+        deps.captureGenerationAssertion?.()?.();
+      } catch (err) {
+        deps.sendBridgeError(res, err, {
+          route: "POST /workspace/git/branch"
+        });
+        return;
+      }
+      void handleCreateBranch(
+        req,
+        res,
+        deps.boundWorkspace,
+        deps.sendBridgeError,
+        "POST /workspace/git/branch"
+      );
+    }
+  );
+  app.post("/workspace/git/push", deps.mutate({ strict: true }), (req, res) => {
+    if (deps.isWorkspaceTrusted?.() === false) {
+      sendUntrustedWorkspaceResponse(res);
+      return;
+    }
+    try {
+      deps.captureGenerationAssertion?.()?.();
+    } catch (err) {
+      deps.sendBridgeError(res, err, { route: "POST /workspace/git/push" });
+      return;
+    }
+    void handlePush(
+      req,
+      res,
+      deps.boundWorkspace,
+      deps.sendBridgeError,
+      "POST /workspace/git/push"
+    );
+  });
+  app.post("/workspace/git/pull", deps.mutate({ strict: true }), (req, res) => {
+    if (deps.isWorkspaceTrusted?.() === false) {
+      sendUntrustedWorkspaceResponse(res);
+      return;
+    }
+    try {
+      deps.captureGenerationAssertion?.()?.();
+    } catch (err) {
+      deps.sendBridgeError(res, err, { route: "POST /workspace/git/pull" });
+      return;
+    }
+    void handlePull(
+      req,
+      res,
+      deps.boundWorkspace,
+      deps.sendBridgeError,
+      "POST /workspace/git/pull"
+    );
+  });
+  app.post(
+    "/workspace/git/commit",
+    deps.mutate({ strict: true }),
+    (req, res) => {
+      if (deps.isWorkspaceTrusted?.() === false) {
+        sendUntrustedWorkspaceResponse(res);
+        return;
+      }
+      try {
+        deps.captureGenerationAssertion?.()?.();
+      } catch (err) {
+        deps.sendBridgeError(res, err, {
+          route: "POST /workspace/git/commit"
+        });
+        return;
+      }
+      void handleCommit(
+        req,
+        res,
+        deps.boundWorkspace,
+        deps.sendBridgeError,
+        "POST /workspace/git/commit"
+      );
+    }
+  );
+}
+__name(registerWorkspaceGitBranchRoutes, "registerWorkspaceGitBranchRoutes");
+function registerWorkspaceQualifiedGitBranchRoutes(app, deps) {
+  app.get("/workspaces/:workspace/git/branches", (req, res) => {
+    const runtime = resolveTrustedRuntime5(deps.workspaceRegistry, req, res);
+    if (!runtime) return;
+    void handleBranches(
+      res,
+      resolveContainedCwd(req, runtime.workspaceCwd),
+      deps.sendBridgeError,
+      "GET /workspaces/:workspace/git/branches",
+      () => runtime.generationGuard?.assertOpen(),
+      runtime.env.effectiveEnv
+    );
+  });
+  app.post(
+    "/workspaces/:workspace/git/checkout",
+    deps.mutate({ strict: true }),
+    (req, res) => {
+      const runtime = resolveTrustedRuntime5(deps.workspaceRegistry, req, res);
+      if (!runtime) return;
+      try {
+        runtime.generationGuard?.assertOpen();
+      } catch (err) {
+        if (sendGenerationClosedError(res, err)) return;
+        deps.sendBridgeError(res, err, {
+          route: "POST /workspaces/:workspace/git/checkout"
+        });
+        return;
+      }
+      const cwd = resolveContainedCwdOrFail(req, runtime.workspaceCwd);
+      if (cwd === null) {
+        res.status(400).json({
+          error: "invalid_cwd",
+          message: "The supplied cwd is invalid or outside the workspace"
+        });
+        return;
+      }
+      void handleCheckout(
+        req,
+        res,
+        cwd,
+        deps.sendBridgeError,
+        "POST /workspaces/:workspace/git/checkout",
+        runtime.env.effectiveEnv
+      );
+    }
+  );
+  app.post(
+    "/workspaces/:workspace/git/branch",
+    deps.mutate({ strict: true }),
+    (req, res) => {
+      const runtime = resolveTrustedRuntime5(deps.workspaceRegistry, req, res);
+      if (!runtime) return;
+      try {
+        runtime.generationGuard?.assertOpen();
+      } catch (err) {
+        if (sendGenerationClosedError(res, err)) return;
+        deps.sendBridgeError(res, err, {
+          route: "POST /workspaces/:workspace/git/branch"
+        });
+        return;
+      }
+      const cwd = resolveContainedCwdOrFail(req, runtime.workspaceCwd);
+      if (cwd === null) {
+        res.status(400).json({
+          error: "invalid_cwd",
+          message: "The supplied cwd is invalid or outside the workspace"
+        });
+        return;
+      }
+      void handleCreateBranch(
+        req,
+        res,
+        cwd,
+        deps.sendBridgeError,
+        "POST /workspaces/:workspace/git/branch",
+        runtime.env.effectiveEnv
+      );
+    }
+  );
+  app.post(
+    "/workspaces/:workspace/git/push",
+    deps.mutate({ strict: true }),
+    (req, res) => {
+      const runtime = resolveTrustedRuntime5(deps.workspaceRegistry, req, res);
+      if (!runtime) return;
+      try {
+        runtime.generationGuard?.assertOpen();
+      } catch (err) {
+        if (sendGenerationClosedError(res, err)) return;
+        deps.sendBridgeError(res, err, {
+          route: "POST /workspaces/:workspace/git/push"
+        });
+        return;
+      }
+      const cwd = resolveContainedCwdOrFail(req, runtime.workspaceCwd);
+      if (cwd === null) {
+        res.status(400).json({
+          error: "invalid_cwd",
+          message: "The supplied cwd is invalid or outside the workspace"
+        });
+        return;
+      }
+      void handlePush(
+        req,
+        res,
+        cwd,
+        deps.sendBridgeError,
+        "POST /workspaces/:workspace/git/push",
+        runtime.env.effectiveEnv
+      );
+    }
+  );
+  app.post(
+    "/workspaces/:workspace/git/pull",
+    deps.mutate({ strict: true }),
+    (req, res) => {
+      const runtime = resolveTrustedRuntime5(deps.workspaceRegistry, req, res);
+      if (!runtime) return;
+      try {
+        runtime.generationGuard?.assertOpen();
+      } catch (err) {
+        if (sendGenerationClosedError(res, err)) return;
+        deps.sendBridgeError(res, err, {
+          route: "POST /workspaces/:workspace/git/pull"
+        });
+        return;
+      }
+      const cwd = resolveContainedCwdOrFail(req, runtime.workspaceCwd);
+      if (cwd === null) {
+        res.status(400).json({
+          error: "invalid_cwd",
+          message: "The supplied cwd is invalid or outside the workspace"
+        });
+        return;
+      }
+      void handlePull(
+        req,
+        res,
+        cwd,
+        deps.sendBridgeError,
+        "POST /workspaces/:workspace/git/pull",
+        runtime.env.effectiveEnv
+      );
+    }
+  );
+  app.post(
+    "/workspaces/:workspace/git/commit",
+    deps.mutate({ strict: true }),
+    (req, res) => {
+      const runtime = resolveTrustedRuntime5(deps.workspaceRegistry, req, res);
+      if (!runtime) return;
+      try {
+        runtime.generationGuard?.assertOpen();
+      } catch (err) {
+        if (sendGenerationClosedError(res, err)) return;
+        deps.sendBridgeError(res, err, {
+          route: "POST /workspaces/:workspace/git/commit"
+        });
+        return;
+      }
+      const cwd = resolveContainedCwdOrFail(req, runtime.workspaceCwd);
+      if (cwd === null) {
+        res.status(400).json({
+          error: "invalid_cwd",
+          message: "The supplied cwd is invalid or outside the workspace"
+        });
+        return;
+      }
+      void handleCommit(
+        req,
+        res,
+        cwd,
+        deps.sendBridgeError,
+        "POST /workspaces/:workspace/git/commit",
+        runtime.env.effectiveEnv
+      );
+    }
+  );
+}
+__name(registerWorkspaceQualifiedGitBranchRoutes, "registerWorkspaceQualifiedGitBranchRoutes");
+
 // packages/cli/src/serve/routes/workspace-github-prs.ts
 init_esbuild_shims();
 var DEFAULT_CACHE_TTL_MS2 = 6e4;
@@ -30807,13 +31452,13 @@ __name(sanitizeMessage, "sanitizeMessage");
 function registerWorkspaceQualifiedGitHubPrsRoutes(app, deps) {
   const ttlMs = deps.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS2;
   const cache = /* @__PURE__ */ new Map();
-  const getPullRequests = /* @__PURE__ */ __name((workspaceCwd) => {
+  const getPullRequests = /* @__PURE__ */ __name((workspaceCwd, env) => {
     const now = Date.now();
     const existing = cache.get(workspaceCwd);
     const fresh = existing !== void 0 && (existing.settledAt === null || now - existing.settledAt < ttlMs);
     if (!fresh) {
       const entry = {
-        promise: fetchGitHubPullRequests(workspaceCwd),
+        promise: fetchGitHubPullRequests(workspaceCwd, env),
         settledAt: null
       };
       cache.set(workspaceCwd, entry);
@@ -30841,7 +31486,10 @@ function registerWorkspaceQualifiedGitHubPrsRoutes(app, deps) {
     if (!requireTrustedWorkspaceRuntime(runtime, res)) return;
     applyReadHeaders(res);
     try {
-      const result = await getPullRequests(runtime.workspaceCwd);
+      const result = await getPullRequests(
+        runtime.workspaceCwd,
+        runtime.env.effectiveEnv
+      );
       switch (result.kind) {
         case "ok":
           res.status(200).json({
@@ -30887,6 +31535,113 @@ function registerWorkspaceQualifiedGitHubPrsRoutes(app, deps) {
       deps.sendBridgeError(res, err, { route });
     }
   });
+  app.post(
+    "/workspaces/:workspace/github/prs/create",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const route = "POST /workspaces/:workspace/github/prs/create";
+      const runtime = resolveWorkspaceRuntimeFromParam(
+        deps.workspaceRegistry,
+        req,
+        res
+      );
+      if (!runtime) return;
+      if (!requireTrustedWorkspaceRuntime(runtime, res)) return;
+      try {
+        runtime.generationGuard?.assertOpen();
+      } catch (err) {
+        if (sendGenerationClosedError(res, err)) return;
+        deps.sendBridgeError(res, err, { route });
+        return;
+      }
+      const body = safeBody(req);
+      const title = body["title"];
+      if (typeof title !== "string" || !title.trim()) {
+        res.status(400).json({ error: "title is required" });
+        return;
+      }
+      for (const field of ["body", "base", "head"]) {
+        if (body[field] !== void 0 && typeof body[field] !== "string") {
+          res.status(400).json({ error: `${field} must be a string` });
+          return;
+        }
+      }
+      const prBody = typeof body["body"] === "string" ? body["body"] : void 0;
+      const base = typeof body["base"] === "string" ? body["base"] : void 0;
+      const head = typeof body["head"] === "string" ? body["head"] : void 0;
+      const cwd = resolveContainedCwdOrFail(req, runtime.workspaceCwd);
+      if (cwd === null) {
+        res.status(400).json({
+          error: "invalid_cwd",
+          message: "The supplied cwd is invalid or outside the workspace"
+        });
+        return;
+      }
+      try {
+        const result = await createGitHubPullRequest(
+          cwd,
+          {
+            title: title.trim(),
+            body: prBody,
+            base,
+            head
+          },
+          runtime.env.effectiveEnv
+        );
+        switch (result.kind) {
+          case "ok":
+            res.status(201).json({ url: result.url, number: result.number });
+            return;
+          case "not_a_repo":
+            res.status(404).json({ error: "not_a_git_repository" });
+            return;
+          case "cli_unavailable":
+            res.status(502).json({
+              error: "gh CLI not available",
+              code: "github_cli_unavailable"
+            });
+            return;
+          case "failed":
+            res.status(502).json({
+              error: sanitizeMessage(
+                sanitizeMessage(result.message, runtime.workspaceCwd),
+                result.gitRoot
+              ).slice(0, GITHUB_PR_ERROR_MESSAGE_MAX),
+              code: "github_pr_create_failed"
+            });
+            return;
+          default:
+            res.status(500).json({ error: "unexpected result" });
+            return;
+        }
+      } catch (err) {
+        deps.sendBridgeError(res, err, { route });
+      }
+    }
+  );
+  app.get("/workspaces/:workspace/github/default-branch", async (req, res) => {
+    const route = "GET /workspaces/:workspace/github/default-branch";
+    const runtime = resolveWorkspaceRuntimeFromParam(
+      deps.workspaceRegistry,
+      req,
+      res
+    );
+    if (!runtime) return;
+    if (!requireTrustedWorkspaceRuntime(runtime, res)) return;
+    applyReadHeaders(res);
+    try {
+      runtime.generationGuard?.assertOpen();
+      const branch = await getDefaultBranch(
+        runtime.workspaceCwd,
+        runtime.env.effectiveEnv
+      );
+      runtime.generationGuard?.assertOpen();
+      res.status(200).json({ branch: branch ?? "origin/main" });
+    } catch (err) {
+      if (sendGenerationClosedError(res, err)) return;
+      deps.sendBridgeError(res, err, { route });
+    }
+  });
 }
 __name(registerWorkspaceQualifiedGitHubPrsRoutes, "registerWorkspaceQualifiedGitHubPrsRoutes");
 
@@ -33542,9 +34297,22 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     workspaceRegistry,
     sendBridgeError: sendBridgeError2
   });
+  registerWorkspaceGitBranchRoutes(app, {
+    boundWorkspace: primaryBoundWorkspace,
+    sendBridgeError: sendBridgeError2,
+    isWorkspaceTrusted: isPrimaryWorkspaceTrusted,
+    captureGenerationAssertion: capturePrimaryGenerationAssertion,
+    mutate
+  });
+  registerWorkspaceQualifiedGitBranchRoutes(app, {
+    workspaceRegistry,
+    sendBridgeError: sendBridgeError2,
+    mutate
+  });
   registerWorkspaceQualifiedGitHubPrsRoutes(app, {
     workspaceRegistry,
-    sendBridgeError: sendBridgeError2
+    sendBridgeError: sendBridgeError2,
+    mutate
   });
   mountWorkspaceMemoryRoutes(app, {
     bridge: primaryBridge,