@qwen-code/qwen-code 0.18.0-preview.2 → 0.18.1

package/chunks/{chunk-ZK4AMNIU.js → chunk-RON7LFNH.js}

@@ -20,19 +20,22 @@ import {
 } from "./chunk-OFEVLU4C.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-JVQOQ3OU.js";
+} from "./chunk-IQHSD7K5.js";
 import {
   InstallationManager
-} from "./chunk-P4J26VDS.js";
+} from "./chunk-LYRSMKLS.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-CNSMKPK6.js";
+} from "./chunk-QILTEBWS.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-2ZTWI7KH.js";
+} from "./chunk-A2ZIEEGJ.js";
+import {
+  atomicWriteFile
+} from "./chunk-LXYWINWF.js";
 import {
   DEFAULT_OPENAI_BASE_URL,
   convertSchema,
@@ -40,20 +43,21 @@ import {
   runtimeDiagnostics,
   safeJsonParse,
   tokenLimit
-} from "./chunk-Y7R6H6FT.js";
+} from "./chunk-LYSND7KR.js";
 import {
   FinishReason,
   GenerateContentResponse
-} from "./chunk-BNESGOSJ.js";
+} from "./chunk-55ZMG67I.js";
 import {
   FatalConfigError,
   Storage,
   createDebugLogger,
+  formatTraceparent,
+  getActiveSpanTraceContext,
   getCurrentSessionId,
   getErrorMessage,
   getErrorStatus,
   getErrorType,
-  getSessionContext,
   isNodeError,
   isSubpaths,
   makeRelative,
@@ -61,7 +65,7 @@ import {
   setShellTracePropagation,
   shortenPath,
   unescapePath
-} from "./chunk-JXAZUMDW.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   require_dist
 } from "./chunk-ZERZSAZL.js";
