@qwen-code/qwen-code 0.19.6-nightly.20260707.bcdb44c5d → 0.19.6-preview.0

package/chunks/{chunk-S6PM5JQZ.js → chunk-IFDJAMJW.js}

@@ -3,10 +3,7 @@
 import {
   isValidSessionId,
   validateAuthMethod
-} from "./chunk-CCPKBMZ4.js";
-import {
-  contextCommand
-} from "./chunk-7YLLBKDB.js";
+} from "./chunk-ZOSL7K3L.js";
 import {
   VSCODE_SHIFT_ENTER_SEQUENCE,
   calculateCost,
@@ -18,25 +15,32 @@ import {
   levelLabel,
   useKeypress,
   writeOsc52
-} from "./chunk-NCOLCOA6.js";
-import {
-  isTerminalGoalStatusKind
-} from "./chunk-KSPVDFE4.js";
+} from "./chunk-GPLKAQUX.js";
 import {
   Text
-} from "./chunk-3A4MUHRP.js";
+} from "./chunk-MZWODTEA.js";
+import {
+  isKittyProtocolEnabled
+} from "./chunk-JZSY4WP3.js";
+import {
+  contextCommand
+} from "./chunk-FCEHOKYP.js";
+import {
+  getInstallationInfo,
+  rollbackStandaloneUpdate
+} from "./chunk-A3ZQMFO6.js";
+import {
+  isTerminalGoalStatusKind
+} from "./chunk-SAIILPQ3.js";
 import {
   require_react
 } from "./chunk-KYMBIKIW.js";
 import {
   themeManager
 } from "./chunk-PC4ZXHU2.js";
-import {
-  isKittyProtocolEnabled
-} from "./chunk-JZSY4WP3.js";
 import {
   getErrorMessage as getErrorMessage2
-} from "./chunk-WAVK7GV6.js";
+} from "./chunk-2X3ZVAAT.js";
 import {
   GITHUB_WORKFLOW_PATHS,
   INSIGHT_CSS,
@@ -49,19 +53,16 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-UOGOM4NJ.js";
-import {
-  require_undici
-} from "./chunk-54YZOP7P.js";
+} from "./chunk-AJ3CEJRJ.js";
 import {
   stripUnsafeCharacters,
   toCodePoints
-} from "./chunk-OGAC66WF.js";
+} from "./chunk-7VCI24VZ.js";
 import {
   getExtendedSystemInfo,
   getGitVersion,
   getNpmVersion
-} from "./chunk-HLJMZYTD.js";
+} from "./chunk-2D5Q33PT.js";
 import {
   formatDuration,
   formatMemoryUsage,
@@ -70,7 +71,7 @@ import {
 import {
   isInlineModelOverrideAllowed,
   parseAcpModelOption
-} from "./chunk-FTEFJT6V.js";
+} from "./chunk-QM4FKX7H.js";
 import {
   formatUnsupportedVoiceModelMessage,
   getVoiceSettingsScope,
@@ -78,7 +79,7 @@ import {
   isVoiceEnabled,
   readVoiceMode,
   readVoiceModel
-} from "./chunk-B2FUQ22Z.js";
+} from "./chunk-ILFQAFWH.js";
 import {
   OUTPUT_LANGUAGE_AUTO,
   getAllSettingKeys,
@@ -90,7 +91,7 @@ import {
   resolveOutputLanguage,
   validateSettingValue,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-INNPK6XG.js";
+} from "./chunk-O6T7PBUM.js";
 import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
@@ -98,11 +99,11 @@ import {
   resolveSupportedLanguage,
   setLanguageAsync,
   t
-} from "./chunk-VCKMHAEZ.js";
+} from "./chunk-2MJAXDFK.js";
 import {
   isFolderTrustEnabled,
   loadTrustedFolders
-} from "./chunk-32KIF557.js";
+} from "./chunk-WKBA74DD.js";
 import {
   require_strip_json_comments
 } from "./chunk-QYUE6W3T.js";
@@ -118,7 +119,6 @@ import {
   SESSION_TITLE_MAX_LENGTH,
   SessionService,
   ShellExecutionService,
-  So,
   appendToLastTextPart,
   buildBackgroundEntryLabel,
   buildBareRememberPrompt,
@@ -150,7 +150,6 @@ import {
   glob,
   hookEventSupportsMatcher,
   ideContextStore,
-  isGitRepository,
   isImageCapable,
   isSuccessStatus,
   isTerminalStatus,
@@ -176,7 +175,7 @@ import {
   stripStartupContext,
   tryGenerateSessionTitle,
   unregisterGoalHook
-} from "./chunk-KD4KV6XW.js";
+} from "./chunk-ZWFS7YCB.js";
 import {
   external_exports
 } from "./chunk-K5PGHDBN.js";
@@ -207,7 +206,7 @@ import {
   recordSkillInvocation,
   resolveOpenAILogDir,
   uiTelemetryService
-} from "./chunk-IPKM25FZ.js";
+} from "./chunk-N33JAGJ7.js";
 import {
   getAutoMemoryRoot
 } from "./chunk-4KJ2BPIT.js";
