@qwen-code/qwen-code 0.20.0-preview.0 → 0.20.0

package/chunks/workspace-skills-status-YVICUR5Y.js

@@ -0,0 +1,71 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  createWorkspaceSkillsStatusProvider
+} from "./chunk-4ILMYHEI.js";
+import "./chunk-2W3OOD4W.js";
+import "./chunk-VDWBQ5AW.js";
+import "./chunk-33XUAINQ.js";
+import "./chunk-RKUWKYED.js";
+import "./chunk-GOXKNSDZ.js";
+import "./chunk-IDS7MSUP.js";
+import "./chunk-TKLLK6XQ.js";
+import "./chunk-TIH2ZTOC.js";
+import "./chunk-QRUIS3DN.js";
+import "./chunk-I2PYAYFM.js";
+import "./chunk-ALGGS7UH.js";
+import "./chunk-MR3PXB6E.js";
+import "./chunk-OWAK7LMW.js";
+import "./chunk-KX6UK4VJ.js";
+import "./chunk-5M6IDOMF.js";
+import "./chunk-T4TZQJ7W.js";
+import "./chunk-H6XPXXMH.js";
+import "./chunk-EAUYY7SS.js";
+import "./chunk-FSL5W5TI.js";
+import "./chunk-OONJNQ42.js";
+import "./chunk-D2VIDMVM.js";
+import "./chunk-E2UVIFI2.js";
+import "./chunk-XU457J4V.js";
+import "./chunk-VDDGDZMA.js";
+import "./chunk-EIAK6Q2B.js";
+import "./chunk-SZRN75WQ.js";
+import "./chunk-HTO4JFDZ.js";
+import "./chunk-CPBF7KYF.js";
+import "./chunk-CPCVCKKF.js";
+import "./chunk-6AM5D4ME.js";
+import "./chunk-G45X5TRN.js";
+import "./chunk-PBATSWUQ.js";
+import "./chunk-ZEOZL37W.js";
+import "./chunk-OOCI5VVU.js";
+import "./chunk-BRRF37CO.js";
+import "./chunk-BMWMT5Y2.js";
+import "./chunk-JESCGQM3.js";
+import "./chunk-ZFKNWQGQ.js";
+import "./chunk-4WKAA4KS.js";
+import "./chunk-CR3C7WXL.js";
+import "./chunk-VGC4I5JJ.js";
+import "./chunk-JD3MKVKL.js";
+import "./chunk-UEY4AYUL.js";
+import "./chunk-BDBMYST4.js";
+import "./chunk-EZVDJFZ7.js";
+import "./chunk-OP4MOGXF.js";
+import "./chunk-XVNQMZ2I.js";
+import "./chunk-FEOZBUMT.js";
+import "./chunk-DJ2GSRLV.js";
+import "./chunk-6EFTQYW7.js";
+import "./chunk-MAQQGNQ5.js";
+import "./chunk-A4UCTEB5.js";
+import "./chunk-XWRJCPHC.js";
+import "./chunk-TYQMGACW.js";
+import "./chunk-TYAMGABM.js";
+import "./chunk-FCMNKVXT.js";
+import "./chunk-C27BYUX6.js";
+import "./chunk-75DOP5OR.js";
+import "./chunk-DMTGGOSA.js";
+import "./chunk-YQ3U5MUC.js";
+import "./chunk-TB6UDU4T.js";
+import "./chunk-5O2XNYP6.js";
+import "./chunk-J2S4EL5Y.js";
+export {
+  createWorkspaceSkillsStatusProvider
+};

package/chunks/write-file-CVGF2OKV.js