@@ -81,8 +85,9 @@ import {
   init_esm,
   isSpanContextValid,
   metrics,
+  propagation,
   trace
-} from "./chunk-WFVXF3OM.js";
+} from "./chunk-Z2Z3GUXZ.js";
 import {
   __qwen_dirname,
   init_esbuild_shims
@@ -17034,7 +17039,7 @@ var require_load_balancer_child_handler = __commonJS({
           createSubchannel(subchannelAddress, subchannelArgs) {
             return this.parent.channelControlHelper.createSubchannel(subchannelAddress, subchannelArgs);
           }
-          updateState(connectivityState, picker, errorMessage) {
+          updateState(connectivityState, picker, errorMessage2) {
             var _a;
             if (this.calledByPendingChild()) {
               if (connectivityState === connectivity_state_1.ConnectivityState.CONNECTING) {
@@ -17046,7 +17051,7 @@ var require_load_balancer_child_handler = __commonJS({
             } else if (!this.calledByCurrentChild()) {
               return;
             }
-            this.parent.channelControlHelper.updateState(connectivityState, picker, errorMessage);
+            this.parent.channelControlHelper.updateState(connectivityState, picker, errorMessage2);
           }
           requestReresolution() {
             var _a;
@@ -17280,11 +17285,11 @@ var require_resolving_load_balancer = __commonJS({
               this.updateResolution();
             }
           }, "requestReresolution"),
-          updateState: /* @__PURE__ */ __name((newState, picker, errorMessage) => {
+          updateState: /* @__PURE__ */ __name((newState, picker, errorMessage2) => {
             this.latestChildState = newState;
             this.latestChildPicker = picker;
-            this.latestChildErrorMessage = errorMessage;
-            this.updateState(newState, picker, errorMessage);
+            this.latestChildErrorMessage = errorMessage2;
+            this.updateState(newState, picker, errorMessage2);
           }, "updateState"),
           addChannelzChild: channelControlHelper.addChannelzChild.bind(channelControlHelper),
           removeChannelzChild: channelControlHelper.removeChannelzChild.bind(channelControlHelper)
@@ -17350,13 +17355,13 @@ var require_resolving_load_balancer = __commonJS({
         }
         this.backoffTimeout.runOnce();
       }
-      updateState(connectivityState, picker, errorMessage) {
+      updateState(connectivityState, picker, errorMessage2) {
         trace2((0, uri_parser_1.uriToString)(this.target) + " " + connectivity_state_1.ConnectivityState[this.currentState] + " -> " + connectivity_state_1.ConnectivityState[connectivityState]);
         if (connectivityState === connectivity_state_1.ConnectivityState.IDLE) {
           picker = new picker_1.QueuePicker(this, picker);
         }
         this.currentState = connectivityState;
-        this.channelControlHelper.updateState(connectivityState, picker, errorMessage);
+        this.channelControlHelper.updateState(connectivityState, picker, errorMessage2);
       }
       handleResolutionFailure(error) {
         if (this.latestChildState === connectivity_state_1.ConnectivityState.IDLE) {
@@ -20117,13 +20122,13 @@ var require_path = __commonJS({
     "use strict";
     init_esbuild_shims();
     var path8 = exports;
-    var isAbsolute2 = (
+    var isAbsolute3 = (
       /**
        * Tests if the specified path is absolute.
        * @param {string} path Path to test
        * @returns {boolean} `true` if path is absolute
        */
-      path8.isAbsolute = /* @__PURE__ */ __name(function isAbsolute3(path9) {
+      path8.isAbsolute = /* @__PURE__ */ __name(function isAbsolute4(path9) {
         return /^(?:\/|\w+:)/.test(path9);
       }, "isAbsolute")
     );
@@ -20135,7 +20140,7 @@ var require_path = __commonJS({
        */
       path8.normalize = /* @__PURE__ */ __name(function normalize4(path9) {
         path9 = path9.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
-        var parts = path9.split("/"), absolute = isAbsolute2(path9), prefix = "";
+        var parts = path9.split("/"), absolute = isAbsolute3(path9), prefix = "";
         if (absolute)
           prefix = parts.shift() + "/";
         for (var i = 0; i < parts.length; ) {
@@ -20157,7 +20162,7 @@ var require_path = __commonJS({
     path8.resolve = /* @__PURE__ */ __name(function resolve2(originPath, includePath, alreadyNormalized) {
       if (!alreadyNormalized)
         includePath = normalize3(includePath);
-      if (isAbsolute2(includePath))
+      if (isAbsolute3(includePath))
         return includePath;
       if (!alreadyNormalized)
         originPath = normalize3(originPath);
@@ -27641,13 +27646,13 @@ var require_subchannel = __commonJS({
        * @param newState The state to transition to
        * @returns True if the state changed, false otherwise
        */
-      transitionToState(oldStates, newState, errorMessage) {
+      transitionToState(oldStates, newState, errorMessage2) {
         var _a, _b;
         if (oldStates.indexOf(this.connectivityState) === -1) {
           return false;
         }
-        if (errorMessage) {
-          this.trace(connectivity_state_1.ConnectivityState[this.connectivityState] + " -> " + connectivity_state_1.ConnectivityState[newState] + ' with error "' + errorMessage + '"');
+        if (errorMessage2) {
+          this.trace(connectivity_state_1.ConnectivityState[this.connectivityState] + " -> " + connectivity_state_1.ConnectivityState[newState] + ' with error "' + errorMessage2 + '"');
         } else {
           this.trace(connectivity_state_1.ConnectivityState[this.connectivityState] + " -> " + connectivity_state_1.ConnectivityState[newState]);
         }
@@ -27688,7 +27693,7 @@ var require_subchannel = __commonJS({
             throw new Error(`Invalid state: unknown ConnectivityState ${newState}`);
         }
         for (const listener of this.stateListeners) {
-          listener(this, previousState, newState, this.keepaliveTime, errorMessage);
+          listener(this, previousState, newState, this.keepaliveTime, errorMessage2);
         }
         return true;
       }
@@ -29257,18 +29262,18 @@ var require_transport = __commonJS({
             setImmediate(() => {
               if (!reportedError) {
                 reportedError = true;
-                reject(`${errorMessage.trim()} (${(/* @__PURE__ */ new Date()).toISOString()})`);
+                reject(`${errorMessage2.trim()} (${(/* @__PURE__ */ new Date()).toISOString()})`);
               }
             });
           }, "closeHandler");
           const errorHandler = /* @__PURE__ */ __name((error) => {
             var _a;
             (_a = this.session) === null || _a === void 0 ? void 0 : _a.destroy();
-            errorMessage = error.message;
-            this.trace("connection failed with error " + errorMessage);
+            errorMessage2 = error.message;
+            this.trace("connection failed with error " + errorMessage2);
             if (!reportedError) {
               reportedError = true;
-              reject(`${errorMessage} (${(/* @__PURE__ */ new Date()).toISOString()})`);
+              reject(`${errorMessage2} (${(/* @__PURE__ */ new Date()).toISOString()})`);
             }
           }, "errorHandler");
           const sessionOptions = {
@@ -29283,7 +29288,7 @@ var require_transport = __commonJS({
           }
           const session = http2.connect(`${scheme}://${targetPath}`, sessionOptions);
           this.session = session;
-          let errorMessage = "Failed to connect";
+          let errorMessage2 = "Failed to connect";
           let reportedError = false;
           session.unref();
           session.once("remoteSettings", () => {
@@ -34699,8 +34704,8 @@ var require_load_balancer_pick_first = __commonJS({
         this.currentState = connectivity_state_1.ConnectivityState.IDLE;
         this.currentSubchannelIndex = 0;
         this.currentPick = null;
-        this.subchannelStateListener = (subchannel, previousState, newState, keepaliveTime, errorMessage) => {
-          this.onSubchannelStateUpdate(subchannel, previousState, newState, errorMessage);
+        this.subchannelStateListener = (subchannel, previousState, newState, keepaliveTime, errorMessage2) => {
+          this.onSubchannelStateUpdate(subchannel, previousState, newState, errorMessage2);
         };
         this.pickedSubchannelHealthListener = () => this.calculateAndReportNewState();
         this.stickyTransientFailureMode = false;
@@ -34722,26 +34727,26 @@ var require_load_balancer_pick_first = __commonJS({
         var _a;
         if (this.currentPick) {
           if (this.reportHealthStatus && !this.currentPick.isHealthy()) {
-            const errorMessage = `Picked subchannel ${this.currentPick.getAddress()} is unhealthy`;
+            const errorMessage2 = `Picked subchannel ${this.currentPick.getAddress()} is unhealthy`;
             this.updateState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE, new picker_1.UnavailablePicker({
-              details: errorMessage
-            }), errorMessage);
+              details: errorMessage2
+            }), errorMessage2);
           } else {
             this.updateState(connectivity_state_1.ConnectivityState.READY, new PickFirstPicker(this.currentPick), null);
           }
         } else if (((_a = this.latestAddressList) === null || _a === void 0 ? void 0 : _a.length) === 0) {
-          const errorMessage = `No connection established. Last error: ${this.lastError}`;
+          const errorMessage2 = `No connection established. Last error: ${this.lastError}`;
           this.updateState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE, new picker_1.UnavailablePicker({
-            details: errorMessage
-          }), errorMessage);
+            details: errorMessage2
+          }), errorMessage2);
         } else if (this.children.length === 0) {
           this.updateState(connectivity_state_1.ConnectivityState.IDLE, new picker_1.QueuePicker(this), null);
         } else {
           if (this.stickyTransientFailureMode) {
-            const errorMessage = `No connection established. Last error: ${this.lastError}`;
+            const errorMessage2 = `No connection established. Last error: ${this.lastError}`;
             this.updateState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE, new picker_1.UnavailablePicker({
-              details: errorMessage
-            }), errorMessage);
+              details: errorMessage2
+            }), errorMessage2);
           } else {
             this.updateState(connectivity_state_1.ConnectivityState.CONNECTING, new picker_1.QueuePicker(this), null);
           }
@@ -34775,7 +34780,7 @@ var require_load_balancer_pick_first = __commonJS({
           this.currentPick = null;
         }
       }
-      onSubchannelStateUpdate(subchannel, previousState, newState, errorMessage) {
+      onSubchannelStateUpdate(subchannel, previousState, newState, errorMessage2) {
         var _a;
         if ((_a = this.currentPick) === null || _a === void 0 ? void 0 : _a.realSubchannelEquals(subchannel)) {
           if (newState !== connectivity_state_1.ConnectivityState.READY) {
@@ -34791,8 +34796,8 @@ var require_load_balancer_pick_first = __commonJS({
             }
             if (newState === connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE) {
               child.hasReportedTransientFailure = true;
-              if (errorMessage) {
-                this.lastError = errorMessage;
+              if (errorMessage2) {
+                this.lastError = errorMessage2;
               }
               this.maybeEnterStickyTransientFailureMode();
               if (index === this.currentSubchannelIndex) {
@@ -34857,10 +34862,10 @@ var require_load_balancer_pick_first = __commonJS({
         clearTimeout(this.connectionDelayTimeout);
         this.calculateAndReportNewState();
       }
-      updateState(newState, picker, errorMessage) {
+      updateState(newState, picker, errorMessage2) {
         trace2(connectivity_state_1.ConnectivityState[this.currentState] + " -> " + connectivity_state_1.ConnectivityState[newState]);
         this.currentState = newState;
-        this.channelControlHelper.updateState(newState, picker, errorMessage);
+        this.channelControlHelper.updateState(newState, picker, errorMessage2);
       }
       resetSubchannelList() {
         for (const child of this.children) {
@@ -34944,10 +34949,10 @@ var require_load_balancer_pick_first = __commonJS({
         this.options = options;
         this.latestState = connectivity_state_1.ConnectivityState.IDLE;
         const childChannelControlHelper = (0, load_balancer_1.createChildChannelControlHelper)(channelControlHelper, {
-          updateState: /* @__PURE__ */ __name((connectivityState, picker, errorMessage) => {
+          updateState: /* @__PURE__ */ __name((connectivityState, picker, errorMessage2) => {
             this.latestState = connectivityState;
             this.latestPicker = picker;
-            channelControlHelper.updateState(connectivityState, picker, errorMessage);
+            channelControlHelper.updateState(connectivityState, picker, errorMessage2);
           }, "updateState")
         });
         this.pickFirstBalancer = new PickFirstLoadBalancer(childChannelControlHelper);
@@ -35459,12 +35464,12 @@ var require_load_balancer_round_robin = __commonJS({
         this.updatesPaused = false;
         this.lastError = null;
         this.childChannelControlHelper = (0, load_balancer_1.createChildChannelControlHelper)(channelControlHelper, {
-          updateState: /* @__PURE__ */ __name((connectivityState, picker, errorMessage) => {
+          updateState: /* @__PURE__ */ __name((connectivityState, picker, errorMessage2) => {
             if (this.currentState === connectivity_state_1.ConnectivityState.READY && connectivityState !== connectivity_state_1.ConnectivityState.READY) {
               this.channelControlHelper.requestReresolution();
             }
-            if (errorMessage) {
-              this.lastError = errorMessage;
+            if (errorMessage2) {
+              this.lastError = errorMessage2;
             }
             this.calculateAndUpdateState();
           }, "updateState")
@@ -35494,10 +35499,10 @@ var require_load_balancer_round_robin = __commonJS({
         } else if (this.countChildrenWithState(connectivity_state_1.ConnectivityState.CONNECTING) > 0) {
           this.updateState(connectivity_state_1.ConnectivityState.CONNECTING, new picker_1.QueuePicker(this), null);
         } else if (this.countChildrenWithState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE) > 0) {
-          const errorMessage = `round_robin: No connection established. Last error: ${this.lastError}`;
+          const errorMessage2 = `round_robin: No connection established. Last error: ${this.lastError}`;
           this.updateState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE, new picker_1.UnavailablePicker({
-            details: errorMessage
-          }), errorMessage);
+            details: errorMessage2
+          }), errorMessage2);
         } else {
           this.updateState(connectivity_state_1.ConnectivityState.IDLE, new picker_1.QueuePicker(this), null);
         }
@@ -35507,7 +35512,7 @@ var require_load_balancer_round_robin = __commonJS({
           }
         }
       }
-      updateState(newState, picker, errorMessage) {
+      updateState(newState, picker, errorMessage2) {
         trace2(connectivity_state_1.ConnectivityState[this.currentState] + " -> " + connectivity_state_1.ConnectivityState[newState]);
         if (newState === connectivity_state_1.ConnectivityState.READY) {
           this.currentReadyPicker = picker;
@@ -35515,7 +35520,7 @@ var require_load_balancer_round_robin = __commonJS({
           this.currentReadyPicker = null;
         }
         this.currentState = newState;
-        this.channelControlHelper.updateState(newState, picker, errorMessage);
+        this.channelControlHelper.updateState(newState, picker, errorMessage2);
       }
       resetSubchannelList() {
         for (const child of this.children) {
@@ -35830,11 +35835,11 @@ var require_load_balancer_outlier_detection = __commonJS({
             mapEntry === null || mapEntry === void 0 ? void 0 : mapEntry.subchannelWrappers.push(subchannelWrapper);
             return subchannelWrapper;
           }, "createSubchannel"),
-          updateState: /* @__PURE__ */ __name((connectivityState, picker, errorMessage) => {
+          updateState: /* @__PURE__ */ __name((connectivityState, picker, errorMessage2) => {
             if (connectivityState === connectivity_state_1.ConnectivityState.READY) {
-              channelControlHelper.updateState(connectivityState, new OutlierDetectionPicker(picker, this.isCountingEnabled()), errorMessage);
+              channelControlHelper.updateState(connectivityState, new OutlierDetectionPicker(picker, this.isCountingEnabled()), errorMessage2);
             } else {
-              channelControlHelper.updateState(connectivityState, picker, errorMessage);
+              channelControlHelper.updateState(connectivityState, picker, errorMessage2);
             }
           }, "updateState")
         }));
@@ -40578,8 +40583,8 @@ var require_root2 = __commonJS({
             return metrics2;
           }();
           collector.logs = function() {
-            var logs2 = {};
-            logs2.v1 = function() {
+            var logs3 = {};
+            logs3.v1 = function() {
               var v1 = {};
               v1.LogsService = function() {
                 function LogsService(rpcImpl, requestDelimited, responseDelimited) {
@@ -40923,7 +40928,7 @@ var require_root2 = __commonJS({
               }();
               return v1;
             }();
-            return logs2;
+            return logs3;
           }();
           return collector;
         }();
@@ -44405,8 +44410,8 @@ var require_root2 = __commonJS({
           return metrics2;
         }();
         proto.logs = function() {
-          var logs2 = {};
-          logs2.v1 = function() {
+          var logs3 = {};
+          logs3.v1 = function() {
             var v1 = {};
             v1.LogsData = function() {
               function LogsData(properties) {
@@ -45348,7 +45353,7 @@ var require_root2 = __commonJS({
             }();
             return v1;
           }();
-          return logs2;
+          return logs3;
         }();
         return proto;
       }();
@@ -48134,19 +48139,19 @@ var require_getMachineId = __commonJS({
       if (!getMachineIdImpl) {
         switch (process3.platform) {
           case "darwin":
-            getMachineIdImpl = (await import("./getMachineId-darwin-T73DJL27.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-darwin-HPQPEMZR.js")).getMachineId;
             break;
           case "linux":
-            getMachineIdImpl = (await import("./getMachineId-linux-MKQTFPQM.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-linux-AUARKYHL.js")).getMachineId;
             break;
           case "freebsd":
-            getMachineIdImpl = (await import("./getMachineId-bsd-F7GNPTER.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-bsd-4CASPIU4.js")).getMachineId;
             break;
           case "win32":
-            getMachineIdImpl = (await import("./getMachineId-win-CDYFC6ZM.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-win-4EFLHYIJ.js")).getMachineId;
             break;
           default:
-            getMachineIdImpl = (await import("./getMachineId-unsupported-MUR5KOQE.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-unsupported-S32ZDA2T.js")).getMachineId;
             break;
         }
       }
@@ -51706,8 +51711,8 @@ var require_ConsoleLogRecordExporter = __commonJS({
        * @param logs
        * @param resultCallback
        */
-      export(logs2, resultCallback) {
-        this._sendLogRecords(logs2, resultCallback);
+      export(logs3, resultCallback) {
+        this._sendLogRecords(logs3, resultCallback);
       }
       /**
        * Shutdown the exporter.
@@ -51824,14 +51829,14 @@ var require_InMemoryLogRecordExporter = __commonJS({
        * When false, exported log records will not be stored in-memory.
        */
       _stopped = false;
-      export(logs2, resultCallback) {
+      export(logs3, resultCallback) {
         if (this._stopped) {
           return resultCallback({
             code: core_1.ExportResultCode.FAILED,
             error: new Error("Exporter has been stopped")
           });
         }
-        this._finishedLogRecords.push(...logs2);
+        this._finishedLogRecords.push(...logs3);
         resultCallback({ code: core_1.ExportResultCode.SUCCESS });
       }
       shutdown() {
@@ -61212,7 +61217,12 @@ function setGeminiMdFilename(newFilename) {
 __name(setGeminiMdFilename, "setGeminiMdFilename");
 function getCurrentGeminiMdFilename() {
   if (Array.isArray(currentGeminiMdFilename)) {
-    return currentGeminiMdFilename[0];
+    for (const entry of currentGeminiMdFilename) {
+      if (typeof entry === "string" && entry.trim() !== "") {
+        return entry.trim();
+      }
+    }
+    return DEFAULT_CONTEXT_FILENAME;
   }
   return currentGeminiMdFilename;
 }
@@ -62678,12 +62688,12 @@ async function processSingleFileContent(filePath, config, offset, limit, pages)
       }
     }
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorMessage2 = error instanceof Error ? error.message : String(error);
     const displayPath = path2.relative(rootDirectory, filePath).replace(/\\/g, "/");
     return {
-      llmContent: `Error reading file ${displayPath}: ${errorMessage}`,
-      returnDisplay: `Error reading file ${displayPath}: ${errorMessage}`,
-      error: `Error reading file ${filePath}: ${errorMessage}`,
+      llmContent: `Error reading file ${displayPath}: ${errorMessage2}`,
+      returnDisplay: `Error reading file ${displayPath}: ${errorMessage2}`,
+      error: `Error reading file ${filePath}: ${errorMessage2}`,
       errorType: "read_content_failure" /* READ_CONTENT_FAILURE */
     };
   }
@@ -63588,7 +63598,7 @@ __name(getProgrammingLanguage, "getProgrammingLanguage");
 
 // packages/core/src/telemetry/loggers.ts
 init_esbuild_shims();
-var import_api_logs = __toESM(require_src2(), 1);
+var import_api_logs2 = __toESM(require_src2(), 1);
 init_esm2();
 
 // packages/core/src/utils/internalPromptIds.ts
@@ -63705,17 +63715,35 @@ init_esbuild_shims();
 import * as fs3 from "node:fs/promises";
 import * as path4 from "node:path";
 import * as crypto2 from "node:crypto";
-async function truncateAndSaveToFile(content, fileName, projectTempDir, threshold, truncateLines) {
+var debugLogger3 = createDebugLogger("TRUNCATION");
+var PREVIEW_SIZE_CHARS = 2e3;
+var MAX_FILE_SIZE_BYTES = 50 * 1024 * 1024;
+var MAX_SESSION_BYTES = 500 * 1024 * 1024;
+var TOOL_OUTPUT_TRUNCATED_PREFIX = "Tool output was too large and has been truncated";
+async function truncateAndSaveToFile(content, fileName, projectTempDir, threshold, truncateLines, keep = "both") {
+  if (content.length <= threshold && !Number.isFinite(truncateLines)) {
+    return { content };
+  }
   const lines = content.split("\n");
   if (content.length <= threshold && lines.length <= truncateLines) {
     return { content };
   }
   const effectiveLines = Math.min(truncateLines, lines.length);
-  const headCount = Math.max(Math.floor(effectiveLines / 5), 1);
-  const tailCount = effectiveLines - headCount;
+  let headCount;
+  let tailCount;
+  if (keep === "head") {
+    headCount = effectiveLines;
+    tailCount = 0;
+  } else if (keep === "tail") {
+    headCount = 0;
+    tailCount = effectiveLines;
+  } else {
+    headCount = Math.max(Math.floor(effectiveLines / 5), 1);
+    tailCount = effectiveLines - headCount;
+  }
   const separator = "\n\n---\n... [CONTENT TRUNCATED] ...\n---\n\n";
   const ellipsis = "...";
-  const headBudget = Math.floor(threshold / 5);
+  const headBudget = keep === "head" ? threshold : keep === "tail" ? 0 : Math.floor(threshold / 5);
   const beginning = [];
   let headChars = 0;
   for (let i = 0; i < Math.min(headCount, lines.length); i++) {
@@ -63730,7 +63758,7 @@ async function truncateAndSaveToFile(content, fileName, projectTempDir, threshol
     beginning.push(lines[i]);
     headChars += lines[i].length + 1;
   }
-  const tailBudget = Math.max(threshold - headChars - separator.length, 0);
+  const tailBudget = keep === "head" ? 0 : Math.max(threshold - headChars - separator.length, 0);
   const end = [];
   let tailChars = 0;
   const tailStart = Math.max(lines.length - tailCount, beginning.length);
@@ -63739,30 +63767,38 @@ async function truncateAndSaveToFile(content, fileName, projectTempDir, threshol
     if (remaining <= 0) break;
     if (lines[i].length + 1 > remaining) {
       const sliceLen = Math.max(remaining - ellipsis.length, 0);
-      end.unshift(ellipsis + lines[i].slice(-sliceLen));
+      end.unshift(ellipsis + (sliceLen > 0 ? lines[i].slice(-sliceLen) : ""));
       tailChars = tailBudget;
       break;
     }
     end.unshift(lines[i]);
     tailChars += lines[i].length + 1;
   }
-  const truncatedContent = beginning.join("\n") + separator + end.join("\n");
+  const truncatedContent = keep === "head" ? beginning.join("\n") + separator : keep === "tail" ? separator + end.join("\n") : beginning.join("\n") + separator + end.join("\n");
   const safeFileName = `${path4.basename(fileName)}.output`;
   const outputFile = path4.join(projectTempDir, safeFileName);
-  try {
-    await fs3.mkdir(projectTempDir, { recursive: true });
-    await fs3.writeFile(outputFile, content);
-    return {
-      content: `Tool output was too large and has been truncated.
+  const wrappedMessage = `${TOOL_OUTPUT_TRUNCATED_PREFIX}.
 The full output has been saved to: ${outputFile}
 To read the complete output, use the ${ReadFileTool.Name} tool with the absolute file path above.
 The truncated output below shows the beginning and end of the content. The marker '... [CONTENT TRUNCATED] ...' indicates where content was removed.
 
 Truncated part of the output:
-${truncatedContent}`,
+${truncatedContent}`;
+  if (wrappedMessage.length >= content.length) {
+    return { content };
+  }
+  try {
+    await fs3.mkdir(projectTempDir, { recursive: true });
+    await fs3.writeFile(outputFile, content, { mode: 384 });
+    return {
+      content: wrappedMessage,
       outputFile
     };
-  } catch (_error) {
+  } catch (error) {
+    debugLogger3.warn(
+      `Failed to save truncated output to ${outputFile}:`,
+      error
+    );
     return {
       content: truncatedContent + `
 [Note: Could not save full output to file]`
@@ -63770,12 +63806,16 @@ ${truncatedContent}`,
   }
 }
 __name(truncateAndSaveToFile, "truncateAndSaveToFile");
-async function truncateToolOutput(config, toolName, content) {
-  const threshold = config.getTruncateToolOutputThreshold();
-  const lines = config.getTruncateToolOutputLines();
+async function truncateToolOutput(config, toolName, content, limits, promptId) {
+  const threshold = limits?.threshold ?? config.getTruncateToolOutputThreshold();
+  const lines = limits?.lines ?? config.getTruncateToolOutputLines();
+  const keep = limits?.keep ?? "both";
   if (threshold <= 0 || lines <= 0) {
     return { content };
   }
+  if (content.length <= threshold && !Number.isFinite(lines)) {
+    return { content };
+  }
   const originalLength = content.length;
   const fileName = `${toolName}_${crypto2.randomBytes(6).toString("hex")}`;
   const result = await truncateAndSaveToFile(
@@ -63783,26 +63823,177 @@ async function truncateToolOutput(config, toolName, content) {
     fileName,
     config.storage.getProjectTempDir(),
     threshold,
-    lines
+    lines,
+    keep
   );
   if (result.outputFile) {
-    logToolOutputTruncated(
-      config,
-      new ToolOutputTruncatedEvent("", {
-        toolName,
-        originalContentLength: originalLength,
-        truncatedContentLength: result.content.length,
-        threshold,
-        lines
-      })
-    );
+    try {
+      logToolOutputTruncated(
+        config,
+        new ToolOutputTruncatedEvent(promptId ?? "", {
+          toolName,
+          originalContentLength: originalLength,
+          truncatedContentLength: result.content.length,
+          threshold,
+          lines
+        })
+      );
+    } catch {
+    }
   }
   return result;
 }
 __name(truncateToolOutput, "truncateToolOutput");
+async function truncateLlmContent(config, toolName, content, limits, promptId) {
+  if (typeof content === "string") {
+    if (content.trim() === "") {
+      return { content: `(${toolName} completed with no output)` };
+    }
+    if (content.startsWith(TOOL_OUTPUT_TRUNCATED_PREFIX)) {
+      return { content };
+    }
+    return truncateToolOutput(config, toolName, content, limits, promptId);
+  }
+  const parts = (Array.isArray(content) ? content : [content]).map(
+    (p) => typeof p === "string" ? { text: p } : p
+  );
+  const textParts = parts.filter((p) => p.text !== void 0);
+  const mediaParts = parts.filter((p) => p.text === void 0);
+  const combined = textParts.map((p) => p.text).join("\n");
+  if (combined.trim() === "" && mediaParts.length === 0) {
+    return { content: `(${toolName} completed with no output)` };
+  }
+  if (textParts.some((p) => p.text?.startsWith(TOOL_OUTPUT_TRUNCATED_PREFIX))) {
+    return { content };
+  }
+  const result = await truncateToolOutput(
+    config,
+    toolName,
+    combined,
+    limits,
+    promptId
+  );
+  if (result.content === combined) {
+    return { content };
+  }
+  return {
+    content: [{ text: result.content }, ...mediaParts],
+    outputFile: result.outputFile
+  };
+}
+__name(truncateLlmContent, "truncateLlmContent");
+function isAlreadyTruncated(content) {
+  return content.includes("... [CONTENT TRUNCATED] ...") || content.startsWith("<persisted-output>");
+}
+__name(isAlreadyTruncated, "isAlreadyTruncated");
+function generatePreview(content) {
+  let text = content.length <= PREVIEW_SIZE_CHARS ? content : (() => {
+    const slice = content.slice(0, PREVIEW_SIZE_CHARS);
+    const lastNewline = slice.lastIndexOf("\n");
+    return (lastNewline > 0 ? slice.slice(0, lastNewline) : slice) + "\n...";
+  })();
+  text = text.replace(/<\/?persisted-output>/g, (m) => `&lt;${m.slice(1, -1)}&gt;`).replace(/<\/?system-reminder>/g, (m) => `&lt;${m.slice(1, -1)}&gt;`);
+  return text;
+}
+__name(generatePreview, "generatePreview");
+async function persistAndTruncateToolResult(callId, toolName, content, config) {
+  const byteSize = Buffer.byteLength(content, "utf-8");
+  if (byteSize > MAX_FILE_SIZE_BYTES) {
+    debugLogger3.warn(
+      `Tool result for ${toolName} exceeds ${MAX_FILE_SIZE_BYTES} bytes (${byteSize}), skipping disk persistence`
+    );
+    return {
+      content: buildStub(content, byteSize, "(file too large to persist)"),
+      bytesWritten: 0
+    };
+  }
+  const budgetUsed = config.getToolResultBytesWritten();
+  if (budgetUsed + byteSize > MAX_SESSION_BYTES) {
+    debugLogger3.warn(
+      `Session tool result budget exhausted (${budgetUsed} + ${byteSize} > ${MAX_SESSION_BYTES}), skipping disk persistence`
+    );
+    return {
+      content: buildStub(
+        content,
+        byteSize,
+        "(session disk budget exhausted)"
+      ),
+      bytesWritten: 0
+    };
+  }
+  config.trackToolResultBytes(byteSize);
+  const safeCallId = path4.basename(callId).replace(/\x00/g, "_");
+  if (!safeCallId || safeCallId === "." || safeCallId === "..") {
+    debugLogger3.warn(`Invalid callId for disk persistence: ${JSON.stringify(callId)}`);
+    config.trackToolResultBytes(-byteSize);
+    return {
+      content: buildStub(content, byteSize, "(invalid callId)"),
+      bytesWritten: 0
+    };
+  }
+  const toolResultsDir = config.storage.getToolResultsDir();
+  const outputFile = path4.join(toolResultsDir, `${safeCallId}.txt`);
+  try {
+    await fs3.mkdir(toolResultsDir, { recursive: true });
+    await atomicWriteFile(outputFile, content, {
+      mode: 384,
+      forceMode: true,
+      noFollow: true,
+      flush: false
+    });
+    return {
+      content: buildStub(content, byteSize, outputFile),
+      outputFile,
+      bytesWritten: byteSize
+    };
+  } catch (error) {
+    config.trackToolResultBytes(-byteSize);
+    debugLogger3.warn(
+      `Failed to persist tool result to ${outputFile}:`,
+      error
+    );
+    try {
+      const fallback = await truncateAndSaveToFile(
+        content,
+        `${toolName}_${crypto2.randomBytes(6).toString("hex")}`,
+        config.storage.getProjectTempDir(),
+        config.getTruncateToolOutputThreshold(),
+        config.getTruncateToolOutputLines()
+      );
+      return { content: fallback.content, bytesWritten: 0 };
+    } catch (fallbackError) {
+      debugLogger3.warn("Fallback truncation also failed:", fallbackError);
+      return {
+        content: buildStub(content, byteSize, "(disk persistence unavailable)"),
+        bytesWritten: 0
+      };
+    }
+  }
+}
+__name(persistAndTruncateToolResult, "persistAndTruncateToolResult");
+function buildStub(content, byteSize, filePathOrNote) {
+  const preview = generatePreview(content);
+  const sizeKb = Math.round(byteSize / 1024);
+  const isFilePath = path4.isAbsolute(filePathOrNote);
+  if (isFilePath) {
+    return `<persisted-output>
+Output too large (${sizeKb} KB). Full output saved to: ${filePathOrNote}
+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.
+
+Preview (up to ${PREVIEW_SIZE_CHARS} chars):
+${preview}
+</persisted-output>`;
+  }
+  return `Output too large (${sizeKb} KB). ${filePathOrNote}
+
+Preview (up to ${PREVIEW_SIZE_CHARS} chars):
+${preview}`;
+}
+__name(buildStub, "buildStub");
 
 // packages/core/src/tools/mcp-tool.ts
-var debugLogger3 = createDebugLogger("MCP_TOOL");
+var debugLogger4 = createDebugLogger("MCP_TOOL");
 var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends BaseToolInvocation {
   constructor(mcpTool, serverName, serverToolName, displayName, trust, params = {}, cliConfig, mcpClient, mcpTimeout, annotations, retryCount = 0) {
     super(params);
@@ -63853,8 +64044,7 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
     };
     return confirmationDetails;
   }
-  // Determine if the response contains tool errors
-  // This is needed because CallToolResults should return errors inside the response.
+  // MCP spec: errors are returned inside the CallToolResult, not as exceptions.
   // ref: https://modelcontextprotocol.io/specification/2025-06-18/schema#calltoolresult
   isMCPToolError(rawResponseParts) {
     const functionResponse = rawResponseParts?.[0]?.functionResponse;
@@ -63873,7 +64063,7 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
       return null;
     }
     try {
-      debugLogger3.info(
+      debugLogger4.info(
         `Attempting to reconnect MCP server '${this.serverName}'...`
       );
       const toolRegistry = this.cliConfig.getToolRegistry();
@@ -63882,23 +64072,23 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
         `mcp__${this.serverName}__${this.serverToolName}`
       );
       if (newTool instanceof DiscoveredMCPTool) {
-        debugLogger3.info(
+        debugLogger4.info(
           `Successfully reconnected to MCP server '${this.serverName}'`
         );
         return newTool;
       }
       return null;
     } catch (error) {
-      debugLogger3.error(
+      debugLogger4.error(
         `Failed to reconnect MCP server '${this.serverName}': ${error}`
       );
       return null;
     }
   }
   async handleReconnectOnError(error, signal, updateOutput) {
-    debugLogger3.error(`MCP server error '${this.serverName}': ${error}`);
+    debugLogger4.error(`MCP server error '${this.serverName}': ${error}`);
     if (this.retryCount < _DiscoveredMCPToolInvocation.MAX_RECONNECT_RETRIES) {
-      debugLogger3.info(
+      debugLogger4.info(
         `Reconnection attempt ${this.retryCount + 1}/${_DiscoveredMCPToolInvocation.MAX_RECONNECT_RETRIES} for MCP server '${this.serverName}'`
       );
       const newTool = await this.attemptReconnect();
@@ -63919,7 +64109,7 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
         return newInvocation.execute(signal, updateOutput);
       }
     } else if (this.retryCount >= _DiscoveredMCPToolInvocation.MAX_RECONNECT_RETRIES) {
-      debugLogger3.error(
+      debugLogger4.error(
         `Max reconnection attempts (${_DiscoveredMCPToolInvocation.MAX_RECONNECT_RETRIES}) reached for MCP server '${this.serverName}'`
       );
     }
@@ -63966,15 +64156,15 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
         callToolResult
       );
       if (this.isMCPToolError(rawResponseParts)) {
-        const errorMessage = `MCP tool '${this.serverToolName}' reported tool error for function call: ${safeJsonStringify({
+        const errorMessage2 = `MCP tool '${this.serverToolName}' reported tool error for function call: ${safeJsonStringify({
           name: this.serverToolName,
           args: this.params
         })} with response: ${safeJsonStringify(rawResponseParts)}`;
         return {
-          llmContent: errorMessage,
+          llmContent: errorMessage2,
           returnDisplay: `Error: MCP tool '${this.serverToolName}' reported an error.`,
           error: {
-            message: errorMessage,
+            message: errorMessage2,
             type: "mcp_tool_error" /* MCP_TOOL_ERROR */
           }
         };
@@ -64027,14 +64217,14 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
         });
       });
       if (this.isMCPToolError(rawResponseParts)) {
-        const errorMessage = `MCP tool '${this.serverToolName}' reported tool error for function call: ${safeJsonStringify(
+        const errorMessage2 = `MCP tool '${this.serverToolName}' reported tool error for function call: ${safeJsonStringify(
           functionCalls[0]
         )} with response: ${safeJsonStringify(rawResponseParts)}`;
         return {
-          llmContent: errorMessage,
+          llmContent: errorMessage2,
           returnDisplay: `Error: MCP tool '${this.serverToolName}' reported an error.`,
           error: {
-            message: errorMessage,
+            message: errorMessage2,
             type: "mcp_tool_error" /* MCP_TOOL_ERROR */
           }
         };
@@ -64063,7 +64253,14 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
         const truncated = await truncateToolOutput(
           this.cliConfig,
           `mcp__${this.serverName}__${this.serverToolName}`,
-          part.text
+          part.text,
+          // Per-tool char budget; mirrors DiscoveredMCPTool.maxOutputChars
+          // (10x the global default, since MCP servers return large structured
+          // output). char-only (lines: Infinity) so the global line cap can't
+          // undercut the 500k char budget — many short lines (structured JSON,
+          // tables) would otherwise truncate while chars remain. Consistent
+          // with the shell tool's in-tool truncation.
+          { threshold: 5e5, lines: Number.POSITIVE_INFINITY }
         );
         result.push({ text: truncated.content });
       } else {
@@ -64110,6 +64307,12 @@ var DiscoveredMCPTool = class _DiscoveredMCPTool extends BaseDeclarativeTool {
   static {
     __name(this, "DiscoveredMCPTool");
   }
+  // MCP servers often return large structured payloads; allow 10x the global
+  // budget (mirrors Claude Code's MCP `maxResultSizeChars`) before the
+  // scheduler offloads. truncateTextParts uses the same ceiling per text part.
+  get maxOutputChars() {
+    return 5e5;
+  }
   asFullyQualifiedTool() {
     return new _DiscoveredMCPTool(
       this.mcpTool,
@@ -64125,6 +64328,40 @@ var DiscoveredMCPTool = class _DiscoveredMCPTool extends BaseDeclarativeTool {
       this.annotations
     );
   }
+  /**
+   * Return a clone of this tool with a different `trust` value while
+   * keeping every other field (including the shared underlying
+   * `CallableTool` / MCP transport) identical.
+   *
+   * pool path: a single shared pool entry produces one
+   * `DiscoveredMCPTool` snapshot; each `SessionMcpView` clones with
+   * its own per-session trust before registering into its session's
+   * `ToolRegistry`. Without this clone, mutating `trust` on the shared
+   * instance would cross-contaminate sessions.
+   *
+   * Trust is the only field that legitimately varies per session;
+   * everything else (transport, schema, name) is transport-level.
+   */
+  withTrust(trust) {
+    if (trust === this.trust) return this;
+    return new _DiscoveredMCPTool(
+      this.mcpTool,
+      this.serverName,
+      this.serverToolName,
+      this.description,
+      this.parameterSchema,
+      trust,
+      // Preserve the original name (do NOT re-call generateValidName)
+      // — equal-by-name is the registry's deduplication key, and a
+      // different name would race-register two tools in the same
+      // session.
+      this.name,
+      this.cliConfig,
+      this.mcpClient,
+      this.mcpTimeout,
+      this.annotations
+    );
+  }
   createInvocation(params) {
     return new DiscoveredMCPToolInvocation(
       this.mcpTool,
@@ -65289,7 +65526,7 @@ init_esbuild_shims();
 
 // packages/core/src/core/openaiContentGenerator/taggedThinkingParser.ts
 init_esbuild_shims();
-var debugLogger4 = createDebugLogger("TAGGED_THINKING_PARSER");
+var debugLogger5 = createDebugLogger("TAGGED_THINKING_PARSER");
 var OPEN_TAGS = ["<think>", "<thinking>"];
 var CLOSE_TAGS = ["</think>", "</thinking>"];
 var MAX_TAG_LENGTH = Math.max(
@@ -65330,7 +65567,7 @@ var TaggedThinkingParser = class {
       const activeTags = this.mode === "text" ? OPEN_TAGS : CLOSE_TAGS;
       const matchedTag = findMatchingTag(lower, index, activeTags);
       if (matchedTag) {
-        debugLogger4.debug(
+        debugLogger5.debug(
           `taggedThinking: detected tag "${matchedTag}" at offset ${index}`
         );
         appendPart(parts, segment, this.mode);
@@ -65348,19 +65585,19 @@ var TaggedThinkingParser = class {
     if (index < this.buffer.length) {
       appendPart(parts, segment, this.mode);
       this.buffer = this.buffer.slice(index);
-      debugLogger4.debug(
+      debugLogger5.debug(
         `taggedThinking: emitted ${parts.length} part(s), buffered ${this.buffer.length} char(s)`
       );
       return parts;
     }
     this.buffer = "";
     if (this.mode === "thought" && segment) {
-      debugLogger4.warn(
+      debugLogger5.warn(
         `taggedThinking: flushing ${segment.length} chars of unclosed thought on stream end`
       );
     }
     appendPart(parts, segment, this.mode);
-    debugLogger4.debug(
+    debugLogger5.debug(
       `taggedThinking: emitted ${parts.length} part(s), flush complete`
     );
     return parts;
@@ -65372,7 +65609,7 @@ function parseTaggedThinkingText(text) {
 __name(parseTaggedThinkingText, "parseTaggedThinkingText");
 
 // packages/core/src/core/openaiContentGenerator/converter.ts
-var debugLogger5 = createDebugLogger("CONVERTER");
+var debugLogger6 = createDebugLogger("CONVERTER");
 var SPLIT_TOOL_MEDIA_TEXT = "(attached media from previous tool call)";
 var CUMULATIVE_DELTA_EXACT_REPEAT_MIN_LENGTH = 64;
 var CUMULATIVE_DETECTION_WINDOW_BYTES = 1024;
@@ -65393,12 +65630,12 @@ function normalizeStreamingTextDelta(rawDelta, state) {
       return suffix;
     }
     if (state.emittedText.startsWith(rawDelta)) {
-      debugLogger5.debug(
+      debugLogger6.debug(
         `normalizeStreamingTextDelta: cumulative rewind suppression (emitted=${state.emittedText.length}b, chunk=${rawDelta.length}b)`
       );
       return "";
     }
-    debugLogger5.debug(
+    debugLogger6.debug(
       "normalizeStreamingTextDelta: exiting cumulative mode (chunk does not match prior accumulated text)"
     );
     state.cumulativeMode = false;
@@ -65415,7 +65652,7 @@ function normalizeStreamingTextDelta(rawDelta, state) {
       state.emittedText = rawDelta;
       state.emittedLength = rawDelta.length;
       state.cumulativeMode = true;
-      debugLogger5.debug(
+      debugLogger6.debug(
         `normalizeStreamingTextDelta: entered cumulative mode (prefix overlap, baseline=${baselineLen}b sliceFrom=${sliceFrom}b -> curr=${rawDelta.length}b)`
       );
       return suffix;
@@ -65424,7 +65661,7 @@ function normalizeStreamingTextDelta(rawDelta, state) {
   if (rawDelta === state.emittedText) {
     if (rawDelta.length >= CUMULATIVE_DELTA_EXACT_REPEAT_MIN_LENGTH) {
       state.cumulativeMode = true;
-      debugLogger5.debug(
+      debugLogger6.debug(
         `normalizeStreamingTextDelta: entered cumulative mode (exact repeat, ${rawDelta.length}b)`
       );
       return "";
@@ -65644,6 +65881,8 @@ function processContent(content, messages, requestContext) {
   const reasoningParts = [];
   const toolCalls = [];
   let toolCallIndex = 0;
+  const emittedFunctionCallIds = /* @__PURE__ */ new Set();
+  const emittedFunctionResponseIds = /* @__PURE__ */ new Set();
   const accumulatedSplitMedia = [];
   for (const part of parts) {
     if (typeof part === "string") {
@@ -65663,8 +65902,18 @@ function processContent(content, messages, requestContext) {
       contentParts.push(mediaPart);
     }
     if ("functionCall" in part && part.functionCall && role === "assistant") {
+      const callId = part.functionCall.id;
+      if (callId) {
+        if (emittedFunctionCallIds.has(callId)) {
+          debugLogger6.debug(
+            `Dropping duplicate functionCall id=${callId} while converting content`
+          );
+          continue;
+        }
+        emittedFunctionCallIds.add(callId);
+      }
       toolCalls.push({
-        id: part.functionCall.id || `call_${toolCallIndex}`,
+        id: callId || `call_${toolCallIndex}`,
         type: "function",
         function: {
           name: part.functionCall.name || "",
@@ -65674,6 +65923,13 @@ function processContent(content, messages, requestContext) {
       toolCallIndex += 1;
     }
     if (part.functionResponse && role === "user") {
+      const responseId = part.functionResponse.id;
+      if (responseId) {
+        if (emittedFunctionResponseIds.has(responseId)) {
+          continue;
+        }
+        emittedFunctionResponseIds.add(responseId);
+      }
       const toolMessage = createToolMessage(
         part.functionResponse,
         requestContext
@@ -65933,7 +66189,7 @@ function createMediaContentPart(part, requestContext) {
 }
 __name(createMediaContentPart, "createMediaContentPart");
 function unsupportedModalityPlaceholder(modality, displayName, requestContext) {
-  debugLogger5.warn(
+  debugLogger6.warn(
     `Model '${requestContext.model}' does not support ${modality} input. Replacing with text placeholder: ${displayName}`
   );
   let hint;
@@ -66257,16 +66513,27 @@ function isSplitToolMediaMessage(message) {
 __name(isSplitToolMediaMessage, "isSplitToolMediaMessage");
 function cleanOrphanedToolCalls(messages) {
   const cleaned = [];
-  const adjacentToolResponseIdsByAssistant = /* @__PURE__ */ new Map();
+  const validToolCallsByAssistant = /* @__PURE__ */ new Map();
   const validToolResponseIndexesByAssistant = /* @__PURE__ */ new Map();
   const splitMediaIndexesByAssistant = /* @__PURE__ */ new Map();
   const emittedWithAssistant = /* @__PURE__ */ new Set();
+  const survivingToolCallIds = /* @__PURE__ */ new Set();
   for (let index = 0; index < messages.length; index += 1) {
     const message = messages[index];
     if (hasToolCalls(message)) {
-      const toolCallIds = new Set(
-        message.tool_calls.map((toolCall) => toolCall.id).filter((id) => Boolean(id))
-      );
+      const candidateToolCalls = [];
+      const candidateToolCallIds = /* @__PURE__ */ new Set();
+      for (const toolCall of message.tool_calls) {
+        const id = toolCall.id;
+        if (!id || survivingToolCallIds.has(id)) {
+          continue;
+        }
+        if (candidateToolCallIds.has(id)) {
+          continue;
+        }
+        candidateToolCallIds.add(id);
+        candidateToolCalls.push(toolCall);
+      }
       const adjacentToolResponseIds = /* @__PURE__ */ new Set();
       const toolResponseIndexes = [];
       const splitMediaIndexes = [];
@@ -66278,7 +66545,7 @@ function cleanOrphanedToolCalls(messages) {
             lastToolResponseMatchesAssistant = false;
             continue;
           }
-          if (toolCallIds.has(nextMessage.tool_call_id)) {
+          if (candidateToolCallIds.has(nextMessage.tool_call_id) && !adjacentToolResponseIds.has(nextMessage.tool_call_id)) {
             adjacentToolResponseIds.add(nextMessage.tool_call_id);
             toolResponseIndexes.push(nextIndex);
             lastToolResponseMatchesAssistant = true;
@@ -66298,7 +66565,13 @@ function cleanOrphanedToolCalls(messages) {
         }
         break;
       }
-      adjacentToolResponseIdsByAssistant.set(index, adjacentToolResponseIds);
+      const validToolCalls = candidateToolCalls.filter(
+        (toolCall) => adjacentToolResponseIds.has(toolCall.id)
+      );
+      for (const toolCall of validToolCalls) {
+        survivingToolCallIds.add(toolCall.id);
+      }
+      validToolCallsByAssistant.set(index, validToolCalls);
       validToolResponseIndexesByAssistant.set(index, toolResponseIndexes);
       splitMediaIndexesByAssistant.set(index, splitMediaIndexes);
     }
@@ -66310,10 +66583,7 @@ function cleanOrphanedToolCalls(messages) {
     const message = messages[index];
     if (hasToolCalls(message)) {
       const reasoningContent = message.reasoning_content;
-      const adjacentToolResponseIds = adjacentToolResponseIdsByAssistant.get(index) ?? /* @__PURE__ */ new Set();
-      const validToolCalls = message.tool_calls.filter(
-        (toolCall) => toolCall.id && adjacentToolResponseIds.has(toolCall.id)
-      );
+      const validToolCalls = validToolCallsByAssistant.get(index) ?? [];
       if (validToolCalls.length > 0) {
         const cleanedMessage = { ...message };
         cleanedMessage.tool_calls = validToolCalls;
@@ -66339,16 +66609,16 @@ function cleanOrphanedToolCalls(messages) {
         delete cleanedMessage.tool_calls;
         cleaned.push(cleanedMessage);
       } else {
-        debugLogger5.debug(
+        debugLogger6.debug(
           `cleanOrphanedToolCalls: dropping assistant with ${message.tool_calls.length} orphaned tool call(s) and no text/reasoning content`
         );
       }
     } else if (message.role === "tool" && "tool_call_id" in message) {
-      debugLogger5.debug(
+      debugLogger6.debug(
         `cleanOrphanedToolCalls: dropping orphaned tool response ${message.tool_call_id || "<empty>"}`
       );
     } else if (isSplitToolMediaMessage(message)) {
-      debugLogger5.debug(
+      debugLogger6.debug(
         "cleanOrphanedToolCalls: dropping orphaned split tool media message"
       );
     } else {
@@ -66476,7 +66746,7 @@ var v4_default = v4;
 
 // packages/core/src/utils/openaiLogger.ts
 import * as os2 from "os";
-var debugLogger6 = createDebugLogger("OPENAI_LOGGER");
+var debugLogger7 = createDebugLogger("OPENAI_LOGGER");
 var MAIN_SESSION_PROMPT_ID_DELIMITER = "########";
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function resolveOpenAILogDir(customLogDir, cwd) {
@@ -66572,7 +66842,7 @@ var OpenAILogger = class {
       await fs4.mkdir(this.logDir, { recursive: true });
       this.initialized = true;
     } catch (error) {
-      debugLogger6.error("Failed to initialize OpenAI logger:", error);
+      debugLogger7.error("Failed to initialize OpenAI logger:", error);
       throw new Error(`Failed to initialize OpenAI logger: ${error}`);
     }
   }
@@ -66614,7 +66884,7 @@ var OpenAILogger = class {
       await fs4.writeFile(filePath, JSON.stringify(logData, null, 2), "utf-8");
       return filePath;
     } catch (writeError) {
-      debugLogger6.error("Failed to write OpenAI log file:", writeError);
+      debugLogger7.error("Failed to write OpenAI log file:", writeError);
       throw new Error(`Failed to write OpenAI log file: ${writeError}`);
     }
   }
@@ -66635,7 +66905,7 @@ var OpenAILogger = class {
       if (error.code === "ENOENT") {
         return [];
       }
-      debugLogger6.error("Failed to read OpenAI log directory:", error);
+      debugLogger7.error("Failed to read OpenAI log directory:", error);
       return [];
     }
   }
@@ -66649,7 +66919,7 @@ var OpenAILogger = class {
       const content = await fs4.readFile(filePath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
-      debugLogger6.error(`Failed to read log file ${filePath}:`, error);
+      debugLogger7.error(`Failed to read log file ${filePath}:`, error);
       throw new Error(`Failed to read log file: ${error}`);
     }
   }
@@ -66718,8 +66988,8 @@ var FileLogExporter = class extends FileExporter {
   static {
     __name(this, "FileLogExporter");
   }
-  export(logs2, resultCallback) {
-    const data = logs2.map((log) => this.serialize(log)).join("");
+  export(logs3, resultCallback) {
+    const data = logs3.map((log) => this.serialize(log)).join("");
     this.writeStream.write(data, (err) => {
       resultCallback({
         code: err ? import_core3.ExportResultCode.FAILED : import_core3.ExportResultCode.SUCCESS,
@@ -66921,16 +67191,12 @@ function clearDetailedSpanState() {
 __name(clearDetailedSpanState, "clearDetailedSpanState");
 
 // packages/core/src/telemetry/session-tracing.ts
-var debugLogger7 = createDebugLogger("SESSION_TRACING");
+var debugLogger8 = createDebugLogger("SESSION_TRACING");
 function resolveParentContext(parent) {
   if (parent) {
     return trace.setSpan(context.active(), parent.span);
   }
-  const active = context.active();
-  if (trace.getSpan(active)) {
-    return active;
-  }
-  return getSessionContext() ?? active;
+  return context.active();
 }
 __name(resolveParentContext, "resolveParentContext");
 var NOOP_SPAN = trace.wrapSpanContext({
@@ -66946,6 +67212,11 @@ function isInNativeSubagentSpan() {
   return ctx !== void 0 && !ctx.ended;
 }
 __name(isInNativeSubagentSpan, "isInNativeSubagentSpan");
+function resolveSessionId(parentCtx) {
+  const fromParent = parentCtx?.attributes?.["session.id"];
+  return typeof fromParent === "string" && fromParent ? fromParent : getCurrentSessionId();
+}
+__name(resolveSessionId, "resolveSessionId");
 var activeSpans = /* @__PURE__ */ new Map();
 var strongSpans = /* @__PURE__ */ new Map();
 var interactionSequence = 0;
@@ -67001,18 +67272,18 @@ function sweepStaleSpans(now) {
           } : {}
         });
       } catch (error) {
-        debugLogger7.warn(
+        debugLogger8.warn(
           `Failed to stamp TTL attrs on stale span ${spanId}: ${error instanceof Error ? error.message : String(error)}`
         );
       }
       const ctxLabel = toolName && callId ? `${ctx.type} (tool.name=${toolName}, tool.call_id=${callId})` : ctx.type;
-      debugLogger7.warn(
+      debugLogger8.warn(
         `Stale ${ctxLabel} span ended by TTL safety net (age=${ageMs}ms, spanId=${spanId})`
       );
       try {
         ctx.span.end();
       } catch (error) {
-        debugLogger7.warn(
+        debugLogger8.warn(
           `Failed to end stale span ${spanId}: ${error instanceof Error ? error.message : String(error)}`
         );
       }
@@ -67060,11 +67331,10 @@ function startInteractionSpan(config, options) {
     "qwen-code.approval_mode": config.getApprovalMode(),
     "interaction.sequence": interactionSequence
   };
-  const sessionCtx = getSessionContext() ?? context.active();
   const span = getTracer().startSpan(
     SPAN_INTERACTION,
     { kind: SpanKind.INTERNAL, attributes },
-    sessionCtx
+    ROOT_CONTEXT
   );
   const spanId = getSpanId(span);
   const spanContextObj = {
@@ -67083,7 +67353,7 @@ function endInteractionSpan(status, metadata) {
   const spanCtx = interactionContext.getStore() ?? lastInteractionCtx;
   if (!spanCtx) return;
   if (spanCtx.ended) {
-    debugLogger7.debug(
+    debugLogger8.debug(
       `endInteractionSpan: span ${getSpanId(spanCtx.span)} already ended (possible TTL sweep race)`
     );
     return;
@@ -67110,13 +67380,90 @@ function endInteractionSpan(status, metadata) {
   interactionContext.enterWith(void 0);
 }
 __name(endInteractionSpan, "endInteractionSpan");
+async function withInteractionSpan(config, options, fn, getResultStatus) {
+  if (!isTelemetrySdkInitialized()) return await fn();
+  ensureCleanupInterval();
+  interactionSequence++;
+  const attributes = {
+    "session.id": config.getSessionId(),
+    "qwen-code.prompt_id": options.promptId,
+    "qwen-code.message_type": options.messageType,
+    "qwen-code.model": options.model,
+    "qwen-code.approval_mode": config.getApprovalMode(),
+    "interaction.sequence": interactionSequence
+  };
+  const parentContext = options.parentContext ?? ROOT_CONTEXT;
+  const span = getTracer().startSpan(
+    SPAN_INTERACTION,
+    {
+      kind: SpanKind.INTERNAL,
+      attributes
+    },
+    parentContext
+  );
+  const spanId = getSpanId(span);
+  const spanContextObj = {
+    span,
+    startTime: Date.now(),
+    attributes,
+    type: "interaction"
+  };
+  activeSpans.set(spanId, new WeakRef(spanContextObj));
+  strongSpans.set(spanId, spanContextObj);
+  const activeContext = trace.setSpan(parentContext, span);
+  return await context.with(
+    activeContext,
+    async () => interactionContext.run(spanContextObj, async () => {
+      let terminalStatus = "ok";
+      let errorStatusSet = false;
+      try {
+        const result = await fn();
+        terminalStatus = getResultStatus?.(result) ?? "ok";
+        return result;
+      } catch (error) {
+        terminalStatus = "error";
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: truncateSpanError(
+            error instanceof Error ? error.message : String(error)
+          )
+        });
+        errorStatusSet = true;
+        throw error;
+      } finally {
+        if (!spanContextObj.ended) {
+          spanContextObj.ended = true;
+          const duration = Date.now() - spanContextObj.startTime;
+          span.setAttributes({
+            "interaction.duration_ms": duration,
+            "qwen-code.turn_status": terminalStatus
+          });
+          if (terminalStatus === "ok") {
+            span.setStatus({ code: SpanStatusCode.OK });
+          } else if (terminalStatus === "error" && !errorStatusSet) {
+            span.setStatus({
+              code: SpanStatusCode.ERROR,
+              message: "interaction error"
+            });
+          }
+          span.end();
+          activeSpans.delete(spanId);
+          strongSpans.delete(spanId);
+        }
+      }
+    })
+  );
+}
+__name(withInteractionSpan, "withInteractionSpan");
 function startLLMRequestSpan(model, promptId) {
   if (!isTelemetrySdkInitialized()) {
     return NOOP_SPAN;
   }
   const parentCtx = subagentContext.getStore() ?? interactionContext.getStore();
   const ctx = resolveParentContext(parentCtx);
+  const sessionId = resolveSessionId(parentCtx);
   const attributes = {
+    ...sessionId ? { "session.id": sessionId } : {},
     "qwen-code.model": model,
     "qwen-code.prompt_id": promptId,
     "llm_request.context": subagentContext.getStore() ? "subagent" : interactionContext.getStore() ? "interaction" : "standalone",
@@ -67147,7 +67494,7 @@ function endLLMRequestSpan(span, metadata) {
   const spanCtx = activeSpans.get(spanId)?.deref();
   if (!spanCtx) return;
   if (spanCtx.ended) {
-    debugLogger7.debug(
+    debugLogger8.debug(
       `endLLMRequestSpan: span ${spanId} already ended (possible TTL sweep race)`
     );
     return;
@@ -67192,6 +67539,30 @@ function endLLMRequestSpan(span, metadata) {
       endAttributes["success"] = metadata.success;
       if (metadata.error !== void 0)
         endAttributes["error"] = truncateSpanError(metadata.error);
+      if (metadata.responseId !== void 0) {
+        endAttributes["response_id"] = metadata.responseId;
+        endAttributes["gen_ai.response.id"] = metadata.responseId;
+      }
+      if (metadata.finishReason !== void 0) {
+        endAttributes["finish_reason"] = metadata.finishReason;
+        endAttributes["gen_ai.response.finish_reasons"] = [
+          metadata.finishReason
+        ];
+      }
+      if (metadata.thoughtsTokenCount !== void 0) {
+        endAttributes["thoughts_token_count"] = metadata.thoughtsTokenCount;
+        endAttributes["gen_ai.usage.reasoning_tokens"] = metadata.thoughtsTokenCount;
+      }
+      if (metadata.subagentName !== void 0) {
+        endAttributes["subagent_name"] = metadata.subagentName;
+      }
+      if (metadata.errorType !== void 0) {
+        endAttributes["error_type"] = metadata.errorType;
+        endAttributes["error.type"] = metadata.errorType;
+      }
+      if (metadata.errorStatusCode !== void 0) {
+        endAttributes["error_status_code"] = metadata.errorStatusCode;
+      }
     }
     spanCtx.span.setAttributes(endAttributes);
     if (metadata === void 0 || metadata.success) {
@@ -67203,14 +67574,14 @@ function endLLMRequestSpan(span, metadata) {
       });
     }
   } catch (error) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       `Failed to update LLM request span attributes/status: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   try {
     spanCtx.span.end();
   } catch (error) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       `Failed to end LLM request span: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -67224,7 +67595,9 @@ function startToolSpan(toolName, attrs) {
   }
   const parentCtx = subagentContext.getStore() ?? interactionContext.getStore();
   const ctx = resolveParentContext(parentCtx);
+  const sessionId = resolveSessionId(parentCtx);
   const attributes = {
+    ...sessionId ? { "session.id": sessionId } : {},
     "tool.name": toolName,
     ...attrs
   };
@@ -67258,7 +67631,7 @@ function endToolSpan(span, metadata) {
   const spanCtx = activeSpans.get(spanId)?.deref();
   if (!spanCtx) return;
   if (spanCtx.ended) {
-    debugLogger7.debug(
+    debugLogger8.debug(
       `endToolSpan: span ${spanId} already ended (possible TTL sweep race)`
     );
     return;
@@ -67285,14 +67658,14 @@ function endToolSpan(span, metadata) {
       }
     }
   } catch (error) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       `Failed to update tool span attributes/status: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   try {
     spanCtx.span.end();
   } catch (error) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       `Failed to end tool span: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -67306,21 +67679,27 @@ function startToolExecutionSpan() {
   }
   const parentCtx = toolContext.getStore();
   if (!parentCtx) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       "startToolExecutionSpan called outside runInToolSpanContext \u2014 span will not be parented to tool span"
     );
   }
   const ctx = resolveParentContext(parentCtx);
+  const sessionId = resolveSessionId(
+    parentCtx ?? interactionContext.getStore()
+  );
   const span = getTracer().startSpan(
     SPAN_TOOL_EXECUTION,
-    { kind: SpanKind.INTERNAL },
+    {
+      kind: SpanKind.INTERNAL,
+      attributes: sessionId ? { "session.id": sessionId } : {}
+    },
     ctx
   );
   const spanId = getSpanId(span);
   const spanContextObj = {
     span,
     startTime: Date.now(),
-    attributes: {},
+    attributes: sessionId ? { "session.id": sessionId } : {},
     type: "tool.execution"
   };
   activeSpans.set(spanId, new WeakRef(spanContextObj));
@@ -67333,7 +67712,7 @@ function endToolExecutionSpan(span, metadata) {
   const spanCtx = activeSpans.get(spanId)?.deref();
   if (!spanCtx) return;
   if (spanCtx.ended) {
-    debugLogger7.debug(
+    debugLogger8.debug(
       `endToolExecutionSpan: span ${spanId} already ended (possible TTL sweep race)`
     );
     return;
@@ -67360,14 +67739,14 @@ function endToolExecutionSpan(span, metadata) {
       }
     }
   } catch (error) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       `Failed to update tool execution span attributes/status: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   try {
     spanCtx.span.end();
   } catch (error) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       `Failed to end tool execution span: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -67383,12 +67762,16 @@ function startToolBlockedOnUserSpan(toolSpan, attrs) {
   const parentSpanId = getSpanId(toolSpan);
   const parentSpanCtx = activeSpans.get(parentSpanId)?.deref();
   if (!parentSpanCtx) {
-    debugLogger7.debug(
+    debugLogger8.debug(
       "startToolBlockedOnUserSpan: tool span not in activeSpans (already ended?) \u2014 using resolveParentContext fallback"
     );
   }
   const ctx = parentSpanCtx ? trace.setSpan(context.active(), parentSpanCtx.span) : resolveParentContext(void 0);
-  const attributes = {};
+  const sessionParentCtx = parentSpanCtx ?? subagentContext.getStore() ?? interactionContext.getStore() ?? void 0;
+  const sessionId = resolveSessionId(sessionParentCtx);
+  const attributes = {
+    ...sessionId ? { "session.id": sessionId } : {}
+  };
   if (attrs?.tool_name !== void 0) attributes["tool.name"] = attrs.tool_name;
   if (attrs?.call_id !== void 0) attributes["tool.call_id"] = attrs.call_id;
   const span = getTracer().startSpan(
@@ -67413,7 +67796,7 @@ function endToolBlockedOnUserSpan(span, metadata) {
   const spanCtx = activeSpans.get(spanId)?.deref();
   if (!spanCtx) return;
   if (spanCtx.ended) {
-    debugLogger7.debug(
+    debugLogger8.debug(
       `endToolBlockedOnUserSpan: span ${spanId} already ended (possible TTL sweep race)`
     );
     return;
@@ -67428,14 +67811,14 @@ function endToolBlockedOnUserSpan(span, metadata) {
       endAttributes["source"] = metadata.source;
     spanCtx.span.setAttributes(endAttributes);
   } catch (error) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       `Failed to update blocked_on_user span attributes: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   try {
     spanCtx.span.end();
   } catch (error) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       `Failed to end blocked_on_user span: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -67450,7 +67833,9 @@ function startHookSpan(opts) {
   ensureCleanupInterval();
   const parentCtx = toolContext.getStore() ?? subagentContext.getStore() ?? interactionContext.getStore() ?? void 0;
   const ctx = resolveParentContext(parentCtx);
+  const sessionId = resolveSessionId(parentCtx);
   const attributes = {
+    ...sessionId ? { "session.id": sessionId } : {},
     hook_event: opts.hookEvent,
     "tool.name": opts.toolName
   };
@@ -67479,7 +67864,7 @@ function endHookSpan(span, metadata) {
   const spanCtx = activeSpans.get(spanId)?.deref();
   if (!spanCtx) return;
   if (spanCtx.ended) {
-    debugLogger7.debug(
+    debugLogger8.debug(
       `endHookSpan: span ${spanId} already ended (possible TTL sweep race)`
     );
     return;
@@ -67516,14 +67901,14 @@ function endHookSpan(span, metadata) {
       });
     }
   } catch (error) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       `Failed to update hook span attributes/status: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   try {
     spanCtx.span.end();
   } catch (error) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       `Failed to end hook span: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -67606,14 +67991,14 @@ function endSubagentSpan(span, metadata) {
   const spanCtx = activeSpans.get(spanId)?.deref();
   if (!spanCtx) {
     if (isTelemetrySdkInitialized()) {
-      debugLogger7.warn(
+      debugLogger8.warn(
         `endSubagentSpan: span ${spanId} not found in activeSpans (already swept?) \u2014 intended status=${metadata.status}, reason=${metadata.terminateReason ?? "none"}`
       );
     }
     return;
   }
   if (spanCtx.ended) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       `endSubagentSpan: span ${spanId} already ended \u2014 intended status=${metadata.status}, reason=${metadata.terminateReason ?? "none"} (possible TTL sweep race)`
     );
     return;
@@ -67649,14 +68034,14 @@ function endSubagentSpan(span, metadata) {
       });
     }
   } catch (error) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       `Failed to update subagent span attributes/status: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   try {
     spanCtx.span.end();
   } catch (error) {
-    debugLogger7.warn(
+    debugLogger8.warn(
       `Failed to end subagent span: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -67984,7 +68369,7 @@ __name(hrTimeDiff, "hrTimeDiff");
 init_esbuild_shims();
 init_esm();
 var tracer = trace.getTracer(SERVICE_NAME);
-var debugLogger8 = createDebugLogger("OTEL_TRACER");
+var debugLogger9 = createDebugLogger("OTEL_TRACER");
 var TELEMETRY_WARNING_INTERVAL_MS = 3e4;
 var API_CALL_FAILED_SPAN_STATUS_MESSAGE = "API call failed";
 var API_CALL_ABORTED_SPAN_STATUS_MESSAGE = "API call aborted";
@@ -68000,7 +68385,7 @@ function warnTelemetryOperationFailed(operation, error) {
   suppressedTelemetryWarnings = 0;
   lastTelemetryWarningMs = now;
   try {
-    debugLogger8.warn(
+    debugLogger9.warn(
       `OTel span ${operation} failed: ${error instanceof Error ? error.message : String(error)}${suppressedSuffix}`
     );
   } catch {
@@ -68039,13 +68424,13 @@ __name(createSessionRootContext, "createSessionRootContext");
 
 // packages/core/src/telemetry/sdk.ts
 function createTelemetryDiagLogger() {
-  const debugLogger12 = createDebugLogger("OTEL");
+  const debugLogger13 = createDebugLogger("OTEL");
   return {
-    error: /* @__PURE__ */ __name((message, ...args) => debugLogger12.error(message, ...args), "error"),
-    warn: /* @__PURE__ */ __name((message, ...args) => debugLogger12.warn(message, ...args), "warn"),
-    info: /* @__PURE__ */ __name((message, ...args) => debugLogger12.info(message, ...args), "info"),
-    debug: /* @__PURE__ */ __name((message, ...args) => debugLogger12.debug(message, ...args), "debug"),
-    verbose: /* @__PURE__ */ __name((message, ...args) => debugLogger12.debug(message, ...args), "verbose")
+    error: /* @__PURE__ */ __name((message, ...args) => debugLogger13.error(message, ...args), "error"),
+    warn: /* @__PURE__ */ __name((message, ...args) => debugLogger13.warn(message, ...args), "warn"),
+    info: /* @__PURE__ */ __name((message, ...args) => debugLogger13.info(message, ...args), "info"),
+    debug: /* @__PURE__ */ __name((message, ...args) => debugLogger13.debug(message, ...args), "debug"),
+    verbose: /* @__PURE__ */ __name((message, ...args) => debugLogger13.debug(message, ...args), "verbose")
   };
 }
 __name(createTelemetryDiagLogger, "createTelemetryDiagLogger");
@@ -68080,6 +68465,7 @@ var NOOP_PROPAGATOR = {
 var sdk;
 var telemetryInitialized = false;
 var telemetryShutdownPromise;
+var activeMetricReader;
 function isTelemetrySdkInitialized() {
   return telemetryInitialized;
 }
@@ -68122,11 +68508,32 @@ function validateUrl(url) {
   }
 }
 __name(validateUrl, "validateUrl");
+var SessionIdSpanProcessor = class {
+  static {
+    __name(this, "SessionIdSpanProcessor");
+  }
+  onStart(span) {
+    try {
+      if (span.attributes?.["session.id"]) return;
+      const sessionId = getCurrentSessionId();
+      if (sessionId) {
+        span.setAttribute("session.id", sessionId);
+      }
+    } catch {
+    }
+  }
+  onEnd(_span) {
+  }
+  async shutdown() {
+  }
+  async forceFlush() {
+  }
+};
 function initializeTelemetry(config) {
   if (telemetryInitialized || !config.getTelemetryEnabled()) {
     return;
   }
-  const debugLogger12 = createDebugLogger("OTEL");
+  const debugLogger13 = createDebugLogger("OTEL");
   const userAttrs = config.getTelemetryResourceAttributes() ?? {};
   const userServiceName = userAttrs["service.name"];
   const {
@@ -68175,7 +68582,7 @@ function initializeTelemetry(config) {
       const metricsUrl = validateUrl(
         config.getTelemetryOtlpMetricsEndpoint() ?? (parsedEndpoint ? resolveHttpOtlpUrl(parsedEndpoint, "metrics") : void 0)
       );
-      debugLogger12.debug(
+      debugLogger13.debug(
         `OTLP HTTP endpoints: traces=${tracesUrl ?? "none"}, logs=${logsUrl ?? "none"}, metrics=${metricsUrl ?? "none"}`
       );
       if (tracesUrl) {
@@ -68191,7 +68598,7 @@ function initializeTelemetry(config) {
             // In interactive (TUI) mode, route bridge diagnostics to the OTEL
             // debug log file so they don't break out of the Ink render area
             // via raw stderr. In non-interactive mode, leave the default sink
-            // alone so CI / scripts can still see export failures on stderr —
+            // alone so CI / scripts can still see export failures on stderr
             // the canonical diagnostic channel for batch runs.
             //
             // Caveat for interactive mode: when the user has explicitly
@@ -68200,7 +68607,7 @@ function initializeTelemetry(config) {
             // trade-off, since falling back to stderr would re-introduce the
             // TUI pollution this injection was added to prevent.
             ...config.isInteractive() && {
-              diagnosticsSink: /* @__PURE__ */ __name((message) => debugLogger12.warn(message), "diagnosticsSink")
+              diagnosticsSink: /* @__PURE__ */ __name((message) => debugLogger13.warn(message), "diagnosticsSink")
             }
           }
         );
@@ -68215,7 +68622,7 @@ function initializeTelemetry(config) {
       if (!parsedEndpoint) {
         const warning = 'Per-signal OTLP endpoints are only supported with HTTP protocol. Set otlpProtocol to "http" or provide a base otlpEndpoint for gRPC. Telemetry SDK startup was skipped because no supported gRPC endpoint was configured.';
         diag.warn(warning);
-        debugLogger12.warn(warning);
+        debugLogger13.warn(warning);
         return;
       } else {
         spanExporter = new import_exporter_trace_otlp_grpc.OTLPTraceExporter({
@@ -68292,15 +68699,14 @@ function initializeTelemetry(config) {
     // before the detectors settle (e.g. during HttpInstrumentation span creation).
     autoDetectResources: false,
     ...textMapPropagator && { textMapPropagator },
-    spanProcessors: spanExporter ? [new import_sdk_trace_node.BatchSpanProcessor(spanExporter)] : [],
+    spanProcessors: spanExporter ? [new SessionIdSpanProcessor(), new import_sdk_trace_node.BatchSpanProcessor(spanExporter)] : [],
     logRecordProcessors: logExporter ? [new import_sdk_logs.BatchLogRecordProcessor(logExporter)] : logToSpanProcessor ? [logToSpanProcessor] : [],
     ...metricReader && { metricReader },
     instrumentations: [
       new import_instrumentation_http.HttpInstrumentation({
         // OTLP HTTP exporter uses node:http (patched here, not by undici).
         // Without this, every OTLP upload batch creates a parasitic client
-        // span that itself gets exported → feedback loop. See PR #4390
-        // review feedback (wenshao).
+        // span that itself gets exported → feedback loop.
         ignoreOutgoingRequestHook: /* @__PURE__ */ __name((req) => {
           if (otlpUrlPrefixes.length === 0) return false;
           const proto = req.protocol ? String(req.protocol).replace(/:$/, "") : void 0;
@@ -68338,8 +68744,9 @@ function initializeTelemetry(config) {
   });
   try {
     sdk.start();
-    debugLogger12.debug("OpenTelemetry SDK started successfully.");
+    debugLogger13.debug("OpenTelemetry SDK started successfully.");
     telemetryInitialized = true;
+    activeMetricReader = metricReader;
     const sessionId = config.getSessionId();
     setSessionContext(createSessionRootContext(sessionId), sessionId);
     setShellTracePropagation(
@@ -68347,7 +68754,7 @@ function initializeTelemetry(config) {
     );
     initializeMetrics(config);
   } catch (error) {
-    debugLogger12.error("Error starting OpenTelemetry SDK:", error);
+    debugLogger13.error("Error starting OpenTelemetry SDK:", error);
   }
 }
 __name(initializeTelemetry, "initializeTelemetry");
@@ -68369,7 +68776,7 @@ async function shutdownTelemetry() {
   }
   endInteractionSpan("cancelled");
   const currentSdk = sdk;
-  const debugLogger12 = createDebugLogger("OTEL");
+  const debugLogger13 = createDebugLogger("OTEL");
   telemetryShutdownPromise = (async () => {
     let timer;
     let timedOut = false;
@@ -68377,7 +68784,7 @@ async function shutdownTelemetry() {
       const sdkShutdown = Promise.resolve(currentSdk.shutdown());
       sdkShutdown.catch((err) => {
         if (timedOut) {
-          debugLogger12.warn(
+          debugLogger13.warn(
             "SDK shutdown rejected after timeout:",
             err instanceof Error ? err.message : err
           );
@@ -68395,17 +68802,18 @@ async function shutdownTelemetry() {
       if (result === "timeout") {
         const msg = `Telemetry shutdown timed out after ${SHUTDOWN_TIMEOUT_MS}ms.`;
         diag.warn(msg);
-        debugLogger12.warn(msg);
+        debugLogger13.warn(msg);
       } else {
-        debugLogger12.debug("OpenTelemetry SDK shut down successfully.");
+        debugLogger13.debug("OpenTelemetry SDK shut down successfully.");
       }
     } catch (error) {
       clearTimeout(timer);
       diag.error("Error shutting down SDK:", error);
-      debugLogger12.error("Error shutting down SDK:", error);
+      debugLogger13.error("Error shutting down SDK:", error);
     } finally {
       telemetryInitialized = false;
       sdk = void 0;
+      activeMetricReader = void 0;
       telemetryShutdownPromise = void 0;
       setSessionContext(void 0);
       setShellTracePropagation(false);
@@ -68414,6 +68822,31 @@ async function shutdownTelemetry() {
   return telemetryShutdownPromise;
 }
 __name(shutdownTelemetry, "shutdownTelemetry");
+var FORCE_FLUSH_TIMEOUT_MS = 2e3;
+async function forceFlushMetrics() {
+  if (!telemetryInitialized || !activeMetricReader) return;
+  const flush = activeMetricReader.forceFlush();
+  flush.catch(() => {
+  });
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(
+        new Error(
+          `forceFlushMetrics timed out after ${FORCE_FLUSH_TIMEOUT_MS}ms`
+        )
+      ),
+      FORCE_FLUSH_TIMEOUT_MS
+    );
+    timer.unref?.();
+  });
+  try {
+    await Promise.race([flush, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+__name(forceFlushMetrics, "forceFlushMetrics");
 
 // packages/core/src/telemetry/config.ts
 init_esbuild_shims();
@@ -68655,27 +69088,24 @@ var createInitialMetrics = /* @__PURE__ */ __name(() => ({
     totalLinesRemoved: 0
   }
 }), "createInitialMetrics");
-var UiTelemetryService = class extends EventEmitter {
+var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
   static {
     __name(this, "UiTelemetryService");
   }
+  static #MAX_CLOSED_SESSIONS = 1e3;
   #metrics = createInitialMetrics();
+  #sessionMetrics = /* @__PURE__ */ new Map();
+  #closedSessions = /* @__PURE__ */ new Set();
   #lastPromptTokenCount = 0;
   #lastCachedContentTokenCount = 0;
   #sessionStartTime = /* @__PURE__ */ new Date();
-  addEvent(event) {
-    switch (event["event.name"]) {
-      case EVENT_API_RESPONSE:
-        this.processApiResponse(event);
-        break;
-      case EVENT_API_ERROR:
-        this.processApiError(event);
-        break;
-      case EVENT_TOOL_CALL:
-        this.processToolCall(event);
-        break;
-      default:
-        return;
+  addEvent(event, sessionId) {
+    if (!this.#accumulateEvent(this.#metrics, event)) return;
+    if (sessionId && !this.#closedSessions.has(sessionId)) {
+      if (!this.#sessionMetrics.has(sessionId)) {
+        this.#sessionMetrics.set(sessionId, createInitialMetrics());
+      }
+      this.#accumulateEvent(this.#sessionMetrics.get(sessionId), event);
     }
     this.emit("update", {
       metrics: this.#metrics,
@@ -68685,6 +69115,9 @@ var UiTelemetryService = class extends EventEmitter {
   getMetrics() {
     return this.#metrics;
   }
+  getMetricsForSession(sessionId) {
+    return this.#sessionMetrics.get(sessionId) ?? createInitialMetrics();
+  }
   getLastPromptTokenCount() {
     return this.#lastPromptTokenCount;
   }
@@ -68709,6 +69142,8 @@ var UiTelemetryService = class extends EventEmitter {
    */
   reset() {
     this.#metrics = createInitialMetrics();
+    this.#sessionMetrics.clear();
+    this.#closedSessions.clear();
     this.#lastPromptTokenCount = 0;
     this.#lastCachedContentTokenCount = 0;
     this.#sessionStartTime = /* @__PURE__ */ new Date();
@@ -68717,21 +69152,36 @@ var UiTelemetryService = class extends EventEmitter {
       lastPromptTokenCount: this.#lastPromptTokenCount
     });
   }
-  getOrCreateModelMetrics(modelName) {
-    if (!this.#metrics.models[modelName]) {
-      this.#metrics.models[modelName] = createInitialModelMetrics();
+  resetSession(sessionId) {
+    this.#sessionMetrics.set(sessionId, createInitialMetrics());
+    this.#closedSessions.delete(sessionId);
+  }
+  removeSession(sessionId) {
+    this.#sessionMetrics.delete(sessionId);
+    this.#closedSessions.add(sessionId);
+    if (this.#closedSessions.size > _UiTelemetryService.#MAX_CLOSED_SESSIONS) {
+      const oldest = this.#closedSessions.values().next().value;
+      if (oldest) this.#closedSessions.delete(oldest);
     }
-    return this.#metrics.models[modelName];
   }
-  getOrCreateSourceMetrics(modelMetrics, source) {
-    if (!modelMetrics.bySource[source]) {
-      modelMetrics.bySource[source] = createInitialModelMetricsCore();
+  #accumulateEvent(metrics2, event) {
+    switch (event["event.name"]) {
+      case EVENT_API_RESPONSE:
+        this.#accumulateApiResponse(metrics2, event);
+        return true;
+      case EVENT_API_ERROR:
+        this.#accumulateApiError(metrics2, event);
+        return true;
+      case EVENT_TOOL_CALL:
+        this.#accumulateToolCall(metrics2, event);
+        return true;
+      default:
+        return false;
     }
-    return modelMetrics.bySource[source];
   }
-  processApiResponse(event) {
-    const modelMetrics = this.getOrCreateModelMetrics(event.model);
-    const sourceMetrics = this.getOrCreateSourceMetrics(
+  #accumulateApiResponse(metrics2, event) {
+    const modelMetrics = this.#getOrCreateModelMetrics(metrics2, event.model);
+    const sourceMetrics = this.#getOrCreateSourceMetrics(
       modelMetrics,
       event.subagent_name ?? MAIN_SOURCE
     );
@@ -68745,9 +69195,9 @@ var UiTelemetryService = class extends EventEmitter {
       bucket.tokens.thoughts += event.thoughts_token_count;
     }
   }
-  processApiError(event) {
-    const modelMetrics = this.getOrCreateModelMetrics(event.model);
-    const sourceMetrics = this.getOrCreateSourceMetrics(
+  #accumulateApiError(metrics2, event) {
+    const modelMetrics = this.#getOrCreateModelMetrics(metrics2, event.model);
+    const sourceMetrics = this.#getOrCreateSourceMetrics(
       modelMetrics,
       event.subagent_name ?? MAIN_SOURCE
     );
@@ -68757,8 +69207,8 @@ var UiTelemetryService = class extends EventEmitter {
       bucket.api.totalLatencyMs += event.duration_ms;
     }
   }
-  processToolCall(event) {
-    const { tools, files } = this.#metrics;
+  #accumulateToolCall(metrics2, event) {
+    const { tools, files } = metrics2;
     tools.totalCalls++;
     tools.totalDurationMs += event.duration_ms;
     if (event.success) {
@@ -68801,9 +69251,476 @@ var UiTelemetryService = class extends EventEmitter {
       }
     }
   }
+  #getOrCreateModelMetrics(metrics2, modelName) {
+    if (!metrics2.models[modelName]) {
+      metrics2.models[modelName] = createInitialModelMetrics();
+    }
+    return metrics2.models[modelName];
+  }
+  #getOrCreateSourceMetrics(modelMetrics, source) {
+    if (!modelMetrics.bySource[source]) {
+      modelMetrics.bySource[source] = createInitialModelMetricsCore();
+    }
+    return modelMetrics.bySource[source];
+  }
 };
 var uiTelemetryService = new UiTelemetryService();
 
+// packages/core/src/telemetry/daemon-tracing.ts
+init_esbuild_shims();
+init_esm();
+var import_api_logs = __toESM(require_src2(), 1);
+import { createHash as createHash3 } from "node:crypto";
+var DAEMON_TRACEPARENT_META_KEY = "qwen.telemetry.traceparent";
+var DAEMON_TRACESTATE_META_KEY = "qwen.telemetry.tracestate";
+var SPAN_DAEMON_REQUEST = "qwen-code.daemon.request";
+var SPAN_DAEMON_BRIDGE = "qwen-code.daemon.bridge";
+var EVENT_DAEMON_ERROR = "qwen-code.daemon.error";
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+__name(errorMessage, "errorMessage");
+function errorType(error) {
+  if (error instanceof Error) return error.name || "Error";
+  return typeof error;
+}
+__name(errorType, "errorType");
+var INVALID_TRACE_ID = "0".repeat(32);
+var INVALID_SPAN_ID = "0".repeat(16);
+function stripReservedTraceMeta(meta) {
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) return {};
+  const record = meta;
+  if (!(DAEMON_TRACEPARENT_META_KEY in record) && !(DAEMON_TRACESTATE_META_KEY in record)) {
+    return { ...record };
+  }
+  const out = { ...record };
+  delete out[DAEMON_TRACEPARENT_META_KEY];
+  delete out[DAEMON_TRACESTATE_META_KEY];
+  return out;
+}
+__name(stripReservedTraceMeta, "stripReservedTraceMeta");
+function hashDaemonWorkspace(workspace) {
+  return createHash3("sha256").update(workspace).digest("hex").slice(0, 16);
+}
+__name(hashDaemonWorkspace, "hashDaemonWorkspace");
+async function withDaemonSpan(name, attributes, fn, options = {}) {
+  if (!isTelemetrySdkInitialized()) {
+    return await fn(void 0);
+  }
+  const autoOkOnSuccess = options.autoOkOnSuccess ?? true;
+  const tracer2 = trace.getTracer(SERVICE_NAME);
+  return await tracer2.startActiveSpan(
+    name,
+    { kind: SpanKind.INTERNAL, attributes },
+    async (span) => {
+      try {
+        const result = await fn(span);
+        if (autoOkOnSuccess) {
+          span.setStatus({ code: SpanStatusCode.OK });
+        }
+        return result;
+      } catch (error) {
+        recordDaemonError(span, error);
+        throw error;
+      } finally {
+        span.end();
+      }
+    }
+  );
+}
+__name(withDaemonSpan, "withDaemonSpan");
+async function withDaemonRequestSpan(options, fn) {
+  return await withDaemonSpan(
+    SPAN_DAEMON_REQUEST,
+    {
+      "http.request.method": options.method,
+      "http.route": options.route,
+      "qwen-code.daemon.operation": "http_request",
+      ...options.workspaceHash ? { "qwen-code.workspace.hash": options.workspaceHash } : {},
+      ...options.sessionId ? { "session.id": options.sessionId } : {},
+      ...options.clientId ? { "qwen-code.client_id": options.clientId } : {},
+      ...options.permissionRequestId ? {
+        "qwen-code.daemon.permission.request_id": options.permissionRequestId
+      } : {}
+    },
+    fn,
+    { autoOkOnSuccess: false }
+  );
+}
+__name(withDaemonRequestSpan, "withDaemonRequestSpan");
+async function withDaemonBridgeSpan(operation, attributes, fn) {
+  return await withDaemonSpan(
+    SPAN_DAEMON_BRIDGE,
+    {
+      "qwen-code.daemon.operation": operation,
+      ...attributes
+    },
+    async () => await fn()
+  );
+}
+__name(withDaemonBridgeSpan, "withDaemonBridgeSpan");
+function recordDaemonHttpResponse(span, statusCode) {
+  try {
+    span?.setAttribute("http.response.status_code", statusCode);
+  } catch {
+  }
+}
+__name(recordDaemonHttpResponse, "recordDaemonHttpResponse");
+function addDaemonRequestAttribute(key, value) {
+  try {
+    trace.getSpan(context.active())?.setAttribute(key, value);
+  } catch {
+  }
+}
+__name(addDaemonRequestAttribute, "addDaemonRequestAttribute");
+function recordDaemonError(span, error, attributes = {}) {
+  const target = span ?? trace.getSpan(context.active());
+  if (!target) return;
+  try {
+    const message = truncateSpanError(errorMessage(error));
+    target.recordException(error instanceof Error ? error : new Error(message));
+    target.setAttributes({
+      "error.type": errorType(error),
+      "error.message": message,
+      ...attributes
+    });
+    target.setStatus({ code: SpanStatusCode.ERROR, message });
+  } catch {
+  }
+}
+__name(recordDaemonError, "recordDaemonError");
+function emitDaemonLog(body, attributes = {}, options) {
+  if (!isTelemetrySdkInitialized()) return;
+  try {
+    import_api_logs.logs.getLogger(SERVICE_NAME).emit({
+      body,
+      timestamp: /* @__PURE__ */ new Date(),
+      attributes: {
+        "event.name": options?.eventName ?? EVENT_DAEMON_ERROR,
+        ...attributes
+      },
+      ...options?.severityNumber != null ? { severityNumber: options.severityNumber } : {}
+    });
+  } catch {
+  }
+}
+__name(emitDaemonLog, "emitDaemonLog");
+function captureDaemonTelemetryContext() {
+  return { context: context.active() };
+}
+__name(captureDaemonTelemetryContext, "captureDaemonTelemetryContext");
+async function runWithDaemonTelemetryContext(captured, fn) {
+  const ctx = captured && typeof captured === "object" && "context" in captured && captured.context ? captured.context : void 0;
+  if (!ctx) return await fn();
+  return await context.with(ctx, fn);
+}
+__name(runWithDaemonTelemetryContext, "runWithDaemonTelemetryContext");
+function injectDaemonTraceContext(request4) {
+  const currentMeta = request4._meta;
+  const nextMeta = stripReservedTraceMeta(currentMeta);
+  try {
+    const ctx = getActiveSpanTraceContext();
+    if (ctx) {
+      nextMeta[DAEMON_TRACEPARENT_META_KEY] = formatTraceparent(ctx);
+    }
+  } catch {
+  }
+  if (!currentMeta && !nextMeta[DAEMON_TRACEPARENT_META_KEY]) {
+    return request4;
+  }
+  return {
+    ...request4,
+    _meta: nextMeta
+  };
+}
+__name(injectDaemonTraceContext, "injectDaemonTraceContext");
+function extractDaemonTraceContext(source) {
+  const meta = source?._meta;
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+    return void 0;
+  }
+  const record = meta;
+  const traceparent = record[DAEMON_TRACEPARENT_META_KEY];
+  if (typeof traceparent !== "string" || traceparent.length === 0) {
+    return void 0;
+  }
+  const carrier = { traceparent };
+  const tracestate = record[DAEMON_TRACESTATE_META_KEY];
+  if (typeof tracestate === "string" && tracestate.length > 0) {
+    carrier["tracestate"] = tracestate;
+  }
+  const extracted = propagation.extract(ROOT_CONTEXT, carrier);
+  if (trace.getSpanContext(extracted)) return extracted;
+  const parts = traceparent.split("-");
+  const traceId = parts[1];
+  const spanId = parts[2];
+  const flags = parts[3];
+  if (parts[0] !== "00" || !traceId?.match(/^[0-9a-f]{32}$/) || !spanId?.match(/^[0-9a-f]{16}$/) || !flags?.match(/^[0-9a-f]{2}$/) || traceId === INVALID_TRACE_ID || spanId === INVALID_SPAN_ID) {
+    return void 0;
+  }
+  return trace.setSpan(
+    ROOT_CONTEXT,
+    trace.wrapSpanContext({
+      traceId,
+      spanId,
+      traceFlags: Number.parseInt(flags, 16),
+      isRemote: true
+    })
+  );
+}
+__name(extractDaemonTraceContext, "extractDaemonTraceContext");
+function createDaemonBridgeTelemetry() {
+  return {
+    captureContext: captureDaemonTelemetryContext,
+    runWithContext: runWithDaemonTelemetryContext,
+    withSpan: withDaemonBridgeSpan,
+    event(name, attributes) {
+      if (!isTelemetrySdkInitialized()) return;
+      try {
+        const activeSpan = trace.getSpan(context.active());
+        if (activeSpan) {
+          activeSpan.addEvent(name, attributes);
+          return;
+        }
+        const span = trace.getTracer(SERVICE_NAME).startSpan(SPAN_DAEMON_BRIDGE, {
+          kind: SpanKind.INTERNAL,
+          attributes: {
+            "event.name": name,
+            "qwen-code.daemon.operation": `event.${name}`,
+            ...attributes
+          }
+        });
+        span.addEvent(name, attributes);
+        span.setStatus({ code: SpanStatusCode.OK });
+        span.end();
+      } catch {
+      }
+    },
+    injectPromptContext: injectDaemonTraceContext
+  };
+}
+__name(createDaemonBridgeTelemetry, "createDaemonBridgeTelemetry");
+
+// packages/core/src/telemetry/daemon-metrics.ts
+init_esbuild_shims();
+init_esm();
+var DAEMON_HTTP_REQUEST_COUNT = `${SERVICE_NAME}.daemon.http.request.count`;
+var DAEMON_HTTP_REQUEST_DURATION = `${SERVICE_NAME}.daemon.http.request.duration`;
+var DAEMON_SESSION_ACTIVE = `${SERVICE_NAME}.daemon.session.active`;
+var DAEMON_SESSION_LIFECYCLE = `${SERVICE_NAME}.daemon.session.lifecycle`;
+var DAEMON_CHANNEL_LIFECYCLE = `${SERVICE_NAME}.daemon.channel.lifecycle`;
+var DAEMON_PROMPT_QUEUE_WAIT = `${SERVICE_NAME}.daemon.prompt.queue_wait`;
+var DAEMON_PROMPT_DURATION = `${SERVICE_NAME}.daemon.prompt.duration`;
+var DAEMON_BRIDGE_ERROR_COUNT = `${SERVICE_NAME}.daemon.bridge.error.count`;
+var DAEMON_CANCEL_COUNT = `${SERVICE_NAME}.daemon.cancel.count`;
+var DAEMON_SSE_ACTIVE = `${SERVICE_NAME}.daemon.sse.active`;
+var DAEMON_PROCESS_HEAP_USED = `${SERVICE_NAME}.daemon.process.heap_used`;
+var KNOWN_ERROR_TYPES = /* @__PURE__ */ new Set([
+  "SessionNotFoundError",
+  "WorkspaceMismatchError",
+  "InvalidClientIdError",
+  "SessionLimitExceededError",
+  "RestoreInProgressError",
+  "InvalidSessionScopeError",
+  "TrustGateError",
+  "WorkspaceInitConflictError",
+  "WorkspaceInitPathEscapeError",
+  "WorkspaceInitSymlinkError",
+  "WorkspaceInitRaceError",
+  "McpServerNotFoundError",
+  "McpServerRestartFailedError",
+  "PromptDeadlineExceededError",
+  "InvalidSessionMetadataError",
+  "SubscriberLimitExceededError",
+  "BridgeChannelClosedError",
+  "BridgeTimeoutError",
+  "PermissionForbiddenError"
+]);
+var initialized = false;
+var httpRequestCounter;
+var httpRequestDurationHistogram;
+var sessionLifecycleCounter;
+var channelLifecycleCounter;
+var promptQueueWaitHistogram;
+var promptDurationHistogram;
+var bridgeErrorCounter;
+var cancelCounter;
+function normalizeErrorType(err) {
+  const name = err instanceof Error ? err.name : typeof err;
+  return KNOWN_ERROR_TYPES.has(name) ? name : "unknown";
+}
+__name(normalizeErrorType, "normalizeErrorType");
+function initializeDaemonMetrics() {
+  if (initialized) return;
+  const meter = getMeter();
+  if (!meter) return;
+  httpRequestCounter = meter.createCounter(DAEMON_HTTP_REQUEST_COUNT, {
+    description: "Daemon HTTP request count by route and status class.",
+    valueType: ValueType.INT
+  });
+  httpRequestDurationHistogram = meter.createHistogram(
+    DAEMON_HTTP_REQUEST_DURATION,
+    {
+      description: "Daemon HTTP request duration in milliseconds.",
+      unit: "ms",
+      valueType: ValueType.DOUBLE,
+      advice: {
+        explicitBucketBoundaries: [
+          1,
+          2,
+          5,
+          10,
+          25,
+          50,
+          100,
+          250,
+          500,
+          1e3,
+          2500,
+          5e3,
+          1e4,
+          3e4
+        ]
+      }
+    }
+  );
+  sessionLifecycleCounter = meter.createCounter(DAEMON_SESSION_LIFECYCLE, {
+    description: "Daemon session lifecycle events (spawn, close, die).",
+    valueType: ValueType.INT
+  });
+  channelLifecycleCounter = meter.createCounter(DAEMON_CHANNEL_LIFECYCLE, {
+    description: "Daemon ACP channel lifecycle events (spawn, exit).",
+    valueType: ValueType.INT
+  });
+  promptQueueWaitHistogram = meter.createHistogram(DAEMON_PROMPT_QUEUE_WAIT, {
+    description: "Time a prompt waited in the per-session FIFO queue.",
+    unit: "ms",
+    valueType: ValueType.DOUBLE,
+    advice: {
+      explicitBucketBoundaries: [
+        1,
+        5,
+        10,
+        50,
+        100,
+        500,
+        1e3,
+        5e3,
+        1e4,
+        3e4,
+        6e4
+      ]
+    }
+  });
+  promptDurationHistogram = meter.createHistogram(DAEMON_PROMPT_DURATION, {
+    description: "End-to-end prompt duration from dispatch to completion.",
+    unit: "ms",
+    valueType: ValueType.DOUBLE,
+    advice: {
+      explicitBucketBoundaries: [
+        100,
+        500,
+        1e3,
+        2500,
+        5e3,
+        1e4,
+        3e4,
+        6e4,
+        12e4,
+        3e5,
+        6e5
+      ]
+    }
+  });
+  bridgeErrorCounter = meter.createCounter(DAEMON_BRIDGE_ERROR_COUNT, {
+    description: "Daemon bridge error count by normalized error type.",
+    valueType: ValueType.INT
+  });
+  cancelCounter = meter.createCounter(DAEMON_CANCEL_COUNT, {
+    description: "Daemon cancel request count.",
+    valueType: ValueType.INT
+  });
+  initialized = true;
+}
+__name(initializeDaemonMetrics, "initializeDaemonMetrics");
+var gaugesRegistered = false;
+function registerDaemonGaugeCallbacks(callbacks) {
+  if (gaugesRegistered) return;
+  const meter = getMeter();
+  if (!meter) return;
+  meter.createObservableGauge(DAEMON_SESSION_ACTIVE, {
+    description: "Current number of active daemon sessions.",
+    valueType: ValueType.INT
+  }).addCallback((result) => {
+    try {
+      result.observe(callbacks.sessionCount());
+    } catch {
+    }
+  });
+  meter.createObservableGauge(DAEMON_SSE_ACTIVE, {
+    description: "Current number of active SSE connections.",
+    valueType: ValueType.INT
+  }).addCallback((result) => {
+    try {
+      result.observe(callbacks.sseCount());
+    } catch {
+    }
+  });
+  meter.createObservableGauge(DAEMON_PROCESS_HEAP_USED, {
+    description: "Daemon process heap memory usage in bytes.",
+    unit: "bytes",
+    valueType: ValueType.INT
+  }).addCallback((result) => {
+    try {
+      result.observe(callbacks.heapUsed());
+    } catch {
+    }
+  });
+  gaugesRegistered = true;
+}
+__name(registerDaemonGaugeCallbacks, "registerDaemonGaugeCallbacks");
+function recordDaemonHttpRequest(durationMs, route, statusCode) {
+  if (!initialized) return;
+  const statusClass = `${Math.floor(statusCode / 100)}xx`;
+  httpRequestCounter?.add(1, { route, status_class: statusClass });
+  httpRequestDurationHistogram?.record(durationMs, { route });
+}
+__name(recordDaemonHttpRequest, "recordDaemonHttpRequest");
+function recordDaemonSessionLifecycle(action) {
+  if (!initialized) return;
+  sessionLifecycleCounter?.add(1, { action });
+}
+__name(recordDaemonSessionLifecycle, "recordDaemonSessionLifecycle");
+function recordDaemonChannelLifecycle(action, expected) {
+  if (!initialized) return;
+  channelLifecycleCounter?.add(1, {
+    action,
+    ...expected != null ? { expected } : {}
+  });
+}
+__name(recordDaemonChannelLifecycle, "recordDaemonChannelLifecycle");
+function recordDaemonPromptQueueWait(durationMs) {
+  if (!initialized) return;
+  promptQueueWaitHistogram?.record(durationMs);
+}
+__name(recordDaemonPromptQueueWait, "recordDaemonPromptQueueWait");
+function recordDaemonPromptDuration(durationMs) {
+  if (!initialized) return;
+  promptDurationHistogram?.record(durationMs);
+}
+__name(recordDaemonPromptDuration, "recordDaemonPromptDuration");
+function recordDaemonBridgeError(err) {
+  if (!initialized) return;
+  bridgeErrorCounter?.add(1, { error_type: normalizeErrorType(err) });
+}
+__name(recordDaemonBridgeError, "recordDaemonBridgeError");
+function recordDaemonCancel() {
+  if (!initialized) return;
+  cancelCounter?.add(1);
+}
+__name(recordDaemonCancel, "recordDaemonCancel");
+
 // packages/core/src/telemetry/index.ts
 var TelemetryTarget = /* @__PURE__ */ ((TelemetryTarget2) => {
   TelemetryTarget2["GCP"] = "gcp";
@@ -68848,7 +69765,7 @@ function snapshotRetryMetadata() {
   };
 }
 __name(snapshotRetryMetadata, "snapshotRetryMetadata");
-var debugLogger9 = createDebugLogger("LOGGING_CONTENT_GENERATOR");
+var debugLogger10 = createDebugLogger("LOGGING_CONTENT_GENERATOR");
 var MAX_RESPONSE_TEXT_LENGTH = 4096;
 var RESPONSE_TEXT_TRUNCATION_SUFFIX = "...[truncated]";
 var MAX_RESPONSE_TEXT_PREFIX_LENGTH = MAX_RESPONSE_TEXT_LENGTH - RESPONSE_TEXT_TRUNCATION_SUFFIX.length;
@@ -68906,8 +69823,8 @@ var LoggingContentGenerator = class {
     );
   }
   _logApiError(responseId, durationMs, error, model, prompt_id) {
-    const errorMessage = getErrorMessage(error);
-    const errorType = getErrorType(error);
+    const errorMessage2 = getErrorMessage(error);
+    const errorType2 = getErrorType(error);
     const errorResponseId = error?.requestID || error?.request_id || responseId;
     const errorStatus = getErrorStatus(error);
     logApiError(
@@ -68918,8 +69835,8 @@ var LoggingContentGenerator = class {
         durationMs,
         promptId: prompt_id,
         authType: this.generatorAuthType,
-        errorMessage,
-        errorType,
+        errorMessage: errorMessage2,
+        errorType: errorType2,
         statusCode: errorStatus,
         subagentName: subagentNameContext.getStore()
       })
@@ -68929,7 +69846,7 @@ var LoggingContentGenerator = class {
     try {
       this._logApiError(responseId, durationMs, error, model, prompt_id);
     } catch (loggingError) {
-      debugLogger9.warn("Failed to log API error:", loggingError);
+      debugLogger10.warn("Failed to log API error:", loggingError);
     }
   }
   safelyLogApiResponse(responseId, durationMs, model, prompt_id, usageMetadata, responseText) {
@@ -68943,7 +69860,7 @@ var LoggingContentGenerator = class {
         responseText
       );
     } catch (loggingError) {
-      debugLogger9.warn("Failed to log API response:", loggingError);
+      debugLogger10.warn("Failed to log API response:", loggingError);
     }
   }
   async generateContent(req, userPromptId) {
@@ -69006,7 +69923,7 @@ var LoggingContentGenerator = class {
             userPromptId
           );
         } catch (loggingError) {
-          debugLogger9.warn("Failed to log OpenAI interaction:", loggingError);
+          debugLogger10.warn("Failed to log OpenAI interaction:", loggingError);
         }
         return result;
       });
@@ -69016,6 +69933,10 @@ var LoggingContentGenerator = class {
         outputTokens: response.usageMetadata?.candidatesTokenCount,
         cachedInputTokens: response.usageMetadata?.cachedContentTokenCount,
         durationMs: Date.now() - startTime,
+        responseId: response.responseId || void 0,
+        finishReason: response.candidates?.[0]?.finishReason || void 0,
+        thoughtsTokenCount: response.usageMetadata?.thoughtsTokenCount,
+        subagentName: subagentNameContext.getStore() || void 0,
         ...retrySnapshot
       });
       return response;
@@ -69026,6 +69947,9 @@ var LoggingContentGenerator = class {
         success: false,
         durationMs,
         error: aborted ? API_CALL_ABORTED_SPAN_STATUS_MESSAGE : API_CALL_FAILED_SPAN_STATUS_MESSAGE,
+        errorType: getErrorType(error),
+        errorStatusCode: getErrorStatus(error),
+        subagentName: subagentNameContext.getStore() || void 0,
         ...retrySnapshot
       });
       await context.with(spanContext, async () => {
@@ -69038,7 +69962,7 @@ var LoggingContentGenerator = class {
             userPromptId
           );
         } catch (loggingError) {
-          debugLogger9.warn("Failed to log OpenAI interaction:", loggingError);
+          debugLogger10.warn("Failed to log OpenAI interaction:", loggingError);
         }
       });
       throw error;
@@ -69096,6 +70020,9 @@ var LoggingContentGenerator = class {
         success: false,
         durationMs,
         error: aborted ? API_CALL_ABORTED_SPAN_STATUS_MESSAGE : API_CALL_FAILED_SPAN_STATUS_MESSAGE,
+        errorType: getErrorType(error),
+        errorStatusCode: getErrorStatus(error),
+        subagentName: subagentNameContext.getStore() || void 0,
         ...retrySnapshot
       });
       try {
@@ -69106,7 +70033,7 @@ var LoggingContentGenerator = class {
           userPromptId
         );
       } catch (loggingError) {
-        debugLogger9.warn("Failed to log OpenAI interaction:", loggingError);
+        debugLogger10.warn("Failed to log OpenAI interaction:", loggingError);
       }
       throw error;
     }
@@ -69115,7 +70042,7 @@ var LoggingContentGenerator = class {
       try {
         resolvedRequest = await session.resolve(req);
       } catch (loggingError) {
-        debugLogger9.warn("Failed to resolve OpenAI request:", loggingError);
+        debugLogger10.warn("Failed to resolve OpenAI request:", loggingError);
       }
     }
     return context.with(
@@ -69151,6 +70078,9 @@ var LoggingContentGenerator = class {
     let firstModelVersion = "";
     let lastUsageMetadata;
     let errorOccurred = false;
+    let lastFinishReason;
+    let lastError;
+    const subagentName = subagentNameContext.getStore();
     let ttftMs;
     let spanEndedByTimeout = false;
     const runInSpan = /* @__PURE__ */ __name((fn) => spanContext ? context.with(spanContext, fn) : fn(), "runInSpan");
@@ -69168,6 +70098,8 @@ var LoggingContentGenerator = class {
           success: false,
           durationMs: Date.now() - startTime,
           error: "Stream span timed out (idle)",
+          responseId: firstResponseId || void 0,
+          subagentName: subagentName || void 0,
           ...retrySnapshot
         });
         spanEndedByTimeout = true;
@@ -69189,6 +70121,10 @@ var LoggingContentGenerator = class {
         if (response.usageMetadata) {
           lastUsageMetadata = response.usageMetadata;
         }
+        const candidate = response.candidates?.[0];
+        if (candidate?.finishReason) {
+          lastFinishReason = candidate.finishReason;
+        }
         if (ttftMs === void 0 && hasUserVisibleContent(response)) {
           ttftMs = Date.now() - startTime;
         }
@@ -69227,6 +70163,7 @@ var LoggingContentGenerator = class {
       }
     } catch (error) {
       errorOccurred = true;
+      lastError = error;
       if (!spanEndedByTimeout) {
         const durationMs = Date.now() - startTime;
         runInSpan(
@@ -69262,6 +70199,12 @@ var LoggingContentGenerator = class {
           ttftMs,
           durationMs: Date.now() - startTime,
           error: errorOccurred ? aborted ? API_CALL_ABORTED_SPAN_STATUS_MESSAGE : API_CALL_FAILED_SPAN_STATUS_MESSAGE : void 0,
+          responseId: firstResponseId || void 0,
+          finishReason: lastFinishReason,
+          thoughtsTokenCount: lastUsageMetadata?.thoughtsTokenCount,
+          subagentName: subagentName || void 0,
+          errorType: lastError ? getErrorType(lastError) : void 0,
+          errorStatusCode: lastError ? getErrorStatus(lastError) : void 0,
           ...retrySnapshot
         });
       }
@@ -69333,7 +70276,7 @@ var LoggingContentGenerator = class {
     try {
       await this.logOpenAIInteraction(openaiRequest, response, error, promptId);
     } catch (loggingError) {
-      debugLogger9.warn("Failed to log OpenAI interaction:", loggingError);
+      debugLogger10.warn("Failed to log OpenAI interaction:", loggingError);
     }
   }
   convertGeminiResponseToOpenAIForLogging(response, openaiRequest) {
@@ -69802,7 +70745,7 @@ var QWEN_OAUTH_ALLOWED_MODELS = QWEN_OAUTH_MODELS.map(
 );
 
 // packages/core/src/models/modelRegistry.ts
-var debugLogger10 = createDebugLogger("MODEL_REGISTRY");
+var debugLogger11 = createDebugLogger("MODEL_REGISTRY");
 function validateAuthTypeKey(key) {
   if (Object.values(AuthType).includes(key)) {
     return key;
@@ -69840,7 +70783,7 @@ var ModelRegistry = class {
       for (const [rawKey, models] of Object.entries(modelProvidersConfig)) {
         const authType = validateAuthTypeKey(rawKey);
         if (!authType) {
-          debugLogger10.warn(
+          debugLogger11.warn(
             `Invalid authType key "${rawKey}" in modelProviders config. Expected one of: ${Object.values(AuthType).join(", ")}. Skipping.`
           );
           continue;
@@ -69863,7 +70806,7 @@ var ModelRegistry = class {
     for (const config of models) {
       const key = modelRegistryKey(config.id, config.baseUrl);
       if (modelMap.has(key)) {
-        debugLogger10.warn(
+        debugLogger11.warn(
           `Duplicate model id "${config.id}"${config.baseUrl ? ` with baseUrl "${config.baseUrl}"` : ""} for authType "${authType}". Using the first registered config.`
         );
         continue;
@@ -69978,7 +70921,7 @@ var ModelRegistry = class {
       for (const [rawKey, models] of Object.entries(modelProvidersConfig)) {
         const authType = validateAuthTypeKey(rawKey);
         if (!authType) {
-          debugLogger10.warn(
+          debugLogger11.warn(
             `Invalid authType key "${rawKey}" in modelProviders config. Expected one of: ${Object.values(AuthType).join(", ")}. Skipping.`
           );
           continue;
@@ -71061,11 +72004,11 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   let baseGenerator;
   try {
     if (authType === "openai" /* USE_OPENAI */) {
-      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-FTR7CDWF.js");
+      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-5PLHYJQL.js");
       baseGenerator = createOpenAIContentGenerator(generatorConfig, config);
     } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
-      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-EFSECGHF.js");
-      const { QwenContentGenerator } = await import("./qwenContentGenerator-U5UFQ566.js");
+      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-KK433U33.js");
+      const { QwenContentGenerator } = await import("./qwenContentGenerator-TSKW73KY.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
@@ -71083,10 +72026,10 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
         throw new Error(error instanceof Error ? error.message : String(error));
       }
     } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
-      const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-M45EVVRM.js");
+      const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-DCI26OQF.js");
       baseGenerator = createAnthropicContentGenerator(generatorConfig, config);
     } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
-      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-I4H2NLJG.js");
+      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-HFJIGO77.js");
       baseGenerator = createGeminiContentGenerator(generatorConfig, config);
     } else {
       throw new Error(
@@ -71961,7 +72904,7 @@ function logStartSession(config, event) {
     skills: event.skills,
     subagents: event.subagents
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: "CLI configuration loaded.",
     attributes
@@ -71985,7 +72928,7 @@ function logUserPrompt(config, event) {
   if (shouldLogUserPrompts(config)) {
     attributes["prompt"] = event.prompt;
   }
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `User prompt. Length: ${event.prompt_length}.`,
     attributes
@@ -72002,7 +72945,7 @@ function logUserRetry(config, event) {
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
     prompt_id: event.prompt_id
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `User retry.`,
     attributes
@@ -72016,7 +72959,7 @@ function logToolCall(config, event) {
     "event.name": EVENT_TOOL_CALL,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  uiTelemetryService.addEvent(uiEvent);
+  uiTelemetryService.addEvent(uiEvent, config.getSessionId());
   if (!isInternalPromptId(event.prompt_id)) {
     config.getChatRecordingService()?.recordUiTelemetryEvent(uiEvent);
   }
@@ -72035,7 +72978,7 @@ function logToolCall(config, event) {
       attributes["error.type"] = event.error_type;
     }
   }
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Tool call: ${event.function_name}${event.decision ? `. Decision: ${event.decision}` : ""}. Success: ${event.success}. Duration: ${event.duration_ms}ms.`,
     attributes
@@ -72058,7 +73001,7 @@ function logToolOutputTruncated(config, event) {
     "event.name": "tool_output_truncated",
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Tool output truncated for ${event.tool_name}.`,
     attributes
@@ -72088,7 +73031,7 @@ function logFileOperation(config, event) {
   if (event.programming_language) {
     attributes["programming_language"] = event.programming_language;
   }
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `File operation: ${event.operation}. Lines: ${event.lines}.`,
     attributes
@@ -72111,7 +73054,7 @@ function logApiRequest(config, event) {
     "event.name": EVENT_API_REQUEST,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `API request to ${event.model}.`,
     attributes
@@ -72128,7 +73071,7 @@ function logFlashFallback(config, event) {
     "event.name": EVENT_FLASH_FALLBACK,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Switching to flash as Fallback.`,
     attributes
@@ -72145,7 +73088,7 @@ function logRipgrepFallback(config, event) {
     "event.name": EVENT_RIPGREP_FALLBACK,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Switching to grep as fallback.`,
     attributes
@@ -72159,7 +73102,7 @@ function logApiError(config, event) {
     "event.name": EVENT_API_ERROR,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  uiTelemetryService.addEvent(uiEvent);
+  uiTelemetryService.addEvent(uiEvent, config.getSessionId());
   if (!isInternalPromptId(event.prompt_id)) {
     config.getChatRecordingService()?.recordUiTelemetryEvent(uiEvent);
   }
@@ -72180,7 +73123,7 @@ function logApiError(config, event) {
   if (typeof event.status_code === "number") {
     attributes[SemanticAttributes.HTTP_STATUS_CODE] = event.status_code;
   }
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `API error for ${event.model}. Error: ${event.error_message}. Duration: ${event.duration_ms}ms.`,
     attributes
@@ -72199,7 +73142,7 @@ function logApiCancel(config, event) {
     "event.name": EVENT_API_CANCEL,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  uiTelemetryService.addEvent(uiEvent);
+  uiTelemetryService.addEvent(uiEvent, config.getSessionId());
   QwenLogger.getInstance(config)?.logApiCancelEvent(event);
   if (!isTelemetrySdkInitialized()) return;
   const attributes = {
@@ -72209,7 +73152,7 @@ function logApiCancel(config, event) {
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
     model_name: event.model
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `API request cancelled for ${event.model}.`,
     attributes
@@ -72223,7 +73166,7 @@ function logApiResponse(config, event) {
     "event.name": EVENT_API_RESPONSE,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  uiTelemetryService.addEvent(uiEvent);
+  uiTelemetryService.addEvent(uiEvent, config.getSessionId());
   if (!isInternalPromptId(event.prompt_id)) {
     config.getChatRecordingService()?.recordUiTelemetryEvent(uiEvent);
   }
@@ -72243,7 +73186,7 @@ function logApiResponse(config, event) {
       attributes[SemanticAttributes.HTTP_STATUS_CODE] = event.status_code;
     }
   }
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `API response from ${event.model}. Status: ${event.status_code || "N/A"}. Duration: ${event.duration_ms}ms.`,
     attributes
@@ -72278,7 +73221,7 @@ function logLoopDetected(config, event) {
     ...getCommonAttributes(config),
     ...event
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Loop detected. Type: ${event.loop_type}.`,
     attributes
@@ -72298,7 +73241,7 @@ function logNextSpeakerCheck(config, event) {
     ...event,
     "event.name": EVENT_NEXT_SPEAKER_CHECK
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Next speaker check.`,
     attributes
@@ -72314,7 +73257,7 @@ function logSlashCommand(config, event) {
     ...event,
     "event.name": EVENT_SLASH_COMMAND
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Slash command: ${event.command}.`,
     attributes
@@ -72330,7 +73273,7 @@ function logIdeConnection(config, event) {
     ...event,
     "event.name": EVENT_IDE_CONNECTION
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Ide connection. Type: ${event.connection_type}.`,
     attributes
@@ -72346,7 +73289,7 @@ function logConversationFinishedEvent(config, event) {
     ...event,
     "event.name": EVENT_CONVERSATION_FINISHED
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Conversation finished.`,
     attributes
@@ -72361,7 +73304,7 @@ function logChatCompression(config, event) {
     ...event,
     "event.name": EVENT_CHAT_COMPRESSION
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Chat compression (Saved ${event.tokens_before - event.tokens_after} tokens)`,
     attributes
@@ -72380,7 +73323,7 @@ function logKittySequenceOverflow(config, event) {
     ...getCommonAttributes(config),
     ...event
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Kitty sequence buffer overflow: ${event.sequence_length} bytes`,
     attributes
@@ -72396,7 +73339,7 @@ function logContentRetry(config, event) {
     ...event,
     "event.name": EVENT_CONTENT_RETRY
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Content retry attempt ${event.attempt_number} due to ${event.error_type}.`,
     attributes
@@ -72413,7 +73356,7 @@ function logContentRetryFailure(config, event) {
     ...event,
     "event.name": EVENT_CONTENT_RETRY_FAILURE
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `All content retries failed after ${event.total_attempts} attempts.`,
     attributes
@@ -72430,7 +73373,7 @@ function logApiRetry(config, event) {
     ...event,
     "event.name": EVENT_API_RETRY
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `API retry attempt ${event.attempt_number} for ${event.model} (status ${event.status_code ?? "unknown"}).`,
     attributes
@@ -72448,7 +73391,7 @@ function logSubagentExecution(config, event) {
     "event.name": EVENT_SUBAGENT_EXECUTION,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Subagent execution: ${event.subagent_name}.`,
     attributes
@@ -72470,7 +73413,7 @@ function logModelSlashCommand(config, event) {
     ...event,
     "event.name": EVENT_MODEL_SLASH_COMMAND
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Model slash command. Model: ${event.model_name}`,
     attributes
@@ -72496,7 +73439,7 @@ function logExtensionInstallEvent(config, event) {
     extension_source: event.extension_source,
     status: event.status
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Installed extension ${event.extension_name}`,
     attributes
@@ -72513,7 +73456,7 @@ function logExtensionUninstall(config, event) {
     "event.name": EVENT_EXTENSION_UNINSTALL,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Uninstalled extension ${event.extension_name}`,
     attributes
@@ -72534,7 +73477,7 @@ async function logExtensionUpdateEvent(config, event) {
     extension_version: event.extension_version,
     extension_source: event.extension_source
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Updated extension ${event.extension_name} from ${event.extension_previous_version} to ${event.extension_version}`,
     attributes
@@ -72551,7 +73494,7 @@ function logExtensionEnable(config, event) {
     "event.name": EVENT_EXTENSION_ENABLE,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Enabled extension ${event.extension_name}`,
     attributes
@@ -72568,7 +73511,7 @@ function logExtensionDisable(config, event) {
     "event.name": EVENT_EXTENSION_DISABLE,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Disabled extension ${event.extension_name}`,
     attributes
@@ -72591,7 +73534,7 @@ function logAuth(config, event) {
   if (event.error_message) {
     attributes["error.message"] = event.error_message;
   }
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Auth event: ${event.action_type} ${event.status} for ${event.auth_type}`,
     attributes
@@ -72608,7 +73551,7 @@ function logSkillLaunch(config, event) {
     "event.name": EVENT_SKILL_LAUNCH,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Skill launch: ${event.skill_name}. Success: ${event.success}.`,
     attributes
@@ -72622,7 +73565,7 @@ function logUserFeedback(config, event) {
     "event.name": EVENT_USER_FEEDBACK,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  uiTelemetryService.addEvent(uiEvent);
+  uiTelemetryService.addEvent(uiEvent, config.getSessionId());
   config.getChatRecordingService()?.recordUiTelemetryEvent(uiEvent);
   QwenLogger.getInstance(config)?.logUserFeedbackEvent(event);
   if (!isTelemetrySdkInitialized()) return;
@@ -72632,7 +73575,7 @@ function logUserFeedback(config, event) {
     "event.name": EVENT_USER_FEEDBACK,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `User feedback: Rating ${event.rating} for session ${event.session_id}.`,
     attributes
@@ -72650,7 +73593,7 @@ function logArenaSessionStarted(config, event) {
     "event.name": EVENT_ARENA_SESSION_STARTED,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Arena session started. Agents: ${event.model_ids.length}.`,
     attributes
@@ -72668,7 +73611,7 @@ function logArenaAgentCompleted(config, event) {
     "event.name": EVENT_ARENA_AGENT_COMPLETED,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Arena agent ${event.agent_model_id} ${event.status}. Duration: ${event.duration_ms}ms. Tokens: ${event.total_tokens}.`,
     attributes
@@ -72693,7 +73636,7 @@ function logArenaSessionEnded(config, event) {
     "event.name": EVENT_ARENA_SESSION_ENDED,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Arena session ended: ${event.status}.${event.winner_model_id ? ` Winner: ${event.winner_model_id}.` : ""}`,
     attributes
@@ -72743,7 +73686,7 @@ function logPromptSuggestion(config, event) {
   if (event.reason) {
     attributes["reason"] = event.reason;
   }
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Prompt suggestion: ${event.outcome}.`,
     attributes
@@ -72767,7 +73710,7 @@ function logSpeculation(config, event) {
   if (event.boundary_type) {
     attributes["boundary_type"] = event.boundary_type;
   }
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   const logRecord = {
     body: `Speculation: ${event.outcome}.`,
     attributes
@@ -72790,7 +73733,7 @@ function logMemoryExtract(config, event) {
   if (event.skipped_reason) {
     attributes["skipped_reason"] = event.skipped_reason;
   }
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   logger.emit({
     body: `Memory extract: ${event.status}. Patches: ${event.patches_count}. Topics: ${event.touched_topics || "none"}.`,
     attributes
@@ -72815,7 +73758,7 @@ function logMemoryDream(config, event) {
     touched_topics: event.touched_topics,
     duration_ms: event.duration_ms
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   logger.emit({
     body: `Memory dream: ${event.status}. Deduped: ${event.deduped_entries}. Topics: ${event.touched_topics || "none"}.`,
     attributes
@@ -72839,7 +73782,7 @@ function logMemoryRecall(config, event) {
     strategy: event.strategy,
     duration_ms: event.duration_ms
   };
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
   logger.emit({
     body: `Memory recall: strategy=${event.strategy}. Selected ${event.docs_selected}/${event.docs_scanned} docs.`,
     attributes
@@ -72879,7 +73822,7 @@ function memoryFreshnessNote(mtimeMs) {
 __name(memoryFreshnessNote, "memoryFreshnessNote");
 
 // packages/core/src/tools/read-file.ts
-var debugLogger11 = createDebugLogger("READ_FILE_CACHE");
+var debugLogger12 = createDebugLogger("READ_FILE_CACHE");
 var ReadFileToolInvocation = class extends BaseToolInvocation {
   constructor(config, params) {
     super(params);
@@ -72948,7 +73891,7 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
     try {
       stats = await fs7.stat(absPath);
     } catch (err) {
-      debugLogger11.debug("stat-failed", {
+      debugLogger12.debug("stat-failed", {
         path: absPath,
         code: err.code
       });
@@ -72958,10 +73901,10 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
       if (status.state === "fresh" && status.entry.lastReadAt !== void 0 && status.entry.lastReadWasFull && status.entry.lastReadCacheable && // Only quote-back if that read is still in history (issue
       // #4239: idle microcompaction flips this off when it blanks it).
       status.entry.readResidentInHistory && (status.entry.lastWriteAt === void 0 || status.entry.lastReadAt > status.entry.lastWriteAt)) {
-        debugLogger11.debug("hit", { path: absPath });
+        debugLogger12.debug("hit", { path: absPath });
         return this.unchangedResult(absPath);
       }
-      debugLogger11.debug("miss", { path: absPath, state: status.state });
+      debugLogger12.debug("miss", { path: absPath, state: status.state });
     }
     const result = await processSingleFileContent(
       this.params.file_path,
@@ -73100,6 +74043,13 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
     __name(this, "ReadFileTool");
   }
   static Name = ToolNames.READ_FILE;
+  // Self-managed: ReadFile controls its own size via line-based paging
+  // (offset/limit, default 2000 lines), so it is exempt from the scheduler's
+  // char-based truncation. Oversized reads are bounded by the per-message
+  // batch budget instead.
+  get maxOutputChars() {
+    return Number.POSITIVE_INFINITY;
+  }
   validateToolParamValues(params) {
     const filePath = unescapePath(params.file_path.trim());
     params.file_path = filePath;
@@ -73258,6 +74208,7 @@ export {
   truncateSpanError,
   startInteractionSpan,
   endInteractionSpan,
+  withInteractionSpan,
   startLLMRequestSpan,
   endLLMRequestSpan,
   startToolSpan,
@@ -73278,6 +74229,7 @@ export {
   initializeTelemetry,
   refreshSessionContext,
   shutdownTelemetry,
+  forceFlushMetrics,
   logStartSession,
   logUserPrompt,
   logUserRetry,
@@ -73323,7 +74275,11 @@ export {
   memoryAge,
   memoryFreshnessText,
   ReadFileTool,
+  TOOL_OUTPUT_TRUNCATED_PREFIX,
   truncateToolOutput,
+  truncateLlmContent,
+  isAlreadyTruncated,
+  persistAndTruncateToolResult,
   DiscoveredMCPTool,
   generateValidName,
   StartSessionEvent,
@@ -73382,6 +74338,30 @@ export {
   parseBooleanEnvFlag,
   parseTelemetryTargetValue,
   resolveTelemetrySettings,
+  DAEMON_TRACEPARENT_META_KEY,
+  DAEMON_TRACESTATE_META_KEY,
+  hashDaemonWorkspace,
+  withDaemonSpan,
+  withDaemonRequestSpan,
+  withDaemonBridgeSpan,
+  recordDaemonHttpResponse,
+  addDaemonRequestAttribute,
+  recordDaemonError,
+  emitDaemonLog,
+  captureDaemonTelemetryContext,
+  runWithDaemonTelemetryContext,
+  injectDaemonTraceContext,
+  extractDaemonTraceContext,
+  createDaemonBridgeTelemetry,
+  initializeDaemonMetrics,
+  registerDaemonGaugeCallbacks,
+  recordDaemonHttpRequest,
+  recordDaemonSessionLifecycle,
+  recordDaemonChannelLifecycle,
+  recordDaemonPromptQueueWait,
+  recordDaemonPromptDuration,
+  recordDaemonBridgeError,
+  recordDaemonCancel,
   TelemetryTarget,
   DEFAULT_TELEMETRY_TARGET,
   DEFAULT_OTLP_ENDPOINT,