@qwen-code/qwen-code 0.15.12-preview.2 → 0.16.0-nightly.20260522.48b0a8bfc

package/chunks/{chunk-GJXIKCKL.js → chunk-XP27SJMH.js}

@@ -336,8 +336,8 @@ __name(sanitizeCwd, "sanitizeCwd");
 function isSubpath(parentPath, childPath) {
   const isWindows = os.platform() === "win32";
   const pathModule = isWindows ? path.win32 : path;
-  const relative = pathModule.relative(parentPath, childPath);
-  return !relative.startsWith(`..${pathModule.sep}`) && relative !== ".." && !pathModule.isAbsolute(relative);
+  const relative2 = pathModule.relative(parentPath, childPath);
+  return !relative2.startsWith(`..${pathModule.sep}`) && relative2 !== ".." && !pathModule.isAbsolute(relative2);
 }
 __name(isSubpath, "isSubpath");
 function isSubpaths(parentPath, childPath) {
@@ -443,6 +443,17 @@ var Storage = class _Storage {
     }
     return resolved;
   }
+  /**
+   * Sanitizes a session id for use as a plan filename.
+   *
+   * Plan files are keyed by session id, but the raw id is public SDK input.
+   * Strip directory separators and Windows-invalid filename characters so a
+   * hostile value cannot escape the plans directory.
+   */
+  static sanitizePlanSessionId(sessionId) {
+    const safeName = path2.basename(sessionId.replace(/\\/g, "/")).replace(/^\.+/g, "_").replace(/[<>:"|?*\x00-\x1F]/g, "_");
+    return safeName || "_";
+  }
   static resolveRuntimeBaseDir(dir, cwd) {
     if (!dir) {
       return null;
@@ -531,11 +542,71 @@ var Storage = class _Storage {
   static getGlobalIdeDir() {
     return path2.join(_Storage.getGlobalQwenDir(), IDE_DIR_NAME);
   }
-  static getPlansDir() {
+  /**
+   * Resolves pathToResolve by realpathing its deepest existing ancestor and
+   * appending the not-yet-created remainder.
+   */
+  static resolvePathThroughExistingAncestor(pathToResolve) {
+    let candidate = pathToResolve;
+    while (true) {
+      try {
+        const realCandidate = fs2.realpathSync(candidate);
+        const remainder = path2.relative(candidate, pathToResolve);
+        return path2.join(realCandidate, remainder);
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+        const parent = path2.dirname(candidate);
+        if (parent === candidate) {
+          return pathToResolve;
+        }
+        candidate = parent;
+      }
+    }
+  }
+  /**
+   * Checks whether {@link childPath} resides within {@link parentPath},
+   * resolving symbolic links to prevent traversal bypass attacks.
+   */
+  static isPathWithinDirectory(childPath, parentPath) {
+    const realParent = _Storage.resolvePathThroughExistingAncestor(parentPath);
+    const realChild = _Storage.resolvePathThroughExistingAncestor(childPath);
+    const relativePath = path2.relative(realParent, realChild);
+    return relativePath === "" || !relativePath.startsWith("..") && !path2.isAbsolute(relativePath);
+  }
+  static assertPathWithinDirectory(childPath, parentPath, errorMessage) {
+    if (!_Storage.isPathWithinDirectory(childPath, parentPath)) {
+      throw new FatalConfigError(errorMessage);
+    }
+  }
+  static getPlansDir(projectRoot, plansDirectory) {
+    const configuredPlansDirectory = plansDirectory?.trim();
+    if (configuredPlansDirectory) {
+      if (!projectRoot) {
+        throw new FatalConfigError(
+          "projectRoot is required when plansDirectory is configured."
+        );
+      }
+      const resolvedProjectRoot = path2.resolve(projectRoot);
+      const resolvedPlansDirectory = _Storage.resolvePath(
+        configuredPlansDirectory,
+        resolvedProjectRoot
+      );
+      _Storage.assertPathWithinDirectory(
+        resolvedPlansDirectory,
+        resolvedProjectRoot,
+        `plansDirectory must resolve within the project root.`
+      );
+      return resolvedPlansDirectory;
+    }
     return path2.join(_Storage.getGlobalQwenDir(), PLANS_DIR_NAME);
   }
-  static getPlanFilePath(sessionId) {
-    return path2.join(_Storage.getPlansDir(), `${sessionId}.md`);
+  static getPlanFilePath(sessionId, projectRoot, plansDirectory) {
+    return path2.join(
+      _Storage.getPlansDir(projectRoot, plansDirectory),
+      `${_Storage.sanitizePlanSessionId(sessionId)}.md`
+    );
   }
   static getGlobalBinDir() {
     return path2.join(_Storage.getGlobalQwenDir(), BIN_DIR_NAME);

package/chunks/chunk-XTYIPAUG.js

@@ -0,0 +1,379 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  resolveBundleDir
+} from "./chunk-OZO6R4KI.js";
+import {
+  Storage
+} from "./chunk-XP27SJMH.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __glob,
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/utils/stdioHelpers.ts
+init_esbuild_shims();
+var writeStdoutLine = /* @__PURE__ */ __name((message) => {
+  process.stdout.write(message.endsWith("\n") ? message : `${message}
+`);
+}, "writeStdoutLine");
+var writeStderrLine = /* @__PURE__ */ __name((message) => {
+  process.stderr.write(message.endsWith("\n") ? message : `${message}
+`);
+}, "writeStderrLine");
+var clearScreen = /* @__PURE__ */ __name(() => {
+  console.clear();
+}, "clearScreen");
+
+// packages/cli/src/i18n/index.ts
+init_esbuild_shims();
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+
+// packages/cli/src/i18n/languages.ts
+init_esbuild_shims();
+var SUPPORTED_LANGUAGES = [
+  {
+    code: "en",
+    id: "en-US",
+    fullName: "English",
+    nativeName: "English"
+  },
+  {
+    code: "zh-TW",
+    id: "zh-TW",
+    fullName: "Traditional Chinese",
+    nativeName: "\u7E41\u9AD4\u4E2D\u6587",
+    strictParity: true
+  },
+  {
+    code: "zh",
+    id: "zh-CN",
+    fullName: "Chinese",
+    nativeName: "\u4E2D\u6587",
+    strictParity: true
+  },
+  {
+    code: "ru",
+    id: "ru-RU",
+    fullName: "Russian",
+    nativeName: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439"
+  },
+  {
+    code: "de",
+    id: "de-DE",
+    fullName: "German",
+    nativeName: "Deutsch"
+  },
+  {
+    code: "ja",
+    id: "ja-JP",
+    fullName: "Japanese",
+    nativeName: "\u65E5\u672C\u8A9E"
+  },
+  {
+    code: "pt",
+    id: "pt-BR",
+    fullName: "Portuguese",
+    nativeName: "Portugu\xEAs"
+  },
+  {
+    code: "fr",
+    id: "fr-FR",
+    fullName: "French",
+    nativeName: "Fran\xE7ais"
+  },
+  {
+    code: "ca",
+    id: "ca-ES",
+    fullName: "Catalan",
+    nativeName: "Catal\xE0"
+  }
+];
+function normalizeLanguageCandidate(input) {
+  return input.trim().replace(/_/g, "-").toLowerCase();
+}
+__name(normalizeLanguageCandidate, "normalizeLanguageCandidate");
+function matchesLocaleToken(candidate, token) {
+  return candidate === token || candidate.startsWith(`${token}-`) || candidate.startsWith(`${token}.`) || candidate.startsWith(`${token}@`);
+}
+__name(matchesLocaleToken, "matchesLocaleToken");
+function getMatchedLocaleTokenLength(candidate, language) {
+  const code = language.code.toLowerCase();
+  const id = language.id.toLowerCase();
+  if (matchesLocaleToken(candidate, id)) {
+    return id.length;
+  }
+  if (matchesLocaleToken(candidate, code)) {
+    return code.length;
+  }
+  return void 0;
+}
+__name(getMatchedLocaleTokenLength, "getMatchedLocaleTokenLength");
+function resolveSupportedLanguage(input) {
+  const normalized = normalizeLanguageCandidate(input);
+  if (!normalized) {
+    return void 0;
+  }
+  let bestMatch;
+  for (const language of SUPPORTED_LANGUAGES) {
+    if (normalized === language.fullName.toLowerCase() || language.nativeName && normalized === language.nativeName.toLowerCase()) {
+      return language.code;
+    }
+    const tokenLength = getMatchedLocaleTokenLength(normalized, language);
+    if (tokenLength !== void 0 && (!bestMatch || tokenLength > bestMatch.tokenLength)) {
+      bestMatch = { code: language.code, tokenLength };
+    }
+  }
+  return bestMatch?.code;
+}
+__name(resolveSupportedLanguage, "resolveSupportedLanguage");
+function getLanguageNameFromLocale(locale) {
+  const resolved = resolveSupportedLanguage(locale);
+  const lang = resolved ? SUPPORTED_LANGUAGES.find((language) => language.code === resolved) : void 0;
+  return lang?.fullName || "English";
+}
+__name(getLanguageNameFromLocale, "getLanguageNameFromLocale");
+function getLanguageSettingsOptions() {
+  return [
+    { value: "auto", label: "Auto (detect from system)" },
+    ...SUPPORTED_LANGUAGES.map((l) => ({
+      value: l.code,
+      label: l.nativeName ? `${l.nativeName} (${l.fullName})` : `${l.fullName} (${l.id})`
+    }))
+  ];
+}
+__name(getLanguageSettingsOptions, "getLanguageSettingsOptions");
+function getSupportedLanguageIds(separator = "|") {
+  return SUPPORTED_LANGUAGES.map((l) => l.id).join(separator);
+}
+__name(getSupportedLanguageIds, "getSupportedLanguageIds");
+
+// packages/cli/src/i18n/translationDict.ts
+init_esbuild_shims();
+function getTranslationModuleExport(module) {
+  return Object.prototype.hasOwnProperty.call(module, "default") ? module["default"] : module;
+}
+__name(getTranslationModuleExport, "getTranslationModuleExport");
+function isTranslationDict(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+__name(isTranslationDict, "isTranslationDict");
+
+// packages/cli/src/i18n/mustTranslateKeys.ts
+init_esbuild_shims();
+
+// import("./locales/**/*.js") in packages/cli/src/i18n/index.ts
+var globImport_locales_js = __glob({
+  "./locales/ca.js": () => import("./ca-UZ7BANMN.js"),
+  "./locales/de.js": () => import("./de-V4IE2OOZ.js"),
+  "./locales/en.js": () => import("./en-HGJ2SPLM.js"),
+  "./locales/fr.js": () => import("./fr-CJULI7ZX.js"),
+  "./locales/ja.js": () => import("./ja-L7CHRQEW.js"),
+  "./locales/pt.js": () => import("./pt-M6JULLEQ.js"),
+  "./locales/ru.js": () => import("./ru-QILM4HBC.js"),
+  "./locales/zh-TW.js": () => import("./zh-TW-S3YGWICZ.js"),
+  "./locales/zh.js": () => import("./zh-PWL2NKY3.js")
+});
+
+// packages/cli/src/i18n/index.ts
+var currentLanguage = "en";
+var translations = {};
+var translationCache = {};
+var loadingPromises = {};
+var getBuiltinLocalesDir = /* @__PURE__ */ __name(() => path.join(resolveBundleDir(import.meta.url), "locales"), "getBuiltinLocalesDir");
+var getUserLocalesDir = /* @__PURE__ */ __name(() => path.join(Storage.getGlobalQwenDir(), "locales"), "getUserLocalesDir");
+var getLocalePath = /* @__PURE__ */ __name((lang, useUserDir = false) => {
+  const baseDir = useUserDir ? getUserLocalesDir() : getBuiltinLocalesDir();
+  return path.join(baseDir, `${lang}.js`);
+}, "getLocalePath");
+function detectSystemLanguage() {
+  const envLang = process.env["QWEN_CODE_LANG"] || process.env["LANG"];
+  if (envLang) {
+    const resolved = resolveSupportedLanguage(envLang);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  try {
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+    const resolved = resolveSupportedLanguage(locale);
+    if (resolved) {
+      return resolved;
+    }
+  } catch {
+  }
+  return "en";
+}
+__name(detectSystemLanguage, "detectSystemLanguage");
+async function tryImportTranslations(moduleSpecifier) {
+  try {
+    const module = await import(moduleSpecifier);
+    const result = getTranslationModuleExport(module);
+    if (isTranslationDict(result)) {
+      return { translations: result };
+    }
+    return {
+      error: new Error("Module loaded but result is empty or invalid")
+    };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+__name(tryImportTranslations, "tryImportTranslations");
+async function tryImportBundledTranslations(lang) {
+  try {
+    const module = await globImport_locales_js(`./locales/${lang}.js`);
+    const result = getTranslationModuleExport(module);
+    if (isTranslationDict(result)) {
+      return { translations: result };
+    }
+    return {
+      error: new Error("Module loaded but result is empty or invalid")
+    };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+__name(tryImportBundledTranslations, "tryImportBundledTranslations");
+async function loadTranslationsAsync(lang) {
+  if (translationCache[lang]) {
+    return translationCache[lang];
+  }
+  const existingPromise = loadingPromises[lang];
+  if (existingPromise) {
+    return existingPromise;
+  }
+  const loadPromise = (async () => {
+    const userJsPath = getLocalePath(lang, true);
+    if (fs.existsSync(getUserLocalesDir()) && fs.existsSync(userJsPath)) {
+      const userResult = await tryImportTranslations(
+        pathToFileURL(userJsPath).href
+      );
+      if (userResult.translations) {
+        translationCache[lang] = userResult.translations;
+        return userResult.translations;
+      }
+      writeStderrLine(
+        `Failed to load translations from user directory for ${lang}: ${userResult.error.message}`
+      );
+    }
+    const builtinJsPath = getLocalePath(lang, false);
+    const builtinModuleSpecifiers = [];
+    if (fs.existsSync(getBuiltinLocalesDir()) && fs.existsSync(builtinJsPath)) {
+      builtinModuleSpecifiers.push(pathToFileURL(builtinJsPath).href);
+    }
+    let lastBuiltinError;
+    for (const moduleSpecifier of builtinModuleSpecifiers) {
+      const builtinResult = await tryImportTranslations(moduleSpecifier);
+      if (builtinResult.translations) {
+        translationCache[lang] = builtinResult.translations;
+        return builtinResult.translations;
+      }
+      lastBuiltinError = builtinResult.error;
+    }
+    const bundledBuiltinResult = await tryImportBundledTranslations(lang);
+    if (bundledBuiltinResult.translations) {
+      translationCache[lang] = bundledBuiltinResult.translations;
+      return bundledBuiltinResult.translations;
+    }
+    lastBuiltinError = bundledBuiltinResult.error;
+    if (lastBuiltinError) {
+      writeStderrLine(
+        `Failed to load JS translations for ${lang}: ${lastBuiltinError.message}`
+      );
+    }
+    translationCache[lang] = {};
+    return {};
+  })();
+  loadingPromises[lang] = loadPromise;
+  loadPromise.finally(() => {
+    delete loadingPromises[lang];
+  });
+  return loadPromise;
+}
+__name(loadTranslationsAsync, "loadTranslationsAsync");
+function interpolate(template, params) {
+  if (!params) return template;
+  return template.replace(
+    /\{\{(\w+)\}\}/g,
+    (match, key) => params[key] ?? match
+  );
+}
+__name(interpolate, "interpolate");
+function resolveLanguage(lang) {
+  if (lang === "auto") {
+    return detectSystemLanguage();
+  }
+  return resolveSupportedLanguage(lang) ?? lang;
+}
+__name(resolveLanguage, "resolveLanguage");
+async function setLanguageAsync(lang) {
+  currentLanguage = resolveLanguage(lang);
+  translations = await loadTranslationsAsync(currentLanguage);
+}
+__name(setLanguageAsync, "setLanguageAsync");
+function getCurrentLanguage() {
+  return currentLanguage;
+}
+__name(getCurrentLanguage, "getCurrentLanguage");
+function t(key, params) {
+  const translation = translations[key] ?? key;
+  if (Array.isArray(translation)) {
+    return key;
+  }
+  return interpolate(translation, params);
+}
+__name(t, "t");
+function ta(key) {
+  const translation = translations[key];
+  if (Array.isArray(translation)) {
+    return translation;
+  }
+  return [];
+}
+__name(ta, "ta");
+async function initializeI18n(lang) {
+  await setLanguageAsync(lang ?? "auto");
+}
+__name(initializeI18n, "initializeI18n");
+
+export {
+  writeStdoutLine,
+  writeStderrLine,
+  clearScreen,
+  SUPPORTED_LANGUAGES,
+  resolveSupportedLanguage,
+  getLanguageNameFromLocale,
+  getLanguageSettingsOptions,
+  getSupportedLanguageIds,
+  detectSystemLanguage,
+  setLanguageAsync,
+  getCurrentLanguage,
+  t,
+  ta,
+  initializeI18n
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-TPGOGCWM.js → chunk-YJLGXDQJ.js}

@@ -5,7 +5,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-FYMSCRHM.js";
+} from "./chunk-PVVL5Q3W.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{contextCommand-MQRG6RMG.js → contextCommand-O2OLCMOG.js}

@@ -4,34 +4,32 @@ import {
   collectContextData,
   contextCommand,
   formatContextUsageText
-} from "./chunk-MXBWOU2L.js";
-import "./chunk-Y6Z2O3WR.js";
-import "./chunk-2WFU3IUH.js";
-import "./chunk-5P5XGNYH.js";
+} from "./chunk-TM4RMEYN.js";
+import "./chunk-XTYIPAUG.js";
+import "./chunk-OZO6R4KI.js";
 import "./chunk-K5PGHDBN.js";
 import "./chunk-O4PICXES.js";
 import "./chunk-TW522KN6.js";
 import "./chunk-MLZQVCF3.js";
-import "./chunk-JMZQICAL.js";
-import "./chunk-SOIEFHIK.js";
-import "./chunk-B7ZL7HUA.js";
+import "./chunk-CAVZVZX6.js";
+import "./chunk-G7YTSRES.js";
+import "./chunk-4AOCVI6J.js";
 import "./chunk-77WXWU44.js";
-import "./chunk-OCC4MZRS.js";
-import "./chunk-CAWKL3UC.js";
-import "./chunk-PCL3EJGY.js";
-import "./chunk-SYCJMSIJ.js";
+import "./chunk-F23NCRJ2.js";
+import "./chunk-CSWBPY3P.js";
+import "./chunk-4U3O4VDA.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
-import "./chunk-CM2IESUE.js";
-import "./chunk-UXW7MYAW.js";
-import "./chunk-G27O2LD2.js";
+import "./chunk-PR4T27R7.js";
+import "./chunk-MAY32HXD.js";
+import "./chunk-D5NTAHYL.js";
 import "./chunk-T4VD6OJ4.js";
 import "./chunk-RDYWTWEM.js";
-import "./chunk-TPGOGCWM.js";
-import "./chunk-FYMSCRHM.js";
-import "./chunk-SQNQIOD5.js";
-import "./chunk-FKVKVE6N.js";
-import "./chunk-GJXIKCKL.js";
+import "./chunk-YJLGXDQJ.js";
+import "./chunk-PVVL5Q3W.js";
+import "./chunk-GGNTZ2NH.js";
+import "./chunk-KXZ4TJB4.js";
+import "./chunk-XP27SJMH.js";
 import "./chunk-E7E2MFYM.js";
 import "./chunk-ZERZSAZL.js";
 import "./chunk-QN5NZ3UQ.js";

package/chunks/{cron-create-WUTD5ZTH.js → cron-create-IGYXQVG4.js}

@@ -11,8 +11,8 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-FYMSCRHM.js";
-import "./chunk-GJXIKCKL.js";
+} from "./chunk-PVVL5Q3W.js";
+import "./chunk-XP27SJMH.js";
 import "./chunk-QWSRH265.js";
 import {
   init_esbuild_shims
@@ -34,6 +34,17 @@ var CronCreateInvocation = class extends BaseToolInvocation {
   getDescription() {
     return `${this.params.cron}: ${this.params.prompt}`;
   }
+  /**
+   * The scheduled prompt fires against the agent at cron-trigger time
+   * and executes with full tool access. The CronCreateTool's L3 default
+   * must NOT be 'allow', because AUTO mode short-circuits at L4 when
+   * `finalPermission === 'allow'` — the classifier never runs and an
+   * arbitrary scheduled prompt is silently approved. `'ask'` routes
+   * the call through the classifier (or manual approval in DEFAULT).
+   */
+  async getDefaultPermission() {
+    return "ask";
+  }
   async execute() {
     const scheduler = this.config.getCronScheduler();
     const recurring = this.params.recurring !== false;
@@ -108,6 +119,21 @@ var CronCreateTool = class _CronCreateTool extends BaseDeclarativeTool {
   createInvocation(params) {
     return new CronCreateInvocation(this.config, params);
   }
+  /**
+   * Forward the prompt and cadence to the classifier. The scheduled
+   * prompt will be enqueued and executed against the agent at fire-time,
+   * so it must go through the same scrutiny as a direct command. Without
+   * this override the default projection returns `''` and the classifier
+   * sees `cron_create({})` — blind to what the agent will be asked to
+   * do in 8 hours.
+   */
+  toAutoClassifierInput(params) {
+    return {
+      cron: params.cron,
+      prompt: params.prompt,
+      recurring: params.recurring ?? true
+    };
+  }
 };
 export {
   CronCreateTool

package/chunks/{cron-delete-N3UQYCRA.js → cron-delete-ETKIZCWT.js}

@@ -5,8 +5,8 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-FYMSCRHM.js";
-import "./chunk-GJXIKCKL.js";
+} from "./chunk-PVVL5Q3W.js";
+import "./chunk-XP27SJMH.js";
 import "./chunk-QWSRH265.js";
 import {
   init_esbuild_shims

package/chunks/{cron-list-Z6RJJ4YH.js → cron-list-BVCUSWRU.js}

@@ -8,8 +8,8 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-FYMSCRHM.js";
-import "./chunk-GJXIKCKL.js";
+} from "./chunk-PVVL5Q3W.js";
+import "./chunk-XP27SJMH.js";
 import "./chunk-QWSRH265.js";
 import {
   init_esbuild_shims

package/chunks/{de-M2IPQRBS.js → de-V4IE2OOZ.js}

@@ -87,6 +87,32 @@ var de_default = {
   "Generate a one-line session recap now": "Jetzt eine einzeilige Sitzungszusammenfassung erstellen",
   "Rename the current conversation. --auto lets the fast model pick a title.": "Die aktuelle Unterhaltung umbenennen. Mit --auto l\xE4sst du das schnelle Modell einen Titel w\xE4hlen.",
   "Rewind conversation to a previous turn": "Die Unterhaltung auf einen fr\xFCheren Gespr\xE4chsschritt zur\xFCcksetzen",
+  "Rewind Conversation": "Unterhaltung zur\xFCckspulen",
+  "No user turns to rewind to.": "Keine Benutzerrunden zum Zur\xFCckspulen.",
+  "Rewind to: ": "Zur\xFCckspulen zu: ",
+  "Restore code and conversation": "Code und Unterhaltung wiederherstellen",
+  "Restore conversation only": "Nur Unterhaltung wiederherstellen",
+  "Restore code only": "Nur Code wiederherstellen",
+  "Never mind": "Egal",
+  "Computing file changes...": "Datei\xE4nderungen werden berechnet...",
+  "Restoring...": "Wiederherstellung l\xE4uft...",
+  "Restored {{count}} file(s).": "{{count}} Datei(en) wiederhergestellt.",
+  "Failed to restore files: {{error}}": "Fehler beim Wiederherstellen der Dateien: {{error}}",
+  "Rewind failed: {{error}}": "Zur\xFCckspulen fehlgeschlagen: {{error}}",
+  "Cannot rewind conversation: no active model client.": "Konversation kann nicht zur\xFCckgespult werden: kein aktiver Modell-Client.",
+  "Code restored, but conversation could not be rewound (no active client).": "Code wiederhergestellt, aber Konversation konnte nicht zur\xFCckgespult werden (kein aktiver Client).",
+  "Conversation rewound. Edit your prompt and press Enter to continue.": "Konversation zur\xFCckgespult. Bearbeite deinen Prompt und dr\xFCcke Enter, um fortzufahren.",
+  "Rewinding does not affect files edited manually or via shell commands.": "Das Zur\xFCckspulen wirkt sich nicht auf Dateien aus, die manuell oder per Shell-Befehl ge\xE4ndert wurden.",
+  "Cannot rewind to a turn that was compressed. Try a more recent turn.": "Zu einem komprimierten Turn kann nicht zur\xFCckgespult werden. Bitte einen aktuelleren Turn versuchen.",
+  "File restore is unavailable for this turn (no captured file changes, or this turn predates the current session).": "Datei-Wiederherstellung ist f\xFCr diesen Turn nicht verf\xFCgbar (keine erfassten Datei\xE4nderungen, oder dieser Turn liegt vor der aktuellen Sitzung).",
+  "(+{{insertions}} -{{deletions}} in {{count}} file)": "(+{{insertions}} -{{deletions}} in {{count}} Datei)",
+  "(+{{insertions}} -{{deletions}} in {{count}} files)": "(+{{insertions}} -{{deletions}} in {{count}} Dateien)",
+  "Failed to restore {{count}} file(s): {{files}}": "{{count}} Datei(en) konnten nicht wiederhergestellt werden: {{files}}",
+  "Cannot restore files: this turn was created before file checkpointing was enabled.": "Dateien k\xF6nnen nicht wiederhergestellt werden: Dieser Turn wurde erstellt, bevor Datei-Checkpointing aktiviert war.",
+  "No files needed to be restored.": "Keine Dateien mussten wiederhergestellt werden.",
+  "\u2191\u2193 to navigate \xB7 Enter to select \xB7 Esc to go back": "\u2191\u2193 navigieren \xB7 Enter ausw\xE4hlen \xB7 Esc zur\xFCck",
+  "\u2191\u2193 to navigate \xB7 Enter to select \xB7 Esc to cancel": "\u2191\u2193 navigieren \xB7 Enter ausw\xE4hlen \xB7 Esc abbrechen",
+  "Enter/Y to confirm \xB7 Esc/N to go back": "Enter/Y best\xE4tigen \xB7 Esc/N zur\xFCck",
   "change the theme": "Design \xE4ndern",
   "Select Theme": "Design ausw\xE4hlen",
   Preview: "Vorschau",
@@ -99,7 +125,7 @@ var de_default = {
   "Compresses the context by replacing it with a summary.": "Komprimiert den Kontext durch Ersetzen mit einer Zusammenfassung.",
   "open full Qwen Code documentation in your browser": "Vollst\xE4ndige Qwen Code Dokumentation im Browser \xF6ffnen",
   "Configuration not available.": "Konfiguration nicht verf\xFCgbar.",
-  "Configure authentication information for login": "Authentifizierungsinformationen f\xFCr die Anmeldung konfigurieren",
+  "Connect an LLM provider": "LLM-Anbieter verbinden",
   "Copy the last result or code snippet to clipboard": "Letztes Ergebnis oder Codeausschnitt in die Zwischenablage kopieren",
   // ============================================================================
   // Commands - Agents
@@ -756,8 +782,8 @@ var de_default = {
   "Continue previous conversation": "Vorheriges Gespr\xE4ch fortsetzen",
   "\u{1F44B} Welcome back! (Last updated: {{timeAgo}})": "\u{1F44B} Willkommen zur\xFCck! (Zuletzt aktualisiert: {{timeAgo}})",
   "\u{1F3AF} Overall Goal:": "\u{1F3AF} Gesamtziel:",
-  "Select Authentication Method": "Authentifizierungsmethode ausw\xE4hlen",
-  "You must select an auth method to proceed. Press Ctrl+C again to exit.": "Sie m\xFCssen eine Authentifizierungsmethode w\xE4hlen, um fortzufahren. Dr\xFCcken Sie erneut Ctrl+C zum Beenden.",
+  "Connect a Provider": "Anbieter verbinden",
+  "You must connect a provider to proceed. Press Ctrl+C again to exit.": "Sie m\xFCssen einen Anbieter verbinden, um fortzufahren. Dr\xFCcken Sie erneut Ctrl+C zum Beenden.",
   "Terms of Services and Privacy Notice": "Nutzungsbedingungen und Datenschutzhinweis",
   "Qwen OAuth": "Qwen OAuth",
   "Discontinued \u2014 switch to Coding Plan or API Key": "Eingestellt \u2014 wechseln Sie zu Coding Plan oder API Key",