@qwen-code/qwen-code 0.21.0 → 0.21.1-nightly.20260731.702932cc7

package/chunks/{chunk-TGILQ3YH.js → chunk-QQTJK5GB.js}

@@ -2,12 +2,12 @@
 "use strict";
 import {
   buildPermissionSettings
-} from "./chunk-VRYUBFMC.js";
+} from "./chunk-GRUAVQQR.js";
 import {
   resolveVoiceStreamConfig,
   resolveVoiceTranscriptionConfig,
   transcribeVoiceAudio
-} from "./chunk-H4SBPHSA.js";
+} from "./chunk-NNL7WPPK.js";
 import {
   getVoiceSettingsScope,
   isSelectableVoiceModel,
@@ -16,7 +16,7 @@ import {
   readVoiceMode,
   readVoiceModel,
   resolveVoiceTransport
-} from "./chunk-YBL3QUDD.js";
+} from "./chunk-NQCXWP5D.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
   WorkspaceSettingsPartialPersistError,
@@ -24,15 +24,8 @@ import {
   WorkspaceSkillNotToggleableError
 } from "./chunk-OA4JVLSA.js";
 import {
-  MCP_RESTART_SERVER_DEADLINE_MS,
-  McpServerNotFoundError,
-  McpServerRestartFailedError,
-  SessionNotFoundError,
-  WorkspaceInitConflictError,
-  WorkspaceInitPathEscapeError,
-  WorkspaceInitRaceError,
-  WorkspaceInitSymlinkError
-} from "./chunk-UH3WSE5L.js";
+  MCP_RESTART_SERVER_DEADLINE_MS
+} from "./chunk-OCPBI7J5.js";
 import {
   BridgeChannelClosedError,
   SERVE_CONTROL_EXT_METHODS,
@@ -46,14 +39,26 @@ import {
   createIdleWorkspaceProvidersStatus,
   createIdleWorkspaceSkillsStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-VIA5XA4U.js";
+} from "./chunk-A5UODYG3.js";
+import {
+  resolveSkillSettings
+} from "./chunk-Z4X5MTRT.js";
+import {
+  McpServerNotFoundError,
+  McpServerRestartFailedError,
+  SessionNotFoundError,
+  WorkspaceInitConflictError,
+  WorkspaceInitPathEscapeError,
+  WorkspaceInitRaceError,
+  WorkspaceInitSymlinkError
+} from "./chunk-B4AJNNOL.js";
 import {
   getPersistScopeForModelSelection,
   loadSettings
-} from "./chunk-TEHGS6UP.js";
+} from "./chunk-A5T5W7PR.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-Z2BC6UJ5.js";
+} from "./chunk-UU2B5YG6.js";
 import {
   writeStderrLine,
   writeStderrLineSafe
@@ -62,11 +67,11 @@ import {
   ModelsConfig,
   SkillManager,
   require_yauzl
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-FRXG4ARO.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -885,7 +890,7 @@ function skillBaseDir(workspace, scope) {
   return scope === "workspace" ? path.join(workspace, ".qwen", "skills") : path.join(Storage.getGlobalQwenDir(), "skills");
 }
 __name(skillBaseDir, "skillBaseDir");
-async function removeInstallArtifacts(baseDir, skillName) {
+async function removeInstallArtifacts(baseDir, skillName, assertGenerationOpen) {
   const workDir = path.dirname(baseDir);
   const workPrefix = `.${path.basename(baseDir)}-${skillName}`;
   const locations = [
@@ -903,17 +908,18 @@ async function removeInstallArtifacts(baseDir, skillName) {
     await Promise.all(
       entries.filter(
         (entry) => prefixes.some((prefix) => entry.name.startsWith(prefix))
-      ).map(
-        (entry) => fs.rm(path.join(directory, entry.name), {
+      ).map(async (entry) => {
+        assertGenerationOpen?.();
+        await fs.rm(path.join(directory, entry.name), {
           recursive: true,
           force: true
-        })
-      )
+        });
+      })
     );
   }
 }
 __name(removeInstallArtifacts, "removeInstallArtifacts");
-async function ensureDirectoryWithoutSymlinks(directory) {
+async function ensureDirectoryWithoutSymlinks(directory, assertGenerationOpen) {
   const missing = [];
   let current = directory;
   while (true) {
@@ -931,15 +937,21 @@ async function ensureDirectoryWithoutSymlinks(directory) {
       current = parent;
     }
   }
-  for (const entry of missing.reverse()) await fs.mkdir(entry);
+  for (const entry of missing.reverse()) {
+    assertGenerationOpen?.();
+    await fs.mkdir(entry);
+  }
 }
 __name(ensureDirectoryWithoutSymlinks, "ensureDirectoryWithoutSymlinks");
-async function installWorkspaceSkill(workspace, request, githubToken) {
+async function installWorkspaceSkill(workspace, request, githubToken, assertGenerationOpen) {
+  assertGenerationOpen?.();
   const skillName = validateWorkspaceSkillName(request.name);
   const files = await filesFromSource(request.source, githubToken);
   const baseDir = skillBaseDir(workspace, request.scope);
-  await ensureDirectoryWithoutSymlinks(baseDir);
-  await removeInstallArtifacts(baseDir, skillName);
+  assertGenerationOpen?.();
+  await ensureDirectoryWithoutSymlinks(baseDir, assertGenerationOpen);
+  assertGenerationOpen?.();
+  await removeInstallArtifacts(baseDir, skillName, assertGenerationOpen);
   const destination = path.join(baseDir, skillName);
   const existing = await fs.lstat(destination).catch(() => void 0);
   if (existing?.isSymbolicLink() || existing && !existing.isDirectory()) {
@@ -947,15 +959,19 @@ async function installWorkspaceSkill(workspace, request, githubToken) {
   }
   const workDir = path.dirname(baseDir);
   const workPrefix = `.${path.basename(baseDir)}-${skillName}`;
+  assertGenerationOpen?.();
   const staging = await fs.mkdtemp(
     path.join(workDir, `${workPrefix}.installing-`)
   );
   const backup = path.join(workDir, `${workPrefix}.backup-${Date.now()}`);
   let movedExisting = false;
+  let committedStaging = false;
   try {
     for (const file of files) {
       const target = path.join(staging, ...file.relativePath.split("/"));
+      assertGenerationOpen?.();
       await fs.mkdir(path.dirname(target), { recursive: true });
+      assertGenerationOpen?.();
       await fs.writeFile(target, file.content);
     }
     const skillFile = path.join(staging, "SKILL.md");
@@ -979,12 +995,19 @@ async function installWorkspaceSkill(workspace, request, githubToken) {
       );
     }
     if (existing) {
+      assertGenerationOpen?.();
       await fs.rename(destination, backup);
       movedExisting = true;
     }
+    assertGenerationOpen?.();
     await fs.rename(staging, destination);
+    committedStaging = true;
+    assertGenerationOpen?.();
   } catch (error) {
-    await fs.rm(staging, { recursive: true, force: true }).catch(() => void 0);
+    await fs.rm(committedStaging ? destination : staging, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
     if (movedExisting) {
       await fs.rename(backup, destination).catch(() => void 0);
     }
@@ -1000,7 +1023,8 @@ async function installWorkspaceSkill(workspace, request, githubToken) {
   };
 }
 __name(installWorkspaceSkill, "installWorkspaceSkill");
-async function deleteWorkspaceSkill(workspace, scope, skillNameInput, installedPath) {
+async function deleteWorkspaceSkill(workspace, scope, skillNameInput, installedPath, assertGenerationOpen) {
+  assertGenerationOpen?.();
   const skillName = validateWorkspaceSkillName(skillNameInput);
   const skillDir = path.resolve(path.dirname(installedPath));
   const skillFile = path.resolve(installedPath);
@@ -1036,12 +1060,14 @@ async function deleteWorkspaceSkill(workspace, scope, skillNameInput, installedP
       "Skill name does not match its installed directory"
     );
   }
+  assertGenerationOpen?.();
   await fs.rm(skillDir, { recursive: true, force: true });
   return { skillName, scope, deleted: true };
 }
 __name(deleteWorkspaceSkill, "deleteWorkspaceSkill");
 
 // packages/cli/src/serve/workspace-service/index.ts
+var WORKSPACE_SKILLS_SNAPSHOT_TTL_MS = 5e3;
 async function canonicalizeExistingAncestor(inputPath) {
   let current = inputPath;
   while (true) {
@@ -1098,6 +1124,8 @@ __name(withTimeout, "withTimeout");
 function createDaemonWorkspaceService(deps) {
   const {
     boundWorkspace,
+    isWorkspaceTrusted,
+    assertGenerationOpen,
     contextFilename,
     statusProvider,
     workspaceProvidersStatusProvider,
@@ -1116,9 +1144,27 @@ function createDaemonWorkspaceService(deps) {
     refreshExtensionsForAllSessions: refreshExtensionsForAllSessionsOnBridge,
     publishWorkspaceEvent
   } = deps;
+  const loadBoundSettings = /* @__PURE__ */ __name((skipLoadEnvironment = false) => {
+    const workspaceTrusted = isWorkspaceTrusted();
+    return loadSettings(boundWorkspace, {
+      skipLoadEnvironment: skipLoadEnvironment || !workspaceTrusted,
+      skipWorkspaceSettings: !workspaceTrusted,
+      workspaceTrusted
+    });
+  }, "loadBoundSettings");
+  const assertActiveGeneration = /* @__PURE__ */ __name(() => assertGenerationOpen?.(), "assertActiveGeneration");
   let lastWorkspaceSkillsStatus;
+  let lastWorkspaceSkillsStatusAt = 0;
+  let workspaceSkillsGeneration = 0;
+  let inFlightWorkspaceSkillsStatus;
   let inFlightAcpPreheat;
-  const getWorkspaceSkillsStatus = /* @__PURE__ */ __name(async () => {
+  const invalidateWorkspaceSkillsSnapshot = /* @__PURE__ */ __name(() => {
+    workspaceSkillsGeneration += 1;
+    lastWorkspaceSkillsStatus = void 0;
+    lastWorkspaceSkillsStatusAt = 0;
+    workspaceSkillsStatusProvider?.invalidate?.(boundWorkspace);
+  }, "invalidateWorkspaceSkillsSnapshot");
+  const readWorkspaceSkillsStatus = /* @__PURE__ */ __name(async (generation) => {
     let status;
     try {
       status = await queryWorkspaceStatus(
@@ -1131,14 +1177,25 @@ function createDaemonWorkspaceService(deps) {
       );
       status = createIdleWorkspaceSkillsStatus(boundWorkspace);
     }
-    if (status.initialized) {
+    if (status.initialized && generation === workspaceSkillsGeneration) {
       lastWorkspaceSkillsStatus = status;
+      lastWorkspaceSkillsStatusAt = Date.now();
       return status;
     }
-    if (lastWorkspaceSkillsStatus) return lastWorkspaceSkillsStatus;
+    if (lastWorkspaceSkillsStatus) {
+      if (generation === workspaceSkillsGeneration) {
+        lastWorkspaceSkillsStatusAt = Date.now();
+      }
+      return lastWorkspaceSkillsStatus;
+    }
     if (workspaceSkillsStatusProvider) {
       try {
-        return await workspaceSkillsStatusProvider(boundWorkspace);
+        const localStatus = await workspaceSkillsStatusProvider(boundWorkspace);
+        if (localStatus.initialized && generation === workspaceSkillsGeneration) {
+          lastWorkspaceSkillsStatus = localStatus;
+          lastWorkspaceSkillsStatusAt = Date.now();
+        }
+        return localStatus;
       } catch (err) {
         writeStderrLine(
           `qwen serve: getWorkspaceSkillsStatus local provider failed: ${err instanceof Error ? err.message : String(err)}`
@@ -1146,22 +1203,47 @@ function createDaemonWorkspaceService(deps) {
       }
     }
     return status;
+  }, "readWorkspaceSkillsStatus");
+  const getWorkspaceSkillsStatus = /* @__PURE__ */ __name(() => {
+    const cacheAgeMs = Date.now() - lastWorkspaceSkillsStatusAt;
+    if (lastWorkspaceSkillsStatus && cacheAgeMs >= 0 && cacheAgeMs < WORKSPACE_SKILLS_SNAPSHOT_TTL_MS) {
+      return Promise.resolve(lastWorkspaceSkillsStatus);
+    }
+    const generation = workspaceSkillsGeneration;
+    if (inFlightWorkspaceSkillsStatus?.generation === generation) {
+      return inFlightWorkspaceSkillsStatus.promise;
+    }
+    const promise = readWorkspaceSkillsStatus(generation);
+    inFlightWorkspaceSkillsStatus = { generation, promise };
+    const clearInFlight = /* @__PURE__ */ __name(() => {
+      if (inFlightWorkspaceSkillsStatus?.promise === promise) {
+        inFlightWorkspaceSkillsStatus = void 0;
+      }
+    }, "clearInFlight");
+    void promise.then(clearInFlight, clearInFlight);
+    return promise;
   }, "getWorkspaceSkillsStatus");
   const refreshWorkspaceSkillsAfterMutation = /* @__PURE__ */ __name(async () => {
-    lastWorkspaceSkillsStatus = void 0;
-    workspaceSkillsStatusProvider?.invalidate?.(boundWorkspace);
+    invalidateWorkspaceSkillsSnapshot();
     if (!(isChannelLive?.() ?? false)) return;
     try {
-      await invokeWorkspaceCommand(
+      const refreshed = await invokeWorkspaceCommand(
         SERVE_CONTROL_EXT_METHODS.workspaceSkillsRefresh,
-        { cwd: boundWorkspace }
+        { cwd: boundWorkspace, reason: "content" }
       );
+      if ((refreshed.configsFailed ?? 0) > 0) {
+        writeStderrLine(
+          `qwen serve: ${refreshed.configsFailed} skill cache refresh(es) failed after mutation`
+        );
+      }
     } catch (err) {
       if (!(err instanceof SessionNotFoundError) && !(err instanceof BridgeChannelClosedError)) {
         writeStderrLine(
           `qwen serve: workspace skill refresh after mutation failed: ${err instanceof Error ? err.message : String(err)}`
         );
       }
+    } finally {
+      invalidateWorkspaceSkillsSnapshot();
     }
   }, "refreshWorkspaceSkillsAfterMutation");
   return {
@@ -1188,6 +1270,7 @@ function createDaemonWorkspaceService(deps) {
       );
     },
     async preheatAcpChild(_ctx, opts) {
+      assertActiveGeneration();
       const startedAt = performance.now();
       const channelLive = /* @__PURE__ */ __name(() => isChannelLive?.() ?? false, "channelLive");
       const finish = /* @__PURE__ */ __name((result) => ({
@@ -1346,24 +1429,22 @@ function createDaemonWorkspaceService(deps) {
     },
     async getWorkspaceTrustStatus(_ctx) {
       return getWorkspaceTrustStatus(
-        loadSettings(boundWorkspace).merged,
+        loadBoundSettings(true).merged,
         boundWorkspace
       );
     },
     async getWorkspacePermissionsStatus(_ctx) {
-      return buildPermissionSettings(loadSettings(boundWorkspace));
+      return buildPermissionSettings(loadBoundSettings());
     },
     async getWorkspaceVoiceStatus(_ctx) {
       return buildWorkspaceVoiceStatus(
         boundWorkspace,
-        loadSettings(
-          boundWorkspace,
-          voiceEnv ? { skipLoadEnvironment: true } : true
-        )
+        loadBoundSettings(Boolean(voiceEnv))
       );
     },
     // -- Mutations --
     async requestWorkspaceTrustChange(ctx, request) {
+      assertActiveGeneration();
       publishWorkspaceEvent({
         type: "trust_change_requested",
         data: {
@@ -1380,6 +1461,7 @@ function createDaemonWorkspaceService(deps) {
       };
     },
     async setWorkspacePermissionRules(ctx, request) {
+      assertActiveGeneration();
       const key = `permissions.${request.ruleType}`;
       try {
         const result = await invokeWorkspaceCommand(
@@ -1391,6 +1473,7 @@ function createDaemonWorkspaceService(deps) {
             rules: request.rules
           }
         );
+        assertActiveGeneration();
         publishWorkspaceEvent({
           type: "settings_changed",
           data: { key, value: request.rules, scope: request.scope },
@@ -1405,6 +1488,7 @@ function createDaemonWorkspaceService(deps) {
       }
     },
     async setWorkspaceVoiceSettings(ctx, request) {
+      assertActiveGeneration();
       if (!persistSettings && !persistSetting) {
         throw new WorkspaceVoiceError(
           501,
@@ -1412,14 +1496,10 @@ function createDaemonWorkspaceService(deps) {
           "Workspace voice settings persistence is not available"
         );
       }
-      const settings = loadSettings(
-        boundWorkspace,
-        voiceEnv ? { skipLoadEnvironment: true } : true
-      );
+      const settings = loadBoundSettings(Boolean(voiceEnv));
       validateWorkspaceVoiceState(settings, request, { env: voiceEnv });
-      const workspaceTrusted = getWorkspaceTrustStatus(settings.merged, boundWorkspace).effective.state === "trusted";
       const writes = buildWorkspaceVoiceSettingsWrites(settings, request, {
-        workspaceTrusted,
+        workspaceTrusted: isWorkspaceTrusted(),
         ...voiceSettingsScope ? { scopeOverride: voiceSettingsScope } : {}
       });
       const publishWrite = /* @__PURE__ */ __name((write) => {
@@ -1435,15 +1515,17 @@ function createDaemonWorkspaceService(deps) {
       }, "publishWrite");
       if (persistSettings) {
         try {
-          await persistSettings(boundWorkspace, writes);
+          await persistSettings(boundWorkspace, writes, assertGenerationOpen);
         } catch (err) {
           if (err instanceof WorkspaceSettingsPartialPersistError) {
+            assertActiveGeneration();
             for (const write of err.committedWrites) {
               publishWrite(write);
             }
           }
           throw err;
         }
+        assertActiveGeneration();
         for (const write of writes) {
           publishWrite(write);
         }
@@ -1455,9 +1537,11 @@ function createDaemonWorkspaceService(deps) {
               boundWorkspace,
               write.scope,
               write.key,
-              write.value
+              write.value,
+              assertGenerationOpen
             );
           } catch (err) {
+            assertActiveGeneration();
             writeStderrLine(
               `qwen serve: workspace voice partial persist error (workspace=${boundWorkspace}, committed=${committed.length}/${writes.length}, failedKey=${write.key}, failedScope=${voiceSettingsScopeToWire(write.scope)}): ${err instanceof Error ? err.message : String(err)}`
             );
@@ -1470,22 +1554,28 @@ function createDaemonWorkspaceService(deps) {
               err
             );
           }
+          assertActiveGeneration();
           committed.push(write);
         }
+        assertActiveGeneration();
         for (const write of committed) {
           publishWrite(write);
         }
       }
       return buildWorkspaceVoiceStatus(
         boundWorkspace,
-        loadSettings(
-          boundWorkspace,
-          voiceEnv ? { skipLoadEnvironment: true } : true
-        )
+        loadBoundSettings(Boolean(voiceEnv))
       );
     },
     async setWorkspaceToolEnabled(ctx, toolName, enabled) {
-      await persistDisabledTools(boundWorkspace, toolName, enabled);
+      assertActiveGeneration();
+      await persistDisabledTools(
+        boundWorkspace,
+        toolName,
+        enabled,
+        assertGenerationOpen
+      );
+      assertActiveGeneration();
       publishWorkspaceEvent({
         type: "tool_toggled",
         data: { toolName, enabled },
@@ -1494,6 +1584,7 @@ function createDaemonWorkspaceService(deps) {
       return { toolName, enabled };
     },
     async setWorkspaceSkillEnabled(ctx, requestedSkillName, enabled) {
+      assertActiveGeneration();
       const normalizedName = requestedSkillName.trim().toLowerCase();
       const status = await getWorkspaceSkillsStatus();
       const skill = status.skills.find(
@@ -1506,11 +1597,11 @@ function createDaemonWorkspaceService(deps) {
           "not_user_invocable"
         );
       }
-      const disabled = loadSettings(boundWorkspace).merged.skills?.disabled;
-      const disabledNames = new Set(
-        (Array.isArray(disabled) ? disabled : []).filter((name) => typeof name === "string").map((name) => name.trim().toLowerCase()).filter(Boolean)
+      const needsLegacyInactiveCheck = skill.level === "extension" && skill.status === "disabled" && skill.disabledReason === void 0;
+      const disabledBySettings = needsLegacyInactiveCheck && resolveSkillSettings(loadBoundSettings(true)).disabledNames.has(
+        normalizedName
       );
-      if (skill.level === "extension" && skill.status === "disabled" && !disabledNames.has(normalizedName)) {
+      if (skill.level === "extension" && skill.status === "disabled" && (skill.disabledReason === "inactive_extension" || skill.disabledReason === void 0 && !disabledBySettings)) {
         throw new WorkspaceSkillNotToggleableError(
           skill.name,
           "inactive_extension"
@@ -1519,21 +1610,23 @@ function createDaemonWorkspaceService(deps) {
       const persisted = await persistDisabledSkills(
         boundWorkspace,
         skill.name,
-        enabled
+        enabled,
+        assertGenerationOpen
       );
+      assertActiveGeneration();
       const channelLive = isChannelLive?.() ?? false;
       let activation = channelLive ? "applied" : "deferred";
       let sessionsRefreshed = 0;
       let sessionsFailed = 0;
       if (persisted.changed) {
-        lastWorkspaceSkillsStatus = void 0;
-        workspaceSkillsStatusProvider?.invalidate?.(boundWorkspace);
+        invalidateWorkspaceSkillsSnapshot();
         if (channelLive) {
           try {
             const refreshed = await invokeWorkspaceCommand(
               SERVE_CONTROL_EXT_METHODS.workspaceSkillsRefresh,
-              { cwd: boundWorkspace }
+              { cwd: boundWorkspace, reason: "settings" }
             );
+            assertActiveGeneration();
             sessionsRefreshed = refreshed.sessionsRefreshed;
             sessionsFailed = refreshed.sessionsFailed;
             if (sessionsFailed > 0) activation = "partial";
@@ -1548,16 +1641,26 @@ function createDaemonWorkspaceService(deps) {
               );
             }
           }
+          invalidateWorkspaceSkillsSnapshot();
         }
-        publishWorkspaceEvent({
-          type: "settings_changed",
-          data: {
+        assertActiveGeneration();
+        const settingsChanges = persisted.settingsChanges ?? [
+          {
             key: "skills.disabled",
-            value: persisted.disabled.length > 0 ? persisted.disabled : void 0,
-            scope: "workspace"
-          },
-          originatorClientId: ctx.originatorClientId
-        });
+            value: persisted.disabled.length > 0 ? persisted.disabled : void 0
+          }
+        ];
+        for (const change of settingsChanges) {
+          publishWorkspaceEvent({
+            type: "settings_changed",
+            data: {
+              key: change.key,
+              value: change.value,
+              scope: "workspace"
+            },
+            originatorClientId: ctx.originatorClientId
+          });
+        }
       }
       return {
         skillName: skill.name,
@@ -1569,15 +1672,20 @@ function createDaemonWorkspaceService(deps) {
       };
     },
     async installWorkspaceSkill(_ctx, request) {
+      assertActiveGeneration();
       const result = await installWorkspaceSkill(
         boundWorkspace,
         request,
-        skillInstallEnv?.["GH_TOKEN"] ?? skillInstallEnv?.["GITHUB_TOKEN"]
+        skillInstallEnv?.["GH_TOKEN"] ?? skillInstallEnv?.["GITHUB_TOKEN"],
+        assertGenerationOpen
       );
+      assertActiveGeneration();
       await refreshWorkspaceSkillsAfterMutation();
+      assertActiveGeneration();
       return result;
     },
     async deleteWorkspaceSkill(_ctx, requestedSkillName, scope) {
+      assertActiveGeneration();
       const normalizedName = requestedSkillName.trim().toLowerCase();
       const status = await getWorkspaceSkillsStatus();
       const skill = status.skills.find(
@@ -1596,12 +1704,16 @@ function createDaemonWorkspaceService(deps) {
         boundWorkspace,
         scope,
         skill.name,
-        skill.installedPath
+        skill.installedPath,
+        assertGenerationOpen
       );
+      assertActiveGeneration();
       await refreshWorkspaceSkillsAfterMutation();
+      assertActiveGeneration();
       return result;
     },
     async initWorkspace(ctx, opts) {
+      assertActiveGeneration();
       const filename = contextFilename;
       const target = path2.resolve(boundWorkspace, filename);
       const withinWorkspace = target === boundWorkspace || target.startsWith(boundWorkspace + path2.sep);
@@ -1661,6 +1773,7 @@ function createDaemonWorkspaceService(deps) {
       if (action === "created") {
         let fh;
         try {
+          assertActiveGeneration();
           fh = await fs2.open(target, "wx");
         } catch (err) {
           const code = err?.code;
@@ -1675,6 +1788,7 @@ function createDaemonWorkspaceService(deps) {
         }
         try {
           await verifyParentPostOpen(target, wsCanonical, fh);
+          assertActiveGeneration();
           await fh.writeFile("", "utf8");
         } finally {
           await fh.close();
@@ -1682,6 +1796,7 @@ function createDaemonWorkspaceService(deps) {
       } else if (action === "overwrote") {
         let overwriteFh;
         try {
+          assertActiveGeneration();
           overwriteFh = await fs2.open(
             target,
             fsConstants.O_WRONLY | (fsConstants.O_NOFOLLOW ?? 0)
@@ -1706,11 +1821,13 @@ function createDaemonWorkspaceService(deps) {
         }
         try {
           await verifyParentPostOpen(target, wsCanonical, overwriteFh);
+          assertActiveGeneration();
           await overwriteFh.truncate(0);
         } finally {
           await overwriteFh.close();
         }
       }
+      assertActiveGeneration();
       publishWorkspaceEvent({
         type: "workspace_initialized",
         data: { path: target, action },
@@ -1719,6 +1836,7 @@ function createDaemonWorkspaceService(deps) {
       return { path: target, action };
     },
     async restartMcpServer(ctx, serverName, opts) {
+      assertActiveGeneration();
       const params = { serverName };
       if (opts?.entryIndex !== void 0) {
         params["entryIndex"] = opts.entryIndex;
@@ -1748,6 +1866,7 @@ function createDaemonWorkspaceService(deps) {
         }
         throw err;
       }
+      assertActiveGeneration();
       if ("entries" in result) {
         const entries = Array.isArray(result.entries) ? result.entries : [];
         if (!Array.isArray(result.entries)) {
@@ -1807,15 +1926,17 @@ function createDaemonWorkspaceService(deps) {
       return result;
     },
     async reload(ctx) {
+      assertActiveGeneration();
       if (deps.reloadDaemonEnv) {
         try {
-          await deps.reloadDaemonEnv(boundWorkspace);
+          await deps.reloadDaemonEnv(boundWorkspace, assertGenerationOpen);
         } catch (err) {
           writeStderrLine(
             `qwen serve: daemon reload failed: ${err instanceof Error ? err.message : String(err)}`
           );
         }
       }
+      assertActiveGeneration();
       let childReloaded = false;
       let env = {
         updatedKeys: [],
@@ -1844,6 +1965,7 @@ function createDaemonWorkspaceService(deps) {
           writeStderrLine(`qwen serve: reload failed: ${childError}`);
         }
       }
+      assertActiveGeneration();
       publishWorkspaceEvent({
         type: "settings_reloaded",
         data: {
@@ -1866,9 +1988,10 @@ function createDaemonWorkspaceService(deps) {
       };
     },
     invalidateWorkspaceSkillsStatus() {
-      lastWorkspaceSkillsStatus = void 0;
+      invalidateWorkspaceSkillsSnapshot();
     },
     async refreshExtensionsForAllSessions() {
+      assertActiveGeneration();
       try {
         if (!refreshExtensionsForAllSessionsOnBridge) {
           throw new Error("refreshExtensionsForAllSessions is not wired");
@@ -1880,7 +2003,7 @@ function createDaemonWorkspaceService(deps) {
         );
         return { refreshed: 0, failed: 1 };
       } finally {
-        lastWorkspaceSkillsStatus = void 0;
+        invalidateWorkspaceSkillsSnapshot();
       }
     }
   };