@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.2-preview.0

package/chunks/{chunk-RD3VPM4E.js → chunk-PQWM4SX2.js}

@@ -3,11 +3,11 @@
 import {
   TURN_INTERRUPTION_HISTORY_TAIL_COUNT,
   detectTurnInterruption
-} from "./chunk-TXAEXF2B.js";
+} from "./chunk-BL6B2QS2.js";
 import {
   SessionService,
   buildApiHistoryFromConversation
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-Z6KFLEG7.js → chunk-PSPAM24S.js}

@@ -57,6 +57,7 @@ var ACTIVE_WORK_HOLD_CATEGORIES = [
   "agent",
   "notification",
   "shell",
+  "session",
   "workflow"
 ];
 function clampActiveWorkIntervalMs(raw) {

package/chunks/{chunk-RUMSY4ES.js → chunk-Q2F43WTJ.js}

@@ -3,7 +3,7 @@
 import {
   customDeepMerge,
   getSettingsSchema
-} from "./chunk-QW7BUOSI.js";
+} from "./chunk-MWEF5MUK.js";
 import {
   DEFAULT_DARK_THEME_NAME,
   DEFAULT_LIGHT_THEME_NAME
@@ -21,7 +21,7 @@ import {
 } from "./chunk-IDS7MSUP.js";
 import {
   t
-} from "./chunk-LD53HMPV.js";
+} from "./chunk-CRZBDVP2.js";
 import {
   SUPPORTED_LANGUAGES,
   getLanguageNameFromLocale
@@ -30,21 +30,21 @@ import {
   getHomeEnvFallbackVars,
   loadEnvironment,
   preResolveHomeEnvOverrides
-} from "./chunk-4OCYWXKF.js";
+} from "./chunk-Y6ZWXM44.js";
 import {
   ENV_CORRUPTED_PATH,
   ENV_WAS_RECOVERED
-} from "./chunk-NUQFUXOG.js";
+} from "./chunk-QTNCGZHQ.js";
 import {
   isWorkspaceTrusted,
   updateSettingsFilePreservingFormat
-} from "./chunk-GEV66YGE.js";
+} from "./chunk-7RXOEUFF.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
 import {
   resolveEnvVarsInObject
-} from "./chunk-3K65MUKD.js";
+} from "./chunk-65I7S4Z3.js";
 import {
   stripRuntimeSnapshotPrefix
 } from "./chunk-565U2ANU.js";
