@qwen-code/qwen-code 0.22.0 → 0.22.2-nightly.20260828.7357136dd1

package/chunks/{chunk-A5F2YNO6.js → chunk-UHQFIS7N.js}

@@ -656,8 +656,14 @@ var IDE_DIR_NAME = "ide";
 var PLANS_DIR_NAME = "plans";
 var DEBUG_DIR_NAME = "debug";
 var ARENA_DIR_NAME = "arena";
+function platformFoldsCase() {
+  return process.platform === "win32" || process.platform === "darwin";
+}
+__name(platformFoldsCase, "platformFoldsCase");
 function isResolvedPathWithinDirectory(childPath, parentPath) {
-  const relativePath = path2.relative(parentPath, childPath);
+  const child = platformFoldsCase() ? childPath.toLowerCase() : childPath;
+  const parent = platformFoldsCase() ? parentPath.toLowerCase() : parentPath;
+  const relativePath = path2.relative(parent, child);
   return relativePath === "" || !relativePath.startsWith(`..${path2.sep}`) && relativePath !== ".." && !path2.isAbsolute(relativePath);
 }
 __name(isResolvedPathWithinDirectory, "isResolvedPathWithinDirectory");
@@ -879,6 +885,170 @@ var Storage = class _Storage {
   static getGlobalArenaDir() {
     return path2.join(_Storage.getGlobalQwenDir(), ARENA_DIR_NAME);
   }
+  /**
+   * Create or adopt the outside-repo landing for /audit reports and sidecars
+   * when the audited repository's ignore state cannot keep them out of
+   * version control. Per-user and per-project, honoring the QWEN_HOME
+   * override; 0700 on POSIX so the quoted (possibly exploitable) module
+   * content stays private to the user.
+   */
+  static ensureAuditFallbackDir(projectRoot) {
+    let resolved = projectRoot;
+    try {
+      resolved = fs2.realpathSync(projectRoot);
+    } catch {
+    }
+    if (platformFoldsCase()) {
+      resolved = resolved.toLowerCase();
+    }
+    const baseDir = _Storage.getGlobalQwenDir();
+    const dir = path2.join(baseDir, "audits", getProjectHash(resolved));
+    _Storage.assertAuditLandingIsOutsideRepo(dir, resolved);
+    try {
+      fs2.mkdirSync(baseDir, { recursive: true });
+    } catch (err) {
+      throw new FatalConfigError(
+        `audit: the QWEN_HOME base ${baseDir} could not be created as a directory (${err.message}) \u2014 remove what stands at that path and re-run.`
+      );
+    }
+    _Storage.assertAuditLandingIsOutsideRepo(dir, resolved);
+    const auditsDir = _Storage.adoptDirectory(
+      path2.join(baseDir, "audits"),
+      "the audit artifact directory"
+    );
+    _Storage.adoptDirectory(dir, "the fallback landing");
+    _Storage.assertAuditLandingIsClean(dir);
+    _Storage.adoptDirectory(auditsDir, "the audit artifact directory");
+    _Storage.adoptDirectory(dir, "the fallback landing");
+    _Storage.assertAuditLandingIsClean(dir);
+    _Storage.assertAuditLandingIsOutsideRepo(dir, resolved, true);
+    _Storage.adoptDirectory(auditsDir, "the audit artifact directory");
+    _Storage.adoptDirectory(dir, "the fallback landing");
+    return dir;
+  }
+  /**
+   * Create one path component and return it only if what is there now is a
+   * real directory (not a symlink). On POSIX a pre-existing component is
+   * tightened to 0700; ownership itself is not checked.
+   *
+   * Non-recursive on purpose: `recursive: true` would silently walk (and
+   * follow) anything already standing in the path. Creating exactly one
+   * component at a time is what makes each component checkable.
+   */
+  static adoptDirectory(dir, what) {
+    try {
+      fs2.mkdirSync(dir, { mode: 448 });
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+    const stat = fs2.lstatSync(dir);
+    if (!stat.isDirectory()) {
+      throw new FatalConfigError(
+        `audit: ${what} ${dir} is not a directory (it may be a symlink planted ahead of the run) \u2014 remove it and re-run.`
+      );
+    }
+    if (process.platform !== "win32" && (stat.mode & 511) !== 448) {
+      fs2.chmodSync(dir, 448);
+    }
+    return dir;
+  }
+  /**
+   * Refuse a fallback landing whose CONTENTS would redirect writes out of it.
+   *
+   * Validating the leaf alone is not enough: artifacts land at paths BELOW it
+   * (`audit-<ts>.sidecar/sidecar.json`, the dated report), and an
+   * O_NOFOLLOW open only ever guards the final component. A planted symlink
+   * child is therefore a complete escape — `mkdirSync` happily treats a
+   * symlink-to-directory as the directory, and every artifact written
+   * "inside" the landing lands wherever the link points, while the leaf
+   * itself stays a perfectly valid directory that re-validation passes.
+   * A hardlinked regular file is the same story for reads: an existing name
+   * reopened with O_TRUNC writes into the planter's inode.
+   *
+   * Directory children are validated recursively: a planted real
+   * subdirectory holding a symlinked file is the same escape. Entries that
+   * are neither regular files nor directories (a FIFO, socket, or device)
+   * are refused outright: opening one for the report would block, or stream
+   * the content to whoever holds the other end.
+   *
+   * The landing is REUSED across runs (the report and its sidecar are the
+   * durable artifacts), so this cannot refuse a non-empty landing — only
+   * entries that are not what a previous run of this tool would have left.
+   */
+  static assertAuditLandingIsClean(dir) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch (err) {
+      throw new FatalConfigError(
+        `audit: the fallback landing ${dir} could not be listed for validation (${err.message}) \u2014 remove it and re-run.`
+      );
+    }
+    for (const entry of entries) {
+      let stat;
+      try {
+        stat = fs2.lstatSync(path2.join(dir, entry.name));
+      } catch {
+        continue;
+      }
+      if (stat.isSymbolicLink()) {
+        throw new FatalConfigError(
+          `audit: the fallback landing ${dir} contains a symlink (${entry.name}) \u2014 artifacts written under it would land outside the landing. Remove it and re-run.`
+        );
+      }
+      if (stat.isDirectory()) {
+        _Storage.assertAuditLandingIsClean(path2.join(dir, entry.name));
+        let childStat;
+        try {
+          childStat = fs2.lstatSync(path2.join(dir, entry.name));
+        } catch {
+          continue;
+        }
+        if (!childStat.isDirectory()) {
+          throw new FatalConfigError(
+            `audit: the fallback landing ${dir} contains a symlink (${entry.name}) \u2014 artifacts written under it would land outside the landing. Remove it and re-run.`
+          );
+        }
+        continue;
+      }
+      if (!stat.isFile()) {
+        throw new FatalConfigError(
+          `audit: the fallback landing ${dir} contains a special file (${entry.name}) \u2014 a write to it would block or be captured by whoever holds the other end. Remove it and re-run.`
+        );
+      }
+      if (stat.nlink > 1) {
+        throw new FatalConfigError(
+          `audit: the fallback landing ${dir} contains a hardlinked file (${entry.name}) \u2014 a write to it would also write through its twin. Remove it and re-run.`
+        );
+      }
+    }
+  }
+  /**
+   * Refuse a fallback landing that resolves inside the audited repository.
+   * A resolution failure (a non-directory component, a symlink loop, an
+   * unreadable ancestor) falls through at the pre-adoption sites: such a
+   * path cannot resolve to a usable landing, and the adoption checks that
+   * still run afterwards own that state with the actionable message. At the
+   * final site nothing runs afterwards, so the same failure fails closed
+   * instead of returning an unvalidated landing.
+   */
+  static assertAuditLandingIsOutsideRepo(dir, resolvedProjectRoot, finalCheck = false) {
+    let contained = false;
+    try {
+      contained = _Storage.isPathWithinDirectory(dir, resolvedProjectRoot);
+    } catch (err) {
+      if (finalCheck) {
+        throw new FatalConfigError(
+          `audit: the fallback landing ${dir} could not be validated as outside the audited project root (${err.message}) \u2014 remove it and re-run.`
+        );
+      }
+    }
+    if (contained) {
+      throw new FatalConfigError(
+        `audit: the fallback landing ${dir} resolves inside the audited project root \u2014 point QWEN_HOME outside the repository and re-run.`
+      );
+    }
+  }
   getQwenDir() {
     return path2.join(this.targetDir, QWEN_DIR);
   }
@@ -938,6 +1108,21 @@ var Storage = class _Storage {
   getWorkflowRunsDir() {
     return path2.join(this.getProjectDir(), "workflows");
   }
+  /**
+   * Generated-workflow scripts directory: `<projectDir>/workflows/generated`.
+   * A trusted root for `Workflow({scriptPath})` / `workflow({scriptPath})`
+   * that is NOT a saved-workflow scope: scripts here are never listed as
+   * `/<name>` slash commands and cannot be reached by `workflow('<name>')`.
+   * It exists for tooling that emits a script for one run (a CLI subcommand
+   * generating a fan-out for the model to dispatch) — such a script has no
+   * business in the user's command namespace, and the runtime dir keeps it
+   * out of the project tree. Layout below the root is the writer's; the
+   * loader trusts the whole subtree. A subprocess reaches it as
+   * `$QWEN_CODE_PROJECT_DIR/workflows/generated`.
+   */
+  getGeneratedWorkflowsDir() {
+    return path2.join(this.getWorkflowRunsDir(), "generated");
+  }
   /**
    * Path to the persisted snapshot of a completed workflow run.
    */
@@ -1023,11 +1208,51 @@ function getSessionIdFromContext(ctx) {
 }
 __name(getSessionIdFromContext, "getSessionIdFromContext");
 
+// packages/core/src/utils/sessionIdContext.ts
+init_esbuild_shims();
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var sessionIdContext = new AsyncLocalStorage2();
+var projectDirBySession = /* @__PURE__ */ new Map();
+function registerSessionProjectDir(sessionId, projectDir) {
+  if (sessionId && projectDir) projectDirBySession.set(sessionId, projectDir);
+}
+__name(registerSessionProjectDir, "registerSessionProjectDir");
+function getSessionProjectDir(sessionId) {
+  return projectDirBySession.get(sessionId);
+}
+__name(getSessionProjectDir, "getSessionProjectDir");
+function unregisterSessionProjectDir(sessionId) {
+  projectDirBySession.delete(sessionId);
+}
+__name(unregisterSessionProjectDir, "unregisterSessionProjectDir");
+var modelBySession = /* @__PURE__ */ new Map();
+var modelIdentityBySession = /* @__PURE__ */ new Map();
+function registerSessionModel(sessionId, model, identity) {
+  if (!sessionId || !model) return;
+  modelBySession.set(sessionId, model);
+  if (identity) modelIdentityBySession.set(sessionId, identity);
+  else modelIdentityBySession.delete(sessionId);
+}
+__name(registerSessionModel, "registerSessionModel");
+function getSessionModel(sessionId) {
+  return modelBySession.get(sessionId);
+}
+__name(getSessionModel, "getSessionModel");
+function getSessionModelIdentity(sessionId) {
+  return modelIdentityBySession.get(sessionId);
+}
+__name(getSessionModelIdentity, "getSessionModelIdentity");
+function unregisterSessionModel(sessionId) {
+  modelBySession.delete(sessionId);
+  modelIdentityBySession.delete(sessionId);
+}
+__name(unregisterSessionModel, "unregisterSessionModel");
+
 // packages/core/src/utils/debugLogger.ts
 init_esbuild_shims();
 import { promises as fs4 } from "node:fs";
 import path4 from "node:path";
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
 import util from "node:util";
 
 // packages/core/src/utils/symlink.ts
@@ -1114,7 +1339,9 @@ var ensureDebugDirPromise = null;
 var ensuredDebugDirPath = null;
 var hasWriteFailure = false;
 var globalSession = null;
-var sessionContext = new AsyncLocalStorage2();
+var lastAliasedKey = null;
+var aliasChain = Promise.resolve();
+var sessionContext = new AsyncLocalStorage3();
 function isDebugLogFileEnabled() {
   const value = process.env["QWEN_DEBUG_LOG_FILE"];
   if (!value) return false;
@@ -1125,7 +1352,12 @@ __name(isDebugLogFileEnabled, "isDebugLogFileEnabled");
 function getActiveSession() {
   const contextSession = sessionContext.getStore();
   if (contextSession === false) return null;
-  return contextSession ?? globalSession;
+  if (contextSession) return contextSession;
+  const sessionId = sessionIdContext.getStore();
+  if (sessionId) {
+    return { getSessionId: /* @__PURE__ */ __name(() => sessionId, "getSessionId") };
+  }
+  return globalSession;
 }
 __name(getActiveSession, "getActiveSession");
 function ensureDebugDirExists() {
@@ -1167,6 +1399,7 @@ function writeLog(session, level, tag, args) {
   const message = formatArgs(args);
   const traceCtx = getTraceContext();
   const line = buildLogLine(level, message, tag, traceCtx);
+  updateLatestDebugLogAlias(sessionId);
   void ensureDebugDirExists().then(() => fs4.appendFile(logFilePath, line, "utf8")).catch(() => {
     hasWriteFailure = true;
   });
@@ -1178,6 +1411,13 @@ function isDebugLoggingDegraded() {
 __name(isDebugLoggingDegraded, "isDebugLoggingDegraded");
 var DEBUG_LATEST_ALIAS = "latest";
 var SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function doUpdateLatestDebugLogAlias(sessionId) {
+  const aliasPath = path4.join(Storage.getGlobalDebugDir(), DEBUG_LATEST_ALIAS);
+  const targetPath = Storage.getDebugLogPath(sessionId);
+  return ensureDebugDirExists().then(() => updateSymlink(aliasPath, targetPath, { fallbackCopy: false })).catch(() => {
+  });
+}
+__name(doUpdateLatestDebugLogAlias, "doUpdateLatestDebugLogAlias");
 function updateLatestDebugLogAlias(sessionId) {
   if (!isDebugLogFileEnabled()) {
     return;
@@ -1185,10 +1425,12 @@ function updateLatestDebugLogAlias(sessionId) {
   if (!SESSION_ID_PATTERN.test(sessionId)) {
     return;
   }
-  const aliasPath = path4.join(Storage.getGlobalDebugDir(), DEBUG_LATEST_ALIAS);
-  const targetPath = Storage.getDebugLogPath(sessionId);
-  void ensureDebugDirExists().then(() => updateSymlink(aliasPath, targetPath, { fallbackCopy: false })).catch(() => {
-  });
+  const key = path4.join(Storage.getGlobalDebugDir(), sessionId);
+  if (key === lastAliasedKey) {
+    return;
+  }
+  lastAliasedKey = key;
+  aliasChain = aliasChain.then(() => doUpdateLatestDebugLogAlias(sessionId));
 }
 __name(updateLatestDebugLogAlias, "updateLatestDebugLogAlias");
 function setDebugLogSession(session) {
@@ -1274,6 +1516,14 @@ export {
   formatTraceparent,
   setShellTracePropagation,
   isShellTracePropagationEnabled,
+  sessionIdContext,
+  registerSessionProjectDir,
+  getSessionProjectDir,
+  unregisterSessionProjectDir,
+  registerSessionModel,
+  getSessionModel,
+  getSessionModelIdentity,
+  unregisterSessionModel,
   isDebugLogFileEnabled,
   isDebugLoggingDegraded,
   setDebugLogSession,
@@ -1287,11 +1537,11 @@ export {
  */
 /**
  * @license
- * Copyright 2025 Qwen Code
+ * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2025 Qwen
+ * Copyright 2025 Qwen Code
  * SPDX-License-Identifier: Apache-2.0
  */

package/chunks/{chunk-6NFAEG54.js → chunk-UTLCH2FK.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -15081,6 +15081,11 @@ __name(fixStringValues, "fixStringValues");
 
 // packages/core/src/tools/tool-error.ts
 init_esbuild_shims();
+
+// packages/core/src/utils/tool-error-type.ts
+init_esbuild_shims();
+
+// packages/core/src/tools/tool-error.ts
 var StructuredToolError = class extends Error {
   constructor(message, errorType) {
     super(message);
@@ -15295,6 +15300,13 @@ var AgentStatistics = class {
   }
 };
 
+// packages/core/src/utils/is-tool.ts
+init_esbuild_shims();
+function isTool(obj) {
+  return typeof obj === "object" && obj !== null && "name" in obj && "build" in obj && typeof obj.build === "function";
+}
+__name(isTool, "isTool");
+
 // packages/core/src/tools/tools.ts
 var BaseToolInvocation = class {
   constructor(params) {
@@ -15499,10 +15511,6 @@ var BaseDeclarativeTool = class extends DeclarativeTool {
     return null;
   }
 };
-function isTool(obj) {
-  return typeof obj === "object" && obj !== null && "name" in obj && "build" in obj && typeof obj.build === "function";
-}
-__name(isTool, "isTool");
 function hasCycleInSchema(schema) {
   function resolveRef2(ref) {
     if (!ref.startsWith("#/")) {
@@ -15628,6 +15636,7 @@ var ToolNames = {
   TEAM_CREATE: "team_create",
   TEAM_DELETE: "team_delete",
   TEAM_PLAN_APPROVAL: "team_plan_approval",
+  REQUEST_SHUTDOWN: "request_shutdown",
   SEND_MESSAGE: "send_message",
   STRUCTURED_OUTPUT: "structured_output",
   MONITOR: "monitor",
@@ -15636,15 +15645,10 @@ var ToolNames = {
   READ_MCP_RESOURCE: "read_mcp_resource",
   ENTER_WORKTREE: "enter_worktree",
   EXIT_WORKTREE: "exit_worktree",
-  // Computer Use tools (computer_use__*) are intentionally NOT enumerated here.
-  // Their full 35-tool surface is generated into computer-use/schemas.ts and
-  // registered via computer-use/index.ts (cast to ToolName). Duplicating a
-  // subset here only goes stale on every cua-driver version bump — review
-  // round 1 removed the old ocu-era 9-name list, which still carried
-  // `get_app_state` / `perform_secondary_action` that no longer exist.
   WORKFLOW: "workflow",
   ARTIFACT: "artifact",
   RECORD_ARTIFACT: "record_artifact",
+  REPORT_FINDINGS: "report_findings",
   GET_GOAL: "get_goal",
   UPDATE_GOAL: "update_goal",
   DISPLAY_IMAGE: "display_image"
@@ -15682,6 +15686,7 @@ var ToolDisplayNames = {
   TEAM_CREATE: "TeamCreate",
   TEAM_DELETE: "TeamDelete",
   TEAM_PLAN_APPROVAL: "TeamPlanApproval",
+  REQUEST_SHUTDOWN: "RequestShutdown",
   SEND_MESSAGE: "SendMessage",
   STRUCTURED_OUTPUT: "StructuredOutput",
   MONITOR: "Monitor",
@@ -15690,10 +15695,10 @@ var ToolDisplayNames = {
   READ_MCP_RESOURCE: "ReadMcpResource",
   ENTER_WORKTREE: "EnterWorktree",
   EXIT_WORKTREE: "ExitWorktree",
-  // computer_use__* display names are not enumerated here (see ToolNames).
   WORKFLOW: "Workflow",
   ARTIFACT: "Artifact",
   RECORD_ARTIFACT: "RecordArtifact",
+  REPORT_FINDINGS: "ReportFindings",
   GET_GOAL: "Goal",
   UPDATE_GOAL: "UpdateGoal",
   DISPLAY_IMAGE: "DisplayImage"
@@ -15730,9 +15735,9 @@ export {
   SchemaValidator,
   StructuredToolError,
   AgentStatistics,
+  isTool,
   BaseToolInvocation,
   BaseDeclarativeTool,
-  isTool,
   hasCycleInSchema,
   isShellProgressData,
   MAX_TERMINAL_IMAGE_BYTES,
@@ -15750,6 +15755,12 @@ export {
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Qwen

package/chunks/{chunk-7JBHIQS2.js → chunk-UY3PBNY3.js}

@@ -2,26 +2,26 @@
 "use strict";
 import {
   t
-} from "./chunk-OE52YHCZ.js";
+} from "./chunk-RWZB422L.js";
 import {
   computeThresholds,
+  estimateContextTextTokens,
   formatContextFileDisplayPath,
-  getCoreSystemPrompt,
-  resolveInteractionMode
-} from "./chunk-T6XLJRQY.js";
+  getMainSessionBaseSystemPrompt
+} from "./chunk-EWIQ3NAE.js";
 import {
   DiscoveredMCPTool,
   uiTelemetryService
-} from "./chunk-FDD2IUEL.js";
+} from "./chunk-SZLBBZH4.js";
 import {
   DEFAULT_TOKEN_LIMIT
 } from "./chunk-FPGTNKCP.js";
 import {
   buildSkillLlmContent
-} from "./chunk-K623ENWT.js";
+} from "./chunk-ZU4UDIWX.js";
 import {
   ToolNames
-} from "./chunk-6NFAEG54.js";
+} from "./chunk-UTLCH2FK.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -39,21 +39,6 @@ function currentTier(tokens, thresholds) {
   return "safe";
 }
 __name(currentTier, "currentTier");
-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, workingDir) {
   if (!memoryContent || memoryContent.trim().length === 0) return [];
   const results = [];
@@ -71,13 +56,13 @@ function parseMemoryFiles(memoryContent, workingDir) {
         path.resolve(workingDir, filePath),
         workingDir
       ),
-      tokens: estimateTokens(content)
+      tokens: estimateContextTextTokens(content)
     });
   }
   if (results.length === 0 && memoryContent.trim().length > 0) {
     results.push({
       path: t("memory"),
-      tokens: estimateTokens(memoryContent)
+      tokens: estimateContextTextTokens(memoryContent)
     });
   }
   return results;
@@ -91,18 +76,13 @@ async function collectContextData(config, showDetails) {
   const activeChat = geminiClient?.isInitialized?.() ? geminiClient.getChat() : void 0;
   const apiTotalTokens = activeChat ? activeChat.getLastPromptTokenCount() : uiTelemetryService.getLastPromptTokenCount();
   const apiCachedTokens = uiTelemetryService.getLastCachedContentTokenCount();
-  const systemPromptText = getCoreSystemPrompt(
-    void 0,
-    modelName,
-    void 0,
-    resolveInteractionMode(config)
-  );
-  const systemPromptTokens = estimateTokens(systemPromptText);
+  const systemPromptText = getMainSessionBaseSystemPrompt(config);
+  const systemPromptTokens = estimateContextTextTokens(systemPromptText);
   const toolRegistry = config.getToolRegistry();
   const allTools = toolRegistry ? toolRegistry.getAllTools() : [];
   const toolDeclarations = toolRegistry ? toolRegistry.getFunctionDeclarations() : [];
   const toolsJsonStr = JSON.stringify(toolDeclarations);
-  const allToolsTokens = estimateTokens(toolsJsonStr);
+  const allToolsTokens = estimateContextTextTokens(toolsJsonStr);
   const builtinTools = [];
   const mcpTools = [];
   for (const tool of allTools) {
@@ -110,7 +90,7 @@ async function collectContextData(config, showDetails) {
       continue;
     }
     const toolJsonStr = JSON.stringify(tool.schema);
-    const tokens = estimateTokens(toolJsonStr);
+    const tokens = estimateContextTextTokens(toolJsonStr);
     if (tool instanceof DiscoveredMCPTool) {
       mcpTools.push({
         name: `${tool.serverName}__${tool.serverToolName || tool.name}`,
@@ -129,19 +109,19 @@ async function collectContextData(config, showDetails) {
   if (autoMemoryPrompt) {
     memoryFiles.push({
       path: t("auto memory"),
-      tokens: estimateTokens(autoMemoryPrompt)
+      tokens: estimateContextTextTokens(autoMemoryPrompt)
     });
   }
   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 skillToolDefinitionTokens = skillTool ? estimateContextTextTokens(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() : [];
   const disabledSkillNames = config.getDisabledSkillNames();
   let loadedBodiesTokens = 0;
   const skills = skillConfigs.map((skill) => {
-    const listingTokens = estimateTokens(
+    const listingTokens = estimateContextTextTokens(
       `<skill>
 <name>
 ${skill.name}
@@ -158,7 +138,9 @@ ${skill.level}
     let bodyTokens;
     if (isLoaded && skill.body) {
       const baseDir = skill.filePath ? skill.filePath.replace(/\/[^/]+$/, "") : "";
-      bodyTokens = estimateTokens(buildSkillLlmContent(baseDir, skill.body));
+      bodyTokens = estimateContextTextTokens(
+        buildSkillLlmContent(baseDir, skill.body)
+      );
       loadedBodiesTokens += bodyTokens;
     }
     return {

package/chunks/{chunk-DWCKACFL.js → chunk-V2NDP3I4.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   isGitRepository
-} from "./chunk-Q54XG7IX.js";
+} from "./chunk-SMPR7SPO.js";
 import {
   createDebugLogger
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";