@qwen-code/qwen-code 0.19.7 → 0.19.8-nightly.20260710.205430235

package/chunks/chunk-6O6Z2I5Q.js

@@ -0,0 +1,292 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  redactLogCredentials
+} from "./chunk-HLKG6CZN.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/workspace-remember-errors.ts
+init_esbuild_shims();
+var MAX_REMEMBER_ERROR_DETAILS_CHARS = 1e3;
+var MAX_REMEMBER_ERROR_CAUSE_DEPTH = 50;
+var REMEMBER_ERROR_FORMAT_RE = new RegExp("[\\p{Cf}]|\\p{Variation_Selector}", "gu");
+var REMEMBER_ERROR_SPACE_SEPARATOR_RE = /[\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]/gu;
+var REMEMBER_ERROR_CREDENTIAL_SEPARATOR_RE = new RegExp("[\\x00-\\x1f\\x7f-\\x9f\\p{Cf}\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000]|\\p{Variation_Selector}", "gu");
+var REMEMBER_ERROR_AUTH_SCHEME_INVISIBLE_RE = new RegExp("\\b(Bearer|QQBot)(?:[\\x00-\\x1f\\x7f-\\x9f\\p{Cf}\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000]|\\p{Variation_Selector})+(?=[A-Za-z0-9._~+/=-])", "giu");
+var REMEMBER_ERROR_AUTH_TOKEN_WITH_SEPARATORS_RE = new RegExp("\\b(Bearer|QQBot)(?:\\s|[\\x00-\\x1f\\x7f-\\x9f\\p{Cf}\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000]|\\p{Variation_Selector})+((?:[A-Za-z0-9._~+/=-]+(?:[\\x00-\\x1f\\x7f-\\x9f\\p{Cf}\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000]|\\p{Variation_Selector})+)*[A-Za-z0-9._~+/=-]+)", "giu");
+var REMEMBER_ERROR_BARE_TOKEN_WITH_SEPARATORS_RE = new RegExp("\\b(?:sk-|ghp_|gho_|ghs_|ghu_|github_pat_|glpat-|xox[b]-|xox[p]-)(?:[A-Za-z0-9_-]+(?:[\\x00-\\x1f\\x7f-\\x9f\\p{Cf}\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000]|\\p{Variation_Selector})+)*[A-Za-z0-9_-]+", "gu");
+var REMEMBER_ERROR_AWS_KEY_WITH_SEPARATORS_RE = new RegExp("\\b(?:AKIA|ASIA)(?:[A-Z0-9]+(?:[\\x00-\\x1f\\x7f-\\x9f\\p{Cf}\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000]|\\p{Variation_Selector})+)*[A-Z0-9]+", "gu");
+var REMEMBER_ERROR_SECRET_ASSIGNMENT_WITH_SEPARATORS_RE = new RegExp("((?:api[_-]?key|token|secret|password|pwd)[_-]?[=:]\\s*)((?:\\S+(?:[\\x00-\\x1f\\x7f-\\x9f\\p{Cf}\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000]|\\p{Variation_Selector})+)*\\S+)", "giu");
+var REMEMBER_ERROR_ENV_SECRET_ASSIGNMENT_WITH_SEPARATORS_RE = new RegExp("([A-Z][A-Z0-9]{0,50}(?:_[A-Z0-9]{1,50}){0,10}_(?:KEY|TOKEN|SECRET|PASSWORD)\\s*[=:]\\s*)((?:\\S+(?:[\\x00-\\x1f\\x7f-\\x9f\\p{Cf}\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000]|\\p{Variation_Selector})+)*\\S+)", "gu");
+var REMEMBER_ERROR_URL_CREDENTIALS_WITH_SEPARATORS_RE = new RegExp("(\\b[a-z][a-z0-9+.-]{0,31}:\\/\\/)([^/@\\s]*(?:[\\x00-\\x1f\\x7f-\\x9f\\p{Cf}\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000]|\\p{Variation_Selector})+[^/@\\s]*)@", "giu");
+var REMEMBER_ERROR_CONTROL_RE = /[\x00-\x1f\x7f-\x9f]/g;
+var DETAIL_SUPPRESSED_REMEMBER_ERROR_CODES = /* @__PURE__ */ new Set([
+  "managed_memory_unavailable"
+]);
+function createWorkspaceMemoryExtractionErrorLogger(logger) {
+  return (target, err) => {
+    logger.warn(`Failed to extract workspace memory error ${target}:`, {
+      extractionError: err instanceof Error ? err.message : String(err)
+    });
+  };
+}
+__name(createWorkspaceMemoryExtractionErrorLogger, "createWorkspaceMemoryExtractionErrorLogger");
+function reportRememberErrorExtractionFailure(onExtractionError, target, err) {
+  try {
+    onExtractionError?.(target, err);
+  } catch {
+  }
+}
+__name(reportRememberErrorExtractionFailure, "reportRememberErrorExtractionFailure");
+function errorCodeFromRecord(record) {
+  if (typeof record["code"] === "string") return record["code"];
+  const data = record["data"];
+  if (data && typeof data === "object") {
+    const dataRecord = data;
+    if (typeof dataRecord["errorKind"] === "string") {
+      return dataRecord["errorKind"];
+    }
+    if (typeof dataRecord["code"] === "string") return dataRecord["code"];
+  }
+  return void 0;
+}
+__name(errorCodeFromRecord, "errorCodeFromRecord");
+function rawRememberErrorCode(err, seen, depth) {
+  if (depth > MAX_REMEMBER_ERROR_CAUSE_DEPTH) return void 0;
+  if (!err || typeof err !== "object") return void 0;
+  if (seen.has(err)) return void 0;
+  seen.add(err);
+  const record = err;
+  const direct = errorCodeFromRecord(record);
+  if (direct) return direct;
+  const cause = record["cause"];
+  if (cause != null) {
+    return rawRememberErrorCode(cause, seen, depth + 1);
+  }
+  return void 0;
+}
+__name(rawRememberErrorCode, "rawRememberErrorCode");
+function extractRememberErrorCode(err, fallback = "remember_failed") {
+  return rawRememberErrorCode(err, /* @__PURE__ */ new WeakSet(), 0) ?? fallback;
+}
+__name(extractRememberErrorCode, "extractRememberErrorCode");
+function workspaceMemoryFailureCode(err, fallback = "remember_failed", onExtractionError) {
+  try {
+    return extractRememberErrorCode(err, fallback);
+  } catch (extractionErr) {
+    reportRememberErrorExtractionFailure(
+      onExtractionError,
+      "code",
+      extractionErr
+    );
+    return fallback;
+  }
+}
+__name(workspaceMemoryFailureCode, "workspaceMemoryFailureCode");
+function detailFromRecord(record, seen, depth) {
+  const data = record["data"];
+  if (data && typeof data === "object") {
+    const dataRecord = data;
+    const details = dataRecord["details"];
+    if (typeof details === "string" && details.length > 0) return details;
+    const message2 = dataRecord["message"];
+    if (typeof message2 === "string" && message2.length > 0) return message2;
+  }
+  const message = record["message"];
+  if (typeof message === "string" && message.length > 0) return message;
+  if (typeof data === "string" && data.length > 0) return data;
+  const cause = record["cause"];
+  if (cause != null) {
+    return rawRememberErrorDetails(cause, seen, depth + 1);
+  }
+  return void 0;
+}
+__name(detailFromRecord, "detailFromRecord");
+function rawRememberErrorDetails(err, seen, depth) {
+  if (depth > MAX_REMEMBER_ERROR_CAUSE_DEPTH) return void 0;
+  if (typeof err === "string" && err.length > 0) return err;
+  if (!err || typeof err !== "object") return void 0;
+  if (seen.has(err)) return void 0;
+  seen.add(err);
+  return detailFromRecord(err, seen, depth);
+}
+__name(rawRememberErrorDetails, "rawRememberErrorDetails");
+function replaceControlChars(details) {
+  return details.replace(REMEMBER_ERROR_AUTH_SCHEME_INVISIBLE_RE, "$1 ").replace(REMEMBER_ERROR_FORMAT_RE, "").replace(REMEMBER_ERROR_SPACE_SEPARATOR_RE, " ").replace(REMEMBER_ERROR_CONTROL_RE, " ");
+}
+__name(replaceControlChars, "replaceControlChars");
+function replaceStackControlChars(stack) {
+  return stack.replace(REMEMBER_ERROR_AUTH_SCHEME_INVISIBLE_RE, "$1 ").replace(REMEMBER_ERROR_FORMAT_RE, "").replace(REMEMBER_ERROR_SPACE_SEPARATOR_RE, " ").replace(
+    REMEMBER_ERROR_CONTROL_RE,
+    (char) => char === "\n" || char === "\r" || char === "	" ? char : " "
+  );
+}
+__name(replaceStackControlChars, "replaceStackControlChars");
+function collapseCredentialSeparators(text) {
+  return text.replace(
+    REMEMBER_ERROR_URL_CREDENTIALS_WITH_SEPARATORS_RE,
+    (_match, scheme, userinfo) => `${scheme}${userinfo.replace(REMEMBER_ERROR_CREDENTIAL_SEPARATOR_RE, "")}@`
+  ).replace(
+    REMEMBER_ERROR_AUTH_TOKEN_WITH_SEPARATORS_RE,
+    (_match, scheme, token) => `${scheme} ${token.replace(REMEMBER_ERROR_CREDENTIAL_SEPARATOR_RE, "")}`
+  ).replace(
+    REMEMBER_ERROR_BARE_TOKEN_WITH_SEPARATORS_RE,
+    (token) => token.replace(REMEMBER_ERROR_CREDENTIAL_SEPARATOR_RE, "")
+  ).replace(
+    REMEMBER_ERROR_AWS_KEY_WITH_SEPARATORS_RE,
+    (token) => token.replace(REMEMBER_ERROR_CREDENTIAL_SEPARATOR_RE, "")
+  ).replace(
+    REMEMBER_ERROR_SECRET_ASSIGNMENT_WITH_SEPARATORS_RE,
+    (_match, prefix, value) => `${prefix}${value.replace(REMEMBER_ERROR_CREDENTIAL_SEPARATOR_RE, "")}`
+  ).replace(
+    REMEMBER_ERROR_ENV_SECRET_ASSIGNMENT_WITH_SEPARATORS_RE,
+    (_match, prefix, value) => `${prefix}${value.replace(REMEMBER_ERROR_CREDENTIAL_SEPARATOR_RE, "")}`
+  );
+}
+__name(collapseCredentialSeparators, "collapseCredentialSeparators");
+function collapseCredentialSeparatorsByStackLine(stack) {
+  return stack.split(/(\r\n|\n|\r)/).map(
+    (part) => part === "\r\n" || part === "\n" || part === "\r" ? part : collapseCredentialSeparators(part)
+  ).join("");
+}
+__name(collapseCredentialSeparatorsByStackLine, "collapseCredentialSeparatorsByStackLine");
+function isHighSurrogate(codeUnit) {
+  return codeUnit >= 55296 && codeUnit <= 56319;
+}
+__name(isHighSurrogate, "isHighSurrogate");
+function isLowSurrogate(codeUnit) {
+  return codeUnit >= 56320 && codeUnit <= 57343;
+}
+__name(isLowSurrogate, "isLowSurrogate");
+function truncateBeforeDanglingSurrogate(details, cutPoint) {
+  const beforeCut = details.charCodeAt(cutPoint - 1);
+  const atCut = details.charCodeAt(cutPoint);
+  if (isHighSurrogate(beforeCut) && isLowSurrogate(atCut)) {
+    return cutPoint - 1;
+  }
+  return cutPoint;
+}
+__name(truncateBeforeDanglingSurrogate, "truncateBeforeDanglingSurrogate");
+function capRememberErrorText(redacted) {
+  if (redacted.length <= MAX_REMEMBER_ERROR_DETAILS_CHARS) return redacted;
+  const truncationSuffix = "... [truncated]";
+  const cutPoint = truncateBeforeDanglingSurrogate(
+    redacted,
+    MAX_REMEMBER_ERROR_DETAILS_CHARS - truncationSuffix.length
+  );
+  return `${redacted.slice(0, cutPoint)}${truncationSuffix}`;
+}
+__name(capRememberErrorText, "capRememberErrorText");
+function redactAndCapRememberErrorText(normalized) {
+  const redacted = redactLogCredentials(normalized).trim();
+  if (!redacted) return void 0;
+  return capRememberErrorText(redacted);
+}
+__name(redactAndCapRememberErrorText, "redactAndCapRememberErrorText");
+function sanitizeRememberErrorDetails(details) {
+  return redactAndCapRememberErrorText(
+    replaceControlChars(collapseCredentialSeparators(details))
+  );
+}
+__name(sanitizeRememberErrorDetails, "sanitizeRememberErrorDetails");
+function sanitizeRememberErrorStack(stack) {
+  return redactAndCapRememberErrorText(
+    replaceStackControlChars(collapseCredentialSeparatorsByStackLine(stack))
+  );
+}
+__name(sanitizeRememberErrorStack, "sanitizeRememberErrorStack");
+function extractRememberErrorDetails(err) {
+  const raw = rawRememberErrorDetails(err, /* @__PURE__ */ new WeakSet(), 0);
+  if (!raw) return void 0;
+  return sanitizeRememberErrorDetails(raw);
+}
+__name(extractRememberErrorDetails, "extractRememberErrorDetails");
+function extractRememberErrorStack(err) {
+  if (!(err instanceof Error) || !err.stack) return void 0;
+  return sanitizeRememberErrorStack(err.stack);
+}
+__name(extractRememberErrorStack, "extractRememberErrorStack");
+function shouldSuppressRememberErrorDetails(code) {
+  return DETAIL_SUPPRESSED_REMEMBER_ERROR_CODES.has(code);
+}
+__name(shouldSuppressRememberErrorDetails, "shouldSuppressRememberErrorDetails");
+function workspaceMemoryFailureDiagnostics(err, onExtractionError) {
+  let details;
+  let stack;
+  try {
+    details = extractRememberErrorDetails(err);
+  } catch (extractionErr) {
+    reportRememberErrorExtractionFailure(
+      onExtractionError,
+      "details",
+      extractionErr
+    );
+    details = void 0;
+  }
+  try {
+    stack = extractRememberErrorStack(err);
+  } catch (extractionErr) {
+    reportRememberErrorExtractionFailure(
+      onExtractionError,
+      "stack",
+      extractionErr
+    );
+    stack = void 0;
+  }
+  return {
+    ...details ? { details } : {},
+    debugDetails: details ?? "<details unavailable>",
+    ...stack ? { stack } : {}
+  };
+}
+__name(workspaceMemoryFailureDiagnostics, "workspaceMemoryFailureDiagnostics");
+
+// packages/cli/src/serve/workspace-memory-remember-constants.ts
+init_esbuild_shims();
+var MAX_REMEMBER_CONTENT_BYTES = 64 * 1024;
+
+// packages/cli/src/serve/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.";
+}
+__name(formatWorkspaceMemoryForgetSummary, "formatWorkspaceMemoryForgetSummary");
+function formatWorkspaceMemoryDreamSummary(touchedTopicCount) {
+  return touchedTopicCount > 0 ? "Managed auto-memory dream completed." : "No managed auto-memory topics changed.";
+}
+__name(formatWorkspaceMemoryDreamSummary, "formatWorkspaceMemoryDreamSummary");
+
+// packages/cli/src/serve/validate-server-name.ts
+init_esbuild_shims();
+var VALID_SERVER_NAME = /^[A-Za-z0-9_-]+$/;
+var RESERVED_SERVER_NAMES = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function isValidServerName(name) {
+  return typeof name === "string" && name.length > 0 && name.length <= 256 && VALID_SERVER_NAME.test(name) && !RESERVED_SERVER_NAMES.has(name);
+}
+__name(isValidServerName, "isValidServerName");
+
+export {
+  createWorkspaceMemoryExtractionErrorLogger,
+  extractRememberErrorCode,
+  workspaceMemoryFailureCode,
+  shouldSuppressRememberErrorDetails,
+  workspaceMemoryFailureDiagnostics,
+  MAX_REMEMBER_CONTENT_BYTES,
+  formatWorkspaceMemoryForgetSummary,
+  formatWorkspaceMemoryDreamSummary,
+  isValidServerName
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-RYFZCUJO.js → chunk-6QKT5VNZ.js}

