@qwen-code/qwen-code 0.19.3 → 0.19.4-nightly.20260702.46814e4f1

package/chunks/{chunk-O75BHFQW.js → chunk-UQTYK5SS.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   escapeAnsiCtrlCodes
-} from "./chunk-JJXWTVSK.js";
+} from "./chunk-XHZKDN7M.js";
 import {
   wrapper_default
 } from "./chunk-H6BD2ELD.js";
 import {
   createDebugLogger
-} from "./chunk-UX4SGCGN.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-Y6YMRS3U.js → chunk-UY2TCIZS.js}

@@ -2,16 +2,20 @@
 "use strict";
 import {
   createTask
-} from "./chunk-QLDPRILK.js";
+} from "./chunk-G7OQ3RFJ.js";
+import {
+  getPlanRequiredTeammatePreApprovalMessage,
+  isPlanRequiredTeammateAwaitingApproval
+} from "./chunk-BPFJQGY7.js";
 import {
   resolveActiveTeamName
-} from "./chunk-LD2XBG6Z.js";
+} from "./chunk-GO6LNQXT.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-BX5YO7UW.js";
+} from "./chunk-MTNTVOJR.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -69,6 +73,16 @@ var TaskCreateInvocation = class extends BaseToolInvocation {
     return Promise.resolve(details);
   }
   async execute() {
+    if (isPlanRequiredTeammateAwaitingApproval(this.config)) {
+      const msg = getPlanRequiredTeammatePreApprovalMessage(
+        ToolNames.TASK_CREATE
+      );
+      return {
+        llmContent: msg,
+        returnDisplay: msg,
+        error: { message: msg }
+      };
+    }
     const teamName = resolveActiveTeamName(
       this.config.getTeamContext()?.teamName
     );

package/chunks/{chunk-FNJ7BDPH.js → chunk-UY7ZAYTY.js}

@@ -2,24 +2,24 @@
 "use strict";
 import {
   t
-} from "./chunk-R5OP2ATH.js";
+} from "./chunk-JZG7VB6C.js";
 import {
   computeThresholds,
   getCoreSystemPrompt
-} from "./chunk-YAINVQ3Q.js";
+} from "./chunk-A5OPLHFM.js";
 import {
   buildSkillLlmContent
-} from "./chunk-HYCC3XM3.js";
+} from "./chunk-B236XPGF.js";
 import {
   DiscoveredMCPTool,
   uiTelemetryService
-} from "./chunk-QNKBEJO2.js";
+} from "./chunk-UA6XBZT7.js";
 import {
   ToolNames
-} from "./chunk-BX5YO7UW.js";
+} from "./chunk-MTNTVOJR.js";
 import {
   DEFAULT_TOKEN_LIMIT
-} from "./chunk-U3KSMM7G.js";
+} from "./chunk-YTFBURQD.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -145,7 +145,10 @@ ${skill.level}
     };
   });
   const skillsTokens = skillToolDefinitionTokens + loadedBodiesTokens;
-  const thresholds = computeThresholds(contextWindowSize);
+  const thresholds = computeThresholds(
+    contextWindowSize,
+    config.getAutoCompactThreshold()
+  );
   const autocompactBuffer = Math.max(
     0,
     Math.round(contextWindowSize - thresholds.auto)

package/chunks/{chunk-UYT3MWEB.js → chunk-UYHWM24C.js}

@@ -4,14 +4,18 @@ import {
   resolveModelConfig,
   resolveProviderProtocol,
   stripRuntimeSnapshotPrefix
-} from "./chunk-YAINVQ3Q.js";
+} from "./chunk-A5OPLHFM.js";
 import {
   external_exports
 } from "./chunk-K5PGHDBN.js";
 import {
   AuthType,
   MODEL_GENERATION_CONFIG_FIELDS
-} from "./chunk-QNKBEJO2.js";
+} from "./chunk-UA6XBZT7.js";
+import {
+  REASONING_EFFORT_TIERS,
+  normalizeReasoningEffort
+} from "./chunk-SIUQ3YYX.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -103,6 +107,19 @@ function parseAcpModelOption(input) {
   return { modelId: trimmed };
 }
 __name(parseAcpModelOption, "parseAcpModelOption");