@@ -234,7 +233,7 @@ import {
   isCpuProfileRecording,
   startCpuProfile,
   stopCpuProfile
-} from "./chunk-H2UZO2II.js";
+} from "./chunk-TPTG52XG.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -281,7 +280,7 @@ var isBtwCommand = /* @__PURE__ */ __name((query) => {
 }, "isBtwCommand");
 var debugLogger = createDebugLogger("COMMAND_UTILS");
 var copyToClipboard = /* @__PURE__ */ __name(async (text) => {
-  const run = /* @__PURE__ */ __name((cmd, args, options) => new Promise((resolve5, reject) => {
+  const run = /* @__PURE__ */ __name((cmd, args, options) => new Promise((resolve4, reject) => {
     const child = options ? spawn(cmd, args, options) : spawn(cmd, args);
     let stderr = "";
     if (child.stderr) {
@@ -289,7 +288,7 @@ var copyToClipboard = /* @__PURE__ */ __name(async (text) => {
     }
     child.on("error", reject);
     child.on("close", (code) => {
-      if (code === 0) return resolve5();
+      if (code === 0) return resolve4();
       const errorMsg = stderr.trim();
       reject(
         new Error(
@@ -455,6 +454,7 @@ init_esbuild_shims();
 
 // packages/cli/src/utils/commands.ts
 init_esbuild_shims();
+var MAX_STACKED_SKILLS = 5;
 var parseSlashCommand = /* @__PURE__ */ __name((query, commands) => {
   const trimmed = query.trim();
   const commandText = trimmed.substring(1).trim();
@@ -490,6 +490,55 @@ var parseSlashCommand = /* @__PURE__ */ __name((query, commands) => {
   const args = commandToExecute ? commandText.slice(argsStart).trim() : parts.slice(pathIndex).join(" ");
   return { commandToExecute, args, canonicalPath };
 }, "parseSlashCommand");
+var parseStackedSlashCommands = /* @__PURE__ */ __name((query, commands) => {
+  const trimmed = query.trim();
+  if (!trimmed.startsWith("/")) {
+    return { skills: [], remainingText: trimmed, exceededMax: false };
+  }
+  const commandText = trimmed.substring(1);
+  const skills = [];
+  let pos = 0;
+  let restPos = 0;
+  let exceededMax = false;
+  while (pos < commandText.length) {
+    while (pos < commandText.length && /\s/.test(commandText[pos])) pos++;
+    if (pos >= commandText.length) {
+      restPos = pos;
+      break;
+    }
+    const tokenStart = pos;
+    while (pos < commandText.length && !/\s/.test(commandText[pos])) pos++;
+    const token = commandText.slice(tokenStart, pos);
+    if (skills.length === 0) {
+      if (token.startsWith("/")) break;
+      const cmd2 = findCommandByName(token, commands);
+      if (!cmd2 || cmd2.kind !== "skill" /* SKILL */) break;
+      skills.push(cmd2);
+      restPos = pos;
+      continue;
+    }
+    if (!token.startsWith("/")) break;
+    const name = token.substring(1);
+    if (!name) break;
+    const cmd = findCommandByName(name, commands);
+    if (!cmd || cmd.kind !== "skill" /* SKILL */) break;
+    if (skills.length >= MAX_STACKED_SKILLS) {
+      exceededMax = true;
+      break;
+    }
+    skills.push(cmd);
+    restPos = pos;
+  }
+  if (skills.length < 2) {
+    return { skills: [], remainingText: trimmed, exceededMax: false };
+  }
+  const afterSkills = commandText.slice(restPos).trim();
+  return { skills, remainingText: afterSkills, exceededMax };
+}, "parseStackedSlashCommands");
+function findCommandByName(name, commands) {
+  return commands.find((cmd) => cmd.name === name) ?? commands.find((cmd) => cmd.altNames?.includes(name));
+}
+__name(findCommandByName, "findCommandByName");
 
 // packages/cli/src/services/CommandService.ts
 init_esbuild_shims();
@@ -4355,7 +4404,7 @@ function writeMemoryHeapSnapshot({
 }
 __name(writeMemoryHeapSnapshot, "writeMemoryHeapSnapshot");
 function defaultWait(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 __name(defaultWait, "defaultWait");
 function normalizeSampleCount(sampleCount) {
@@ -4560,925 +4609,6 @@ function formatMemoryDiagnostics(diagnostics) {
 }
 __name(formatMemoryDiagnostics, "formatMemoryDiagnostics");
 
-// packages/cli/src/utils/standalone-update.ts
-init_esbuild_shims();
-var import_undici = __toESM(require_undici(), 1);
-import { createHash } from "node:crypto";
-import * as fs5 from "node:fs";
-import * as os3 from "node:os";
-import * as path5 from "node:path";
-import { Readable, Transform } from "node:stream";
-import { spawn as spawn2, execFile } from "node:child_process";
-import { pipeline } from "node:stream/promises";
-
-// packages/cli/src/utils/standalone-update-verify.ts
-init_esbuild_shims();
-import { createPublicKey, verify } from "node:crypto";
-var RELEASE_PUBLIC_KEY_DER_B64 = "MCowBQYDK2VwAyEAr9WRFLDauibZQKCe1oKfuFZn6zRMaEkD5+KVqN6mKM4=";
-function verifySignature(sha256sumsContent, signatureBase64) {
-  const key = createPublicKey({
-    key: Buffer.from(RELEASE_PUBLIC_KEY_DER_B64, "base64"),
-    format: "der",
-    type: "spki"
-  });
-  const signature = Buffer.from(signatureBase64, "base64");
-  if (signature.length !== 64) {
-    throw new Error(
-      `Invalid signature length: expected 64 bytes, got ${signature.length}`
-    );
-  }
-  const valid = verify(null, Buffer.from(sha256sumsContent), key, signature);
-  if (!valid) {
-    throw new Error(
-      "SHA256SUMS signature verification failed \u2014 possible tampering detected"
-    );
-  }
-}
-__name(verifySignature, "verifySignature");
-
-// packages/cli/src/utils/standalone-update.ts
-var debugLogger6 = createDebugLogger("STANDALONE_UPDATE");
-var OSS_BASE = "https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/releases/qwen-code";
-var GITHUB_BASE = "https://github.com/QwenLM/qwen-code/releases/download";
-var FETCH_TIMEOUT_MS = 3e4;
-var ARCHIVE_TIMEOUT_MS = 3e5;
-var VALID_TARGETS = /* @__PURE__ */ new Set([
-  "darwin-arm64",
-  "darwin-x64",
-  "linux-arm64",
-  "linux-x64",
-  "win-x64"
-]);
-var SEMVER_RE = /^v?\d+\.\d+\.\d+(-[\w.]+)?$/;
-function normalizeVersion(version) {
-  if (!SEMVER_RE.test(version)) {
-    throw new Error(`Invalid version format: ${version}`);
-  }
-  return version.startsWith("v") ? version : `v${version}`;
-}
-__name(normalizeVersion, "normalizeVersion");
-function validateTarget(target) {
-  if (!VALID_TARGETS.has(target)) {
-    throw new Error(`Unknown target: ${target}`);
-  }
-}
-__name(validateTarget, "validateTarget");
-function archiveFilename(target) {
-  const ext = target.startsWith("win") ? "zip" : "tar.gz";
-  return `qwen-code-${target}.${ext}`;
-}
-__name(archiveFilename, "archiveFilename");
-function escapePS(s) {
-  return s.replace(/'/g, "''");
-}
-__name(escapePS, "escapePS");
-async function tryFetch(url, timeoutMs = FETCH_TIMEOUT_MS) {
-  try {
-    const res = await (0, import_undici.fetch)(url, {
-      signal: AbortSignal.timeout(timeoutMs)
-    });
-    if (res.ok) return { response: res };
-    await res.body?.cancel().catch(() => {
-    });
-    return { error: new Error(`HTTP ${res.status} ${res.statusText}`) };
-  } catch (err) {
-    const error = err instanceof Error ? err : new Error(String(err));
-    debugLogger6.debug(`Fetch failed for ${url}: ${error.message}`);
-    return { error };
-  }
-}
-__name(tryFetch, "tryFetch");
-async function downloadWithFallback(versionPath, filename, timeoutMs = FETCH_TIMEOUT_MS) {
-  const ossUrl = `${OSS_BASE}/${versionPath}/${filename}`;
-  const ossResult = await tryFetch(ossUrl, timeoutMs);
-  if (ossResult.response) return ossResult.response;
-  const ghUrl = `${GITHUB_BASE}/${versionPath}/${filename}`;
-  const ghResult = await tryFetch(ghUrl, timeoutMs);
-  if (ghResult.response) return ghResult.response;
-  throw new Error(
-    `Failed to download ${filename}: OSS (${ossResult.error?.message ?? "unknown"}), GitHub (${ghResult.error?.message ?? "unknown"})`
-  );
-}
-__name(downloadWithFallback, "downloadWithFallback");
-async function verifyChecksum(actualHash, filename, versionPath) {
-  const response = await downloadWithFallback(versionPath, "SHA256SUMS");
-  const text = await response.text();
-  const requireSig = process.env["QWEN_REQUIRE_SIGNATURE"] === "1";
-  let sigResponse;
-  try {
-    sigResponse = await downloadWithFallback(versionPath, "SHA256SUMS.sig");
-  } catch (err) {
-    debugLogger6.debug("SHA256SUMS.sig not available:", err);
-  }
-  if (sigResponse) {
-    const sigContent = await sigResponse.text();
-    verifySignature(text, sigContent.trim());
-    debugLogger6.info("SHA256SUMS signature verified.");
-  } else if (requireSig) {
-    throw new Error(
-      "SHA256SUMS.sig not found and QWEN_REQUIRE_SIGNATURE=1 is set"
-    );
-  } else {
-    debugLogger6.warn(
-      "SHA256SUMS.sig not available \u2014 update integrity relies on SHA256 checksum only. Set QWEN_REQUIRE_SIGNATURE=1 to enforce signature verification."
-    );
-  }
-  const expectedLine = text.split("\n").find((line) => {
-    const parts = line.trim().split(/\s+/);
-    if (parts.length < 2) return false;
-    const name = parts[parts.length - 1].replace(/^\*/, "");
-    return name === filename;
-  });
-  if (!expectedLine) {
-    throw new Error(`No checksum found for ${filename} in SHA256SUMS`);
-  }
-  const expectedHash = expectedLine.trim().split(/\s+/)[0];
-  if (actualHash !== expectedHash) {
-    throw new Error(
-      `Checksum mismatch: expected ${expectedHash}, got ${actualHash}`
-    );
-  }
-}
-__name(verifyChecksum, "verifyChecksum");
-var MAX_DOWNLOAD_BYTES = 512 * 1024 * 1024;
-async function downloadToFile(versionPath, filename, destPath) {
-  const response = await downloadWithFallback(
-    versionPath,
-    filename,
-    ARCHIVE_TIMEOUT_MS
-  );
-  const body = response.body;
-  if (!body) throw new Error("Empty response body");
-  const contentLength = response.headers.get("content-length");
-  if (contentLength && parseInt(contentLength, 10) > MAX_DOWNLOAD_BYTES) {
-    await body.cancel().catch(() => {
-    });
-    throw new Error(
-      `Download too large: ${contentLength} bytes exceeds ${MAX_DOWNLOAD_BYTES} limit`
-    );
-  }
-  const hash = createHash("sha256");
-  let bytesWritten = 0;
-  const dest = fs5.createWriteStream(destPath);
-  const sizeGuard = new Transform({
-    transform(chunk, _encoding, callback) {
-      bytesWritten += chunk.length;
-      if (bytesWritten > MAX_DOWNLOAD_BYTES) {
-        callback(
-          new Error(`Download exceeded ${MAX_DOWNLOAD_BYTES} byte limit`)
-        );
-      } else {
-        hash.update(chunk);
-        callback(null, chunk);
-      }
-    }
-  });
-  await pipeline(Readable.fromWeb(body), sizeGuard, dest);
-  return hash.digest("hex");
-}
-__name(downloadToFile, "downloadToFile");
-function validateExtractedPaths(resolvedDest) {
-  const entries = fs5.readdirSync(resolvedDest, {
-    recursive: true,
-    withFileTypes: true
-  });
-  for (const entry of entries) {
-    const fullPath = path5.join(
-      String(entry.parentPath || entry.path),
-      entry.name
-    );
-    const resolved = fs5.realpathSync(fullPath);
-    if (!resolved.startsWith(resolvedDest + path5.sep) && resolved !== resolvedDest) {
-      fs5.rmSync(resolvedDest, { recursive: true, force: true });
-      throw new Error(
-        `Path traversal detected in archive: ${entry.name} resolves to ${resolved}`
-      );
-    }
-  }
-}
-__name(validateExtractedPaths, "validateExtractedPaths");
-function isSafeTarEntryPath(entryPath) {
-  if (entryPath.length === 0) return false;
-  if (path5.posix.isAbsolute(entryPath) || path5.win32.isAbsolute(entryPath)) {
-    return false;
-  }
-  return !entryPath.split(/[\\/]+/).includes("..");
-}
-__name(isSafeTarEntryPath, "isSafeTarEntryPath");
-async function extractArchive(archivePath, destDir, target) {
-  fs5.mkdirSync(destDir, { recursive: true });
-  if (target.startsWith("win")) {
-    await new Promise((resolve5, reject) => {
-      const ps = spawn2(
-        "powershell.exe",
-        [
-          "-NoProfile",
-          "-Command",
-          `Expand-Archive -Path '${escapePS(archivePath)}' -DestinationPath '${escapePS(destDir)}' -Force`
-        ],
-        { stdio: "ignore" }
-      );
-      ps.on(
-        "close",
-        (code) => code === 0 ? resolve5() : reject(new Error(`Expand-Archive exited with code ${code}`))
-      );
-      ps.on("error", reject);
-    });
-    const resolvedDest = fs5.realpathSync(destDir);
-    validateExtractedPaths(resolvedDest);
-  } else {
-    const resolvedDest = path5.resolve(destDir);
-    await So({
-      file: archivePath,
-      cwd: destDir,
-      preservePaths: false,
-      filter: /* @__PURE__ */ __name((p, entry) => {
-        if (!isSafeTarEntryPath(p)) return false;
-        if ("type" in entry && entry.type === "SymbolicLink" && "linkpath" in entry) {
-          const linkTarget = path5.resolve(
-            resolvedDest,
-            path5.dirname(p),
-            String(entry.linkpath)
-          );
-          if (!linkTarget.startsWith(resolvedDest + path5.sep) && linkTarget !== resolvedDest) {
-            return false;
-          }
-        }
-        return true;
-      }, "filter")
-    });
-    validateExtractedPaths(fs5.realpathSync(destDir));
-  }
-}
-__name(extractArchive, "extractArchive");
-function spawnAndCapture(command, args, timeoutMs) {
-  return new Promise((resolve5, reject) => {
-    let settled = false;
-    const child = execFile(
-      command,
-      args,
-      { timeout: timeoutMs },
-      (err, out, stderr) => {
-        if (settled) return;
-        settled = true;
-        if (err && ("killed" in err && err.killed || "signal" in err && err.signal)) {
-          reject(new Error("Smoke test timed out"));
-          return;
-        }
-        if (err) {
-          const exitCode = "code" in err && typeof err.code === "number" ? err.code : 1;
-          resolve5({ exitCode, stdout: out || "", stderr: stderr || "" });
-          return;
-        }
-        resolve5({ exitCode: 0, stdout: out || "", stderr: stderr || "" });
-      }
-    );
-    child.on("error", (e) => {
-      if (settled) return;
-      settled = true;
-      reject(e);
-    });
-  });
-}
-__name(spawnAndCapture, "spawnAndCapture");
-async function smokeTest(newInstallDir, target) {
-  const resolvedInstallDir = path5.resolve(newInstallDir);
-  const nodeBin = target.startsWith("win") ? path5.join(resolvedInstallDir, "node", "node.exe") : path5.join(resolvedInstallDir, "node", "bin", "node");
-  const cliBin = path5.join(resolvedInstallDir, "lib", "cli.js");
-  if (!fs5.existsSync(nodeBin)) {
-    throw new Error(`Smoke test failed: node binary not found at ${nodeBin}`);
-  }
-  if (!fs5.existsSync(cliBin)) {
-    throw new Error(`Smoke test failed: cli.js not found at ${cliBin}`);
-  }
-  const { exitCode, stdout, stderr } = await spawnAndCapture(
-    nodeBin,
-    [cliBin, "--version"],
-    1e4
-  );
-  if (exitCode !== 0) {
-    const detail = stderr.trim() ? `: ${stderr.trim()}` : "";
-    throw new Error(
-      `Smoke test failed: new binary exited with code ${exitCode}${detail}`
-    );
-  }
-  const version = stdout.trim();
-  if (!SEMVER_RE.test(version)) {
-    throw new Error(
-      `Smoke test failed: unexpected version output "${version}"`
-    );
-  }
-  debugLogger6.info(`Smoke test passed: ${version}`);
-}
-__name(smokeTest, "smokeTest");
-function acquireLock(lockPath) {
-  try {
-    fs5.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
-    return true;
-  } catch {
-    try {
-      const pidStr = fs5.readFileSync(lockPath, "utf-8").trim();
-      const pid = parseInt(pidStr, 10);
-      if (Number.isNaN(pid) || !isProcessAlive(pid)) {
-        fs5.unlinkSync(lockPath);
-        try {
-          fs5.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
-          return true;
-        } catch {
-          return false;
-        }
-      }
-    } catch {
-    }
-    return false;
-  }
-}
-__name(acquireLock, "acquireLock");
-function releaseLock(lockPath) {
-  try {
-    fs5.unlinkSync(lockPath);
-  } catch {
-  }
-}
-__name(releaseLock, "releaseLock");
-function cleanupEmptyStandaloneDir(standaloneDir) {
-  const manifestPath = path5.join(standaloneDir, "manifest.json");
-  if (fs5.existsSync(standaloneDir) && !fs5.existsSync(manifestPath)) {
-    fs5.rmSync(standaloneDir, { recursive: true, force: true });
-  }
-}
-__name(cleanupEmptyStandaloneDir, "cleanupEmptyStandaloneDir");
-var UNSAFE_SHELL_CHARS = /["`$\\;\n\r]/;
-var UNSAFE_CMD_CHARS = /[&|<>^%!"`\n\r]/;
-function assertSafeForShellEmbed(p, context) {
-  if (UNSAFE_SHELL_CHARS.test(p)) {
-    throw new Error(
-      `${context} contains characters unsafe for shell embedding: ${p}`
-    );
-  }
-}
-__name(assertSafeForShellEmbed, "assertSafeForShellEmbed");
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-__name(isProcessAlive, "isProcessAlive");
-function atomicReplace(standaloneDir, newDir, lockPath) {
-  const oldDir = `${standaloneDir}.old`;
-  const pendingDir = `${standaloneDir}.new`;
-  if (fs5.existsSync(oldDir)) {
-    fs5.rmSync(oldDir, { recursive: true, force: true });
-  }
-  if (os3.platform() === "win32") {
-    if (UNSAFE_CMD_CHARS.test(standaloneDir) || UNSAFE_CMD_CHARS.test(oldDir) || UNSAFE_CMD_CHARS.test(pendingDir)) {
-      throw new Error(
-        "Installation path contains characters unsafe for deferred update script"
-      );
-    }
-    if (fs5.existsSync(pendingDir)) {
-      fs5.rmSync(pendingDir, { recursive: true, force: true });
-    }
-    fs5.renameSync(newDir, pendingDir);
-    const lockFile = lockPath;
-    const logFile = path5.join(path5.dirname(standaloneDir), "qwen-update.log");
-    const script = [
-      "@echo off",
-      "set /a TRIES=0",
-      ":wait",
-      "set /a TRIES+=1",
-      "if %TRIES% GTR 30 goto proceed",
-      `tasklist /FI "PID eq ${process.pid}" 2>nul | find "${process.pid}" >nul && (timeout /t 1 >nul & goto wait)`,
-      ":proceed",
-      `echo [%DATE% %TIME%] starting swap >> "${logFile}"`,
-      `move /Y "${standaloneDir}" "${oldDir}"`,
-      "if errorlevel 1 goto move1_failed",
-      `move /Y "${pendingDir}" "${standaloneDir}"`,
-      "if errorlevel 1 goto move2_failed",
-      `echo [%DATE% %TIME%] swap completed >> "${logFile}"`,
-      "goto cleanup",
-      ":move1_failed",
-      `echo [%DATE% %TIME%] ERROR: failed to rename install to .old (errorlevel %errorlevel%) >> "${logFile}"`,
-      "goto cleanup",
-      ":move2_failed",
-      `echo [%DATE% %TIME%] ERROR: failed to promote .new; rolling back >> "${logFile}"`,
-      `move /Y "${oldDir}" "${standaloneDir}"`,
-      "if errorlevel 1 (",
-      `  echo [%DATE% %TIME%] CRITICAL: rollback also failed; manual recovery: move "${oldDir}" "${standaloneDir}" >> "${logFile}"`,
-      ") else (",
-      `  echo [%DATE% %TIME%] rollback succeeded >> "${logFile}"`,
-      ")",
-      ":cleanup",
-      `del /F /Q "${lockFile}" 2>nul`,
-      `del "%~f0"`
-    ].join("\r\n");
-    const scriptPath = path5.join(
-      path5.dirname(standaloneDir),
-      "qwen-update.bat"
-    );
-    fs5.writeFileSync(scriptPath, script);
-    spawn2("cmd.exe", ["/c", scriptPath], {
-      detached: true,
-      stdio: "ignore",
-      windowsHide: true
-    }).unref();
-    return "deferred";
-  } else {
-    fs5.renameSync(standaloneDir, oldDir);
-    try {
-      fs5.renameSync(newDir, standaloneDir);
-    } catch (promoteErr) {
-      try {
-        fs5.renameSync(oldDir, standaloneDir);
-      } catch (rollbackErr) {
-        const detail = `Standalone update failed AND rollback failed.
-Original error: ${promoteErr.message}
-Rollback error: ${rollbackErr.message}
-Manual recovery: mv "${oldDir}" "${standaloneDir}"`;
-        throw new Error(detail);
-      }
-      throw promoteErr;
-    }
-    return "done";
-  }
-}
-__name(atomicReplace, "atomicReplace");
-function ensureBinWrapper(standaloneDir, target) {
-  const binDir = path5.join(path5.dirname(standaloneDir), "..", "bin");
-  try {
-    fs5.mkdirSync(binDir, { recursive: true });
-    if (target.startsWith("win")) {
-      if (UNSAFE_CMD_CHARS.test(standaloneDir)) {
-        throw new Error(
-          "standaloneDir contains characters unsafe for cmd.exe wrapper"
-        );
-      }
-      const wrapperPath = path5.join(binDir, "qwen.cmd");
-      if (!fs5.existsSync(wrapperPath)) {
-        const content = `@echo off\r
-call "${standaloneDir}\\bin\\qwen.cmd" %*\r
-`;
-        fs5.writeFileSync(wrapperPath, content);
-      }
-    } else {
-      assertSafeForShellEmbed(standaloneDir, "standaloneDir");
-      const wrapperPath = path5.join(binDir, "qwen");
-      if (!fs5.existsSync(wrapperPath)) {
-        const content = `#!/bin/sh
-exec "${standaloneDir}/bin/qwen" "$@"
-`;
-        fs5.writeFileSync(wrapperPath, content, { mode: 493 });
-      }
-      ensurePathInShellRc(binDir);
-    }
-  } catch (err) {
-    debugLogger6.warn("Failed to create bin wrapper:", err);
-  }
-}
-__name(ensureBinWrapper, "ensureBinWrapper");
-function ensurePathInShellRc(binDir) {
-  assertSafeForShellEmbed(binDir, "binDir");
-  const shell = process.env["SHELL"] || "";
-  let rcFile = null;
-  const home = process.env["HOME"] || os3.homedir();
-  if (shell.endsWith("/zsh")) {
-    rcFile = path5.join(home, ".zshrc");
-  } else if (shell.endsWith("/bash")) {
-    const bashrc = path5.join(home, ".bashrc");
-    const profile = path5.join(home, ".bash_profile");
-    if (os3.platform() === "darwin") {
-      rcFile = fs5.existsSync(profile) ? profile : bashrc;
-    } else {
-      rcFile = bashrc;
-    }
-  } else if (shell.endsWith("/fish")) {
-    rcFile = path5.join(home, ".config", "fish", "config.fish");
-  }
-  if (!rcFile) return;
-  try {
-    const content = fs5.existsSync(rcFile) ? fs5.readFileSync(rcFile, "utf-8") : "";
-    const marker = "# Added by Qwen Code standalone installer";
-    if (content.includes(marker)) return;
-    const exportLine = shell.endsWith("/fish") ? `
-${marker}
-fish_add_path "${binDir}"
-` : `
-${marker}
-export PATH="${binDir}:$PATH"
-`;
-    fs5.appendFileSync(rcFile, exportLine);
-    debugLogger6.info(`Added ${binDir} to ${rcFile}`);
-  } catch (err) {
-    debugLogger6.debug("Failed to update shell rc:", err);
-  }
-}
-__name(ensurePathInShellRc, "ensurePathInShellRc");
-function detectTarget() {
-  const platform3 = os3.platform();
-  const arch2 = os3.arch();
-  if (platform3 === "darwin") {
-    return arch2 === "arm64" ? "darwin-arm64" : "darwin-x64";
-  }
-  if (platform3 === "win32") return "win-x64";
-  if (platform3 === "linux") {
-    if (arch2 === "arm64") return "linux-arm64";
-    if (arch2 === "x64") return "linux-x64";
-  }
-  throw new Error(`Unsupported platform: ${platform3}-${arch2}`);
-}
-__name(detectTarget, "detectTarget");
-async function performStandaloneUpdate(standaloneDir, newVersion) {
-  const versionPath = normalizeVersion(newVersion);
-  let target;
-  let isFirstTimeMigration = false;
-  const manifestPath = path5.join(standaloneDir, "manifest.json");
-  if (fs5.existsSync(manifestPath)) {
-    const manifestRaw = fs5.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(manifestRaw);
-    target = manifest.target ?? detectTarget();
-  } else if (fs5.existsSync(standaloneDir)) {
-    throw new Error(
-      `${standaloneDir} exists but is not a Qwen Code standalone install. Remove it manually to proceed.`
-    );
-  } else {
-    target = detectTarget();
-    isFirstTimeMigration = true;
-  }
-  validateTarget(target);
-  const filename = archiveFilename(target);
-  const parentDir = path5.dirname(standaloneDir);
-  fs5.mkdirSync(parentDir, { recursive: true });
-  const lockPath = path5.join(parentDir, ".qwen-update.lock");
-  if (!acquireLock(lockPath)) {
-    throw new Error("Another update is already in progress");
-  }
-  if (isFirstTimeMigration) {
-    fs5.mkdirSync(standaloneDir, { recursive: true });
-  }
-  const tempDir = fs5.mkdtempSync(path5.join(os3.tmpdir(), "qwen-code-update-"));
-  let extractDir;
-  let updateResult;
-  try {
-    extractDir = fs5.mkdtempSync(path5.join(parentDir, ".qwen-code-update-"));
-  } catch (err) {
-    fs5.rmSync(tempDir, { recursive: true, force: true });
-    releaseLock(lockPath);
-    throw err;
-  }
-  try {
-    const archivePath = path5.join(tempDir, filename);
-    debugLogger6.info(`Downloading ${filename} (${versionPath})...`);
-    const archiveHash = await downloadToFile(
-      versionPath,
-      filename,
-      archivePath
-    );
-    debugLogger6.info("Verifying checksum...");
-    await verifyChecksum(archiveHash, filename, versionPath);
-    debugLogger6.info("Extracting archive...");
-    await extractArchive(archivePath, extractDir, target);
-    const newInstallDir = path5.join(extractDir, "qwen-code");
-    if (!fs5.existsSync(path5.join(newInstallDir, "manifest.json"))) {
-      throw new Error(
-        "Extracted archive does not contain expected qwen-code directory"
-      );
-    }
-    debugLogger6.info("Running smoke test...");
-    await smokeTest(newInstallDir, target);
-    debugLogger6.info("Replacing installation...");
-    updateResult = atomicReplace(standaloneDir, newInstallDir, lockPath);
-    const oldDir = `${standaloneDir}.old`;
-    if (fs5.existsSync(oldDir)) {
-      if (isFirstTimeMigration) {
-        fs5.rmSync(oldDir, { recursive: true, force: true });
-      } else {
-        try {
-          const oldManifestPath = path5.join(oldDir, "manifest.json");
-          let oldVersion = "unknown";
-          if (fs5.existsSync(oldManifestPath)) {
-            const oldManifest = JSON.parse(
-              fs5.readFileSync(oldManifestPath, "utf-8")
-            );
-            oldVersion = oldManifest.version || "unknown";
-          }
-          const rollbackInfo = {
-            preservedVersion: oldVersion,
-            updatedTo: versionPath,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            reason: "auto-update"
-          };
-          fs5.writeFileSync(
-            path5.join(oldDir, ".qwen-rollback-info.json"),
-            JSON.stringify(rollbackInfo, null, 2)
-          );
-        } catch {
-        }
-      }
-    }
-    ensureBinWrapper(standaloneDir, target);
-    debugLogger6.info("Standalone update complete.");
-    return updateResult;
-  } catch (err) {
-    const pendingDir = `${standaloneDir}.new`;
-    if (fs5.existsSync(pendingDir)) {
-      fs5.rmSync(pendingDir, { recursive: true, force: true });
-    }
-    cleanupEmptyStandaloneDir(standaloneDir);
-    throw err;
-  } finally {
-    if (updateResult !== "deferred") {
-      releaseLock(lockPath);
-    }
-    try {
-      fs5.rmSync(tempDir, { recursive: true, force: true });
-    } catch {
-    }
-    try {
-      fs5.rmSync(extractDir, { recursive: true, force: true });
-    } catch {
-    }
-  }
-}
-__name(performStandaloneUpdate, "performStandaloneUpdate");
-function rollbackStandaloneUpdate(standaloneDir) {
-  const lockPath = path5.join(path5.dirname(standaloneDir), ".qwen-update.lock");
-  try {
-    const pidStr = fs5.readFileSync(lockPath, "utf-8").trim();
-    const pid = parseInt(pidStr, 10);
-    if (!Number.isNaN(pid) && isProcessAlive(pid)) {
-      return {
-        ok: false,
-        reason: "rename-failed",
-        detail: "An auto-update is currently in progress. Wait for it to finish before rolling back."
-      };
-    }
-  } catch {
-  }
-  const oldDir = `${standaloneDir}.old`;
-  if (!fs5.existsSync(oldDir)) {
-    return { ok: false, reason: "no-old", detail: `${oldDir} does not exist` };
-  }
-  const oldManifest = path5.join(oldDir, "manifest.json");
-  if (!fs5.existsSync(oldManifest)) {
-    debugLogger6.error("Rollback failed: .old directory has no manifest.json");
-    return {
-      ok: false,
-      reason: "no-manifest",
-      detail: `${oldDir}/manifest.json missing \u2014 .old may be corrupt`
-    };
-  }
-  const failedDir = `${standaloneDir}.failed`;
-  try {
-    if (fs5.existsSync(failedDir)) {
-      fs5.rmSync(failedDir, { recursive: true, force: true });
-    }
-    fs5.renameSync(standaloneDir, failedDir);
-    fs5.renameSync(oldDir, standaloneDir);
-    debugLogger6.info("Rollback successful.");
-    try {
-      fs5.rmSync(failedDir, { recursive: true, force: true });
-    } catch {
-      debugLogger6.debug(`Leftover .failed dir at ${failedDir}, safe to delete`);
-    }
-    return { ok: true };
-  } catch (err) {
-    debugLogger6.error("Rollback failed:", err);
-    if (!fs5.existsSync(standaloneDir) && fs5.existsSync(failedDir)) {
-      try {
-        fs5.renameSync(failedDir, standaloneDir);
-        return {
-          ok: false,
-          reason: "rename-failed",
-          detail: `Filesystem error: ${err.message}. Current installation was restored automatically.`
-        };
-      } catch {
-      }
-    }
-    return {
-      ok: false,
-      reason: "rename-failed",
-      detail: `Filesystem error: ${err.message}. Manual recovery: mv "${oldDir}" "${standaloneDir}"`
-    };
-  }
-}
-__name(rollbackStandaloneUpdate, "rollbackStandaloneUpdate");
-
-// packages/cli/src/utils/installationInfo.ts
-init_esbuild_shims();
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
-import * as childProcess from "node:child_process";
-var debugLogger7 = createDebugLogger("INSTALLATION_INFO");
-var STANDALONE_UNIX_INSTALLER = "https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.sh";
-var STANDALONE_WINDOWS_INSTALLER = "https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.ps1";
-function getInstallationInfo(projectRoot, isAutoUpdateEnabled) {
-  const cliPath = process.argv[1];
-  if (!cliPath) {
-    return { packageManager: "unknown" /* UNKNOWN */, isGlobal: false };
-  }
-  try {
-    const realPath = fs6.realpathSync(cliPath).replace(/\\/g, "/");
-    const normalizedProjectRoot = projectRoot?.replace(/\\/g, "/");
-    const isGit = isGitRepository(process.cwd());
-    if (isGit && normalizedProjectRoot && isSamePathOrInside(realPath, normalizedProjectRoot) && !realPath.includes("/node_modules/")) {
-      return {
-        packageManager: "unknown" /* UNKNOWN */,
-        // Not managed by a package manager in this sense
-        isGlobal: false,
-        updateMessage: 'Running from a local git clone. Please update with "git pull".'
-      };
-    }
-    if (realPath.includes("/.npm/_npx") || realPath.includes("/npm/_npx")) {
-      return {
-        packageManager: "npx" /* NPX */,
-        isGlobal: false,
-        updateMessage: "Running via npx, update not applicable."
-      };
-    }
-    if (realPath.includes("/.pnpm/_pnpx")) {
-      return {
-        packageManager: "pnpx" /* PNPX */,
-        isGlobal: false,
-        updateMessage: "Running via pnpx, update not applicable."
-      };
-    }
-    const standaloneInfo = getStandaloneInstallInfo(
-      realPath,
-      isAutoUpdateEnabled
-    );
-    if (standaloneInfo) {
-      return standaloneInfo;
-    }
-    if (process.platform === "darwin") {
-      try {
-        childProcess.execSync('brew list -1 | grep -q "^qwen-code$"', {
-          stdio: "ignore"
-        });
-        return {
-          packageManager: "homebrew" /* HOMEBREW */,
-          isGlobal: true,
-          updateMessage: 'Installed via Homebrew. Please update with "brew upgrade".'
-        };
-      } catch (_error) {
-      }
-    }
-    if (realPath.includes("/.pnpm/global")) {
-      const updateCommand2 = "pnpm add -g @qwen-code/qwen-code@latest";
-      return {
-        packageManager: "pnpm" /* PNPM */,
-        isGlobal: true,
-        updateCommand: updateCommand2,
-        updateMessage: isAutoUpdateEnabled ? "Installed with pnpm. Attempting to automatically update now..." : `Please run ${updateCommand2} to update`
-      };
-    }
-    if (realPath.includes("/.yarn/global")) {
-      const updateCommand2 = "yarn global add @qwen-code/qwen-code@latest";
-      return {
-        packageManager: "yarn" /* YARN */,
-        isGlobal: true,
-        updateCommand: updateCommand2,
-        updateMessage: isAutoUpdateEnabled ? "Installed with yarn. Attempting to automatically update now..." : `Please run ${updateCommand2} to update`
-      };
-    }
-    if (realPath.includes("/.bun/install/cache")) {
-      return {
-        packageManager: "bunx" /* BUNX */,
-        isGlobal: false,
-        updateMessage: "Running via bunx, update not applicable."
-      };
-    }
-    if (realPath.includes("/.bun/bin")) {
-      const updateCommand2 = "bun add -g @qwen-code/qwen-code@latest";
-      return {
-        packageManager: "bun" /* BUN */,
-        isGlobal: true,
-        updateCommand: updateCommand2,
-        updateMessage: isAutoUpdateEnabled ? "Installed with bun. Attempting to automatically update now..." : `Please run ${updateCommand2} to update`
-      };
-    }
-    if (normalizedProjectRoot && isSamePathOrInside(realPath, `${normalizedProjectRoot}/node_modules`)) {
-      let pm = "npm" /* NPM */;
-      if (fs6.existsSync(path6.join(projectRoot, "yarn.lock"))) {
-        pm = "yarn" /* YARN */;
-      } else if (fs6.existsSync(path6.join(projectRoot, "pnpm-lock.yaml"))) {
-        pm = "pnpm" /* PNPM */;
-      } else if (fs6.existsSync(path6.join(projectRoot, "bun.lockb"))) {
-        pm = "bun" /* BUN */;
-      }
-      return {
-        packageManager: pm,
-        isGlobal: false,
-        updateMessage: "Locally installed. Please update via your project's package.json."
-      };
-    }
-    const npmPackageDir = path6.dirname(path6.dirname(realPath));
-    let npmPrefixWritable = false;
-    try {
-      fs6.accessSync(npmPackageDir, fs6.constants.W_OK);
-      npmPrefixWritable = true;
-    } catch {
-    }
-    if (!npmPrefixWritable) {
-      return {
-        packageManager: "npm" /* NPM */,
-        isGlobal: true,
-        updateMessage: "Update requires sudo. Please run: sudo npm install -g @qwen-code/qwen-code@latest"
-      };
-    }
-    const updateCommand = "npm install -g @qwen-code/qwen-code@latest";
-    return {
-      packageManager: "npm" /* NPM */,
-      isGlobal: true,
-      updateCommand,
-      updateMessage: isAutoUpdateEnabled ? "Installed with npm. Attempting to automatically update now..." : `Please run ${updateCommand} to update`
-    };
-  } catch (error) {
-    debugLogger7.error("Failed to detect installation info:", error);
-    return { packageManager: "unknown" /* UNKNOWN */, isGlobal: false };
-  }
-}
-__name(getInstallationInfo, "getInstallationInfo");
-function stripTrailingSlashes(value) {
-  return value.replace(/\/+$/, "") || "/";
-}
-__name(stripTrailingSlashes, "stripTrailingSlashes");
-function isSamePathOrInside(candidate, parent) {
-  const normalizedCandidate = stripTrailingSlashes(candidate);
-  const normalizedParent = stripTrailingSlashes(parent);
-  if (normalizedParent === "/") {
-    return normalizedCandidate === "/" || normalizedCandidate.startsWith("/");
-  }
-  return normalizedCandidate === normalizedParent || normalizedCandidate.startsWith(`${normalizedParent}/`);
-}
-__name(isSamePathOrInside, "isSamePathOrInside");
-function getStandaloneInstallInfo(realPath, isAutoUpdateEnabled) {
-  const installDir = standaloneInstallDirForCliPath(realPath);
-  if (!installDir || !isStandaloneInstallDir(installDir)) {
-    return null;
-  }
-  const updateCommand = process.platform === "win32" ? `powershell -ExecutionPolicy Bypass -c "irm ${STANDALONE_WINDOWS_INSTALLER} | iex"` : `curl -fsSL ${STANDALONE_UNIX_INSTALLER} | bash`;
-  return {
-    packageManager: "standalone" /* STANDALONE */,
-    isGlobal: true,
-    isStandalone: true,
-    standaloneDir: installDir,
-    updateMessage: isAutoUpdateEnabled ? "Standalone install detected. Attempting to automatically update now..." : `Standalone install detected. Please rerun the standalone installer to update: ${updateCommand}`
-  };
-}
-__name(getStandaloneInstallInfo, "getStandaloneInstallInfo");
-function standaloneInstallDirForCliPath(realPath) {
-  const normalized = realPath.replace(/\\/g, "/");
-  const suffix = "/lib/cli.js";
-  if (!normalized.endsWith(suffix)) {
-    return null;
-  }
-  return realPath.slice(0, -suffix.length);
-}
-__name(standaloneInstallDirForCliPath, "standaloneInstallDirForCliPath");
-function isStandaloneInstallDir(installDir) {
-  try {
-    const manifestPath = path6.join(installDir, "manifest.json");
-    if (!fs6.existsSync(manifestPath)) {
-      return false;
-    }
-    const manifest = JSON.parse(fs6.readFileSync(manifestPath, "utf8"));
-    if (manifest.name !== "@qwen-code/qwen-code" || typeof manifest.target !== "string" || !isStandaloneTargetForCurrentPlatform(manifest.target)) {
-      return false;
-    }
-    const qwenBin = process.platform === "win32" ? path6.join(installDir, "bin", "qwen.cmd") : path6.join(installDir, "bin", "qwen");
-    const nodeBin = process.platform === "win32" ? path6.join(installDir, "node", "node.exe") : path6.join(installDir, "node", "bin", "node");
-    return fs6.existsSync(qwenBin) && fs6.existsSync(nodeBin) && isStandaloneRuntimeFile(qwenBin) && isStandaloneRuntimeFile(nodeBin);
-  } catch (err) {
-    debugLogger7.error("Standalone detection failed:", installDir, err);
-    return false;
-  }
-}
-__name(isStandaloneInstallDir, "isStandaloneInstallDir");
-function isStandaloneTargetForCurrentPlatform(target) {
-  switch (process.platform) {
-    case "darwin":
-      return /^darwin-(arm64|x64)$/.test(target);
-    case "linux":
-      return /^linux-(arm64|x64)$/.test(target);
-    case "win32":
-      return /^win-(arm64|x64)$/.test(target);
-    default:
-      return false;
-  }
-}
-__name(isStandaloneTargetForCurrentPlatform, "isStandaloneTargetForCurrentPlatform");
-function isStandaloneRuntimeFile(filePath) {
-  const stats = fs6.lstatSync(filePath);
-  if (!stats.isFile() || stats.isSymbolicLink()) {
-    return false;
-  }
-  return process.platform === "win32" || (stats.mode & 73) !== 0;
-}
-__name(isStandaloneRuntimeFile, "isStandaloneRuntimeFile");
-
 // packages/cli/src/ui/commands/doctorCommand.ts
 var MEMORY_SUBCOMMAND = "memory";
 var CPU_PROFILE_SUBCOMMAND = "cpu-profile";
@@ -5921,14 +5051,14 @@ async function cpuProfileDoctorAction(context, args = "") {
       })
     });
   }
-  await new Promise((resolve5) => {
-    const timer = setTimeout(resolve5, durationSec * 1e3);
+  await new Promise((resolve4) => {
+    const timer = setTimeout(resolve4, durationSec * 1e3);
     if (abortSignal) {
       abortSignal.addEventListener(
         "abort",
         () => {
           clearTimeout(timer);
-          resolve5();
+          resolve4();
         },
         { once: true }
       );
@@ -6128,10 +5258,10 @@ var effortCommand = {
 
 // packages/cli/src/ui/commands/exportCommand.ts
 init_esbuild_shims();
-import * as fs7 from "node:fs/promises";
-import path7 from "node:path";
+import * as fs5 from "node:fs/promises";
+import path5 from "node:path";
 var EXPORT_DIR_OUT_OF_CWD = "Export directory must be within the project working directory.";
-var debugLogger8 = createDebugLogger("EXPORT_COMMAND");
+var debugLogger6 = createDebugLogger("EXPORT_COMMAND");
 function formatExportTargetContext(target) {
   return `target: "${target.outputDir}", cwd: "${target.resolvedCwd}"`;
 }
@@ -6143,16 +5273,16 @@ __name(formatMissingCwdError, "formatMissingCwdError");
 function resolveExportTarget(cwd, args, extension) {
   const filename = generateExportFilename(extension);
   const outputDirArg = args.trim();
-  const resolvedCwd = path7.resolve(cwd);
-  const outputDir = outputDirArg ? path7.resolve(resolvedCwd, outputDirArg) : resolvedCwd;
-  const filepath = path7.join(outputDir, filename);
+  const resolvedCwd = path5.resolve(cwd);
+  const outputDir = outputDirArg ? path5.resolve(resolvedCwd, outputDirArg) : resolvedCwd;
+  const filepath = path5.join(outputDir, filename);
   const isDefaultOutputDir = outputDir === resolvedCwd;
   const isInsideCwd = isSubpath(resolvedCwd, outputDir);
   const outputDirKind = outputDirArg && !isDefaultOutputDir ? "custom" : "default";
   return {
     filepath,
     outputDir,
-    displayPath: isDefaultOutputDir ? filename : path7.join(outputDirArg, filename),
+    displayPath: isDefaultOutputDir ? filename : path5.join(outputDirArg, filename),
     resolvedCwd,
     outputDirKind,
     isInsideCwd
@@ -6160,7 +5290,7 @@ function resolveExportTarget(cwd, args, extension) {
 }
 __name(resolveExportTarget, "resolveExportTarget");
 async function validateExportTargetWithinCwd(target) {
-  debugLogger8.debug(
+  debugLogger6.debug(
     "Validating export target realpath:",
     formatExportTargetContext(target)
   );
@@ -6168,12 +5298,12 @@ async function validateExportTargetWithinCwd(target) {
   let realOutputDir;
   try {
     [realCwd, realOutputDir] = await Promise.all([
-      fs7.realpath(target.resolvedCwd),
-      fs7.realpath(target.outputDir)
+      fs5.realpath(target.resolvedCwd),
+      fs5.realpath(target.outputDir)
     ]);
   } catch (error) {
     if (error.code === "ENOENT") {
-      debugLogger8.debug(
+      debugLogger6.debug(
         "Export target realpath validation failed: missing path",
         formatExportTargetContext(target)
       );
@@ -6188,7 +5318,7 @@ async function validateExportTargetWithinCwd(target) {
     throw error;
   }
   if (!isSubpath(realCwd, realOutputDir)) {
-    debugLogger8.debug("Export target realpath escaped cwd:", {
+    debugLogger6.debug("Export target realpath escaped cwd:", {
       realCwd,
       realOutputDir,
       target
@@ -6206,24 +5336,24 @@ async function validateExportTargetWithinCwd(target) {
 __name(validateExportTargetWithinCwd, "validateExportTargetWithinCwd");
 async function realpathNearestExisting(outputDir, resolvedCwd) {
   let currentPath = outputDir;
-  debugLogger8.debug("Resolving nearest existing export parent:", {
+  debugLogger6.debug("Resolving nearest existing export parent:", {
     outputDir,
     resolvedCwd
   });
   while (isSubpath(resolvedCwd, currentPath)) {
     try {
-      const realCurrentPath = await fs7.realpath(currentPath);
-      debugLogger8.debug("Resolved nearest existing export parent:", {
+      const realCurrentPath = await fs5.realpath(currentPath);
+      debugLogger6.debug("Resolved nearest existing export parent:", {
         currentPath,
         realCurrentPath
       });
       return realCurrentPath;
     } catch (error) {
       if (error.code !== "ENOENT") {
-        debugLogger8.debug("Failed to resolve existing export parent:", error);
+        debugLogger6.debug("Failed to resolve existing export parent:", error);
         throw error;
       }
-      const parentPath = path7.dirname(currentPath);
+      const parentPath = path5.dirname(currentPath);
       if (parentPath === currentPath) {
         break;
       }
@@ -6234,13 +5364,13 @@ async function realpathNearestExisting(outputDir, resolvedCwd) {
 }
 __name(realpathNearestExisting, "realpathNearestExisting");
 async function validateExistingExportParentWithinCwd(target) {
-  debugLogger8.debug(
+  debugLogger6.debug(
     "Validating existing export parent realpath:",
     formatExportTargetContext(target)
   );
   let realCwd;
   try {
-    realCwd = await fs7.realpath(target.resolvedCwd);
+    realCwd = await fs5.realpath(target.resolvedCwd);
   } catch (error) {
     if (error.code === "ENOENT") {
       throw new Error(formatMissingCwdError(target.resolvedCwd));
@@ -6252,7 +5382,7 @@ async function validateExistingExportParentWithinCwd(target) {
     target.resolvedCwd
   );
   if (!isSubpath(realCwd, realExistingParent)) {
-    debugLogger8.debug("Existing export parent escaped cwd:", {
+    debugLogger6.debug("Existing export parent escaped cwd:", {
       realCwd,
       realExistingParent,
       target
@@ -6288,7 +5418,7 @@ async function exportSessionAction(context, args, exportFormat) {
   }
   const target = resolveExportTarget(cwd, args, exportFormat.extension);
   const targetFilepath = target.filepath;
-  debugLogger8.debug("Resolved export target:", {
+  debugLogger6.debug("Resolved export target:", {
     format: exportFormat.displayName,
     cwd,
     outputDirArg: args.trim(),
@@ -6297,7 +5427,7 @@ async function exportSessionAction(context, args, exportFormat) {
     filepath: target.filepath
   });
   if (!target.isInsideCwd) {
-    debugLogger8.debug(
+    debugLogger6.debug(
       "Export target rejected before realpath validation:",
       formatExportTargetContext(target)
     );
@@ -6314,17 +5444,17 @@ async function exportSessionAction(context, args, exportFormat) {
     if (initialValidationError) {
       return initialValidationError;
     }
-    debugLogger8.debug("Export target validation passed:", {
+    debugLogger6.debug("Export target validation passed:", {
       format: exportFormat.displayName,
       outputDir: target.outputDir,
       outputDirKind: target.outputDirKind
     });
     const sessionService = new SessionService(cwd);
     const sessionId = config.getSessionId();
-    debugLogger8.debug("Loading session for export:", { sessionId, cwd });
+    debugLogger6.debug("Loading session for export:", { sessionId, cwd });
     const sessionData = await sessionService.loadSession(sessionId);
     if (!sessionData) {
-      debugLogger8.debug("No active session found for export:", {
+      debugLogger6.debug("No active session found for export:", {
         sessionId,
         cwd
       });
@@ -6344,12 +5474,12 @@ async function exportSessionAction(context, args, exportFormat) {
     const content = exportFormat.format(normalizedData);
     if (target.outputDirKind === "custom") {
       try {
-        debugLogger8.debug("Creating export directory:", {
+        debugLogger6.debug("Creating export directory:", {
           outputDir: target.outputDir
         });
-        await fs7.mkdir(target.outputDir, { recursive: true, mode: 448 });
+        await fs5.mkdir(target.outputDir, { recursive: true, mode: 448 });
       } catch (error) {
-        debugLogger8.debug("Failed to create export directory:", error);
+        debugLogger6.debug("Failed to create export directory:", error);
         return {
           type: "message",
           messageType: "error",
@@ -6363,7 +5493,7 @@ async function exportSessionAction(context, args, exportFormat) {
         return writeValidationError;
       }
     } catch (error) {
-      debugLogger8.debug("Export path validation failed before write:", error);
+      debugLogger6.debug("Export path validation failed before write:", error);
       return {
         type: "message",
         messageType: "error",
@@ -6371,26 +5501,26 @@ async function exportSessionAction(context, args, exportFormat) {
       };
     }
     try {
-      debugLogger8.debug("Writing export file:", {
+      debugLogger6.debug("Writing export file:", {
         format: exportFormat.displayName,
         filepath: target.filepath
       });
-      await fs7.writeFile(target.filepath, content, {
+      await fs5.writeFile(target.filepath, content, {
         encoding: "utf-8",
         mode: 384
       });
-      await fs7.chmod(target.filepath, 384).catch((error) => {
-        debugLogger8.debug("Failed to tighten export file permissions:", error);
+      await fs5.chmod(target.filepath, 384).catch((error) => {
+        debugLogger6.debug("Failed to tighten export file permissions:", error);
       });
     } catch (error) {
-      debugLogger8.debug("Failed to write export file:", error);
+      debugLogger6.debug("Failed to write export file:", error);
       return {
         type: "message",
         messageType: "error",
         content: `Failed to export session: ${error instanceof Error ? error.message : String(error)} (${exportFormat.displayName} target: "${targetFilepath}")`
       };
     }
-    debugLogger8.debug("Session export completed:", {
+    debugLogger6.debug("Session export completed:", {
       format: exportFormat.displayName,
       filepath: target.filepath
     });
@@ -6400,7 +5530,7 @@ async function exportSessionAction(context, args, exportFormat) {
       content: `Session exported to ${exportFormat.displayName}: ${target.displayPath}`
     };
   } catch (error) {
-    debugLogger8.debug("Session export failed:", {
+    debugLogger6.debug("Session export failed:", {
       format: exportFormat.displayName,
       target,
       error
@@ -6496,7 +5626,7 @@ var exportCommand = {
 
 // packages/cli/src/ui/commands/forkCommand.ts
 init_esbuild_shims();
-var debugLogger9 = createDebugLogger("FORK_COMMAND");
+var debugLogger7 = createDebugLogger("FORK_COMMAND");
 function deriveForkDescription(directive) {
   const oneLine = directive.replace(/\s+/g, " ").trim();
   return oneLine.length > 60 ? `${oneLine.slice(0, 57)}\u2026` : oneLine;
@@ -6552,7 +5682,7 @@ var forkCommand = {
     try {
       hasHistory = (config.getGeminiClient().getHistoryShallow() ?? []).length > 0;
     } catch (error) {
-      debugLogger9.debug("Failed to read history before /fork:", error);
+      debugLogger7.debug("Failed to read history before /fork:", error);
       hasHistory = false;
     }
     if (!hasHistory) {
@@ -6612,7 +5742,7 @@ var forkCommand = {
         ]
       });
     } catch (error) {
-      debugLogger9.debug("Failed to record fork event in history:", error);
+      debugLogger7.debug("Failed to record fork event in history:", error);
     }
     return {
       type: "message",
@@ -6626,7 +5756,7 @@ var forkCommand = {
 
 // packages/cli/src/ui/commands/extensionsCommand.ts
 init_esbuild_shims();
-var debugLogger10 = createDebugLogger("EXTENSIONS_COMMAND");
+var debugLogger8 = createDebugLogger("EXTENSIONS_COMMAND");
 var EXTENSION_EXPLORE_URL = {
   Gemini: "https://geminicli.com/extensions/",
   ClaudeCode: "https://claudemarketplaces.com/"
@@ -6789,7 +5919,7 @@ async function installAction(context, args) {
   }
   const extensionManager = context.services.config?.getExtensionManager();
   if (!(extensionManager instanceof ExtensionManager)) {
-    debugLogger10.error(
+    debugLogger8.error(
       `Cannot ${context.invocation?.name} extensions in this environment`
     );
     return;
@@ -7727,7 +6857,7 @@ var hooksCommand = {
 
 // packages/cli/src/ui/commands/ideCommand.ts
 init_esbuild_shims();
-import path8 from "node:path";
+import path6 from "node:path";
 function getIdeStatusMessage(ideClient) {
   const connection = ideClient.getConnectionStatus();
   switch (connection.status) {
@@ -7757,13 +6887,13 @@ __name(getIdeStatusMessage, "getIdeStatusMessage");
 function formatFileList(openFiles) {
   const basenameCounts = /* @__PURE__ */ new Map();
   for (const file of openFiles) {
-    const basename3 = path8.basename(file.path);
+    const basename3 = path6.basename(file.path);
     basenameCounts.set(basename3, (basenameCounts.get(basename3) || 0) + 1);
   }
   const fileList = openFiles.map((file) => {
-    const basename3 = path8.basename(file.path);
+    const basename3 = path6.basename(file.path);
     const isDuplicate = (basenameCounts.get(basename3) || 0) > 1;
-    const parentDir = path8.basename(path8.dirname(file.path));
+    const parentDir = path6.basename(path6.dirname(file.path));
     const displayName = isDuplicate ? `${basename3} (/${parentDir})` : basename3;
     return `  - ${displayName}${file.isActive ? " (active)" : ""}`;
   }).join("\n");
@@ -7925,7 +7055,7 @@ var ideCommand = /* @__PURE__ */ __name(async () => {
           if (ideClient.getConnectionStatus().status === "connected" /* Connected */) {
             break;
           }
-          await new Promise((resolve5) => setTimeout(resolve5, 500));
+          await new Promise((resolve4) => setTimeout(resolve4, 500));
         }
         const { messageType, content } = getIdeStatusMessage(ideClient);
         if (messageType === "error") {
@@ -8015,9 +7145,9 @@ init_esbuild_shims();
 
 // packages/cli/src/config/claudeMcpImport.ts
 init_esbuild_shims();
-import * as fs8 from "node:fs";
-import * as os4 from "node:os";
-import * as path9 from "node:path";
+import * as fs6 from "node:fs";
+import * as os3 from "node:os";
+import * as path7 from "node:path";
 var import_strip_json_comments = __toESM(require_strip_json_comments(), 1);
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -8038,7 +7168,7 @@ __name(emptyServerRecord, "emptyServerRecord");
 function readJsonObject(filePath) {
   let raw;
   try {
-    raw = fs8.readFileSync(filePath, "utf-8");
+    raw = fs6.readFileSync(filePath, "utf-8");
   } catch (error) {
     if (isReadableConfigError(error) && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
       return { found: false };
@@ -8087,7 +7217,7 @@ function copyMcpServers(value, sourcePath, servers, errors) {
 }
 __name(copyMcpServers, "copyMcpServers");
 function normalizeProjectPath(projectPath) {
-  return path9.resolve(projectPath);
+  return path7.resolve(projectPath);
 }
 __name(normalizeProjectPath, "normalizeProjectPath");
 function getClaudeProjectSettings(projects, cwd) {
@@ -8103,17 +7233,17 @@ function getClaudeProjectSettings(projects, cwd) {
   return void 0;
 }
 __name(getClaudeProjectSettings, "getClaudeProjectSettings");
-function getClaudeCodeConfigPath(homeDir = os4.homedir()) {
-  return path9.join(homeDir, ".claude.json");
+function getClaudeCodeConfigPath(homeDir = os3.homedir()) {
+  return path7.join(homeDir, ".claude.json");
 }
 __name(getClaudeCodeConfigPath, "getClaudeCodeConfigPath");
-function getClaudeDesktopConfigPath(homeDir = os4.homedir(), platform3 = process.platform, env = process.env) {
-  if (platform3 === "win32") {
-    const appData = env["APPDATA"] ?? path9.win32.join(homeDir, "AppData", "Roaming");
-    return path9.win32.join(appData, "Claude", "claude_desktop_config.json");
+function getClaudeDesktopConfigPath(homeDir = os3.homedir(), platform2 = process.platform, env = process.env) {
+  if (platform2 === "win32") {
+    const appData = env["APPDATA"] ?? path7.win32.join(homeDir, "AppData", "Roaming");
+    return path7.win32.join(appData, "Claude", "claude_desktop_config.json");
   }
-  if (platform3 === "darwin") {
-    return path9.join(
+  if (platform2 === "darwin") {
+    return path7.join(
       homeDir,
       "Library",
       "Application Support",
@@ -8121,7 +7251,7 @@ function getClaudeDesktopConfigPath(homeDir = os4.homedir(), platform3 = process
       "claude_desktop_config.json"
     );
   }
-  return path9.join(homeDir, ".config", "Claude", "claude_desktop_config.json");
+  return path7.join(homeDir, ".config", "Claude", "claude_desktop_config.json");
 }
 __name(getClaudeDesktopConfigPath, "getClaudeDesktopConfigPath");
 function loadMcpServersFromSettingsFile(filePath, label, source) {
@@ -8213,7 +7343,7 @@ __name(loadClaudeCodeJsonMcpServers, "loadClaudeCodeJsonMcpServers");
 function loadClaudeCodeMcpSources(homeDir, cwd, scope) {
   const candidates = scope === "project" ? [
     loadMcpServersFromSettingsFile(
-      path9.join(cwd, ".claude", "settings.json"),
+      path7.join(cwd, ".claude", "settings.json"),
       "Claude Code project settings",
       "claude-code"
     ),
@@ -8221,7 +7351,7 @@ function loadClaudeCodeMcpSources(homeDir, cwd, scope) {
   ] : [
     loadClaudeCodeJsonMcpServers(homeDir, cwd, scope),
     loadMcpServersFromSettingsFile(
-      path9.join(homeDir, ".claude", "settings.json"),
+      path7.join(homeDir, ".claude", "settings.json"),
       "Claude Code global settings",
       "claude-code"
     )
@@ -8236,8 +7366,8 @@ function loadClaudeCodeMcpSources(homeDir, cwd, scope) {
   });
 }
 __name(loadClaudeCodeMcpSources, "loadClaudeCodeMcpSources");
-function loadClaudeDesktopMcpServers(homeDir, platform3, env) {
-  const filePath = getClaudeDesktopConfigPath(homeDir, platform3, env);
+function loadClaudeDesktopMcpServers(homeDir, platform2, env) {
+  const filePath = getClaudeDesktopConfigPath(homeDir, platform2, env);
   const errors = [];
   const servers = emptyServerRecord();
   const parsed = readJsonObject(filePath);
@@ -8273,14 +7403,14 @@ function loadClaudeDesktopMcpServers(homeDir, platform3, env) {
 }
 __name(loadClaudeDesktopMcpServers, "loadClaudeDesktopMcpServers");
 function loadClaudeMcpSources(options) {
-  const homeDir = options.homeDir ?? os4.homedir();
+  const homeDir = options.homeDir ?? os3.homedir();
   const cwd = options.cwd ?? process.cwd();
-  const platform3 = options.platform ?? process.platform;
+  const platform2 = options.platform ?? process.platform;
   const env = options.env ?? process.env;
   const scope = options.scope ?? "user";
   const sources = options.source === "all" ? ["claude-code", "claude-desktop"] : [options.source];
   return sources.flatMap(
-    (source) => source === "claude-code" ? loadClaudeCodeMcpSources(homeDir, cwd, scope) : [loadClaudeDesktopMcpServers(homeDir, platform3, env)]
+    (source) => source === "claude-code" ? loadClaudeCodeMcpSources(homeDir, cwd, scope) : [loadClaudeDesktopMcpServers(homeDir, platform2, env)]
   );
 }
 __name(loadClaudeMcpSources, "loadClaudeMcpSources");
@@ -8633,8 +7763,8 @@ ${usage()}`
 
 // packages/cli/src/ui/commands/initCommand.ts
 init_esbuild_shims();
-import * as fs9 from "node:fs";
-import * as path10 from "node:path";
+import * as fs7 from "node:fs";
+import * as path8 from "node:path";
 var import_react2 = __toESM(require_react(), 1);
 var initCommand = {
   name: "init",
@@ -8653,11 +7783,11 @@ var initCommand = {
     }
     const targetDir = context.services.config.getTargetDir();
     const contextFileName = getCurrentGeminiMdFilename();
-    const contextFilePath = path10.join(targetDir, contextFileName);
+    const contextFilePath = path8.join(targetDir, contextFileName);
     try {
-      if (fs9.existsSync(contextFilePath)) {
+      if (fs7.existsSync(contextFilePath)) {
         try {
-          const existing = fs9.readFileSync(contextFilePath, "utf8");
+          const existing = fs7.readFileSync(contextFilePath, "utf8");
           if (existing && existing.trim().length > 0) {
             if (!context.overwriteConfirmed) {
               return {
@@ -8679,7 +7809,7 @@ var initCommand = {
         }
       }
       try {
-        fs9.writeFileSync(contextFilePath, "", "utf8");
+        fs7.writeFileSync(contextFilePath, "", "utf8");
         context.ui.addItem(
           {
             type: "info",
@@ -8744,7 +7874,7 @@ Write the complete content to the \`${contextFileName}\` file. The output must b
 
 // packages/cli/src/ui/commands/languageCommand.ts
 init_esbuild_shims();
-var debugLogger11 = createDebugLogger("LANGUAGE_COMMAND");
+var debugLogger9 = createDebugLogger("LANGUAGE_COMMAND");
 function getCurrentOutputLanguage(context) {
   const settingValue = context?.services?.settings?.merged?.general?.outputLanguage || OUTPUT_LANGUAGE_AUTO;
   const resolved = resolveOutputLanguage(settingValue);
@@ -8775,7 +7905,7 @@ async function setUiLanguage(context, lang) {
     try {
       services.settings.setValue("User" /* User */, "general.language", lang);
     } catch (error) {
-      debugLogger11.warn("Failed to save language setting:", error);
+      debugLogger9.warn("Failed to save language setting:", error);
     }
   }
   context.ui.reloadCommands();
@@ -8802,7 +7932,7 @@ async function setOutputLanguage(context, language) {
           settingValue
         );
       } catch (error) {
-        debugLogger11.warn("Failed to save output language setting:", error);
+        debugLogger9.warn("Failed to save output language setting:", error);
       }
     }
     const config = context.services.config;
@@ -8811,7 +7941,7 @@ async function setOutputLanguage(context, language) {
         await config.refreshHierarchicalMemory();
         await config.getGeminiClient().refreshSystemInstruction();
       } catch (error) {
-        debugLogger11.warn(
+        debugLogger9.warn(
           "Failed to apply output language to running session:",
           error
         );
@@ -9035,7 +8165,7 @@ var mcpCommand = {
 
 // packages/cli/src/ui/commands/dreamCommand.ts
 init_esbuild_shims();
-import * as path11 from "node:path";
+import * as path9 from "node:path";
 var dreamCommand = {
   name: "dream",
   get description() {
@@ -9055,7 +8185,7 @@ var dreamCommand = {
     try {
       const projectRoot = config.getProjectRoot();
       const memoryRoot = getAutoMemoryRoot(projectRoot);
-      const transcriptDir = path11.join(
+      const transcriptDir = path9.join(
         new Storage(projectRoot).getProjectDir(),
         "chats"
       );
@@ -9156,17 +8286,44 @@ init_esbuild_shims();
 var MAIN_MODEL_CONFIGURATION_HINT = "Configure models in settings.modelProviders and ensure the required environment variables are set. In interactive mode, run /auth to configure or switch providers, or run /model without arguments to choose from configured models.";
 var FAST_MODEL_CONFIGURATION_HINT = "Configure models in settings.modelProviders and ensure the required environment variables are set. In interactive mode, run /auth to configure or switch providers, or run /model --fast without a model to choose from configured models.";
 var VISION_MODEL_CONFIGURATION_HINT = "Configure an image-capable model in settings.modelProviders and ensure the required environment variables are set. Run /model --vision <model-id> to set it, or leave it unset to auto-pick a same-provider vision model.";
+function parseScopeFlags(args) {
+  let scopeOverride;
+  let remaining = args;
+  const hasProject = /(?:^|\s)--project(?:\s|$)/.test(remaining);
+  const hasGlobal = /(?:^|\s)--global(?:\s|$)/.test(remaining);
+  if (hasProject) {
+    scopeOverride = "Workspace" /* Workspace */;
+    remaining = remaining.replace(/(?:^|\s)--project(?:\s|$)/, " ").trim();
+  } else if (hasGlobal) {
+    scopeOverride = "User" /* User */;
+    remaining = remaining.replace(/(?:^|\s)--global(?:\s|$)/, " ").trim();
+  }
+  return { scopeOverride, remaining, hasProject, hasGlobal };
+}
+__name(parseScopeFlags, "parseScopeFlags");
+function resolveScope(settings, scopeOverride) {
+  return scopeOverride ?? getPersistScopeForModelSelection(settings);
+}
+__name(resolveScope, "resolveScope");
+function persistScopeSpread(scopeOverride) {
+  if (scopeOverride === "Workspace" /* Workspace */)
+    return { persistScope: "workspace" };
+  if (scopeOverride === "User" /* User */)
+    return { persistScope: "user" };
+  return {};
+}
+__name(persistScopeSpread, "persistScopeSpread");
 function formatVisionModelSettingForDisplay(setting) {
   const parsed = parseVisionModelSetting(setting);
   if (!parsed) return setting.replace(/\0/g, "\\0");
   return parsed.baseUrl ? `${parsed.selector} (${parsed.baseUrl})` : parsed.selector;
 }
 __name(formatVisionModelSettingForDisplay, "formatVisionModelSettingForDisplay");
-function persistSetting(settings, path20, value) {
-  settings.setValue(getPersistScopeForModelSelection(settings), path20, value);
+function persistSetting(settings, path18, value, scopeOverride) {
+  settings.setValue(resolveScope(settings, scopeOverride), path18, value);
 }
 __name(persistSetting, "persistSetting");
-async function switchMainModel(config, settings, currentAuthType, modelArg) {
+async function switchMainModel(config, settings, currentAuthType, modelArg, scopeOverride) {
   const parsed = parseAcpModelOption(modelArg);
   if (parsed.authType) {
     await config.switchModel(
@@ -9174,14 +8331,19 @@ async function switchMainModel(config, settings, currentAuthType, modelArg) {
       parsed.modelId,
       parsed.authType !== currentAuthType && parsed.authType === "qwen-oauth" /* QWEN_OAUTH */ ? { requireCachedCredentials: true } : void 0
     );
-    persistSetting(settings, "security.auth.selectedType", parsed.authType);
-    persistSetting(settings, "model.name", parsed.modelId);
-    persistSetting(settings, "model.baseUrl", "");
+    persistSetting(
+      settings,
+      "security.auth.selectedType",
+      parsed.authType,
+      scopeOverride
+    );
+    persistSetting(settings, "model.name", parsed.modelId, scopeOverride);
+    persistSetting(settings, "model.baseUrl", "", scopeOverride);
     return parsed.modelId;
   }
   await config.switchModel(currentAuthType, modelArg, void 0);
-  persistSetting(settings, "model.name", modelArg);
-  persistSetting(settings, "model.baseUrl", "");
+  persistSetting(settings, "model.name", modelArg, scopeOverride);
+  persistSetting(settings, "model.baseUrl", "", scopeOverride);
   return modelArg;
 }
 __name(switchMainModel, "switchMainModel");
@@ -9287,10 +8449,10 @@ var modelCommand = {
   completionPriority: 100,
   get description() {
     return t(
-      "Switch the model for this session (--fast for suggestion model, --voice for voice transcription model, --vision for the vision bridge model, [model-id] to switch immediately, or [model-id] [prompt] to run a one-off prompt on another model; the inline prompt is sent verbatim without @file expansion)."
+      "Switch the model for this session (--fast for suggestion model, --voice for voice transcription model, --vision for the vision bridge model, --project to persist to project settings, --global to persist to user settings, [model-id] to switch immediately, or [model-id] [prompt] to run a one-off prompt on another model; the inline prompt is sent verbatim without @file expansion)."
     );
   },
-  argumentHint: "[--fast|--voice|--vision] [<model-id>] | <model-id> <prompt>",
+  argumentHint: "[--fast|--voice|--vision] [--project|--global] [<model-id>] | <model-id> <prompt>",
   kind: "built-in" /* BUILT_IN */,
   supportedModes: ["interactive", "non_interactive", "acp"],
   completion: /* @__PURE__ */ __name(async (context, partialArg) => {
@@ -9311,6 +8473,18 @@ var modelCommand = {
           description: t(
             "Set the image-capable model used to transcribe images for a text-only main model"
           )
+        },
+        {
+          value: "--project",
+          description: t(
+            "Persist the model selection to the project settings (workspace scope)"
+          )
+        },
+        {
+          value: "--global",
+          description: t(
+            "Persist the model selection to the user settings (global scope)"
+          )
         }
       ].filter((item) => item.value.startsWith(partialArg));
       if (flagCompletions.length > 0) {
@@ -9319,17 +8493,10 @@ var modelCommand = {
       const trimmed = partialArg.trim();
       if (trimmed) {
         let mode = "main";
-        let modelPrefix = trimmed;
-        if (trimmed.startsWith("--fast ")) {
-          mode = "fast";
-          modelPrefix = trimmed.slice("--fast ".length);
-        } else if (trimmed.startsWith("--voice ")) {
-          mode = "voice";
-          modelPrefix = trimmed.slice("--voice ".length);
-        } else if (trimmed.startsWith("--vision ")) {
-          mode = "vision";
-          modelPrefix = trimmed.slice("--vision ".length);
-        }
+        const modelPrefix = trimmed.replace(/(?:^|\s)--fast(?:\s|$)/, " ").replace(/(?:^|\s)--voice(?:\s|$)/, " ").replace(/(?:^|\s)--vision(?:\s|$)/, " ").replace(/(?:^|\s)--project(?:\s|$)/, " ").replace(/(?:^|\s)--global(?:\s|$)/, " ").trim();
+        if (/(?:^|\s)--fast(?:\s|$)/.test(trimmed)) mode = "fast";
+        else if (/(?:^|\s)--voice(?:\s|$)/.test(trimmed)) mode = "voice";
+        else if (/(?:^|\s)--vision(?:\s|$)/.test(trimmed)) mode = "vision";
         return getAvailableModelIds(context, mode).filter(
           (id) => id.startsWith(modelPrefix)
         );
@@ -9349,7 +8516,30 @@ var modelCommand = {
         content: t("Configuration not available.")
       };
     }
-    const args = context.invocation?.args?.trim() || actionArgs.trim();
+    const rawArgs = context.invocation?.args?.trim() || actionArgs.trim();
+    const {
+      scopeOverride,
+      remaining: args,
+      hasProject,
+      hasGlobal
+    } = parseScopeFlags(rawArgs);
+    if (hasProject && hasGlobal) {
+      return {
+        type: "message",
+        messageType: "error",
+        content: t(
+          "Cannot use both --project and --global. Choose one scope flag."
+        )
+      };
+    }
+    if (scopeOverride === "Workspace" /* Workspace */ && settings && !settings.isTrusted) {
+      return {
+        type: "message",
+        messageType: "error",
+        content: t("Workspace is untrusted; run /trust first or use --global.")
+      };
+    }
+    const scopeSuffix = scopeOverride === "Workspace" /* Workspace */ ? t(" (this project)") : scopeOverride === "User" /* User */ ? t(" (global)") : "";
     const isVoiceModelCommand = args === "--voice" || args.startsWith("--voice ");
     if (isVoiceModelCommand) {
       const modelName2 = args.replace("--voice", "").trim();
@@ -9367,7 +8557,8 @@ var modelCommand = {
         }
         return {
           type: "dialog",
-          dialog: "voice-model"
+          dialog: "voice-model",
+          ...persistScopeSpread(scopeOverride)
         };
       }
       if (!settings) {
@@ -9406,11 +8597,11 @@ var modelCommand = {
           content: formatUnsupportedVoiceModelMessage(modelName2)
         };
       }
-      persistSetting(settings, "voiceModel", modelName2);
+      persistSetting(settings, "voiceModel", modelName2, scopeOverride);
       return {
         type: "message",
         messageType: "info",
-        content: t("Voice Model") + ": " + modelName2
+        content: t("Voice Model") + ": " + modelName2 + scopeSuffix
       };
     }
     const isFastModelCommand = args === "--fast" || args.startsWith("--fast ");
@@ -9428,7 +8619,8 @@ Use "/model --fast <model-id>" to set fast model.`
         }
         return {
           type: "dialog",
-          dialog: "fast-model"
+          dialog: "fast-model",
+          ...persistScopeSpread(scopeOverride)
         };
       }
       if (!settings) {
@@ -9474,12 +8666,12 @@ Use "/model --fast <model-id>" to set fast model.`
           ) : formatUnavailableFastModelMessage(modelName2, availableModels)
         };
       }
-      persistSetting(settings, "fastModel", modelName2);
+      persistSetting(settings, "fastModel", modelName2, scopeOverride);
       config.setFastModel(modelName2);
       return {
         type: "message",
         messageType: "info",
-        content: t("Fast Model") + ": " + modelName2
+        content: t("Fast Model") + ": " + modelName2 + scopeSuffix
       };
     }
     const isVisionModelCommand = args === "--vision" || args.startsWith("--vision ");
@@ -9501,7 +8693,8 @@ Use "/model --fast <model-id>" to set fast model.`
         }
         return {
           type: "dialog",
-          dialog: "vision-model"
+          dialog: "vision-model",
+          ...persistScopeSpread(scopeOverride)
         };
       }
       if (!settings) {
@@ -9561,14 +8754,14 @@ Use "/model --fast <model-id>" to set fast model.`
       }
       const qualifiedModelName = `${selector.authType ?? matched.authType}:${selector.modelId}`;
       const visionModel = matched.baseUrl ? `${qualifiedModelName}\0${matched.baseUrl}` : qualifiedModelName;
-      persistSetting(settings, "visionModel", visionModel);
+      persistSetting(settings, "visionModel", visionModel, scopeOverride);
       config.setVisionModel(visionModel);
       const visionWarning = isImageCapable(matched) ? "" : `
 ${formatNonVisionModelWarning(modelName2)}`;
       return {
         type: "message",
         messageType: "info",
-        content: t("Vision Model") + ": " + modelName2 + visionWarning
+        content: t("Vision Model") + ": " + modelName2 + scopeSuffix + visionWarning
       };
     }
     const contentGeneratorConfig = config.getContentGeneratorConfig();
@@ -9618,6 +8811,17 @@ ${formatNonVisionModelWarning(modelName2)}`;
             )
           };
         }
+        if (scopeOverride) {
+          const scopeFlag = hasProject ? "--project" : hasGlobal ? "--global" : "";
+          return {
+            type: "message",
+            messageType: "error",
+            content: t(
+              "Cannot combine {{flag}} with an inline prompt. Run '/model {{flag}} {{model}}' first, then send your prompt.",
+              { flag: scopeFlag }
+            )
+          };
+        }
         const sameAuthType = targetAuthType === authType;
         if (!sameAuthType || !isInlineModelOverrideAllowed(config, parsed.modelId)) {
           return {
@@ -9646,12 +8850,13 @@ ${formatNonVisionModelWarning(modelName2)}`;
         config,
         settings,
         authType,
-        modelName
+        modelName,
+        scopeOverride
       );
       return {
         type: "message",
         messageType: "info",
-        content: t("Model") + ": " + effectiveModelName
+        content: t("Model") + ": " + effectiveModelName + scopeSuffix
       };
     }
     if (context.executionMode !== "interactive") {
@@ -9659,13 +8864,16 @@ ${formatNonVisionModelWarning(modelName2)}`;
       return {
         type: "message",
         messageType: "info",
-        content: `Current model: ${currentModel}
-Use "/model <model-id>" to switch models or "/model --fast <model-id>" to set the fast model.`
+        content: t(
+          'Current model: {{model}}\nUse "/model <model-id>" to switch models, "/model --fast <model-id>" to set the fast model, "/model --project <model-id>" to persist to project settings, or "/model --global <model-id>" to persist to user settings.',
+          { model: currentModel }
+        )
       };
     }
     return {
       type: "dialog",
-      dialog: "model"
+      dialog: "model",
+      ...persistScopeSpread(scopeOverride)
     };
   }, "action")
 };
@@ -10097,8 +9305,8 @@ var renameCommand = {
 
 // packages/cli/src/ui/commands/restoreCommand.ts
 init_esbuild_shims();
-import * as fs10 from "node:fs/promises";
-import path12 from "node:path";
+import * as fs8 from "node:fs/promises";
+import path10 from "node:path";
 async function restoreAction(context, args) {
   const { services, ui } = context;
   const { config } = services;
@@ -10112,8 +9320,8 @@ async function restoreAction(context, args) {
     };
   }
   try {
-    await fs10.mkdir(checkpointDir, { recursive: true });
-    const files = await fs10.readdir(checkpointDir);
+    await fs8.mkdir(checkpointDir, { recursive: true });
+    const files = await fs8.readdir(checkpointDir);
     const jsonFiles = files.filter((file) => file.endsWith(".json"));
     if (!args) {
       if (jsonFiles.length === 0) {
@@ -10148,8 +9356,8 @@ ${fileList}`
         content: `File not found: ${selectedFile}`
       };
     }
-    const filePath = path12.join(checkpointDir, selectedFile);
-    const data = await fs10.readFile(filePath, "utf-8");
+    const filePath = path10.join(checkpointDir, selectedFile);
+    const data = await fs8.readFile(filePath, "utf-8");
     const toolCallData = JSON.parse(data);
     if (toolCallData.commitHash && !toolCallData.promptId) {
       return {
@@ -10235,7 +9443,7 @@ async function completion(context, _partialArg) {
     return [];
   }
   try {
-    const files = await fs10.readdir(checkpointDir);
+    const files = await fs8.readdir(checkpointDir);
     return files.filter((file) => file.endsWith(".json")).map((file) => file.replace(".json", ""));
   } catch (_err) {
     return [];
@@ -10422,9 +9630,9 @@ ${lines.join("\n")}`
 
 // packages/cli/src/ui/commands/statsCommand.ts
 init_esbuild_shims();
-import * as fs11 from "node:fs/promises";
+import * as fs9 from "node:fs/promises";
 import { randomUUID } from "node:crypto";
-import path13 from "node:path";
+import path11 from "node:path";
 var VALID_EXPORT_FORMATS = /* @__PURE__ */ new Set(["csv", "json"]);
 var EMPTY_SKILL_METRICS = {
   totalCalls: 0,
@@ -10621,12 +9829,12 @@ async function realpathNearestExisting2(targetDirectory, cwd) {
   let currentDirectory = targetDirectory;
   while (isSubpath(cwd, currentDirectory)) {
     try {
-      return await fs11.realpath(currentDirectory);
+      return await fs9.realpath(currentDirectory);
     } catch (error) {
       if (!isNotFoundError(error)) {
         throw error;
       }
-      const parentDirectory = path13.dirname(currentDirectory);
+      const parentDirectory = path11.dirname(currentDirectory);
       if (parentDirectory === currentDirectory) {
         break;
       }
@@ -10640,7 +9848,7 @@ async function realpathNearestExisting2(targetDirectory, cwd) {
 __name(realpathNearestExisting2, "realpathNearestExisting");
 async function validateStatsExportExistingParent(cwd, outputDirectory) {
   const [realCwd, realExistingParent] = await Promise.all([
-    fs11.realpath(cwd),
+    fs9.realpath(cwd),
     realpathNearestExisting2(outputDirectory, cwd)
   ]);
   if (!isSubpath(realCwd, realExistingParent)) {
@@ -10651,8 +9859,8 @@ async function validateStatsExportExistingParent(cwd, outputDirectory) {
 __name(validateStatsExportExistingParent, "validateStatsExportExistingParent");
 async function validateStatsExportDirectory(cwd, outputDirectory) {
   const [realCwd, realOutputDirectory] = await Promise.all([
-    fs11.realpath(cwd),
-    fs11.realpath(outputDirectory)
+    fs9.realpath(cwd),
+    fs9.realpath(outputDirectory)
   ]);
   if (!isSubpath(realCwd, realOutputDirectory)) {
     return statsExportPathError();
@@ -10661,7 +9869,7 @@ async function validateStatsExportDirectory(cwd, outputDirectory) {
 }
 __name(validateStatsExportDirectory, "validateStatsExportDirectory");
 function validateStatsExportPathShape(targetPath) {
-  if (process.platform === "win32" && path13.basename(targetPath).includes(":")) {
+  if (process.platform === "win32" && path11.basename(targetPath).includes(":")) {
     return statsExportPathError();
   }
   return void 0;
@@ -10669,7 +9877,7 @@ function validateStatsExportPathShape(targetPath) {
 __name(validateStatsExportPathShape, "validateStatsExportPathShape");
 async function validateStatsExportFileTarget(targetPath) {
   try {
-    const stats = await fs11.lstat(targetPath);
+    const stats = await fs9.lstat(targetPath);
     if (stats.isSymbolicLink() || !stats.isFile()) {
       return statsExportPathError();
     }
@@ -10685,7 +9893,7 @@ __name(validateStatsExportFileTarget, "validateStatsExportFileTarget");
 async function validateStatsExportFinalFile(cwd, targetPath) {
   let stats;
   try {
-    stats = await fs11.lstat(targetPath);
+    stats = await fs9.lstat(targetPath);
   } catch (error) {
     if (isNotFoundError(error)) {
       return statsExportTargetMissingError(targetPath);
@@ -10696,8 +9904,8 @@ async function validateStatsExportFinalFile(cwd, targetPath) {
     return statsExportPathError();
   }
   const [realCwd, realTargetPath] = await Promise.all([
-    fs11.realpath(cwd),
-    fs11.realpath(targetPath)
+    fs9.realpath(cwd),
+    fs9.realpath(targetPath)
   ]);
   if (!isSubpath(realCwd, realTargetPath)) {
     return statsExportPathError();
@@ -10706,9 +9914,9 @@ async function validateStatsExportFinalFile(cwd, targetPath) {
 }
 __name(validateStatsExportFinalFile, "validateStatsExportFinalFile");
 function createTemporaryExportPath(outputDirectory, targetPath) {
-  return path13.join(
+  return path11.join(
     outputDirectory,
-    `.${path13.basename(targetPath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`
+    `.${path11.basename(targetPath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`
   );
 }
 __name(createTemporaryExportPath, "createTemporaryExportPath");
@@ -10718,8 +9926,8 @@ function isSamePath(leftPath, rightPath) {
 __name(isSamePath, "isSamePath");
 async function validateStatsExportDirectoryIdentity(cwd, outputDirectory, expectedRealOutputDirectory) {
   const [realCwd, realOutputDirectory] = await Promise.all([
-    fs11.realpath(cwd),
-    fs11.realpath(outputDirectory)
+    fs9.realpath(cwd),
+    fs9.realpath(outputDirectory)
   ]);
   if (!isSubpath(realCwd, realOutputDirectory) || !isSamePath(expectedRealOutputDirectory, realOutputDirectory)) {
     return statsExportPathError();
@@ -10736,12 +9944,12 @@ async function writeStatsExportFileAtomically(cwd, outputDirectory, targetPath,
     return initialDirectoryError;
   }
   const [realCwd, realOutputDirectory] = await Promise.all([
-    fs11.realpath(cwd),
-    fs11.realpath(outputDirectory)
+    fs9.realpath(cwd),
+    fs9.realpath(outputDirectory)
   ]);
-  const realTargetPath = path13.join(
+  const realTargetPath = path11.join(
     realOutputDirectory,
-    path13.basename(targetPath)
+    path11.basename(targetPath)
   );
   if (!isSubpath(realCwd, realTargetPath)) {
     return statsExportPathError();
@@ -10767,7 +9975,7 @@ async function writeStatsExportFileAtomically(cwd, outputDirectory, targetPath,
       if (preTempFileError) {
         return preTempFileError;
       }
-      const file = await fs11.open(tempPath, "wx", 384);
+      const file = await fs9.open(tempPath, "wx", 384);
       try {
         await file.writeFile(content, { encoding: "utf-8" });
       } finally {
@@ -10789,7 +9997,7 @@ async function writeStatsExportFileAtomically(cwd, outputDirectory, targetPath,
       if (preRenameFileError) {
         return preRenameFileError;
       }
-      await fs11.rename(tempPath, realTargetPath);
+      await fs9.rename(tempPath, realTargetPath);
       tempPath = void 0;
       return validateStatsExportFinalFile(cwd, realTargetPath);
     } catch (error) {
@@ -10799,7 +10007,7 @@ async function writeStatsExportFileAtomically(cwd, outputDirectory, targetPath,
       throw error;
     } finally {
       if (tempPath) {
-        await fs11.rm(tempPath, { force: true }).catch(() => void 0);
+        await fs9.rm(tempPath, { force: true }).catch(() => void 0);
       }
     }
   }
@@ -10891,10 +10099,10 @@ async function writeStatsExport(context, args) {
     });
     const content = parsed.format === "json" ? formatTokenUsageSummaryAsJson(summary) : `${formatTokenUsageSummaryAsCsv(summary)}
 `;
-    const cwd = path13.resolve(getConfigCwd(context));
+    const cwd = path11.resolve(getConfigCwd(context));
     const defaultFilename = `qwen-token-usage-${summary.period}-${summary.value}.${parsed.format}`;
-    const targetPath = path13.resolve(cwd, parsed.outputPath || defaultFilename);
-    const outputDirectory = path13.dirname(targetPath);
+    const targetPath = path11.resolve(cwd, parsed.outputPath || defaultFilename);
+    const outputDirectory = path11.dirname(targetPath);
     if (!isSubpath(cwd, targetPath) || !isSubpath(cwd, outputDirectory)) {
       return statsExportPathError();
     }
@@ -10909,7 +10117,7 @@ async function writeStatsExport(context, args) {
     if (parentError) {
       return parentError;
     }
-    await fs11.mkdir(outputDirectory, { recursive: true });
+    await fs9.mkdir(outputDirectory, { recursive: true });
     const postMkdirError = await validateStatsExportDirectory(
       cwd,
       outputDirectory
@@ -10933,7 +10141,7 @@ async function writeStatsExport(context, args) {
     return asMessage(
       t("Token usage exported to {{format}}: {{path}}", {
         format: parsed.format.toUpperCase(),
-        path: path13.relative(cwd, targetPath)
+        path: path11.relative(cwd, targetPath)
       })
     );
   } catch (error) {
@@ -11144,7 +10352,7 @@ var statsCommand = {
 // packages/cli/src/ui/commands/summaryCommand.ts
 init_esbuild_shims();
 import * as fsPromises from "fs/promises";
-import path14 from "path";
+import path12 from "path";
 var summaryCommand = {
   name: "summary",
   get description() {
@@ -11237,12 +10445,12 @@ var summaryCommand = {
     }, "generateSummaryMarkdown");
     const saveSummaryToDisk = /* @__PURE__ */ __name(async (markdownSummary) => {
       const projectRoot = config.getProjectRoot();
-      const qwenDir = path14.join(projectRoot, ".qwen");
+      const qwenDir = path12.join(projectRoot, ".qwen");
       try {
         await fsPromises.mkdir(qwenDir, { recursive: true });
       } catch (_err) {
       }
-      const summaryPath = path14.join(qwenDir, "PROJECT_SUMMARY.md");
+      const summaryPath = path12.join(qwenDir, "PROJECT_SUMMARY.md");
       const summaryContent = `${markdownSummary}
 
 ---
@@ -11398,12 +10606,12 @@ init_esbuild_shims();
 
 // packages/cli/src/ui/utils/terminalSetup.ts
 init_esbuild_shims();
-import { promises as fs12 } from "node:fs";
-import * as os5 from "node:os";
-import * as path15 from "node:path";
+import { promises as fs10 } from "node:fs";
+import * as os4 from "node:os";
+import * as path13 from "node:path";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
-var debugLogger12 = createDebugLogger("TERMINAL_SETUP");
+var debugLogger10 = createDebugLogger("TERMINAL_SETUP");
 var execAsync = promisify(exec);
 function stripJsonComments2(content) {
   return content.replace(/^\s*\/\/.*$/gm, "");
@@ -11423,7 +10631,7 @@ async function detectTerminal() {
   if (termProgram === "vscode" || process.env["VSCODE_GIT_IPC_HANDLE"]) {
     return "vscode";
   }
-  if (os5.platform() !== "win32") {
+  if (os4.platform() !== "win32") {
     try {
       const { stdout } = await execAsync("ps -o comm= -p $PPID");
       const parentName = stdout.trim();
@@ -11436,7 +10644,7 @@ async function detectTerminal() {
       if (parentName.includes("trae") || parentName.includes("Trae"))
         return "trae";
     } catch (error) {
-      debugLogger12.debug("Parent process detection failed:", error);
+      debugLogger10.debug("Parent process detection failed:", error);
     }
   }
   return null;
@@ -11446,29 +10654,29 @@ async function backupFile(filePath) {
   try {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const backupPath = `${filePath}.backup.${timestamp}`;
-    await fs12.copyFile(filePath, backupPath);
+    await fs10.copyFile(filePath, backupPath);
   } catch (error) {
-    debugLogger12.warn(`Failed to create backup of ${filePath}:`, error);
+    debugLogger10.warn(`Failed to create backup of ${filePath}:`, error);
   }
 }
 __name(backupFile, "backupFile");
 function getVSCodeStyleConfigDir(appName) {
-  const platform3 = os5.platform();
-  if (platform3 === "darwin") {
-    return path15.join(
-      os5.homedir(),
+  const platform2 = os4.platform();
+  if (platform2 === "darwin") {
+    return path13.join(
+      os4.homedir(),
       "Library",
       "Application Support",
       appName,
       "User"
     );
-  } else if (platform3 === "win32") {
+  } else if (platform2 === "win32") {
     if (!process.env["APPDATA"]) {
       return null;
     }
-    return path15.join(process.env["APPDATA"], appName, "User");
+    return path13.join(process.env["APPDATA"], appName, "User");
   } else {
-    return path15.join(os5.homedir(), ".config", appName, "User");
+    return path13.join(os4.homedir(), ".config", appName, "User");
   }
 }
 __name(getVSCodeStyleConfigDir, "getVSCodeStyleConfigDir");
@@ -11483,12 +10691,12 @@ async function configureVSCodeStyle(terminalName, appName) {
       )
     };
   }
-  const keybindingsFile = path15.join(configDir, "keybindings.json");
+  const keybindingsFile = path13.join(configDir, "keybindings.json");
   try {
-    await fs12.mkdir(configDir, { recursive: true });
+    await fs10.mkdir(configDir, { recursive: true });
     let keybindings = [];
     try {
-      const content = await fs12.readFile(keybindingsFile, "utf8");
+      const content = await fs10.readFile(keybindingsFile, "utf8");
       await backupFile(keybindingsFile);
       try {
         const cleanContent = stripJsonComments2(content);
@@ -11562,7 +10770,7 @@ async function configureVSCodeStyle(terminalName, appName) {
     if (!hasOurShiftEnter || !hasOurCtrlEnter) {
       if (!hasOurShiftEnter) keybindings.unshift(shiftEnterBinding);
       if (!hasOurCtrlEnter) keybindings.unshift(ctrlEnterBinding);
-      await fs12.writeFile(keybindingsFile, JSON.stringify(keybindings, null, 4));
+      await fs10.writeFile(keybindingsFile, JSON.stringify(keybindings, null, 4));
       return {
         success: true,
         message: t(
@@ -11757,7 +10965,7 @@ init_esbuild_shims();
 
 // packages/cli/src/ui/voice/voice-availability.ts
 init_esbuild_shims();
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import process5 from "node:process";
 var SUPPORTED_PLATFORMS = [
   "darwin",
@@ -11772,14 +10980,14 @@ function getVoiceUnavailableReason(environment = {
   platform: process5.platform,
   env: process5.env
 }) {
-  const { platform: platform3, env } = environment;
-  const fileExists = environment.fileExists ?? existsSync4;
-  if (!SUPPORTED_PLATFORMS.includes(platform3)) {
+  const { platform: platform2, env } = environment;
+  const fileExists = environment.fileExists ?? existsSync2;
+  if (!SUPPORTED_PLATFORMS.includes(platform2)) {
     return t("Voice dictation is not supported on {{platform}}.", {
-      platform: platform3
+      platform: platform2
     });
   }
-  if (platform3 === "linux" && isWsl(env) && !env["PULSE_SERVER"] && !fileExists("/mnt/wslg/PulseServer")) {
+  if (platform2 === "linux" && isWsl(env) && !env["PULSE_SERVER"] && !fileExists("/mnt/wslg/PulseServer")) {
     return t(
       "Voice dictation needs microphone access, which is unavailable in this WSL session. Use WSLg/PulseAudio, or run Qwen Code on a host with a microphone."
     );
@@ -11936,18 +11144,18 @@ var setupGithubCommand = {
 
 // packages/cli/src/ui/commands/insightCommand.ts
 init_esbuild_shims();
-import { join as join9 } from "path";
+import { join as join7 } from "path";
 import { pathToFileURL } from "node:url";
 
 // packages/cli/src/services/insight/generators/StaticInsightGenerator.ts
 init_esbuild_shims();
-import fs14 from "fs/promises";
-import path17 from "path";
+import fs12 from "fs/promises";
+import path15 from "path";
 
 // packages/cli/src/services/insight/generators/DataProcessor.ts
 init_esbuild_shims();
-import fs13 from "fs/promises";
-import path16 from "path";
+import fs11 from "fs/promises";
+import path14 from "path";
 
 // packages/cli/node_modules/p-limit/index.js
 init_esbuild_shims();
@@ -12047,27 +11255,27 @@ function pLimit(concurrency) {
     activeCount--;
     resumeNext();
   }, "next");
-  const run = /* @__PURE__ */ __name(async (function_, resolve5, arguments_) => {
+  const run = /* @__PURE__ */ __name(async (function_, resolve4, arguments_) => {
     const result = (async () => function_(...arguments_))();
-    resolve5(result);
+    resolve4(result);
     try {
       await result;
     } catch {
     }
     next();
   }, "run");
-  const enqueue = /* @__PURE__ */ __name((function_, resolve5, reject, arguments_) => {
+  const enqueue = /* @__PURE__ */ __name((function_, resolve4, reject, arguments_) => {
     const queueItem = { reject };
     new Promise((internalResolve) => {
       queueItem.run = internalResolve;
       queue.enqueue(queueItem);
-    }).then(run.bind(void 0, function_, resolve5, arguments_));
+    }).then(run.bind(void 0, function_, resolve4, arguments_));
     if (activeCount < concurrency) {
       resumeNext();
     }
   }, "enqueue");
-  const generator = /* @__PURE__ */ __name((function_, ...arguments_) => new Promise((resolve5, reject) => {
-    enqueue(function_, resolve5, reject, arguments_);
+  const generator = /* @__PURE__ */ __name((function_, ...arguments_) => new Promise((resolve4, reject) => {
+    enqueue(function_, resolve4, reject, arguments_);
   }), "generator");
   Object.defineProperties(generator, {
     activeCount: {
@@ -12901,19 +12109,19 @@ None captured`;
   async scanChatFiles(baseDir) {
     const allChatFiles = [];
     try {
-      const projectDirs = await fs13.readdir(baseDir);
+      const projectDirs = await fs11.readdir(baseDir);
       for (const projectDir of projectDirs) {
-        const projectPath = path16.join(baseDir, projectDir);
-        const stats = await fs13.stat(projectPath);
+        const projectPath = path14.join(baseDir, projectDir);
+        const stats = await fs11.stat(projectPath);
         if (stats.isDirectory()) {
-          const chatsDir = path16.join(projectPath, "chats");
+          const chatsDir = path14.join(projectPath, "chats");
           try {
-            const files = await fs13.readdir(chatsDir);
+            const files = await fs11.readdir(chatsDir);
             const chatFiles = files.filter((file) => file.endsWith(".jsonl"));
             for (const file of chatFiles) {
-              const filePath = path16.join(chatsDir, file);
+              const filePath = path14.join(chatsDir, file);
               try {
-                const fileStats = await fs13.stat(filePath);
+                const fileStats = await fs11.stat(filePath);
                 allChatFiles.push({ path: filePath, mtime: fileStats.mtimeMs });
               } catch (e) {
                 logger.error(`Failed to stat file ${filePath}:`, e);
@@ -13008,7 +12216,7 @@ None captured`;
           overallProgress
         );
       }
-      await new Promise((resolve5) => setTimeout(resolve5, 0));
+      await new Promise((resolve4) => setTimeout(resolve4, 0));
     }
     const streakData = this.calculateStreaks(Object.keys(heatmap));
     let longestWorkDuration = 0;
@@ -13091,12 +12299,12 @@ None captured`;
           if (records.length > 0 && facetsOutputDir) {
             const sessionId = records[0].sessionId;
             if (sessionId) {
-              const existingFacetPath = path16.join(
+              const existingFacetPath = path14.join(
                 facetsOutputDir,
                 `${sessionId}.json`
               );
               try {
-                const existingData = await fs13.readFile(
+                const existingData = await fs11.readFile(
                   existingFacetPath,
                   "utf-8"
                 );
@@ -13114,7 +12322,7 @@ None captured`;
                 const normalizedData = JSON.stringify(normalizedFacet, null, 2);
                 if (existingData !== normalizedData) {
                   try {
-                    await fs13.writeFile(
+                    await fs11.writeFile(
                       existingFacetPath,
                       normalizedData,
                       "utf-8"
@@ -13149,11 +12357,11 @@ None captured`;
           const facet = await this.analyzeSession(records);
           if (facet && facetsOutputDir) {
             try {
-              const facetPath = path16.join(
+              const facetPath = path14.join(
                 facetsOutputDir,
                 `${facet.session_id}.json`
               );
-              await fs13.writeFile(
+              await fs11.writeFile(
                 facetPath,
                 JSON.stringify(facet, null, 2),
                 "utf-8"
@@ -13251,8 +12459,8 @@ var StaticInsightGenerator = class {
   }
   // Ensure the output directory exists
   async ensureOutputDirectory() {
-    const outputDir = path17.join(Storage.getRuntimeBaseDir(), "insights");
-    await fs14.mkdir(outputDir, { recursive: true });
+    const outputDir = path15.join(Storage.getRuntimeBaseDir(), "insights");
+    await fs12.mkdir(outputDir, { recursive: true });
     return outputDir;
   }
   // Generate timestamped filename with collision detection
@@ -13260,23 +12468,23 @@ var StaticInsightGenerator = class {
     const now = /* @__PURE__ */ new Date();
     const date = now.toISOString().split("T")[0];
     const time = now.toTimeString().slice(0, 8).replace(/:/g, "");
-    let outputPath = path17.join(outputDir, `insight-${date}.html`);
+    let outputPath = path15.join(outputDir, `insight-${date}.html`);
     try {
-      await fs14.access(outputPath);
-      outputPath = path17.join(outputDir, `insight-${date}-${time}.html`);
+      await fs12.access(outputPath);
+      outputPath = path15.join(outputDir, `insight-${date}-${time}.html`);
     } catch {
     }
     return outputPath;
   }
   async updateInsightSymlink(outputDir, targetPath) {
-    const latestPath = path17.join(outputDir, "insight.html");
+    const latestPath = path15.join(outputDir, "insight.html");
     await updateSymlink(latestPath, targetPath);
   }
   // Generate the static insight HTML file
   async generateStaticInsight(baseDir, onProgress) {
     const outputDir = await this.ensureOutputDirectory();
-    const facetsDir = path17.join(outputDir, "facets");
-    await fs14.mkdir(facetsDir, { recursive: true });
+    const facetsDir = path15.join(outputDir, "facets");
+    await fs12.mkdir(facetsDir, { recursive: true });
     const insights = await this.dataProcessor.generateInsights(
       baseDir,
       facetsDir,
@@ -13284,7 +12492,7 @@ var StaticInsightGenerator = class {
     );
     const html = await this.templateRenderer.renderInsightHTML(insights);
     const outputPath = await this.generateOutputPath(outputDir);
-    await fs14.writeFile(outputPath, html, "utf-8");
+    await fs12.writeFile(outputPath, html, "utf-8");
     await this.updateInsightSymlink(outputDir, outputPath);
     return outputPath;
   }
@@ -13304,7 +12512,7 @@ var insightCommand = {
   action: /* @__PURE__ */ __name(async (context) => {
     try {
       context.ui.setDebugMessage(t("Generating insights..."));
-      const projectsDir = join9(Storage.getRuntimeBaseDir(), "projects");
+      const projectsDir = join7(Storage.getRuntimeBaseDir(), "projects");
       if (!context.services.config) {
         if (context.executionMode !== "interactive") {
           return {
@@ -13347,12 +12555,12 @@ var insightCommand = {
         let isComplete = false;
         let resume = null;
         const flushResume = /* @__PURE__ */ __name(() => {
-          const resolve5 = resume;
-          if (!resolve5) {
+          const resolve4 = resume;
+          if (!resolve4) {
             return;
           }
           resume = null;
-          resolve5();
+          resolve4();
         }, "flushResume");
         const pushMessage = /* @__PURE__ */ __name((message) => {
           pendingMessages.push(message);
@@ -13361,8 +12569,8 @@ var insightCommand = {
         const streamMessages = /* @__PURE__ */ __name(async function* () {
           while (!isComplete || pendingMessages.length > 0) {
             if (pendingMessages.length === 0) {
-              await new Promise((resolve5) => {
-                resume = resolve5;
+              await new Promise((resolve4) => {
+                resume = resolve4;
               });
             }
             while (pendingMessages.length > 0) {
@@ -13720,8 +12928,8 @@ var BuiltinCommandLoader = class {
 
 // packages/cli/src/services/BundledSkillLoader.ts
 init_esbuild_shims();
-import { dirname as dirname4 } from "node:path";
-var debugLogger13 = createDebugLogger("BUNDLED_SKILL_LOADER");
+import { dirname as dirname2 } from "node:path";
+var debugLogger11 = createDebugLogger("BUNDLED_SKILL_LOADER");
 var BundledSkillLoader = class {
   constructor(config) {
     this.config = config;
@@ -13731,12 +12939,12 @@ var BundledSkillLoader = class {
   }
   async loadCommands(_signal) {
     if (this.config?.getBareMode?.()) {
-      debugLogger13.debug("Bare mode enabled, skipping bundled skills");
+      debugLogger11.debug("Bare mode enabled, skipping bundled skills");
       return [];
     }
     const skillManager = this.config?.getSkillManager();
     if (!skillManager) {
-      debugLogger13.debug("SkillManager not available, skipping bundled skills");
+      debugLogger11.debug("SkillManager not available, skipping bundled skills");
       return [];
     }
     try {
@@ -13744,7 +12952,7 @@ var BundledSkillLoader = class {
       const cronEnabled = this.config?.isCronEnabled() ?? false;
       const cronVisible = allSkills.filter((skill) => {
         if (!cronEnabled && skill.allowedTools?.some((t2) => t2.startsWith("cron_"))) {
-          debugLogger13.debug(
+          debugLogger11.debug(
             `Hiding skill "${skill.name}" because cron is not enabled`
           );
           return false;
@@ -13755,7 +12963,7 @@ var BundledSkillLoader = class {
       const skills = cronVisible.filter(
         (skill) => !disabled.has(skill.name.toLowerCase())
       );
-      debugLogger13.debug(
+      debugLogger11.debug(
         `Loaded ${skills.length} bundled skill(s) as slash commands; ${cronVisible.length - skills.length} hidden by skills.disabled`
       );
       return skills.map((skill) => ({
@@ -13792,7 +13000,7 @@ ${body}`;
             }
           }
           const skillPrompt = buildSkillLlmContent(
-            dirname4(skill.filePath),
+            dirname2(skill.filePath),
             body
           );
           const content = context.invocation?.args ? appendToLastTextPart(
@@ -13806,7 +13014,7 @@ ${body}`;
         }, "action")
       }));
     } catch (error) {
-      debugLogger13.error("Failed to load bundled skills:", error);
+      debugLogger11.error("Failed to load bundled skills:", error);
       return [];
     }
   }
@@ -13815,9 +13023,9 @@ ${body}`;
 // packages/cli/src/services/FileCommandLoader.ts
 init_esbuild_shims();
 var import_toml = __toESM(require_toml(), 1);
-import { promises as fs15 } from "node:fs";
+import { promises as fs13 } from "node:fs";
 import * as fsSync from "node:fs";
-import path19 from "node:path";
+import path17 from "node:path";
 
 // packages/cli/src/services/markdown-command-parser.ts
 init_esbuild_shims();
@@ -13862,7 +13070,7 @@ __name(parseMarkdownCommand, "parseMarkdownCommand");
 
 // packages/cli/src/services/command-factory.ts
 init_esbuild_shims();
-import path18 from "node:path";
+import path16 from "node:path";
 
 // packages/cli/src/services/prompt-processors/argumentProcessor.ts
 init_esbuild_shims();
@@ -14086,7 +13294,7 @@ var ShellProcessor = class {
 
 // packages/cli/src/services/prompt-processors/atFileProcessor.ts
 init_esbuild_shims();
-var debugLogger14 = createDebugLogger("AT_FILE_PROCESSOR");
+var debugLogger12 = createDebugLogger("AT_FILE_PROCESSOR");
 var AtFileProcessor = class {
   constructor(commandName) {
     this.commandName = commandName;
@@ -14132,7 +13340,7 @@ var AtFileProcessor = class {
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
           const uiMessage = `Failed to inject content for '@{${pathStr}}': ${message}`;
-          debugLogger14.error(
+          debugLogger12.error(
             `[AtFileProcessor] ${uiMessage}. Leaving placeholder in prompt.`
           );
           context.ui.addItem(
@@ -14157,15 +13365,15 @@ var AtFileProcessor = class {
 };
 
 // packages/cli/src/services/command-factory.ts
-var debugLogger15 = createDebugLogger("COMMAND_FACTORY");
+var debugLogger13 = createDebugLogger("COMMAND_FACTORY");
 function createSlashCommandFromDefinition(filePath, baseDir, definition, extensionName, fileExtension) {
-  const relativePathWithExt = path18.relative(baseDir, filePath);
+  const relativePathWithExt = path16.relative(baseDir, filePath);
   const relativePath = relativePathWithExt.substring(
     0,
     relativePathWithExt.length - fileExtension.length
   );
-  const baseCommandName = relativePath.split(path18.sep).map((segment) => segment.replaceAll(":", "_")).join(":");
-  const defaultDescription = `Custom command from ${path18.basename(filePath)}`;
+  const baseCommandName = relativePath.split(path16.sep).map((segment) => segment.replaceAll(":", "_")).join(":");
+  const defaultDescription = `Custom command from ${path16.basename(filePath)}`;
   let description = definition.description || defaultDescription;
   if (extensionName) {
     description = `[${extensionName}] ${description}`;
@@ -14201,7 +13409,7 @@ function createSlashCommandFromDefinition(filePath, baseDir, definition, extensi
     whenToUse: definition.whenToUse,
     action: /* @__PURE__ */ __name(async (context, _args) => {
       if (!context.invocation) {
-        debugLogger15.error(
+        debugLogger13.error(
           `[FileCommandLoader] Critical error: Command '${baseCommandName}' was executed without invocation context.`
         );
         return {
@@ -14239,7 +13447,7 @@ function createSlashCommandFromDefinition(filePath, baseDir, definition, extensi
 __name(createSlashCommandFromDefinition, "createSlashCommandFromDefinition");
 
 // packages/cli/src/services/FileCommandLoader.ts
-var debugLogger16 = createDebugLogger("FILE_COMMAND_LOADER");
+var debugLogger14 = createDebugLogger("FILE_COMMAND_LOADER");
 var TomlCommandDefSchema = external_exports.object({
   prompt: external_exports.string({
     required_error: "The 'prompt' field is required.",
@@ -14273,7 +13481,7 @@ var FileCommandLoader = class {
    */
   async loadCommands(signal) {
     if (this.config?.getBareMode?.()) {
-      debugLogger16.debug("Bare mode enabled, skipping auto-discovered commands");
+      debugLogger14.debug("Bare mode enabled, skipping auto-discovered commands");
       return [];
     }
     const allCommands = [];
@@ -14299,14 +13507,14 @@ var FileCommandLoader = class {
         }
         const tomlCommandPromises = tomlFiles.map(
           (file) => this.parseAndAdaptTomlFile(
-            path19.join(dirInfo.path, file),
+            path17.join(dirInfo.path, file),
             dirInfo.path,
             dirInfo.extensionName
           )
         );
         const mdCommandPromises = mdFiles.map(
           (file) => this.parseAndAdaptMarkdownFile(
-            path19.join(dirInfo.path, file),
+            path17.join(dirInfo.path, file),
             dirInfo.path,
             dirInfo.extensionName
           )
@@ -14317,7 +13525,7 @@ var FileCommandLoader = class {
         const isEnoent = error.code === "ENOENT";
         const isAbortError = error instanceof Error && error.name === "AbortError";
         if (!isEnoent && !isAbortError) {
-          debugLogger16.error(
+          debugLogger14.error(
             `[FileCommandLoader] Error loading commands from ${dirInfo.path}:`,
             error
           );
@@ -14356,14 +13564,14 @@ var FileCommandLoader = class {
    */
   getExtensionCommandsPaths(ext) {
     try {
-      const configPath = path19.join(ext.path, EXTENSIONS_CONFIG_FILENAME);
+      const configPath = path17.join(ext.path, EXTENSIONS_CONFIG_FILENAME);
       if (fsSync.existsSync(configPath)) {
         const configContent = fsSync.readFileSync(configPath, "utf-8");
         const config = JSON.parse(configContent);
         if (config.commands) {
           const commandsArray = Array.isArray(config.commands) ? config.commands : [config.commands];
           return commandsArray.map(
-            (cmdPath) => path19.isAbsolute(cmdPath) ? cmdPath : path19.join(ext.path, cmdPath)
+            (cmdPath) => path17.isAbsolute(cmdPath) ? cmdPath : path17.join(ext.path, cmdPath)
           ).filter((cmdPath) => {
             try {
               return fsSync.existsSync(cmdPath);
@@ -14374,12 +13582,12 @@ var FileCommandLoader = class {
         }
       }
     } catch (error) {
-      debugLogger16.warn(
+      debugLogger14.warn(
         `Failed to read extension config for ${ext.name}:`,
         error
       );
     }
-    const defaultPath = path19.join(ext.path, "commands");
+    const defaultPath = path17.join(ext.path, "commands");
     try {
       if (fsSync.existsSync(defaultPath)) {
         return [defaultPath];
@@ -14398,9 +13606,9 @@ var FileCommandLoader = class {
   async parseAndAdaptTomlFile(filePath, baseDir, extensionName) {
     let fileContent;
     try {
-      fileContent = await fs15.readFile(filePath, "utf-8");
+      fileContent = await fs13.readFile(filePath, "utf-8");
     } catch (error) {
-      debugLogger16.error(
+      debugLogger14.error(
         `[FileCommandLoader] Failed to read file ${filePath}:`,
         error instanceof Error ? error.message : String(error)
       );
@@ -14410,7 +13618,7 @@ var FileCommandLoader = class {
     try {
       parsed = import_toml.default.parse(fileContent);
     } catch (error) {
-      debugLogger16.error(
+      debugLogger14.error(
         `[FileCommandLoader] Failed to parse TOML file ${filePath}:`,
         error instanceof Error ? error.message : String(error)
       );
@@ -14418,7 +13626,7 @@ var FileCommandLoader = class {
     }
     const validationResult = TomlCommandDefSchema.safeParse(parsed);
     if (!validationResult.success) {
-      debugLogger16.error(
+      debugLogger14.error(
         `[FileCommandLoader] Skipping invalid command file: ${filePath}. Validation errors:`,
         validationResult.error.flatten()
       );
@@ -14443,9 +13651,9 @@ var FileCommandLoader = class {
   async parseAndAdaptMarkdownFile(filePath, baseDir, extensionName) {
     let fileContent;
     try {
-      fileContent = await fs15.readFile(filePath, "utf-8");
+      fileContent = await fs13.readFile(filePath, "utf-8");
     } catch (error) {
-      debugLogger16.error(
+      debugLogger14.error(
         `[FileCommandLoader] Failed to read file ${filePath}:`,
         error instanceof Error ? error.message : String(error)
       );
@@ -14455,7 +13663,7 @@ var FileCommandLoader = class {
     try {
       parsed = parseMarkdownCommand(fileContent);
     } catch (error) {
-      debugLogger16.error(
+      debugLogger14.error(
         `[FileCommandLoader] Failed to parse Markdown file ${filePath}:`,
         error instanceof Error ? error.message : String(error)
       );
@@ -14463,7 +13671,7 @@ var FileCommandLoader = class {
     }
     const validationResult = MarkdownCommandDefSchema.safeParse(parsed);
     if (!validationResult.success) {
-      debugLogger16.error(
+      debugLogger14.error(
         `[FileCommandLoader] Skipping invalid command file: ${filePath}. Validation errors:`,
         validationResult.error.flatten()
       );
@@ -14489,7 +13697,7 @@ var FileCommandLoader = class {
 
 // packages/cli/src/services/saved-workflow-loader.ts
 init_esbuild_shims();
-var debugLogger17 = createDebugLogger("SavedWorkflowLoader");
+var debugLogger15 = createDebugLogger("SavedWorkflowLoader");
 var SavedWorkflowLoader = class {
   constructor(config) {
     this.config = config;
@@ -14508,7 +13716,7 @@ var SavedWorkflowLoader = class {
     try {
       entries = await listSavedWorkflows(this.config);
     } catch (e) {
-      debugLogger17.debug(`listSavedWorkflows failed: ${e}`);
+      debugLogger15.debug(`listSavedWorkflows failed: ${e}`);
       return [];
     }
     if (signal.aborted) return [];
@@ -14805,8 +14013,8 @@ var McpPromptLoader = class {
 
 // packages/cli/src/services/SkillCommandLoader.ts
 init_esbuild_shims();
-import { dirname as dirname5 } from "node:path";
-var debugLogger18 = createDebugLogger("SKILL_COMMAND_LOADER");
+import { dirname as dirname3 } from "node:path";
+var debugLogger16 = createDebugLogger("SKILL_COMMAND_LOADER");
 var SkillCommandLoader = class {
   constructor(config) {
     this.config = config;
@@ -14816,12 +14024,12 @@ var SkillCommandLoader = class {
   }
   async loadCommands(_signal) {
     if (this.config?.getBareMode?.()) {
-      debugLogger18.debug("Bare mode enabled, skipping skill commands");
+      debugLogger16.debug("Bare mode enabled, skipping skill commands");
       return [];
     }
     const skillManager = this.config?.getSkillManager();
     if (!skillManager) {
-      debugLogger18.debug("SkillManager not available, skipping skill commands");
+      debugLogger16.debug("SkillManager not available, skipping skill commands");
       return [];
     }
     try {
@@ -14838,7 +14046,7 @@ var SkillCommandLoader = class {
       const nonUserInvocableCount = visibleSkills.filter(
         (skill) => skill.userInvocable === false
       ).length;
-      debugLogger18.debug(
+      debugLogger16.debug(
         `Loaded ${userSkills.length} user + ${projectSkills.length} project + ${extensionSkills.length} extension skill(s) as slash commands; ${allSkills.length - visibleSkills.length} hidden by skills.disabled; ${nonUserInvocableCount} marked non-user-invocable`
       );
       return visibleSkills.map((skill) => {
@@ -14869,7 +14077,7 @@ var SkillCommandLoader = class {
               skill.allowedTools
             );
             const body = buildSkillLlmContent(
-              dirname5(skill.filePath),
+              dirname3(skill.filePath),
               skill.body
             );
             const content = context.invocation?.args ? appendToLastTextPart([{ text: body }], context.invocation.raw) : [{ text: body }];
@@ -14881,7 +14089,7 @@ var SkillCommandLoader = class {
         };
       });
     } catch (error) {
-      debugLogger18.error("Failed to load skill commands:", error);
+      debugLogger16.error("Failed to load skill commands:", error);
       return [];
     }
   }
@@ -14956,7 +14164,7 @@ function formatUserPromptExpansionBlockedMessage(reason) {
 __name(formatUserPromptExpansionBlockedMessage, "formatUserPromptExpansionBlockedMessage");
 
 // packages/cli/src/nonInteractiveCliCommands.ts
-var debugLogger19 = createDebugLogger("NON_INTERACTIVE_COMMANDS");
+var debugLogger17 = createDebugLogger("NON_INTERACTIVE_COMMANDS");
 function getSkillCommandName(command) {
   return command.skillDetail?.name ?? command.name;
 }
@@ -15167,6 +14375,60 @@ var handleSlashCommand = /* @__PURE__ */ __name(async (rawQuery, abortController
     rawQuery,
     filteredCommands
   );
+  const stackedResult = parseStackedSlashCommands(rawQuery, filteredCommands);
+  if (stackedResult.skills.length >= 2) {
+    const combinedContent = [];
+    let firstModelOverride;
+    const onCompleteCallbacks = [];
+    for (const skill of stackedResult.skills) {
+      if (!skill.action) continue;
+      const skillContext = {
+        executionMode,
+        invocation: {
+          raw: `/${skill.name}`,
+          name: skill.name,
+          args: ""
+        },
+        services: { config, settings, logger: null }
+      };
+      const skillResult = await skill.action(skillContext, "");
+      if (skillResult?.type === "submit_prompt") {
+        combinedContent.push(skillResult.content);
+        firstModelOverride ??= skillResult.modelOverride;
+        if (skillResult.onComplete) {
+          onCompleteCallbacks.push(skillResult.onComplete);
+        }
+      }
+      recordSkillInvocation(config, {
+        skillName: getSkillCommandName(skill),
+        success: skillResult?.type === "submit_prompt"
+      });
+    }
+    if (stackedResult.remainingText) {
+      combinedContent.push([{ text: stackedResult.remainingText }]);
+    }
+    const mergedContent = combinedContent.flat();
+    const hookResult = await fireUserPromptExpansionHook(
+      config,
+      stackedResult.skills.map((s) => s.name).join(" "),
+      stackedResult.remainingText,
+      mergedContent,
+      abortController.signal
+    );
+    if (hookResult.blockedResult) {
+      return hookResult.blockedResult;
+    }
+    return {
+      type: "submit_prompt",
+      content: hookResult.content,
+      ...firstModelOverride ? { modelOverride: firstModelOverride } : {},
+      ...onCompleteCallbacks.length ? {
+        onComplete: /* @__PURE__ */ __name(async () => {
+          for (const cb of onCompleteCallbacks) await cb();
+        }, "onComplete")
+      } : {}
+    };
+  }
   if (!commandToExecute) {
     const { commandToExecute: knownCommand } = parseSlashCommand(
       rawQuery,
@@ -15305,14 +14567,14 @@ var getAvailableCommands = /* @__PURE__ */ __name(async (config, abortSignal, mo
     );
     return commandService.getCommandsForMode(mode);
   } catch (error) {
-    debugLogger19.error("Error loading available commands:", error);
+    debugLogger17.error("Error loading available commands:", error);
     return [];
   }
 }, "getAvailableCommands");
 
 // packages/cli/src/utils/nonInteractiveHelpers.ts
 init_esbuild_shims();
-var debugLogger20 = createDebugLogger("NON_INTERACTIVE");
+var debugLogger18 = createDebugLogger("NON_INTERACTIVE");
 function normalizePartList(parts) {
   if (!parts) {
     return [];
@@ -15410,7 +14672,7 @@ async function loadSlashCommandNames(config) {
     );
     return commands.map((cmd) => cmd.name).sort();
   } catch (error) {
-    debugLogger20.error(
+    debugLogger18.error(
       "[buildSystemMessage] Failed to load slash commands:",
       error
     );
@@ -15435,7 +14697,7 @@ async function buildSystemMessage(config, sessionId, permissionMode) {
     const subagents = await subagentManager.listSubagents();
     agentNames = subagents.map((subagent) => subagent.name);
   } catch (error) {
-    debugLogger20.error("[buildSystemMessage] Failed to load subagents:", error);
+    debugLogger18.error("[buildSystemMessage] Failed to load subagents:", error);
   }
   const systemMessage = {
     type: "system",
@@ -15596,7 +14858,9 @@ function functionResponsePartsToString(parts) {
 __name(functionResponsePartsToString, "functionResponsePartsToString");
 
 export {
+  MAX_STACKED_SKILLS,
   parseSlashCommand,
+  parseStackedSlashCommands,
   CommandService,
   useAutoAcceptIndicator,
   formatApprovalModeName,
@@ -15611,8 +14875,6 @@ export {
   findMidInputSlashCommand,
   getBestSlashCommandMatch,
   findSlashCommandTokens,
-  performStandaloneUpdate,
-  getInstallationInfo,
   recordGoalStatusItem,
   restoreGoalFromHistory,
   getTranslatedSourceDisplayMap,