@qwen-code/qwen-code 0.21.2 → 0.21.3

package/chunks/{chunk-DUNI4EBW.js → chunk-4K3RV3OA.js}

@@ -5,20 +5,20 @@ import {
 } from "./chunk-VGC4I5JJ.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-3I6DUGQD.js";
+} from "./chunk-E4WHKETF.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-7ULQIS27.js";
+} from "./chunk-UEJESCS7.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   SchemaValidator,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MM7TH7ZM.js";
+} from "./chunk-CFDR3GNL.js";
 import {
   DEFAULT_QWEN_MODEL
-} from "./chunk-HIVKI6O6.js";
+} from "./chunk-H35Q5CEG.js";
 import {
   estimateTextTokens,
   generateLegacyMcpToolName,
@@ -29,10 +29,10 @@ import {
 } from "./chunk-ZBVS26BY.js";
 import {
   InstallationManager
-} from "./chunk-R2XWGR75.js";
+} from "./chunk-TYERNYH4.js";
 import {
   atomicWriteFile
-} from "./chunk-HC45LTEN.js";
+} from "./chunk-UH7Z7Y45.js";
 import {
   isTelemetrySdkInitialized,
   recordApiErrorMetrics,
@@ -53,7 +53,7 @@ import {
   recordSubagentExecutionMetrics,
   recordTokenUsageMetrics,
   recordToolCallMetrics
-} from "./chunk-QARJNL2V.js";
+} from "./chunk-O2ZYHG33.js";
 import {
   require_src,
   safeJsonStringify
@@ -113,7 +113,7 @@ import {
   makeRelative,
   shortenPath,
   unescapePath
-} from "./chunk-E2BHWIDT.js";
+} from "./chunk-3RXUYQJI.js";
 import {
   SemanticAttributes,
   init_esm
@@ -9730,12 +9730,15 @@ async function readFileWithLineAndLimit(params) {
   const endLine = Math.min(startLine + limit, originalLineCount);
   const actualStartLine = Math.min(startLine, originalLineCount);
   const selectedLines = lines.slice(actualStartLine, endLine);
+  const joined = selectedLines.join("\n");
   return {
-    content: selectedLines.join("\n"),
+    content: joined,
     bom,
     encoding,
     originalLineCount,
-    originalLineCountExact: true
+    originalLineCountExact: true,
+    truncatedByBytes: false,
+    lineEnding: detectLineEndingFromContent(joined)
   };
 }
 __name(readFileWithLineAndLimit, "readFileWithLineAndLimit");
@@ -10071,20 +10074,22 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
     preserveUnsupportedImage = false,
     preparePdfForVisionBridge = false,
     signal,
-    largePdfBehavior = "error"
+    largePdfBehavior = "error",
+    displayPath = filePath
   } = options;
   const rootDirectory = config.getTargetDir();
+  const relativePathForDisplay = (path2.isAbsolute(displayPath) ? path2.relative(rootDirectory, displayPath) : displayPath).replace(/\\/g, "/");
   try {
     signal?.throwIfAborted();
     let stats;
     try {
-      stats = await fs3.promises.stat(filePath);
+      stats = options.textFileStats ?? await fs3.promises.stat(filePath);
     } catch (error) {
       if (isNodeError(error) && error.code === "ENOENT") {
         return {
           llmContent: "Could not read file because no file was found at the specified path.",
           returnDisplay: "File not found.",
-          error: `File not found: ${filePath}`,
+          error: `File not found: ${displayPath}`,
           errorType: "file_not_found" /* FILE_NOT_FOUND */
         };
       }
@@ -10094,7 +10099,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       return {
         llmContent: "Could not read file because the provided path is a directory, not a file.",
         returnDisplay: "Path is a directory.",
-        error: `Path is a directory, not a file: ${filePath}`,
+        error: `Path is a directory, not a file: ${displayPath}`,
         errorType: "target_is_directory" /* TARGET_IS_DIRECTORY */
       };
     }
@@ -10102,15 +10107,14 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       return {
         llmContent: `Cannot read file: ${path2.basename(filePath)} is not a regular file (e.g. device, socket, or pipe).`,
         returnDisplay: "Not a regular file.",
-        error: `Not a regular file: ${filePath}`,
+        error: `Not a regular file: ${displayPath}`,
         errorType: "read_content_failure" /* READ_CONTENT_FAILURE */
       };
     }
-    const fileType = await detectFileType(filePath);
+    const fileType = options.textFileHandle ? "text" : await detectFileType(filePath);
     const mediaMimeType = index_lite_default.getType(filePath) ?? MIME_LITE_MISSING_VIDEO_TYPES.get(path2.extname(filePath).toLowerCase()) ?? "application/octet-stream";
     const shouldRenderImageOverview = fileType === "image" && CANONICAL_IMAGE_MIME_TYPES.has(mediaMimeType);
-    const relativePathForDisplay = path2.relative(rootDirectory, filePath).replace(/\\/g, "/");
-    const displayName = path2.basename(filePath);
+    const displayName = path2.basename(displayPath);
     const modalities = config.getContentGeneratorConfig?.()?.modalities ?? {};
     const willRenderPdfImages = fileType === "pdf" && !!modalities.image && largePdfBehavior !== "reference";
     const renderForBridge = fileType === "pdf" && !modalities.image && !modalities.pdf && (preserveUnsupportedImage || preparePdfForVisionBridge);
@@ -10149,7 +10153,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       return {
         llmContent: `PDF file is too large for full text extraction: ${fileSizeInMB.toFixed(2)}MB exceeds the ${PDF_FULL_TEXT_EXTRACTION_MAX_MB}MB limit. Use the 'pages' parameter to read a narrower range, or split the document into smaller files before retrying.`,
         returnDisplay: `PDF file too large (${fileSizeInMB.toFixed(2)}MB > ${PDF_FULL_TEXT_EXTRACTION_MAX_MB}MB).`,
-        error: `PDF exceeds extraction size limit: ${filePath} (${fileSizeInMB.toFixed(2)}MB)`,
+        error: `PDF exceeds extraction size limit: ${displayPath} (${fileSizeInMB.toFixed(2)}MB)`,
         errorType: "file_too_large" /* FILE_TOO_LARGE */,
         stats
       };
@@ -10158,7 +10162,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       return {
         llmContent: `PDF file is too large for page-range text extraction: ${fileSizeInMB.toFixed(2)}MB exceeds the ${PDF_PAGED_TEXT_EXTRACTION_MAX_MB}MB limit. Split the document into smaller files before retrying.`,
         returnDisplay: `PDF file too large (${fileSizeInMB.toFixed(2)}MB > ${PDF_PAGED_TEXT_EXTRACTION_MAX_MB}MB).`,
-        error: `PDF exceeds page-range extraction size limit: ${filePath} (${fileSizeInMB.toFixed(2)}MB)`,
+        error: `PDF exceeds page-range extraction size limit: ${displayPath} (${fileSizeInMB.toFixed(2)}MB)`,
         errorType: "file_too_large" /* FILE_TOO_LARGE */,
         stats
       };
@@ -10197,7 +10201,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       return {
         llmContent: "Image file exceeds the 100 MB source limit.",
         returnDisplay: "Image file exceeds the 100 MB source limit.",
-        error: `Image file exceeds the 100 MB source limit: ${filePath}`,
+        error: `Image file exceeds the 100 MB source limit: ${displayPath}`,
         errorType: "file_too_large" /* FILE_TOO_LARGE */
       };
     }
@@ -10205,7 +10209,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       return {
         llmContent: "File size exceeds the 10MB limit.",
         returnDisplay: "File size exceeds the 10MB limit.",
-        error: `File size exceeds the 10MB limit: ${filePath} (${fileSizeInMB.toFixed(2)}MB)`,
+        error: `File size exceeds the 10MB limit: ${displayPath} (${fileSizeInMB.toFixed(2)}MB)`,
         errorType: "file_too_large" /* FILE_TOO_LARGE */
       };
     }
