@qwen-code/qwen-code 0.20.0 → 0.20.1-nightly.20260724.7d17c44a3

package/chunks/{chunk-FQD7GFSV.js → chunk-HJJDKFL5.js}

@@ -2,16 +2,16 @@
 "use strict";
 import {
   useKeypress
-} from "./chunk-O3Z73NBP.js";
+} from "./chunk-RW2NEXYJ.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   t
-} from "./chunk-TKLLK6XQ.js";
+} from "./chunk-ZT4POVWC.js";
 import {
   APPROVAL_MODES
-} from "./chunk-CPCVCKKF.js";
+} from "./chunk-XAWJ2526.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-4N3KMAIL.js → chunk-HPWHDJID.js}

@@ -3,16 +3,16 @@
 import {
   settleChatRecording,
   subscribeToHeadlessChatRecordingFailures
-} from "./chunk-O3OCNYY5.js";
+} from "./chunk-PDYB7HG2.js";
+import {
+  handleAtCommand
+} from "./chunk-F5MBYZSU.js";
 import {
   JsonOutputAdapter
-} from "./chunk-6AFUCL3D.js";
+} from "./chunk-CEZB3XFD.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-4EP2PYYL.js";
-import {
-  handleAtCommand
-} from "./chunk-IVPSS6EL.js";
+} from "./chunk-2G6QIHYL.js";
 import {
   buildInitialSystemReminders,
   buildSystemMessage,
@@ -24,10 +24,11 @@ import {
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-PBWEWI4N.js";
+} from "./chunk-BW5Z5NOG.js";
 import {
-  RunBudgetEnforcer
-} from "./chunk-4XNLIGVA.js";
+  RunBudgetEnforcer,
+  cleanupReviewWorktreeLeases
+} from "./chunk-JKCALGYN.js";
 import {
   AlreadyReportedError,
   handleBudgetExceededError,
@@ -35,39 +36,51 @@ import {
   handleError,
   handleMaxTurnsExceededError,
   handleToolError
-} from "./chunk-VEXFOTEO.js";
+} from "./chunk-JYUSL2V4.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-NGFEPAE6.js";
+} from "./chunk-WLEFWSSC.js";
 import {
+  PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE,
   buildSessionRecoveryPlanFromApiHistory,
   canonicalToolName,
   createDuplicateProviderToolCallResponse,
   detectAutonomousSentinel,
   detectLoopSentinel,
   executeToolCall,
+  finalizeToolResponses,
+  findPlanModeEntryBatchBoundaryIndex,
   findRepeatedDuplicateProviderToolCall,
-  isSystemReminderContent,
   isToolCallConcurrencySafe,
   markDuplicateProviderToolCallResponseSent,
   parseAndFormatApiError,
-  parsePositiveIntegerEnv,
   partitionByConcurrencySafety,
   promptIdContext,
   restoreWorktreeContext
-} from "./chunk-KX6UK4VJ.js";
+} from "./chunk-LI4I37W4.js";
+import {
+  parsePositiveIntegerEnv
+} from "./chunk-6PVPNMXU.js";
+import {
+  isSystemReminderContent
+} from "./chunk-XAWJ2526.js";
 import {
-  isTelemetrySdkInitialized,
-  shutdownTelemetry,
   uiTelemetryService
-} from "./chunk-ZFKNWQGQ.js";
+} from "./chunk-IFG6TYJ2.js";
+import {
+  isTelemetrySdkInitialized,
+  shutdownTelemetry
+} from "./chunk-PKL3HGNZ.js";
 import {
   ToolNames
-} from "./chunk-OP4MOGXF.js";
+} from "./chunk-P5RRUHL7.js";
 import {
   FatalInputError,
   createDebugLogger
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
+import {
+  registerCleanup
+} from "./chunk-EL2IQ2S5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -78,6 +91,7 @@ import {
 // packages/cli/src/nonInteractiveCli.ts
 init_esbuild_shims();
 var debugLogger = createDebugLogger("NON_INTERACTIVE_CLI");
+var restoredBackgroundAgentSessions = /* @__PURE__ */ new WeakMap();
 var STRUCTURED_SHUTDOWN_HOLDBACK_MS = 500;
 function isHeadlessLoopSentinel(prompt) {
   return detectLoopSentinel(prompt) !== null || detectAutonomousSentinel(prompt) !== null;
@@ -201,6 +215,15 @@ async function runNonInteractive(config, settings, input, prompt_id, options = {
     }, "emitResult");
     const sessionId = config.getSessionId();
     const permissionMode = config.getApprovalMode();
+    const cleanupReviewWorktrees = /* @__PURE__ */ __name((gitTimeout) => cleanupReviewWorktreeLeases({
+      sessionId,
+      promptId: prompt_id,
+      repositoryRoot: config.getProjectRoot(),
+      gitTimeout
+    }), "cleanupReviewWorktrees");
+    const unregisterReviewWorktreeCleanup = registerCleanup(
+      () => cleanupReviewWorktrees(1e3)
+    );
     let turnCount = 0;
     let totalApiDurationMs = 0;
     const startTime = Date.now();
@@ -226,6 +249,9 @@ async function runNonInteractive(config, settings, input, prompt_id, options = {
     }, "routeAbort");
     const localQueue = [];
     const sdkOnlyMonitorQueue = [];
+    const isCancelledMonitorEvent = /* @__PURE__ */ __name((item) => Boolean(
+      item.monitorId && item.sdkNotification?.status === "running" && config.getMonitorRegistry().get(item.monitorId)?.status === "cancelled"
+    ), "isCancelledMonitorEvent");
     const emitNotificationToSdk = /* @__PURE__ */ __name((item) => {
       if (item.sendMessageType !== "notification" /* Notification */) return;
       adapter.emitUserMessage([{ text: item.displayText }]);
@@ -235,7 +261,10 @@ async function runNonInteractive(config, settings, input, prompt_id, options = {
     }, "emitNotificationToSdk");
     const flushQueuedNotificationsToSdk = /* @__PURE__ */ __name((queue) => {
       while (queue.length > 0) {
-        emitNotificationToSdk(queue.shift());
+        const item = queue.shift();
+        if (!isCancelledMonitorEvent(item)) {
+          emitNotificationToSdk(item);
+        }
       }
     }, "flushQueuedNotificationsToSdk");
     let captureMonitorTurnsInLocalQueue = true;
@@ -290,7 +319,9 @@ async function runNonInteractive(config, settings, input, prompt_id, options = {
         } else {
           approvalListener = /* @__PURE__ */ __name((event) => {
             const mode = config.getApprovalMode();
-            if (mode === "yolo" /* YOLO */) {
+            const confirmationDetails = event.confirmationDetails;
+            const requiresExplicitHostApproval = confirmationDetails?.type !== "plan" && confirmationDetails !== void 0 && "hideAlwaysAllow" in confirmationDetails && confirmationDetails.hideAlwaysAllow === true;
+            if (mode === "yolo" /* YOLO */ && !requiresExplicitHostApproval) {
               event.respond("proceed_once" /* ProceedOnce */).catch((err) => {
                 debugLogger.warn(
                   "Teammate approval ProceedOnce failed:",
@@ -299,7 +330,7 @@ async function runNonInteractive(config, settings, input, prompt_id, options = {
               });
               return;
             }
-            const reason = `Auto-cancelling tool ${event.toolName} requested by teammate "${event.teammateName}": current approval mode (${mode}) cannot prompt in non-stream-json mode. Use --yolo or stream-json to allow teammate tool calls.`;
+            const reason = requiresExplicitHostApproval ? mode === "yolo" /* YOLO */ ? `Auto-cancelling tool ${event.toolName} requested by teammate "${event.teammateName}": this request requires an explicit interactive approval surface and cannot be bypassed by YOLO mode.` : `Auto-cancelling tool ${event.toolName} requested by teammate "${event.teammateName}": this request requires an explicit interactive approval surface, which is unavailable in non-stream-json mode with the current approval mode (${mode}). Use --input-format stream-json --output-format stream-json to review it.` : `Auto-cancelling tool ${event.toolName} requested by teammate "${event.teammateName}": current approval mode (${mode}) cannot prompt in non-stream-json mode. Use --yolo or stream-json to allow teammate tool calls.`;
             process.stderr.write(`[team] ${reason}
 `);
             pendingTeammateMessages.push(
@@ -331,6 +362,15 @@ ${reason}
         permissionMode
       );
       adapter.emitMessage(systemMessage);
+      const resumedSessionData = config.getResumedSessionData();
+      if (resumedSessionData) {
+        const restoredSessions = restoredBackgroundAgentSessions.get(config) ?? /* @__PURE__ */ new Set();
+        if (!restoredSessions.has(sessionId)) {
+          await config.loadPausedBackgroundAgents(sessionId);
+          restoredSessions.add(sessionId);
+          restoredBackgroundAgentSessions.set(config, restoredSessions);
+        }
+      }
       let initialPartList = extractPartsFromUserMessage(
         options.userMessage
       );
@@ -475,7 +515,7 @@ ${text}
         adapter.emitSystemMessage("worktree_started", {
           notice: startupNotice
         });
-      } else if (!options.continueInterrupted && config.getResumedSessionData()) {
+      } else if (!options.continueInterrupted && resumedSessionData) {
         try {
           const sessionPath = config.getSessionService().getWorktreeSessionPath(sessionId);
           const restored = await restoreWorktreeContext(sessionPath);
@@ -494,6 +534,10 @@ ${text}
           debugLogger.warn(`worktree restore failed (non-fatal):`, error);
         }
       }
+      const recoveredAgentsNotice = resumedSessionData && !options.continueInterrupted && !isSlashCommand(input) ? config.consumePendingRecoveredAgentsNotice() : null;
+      if (recoveredAgentsNotice) {
+        initialPartList = withReminder(initialPartList, recoveredAgentsNotice);
+      }
       const initialParts = normalizePartList(initialPartList);
       let currentMessages = [{ role: "user", parts: initialParts }];
       const registry = config.getBackgroundTaskRegistry();
@@ -534,6 +578,7 @@ ${text}
               displayText,
               modelText,
               sendMessageType: "notification" /* Notification */,
+              monitorId: meta.monitorId,
               sdkNotification: {
                 task_id: meta.monitorId,
                 tool_use_id: meta.toolUseId,
@@ -619,7 +664,8 @@ ${text}
       const handledProviderToolCallIds = geminiClient.getHistoryFunctionResponseIds();
       const duplicateProviderToolCallResponseIds = /* @__PURE__ */ new Set();
       const processToolCallBatch = /* @__PURE__ */ __name(async (batchRequests, setModelOverride) => {
-        const toolResponseParts = [];
+        const responseByRequest = /* @__PURE__ */ new Map();
+        const statusByResponse = /* @__PURE__ */ new Map();
         const structuredOutputActive = config.getJsonSchema() && batchRequests.some((r) => r.name === ToolNames.STRUCTURED_OUTPUT);
         const getProviderResponseId = /* @__PURE__ */ __name((request) => request.providerCallId ?? (structuredOutputActive ? void 0 : request.callId || void 0), "getProviderResponseId");
         const seenBatchCallIds = /* @__PURE__ */ new Set();
@@ -658,7 +704,6 @@ ${text}
         }
         const respondedRequests = /* @__PURE__ */ new Set();
         const executableBatchRequests = [];
-        const duplicatePendingResponses = [];
         for (const requestInfo of uniqueBatchRequests) {
           const providerCallId = getProviderResponseId(requestInfo);
           if (!providerCallId) {
@@ -680,15 +725,18 @@ ${text}
           );
           respondedRequests.add(requestInfo);
           adapter.emitToolResult(requestInfo, toolResponse);
-          duplicatePendingResponses.push(...toolResponse.responseParts);
+          responseByRequest.set(requestInfo, toolResponse);
         }
-        toolResponseParts.push(...duplicatePendingResponses);
         let requestsToExecute = executableBatchRequests;
         if (structuredOutputActive) {
           requestsToExecute = executableBatchRequests.filter(
             (r) => r.name === ToolNames.STRUCTURED_OUTPUT
           );
         }
+        const planModeEntryBoundaryIndex = findPlanModeEntryBatchBoundaryIndex(
+          requestsToExecute.map((request) => request.name)
+        );
+        const planModeEntryBoundary = planModeEntryBoundaryIndex === void 0 ? void 0 : requestsToExecute[planModeEntryBoundaryIndex];
         const executedRequests = new Set(
           respondedRequests
         );
@@ -714,7 +762,13 @@ ${text}
             requestInfo,
             abortController.signal,
             {
+              recordToolResult: false,
               outputUpdateHandler,
+              onAllToolCallsComplete: /* @__PURE__ */ __name(async (completedCalls) => {
+                for (const call of completedCalls) {
+                  statusByResponse.set(call.response, call.status);
+                }
+              }, "onAllToolCallsComplete"),
               ...toolCallUpdateCallback && {
                 onToolCallsUpdate: toolCallUpdateCallback
               }
@@ -736,13 +790,11 @@ ${text}
             );
           }
           adapter.emitToolResult(requestInfo, toolResponse);
+          responseByRequest.set(requestInfo, toolResponse);
           config.getGeminiClient().recordCompletedToolCall(
             requestInfo.name,
             requestInfo.args
           );
-          if (toolResponse.responseParts) {
-            toolResponseParts.push(...toolResponse.responseParts);
-          }
           if ("modelOverride" in toolResponse) {
             setModelOverride(toolResponse.modelOverride);
           }
@@ -752,6 +804,33 @@ ${text}
           }
           return false;
         }, "finalizeToolCall");
+        const finalizePlanModeEntrySiblingSkip = /* @__PURE__ */ __name((requestInfo) => {
+          const error = new Error(PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE);
+          const responseParts = [
+            {
+              functionResponse: {
+                id: requestInfo.callId,
+                name: requestInfo.name,
+                response: { error: error.message }
+              }
+            }
+          ];
+          adapter.emitToolResult(requestInfo, {
+            callId: requestInfo.callId,
+            responseParts,
+            resultDisplay: error.message,
+            error,
+            errorType: "execution_denied" /* EXECUTION_DENIED */
+          });
+          responseByRequest.set(requestInfo, {
+            callId: requestInfo.callId,
+            responseParts,
+            resultDisplay: error.message,
+            error,
+            errorType: "execution_denied" /* EXECUTION_DENIED */
+          });
+          executedRequests.add(requestInfo);
+        }, "finalizePlanModeEntrySiblingSkip");
         const maxToolConcurrency = parsePositiveIntegerEnv(
           process.env["QWEN_CODE_MAX_TOOL_CONCURRENCY"],
           10
@@ -763,6 +842,10 @@ ${text}
             const launched = [];
             const inFlight = /* @__PURE__ */ new Set();
             for (const requestInfo of batch.calls) {
+              if (planModeEntryBoundary && requestInfo !== planModeEntryBoundary) {
+                finalizePlanModeEntrySiblingSkip(requestInfo);
+                continue;
+              }
               if (!isBudgetExempt(requestInfo)) {
                 budgetEnforcer.tickToolCall();
               }
@@ -801,6 +884,10 @@ ${text}
             }
           } else {
             for (const requestInfo of batch.calls) {
+              if (planModeEntryBoundary && requestInfo !== planModeEntryBoundary) {
+                finalizePlanModeEntrySiblingSkip(requestInfo);
+                continue;
+              }
               if (!isBudgetExempt(requestInfo)) {
                 budgetEnforcer.tickToolCall();
               }
@@ -831,14 +918,15 @@ ${text}
                 }
               }
             ];
-            adapter.emitToolResult(call, {
+            const toolResponse = {
               callId: call.callId,
               responseParts,
               resultDisplay: skippedOutput,
               error: void 0,
               errorType: void 0
-            });
-            toolResponseParts.push(...responseParts);
+            };
+            adapter.emitToolResult(call, toolResponse);
+            responseByRequest.set(call, toolResponse);
           }
         }
         for (const requestInfo of duplicateBatchRequests) {
@@ -850,7 +938,34 @@ ${text}
           );
           const toolResponse = createDuplicateProviderToolCallResponse(requestInfo);
           adapter.emitToolResult(requestInfo, toolResponse);
-          toolResponseParts.push(...toolResponse.responseParts);
+          responseByRequest.set(requestInfo, toolResponse);
+        }
+        const orderedResponses = batchRequests.flatMap((request) => {
+          const response = responseByRequest.get(request);
+          return response ? [{ request, response }] : [];
+        });
+        const finalized = await finalizeToolResponses(
+          config,
+          orderedResponses.map(({ request, response }) => ({
+            callId: request.callId,
+            toolName: request.name,
+            responseParts: response.responseParts,
+            persistedOutputFiles: response.persistedOutputFiles
+          }))
+        );
+        const chatRecordingService = config.getChatRecordingService?.();
+        const toolResponseParts = [];
+        for (let index = 0; index < orderedResponses.length; index++) {
+          const { request, response } = orderedResponses[index];
+          const finalizedParts = finalized[index].responseParts;
+          toolResponseParts.push(...finalizedParts);
+          chatRecordingService?.recordToolResult?.(finalizedParts, {
+            callId: request.callId,
+            status: statusByResponse.get(response) ?? (response.error ? "error" : "success"),
+            resultDisplay: response.resultDisplay,
+            error: response.error,
+            errorType: response.errorType
+          });
         }
         return {
           responseParts: toolResponseParts,
@@ -1015,7 +1130,7 @@ ${text}
                 splitIdx++;
               }
             }
-            const batch = localQueue.splice(0, splitIdx);
+            const batch = localQueue.splice(0, splitIdx).filter((item2) => !isCancelledMonitorEvent(item2));
             if (batch.length === 0) return;
             for (const queueItem of batch) {
               emitNotificationToSdk(queueItem);
@@ -1281,6 +1396,8 @@ ${text}
       }
       await handleError(error, config);
     } finally {
+      cleanupReviewWorktrees();
+      unregisterReviewWorktreeCleanup();
       config.onTeamManagerChange(null, onTeamManagerChangeHandler);
       if (boundManager) {
         detachFromManager(boundManager);

package/chunks/{chunk-KQNM4EO7.js → chunk-HQCSRJ3P.js}

@@ -3,7 +3,7 @@
 import {
   MAX_WORKSPACE_PATH_LENGTH,
   canonicalizeWorkspace
-} from "./chunk-W7FJ3N32.js";
+} from "./chunk-2RFKHEXL.js";
 import {
   MAX_DAEMON_WORKSPACES
 } from "./chunk-5HBA2Z7V.js";
@@ -15,7 +15,7 @@ import {
 } from "./chunk-MR3PXB6E.js";
 import {
   require_proper_lockfile
-} from "./chunk-E2UVIFI2.js";
+} from "./chunk-KRXPRVGL.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -124,6 +124,7 @@ __name(resolveWorkspaceInputs, "resolveWorkspaceInputs");
 var SCHEMA_VERSION = 1;
 var MAX_SECONDARY_WORKSPACES = MAX_REGISTERED_WORKSPACES - 1;
 var MAX_STORE_BYTES = 256 * 1024;
+var MAX_WORKSPACE_DISPLAY_NAME_LENGTH = 256;
 var LOCK_OPTIONS = {
   realpath: false,
   stale: 1e4,
@@ -136,6 +137,43 @@ var LOCK_OPTIONS = {
     randomize: true
   }
 };
+var WorkspaceDisplayNameValidationError = class extends Error {
+  static {
+    __name(this, "WorkspaceDisplayNameValidationError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "WorkspaceDisplayNameValidationError";
+  }
+};
+function containsDisplayNameControlCharacter(value) {
+  for (const character of value) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint <= 31 || codePoint === 127) return true;
+  }
+  return false;
+}
+__name(containsDisplayNameControlCharacter, "containsDisplayNameControlCharacter");
+function normalizeWorkspaceDisplayName(value) {
+  if (typeof value !== "string") {
+    throw new WorkspaceDisplayNameValidationError(
+      "Workspace display name must be a string"
+    );
+  }
+  const trimmed = value.trim();
+  if (trimmed.length > MAX_WORKSPACE_DISPLAY_NAME_LENGTH) {
+    throw new WorkspaceDisplayNameValidationError(
+      `Workspace display name exceeds ${MAX_WORKSPACE_DISPLAY_NAME_LENGTH} characters`
+    );
+  }
+  if (containsDisplayNameControlCharacter(trimmed)) {
+    throw new WorkspaceDisplayNameValidationError(
+      "Workspace display name contains control characters"
+    );
+  }
+  return trimmed.length === 0 ? void 0 : trimmed;
+}
+__name(normalizeWorkspaceDisplayName, "normalizeWorkspaceDisplayName");
 var WorkspaceRegistrationStoreError = class extends Error {
   static {
     __name(this, "WorkspaceRegistrationStoreError");
@@ -196,6 +234,38 @@ function validateWorkspacePath(value, label) {
   return value;
 }
 __name(validateWorkspacePath, "validateWorkspacePath");
+function validateStoredDisplayName(value, label) {
+  let displayName;
+  try {
+    displayName = normalizeWorkspaceDisplayName(value);
+  } catch (err) {
+    throw new WorkspaceRegistrationStoreError(
+      `${label} is invalid: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (displayName === void 0) {
+    throw new WorkspaceRegistrationStoreError(`${label} must not be empty`);
+  }
+  return displayName;
+}
+__name(validateStoredDisplayName, "validateStoredDisplayName");
+function setSnapshotDisplayName(snapshot, registrationId, displayName) {
+  if (displayName === void 0) {
+    if (!snapshot.displayNames || !Object.hasOwn(snapshot.displayNames, registrationId)) {
+      return false;
+    }
+    delete snapshot.displayNames[registrationId];
+    if (Object.keys(snapshot.displayNames).length === 0) {
+      delete snapshot.displayNames;
+    }
+    return true;
+  }
+  if (snapshot.displayNames?.[registrationId] === displayName) return false;
+  snapshot.displayNames ??= {};
+  snapshot.displayNames[registrationId] = displayName;
+  return true;
+}
+__name(setSnapshotDisplayName, "setSnapshotDisplayName");
 function parseSnapshot(raw, primaryWorkspace) {
   let value;
   try {
@@ -252,7 +322,34 @@ function parseSnapshot(raw, primaryWorkspace) {
     seen.add(normalizedWorkspace);
     return workspace;
   });
-  return { schemaVersion: SCHEMA_VERSION, primaryWorkspace, workspaces };
+  const rawDisplayNames = record["displayNames"];
+  let displayNames;
+  if (rawDisplayNames !== void 0) {
+    if (typeof rawDisplayNames !== "object" || rawDisplayNames === null || Array.isArray(rawDisplayNames)) {
+      throw new WorkspaceRegistrationStoreError(
+        "Workspace registration store displayNames must be an object"
+      );
+    }
+    const registrationIds = new Set(workspaces.map(workspaceRegistrationId));
+    for (const [registrationId, value2] of Object.entries(rawDisplayNames)) {
+      if (!registrationIds.has(registrationId)) {
+        throw new WorkspaceRegistrationStoreError(
+          `Workspace registration store displayNames contains unknown registration id ${JSON.stringify(registrationId)}`
+        );
+      }
+      displayNames ??= {};
+      displayNames[registrationId] = validateStoredDisplayName(
+        value2,
+        `displayNames[${JSON.stringify(registrationId)}]`
+      );
+    }
+  }
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    primaryWorkspace,
+    workspaces,
+    ...displayNames ? { displayNames } : {}
+  };
 }
 __name(parseSnapshot, "parseSnapshot");
 var updateChains = /* @__PURE__ */ new Map();
@@ -391,8 +488,9 @@ var WorkspaceRegistrationStore = class {
       await file.close();
     }
   }
-  async add(workspace) {
+  async add(workspace, displayName) {
     validateWorkspacePath(workspace, "workspace");
+    const normalizedDisplayName = displayName === void 0 ? void 0 : normalizeWorkspaceDisplayName(displayName);
     if (normalizedScopePath(workspace) === normalizedScopePath(this.primaryWorkspace)) {
       throw new WorkspaceRegistrationStoreError(
         "Primary workspace cannot be stored as a secondary registration"
@@ -411,30 +509,61 @@ var WorkspaceRegistrationStore = class {
         );
       }
       snapshot.workspaces.push(workspace);
+      if (normalizedDisplayName !== void 0) {
+        snapshot.displayNames ??= {};
+        snapshot.displayNames[workspaceRegistrationId(workspace)] = normalizedDisplayName;
+      }
       return true;
     });
   }
   async removeById(id) {
     return await this.removeByIds([id]) > 0;
   }
+  async setDisplayNameByIds(ids, displayName) {
+    const normalizedDisplayName = displayName === void 0 ? void 0 : normalizeWorkspaceDisplayName(displayName);
+    const requested = new Set(ids);
+    if (requested.size === 0) return 0;
+    let matched = 0;
+    await this.update((snapshot) => {
+      let changed = false;
+      for (const workspace of snapshot.workspaces) {
+        const registrationId = workspaceRegistrationId(workspace);
+        if (!requested.has(registrationId)) continue;
+        matched++;
+        changed = setSnapshotDisplayName(
+          snapshot,
+          registrationId,
+          normalizedDisplayName
+        ) || changed;
+      }
+      return changed;
+    });
+    return matched;
+  }
   async removeByIds(ids) {
     const requested = new Set(ids);
     if (requested.size === 0) return 0;
     let removed = 0;
     await this.update((snapshot) => {
+      const removedIds = /* @__PURE__ */ new Set();
       const retained = snapshot.workspaces.filter((workspace) => {
-        if (!requested.has(workspaceRegistrationId(workspace))) return true;
+        const registrationId = workspaceRegistrationId(workspace);
+        if (!requested.has(registrationId)) return true;
         removed++;
+        removedIds.add(registrationId);
         return false;
       });
       if (removed === 0) return false;
       snapshot.workspaces.splice(0, snapshot.workspaces.length, ...retained);
+      for (const registrationId of removedIds) {
+        setSnapshotDisplayName(snapshot, registrationId, void 0);
+      }
       return true;
     });
     return removed;
   }
   async update(mutate) {
-    const { atomicWriteFile } = await import("./src-43LM7JLB.js");
+    const { atomicWriteFile } = await import("./src-LKKTJ4NG.js");
     return withInProcessLock(this.filePath, async () => {
       const lock = await acquireFileLock(this.filePath);
       let committed = false;
@@ -478,6 +607,9 @@ var WorkspaceRegistrationStore = class {
 export {
   MAX_REGISTERED_WORKSPACES,
   resolveWorkspaceInputs,
+  MAX_WORKSPACE_DISPLAY_NAME_LENGTH,
+  WorkspaceDisplayNameValidationError,
+  normalizeWorkspaceDisplayName,
   WorkspaceRegistrationStoreError,
   WorkspaceRegistrationStoreLimitError,
   WorkspaceRegistrationStoreCommittedError,