@qwen-code/qwen-code 0.16.0-preview.0 → 0.16.1

package/chunks/chunk-7LMPOVYW.js

@@ -0,0 +1,956 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  t
+} from "./chunk-HW5S7L73.js";
+import {
+  getCoreSystemPrompt
+} from "./chunk-BAZDG3QU.js";
+import {
+  buildSkillLlmContent
+} from "./chunk-G7YTSRES.js";
+import {
+  DiscoveredMCPTool,
+  uiTelemetryService
+} from "./chunk-JCR2WRXZ.js";
+import {
+  DEFAULT_TOKEN_LIMIT
+} from "./chunk-MAY32HXD.js";
+import {
+  ToolNames
+} from "./chunk-PVVL5Q3W.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __commonJS,
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// node_modules/react/cjs/react.production.js
+var require_react_production = __commonJS({
+  "node_modules/react/cjs/react.production.js"(exports) {
+    "use strict";
+    init_esbuild_shims();
+    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element");
+    var REACT_PORTAL_TYPE = Symbol.for("react.portal");
+    var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+    var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
+    var REACT_PROFILER_TYPE = Symbol.for("react.profiler");
+    var REACT_CONSUMER_TYPE = Symbol.for("react.consumer");
+    var REACT_CONTEXT_TYPE = Symbol.for("react.context");
+    var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
+    var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");
+    var REACT_MEMO_TYPE = Symbol.for("react.memo");
+    var REACT_LAZY_TYPE = Symbol.for("react.lazy");
+    var REACT_ACTIVITY_TYPE = Symbol.for("react.activity");
+    var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+    function getIteratorFn(maybeIterable) {
+      if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+      return "function" === typeof maybeIterable ? maybeIterable : null;
+    }
+    __name(getIteratorFn, "getIteratorFn");
+    var ReactNoopUpdateQueue = {
+      isMounted: /* @__PURE__ */ __name(function() {
+        return false;
+      }, "isMounted"),
+      enqueueForceUpdate: /* @__PURE__ */ __name(function() {
+      }, "enqueueForceUpdate"),
+      enqueueReplaceState: /* @__PURE__ */ __name(function() {
+      }, "enqueueReplaceState"),
+      enqueueSetState: /* @__PURE__ */ __name(function() {
+      }, "enqueueSetState")
+    };
+    var assign = Object.assign;
+    var emptyObject = {};
+    function Component(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    __name(Component, "Component");
+    Component.prototype.isReactComponent = {};
+    Component.prototype.setState = function(partialState, callback) {
+      if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState)
+        throw Error(
+          "takes an object of state variables to update or a function which returns an object of state variables."
+        );
+      this.updater.enqueueSetState(this, partialState, callback, "setState");
+    };
+    Component.prototype.forceUpdate = function(callback) {
+      this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+    };
+    function ComponentDummy() {
+    }
+    __name(ComponentDummy, "ComponentDummy");
+    ComponentDummy.prototype = Component.prototype;
+    function PureComponent(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    __name(PureComponent, "PureComponent");
+    var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+    pureComponentPrototype.constructor = PureComponent;
+    assign(pureComponentPrototype, Component.prototype);
+    pureComponentPrototype.isPureReactComponent = true;
+    var isArrayImpl = Array.isArray;
+    function noop() {
+    }
+    __name(noop, "noop");
+    var ReactSharedInternals = { H: null, A: null, T: null, S: null };
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    function ReactElement(type, key, props) {
+      var refProp = props.ref;
+      return {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        ref: void 0 !== refProp ? refProp : null,
+        props
+      };
+    }
+    __name(ReactElement, "ReactElement");
+    function cloneAndReplaceKey(oldElement, newKey) {
+      return ReactElement(oldElement.type, newKey, oldElement.props);
+    }
+    __name(cloneAndReplaceKey, "cloneAndReplaceKey");
+    function isValidElement(object) {
+      return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    __name(isValidElement, "isValidElement");
+    function escape(key) {
+      var escaperLookup = { "=": "=0", ":": "=2" };
+      return "$" + key.replace(/[=:]/g, function(match) {
+        return escaperLookup[match];
+      });
+    }
+    __name(escape, "escape");
+    var userProvidedKeyEscapeRegex = /\/+/g;
+    function getElementKey(element, index) {
+      return "object" === typeof element && null !== element && null != element.key ? escape("" + element.key) : index.toString(36);
+    }
+    __name(getElementKey, "getElementKey");
+    function resolveThenable(thenable) {
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
+        default:
+          switch ("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(
+            function(fulfilledValue) {
+              "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
+            },
+            function(error) {
+              "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
+            }
+          )), thenable.status) {
+            case "fulfilled":
+              return thenable.value;
+            case "rejected":
+              throw thenable.reason;
+          }
+      }
+      throw thenable;
+    }
+    __name(resolveThenable, "resolveThenable");
+    function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+      var type = typeof children;
+      if ("undefined" === type || "boolean" === type) children = null;
+      var invokeCallback = false;
+      if (null === children) invokeCallback = true;
+      else
+        switch (type) {
+          case "bigint":
+          case "string":
+          case "number":
+            invokeCallback = true;
+            break;
+          case "object":
+            switch (children.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+              case REACT_PORTAL_TYPE:
+                invokeCallback = true;
+                break;
+              case REACT_LAZY_TYPE:
+                return invokeCallback = children._init, mapIntoArray(
+                  invokeCallback(children._payload),
+                  array,
+                  escapedPrefix,
+                  nameSoFar,
+                  callback
+                );
+            }
+        }
+      if (invokeCallback)
+        return callback = callback(children), invokeCallback = "" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar, isArrayImpl(callback) ? (escapedPrefix = "", null != invokeCallback && (escapedPrefix = invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
+          return c;
+        })) : null != callback && (isValidElement(callback) && (callback = cloneAndReplaceKey(
+          callback,
+          escapedPrefix + (null == callback.key || children && children.key === callback.key ? "" : ("" + callback.key).replace(
+            userProvidedKeyEscapeRegex,
+            "$&/"
+          ) + "/") + invokeCallback
+        )), array.push(callback)), 1;
+      invokeCallback = 0;
+      var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";
+      if (isArrayImpl(children))
+        for (var i = 0; i < children.length; i++)
+          nameSoFar = children[i], type = nextNamePrefix + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(
+            nameSoFar,
+            array,
+            escapedPrefix,
+            type,
+            callback
+          );
+      else if (i = getIteratorFn(children), "function" === typeof i)
+        for (children = i.call(children), i = 0; !(nameSoFar = children.next()).done; )
+          nameSoFar = nameSoFar.value, type = nextNamePrefix + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(
+            nameSoFar,
+            array,
+            escapedPrefix,
+            type,
+            callback
+          );
+      else if ("object" === type) {
+        if ("function" === typeof children.then)
+          return mapIntoArray(
+            resolveThenable(children),
+            array,
+            escapedPrefix,
+            nameSoFar,
+            callback
+          );
+        array = String(children);
+        throw Error(
+          "Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead."
+        );
+      }
+      return invokeCallback;
+    }
+    __name(mapIntoArray, "mapIntoArray");
+    function mapChildren(children, func, context) {
+      if (null == children) return children;
+      var result = [], count = 0;
+      mapIntoArray(children, result, "", "", function(child) {
+        return func.call(context, child, count++);
+      });
+      return result;
+    }
+    __name(mapChildren, "mapChildren");
+    function lazyInitializer(payload) {
+      if (-1 === payload._status) {
+        var ctor = payload._result;
+        ctor = ctor();
+        ctor.then(
+          function(moduleObject) {
+            if (0 === payload._status || -1 === payload._status)
+              payload._status = 1, payload._result = moduleObject;
+          },
+          function(error) {
+            if (0 === payload._status || -1 === payload._status)
+              payload._status = 2, payload._result = error;
+          }
+        );
+        -1 === payload._status && (payload._status = 0, payload._result = ctor);
+      }
+      if (1 === payload._status) return payload._result.default;
+      throw payload._result;
+    }
+    __name(lazyInitializer, "lazyInitializer");
+    var reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
+      if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
+        var event = new window.ErrorEvent("error", {
+          bubbles: true,
+          cancelable: true,
+          message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
+          error
+        });
+        if (!window.dispatchEvent(event)) return;
+      } else if ("object" === typeof process && "function" === typeof process.emit) {
+        process.emit("uncaughtException", error);
+        return;
+      }
+      console.error(error);
+    };
+    var Children = {
+      map: mapChildren,
+      forEach: /* @__PURE__ */ __name(function(children, forEachFunc, forEachContext) {
+        mapChildren(
+          children,
+          function() {
+            forEachFunc.apply(this, arguments);
+          },
+          forEachContext
+        );
+      }, "forEach"),
+      count: /* @__PURE__ */ __name(function(children) {
+        var n = 0;
+        mapChildren(children, function() {
+          n++;
+        });
+        return n;
+      }, "count"),
+      toArray: /* @__PURE__ */ __name(function(children) {
+        return mapChildren(children, function(child) {
+          return child;
+        }) || [];
+      }, "toArray"),
+      only: /* @__PURE__ */ __name(function(children) {
+        if (!isValidElement(children))
+          throw Error(
+            "React.Children.only expected to receive a single React element child."
+          );
+        return children;
+      }, "only")
+    };
+    exports.Activity = REACT_ACTIVITY_TYPE;
+    exports.Children = Children;
+    exports.Component = Component;
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.Profiler = REACT_PROFILER_TYPE;
+    exports.PureComponent = PureComponent;
+    exports.StrictMode = REACT_STRICT_MODE_TYPE;
+    exports.Suspense = REACT_SUSPENSE_TYPE;
+    exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+    exports.__COMPILER_RUNTIME = {
+      __proto__: null,
+      c: /* @__PURE__ */ __name(function(size) {
+        return ReactSharedInternals.H.useMemoCache(size);
+      }, "c")
+    };
+    exports.cache = function(fn) {
+      return function() {
+        return fn.apply(null, arguments);
+      };
+    };
+    exports.cacheSignal = function() {
+      return null;
+    };
+    exports.cloneElement = function(element, config, children) {
+      if (null === element || void 0 === element)
+        throw Error(
+          "The argument must be a React element, but you passed " + element + "."
+        );
+      var props = assign({}, element.props), key = element.key;
+      if (null != config)
+        for (propName in void 0 !== config.key && (key = "" + config.key), config)
+          !hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
+      var propName = arguments.length - 2;
+      if (1 === propName) props.children = children;
+      else if (1 < propName) {
+        for (var childArray = Array(propName), i = 0; i < propName; i++)
+          childArray[i] = arguments[i + 2];
+        props.children = childArray;
+      }
+      return ReactElement(element.type, key, props);
+    };
+    exports.createContext = function(defaultValue) {
+      defaultValue = {
+        $$typeof: REACT_CONTEXT_TYPE,
+        _currentValue: defaultValue,
+        _currentValue2: defaultValue,
+        _threadCount: 0,
+        Provider: null,
+        Consumer: null
+      };
+      defaultValue.Provider = defaultValue;
+      defaultValue.Consumer = {
+        $$typeof: REACT_CONSUMER_TYPE,
+        _context: defaultValue
+      };
+      return defaultValue;
+    };
+    exports.createElement = function(type, config, children) {
+      var propName, props = {}, key = null;
+      if (null != config)
+        for (propName in void 0 !== config.key && (key = "" + config.key), config)
+          hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (props[propName] = config[propName]);
+      var childrenLength = arguments.length - 2;
+      if (1 === childrenLength) props.children = children;
+      else if (1 < childrenLength) {
+        for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++)
+          childArray[i] = arguments[i + 2];
+        props.children = childArray;
+      }
+      if (type && type.defaultProps)
+        for (propName in childrenLength = type.defaultProps, childrenLength)
+          void 0 === props[propName] && (props[propName] = childrenLength[propName]);
+      return ReactElement(type, key, props);
+    };
+    exports.createRef = function() {
+      return { current: null };
+    };
+    exports.forwardRef = function(render) {
+      return { $$typeof: REACT_FORWARD_REF_TYPE, render };
+    };
+    exports.isValidElement = isValidElement;
+    exports.lazy = function(ctor) {
+      return {
+        $$typeof: REACT_LAZY_TYPE,
+        _payload: { _status: -1, _result: ctor },
+        _init: lazyInitializer
+      };
+    };
+    exports.memo = function(type, compare) {
+      return {
+        $$typeof: REACT_MEMO_TYPE,
+        type,
+        compare: void 0 === compare ? null : compare
+      };
+    };
+    exports.startTransition = function(scope) {
+      var prevTransition = ReactSharedInternals.T, currentTransition = {};
+      ReactSharedInternals.T = currentTransition;
+      try {
+        var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
+        null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+        "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && returnValue.then(noop, reportGlobalError);
+      } catch (error) {
+        reportGlobalError(error);
+      } finally {
+        null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+      }
+    };
+    exports.unstable_useCacheRefresh = function() {
+      return ReactSharedInternals.H.useCacheRefresh();
+    };
+    exports.use = function(usable) {
+      return ReactSharedInternals.H.use(usable);
+    };
+    exports.useActionState = function(action, initialState, permalink) {
+      return ReactSharedInternals.H.useActionState(action, initialState, permalink);
+    };
+    exports.useCallback = function(callback, deps) {
+      return ReactSharedInternals.H.useCallback(callback, deps);
+    };
+    exports.useContext = function(Context) {
+      return ReactSharedInternals.H.useContext(Context);
+    };
+    exports.useDebugValue = function() {
+    };
+    exports.useDeferredValue = function(value, initialValue) {
+      return ReactSharedInternals.H.useDeferredValue(value, initialValue);
+    };
+    exports.useEffect = function(create, deps) {
+      return ReactSharedInternals.H.useEffect(create, deps);
+    };
+    exports.useEffectEvent = function(callback) {
+      return ReactSharedInternals.H.useEffectEvent(callback);
+    };
+    exports.useId = function() {
+      return ReactSharedInternals.H.useId();
+    };
+    exports.useImperativeHandle = function(ref, create, deps) {
+      return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
+    };
+    exports.useInsertionEffect = function(create, deps) {
+      return ReactSharedInternals.H.useInsertionEffect(create, deps);
+    };
+    exports.useLayoutEffect = function(create, deps) {
+      return ReactSharedInternals.H.useLayoutEffect(create, deps);
+    };
+    exports.useMemo = function(create, deps) {
+      return ReactSharedInternals.H.useMemo(create, deps);
+    };
+    exports.useOptimistic = function(passthrough, reducer) {
+      return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
+    };
+    exports.useReducer = function(reducer, initialArg, init) {
+      return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
+    };
+    exports.useRef = function(initialValue) {
+      return ReactSharedInternals.H.useRef(initialValue);
+    };
+    exports.useState = function(initialState) {
+      return ReactSharedInternals.H.useState(initialState);
+    };
+    exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
+      return ReactSharedInternals.H.useSyncExternalStore(
+        subscribe,
+        getSnapshot,
+        getServerSnapshot
+      );
+    };
+    exports.useTransition = function() {
+      return ReactSharedInternals.H.useTransition();
+    };
+    exports.version = "19.2.4";
+  }
+});
+
+// node_modules/react/index.js
+var require_react = __commonJS({
+  "node_modules/react/index.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    if (true) {
+      module.exports = require_react_production();
+    } else {
+      module.exports = null;
+    }
+  }
+});
+
+// packages/cli/src/ui/commands/contextCommand.ts
+init_esbuild_shims();
+
+// packages/cli/src/ui/commands/types.ts
+init_esbuild_shims();
+
+// packages/cli/src/ui/types.ts
+init_esbuild_shims();
+var import_react = __toESM(require_react(), 1);
+var TERMINAL_GOAL_STATUS_KINDS = [
+  "achieved",
+  "aborted",
+  "failed"
+];
+function isTerminalGoalStatusKind(kind) {
+  return TERMINAL_GOAL_STATUS_KINDS.includes(
+    kind
+  );
+}
+__name(isTerminalGoalStatusKind, "isTerminalGoalStatusKind");
+
+// packages/cli/src/ui/commands/contextCommand.ts
+var DEFAULT_COMPRESSION_THRESHOLD = 0.7;
+function estimateTokens(text) {
+  if (!text || text.length === 0) return 0;
+  let asciiChars = 0;
+  let nonAsciiChars = 0;
+  for (let i = 0; i < text.length; i++) {
+    const charCode = text.charCodeAt(i);
+    if (charCode < 128) {
+      asciiChars++;
+    } else {
+      nonAsciiChars++;
+    }
+  }
+  return Math.ceil(asciiChars / 4 + nonAsciiChars * 1.5);
+}
+__name(estimateTokens, "estimateTokens");
+function parseMemoryFiles(memoryContent) {
+  if (!memoryContent || memoryContent.trim().length === 0) return [];
+  const results = [];
+  const regex = /--- Context from: (.+?) ---\n([\s\S]*?)--- End of Context from: \1 ---/g;
+  let match;
+  while ((match = regex.exec(memoryContent)) !== null) {
+    const filePath = match[1];
+    const content = match[2];
+    results.push({
+      path: filePath,
+      tokens: estimateTokens(content)
+    });
+  }
+  if (results.length === 0 && memoryContent.trim().length > 0) {
+    results.push({
+      path: t("memory"),
+      tokens: estimateTokens(memoryContent)
+    });
+  }
+  return results;
+}
+__name(parseMemoryFiles, "parseMemoryFiles");
+async function collectContextData(config, showDetails) {
+  const modelName = config.getModel() || "unknown";
+  const contentGeneratorConfig = config.getContentGeneratorConfig();
+  const contextWindowSize = contentGeneratorConfig.contextWindowSize ?? DEFAULT_TOKEN_LIMIT;
+  const apiTotalTokens = uiTelemetryService.getLastPromptTokenCount();
+  const apiCachedTokens = uiTelemetryService.getLastCachedContentTokenCount();
+  const systemPromptText = getCoreSystemPrompt(void 0, modelName);
+  const systemPromptTokens = estimateTokens(systemPromptText);
+  const toolRegistry = config.getToolRegistry();
+  const allTools = toolRegistry ? toolRegistry.getAllTools() : [];
+  const toolDeclarations = toolRegistry ? toolRegistry.getFunctionDeclarations({ includeDeferred: true }) : [];
+  const toolsJsonStr = JSON.stringify(toolDeclarations);
+  const allToolsTokens = estimateTokens(toolsJsonStr);
+  const builtinTools = [];
+  const mcpTools = [];
+  for (const tool of allTools) {
+    const toolJsonStr = JSON.stringify(tool.schema);
+    const tokens = estimateTokens(toolJsonStr);
+    if (tool instanceof DiscoveredMCPTool) {
+      mcpTools.push({
+        name: `${tool.serverName}__${tool.serverToolName || tool.name}`,
+        tokens
+      });
+    } else if (tool.name !== ToolNames.SKILL) {
+      builtinTools.push({
+        name: tool.name,
+        tokens
+      });
+    }
+  }
+  const memoryContent = config.getUserMemory();
+  const memoryFiles = parseMemoryFiles(memoryContent);
+  const memoryFilesTokens = memoryFiles.reduce((sum, f) => sum + f.tokens, 0);
+  const skillTool = allTools.find((tool) => tool.name === ToolNames.SKILL);
+  const skillToolDefinitionTokens = skillTool ? estimateTokens(JSON.stringify(skillTool.schema)) : 0;
+  const loadedSkillNames = skillTool && "getLoadedSkillNames" in skillTool ? skillTool.getLoadedSkillNames() : /* @__PURE__ */ new Set();
+  const skillManager = config.getSkillManager();
+  const skillConfigs = skillManager ? await skillManager.listSkills() : [];
+  let loadedBodiesTokens = 0;
+  const skills = skillConfigs.map((skill) => {
+    const listingTokens = estimateTokens(
+      `<skill>
+<name>
+${skill.name}
+</name>
+<description>
+${skill.description} (${skill.level})
+</description>
+<location>
+${skill.level}
+</location>
+</skill>`
+    );
+    const isLoaded = loadedSkillNames.has(skill.name);
+    let bodyTokens;
+    if (isLoaded && skill.body) {
+      const baseDir = skill.filePath ? skill.filePath.replace(/\/[^/]+$/, "") : "";
+      bodyTokens = estimateTokens(buildSkillLlmContent(baseDir, skill.body));
+      loadedBodiesTokens += bodyTokens;
+    }
+    return {
+      name: skill.name,
+      tokens: listingTokens,
+      loaded: isLoaded,
+      bodyTokens
+    };
+  });
+  const skillsTokens = skillToolDefinitionTokens + loadedBodiesTokens;
+  const compressionThreshold = config.getChatCompression()?.contextPercentageThreshold ?? DEFAULT_COMPRESSION_THRESHOLD;
+  const autocompactBuffer = compressionThreshold > 0 ? Math.round((1 - compressionThreshold) * contextWindowSize) : 0;
+  const rawOverhead = systemPromptTokens + allToolsTokens + memoryFilesTokens + loadedBodiesTokens;
+  const isEstimated = apiTotalTokens === 0;
+  const mcpToolsTotalTokens = mcpTools.reduce(
+    (sum, tool) => sum + tool.tokens,
+    0
+  );
+  let totalTokens;
+  let displaySystemPrompt;
+  let displayBuiltinTools;
+  let displayMcpTools;
+  let displayMemoryFiles;
+  let displaySkills;
+  let messagesTokens;
+  let freeSpace;
+  let detailBuiltinTools;
+  let detailMcpTools;
+  let detailMemoryFiles;
+  let detailSkills;
+  if (isEstimated) {
+    totalTokens = 0;
+    displaySystemPrompt = systemPromptTokens;
+    displaySkills = skillsTokens;
+    displayBuiltinTools = Math.max(
+      0,
+      allToolsTokens - skillToolDefinitionTokens - mcpToolsTotalTokens
+    );
+    displayMcpTools = mcpToolsTotalTokens;
+    displayMemoryFiles = memoryFilesTokens;
+    messagesTokens = 0;
+    freeSpace = Math.max(
+      0,
+      contextWindowSize - rawOverhead - autocompactBuffer
+    );
+    detailBuiltinTools = builtinTools;
+    detailMcpTools = mcpTools;
+    detailMemoryFiles = memoryFiles;
+    detailSkills = skills;
+  } else {
+    totalTokens = apiTotalTokens;
+    const overheadScale = rawOverhead > totalTokens ? totalTokens / rawOverhead : 1;
+    displaySystemPrompt = Math.round(systemPromptTokens * overheadScale);
+    const scaledAllTools = Math.round(allToolsTokens * overheadScale);
+    displayMemoryFiles = Math.round(memoryFilesTokens * overheadScale);
+    displaySkills = Math.round(skillsTokens * overheadScale);
+    const scaledMcpTotal = Math.round(mcpToolsTotalTokens * overheadScale);
+    displayMcpTools = scaledMcpTotal;
+    const scaledSkillDefinition = Math.round(
+      skillToolDefinitionTokens * overheadScale
+    );
+    displayBuiltinTools = Math.max(
+      0,
+      scaledAllTools - scaledSkillDefinition - scaledMcpTotal
+    );
+    const scaledOverhead = displaySystemPrompt + scaledAllTools + displayMemoryFiles + Math.round(loadedBodiesTokens * overheadScale);
+    if (apiCachedTokens > 0) {
+      messagesTokens = Math.max(0, totalTokens - apiCachedTokens);
+    } else {
+      messagesTokens = Math.max(0, totalTokens - scaledOverhead);
+    }
+    freeSpace = Math.max(
+      0,
+      contextWindowSize - totalTokens - autocompactBuffer
+    );
+    const scaleDetail = /* @__PURE__ */ __name((items) => overheadScale < 1 ? items.map((item) => ({
+      ...item,
+      tokens: Math.round(item.tokens * overheadScale)
+    })) : items, "scaleDetail");
+    detailBuiltinTools = scaleDetail(builtinTools);
+    detailMcpTools = scaleDetail(mcpTools);
+    detailMemoryFiles = scaleDetail(memoryFiles);
+    detailSkills = overheadScale < 1 ? skills.map((item) => ({
+      ...item,
+      tokens: Math.round(item.tokens * overheadScale),
+      bodyTokens: item.bodyTokens ? Math.round(item.bodyTokens * overheadScale) : void 0
+    })) : skills;
+  }
+  const breakdown = {
+    systemPrompt: displaySystemPrompt,
+    builtinTools: displayBuiltinTools,
+    mcpTools: displayMcpTools,
+    memoryFiles: displayMemoryFiles,
+    skills: displaySkills,
+    messages: messagesTokens,
+    freeSpace,
+    autocompactBuffer
+  };
+  return {
+    type: "context_usage" /* CONTEXT_USAGE */,
+    modelName,
+    totalTokens,
+    contextWindowSize,
+    breakdown,
+    builtinTools: showDetails ? detailBuiltinTools : [],
+    mcpTools: showDetails ? detailMcpTools : [],
+    memoryFiles: showDetails ? detailMemoryFiles : [],
+    skills: showDetails ? detailSkills : [],
+    isEstimated,
+    showDetails
+  };
+}
+__name(collectContextData, "collectContextData");
+function fmtTokens(tokens) {
+  if (tokens >= 1e3) {
+    return `${(tokens / 1e3).toFixed(1)}k`;
+  }
+  return `${tokens}`;
+}
+__name(fmtTokens, "fmtTokens");
+function fmtCategoryRow(label, tokens, contextWindowSize, indent = "  ") {
+  const percentage = (tokens / contextWindowSize * 100).toFixed(1);
+  const right = `${fmtTokens(tokens)} tokens (${percentage}%)`;
+  const leftPart = `${indent}${label}`;
+  const totalWidth = 56;
+  const dots = Math.max(1, totalWidth - leftPart.length - right.length);
+  return `${leftPart}${" ".repeat(dots)}${right}`;
+}
+__name(fmtCategoryRow, "fmtCategoryRow");
+function formatContextUsageText(data) {
+  const {
+    modelName,
+    totalTokens,
+    contextWindowSize,
+    breakdown,
+    builtinTools,
+    mcpTools,
+    memoryFiles,
+    skills,
+    isEstimated,
+    showDetails
+  } = data;
+  const lines = [];
+  lines.push("## Context Usage");
+  lines.push("");
+  if (isEstimated) {
+    lines.push("*No API response yet. Send a message to see actual usage.*");
+    lines.push("");
+    lines.push("**Estimated pre-conversation overhead**");
+    lines.push(
+      `Model: ${modelName}  Context window: ${fmtTokens(contextWindowSize)} tokens`
+    );
+    lines.push("");
+  } else {
+    lines.push(
+      `Model: ${modelName}  Context window: ${fmtTokens(contextWindowSize)} tokens`
+    );
+    lines.push("");
+    lines.push(fmtCategoryRow("Used", totalTokens, contextWindowSize));
+    lines.push(fmtCategoryRow("Free", breakdown.freeSpace, contextWindowSize));
+    lines.push(
+      fmtCategoryRow(
+        "Autocompact buffer",
+        breakdown.autocompactBuffer,
+        contextWindowSize
+      )
+    );
+    lines.push("");
+    lines.push("**Usage by category**");
+  }
+  lines.push(
+    fmtCategoryRow("System prompt", breakdown.systemPrompt, contextWindowSize)
+  );
+  lines.push(
+    fmtCategoryRow("Built-in tools", breakdown.builtinTools, contextWindowSize)
+  );
+  if (breakdown.mcpTools > 0) {
+    lines.push(
+      fmtCategoryRow("MCP tools", breakdown.mcpTools, contextWindowSize)
+    );
+  }
+  lines.push(
+    fmtCategoryRow("Memory files", breakdown.memoryFiles, contextWindowSize)
+  );
+  lines.push(fmtCategoryRow("Skills", breakdown.skills, contextWindowSize));
+  if (!isEstimated) {
+    lines.push(
+      fmtCategoryRow("Messages", breakdown.messages, contextWindowSize)
+    );
+  }
+  if (showDetails) {
+    const sortedBuiltin = [...builtinTools].sort((a, b) => b.tokens - a.tokens);
+    const sortedMcp = [...mcpTools].sort((a, b) => b.tokens - a.tokens);
+    const sortedMemory = [...memoryFiles].sort((a, b) => b.tokens - a.tokens);
+    const sortedSkills = [...skills].sort((a, b) => {
+      if (a.loaded !== b.loaded) return a.loaded ? -1 : 1;
+      return b.tokens + (b.bodyTokens ?? 0) - (a.tokens + (a.bodyTokens ?? 0));
+    });
+    if (sortedBuiltin.length > 0) {
+      lines.push("");
+      lines.push("**Built-in tools**");
+      for (const tool of sortedBuiltin) {
+        lines.push(
+          fmtCategoryRow(tool.name, tool.tokens, contextWindowSize, "  \u2514 ")
+        );
+      }
+    }
+    if (sortedMcp.length > 0) {
+      lines.push("");
+      lines.push("**MCP tools**");
+      for (const tool of sortedMcp) {
+        lines.push(
+          fmtCategoryRow(tool.name, tool.tokens, contextWindowSize, "  \u2514 ")
+        );
+      }
+    }
+    if (sortedMemory.length > 0) {
+      lines.push("");
+      lines.push("**Memory files**");
+      for (const file of sortedMemory) {
+        lines.push(
+          fmtCategoryRow(file.path, file.tokens, contextWindowSize, "  \u2514 ")
+        );
+      }
+    }
+    if (sortedSkills.length > 0) {
+      lines.push("");
+      lines.push("**Skills**");
+      for (const skill of sortedSkills) {
+        const label = skill.loaded ? `${skill.name} (active)` : skill.name;
+        lines.push(
+          fmtCategoryRow(label, skill.tokens, contextWindowSize, "  \u2514 ")
+        );
+        if (skill.loaded && skill.bodyTokens && skill.bodyTokens > 0) {
+          lines.push(
+            fmtCategoryRow(
+              "body loaded",
+              skill.bodyTokens,
+              contextWindowSize,
+              "    \u2514 "
+            )
+          );
+        }
+      }
+    }
+  } else {
+    lines.push("");
+    lines.push("*Run /context detail for per-item breakdown.*");
+  }
+  return lines.join("\n");
+}
+__name(formatContextUsageText, "formatContextUsageText");
+var contextCommand = {
+  name: "context",
+  get description() {
+    return t(
+      'Show context window usage breakdown. Use "/context detail" for per-item breakdown.'
+    );
+  },
+  kind: "built-in" /* BUILT_IN */,
+  supportedModes: ["interactive", "non_interactive", "acp"],
+  action: /* @__PURE__ */ __name(async (context, args) => {
+    const showDetails = args?.trim().toLowerCase() === "detail" || args?.trim().toLowerCase() === "-d";
+    const executionMode = context.executionMode ?? "interactive";
+    const { config } = context.services;
+    if (!config) {
+      if (executionMode === "interactive") {
+        context.ui.addItem(
+          {
+            type: "error" /* ERROR */,
+            text: t("Config not loaded.")
+          },
+          Date.now()
+        );
+        return;
+      }
+      return {
+        type: "message",
+        messageType: "error",
+        content: t("Config not loaded.")
+      };
+    }
+    const contextUsageItem = await collectContextData(config, showDetails);
+    if (executionMode === "interactive") {
+      context.ui.addItem(contextUsageItem, Date.now());
+      return;
+    } else {
+      return {
+        type: "message",
+        messageType: "info",
+        content: formatContextUsageText(contextUsageItem)
+      };
+    }
+  }, "action"),
+  subCommands: [
+    {
+      name: "detail",
+      get description() {
+        return t("Show per-item context usage breakdown.");
+      },
+      kind: "built-in" /* BUILT_IN */,
+      supportedModes: ["interactive", "non_interactive", "acp"],
+      action: /* @__PURE__ */ __name(async (context) => {
+        await contextCommand.action(context, "detail");
+      }, "action")
+    }
+  ]
+};
+
+export {
+  require_react,
+  isTerminalGoalStatusKind,
+  collectContextData,
+  formatContextUsageText,
+  contextCommand
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/*! Bundled license information:
+
+react/cjs/react.production.js:
+  (**
+   * @license React
+   * react.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+*/