@qwen-code/qwen-code 0.21.0 → 0.21.1

package/chunks/{chunk-5NBDS5S6.js → chunk-GNR2RNMP.js}

@@ -1,5 +1,12 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  CHANNEL_LOOP_MCP_IPC_TIMEOUT_MS,
+  MAX_CHANNEL_LOOP_MCP_IN_FLIGHT,
+  createChannelLoopMcpRequest,
+  isChannelLoopMcpControlMessage,
+  isChannelLoopMcpResultMessage
+} from "./chunk-FYJ7W2PI.js";
 import {
   CHANNEL_DAEMON_WORKER_SENTINEL,
   CHANNEL_DELIVERY_IPC_TIMEOUT_MS,
@@ -18,26 +25,28 @@ import {
   QWEN_SERVER_TOKEN_ENV,
   createChannelDeliveryMessage,
   createChannelWebhookTaskMessage,
-  createWorkerDiagnosticRedactor,
   isChannelDeliveryResultMessage,
   isChannelStartupReportMessage,
   isChannelStartupReportType,
   isChannelWebhookEnqueueErrorCode,
-  isChannelWebhookTaskResultMessage,
+  isChannelWebhookTaskResultMessage
+} from "./chunk-U4VTUMMK.js";
+import {
+  createWorkerDiagnosticRedactor,
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
-} from "./chunk-LK7CHLVP.js";
+} from "./chunk-GZ3RCT54.js";
 import {
   channelSelectionNames
-} from "./chunk-JLU636DO.js";
-import {
-  sanitizeLogText
-} from "./chunk-RWTEFFPU.js";
+} from "./chunk-ALMR3E6Q.js";
 import {
   CHANNEL_WORKER_KILL_GRACE_MS,
   CHANNEL_WORKER_STARTUP_TIMEOUT_MS,
   CHANNEL_WORKER_STOP_GRACE_MS
 } from "./chunk-5HBA2Z7V.js";
+import {
+  sanitizeLogText
+} from "./chunk-7I5GTCT4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -269,6 +278,8 @@ function createChannelWorkerSupervisor(opts) {
   let restartAttemptTimes = [];
   const pendingWebhookTasks = /* @__PURE__ */ new Map();
   const pendingChannelDeliveries = /* @__PURE__ */ new Map();
+  const pendingChannelLoopMcpMessages = /* @__PURE__ */ new Map();
+  let cleanupChannelLoopMcpRegistrations;
   let restarting;
   let disposed = false;
   const snapshotCopy = /* @__PURE__ */ __name(() => ({
@@ -365,6 +376,28 @@ function createChannelWorkerSupervisor(opts) {
     }
     return true;
   }, "settleChannelDelivery");
+  const rejectPendingChannelLoopMcpMessages = /* @__PURE__ */ __name((message) => {
+    for (const pending of pendingChannelLoopMcpMessages.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(message));
+    }
+    pendingChannelLoopMcpMessages.clear();
+  }, "rejectPendingChannelLoopMcpMessages");
+  const settleChannelLoopMcpMessage = /* @__PURE__ */ __name((message) => {
+    if (!isChannelLoopMcpResultMessage(message)) return false;
+    const pending = pendingChannelLoopMcpMessages.get(message.id);
+    if (!pending) return true;
+    pendingChannelLoopMcpMessages.delete(message.id);
+    clearTimeout(pending.timer);
+    if (message.ok) {
+      pending.resolve(message.payload ?? {});
+    } else {
+      pending.reject(
+        new Error(message.error ?? "Channel loop MCP request failed.")
+      );
+    }
+    return true;
+  }, "settleChannelLoopMcpMessage");
   const pruneRestartAttempts = /* @__PURE__ */ __name((nowMs) => {
     restartAttemptTimes = restartAttemptTimes.filter(
       (attemptMs) => nowMs - attemptMs < restartPolicy.windowMs
@@ -527,6 +560,57 @@ function createChannelWorkerSupervisor(opts) {
     if (startedChild.pid !== void 0) {
       snapshot = { ...snapshot, pid: startedChild.pid };
     }
+    const channelLoopMcpOwnerId = `channel-worker:${randomUUID()}`;
+    const registeredChannelLoopMcpSessions = /* @__PURE__ */ new Set();
+    const activeChannelLoopMcpControls = /* @__PURE__ */ new Set();
+    const sendToStartedChild = /* @__PURE__ */ __name((message, callback) => {
+      if (child !== startedChild || !startedChild.send) {
+        throw new Error("Channel worker IPC is unavailable.");
+      }
+      return callback ? startedChild.send.call(startedChild, message, callback) : startedChild.send.call(startedChild, message);
+    }, "sendToStartedChild");
+    const sendChannelLoopMcpMessage = /* @__PURE__ */ __name((sessionId, payload) => {
+      if (pendingChannelLoopMcpMessages.size >= MAX_CHANNEL_LOOP_MCP_IN_FLIGHT) {
+        return Promise.reject(new Error("Channel loop MCP IPC queue is full."));
+      }
+      const message = createChannelLoopMcpRequest(sessionId, payload);
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pendingChannelLoopMcpMessages.delete(message.id);
+          reject(new Error("Channel loop MCP IPC timed out."));
+        }, CHANNEL_LOOP_MCP_IPC_TIMEOUT_MS);
+        timer.unref();
+        pendingChannelLoopMcpMessages.set(message.id, {
+          resolve,
+          reject,
+          timer
+        });
+        try {
+          sendToStartedChild(message, (error) => {
+            if (!error) return;
+            const pending = pendingChannelLoopMcpMessages.get(message.id);
+            if (!pending) return;
+            pendingChannelLoopMcpMessages.delete(message.id);
+            clearTimeout(pending.timer);
+            pending.reject(new Error("Channel loop MCP IPC send failed."));
+          });
+        } catch {
+          const pending = pendingChannelLoopMcpMessages.get(message.id);
+          if (!pending) return;
+          pendingChannelLoopMcpMessages.delete(message.id);
+          clearTimeout(pending.timer);
+          pending.reject(new Error("Channel loop MCP IPC send failed."));
+        }
+      });
+    }, "sendChannelLoopMcpMessage");
+    const cleanupLaunchChannelLoopMcpRegistrations = /* @__PURE__ */ __name(() => {
+      for (const sessionId of registeredChannelLoopMcpSessions) {
+        void opts.unregisterChannelLoopMcp?.(sessionId, channelLoopMcpOwnerId).catch(() => {
+        });
+      }
+      registeredChannelLoopMcpSessions.clear();
+    }, "cleanupLaunchChannelLoopMcpRegistrations");
+    cleanupChannelLoopMcpRegistrations = cleanupLaunchChannelLoopMcpRegistrations;
     await new Promise((resolve, reject) => {
       let settled = false;
       let ready = false;
@@ -723,6 +807,61 @@ function createChannelWorkerSupervisor(opts) {
         };
         armStaleHeartbeatTimer(startedChild);
       }, "handleHeartbeat");