@@ -10255,11 +10259,22 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
         };
       }
       case "text": {
-        const { content, _meta } = await config.getFileSystemService().readTextFile({
+        const fileSystemService = config.getFileSystemService();
+        const maxOutputBytes = getRangeReadByteLimit(config);
+        const readTextFileFromHandle = fileSystemService.readTextFileFromHandle;
+        const { content, _meta } = options.textFileHandle ? await readTextFileFromHandle.call(fileSystemService, {
+          fileHandle: options.textFileHandle,
+          fileSize: stats.size,
+          limit: limit ?? config.getTruncateToolOutputLines(),
+          line: offset,
+          maxOutputBytes,
+          maxScanBytes: options.textFileMaxScanBytes ?? maxOutputBytes,
+          ...signal !== void 0 ? { signal } : {}
+        }) : await fileSystemService.readTextFile({
           path: filePath,
           limit: limit ?? config.getTruncateToolOutputLines(),
           line: offset,
-          maxOutputBytes: getRangeReadByteLimit(config),
+          maxOutputBytes,
           stats,
           ...signal !== void 0 ? { signal } : {}
         });
@@ -10379,7 +10394,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
           return {
             llmContent: `File exceeds the 10MB data URI limit after base64 encoding (${base64SizeInMB.toFixed(2)}MB encoded).`,
             returnDisplay: `File exceeds the 10MB data URI limit after base64 encoding.`,
-            error: `File exceeds the 10MB data URI limit after base64 encoding: ${filePath} (${base64SizeInMB.toFixed(2)}MB encoded)`,
+            error: `File exceeds the 10MB data URI limit after base64 encoding: ${displayPath} (${base64SizeInMB.toFixed(2)}MB encoded)`,
             errorType: "file_too_large" /* FILE_TOO_LARGE */
           };
         }
@@ -10403,7 +10418,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
           return {
             llmContent: `File exceeds the 10MB data URI limit after base64 encoding (${base64SizeInMB.toFixed(2)}MB encoded).`,
             returnDisplay: `File exceeds the 10MB data URI limit after base64 encoding.`,
-            error: `File exceeds the 10MB data URI limit after base64 encoding: ${filePath} (${base64SizeInMB.toFixed(2)}MB encoded)`,
+            error: `File exceeds the 10MB data URI limit after base64 encoding: ${displayPath} (${base64SizeInMB.toFixed(2)}MB encoded)`,
             errorType: "file_too_large" /* FILE_TOO_LARGE */
           };
         }
@@ -10427,7 +10442,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
             return {
               llmContent: `File exceeds the 10MB data URI limit after base64 encoding (${base64SizeInMB.toFixed(2)}MB encoded).`,
               returnDisplay: `File exceeds the 10MB data URI limit after base64 encoding.`,
-              error: `File exceeds the 10MB data URI limit after base64 encoding: ${filePath} (${base64SizeInMB.toFixed(2)}MB encoded)`,
+              error: `File exceeds the 10MB data URI limit after base64 encoding: ${displayPath} (${base64SizeInMB.toFixed(2)}MB encoded)`,
               errorType: "file_too_large" /* FILE_TOO_LARGE */
             };
           }
@@ -10638,7 +10653,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
           return {
             llmContent: `Error parsing notebook ${relativePathForDisplay}: ${msg}`,
             returnDisplay: `Error reading notebook: ${relativePathForDisplay}`,
-            error: `Error parsing notebook ${filePath}: ${msg}`,
+            error: `Error parsing notebook ${displayPath}: ${msg}`,
             errorType: "read_content_failure" /* READ_CONTENT_FAILURE */
           };
         }
@@ -10648,7 +10663,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
         return {
           llmContent: `Unhandled file type: ${exhaustiveCheck}`,
           returnDisplay: `Skipped unhandled file type: ${relativePathForDisplay}`,
-          error: `Unhandled file type for ${filePath}`
+          error: `Unhandled file type for ${displayPath}`
         };
       }
     }
@@ -10657,11 +10672,10 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       throw error;
     }
     const errorMessage = getErrorMessage(error);
-    const displayPath = path2.relative(rootDirectory, filePath).replace(/\\/g, "/");
     return {
-      llmContent: `Error reading file ${displayPath}: ${errorMessage}`,
-      returnDisplay: `Error reading file ${displayPath}: ${errorMessage}`,
-      error: `Error reading file ${filePath}: ${errorMessage}`,
+      llmContent: `Error reading file ${relativePathForDisplay}: ${errorMessage}`,
+      returnDisplay: `Error reading file ${relativePathForDisplay}: ${errorMessage}`,
+      error: `Error reading file ${relativePathForDisplay}: ${errorMessage}`,
       errorType: "read_content_failure" /* READ_CONTENT_FAILURE */
     };
   }