@@ -0,0 +1,596 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  checkTeamMemorySecrets
+} from "./chunk-SEKHYHMS.js";
+import {
+  CommitAttributionService,
+  FileEncoding,
+  StructuredToolError,
+  checkPriorRead,
+  createPatchSmart,
+  detectLineEnding,
+  getDiffStat,
+  needsUtf8Bom
+} from "./chunk-KX6UK4VJ.js";
+import "./chunk-5M6IDOMF.js";
+import "./chunk-T4TZQJ7W.js";
+import "./chunk-H6XPXXMH.js";
+import "./chunk-EAUYY7SS.js";
+import "./chunk-FSL5W5TI.js";
+import "./chunk-OONJNQ42.js";
+import "./chunk-D2VIDMVM.js";
+import "./chunk-E2UVIFI2.js";
+import "./chunk-XU457J4V.js";
+import "./chunk-VDDGDZMA.js";
+import "./chunk-EIAK6Q2B.js";
+import "./chunk-SZRN75WQ.js";
+import "./chunk-HTO4JFDZ.js";
+import "./chunk-CPBF7KYF.js";
+import "./chunk-CPCVCKKF.js";
+import "./chunk-6AM5D4ME.js";
+import "./chunk-G45X5TRN.js";
+import "./chunk-PBATSWUQ.js";
+import "./chunk-ZEOZL37W.js";
+import "./chunk-OOCI5VVU.js";
+import "./chunk-BRRF37CO.js";
+import "./chunk-BMWMT5Y2.js";
+import "./chunk-JESCGQM3.js";
+import {
+  FileOperationEvent,
+  fileExists,
+  getLanguageFromFilePath,
+  getSpecificMimeType,
+  logFileOperation
+} from "./chunk-ZFKNWQGQ.js";
+import "./chunk-4WKAA4KS.js";
+import "./chunk-CR3C7WXL.js";
+import "./chunk-VGC4I5JJ.js";
+import {
+  isAnyAutoMemPath,
+  isTeamAutoMemPath
+} from "./chunk-JD3MKVKL.js";
+import "./chunk-UEY4AYUL.js";
+import "./chunk-BDBMYST4.js";
+import "./chunk-EZVDJFZ7.js";
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolDisplayNames,
+  ToolNames
+} from "./chunk-OP4MOGXF.js";
+import "./chunk-XVNQMZ2I.js";
+import "./chunk-FEOZBUMT.js";
+import "./chunk-DJ2GSRLV.js";
+import "./chunk-6EFTQYW7.js";
+import "./chunk-MAQQGNQ5.js";
+import "./chunk-A4UCTEB5.js";
+import "./chunk-XWRJCPHC.js";
+import "./chunk-TYQMGACW.js";
+import "./chunk-TYAMGABM.js";
+import "./chunk-FCMNKVXT.js";
+import {
+  createDebugLogger,
+  getErrorMessage,
+  isNodeError,
+  makeRelative,
+  shortenPath,
+  unescapePath
+} from "./chunk-C27BYUX6.js";
+import "./chunk-75DOP5OR.js";
+import "./chunk-DMTGGOSA.js";
+import "./chunk-YQ3U5MUC.js";
+import "./chunk-TB6UDU4T.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/tools/write-file.ts
+init_esbuild_shims();
+import fs from "node:fs";
+import path from "node:path";
+var debugLogger = createDebugLogger("WRITE_FILE");
+var ARTIFACT_LIKE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".htm",
+  ".html",
+  ".ipynb",
+  ".jpeg",
+  ".jpg",
+  ".pdf",
+  ".png",
+  ".svg",
+  ".webp"
+]);
+var WriteFileToolInvocation = class extends BaseToolInvocation {
+  constructor(config, params) {
+    super(params);
+    this.config = config;
+  }
+  static {
+    __name(this, "WriteFileToolInvocation");
+  }
+  toolLocations() {
+    return [{ path: this.params.file_path }];
+  }
+  getDescription() {
+    const relativePath = makeRelative(
+      this.params.file_path,
+      this.config.getTargetDir()
+    );
+    return `Writing to ${shortenPath(relativePath)}`;
+  }
+  /**
+   * Write operations always need user confirmation, except for the private
+   * managed auto-memory files (user/project) which are written autonomously.
+   * Team memory is shared and committed to the repo, so it is NOT auto-allowed
+   * like the private tiers — writes default to 'ask'. (In AUTO_EDIT/YOLO the
+   * user has globally opted into auto-approval; team writes still surface in the
+   * git diff for review before commit.)
+   */
+  async getDefaultPermission() {
+    const projectRoot = this.config.getProjectRoot();
+    const filePath = path.resolve(this.params.file_path);
+    if (isTeamAutoMemPath(filePath, projectRoot)) {
+      return "ask";
+    }
+    if (isAnyAutoMemPath(filePath, projectRoot)) {
+      return "allow";
+    }
+    return "ask";
+  }
+  /**
+   * Constructs the write-file diff confirmation details.
+   */
+  async getConfirmationDetails(_abortSignal) {
+    let originalContent = "";
+    let fileExists2 = await fileExists(this.params.file_path);
+    if (!this.config.getFileReadCacheDisabled()) {
+      const decision = await checkPriorRead(
+        this.config.getFileReadCache(),
+        this.params.file_path,
+        "overwriting"
+      );
+      if (!decision.ok) {
+        throw new StructuredToolError(decision.rawMessage, decision.type);
+      }
+    }
+    if (fileExists2) {
+      try {
+        const { content } = await this.config.getFileSystemService().readTextFile({ path: this.params.file_path });
+        originalContent = content;
+      } catch (err) {
+        if (isNodeError(err) && err.code === "ENOENT") {
+          fileExists2 = false;
+        } else {
+          throw new Error(
+            `Error reading existing file for confirmation: ${getErrorMessage(err)}`
+          );
+        }
+      }
+    }
+    if (fileExists2 && !this.config.getFileReadCacheDisabled()) {
+      const postDecision = await checkPriorRead(
+        this.config.getFileReadCache(),
+        this.params.file_path,
+        "overwriting",
+        { expectExisting: true }
+      );
+      if (!postDecision.ok) {
+        debugLogger.warn("post-read TOCTOU rejection (confirmation)", {
+          path: this.params.file_path,
+          reason: postDecision.type
+        });
+        throw new StructuredToolError(
+          postDecision.rawMessage,
+          postDecision.type
+        );
+      }
+    }
+    const relativePath = makeRelative(
+      this.params.file_path,
+      this.config.getTargetDir()
+    );
+    const fileName = path.basename(this.params.file_path);
+    const fileDiff = createPatchSmart(
+      fileName,
+      originalContent,
+      this.params.content,
+      "Current",
+      "Proposed"
+    );
+    const confirmationDetails = {
+      type: "edit",
+      title: `Confirm Write: ${shortenPath(relativePath)}`,
+      fileName,
+      filePath: this.params.file_path,
+      fileDiff,
+      originalContent,
+      newContent: this.params.content,
+      onConfirm: /* @__PURE__ */ __name(async (outcome) => {
+        if (outcome === "proceed_always" /* ProceedAlways */) {
+          this.config.setApprovalMode("auto-edit" /* AUTO_EDIT */);
+        }
+      }, "onConfirm")
+    };
+    return confirmationDetails;
+  }
+  async execute(_abortSignal) {
+    const { file_path, content, ai_proposed_content, modified_by_user } = this.params;
+    let fileExists2 = await fileExists(file_path);
+    let originalContent = "";
+    let useBOM = false;
+    let detectedEncoding;
+    let detectedLineEnding;
+    const dirName = path.dirname(file_path);
+    const teamMemoryError = checkTeamMemorySecrets(
+      file_path,
+      content,
+      this.config.getProjectRoot()
+    );
+    if (teamMemoryError) {
+      return {
+        llmContent: `[ERROR: ${teamMemoryError}]`,
+        returnDisplay: teamMemoryError,
+        error: {
+          message: teamMemoryError,
+          type: "invalid_tool_params" /* INVALID_TOOL_PARAMS */
+        }
+      };
+    }
+    if (!this.config.getFileReadCacheDisabled()) {
+      const decision = await checkPriorRead(
+        this.config.getFileReadCache(),
+        file_path,
+        "overwriting"
+      );
+      if (!decision.ok) {
+        return {
+          llmContent: decision.rawMessage,
+          returnDisplay: `Error: ${decision.displayMessage}`,
+          error: {
+            message: decision.rawMessage,
+            type: decision.type
+          }
+        };
+      }
+    }
+    if (fileExists2) {
+      try {
+        const fileInfo = await this.config.getFileSystemService().readTextFile({ path: file_path });
+        if (fileInfo._meta?.bom !== void 0) {
+          useBOM = fileInfo._meta.bom;
+        } else {
+          useBOM = fileInfo.content.length > 0 && fileInfo.content.codePointAt(0) === 65279;
+        }
+        detectedEncoding = fileInfo._meta?.encoding || "utf-8";
+        detectedLineEnding = detectLineEnding(fileInfo.content);
+        originalContent = fileInfo.content;
+        fileExists2 = true;
+      } catch (err) {
+        if (isNodeError(err) && err.code === "ENOENT") {
+          fileExists2 = false;
+        } else {
+          const error = {
+            message: getErrorMessage(err),
+            code: isNodeError(err) ? err.code : void 0
+          };
+          const errorMsg = error.code ? `Error checking existing file '${file_path}': ${error.message} (${error.code})` : `Error checking existing file: ${error.message}`;
+          return {
+            llmContent: errorMsg,
+            returnDisplay: errorMsg,
+            error: {
+              message: errorMsg,
+              type: "file_write_failure" /* FILE_WRITE_FAILURE */
+            }
+          };
+        }
+      }
+    }
+    if (fileExists2 && !this.config.getFileReadCacheDisabled()) {
+      const postDecision = await checkPriorRead(
+        this.config.getFileReadCache(),
+        file_path,
+        "overwriting",
+        { expectExisting: true }
+      );
+      if (!postDecision.ok) {
+        debugLogger.warn("post-read TOCTOU rejection (execute)", {
+          path: file_path,
+          reason: postDecision.type
+        });
+        return {
+          llmContent: postDecision.rawMessage,
+          returnDisplay: `Error: ${postDecision.displayMessage}`,
+          error: {
+            message: postDecision.rawMessage,
+            type: postDecision.type
+          }
+        };
+      }
+    }
+    if (!fileExists2) {
+      const userEncoding = this.config.getDefaultFileEncoding();
+      if (userEncoding === FileEncoding.UTF8_BOM) {
+        useBOM = true;
+      } else if (userEncoding === void 0) {
+        useBOM = needsUtf8Bom(file_path);
+      }
+      detectedEncoding = void 0;
+    }
+    try {
+      await this.config.getFileHistoryService().trackEdit(file_path);
+    } catch {
+    }
+    if (!this.config.getFileReadCacheDisabled()) {
+      const writeDecision = await checkPriorRead(
+        this.config.getFileReadCache(),
+        file_path,
+        "overwriting",
+        // If the file existed when we read it (`fileExists` is still
+        // true after readTextFile), ENOENT here means the original
+        // target disappeared between the post-read check and now —
+        // reject rather than fall through and silently re-create the
+        // file from stale bytes. For new-file creation
+        // (`fileExists === false`), ENOENT is the expected pre-write
+        // state (ok:true → writeTextFile creates).
+        { expectExisting: fileExists2 }
+      );
+      if (!writeDecision.ok) {
+        debugLogger.warn("pre-write TOCTOU rejection", {
+          path: file_path,
+          reason: writeDecision.type
+        });
+        return {
+          llmContent: writeDecision.rawMessage,
+          returnDisplay: `Error: ${writeDecision.displayMessage}`,
+          error: {
+            message: writeDecision.rawMessage,
+            type: writeDecision.type
+          }
+        };
+      }
+    }
+    if (!fileExists2) {
+      fs.mkdirSync(dirName, { recursive: true });
+    }
+    try {
+      await this.config.getFileSystemService().writeTextFile({
+        path: file_path,
+        content,
+        _meta: {
+          bom: useBOM,
+          encoding: detectedEncoding,
+          lineEnding: detectedLineEnding
+        }
+      });
+      if (!modified_by_user) {
+        CommitAttributionService.getInstance().recordEdit(
+          file_path,
+          fileExists2 ? originalContent : null,
+          content
+        );
+      }
+      try {
+        const postWriteStats = fs.statSync(file_path);
+        this.config.getFileReadCache().recordWrite(file_path, postWriteStats);
+      } catch {
+      }
+      const fileName = path.basename(file_path);
+      const currentContentForDiff = originalContent;
+      const fileDiff = createPatchSmart(
+        fileName,
+        currentContentForDiff,
+        content,
+        "Original",
+        "Written"
+      );
+      const originallyProposedContent = ai_proposed_content || content;
+      const diffStat = getDiffStat(
+        fileName,
+        currentContentForDiff,
+        originallyProposedContent,
+        content
+      );
+      const llmSuccessMessageParts = [
+        !fileExists2 ? `Successfully created and wrote to new file: ${file_path}.` : `Successfully overwrote file: ${file_path}.`
+      ];
+      if (modified_by_user) {
+        llmSuccessMessageParts.push(
+          `User modified the \`content\` to be: ${content}`
+        );
+      }
+      const artifactReminder = buildRecordArtifactReminder(
+        this.config,
+        file_path
+      );
+      if (artifactReminder) {
+        llmSuccessMessageParts.push(artifactReminder);
+      }
+      const mimetype = getSpecificMimeType(file_path);
+      const programmingLanguage = getLanguageFromFilePath(file_path);
+      const extension = path.extname(file_path);
+      const operation = !fileExists2 ? "create" /* CREATE */ : "update" /* UPDATE */;
+      const lineCount = content.split("\n").length;
+      logFileOperation(
+        this.config,
+        new FileOperationEvent(
+          WriteFileTool.Name,
+          operation,
+          lineCount,
+          mimetype,
+          extension,
+          programmingLanguage
+        )
+      );
+      const displayResult = {
+        fileDiff,
+        fileName,
+        originalContent,
+        newContent: content,
+        diffStat
+      };
+      return {
+        llmContent: llmSuccessMessageParts.join(" "),
+        returnDisplay: displayResult
+      };
+    } catch (error) {
+      let errorMsg;
+      let errorType = "file_write_failure" /* FILE_WRITE_FAILURE */;
+      if (isNodeError(error)) {
+        errorMsg = `Error writing to file '${file_path}': ${error.message} (${error.code})`;
+        if (error.code === "EACCES") {
+          errorMsg = `Permission denied writing to file: ${file_path} (${error.code})`;
+          errorType = "permission_denied" /* PERMISSION_DENIED */;
+        } else if (error.code === "ENOSPC") {
+          errorMsg = `No space left on device: ${file_path} (${error.code})`;
+          errorType = "no_space_left" /* NO_SPACE_LEFT */;
+        } else if (error.code === "EISDIR") {
+          errorMsg = `Target is a directory, not a file: ${file_path} (${error.code})`;
+          errorType = "target_is_directory" /* TARGET_IS_DIRECTORY */;
+        }
+        if (this.config.getDebugMode() && error.stack) {
+          debugLogger.debug("Write file error stack:", error.stack);
+        }
+      } else {
+        errorMsg = `Error writing to file: ${getErrorMessage(error)}`;
+      }
+      return {
+        llmContent: errorMsg,
+        returnDisplay: errorMsg,
+        error: {
+          message: errorMsg,
+          type: errorType
+        }
+      };
+    }
+  }
+};
+function buildRecordArtifactReminder(config, filePath) {
+  if (!config.isRecordArtifactEnabled()) {
+    return null;
+  }
+  if (!ARTIFACT_LIKE_EXTENSIONS.has(path.extname(filePath).toLowerCase())) {
+    return null;
+  }
+  const relativePath = path.relative(config.getTargetDir(), filePath);
+  if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath)) {
+    return null;
+  }
+  const workspacePath = relativePath.split(path.sep).join("/");
+  return `If this file is a reusable user-facing artifact, call record_artifact with workspacePath "${workspacePath}" before telling the user it is available in the artifacts panel.`;
+}
+__name(buildRecordArtifactReminder, "buildRecordArtifactReminder");
+var WriteFileTool = class _WriteFileTool extends BaseDeclarativeTool {
+  constructor(config) {
+    super(
+      _WriteFileTool.Name,
+      ToolDisplayNames.WRITE_FILE,
+      `Writes content to a specified file in the local filesystem. The file_path argument MUST be an absolute path. Always construct it by combining the project root with the file's relative path (e.g. project root '/path/to/project/' + relative 'foo/bar.txt' = '/path/to/project/foo/bar.txt'). If the user provides a relative path, resolve it against the project root first.
+
+The user has the ability to modify \`content\`. If modified, this will be stated in the response.`,
+      "edit" /* Edit */,
+      {
+        properties: {
+          file_path: {
+            description: "The absolute path to the file to write to (e.g., '/home/user/project/file.txt'). Relative paths are not supported.",
+            type: "string"
+          },
+          content: {
+            description: "The content to write to the file.",
+            type: "string"
+          }
+        },
+        required: ["file_path", "content"],
+        type: "object"
+      }
+    );
+    this.config = config;
+  }
+  static {
+    __name(this, "WriteFileTool");
+  }
+  static Name = ToolNames.WRITE_FILE;
+  validateToolParamValues(params) {
+    const filePath = unescapePath(params.file_path.trim());
+    params.file_path = filePath;
+    if (!filePath) {
+      return `Missing or empty "file_path"`;
+    }
+    if (!path.isAbsolute(filePath)) {
+      return `File path must be absolute: ${filePath}`;
+    }
+    try {
+      if (fs.existsSync(filePath)) {
+        const stats = fs.lstatSync(filePath);
+        if (stats.isDirectory()) {
+          return `Path is a directory, not a file: ${filePath}`;
+        }
+      }
+    } catch (statError) {
+      return `Error accessing path properties for validation: ${filePath}. Reason: ${getErrorMessage(
+        statError
+      )}`;
+    }
+    const teamMemoryError = checkTeamMemorySecrets(
+      filePath,
+      params.content ?? "",
+      this.config.getProjectRoot()
+    );
+    if (teamMemoryError) {
+      return teamMemoryError;
+    }
+    return null;
+  }
+  createInvocation(params) {
+    return new WriteFileToolInvocation(this.config, params);
+  }
+  toAutoClassifierInput(params) {
+    const content = params.content ?? "";
+    return {
+      file_path: params.file_path,
+      byte_count: Buffer.byteLength(content, "utf8"),
+      content_preview: content.slice(0, 300),
+      content_truncated: content.length > 300
+    };
+  }
+  getModifyContext(_abortSignal) {
+    return {
+      getFilePath: /* @__PURE__ */ __name((params) => params.file_path, "getFilePath"),
+      getCurrentContent: /* @__PURE__ */ __name(async (params) => {
+        const fileExists2 = await fileExists(params.file_path);
+        if (fileExists2) {
+          try {
+            const { content } = await this.config.getFileSystemService().readTextFile({ path: params.file_path });
+            return content;
+          } catch (err) {
+            if (!isNodeError(err) || err.code !== "ENOENT") throw err;
+            return "";
+          }
+        } else {
+          return "";
+        }
+      }, "getCurrentContent"),
+      getProposedContent: /* @__PURE__ */ __name(async (params) => params.content, "getProposedContent"),
+      createUpdatedParams: /* @__PURE__ */ __name((_oldContent, modifiedProposedContent, originalParams) => {
+        const content = originalParams.content;
+        return {
+          ...originalParams,
+          ai_proposed_content: content,
+          content: modifiedProposedContent,
+          modified_by_user: true
+        };
+      }, "createUpdatedParams")
+    };
+  }
+};
+export {
+  WriteFileTool
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{zh-WY5DWYZD.js → zh-6ANG2HTL.js}

@@ -1884,11 +1884,7 @@ var zh_default = {
   "Qwen Code update available! {{current}} \u2192 {{latest}}": "Qwen Code \u6709\u53EF\u7528\u66F4\u65B0\uFF01{{current}} \u2192 {{latest}}",
   "A new version of Qwen Code is available! {{current}} \u2192 {{latest}}": "Qwen Code \u6709\u65B0\u7248\u672C\u53EF\u7528\uFF01{{current}} \u2192 {{latest}}",
   "Qwen Code {{version}} is up to date!": "Qwen Code {{version}} \u5DF2\u662F\u6700\u65B0\uFF01",
-  "Failed to check for updates ({{reason}}). Please check your network or registry configuration.": "\u68C0\u67E5\u66F4\u65B0\u5931\u8D25\uFF08{{reason}}\uFF09\u3002\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216 registry \u914D\u7F6E\u3002",
-  "Update check skipped ({{reason}}) \u2014 run /update to retry.": "\u5DF2\u8DF3\u8FC7\u66F4\u65B0\u68C0\u67E5\uFF08{{reason}}\uFF09\u2014 \u53EF\u8FD0\u884C /update \u91CD\u8BD5\u3002",
-  "registry did not respond within {{seconds}}s": "registry \u5728 {{seconds}} \u79D2\u5185\u672A\u54CD\u5E94",
-  "registry unreachable": "registry \u65E0\u6CD5\u8FDE\u63A5",
-  "registry error": "registry \u9519\u8BEF",
+  "Failed to check for updates. Please check your network or registry configuration.": "\u68C0\u67E5\u66F4\u65B0\u5931\u8D25\u3002\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216 registry \u914D\u7F6E\u3002",
   "Unable to check for updates: {{reason}}": "\u65E0\u6CD5\u68C0\u67E5\u66F4\u65B0\uFF1A{{reason}}",
   "Update successful! The new version will be used on your next run.": "\u66F4\u65B0\u6210\u529F\uFF01\u65B0\u7248\u672C\u5C06\u5728\u4E0B\u6B21\u8FD0\u884C\u65F6\u751F\u6548\u3002",
   "Update downloaded. It will be applied after you exit this session.": "\u66F4\u65B0\u5DF2\u4E0B\u8F7D\u3002\u5C06\u5728\u9000\u51FA\u5F53\u524D\u4F1A\u8BDD\u540E\u5E94\u7528\u3002",

package/chunks/{zh-TW-BM47YBFH.js → zh-TW-4RR3YHNN.js}

@@ -1717,11 +1717,7 @@ var zh_TW_default = {
   "Qwen Code update available! {{current}} \u2192 {{latest}}": "Qwen Code \u6709\u53EF\u7528\u66F4\u65B0\uFF01{{current}} \u2192 {{latest}}",
   "A new version of Qwen Code is available! {{current}} \u2192 {{latest}}": "Qwen Code \u6709\u65B0\u7248\u672C\u53EF\u7528\uFF01{{current}} \u2192 {{latest}}",
   "Qwen Code {{version}} is up to date!": "Qwen Code {{version}} \u5DF2\u662F\u6700\u65B0\uFF01",
-  "Failed to check for updates ({{reason}}). Please check your network or registry configuration.": "\u6AA2\u67E5\u66F4\u65B0\u5931\u6557\uFF08{{reason}}\uFF09\u3002\u8ACB\u6AA2\u67E5\u7DB2\u8DEF\u6216 registry \u8A2D\u5B9A\u3002",
-  "Update check skipped ({{reason}}) \u2014 run /update to retry.": "\u5DF2\u7565\u904E\u66F4\u65B0\u6AA2\u67E5\uFF08{{reason}}\uFF09\u2014 \u53EF\u57F7\u884C /update \u91CD\u8A66\u3002",
-  "registry did not respond within {{seconds}}s": "registry \u5728 {{seconds}} \u79D2\u5167\u672A\u56DE\u61C9",
-  "registry unreachable": "registry \u7121\u6CD5\u9023\u7DDA",
-  "registry error": "registry \u932F\u8AA4",
+  "Failed to check for updates. Please check your network or registry configuration.": "\u6AA2\u67E5\u66F4\u65B0\u5931\u6557\u3002\u8ACB\u6AA2\u67E5\u7DB2\u8DEF\u6216 registry \u8A2D\u5B9A\u3002",
   "Unable to check for updates: {{reason}}": "\u7121\u6CD5\u6AA2\u67E5\u66F4\u65B0\uFF1A{{reason}}",
   "Update successful! The new version will be used on your next run.": "\u66F4\u65B0\u6210\u529F\uFF01\u65B0\u7248\u672C\u5C07\u5728\u4E0B\u6B21\u57F7\u884C\u6642\u751F\u6548\u3002",
   "Update downloaded. It will be applied after you exit this session.": "\u66F4\u65B0\u5DF2\u4E0B\u8F09\u3002\u5C07\u5728\u7D50\u675F\u76EE\u524D\u5DE5\u4F5C\u968E\u6BB5\u5F8C\u5957\u7528\u3002",