@qwen-code/qwen-code 0.22.3-nightly.20260831.3a0c4c6108 → 0.23.0

package/chunks/chunk-P6UIF2OW.js

@@ -0,0 +1,400 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  STATUS_SCHEMA_VERSION
+} from "./chunk-64QH2UC6.js";
+import {
+  WorkspaceDrainingError
+} from "./chunk-F47DITLZ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/workspace-runtime-coordinator.ts
+init_esbuild_shims();
+var DEFAULT_ENSURE_TIMEOUT_MS = 6e4;
+var ENSURE_KEEP_ALIVE_MS = 10 * 6e4;
+var MCP_PREPARE_TIMEOUT_MS = 2 * 6e4;
+var MCP_POLL_INTERVAL_MS = 250;
+var WorkspaceRuntimeStillStartingError = class extends Error {
+  static {
+    __name(this, "WorkspaceRuntimeStillStartingError");
+  }
+  constructor() {
+    super("Workspace runtime is still starting");
+    this.name = "WorkspaceRuntimeStillStartingError";
+  }
+};
+var WorkspaceRuntimeInitializationError = class extends Error {
+  static {
+    __name(this, "WorkspaceRuntimeInitializationError");
+  }
+  constructor(cause) {
+    super("Workspace runtime failed to initialize", { cause });
+    this.name = "WorkspaceRuntimeInitializationError";
+  }
+};
+function withTimeout(operation, timeoutMs) {
+  let timer;
+  return Promise.race([
+    operation,
+    new Promise((_resolve, reject) => {
+      timer = setTimeout(
+        () => reject(new WorkspaceRuntimeStillStartingError()),
+        timeoutMs
+      );
+      timer.unref?.();
+    })
+  ]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+__name(withTimeout, "withTimeout");
+function supportsWorkspaceRuntimeLifecycle(bridge) {
+  return typeof bridge.getWorkspaceRuntimeLifecycleSnapshot === "function";
+}
+__name(supportsWorkspaceRuntimeLifecycle, "supportsWorkspaceRuntimeLifecycle");
+var WorkspaceRuntimeCoordinator = class {
+  constructor(runtime, bridge) {
+    this.runtime = runtime;
+    this.bridge = bridge;
+  }
+  static {
+    __name(this, "WorkspaceRuntimeCoordinator");
+  }
+  disposed = false;
+  draining = false;
+  activeManagementOperations = 0;
+  mcpRevision = 0;
+  mcpConfigRevision = 0;
+  mcpStatus = {
+    state: "not_started",
+    revision: 0
+  };
+  mcpReconcileDeferred = false;
+  mcpPhysicalTail = Promise.resolve();
+  mcpQueuedWork = 0;
+  beginDrain() {
+    this.draining = true;
+  }
+  cancelDrain() {
+    if (this.disposed) return;
+    this.draining = false;
+    if (this.mcpReconcileDeferred) {
+      this.mcpReconcileDeferred = false;
+      this.scheduleMcpReconciliation();
+    }
+  }
+  hasActiveWork() {
+    return this.activeManagementOperations > 0 || this.mcpQueuedWork > 0 || this.bridge.getWorkspaceRuntimeLifecycleSnapshot().activeWork;
+  }
+  dispose() {
+    this.disposed = true;
+    this.draining = true;
+  }
+  status() {
+    const snapshot = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+    const mcpStatus = this.mcpStatus.runtimeEpoch !== void 0 && (!snapshot.runtimeLive || this.mcpStatus.runtimeEpoch !== snapshot.runtimeEpoch) ? {
+      state: "stale",
+      revision: this.mcpStatus.revision,
+      runtimeEpoch: this.mcpStatus.runtimeEpoch
+    } : this.mcpStatus;
+    return {
+      v: STATUS_SCHEMA_VERSION,
+      workspaceCwd: this.runtime.workspaceCwd,
+      state: snapshot.state,
+      runtimeLive: snapshot.runtimeLive,
+      runtimeEpoch: snapshot.runtimeEpoch,
+      capabilities: { mcp: mcpStatus }
+    };
+  }
+  async ensure(timeoutMs = DEFAULT_ENSURE_TIMEOUT_MS) {
+    this.assertAcceptingWork();
+    const deadline = Date.now() + timeoutMs;
+    try {
+      await withTimeout(
+        this.bridge.preheat({ keepAliveMs: ENSURE_KEEP_ALIVE_MS }),
+        timeoutMs
+      );
+    } catch (error) {
+      this.assertAcceptingWork(error);
+      if (error instanceof WorkspaceRuntimeStillStartingError) throw error;
+      throw new WorkspaceRuntimeInitializationError(error);
+    }
+    this.assertAcceptingWork();
+    const status = this.status();
+    if (!status.runtimeLive) {
+      throw new WorkspaceRuntimeInitializationError(
+        new Error("ACP preheat completed without a live runtime")
+      );
+    }
+    const revision = this.mcpRevision;
+    const preparation = this.prepareMcp();
+    void preparation.catch((error) => {
+      this.recordMcpError(revision, status.runtimeEpoch, error);
+    });
+    const remainingMs = deadline - Date.now();
+    if (remainingMs > 0) {
+      try {
+        await withTimeout(preparation, remainingMs);
+      } catch (error) {
+        if (!(error instanceof WorkspaceRuntimeStillStartingError)) throw error;
+      }
+    }
+    return this.status();
+  }
+  async runManagementOperation(run) {
+    this.assertAcceptingWork();
+    this.activeManagementOperations += 1;
+    try {
+      return await run();
+    } finally {
+      this.activeManagementOperations -= 1;
+    }
+  }
+  reconcileMcpConfiguration() {
+    this.mcpRevision += 1;
+    this.mcpConfigRevision += 1;
+    return this.scheduleMcpReconciliation();
+  }
+  scheduleMcpReconciliation() {
+    const snapshot = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+    if (!snapshot.runtimeLive || this.draining || this.disposed) {
+      this.mcpReconcileDeferred ||= snapshot.runtimeLive && this.draining;
+      this.mcpStatus = {
+        state: this.mcpStatus.runtimeEpoch === void 0 ? "not_started" : "stale",
+        revision: this.mcpRevision,
+        ...this.mcpStatus.runtimeEpoch === void 0 ? {} : { runtimeEpoch: this.mcpStatus.runtimeEpoch }
+      };
+      return "deferred";
+    }
+    this.mcpStatus = {
+      state: "starting",
+      revision: this.mcpRevision,
+      runtimeEpoch: snapshot.runtimeEpoch
+    };
+    const revision = this.mcpRevision;
+    const configRevision = this.mcpConfigRevision;
+    void this.queueMcpWork(async () => {
+      if (configRevision !== this.mcpConfigRevision) return;
+      await this.bridge.reloadWorkspaceMcp();
+      await this.prepareMcpRevision(revision);
+    }).catch((error) => {
+      if (this.draining && !this.disposed) this.mcpReconcileDeferred = true;
+      this.recordMcpError(revision, snapshot.runtimeEpoch, error);
+    });
+    return "reconciling";
+  }
+  async runMcpRuntimeMutation(run) {
+    this.assertAcceptingWork();
+    const revision = ++this.mcpRevision;
+    const initial = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+    this.mcpStatus = {
+      state: initial.runtimeLive ? "starting" : "not_started",
+      revision,
+      ...initial.runtimeLive ? { runtimeEpoch: initial.runtimeEpoch } : {}
+    };
+    let started = false;
+    const operation = this.queueMcpWork(async () => {
+      started = true;
+      let snapshot = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+      let mutationRejected = false;
+      try {
+        if (!snapshot.runtimeLive) {
+          try {
+            await this.bridge.preheat({ keepAliveMs: ENSURE_KEEP_ALIVE_MS });
+          } catch (error) {
+            if (error instanceof WorkspaceRuntimeStillStartingError)
+              throw error;
+            throw new WorkspaceRuntimeInitializationError(error);
+          }
+          snapshot = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+          if (!snapshot.runtimeLive) {
+            throw new WorkspaceRuntimeInitializationError(
+              new Error("ACP preheat completed without a live runtime")
+            );
+          }
+        }
+        if (revision === this.mcpRevision) {
+          this.mcpStatus = {
+            state: "starting",
+            revision,
+            runtimeEpoch: snapshot.runtimeEpoch
+          };
+        }
+        let result;
+        try {
+          result = await run();
+        } catch (error) {
+          mutationRejected = true;
+          void this.queueMcpWork(() => this.prepareMcpRevision(revision)).catch(
+            (prepareError) => {
+              this.recordMcpError(
+                revision,
+                snapshot.runtimeEpoch,
+                prepareError
+              );
+            }
+          );
+          throw error;
+        }
+        await this.prepareMcpRevision(revision);
+        return result;
+      } catch (error) {
+        if (!mutationRejected) {
+          this.recordMcpError(revision, snapshot.runtimeEpoch, error);
+        }
+        throw error;
+      }
+    });
+    try {
+      return await operation;
+    } catch (error) {
+      if (!started) {
+        if (this.draining && !this.disposed) this.mcpReconcileDeferred = true;
+        this.recordMcpError(revision, initial.runtimeEpoch, error);
+      }
+      throw error;
+    }
+  }
+  prepareMcp() {
+    const revision = this.mcpRevision;
+    return this.queueMcpWork(() => this.prepareMcpRevision(revision));
+  }
+  queueMcpWork(run) {
+    this.mcpQueuedWork += 1;
+    const operation = this.mcpPhysicalTail.catch(() => void 0).then(async () => {
+      this.assertAcceptingWork();
+      return await run();
+    }).finally(() => {
+      this.mcpQueuedWork -= 1;
+    });
+    this.mcpPhysicalTail = operation.then(
+      () => void 0,
+      () => void 0
+    );
+    return operation;
+  }
+  async prepareMcpRevision(revision) {
+    const deadline = Date.now() + MCP_PREPARE_TIMEOUT_MS;
+    let snapshot = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+    if (!snapshot.runtimeLive) {
+      try {
+        await this.bridge.preheat({ keepAliveMs: ENSURE_KEEP_ALIVE_MS });
+      } catch (error) {
+        if (error instanceof WorkspaceRuntimeStillStartingError) throw error;
+        throw new WorkspaceRuntimeInitializationError(error);
+      }
+      snapshot = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+    }
+    const epoch = snapshot.runtimeEpoch;
+    if (revision !== this.mcpRevision) return;
+    this.mcpStatus = { state: "starting", revision, runtimeEpoch: epoch };
+    try {
+      let status = await this.runtime.workspaceService.getWorkspaceMcpStatus({
+        route: "workspace runtime MCP preparation",
+        workspaceCwd: this.runtime.workspaceCwd
+      });
+      let initializationRequested = false;
+      while (true) {
+        if (revision !== this.mcpRevision) return;
+        const current2 = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+        if (this.draining || this.disposed || !current2.runtimeLive || current2.runtimeEpoch !== epoch) {
+          if (this.draining && !this.disposed && current2.runtimeLive && current2.runtimeEpoch === epoch) {
+            this.mcpReconcileDeferred = true;
+          }
+          this.mcpStatus = { state: "stale", revision, runtimeEpoch: epoch };
+          return;
+        }
+        const currentEpochStatus = status.runtimeEpoch === epoch && status.source === "live";
+        if (currentEpochStatus && status.discoveryState === "not_started" && !initializationRequested) {
+          initializationRequested = true;
+          await this.bridge.initializeWorkspaceMcp();
+        }
+        if (currentEpochStatus && status.errors?.length) {
+          throw new Error(
+            status.errors[0]?.error ?? "MCP discovery failed to initialize"
+          );
+        }
+        if (currentEpochStatus && status.discoveryState === "completed") break;
+        if (Date.now() >= deadline) {
+          throw new WorkspaceRuntimeStillStartingError();
+        }
+        await new Promise((resolve) => {
+          const timer = setTimeout(resolve, MCP_POLL_INTERVAL_MS);
+          timer.unref?.();
+        });
+        status = await this.runtime.workspaceService.getWorkspaceMcpStatus({
+          route: "workspace runtime MCP preparation",
+          workspaceCwd: this.runtime.workspaceCwd
+        });
+      }
+      const current = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+      if (revision !== this.mcpRevision) return;
+      if (!current.runtimeLive || current.runtimeEpoch !== epoch) {
+        this.mcpStatus = { state: "stale", revision, runtimeEpoch: epoch };
+        return;
+      }
+      this.mcpStatus = { state: "ready", revision, runtimeEpoch: epoch };
+    } catch (error) {
+      this.recordMcpError(revision, epoch, error);
+    }
+  }
+  recordMcpError(revision, runtimeEpoch, error) {
+    const current = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+    if (revision !== this.mcpRevision) return;
+    if (this.draining || !current.runtimeLive || current.runtimeEpoch !== runtimeEpoch) {
+      this.mcpStatus = { state: "stale", revision, runtimeEpoch };
+      return;
+    }
+    this.mcpStatus = {
+      state: "error",
+      revision,
+      runtimeEpoch,
+      error: {
+        code: error instanceof WorkspaceRuntimeStillStartingError ? "mcp_prepare_timed_out" : "mcp_prepare_failed",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+  assertAcceptingWork(cause) {
+    this.runtime.generationGuard?.assertOpen();
+    if (this.disposed || this.draining) {
+      throw new WorkspaceDrainingError(this.runtime.workspaceCwd, cause);
+    }
+  }
+};
+function getWorkspaceRuntimeCoordinatorIfSupported(runtime) {
+  if (!supportsWorkspaceRuntimeLifecycle(runtime.bridge)) return void 0;
+  runtime.runtimeCoordinator ??= new WorkspaceRuntimeCoordinator(
+    runtime,
+    runtime.bridge
+  );
+  return runtime.runtimeCoordinator;
+}
+__name(getWorkspaceRuntimeCoordinatorIfSupported, "getWorkspaceRuntimeCoordinatorIfSupported");
+function getWorkspaceRuntimeCoordinator(runtime) {
+  const coordinator = getWorkspaceRuntimeCoordinatorIfSupported(runtime);
+  if (!coordinator) {
+    throw new Error("Workspace runtime lifecycle is not supported");
+  }
+  return coordinator;
+}
+__name(getWorkspaceRuntimeCoordinator, "getWorkspaceRuntimeCoordinator");
+
+export {
+  WorkspaceRuntimeStillStartingError,
+  WorkspaceRuntimeInitializationError,
+  supportsWorkspaceRuntimeLifecycle,
+  WorkspaceRuntimeCoordinator,
+  getWorkspaceRuntimeCoordinatorIfSupported,
+  getWorkspaceRuntimeCoordinator
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-V4HN35IF.js → chunk-PCRBLMIN.js}

@@ -3,10 +3,13 @@
 import {
   getPlugin,
   supportedTypes
-} from "./chunk-CAZADEU7.js";
+} from "./chunk-NXKOVOM5.js";
 import {
   resolveChannelCwd
-} from "./chunk-GN422P4J.js";
+} from "./chunk-TSZSGQ3N.js";
+import {
+  isInternalSecretEnvVar
+} from "./chunk-4F7GQGXB.js";
 import {
   APPROVAL_MODES
 } from "./chunk-JX6XHPTX.js";
@@ -21,12 +24,21 @@ import {
 init_esbuild_shims();
 var ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
 var CHANNEL_APPROVAL_MODES = new Set(APPROVAL_MODES);
+function assertNotInternalSecret(envName, reference) {
+  if (isInternalSecretEnvVar(envName)) {
+    throw new Error(
+      `Environment variable ${envName} is a Qwen-internal secret and is never resolved into channel configuration (referenced as ${reference})`
+    );
+  }
+}
+__name(assertNotInternalSecret, "assertNotInternalSecret");
 function resolveEnvVars(value, env = process.env) {
   if (value.startsWith("$$")) {
     return value.substring(1);
   }
   if (value.startsWith("$")) {
     const envName = value.substring(1);
+    assertNotInternalSecret(envName, value);
     const envValue = env[envName];
     if (envValue === void 0) {
       throw new Error(
@@ -82,6 +94,7 @@ function resolveConfigEnvVar(value, mode) {
   if (value.startsWith("$$")) return value.substring(1);
   if (mode === "available" && value.startsWith("$")) {
     const envName = value.substring(1);
+    assertNotInternalSecret(envName, value);
     const envValue = process.env[envName];
     if (envValue === void 0) {
       throw new Error(
@@ -248,6 +261,7 @@ function resolveWebhookSecretEnv(channelName, path, secretEnv, env) {
       `Channel "${channelName}" field "${path}.secretEnv" must be an environment variable name or $-prefixed reference.`
     );
   }
+  assertNotInternalSecret(envName, `${path}.secretEnv`);
   const envValue = env[envName];
   if (envValue === void 0) {
     throw new Error(

package/chunks/{chunk-L2OKAIUK.js → chunk-QI27MKNQ.js}

@@ -1,11 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  formatHistoryGapNotice
+} from "./chunk-NRL5CUZT.js";
 import {
   sanitizeTerminalText
 } from "./chunk-47ECGEJC.js";
-import {
-  formatHistoryGapNotice
-} from "./chunk-OQYXJK2V.js";
 import {
   loadUndici
 } from "./chunk-TXASDT2M.js";
@@ -14,25 +14,23 @@ import {
 } from "./chunk-ZGCKTAL5.js";
 import {
   projectGoalStateToLegacy
-} from "./chunk-NT7LXVV5.js";
+} from "./chunk-JUARRUMA.js";
 import {
   observeToolResultBoundary,
-  toolResultBoundaryArtifact
-} from "./chunk-ZBDYI7VM.js";
-import {
   parseGoalSnapshotV2,
-  parseGoalStateCause
-} from "./chunk-4P7PPAHN.js";
+  parseGoalStateCause,
+  toolResultBoundaryArtifact
+} from "./chunk-4F7GQGXB.js";
 import {
   projectUserTranscriptForDisplay
-} from "./chunk-7J6OTNGO.js";
+} from "./chunk-EFTPIZIC.js";
 import {
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-FXUSWLBF.js";
+} from "./chunk-GH2S4GD5.js";
 import {
   ToolNames
-} from "./chunk-LYSZVCCD.js";
+} from "./chunk-7JMGTOH7.js";
 import {
   createDebugLogger
 } from "./chunk-EAHOJF6V.js";
@@ -1142,7 +1140,13 @@ var DefaultTranscriptReplayMachine = class {
           createTranscriptPlanUpdate(plan.todos, this.usage, {
             ...meta,
             planToolCallId: callId,
-            todoPlanId: plan.planId
+            todoPlanId: plan.planId,
+            ...plan.sessionWorkflow ? {
+              extra: {
+                ...meta.extra,
+                qwenSessionWorkflow: true
+              }
+            } : {}
           })
         );
       }
@@ -1632,6 +1636,7 @@ function extractTodoPlanFromDisplay(value) {
   if (isObjectRecord(value) && value["type"] === "todo_list") {
     return Array.isArray(value["todos"]) ? {
       ...typeof value["planId"] === "string" ? { planId: value["planId"] } : {},
+      ...value["sessionWorkflow"] === true ? { sessionWorkflow: true } : {},
       todos: normalizeTodos(value["todos"])
     } : null;
   }
@@ -1640,6 +1645,7 @@ function extractTodoPlanFromDisplay(value) {
     const parsed = JSON.parse(value);
     return isObjectRecord(parsed) && parsed["type"] === "todo_list" && Array.isArray(parsed["todos"]) ? {
       ...typeof parsed["planId"] === "string" ? { planId: parsed["planId"] } : {},
+      ...parsed["sessionWorkflow"] === true ? { sessionWorkflow: true } : {},
       todos: normalizeTodos(parsed["todos"])
     } : null;
   } catch {
@@ -1758,7 +1764,8 @@ var PlanEmitter = class extends BaseEmitter {
     await this.sendUpdate(
       createTranscriptPlanUpdate(plan.todos, cumulative, {
         planToolCallId: sourceCallId,
-        todoPlanId: plan.planId
+        todoPlanId: plan.planId,
+        ...plan.sessionWorkflow ? { extra: { qwenSessionWorkflow: true } } : {}
       })
     );
   }
@@ -1778,6 +1785,7 @@ var PlanEmitter = class extends BaseEmitter {
     if (!plan) return null;
     return {
       ...plan.planId ? { planId: plan.planId } : {},
+      ...plan.sessionWorkflow ? { sessionWorkflow: true } : {},
       todos: plan.todos.map((todo, index) => ({
         id: todo.id ?? String(index),
         content: todo.content,
@@ -2966,7 +2974,7 @@ async function extractMetadata(conversation, config) {
   const gitBranch = firstRecord?.gitBranch;
   let gitRepo;
   if (cwd) {
-    const { getGitRepoName } = await import("./deferred-core-runtime-SCOJLVYG.js");
+    const { getGitRepoName } = await import("./deferred-core-runtime-S32AYVZI.js");
     gitRepo = getGitRepoName(cwd);
   }
   let model;

package/chunks/{chunk-FHPYRXRH.js → chunk-QJGYU5PG.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   registerCleanup
-} from "./chunk-TV7BJ7TX.js";
+} from "./chunk-RJUVTJEZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-IVUWTA2D.js → chunk-QJVZLILI.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-NYWWQ437.js";
 import {
   SessionNotFoundError
-} from "./chunk-YPISTYEI.js";
+} from "./chunk-F47DITLZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-TBJ3SNS3.js → chunk-QKDNS6FU.js}

@@ -1216,7 +1216,7 @@ function initializeTelemetry(config) {
   telemetryInitPromise ??= (async () => {
     const debugLogger3 = createDebugLogger("OTEL");
     try {
-      const { startTelemetrySdk } = await import("./sdk-impl-2RXJ4Q6X.js");
+      const { startTelemetrySdk } = await import("./sdk-impl-HZAUUTHJ.js");
       if (telemetryInitialized) return;
       const started = await startTelemetrySdk(config);
       if (!started) return;

package/chunks/{chunk-YKADANK6.js → chunk-QQD2GART.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-AQ37AY7B.js";
 import {
   ToolNames
-} from "./chunk-LYSZVCCD.js";
+} from "./chunk-7JMGTOH7.js";
 import {
   createDebugLogger
 } from "./chunk-EAHOJF6V.js";
@@ -130,12 +130,18 @@ ${escapeXml(entry.description)}
   }).join("\n");
 }
 __name(renderAvailableSkillsBlock, "renderAvailableSkillsBlock");
-function applySkillAllowedTools(permissionManager, allowedTools) {
+function canApplySkillSideEffects(skill, config) {
+  return skill.level !== "project" || config.isTrustedFolder();
+}
+__name(canApplySkillSideEffects, "canApplySkillSideEffects");
+function applySkillAllowedTools(permissionManager, allowedTools, options) {
   if (!permissionManager || !allowedTools?.length) {
     return;
   }
   for (const rule of allowedTools) {
-    permissionManager.addSessionAllowRule(rule);
+    permissionManager.addSessionAllowRule(rule, {
+      trustGated: options?.trustGated === true
+    });
   }
 }
 __name(applySkillAllowedTools, "applySkillAllowedTools");
@@ -155,6 +161,7 @@ export {
   clearCollectedSkillEntriesCache,
   collectAvailableSkillEntries,
   renderAvailableSkillsBlock,
+  canApplySkillSideEffects,
   applySkillAllowedTools,
   clearLoadedSkillTracking
 };

package/chunks/{chunk-ED7DD7MV.js → chunk-RAFQIHN2.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   readRuntimeStatus
-} from "./chunk-SDCHI64N.js";
+} from "./chunk-KM3XVTMO.js";
 import {
   atomicWriteJSON
 } from "./chunk-KHP66DFN.js";

package/chunks/{chunk-TV7BJ7TX.js → chunk-RJUVTJEZ.js}

@@ -64,7 +64,7 @@ async function runExitCleanup(options = {}) {
 }
 __name(runExitCleanup, "runExitCleanup");
 async function cleanupCheckpoints() {
-  const { Storage } = await import("./deferred-core-runtime-SCOJLVYG.js");
+  const { Storage } = await import("./deferred-core-runtime-S32AYVZI.js");
   const storage = new Storage(process.cwd());
   const tempDir = storage.getProjectTempDir();
   const checkpointsDir = join(tempDir, "checkpoints");

package/chunks/{chunk-RVCGAHC7.js → chunk-RM4WT2XB.js}

@@ -3,17 +3,17 @@
 import {
   getGitVersion,
   getNpmVersion
-} from "./chunk-6YXNJXQW.js";
+} from "./chunk-RN3YGDCA.js";
 import {
   buildEnvStatusFromEnv,
   snapshotProcessEnv
-} from "./chunk-ERRJA23L.js";
+} from "./chunk-KMU3ZHH4.js";
 import {
   mapDomainErrorToErrorKind
-} from "./chunk-J4Y3QJHF.js";
+} from "./chunk-64QH2UC6.js";
 import {
   canUseRipgrep
-} from "./chunk-PDXYZBBQ.js";
+} from "./chunk-VYIUNFEA.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-6YXNJXQW.js → chunk-RN3YGDCA.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   GIT_COMMIT_INFO
-} from "./chunk-AN3KFCNH.js";
+} from "./chunk-3JQZVCBI.js";
 import {
   getCliVersion
-} from "./chunk-ZYPJ7HVZ.js";
+} from "./chunk-VBWD6C27.js";
 import {
   IdeClient
-} from "./chunk-ZBDYI7VM.js";
+} from "./chunk-4F7GQGXB.js";
 import {
   formatMemoryUsage
 } from "./chunk-CHEIIBT3.js";

package/chunks/{chunk-SMRDCANI.js → chunk-S6H3ELPG.js}

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