@qwen-code/qwen-code 0.23.3 → 0.23.4-nightly.20260914.f024b37689

package/chunks/{chunk-3UXUOFO6.js → chunk-LLJIZIRQ.js}

@@ -135,9 +135,6 @@ init_esbuild_shims();
 var DEFAULT_QWEN_EMBEDDING_MODEL = "text-embedding-v4";
 var MAINLINE_CODER_MODEL = "qwen3.7-max";
 
-// packages/core/src/core/contentGenerator.ts
-init_esbuild_shims();
-
 // packages/core/src/models/constants.ts
 init_esbuild_shims();
 var MODEL_GENERATION_CONFIG_FIELDS = [
@@ -149,6 +146,7 @@ var MODEL_GENERATION_CONFIG_FIELDS = [
   "retryMaxDelayMs",
   "retryErrorCodes",
   "enableCacheControl",
+  "enableRequestMetadata",
   "forceGlobalCacheScope",
   "cacheRetention",
   "cacheRetentionByBlock",
@@ -221,6 +219,7 @@ var QWEN_OAUTH_ALLOWED_MODELS = QWEN_OAUTH_MODELS.map(
 );
 
 // packages/core/src/core/contentGenerator.ts
+init_esbuild_shims();
 function setSource(sources, path, source) {
   sources[path] = source;
 }
@@ -418,23 +417,23 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   try {
     if (authType === "openai" /* USE_OPENAI */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-BE4S5TRD.js");
+        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-KDGLKJVS.js");
         return createOpenAIContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "openai-responses" /* USE_OPENAI_RESPONSES */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createOpenAIResponsesContentGenerator } = await import("./openaiResponsesContentGenerator-RTCAJ5V5.js");
+        const { createOpenAIResponsesContentGenerator } = await import("./openaiResponsesContentGenerator-AWRYZLJU.js");
         return createOpenAIResponsesContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
-      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-3ZRQHHTC.js");
+      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-WIEUEFEY.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
           isInitialAuth ? { requireCachedCredentials: true } : void 0
         );
         loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-          const { QwenContentGenerator } = await import("./qwenContentGenerator-TMQC623Z.js");
+          const { QwenContentGenerator } = await import("./qwenContentGenerator-LSRUVWCL.js");
           return new QwenContentGenerator(qwenClient, generatorConfig, config);
         }, "loadBaseGenerator");
       } catch (error) {
@@ -445,12 +444,12 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
       }
     } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-JSKMKS6V.js");
+        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-H5YPXIDE.js");
         return createAnthropicContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createLlmContentGenerator } = await import("./llm-content-generator-ZHQQT5W7.js");