@@ -5,7 +5,7 @@ import {
   isTranscribableVoiceModel,
   readVoiceLanguage,
   resolveVoiceTransport
-} from "./chunk-ADZG46HR.js";
+} from "./chunk-YHGCTQG3.js";
 import {
   resolvePath
 } from "./chunk-E7KNELIZ.js";
@@ -368,12 +368,12 @@ async function assertVoiceBaseUrlNetworkAllowed(voiceConfig, lookupHost) {
   }
 }
 __name(assertVoiceBaseUrlNetworkAllowed, "assertVoiceBaseUrlNetworkAllowed");
-function readApiKey(settings, model, baseUrl) {
+function readApiKey(settings, model, baseUrl, env) {
   if (!model.envKey && !isQwenBaseUrl(baseUrl)) {
     return void 0;
   }
   const envKey = model.envKey ?? DEFAULT_OPENAI_API_KEY;
-  const envValue = process.env[envKey];
+  const envValue = (env ?? process.env)[envKey];
   if (envValue && envValue.trim().length > 0) {
     return envValue.trim();
   }
@@ -391,7 +391,8 @@ __name(readApiKey, "readApiKey");
 function resolveVoiceTranscriptionConfig({
   config,
   settings,
-  voiceModel
+  voiceModel,
+  env
 }) {
   const matches = config.getAllConfiguredModels().filter((model2) => model2.id === voiceModel);
   if (matches.length === 0) {
@@ -423,7 +424,7 @@ function resolveVoiceTranscriptionConfig({
       `Voice model '${voiceModel}' must not use a private-network baseUrl.`
     );
   }
-  const apiKey = readApiKey(settings, model, normalizedBaseUrl);
+  const apiKey = readApiKey(settings, model, normalizedBaseUrl, env);
   if (model.envKey && !apiKey) {
     throw new Error(`Voice model '${voiceModel}' requires ${model.envKey}.`);
   }
@@ -588,6 +589,7 @@ async function transcribeViaQwenAsr(audio, voiceConfig, options, fetchFn) {
   }
   let response;
   try {
+    options.onEgress?.();
     response = await fetchFn(
       `${trimTrailingSlashes(voiceConfig.baseUrl)}/chat/completions`,
       {
@@ -657,7 +659,12 @@ async function transcribeVoiceAudio(audio, args) {
       return transcribeViaQwenAsr(
         audio,
         voiceConfig,
-        { language, keytermsContext, abortSignal: args.abortSignal },
+        {
+          language,
+          keytermsContext,
+          abortSignal: args.abortSignal,
+          ...args.onEgress ? { onEgress: args.onEgress } : {}
+        },
         fetchFn
       );
     case "qwen-asr-realtime":
@@ -680,6 +687,7 @@ export {
   isStreamingVoiceModel,
   resolveVoiceStreamConfig,
   isKeytermEcho,
+  MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
 };

package/chunks/{chunk-SD4N3QJ2.js → chunk-6ZPSVWLF.js}

@@ -2,16 +2,17 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-I4A4K72C.js";
+} from "./chunk-5F2H3PXG.js";
 import {
   require_undici
 } from "./chunk-54YZOP7P.js";
 import {
+  IdeClient,
   getAllProviderBaseUrls
-} from "./chunk-YEGT55NW.js";
+} from "./chunk-ZDAZSR2O.js";
 import {
   initializeTelemetry
-} from "./chunk-GMOWQOQQ.js";
+} from "./chunk-5ZVIYNLN.js";
 import {
   detectRuntime,
   getOrCreateSharedDispatcher,
@@ -144,24 +145,38 @@ __name(preconnectApi, "preconnectApi");
 
 // packages/cli/src/startup/startup-prefetch.ts
 var debugLogger2 = createDebugLogger("STARTUP_PREFETCH");
-var DEFERRED_IDE_CONNECT_TIMEOUT_MS = 1e4;
+var DEFERRED_IDE_CONNECT_TIMEOUT_MS = 15e3;
 var earlyStarted = /* @__PURE__ */ new WeakSet();
 var postRenderStarted = /* @__PURE__ */ new WeakSet();
-function withTimeout(promise, name, timeoutMs) {
+function withTimeout(promise, name, timeoutMs, onTimeout = () => {
+}) {
   let timeoutId;
   let timedOut = false;
+  const runTimeoutCleanup = /* @__PURE__ */ __name(() => {
+    void Promise.resolve().then(onTimeout).catch((err) => {
+      debugLogger2.debug(`${name} timeout cleanup failed:`, err);
+    });
+  }, "runTimeoutCleanup");
   const timeout = new Promise((_, reject) => {
     timeoutId = setTimeout(() => {
       timedOut = true;
+      runTimeoutCleanup();
       reject(new Error(`${name} timed out after ${timeoutMs}ms`));
     }, timeoutMs);
     timeoutId.unref?.();
   });
-  promise.catch((err) => {
-    if (timedOut) {
-      debugLogger2.debug(`${name} underlying error after timeout:`, err);
+  void promise.then(
+    () => {
+      if (timedOut) {
+        runTimeoutCleanup();
+      }
+    },
+    (err) => {
+      if (timedOut) {
+        debugLogger2.debug(`${name} underlying error after timeout:`, err);
+      }
     }
-  });
+  );
   return Promise.race([promise, timeout]).finally(() => {
     if (timeoutId) {
       clearTimeout(timeoutId);
@@ -179,6 +194,11 @@ function runDeferredTask(name, task) {
   });
 }
 __name(runDeferredTask, "runDeferredTask");
+async function disconnectIdeAfterDeferredTimeout() {
+  const ideClient = await IdeClient.getInstance();
+  await ideClient.disconnect();
+}
+__name(disconnectIdeAfterDeferredTimeout, "disconnectIdeAfterDeferredTimeout");
 function startEarlyStartupPrefetches(config) {
   if (earlyStarted.has(config)) return;
   earlyStarted.add(config);
@@ -200,12 +220,35 @@ function startPostRenderPrefetches(config, settings, options = {}) {
   postRenderStarted.add(config);
   if (settings.merged.general?.enableAutoUpdate !== false) {
     runDeferredTask("update_check", async () => {
-      const [{ checkForUpdates }, { handleAutoUpdate }] = await Promise.all([
-        import("./updateCheck-E2ZX7RL7.js"),
-        import("./handleAutoUpdate-HN7ZOSXY.js")
+      const [
+        { checkForUpdatesDetailed },
+        { handleAutoUpdate },
+        { updateEventEmitter },
+        { t }
+      ] = await Promise.all([
+        import("./updateCheck-X3ZWDO3Z.js"),
+        import("./handleAutoUpdate-TEZC5ZIR.js"),
+        import("./updateEventEmitter-NXWTRHXY.js"),
+        import("./i18n-5QEODTJV.js")
       ]);
-      const info = await checkForUpdates();
-      handleAutoUpdate(info, settings, config.getProjectRoot());
+      const updateFailedMessage = t(
+        "Failed to check for updates. Please check your network or registry configuration."
+      );
+      try {
+        const result = await checkForUpdatesDetailed();
+        if (result.status === "update") {
+          handleAutoUpdate(result.info, settings, config.getProjectRoot());
+        } else if (result.status === "error") {
+          updateEventEmitter.emit("update-failed", {
+            message: updateFailedMessage
+          });
+        }
+      } catch (error) {
+        updateEventEmitter.emit("update-failed", {
+          message: updateFailedMessage
+        });
+        throw error;
+      }
     });
   }
   if (options.connectIde && config.getIdeMode()) {
@@ -214,11 +257,12 @@ function startPostRenderPrefetches(config, settings, options = {}) {
         state: "connecting"
       });
       try {
-        const { connectIdeForStartup } = await import("./initializer-SRN3IM42.js");
+        const { connectIdeForStartup } = await import("./initializer-222MPCLQ.js");
         await withTimeout(
           connectIdeForStartup(config),
           "ide_connect",
-          DEFERRED_IDE_CONNECT_TIMEOUT_MS
+          DEFERRED_IDE_CONNECT_TIMEOUT_MS,
+          disconnectIdeAfterDeferredTimeout
         );
         appEvents.emit("startup-ide-connection-status-changed" /* StartupIdeConnectionStatusChanged */, {
           state: "connected"
@@ -239,7 +283,7 @@ function startPostRenderPrefetches(config, settings, options = {}) {
   }
   if (config.isInteractive()) {
     runDeferredTask("background_housekeeping", async () => {
-      const { startBackgroundHousekeeping } = await import("./scheduler-ZRW3AIDU.js");
+      const { startBackgroundHousekeeping } = await import("./scheduler-FFATTAYZ.js");
       startBackgroundHousekeeping(config, settings);
     });
   }

package/chunks/{chunk-X265R5C6.js → chunk-7YGSDQ5J.js}

@@ -6,7 +6,7 @@ import {
 import {
   getPlanRequiredTeammatePreApprovalMessage,
   isPlanRequiredTeammateAwaitingApproval
-} from "./chunk-VEB3NYSO.js";
+} from "./chunk-ZJQBTFJ6.js";
 import {
   resolveActiveTeamName
 } from "./chunk-GO6LNQXT.js";
@@ -15,7 +15,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-X3YGAX7V.js";
+} from "./chunk-KS2FRTYI.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-PRDFOIZF.js → chunk-A6KEUFJO.js}

@@ -1,17 +1,21 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  formatHistoryGapNotice,
+  indexGapsByChild
+} from "./chunk-GVVY7GSP.js";
 import {
   require_undici
 } from "./chunk-54YZOP7P.js";
 import {
   writeStderrLine
-} from "./chunk-Y6Z2O3WR.js";
+} from "./chunk-JM7BYJO5.js";
 import {
   getActiveGoal
-} from "./chunk-YEGT55NW.js";
+} from "./chunk-ZDAZSR2O.js";
 import {
   ToolNames
-} from "./chunk-X3YGAX7V.js";
+} from "./chunk-KS2FRTYI.js";
 import {
   createDebugLogger
 } from "./chunk-22MNNNXE.js";
@@ -690,13 +694,21 @@ var HistoryReplayer = class {
    * Replays all chat records from a loaded session.
    *
    * @param records - Array of chat records to replay
+   * @param gaps - Optional detected history gaps; a visible notice is emitted
+   *   immediately before each gap's child record so the user sees that an
+   *   earlier segment was lost rather than assuming the halves are contiguous.
    */
-  async replay(records) {
+  async replay(records, gaps) {
     this.pendingReplayToolCalls.clear();
+    const gapByChildUuid = indexGapsByChild(gaps);
     try {
       let replayError;
       try {
         for (const record of records) {
+          const gap = gapByChildUuid.get(record.uuid);
+          if (gap) {
+            await this.emitHistoryGapNotice(gap, record.timestamp);
+          }
           await this.replayRecord(record);
         }
       } catch (error) {
@@ -798,6 +810,20 @@ var HistoryReplayer = class {
       this.setActiveRecordId(null);
     }
   }
+  /**
+   * Emits a visible notice marking a break in the persisted history chain: an
+   * earlier segment was physically lost (storage interruption) and could not be
+   * recovered, so the surviving turns below must not be read as contiguous with
+   * whatever came before the gap. Uses the agent message channel — the same one
+   * used for other system notices (see MessageEmitter.emitStopHookLoop) — so no
+   * new session-update kind is needed.
+   */
+  async emitHistoryGapNotice(gap, timestamp) {
+    await this.messageEmitter.emitAgentMessage(
+      formatHistoryGapNotice(gap),
+      timestamp
+    );
+  }
   /**
    * Replays content from a message (user or assistant).
    * Handles text parts, thought parts, and function calls.
@@ -863,6 +889,7 @@ var HistoryReplayer = class {
       success: !result?.error,
       message: record.message.parts,
       resultDisplay: result?.resultDisplay,
+      artifacts: result?.artifacts,
       // For TodoWriteTool fallback, try to extract args from the record
       // Note: args aren't stored in tool_result records by default
       args: void 0,
@@ -1603,7 +1630,7 @@ async function extractMetadata(conversation, config) {
   const gitBranch = firstRecord?.gitBranch;
   let gitRepo;
   if (cwd) {
-    const { getGitRepoName } = await import("./src-XKZMNHXS.js");
+    const { getGitRepoName } = await import("./src-NELBIIGI.js");
     gitRepo = getGitRepoName(cwd);
   }
   let model;