@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.1

package/chunks/{chunk-4OCYWXKF.js → chunk-5CVY5Q2P.js}

@@ -10,13 +10,13 @@ import {
   publishPendingCompileCache,
   reportRejectedLoaderKeys,
   resetLoaderKeyRejectionReportingForTesting
-} from "./chunk-NUQFUXOG.js";
+} from "./chunk-QTNCGZHQ.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-GEV66YGE.js";
+} from "./chunk-3VDLQUR2.js";
 import {
   require_main
-} from "./chunk-3K65MUKD.js";
+} from "./chunk-65I7S4Z3.js";
 import {
   QWEN_DIR,
   Storage,

package/chunks/{chunk-ZRVFHLLK.js → chunk-5DQ4YTIZ.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-N6VQ37ZZ.js";
 import {
   t
-} from "./chunk-LD53HMPV.js";
+} from "./chunk-CRZBDVP2.js";
 import {
   getPackageJson
 } from "./chunk-W3N5XAZ6.js";

package/chunks/{chunk-FWH4736Q.js → chunk-5IL2BZHW.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   GIT_COMMIT_INFO
-} from "./chunk-TDHVOZ65.js";
+} from "./chunk-6QILGINT.js";
 import {
   getCliVersion
-} from "./chunk-SHX2HIE7.js";
+} from "./chunk-27LTEY6D.js";
 import {
   IdeClient
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-PDUMGZ2P.js";
 import {
   formatMemoryUsage
 } from "./chunk-CHEIIBT3.js";

package/chunks/{chunk-537SQ2AI.js → chunk-5WC2ECUK.js}

@@ -3012,6 +3012,62 @@ var DaemonClient = class {
   async resumeSession(sessionId, req = {}, clientId) {
     return this.restoreSession("resume", sessionId, req, clientId);
   }
+  /**
+   * Transfer a worktree session's checkout ownership to a fresh replacement
+   * session (`POST /session/:id/worktree-reset`, capability
+   * `session_worktree_reset_v1`). Resolves 200 with the replacement
+   * session's create-shape response. The route never reads a caller-supplied
+   * client id, so this method takes none — but the response is not
+   * registration-free: a fresh transfer mints an owner-style `clientId` for
+   * the spawn it performs, registers it on the replacement, and returns it in
+   * the body, while an idempotent resume of a committed transfer returns
+   * none. That registration is not an attachment (the replacement's attach
+   * count is unaffected), and nothing detaches it for you — pass a minted id
+   * you do not keep using to `detachSession`, or the replacement never
+   * reaches the daemon's idle cleanup. Typed 409 bodies carry the reset
+   * taxonomy: `worktree_reset_unsupported` (not a worktree session),
+   * `worktree_reset_active` (a session involved is busy), and
+   * `worktree_reset_invalid_state` (corrupt or ambiguous ownership state; a
+   * partial transfer this request started is rolled back, while a
+   * pre-existing interrupted state is left untouched for operator repair).
+   * A crashed transfer whose sidecar links agree is self-healed here: a
+   * pre-commit one (the marker still names this session, or is absent while
+   * the replacement is dormant) is rolled back and re-run in the same
+   * request, and a committed one (the marker names the replacement) is
+   * finished idempotently. Every other interrupted shape — disagreeing links,
+   * an invalid marker, a marker naming a third session, a replacement still
+   * live with no marker — is reported as `worktree_reset_invalid_state` (or
+   * `worktree_reset_active` when the committed replacement is busy) and left
+   * untouched: a retry re-reads the same state and returns the same 409, so
+   * it does not converge and needs operator repair rather than a retry loop.
+   * `worktree_reset_interrupted`, `worktree_session_superseded`, and
+   * `worktree_marker_missing` belong to the restore surface (`loadSession` /
+   * `resumeSession`) instead; for `worktree_reset_interrupted` — the
+   * agreeing-links shape — retrying this reset against the superseded session
+   * is the repair.
+   */
+  async resetWorktreeSession(sessionId, req = {}) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/session/${urlEncode(sessionId)}/worktree-reset`,
+      {
+        method: "POST",
+        headers: this.headers({ "Content-Type": "application/json" }),
+        body: JSON.stringify({
+          ...req.workspaceCwd !== void 0 ? { cwd: req.workspaceCwd } : {},
+          ...req.modelServiceId !== void 0 ? { modelServiceId: req.modelServiceId } : {},
+          ...req.approvalMode !== void 0 ? { approvalMode: req.approvalMode } : {},
+          ...req.sourceType !== void 0 ? { sourceType: req.sourceType } : {},
+          ...req.sourceId !== void 0 ? { sourceId: req.sourceId } : {}
+        })
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "POST /session/:id/worktree-reset");
+        }
+        return await res.json();
+      }
+    );
+  }
   async branchSession(sessionId, req = {}, clientId) {
     return await this.fetchWithTimeout(
       `${this.baseUrl}/session/${urlEncode(sessionId)}/branch`,
@@ -6437,6 +6493,36 @@ var DaemonSessionClient = class _DaemonSessionClient {
       eventEpoch
     });
   }
+  /**
+   * Transfer a worktree session's checkout ownership to a fresh replacement
+   * session and return a client bound to the replacement's identity. That
+   * client carries whatever `clientId` the response had: a fresh transfer
+   * mints and registers an owner-style one for the spawn it performs, while
+   * an idempotent resume of a committed transfer returns none. The
+   * registration is not an attachment (the replacement's attach count is
+   * unaffected), but it is a client registration, and a non-empty one is what
+   * holds the daemon's idle cleanup off — so detach a minted id you do not
+   * keep using, or the replacement stays live indefinitely. A registered
+   * attachment still requires the normal restore surface: load or resume the
+   * replacement, passing the minted id to reuse that registration instead of
+   * adding a second one. The replacement is a brand-new conversation; the
+   * superseded session keeps its transcript on the daemon and is never
+   * restored again (its restore surfaces `worktree_session_superseded`). The
+   * existing reattach identity guard applies to the replacement client
+   * unchanged.
+   */
+  static async resetWorktree(client, sessionId, req = {}) {
+    const session = await client.resetWorktreeSession(sessionId, req);
+    return new _DaemonSessionClient({
+      client,
+      session,
+      hasActivePrompt: session.hasActivePrompt,
+      // The replacement is freshly created: seed from the start of its bus
+      // so events fired during the transfer window are not skipped.
+      lastEventId: 0,
+      eventEpoch: session.eventEpoch
+    });
+  }
   static async createStandalone(client, options = {}) {
     const session = await client.createStandaloneSession(options);
     return new _DaemonSessionClient({
@@ -6672,16 +6758,21 @@ var DaemonSessionClient = class _DaemonSessionClient {
     });
     this.reattaching = resume.then(async (session) => {
       if (this.session.worktreeState === "persisted-v1") {
-        const sameWorktree = session.worktreeState === "persisted-v1" && session.worktree?.path === this.session.worktree?.path;
-        if (!sameWorktree) {
-          await this.client.detachSession(session.sessionId, session.clientId).catch(() => {
-          });
-          throw new Error(
-            `Daemon lost durable worktree identity for session ${this.sessionId}`
-          );
+        if (!session.worktree) {
+          this.session.worktree = void 0;
+          this.session.worktreeState = void 0;
+        } else {
+          const sameWorktree = session.worktreeState === "persisted-v1" && session.worktree.path === this.session.worktree?.path;
+          if (!sameWorktree) {
+            await this.client.detachSession(session.sessionId, session.clientId).catch(() => {
+            });
+            throw new Error(
+              `Daemon lost durable worktree identity for session ${this.sessionId}`
+            );
+          }
+          this.session.worktree = session.worktree;
+          this.session.worktreeState = session.worktreeState;
         }
-        this.session.worktree = session.worktree;
-        this.session.worktreeState = session.worktreeState;
       }
       this.session.clientId = session.clientId;
     });
@@ -9369,13 +9460,10 @@ function normalizeDaemonEvent(event, opts = {}) {
         }
       ];
     case "slow_client_warning":
-      return [
-        {
-          ...base,
-          type: "status",
-          text: "SSE stream is lagging"
-        }
-      ];
+      if (typeof console !== "undefined") {
+        console.warn?.("[daemon-ui] SSE stream is lagging", event.data);
+      }
+      return [];
     case "stream_error": {
       const errorKind = asDaemonErrorKind(getString2(event.data, "errorKind"));
       return [

package/chunks/{chunk-3K65MUKD.js → chunk-65I7S4Z3.js}

@@ -382,7 +382,8 @@ function resolveEnvVarsInString(value, customEnv) {
   const envVarRegex = /\$(?:(\w+)|{([^}]+)})/g;
   return value.replace(envVarRegex, (match, varName1, varName2) => {
     const varName = varName1 || varName2;
-    if (isInternalSecretEnvVar(varName)) {
+    const normalizedVarName = varName.toUpperCase();
+    if (normalizedVarName === "SESSION_ID" || normalizedVarName === "QWEN_CODE_SESSION_ID" || isInternalSecretEnvVar(varName)) {
       return match;
     }
     if (customEnv && typeof customEnv[varName] === "string") {

package/chunks/{chunk-RUMSY4ES.js → chunk-66JBCTJF.js}

@@ -3,7 +3,7 @@
 import {
   customDeepMerge,
   getSettingsSchema
-} from "./chunk-QW7BUOSI.js";
+} from "./chunk-2ZFO5JD7.js";
 import {
   DEFAULT_DARK_THEME_NAME,
   DEFAULT_LIGHT_THEME_NAME
@@ -21,7 +21,7 @@ import {
 } from "./chunk-IDS7MSUP.js";
 import {
   t
-} from "./chunk-LD53HMPV.js";
+} from "./chunk-CRZBDVP2.js";
 import {
   SUPPORTED_LANGUAGES,
   getLanguageNameFromLocale
@@ -30,21 +30,21 @@ import {
   getHomeEnvFallbackVars,
   loadEnvironment,
   preResolveHomeEnvOverrides
-} from "./chunk-4OCYWXKF.js";
+} from "./chunk-5CVY5Q2P.js";
 import {
   ENV_CORRUPTED_PATH,
   ENV_WAS_RECOVERED
-} from "./chunk-NUQFUXOG.js";
+} from "./chunk-QTNCGZHQ.js";
 import {
   isWorkspaceTrusted,
   updateSettingsFilePreservingFormat
-} from "./chunk-GEV66YGE.js";
+} from "./chunk-3VDLQUR2.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
 import {
   resolveEnvVarsInObject
-} from "./chunk-3K65MUKD.js";
+} from "./chunk-65I7S4Z3.js";
 import {
   stripRuntimeSnapshotPrefix
 } from "./chunk-565U2ANU.js";
@@ -439,7 +439,8 @@ var WORKSPACE_RESTRICTED_SETTINGS = [
   { section: "tools", key: "workflowsEnabled" },
   { section: "security", key: "allowPrivateNetworkHooks" },
   { section: "security", key: "allowedInsecureVoiceBaseUrls" },
-  { section: "goals", key: "modelProposed" }
+  { section: "goals", key: "modelProposed" },
+  { section: "outboundCorrelation", key: "allowDynamicHeaderValues" }
 ];
 var WORKSPACE_TIGHTEN_ONLY_SETTINGS = [
   {

package/chunks/{chunk-YLFICBYK.js → chunk-6JXHO7LG.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   JsonFormatter
-} from "./chunk-TXAEXF2B.js";
+} from "./chunk-ZU2T5JIS.js";
 import {
   parseAndFormatApiError
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-PDUMGZ2P.js";
 import {
   FatalBudgetExceededError,
   FatalCancellationError,
@@ -14,7 +14,7 @@ import {
 } from "./chunk-ZAFYHRVY.js";
 import {
   runExitCleanup
-} from "./chunk-HPE4LEWX.js";
+} from "./chunk-USN6VNTO.js";
 import {
   writeStderrLine
 } from "./chunk-7FA2II6K.js";

package/chunks/{chunk-TDHVOZ65.js → chunk-6QILGINT.js}

@@ -6,8 +6,8 @@ import {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "4bfa3f93d3";
-var CLI_VERSION = "0.23.1-preview.2";
+var GIT_COMMIT_INFO = "d9331e6fcf";
+var CLI_VERSION = "0.23.1";
 
 export {
   GIT_COMMIT_INFO,

package/chunks/{chunk-WQBR7LN5.js → chunk-6QV7Z74P.js}

@@ -31,7 +31,7 @@ import {
 } from "./chunk-TIGXX4PA.js";
 import {
   DEFAULT_QWEN_MODEL
-} from "./chunk-PLUAIHZO.js";
+} from "./chunk-N7YQEKGX.js";
 import {
   atomicWriteFile
 } from "./chunk-XFFRI3WM.js";

package/chunks/{chunk-RSU3I6UL.js → chunk-6SADVYQQ.js}

@@ -9,7 +9,7 @@ import {
 import {
   RipgrepRuntimeRecoveryEvent,
   logRipgrepRuntimeRecovery
-} from "./chunk-WQBR7LN5.js";
+} from "./chunk-6QV7Z74P.js";
 import {
   DEFAULT_FILE_FILTERING_OPTIONS,
   QwenIgnoreParser,

package/chunks/{chunk-AIMZIXZM.js → chunk-6TPVIESH.js}

@@ -5,14 +5,14 @@ import {
 } from "./chunk-KW7NOTN6.js";
 import {
   DEFAULT_OPENAI_LOG_RETENTION_DAYS
-} from "./chunk-QW7BUOSI.js";
+} from "./chunk-2ZFO5JD7.js";
 import {
   resolveOpenAILogDir
-} from "./chunk-SD7Y2PMC.js";
+} from "./chunk-YAC7H4K3.js";
 import {
   FILE_HISTORY_DIR,
   getSubagentsRootDir
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-PDUMGZ2P.js";
 import {
   Storage,
   createDebugLogger,
@@ -169,10 +169,8 @@ var STALE_LOCK_MS = 60 * 60 * 1e3;
 async function runThrottledOnce(opts, task) {
   const minIntervalMs = opts.minIntervalMs ?? ONE_DAY_MS;
   const staleLockMs = opts.staleLockMs ?? STALE_LOCK_MS;
-  await mkdir(dirname(opts.lockPath), { recursive: true, mode: 448 }).catch(
-    () => {
-    }
-  );
+  await mkdir(dirname(opts.lockPath), { mode: 448 }).catch(() => {
+  });
   const firstFreshForMs = await markerFreshForMs(
     opts.markerPath,
     minIntervalMs,

package/chunks/{chunk-2LD5U7Q3.js → chunk-6YEOCHSE.js}

@@ -90,6 +90,33 @@ function applyReasoningEffort(config, effort) {
   return config.getReasoningEffort() === effort;
 }
 __name(applyReasoningEffort, "applyReasoningEffort");
+function parseModelReasoningCapabilities(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const candidate = value;
+  if (candidate["thinking"] !== true) return void 0;
+  const disableField = candidate["disableField"];
+  if (disableField !== "enable_thinking" && disableField !== "reasoning_effort" && disableField !== "thinking") {
+    return void 0;
+  }
+  if ("toggleOnly" in candidate && typeof candidate["toggleOnly"] !== "boolean" || "canDisable" in candidate && candidate["canDisable"] !== false) {
+    return void 0;
+  }
+  if (candidate["toggleOnly"] === true) {
+    return candidate;
+  }
+  const efforts = candidate["efforts"];
+  if (!Array.isArray(efforts) || efforts.length === 0 || !efforts.every(
+    (effort) => typeof effort === "string" && REASONING_EFFORT_TIERS.includes(effort)
+  ) || new Set(efforts).size !== efforts.length) {
+    return void 0;
+  }
+  const defaultEffort = candidate["defaultEffort"];
+  if (defaultEffort !== void 0 && !efforts.includes(defaultEffort)) {
+    return void 0;
+  }
+  return candidate;
+}
+__name(parseModelReasoningCapabilities, "parseModelReasoningCapabilities");
 
 export {
   resolveRequestTimeout,
@@ -105,7 +132,8 @@ export {
   REASONING_EFFORT_TIERS,
   normalizeReasoningEffort,
   clampReasoningEffort,
-  applyReasoningEffort
+  applyReasoningEffort,
+  parseModelReasoningCapabilities
 };
 /**
  * @license

package/chunks/{chunk-7PMKXGRP.js → chunk-75LBC7SV.js}

@@ -7,7 +7,7 @@ import {
   resolveStreamIdleTimeoutMs,
   resolveStreamMaxLifetimeMs,
   withStreamGuards
-} from "./chunk-ADJD4LZF.js";
+} from "./chunk-MA5OUNN6.js";
 import {
   OpenAIContentConverter,
   TaggedThinkingParser,
@@ -31,7 +31,7 @@ import {
 import {
   DashScopeOpenAICompatibleProvider,
   DefaultOpenAICompatibleProvider
-} from "./chunk-3K456UJF.js";
+} from "./chunk-VF6D6EGV.js";
 import {
   getCurrentAgentId
 } from "./chunk-H3Q3RSKZ.js";
@@ -40,19 +40,20 @@ import {
   getToolCallPreparations
 } from "./chunk-CFKIH3D3.js";
 import {
-  REASONING_EFFORT_TIERS
-} from "./chunk-2LD5U7Q3.js";
+  REASONING_EFFORT_TIERS,
+  parseModelReasoningCapabilities
+} from "./chunk-6YEOCHSE.js";
 import {
   createChildAbortController
 } from "./chunk-DJ2GSRLV.js";
 import {
   getRateLimitErrorDetails,
   getTransportCode
-} from "./chunk-W4LL5RZO.js";
+} from "./chunk-4ALNJDHL.js";
 import {
   ProtocolTagSanitizedEvent,
   logProtocolTagSanitized
-} from "./chunk-WQBR7LN5.js";
+} from "./chunk-6QV7Z74P.js";
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
@@ -1016,6 +1017,26 @@ function asObject(value) {
   return value;
 }
 __name(asObject, "asObject");
+function applyConfiguredReasoningEffort(request, capabilities) {
+  if (!capabilities || capabilities.toggleOnly || !Array.isArray(capabilities.efforts)) {
+    return request;
+  }
+  const loose = request;
+  const reasoning = asObject(loose["reasoning"]);
+  if (!reasoning || !("effort" in reasoning)) return request;
+  const effort = capabilities.efforts.find(
+    (candidate) => candidate === reasoning["effort"]
+  );
+  const { effort: _drop, ...rest } = reasoning;
+  const next = { ...loose };
+  if (Object.keys(rest).length > 0) next["reasoning"] = rest;
+  else delete next["reasoning"];
+  if (effort && next["reasoning_effort"] === void 0) {
+    next["reasoning_effort"] = effort;
+  }
+  return next;
+}
+__name(applyConfiguredReasoningEffort, "applyConfiguredReasoningEffort");
 function normalizeSchemaType(value) {
   if (typeof value !== "string") return void 0;
   const normalized = value.toLowerCase();
@@ -1467,7 +1488,7 @@ var ContentGenerationPipeline = class {
       request,
       context
     );
-    const baseRequest = {
+    let baseRequest = {
       model: context.model,
       messages,
       ...this.buildGenerateContentConfig(request),
@@ -1479,6 +1500,26 @@ var ContentGenerationPipeline = class {
     } else {
       baseRequest.stream = false;
     }
+    const authType = this.contentGeneratorConfig.authType;
+    const reasoningCapabilities = authType ? parseModelReasoningCapabilities(
+      this.config.cliConfig.getResolvedModelConfig?.(
+        authType,
+        context.model,
+        this.contentGeneratorConfig.baseUrl
+      )?.capabilities.reasoning
+    ) : void 0;
+    if (reasoningCapabilities && !("reasoning" in baseRequest) && this.contentGeneratorConfig.reasoning) {
+      baseRequest = {
+        ...baseRequest,
+        reasoning: this.contentGeneratorConfig.reasoning
+      };
+    }
+    if (this.contentGeneratorConfig.samplingParams?.["reasoning"] === void 0 && !isOpenRouterHostname(this.contentGeneratorConfig)) {
+      baseRequest = applyConfiguredReasoningEffort(
+        baseRequest,
+        reasoningCapabilities
+      );
+    }
     if (request.config?.tools && request.config.tools.length > 0) {
       baseRequest.tools = await OpenAIContentConverter.convertLlmToolsToOpenAI(
         request.config.tools,
@@ -1507,7 +1548,7 @@ var ContentGenerationPipeline = class {
     const isDashScope = DashScopeOpenAICompatibleProvider.isDashScopeProvider(
       this.contentGeneratorConfig
     );
-    const thinkingMandatory = this.requiresThinking(model);
+    const thinkingMandatory = reasoningCapabilities?.canDisable === false || this.requiresThinking(model);
     const reasoningDisabled = request.config?.thinkingConfig?.includeThoughts === false || this.contentGeneratorConfig.reasoning === false;
     if (reasoningDisabled) {
       const typed2 = providerRequest;
@@ -1529,13 +1570,22 @@ var ContentGenerationPipeline = class {
           };
         }
       }
+      if (!thinkingMandatory) {
+        if (reasoningCapabilities?.disableField === "reasoning_effort") {
+          delete typed2["enable_thinking"];
+          delete typed2["thinking_budget"];
+          typed2["reasoning_effort"] = "none";
+        } else if (reasoningCapabilities?.disableField === "enable_thinking") {
+          typed2["enable_thinking"] = false;
+        }
+      }
       if ("reasoning" in typed2) {
         delete typed2["reasoning"];
       }
       if ("reasoning_effort" in typed2 && typed2["reasoning_effort"] !== "none") {
         delete typed2["reasoning_effort"];
       }
-      if (isDeepSeekHostname(this.contentGeneratorConfig)) {
+      if (isDeepSeekHostname(this.contentGeneratorConfig) || reasoningCapabilities?.disableField === "thinking") {
         typed2["thinking"] = { type: "disabled" };
       }
       if (!thinkingMandatory && isOpenRouterHostname(this.contentGeneratorConfig)) {
@@ -1550,6 +1600,13 @@ var ContentGenerationPipeline = class {
       if (typed2["reasoning_effort"] === "none") {
         delete typed2["reasoning_effort"];
       }
+      const thinking = asObject(typed2["thinking"]);
+      if (thinking?.["type"] === "disabled") {
+        const remaining = { ...thinking };
+        delete remaining["type"];
+        if (Object.keys(remaining).length > 0) typed2["thinking"] = remaining;
+        else delete typed2["thinking"];
+      }
       const chatTemplateKwargs = typed2["chat_template_kwargs"];
       if (chatTemplateKwargs?.["enable_thinking"] === false) {
         const remaining = { ...chatTemplateKwargs };

package/chunks/{chunk-B5FF3LRF.js → chunk-7SL55L5H.js}

@@ -11,6 +11,7 @@ import {
   USER_AGREEMENT_RATE_MEDIUM,
   flattenModelsBySource,
   formatDuration as formatDuration2,
+  formatTokenCount as formatTokenCount2,
   getArenaStatusLabel,
   getStatusColor,
   isSafeOscScheme,
@@ -21,7 +22,7 @@ import {
   shouldWrapMarkdownLink,
   trimTrailingUrlPunctuation,
   useSessionStats
-} from "./chunk-KP5QK3FB.js";
+} from "./chunk-RNYENHN5.js";
 import {
   CompactToolGroupDisplay,
   ICON,
@@ -39,20 +40,20 @@ import {
   isCollapsibleTool,
   isFindingsListDisplay,
   wrapAnsi
-} from "./chunk-T7TP5UQL.js";
+} from "./chunk-E7XSUYCZ.js";
 import {
   disableMouseEvents,
   enableMouseEvents,
   useKeypress,
   useKeypressContext
-} from "./chunk-AWDF462I.js";
+} from "./chunk-WQMUGQ6G.js";
 import {
   formatSupportedModes,
   getCommandDisplayName,
   getCommandSourceBadge,
   getCommandSourceGroup,
   getCommandSubcommandNames
-} from "./chunk-VYCJITND.js";
+} from "./chunk-O2JBJQCF.js";
 import {
   INLINE_CODE_SPAN_PATTERN_SOURCE,
   calculateAverageLatency,
@@ -68,7 +69,7 @@ import {
   readInlineMathSpanAt,
   unescapeMarkdownBeforeMath,
   unescapeMarkdownDollars
-} from "./chunk-I67KJGM6.js";
+} from "./chunk-MFYH2VXV.js";
 import {
   formatDuration,
   formatRelativeTime,
@@ -103,10 +104,10 @@ import {
 } from "./chunk-5QWWOFGG.js";
 import {
   getErrorMessage
-} from "./chunk-YLFICBYK.js";
+} from "./chunk-6JXHO7LG.js";
 import {
   relaunchApp
-} from "./chunk-22QOQKG4.js";
+} from "./chunk-RXT4QBDX.js";
 import {
   markKittyImageWritten,
   prepareInlineTerminalImage,
@@ -142,18 +143,18 @@ import {
 } from "./chunk-57OAHC2Y.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-UTVIIA7N.js";
+} from "./chunk-FW4E4QPG.js";
 import {
   getPersistScopeForModelSelection
-} from "./chunk-RUMSY4ES.js";
+} from "./chunk-66JBCTJF.js";
 import {
   getCurrentLanguage,
   localizeToolDisplayName,
   t
-} from "./chunk-LD53HMPV.js";
+} from "./chunk-CRZBDVP2.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-GEV66YGE.js";
+} from "./chunk-3VDLQUR2.js";
 import {
   ALL_PROVIDERS,
   PROVIDER_METADATA_NS,
@@ -166,11 +167,11 @@ import {
   resolveBaseUrl,
   resolveMetadataKey,
   resolveOwnsModel
-} from "./chunk-TXAEXF2B.js";
+} from "./chunk-ZU2T5JIS.js";
 import {
   sanitizeForOsc,
   supportsHyperlinks
-} from "./chunk-VU7O7CGQ.js";
+} from "./chunk-XDNFODER.js";
 import {
   IdeClient,
   ShellExecutionService,
@@ -181,7 +182,7 @@ import {
   getExternalEditorCommand,
   ideContextStore,
   isValidEditorType
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-PDUMGZ2P.js";
 import {
   stripAnsi
 } from "./chunk-TWPJO254.js";
@@ -192,7 +193,7 @@ import {
   formatVisionBridgeNoticeDisplay,
   getMCPServerStatus,
   isVisionBridgeNoticeDisplay
-} from "./chunk-WQBR7LN5.js";
+} from "./chunk-6QV7Z74P.js";
 import {
   ToolNames,
   ToolNamesMigration,
@@ -16592,6 +16593,12 @@ var GoalStateCard = /* @__PURE__ */ __name(({
   if (goal.activeTimeMs > 0) {
     stats.push(formatDuration(goal.activeTimeMs, { hideTrailingZeros: true }));
   }
+  if (goal.tokensUsed > 0) {
+    const used = formatTokenCount2(goal.tokensUsed);
+    stats.push(
+      goal.tokenBudget === void 0 ? `${used} tokens` : `${used}/${formatTokenCount2(goal.tokenBudget)} tokens`
+    );
+  }
   const subtitle = stats.length > 0 ? stats.join(" \xB7 ") : null;
   const reason = goal.status !== "active" || snapshot.activity === "verifying" ? goal.lastReason?.trim() : void 0;
   return /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(Box_default, { flexDirection: "row", children: [