+        const { createLlmContentGenerator } = await import("./llm-content-generator-EXJEU5MJ.js");
         return createLlmContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else {
@@ -465,7 +464,7 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
     try {
       const [baseGenerator, { LoggingContentGenerator }] = await Promise.all([
         loadBaseGenerator(),
-        import("./loggingContentGenerator-V72OCCJO.js")
+        import("./loggingContentGenerator-RE3L7S24.js")
       ]);
       return new LoggingContentGenerator(
         baseGenerator,

package/chunks/chunk-LMJSPC55.js

@@ -0,0 +1,260 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  skillRestrictionNames
+} from "./chunk-NJ2OFVUX.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/config/skill-settings.ts
+init_esbuild_shims();
+function normalizeSkillNames(value) {
+  if (!Array.isArray(value)) return /* @__PURE__ */ new Set();
+  return new Set(
+    value.filter((name) => typeof name === "string").map((name) => name.trim().toLowerCase()).filter(Boolean)
+  );
+}
+__name(normalizeSkillNames, "normalizeSkillNames");
+function skillSettingStrings(settings, scope, key) {
+  const value = settings.forScope(scope).settings.skills?.[key];
+  return Array.isArray(value) ? value.filter((name) => typeof name === "string") : [];
+}
+__name(skillSettingStrings, "skillSettingStrings");
+function resolveSkillSettings(settings) {
+  const hardDisabled = normalizeSkillNames(settings.merged.skills?.disabled);
+  const defaultDisabled = normalizeSkillNames(
+    settings.merged.skills?.defaultDisabled
+  );
+  const enabled = normalizeSkillNames(settings.merged.skills?.enabled);
+  const disablements = /* @__PURE__ */ new Map();
+  for (const name of defaultDisabled) {
+    if (!enabled.has(name)) disablements.set(name, { reason: "default" });
+  }
+  const lockedScopes = [
+    ["SystemDefaults" /* SystemDefaults */, "systemDefaults"],
+    ["User" /* User */, "user"],
+    ["System" /* System */, "system"]
+  ];
+  const lockedByName = /* @__PURE__ */ new Map();
+  for (const [scope, label] of lockedScopes) {
+    for (const name of normalizeSkillNames(
+      skillSettingStrings(settings, scope, "disabled")
+    )) {
+      lockedByName.set(name, label);
+    }
+  }
+  for (const name of hardDisabled) {
+    const lockedScope = lockedByName.get(name);
+    disablements.set(name, {
+      reason: "hard",
+      ...lockedScope ? { lockedScope } : {}
+    });
+  }
+  return {
+    disabledNames: new Set(disablements.keys()),
+    defaultDisabledNames: defaultDisabled,
+    enabledNames: enabled,
+    disablements
+  };
+}
+__name(resolveSkillSettings, "resolveSkillSettings");
+function lookupSkillSetting(entries, skill) {
+  for (const name of skillRestrictionNames(skill)) {
+    const found = entries.get(name);
+    if (found !== void 0) return found;
+  }
+  return void 0;
+}
+__name(lookupSkillSetting, "lookupSkillSetting");
+function lookupSkillDisablement(disablements, skill) {
+  let fallback;
+  let hard;
+  for (const name of skillRestrictionNames(skill)) {
+    const found = disablements.get(name);
+    if (found?.reason === "hard") {
+      if (found.lockedScope) return found;
+      hard ??= found;
+      continue;
+    }
+    fallback ??= found;
+  }
+  return hard ?? fallback;
+}
+__name(lookupSkillDisablement, "lookupSkillDisablement");
+function buildHigherDisabled(settings) {
+  const scopeOfEntry = /* @__PURE__ */ new Map();
+  for (const [scope, label] of [
+    ["SystemDefaults" /* SystemDefaults */, "SystemDefaults"],
+    ["User" /* User */, "User"],
+    ["System" /* System */, "System"]
+  ]) {
+    for (const name of normalizeSkillNames(
+      skillSettingStrings(settings, scope, "disabled")
+    )) {
+      scopeOfEntry.set(name, label);
+    }
+  }
+  const hardEntries = /* @__PURE__ */ new Map();
+  const defaultEntries = /* @__PURE__ */ new Map();
+  for (const [scope, label] of [
+    ["SystemDefaults" /* SystemDefaults */, "SystemDefaults"],
+    ["User" /* User */, "User"],
+    ["Workspace" /* Workspace */, "Workspace"],
+    ["System" /* System */, "System"]
+  ]) {
+    if (scope === "Workspace" /* Workspace */ && !settings.isTrusted) continue;
+    for (const name of normalizeSkillNames(
+      skillSettingStrings(settings, scope, "disabled")
+    )) {
+      hardEntries.set(name, label);
+    }
+    for (const name of normalizeSkillNames(
+      skillSettingStrings(settings, scope, "defaultDisabled")
+    )) {
+      defaultEntries.set(name, label);
+    }
+  }
+  const enabledEntries = new Set(
+    [
+      "SystemDefaults" /* SystemDefaults */,
+      "User" /* User */,
+      "System" /* System */,
+      ...settings.isTrusted ? ["Workspace" /* Workspace */] : []
+    ].flatMap((scope) => [
+      ...normalizeSkillNames(skillSettingStrings(settings, scope, "enabled"))
+    ])
+  );
+  const workspaceDisabled = new Set(
+    settings.isTrusted ? normalizeSkillNames(
+      skillSettingStrings(settings, "Workspace" /* Workspace */, "disabled")
+    ) : []
+  );
+  const blockIn = /* @__PURE__ */ __name((skill) => {
+    const registry = skill.name.trim().toLowerCase();
+    const spellings = skillRestrictionNames(skill);
+    for (const spelling of spellings) {
+      const scope = scopeOfEntry.get(spelling);
+      if (scope) {
+        return { reason: "hard", list: "disabled", entry: spelling, scope };
+      }
+    }
+    for (const spelling of spellings) {
+      const hard = hardEntries.get(spelling);
+      if (hard) {
+        if (spelling === registry && workspaceDisabled.has(spelling)) {
+          continue;
+        }
+        return {
+          reason: "hard",
+          list: "disabled",
+          entry: spelling,
+          scope: hard
+        };
+      }
+      const def = defaultEntries.get(spelling);
+      if (def) {
+        if (spelling === registry || enabledEntries.has(spelling)) continue;
+        return {
+          reason: "default",
+          list: "defaultDisabled",
+          entry: spelling,
+          scope: def
+        };
+      }
+    }
+    return null;
+  }, "blockIn");
+  return {
+    blockIn,
+    lockedIn: /* @__PURE__ */ __name((skill) => {
+      const block = blockIn(skill);
+      if (!block) return null;
+      if (block.reason === "hard" && block.scope !== "Workspace") {
+        return block.scope;
+      }
+      return `skills.${block.list} '${block.entry}' (${block.scope})`;
+    }, "lockedIn")
+  };
+}
+__name(buildHigherDisabled, "buildHigherDisabled");
+function skillToggleBlockForName(settings, skillName) {
+  const prefixEnd = skillName.indexOf(":");
+  return buildHigherDisabled(settings).blockIn({
+    name: skillName,
+    ...prefixEnd > 0 ? { authoredName: skillName.slice(prefixEnd + 1) } : {}
+  });
+}
+__name(skillToggleBlockForName, "skillToggleBlockForName");
+function updateTarget(names, skillName, include) {
+  const normalizedName = skillName.trim().toLowerCase();
+  const next = [];
+  let found = false;
+  for (const name of names) {
+    if (name.trim().toLowerCase() !== normalizedName) {
+      next.push(name);
+    } else if (include && !found) {
+      next.push(skillName);
+      found = true;
+    }
+  }
+  if (include && !found) next.push(skillName);
+  return next;
+}
+__name(updateTarget, "updateTarget");
+function updateWorkspaceSkillSettingLists(lists, skillName, enabled) {
+  if (enabled) {
+    return {
+      disabled: updateTarget(lists.disabled, skillName, false),
+      enabled: updateTarget(lists.enabled, skillName, true)
+    };
+  }
+  return {
+    disabled: updateTarget(lists.disabled, skillName, true),
+    enabled: updateTarget(lists.enabled, skillName, false)
+  };
+}
+__name(updateWorkspaceSkillSettingLists, "updateWorkspaceSkillSettingLists");
+function computeWorkspaceSkillListUpdates(workspaceDisabled, workspaceEnabled, toggles) {
+  const previousDisabled = [...workspaceDisabled];
+  const previousEnabled = [...workspaceEnabled];
+  let next = {
+    disabled: previousDisabled,
+    enabled: previousEnabled
+  };
+  for (const toggle of toggles) {
+    if (toggle.wasEnabled === toggle.isEnabled) continue;
+    next = updateWorkspaceSkillSettingLists(
+      next,
+      toggle.name,
+      toggle.isEnabled
+    );
+  }
+  return {
+    disabled: next.disabled,
+    enabled: next.enabled,
+    disabledChanged: JSON.stringify(previousDisabled) !== JSON.stringify(next.disabled),
+    enabledChanged: JSON.stringify(previousEnabled) !== JSON.stringify(next.enabled)
+  };
+}
+__name(computeWorkspaceSkillListUpdates, "computeWorkspaceSkillListUpdates");
+
+export {
+  normalizeSkillNames,
+  skillSettingStrings,
+  resolveSkillSettings,
+  lookupSkillSetting,
+  lookupSkillDisablement,
+  buildHigherDisabled,
+  skillToggleBlockForName,
+  updateWorkspaceSkillSettingLists,
+  computeWorkspaceSkillListUpdates
+};
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-YQHLFCPU.js → chunk-LOAW7JYR.js}

@@ -17,6 +17,9 @@ import {
   normalizeSessionIdForLookup,
   parseCallerSuppliedSessionId
 } from "./chunk-ZEZKIS2K.js";
+import {
+  createSessionOrganizationService
+} from "./chunk-OAWFG54S.js";
 import {
   SessionArchivedError,
   SessionArchivingError,
@@ -27,13 +30,12 @@ import {
 import {
   readWorktreeSession,
   readWorktreeSessionStrict
-} from "./chunk-ZKZHSB5W.js";
+} from "./chunk-QR4Q425T.js";
 import {
   SESSION_PR_LIST_LIMIT,
   SESSION_PR_URL_MAX_LENGTH,
   SessionIdCaseConflictError,
   SessionOrganizationError,
-  SessionOrganizationService,
   SessionService,
   SessionTranscriptChangedError,
   SessionWriterUnavailableError,
@@ -41,21 +43,24 @@ import {
   gitEnv,
   readSessionPrs,
   toSessionPrInfo
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-KJFGH23C.js";
 import {
+  cronTaskSessionDeletionId,
+  getCronFilePath,
   updateCronTasks
-} from "./chunk-F53KKZUD.js";
+} from "./chunk-3LMDSCLU.js";
 import {
   GitWorktreeService,
   WORKTREE_SESSION_FILE,
   readWorktreeSessionMarkerStrict
-} from "./chunk-36HCNKDS.js";
+} from "./chunk-WKVZES7O.js";
 import {
+  NO_EXEC_CONFIG,
   findGitRoot
-} from "./chunk-3CZ2BQV6.js";
+} from "./chunk-NXUZFW3G.js";
 import {
   addDaemonRequestAttribute
-} from "./chunk-ZW2EUO2A.js";
+} from "./chunk-L6DIANLD.js";
 import {
   Storage
 } from "./chunk-ZAFYHRVY.js";
@@ -72,15 +77,6 @@ import {
 // packages/cli/src/serve/server/session-list.ts
 init_esbuild_shims();
 
-// packages/cli/src/serve/session-organization-helpers.ts
-init_esbuild_shims();
-function createSessionOrganizationService(workspaceCwd) {
-  return new SessionOrganizationService(workspaceCwd, (message) => {
-    writeStderrLine(`qwen serve: session-org: ${message}`);
-  });
-}
-__name(createSessionOrganizationService, "createSessionOrganizationService");
-
 // packages/cli/src/serve/server/persisted-session-list-cache.ts
 init_esbuild_shims();
 import path from "node:path";
@@ -1332,6 +1328,7 @@ import fs2 from "node:fs";
 
 // packages/cli/src/serve/scheduled-task-session-lifecycle.ts
 init_esbuild_shims();
+import { access } from "node:fs/promises";
 function isBoundTask(task) {
   return typeof task.sessionId === "string" && task.sessionId.length > 0;
 }
@@ -1387,16 +1384,26 @@ async function enableTasksForSessions(projectRoot, sessionIds, now = Date.now(),
 __name(enableTasksForSessions, "enableTasksForSessions");
 async function removeTasksForSessions(projectRoot, sessionIds, options = {}) {
   if (sessionIds.length === 0) return;
-  const targets = new Set(sessionIds);
+  try {
+    await access(getCronFilePath(projectRoot));
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  const targets = new Set(sessionIds.map(cronTaskSessionDeletionId));
+  const removedIds = [];
   await updateCronTasks(
     projectRoot,
     (tasks) => {
-      const next = tasks.filter(
-        (task) => !isBoundTask(task) || !targets.has(task.sessionId)
-      );
+      const next = tasks.filter((task) => {
+        if (!isBoundTask(task) || !targets.has(cronTaskSessionDeletionId(task.sessionId)))
+          return true;
+        removedIds.push(task.id);
+        return false;
+      });
       return next.length === tasks.length ? tasks : next;
     },
-    options
+    { ...options, deletionIds: /* @__PURE__ */ __name(() => [...removedIds, ...targets], "deletionIds") }
   );
 }
 __name(removeTasksForSessions, "removeTasksForSessions");
@@ -1451,6 +1458,8 @@ async function checkoutHasWork(worktreePath) {
     const { stdout } = await execFileAsync(
       "git",
       [
+        ...NO_EXEC_CONFIG,
+        "--no-optional-locks",
         "status",
         "--porcelain",
         "--untracked-files=normal",
@@ -2908,7 +2917,6 @@ var defaultAoneMrBackend = {
 };
 
 export {
-  createSessionOrganizationService,
   laterActivityTimestamp,
   invalidateWorkspaceSessionListCache,
   InvalidCursorError,
@@ -2938,11 +2946,11 @@ export {
 };
 /**
  * @license
- * Copyright 2025 Qwen Team
+ * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2026 Qwen Team
+ * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */

package/chunks/{chunk-X6K77VHC.js → chunk-LWWRJRCD.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getGlobalQwenDir
-} from "./chunk-7QYWGTHB.js";
+} from "./chunk-EPVEPTI3.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-UXEO7E3V.js → chunk-LYD3T3H7.js}

@@ -143,6 +143,7 @@ export {
   MAX_CHILD_HEAP_MB,
   JOURNAL_GROWTH_POOL_FRACTION,
   MAX_JOURNAL_GROWTH_POOL_MB,
+  detectAvailableMemoryMb,
   isValidMemoryBudgetMb,
   memoryBudgetRangeError,
   recommendedChildShareMb,