@@ -10670,7 +10684,7 @@ __name(processSingleFileContent, "processSingleFileContent");
 function getRangeReadByteLimit(config) {
   const charLimit = config.getTruncateToolOutputThreshold();
   if (charLimit === Number.POSITIVE_INFINITY) {
-    return Number.POSITIVE_INFINITY;
+    return Number.MAX_SAFE_INTEGER;
   }
   if (!Number.isFinite(charLimit)) {
     return DEFAULT_RANGE_READ_BYTES;
@@ -11214,6 +11228,8 @@ var QwenLogger = class _QwenLogger {
           response_id: event.response_id,
           tool_name: event.function_name,
           permission: event.decision,
+          status: event.status,
+          tool_type: event.tool_type,
           success: event.success ? 1 : 0,
           duration_ms: event.duration_ms,
           error_type: event.error_type,
@@ -12780,42 +12796,55 @@ function logUserRetry(config, event) {
   logger.emit(logRecord);
 }
 __name(logUserRetry, "logUserRetry");
+function normalizeToolCallEvent(event) {
+  const isError = event.status === "error";
+  return {
+    ...event,
+    function_name: event.function_name.trim().length > 0 ? event.function_name : "unknown_tool",
+    success: event.status === "success",
+    error: isError ? event.error : void 0,
+    error_type: isError ? event.error_type?.trim() ? event.error_type : "unknown" /* UNKNOWN */ : void 0
+  };
+}
+__name(normalizeToolCallEvent, "normalizeToolCallEvent");
 function logToolCall(config, event) {
+  const normalizedEvent = normalizeToolCallEvent(event);
   const uiEvent = {
-    ...event,
+    ...normalizedEvent,
     "event.name": EVENT_TOOL_CALL,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
   uiTelemetryService.addEvent(uiEvent, config.getSessionId());
-  if (!isInternalPromptId(event.prompt_id)) {
+  if (!isInternalPromptId(normalizedEvent.prompt_id)) {
     recordUiTelemetryEventToChat(config, uiEvent);
   }
-  QwenLogger.getInstance(config)?.logToolCallEvent(event);
+  QwenLogger.getInstance(config)?.logToolCallEvent(normalizedEvent);
   if (!isTelemetrySdkInitialized()) return;
   const attributes = {
     ...getCommonAttributes(config),
-    ...event,
+    ...normalizedEvent,
     "event.name": EVENT_TOOL_CALL,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
-    function_args: safeJsonStringify(event.function_args, 2)
+    function_args: safeJsonStringify(normalizedEvent.function_args, 2)
   };
-  if (event.error) {
-    attributes["error.message"] = event.error;
-    if (event.error_type) {
-      attributes["error.type"] = event.error_type;
-    }
+  if (normalizedEvent.error) {
+    attributes["error.message"] = normalizedEvent.error;
+  }
+  if (normalizedEvent.error_type) {
+    attributes["error.type"] = normalizedEvent.error_type;
   }
   const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
   const logRecord = {
-    body: `Tool call: ${event.function_name}${event.decision ? `. Decision: ${event.decision}` : ""}. Success: ${event.success}. Duration: ${event.duration_ms}ms.`,
+    body: `Tool call: ${normalizedEvent.function_name}${normalizedEvent.decision ? `. Decision: ${normalizedEvent.decision}` : ""}. Success: ${normalizedEvent.success}. Duration: ${normalizedEvent.duration_ms}ms.`,
     attributes
   };
   logger.emit(logRecord);
-  recordToolCallMetrics(config, event.duration_ms, {
-    function_name: event.function_name,
-    success: event.success,
-    decision: event.decision,
-    tool_type: event.tool_type
+  recordToolCallMetrics(config, normalizedEvent.duration_ms, {
+    function_name: normalizedEvent.function_name,
+    status: normalizedEvent.status,
+    success: normalizedEvent.success,
+    decision: normalizedEvent.decision,
+    tool_type: normalizedEvent.tool_type
   });
 }
 __name(logToolCall, "logToolCall");
@@ -16980,6 +17009,7 @@ export {
   readFileWithLineAndLimit,
   getSpecificMimeType,
   isWithinRoot,
+  detectFileType,
   isCacheableReadResult,
   processSingleFileContent,
   fileExists,

package/chunks/{chunk-L2E5GFAG.js → chunk-4LKVQFHM.js}

@@ -9,7 +9,7 @@ import {
   relaxSchemaForFunctionCalling,
   safeJsonParse,
   setGenAiUsageProvenance
-} from "./chunk-QTHQ6Z5X.js";
+} from "./chunk-WK4TJUEA.js";
 import {
   setToolCallPreparations
 } from "./chunk-GLCZKT5V.js";
@@ -21,7 +21,7 @@ import {
 } from "./chunk-46UV252V.js";
 import {
   createDebugLogger
-} from "./chunk-E2BHWIDT.js";
+} from "./chunk-3RXUYQJI.js";
 import {
   FinishReason,
   GenerateContentResponse

package/chunks/{chunk-YDLJGZHL.js → chunk-4NFY2S7N.js}

@@ -109,38 +109,6 @@ function truncateToWidth(text, maxWidth) {
   return `${result}${ellipsis}`;
 }
 __name(truncateToWidth, "truncateToWidth");
-function wrapToVisualLines(text, width) {
-  if (width <= 0) {
-    return [""];
-  }
-  const visualLines = [];
-  for (const logicalLine of text.split("\n")) {
-    if (logicalLine === "") {
-      visualLines.push("");
-      continue;
-    }
-    let currentLine = "";
-    let currentWidth = 0;
-    for (const char of logicalLine) {
-      const charWidth = Math.max(getCachedStringWidth(char), 1);
-      if (currentWidth + charWidth > width && currentWidth > 0) {
-        visualLines.push(currentLine);
-        currentLine = "";
-        currentWidth = 0;
-      }
-      currentLine += char;
-      currentWidth += charWidth;
-    }
-    if (currentLine) {
-      visualLines.push(currentLine);
-    }
-  }
-  if (visualLines.length === 0) {
-    visualLines.push("");
-  }
-  return visualLines;
-}
-__name(wrapToVisualLines, "wrapToVisualLines");
 var regex = ansiRegex();
 var BARE_C0_CONTROL_CHARS_REGEX = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
 var BIDI_OVERRIDE_CHARS_REGEX = /[\u200e\u200f\u202a-\u202e\u2066-\u2069]/g;
@@ -289,7 +257,6 @@ export {
   stripUnsafeCharacters,
   getCachedStringWidth,
   truncateToWidth,
-  wrapToVisualLines,
   sanitizeTerminalText,
   escapeAnsiCtrlCodes,
   sanitizeSensitiveText,

package/chunks/{chunk-JLZ3RBQG.js → chunk-5JPVOYWA.js}

@@ -2,24 +2,41 @@
 "use strict";
 import {
   HistoryReplayer
-} from "./chunk-PZEXDV3H.js";
+} from "./chunk-VUNRNRN6.js";
 import {
   ChannelDeliveryError,
   MAX_CHANNEL_DELIVERY_TEXT_LENGTH
-} from "./chunk-U4VTUMMK.js";
+} from "./chunk-QONSRAEV.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
 import {
-  getResponseText
-} from "./chunk-54YCNSK5.js";
+  getUserSettingsPath,
+  loadSettings
+} from "./chunk-22YFMJBW.js";
+import {
+  getSystemDefaultsPath,
+  getSystemSettingsPath
+} from "./chunk-IDS7MSUP.js";
+import {
+  findEnvFiles,
+  preResolveHomeEnvOverrides
+} from "./chunk-6NE5NTHJ.js";
+import {
+  getResponseText,
+  ideContextStore
+} from "./chunk-UQDFEU47.js";
 import {
   MAX_CHANNEL_DELIVERY_NAME_LENGTH,
   MAX_CHANNEL_DELIVERY_TARGET_ID_LENGTH
-} from "./chunk-TEGJSJDF.js";
+} from "./chunk-MOHAWIAW.js";
 import {
   parseGoalSnapshotV2
-} from "./chunk-6FMJLI5M.js";
+} from "./chunk-HFVW54NL.js";
+import {
+  Storage,
+  createDebugLogger
+} from "./chunk-3RXUYQJI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -27,7 +44,7 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
-// packages/cli/src/serve/workspace-remember-errors.ts
+// packages/cli/src/runtime/workspace-remember-errors.ts
 init_esbuild_shims();
 var MAX_REMEMBER_ERROR_DETAILS_CHARS = 1e3;
 var MAX_REMEMBER_ERROR_CAUSE_DEPTH = 50;
@@ -263,11 +280,11 @@ function workspaceMemoryFailureDiagnostics(err, onExtractionError) {
 }
 __name(workspaceMemoryFailureDiagnostics, "workspaceMemoryFailureDiagnostics");
 
-// packages/cli/src/serve/workspace-memory-remember-constants.ts
+// packages/cli/src/runtime/workspace-memory-remember-constants.ts
 init_esbuild_shims();
 var MAX_REMEMBER_CONTENT_BYTES = 64 * 1024;
 
-// packages/cli/src/serve/workspace-memory-summaries.ts
+// packages/cli/src/runtime/workspace-memory-summaries.ts
 init_esbuild_shims();
 function formatWorkspaceMemoryForgetSummary(removedEntryCount) {
   return removedEntryCount > 0 ? `Forgot ${removedEntryCount} memory entr${removedEntryCount === 1 ? "y" : "ies"}.` : "No managed auto-memory entries matched.";
@@ -361,7 +378,7 @@ function restoreRedactedMcpServersSetting(value, existing) {
 }
 __name(restoreRedactedMcpServersSetting, "restoreRedactedMcpServersSetting");
 
-// packages/cli/src/serve/validate-server-name.ts
+// packages/cli/src/runtime/validate-server-name.ts
 init_esbuild_shims();
 var VALID_SERVER_NAME = /^[A-Za-z0-9_-]+$/;
 var RESERVED_SERVER_NAMES = /* @__PURE__ */ new Set([
@@ -432,6 +449,121 @@ async function executeGeneration(config, requestId, prompt, signal, emit) {
 }
 __name(executeGeneration, "executeGeneration");
 
+// packages/cli/src/config/settings-cache.ts
+init_esbuild_shims();
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var MAX_CACHE_ENTRIES = 64;
+var debugLogger = createDebugLogger("SETTINGS_CACHE");
+var cache = /* @__PURE__ */ new Map();
+function statSig(filePath) {
+  const st = fs.statSync(filePath, { throwIfNoEntry: false });
+  return st ? `${st.mtimeMs}:${st.size}:${st.ino}` : "missing";
+}
+__name(statSig, "statSig");
+function realpathOr(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return path.resolve(p);
+  }
+}
+__name(realpathOr, "realpathOr");
+function settingsFileSigs(workspaceDir) {
+  const filePaths = [
+    getSystemSettingsPath(),
+    getSystemDefaultsPath(),
+    getUserSettingsPath(),
+    new Storage(workspaceDir).getWorkspaceSettingsPath()
+  ];
+  return filePaths.map((filePath) => ({ filePath, sig: statSig(filePath) }));
+}
+__name(settingsFileSigs, "settingsFileSigs");
+function envFileSigs(settings, workspaceDir) {
+  return findEnvFiles(settings.merged, workspaceDir).map((filePath) => ({
+    filePath,
+    sig: statSig(filePath)
+  }));
+}
+__name(envFileSigs, "envFileSigs");
+function sameFileSigs(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  return a.every(
+    (sig, i) => sig.filePath === b[i].filePath && sig.sig === b[i].sig
+  );
+}
+__name(sameFileSigs, "sameFileSigs");
+function isEntryFresh(key, entry) {
+  const fp = entry.fingerprint;
+  return ideContextStore.get()?.workspaceState?.isTrusted === fp.ideTrust && realpathOr(key) === fp.realCwd && // homeDir guards the corner where nothing else moves: QWEN_HOME set (so
+  // settings paths don't follow HOME), no .env files anywhere, and the new
+  // home equals the workspace dir — which flips workspaceSettingsActive.
+  realpathOr(os.homedir()) === fp.homeDir && sameFileSigs(settingsFileSigs(key), fp.settingsFiles) && sameFileSigs(envFileSigs(entry.settings, key), fp.envFiles);
+}
+__name(isEntryFresh, "isEntryFresh");
+function loadSettingsCached(workspaceDir) {
+  preResolveHomeEnvOverrides();
+  const key = path.resolve(workspaceDir);
+  const entry = cache.get(key);
+  if (entry) {
+    let isFresh = false;
+    try {
+      isFresh = isEntryFresh(key, entry);
+    } catch (error) {
+      debugLogger.warn(
+        `fingerprint check failed for ${key}; reloading:`,
+        error
+      );
+    }
+    if (isFresh) {
+      cache.delete(key);
+      cache.set(key, entry);
+      debugLogger.debug(`hit ${key}`);
+      return entry.settings;
+    }
+    cache.delete(key);
+  }
+  debugLogger.debug(`miss ${key}`);
+  let preLoadSigs;
+  try {
+    preLoadSigs = settingsFileSigs(key);
+  } catch (error) {
+    debugLogger.warn(`pre-load signing failed for ${key}; not caching:`, error);
+  }
+  const settings = loadSettings(key);
+  if (preLoadSigs) {
+    try {
+      cache.set(key, {
+        settings,
+        fingerprint: {
+          settingsFiles: preLoadSigs,
+          // .env discovery needs the merged settings (trust), so it can only
+          // be signed after the load — see difference (2) in the module doc.
+          envFiles: envFileSigs(settings, key),
+          ideTrust: ideContextStore.get()?.workspaceState?.isTrusted,
+          realCwd: realpathOr(key),
+          homeDir: realpathOr(os.homedir())
+        }
+      });
+      if (cache.size > MAX_CACHE_ENTRIES) {
+        const oldest = cache.keys().next().value;
+        if (oldest !== void 0) {
+          cache.delete(oldest);
+          debugLogger.debug(`evicted LRU entry ${oldest}`);
+        }
+      }
+    } catch (error) {
+      cache.delete(key);
+      debugLogger.warn(`caching failed for ${key}; serving uncached:`, error);
+    }
+  }
+  return settings;
+}
+__name(loadSettingsCached, "loadSettingsCached");
+
 // packages/cli/src/acp-integration/session/history-replay-page.ts
 init_esbuild_shims();
 function createReplayCumulativeUsage() {
@@ -621,7 +753,7 @@ async function replayTranscriptRecordPage({
 }
 __name(replayTranscriptRecordPage, "replayTranscriptRecordPage");
 
-// packages/cli/src/serve/channel-delivery.ts
+// packages/cli/src/runtime/channel-delivery.ts
 init_esbuild_shims();
 var TRUNCATED_TEXT_SUFFIX = "\n\n[Channel delivery truncated because the result exceeded the delivery size limit.]";
 function isBoundedString(value, maxLength) {
@@ -707,6 +839,7 @@ export {
   GENERATION_MAX_PROMPT_BYTES,
   GENERATION_TIMEOUT_MS,
   executeGeneration,
+  loadSettingsCached,
   parseChannelDelivery,
   normalizeChannelDeliveryText,
   normalizeChannelDelivery,

package/chunks/{chunk-6TAASXWL.js → chunk-5VYFXHY2.js}

@@ -3,13 +3,13 @@
 import {
   resolveModelConfig,
   resolveProviderProtocol
-} from "./chunk-54YCNSK5.js";
+} from "./chunk-UQDFEU47.js";
 import {
   external_exports
 } from "./chunk-H6XPXXMH.js";
 import {
   stripRuntimeSnapshotPrefix
-} from "./chunk-ZMOJ7ISP.js";
+} from "./chunk-XUMAD5IT.js";
 import {
   REASONING_EFFORT_TIERS,
   normalizeReasoningEffort
@@ -17,7 +17,7 @@ import {
 import {
   AuthType,
   MODEL_GENERATION_CONFIG_FIELDS
-} from "./chunk-HIVKI6O6.js";
+} from "./chunk-H35Q5CEG.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-EU5TBFJI.js → chunk-6NE5NTHJ.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-6PEXNQTX.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-P755N4CS.js";
+} from "./chunk-M5LIY7Y6.js";
 import {
   require_main
 } from "./chunk-5M6IDOMF.js";
@@ -16,7 +16,7 @@ import {
   QWEN_DIR,
   Storage,
   getErrorMessage
-} from "./chunk-E2BHWIDT.js";
+} from "./chunk-3RXUYQJI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-XQK4XXTN.js → chunk-6O5DVH27.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getErrorStatus
-} from "./chunk-E2BHWIDT.js";
+} from "./chunk-3RXUYQJI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";