@qwen-code/qwen-code 0.22.3 → 0.23.0

package/chunks/{chunk-CAJTKR6W.js → chunk-G7HBEEX7.js}

@@ -3,21 +3,21 @@
 import {
   collectAvailableSkillEntries,
   renderAvailableSkillsBlock
-} from "./chunk-ZU4UDIWX.js";
+} from "./chunk-QQD2GART.js";
 import {
   escapeSystemReminderTags
 } from "./chunk-AQ37AY7B.js";
 import {
   DEFAULT_FILE_FILTERING_OPTIONS
-} from "./chunk-PDQGMSZK.js";
+} from "./chunk-ODZF64DM.js";
 import {
   ToolNames
-} from "./chunk-UTLCH2FK.js";
+} from "./chunk-7JMGTOH7.js";
 import {
   createDebugLogger,
   getErrorMessage,
   isNodeError
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -406,9 +406,13 @@ function buildChangedMcpToolsReminder(addedTools, removedToolNames) {
 }
 __name(buildChangedMcpToolsReminder, "buildChangedMcpToolsReminder");
 function buildMcpServerInstructionsReminder(toolRegistry) {
-  const serverInstructions = Array.from(
-    toolRegistry.getMcpServerInstructions().entries()
-  ).filter(([, instructions]) => instructions.trim().length > 0).sort(([left], [right]) => left.localeCompare(right));
+  return buildMcpServerInstructionsReminderFromEntries(
+    toolRegistry.getMcpServerInstructions()
+  );
+}
+__name(buildMcpServerInstructionsReminder, "buildMcpServerInstructionsReminder");
+function buildMcpServerInstructionsReminderFromEntries(instructionsByServer) {
+  const serverInstructions = Array.from(instructionsByServer.entries()).filter(([, instructions]) => instructions.trim().length > 0).sort(([left], [right]) => left.localeCompare(right));
   if (serverInstructions.length === 0) {
     return null;
   }
@@ -421,7 +425,7 @@ ${instructions}`
   ];
   return wrapSystemReminder(bodyParts.join("\n\n"));
 }
-__name(buildMcpServerInstructionsReminder, "buildMcpServerInstructionsReminder");
+__name(buildMcpServerInstructionsReminderFromEntries, "buildMcpServerInstructionsReminderFromEntries");
 function trimSkillEntriesTowardsBudget(entries) {
   if (renderAvailableSkillsBlock(entries).length <= MAX_SKILL_LISTING_CHARS) {
     return entries;
@@ -692,7 +696,7 @@ __name(resolveForkExecutionAllowedTools, "resolveForkExecutionAllowedTools");
 function registerForkDisplayImageForCache(config, advertisedToolNames) {
   if (!advertisedToolNames.includes(ToolNames.DISPLAY_IMAGE)) return;
   config.getToolRegistry().registerFactory(ToolNames.DISPLAY_IMAGE, async () => {
-    const { DisplayImageTool } = await import("./display-image-BE7I6ZB6.js");
+    const { DisplayImageTool } = await import("./display-image-73C7XNRK.js");
     return new DisplayImageTool(config);
   });
 }
@@ -880,9 +884,11 @@ export {
   getFolderStructure,
   formatDateForContext,
   getDirectoryContextString,
+  wrapSystemReminder,
   buildDeferredToolsReminder,
   buildChangedMcpToolsReminder,
   buildMcpServerInstructionsReminder,
+  buildMcpServerInstructionsReminderFromEntries,
   buildAvailableSkillsReminder,
   buildChangedSkillsReminder,
   buildChangedAgentsReminder,

package/chunks/{chunk-4QHPPXK2.js → chunk-GB4UKWY5.js}

@@ -8,11 +8,11 @@ import {
   isQuotaExhaustedError,
   isQwenQuotaExceededError,
   isRateLimitError
-} from "./chunk-DYXFD5RO.js";
+} from "./chunk-S2T7H5MI.js";
 import {
   createDebugLogger,
   getErrorStatus
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-QYMAKPY5.js → chunk-GH2S4GD5.js}

@@ -14,23 +14,23 @@ import {
   isCacheableReadResult,
   parsePDFPageRange,
   processSingleFileContent
-} from "./chunk-BKWNKLZB.js";
+} from "./chunk-DYTW3QVG.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-6PJOTWAN.js";
-import {
-  runSideQuery
-} from "./chunk-BWORX6FA.js";
+} from "./chunk-HT5S5TRQ.js";
 import {
   generateLegacyMcpToolName,
   normalizeToolNameForProvider
 } from "./chunk-WZAD4ZNJ.js";
 import {
   InstallationManager
-} from "./chunk-6DIGWMGT.js";
+} from "./chunk-EIJT2PQ6.js";
+import {
+  DEFAULT_QWEN_MODEL
+} from "./chunk-BFY33IB4.js";
 import {
   atomicWriteFile
-} from "./chunk-23RFD54N.js";
+} from "./chunk-KHP66DFN.js";
 import {
   safeJsonStringify
 } from "./chunk-HHJLM3WQ.js";
@@ -102,7 +102,7 @@ import {
   recordTokenUsageMetrics,
   recordToolCallMetrics,
   recordToolExecutionMetrics
-} from "./chunk-B5PHIJGI.js";
+} from "./chunk-QKDNS6FU.js";
 import {
   SemanticAttributes,
   init_esm,
@@ -110,14 +110,15 @@ import {
 } from "./chunk-74TONY4F.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-XF63PKEN.js";
+} from "./chunk-ZDFQGHZH.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
+  SchemaValidator,
   StructuredToolError,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-UTLCH2FK.js";
+} from "./chunk-7JMGTOH7.js";
 import {
   Storage,
   createDebugLogger,
@@ -128,7 +129,7 @@ import {
   realpathNearestExisting,
   shortenPath,
   unescapePath
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   require_dist
 } from "./chunk-75DOP5OR.js";
@@ -2238,7 +2239,8 @@ var QwenLogger = class _QwenLogger {
       properties: {
         subagent_name: event.subagent_name,
         status: event.status,
-        terminate_reason: event.terminate_reason
+        terminate_reason: event.terminate_reason,
+        ...event.loop_type ? { loop_type: event.loop_type } : {}
       },
       snapshots: JSON.stringify({
         ...event.execution_summary ? { execution_summary: event.execution_summary } : {}
@@ -5014,6 +5016,7 @@ var debugLogger4 = createDebugLogger("TRUNCATION");
 var PREVIEW_SIZE_CHARS = 2e3;
 var MAX_FILE_SIZE_BYTES = 50 * 1024 * 1024;
 var MAX_SESSION_BYTES = 500 * 1024 * 1024;
+var FULL_OUTPUT_DIGEST_LABEL = "Full output sha256: ";
 var TOOL_OUTPUT_TRUNCATED_PREFIX = "Tool output was too large and has been truncated";
 var COMBINED_PASS_TOLERANCE_FACTOR = 2;
 var TRUNCATION_FALLBACK_ENVELOPE_SLACK = 500;
@@ -5289,9 +5292,11 @@ function buildStub(content, byteSize, filePathOrNote) {
   const preview = generatePreview(content);
   const sizeKb = Math.round(byteSize / 1024);
   const isFilePath = path5.isAbsolute(filePathOrNote);
+  const fullDigest = crypto.createHash("sha256").update(content).digest("hex");
   if (isFilePath) {
     return `<persisted-output>
 Output too large (${sizeKb} KB). Full output saved to: ${filePathOrNote}
+${FULL_OUTPUT_DIGEST_LABEL}${fullDigest}
 Note: this file may be cleaned up after 24 hours.
 To read the complete output, use the ${ReadFileTool.Name} tool with the absolute file path above.
 
@@ -5300,6 +5305,7 @@ ${preview}
 </persisted-output>`;
   }
   return `Output too large (${sizeKb} KB). ${filePathOrNote}
+${FULL_OUTPUT_DIGEST_LABEL}${fullDigest}
 
 Preview (up to ${PREVIEW_SIZE_CHARS} chars):
 ${preview}`;
@@ -5481,6 +5487,189 @@ function collectText(parts) {
 }
 __name(collectText, "collectText");
 
+// packages/core/src/tools/mcp-classifier-input.ts
+init_esbuild_shims();
+var MCP_CLASSIFIER_MAX_STRING_CHARS = 2e3;
+var MCP_CLASSIFIER_MAX_TOTAL_CHARS = 16e3;
+var MCP_CLASSIFIER_MAX_DEPTH = 8;
+var MCP_CLASSIFIER_MAX_ENTRIES = 64;
+var MCP_CLASSIFIER_MAX_NAME_CHARS = 200;
+var ENTRY_OVERHEAD = 2 * MCP_CLASSIFIER_MAX_DEPTH + 8;
+var CONTAINER_OVERHEAD = 2 * MCP_CLASSIFIER_MAX_DEPTH + 4;
+var ANNOTATION_KEYS = [
+  "readOnlyHint",
+  "destructiveHint",
+  "idempotentHint",
+  "openWorldHint"
+];
+function charge(budget, chars) {
+  budget.remaining -= chars;
+}
+__name(charge, "charge");
+function marker(budget, text) {
+  budget.truncated = true;
+  charge(budget, text.length);
+  return text;
+}
+__name(marker, "marker");
+function fitString(value, limit, budget) {
+  value = value.replace(/[\p{Cc}\p{Zl}\p{Zp}]/gu, " ");
+  let encoded = JSON.stringify(value);
+  if (encoded.length - 2 <= limit) {
+    charge(budget, encoded.length);
+    return value;
+  }
+  budget.truncated = true;
+  let keep = Math.min(value.length, Math.max(0, limit));
+  let cut = value.slice(0, keep);
+  encoded = JSON.stringify(cut);
+  while (keep > 0 && encoded.length - 2 > limit) {
+    keep = Math.min(
+      keep - 1,
+      Math.floor(keep * limit / (encoded.length - 2))
+    );
+    cut = value.slice(0, Math.max(0, keep));
+    encoded = JSON.stringify(cut);
+  }
+  const note = `\u2026[truncated ${value.length - cut.length} chars]`;
+  charge(budget, encoded.length + note.length);
+  return cut + note;
+}
+__name(fitString, "fitString");
+function stringLimit(budget) {
+  return Math.max(
+    0,
+    Math.min(MCP_CLASSIFIER_MAX_STRING_CHARS, budget.remaining)
+  );
+}
+__name(stringLimit, "stringLimit");
+function uniqueKey(out, wanted) {
+  let key = wanted;
+  while (key in out) key += "\u2026";
+  return key;
+}
+__name(uniqueKey, "uniqueKey");
+function projectValue(value, depth, budget) {
+  if (budget.remaining <= 0) {
+    return marker(budget, "[omitted: argument budget exhausted]");
+  }
+  if (typeof value === "string") {
+    return fitString(value, stringLimit(budget), budget);
+  }
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    charge(budget, String(value).length);
+    return value;
+  }
+  if (typeof value !== "object") {
+    if (value === void 0) {
+      charge(budget, 4);
+      return null;
+    }
+    return fitString(String(value), stringLimit(budget), budget);
+  }
+  if (depth >= MCP_CLASSIFIER_MAX_DEPTH) {
+    return marker(budget, "[omitted: nesting too deep]");
+  }
+  charge(budget, CONTAINER_OVERHEAD);
+  if (Array.isArray(value)) {
+    const out2 = [];
+    for (let i = 0; i < value.length; i++) {
+      const left = value.length - i;
+      if (i >= MCP_CLASSIFIER_MAX_ENTRIES) {
+        out2.push(marker(budget, `[omitted: ${left} more entries]`));
+        break;
+      }
+      if (budget.remaining <= 0) {
+        out2.push(
+          marker(
+            budget,
+            `[omitted: ${left} more entries, argument budget exhausted]`
+          )
+        );
+        break;
+      }
+      charge(budget, ENTRY_OVERHEAD);
+      out2.push(projectValue(value[i], depth + 1, budget));
+    }
+    return out2;
+  }
+  const out = /* @__PURE__ */ Object.create(null);
+  const entries = Object.entries(value);
+  for (let i = 0; i < entries.length; i++) {
+    const left = entries.length - i;
+    if (i >= MCP_CLASSIFIER_MAX_ENTRIES) {
+      out[uniqueKey(out, "\u2026")] = marker(budget, `[omitted: ${left} more keys]`);
+      break;
+    }
+    if (budget.remaining <= 0) {
+      out[uniqueKey(out, "\u2026")] = marker(
+        budget,
+        `[omitted: ${left} more keys, argument budget exhausted]`
+      );
+      break;
+    }
+    const [key, item] = entries[i];
+    charge(budget, ENTRY_OVERHEAD);
+    const projectedKey = uniqueKey(
+      out,
+      fitString(key, stringLimit(budget), budget)
+    );
+    out[projectedKey] = projectValue(item, depth + 1, budget);
+  }
+  return out;
+}
+__name(projectValue, "projectValue");
+function projectMcpArgumentsWithBudget(args, budget) {
+  if (args === null || typeof args !== "object" || Array.isArray(args)) {
+    return { value: {}, truncated: args !== void 0 && args !== null };
+  }
+  const value = projectValue(args, 0, budget);
+  return { value, truncated: budget.truncated };
+}
+__name(projectMcpArgumentsWithBudget, "projectMcpArgumentsWithBudget");
+function fitName(name, budget) {
+  const limit = Math.max(
+    0,
+    Math.min(MCP_CLASSIFIER_MAX_NAME_CHARS, budget.remaining)
+  );
+  return fitString(name, limit, budget);
+}
+__name(fitName, "fitName");
+function projectAnnotations(annotations) {
+  if (!annotations) return void 0;
+  const out = {};
+  for (const key of ANNOTATION_KEYS) {
+    if (typeof annotations[key] === "boolean") out[key] = annotations[key];
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+__name(projectAnnotations, "projectAnnotations");
+function buildMcpClassifierInput(options) {
+  const budget = {
+    remaining: MCP_CLASSIFIER_MAX_TOTAL_CHARS,
+    truncated: false
+  };
+  const server = fitName(options.serverName, budget);
+  const tool = fitName(options.serverToolName, budget);
+  const nameTruncated = budget.truncated;
+  budget.truncated = false;
+  const { value, truncated } = projectMcpArgumentsWithBudget(
+    options.params,
+    budget
+  );
+  const annotations = projectAnnotations(options.annotations);
+  const input = {
+    server,
+    tool,
+    ...annotations ? { annotations } : {},
+    arguments: value
+  };
+  if (truncated) input.arguments_truncated = true;
+  if (nameTruncated) input.name_truncated = true;
+  return input;
+}
+__name(buildMcpClassifierInput, "buildMcpClassifierInput");
+
 // packages/core/src/tools/mcp-tool.ts
 var debugLogger5 = createDebugLogger("MCP_TOOL");
 var MCP_DEAD_SESSION_ERROR_PATTERN = /session (not found|terminated|expired)/i;
@@ -6083,6 +6272,36 @@ var DiscoveredMCPTool = class _DiscoveredMCPTool extends BaseDeclarativeTool {
     );
     return legacyName === this.name ? [] : [legacyName];
   }
+  /**
+   * AUTO-mode classifier projection.
+   *
+   * Forwards the server name, the server-side tool name, the server's
+   * self-reported annotations, and a bounded copy of the arguments (see
+   * `mcp-classifier-input.ts` for the caps). Without the arguments the
+   * classifier can only see the tool name, cannot apply its
+   * data-exfiltration or external-write rules, and — being told to err on
+   * the side of blocking — rejects most MCP calls outright, which pushes
+   * users toward blanket `mcp__server` allow rules that skip the
+   * classifier entirely.
+   *
+   * The arguments are the agent's own output (already sent to the model
+   * provider as a function call), so forwarding them to a classifier on
+   * the same model configuration is not a new disclosure. Deployments that
+   * route the classifier elsewhere can opt out with
+   * `permissions.autoMode.mcp.forwardArguments: false`, which restores the
+   * name-only projection.
+   */
+  toAutoClassifierInput(params) {
+    if (this.cliConfig?.getAutoModeSettings?.()?.mcp?.forwardArguments === false) {
+      return "";
+    }
+    return buildMcpClassifierInput({
+      serverName: this.serverName,
+      serverToolName: this.serverToolName,
+      annotations: this.annotations,
+      params
+    });
+  }
   asFullyQualifiedTool() {
     return new _DiscoveredMCPTool(
       this.mcpTool,
@@ -7085,6 +7304,7 @@ var SubagentExecutionEvent = class {
   terminate_reason;
   result;
   execution_summary;
+  loop_type;
   constructor(subagent_name, status, options) {
     this["event.name"] = "subagent_execution";
     this["event.timestamp"] = (/* @__PURE__ */ new Date()).toISOString();
@@ -7093,6 +7313,7 @@ var SubagentExecutionEvent = class {
     this.terminate_reason = options?.terminate_reason;
     this.result = options?.result;
     this.execution_summary = options?.execution_summary;
+    this.loop_type = options?.loop_type;
   }
 };
 var AuthEvent = class {
@@ -7525,6 +7746,120 @@ __name(getFileReadDefaultPermission, "getFileReadDefaultPermission");
 
 // packages/core/src/services/visionBridge/vision-bridge-service.ts
 init_esbuild_shims();
+
+// packages/core/src/utils/sideQuery.ts
+init_esbuild_shims();
+import { readFile } from "node:fs/promises";
+function buildDefaultPromptId(purpose) {
+  return purpose ? `side-query:${purpose}` : "side-query";
+}
+__name(buildDefaultPromptId, "buildDefaultPromptId");
+function resolveDefaultModel(config, override) {
+  return override ?? config.getFastModel?.() ?? config.getModel() ?? DEFAULT_QWEN_MODEL;
+}
+__name(resolveDefaultModel, "resolveDefaultModel");
+function applyThinkingDefault(callerConfig) {
+  const thinkingOverride = callerConfig?.thinkingConfig;
+  return {
+    ...callerConfig ?? {},
+    thinkingConfig: thinkingOverride ? { includeThoughts: false, ...thinkingOverride } : { includeThoughts: false }
+  };
+}
+__name(applyThinkingDefault, "applyThinkingDefault");
+async function getOutputLanguageInstruction(config) {
+  const outputLanguageFilePath = config.getOutputLanguageFilePath?.();
+  if (!outputLanguageFilePath) return void 0;
+  try {
+    const preference = (await readFile(outputLanguageFilePath, "utf8")).trim();
+    if (!preference) return void 0;
+    return [
+      "Follow the user-visible output language preference below for this side query.",
+      "This preference overrides any earlier language-selection rule in this system instruction.",
+      preference
+    ].join("\n\n");
+  } catch {
+    return void 0;
+  }
+}
+__name(getOutputLanguageInstruction, "getOutputLanguageInstruction");
+function appendSystemInstruction(systemInstruction, outputLanguageInstruction) {
+  if (!outputLanguageInstruction) return systemInstruction;
+  if (systemInstruction === void 0) return outputLanguageInstruction;
+  if (typeof systemInstruction === "string") {
+    return `${systemInstruction}
+
+${outputLanguageInstruction}`;
+  }
+  if (Array.isArray(systemInstruction)) {
+    return [...systemInstruction, { text: outputLanguageInstruction }];
+  }
+  if (typeof systemInstruction === "object" && "parts" in systemInstruction && Array.isArray(systemInstruction.parts)) {
+    return {
+      ...systemInstruction,
+      parts: [...systemInstruction.parts, { text: outputLanguageInstruction }]
+    };
+  }
+  return [systemInstruction, { text: outputLanguageInstruction }];
+}
+__name(appendSystemInstruction, "appendSystemInstruction");
+function isJsonOptions(options) {
+  return options.schema !== void 0 && options.schema !== null;
+}
+__name(isJsonOptions, "isJsonOptions");
+async function runSideQuery(config, options) {
+  const model = resolveDefaultModel(config, options.model);
+  const promptId = options.promptId ?? buildDefaultPromptId(options.purpose);
+  const requestConfig = applyThinkingDefault(options.config);
+  const outputLanguageInstruction = options.skipOutputLanguagePreference ? void 0 : await getOutputLanguageInstruction(config);
+  const systemInstruction = appendSystemInstruction(
+    options.systemInstruction,
+    outputLanguageInstruction
+  );
+  if (isJsonOptions(options)) {
+    const response = await config.getBaseLlmClient().generateJson({
+      contents: options.contents,
+      schema: options.schema,
+      abortSignal: options.abortSignal,
+      model,
+      systemInstruction,
+      promptId,
+      config: requestConfig,
+      ...options.maxAttempts !== void 0 && {
+        maxAttempts: options.maxAttempts
+      }
+    });
+    const schemaError = SchemaValidator.validate(options.schema, response);
+    if (schemaError) {
+      throw new Error(`Invalid side query response: ${schemaError}`);
+    }
+    const customError2 = options.validate?.(response);
+    if (customError2) {
+      throw new Error(customError2);
+    }
+    return response;
+  }
+  const result = await config.getBaseLlmClient().generateText({
+    contents: options.contents,
+    model,
+    systemInstruction,
+    abortSignal: options.abortSignal,
+    promptId,
+    config: requestConfig,
+    ...options.maxAttempts !== void 0 && {
+      maxAttempts: options.maxAttempts
+    },
+    ...options.stream !== void 0 && { stream: options.stream },
+    ...options.failClosed !== void 0 && { failClosed: options.failClosed }
+  });
+  const customError = options.validate?.(result.text);
+  if (customError) {
+    throw new Error(customError);
+  }
+  return result;
+}
+__name(runSideQuery, "runSideQuery");
+
+// packages/core/src/services/visionBridge/vision-bridge-service.ts
 var debugLogger6 = createDebugLogger("VISION_BRIDGE");
 var turnImageCounts = /* @__PURE__ */ new WeakMap();
 var BRIDGE_MAX_OUTPUT_TOKENS = 2048;
@@ -8265,6 +8600,7 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
 };
 
 export {
+  runSideQuery,
   normalizeParts,
   isImagePart,
   hasImageParts,
@@ -8354,7 +8690,9 @@ export {
   memoryFreshnessText,
   getFileReadDefaultPermission,
   ReadFileTool,
+  PREVIEW_SIZE_CHARS,
   MAX_SESSION_BYTES,
+  FULL_OUTPUT_DIGEST_LABEL,
   TOOL_OUTPUT_TRUNCATED_PREFIX,
   COMBINED_PASS_TOLERANCE_FACTOR,
   TRUNCATION_FALLBACK_ENVELOPE_SLACK,

package/chunks/{chunk-LHBUKJG2.js → chunk-GXUTFQXK.js}

@@ -5,18 +5,19 @@ import {
 } from "./chunk-KW7NOTN6.js";
 import {
   DEFAULT_OPENAI_LOG_RETENTION_DAYS
-} from "./chunk-ZEYFMJQA.js";
+} from "./chunk-NQ4L2CMD.js";
 import {
   resolveOpenAILogDir
-} from "./chunk-ST5V3ZOC.js";
+} from "./chunk-SULZPKTA.js";
 import {
   FILE_HISTORY_DIR,
   getSubagentsRootDir
-} from "./chunk-PZ66FRIC.js";
+} from "./chunk-4F7GQGXB.js";
 import {
   Storage,
-  createDebugLogger
-} from "./chunk-UHQFIS7N.js";
+  createDebugLogger,
+  sessionIdContext
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -352,26 +353,28 @@ function getOpenAILogCleanupTarget(config, settings) {
 __name(getOpenAILogCleanupTarget, "getOpenAILogCleanupTarget");
 function startNonInteractiveOpenAILogHousekeeping(config, settings) {
   if (nonInteractiveStopping) return;
-  try {
-    const target = getOpenAILogCleanupTarget(config, settings);
-    if (!target || nonInteractiveJobs.has(target.logDir)) return;
-    const markerPath = getOpenAILogsMarkerPath(
-      Storage.getGlobalQwenDir(),
-      target.logDir
-    );
-    const job = {
-      target,
-      markerPath,
-      queued: false
-    };
-    nonInteractiveJobs.set(target.logDir, job);
-    enqueueNonInteractiveJob(job);
-  } catch (err) {
-    debugLogger3.error(
-      "failed to start non-interactive OpenAI log cleanup; skipping",
-      err
-    );
-  }
+  sessionIdContext.exit(() => {
+    try {
+      const target = getOpenAILogCleanupTarget(config, settings);
+      if (!target || nonInteractiveJobs.has(target.logDir)) return;
+      const markerPath = getOpenAILogsMarkerPath(
+        Storage.getGlobalQwenDir(),
+        target.logDir
+      );
+      const job = {
+        target,
+        markerPath,
+        queued: false
+      };
+      nonInteractiveJobs.set(target.logDir, job);
+      enqueueNonInteractiveJob(job);
+    } catch (err) {
+      debugLogger3.error(
+        "failed to start non-interactive OpenAI log cleanup; skipping",
+        err
+      );
+    }
+  });
 }
 __name(startNonInteractiveOpenAILogHousekeeping, "startNonInteractiveOpenAILogHousekeeping");
 function stopNonInteractiveOpenAILogHousekeeping() {

package/chunks/{chunk-KJO2LBUK.js → chunk-H43PSPYS.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-MLXTMF7H.js";
 import {
   stringifyGenAiJson
-} from "./chunk-V4264FEG.js";
+} from "./chunk-LKODFJRD.js";
 import {
   atomicWriteJSON
-} from "./chunk-23RFD54N.js";
+} from "./chunk-KHP66DFN.js";
 import {
   DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH,
   SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT,
@@ -16,12 +16,12 @@ import {
   getMeter,
   isTelemetrySdkInitialized,
   isValidSensitiveSpanAttributeMaxLength
-} from "./chunk-B5PHIJGI.js";
+} from "./chunk-QKDNS6FU.js";
 import {
   FatalConfigError,
   QWEN_DIR,
   createDebugLogger
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   ValueType,
   diag,
@@ -9590,7 +9590,7 @@ function registerSkillHooks(sessionHooksManager, sessionId, skill) {
           eventName,
           matcherPattern,
           hookConfig,
-          { skillRoot: skill.skillRoot }
+          { skillRoot: skill.skillRoot, trustGated: skill.level === "project" }
         );
         registeredCount++;
         debugLogger4.debug(