+function isInlineModelOverrideAllowed(config, modelId) {
+  const contentGeneratorConfig = config.getContentGeneratorConfig();
+  const authType = contentGeneratorConfig?.authType;
+  if (!authType) {
+    return false;
+  }
+  const activeBaseUrl = contentGeneratorConfig.baseUrl;
+  const activeEnvKey = contentGeneratorConfig.apiKeyEnvKey;
+  return config.getAvailableModelsForAuthType(authType).filter((m) => !m.fastOnly && !m.voiceOnly).some(
+    (m) => m.id === modelId && (m.baseUrl ?? void 0) === (activeBaseUrl ?? void 0) && (m.envKey ?? void 0) === (activeEnvKey ?? void 0)
+  );
+}
+__name(isInlineModelOverrideAllowed, "isInlineModelOverrideAllowed");
 
 // packages/cli/src/utils/modelConfigUtils.ts
 init_esbuild_shims();
@@ -311,6 +328,15 @@ function resolveCliGenerationConfig(inputs) {
     enableOpenAILogging,
     openAILoggingDir
   };
+  const rawReasoningEffort = settings.model?.reasoningEffort;
+  const reasoningEffort = normalizeReasoningEffort(rawReasoningEffort);
+  const invalidReasoningEffortWarning = rawReasoningEffort && !reasoningEffort ? `Ignoring invalid model.reasoningEffort "${rawReasoningEffort}"; expected one of: ${REASONING_EFFORT_TIERS.join(", ")}.` : void 0;
+  if (reasoningEffort && generationConfig.reasoning !== false) {
+    generationConfig.reasoning = {
+      ...generationConfig.reasoning ?? {},
+      effort: reasoningEffort
+    };
+  }
   return {
     model: resolved.config.model || "",
     apiKey: resolved.config.apiKey || "",
@@ -319,6 +345,7 @@ function resolveCliGenerationConfig(inputs) {
     sources: resolved.sources,
     warnings: [
       ...resolved.warnings,
+      ...invalidReasoningEffortWarning ? [invalidReasoningEffortWarning] : [],
       ...disambiguationWarning ? [disambiguationWarning] : [],
       ...ignoredGenerationConfigWarning ? [ignoredGenerationConfigWarning] : [],
       ...buildSkippedProviderWarnings(
@@ -335,6 +362,7 @@ export {
   sanitizeProviderBaseUrl,
   parseAcpBaseModelId,
   parseAcpModelOption,
+  isInlineModelOverrideAllowed,
   collectProviderModelsForProtocol,
   getAuthTypeFromEnv,
   resolveCliGenerationConfig

package/chunks/{chunk-SMXULRAN.js → chunk-VXGPYF7U.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   themeManager
-} from "./chunk-I4H7PRWQ.js";
+} from "./chunk-HTWHAN44.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-BTLJ2MF5.js → chunk-W7CG5HPC.js}

@@ -5,14 +5,14 @@ import {
   isTranscribableVoiceModel,
   readVoiceLanguage,
   resolveVoiceTransport
-} from "./chunk-4LUZAKMK.js";
+} from "./chunk-7KXAGQJ2.js";
 import {
   resolvePath
-} from "./chunk-BC3C4F3Q.js";
+} from "./chunk-NIOPRZNN.js";
 import {
   createDebugLogger,
   isSubpath
-} from "./chunk-UX4SGCGN.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-JJXWTVSK.js → chunk-XHZKDN7M.js}

@@ -4,7 +4,7 @@ import {
   ansiRegex,
   init_ansi_regex,
   stripAnsi
-} from "./chunk-YAINVQ3Q.js";
+} from "./chunk-A5OPLHFM.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -249,6 +249,38 @@ var getCachedStringWidth = /* @__PURE__ */ __name((str) => {
   stringWidthCache.set(str, width);
   return width;
 }, "getCachedStringWidth");
+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 = getCachedStringWidth(char);
+      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();
 function escapeAnsiCtrlCodes(obj) {
   if (typeof obj === "string") {
@@ -386,6 +418,7 @@ export {
   cpSlice,
   stripUnsafeCharacters,
   getCachedStringWidth,
+  wrapToVisualLines,
   escapeAnsiCtrlCodes,
   sanitizeSensitiveText,
   sanitizeFilenameForDisplay

package/chunks/{chunk-K5XU6E4T.js → chunk-XKSCTXPK.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   isTeamAutoMemPath
-} from "./chunk-RD6YJJJ6.js";
+} from "./chunk-MOUXUCXQ.js";
 import {
   createDebugLogger
-} from "./chunk-UX4SGCGN.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/chunk-Y4LITCRB.js

@@ -0,0 +1,367 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  disableMouseEvents,
+  enableMouseEvents,
+  useKeypressContext
+} from "./chunk-SCYK2YLI.js";
+import {
+  use_stdin_default,
+  use_stdout_default
+} from "./chunk-LOW52WYZ.js";
+import {
+  require_react
+} from "./chunk-KYMBIKIW.js";
+import {
+  themeManager
+} from "./chunk-HTWHAN44.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/ui/contexts/SettingsContext.tsx
+init_esbuild_shims();
+var import_react = __toESM(require_react(), 1);
+var SettingsContext = import_react.default.createContext(
+  void 0
+);
+var useSettings = /* @__PURE__ */ __name(() => {
+  const context = (0, import_react.useContext)(SettingsContext);
+  if (context === void 0) {
+    throw new Error("useSettings must be used within a SettingsProvider");
+  }
+  return context;
+}, "useSettings");
+
+// packages/cli/src/ui/hooks/useTerminalSize.ts
+init_esbuild_shims();
+var import_react2 = __toESM(require_react(), 1);
+function useTerminalSize() {
+  const [size, setSize] = (0, import_react2.useState)({
+    columns: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24
+  });
+  (0, import_react2.useEffect)(() => {
+    function updateSize() {
+      setSize({
+        columns: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24
+      });
+    }
+    __name(updateSize, "updateSize");
+    process.stdout.on("resize", updateSize);
+    return () => {
+      process.stdout.off("resize", updateSize);
+    };
+  }, []);
+  return size;
+}
+__name(useTerminalSize, "useTerminalSize");
+
+// packages/cli/src/ui/hooks/useMouseEvents.ts
+init_esbuild_shims();
+var import_react3 = __toESM(require_react(), 1);
+var mouseModeRefs = /* @__PURE__ */ new Map();
+function effectiveTracking(entry) {
+  if (entry.any > 0) return "any";
+  if (entry.button > 0) return "button";
+  return null;
+}
+__name(effectiveTracking, "effectiveTracking");
+function reconcileMouseMode(stdout, entry) {
+  const desired = effectiveTracking(entry);
+  if (desired === entry.active) return;
+  if (entry.active) disableMouseEvents(stdout, entry.active);
+  if (desired) enableMouseEvents(stdout, desired);
+  entry.active = desired;
+}
+__name(reconcileMouseMode, "reconcileMouseMode");
+var disableAllMouseModes = /* @__PURE__ */ __name(() => {
+  for (const [stdout, entry] of mouseModeRefs) {
+    if (entry.active) disableMouseEvents(stdout, entry.active);
+  }
+  mouseModeRefs.clear();
+}, "disableAllMouseModes");
+function acquireMouseMode(stdout, tracking) {
+  let entry = mouseModeRefs.get(stdout);
+  if (!entry) {
+    if (mouseModeRefs.size === 0) {
+      process.on("exit", disableAllMouseModes);
+    }
+    entry = { button: 0, any: 0, active: null };
+    mouseModeRefs.set(stdout, entry);
+  }
+  entry[tracking] += 1;
+  reconcileMouseMode(stdout, entry);
+}
+__name(acquireMouseMode, "acquireMouseMode");
+function releaseMouseMode(stdout, tracking) {
+  const entry = mouseModeRefs.get(stdout);
+  if (!entry) return;
+  entry[tracking] = Math.max(0, entry[tracking] - 1);
+  reconcileMouseMode(stdout, entry);
+  if (entry.button === 0 && entry.any === 0) {
+    mouseModeRefs.delete(stdout);
+    if (mouseModeRefs.size === 0) {
+      process.removeListener("exit", disableAllMouseModes);
+    }
+  }
+}
+__name(releaseMouseMode, "releaseMouseMode");
+function useMouseEvents(handler, { isActive, tracking = "button", bypassVpGate = false }) {
+  const { isRawModeSupported } = use_stdin_default();
+  const { stdout } = use_stdout_default();
+  const { subscribeMouse, unsubscribeMouse } = useKeypressContext();
+  const settings = (0, import_react3.useContext)(SettingsContext);
+  const isVpMode = settings?.merged.ui?.useTerminalBuffer ?? false;
+  const vpGateOpen = isVpMode || bypassVpGate;
+  const handlerRef = (0, import_react3.useRef)(handler);
+  handlerRef.current = handler;
+  const enabled = isActive && isRawModeSupported && vpGateOpen;
+  (0, import_react3.useEffect)(() => {
+    if (!enabled) return;
+    acquireMouseMode(stdout, tracking);
+    return () => {
+      releaseMouseMode(stdout, tracking);
+    };
+  }, [enabled, stdout, tracking]);
+  const mouseCallback = (0, import_react3.useCallback)((event) => {
+    handlerRef.current(event);
+  }, []);
+  (0, import_react3.useEffect)(() => {
+    if (!enabled) return;
+    subscribeMouse(mouseCallback);
+    return () => unsubscribeMouse(mouseCallback);
+  }, [enabled, subscribeMouse, unsubscribeMouse, mouseCallback]);
+}
+__name(useMouseEvents, "useMouseEvents");
+
+// packages/cli/src/ui/colors.ts
+init_esbuild_shims();
+var Colors = {
+  get type() {
+    return themeManager.getActiveTheme().colors.type;
+  },
+  get Foreground() {
+    return themeManager.getActiveTheme().colors.Foreground;
+  },
+  get Background() {
+    return themeManager.getActiveTheme().colors.Background;
+  },
+  get LightBlue() {
+    return themeManager.getActiveTheme().colors.LightBlue;
+  },
+  get AccentBlue() {
+    return themeManager.getActiveTheme().colors.AccentBlue;
+  },
+  get AccentPurple() {
+    return themeManager.getActiveTheme().colors.AccentPurple;
+  },
+  get AccentCyan() {
+    return themeManager.getActiveTheme().colors.AccentCyan;
+  },
+  get AccentGreen() {
+    return themeManager.getActiveTheme().colors.AccentGreen;
+  },
+  get AccentYellow() {
+    return themeManager.getActiveTheme().colors.AccentYellow;
+  },
+  get AccentRed() {
+    return themeManager.getActiveTheme().colors.AccentRed;
+  },
+  get AccentYellowDim() {
+    return themeManager.getActiveTheme().colors.AccentYellowDim;
+  },
+  get AccentRedDim() {
+    return themeManager.getActiveTheme().colors.AccentRedDim;
+  },
+  get DiffAdded() {
+    return themeManager.getActiveTheme().colors.DiffAdded;
+  },
+  get DiffRemoved() {
+    return themeManager.getActiveTheme().colors.DiffRemoved;
+  },
+  get Comment() {
+    return themeManager.getActiveTheme().colors.Comment;
+  },
+  get Gray() {
+    return themeManager.getActiveTheme().colors.Gray;
+  },
+  get GradientColors() {
+    return themeManager.getActiveTheme().colors.GradientColors;
+  }
+};
+
+// packages/cli/src/ui/utils/measure-element-position.ts
+init_esbuild_shims();
+
+// packages/cli/src/ui/utils/list-mouse.ts
+init_esbuild_shims();
+function frameAnchor(terminalHeight, frameHeight) {
+  return Math.min(0, terminalHeight - frameHeight);
+}
+__name(frameAnchor, "frameAnchor");
+function terminalRowToLayoutRow(terminalRow1Based, anchor) {
+  return terminalRow1Based - 1 - anchor;
+}
+__name(terminalRowToLayoutRow, "terminalRowToLayoutRow");
+function findItemAtLayoutRow(rects, layoutRow) {
+  for (const rect of rects) {
+    if (layoutRow >= rect.top && layoutRow < rect.top + rect.height) {
+      return rect.index;
+    }
+  }
+  return null;
+}
+__name(findItemAtLayoutRow, "findItemAtLayoutRow");
+
+// packages/cli/src/ui/utils/measure-element-position.ts
+function measureElementPosition(node) {
+  const { yogaNode } = node;
+  if (!yogaNode) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  let x = yogaNode.getComputedLeft();
+  let y = yogaNode.getComputedTop();
+  let current = node.parentNode;
+  while (current) {
+    if (current.yogaNode) {
+      x += current.yogaNode.getComputedLeft();
+      y += current.yogaNode.getComputedTop();
+    }
+    current = current.parentNode;
+  }
+  return {
+    x,
+    y,
+    width: yogaNode.getComputedWidth(),
+    height: yogaNode.getComputedHeight()
+  };
+}
+__name(measureElementPosition, "measureElementPosition");
+function measureFrameHeight(node) {
+  let root = node;
+  let current = node;
+  while (current) {
+    root = current;
+    current = current.parentNode;
+  }
+  return root.yogaNode?.getComputedHeight() ?? 0;
+}
+__name(measureFrameHeight, "measureFrameHeight");
+function layoutRowForEvent(node, terminalRow1Based, terminalHeight) {
+  const anchor = frameAnchor(terminalHeight, measureFrameHeight(node));
+  return terminalRowToLayoutRow(terminalRow1Based, anchor);
+}
+__name(layoutRowForEvent, "layoutRowForEvent");
+
+// packages/cli/src/ui/components/shared/RowMouseController.tsx
+init_esbuild_shims();
+var import_react4 = __toESM(require_react(), 1);
+function RowMouseController({
+  containerRef,
+  itemRefs,
+  scrollOffset,
+  isDisabled,
+  onHoverIndex,
+  onSelectIndex
+}) {
+  const { rows: terminalHeight } = useTerminalSize();
+  const resolveIndex = (0, import_react4.useCallback)(
+    (event) => {
+      const container = containerRef.current;
+      if (!container) return null;
+      const containerRect = measureElementPosition(container);
+      const col0 = event.col - 1;
+      if (containerRect.width > 0 && (col0 < containerRect.x || col0 >= containerRect.x + containerRect.width)) {
+        return null;
+      }
+      const layoutRow = layoutRowForEvent(container, event.row, terminalHeight);
+      const rects = [];
+      const nodes = itemRefs.current;
+      for (let visiblePos = 0; visiblePos < nodes.length; visiblePos++) {
+        const node = nodes[visiblePos];
+        if (!node) continue;
+        const rect = measureElementPosition(node);
+        if (rect.height <= 0) continue;
+        rects.push({
+          index: scrollOffset + visiblePos,
+          top: rect.y,
+          height: rect.height
+        });
+      }
+      return findItemAtLayoutRow(rects, layoutRow);
+    },
+    [containerRef, itemRefs, scrollOffset, terminalHeight]
+  );
+  const handleMouse = (0, import_react4.useCallback)(
+    (event) => {
+      if (event.name !== "move" && event.name !== "left-press") return;
+      const index = resolveIndex(event);
+      if (index === null || isDisabled?.(index)) return;
+      if (event.name === "move") {
+        onHoverIndex(index);
+      } else {
+        onSelectIndex(index);
+      }
+    },
+    [resolveIndex, isDisabled, onHoverIndex, onSelectIndex]
+  );
+  useMouseEvents(handleMouse, { isActive: true, tracking: "any" });
+  return null;
+}
+__name(RowMouseController, "RowMouseController");
+
+export {
+  SettingsContext,
+  useSettings,
+  useTerminalSize,
+  Colors,
+  useMouseEvents,
+  measureElementPosition,
+  layoutRowForEvent,
+  RowMouseController
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Inspired by gemini-cli's MouseContext (Google LLC, Apache-2.0): enable SGR
+ * mouse mode while at least one subscriber is active, parse mouse sequences
+ * out of the KeypressContext pipeline, call each handler, restore on cleanup.
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Pure geometry helper for mapping a terminal mouse row onto a vertical list of
+ * items. The DOM measurement (reading yoga layout via measureElementPosition)
+ * lives in the component that owns the refs; this is pure arithmetic so it can
+ * be unit-tested without a renderer.
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Shim for ink PR #968 (vadimdemedes/ink#968): extends measureElement()
+ * to return {x, y, width, height}. Once the upstream PR is merged and
+ * ink is upgraded, replace usages with `measureElement` from 'ink'
+ * and delete this file.
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */