@qwen-code/qwen-code 0.21.1-simplify-system-prompt.0 → 0.21.1

package/chunks/{chunk-MVS3NS2N.js → chunk-GEBV2JGB.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getGlobalQwenDir
-} from "./chunk-ML52PL6O.js";
+} from "./chunk-7I5GTCT4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -12,7 +12,8 @@ import {
 
 // packages/channels/weixin/dist/accounts.js
 init_esbuild_shims();
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, chmodSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync, renameSync } from "node:fs";
+import { randomBytes } from "node:crypto";
 import { join } from "node:path";
 var DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
 function getStateDir() {
@@ -40,15 +41,37 @@ function loadAccount() {
 __name(loadAccount, "loadAccount");
 function saveAccount(data) {
   const p = accountPath();
-  writeFileSync(p, JSON.stringify(data, null, 2), "utf-8");
-  chmodSync(p, 384);
+  const tmp = `${p}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    writeFileSync(tmp, JSON.stringify(data, null, 2), {
+      encoding: "utf-8",
+      mode: 384,
+      flag: "wx"
+    });
+    renameSync(tmp, p);
+  } catch (e) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw e;
+  }
 }
 __name(saveAccount, "saveAccount");
 function clearAccount() {
-  const p = accountPath();
+  const dir = getStateDir();
+  const p = join(dir, "account.json");
   if (existsSync(p)) {
     unlinkSync(p);
   }
+  for (const f of readdirSync(dir)) {
+    if (f.startsWith("account.json.") && f.endsWith(".tmp")) {
+      try {
+        unlinkSync(join(dir, f));
+      } catch {
+      }
+    }
+  }
 }
 __name(clearAccount, "clearAccount");
 

package/chunks/{chunk-VAK25FTU.js → chunk-GKX7E4CO.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   themeManager
-} from "./chunk-L5UHQJTJ.js";
+} from "./chunk-GATT5TKW.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-LS77BEZP.js → chunk-GLCZKT5V.js}

@@ -387,11 +387,7 @@ __name(asOptionalRecord, "asOptionalRecord");
 export {
   setToolCallPreparations,
   getToolCallPreparations,
-  isRuntimeDiagnosticsEnabled,
-  RuntimeDiagnosticsCollector,
-  runtimeDiagnostics,
-  summarizeOpenAIWireRequest,
-  summarizeAnthropicWireRequest
+  runtimeDiagnostics
 };
 /**
  * @license

package/chunks/{chunk-N3FAY5CM.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,
@@ -28,18 +35,18 @@ import {
   createWorkerDiagnosticRedactor,
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
-} from "./chunk-HV3G62R6.js";
+} from "./chunk-GZ3RCT54.js";
 import {
   channelSelectionNames
 } from "./chunk-ALMR3E6Q.js";
-import {
-  sanitizeLogText
-} from "./chunk-ML52PL6O.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";
@@ -271,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(() => ({
@@ -367,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
@@ -529,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;
@@ -725,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)) {
@@ -733,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)) {
@@ -762,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();
@@ -841,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" };
@@ -889,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-HV3G62R6.js → chunk-GZ3RCT54.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-M5GB774H.js";
 import {
   sanitizeLogText
-} from "./chunk-ML52PL6O.js";
+} from "./chunk-7I5GTCT4.js";
 import {
   stripAnsi
 } from "./chunk-TWPJO254.js";

package/chunks/{chunk-QY5MMZ6O.js → chunk-HMRM2A3U.js}

@@ -2,16 +2,16 @@
 "use strict";
 import {
   useKeypress
-} from "./chunk-LNURQEMZ.js";
+} from "./chunk-CQL64ESB.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   t
-} from "./chunk-VV6XU5L7.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
+ */