+      const sendChannelLoopMcpControlResult = /* @__PURE__ */ __name((id, result) => {
+        try {
+          sendToStartedChild({
+            type: "channel_loop_mcp_control_result",
+            id,
+            ...result
+          });
+        } catch {
+        }
+      }, "sendChannelLoopMcpControlResult");
+      const handleChannelLoopMcpControl = /* @__PURE__ */ __name((message) => {
+        if (activeChannelLoopMcpControls.size >= MAX_CHANNEL_LOOP_MCP_IN_FLIGHT) {
+          sendChannelLoopMcpControlResult(message.id, {
+            ok: false,
+            error: "Channel loop MCP IPC queue is full."
+          });
+          return;
+        }
+        activeChannelLoopMcpControls.add(message.id);
+        const operation = message.type === "channel_loop_mcp_register" ? opts.registerChannelLoopMcp?.({
+          sessionId: message.sessionId,
+          ownerId: channelLoopMcpOwnerId,
+          sendMessage: /* @__PURE__ */ __name((payload) => sendChannelLoopMcpMessage(message.sessionId, payload), "sendMessage")
+        }).then(async () => {
+          if (child !== startedChild) {
+            await opts.unregisterChannelLoopMcp?.(
+              message.sessionId,
+              channelLoopMcpOwnerId
+            );
+            throw new Error("Channel worker exited during MCP setup.");
+          }
+          registeredChannelLoopMcpSessions.add(message.sessionId);
+        }) ?? Promise.reject(
+          new Error("Channel loop MCP registration is unavailable.")
+        ) : opts.unregisterChannelLoopMcp?.(
+          message.sessionId,
+          channelLoopMcpOwnerId
+        ).then(() => {
+          registeredChannelLoopMcpSessions.delete(message.sessionId);
+        }) ?? Promise.resolve();
+        void operation.then(() => {
+          sendChannelLoopMcpControlResult(message.id, { ok: true });
+        }).catch((error) => {
+          sendChannelLoopMcpControlResult(message.id, {
+            ok: false,
+            error: sanitizeWorkerDiagnostic(
+              error instanceof Error ? error.message : String(error),
+              512,
+              redaction
+            ) || "Channel loop MCP operation failed."
+          });
+        }).finally(() => {
+          activeChannelLoopMcpControls.delete(message.id);
+        });
+      }, "handleChannelLoopMcpControl");
       function handleMessage(message) {
         if (child !== startedChild) return;
         if (settleChannelDelivery(message)) {
@@ -731,6 +870,13 @@ function createChannelWorkerSupervisor(opts) {
         if (settleWebhookTask(message)) {
           return;
         }
+        if (settleChannelLoopMcpMessage(message)) {
+          return;
+        }
+        if (isChannelLoopMcpControlMessage(message)) {
+          handleChannelLoopMcpControl(message);
+          return;
+        }
         if (!ready && isChannelStartupReportType(message)) {
           handleStartupReport(message);
         } else if (!ready && isReadyMessage(message)) {
@@ -760,6 +906,11 @@ function createChannelWorkerSupervisor(opts) {
           "channel_worker_unavailable",
           "Channel worker exited."
         );
+        rejectPendingChannelLoopMcpMessages("Channel worker exited.");
+        cleanupLaunchChannelLoopMcpRegistrations();
+        if (cleanupChannelLoopMcpRegistrations === cleanupLaunchChannelLoopMcpRegistrations) {
+          cleanupChannelLoopMcpRegistrations = void 0;
+        }
         child = void 0;
         if ((ready || kind === "restart") && !stopping) {
           scheduleRestart();
@@ -839,6 +990,7 @@ function createChannelWorkerSupervisor(opts) {
         "channel_worker_unavailable",
         "Channel worker stopped."
       );
+      rejectPendingChannelLoopMcpMessages("Channel worker stopped.");
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         child = void 0;
         snapshot = { ...snapshot, state: "stopped" };
@@ -887,6 +1039,9 @@ function createChannelWorkerSupervisor(opts) {
         "channel_worker_unavailable",
         "Channel worker stopped."
       );
+      rejectPendingChannelLoopMcpMessages("Channel worker stopped.");
+      cleanupChannelLoopMcpRegistrations?.();
+      cleanupChannelLoopMcpRegistrations = void 0;
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         clearRestartTimer();
         clearStaleHeartbeatTimer();

package/chunks/{chunk-YH6G52F2.js → chunk-GXIJHV66.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   createTask
-} from "./chunk-K4XWPEWB.js";
+} from "./chunk-64LQLPL7.js";
 import {
   getPlanRequiredTeammatePreApprovalMessage,
   isPlanRequiredTeammateAwaitingApproval
-} from "./chunk-L26JL52R.js";
+} from "./chunk-JSD33JG6.js";
 import {
   resolveActiveTeamName
-} from "./chunk-6AM5D4ME.js";
+} from "./chunk-S6LOFUVP.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-PR75REBZ.js";
+} from "./chunk-Y6AXW2OG.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-GZ3RCT54.js

@@ -0,0 +1,76 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  redactLogCredentials
+} from "./chunk-M5GB774H.js";
+import {
+  sanitizeLogText
+} from "./chunk-7I5GTCT4.js";
+import {
+  stripAnsi
+} from "./chunk-TWPJO254.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/channel-worker-diagnostics.ts
+init_esbuild_shims();
+var WORKER_LOG_INVISIBLE_RE = new RegExp("[\\p{Cf}\\u2028\\u2029]|\\p{Variation_Selector}", "gu");
+var WORKER_LOG_CONTROL_RE = /[\x00-\x1f\x7f-\x9f]/g;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegExp, "escapeRegExp");
+function sensitiveEnvValues(env) {
+  const sensitiveKey = /(^|_)(TOKEN|SECRET|API_KEY|ACCESS_KEY|PRIVATE_KEY|CREDENTIAL|PASSWORD|PASSWD|PASSPHRASE|BASIC_AUTH|AUTH_TOKEN|AUTHORIZATION|SESSION_SECRET|SESSION_TOKEN|SESSION_KEY|SESSION_COOKIE|DSN|CONNECTION_STRING)($|_)/i;
+  return Object.entries(env).filter(([key, value]) => sensitiveKey.test(key) && value !== void 0).flatMap(([, value]) => {
+    const lines = value.split("\n").filter((line) => line.length >= 4);
+    return lines.length > 0 ? [value, ...lines] : [value];
+  }).filter((value) => value.length >= 4);
+}
+__name(sensitiveEnvValues, "sensitiveEnvValues");
+function normalizeWorkerDiagnostic(value) {
+  return stripAnsi(value).replace(WORKER_LOG_INVISIBLE_RE, "").replace(WORKER_LOG_CONTROL_RE, "");
+}
+__name(normalizeWorkerDiagnostic, "normalizeWorkerDiagnostic");
+function createWorkerDiagnosticRedactor(opts) {
+  const secretPatterns = [
+    ...new Set(
+      [
+        ...opts.daemonToken ? [opts.daemonToken] : [],
+        ...sensitiveEnvValues(opts.workerEnv)
+      ].flatMap((secret) => [
+        normalizeWorkerDiagnostic(secret),
+        normalizeWorkerDiagnostic(secret.replace(/\t/gu, " "))
+      ]).filter((secret) => secret.length >= 4)
+    )
+  ].sort((left, right) => right.length - left.length).map((secret) => new RegExp(escapeRegExp(secret), "g"));
+  return (value) => {
+    let redacted = value;
+    for (const secretPattern of secretPatterns) {
+      redacted = redacted.replace(secretPattern, "<redacted>");
+    }
+    return redactLogCredentials(redacted);
+  };
+}
+__name(createWorkerDiagnosticRedactor, "createWorkerDiagnosticRedactor");
+function sanitizeWorkerDiagnostic(value, maxLength, opts) {
+  const normalized = normalizeWorkerDiagnostic(value);
+  const redacted = createWorkerDiagnosticRedactor(opts)(normalized);
+  return sanitizeLogText(redacted, maxLength);
+}
+__name(sanitizeWorkerDiagnostic, "sanitizeWorkerDiagnostic");
+
+export {
+  normalizeWorkerDiagnostic,
+  createWorkerDiagnosticRedactor,
+  sanitizeWorkerDiagnostic
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-2X55UKQE.js → chunk-HMRM2A3U.js}