@@ -439,7 +439,8 @@ var WORKSPACE_RESTRICTED_SETTINGS = [
   { section: "tools", key: "workflowsEnabled" },
   { section: "security", key: "allowPrivateNetworkHooks" },
   { section: "security", key: "allowedInsecureVoiceBaseUrls" },
-  { section: "goals", key: "modelProposed" }
+  { section: "goals", key: "modelProposed" },
+  { section: "outboundCorrelation", key: "allowDynamicHeaderValues" }
 ];
 var WORKSPACE_TIGHTEN_ONLY_SETTINGS = [
   {

package/chunks/{chunk-VYCJITND.js → chunk-QJAFSFYA.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getEffectiveSupportedModes
-} from "./chunk-I67KJGM6.js";
+} from "./chunk-W3ONSAYO.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-L36LLVA5.js → chunk-QLM7D7W3.js}

@@ -27,10 +27,10 @@ import {
 } from "./chunk-3VUENPWF.js";
 import {
   loadSettings
-} from "./chunk-RUMSY4ES.js";
+} from "./chunk-Q2F43WTJ.js";
 import {
   MCP_BUDGET_WARN_FRACTION
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
@@ -447,7 +447,7 @@ var serveCommand = {
     delete process.env[EXTERNAL_TOOL_GUARD_TOKEN_ENV];
     const openWithAuth = argv["open-with-auth"];
     const open = argv.open || openWithAuth;
-    const { runQwenServe } = await import("./run-qwen-serve-CTFL5R6U.js");
+    const { runQwenServe } = await import("./run-qwen-serve-OJYVH7N6.js");
     try {
       const serveOptions = {
         port: argv.port,

package/chunks/{chunk-NUQFUXOG.js → chunk-QTNCGZHQ.js}

@@ -39,6 +39,8 @@ var PROJECT_ENV_HARDCODED_EXCLUSIONS = [
   "QWEN_RUNTIME_DIR",
   "QWEN_CODE_MCP_APPROVALS_PATH",
   "QWEN_CODE_TRUSTED_FOLDERS_PATH",
+  // Downloaded updates execute as the user; a project must not select them.
+  "QWEN_UPDATE_BASE_URL",
   // This points to a host temp file that carries build warnings. A project
   // `.env` must not redirect it to an arbitrary file to read or delete.
   "QWEN_CODE_WARNINGS_FILE",

package/chunks/{chunk-XNC2TCUO.js → chunk-QXXBW2G4.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   t
-} from "./chunk-LD53HMPV.js";
+} from "./chunk-CRZBDVP2.js";
 import {
   SessionReferenceService,
   readManyFiles
-} from "./chunk-TXAEXF2B.js";
+} from "./chunk-BL6B2QS2.js";
 import {
   emptyMcpResourceText,
   formatMcpResourceContents,
@@ -15,10 +15,10 @@ import {
 import {
   SessionService,
   stripTerminalControlSequences
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
 import {
   shouldRunVisionBridge
-} from "./chunk-WQBR7LN5.js";
+} from "./chunk-OIPUQE3S.js";
 import {
   Storage,
   getErrorMessage,

package/chunks/{chunk-TDHVOZ65.js → chunk-R2266LQ5.js}

@@ -6,8 +6,8 @@ import {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "4bfa3f93d3";
-var CLI_VERSION = "0.23.1-preview.2";
+var GIT_COMMIT_INFO = "88acf9947d";
+var CLI_VERSION = "0.23.2-preview.0";
 
 export {
   GIT_COMMIT_INFO,

package/chunks/{chunk-QJVZLILI.js → chunk-R7OO56VZ.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-NYWWQ437.js";
 import {
   SessionNotFoundError
-} from "./chunk-F47DITLZ.js";
+} from "./chunk-FAWTMDX7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-LYHYXJJ3.js → chunk-RDV4NLI3.js}

@@ -8,16 +8,16 @@ import {
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-LD53HMPV.js";
+} from "./chunk-CRZBDVP2.js";
 import {
   IdeClient
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
 import {
   AuthEvent,
   IdeConnectionEvent,
   logAuth,
   logIdeConnection
-} from "./chunk-WQBR7LN5.js";
+} from "./chunk-OIPUQE3S.js";
 import {
   getErrorMessage
 } from "./chunk-ZAFYHRVY.js";

package/chunks/{chunk-733KQL63.js → chunk-RN6V5HKE.js}

@@ -3,7 +3,7 @@
 import {
   getUserSettingsPath,
   v1ToV2Migration
-} from "./chunk-RUMSY4ES.js";
+} from "./chunk-Q2F43WTJ.js";
 import {
   getSystemDefaultsPath,
   getSystemSettingsPath
@@ -13,7 +13,7 @@ import {
   TrustLevel,
   getExplicitTrustLevel,
   getTrustedFoldersPath
-} from "./chunk-GEV66YGE.js";
+} from "./chunk-7RXOEUFF.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
@@ -22,7 +22,7 @@ import {
 } from "./chunk-MR3PXB6E.js";
 import {
   ideContextStore
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-WLZRMF3C.js → chunk-RX3FYFCN.js}

@@ -23,10 +23,11 @@ import {
   SessionConflictError,
   SessionNotArchivedError,
   SessionNotFoundError
-} from "./chunk-F47DITLZ.js";
+} from "./chunk-FAWTMDX7.js";
 import {
-  readWorktreeSession
-} from "./chunk-E4VX6LXB.js";
+  readWorktreeSession,
+  readWorktreeSessionStrict
+} from "./chunk-YZTGGCEE.js";
 import {
   SESSION_PR_LIST_LIMIT,
   SESSION_PR_URL_MAX_LENGTH,
@@ -40,7 +41,12 @@ import {
   gitEnv,
   readSessionPrs,
   toSessionPrInfo
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
+import {
+  GitWorktreeService,
+  WORKTREE_SESSION_FILE,
+  readWorktreeSessionMarkerStrict
+} from "./chunk-HIXUUCGY.js";
 import {
   updateCronTasks
 } from "./chunk-F53KKZUD.js";
@@ -1322,6 +1328,7 @@ __name(createWorkspaceRuntimeSessionService, "createWorkspaceRuntimeSessionServi
 
 // packages/cli/src/serve/server/session-archive.ts
 init_esbuild_shims();
+import fs2 from "node:fs";
 
 // packages/cli/src/serve/scheduled-task-session-lifecycle.ts
 init_esbuild_shims();
@@ -1394,6 +1401,296 @@ async function removeTasksForSessions(projectRoot, sessionIds, options = {}) {
 }
 __name(removeTasksForSessions, "removeTasksForSessions");
 
+// packages/cli/src/serve/server/worktree-orphan-cleanup.ts
+init_esbuild_shims();
+import fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import path2 from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+// packages/cli/src/serve/server/worktree-ownership-op.ts
+init_esbuild_shims();
+var worktreeOwnershipOpTails = /* @__PURE__ */ new Map();
+async function acquireWorktreeOwnershipOp(worktreeKey) {
+  const previous = worktreeOwnershipOpTails.get(worktreeKey);
+  let releaseGate;
+  const gate = new Promise((resolve) => {
+    releaseGate = resolve;
+  });
+  const tail = (previous ?? Promise.resolve()).then(() => gate);
+  worktreeOwnershipOpTails.set(worktreeKey, tail);
+  if (previous) {
+    await previous;
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    releaseGate();
+    if (worktreeOwnershipOpTails.get(worktreeKey) === tail) {
+      worktreeOwnershipOpTails.delete(worktreeKey);
+    }
+  };
+}
+__name(acquireWorktreeOwnershipOp, "acquireWorktreeOwnershipOp");
+
+// packages/cli/src/serve/server/worktree-orphan-cleanup.ts
+function canonicalPath(candidate) {
+  try {
+    return fs.realpathSync(candidate);
+  } catch {
+    return candidate;
+  }
+}
+__name(canonicalPath, "canonicalPath");
+var execFileAsync = promisify(execFile);
+var DISPOSABLE_IGNORED_ROOTS = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage"]);
+async function checkoutHasWork(worktreePath) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      [
+        "status",
+        "--porcelain",
+        "--untracked-files=normal",
+        "--ignored=matching"
+      ],
+      { cwd: worktreePath, env: gitEnv() }
+    );
+    return stdout.split("\n").filter((line) => line.trim().length > 0).some((line) => {
+      const entry = line.slice(3);
+      if (entry === WORKTREE_SESSION_FILE) return false;
+      if (line.startsWith("!!")) {
+        return !DISPOSABLE_IGNORED_ROOTS.has(entry.split("/")[0]);
+      }
+      return true;
+    });
+  } catch {
+    return true;
+  }
+}
+__name(checkoutHasWork, "checkoutHasWork");
+function logWarning(message) {
+  writeStderrLine(`qwen serve: ${message}`);
+}
+__name(logWarning, "logWarning");
+function logWorktreeCleanupPreserve(sessionId, reason) {
+  logWarning(
+    `worktree cleanup preserved checkout action=delete session=${safeLogValue(
+      sessionId
+    )} reason=${safeLogValue(reason)}`
+  );
+}
+__name(logWorktreeCleanupPreserve, "logWorktreeCleanupPreserve");
+async function preclassifyWorktreeCleanup(service, sessionId, runtimeWorkspaceCwd) {
+  let sidecarPath = service.getWorktreeSessionPath(sessionId);
+  let sidecar = await readWorktreeSessionStrict(sidecarPath);
+  if (sidecar.state === "missing") {
+    const archivedPath = service.getWorktreeSessionPathForArchiveState(
+      sessionId,
+      "archived"
+    );
+    if (archivedPath !== sidecarPath) {
+      sidecarPath = archivedPath;
+      sidecar = await readWorktreeSessionStrict(sidecarPath);
+    }
+  }
+  if (sidecar.state === "missing") return void 0;
+  if (sidecar.state === "invalid") {
+    logWorktreeCleanupPreserve(
+      sessionId,
+      `unreadable sidecar (${sidecar.reason})`
+    );
+    return void 0;
+  }
+  const session = sidecar.session;
+  if (session.workspaceCwd === void 0) return void 0;
+  if (session.supersededBy !== void 0) return void 0;
+  if (!path2.isAbsolute(session.workspaceCwd) || !path2.isAbsolute(session.originalCwd)) {
+    logWorktreeCleanupPreserve(
+      sessionId,
+      "sidecar base is not an absolute path"
+    );
+    return void 0;
+  }
+  if (runtimeWorkspaceCwd !== void 0) {
+    if (canonicalPath(session.workspaceCwd) !== canonicalPath(runtimeWorkspaceCwd)) {
+      logWorktreeCleanupPreserve(
+        sessionId,
+        "sidecar belongs to another workspace"
+      );
+      return void 0;
+    }
+    const workspaceRoots = [canonicalPath(runtimeWorkspaceCwd)];
+    try {
+      const repoTop = await new GitWorktreeService(
+        runtimeWorkspaceCwd
+      ).getRepoTopLevel();
+      if (repoTop && canonicalPath(repoTop) !== workspaceRoots[0]) {
+        workspaceRoots.push(canonicalPath(repoTop));
+      }
+    } catch {
+    }
+    if (!workspaceRoots.includes(canonicalPath(session.originalCwd))) {
+      logWorktreeCleanupPreserve(
+        sessionId,
+        "sidecar original cwd is outside the accepted roots"
+      );
+      return void 0;
+    }
+  }
+  return {
+    sessionId,
+    sidecar: session,
+    sidecarPath,
+    lockKey: canonicalPath(session.worktreePath)
+  };
+}
+__name(preclassifyWorktreeCleanup, "preclassifyWorktreeCleanup");
+function acquireWorktreeCleanupLock(plan) {
+  return acquireWorktreeOwnershipOp(plan.lockKey);
+}
+__name(acquireWorktreeCleanupLock, "acquireWorktreeCleanupLock");
+async function worktreeAllowedRoots(workspaceCwd, originalCwd) {
+  const roots = /* @__PURE__ */ new Set();
+  for (const base of [workspaceCwd, originalCwd]) {
+    if (!path2.isAbsolute(base)) continue;
+    roots.add(path2.join(base, ".qwen", "worktrees"));
+    try {
+      const repoTop = await new GitWorktreeService(base).getRepoTopLevel();
+      if (repoTop) {
+        roots.add(path2.join(repoTop, ".qwen", "worktrees"));
+      }
+    } catch {
+    }
+  }
+  return [...roots];
+}
+__name(worktreeAllowedRoots, "worktreeAllowedRoots");
+async function verifyWorktreeCleanupOwnership(plan) {
+  const { sessionId, sidecar } = plan;
+  const locked = await readWorktreeSessionStrict(plan.sidecarPath);
+  if (locked.state !== "valid") {
+    return {
+      ok: false,
+      reason: locked.state === "missing" ? "sidecar disappeared before delete" : `unreadable sidecar (${locked.reason})`
+    };
+  }
+  const current = locked.session;
+  if (current.workspaceCwd === void 0 || current.supersededBy !== void 0 || current.slug !== sidecar.slug || current.worktreePath !== sidecar.worktreePath || current.originalCwd !== sidecar.originalCwd || current.workspaceCwd !== sidecar.workspaceCwd) {
+    return { ok: false, reason: "sidecar changed before delete" };
+  }
+  const marker = await readWorktreeSessionMarkerStrict(plan.lockKey);
+  if (marker.state !== "valid" || marker.sessionId !== sessionId) {
+    return {
+      ok: false,
+      reason: marker.state === "valid" ? "marker names another session" : `marker ${marker.state}`
+    };
+  }
+  const allowedRoots = await worktreeAllowedRoots(
+    current.workspaceCwd,
+    current.originalCwd
+  );
+  const contained = allowedRoots.some((root) => {
+    try {
+      const realRoot = fs.realpathSync(root);
+      return plan.lockKey === realRoot || plan.lockKey.startsWith(realRoot + path2.sep);
+    } catch {
+      return false;
+    }
+  });
+  if (!contained) {
+    return { ok: false, reason: "checkout outside workspace worktree roots" };
+  }
+  const chatsDir = path2.dirname(plan.sidecarPath);
+  const ownFile = path2.basename(plan.sidecarPath);
+  let entries;
+  try {
+    entries = await fsp.readdir(chatsDir);
+  } catch (error) {
+    return {
+      ok: false,
+      reason: `sidecar scan failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  for (const entry of entries) {
+    if (!entry.endsWith(".worktree.json") || entry === ownFile) continue;
+    const other = await readWorktreeSessionStrict(path2.join(chatsDir, entry));
+    if (other.state === "missing") continue;
+    if (other.state === "invalid") {
+      return { ok: false, reason: `unreadable sibling sidecar ${entry}` };
+    }
+    if (canonicalPath(other.session.worktreePath) === plan.lockKey) {
+      if (other.session.supersededBy === sessionId) continue;
+      return { ok: false, reason: `checkout shared with ${entry}` };
+    }
+  }
+  const removalTarget = canonicalPath(
+    new GitWorktreeService(current.originalCwd).getUserWorktreePath(
+      current.slug
+    )
+  );
+  if (removalTarget !== plan.lockKey) {
+    return {
+      ok: false,
+      reason: "slug does not resolve to the verified checkout"
+    };
+  }
+  plan.sidecar = current;
+  return { ok: true };
+}
+__name(verifyWorktreeCleanupOwnership, "verifyWorktreeCleanupOwnership");
+async function checkoutStillPopulated(worktreePath) {
+  try {
+    return (await fsp.readdir(worktreePath)).length > 0;
+  } catch {
+    return false;
+  }
+}
+__name(checkoutStillPopulated, "checkoutStillPopulated");
+async function executeWorktreeCleanup(plan) {
+  const { sessionId, sidecar } = plan;
+  const marker = await readWorktreeSessionMarkerStrict(plan.lockKey);
+  if (marker.state !== "valid" || marker.sessionId !== sessionId) {
+    logWorktreeCleanupPreserve(sessionId, "marker changed after delete");
+    return;
+  }
+  if (await checkoutHasWork(plan.lockKey)) {
+    logWorktreeCleanupPreserve(sessionId, "checkout has uncommitted work");
+    return;
+  }
+  const result = await new GitWorktreeService(
+    sidecar.originalCwd
+  ).removeUserWorktree(sidecar.slug, { deleteBranch: true });
+  if (!result.success) {
+    const errorText = result.error ?? "unknown error";
+    if (await checkoutStillPopulated(plan.lockKey)) {
+      logWorktreeCleanupPreserve(
+        sessionId,
+        `checkout removal failed: ${errorText}`
+      );
+    } else {
+      logWarning(
+        `worktree cleanup removal failed, checkout may be partially deleted action=delete session=${safeLogValue(
+          sessionId
+        )} reason=${safeLogValue(errorText)}`
+      );
+    }
+    return;
+  }
+  if (result.branchPreserved) {
+    logWarning(
+      `worktree cleanup removed checkout but kept branch action=delete session=${safeLogValue(
+        sessionId
+      )} slug=${safeLogValue(sidecar.slug)} branch=${safeLogValue(
+        sidecar.worktreeBranch
+      )} reason=unmerged commits`
+    );
+  }
+}
+__name(executeWorktreeCleanup, "executeWorktreeCleanup");
+
 // packages/cli/src/serve/server/session-archive.ts
 var DaemonDrainingError = class extends Error {
   static {
@@ -1755,6 +2052,7 @@ async function deleteDaemonSessions(params) {
     coordinator,
     coordinatorLockHeld = false,
     assertCanMutate,
+    runtimeWorkspaceCwd,
     onError
   } = params;
   const uniqueSessionIds = [
@@ -1765,6 +2063,49 @@ async function deleteDaemonSessions(params) {
       coordinator.assertNotTransitioning(sessionId);
     }
   }
+  const runWithWorktreeCleanup = /* @__PURE__ */ __name(async (sessionId, mutateSession) => {
+    const activeSidecarPath = service.getWorktreeSessionPath(sessionId);
+    const archivedSidecarPath = service.getWorktreeSessionPathForArchiveState(
+      sessionId,
+      "archived"
+    );
+    if (!fs2.existsSync(activeSidecarPath) && (archivedSidecarPath === activeSidecarPath || !fs2.existsSync(archivedSidecarPath))) {
+      return coordinator.runExclusiveMany([sessionId], mutateSession);
+    }
+    const cleanupPlan = await preclassifyWorktreeCleanup(
+      service,
+      sessionId,
+      runtimeWorkspaceCwd
+    );
+    if (!cleanupPlan) {
+      return coordinator.runExclusiveMany([sessionId], mutateSession);
+    }
+    const releaseCleanupLock = await acquireWorktreeCleanupLock(cleanupPlan);
+    try {
+      const ownership = await verifyWorktreeCleanupOwnership(cleanupPlan);
+      if (!ownership.ok) {
+        logWorktreeCleanupPreserve(sessionId, ownership.reason);
+      }
+      const result = await coordinator.runExclusiveMany(
+        [sessionId],
+        mutateSession
+      );
+      if (ownership.ok && result.kind === "removed") {
+        try {
+          assertCanMutate?.();
+          await executeWorktreeCleanup(cleanupPlan);
+        } catch (error) {
+          logWorktreeCleanupPreserve(
+            sessionId,
+            `cleanup execution failed: ${errorMessage(error)}`
+          );
+        }
+      }
+      return result;
+    } finally {
+      releaseCleanupLock();
+    }
+  }, "runWithWorktreeCleanup");
   const results = await Promise.all(
     uniqueSessionIds.map(async (sessionId) => {
       try {
@@ -1810,7 +2151,7 @@ async function deleteDaemonSessions(params) {
           try {
             await bridge.closeSession(sessionId);
           } catch (error) {
-            if (isSessionNotFoundError(error)) {
+            if (isSessionNotFoundError(error) && error.code !== "session_closing") {
               return await removePersistedSession();
             }
             onError?.({
@@ -1826,7 +2167,7 @@ async function deleteDaemonSessions(params) {
           }
           return await removePersistedSession();
         }, "mutateSession");
-        return await (coordinatorLockHeld ? mutateSession() : coordinator.runExclusiveMany([sessionId], mutateSession));
+        return await (coordinatorLockHeld ? mutateSession() : runWithWorktreeCleanup(sessionId, mutateSession));
       } catch (error) {
         if (error instanceof DaemonDrainingError) {
           throw error;
@@ -2361,12 +2702,12 @@ __name(unarchiveDaemonSessions, "unarchiveDaemonSessions");
 
 // packages/cli/src/serve/server/aone-mrs.ts
 init_esbuild_shims();
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
 var a1AvailabilityVerified = false;
 var defaultA1Exec = /* @__PURE__ */ __name(async (args, options) => {
-  const { stdout } = await execFileAsync("a1", [...args], {
+  const { stdout } = await execFileAsync2("a1", [...args], {
     ...options,
     encoding: "utf8",
     windowsHide: true
@@ -2409,7 +2750,7 @@ async function resolveAoneWorkspaceRepo(workspaceCwd, env) {
   if (!gitRoot) return void 0;
   let origin;
   try {
-    ({ stdout: origin } = await execFileAsync(
+    ({ stdout: origin } = await execFileAsync2(
       "git",
       ["remote", "get-url", "origin"],
       {
@@ -2578,6 +2919,7 @@ export {
   parseSessionPageSizeQuery,
   runWithWorkspaceRuntimeStorage,
   createWorkspaceRuntimeSessionService,
+  acquireWorktreeOwnershipOp,
   DaemonDrainingError,
   SessionArchiveCoordinator,
   deleteDaemonSessions,

package/chunks/{chunk-NXWYCSPL.js → chunk-SOA4HKRJ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   isPrivateHost
-} from "./chunk-UKADFFL2.js";
+} from "./chunk-OFVAS4AR.js";
 import {
   loadUndici
 } from "./chunk-4HOEU2OR.js";

package/chunks/{chunk-ZNI3V2XA.js → chunk-TK4XHPKW.js}

@@ -2,14 +2,14 @@
 "use strict";
 import {
   SCHEDULED_TASK_RUN_SOURCE_ID_PREFIX
-} from "./chunk-ZT3XUGSU.js";
+} from "./chunk-63ACHB2H.js";
 import {
   ChannelDeliveryError,
   MAX_CHANNEL_DELIVERY_TEXT_LENGTH
 } from "./chunk-RKFGE7JH.js";
 import {
   stripTerminalControlSequences
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
 import {
   MAX_CHANNEL_DELIVERY_NAME_LENGTH,
   MAX_CHANNEL_DELIVERY_TARGET_ID_LENGTH