@qwen-code/qwen-code 0.15.12-preview.3 → 0.16.0-preview.0

package/chunks/{chunk-AJSOD5IR.js → chunk-MNPZ2WO6.js}

@@ -39,11 +39,11 @@ import {
 } from "./chunk-TW522KN6.js";
 import {
   runSideQuery
-} from "./chunk-JMZQICAL.js";
+} from "./chunk-PPHYLJSS.js";
 import {
   escapeSystemReminderTags,
   escapeXml
-} from "./chunk-5QQ5FGTU.js";
+} from "./chunk-G7YTSRES.js";
 import {
   DefaultHookOutput,
   HOOKS_CONFIG_FIELDS,
@@ -55,14 +55,14 @@ import {
   StopHookOutput,
   createHookOutput,
   getHookKey
-} from "./chunk-B7ZL7HUA.js";
+} from "./chunk-XVHR7ATJ.js";
 import {
   DEFAULT_FILE_FILTERING_OPTIONS
 } from "./chunk-77WXWU44.js";
 import {
   BaseTokenStorage,
   KeychainTokenStorage
-} from "./chunk-OCC4MZRS.js";
+} from "./chunk-F23NCRJ2.js";
 import {
   AUTH_ENV_MAPPINGS,
   ApiResponseEvent,
@@ -154,7 +154,7 @@ import {
   subagentNameContext,
   truncateToolOutput,
   uiTelemetryService
-} from "./chunk-XLQ4E5PS.js";
+} from "./chunk-C3LHPHN2.js";
 import {
   DEFAULT_QWEN_EMBEDDING_MODEL,
   DEFAULT_QWEN_MODEL
@@ -167,12 +167,12 @@ import {
   getAutoMemoryMetadataPath,
   getAutoMemoryRoot,
   isAutoMemPath
-} from "./chunk-CM2IESUE.js";
+} from "./chunk-PR4T27R7.js";
 import {
   DEFAULT_TOKEN_LIMIT,
   ESCALATED_MAX_TOKENS,
   tokenLimit
-} from "./chunk-UXW7MYAW.js";
+} from "./chunk-CW44BRRA.js";
 import {
   FinishReason,
   createModelContent,
@@ -182,7 +182,7 @@ import {
 } from "./chunk-T4VD6OJ4.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-TPGOGCWM.js";
+} from "./chunk-JYQUJ5DS.js";
 import {
   AgentStatistics,
   BaseDeclarativeTool,
@@ -197,7 +197,7 @@ import {
   isTool,
   require_ajv,
   require_dist
-} from "./chunk-FYMSCRHM.js";
+} from "./chunk-FZIUV27X.js";
 import {
   PATH_ARG_KEYS,
   QWEN_DIR,
@@ -216,7 +216,7 @@ import {
   setDebugLogSession,
   toFriendlyError,
   unescapePath
-} from "./chunk-GJXIKCKL.js";
+} from "./chunk-XP27SJMH.js";
 import {
   require_undici
 } from "./chunk-E7E2MFYM.js";
@@ -32315,6 +32315,19 @@ function stripThoughtsFromContent(content) {
   };
 }
 __name(stripThoughtsFromContent, "stripThoughtsFromContent");
+function appendApiHistoryRecord(history, record2) {
+  if (!record2.message) return;
+  const message = structuredClone(record2.message);
+  if (record2.subtype === "mid_turn_user_message") {
+    const previous = history.at(-1);
+    if (previous?.role === "user") {
+      previous.parts = [...previous.parts ?? [], ...message.parts ?? []];
+      return;
+    }
+  }
+  history.push(message);
+}
+__name(appendApiHistoryRecord, "appendApiHistoryRecord");
 function buildApiHistoryFromConversation(conversation, options2 = {}) {
   const { stripThoughtsFromHistory = false } = options2;
   const { messages } = conversation;
@@ -32334,16 +32347,17 @@ function buildApiHistoryFromConversation(conversation, options2 = {}) {
     for (let i2 = lastCompressionIndex + 1; i2 < messages.length; i2++) {
       const record2 = messages[i2];
       if (record2.type === "system") continue;
-      if (record2.message) {
-        baseHistory.push(structuredClone(record2.message));
-      }
+      appendApiHistoryRecord(baseHistory, record2);
     }
     if (stripThoughtsFromHistory) {
       return baseHistory.map(stripThoughtsFromContent).filter((content) => content !== null);
     }
     return baseHistory;
   }
-  const result = messages.map((record2) => record2.message).filter((message) => message !== void 0).map((message) => structuredClone(message));
+  const result = [];
+  for (const record2 of messages) {
+    appendApiHistoryRecord(result, record2);
+  }
   if (stripThoughtsFromHistory) {
     return result.map(stripThoughtsFromContent).filter((content) => content !== null);
   }
@@ -32972,6 +32986,26 @@ var ChatRecordingService = class {
       debugLogger12.error("Error saving user message:", error);
     }
   }
+  /**
+   * Records a user message drained while tool results are being submitted.
+   *
+   * The model sees these as extra user-role parts in the same API Content as
+   * tool results. Keeping a distinct subtype lets resume reconstruct that shape
+   * instead of replaying consecutive user-role entries.
+   */
+  recordMidTurnUserMessage(message, displayText) {
+    try {
+      const record2 = {
+        ...this.createBaseRecord("user"),
+        subtype: "mid_turn_user_message",
+        message: createUserContent(message),
+        systemPayload: displayText ? { displayText } : void 0
+      };
+      this.appendRecord(record2);
+    } catch (error) {
+      debugLogger12.error("Error saving mid-turn user message:", error);
+    }
+  }
   /**
    * Records a cron-fired prompt.
    * Stored as a user-role message with subtype 'cron' so the UI
@@ -33216,7 +33250,7 @@ var ChatRecordingService = class {
     let prevUuid = this.config.getResumedSessionData()?.lastCompletedUuid !== void 0 ? null : this.lastRecordUuid;
     for (let i2 = 0; i2 < messages.length; i2++) {
       const record2 = messages[i2];
-      if (record2.type === "user" && record2.subtype !== "notification" && record2.subtype !== "cron") {
+      if (record2.type === "user" && record2.subtype !== "notification" && record2.subtype !== "cron" && record2.subtype !== "mid_turn_user_message") {
         this.turnParentUuids.push(prevUuid);
       }
       prevUuid = record2.uuid;
@@ -45577,7 +45611,7 @@ var createErrorResponse = /* @__PURE__ */ __name((request, error, errorType) =>
   contentLength: error.message.length
 }), "createErrorResponse");
 function isConcurrencySafe(call) {
-  if (call.request.name === ToolNames.AGENT) return true;
+  if (canonicalToolName(call.request.name) === ToolNames.AGENT) return true;
   if (call.tool.kind === "execute" /* Execute */) {
     const command = call.request.args.command;
     if (typeof command !== "string") return false;
@@ -45914,10 +45948,11 @@ var CoreToolScheduler = class {
       }
       const newToolCalls = [];
       for (const reqInfo of requestsToProcess) {
+        const canonicalName = canonicalToolName(reqInfo.name);
         const pm = this.config.getPermissionManager?.();
-        if (pm && !await pm.isToolEnabled(reqInfo.name)) {
+        if (pm && !await pm.isToolEnabled(canonicalName)) {
           const matchingRule = pm.findMatchingDenyRule({
-            toolName: reqInfo.name
+            toolName: canonicalName
           });
           const ruleInfo = matchingRule ? ` Matching deny rule: "${matchingRule}".` : "";
           const permissionErrorMessage = `Qwen Code requires permission to use "${reqInfo.name}", but that permission was declined.${ruleInfo}`;
@@ -45936,7 +45971,7 @@ var CoreToolScheduler = class {
         if (!pm) {
           const excludeTools = this.config.getPermissionsDeny?.() ?? void 0;
           if (excludeTools && excludeTools.length > 0) {
-            const normalizedToolName = reqInfo.name.toLowerCase().trim();
+            const normalizedToolName = canonicalName.toLowerCase().trim();
             const excludedMatch = excludeTools.find(
               (excludedTool) => excludedTool.toLowerCase().trim() === normalizedToolName
             );
@@ -45956,7 +45991,7 @@ var CoreToolScheduler = class {
             }
           }
         }
-        const toolInstance = await this.toolRegistry.ensureTool(reqInfo.name);
+        const toolInstance = await this.toolRegistry.ensureTool(canonicalName);
         if (!toolInstance) {
           const errorMessage = await this.getToolNotFoundMessage(reqInfo.name);
           newToolCalls.push({
@@ -46033,6 +46068,7 @@ var CoreToolScheduler = class {
           continue;
         }
         const { request: reqInfo, invocation } = toolCall;
+        const canonicalName = canonicalToolName(reqInfo.name);
         try {
           if (signal.aborted) {
             this.setStatusInternal(
@@ -46046,13 +46082,13 @@ var CoreToolScheduler = class {
           const flowResult = await evaluatePermissionFlow(
             this.config,
             invocation,
-            reqInfo.name,
+            canonicalName,
             toolParams
           );
           const { finalPermission, pmForcedAsk, pmCtx, denyMessage } = flowResult;
           const approvalMode = this.config.getApprovalMode();
           const isPlanMode = approvalMode === "plan" /* PLAN */;
-          const isExitPlanModeTool = reqInfo.name === "exit_plan_mode";
+          const isExitPlanModeTool = canonicalName === ToolNames.EXIT_PLAN_MODE;
           if (finalPermission === "allow") {
             this.setToolCallOutcome(
               reqInfo.callId,
@@ -46073,9 +46109,9 @@ var CoreToolScheduler = class {
             );
             continue;
           }
-          const isAskUserQuestionTool = reqInfo.name === ToolNames.ASK_USER_QUESTION;
+          const isAskUserQuestionTool = canonicalName === ToolNames.ASK_USER_QUESTION;
           let confirmationDetails;
-          if (!needsConfirmation(finalPermission, approvalMode, reqInfo.name)) {
+          if (!needsConfirmation(finalPermission, approvalMode, canonicalName)) {
             this.setToolCallOutcome(
               reqInfo.callId,
               "proceed_always" /* ProceedAlways */
@@ -46131,7 +46167,7 @@ var CoreToolScheduler = class {
               const permissionMode = String(this.config.getApprovalMode());
               const hookResult = await firePermissionRequestHook(
                 messageBus,
-                reqInfo.name,
+                canonicalName,
                 reqInfo.args || {},
                 permissionMode
               );
@@ -46464,6 +46500,7 @@ var CoreToolScheduler = class {
   }
   async _executeToolCallBody(scheduledCall, signal, span) {
     const { callId, name: toolName } = scheduledCall.request;
+    const canonicalName = canonicalToolName(toolName);
     const invocation = scheduledCall.invocation;
     const toolInput = scheduledCall.request.args;
     for (const key of PATH_ARG_KEYS) {
@@ -46486,7 +46523,7 @@ var CoreToolScheduler = class {
       const permissionMode = this.config.getApprovalMode();
       const preHookResult = await firePreToolUseHook(
         messageBus,
-        toolName,
+        canonicalName,
         toolInput,
         toolUseId,
         permissionMode
@@ -46564,7 +46601,7 @@ var CoreToolScheduler = class {
           const failureHookResult = await safelyFirePostToolUseFailureHook(
             messageBus,
             toolUseId,
-            toolName,
+            canonicalName,
             toolInput,
             cancelMessage,
             true,
@@ -46597,7 +46634,7 @@ ${failureHookResult.additionalContext}`;
           const permissionMode = this.config.getApprovalMode();
           const postHookResult = await firePostToolUseHook(
             messageBus,
-            toolName,
+            canonicalName,
             toolInput,
             toolResponse,
             toolUseId,
@@ -46696,7 +46733,7 @@ ${body2}
           const failureHookResult = await safelyFirePostToolUseFailureHook(
             messageBus,
             toolUseId,
-            toolName,
+            canonicalName,
             toolInput,
             toolResult.error.message,
             false,
@@ -46739,7 +46776,7 @@ ${failureHookResult.additionalContext}`;
           const failureHookResult = await safelyFirePostToolUseFailureHook(
             messageBus,
             toolUseId,
-            toolName,
+            canonicalName,
             toolInput,
             cancelMessage,
             true,
@@ -46766,7 +46803,7 @@ ${failureHookResult.additionalContext}`;
           const failureHookResult = await safelyFirePostToolUseFailureHook(
             messageBus,
             toolUseId,
-            toolName,
+            canonicalName,
             toolInput,
             errorMessage,
             false,
@@ -72327,7 +72364,7 @@ var PathScurryBase = class {
     const dirs = /* @__PURE__ */ new Set();
     const queue = [entry];
     let processing = 0;
-    const process7 = /* @__PURE__ */ __name(() => {
+    const process8 = /* @__PURE__ */ __name(() => {
       let paused = false;
       while (!paused) {
         const dir = queue.shift();
@@ -72368,9 +72405,9 @@ var PathScurryBase = class {
             }
           }
           if (paused && !results.flowing) {
-            results.once("drain", process7);
+            results.once("drain", process8);
           } else if (!sync2) {
-            process7();
+            process8();
           }
         }, "onReaddir");
         let sync2 = true;
@@ -72378,7 +72415,7 @@ var PathScurryBase = class {
         sync2 = false;
       }
     }, "process");
-    process7();
+    process8();
     return results;
   }
   streamSync(entry = this.cwd, opts = {}) {
@@ -72396,7 +72433,7 @@ var PathScurryBase = class {
     }
     const queue = [entry];
     let processing = 0;
-    const process7 = /* @__PURE__ */ __name(() => {
+    const process8 = /* @__PURE__ */ __name(() => {
       let paused = false;
       while (!paused) {
         const dir = queue.shift();
@@ -72430,9 +72467,9 @@ var PathScurryBase = class {
         }
       }
       if (paused && !results.flowing)
-        results.once("drain", process7);
+        results.once("drain", process8);
     }, "process");
-    process7();
+    process8();
     return results;
   }
   chdir(path81 = this.cwd) {
@@ -75228,7 +75265,7 @@ var HybridTokenStorage = class extends BaseTokenStorage {
     const forceFileStorage = process.env[FORCE_FILE_STORAGE_ENV_VAR] === "true";
     if (!forceFileStorage) {
       try {
-        const { KeychainTokenStorage: KeychainTokenStorage2 } = await import("./keychain-token-storage-DMFP5IJM.js");
+        const { KeychainTokenStorage: KeychainTokenStorage2 } = await import("./keychain-token-storage-335UOLJ6.js");
         const keychainStorage = new KeychainTokenStorage2(this.serviceName);
         const isAvailable = await keychainStorage.isAvailable();
         if (isAvailable) {
@@ -85639,6 +85676,7 @@ var FileReadCache = class _FileReadCache {
     __name(this, "FileReadCache");
   }
   byInode = /* @__PURE__ */ new Map();
+  static MAX_ENTRIES = 4096;
   /** Build the canonical key for a file from its Stats. */
   static inodeKey(stats) {
     return `${stats.dev}:${stats.ino}`;
@@ -85766,11 +85804,19 @@ var FileReadCache = class _FileReadCache {
     const key = _FileReadCache.inodeKey(stats);
     const existing = this.byInode.get(key);
     if (existing) {
+      this.byInode.delete(key);
       existing.realPath = absPath;
       existing.mtimeMs = stats.mtimeMs;
       existing.sizeBytes = stats.size;
+      this.byInode.set(key, existing);
       return existing;
     }
+    if (this.byInode.size >= _FileReadCache.MAX_ENTRIES) {
+      const oldestKey = this.byInode.keys().next().value;
+      if (oldestKey) {
+        this.byInode.delete(oldestKey);
+      }
+    }
     const entry = {
       inodeKey: key,
       realPath: absPath,
@@ -101138,6 +101184,8 @@ var Config = class {
   jsonFile;
   jsonSchema;
   inputFile;
+  plansDir;
+  plansDirectoryConfigured;
   defaultFileEncoding;
   enableManagedAutoMemory;
   enableManagedAutoDream;
@@ -101164,6 +101212,8 @@ var Config = class {
     this.fileSystemService = new StandardFileSystemService();
     this.sandbox = params.sandbox;
     this.targetDir = path63.resolve(params.targetDir);
+    this.plansDirectoryConfigured = Boolean(params.plansDirectory?.trim());
+    this.plansDir = Storage.getPlansDir(this.targetDir, params.plansDirectory);
     this.explicitIncludeDirectories = Array.from(
       new Set(params.includeDirectories ?? [])
     );
@@ -101264,6 +101314,7 @@ var Config = class {
     this.skipStartupContext = params.skipStartupContext ?? false;
     this.bareMode = params.bareMode ?? false;
     this.warnings = params.warnings ?? [];
+    this.addLegacyPlanLocationWarning();
     this.allowedHttpHookUrls = params.allowedHttpHookUrls ?? [];
     this.onPersistPermissionRuleCallback = params.onPersistPermissionRule;
     this.useRipgrep = params.useRipgrep ?? true;
@@ -102392,26 +102443,120 @@ var Config = class {
     }
     this.approvalMode = mode;
   }
+  /**
+   * Returns the directory where this session's plan file is stored.
+   */
+  getPlansDir() {
+    return this.plansDir;
+  }
+  assertPlansDirWithinTargetDir() {
+    if (!this.plansDirectoryConfigured) {
+      return;
+    }
+    Storage.assertPathWithinDirectory(
+      this.plansDir,
+      this.targetDir,
+      `plansDirectory must resolve within the project root.`
+    );
+  }
+  assertPlanFilePathWithinTargetDir(filePath) {
+    if (!this.plansDirectoryConfigured) {
+      return;
+    }
+    Storage.assertPathWithinDirectory(
+      filePath,
+      this.targetDir,
+      `plansDirectory must resolve within the project root.`
+    );
+  }
+  addLegacyPlanLocationWarning() {
+    try {
+      if (!this.plansDirectoryConfigured) {
+        return;
+      }
+      const legacyPlansDir = Storage.getPlansDir();
+      const legacyPlanFiles = this.getPlanFileNames(legacyPlansDir);
+      if (legacyPlanFiles.length === 0) {
+        return;
+      }
+      const configuredPlanFiles = new Set(this.getPlanFileNames(this.plansDir));
+      const hiddenLegacyPlanFiles = legacyPlanFiles.filter(
+        (fileName) => !configuredPlanFiles.has(fileName)
+      );
+      if (hiddenLegacyPlanFiles.length === 0) {
+        return;
+      }
+      this.warnings.push(
+        `Warning: Saved plan files exist at ${legacyPlansDir}, but plansDirectory is configured to use ${this.plansDir}. Move existing plan files to ${this.plansDir} if you want to keep using them.`
+      );
+    } catch (err2) {
+      const message = `Failed to check legacy plan directory migration warning: ${err2 instanceof Error ? err2.message : String(err2)}`;
+      this.warnings.push(message);
+      this.debugLogger.warn(message, err2);
+    }
+  }
+  getPlanFileNames(plansDir) {
+    try {
+      return fs63.readdirSync(plansDir).filter((entry) => entry.endsWith(".md"));
+    } catch (err2) {
+      const code2 = err2.code;
+      if (code2 === "ENOENT") {
+        return [];
+      }
+      if (code2 === "EACCES" || code2 === "EPERM") {
+        const message = `Failed to read plan directory ${plansDir}: ${err2 instanceof Error ? err2.message : String(err2)}`;
+        this.warnings.push(message);
+        this.debugLogger.warn(message, err2);
+        return [];
+      }
+      throw err2;
+    }
+  }
   /**
    * Returns the file path for this session's plan file.
    */
   getPlanFilePath() {
-    return Storage.getPlanFilePath(this.sessionId);
+    return path63.join(
+      this.plansDir,
+      `${Storage.sanitizePlanSessionId(this.sessionId)}.md`
+    );
   }
   /**
    * Saves a plan to disk for the current session.
    */
   savePlan(plan) {
+    this.assertPlansDirWithinTargetDir();
     const filePath = this.getPlanFilePath();
     const dir = path63.dirname(filePath);
     fs63.mkdirSync(dir, { recursive: true });
-    fs63.writeFileSync(filePath, plan, "utf-8");
+    const tmpPath = filePath + ".tmp";
+    fs63.writeFileSync(tmpPath, plan, "utf-8");
+    try {
+      fs63.renameSync(tmpPath, filePath);
+    } catch (err2) {
+      if (err2.code !== "EXDEV") {
+        throw err2;
+      }
+      fs63.copyFileSync(tmpPath, filePath);
+      fs63.unlinkSync(tmpPath);
+    }
+    try {
+      this.assertPlanFilePathWithinTargetDir(filePath);
+    } catch (err2) {
+      try {
+        fs63.unlinkSync(filePath);
+      } catch {
+      }
+      throw err2;
+    }
   }
   /**
    * Loads the plan for the current session, or returns undefined if none exists.
    */
   loadPlan() {
+    this.assertPlansDirWithinTargetDir();
     const filePath = this.getPlanFilePath();
+    this.assertPlanFilePathWithinTargetDir(filePath);
     try {
       return fs63.readFileSync(filePath, "utf-8");
     } catch (error) {
@@ -103047,21 +103192,21 @@ var Config = class {
       if (options2?.forSubAgent) return;
       const schema = this.jsonSchema;
       await registerLazy(ToolNames.STRUCTURED_OUTPUT, async () => {
-        const { SyntheticOutputTool } = await import("./syntheticOutput-S4DRGMQM.js");
+        const { SyntheticOutputTool } = await import("./syntheticOutput-HFL3DE7R.js");
         return new SyntheticOutputTool(schema);
       });
     }, "registerStructuredOutputIfRequested");
     if (this.getBareMode()) {
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-WWUQVNCZ.js");
+        const { ReadFileTool } = await import("./read-file-CQOF7BQ2.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-VNAZBIZR.js");
+        const { EditTool } = await import("./edit-74Q4AFHQ.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-IAOKGIJ6.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-E2HMCBGR.js");
         return new ShellTool2(this);
       });
       await registerStructuredOutputIfRequested();
@@ -103071,31 +103216,31 @@ var Config = class {
       return registry;
     }
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-MSJ6SXLI.js");
+      const { ToolSearchTool } = await import("./tool-search-U4XQVLFU.js");
       return new ToolSearchTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-LIAWUWAO.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-ZNQPH67I.js");
       return new AgentTool2(this);
     });
     await registerLazy(ToolNames.TASK_STOP, async () => {
-      const { TaskStopTool } = await import("./task-stop-7THHVAQS.js");
+      const { TaskStopTool } = await import("./task-stop-ZQF26RXS.js");
       return new TaskStopTool(this);
     });
     await registerLazy(ToolNames.SEND_MESSAGE, async () => {
-      const { SendMessageTool } = await import("./send-message-Q2JRAC3J.js");
+      const { SendMessageTool } = await import("./send-message-GB4AQZNC.js");
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-NHW6222K.js");
+      const { SkillTool } = await import("./skill-KDZH6UZ6.js");
       return new SkillTool(this);
     });
     await registerLazy(ToolNames.LS, async () => {
-      const { LSTool } = await import("./ls-SUILOZZB.js");
+      const { LSTool } = await import("./ls-6F3VSP6S.js");
       return new LSTool(this);
     });
     await registerLazy(ToolNames.READ_FILE, async () => {
-      const { ReadFileTool } = await import("./read-file-WWUQVNCZ.js");
+      const { ReadFileTool } = await import("./read-file-CQOF7BQ2.js");
       return new ReadFileTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -103108,7 +103253,7 @@ var Config = class {
       }
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-WCOAIWL6.js");
+          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-KR5LKGTI.js");
           return new RipGrepTool2(this);
         });
       } else {
@@ -103121,81 +103266,81 @@ var Config = class {
           )
         );
         await registerLazy(ToolNames.GREP, async () => {
-          const { GrepTool } = await import("./grep-4SETMY47.js");
+          const { GrepTool } = await import("./grep-DZKSBFZK.js");
           return new GrepTool(this);
         });
       }
     } else {
       await registerLazy(ToolNames.GREP, async () => {
-        const { GrepTool } = await import("./grep-4SETMY47.js");
+        const { GrepTool } = await import("./grep-DZKSBFZK.js");
         return new GrepTool(this);
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-G7XATELV.js");
+      const { GlobTool } = await import("./glob-WEE3CJL6.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-VNAZBIZR.js");
+      const { EditTool } = await import("./edit-74Q4AFHQ.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool } = await import("./write-file-RKCENFZ5.js");
+      const { WriteFileTool } = await import("./write-file-NBLRMNGB.js");
       return new WriteFileTool(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-IAOKGIJ6.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-E2HMCBGR.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.TODO_WRITE, async () => {
-      const { TodoWriteTool } = await import("./todoWrite-WKUGUTPX.js");
+      const { TodoWriteTool } = await import("./todoWrite-U4SC643O.js");
       return new TodoWriteTool(this);
     });
     await registerLazy(ToolNames.ASK_USER_QUESTION, async () => {
-      const { AskUserQuestionTool } = await import("./askUserQuestion-QFSCBTUO.js");
+      const { AskUserQuestionTool } = await import("./askUserQuestion-WQILGUSQ.js");
       return new AskUserQuestionTool(this);
     });
     if (!this.sdkMode) {
       await registerLazy(ToolNames.EXIT_PLAN_MODE, async () => {
-        const { ExitPlanModeTool } = await import("./exitPlanMode-QZKO7GH7.js");
+        const { ExitPlanModeTool } = await import("./exitPlanMode-NBR2PK2D.js");
         return new ExitPlanModeTool(this);
       });
     }
     await registerLazy(ToolNames.ENTER_WORKTREE, async () => {
-      const { EnterWorktreeTool } = await import("./enter-worktree-FOF5YZIV.js");
+      const { EnterWorktreeTool } = await import("./enter-worktree-H72HXC7D.js");
       return new EnterWorktreeTool(this);
     });
     await registerLazy(ToolNames.EXIT_WORKTREE, async () => {
-      const { ExitWorktreeTool } = await import("./exit-worktree-Y6QVAO3C.js");
+      const { ExitWorktreeTool } = await import("./exit-worktree-FGIQO3S3.js");
       return new ExitWorktreeTool(this);
     });
     await registerLazy(ToolNames.WEB_FETCH, async () => {
-      const { WebFetchTool } = await import("./web-fetch-OZE6ZQUF.js");
+      const { WebFetchTool } = await import("./web-fetch-BRWZ4WSE.js");
       return new WebFetchTool(this);
     });
     if (this.isLspEnabled() && this.getLspClient()) {
       await registerLazy(ToolNames.LSP, async () => {
-        const { LspTool } = await import("./lsp-6TQBWVMZ.js");
+        const { LspTool } = await import("./lsp-67Y7DJN5.js");
         return new LspTool(this);
       });
     }
     await registerStructuredOutputIfRequested();
     if (this.isCronEnabled()) {
       await registerLazy(ToolNames.CRON_CREATE, async () => {
-        const { CronCreateTool } = await import("./cron-create-WUTD5ZTH.js");
+        const { CronCreateTool } = await import("./cron-create-AVI3Q267.js");
         return new CronCreateTool(this);
       });
       await registerLazy(ToolNames.CRON_LIST, async () => {
-        const { CronListTool } = await import("./cron-list-Z6RJJ4YH.js");
+        const { CronListTool } = await import("./cron-list-VN653OK5.js");
         return new CronListTool(this);
       });
       await registerLazy(ToolNames.CRON_DELETE, async () => {
-        const { CronDeleteTool } = await import("./cron-delete-N3UQYCRA.js");
+        const { CronDeleteTool } = await import("./cron-delete-ZCEGDXXV.js");
         return new CronDeleteTool(this);
       });
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-JTLJBJ7H.js");
+      const { MonitorTool } = await import("./monitor-EDZWEZVS.js");
       return new MonitorTool(this);
     });
     if (!options2?.skipDiscovery) {
@@ -106321,16 +106466,16 @@ var LspServerManager = class {
       if (!config.socket) {
         throw new Error("LSP socket transport requires host/port or path");
       }
-      let process7;
+      let process8;
       if (config.command) {
-        process7 = spawn7(config.command, config.args ?? [], {
+        process8 = spawn7(config.command, config.args ?? [], {
           cwd: workspaceFolder,
           env: env2,
           stdio: "ignore"
         });
         await new Promise((resolve29, reject) => {
-          process7?.once("spawn", () => resolve29());
-          process7?.once("error", (error) => {
+          process8?.once("spawn", () => resolve29());
+          process8?.once("error", (error) => {
             reject(new Error(`Failed to spawn LSP server: ${error.message}`));
           });
         });
@@ -106342,7 +106487,7 @@ var LspServerManager = class {
         );
         return {
           connection: lspConnection.connection,
-          process: process7,
+          process: process8,
           shutdown: /* @__PURE__ */ __name(async () => {
             await lspConnection.connection.shutdown();
           }, "shutdown"),
@@ -106352,8 +106497,8 @@ var LspServerManager = class {
           initialize: /* @__PURE__ */ __name(async (params) => lspConnection.connection.initialize(params), "initialize")
         };
       } catch (error) {
-        if (process7 && process7.exitCode === null) {
-          process7.kill();
+        if (process8 && process8.exitCode === null) {
+          process8.kill();
         }
         throw error;
       }
@@ -109003,6 +109148,8 @@ init_esbuild_shims();
 import crypto5 from "node:crypto";
 var crawlCache = /* @__PURE__ */ new Map();
 var cacheTimers = /* @__PURE__ */ new Map();
+var MAX_CACHE_ENTRIES = 256;
+var MAX_TOTAL_PATHS = 5e4;
 var getCacheKey = /* @__PURE__ */ __name((directory, ignoreContent, maxDepth, maxFiles, useGitignore = true) => {
   const hash = crypto5.createHash("sha256");
   hash.update(directory);
@@ -109016,11 +109163,58 @@ var getCacheKey = /* @__PURE__ */ __name((directory, ignoreContent, maxDepth, ma
   }
   return hash.digest("hex");
 }, "getCacheKey");
-var read2 = /* @__PURE__ */ __name((key) => crawlCache.get(key), "read");
+var read2 = /* @__PURE__ */ __name((key) => {
+  const result = crawlCache.get(key);
+  if (result !== void 0) {
+    crawlCache.delete(key);
+    crawlCache.set(key, result);
+  }
+  return result;
+}, "read");
 var write2 = /* @__PURE__ */ __name((key, results, ttlMs) => {
   if (cacheTimers.has(key)) {
     clearTimeout(cacheTimers.get(key));
   }
+  while (crawlCache.size >= MAX_CACHE_ENTRIES && !crawlCache.has(key)) {
+    const oldestKey = crawlCache.keys().next().value;
+    if (oldestKey) {
+      crawlCache.delete(oldestKey);
+      if (cacheTimers.has(oldestKey)) {
+        clearTimeout(cacheTimers.get(oldestKey));
+        cacheTimers.delete(oldestKey);
+      }
+    }
+  }
+  let totalPaths = 0;
+  for (const [k, entry] of crawlCache) {
+    if (k !== key) {
+      totalPaths += entry.length;
+    }
+  }
+  while (totalPaths + results.length > MAX_TOTAL_PATHS && crawlCache.size > 0) {
+    let largestKey;
+    let largestSize = 0;
+    for (const [k, v] of crawlCache) {
+      if (k === key) continue;
+      if (v.length > largestSize) {
+        largestSize = v.length;
+        largestKey = k;
+      }
+    }
+    if (largestKey) {
+      totalPaths -= crawlCache.get(largestKey).length;
+      crawlCache.delete(largestKey);
+      if (cacheTimers.has(largestKey)) {
+        clearTimeout(cacheTimers.get(largestKey));
+        cacheTimers.delete(largestKey);
+      }
+    } else {
+      break;
+    }
+  }
+  if (crawlCache.has(key)) {
+    crawlCache.delete(key);
+  }
   crawlCache.set(key, results);
   const timerId = setTimeout(() => {
     crawlCache.delete(key);
@@ -111834,6 +112028,205 @@ async function runGit(args2, cwd2) {
 }
 __name(runGit, "runGit");
 
+// packages/core/src/utils/memoryDiagnostics.ts
+init_esbuild_shims();
+import { readdir as readdir14, readFile as readFile25 } from "node:fs/promises";
+import process7 from "node:process";
+import v8 from "node:v8";
+var RSS_HEAP_GAP_RATIO = 10;
+var RSS_HEAP_GAP_MIN_BYTES = 256 * 1024 * 1024;
+var NATIVE_MEMORY_PRESSURE_MIN_BYTES = 64 * 1024 * 1024;
+var ACTIVE_HANDLES_THRESHOLD = 256;
+var ACTIVE_REQUESTS_THRESHOLD = 100;
+var OPEN_FD_THRESHOLD = 500;
+var debugLogger89 = createDebugLogger("MEMORY_DIAGNOSTICS");
+async function collectMemoryDiagnostics(options2 = {}) {
+  const now = options2.now ?? (() => /* @__PURE__ */ new Date());
+  const platform8 = options2.platform ?? process7.platform;
+  const memoryUsage = options2.memoryUsage?.() ?? process7.memoryUsage();
+  const heapStatistics = options2.heapStatistics?.() ?? v8.getHeapStatistics();
+  const resourceUsage = options2.resourceUsage?.() ?? process7.resourceUsage();
+  const uptimeSeconds = options2.uptimeSeconds?.() ?? process7.uptime();
+  const [openFileDescriptors, smapsRollup, heapSpaceStatistics] = await Promise.all([
+    optionalProbe(
+      "openFileDescriptors",
+      options2.openFileDescriptors ?? countOpenFileDescriptors
+    ),
+    optionalProbe("smapsRollup", options2.smapsRollup ?? readProcSmapsRollup),
+    optionalSyncProbe(
+      "heapSpaceStatistics",
+      options2.heapSpaceStatistics ?? (() => v8.getHeapSpaceStatistics())
+    )
+  ]);
+  const v8HeapSpaces = mapHeapSpaces(heapSpaceStatistics);
+  const maxRSSBytes = resourceUsage.maxRSS;
+  const diagnostics = {
+    timestamp: now().toISOString(),
+    sessionId: options2.sessionId,
+    qwenVersion: options2.qwenVersion,
+    uptimeSeconds,
+    memoryUsage,
+    v8HeapStats: mapHeapStats(heapStatistics),
+    v8HeapSpaces,
+    resourceUsage: {
+      maxRSS: maxRSSBytes,
+      userCPUTime: resourceUsage.userCPUTime,
+      systemCPUTime: resourceUsage.systemCPUTime
+    },
+    activeHandles: getProcessInternalCount(
+      "activeHandles",
+      "_getActiveHandles",
+      options2.activeHandles
+    ),
+    activeRequests: getProcessInternalCount(
+      "activeRequests",
+      "_getActiveRequests",
+      options2.activeRequests
+    ),
+    openFileDescriptors,
+    smapsRollup,
+    platform: platform8,
+    nodeVersion: options2.nodeVersion ?? process7.version
+  };
+  return {
+    ...diagnostics,
+    analysis: analyzeMemoryDiagnostics(diagnostics)
+  };
+}
+__name(collectMemoryDiagnostics, "collectMemoryDiagnostics");
+function mapHeapStats(heapInfo) {
+  return {
+    heapSizeLimit: heapInfo.heap_size_limit,
+    totalHeapSize: heapInfo.total_heap_size,
+    usedHeapSize: heapInfo.used_heap_size,
+    mallocedMemory: heapInfo.malloced_memory,
+    peakMallocedMemory: heapInfo.peak_malloced_memory,
+    detachedContexts: heapInfo.number_of_detached_contexts,
+    nativeContexts: heapInfo.number_of_native_contexts
+  };
+}
+__name(mapHeapStats, "mapHeapStats");
+function mapHeapSpaces(heapSpaces) {
+  if (!heapSpaces) {
+    return null;
+  }
+  return heapSpaces.map((space) => ({
+    name: space.space_name,
+    size: space.space_size,
+    used: space.space_used_size,
+    available: space.space_available_size
+  }));
+}
+__name(mapHeapSpaces, "mapHeapSpaces");
+function getProcessInternalCount(name3, internalMethod, probe) {
+  try {
+    if (probe) {
+      return probe();
+    }
+    const internals = process7;
+    const internalProbe = internals[internalMethod];
+    if (typeof internalProbe !== "function") {
+      logProbeFailure(name3, new Error(`${internalMethod} is unavailable`));
+      return 0;
+    }
+    const result = internalProbe();
+    if (!Array.isArray(result)) {
+      logProbeFailure(
+        name3,
+        new Error(`${internalMethod} returned a non-array result`)
+      );
+      return 0;
+    }
+    return result.length;
+  } catch (error) {
+    logProbeFailure(name3, error);
+    return 0;
+  }
+}
+__name(getProcessInternalCount, "getProcessInternalCount");
+async function countOpenFileDescriptors() {
+  return (await readdir14("/proc/self/fd")).length;
+}
+__name(countOpenFileDescriptors, "countOpenFileDescriptors");
+async function readProcSmapsRollup() {
+  return readFile25("/proc/self/smaps_rollup", "utf8");
+}
+__name(readProcSmapsRollup, "readProcSmapsRollup");
+async function optionalProbe(name3, probe) {
+  try {
+    return await probe();
+  } catch (error) {
+    logProbeFailure(name3, error);
+    return null;
+  }
+}
+__name(optionalProbe, "optionalProbe");
+async function optionalSyncProbe(name3, probe) {
+  try {
+    return probe();
+  } catch (error) {
+    logProbeFailure(name3, error);
+    return null;
+  }
+}
+__name(optionalSyncProbe, "optionalSyncProbe");
+function logProbeFailure(name3, error) {
+  debugLogger89.debug(`memory diagnostics probe failed: ${name3}`, error);
+}
+__name(logProbeFailure, "logProbeFailure");
+function analyzeMemoryDiagnostics(diagnostics) {
+  const risks = [];
+  const heapRatio = diagnostics.v8HeapStats.heapSizeLimit > 0 ? diagnostics.v8HeapStats.usedHeapSize / diagnostics.v8HeapStats.heapSizeLimit : 0;
+  if (heapRatio >= 0.75) {
+    risks.push({
+      type: "heap-pressure",
+      message: `Heap usage is ${(heapRatio * 100).toFixed(1)}% of the V8 limit.`
+    });
+  }
+  if (diagnostics.v8HeapStats.detachedContexts > 0) {
+    risks.push({
+      type: "detached-contexts",
+      message: `${diagnostics.v8HeapStats.detachedContexts} detached V8 context(s) detected.`
+    });
+  }
+  if (diagnostics.activeHandles > ACTIVE_HANDLES_THRESHOLD) {
+    risks.push({
+      type: "active-handles",
+      message: `${diagnostics.activeHandles} active handle(s) detected.`
+    });
+  }
+  if (diagnostics.activeRequests > ACTIVE_REQUESTS_THRESHOLD) {
+    risks.push({
+      type: "active-requests",
+      message: `${diagnostics.activeRequests} active request(s) detected.`
+    });
+  }
+  if (diagnostics.openFileDescriptors !== null && diagnostics.openFileDescriptors > OPEN_FD_THRESHOLD) {
+    risks.push({
+      type: "fd-leak",
+      message: `${diagnostics.openFileDescriptors} open file descriptor(s) detected.`
+    });
+  }
+  const nativeMemory = diagnostics.v8HeapStats.mallocedMemory;
+  if (nativeMemory >= NATIVE_MEMORY_PRESSURE_MIN_BYTES && nativeMemory > diagnostics.memoryUsage.heapUsed * 2) {
+    risks.push({
+      type: "native-memory-pressure",
+      message: `V8 native malloced memory (${formatMemoryUsage(nativeMemory)}) is more than 2\xD7 heap used (${formatMemoryUsage(diagnostics.memoryUsage.heapUsed)}).`
+    });
+  }
+  if (diagnostics.memoryUsage.heapUsed > 0 && diagnostics.memoryUsage.rss >= RSS_HEAP_GAP_MIN_BYTES && diagnostics.memoryUsage.rss > diagnostics.memoryUsage.heapUsed * RSS_HEAP_GAP_RATIO) {
+    risks.push({
+      type: "rss-heap-gap",
+      message: `RSS (${formatMemoryUsage(diagnostics.memoryUsage.rss)}) is more than ${RSS_HEAP_GAP_RATIO}\xD7 heap used (${formatMemoryUsage(diagnostics.memoryUsage.heapUsed)}). Check native addons, libuv buffers, mapped files, or retained tool output.`
+    });
+  }
+  return {
+    risks,
+    recommendation: risks.length > 0 ? `${risks.length} potential leak indicator(s) found.` : "No obvious leak indicators detected."
+  };
+}
+__name(analyzeMemoryDiagnostics, "analyzeMemoryDiagnostics");
+
 // packages/core/src/utils/pathReader.ts
 init_esbuild_shims();
 import { promises as fs73 } from "node:fs";
@@ -114140,7 +114533,7 @@ __name(shouldDefaultToNodePty, "shouldDefaultToNodePty");
 // packages/core/src/services/shellExecutionService.ts
 var import_headless = __toESM(require_xterm_headless(), 1);
 var { Terminal } = import_headless.default;
-var debugLogger89 = createDebugLogger("SHELL_EXECUTION");
+var debugLogger90 = createDebugLogger("SHELL_EXECUTION");
 var SIGKILL_TIMEOUT_MS = 200;
 var PROMOTE_DRAIN_TIMEOUT_MS = 200;
 function getShellAbortReasonKind(reason) {
@@ -114459,13 +114852,13 @@ var ShellExecutionService = class _ShellExecutionService {
         const performBackgroundPromote = /* @__PURE__ */ __name(() => {
           if (!child.pid || exited) return;
           if (child.exitCode !== null || child.signalCode !== null) {
-            debugLogger89.debug(
+            debugLogger90.debug(
               `Background-promote requested for pid ${child.pid} but child is already terminal (exitCode=${child.exitCode}, signalCode=${child.signalCode}); falling through to the normal exit-handled resolution.`
             );
             return;
           }
           if (streamStdout) {
-            debugLogger89.warn(
+            debugLogger90.warn(
               "Background-promote on a streamStdout=true child_process: snapshot accumulators were never populated (output went through onOutputEvent), so result.output will be empty. Caller should fall back to rawOutput, or assemble its own snapshot from the data events it received."
             );
           }
@@ -114499,7 +114892,7 @@ var ShellExecutionService = class _ShellExecutionService {
                   chunk: decoder.decode(chunk, { stream: true })
                 });
               } catch (cbErr) {
-                debugLogger89.warn(
+                debugLogger90.warn(
                   `postPromote.onData threw: ${cbErr instanceof Error ? cbErr.message : String(cbErr)}`
                 );
               }
@@ -114514,7 +114907,7 @@ var ShellExecutionService = class _ShellExecutionService {
                 child.stderr?.on("data", postPromoteStderrHandler);
               }
             } catch (e) {
-              debugLogger89.warn(
+              debugLogger90.warn(
                 `re-attaching post-promote data listeners threw: ${e instanceof Error ? e.message : String(e)}`
               );
             }
@@ -114523,7 +114916,7 @@ var ShellExecutionService = class _ShellExecutionService {
               child.stdout?.resume();
               child.stderr?.resume();
             } catch (e) {
-              debugLogger89.warn(
+              debugLogger90.warn(
                 `post-promote stdout/stderr resume() threw: ${e instanceof Error ? e.message : String(e)}`
               );
             }
@@ -114551,7 +114944,7 @@ var ShellExecutionService = class _ShellExecutionService {
                 }
               }
             } catch (flushErr) {
-              debugLogger89.warn(
+              debugLogger90.warn(
                 `post-promote decoder flush threw: ${flushErr instanceof Error ? flushErr.message : String(flushErr)}`
               );
             }
@@ -114572,7 +114965,7 @@ var ShellExecutionService = class _ShellExecutionService {
             try {
               postPromote.onSettle(info2);
             } catch (cbErr) {
-              debugLogger89.warn(
+              debugLogger90.warn(
                 `postPromote.onSettle threw: ${cbErr instanceof Error ? cbErr.message : String(cbErr)}`
               );
             }
@@ -114598,7 +114991,7 @@ var ShellExecutionService = class _ShellExecutionService {
                 });
               });
             } catch (e) {
-              debugLogger89.warn(
+              debugLogger90.warn(
                 `re-attaching post-promote exit/error listeners threw: ${e instanceof Error ? e.message : String(e)}`
               );
             }
@@ -114934,7 +115327,7 @@ var ShellExecutionService = class _ShellExecutionService {
         const performBackgroundPromote = /* @__PURE__ */ __name(async () => {
           if (!ptyProcess.pid || exited) return;
           if (!_ShellExecutionService.isPtyActive(ptyProcess.pid)) {
-            debugLogger89.debug(
+            debugLogger90.debug(
               `Background-promote requested for PTY pid ${ptyProcess.pid} but the process is no longer alive (process.kill(pid, 0) failed); falling through to normal exit-handled resolution.`
             );
             return;
@@ -114945,21 +115338,21 @@ var ShellExecutionService = class _ShellExecutionService {
           try {
             dataDisposable.dispose();
           } catch (e) {
-            debugLogger89.warn(
+            debugLogger90.warn(
               `dataDisposable.dispose() threw during background-promote: ${e instanceof Error ? e.message : String(e)}`
             );
           }
           try {
             exitDisposable.dispose();
           } catch (e) {
-            debugLogger89.warn(
+            debugLogger90.warn(
               `exitDisposable.dispose() threw during background-promote: ${e instanceof Error ? e.message : String(e)}`
             );
           }
           try {
             ptyProcess.removeListener("error", ptyErrorHandler);
           } catch (e) {
-            debugLogger89.warn(
+            debugLogger90.warn(
               `ptyProcess.removeListener('error') threw during background-promote: ${e instanceof Error ? e.message : String(e)}`
             );
           }
@@ -114977,7 +115370,7 @@ var ShellExecutionService = class _ShellExecutionService {
               try {
                 postPromoteDataDisposable.dispose();
               } catch (e) {
-                debugLogger89.warn(
+                debugLogger90.warn(
                   `disposing post-promote data listener threw: ${e instanceof Error ? e.message : String(e)}`
                 );
               }
@@ -114987,7 +115380,7 @@ var ShellExecutionService = class _ShellExecutionService {
               try {
                 postPromoteExitDisposable.dispose();
               } catch (e) {
-                debugLogger89.warn(
+                debugLogger90.warn(
                   `disposing post-promote exit listener threw: ${e instanceof Error ? e.message : String(e)}`
                 );
               }
@@ -114997,7 +115390,7 @@ var ShellExecutionService = class _ShellExecutionService {
               try {
                 ptyProcess.removeListener("error", postPromoteErrorListener);
               } catch (e) {
-                debugLogger89.warn(
+                debugLogger90.warn(
                   `removing post-promote error listener threw: ${e instanceof Error ? e.message : String(e)}`
                 );
               }
@@ -115012,7 +115405,7 @@ var ShellExecutionService = class _ShellExecutionService {
             try {
               postPromote.onSettle(info2);
             } catch (cbErr) {
-              debugLogger89.warn(
+              debugLogger90.warn(
                 `postPromote.onSettle threw: ${cbErr instanceof Error ? cbErr.message : String(cbErr)}`
               );
             }
@@ -115024,13 +115417,13 @@ var ShellExecutionService = class _ShellExecutionService {
                 try {
                   onPostData({ type: "data", chunk: data });
                 } catch (cbErr) {
-                  debugLogger89.warn(
+                  debugLogger90.warn(
                     `postPromote.onData threw: ${cbErr instanceof Error ? cbErr.message : String(cbErr)}`
                   );
                 }
               });
             } catch (e) {
-              debugLogger89.warn(
+              debugLogger90.warn(
                 `re-attaching post-promote data listener threw: ${e instanceof Error ? e.message : String(e)}`
               );
             }
@@ -115050,7 +115443,7 @@ var ShellExecutionService = class _ShellExecutionService {
                 }
               );
             } catch (e) {
-              debugLogger89.warn(
+              debugLogger90.warn(
                 `re-attaching post-promote exit listener threw: ${e instanceof Error ? e.message : String(e)}`
               );
             }
@@ -115068,7 +115461,7 @@ var ShellExecutionService = class _ShellExecutionService {
               }, "postPromoteErrorListener");
               ptyProcess.on("error", postPromoteErrorListener);
             } catch (e) {
-              debugLogger89.warn(
+              debugLogger90.warn(
                 `re-attaching post-promote error listener threw: ${e instanceof Error ? e.message : String(e)}`
               );
             }
@@ -115084,7 +115477,7 @@ var ShellExecutionService = class _ShellExecutionService {
             )
           ]);
           if (winner === TIMEOUT_SENTINEL) {
-            debugLogger89.warn(
+            debugLogger90.warn(
               `Background-promote drain hit the ${PROMOTE_DRAIN_TIMEOUT_MS}ms timeout before processingChain settled. The output snapshot may be missing the very last batch of bytes the PTY emitted before promote (rawOutput in the result still has the full buffer the caller can re-render).`
             );
           }
@@ -115101,7 +115494,7 @@ var ShellExecutionService = class _ShellExecutionService {
               snapshot = serializeTerminalToText(headlessTerminal) ?? "";
             }
           } catch (serErr) {
-            debugLogger89.warn(
+            debugLogger90.warn(
               `Background-promote snapshot replay failed: ${serErr instanceof Error ? serErr.message : String(serErr)}. Falling back to direct headlessTerminal serialize; if that also fails, output stays empty.`
             );
             try {
@@ -115261,7 +115654,7 @@ var ShellExecutionService = class _ShellExecutionService {
 
 // packages/core/src/tools/shell.ts
 var import_shell_quote6 = __toESM(require_shell_quote(), 1);
-var debugLogger90 = createDebugLogger("SHELL");
+var debugLogger91 = createDebugLogger("SHELL");
 function stripTrailingBackgroundAmp2(command) {
   const trimmed2 = command.trimEnd();
   if (!trimmed2.endsWith("&")) return command;
@@ -115344,7 +115737,7 @@ function tokeniseSegment(segment) {
       (t) => typeof t === "string"
     );
   } catch (e) {
-    debugLogger90.warn(
+    debugLogger91.warn(
       `tokeniseSegment: parse failed for "${segment.slice(0, 80)}": ${e instanceof Error ? e.message : String(e)}`
     );
     return null;
@@ -115571,7 +115964,7 @@ function findAttributableCommitSegment(command) {
   for (const sub of splitCommands(command)) {
     const start2 = command.indexOf(sub, cursor);
     if (start2 < 0) {
-      debugLogger90.warn(
+      debugLogger91.warn(
         `findAttributableCommitSegment: cannot map segment "${sub.slice(0, 60)}" back to the original command (likely line-continuation / whitespace mismatch).`
       );
       continue;
@@ -115605,7 +115998,7 @@ function findGhPrCreateSegment(command) {
   for (const sub of splitCommands(command)) {
     const start2 = command.indexOf(sub, cursor);
     if (start2 < 0) {
-      debugLogger90.warn(
+      debugLogger91.warn(
         `findGhPrCreateSegment: cannot map segment "${sub.slice(0, 60)}" back to the original command (likely line-continuation / whitespace mismatch).`
       );
       continue;
@@ -115970,7 +116363,7 @@ var ShellToolInvocation = class extends BaseToolInvocation {
         return "allow";
       }
     } catch (e) {
-      debugLogger90.warn("AST read-only check failed, falling back to ask:", e);
+      debugLogger91.warn("AST read-only check failed, falling back to ask:", e);
     }
     return "ask";
   }
@@ -116001,7 +116394,7 @@ var ShellToolInvocation = class extends BaseToolInvocation {
             continue;
           }
         } catch (e) {
-          debugLogger90.warn("PermissionManager command check failed:", e);
+          debugLogger91.warn("PermissionManager command check failed:", e);
         }
       }
       confirmableSubCommands.push(sub);
@@ -116021,7 +116414,7 @@ var ShellToolInvocation = class extends BaseToolInvocation {
       }
       permissionRules = [...new Set(allRules)].map((rule) => `Bash(${rule})`);
     } catch (e) {
-      debugLogger90.warn("Failed to extract command rules:", e);
+      debugLogger91.warn("Failed to extract command rules:", e);
     }
     const confirmationDetails = {
       type: "exec",
@@ -116165,12 +116558,12 @@ var ShellToolInvocation = class extends BaseToolInvocation {
           try {
             promoteArtifacts.stream.write(chunk);
           } catch (err2) {
-            debugLogger90.warn(
+            debugLogger91.warn(
               `promote: postPromote stream.write failed: ${getErrorMessage(err2)}`
             );
           }
         } else if (promoteArtifacts.streamClosed) {
-          debugLogger90.debug(
+          debugLogger91.debug(
             "promote: dropping post-promote chunk because output stream open failed"
           );
         } else {
@@ -116276,7 +116669,7 @@ ${result.output}`;
     const elapsedMs = performance.now() - executionStartTime;
     const longRunThreshold = longRunThresholdFor(effectiveTimeout);
     const shouldAppendLongRunHint = !result.aborted && result.signal === null && elapsedMs >= longRunThreshold;
-    debugLogger90.debug(
+    debugLogger91.debug(
       `long-run hint: elapsed=${Math.round(elapsedMs)}ms threshold=${longRunThreshold}ms aborted=${result.aborted} signal=${result.signal} \u2192 ${shouldAppendLongRunHint ? "fire" : "suppress"}`
     );
     let returnDisplayMessage = "";
@@ -116374,7 +116767,7 @@ ${longRunHint}` : ""),
       mkdirError = err2 instanceof Error ? err2 : new Error(String(err2));
     }
     if (mkdirError) {
-      debugLogger90.warn(
+      debugLogger91.warn(
         `promote: mkdirSync(${outputDir}) failed before registry register \u2014 killing orphan child: ${mkdirError.message}`
       );
       const pid = result.pid;
@@ -116406,7 +116799,7 @@ ${longRunHint}` : ""),
     try {
       outputStream = fs77.createWriteStream(outputPath, { flags: "w" });
       outputStream.on("error", (err2) => {
-        debugLogger90.warn(
+        debugLogger91.warn(
           `promote: output write stream error for ${outputPath}: ${getErrorMessage(err2)}`
         );
         const droppedChunks = promoteArtifacts.buffer.length;
@@ -116429,13 +116822,13 @@ ${longRunHint}` : ""),
         outputStream.write(chunk);
       }
     } catch (err2) {
-      debugLogger90.warn(
+      debugLogger91.warn(
         `promote: failed to open output stream for ${outputPath}: ${getErrorMessage(err2)}`
       );
       promoteArtifacts.stream = null;
       promoteArtifacts.streamClosed = true;
       if (promoteArtifacts.buffer.length > 0) {
-        debugLogger90.warn(
+        debugLogger91.warn(
           `promote: dropping ${promoteArtifacts.buffer.length} buffered post-promote chunks for ${outputPath} (stream open failed before drain)`
         );
         promoteArtifacts.buffer.length = 0;
@@ -116443,7 +116836,7 @@ ${longRunHint}` : ""),
       try {
         fs77.writeFileSync(outputPath, result.output);
       } catch (err22) {
-        debugLogger90.warn(
+        debugLogger91.warn(
           `promote: snapshot fallback writeFileSync also failed for ${outputPath}: ${getErrorMessage(err22)}`
         );
       }
@@ -116463,12 +116856,12 @@ ${longRunHint}` : ""),
               "/t"
             ]);
             taskkillChild.on("error", (err2) => {
-              debugLogger90.warn(
+              debugLogger91.warn(
                 `promote: taskkill spawn failed for pid=${pid}: ${err2.message}`
               );
             });
           } catch (e) {
-            debugLogger90.warn(
+            debugLogger91.warn(
               `promote: childProcess.spawn('taskkill') threw for pid=${pid}: ${getErrorMessage(e)}`
             );
           }
@@ -116483,7 +116876,7 @@ ${longRunHint}` : ""),
             } catch {
             }
           } catch (e) {
-            debugLogger90.warn(
+            debugLogger91.warn(
               `promote: process.kill on -${pid} threw: ${getErrorMessage(e)}`
             );
           }
@@ -116512,7 +116905,7 @@ ${longRunHint}` : ""),
     try {
       registry.register(entry);
     } catch (e) {
-      debugLogger90.warn(
+      debugLogger91.warn(
         `promote: registry.register threw for ${shellId} (pid=${result.pid}) \u2014 killing orphan child: ${e instanceof Error ? e.message : String(e)}`
       );
       try {
@@ -116541,7 +116934,7 @@ ${longRunHint}` : ""),
           status: "failed",
           failMsg: `Terminated by signal ${info2.signal}`
         };
-      debugLogger90.warn(
+      debugLogger91.warn(
         `promote: classifySettle all-null fallback hit for ${shellId} \u2014 exitCode=${info2.exitCode}, signal=${info2.signal}, error=undefined`
       );
       return {
@@ -116567,7 +116960,7 @@ ${longRunHint}` : ""),
           try {
             stream2.write(promoteArtifacts.buffer.shift());
           } catch (writeErr) {
-            debugLogger90.warn(
+            debugLogger91.warn(
               `promote: pre-end buffer drain write failed: ${getErrorMessage(writeErr)}`
             );
           }
@@ -116587,7 +116980,7 @@ ${longRunHint}` : ""),
           transitionRegistry(info2);
         }, "finalize");
         const flushTimer = setTimeout(() => {
-          debugLogger90.warn(
+          debugLogger91.warn(
             `promote: output stream flush timed out for ${shellId} after ${PROMOTE_FLUSH_TIMEOUT_MS}ms \u2014 transitioning registry without flush confirmation`
           );
           finalize();
@@ -116603,7 +116996,7 @@ ${longRunHint}` : ""),
         });
         stream2.end();
       } catch (closeErr) {
-        debugLogger90.warn(
+        debugLogger91.warn(
           `promote: closing output stream on settle threw: ${getErrorMessage(closeErr)}`
         );
         transitionRegistry(info2);
@@ -116624,7 +117017,7 @@ ${longRunHint}` : ""),
       inspectLine,
       stopLine
     ].join("\n");
-    debugLogger90.debug(
+    debugLogger91.debug(
       `promote: registered ${shellId} (pid=${result.pid}) \u2014 outputPath=${outputPath}`
     );
     return {
@@ -116650,7 +117043,7 @@ ${longRunHint}` : ""),
     const trimmedOriginal = this.params.command.trim();
     const noTrailingAmp = stripTrailingBackgroundAmp2(trimmedOriginal);
     if (noTrailingAmp !== trimmedOriginal) {
-      debugLogger90.warn(
+      debugLogger91.warn(
         "Stripped trailing & from background shell command \u2014 managed path handles backgrounding"
       );
     }
@@ -116669,7 +117062,7 @@ ${longRunHint}` : ""),
     const entryAc = new AbortController();
     const outputStream = fs77.createWriteStream(outputPath, { flags: "w" });
     outputStream.on("error", (err2) => {
-      debugLogger90.warn(
+      debugLogger91.warn(
         `background shell ${shellId} output write error: ${err2.message}`
       );
     });
@@ -116707,7 +117100,7 @@ ${longRunHint}` : ""),
     try {
       registry.register(registration);
     } catch (e) {
-      debugLogger90.warn(
+      debugLogger91.warn(
         `background shell ${shellId} register threw (pid=${pid}) \u2014 aborting orphan child: ${e instanceof Error ? e.message : String(e)}`
       );
       try {
@@ -116878,7 +117271,7 @@ To inspect: /tasks (text) or the interactive Background tasks dialog (focus the
     const commitCount = preHead !== null ? await this.countCommitsAfter(cwd2, preHead, postHead) : await this.countCommitsFromRoot(cwd2, postHead);
     if (commitCount !== 1) {
       const reason = commitCount === 0 ? "commit count unavailable (rev-list failed) after HEAD moved \u2014 refusing to assume single commit" : `multi-commit shell command (${commitCount} commits since ${preHead ? preHead.slice(0, 12) : "repo root"})`;
-      debugLogger90.warn(`Refusing AI attribution: ${reason}.`);
+      debugLogger91.warn(`Refusing AI attribution: ${reason}.`);
       attributionService.noteCommitWithoutClearing();
       return null;
     }
@@ -116949,7 +117342,7 @@ To inspect: /tasks (text) or the interactive Background tasks dialog (focus the
       );
       const notesCommand = buildGitNotesCommand(note, postHead);
       if (!notesCommand) {
-        debugLogger90.warn(
+        debugLogger91.warn(
           "AI attribution note too large, skipping git notes attachment"
         );
         warning = "AI attribution note skipped: payload exceeded the 30 KB size cap (large generated-file exclusion list?). Co-authored-by trailer is unaffected.";
@@ -116981,20 +117374,20 @@ To inspect: /tasks (text) or the interactive Background tasks dialog (focus the
       });
       if (exitCode !== 0) {
         if (timedOut) {
-          debugLogger90.warn(`git notes timed out after 5s: ${output}`);
+          debugLogger91.warn(`git notes timed out after 5s: ${output}`);
           warning = "AI attribution note skipped: `git notes add` timed out after 5s" + (output ? ` (${output.trim().slice(0, 120)})` : "") + ". Co-authored-by trailer is unaffected.";
         } else {
-          debugLogger90.warn(`git notes exited with code ${exitCode}: ${output}`);
+          debugLogger91.warn(`git notes exited with code ${exitCode}: ${output}`);
           warning = `AI attribution note skipped: \`git notes add\` exited ${exitCode}` + (output ? ` (${output.trim().slice(0, 120)})` : "") + ". Co-authored-by trailer is unaffected.";
         }
       } else {
-        debugLogger90.debug(
+        debugLogger91.debug(
           `Attached AI attribution note: ${note.summary.aiPercent}% AI, ${note.summary.totalFilesTouched} file(s)`
         );
         shouldClear = committedAbsolutePaths;
       }
     } catch (err2) {
-      debugLogger90.warn(
+      debugLogger91.warn(
         `Failed to attach AI attribution note: ${getErrorMessage(err2)}`
       );
       warning = `AI attribution note skipped: ${getErrorMessage(err2)}. Co-authored-by trailer is unaffected.`;
@@ -117059,14 +117452,14 @@ To inspect: /tasks (text) or the interactive Background tasks dialog (focus the
       ]);
       const hasParent = hasParentOutput !== null && hasParentOutput.length > 0;
       if (parentShaOutput === null) {
-        debugLogger90.warn(
+        debugLogger91.warn(
           "getCommittedFileInfo: log -1 --pretty=%P <postHead> failed; cannot distinguish shallow clone from true root commit."
         );
         return null;
       }
       const isTrueRootCommit = parentShaOutput.trim().length === 0;
       if (!hasParent && !isTrueRootCommit) {
-        debugLogger90.warn(
+        debugLogger91.warn(
           "getCommittedFileInfo: <postHead>~1 unreadable but commit is not the true root (shallow clone?); skipping attribution to avoid attributing the entire commit contents."
         );
         return null;
@@ -117075,14 +117468,14 @@ To inspect: /tasks (text) or the interactive Background tasks dialog (focus the
       let diffArgs;
       if (isAmend) {
         if (preHead === null) {
-          debugLogger90.warn(
+          debugLogger91.warn(
             "getCommittedFileInfo: --amend with no preHead; skipping attribution note (cannot determine amend delta)."
           );
           return null;
         }
         const preHeadProbe = await runGit2(`rev-parse --verify ${preHead}`);
         if (preHeadProbe === null || preHeadProbe.length === 0) {
-          debugLogger90.warn(
+          debugLogger91.warn(
             "getCommittedFileInfo: --amend preHead unresolvable; skipping attribution note (cannot determine amend delta)."
           );
           return null;
@@ -117111,7 +117504,7 @@ To inspect: /tasks (text) or the interactive Background tasks dialog (focus the
         runGit2(diffArgs.numstat)
       ]);
       if (nameOutput === null || statusOutput === null || numstatOutput === null) {
-        debugLogger90.warn(
+        debugLogger91.warn(
           "getCommittedFileInfo: one or more diff calls failed; cannot distinguish empty commit from analysis failure."
         );
         return null;
@@ -117133,7 +117526,7 @@ To inspect: /tasks (text) or the interactive Background tasks dialog (focus the
       }
       const diffSizes = parseNumstat(numstatOutput);
       if (diffSizes.size === 0) {
-        debugLogger90.warn(
+        debugLogger91.warn(
           "getCommittedFileInfo: --numstat returned empty while --name-only listed files; skipping attribution note to avoid emitting all-zero AI percentages."
         );
         return null;
@@ -117266,7 +117659,7 @@ Co-authored-by: ${escapedName} <${escapedEmail}>`;
         return command.slice(0, idx) + replacement + command.slice(idx + fullMatch.length);
       }
     }
-    debugLogger90.warn(
+    debugLogger91.warn(
       'addAttributionToPR: gh pr create detected but no inline `--body`/`-b` argument found to append attribution to (--body-file / --fill / editor flows are unsupported); PR will be created without the AI attribution line. Pass `--body "..."` inline to enable automatic attribution.'
     );
     return command;
@@ -118068,6 +118461,7 @@ export {
   parseShortstat,
   parseDeletedFromNameStatus,
   resolveGitDir2 as resolveGitDir,
+  collectMemoryDiagnostics,
   readPathFromWorkspace,
   getWelcomeBackState,
   saveWelcomeBackRestartChoice,