@@ -2,16 +2,16 @@
 "use strict";
 import {
   useKeypress
-} from "./chunk-LQIW3YFY.js";
+} from "./chunk-CQL64ESB.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   t
-} from "./chunk-LKEJ26GS.js";
+} from "./chunk-TCIFAA7K.js";
 import {
   APPROVAL_MODES
-} from "./chunk-L26JL52R.js";
+} from "./chunk-JSD33JG6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-HV26XH34.js

@@ -0,0 +1,319 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getUserSettingsPath,
+  v1ToV2Migration
+} from "./chunk-EIF3FXTB.js";
+import {
+  getSystemDefaultsPath,
+  getSystemSettingsPath
+} from "./chunk-IDS7MSUP.js";
+import {
+  LoadedTrustedFolders,
+  TrustLevel,
+  getTrustedFoldersPath
+} from "./chunk-Q43KPN7X.js";
+import {
+  require_strip_json_comments
+} from "./chunk-ALGGS7UH.js";
+import {
+  arePathsEquivalent
+} from "./chunk-MR3PXB6E.js";
+import {
+  ideContextStore
+} from "./chunk-X5WNMMIA.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/config/daemon-trust-policy.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import * as fs from "node:fs/promises";
+var import_strip_json_comments = __toESM(require_strip_json_comments(), 1);
+var MAX_TRUSTED_FOLDERS_BYTES = 1024 * 1024;
+var MAX_SETTINGS_BYTES = 4 * 1024 * 1024;
+function policyError(code, filePath, error) {
+  return {
+    code,
+    path: filePath,
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+__name(policyError, "policyError");
+async function readJsonObject(filePath, maxBytes, requireRegularFile, retryMissing = false) {
+  const delays = [0, 50, 200];
+  let result = {};
+  for (const delay of delays) {
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    result = await readJsonObjectOnce(filePath, maxBytes, requireRegularFile);
+    if (!result.error && (!result.missing || !retryMissing)) return result;
+  }
+  return result;
+}
+__name(readJsonObject, "readJsonObject");
+async function readJsonObjectOnce(filePath, maxBytes, requireRegularFile) {
+  let stat2;
+  try {
+    stat2 = await fs.lstat(filePath);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { value: {}, missing: true };
+    }
+    return {
+      error: policyError("trust_policy_unreadable", filePath, error)
+    };
+  }
+  if (!requireRegularFile && stat2.isSymbolicLink()) {
+    try {
+      stat2 = await fs.stat(filePath);
+    } catch (error) {
+      return {
+        error: policyError("trust_policy_unreadable", filePath, error)
+      };
+    }
+  }
+  if (requireRegularFile && stat2.isSymbolicLink() || !stat2.isFile()) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error("Trust policy input must be a regular file.")
+      )
+    };
+  }
+  if (stat2.size > maxBytes) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error(`Trust policy input exceeds ${maxBytes} bytes.`)
+      )
+    };
+  }
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = JSON.parse((0, import_strip_json_comments.default)(raw));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("Trust policy input must contain a JSON object.");
+    }
+    return { value: parsed };
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { value: {}, missing: true };
+    }
+    return { error: policyError("trust_policy_invalid", filePath, error) };
+  }
+}
+__name(readJsonObjectOnce, "readJsonObjectOnce");
+function migrateFolderTrustSettings(value, scope) {
+  if (!value || !v1ToV2Migration.shouldMigrate(value)) return value;
+  return v1ToV2Migration.migrate(value, scope).settings;
+}
+__name(migrateFolderTrustSettings, "migrateFolderTrustSettings");
+function folderTrustSetting(value, filePath) {
+  if (!value || !("security" in value)) return {};
+  const security = value?.["security"];
+  if (typeof security !== "object" || security === null || Array.isArray(security)) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error("`security` must be an object.")
+      )
+    };
+  }
+  if (!("folderTrust" in security)) return {};
+  const folderTrust = security["folderTrust"];
+  if (typeof folderTrust !== "object" || folderTrust === null || Array.isArray(folderTrust)) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error("`security.folderTrust` must be an object.")
+      )
+    };
+  }
+  if (!("enabled" in folderTrust)) return {};
+  const enabled = folderTrust["enabled"];
+  if (typeof enabled === "boolean") return { value: enabled };
+  return {
+    error: policyError(
+      "trust_policy_invalid",
+      filePath,
+      new Error("`security.folderTrust.enabled` must be a boolean.")
+    )
+  };
+}
+__name(folderTrustSetting, "folderTrustSetting");
+function parseTrustedFolders(value, filePath) {
+  const config = {};
+  for (const [rulePath, rawLevel] of Object.entries(value ?? {})) {
+    if (!Object.values(TrustLevel).includes(rawLevel)) {
+      return {
+        config: {},
+        error: policyError(
+          "trust_policy_invalid",
+          filePath,
+          new Error(`Invalid trust level for ${JSON.stringify(rulePath)}.`)
+        )
+      };
+    }
+    config[rulePath] = rawLevel;
+  }
+  return { config };
+}
+__name(parseTrustedFolders, "parseTrustedFolders");
+function semanticRevision(input) {
+  const sortedRules = Object.entries(input.trustedFolders).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  return createHash("sha256").update(
+    JSON.stringify({
+      folderTrustEnabled: input.folderTrustEnabled,
+      ideTrust: input.ideTrust ?? null,
+      trustedFolders: sortedRules,
+      settingsError: input.settingsError?.code ?? null,
+      trustedFoldersError: input.trustedFoldersError?.code ?? null
+    })
+  ).digest("hex");
+}
+__name(semanticRevision, "semanticRevision");
+async function readDaemonTrustPolicySnapshot() {
+  const [user, system, systemDefaults] = await Promise.all([
+    readJsonObject(getUserSettingsPath(), MAX_SETTINGS_BYTES, false),
+    readJsonObject(getSystemSettingsPath(), MAX_SETTINGS_BYTES, false),
+    readJsonObject(getSystemDefaultsPath(), MAX_SETTINGS_BYTES, false)
+  ]);
+  const systemFolderTrust = folderTrustSetting(
+    migrateFolderTrustSettings(system.value, "System"),
+    getSystemSettingsPath()
+  );
+  const userFolderTrust = folderTrustSetting(
+    migrateFolderTrustSettings(user.value, "User"),
+    getUserSettingsPath()
+  );
+  const defaultsFolderTrust = folderTrustSetting(
+    migrateFolderTrustSettings(systemDefaults.value, "SystemDefaults"),
+    getSystemDefaultsPath()
+  );
+  const settingsError = system.error ?? systemFolderTrust.error ?? user.error ?? userFolderTrust.error ?? systemDefaults.error ?? defaultsFolderTrust.error;
+  const folderTrustEnabled = systemFolderTrust.value ?? userFolderTrust.value ?? defaultsFolderTrust.value ?? false;
+  const trustedFoldersFile = await readJsonObject(
+    getTrustedFoldersPath(),
+    MAX_TRUSTED_FOLDERS_BYTES,
+    true,
+    folderTrustEnabled
+  );
+  const parsedTrustedFolders = parseTrustedFolders(
+    trustedFoldersFile.value,
+    getTrustedFoldersPath()
+  );
+  const trustedFoldersError = trustedFoldersFile.error ?? parsedTrustedFolders.error;
+  const ideTrust = ideContextStore.get()?.workspaceState?.isTrusted;
+  const revision = semanticRevision({
+    folderTrustEnabled,
+    ideTrust,
+    trustedFolders: parsedTrustedFolders.config,
+    ...settingsError ? { settingsError } : {},
+    ...trustedFoldersError ? { trustedFoldersError } : {}
+  });
+  return {
+    revision,
+    folderTrustEnabled,
+    ideTrust,
+    trustedFolders: Object.freeze({ ...parsedTrustedFolders.config }),
+    ...settingsError ? { settingsError } : {},
+    ...trustedFoldersError ? { trustedFoldersError } : {}
+  };
+}
+__name(readDaemonTrustPolicySnapshot, "readDaemonTrustPolicySnapshot");
+function explicitTrustLevel(snapshot, workspaceCwd) {
+  const folders = new LoadedTrustedFolders(
+    {
+      path: getTrustedFoldersPath(),
+      config: { ...snapshot.trustedFolders }
+    },
+    []
+  );
+  const effective = folders.isPathTrusted(workspaceCwd);
+  if (effective === void 0) return null;
+  for (const [rulePath, trustLevel] of Object.entries(
+    snapshot.trustedFolders
+  )) {
+    const preview = new LoadedTrustedFolders(
+      { path: getTrustedFoldersPath(), config: { [rulePath]: trustLevel } },
+      []
+    ).isPathTrusted(workspaceCwd);
+    if (preview === effective) return trustLevel;
+  }
+  return null;
+}
+__name(explicitTrustLevel, "explicitTrustLevel");
+function evaluateDaemonWorkspaceTrust(snapshot, workspaceCwd, processCwd = process.cwd()) {
+  if (snapshot.settingsError) {
+    return {
+      state: "error",
+      targetTrusted: false,
+      source: "none",
+      explicitTrustLevel: null,
+      error: snapshot.settingsError
+    };
+  }
+  if (!snapshot.folderTrustEnabled) {
+    return {
+      state: "trusted",
+      targetTrusted: true,
+      source: "disabled",
+      explicitTrustLevel: null
+    };
+  }
+  if (snapshot.ideTrust !== void 0 && arePathsEquivalent(workspaceCwd, processCwd)) {
+    return {
+      state: snapshot.ideTrust ? "trusted" : "untrusted",
+      targetTrusted: snapshot.ideTrust,
+      source: "ide",
+      explicitTrustLevel: null
+    };
+  }
+  if (snapshot.trustedFoldersError) {
+    return {
+      state: "error",
+      targetTrusted: false,
+      source: "none",
+      explicitTrustLevel: null,
+      error: snapshot.trustedFoldersError
+    };
+  }
+  const folders = new LoadedTrustedFolders(
+    {
+      path: getTrustedFoldersPath(),
+      config: { ...snapshot.trustedFolders }
+    },
+    []
+  );
+  const trusted = folders.isPathTrusted(workspaceCwd);
+  return {
+    state: trusted === true ? "trusted" : trusted === false ? "untrusted" : "unknown",
+    targetTrusted: trusted === true,
+    source: trusted === void 0 ? "none" : "file",
+    explicitTrustLevel: explicitTrustLevel(snapshot, workspaceCwd)
+  };
+}
+__name(evaluateDaemonWorkspaceTrust, "evaluateDaemonWorkspaceTrust");
+
+export {
+  readDaemonTrustPolicySnapshot,
+  evaluateDaemonWorkspaceTrust
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */