@qwen-code/qwen-code 0.19.12 → 0.20.0-nightly.20260721.cda0e0348

package/chunks/{chunk-GCY7QTCE.js → chunk-NO6XTCYT.js}

@@ -37,7 +37,7 @@ import {
   CronScheduler,
   DEFAULT_RECURRING_MAX_AGE_DAYS,
   normalizeRecurringMaxAge
-} from "./chunk-LKR7QQ63.js";
+} from "./chunk-EAUYY7SS.js";
 import {
   consumeUnread,
   forwardApproval,
@@ -46,13 +46,13 @@ import {
   sendStructuredMessage,
   wrapConfirmWithBadge,
   writeMessage
-} from "./chunk-4XCVGEEX.js";
+} from "./chunk-FSL5W5TI.js";
 import {
   claimTask,
   listTasks,
   onTasksUpdated,
   unassignTeammateTasks
-} from "./chunk-XSPFQQRE.js";
+} from "./chunk-OONJNQ42.js";
 import {
   assignTeammateColor,
   classifyShutdownResponse,
@@ -60,7 +60,7 @@ import {
   formatAgentId,
   generateUniqueTeammateName,
   writeTeamFile
-} from "./chunk-4RPARQ5D.js";
+} from "./chunk-D2VIDMVM.js";
 import {
   require_proper_lockfile
 } from "./chunk-E2UVIFI2.js";
@@ -103,7 +103,7 @@ import {
   runWithRuntimeContentGenerator,
   shouldUsePlanOnlyReminderInSubagentContext,
   spawnBlockReason
-} from "./chunk-UOA2IHRI.js";
+} from "./chunk-CPCVCKKF.js";
 import {
   getTeammateContext,
   isTeammate,
@@ -114,7 +114,7 @@ import {
   escapeSystemReminderTags,
   escapeXml,
   renderAvailableSkillsBlock
-} from "./chunk-OSSDHJDU.js";
+} from "./chunk-G45X5TRN.js";
 import {
   DefaultHookOutput,
   HOOKS_CONFIG_FIELDS,
@@ -129,7 +129,7 @@ import {
   createHookOutput,
   getHookKey,
   isToolArtifactLike
-} from "./chunk-SGPFJMRP.js";
+} from "./chunk-PBATSWUQ.js";
 import {
   DEFAULT_FILE_FILTERING_OPTIONS,
   DEFAULT_QWEN_CUSTOM_IGNORE_FILE_NAMES,
@@ -139,17 +139,17 @@ import {
   getQwenIgnoreFileNames,
   isPathWithinRoot,
   require_ignore
-} from "./chunk-335ECZTA.js";
+} from "./chunk-ZEOZL37W.js";
 import {
   BaseTokenStorage,
   KeychainTokenStorage
-} from "./chunk-JCJPZMJV.js";
+} from "./chunk-OOCI5VVU.js";
 import {
   classifyRetryError,
   isFallbackEligible,
   isUnattendedMode,
   retryWithBackoff
-} from "./chunk-6ETOSWAO.js";
+} from "./chunk-246TW4IX.js";
 import {
   openBrowserSecurely,
   shouldAttemptBrowserLaunch
@@ -300,7 +300,7 @@ import {
   updateMCPServerStatus,
   writeLine,
   writeLineSync
-} from "./chunk-CPU6I5YV.js";
+} from "./chunk-P64HXIC5.js";
 import {
   E_TIMEOUT,
   Mutex,
@@ -324,16 +324,16 @@ import {
   isManagedMemoryPath,
   isTeamAutoMemPath,
   isUserAutoMemPath
-} from "./chunk-LPHGXXZX.js";
+} from "./chunk-JD3MKVKL.js";
 import {
   atomicWriteFile,
   atomicWriteFileSync,
   atomicWriteJSON,
   renameWithRetry
-} from "./chunk-VAJS2E2D.js";
+} from "./chunk-BDBMYST4.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-WEPXQKGP.js";
+} from "./chunk-EZVDJFZ7.js";
 import {
   AgentStatistics,
   BaseDeclarativeTool,
@@ -350,7 +350,7 @@ import {
   require_dist,
   require_fast_deep_equal,
   require_fast_uri
-} from "./chunk-ANRANWVE.js";
+} from "./chunk-OP4MOGXF.js";
 import {
   DEFAULT_OPENAI_BASE_URL
 } from "./chunk-FEOZBUMT.js";
@@ -361,7 +361,7 @@ import {
 } from "./chunk-DJ2GSRLV.js";
 import {
   require_undici
-} from "./chunk-4CHDYDG3.js";
+} from "./chunk-6EFTQYW7.js";
 import {
   DEFAULT_TOKEN_LIMIT,
   OUTPUT_TOKEN_CEILING,
@@ -369,10 +369,12 @@ import {
   defaultOutputCeiling,
   getToolCallPreparations,
   knownTokenLimit,
+  normalizeMcpToolName,
   parsePositiveIntegerEnvValue,
+  sanitizeToolNameForProvider,
   setToolCallPreparations,
   tokenLimit
-} from "./chunk-V4PCIS25.js";
+} from "./chunk-FZVSFBNW.js";
 import {
   FinishReason,
   FunctionCallingConfigMode,
@@ -408,7 +410,7 @@ import {
   tildeifyPath,
   toFriendlyError,
   unescapePath
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-C27BYUX6.js";
 import {
   require_src
 } from "./chunk-DMTGGOSA.js";
@@ -8664,16 +8666,16 @@ var require_windows = __commonJS({
       return false;
     }
     __name(checkPathExt, "checkPathExt");
-    function checkStat(stat19, path99, options2) {
-      if (!stat19.isSymbolicLink() && !stat19.isFile()) {
+    function checkStat(stat20, path99, options2) {
+      if (!stat20.isSymbolicLink() && !stat20.isFile()) {
         return false;
       }
       return checkPathExt(path99, options2);
     }
     __name(checkStat, "checkStat");
     function isexe(path99, options2, cb) {
-      fs93.stat(path99, function(er2, stat19) {
-        cb(er2, er2 ? false : checkStat(stat19, path99, options2));
+      fs93.stat(path99, function(er2, stat20) {
+        cb(er2, er2 ? false : checkStat(stat20, path99, options2));
       });
     }
     __name(isexe, "isexe");
@@ -8692,8 +8694,8 @@ var require_mode = __commonJS({
     isexe.sync = sync2;
     var fs93 = __require("fs");
     function isexe(path99, options2, cb) {
-      fs93.stat(path99, function(er2, stat19) {
-        cb(er2, er2 ? false : checkStat(stat19, options2));
+      fs93.stat(path99, function(er2, stat20) {
+        cb(er2, er2 ? false : checkStat(stat20, options2));
       });
     }
     __name(isexe, "isexe");
@@ -8701,14 +8703,14 @@ var require_mode = __commonJS({
       return checkStat(fs93.statSync(path99), options2);
     }
     __name(sync2, "sync");
-    function checkStat(stat19, options2) {
-      return stat19.isFile() && checkMode(stat19, options2);
+    function checkStat(stat20, options2) {
+      return stat20.isFile() && checkMode(stat20, options2);
     }
     __name(checkStat, "checkStat");
-    function checkMode(stat19, options2) {
-      var mod = stat19.mode;
-      var uid = stat19.uid;
-      var gid = stat19.gid;
+    function checkMode(stat20, options2) {
+      var mod = stat20.mode;
+      var uid = stat20.uid;
+      var gid = stat20.gid;
       var myUid = options2.uid !== void 0 ? options2.uid : process.getuid && process.getuid();
       var myGid = options2.gid !== void 0 ? options2.gid : process.getgid && process.getgid();
       var u2 = parseInt("100", 8);
@@ -9413,12 +9415,12 @@ var require_src3 = __commonJS({
     function check(path99, isFile, isDirectory) {
       log(`checking %s`, path99);
       try {
-        const stat19 = fs_1.statSync(path99);
-        if (stat19.isFile() && isFile) {
+        const stat20 = fs_1.statSync(path99);
+        if (stat20.isFile() && isFile) {
           log(`[OK] path represents a file`);
           return true;
         }
-        if (stat19.isDirectory() && isDirectory) {
+        if (stat20.isDirectory() && isDirectory) {
           log(`[OK] path represents a directory`);
           return true;
         }
@@ -29231,12 +29233,12 @@ var require_resolve_symlink = __commonJS({
       fs_1.default.realpath(path99, (error, resolvedPath) => {
         if (error)
           return queue.dequeue(suppressErrors ? null : error, state);
-        fs_1.default.stat(resolvedPath, (error2, stat19) => {
+        fs_1.default.stat(resolvedPath, (error2, stat20) => {
           if (error2)
             return queue.dequeue(suppressErrors ? null : error2, state);
-          if (stat19.isDirectory() && isRecursive(path99, resolvedPath, state))
+          if (stat20.isDirectory() && isRecursive(path99, resolvedPath, state))
             return queue.dequeue(null, state);
-          callback(stat19, resolvedPath);
+          callback(stat20, resolvedPath);
           queue.dequeue(null, state);
         });
       });
@@ -29246,10 +29248,10 @@ var require_resolve_symlink = __commonJS({
       queue.enqueue();
       try {
         const resolvedPath = fs_1.default.realpathSync(path99);
-        const stat19 = fs_1.default.statSync(resolvedPath);
-        if (stat19.isDirectory() && isRecursive(path99, resolvedPath, state))
+        const stat20 = fs_1.default.statSync(resolvedPath);
+        if (stat20.isDirectory() && isRecursive(path99, resolvedPath, state))
           return;
-        callback(stat19, resolvedPath);
+        callback(stat20, resolvedPath);
       } catch (e) {
         if (!suppressErrors)
           throw e;
@@ -29568,8 +29570,8 @@ var require_walker = __commonJS({
             this.walkDirectory(this.state, path99, path99, depth - 1, this.walk);
           } else if (this.resolveSymlink && entry.isSymbolicLink()) {
             let path99 = joinPath.joinPathWithBasePath(entry.name, directoryPath);
-            this.resolveSymlink(path99, this.state, (stat19, resolvedPath) => {
-              if (stat19.isDirectory()) {
+            this.resolveSymlink(path99, this.state, (stat20, resolvedPath) => {
+              if (stat20.isDirectory()) {
                 resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
                 if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path99 + pathSeparator))
                   return;
@@ -31459,12 +31461,12 @@ async function cleanupLegacyOutputFiles(dir, now, maxAgeMs, result) {
 __name(cleanupLegacyOutputFiles, "cleanupLegacyOutputFiles");
 async function tryDeleteIfOld(filePath, now, maxAgeMs, result) {
   try {
-    const stat19 = await fs2.lstat(filePath);
-    if (!stat19.isFile()) return;
-    if (now - stat19.mtimeMs < maxAgeMs) return;
+    const stat20 = await fs2.lstat(filePath);
+    if (!stat20.isFile()) return;
+    if (now - stat20.mtimeMs < maxAgeMs) return;
     await fs2.unlink(filePath);
     result.filesDeleted++;
-    result.bytesFreed += stat19.size;
+    result.bytesFreed += stat20.size;
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
       return;
@@ -32360,6 +32362,7 @@ var MAX_GOAL_ITERATIONS = 50;
 var GOAL_JUDGE_TIMEOUT_MS = 25e3;
 var GOAL_HOOK_TIMEOUT_SECONDS = 30;
 var GOAL_HOOK_TIMEOUT_MS = GOAL_HOOK_TIMEOUT_SECONDS * 1e3;
+var GOAL_HOOK_ID_OUTPUT_KEY = "qwenGoalHookId";
 var GOAL_ABORTED_REASON = "Goal max iterations reached; cleared. Re-set with `/goal <condition>` if you still need it.";
 var GOAL_JUDGE_TIMEOUT_MESSAGE = "Goal judge timed out; the automatic /goal loop paused. The goal remains active.";
 function continuationReasonForGoal(condition) {
@@ -32367,6 +32370,14 @@ function continuationReasonForGoal(condition) {
 Goal condition: ${condition}`;
 }
 __name(continuationReasonForGoal, "continuationReasonForGoal");
+function getStopHookContinuationReason(output) {
+  const hasGoalOutput = typeof output.hookSpecificOutput?.[GOAL_HOOK_ID_OUTPUT_KEY] === "string";
+  if (!hasGoalOutput) {
+    return output.stopReason || output.reason || "No reason provided";
+  }
+  return [output.stopReason, output.reason].filter(Boolean).join("\n") || "No reason provided";
+}
+__name(getStopHookContinuationReason, "getStopHookContinuationReason");
 async function judgeGoalWithTimeout(config, args) {
   let timeoutId;
   const judgeController = new AbortController();
@@ -32510,7 +32521,10 @@ function createGoalStopHookCallback(args) {
     }
     return {
       decision: "block",
-      reason: continuationReasonForGoal(condition)
+      reason: continuationReasonForGoal(condition),
+      hookSpecificOutput: {
+        [GOAL_HOOK_ID_OUTPUT_KEY]: evaluated.hookId
+      }
     };
   };
 }
@@ -32848,7 +32862,8 @@ function parseAndFormatApiError(error, authType) {
     if (isAlreadyFormatted(error.message)) {
       return error.message;
     }
-    let text = `[API Error: ${error.message}]`;
+    const message = error instanceof Error ? getErrorMessage(error) : error.message;
+    let text = `[API Error: ${message}]`;
     if (error.status === 429) {
       text += getRateLimitMessage(authType);
     }
@@ -34080,42 +34095,353 @@ import fs10 from "node:fs";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import readline from "node:readline";
 
-// packages/core/src/utils/conversation-chain.ts
+// packages/core/src/utils/transcript-records.ts
 init_esbuild_shims();
-function buildOrderedUuidChain(records, opts) {
-  if (records.length === 0) return { uuids: [], gaps: [] };
-  const detectGaps = opts?.detectGaps ?? false;
-  const firstByUuid = /* @__PURE__ */ new Map();
-  for (const r2 of records) {
-    if (!firstByUuid.has(r2.uuid)) firstByUuid.set(r2.uuid, r2);
+var TranscriptRecordPreparationError = class extends TypeError {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "TranscriptRecordPreparationError";
+  }
+  static {
+    __name(this, "TranscriptRecordPreparationError");
   }
+};
+var RECORD_TYPES = /* @__PURE__ */ new Set([
+  "user",
+  "assistant",
+  "tool_result",
+  "system"
+]);
+var ARTIFACT_RECORD_SUBTYPES = /* @__PURE__ */ new Set([
+  "session_artifact_event",
+  "session_artifact_snapshot"
+]);
+var KNOWN_RECORD_SUBTYPES = /* @__PURE__ */ new Set([
+  "chat_compression",
+  "slash_command",
+  "ui_telemetry",
+  "at_command",
+  "attribution_snapshot",
+  "notification",
+  "cron",
+  "mid_turn_user_message",
+  "custom_title",
+  "parent_session",
+  "rewind",
+  "agent_bootstrap",
+  "agent_launch_prompt",
+  "file_history_snapshot",
+  "session_source",
+  ...ARTIFACT_RECORD_SUBTYPES
+]);
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isObjectRecord, "isObjectRecord");
+function diagnostic(code, message, affectsCompleteness, fields = {}, severity = affectsCompleteness ? "warning" : "info") {
+  return {
+    code,
+    severity,
+    message,
+    affectsCompleteness,
+    ...fields
+  };
+}
+__name(diagnostic, "diagnostic");
+function isTranscriptConversationRecord(record2) {
+  return !isTranscriptArtifactRecord(record2);
+}
+__name(isTranscriptConversationRecord, "isTranscriptConversationRecord");
+function isTranscriptArtifactRecord(record2) {
+  return record2.type === "system" && typeof record2.subtype === "string" && ARTIFACT_RECORD_SUBTYPES.has(record2.subtype);
+}
+__name(isTranscriptArtifactRecord, "isTranscriptArtifactRecord");
+function validateTranscriptRecord(value, recordIndex) {
+  const diagnostics = [];
+  if (!isObjectRecord(value)) {
+    diagnostics.push(
+      diagnostic(
+        "invalid_record",
+        "Skipped a transcript record that is not an object.",
+        true,
+        { recordIndex }
+      )
+    );
+    return { diagnostics };
+  }
+  const uuid = value["uuid"];
+  const parentUuid = value["parentUuid"];
+  const sessionId = value["sessionId"];
+  const type = value["type"];
+  const recordId = typeof uuid === "string" ? uuid : void 0;
+  if (typeof uuid !== "string" || uuid.length === 0 || typeof parentUuid !== "string" && parentUuid !== null || typeof sessionId !== "string" || sessionId.length === 0) {
+    diagnostics.push(
+      diagnostic(
+        "invalid_record",
+        "Skipped a transcript record with invalid identity fields.",
+        true,
+        { recordIndex, recordId }
+      )
+    );
+    return { diagnostics };
+  }
+  if (typeof type !== "string" || !RECORD_TYPES.has(type)) {
+    diagnostics.push(
+      diagnostic(
+        "unknown_record_or_part",
+        "Skipped a transcript record with an unknown record type.",
+        true,
+        { recordIndex, recordId }
+      )
+    );
+    return { diagnostics };
+  }
+  const timestamp = value["timestamp"];
+  if (timestamp !== void 0 && (typeof timestamp !== "string" || !Number.isFinite(new Date(timestamp).getTime()))) {
+    diagnostics.push(
+      diagnostic(
+        "invalid_timestamp",
+        "Ignored an invalid transcript record timestamp.",
+        false,
+        { recordIndex, recordId, path: "timestamp" }
+      )
+    );
+  }
+  const subtype = value["subtype"];
+  if (subtype !== void 0 && (typeof subtype !== "string" || !KNOWN_RECORD_SUBTYPES.has(subtype))) {
+    diagnostics.push(
+      diagnostic(
+        "unknown_record_or_part",
+        "The transcript record has an unknown subtype.",
+        true,
+        { recordIndex, recordId, path: "subtype" }
+      )
+    );
+  }
+  let message;
+  if (value["message"] !== void 0) {
+    if (!isObjectRecord(value["message"])) {
+      diagnostics.push(
+        diagnostic(
+          "malformed_part",
+          "Ignored a malformed transcript message payload.",
+          true,
+          { recordIndex, recordId, path: "message" }
+        )
+      );
+    } else {
+      const parts = value["message"]["parts"];
+      if (parts !== void 0 && !Array.isArray(parts)) {
+        diagnostics.push(
+          diagnostic(
+            "malformed_part",
+            "Ignored malformed transcript message parts.",
+            true,
+            { recordIndex, recordId, path: "message.parts" }
+          )
+        );
+      }
+      message = {
+        ...typeof value["message"]["role"] === "string" ? { role: value["message"]["role"] } : {},
+        ...Array.isArray(parts) ? { parts } : {}
+      };
+    }
+  }
+  return {
+    record: {
+      ...value,
+      uuid,
+      parentUuid,
+      sessionId,
+      type,
+      ...typeof subtype === "string" ? { subtype } : { subtype: void 0 },
+      ...typeof timestamp === "string" && Number.isFinite(new Date(timestamp).getTime()) ? { timestamp } : { timestamp: void 0 },
+      ...message ? { message } : { message: void 0 }
+    },
+    diagnostics
+  };
+}
+__name(validateTranscriptRecord, "validateTranscriptRecord");
+function selectTranscriptLeaf(records, leafUuid) {
+  if (leafUuid !== void 0) {
+    return records.some(
+      (record2) => record2.uuid === leafUuid && isTranscriptConversationRecord(record2)
+    ) ? leafUuid : void 0;
+  }
+  for (let index = records.length - 1; index >= 0; index -= 1) {
+    const record2 = records[index];
+    if (record2 && isTranscriptConversationRecord(record2)) return record2.uuid;
+  }
+  return void 0;
+}
+__name(selectTranscriptLeaf, "selectTranscriptLeaf");
+function walkTranscriptUuidChain(leafUuid, lookup2) {
   const uuids = [];
   const gaps = [];
   const visited = /* @__PURE__ */ new Set();
-  const startUuid = opts?.leafUuid ?? records[records.length - 1].uuid;
-  if (!firstByUuid.has(startUuid)) return { uuids: [], gaps: [] };
-  let currentUuid = startUuid;
+  let currentUuid = leafUuid;
+  let cycleUuid;
   while (currentUuid) {
-    if (visited.has(currentUuid)) break;
+    if (visited.has(currentUuid)) {
+      cycleUuid = currentUuid;
+      break;
+    }
     visited.add(currentUuid);
+    const record2 = lookup2(currentUuid);
+    if (!record2) break;
     uuids.push(currentUuid);
-    const rec = firstByUuid.get(currentUuid);
-    if (!rec) break;
-    const parent = rec.parentUuid;
-    if (!parent) break;
-    if (firstByUuid.has(parent)) {
-      currentUuid = parent;
-      continue;
-    }
-    if (detectGaps) {
-      gaps.push({ childUuid: currentUuid, missingParentUuid: parent });
+    if (!record2.parentUuid) break;
+    if (!lookup2(record2.parentUuid)) {
+      gaps.push({
+        childUuid: currentUuid,
+        missingParentUuid: record2.parentUuid
+      });
+      break;
     }
-    break;
+    currentUuid = record2.parentUuid;
   }
   uuids.reverse();
-  return { uuids, gaps };
+  return { uuids, gaps, ...cycleUuid ? { cycleUuid } : {} };
 }
-__name(buildOrderedUuidChain, "buildOrderedUuidChain");
+__name(walkTranscriptUuidChain, "walkTranscriptUuidChain");
+function aggregateTranscriptRecordFragments(records) {
+  const first2 = records[0];
+  if (!first2) {
+    throw new Error("Cannot aggregate empty transcript record array");
+  }
+  const base = { ...first2 };
+  let message = first2.message ? { ...first2.message, parts: [...first2.message.parts ?? []] } : void 0;
+  for (let index = 1; index < records.length; index += 1) {
+    const record2 = records[index];
+    if (record2.message !== void 0) {
+      message = message ? {
+        role: message.role,
+        parts: [...message.parts ?? [], ...record2.message.parts ?? []]
+      } : { ...record2.message, parts: [...record2.message.parts ?? []] };
+    }
+    if (record2.usageMetadata) base["usageMetadata"] = record2.usageMetadata;
+    if (record2.toolCallResult && !base["toolCallResult"]) {
+      base["toolCallResult"] = record2.toolCallResult;
+    }
+    if (record2.model && !base["model"]) base["model"] = record2.model;
+    if (record2.timestamp && (!base["timestamp"] || record2.timestamp > String(base["timestamp"]))) {
+      base["timestamp"] = record2.timestamp;
+    }
+  }
+  base["message"] = message;
+  return base;
+}
+__name(aggregateTranscriptRecordFragments, "aggregateTranscriptRecordFragments");
+function prepareTranscriptRecords(values, options2 = {}) {
+  if (!Array.isArray(values)) {
+    throw new TranscriptRecordPreparationError(
+      "invalid_records",
+      "Transcript records must be an array."
+    );
+  }
+  const diagnostics = [];
+  const records = [];
+  const sourceIndexByRecord = /* @__PURE__ */ new Map();
+  for (let index = 0; index < values.length; index += 1) {
+    const validated = validateTranscriptRecord(values[index], index);
+    diagnostics.push(...validated.diagnostics);
+    if (validated.record) {
+      records.push(validated.record);
+      sourceIndexByRecord.set(validated.record, index);
+    }
+  }
+  const sessionIds = new Set(records.map((record2) => record2.sessionId));
+  if (sessionIds.size > 1) {
+    throw new TranscriptRecordPreparationError(
+      "mixed_session_ids",
+      "Transcript records contain multiple session ids."
+    );
+  }
+  const leafUuid = selectTranscriptLeaf(records, options2.leafUuid);
+  if (options2.leafUuid !== void 0 && leafUuid === void 0) {
+    throw new TranscriptRecordPreparationError(
+      "leaf_not_found",
+      "The requested transcript leaf was not found."
+    );
+  }
+  if (!leafUuid) {
+    if (records.length > 0) {
+      diagnostics.push(
+        diagnostic(
+          "artifact_only",
+          "The input contains no conversation records.",
+          false
+        )
+      );
+    }
+    return {
+      ...sessionIds.size === 1 ? { sessionId: records[0].sessionId } : {},
+      records: [],
+      gaps: [],
+      diagnostics
+    };
+  }
+  const fragmentsByUuid = /* @__PURE__ */ new Map();
+  const firstByUuid = /* @__PURE__ */ new Map();
+  for (const record2 of records) {
+    if (!isTranscriptConversationRecord(record2)) continue;
+    const fragments = fragmentsByUuid.get(record2.uuid);
+    if (fragments) {
+      if (fragments[0].parentUuid !== record2.parentUuid) {
+        diagnostics.push(
+          diagnostic(
+            "conflicting_parent_uuid",
+            "Duplicate transcript record fragments disagree on parentUuid.",
+            true,
+            {
+              recordIndex: sourceIndexByRecord.get(record2),
+              recordId: record2.uuid,
+              path: "parentUuid"
+            }
+          )
+        );
+      }
+      fragments.push(record2);
+    } else {
+      fragmentsByUuid.set(record2.uuid, [record2]);
+      firstByUuid.set(record2.uuid, record2);
+    }
+  }
+  const chain = walkTranscriptUuidChain(
+    leafUuid,
+    (uuid) => firstByUuid.get(uuid)
+  );
+  for (const gap of chain.gaps) {
+    diagnostics.push(
+      diagnostic(
+        "history_gap",
+        "The active transcript chain is missing a parent record.",
+        true,
+        { recordId: gap.childUuid }
+      )
+    );
+  }
+  if (chain.cycleUuid) {
+    diagnostics.push(
+      diagnostic(
+        "parent_cycle",
+        "The active transcript chain contains a parent cycle.",
+        true,
+        { recordId: chain.cycleUuid }
+      )
+    );
+  }
+  return {
+    ...sessionIds.size === 1 ? { sessionId: records[0].sessionId } : {},
+    records: chain.uuids.map(
+      (uuid) => aggregateTranscriptRecordFragments(fragmentsByUuid.get(uuid) ?? [])
+    ),
+    gaps: chain.gaps,
+    diagnostics
+  };
+}
+__name(prepareTranscriptRecords, "prepareTranscriptRecords");
 
 // packages/core/src/services/fileHistoryService.ts
 init_esbuild_shims();
@@ -35225,13 +35551,9 @@ async function synthesizeUntrackedHunk(gitRoot, filePath) {
   }
 }
 __name(synthesizeUntrackedHunk, "synthesizeUntrackedHunk");
-function parseGitNumstat(stdout) {
+function forEachNumstatEntry(stdout, visit) {
   const tokens = stdout.split("\0");
   if (tokens.length > 0 && tokens[tokens.length - 1] === "") tokens.pop();
-  let added = 0;
-  let removed = 0;
-  let validFileCount = 0;
-  const perFileStats = /* @__PURE__ */ new Map();
   let pending = null;
   let renameOld = null;
   for (const token of tokens) {
@@ -35240,13 +35562,7 @@ function parseGitNumstat(stdout) {
         renameOld = token;
         continue;
       }
-      commitEntry(
-        token,
-        pending.added,
-        pending.removed,
-        pending.isBinary,
-        renameOld
-      );
+      visit({ ...pending, path: token, oldPath: renameOld });
       pending = null;
       renameOld = null;
       continue;
@@ -35257,16 +35573,32 @@ function parseGitNumstat(stdout) {
     if (secondTab < 0) continue;
     const addStr = token.slice(0, firstTab);
     const remStr = token.slice(firstTab + 1, secondTab);
-    const filePath = token.slice(secondTab + 1);
+    const path99 = token.slice(secondTab + 1);
     const isBinary2 = addStr === "-" || remStr === "-";
-    const fileAdded = isBinary2 ? 0 : parseInt(addStr, 10) || 0;
-    const fileRemoved = isBinary2 ? 0 : parseInt(remStr, 10) || 0;
-    if (filePath === "") {
-      pending = { added: fileAdded, removed: fileRemoved, isBinary: isBinary2 };
+    const added = isBinary2 ? 0 : parseInt(addStr, 10) || 0;
+    const removed = isBinary2 ? 0 : parseInt(remStr, 10) || 0;
+    if (path99 === "") {
+      pending = { added, removed, isBinary: isBinary2 };
       continue;
     }
-    commitEntry(filePath, fileAdded, fileRemoved, isBinary2);
+    visit({ path: path99, added, removed, isBinary: isBinary2 });
   }
+}
+__name(forEachNumstatEntry, "forEachNumstatEntry");
+function parseGitNumstat(stdout) {
+  let added = 0;
+  let removed = 0;
+  let validFileCount = 0;
+  const perFileStats = /* @__PURE__ */ new Map();
+  forEachNumstatEntry(stdout, (entry) => {
+    commitEntry(
+      entry.path,
+      entry.added,
+      entry.removed,
+      entry.isBinary,
+      entry.oldPath
+    );
+  });
   function commitEntry(filePath, fileAdded, fileRemoved, isBinary2, oldPath) {
     validFileCount++;
     added += fileAdded;
@@ -35767,6 +36099,150 @@ async function countStashEntries(gitRoot) {
   }
 }
 __name(countStashEntries, "countStashEntries");
+var MAX_LOG_LIMIT = 200;
+var DEFAULT_LOG_LIMIT = 50;
+var LOG_FORMAT = "%H%x00%h%x00%an%x00%ae%x00%at%x00%s%x00%D%x00%P";
+var LOG_DETAIL_FORMAT = "%H%x00%h%x00%an%x00%ae%x00%at%x00%s%x00%D%x00%P%x00%b";
+function parseLogFields(parts) {
+  if (parts.length !== 8) return null;
+  return {
+    sha: parts[0],
+    shortSha: parts[1],
+    authorName: parts[2],
+    authorEmail: parts[3],
+    authorDate: parseInt(parts[4], 10) || 0,
+    subject: parts[5],
+    refs: parts[6],
+    parents: parts[7] ? parts[7].split(" ").filter(Boolean) : []
+  };
+}
+__name(parseLogFields, "parseLogFields");
+async function fetchGitLog(cwd, options2) {
+  const gitRoot = findGitRoot(cwd);
+  if (!gitRoot) return null;
+  const limit = Math.min(
+    Math.max(options2?.limit ?? DEFAULT_LOG_LIMIT, 1),
+    MAX_LOG_LIMIT
+  );
+  const skip = Math.max(options2?.skip ?? 0, 0);
+  const stdout = await runGit(
+    [
+      "--no-optional-locks",
+      "log",
+      "-z",
+      `--format=${LOG_FORMAT}`,
+      "-n",
+      String(limit + 1),
+      ...skip > 0 ? ["--skip", String(skip)] : []
+    ],
+    gitRoot
+  );
+  if (stdout === null) {
+    const head = await runGit(["rev-parse", "--verify", "HEAD"], gitRoot);
+    return head === null ? { entries: [], hasMore: false } : null;
+  }
+  const fields = stdout.split("\0");
+  if (fields.at(-1) === "") fields.pop();
+  const recordCount = Math.floor(fields.length / 8);
+  const hasMore = recordCount > limit;
+  const pageCount = hasMore ? limit : recordCount;
+  const entries = [];
+  for (let i2 = 0; i2 < pageCount; i2++) {
+    const entry = parseLogFields(fields.slice(i2 * 8, i2 * 8 + 8));
+    if (entry) entries.push(entry);
+  }
+  return { entries, hasMore };
+}
+__name(fetchGitLog, "fetchGitLog");
+async function fetchGitCommitDetail(cwd, sha) {
+  if (!/^[0-9a-f]{7,40}$/i.test(sha)) return null;
+  const gitRoot = findGitRoot(cwd);
+  if (!gitRoot) return null;
+  const metaRaw = await runGit(
+    [
+      "--no-optional-locks",
+      "log",
+      "-1",
+      "-z",
+      `--format=${LOG_DETAIL_FORMAT}`,
+      sha
+    ],
+    gitRoot
+  );
+  if (metaRaw === null) return null;
+  const parts = metaRaw.split("\0");
+  if (parts.at(-1) === "") parts.pop();
+  if (parts.length !== 9) return null;
+  const parents = parts[7] ? parts[7].split(" ").filter(Boolean) : [];
+  const diffTreeArgs = parents.length > 1 ? [
+    "--no-optional-locks",
+    "diff-tree",
+    "--no-commit-id",
+    "--numstat",
+    // Detect renames so `git mv` counts as one file (by its new path),
+    // matching the main `git diff` path — diff-tree is plumbing and does
+    // NOT honour diff.renames, so without -M a rename splits into a
+    // delete + add pair. The three-token `-z` rename sequence it then
+    // emits is handled by the pending-rename state machine below.
+    "-M",
+    "-r",
+    "-z",
+    `${sha}^1`,
+    sha
+  ] : [
+    "--no-optional-locks",
+    "diff-tree",
+    "--no-commit-id",
+    "--numstat",
+    // Detect renames so `git mv` counts as one file (by its new path),
+    // matching the main `git diff` path — diff-tree is plumbing and does
+    // NOT honour diff.renames, so without -M a rename splits into a
+    // delete + add pair. The three-token `-z` rename sequence it then
+    // emits is handled by the pending-rename state machine below.
+    "-M",
+    "-r",
+    "-z",
+    "--root",
+    sha
+  ];
+  const numstatRaw = await runGit(diffTreeArgs, gitRoot);
+  const files = [];
+  let filesCount = 0;
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  if (numstatRaw) {
+    forEachNumstatEntry(numstatRaw, (entry) => {
+      filesCount++;
+      linesAdded += entry.added;
+      linesRemoved += entry.removed;
+      if (files.length < MAX_FILES) {
+        files.push({
+          path: entry.path,
+          added: entry.added,
+          removed: entry.removed,
+          isBinary: entry.isBinary
+        });
+      }
+    });
+  }
+  return {
+    sha: parts[0],
+    shortSha: parts[1],
+    authorName: parts[2],
+    authorEmail: parts[3],
+    authorDate: parseInt(parts[4], 10) || 0,
+    subject: parts[5],
+    refs: parts[6],
+    parents,
+    body: parts[8].replace(/\n$/, ""),
+    files,
+    filesCount,
+    linesAdded,
+    linesRemoved,
+    hiddenCount: Math.max(filesCount - files.length, 0)
+  };
+}
+__name(fetchGitCommitDetail, "fetchGitCommitDetail");
 
 // packages/core/src/services/fileHistoryService.ts
 var debugLogger12 = createDebugLogger("FILE_HISTORY");
@@ -37021,12 +37497,8 @@ var MAX_PERSISTED_MIME_CHARS = 120;
 var MAX_PERSISTED_FIELD_CHARS = 200;
 var MAX_PERSISTED_TIMESTAMP_CHARS = 64;
 var SECRET_TOKEN_VALUE_PATTERN = /(?:^|\s)(?:bearer\s+\S{8,}|sk-[A-Za-z0-9_-]{12,}|(?:gh[pousr]|github_pat)_[A-Za-z0-9_/-]{12,}|[a-f0-9]{40,}|[A-Za-z0-9+/]{48,}={0,2})(?:$|\s)/i;
-var ARTIFACT_RECORD_SUBTYPES = /* @__PURE__ */ new Set([
-  "session_artifact_event",
-  "session_artifact_snapshot"
-]);
 function isSessionArtifactRecord(record2) {
-  return record2.type === "system" && typeof record2.subtype === "string" && ARTIFACT_RECORD_SUBTYPES.has(record2.subtype);
+  return isTranscriptArtifactRecord(record2);
 }
 __name(isSessionArtifactRecord, "isSessionArtifactRecord");
 function stableSessionArtifactId(sessionId, identityKey) {
@@ -38310,10 +38782,10 @@ function makeSessionTranscriptNotFoundError(sessionId) {
   return error;
 }
 __name(makeSessionTranscriptNotFoundError, "makeSessionTranscriptNotFoundError");
-function isObjectRecord(value) {
+function isObjectRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-__name(isObjectRecord, "isObjectRecord");
+__name(isObjectRecord2, "isObjectRecord");
 function isFiniteNonNegativeInteger(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
@@ -38423,11 +38895,11 @@ function decodeCursorState(cursor, key) {
   try {
     const decoded = Buffer.from(cursor, "base64url").toString("utf8");
     const parsed = JSON.parse(decoded);
-    if (!isObjectRecord(parsed)) {
+    if (!isObjectRecord2(parsed)) {
       throw new InvalidSessionTranscriptCursorError();
     }
     const fileIdentity = parsed["fileIdentity"];
-    if (parsed["v"] !== SESSION_TRANSCRIPT_CURSOR_VERSION || typeof parsed["sessionId"] !== "string" || !isObjectRecord(fileIdentity) || !isFiniteNonNegativeInteger(fileIdentity["dev"]) || !isFiniteNonNegativeInteger(fileIdentity["ino"]) || !isFiniteNonNegativeInteger(parsed["snapshotSize"]) || !isFiniteNonNegativeInteger(parsed["position"]) || parsed["direction"] !== void 0 && parsed["direction"] !== "backward" || typeof parsed["leafUuid"] !== "string" || typeof parsed["startTime"] !== "string" || typeof parsed["lastUpdated"] !== "string" || typeof parsed["mac"] !== "string") {
+    if (parsed["v"] !== SESSION_TRANSCRIPT_CURSOR_VERSION || typeof parsed["sessionId"] !== "string" || !isObjectRecord2(fileIdentity) || !isFiniteNonNegativeInteger(fileIdentity["dev"]) || !isFiniteNonNegativeInteger(fileIdentity["ino"]) || !isFiniteNonNegativeInteger(parsed["snapshotSize"]) || !isFiniteNonNegativeInteger(parsed["position"]) || parsed["direction"] !== void 0 && parsed["direction"] !== "backward" || typeof parsed["leafUuid"] !== "string" || typeof parsed["startTime"] !== "string" || typeof parsed["lastUpdated"] !== "string" || typeof parsed["mac"] !== "string") {
       debugLogger13.debug("cursor decode failed: invalid payload shape");
       throw new InvalidSessionTranscriptCursorError();
     }
@@ -38662,12 +39134,6 @@ function pruneCache(now = Date.now()) {
   }
 }
 __name(pruneCache, "pruneCache");
-function isChatRecord(value) {
-  if (!isObjectRecord(value)) return false;
-  const type = value["type"];
-  return typeof value["uuid"] === "string" && (typeof value["parentUuid"] === "string" || value["parentUuid"] === null) && typeof value["sessionId"] === "string" && typeof value["timestamp"] === "string" && (type === "user" || type === "assistant" || type === "tool_result" || type === "system");
-}
-__name(isChatRecord, "isChatRecord");
 async function forEachLineInSnapshot(filePath, snapshotSize, onLine) {
   if (snapshotSize === 0) return;
   let pending = [];
@@ -38721,7 +39187,10 @@ async function readSegmentRecords(handle, filePath, segment, uuid) {
   await handle.read(buffer, 0, segment.length, segment.offset);
   const line = buffer.toString("utf8").trim();
   if (line.length === 0) return [];
-  const records = parseLineTolerant(line, filePath).filter((record3) => isChatRecord(record3));
+  const records = parseLineTolerant(line, filePath).flatMap((value) => {
+    const record3 = validateTranscriptRecord(value).record;
+    return record3 && isTranscriptConversationRecord(record3) ? [record3] : [];
+  });
   const anomalySessionId = path9.basename(filePath, ".jsonl");
   const record2 = records[segment.fragmentIndex];
   if (!record2) {
@@ -38739,42 +39208,6 @@ async function readSegmentRecords(handle, filePath, segment, uuid) {
   return [record2];
 }
 __name(readSegmentRecords, "readSegmentRecords");
-function aggregateRecords(records) {
-  if (records.length === 0) {
-    throw new Error("Cannot aggregate empty transcript record array");
-  }
-  const base = { ...records[0] };
-  for (let i2 = 1; i2 < records.length; i2++) {
-    const record2 = records[i2];
-    if (record2.message !== void 0) {
-      if (base.message === void 0) {
-        base.message = record2.message;
-      } else {
-        base.message = {
-          role: base.message.role,
-          parts: [
-            ...base.message.parts ?? [],
-            ...record2.message.parts ?? []
-          ]
-        };
-      }
-    }
-    if (record2.usageMetadata) {
-      base.usageMetadata = record2.usageMetadata;
-    }
-    if (record2.toolCallResult && !base.toolCallResult) {
-      base.toolCallResult = record2.toolCallResult;
-    }
-    if (record2.model && !base.model) {
-      base.model = record2.model;
-    }
-    if (record2.timestamp > base.timestamp) {
-      base.timestamp = record2.timestamp;
-    }
-  }
-  return base;
-}
-__name(aggregateRecords, "aggregateRecords");
 async function readAggregatedRecords(index, uuids) {
   const handle = await fsp.open(index.filePath, "r");
   try {
@@ -38789,7 +39222,7 @@ async function readAggregatedRecords(index, uuids) {
         );
       }
       if (physicalRecords.length > 0) {
-        records.push(aggregateRecords(physicalRecords));
+        records.push(aggregateTranscriptRecordFragments(physicalRecords));
       }
     }
     return records;
@@ -38825,12 +39258,12 @@ async function buildIndex(params) {
       const text = line.toString("utf8").trim();
       if (text.length === 0) return;
       let fragmentIndex = 0;
-      for (const record2 of parseLineTolerant(
-        text,
-        filePath
-      )) {
-        if (!isChatRecord(record2)) continue;
-        startTime ??= record2.timestamp;
+      for (const value of parseLineTolerant(text, filePath)) {
+        const record2 = validateTranscriptRecord(value).record;
+        if (!record2 || !isTranscriptConversationRecord(record2)) {
+          continue;
+        }
+        if (record2.timestamp) startTime ??= record2.timestamp;
         leafUuid = record2.uuid;
         const existing = byUuid.get(record2.uuid);
         const segment = {
@@ -38853,43 +39286,30 @@ async function buildIndex(params) {
       }
     }
   );
-  if (!leafUuid || !startTime) {
+  if (!leafUuid) {
     debugLogger13.warn(
       `index build failed: no transcript records session=${sessionId}`
     );
     throw new SessionTranscriptSnapshotUnavailableError(sessionId);
   }
-  const activeUuids = [];
-  const gaps = [];
-  const visited = /* @__PURE__ */ new Set();
-  let currentUuid = leafUuid;
-  while (currentUuid && !visited.has(currentUuid)) {
-    visited.add(currentUuid);
-    const entry = byUuid.get(currentUuid);
-    if (!entry) {
-      debugLogger13.debug(
-        `active chain terminated: missing uuid session=${sessionId} uuid=${currentUuid}`
-      );
-      break;
-    }
-    activeUuids.push(currentUuid);
-    const parentUuid = entry.parentUuid;
-    if (!parentUuid) break;
-    if (!byUuid.has(parentUuid)) {
-      gaps.push({ childUuid: currentUuid, missingParentUuid: parentUuid });
-      debugLogger13.debug(
-        `active chain gap session=${sessionId} child=${currentUuid} missingParent=${parentUuid}`
-      );
-      break;
-    }
-    currentUuid = parentUuid;
-  }
-  if (currentUuid && visited.has(currentUuid)) {
+  startTime ??= lastUpdated;
+  const chain = walkTranscriptUuidChain(leafUuid, (uuid) => {
+    const entry = byUuid.get(uuid);
+    return entry ? {
+      uuid,
+      parentUuid: entry.parentUuid,
+      sessionId,
+      timestamp: startTime,
+      type: "system"
+    } : void 0;
+  });
+  const activeUuids = [...chain.uuids];
+  const gaps = [...chain.gaps];
+  if (chain.cycleUuid) {
     debugLogger13.debug(
-      `active chain terminated: cycle session=${sessionId} uuid=${currentUuid}`
+      `active chain terminated: cycle session=${sessionId} uuid=${chain.cycleUuid}`
     );
   }
-  activeUuids.reverse();
   debugLogger13.debug(
     `index build complete session=${sessionId} records=${byUuid.size} active=${activeUuids.length} gaps=${gaps.length}`
   );
@@ -39168,6 +39588,14 @@ var SessionService = class {
     if (getProjectHash(recordCwd) === this.projectHash) {
       return true;
     }
+    const worktreesMarker = `${path10.sep}.qwen${path10.sep}worktrees${path10.sep}`;
+    const markerIdx = recordCwd.lastIndexOf(worktreesMarker);
+    if (markerIdx > 0) {
+      const repoRoot = recordCwd.substring(0, markerIdx);
+      if (getProjectHash(repoRoot) === this.projectHash) {
+        return true;
+      }
+    }
     const status = await readRuntimeStatus(
       this.storage.getRuntimeStatusPath(sessionId)
     );
@@ -39181,6 +39609,9 @@ var SessionService = class {
   getWorktreeSessionPath(sessionId) {
     return this.getWorktreeSessionPathForState(sessionId, "active");
   }
+  getWorktreeSessionPathForArchiveState(sessionId, state) {
+    return this.getWorktreeSessionPathForState(sessionId, state);
+  }
   async readProjectSessionHead(sessionId, filePath) {
     try {
       const records = await readLines(filePath, 1);
@@ -39731,49 +40162,11 @@ var SessionService = class {
       return [];
     }
   }
-  /**
-   * Aggregates multiple records with the same uuid into a single ChatRecord.
-   * Merges content fields (message, tokens, model, toolCallResult).
-   */
-  aggregateRecords(records) {
-    if (records.length === 0) {
-      throw new Error("Cannot aggregate empty records array");
-    }
-    const base = { ...records[0] };
-    for (let i2 = 1; i2 < records.length; i2++) {
-      const record2 = records[i2];
-      if (record2.message !== void 0) {
-        if (base.message === void 0) {
-          base.message = record2.message;
-        } else {
-          base.message = {
-            role: base.message.role,
-            parts: [
-              ...base.message.parts || [],
-              ...record2.message.parts || []
-            ]
-          };
-        }
-      }
-      if (record2.usageMetadata) {
-        base.usageMetadata = record2.usageMetadata;
-      }
-      if (record2.toolCallResult && !base.toolCallResult) {
-        base.toolCallResult = record2.toolCallResult;
-      }
-      if (record2.model && !base.model) {
-        base.model = record2.model;
-      }
-      if (record2.timestamp > base.timestamp) {
-        base.timestamp = record2.timestamp;
-      }
-    }
-    return base;
-  }
   /**
    * Reconstructs a linear conversation from tree-structured records.
    *
-   * Delegates the parentUuid walk to {@link buildOrderedUuidChain}. With
+   * Delegates validation, parentUuid walking, and fragment aggregation to the
+   * shared transcript record preparation module. With
    * `detectGaps`, a walk that stops on a physically-missing parent records the
    * break in the returned `gaps` (see {@link HistoryGap}) so the surface can
    * mark it — the earlier records are NOT reconstructed (reconnecting them
@@ -39782,30 +40175,13 @@ var SessionService = class {
    */
   reconstructHistory(records, opts) {
     if (records.length === 0) return { messages: [], gaps: [] };
-    const recordsByUuid = /* @__PURE__ */ new Map();
-    for (const record2 of records) {
-      const existing = recordsByUuid.get(record2.uuid) || [];
-      existing.push(record2);
-      recordsByUuid.set(record2.uuid, existing);
-    }
-    const { uuids, gaps } = buildOrderedUuidChain(records, opts);
-    const messages = [];
-    for (const uuid of uuids) {
-      const recordsForUuid = recordsByUuid.get(uuid);
-      if (recordsForUuid && recordsForUuid.length > 0) {
-        messages.push(this.aggregateRecords(recordsForUuid));
-      }
-    }
-    return { messages, gaps };
-  }
-  lastConversationRecordUuid(records) {
-    for (let index = records.length - 1; index >= 0; index--) {
-      const record2 = records[index];
-      if (record2 && !isSessionArtifactRecord(record2)) {
-        return record2.uuid;
-      }
-    }
-    return null;
+    const prepared = prepareTranscriptRecords(records, {
+      ...opts?.leafUuid !== void 0 ? { leafUuid: opts.leafUuid } : {}
+    });
+    return {
+      messages: prepared.records.map((record2) => record2),
+      gaps: opts?.detectGaps ? [...prepared.gaps] : []
+    };
   }
   /**
    * Loads a session by its session ID.
@@ -39862,12 +40238,7 @@ var SessionService = class {
     )) {
       return;
     }
-    const leafUuid = this.lastConversationRecordUuid(records);
-    if (!leafUuid) {
-      return;
-    }
     const { messages, gaps } = this.reconstructHistory(records, {
-      leafUuid,
       detectGaps: true
     });
     if (messages.length === 0) {
@@ -40226,13 +40597,7 @@ var SessionService = class {
         `Source session does not belong to current project: ${sourceSessionId}`
       );
     }
-    const leafUuid = this.lastConversationRecordUuid(records);
-    if (!leafUuid) {
-      throw new Error(`Source session not found or empty: ${sourceSessionId}`);
-    }
-    const { messages: activeMessages } = this.reconstructHistory(records, {
-      leafUuid
-    });
+    const { messages: activeMessages } = this.reconstructHistory(records);
     const sourceRecords = includeActiveSideArtifactRecords(
       records,
       activeMessages
@@ -43149,6 +43514,81 @@ I found the following 'app.config' files:
 To help you check their settings, I can read their contents. Which one would you like to start with, or should I read all of them?
 </example>
 `.trim();
+var gemma4ToolCallExamples = `
+# Examples (Illustrating Tone and Workflow)
+<example>
+user: 1 + 2
+model: 3
+</example>
+
+<example>
+user: is 13 a prime number?
+model: true
+</example>
+
+<example>
+user: start the server implemented in server.js
+model: <|tool_call>call:${ToolNames.SHELL}{command:<|"|>node server.js<|"|>,is_background:true}<tool_call|>
+</example>
+
+<example>
+user: Refactor the auth logic in src/auth.py to use the requests library instead of urllib.
+model: Okay, I can refactor 'src/auth.py'.
+First, I'll analyze the code and check for a test safety net before planning any changes.
+<|tool_call>call:${ToolNames.GLOB}{pattern:<|"|>tests/test_auth.py<|"|>}<tool_call|>
+<|tool_call>call:${ToolNames.READ_FILE}{file_path:<|"|>/path/to/tests/test_auth.py<|"|>,offset:0,limit:10}<tool_call|>
+(After analysis)
+Great, 'tests/test_auth.py' exists and covers the core authentication logic. With this safety net in place, I can safely plan the refactoring.
+I'll also confirm 'requests' is a dependency.
+<|tool_call>call:${ToolNames.READ_FILE}{file_path:<|"|>/path/to/requirements.txt<|"|>}<tool_call|>
+(After analysis)
+Looks good, 'requests' is available.
+
+Here's the plan:
+1.  Replace the 'urllib' calls with 'requests'.
+2.  Add proper 'try...except' error handling for the new network calls.
+3.  Remove the old 'urllib' import.
+4.  Run the project's linter and tests to verify the changes.
+
+<|tool_call>call:${ToolNames.EDIT}{file_path:<|"|>/path/to/src/auth.py<|"|>,old_string:<|"|>(old code content)<|"|>,new_string:<|"|>(new code content)<|"|>}<tool_call|>
+Refactoring complete. Running verification...
+<|tool_call>call:${ToolNames.SHELL}{command:<|"|>ruff check src/auth.py && pytest<|"|>}<tool_call|>
+(After verification passes)
+All checks passed. This is a stable checkpoint.
+Would you like me to write a commit message and commit these changes?
+</example>
+
+<example>
+user: Delete the temp directory.
+model: I can run \`rm -rf /path/to/project/temp\`. This will permanently delete the directory and all its contents.
+</example>
+
+<example>
+user: Write tests for someFile.ts
+model:
+Okay, I can write those tests. First, I'll read someFile.ts to understand its functionality.
+<|tool_call>call:${ToolNames.READ_FILE}{file_path:<|"|>/path/to/someFile.ts<|"|>}<tool_call|>
+Now I'll look for existing or related test files to understand current testing conventions and dependencies.
+<|tool_call>call:${ToolNames.READ_FILE}{file_path:<|"|>/path/to/existingTest.test.ts<|"|>}<tool_call|>
+(After reviewing existing tests and the file content)
+<|tool_call>call:${ToolNames.WRITE_FILE}{file_path:<|"|>/path/to/someFile.test.ts<|"|>,content:<|"|>(test code content)<|"|>}<tool_call|>
+I've written the tests. Now I'll run the project's test command to verify them.
+<|tool_call>call:${ToolNames.SHELL}{command:<|"|>npm run test<|"|>}<tool_call|>
+(After verification passes)
+All checks passed. This is a stable checkpoint.
+</example>
+
+<example>
+user: Where are all the 'app.config' files in this project? I need to check their settings.
+model:
+<|tool_call>call:${ToolNames.GLOB}{pattern:<|"|>./**/app.config<|"|>}<tool_call|>
+(Assuming GlobTool returns a list of paths like ['/path/to/moduleA/app.config', '/path/to/moduleB/app.config'])
+I found the following 'app.config' files:
+- /path/to/moduleA/app.config
+- /path/to/moduleB/app.config
+To help you check their settings, I can read their contents. Which one would you like to start with, or should I read all of them?
+</example>
+`.trim();
 function getToolCallExamples(model) {
   const toolCallStyle = process2.env["QWEN_CODE_TOOL_CALL_STYLE"];
   if (toolCallStyle) {
@@ -43157,6 +43597,8 @@ function getToolCallExamples(model) {
         return qwenCoderToolCallExamples;
       case "qwen-vl":
         return qwenVlToolCallExamples;
+      case "gemma4":
+        return gemma4ToolCallExamples;
       case "general":
         return generalToolCallExamples;
       default:
@@ -43176,13 +43618,16 @@ function getToolCallExamples(model) {
     if (/coder-model/i.test(model)) {
       return qwenCoderToolCallExamples;
     }
+    if (/gemma[-_]?4/i.test(model)) {
+      return gemma4ToolCallExamples;
+    }
   }
   return generalToolCallExamples;
 }
 __name(getToolCallExamples, "getToolCallExamples");
 function getPlanModeSystemReminder(planOnly = false) {
   return `<system-reminder>
-Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received (for example, to make edits).
+Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run tools classified as state-modifying (including changing configs or making commits), or otherwise make changes to the system. A shell command whose safety cannot be determined may run only after the user explicitly approves that exact invocation once, and only when it is necessary for the investigation. This supersedes any other instructions you have received (for example, to make edits).
 
 ## Iterative Planning Workflow
 
@@ -43218,10 +43663,13 @@ Start by quickly scanning a few key files to form an initial understanding of th
 
 If a non-read-only tool is blocked:
 - Do NOT retry the blocked tool or repeatedly attempt similar non-read-only tools
+- Do NOT use wrappers, quoting tricks, aliases, or obfuscation to make a blocked write look unknown
 - Do NOT immediately call exit_plan_mode just to unblock it \u2014 continue gathering context with read-only tools first
 - Pivot to read-only tools (read_file, grep_search, glob, list_directory, agents) to gather the information the blocked tool would have provided
 - Once you have enough context to form a complete plan, call exit_plan_mode
 
+An exact one-off approval for an unknown shell command approves only that invocation. It does not approve the plan, authorize related commands, or exit Plan mode.
+
 ### When to Converge
 
 Your plan is ready when you have addressed all ambiguities and it covers: what to change, which files to modify, what existing code to reuse (with file paths), and how to verify the changes. Present your plan ${planOnly ? "directly" : `by calling the ${ToolNames.EXIT_PLAN_MODE} tool, which will prompt the user to confirm the plan`}. Do NOT make any file changes or run any tools that modify the system state in any way until the user has confirmed the plan.
@@ -49577,25 +50025,32 @@ function matchesMcpPattern(pattern, toolName) {
   if (pattern === toolName) {
     return true;
   }
+  if (!pattern.endsWith("*") && pattern.split("__").length >= 3 && normalizeMcpToolName(pattern) === normalizeMcpToolName(toolName)) {
+    return true;
+  }
   if (pattern.endsWith("*")) {
-    const prefix = pattern.slice(0, -1);
-    return toolName.startsWith(prefix);
+    const prefix = sanitizeToolNameForProvider(pattern.slice(0, -1));
+    return sanitizeToolNameForProvider(toolName).startsWith(prefix);
   }
   const patternParts = pattern.split("__");
   const toolParts = toolName.split("__");
-  if (patternParts.length === 2 && toolParts.length >= 3 && patternParts[0] === toolParts[0] && patternParts[1] === toolParts[1]) {
+  if (patternParts.length === 2 && toolParts.length >= 3 && patternParts[0] === toolParts[0] && sanitizeToolNameForProvider(patternParts[1]) === sanitizeToolNameForProvider(toolParts[1])) {
     return true;
   }
   return false;
 }
 __name(matchesMcpPattern, "matchesMcpPattern");
-function matchesRule(rule, toolName, command, filePath, domain, pathContext, specifier, toolParams, pathMatchMode = "lexical") {
+function matchesRule(rule, toolName, command, filePath, domain, pathContext, specifier, toolParams, toolAliases2, pathMatchMode = "lexical") {
   const canonicalCtxToolName = resolveToolName(toolName);
   if (rule.invalid) {
     return false;
   }
   if (rule.toolName.startsWith("mcp__") || canonicalCtxToolName.startsWith("mcp__")) {
-    if (!matchesMcpPattern(rule.toolName, canonicalCtxToolName)) {
+    const matchesLegacyExactName = !rule.toolName.endsWith("*") && rule.toolName.split("__").length >= 3 && (toolAliases2 ?? []).some(
+      (alias) => rule.toolName === resolveToolName(alias)
+    );
+    const matchesMcpName = matchesMcpPattern(rule.toolName, canonicalCtxToolName) || matchesLegacyExactName;
+    if (!matchesMcpName) {
       return false;
     }
     if (rule.specifier) {
@@ -54629,6 +55084,11 @@ async function classifyInternal(command) {
   }
 }
 __name(classifyInternal, "classifyInternal");
+async function classifyShellCommandSafety(command) {
+  if (typeof command !== "string" || !command.trim()) return "unknown";
+  return classifyInternal(command).catch(() => "unknown");
+}
+__name(classifyShellCommandSafety, "classifyShellCommandSafety");
 async function isShellCommandReadOnlyAST(command) {
   if (typeof command !== "string" || !command.trim()) return false;
   if (parserInitFailed) {
@@ -54981,7 +55441,16 @@ var PermissionManager = class _PermissionManager {
    *      to match equivalent shell commands (e.g. `cat` → Read, `curl` → WebFetch).
    */
   evaluateSingle(ctx) {
-    const { toolName, command, cwd, filePath, domain, specifier, toolParams } = ctx;
+    const {
+      toolName,
+      toolAliases: toolAliases2,
+      command,
+      cwd,
+      filePath,
+      domain,
+      specifier,
+      toolParams
+    } = ctx;
     const pathCtx = this.config.getProjectRoot && this.config.getCwd ? {
       projectRoot: this.config.getProjectRoot(),
       cwd: cwd ?? this.config.getCwd()
@@ -54993,7 +55462,8 @@ var PermissionManager = class _PermissionManager {
       domain,
       pathCtx,
       specifier,
-      toolParams
+      toolParams,
+      toolAliases2
     ];
     const baseDecision = (() => {
       for (const rule of [
@@ -55224,7 +55694,16 @@ var PermissionManager = class _PermissionManager {
    */
   findMatchingDenyRule(ctx) {
     ctx = this.normalizePermissionContext(ctx);
-    const { toolName, command, cwd, filePath, domain, specifier, toolParams } = ctx;
+    const {
+      toolName,
+      toolAliases: toolAliases2,
+      command,
+      cwd,
+      filePath,
+      domain,
+      specifier,
+      toolParams
+    } = ctx;
     const pathCtx = this.config.getProjectRoot && this.config.getCwd ? {
       projectRoot: this.config.getProjectRoot(),
       cwd: cwd ?? this.config.getCwd()
@@ -55236,7 +55715,8 @@ var PermissionManager = class _PermissionManager {
       domain,
       pathCtx,
       specifier,
-      toolParams
+      toolParams,
+      toolAliases2
     ];
     for (const rule of [
       ...this.sessionRules.deny,
@@ -55290,7 +55770,16 @@ var PermissionManager = class _PermissionManager {
    */
   hasRelevantRules(ctx) {
     ctx = this.normalizePermissionContext(ctx);
-    const { toolName, command, cwd, filePath, domain, specifier, toolParams } = ctx;
+    const {
+      toolName,
+      toolAliases: toolAliases2,
+      command,
+      cwd,
+      filePath,
+      domain,
+      specifier,
+      toolParams
+    } = ctx;
     const pathCtx = this.config.getProjectRoot && this.config.getCwd ? {
       projectRoot: this.config.getProjectRoot(),
       cwd: cwd ?? this.config.getCwd()
@@ -55321,7 +55810,13 @@ var PermissionManager = class _PermissionManager {
           void 0
         ];
         return restrictiveRules.some(
-          (rule) => matchesRule(rule, ...opMatchArgs, void 0, "canonical")
+          (rule) => matchesRule(
+            rule,
+            ...opMatchArgs,
+            void 0,
+            void 0,
+            "canonical"
+          )
         ) || allowRules.some(
           (rule) => matchesRule(rule, ...opMatchArgs, void 0)
         );
@@ -55344,7 +55839,8 @@ var PermissionManager = class _PermissionManager {
       domain,
       pathCtx,
       specifier,
-      toolParams
+      toolParams,
+      toolAliases2
     ];
     return restrictiveRules.some(
       (rule) => matchesRule(rule, ...matchArgs, "canonical")
@@ -55361,7 +55857,16 @@ var PermissionManager = class _PermissionManager {
    */
   hasMatchingAskRule(ctx) {
     ctx = this.normalizePermissionContext(ctx);
-    const { toolName, command, cwd, filePath, domain, specifier, toolParams } = ctx;
+    const {
+      toolName,
+      toolAliases: toolAliases2,
+      command,
+      cwd,
+      filePath,
+      domain,
+      specifier,
+      toolParams
+    } = ctx;
     const pathCtx = this.config.getProjectRoot && this.config.getCwd ? {
       projectRoot: this.config.getProjectRoot(),
       cwd: cwd ?? this.config.getCwd()
@@ -55383,7 +55888,13 @@ var PermissionManager = class _PermissionManager {
           void 0
         ];
         return askRules.some(
-          (rule) => matchesRule(rule, ...opMatchArgs, void 0, "canonical")
+          (rule) => matchesRule(
+            rule,
+            ...opMatchArgs,
+            void 0,
+            void 0,
+            "canonical"
+          )
         );
       })) {
         return true;
@@ -55404,7 +55915,8 @@ var PermissionManager = class _PermissionManager {
       domain,
       pathCtx,
       specifier,
-      toolParams
+      toolParams,
+      toolAliases2
     ];
     return askRules.some(
       (rule) => matchesRule(rule, ...matchArgs, "canonical")
@@ -58253,7 +58765,7 @@ init_esbuild_shims();
 // packages/core/src/core/permission-helpers.ts
 init_esbuild_shims();
 import * as path18 from "node:path";
-function buildPermissionCheckContext(toolName, toolParams, targetDir) {
+function buildPermissionCheckContext(toolName, toolParams, targetDir, toolAliases2) {
   const rawCommand = "command" in toolParams ? String(toolParams["command"]) : void 0;
   const command = rawCommand;
   const cwd = typeof toolParams["directory"] === "string" ? path18.isAbsolute(toolParams["directory"]) ? toolParams["directory"] : path18.resolve(targetDir, toolParams["directory"]) : void 0;
@@ -58272,7 +58784,16 @@ function buildPermissionCheckContext(toolName, toolParams, targetDir) {
     }
   }
   const specifier = typeof toolParams["skill"] === "string" ? toolParams["skill"] : typeof toolParams["subagent_type"] === "string" ? toolParams["subagent_type"] : typeof toolParams["server_name"] === "string" ? toolParams["server_name"] : void 0;
-  return { toolName, command, cwd, filePath, domain, specifier, toolParams };
+  return {
+    toolName,
+    toolAliases: toolAliases2,
+    command,
+    cwd,
+    filePath,
+    domain,
+    specifier,
+    toolParams
+  };
 }
 __name(buildPermissionCheckContext, "buildPermissionCheckContext");
 async function evaluatePermissionRules(pm, defaultPermission, pmCtx) {
@@ -58324,7 +58845,8 @@ async function evaluatePermissionFlow(config, invocation, toolName, toolParams)
   const pmCtx = buildPermissionCheckContext(
     toolName,
     toolParams,
-    config.getTargetDir?.() ?? ""
+    config.getTargetDir?.() ?? "",
+    invocation.permissionAliases
   );
   const { finalPermission, pmForcedAsk } = await evaluatePermissionRules(
     pm,
@@ -58382,6 +58904,200 @@ function isAutoEditApproved(approvalMode, confirmationDetails) {
 }
 __name(isAutoEditApproved, "isAutoEditApproved");
 
+// packages/core/src/core/plan-mode-shell-policy.ts
+init_esbuild_shims();
+import { isDeepStrictEqual } from "node:util";
+var UNKNOWN_WARNING = "Plan mode could not determine whether this shell command is read-only. Approval applies only to this exact invocation once; it may modify system state, and Plan mode will remain active.";
+var WRITE_BLOCK_MESSAGE = "Plan mode blocked this shell command because it was classified as state-modifying. Do not retry it through wrappers or obfuscation; continue read-only investigation and include the action in the plan.";
+var NO_APPROVAL_MESSAGE = "Plan mode could not determine whether this shell command is read-only, and no approval surface is available. The command was not run; Plan mode remains active.";
+var STALE_APPROVAL_MESSAGE = "Plan-mode shell approval is no longer valid because the mode, permission policy, or exact invocation changed. Submit a new tool call.";
+function isApplicable(decision) {
+  return decision.classification !== "not-applicable";
+}
+__name(isApplicable, "isApplicable");
+function clone(value) {
+  return structuredClone(value);
+}
+__name(clone, "clone");
+function abortError(signal) {
+  return signal.reason instanceof Error ? signal.reason : new Error("Plan-mode shell policy evaluation was aborted.");
+}
+__name(abortError, "abortError");
+function raceWithAbort(operation, signal) {
+  if (signal.aborted) {
+    return Promise.reject(abortError(signal));
+  }
+  return new Promise((resolve38, reject) => {
+    let settled = false;
+    const finish = /* @__PURE__ */ __name((callback) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      callback();
+    }, "finish");
+    const onAbort = /* @__PURE__ */ __name(() => finish(() => reject(abortError(signal))), "onAbort");
+    signal.addEventListener("abort", onAbort, { once: true });
+    let pending;
+    try {
+      pending = operation();
+    } catch (error) {
+      finish(() => reject(error));
+      return;
+    }
+    pending.then(
+      (value) => finish(() => resolve38(value)),
+      (error) => finish(() => reject(error))
+    );
+  });
+}
+__name(raceWithAbort, "raceWithAbort");
+function appendUnique(values, value) {
+  return values?.includes(value) ? values : [...values ?? [], value];
+}
+__name(appendUnique, "appendUnique");
+function effectiveWorkingDirectory(config, invocationParams) {
+  const directory = invocationParams["directory"];
+  return typeof directory === "string" && directory.length > 0 ? directory : config.getTargetDir();
+}
+__name(effectiveWorkingDirectory, "effectiveWorkingDirectory");
+async function evaluatePlanModeShellPolicy(input) {
+  if (input.toolName !== ToolNames.SHELL && input.toolName !== ToolNames.MONITOR) {
+    return { classification: "not-applicable" };
+  }
+  if (input.config.getApprovalMode() !== "plan" /* PLAN */) {
+    return { classification: "not-applicable" };
+  }
+  const rawCommand = typeof input.invocationParams["command"] === "string" ? input.invocationParams["command"] : "";
+  const safetyCommand = input.toolName === ToolNames.MONITOR ? normalizeMonitorCommand(rawCommand).safetyCommand : rawCommand;
+  const permissionContext = clone(input.permissionContext);
+  permissionContext.cwd = effectiveWorkingDirectory(
+    input.config,
+    input.invocationParams
+  );
+  permissionContext.toolParams = clone(input.invocationParams);
+  const invocationDirectory = input.invocationParams["directory"];
+  const ambientWorkingDirectory = input.ambientWorkingDirectory ?? (typeof invocationDirectory !== "string" || invocationDirectory.length === 0 ? input.config.getTargetDir() : void 0);
+  const snapshot = {
+    requestArgs: clone(input.requestArgs),
+    invocationParams: clone(input.invocationParams),
+    approvalModeRevision: input.config.getApprovalModeRevision(),
+    permissionContext,
+    ambientWorkingDirectory
+  };
+  let classification;
+  try {
+    classification = await raceWithAbort(
+      () => classifyShellCommandSafety(safetyCommand),
+      input.signal
+    );
+  } catch (error) {
+    if (input.signal.aborted) throw error;
+    classification = "unknown";
+  }
+  return {
+    classification,
+    rawCommand,
+    snapshot,
+    writeBlockMessage: WRITE_BLOCK_MESSAGE,
+    noApprovalMessage: NO_APPROVAL_MESSAGE
+  };
+}
+__name(evaluatePlanModeShellPolicy, "evaluatePlanModeShellPolicy");
+async function validatePlanModeShellContext(input) {
+  if (!isApplicable(input.decision)) return void 0;
+  const decision = input.decision;
+  if (input.signal.aborted) throw abortError(input.signal);
+  const matchesSnapshot = /* @__PURE__ */ __name(() => !input.signal.aborted && input.config.getApprovalMode() === "plan" /* PLAN */ && input.config.getApprovalModeRevision() === decision.snapshot.approvalModeRevision && (decision.snapshot.ambientWorkingDirectory === void 0 || input.config.getTargetDir() === decision.snapshot.ambientWorkingDirectory) && effectiveWorkingDirectory(input.config, input.invocationParams) === decision.snapshot.permissionContext.cwd && isDeepStrictEqual(input.requestArgs, decision.snapshot.requestArgs) && isDeepStrictEqual(
+    input.invocationParams,
+    decision.snapshot.invocationParams
+  ), "matchesSnapshot");
+  if (!matchesSnapshot()) return STALE_APPROVAL_MESSAGE;
+  const permissionManager = input.config.getPermissionManager?.();
+  if (permissionManager) {
+    try {
+      const currentPermission = await raceWithAbort(
+        () => permissionManager.evaluate(
+          clone(decision.snapshot.permissionContext)
+        ),
+        input.signal
+      );
+      if (currentPermission === "deny") return STALE_APPROVAL_MESSAGE;
+    } catch {
+      if (input.signal.aborted) throw abortError(input.signal);
+      return STALE_APPROVAL_MESSAGE;
+    }
+  }
+  if (input.signal.aborted) throw abortError(input.signal);
+  return matchesSnapshot() ? void 0 : STALE_APPROVAL_MESSAGE;
+}
+__name(validatePlanModeShellContext, "validatePlanModeShellContext");
+function decoratePlanModeShellConfirmation(decision, confirmation) {
+  if (!isApplicable(decision)) return confirmation;
+  if (confirmation.type === "ask_user_question") {
+    throw new Error(decision.noApprovalMessage);
+  }
+  if (decision.classification !== "unknown") {
+    return { ...confirmation, hideAlwaysAllow: true };
+  }
+  if (confirmation.type === "exec") {
+    return {
+      ...confirmation,
+      hideAlwaysAllow: true,
+      warnings: appendUnique(confirmation.warnings, UNKNOWN_WARNING)
+    };
+  }
+  if (confirmation.type === "edit") {
+    const warnings = appendUnique(confirmation.warnings, UNKNOWN_WARNING);
+    return {
+      ...confirmation,
+      hideAlwaysAllow: true,
+      hideModify: true,
+      skipIdeDiff: true,
+      warnings: appendUnique(
+        warnings,
+        `Exact shell command: \`${decision.rawCommand}\``
+      )
+    };
+  }
+  throw new Error(decision.noApprovalMessage);
+}
+__name(decoratePlanModeShellConfirmation, "decoratePlanModeShellConfirmation");
+async function validatePlanModeShellApproval(input) {
+  if (!isApplicable(input.decision)) {
+    return { outcome: input.outcome, payload: input.payload };
+  }
+  if (input.outcome === "cancel" /* Cancel */) {
+    return {
+      outcome: "cancel" /* Cancel */,
+      ...input.payload?.cancelMessage ? { payload: { cancelMessage: input.payload.cancelMessage } } : {}
+    };
+  }
+  const invalidContext = await validatePlanModeShellContext(input);
+  const invalidOutcome = input.outcome !== "proceed_once" /* ProceedOnce */;
+  const invalidPayload = input.payload?.newContent !== void 0 || input.payload?.updatedInput !== void 0 && !isDeepStrictEqual(
+    input.payload.updatedInput,
+    input.decision.snapshot.requestArgs
+  );
+  if (invalidContext || invalidOutcome || invalidPayload) {
+    return {
+      outcome: "cancel" /* Cancel */,
+      payload: { cancelMessage: STALE_APPROVAL_MESSAGE }
+    };
+  }
+  return { outcome: "proceed_once" /* ProceedOnce */ };
+}
+__name(validatePlanModeShellApproval, "validatePlanModeShellApproval");
+
+// packages/core/src/core/plan-mode-entry-policy.ts
+init_esbuild_shims();
+var PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE = "Tool call skipped because enter_plan_mode is an execution boundary. Retry it in the next model turn after observing the resulting approval mode.";
+function findPlanModeEntryBatchBoundaryIndex(toolNames) {
+  if (toolNames.length <= 1) return void 0;
+  const index = toolNames.indexOf(ToolNames.ENTER_PLAN_MODE);
+  return index === -1 ? void 0 : index;
+}
+__name(findPlanModeEntryBatchBoundaryIndex, "findPlanModeEntryBatchBoundaryIndex");
+
 // packages/core/src/core/geminiRequest.ts
 init_esbuild_shims();
 function partListUnionToString(value) {
@@ -65642,7 +66358,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-K23CFKGN.js");
+        const { KeychainTokenStorage: KeychainTokenStorage2 } = await import("./keychain-token-storage-DWRJMNH3.js");
         const keychainStorage = new KeychainTokenStorage2(this.serviceName);
         const isAvailable = await keychainStorage.isAvailable();
         if (isAvailable) {
@@ -70842,15 +71558,28 @@ var ToolRegistry = class _ToolRegistry {
    * built-ins and MCP-discovered tools flow through `registerTool`, so
    * gating here covers every registration path.
    */
-  isToolDisabled(name) {
-    return this.config.getDisabledTools().has(name);
+  isToolDisabled(name, aliases = []) {
+    const disabledTools = this.config.getDisabledTools();
+    const hasExactMatch = disabledTools.has(name) || aliases.some((alias) => disabledTools.has(alias));
+    if (hasExactMatch || !name.startsWith("mcp__")) {
+      return hasExactMatch;
+    }
+    for (const disabledName of disabledTools) {
+      if (normalizeMcpToolName(disabledName) === name) {
+        return true;
+      }
+    }
+    return false;
   }
   /**
    * Registers a tool definition.
    * @param tool - The tool object containing schema and execution logic.
    */
   registerTool(tool) {
-    if (this.isToolDisabled(tool.name)) {
+    if (this.isToolDisabled(
+      tool.name,
+      tool instanceof DiscoveredMCPTool ? tool.permissionAliases : []
+    )) {
       debugLogger39.info(
         `Tool "${tool.name}" skipped: present in disabledTools set.`
       );
@@ -70867,7 +71596,10 @@ var ToolRegistry = class _ToolRegistry {
         );
       }
     }
-    if (this.isToolDisabled(tool.name)) {
+    if (this.isToolDisabled(
+      tool.name,
+      tool instanceof DiscoveredMCPTool ? tool.permissionAliases : []
+    )) {
       debugLogger39.info(
         `Tool "${tool.name}" skipped (post-rename): present in disabledTools set.`
       );
@@ -75064,6 +75796,12 @@ var TOKEN_PLAN_MODELS = [
     modalities: { image: true, video: true }
   },
   { id: "qwen3.7-max", contextWindowSize: 1e6, enableThinking: true },
+  {
+    id: "qwen3.8-max-preview",
+    contextWindowSize: 1e6,
+    enableThinking: true,
+    modalities: { image: true, video: true }
+  },
   {
     id: "qwen3.6-flash",
     contextWindowSize: 1e6,
@@ -89156,8 +89894,8 @@ var GitWorktreeService = class _GitWorktreeService {
   async getRegisteredWorktreeBranch(worktreePath) {
     let resolvedWorktreePath;
     try {
-      const stat19 = await fs25.stat(worktreePath);
-      if (!stat19.isDirectory()) return null;
+      const stat20 = await fs25.stat(worktreePath);
+      if (!stat20.isDirectory()) return null;
       resolvedWorktreePath = await fs25.realpath(worktreePath);
     } catch {
       return null;
@@ -89996,6 +90734,387 @@ function takeRecentDialog2(history, windowSize) {
 }
 __name(takeRecentDialog2, "takeRecentDialog");
 
+// packages/core/src/utils/conversation-chain.ts
+init_esbuild_shims();
+function buildOrderedUuidChain(records, opts) {
+  if (records.length === 0) return { uuids: [], gaps: [] };
+  const detectGaps = opts?.detectGaps ?? false;
+  const transcriptRecords = records;
+  const firstByUuid = /* @__PURE__ */ new Map();
+  for (const r2 of records) {
+    if (isTranscriptConversationRecord(r2) && !firstByUuid.has(r2.uuid)) {
+      firstByUuid.set(r2.uuid, r2);
+    }
+  }
+  const startUuid = selectTranscriptLeaf(transcriptRecords, opts?.leafUuid);
+  if (!startUuid) return { uuids: [], gaps: [] };
+  const chain = walkTranscriptUuidChain(
+    startUuid,
+    (uuid) => firstByUuid.get(uuid)
+  );
+  return {
+    uuids: [...chain.uuids],
+    gaps: detectGaps ? [...chain.gaps] : []
+  };
+}
+__name(buildOrderedUuidChain, "buildOrderedUuidChain");
+
+// packages/core/src/utils/conversation-branches.ts
+init_esbuild_shims();
+var SUMMARY_TEXT_LIMIT = 200;
+var SYNTHETIC_USER_SUBTYPES = /* @__PURE__ */ new Set([
+  "notification",
+  "cron",
+  "mid_turn_user_message"
+]);
+var NEUTRAL_TAIL_SUBTYPES = /* @__PURE__ */ new Set([
+  "custom_title",
+  "session_artifact_event",
+  "session_artifact_snapshot"
+]);
+function inspectConversationBranches(records) {
+  if (records.length === 0) return { branches: [], diagnostics: [] };
+  const index = buildConversationIndex(records);
+  const semanticLeaves = findSemanticLeaves(index);
+  const leafCountByAncestor = countLeafDescendants(
+    semanticLeaves.map(({ leafUuid }) => leafUuid),
+    index.firstByUuid
+  );
+  const rewindUuids = [...index.firstByUuid.values()].filter(isRewindRecord).map((record2) => record2.uuid);
+  const forestPositions = indexForest(index);
+  const branches = semanticLeaves.map(
+    ({ leafUuid, physicalLeafUuid }) => summarizeBranch(
+      leafUuid,
+      physicalLeafUuid,
+      leafCountByAncestor,
+      rewindUuids,
+      forestPositions,
+      index
+    )
+  );
+  return { branches, diagnostics: index.diagnostics };
+}
+__name(inspectConversationBranches, "inspectConversationBranches");
+function indexForest(index) {
+  const positions = /* @__PURE__ */ new Map();
+  let clock = 0;
+  for (const [uuid, record2] of index.firstByUuid) {
+    if (record2.parentUuid !== null && index.firstByUuid.has(record2.parentUuid)) {
+      continue;
+    }
+    const stack = [
+      { uuid, exiting: false }
+    ];
+    while (stack.length > 0) {
+      const frame = stack.pop();
+      if (frame.exiting) {
+        const position = positions.get(frame.uuid);
+        if (position) position.exitedAt = clock++;
+        continue;
+      }
+      if (positions.has(frame.uuid)) continue;
+      positions.set(frame.uuid, {
+        rootUuid: uuid,
+        enteredAt: clock++,
+        exitedAt: -1
+      });
+      stack.push({ uuid: frame.uuid, exiting: true });
+      const children = index.childrenByUuid.get(frame.uuid) ?? [];
+      for (let childIndex = children.length - 1; childIndex >= 0; childIndex--) {
+        stack.push({ uuid: children[childIndex], exiting: false });
+      }
+    }
+  }
+  return positions;
+}
+__name(indexForest, "indexForest");
+function buildConversationIndex(records) {
+  const firstByUuid = /* @__PURE__ */ new Map();
+  const recordsByUuid = /* @__PURE__ */ new Map();
+  const physicalIndexByUuid = /* @__PURE__ */ new Map();
+  for (const [physicalIndex, record2] of records.entries()) {
+    const grouped = recordsByUuid.get(record2.uuid);
+    if (grouped) {
+      grouped.push(record2);
+    } else {
+      firstByUuid.set(record2.uuid, record2);
+      recordsByUuid.set(record2.uuid, [record2]);
+      physicalIndexByUuid.set(record2.uuid, physicalIndex);
+    }
+  }
+  const diagnostics = [];
+  const childrenByUuid = /* @__PURE__ */ new Map();
+  for (const [uuid, grouped] of recordsByUuid) {
+    const parentUuids = [
+      ...new Set(grouped.map((record2) => record2.parentUuid))
+    ];
+    if (parentUuids.length > 1) {
+      diagnostics.push({ kind: "conflicting-parent", uuid, parentUuids });
+    }
+    const parentUuid = firstByUuid.get(uuid)?.parentUuid;
+    if (parentUuid === void 0 || parentUuid === null) continue;
+    if (!firstByUuid.has(parentUuid)) {
+      diagnostics.push({
+        kind: "missing-parent",
+        childUuid: uuid,
+        missingParentUuid: parentUuid
+      });
+      continue;
+    }
+    const children = childrenByUuid.get(parentUuid);
+    if (children) {
+      children.push(uuid);
+    } else {
+      childrenByUuid.set(parentUuid, [uuid]);
+    }
+  }
+  diagnostics.push(...findParentCycles(firstByUuid));
+  return {
+    firstByUuid,
+    recordsByUuid,
+    childrenByUuid,
+    physicalIndexByUuid,
+    diagnostics
+  };
+}
+__name(buildConversationIndex, "buildConversationIndex");
+function findParentCycles(firstByUuid) {
+  const complete = /* @__PURE__ */ new Set();
+  const diagnostics = [];
+  for (const startUuid of firstByUuid.keys()) {
+    if (complete.has(startUuid)) continue;
+    const path99 = [];
+    const positionByUuid = /* @__PURE__ */ new Map();
+    let currentUuid = startUuid;
+    while (currentUuid !== null && firstByUuid.has(currentUuid)) {
+      if (complete.has(currentUuid)) break;
+      const existingPosition = positionByUuid.get(currentUuid);
+      if (existingPosition !== void 0) {
+        diagnostics.push({
+          kind: "parent-cycle",
+          uuids: path99.slice(existingPosition)
+        });
+        break;
+      }
+      positionByUuid.set(currentUuid, path99.length);
+      path99.push(currentUuid);
+      currentUuid = firstByUuid.get(currentUuid)?.parentUuid ?? null;
+    }
+    for (const uuid of path99) complete.add(uuid);
+  }
+  return diagnostics;
+}
+__name(findParentCycles, "findParentCycles");
+function findSemanticLeaves(index) {
+  const candidates = /* @__PURE__ */ new Set();
+  const physicalLeafBySemanticLeaf = /* @__PURE__ */ new Map();
+  for (const uuid of index.firstByUuid.keys()) {
+    if ((index.childrenByUuid.get(uuid)?.length ?? 0) > 0) continue;
+    const leafUuid = collapseNeutralTail(uuid, index.firstByUuid);
+    if (leafUuid === null) continue;
+    candidates.add(leafUuid);
+    physicalLeafBySemanticLeaf.set(leafUuid, uuid);
+  }
+  const superseded = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const visited = /* @__PURE__ */ new Set();
+    let currentUuid = index.firstByUuid.get(candidate)?.parentUuid ?? null;
+    while (currentUuid !== null && index.firstByUuid.has(currentUuid) && !visited.has(currentUuid)) {
+      if (candidates.has(currentUuid)) superseded.add(currentUuid);
+      visited.add(currentUuid);
+      currentUuid = index.firstByUuid.get(currentUuid)?.parentUuid ?? null;
+    }
+  }
+  const leaves = [...candidates].filter(
+    (candidate) => !superseded.has(candidate)
+  );
+  return leaves.sort((left, right) => {
+    const leftPhysicalLeaf = physicalLeafBySemanticLeaf.get(left);
+    const rightPhysicalLeaf = physicalLeafBySemanticLeaf.get(right);
+    return index.physicalIndexByUuid.get(leftPhysicalLeaf) - index.physicalIndexByUuid.get(rightPhysicalLeaf);
+  }).map((leafUuid) => ({
+    leafUuid,
+    physicalLeafUuid: physicalLeafBySemanticLeaf.get(leafUuid)
+  }));
+}
+__name(findSemanticLeaves, "findSemanticLeaves");
+function countLeafDescendants(semanticLeaves, firstByUuid) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const leafUuid of semanticLeaves) {
+    for (const uuid of buildChain(leafUuid, firstByUuid)) {
+      counts.set(uuid, (counts.get(uuid) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
+__name(countLeafDescendants, "countLeafDescendants");
+function collapseNeutralTail(leafUuid, firstByUuid) {
+  const visited = /* @__PURE__ */ new Set();
+  let currentUuid = leafUuid;
+  while (!visited.has(currentUuid)) {
+    visited.add(currentUuid);
+    const record2 = firstByUuid.get(currentUuid);
+    if (!record2) return null;
+    if (!isNeutralTailRecord(record2)) return currentUuid;
+    const parentUuid = record2.parentUuid;
+    if (parentUuid === null || !firstByUuid.has(parentUuid)) return null;
+    currentUuid = parentUuid;
+  }
+  return null;
+}
+__name(collapseNeutralTail, "collapseNeutralTail");
+function summarizeBranch(leafUuid, physicalLeafUuid, leafCountByAncestor, rewindUuids, forestPositions, index) {
+  const chain = buildChain(leafUuid, index.firstByUuid);
+  const chainSet = new Set(chain);
+  const branchPointUuid = findBranchPoint(chain, leafCountByAncestor);
+  const containsRewindUuids = chain.filter(
+    (uuid) => isRewindRecord(index.firstByUuid.get(uuid))
+  );
+  const siblingRewindUuids = rewindUuids.filter(
+    (rewindUuid) => !chainSet.has(rewindUuid) && isSiblingPath(
+      leafUuid,
+      chain,
+      rewindUuid,
+      forestPositions,
+      index.firstByUuid
+    )
+  );
+  const firstRecord = index.firstByUuid.get(chain[0]);
+  const physicalLeafRecord = index.firstByUuid.get(physicalLeafUuid);
+  const recordCounts = { user: 0, assistant: 0, toolResult: 0, system: 0 };
+  for (const uuid of chain) {
+    const record2 = index.firstByUuid.get(uuid);
+    if (record2.type === "tool_result") {
+      recordCounts.toolResult++;
+    } else {
+      recordCounts[record2.type]++;
+    }
+  }
+  const firstDistinctIndex = branchPointUuid ? chain.indexOf(branchPointUuid) + 1 : 0;
+  const firstUserTextAfterBranchPoint = findUserText(
+    chain.slice(firstDistinctIndex),
+    index
+  );
+  const lastUserText = findUserText([...chain].reverse(), index);
+  const lastAssistantText = findAssistantText([...chain].reverse(), index);
+  return {
+    leafUuid,
+    branchPointUuid,
+    classification: classifyBranch(
+      containsRewindUuids.length > 0,
+      siblingRewindUuids.length > 0
+    ),
+    containsRewindUuids,
+    siblingRewindUuids,
+    ...firstUserTextAfterBranchPoint ? { firstUserTextAfterBranchPoint } : {},
+    ...lastUserText ? { lastUserText } : {},
+    ...lastAssistantText ? { lastAssistantText } : {},
+    recordCounts,
+    startedAt: firstRecord.timestamp,
+    updatedAt: physicalLeafRecord.timestamp
+  };
+}
+__name(summarizeBranch, "summarizeBranch");
+function findBranchPoint(chain, leafCountByAncestor) {
+  for (let index = chain.length - 2; index >= 0; index--) {
+    const candidate = chain[index];
+    if (candidate && (leafCountByAncestor.get(candidate) ?? 0) > 1) {
+      return candidate;
+    }
+  }
+  return null;
+}
+__name(findBranchPoint, "findBranchPoint");
+function findUserText(uuids, index) {
+  for (const uuid of uuids) {
+    const record2 = index.firstByUuid.get(uuid);
+    if (!record2 || record2.type !== "user" || isSyntheticUserRecord(record2)) {
+      continue;
+    }
+    const text = extractText2(index.recordsByUuid.get(uuid) ?? [], "user");
+    if (text) return text;
+  }
+  return void 0;
+}
+__name(findUserText, "findUserText");
+function findAssistantText(uuids, index) {
+  for (const uuid of uuids) {
+    if (index.firstByUuid.get(uuid)?.type !== "assistant") continue;
+    const text = extractText2(index.recordsByUuid.get(uuid) ?? [], "assistant");
+    if (text) return text;
+  }
+  return void 0;
+}
+__name(findAssistantText, "findAssistantText");
+function extractText2(records, type) {
+  const text = records.filter(
+    (record2) => record2.type === type && (type !== "user" || !isSyntheticUserRecord(record2))
+  ).flatMap((record2) => record2.message?.parts ?? []).map((part) => {
+    const textPart = part;
+    return typeof textPart.text === "string" && textPart.thought !== true ? textPart.text : "";
+  }).join(" ").replace(/\s+/g, " ").trim();
+  if (!text) return void 0;
+  return text.length > SUMMARY_TEXT_LIMIT ? `${text.slice(0, SUMMARY_TEXT_LIMIT)}...` : text;
+}
+__name(extractText2, "extractText");
+function buildChain(leafUuid, firstByUuid) {
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  let currentUuid = leafUuid;
+  while (currentUuid !== null && firstByUuid.has(currentUuid) && !visited.has(currentUuid)) {
+    visited.add(currentUuid);
+    chain.push(currentUuid);
+    currentUuid = firstByUuid.get(currentUuid)?.parentUuid ?? null;
+  }
+  chain.reverse();
+  return chain;
+}
+__name(buildChain, "buildChain");
+function isSiblingPath(leafUuid, leafChain, rewindUuid, forestPositions, firstByUuid) {
+  const leafPosition = forestPositions.get(leafUuid);
+  const rewindPosition = forestPositions.get(rewindUuid);
+  if (leafPosition && rewindPosition) {
+    return leafPosition.rootUuid === rewindPosition.rootUuid && !isAncestorPosition(leafPosition, rewindPosition);
+  }
+  return pathsDiverge(leafChain, buildChain(rewindUuid, firstByUuid));
+}
+__name(isSiblingPath, "isSiblingPath");
+function isAncestorPosition(ancestor, descendant) {
+  return ancestor.enteredAt <= descendant.enteredAt && ancestor.exitedAt >= descendant.exitedAt;
+}
+__name(isAncestorPosition, "isAncestorPosition");
+function pathsDiverge(left, right) {
+  const rightPositions = new Map(right.map((uuid, index) => [uuid, index]));
+  for (let leftIndex = left.length - 1; leftIndex >= 0; leftIndex--) {
+    const uuid = left[leftIndex];
+    if (!uuid) continue;
+    const rightIndex = rightPositions.get(uuid);
+    if (rightIndex === void 0) continue;
+    return leftIndex < left.length - 1 && rightIndex < right.length - 1;
+  }
+  return false;
+}
+__name(pathsDiverge, "pathsDiverge");
+function isNeutralTailRecord(record2) {
+  return record2.type === "system" && record2.subtype !== void 0 && NEUTRAL_TAIL_SUBTYPES.has(record2.subtype);
+}
+__name(isNeutralTailRecord, "isNeutralTailRecord");
+function isSyntheticUserRecord(record2) {
+  return record2.externalInputKind === "notification" || record2.subtype !== void 0 && SYNTHETIC_USER_SUBTYPES.has(record2.subtype);
+}
+__name(isSyntheticUserRecord, "isSyntheticUserRecord");
+function isRewindRecord(record2) {
+  return record2?.type === "system" && record2.subtype === "rewind";
+}
+__name(isRewindRecord, "isRewindRecord");
+function classifyBranch(containsRewind, hasSiblingRewind) {
+  if (containsRewind && hasSiblingRewind) return "mixed-rewind";
+  if (containsRewind) return "rewind-descendant";
+  if (hasSiblingRewind) return "rewind-sibling";
+  return "ordinary";
+}
+__name(classifyBranch, "classifyBranch");
+
 // packages/core/src/services/worktreeSessionService.ts
 init_esbuild_shims();
 import * as fs26 from "node:fs/promises";
@@ -90259,8 +91378,8 @@ async function restoreWorktreeContext(sidecarPath, onWarn) {
   }
   let worktreeAlive = false;
   try {
-    const stat19 = await fs26.stat(session.worktreePath);
-    worktreeAlive = stat19.isDirectory();
+    const stat20 = await fs26.stat(session.worktreePath);
+    worktreeAlive = stat20.isDirectory();
   } catch {
     worktreeAlive = false;
   }
@@ -93051,10 +94170,10 @@ function readOutputTail(outputFile) {
   let fd;
   try {
     fd = fs28.openSync(outputFile, getReadOutputOpenFlags());
-    const stat19 = fs28.fstatSync(fd);
-    if (!stat19.isFile() || stat19.size <= 0) return void 0;
-    const length = Math.min(stat19.size, MAX_NOTIFICATION_OUTPUT_TAIL_BYTES);
-    const start = stat19.size - length;
+    const stat20 = fs28.fstatSync(fd);
+    if (!stat20.isFile() || stat20.size <= 0) return void 0;
+    const length = Math.min(stat20.size, MAX_NOTIFICATION_OUTPUT_TAIL_BYTES);
+    const start = stat20.size - length;
     const buffer = Buffer.allocUnsafe(length);
     const bytesRead = fs28.readSync(fd, buffer, 0, length, start);
     let sliceOffset = 0;
@@ -95318,6 +96437,32 @@ async function listChannelMemoryEntries(target) {
   return document.entries;
 }
 __name(listChannelMemoryEntries, "listChannelMemoryEntries");
+async function getFileRevision(filePath) {
+  try {
+    const stats = await fs32.stat(filePath, { bigint: true });
+    return [
+      stats.dev,
+      stats.ino,
+      stats.size,
+      stats.mtimeNs,
+      stats.ctimeNs
+    ].join(":");
+  } catch (error) {
+    if (isMissingFile(error)) {
+      return "missing";
+    }
+    throw error;
+  }
+}
+__name(getFileRevision, "getFileRevision");
+async function getChannelMemoryRevision(target) {
+  const [canonical, legacy] = await Promise.all([
+    getFileRevision(getChannelMemoryFilePath(target)),
+    getFileRevision(getLegacyChannelMemoryFilePath(target))
+  ]);
+  return createHash11("sha256").update(canonical).update("\0").update(legacy).digest("hex");
+}
+__name(getChannelMemoryRevision, "getChannelMemoryRevision");
 async function addChannelMemoryEntries(target, texts, createdBy) {
   const textSnapshot = Array.from(texts);
   if (textSnapshot.length > MAX_CHANNEL_MEMORY_ENTRIES_PER_REQUEST) {
@@ -97327,11 +98472,11 @@ var WorkspaceMemoryFileTooLargeError = class extends Error {
 async function composeAppendedContent(filePath, newContent) {
   let existing = "";
   try {
-    const stat19 = await fs39.stat(filePath);
-    if (stat19.size > MAX_EXISTING_FILE_BYTES) {
+    const stat20 = await fs39.stat(filePath);
+    if (stat20.size > MAX_EXISTING_FILE_BYTES) {
       throw new WorkspaceMemoryFileTooLargeError(
         filePath,
-        stat19.size,
+        stat20.size,
         MAX_EXISTING_FILE_BYTES
       );
     }
@@ -98380,13 +99525,13 @@ var IdeClient = class _IdeClient {
       lockFiles.map(async (file) => {
         const fullPath = path47.join(ideDir, file);
         try {
-          const stat19 = await fs40.promises.stat(fullPath);
+          const stat20 = await fs40.promises.stat(fullPath);
           const content = await fs40.promises.readFile(fullPath, "utf8");
           try {
             return {
               file,
               fullPath,
-              mtimeMs: stat19.mtimeMs,
+              mtimeMs: stat20.mtimeMs,
               parsed: JSON.parse(content)
             };
           } catch (error) {
@@ -99922,7 +101067,7 @@ var LspResponseNormalizer = class {
   /**
    * Convert diagnostic back to LSP format for requests
    */
-  denormalizeDiagnostic(diagnostic) {
+  denormalizeDiagnostic(diagnostic2) {
     const severityMap = {
       error: 1,
       warning: 2,
@@ -99930,11 +101075,11 @@ var LspResponseNormalizer = class {
       hint: 4
     };
     return {
-      range: diagnostic.range,
-      message: diagnostic.message,
-      severity: diagnostic.severity ? severityMap[diagnostic.severity] : void 0,
-      code: diagnostic.code,
-      source: diagnostic.source
+      range: diagnostic2.range,
+      message: diagnostic2.message,
+      severity: diagnostic2.severity ? severityMap[diagnostic2.severity] : void 0,
+      code: diagnostic2.code,
+      source: diagnostic2.source
     };
   }
   /**
@@ -107832,8 +108977,8 @@ async function collectResources(resourcePaths, pluginRoot, destDir) {
       debugLogger75.warn(`Resource path not found: ${resolvedPath}`);
       continue;
     }
-    const stat19 = fs51.statSync(resolvedPath);
-    if (stat19.isDirectory()) {
+    const stat20 = fs51.statSync(resolvedPath);
+    if (stat20.isDirectory()) {
       const dirName = path56.basename(resolvedPath);
       const finalDestDir = dirName === destFolderName ? destDir : path56.join(destDir, dirName);
       const files = await glob("**/*", {
@@ -109425,7 +110570,7 @@ import * as path62 from "node:path";
 init_esbuild_shims();
 import * as fs57 from "node:fs";
 import * as path61 from "node:path";
-import { stat as stat9 } from "node:fs/promises";
+import { stat as stat10 } from "node:fs/promises";
 var debugLogger79 = createDebugLogger("EXT_MARKETPLACE");
 function parseSourceAndPluginName(source) {
   const urlSchemes = ["http://", "https://", "git@", "sso://"];
@@ -109612,7 +110757,7 @@ async function loadMarketplaceConfigFromSource(source, networkPolicy) {
   const trimmed2 = source.trim();
   const lowerTrimmed = trimmed2.toLowerCase();
   try {
-    const stats = await stat9(trimmed2);
+    const stats = await stat10(trimmed2);
     if (stats.isDirectory()) {
       return await readLocalMarketplaceConfig(trimmed2);
     }
@@ -109685,7 +110830,7 @@ async function parseInstallSource(source, options2 = {}) {
   let marketplaceConfig = null;
   let isLocalPath = false;
   try {
-    await stat9(repo);
+    await stat10(repo);
     isLocalPath = true;
   } catch {
   }
@@ -115584,13 +116729,13 @@ import * as os20 from "os";
 // node_modules/chokidar/esm/index.js
 init_esbuild_shims();
 import { stat as statcb } from "fs";
-import { stat as stat13, readdir as readdir11 } from "fs/promises";
+import { stat as stat14, readdir as readdir11 } from "fs/promises";
 import { EventEmitter as EventEmitter5 } from "events";
 import * as sysPath2 from "path";
 
 // node_modules/readdirp/esm/index.js
 init_esbuild_shims();
-import { stat as stat11, lstat as lstat6, readdir as readdir10, realpath as realpath7 } from "node:fs/promises";
+import { stat as stat12, lstat as lstat6, readdir as readdir10, realpath as realpath7 } from "node:fs/promises";
 import { Readable } from "node:stream";
 import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from "node:path";
 var EntryTypes = {
@@ -115660,7 +116805,7 @@ var ReaddirpStream = class extends Readable {
     const { root, type } = opts;
     this._fileFilter = normalizeFilter(opts.fileFilter);
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
-    const statMethod = opts.lstat ? lstat6 : stat11;
+    const statMethod = opts.lstat ? lstat6 : stat12;
     if (wantBigintFsStats) {
       this._stat = (path99) => statMethod(path99, { bigint: true });
     } else {
@@ -115815,7 +116960,7 @@ __name(readdirp, "readdirp");
 // node_modules/chokidar/esm/handler.js
 init_esbuild_shims();
 import { watchFile, unwatchFile, watch as fs_watch } from "fs";
-import { open as open6, stat as stat12, lstat as lstat7, realpath as fsrealpath } from "fs/promises";
+import { open as open6, stat as stat13, lstat as lstat7, realpath as fsrealpath } from "fs/promises";
 import * as sysPath from "path";
 import { type as osType } from "os";
 var STR_DATA = "data";
@@ -115842,7 +116987,7 @@ var EVENTS = {
 };
 var EV = EVENTS;
 var THROTTLE_MODE_WATCH = "watch";
-var statMethods = { lstat: lstat7, stat: stat12 };
+var statMethods = { lstat: lstat7, stat: stat13 };
 var KEY_LISTENERS = "listeners";
 var KEY_ERR = "errHandlers";
 var KEY_RAW = "rawEmitters";
@@ -116332,7 +117477,7 @@ var NodeFsHandler = class {
         return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
-          const newStats2 = await stat12(file);
+          const newStats2 = await stat13(file);
           if (this.fsw.closed)
             return;
           const at2 = newStats2.atimeMs;
@@ -117045,7 +118190,7 @@ var FSWatcher = class extends EventEmitter5 {
       const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path99) : path99;
       let stats2;
       try {
-        stats2 = await stat13(fullPath);
+        stats2 = await stat14(fullPath);
       } catch (err) {
       }
       if (!stats2 || this.closed)
@@ -117173,8 +118318,8 @@ var FSWatcher = class extends EventEmitter5 {
     }
     return this._userIgnored(path99, stats);
   }
-  _isntIgnored(path99, stat19) {
-    return !this._isIgnored(path99, stat19);
+  _isntIgnored(path99, stat20) {
+    return !this._isIgnored(path99, stat20);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
@@ -118345,12 +119490,12 @@ __name(isWithin, "isWithin");
 async function readBoundedTaskFile(filePath) {
   const handle = await fs66.open(filePath, "r");
   try {
-    const stat19 = await handle.stat();
-    if (!stat19.isFile()) {
+    const stat20 = await handle.stat();
+    if (!stat20.isFile()) {
       return null;
     }
     const cap = LOOP_TASK_FILE_MAX_BYTES + 1;
-    const allocSize = Math.min(cap, stat19.size + 1);
+    const allocSize = Math.min(cap, stat20.size + 1);
     const buffer = Buffer.alloc(allocSize);
     let total = 0;
     while (total < allocSize) {
@@ -123613,6 +124758,7 @@ ${_TeamManager.escapeEnvelopeTags(m2.text)}
       // fileDiff}`), which doesn't match what permission policies
       // expect to see (e.g. `{file_path, content}`).
       toolInput: event.args ?? {},
+      confirmationDetails: event.confirmationDetails,
       respond: event.respond,
       timestamp: Date.now()
     };
@@ -123814,9 +124960,12 @@ var MAX_DESCRIPTION_LENGTH2 = 40;
 var MAX_RECENT_ACTIVITIES = 10;
 var DEFAULT_MAX_CONCURRENT_BACKGROUND_AGENTS = 10;
 var BACKGROUND_AGENT_CONCURRENCY_ENV = "QWEN_CODE_MAX_BACKGROUND_AGENTS";
-function normalizeBackgroundApprovalOutcome(outcome) {
+function normalizeBackgroundApprovalOutcome(outcome, confirmationDetails) {
   if (outcome === "proceed_always" /* ProceedAlways */ || outcome === "proceed_always_project" /* ProceedAlwaysProject */ || outcome === "proceed_always_user" /* ProceedAlwaysUser */ || outcome === "proceed_always_server" /* ProceedAlwaysServer */ || outcome === "proceed_always_tool" /* ProceedAlwaysTool */) {
-    return "proceed_once" /* ProceedOnce */;
+    if (confirmationDetails.type === "plan" && outcome === "proceed_always" /* ProceedAlways */) {
+      return outcome;
+    }
+    return "cancel" /* Cancel */;
   }
   return outcome;
 }
@@ -124228,9 +125377,13 @@ var BackgroundTaskRegistry = class {
     );
     this.emitApprovalChange(entry);
     try {
+      const normalizedOutcome = normalizeBackgroundApprovalOutcome(
+        outcome,
+        approval.confirmationDetails
+      );
       await approval.respond(
-        normalizeBackgroundApprovalOutcome(outcome),
-        payload
+        normalizedOutcome,
+        normalizedOutcome === outcome ? payload : void 0
       );
     } catch (error) {
       debugLogger99.error(
@@ -124928,11 +126081,11 @@ function reconstructHistory(records, leafUuid) {
   return uuids.map((uuid) => firstByUuid.get(uuid)).filter((record2) => !!record2);
 }
 __name(reconstructHistory, "reconstructHistory");
-function extractText2(parts) {
+function extractText3(parts) {
   if (!parts?.length) return "";
   return parts.map((part) => "text" in part && part.text ? part.text : "").join("\n").trim();
 }
-__name(extractText2, "extractText");
+__name(extractText3, "extractText");
 function coalesceAdjacentUserHistory(messages) {
   const result = [];
   for (const message of messages) {
@@ -124960,7 +126113,7 @@ function recoverTranscript(records) {
   const launchPromptRecord = filtered.find(
     (record2) => record2.type === "system" && record2.subtype === "agent_launch_prompt" && record2.systemPayload
   );
-  const initialPrompt = filtered.find((record2) => record2.type === "user") ? extractText2(
+  const initialPrompt = filtered.find((record2) => record2.type === "user") ? extractText3(
     filtered.find((record2) => record2.type === "user")?.message?.parts
   ) : void 0;
   const stableForBranch = [...filtered];
@@ -126272,7 +127425,7 @@ async function evaluateToolCall(toolName, args, overlayFs, approvalMode) {
   }
   if (toolName === ToolNames.SHELL) {
     const command = typeof args["command"] === "string" ? args["command"] : "";
-    if (command && await isShellCommandReadOnlyAST(command)) {
+    if (command && await classifyShellCommandSafety(command) === "read-only") {
       return { action: "allow" };
     }
     return {
@@ -127148,12 +128301,12 @@ function resolveGitDir2(crawlDirectory) {
   while (current) {
     const gitPath = path77.join(current, ".git");
     try {
-      const stat19 = fs71.statSync(gitPath);
-      if (stat19.isDirectory()) {
+      const stat20 = fs71.statSync(gitPath);
+      if (stat20.isDirectory()) {
         pathCacheSet(resolveGitDirCache, cacheKey, gitPath);
         return gitPath;
       }
-      if (stat19.isFile()) {
+      if (stat20.isFile()) {
         const contents = fs71.readFileSync(gitPath, "utf8").trim();
         const match2 = contents.match(/^gitdir:\s*(.+)$/i);
         if (!match2) {
@@ -127748,13 +128901,13 @@ async function crawlWithGitLsFiles(stateKey, crawlDirectory, cwd, options2, work
     if (deletedSet.has(normalizedFile)) {
       return true;
     }
-    let stat19;
+    let stat20;
     try {
-      stat19 = fs71.lstatSync(path77.join(gitRoot, ...normalizedFile.split("/")));
+      stat20 = fs71.lstatSync(path77.join(gitRoot, ...normalizedFile.split("/")));
     } catch {
       return true;
     }
-    if (stat19.isDirectory()) {
+    if (stat20.isDirectory()) {
       return true;
     }
     if (relativeToGitRoot && relativeToGitRoot !== "." && normalizedFile === relativeToGitRoot) {
@@ -133084,8 +134237,8 @@ function getWelcomeBackStatePath() {
   return path86.join(process.cwd(), ".qwen", WELCOME_BACK_STATE_FILENAME);
 }
 __name(getWelcomeBackStatePath, "getWelcomeBackStatePath");
-function buildSummaryFingerprint(stat19) {
-  return `${stat19.mtimeMs}:${stat19.size}`;
+function buildSummaryFingerprint(stat20) {
+  return `${stat20.mtimeMs}:${stat20.size}`;
 }
 __name(buildSummaryFingerprint, "buildSummaryFingerprint");
 async function getWelcomeBackState() {
@@ -138161,7 +139314,8 @@ __name(dedupeRequestsByCallId, "dedupeRequestsByCallId");
 var GATE_HEADROOM = 3e3;
 var GATE_EXEMPT_TOOLS = /* @__PURE__ */ new Set([
   ToolNames.READ_FILE,
-  ToolNames.READ_MCP_RESOURCE
+  ToolNames.READ_MCP_RESOURCE,
+  ToolNames.ENTER_PLAN_MODE
 ]);
 function extractTextFromPartListUnion(c3) {
   if (typeof c3 === "string") return c3;
@@ -139212,7 +140366,7 @@ var CoreToolScheduler = class {
     if (!unknownToolName.startsWith("mcp__")) {
       return null;
     }
-    const prefixOf = /* @__PURE__ */ __name((server) => `mcp__${server}__`.replace(/[^a-zA-Z0-9_.-]/g, "_"), "prefixOf");
+    const prefixOf = /* @__PURE__ */ __name((server) => sanitizeToolNameForProvider(`mcp__${server}__`), "prefixOf");
     const byPrefixLengthDesc = /* @__PURE__ */ __name((a, b3) => prefixOf(b3).length - prefixOf(a).length, "byPrefixLengthDesc");
     const candidates = Array.from(
       /* @__PURE__ */ new Set([
@@ -139347,6 +140501,9 @@ var CoreToolScheduler = class {
       const requestsToProcess = dedupeRequestsByCallId(
         Array.isArray(request) ? request : [request]
       );
+      const planModeEntryBoundaryIndex = findPlanModeEntryBatchBoundaryIndex(
+        requestsToProcess.map((item) => canonicalToolName2(item.name))
+      );
       if (this.validationRetryCounts.size > 0) {
         const currentToolNames = new Set(requestsToProcess.map((r2) => r2.name));
         for (const key of [...this.validationRetryCounts.keys()]) {
@@ -139358,7 +140515,20 @@ var CoreToolScheduler = class {
         }
       }
       const newToolCalls = [];
-      for (const reqInfo of requestsToProcess) {
+      for (const [requestIndex, reqInfo] of requestsToProcess.entries()) {
+        if (planModeEntryBoundaryIndex !== void 0 && requestIndex !== planModeEntryBoundaryIndex) {
+          newToolCalls.push({
+            status: "error",
+            request: reqInfo,
+            response: createErrorResponse(
+              reqInfo,
+              new Error(PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE),
+              "execution_denied" /* EXECUTION_DENIED */
+            ),
+            durationMs: 0
+          });
+          continue;
+        }
         const canonicalName = canonicalToolName2(reqInfo.name);
         const pm = this.config.getPermissionManager?.();
         if (pm && !await pm.isToolEnabled(canonicalName)) {
@@ -139511,7 +140681,7 @@ var CoreToolScheduler = class {
             this.finalizeToolSpan(reqInfo.callId);
             continue;
           }
-          const toolParams = invocation.params;
+          let toolParams = invocation.params;
           const flowResult = await evaluatePermissionFlow(
             this.config,
             invocation,
@@ -139528,6 +140698,7 @@ var CoreToolScheduler = class {
           } = flowResult;
           const approvalMode = this.config.getApprovalMode();
           const isPlanMode = approvalMode === "plan" /* PLAN */;
+          const isPlanShellCall = isPlanMode && (canonicalName === ToolNames.SHELL || canonicalName === ToolNames.MONITOR);
           const isExitPlanModeTool = canonicalName === ToolNames.EXIT_PLAN_MODE;
           const isEnterPlanModeTool = canonicalName === ToolNames.ENTER_PLAN_MODE;
           const forceAutoReviewForAllow = approvalMode === "auto" /* AUTO */ && (shouldForceAutoModeReviewForAllow(pmCtx, this.config.getCwd()) || shouldClassifyAllShellForAutoMode(canonicalName, this.config));
@@ -139572,19 +140743,6 @@ var CoreToolScheduler = class {
             this.finalizeToolSpan(reqInfo.callId);
             continue;
           }
-          if (finalPermission === "allow" && !forceAutoReviewForAllow) {
-            if (approvalMode === "auto" /* AUTO */) {
-              this.config.setAutoModeDenialState(
-                recordAllow(this.config.getAutoModeDenialState())
-              );
-            }
-            this.setToolCallOutcome(
-              reqInfo.callId,
-              "proceed_always" /* ProceedAlways */
-            );
-            this.setStatusInternal(reqInfo.callId, "scheduled");
-            continue;
-          }
           if (finalPermission === "deny") {
             this.setStatusInternal(
               reqInfo.callId,
@@ -139603,6 +140761,72 @@ var CoreToolScheduler = class {
             this.finalizeToolSpan(reqInfo.callId);
             continue;
           }
+          let planShellAmbientWorkingDirectory;
+          if (isPlanShellCall) {
+            const directory = toolParams["directory"];
+            planShellAmbientWorkingDirectory = typeof directory === "string" && directory.length > 0 ? void 0 : this.config.getTargetDir();
+            invocation.params = {
+              ...structuredClone(invocation.params),
+              directory: typeof directory === "string" && directory.length > 0 ? directory : planShellAmbientWorkingDirectory
+            };
+            toolParams = invocation.params;
+          }
+          const planShellDecision = isPlanShellCall ? await evaluatePlanModeShellPolicy({
+            config: this.config,
+            toolName: canonicalName,
+            requestArgs: reqInfo.args,
+            invocationParams: toolParams,
+            permissionContext: pmCtx,
+            ambientWorkingDirectory: planShellAmbientWorkingDirectory,
+            signal
+          }) : { classification: "not-applicable" };
+          const rejectPlanShell = /* @__PURE__ */ __name((message) => {
+            this.setStatusInternal(reqInfo.callId, "error", {
+              ...createErrorResponse(
+                reqInfo,
+                new Error(message),
+                "execution_denied" /* EXECUTION_DENIED */
+              ),
+              resultDisplay: message
+            });
+            setToolSpanFailure(
+              toolSpan,
+              TOOL_FAILURE_KIND_PLAN_MODE_BLOCKED,
+              TOOL_SPAN_STATUS_PLAN_MODE_BLOCKED
+            );
+            this.finalizeToolSpan(reqInfo.callId);
+          }, "rejectPlanShell");
+          if (planShellDecision.classification !== "not-applicable") {
+            const initialPlanShellError = await validatePlanModeShellContext({
+              config: this.config,
+              decision: planShellDecision,
+              requestArgs: reqInfo.args,
+              invocationParams: invocation.params,
+              signal
+            });
+            if (initialPlanShellError) {
+              rejectPlanShell(initialPlanShellError);
+              continue;
+            }
+          }
+          if (planShellDecision.classification === "write") {
+            rejectPlanShell(planShellDecision.writeBlockMessage);
+            continue;
+          }
+          const planShellRequiresConfirmation = planShellDecision.classification === "unknown";
+          if (finalPermission === "allow" && !forceAutoReviewForAllow && !planShellRequiresConfirmation) {
+            if (approvalMode === "auto" /* AUTO */) {
+              this.config.setAutoModeDenialState(
+                recordAllow(this.config.getAutoModeDenialState())
+              );
+            }
+            this.setToolCallOutcome(
+              reqInfo.callId,
+              "proceed_always" /* ProceedAlways */
+            );
+            this.setStatusInternal(reqInfo.callId, "scheduled");
+            continue;
+          }
           if (!requiresUserInteraction && shouldRunAutoModeForCall(approvalMode, canonicalName)) {
             const denialState = this.config.getAutoModeDenialState();
             const fallback = shouldFallback(denialState);
@@ -139676,7 +140900,7 @@ var CoreToolScheduler = class {
           const isAskUserQuestionTool = canonicalName === ToolNames.ASK_USER_QUESTION;
           let confirmationDetails;
           if (!needsConfirmation(
-            confirmationPermission,
+            planShellRequiresConfirmation ? "ask" : confirmationPermission,
             approvalMode,
             canonicalName,
             requiresUserInteraction
@@ -139688,8 +140912,33 @@ var CoreToolScheduler = class {
             this.setStatusInternal(reqInfo.callId, "scheduled");
           } else {
             confirmationDetails = await invocation.getConfirmationDetails(signal);
+            if (planShellDecision.classification !== "not-applicable") {
+              const preDisplayPlanShellError = await validatePlanModeShellContext({
+                config: this.config,
+                decision: planShellDecision,
+                requestArgs: reqInfo.args,
+                invocationParams: invocation.params,
+                signal
+              });
+              if (preDisplayPlanShellError) {
+                rejectPlanShell(preDisplayPlanShellError);
+                continue;
+              }
+            }
+            try {
+              confirmationDetails = decoratePlanModeShellConfirmation(
+                planShellDecision,
+                confirmationDetails
+              );
+            } catch {
+              if (planShellDecision.classification === "unknown") {
+                rejectPlanShell(planShellDecision.noApprovalMessage);
+                continue;
+              }
+              throw new Error("Unable to prepare shell confirmation.");
+            }
             injectPermissionRulesIfMissing(confirmationDetails, pmCtx);
-            if (isPlanModeBlocked(
+            if (planShellDecision.classification === "not-applicable" && isPlanModeBlocked(
               isPlanMode,
               isExitPlanModeTool,
               isAskUserQuestionTool,
@@ -139726,7 +140975,11 @@ var CoreToolScheduler = class {
             }
             const isNonInteractiveDeny = !this.config.isInteractive() && !this.config.getExperimentalZedIntegration() && this.config.getInputFormat() !== "stream-json" /* STREAM_JSON */;
             if (isNonInteractiveDeny) {
-              const errorMessage = `Qwen Code requires permission to use "${reqInfo.name}", but that permission was declined (non-interactive mode cannot prompt for confirmation).`;
+              const errorMessage = planShellDecision.classification === "unknown" ? planShellDecision.noApprovalMessage : `Qwen Code requires permission to use "${reqInfo.name}", but that permission was declined (non-interactive mode cannot prompt for confirmation).`;
+              if (planShellDecision.classification === "unknown") {
+                rejectPlanShell(errorMessage);
+                continue;
+              }
               this.setStatusInternal(
                 reqInfo.callId,
                 "error",
@@ -139752,10 +141005,44 @@ var CoreToolScheduler = class {
                 messageBus,
                 canonicalName,
                 reqInfo.args || {},
-                permissionMode
+                permissionMode,
+                void 0,
+                signal
               );
               if (hookResult.hasDecision && (!hookResult.shouldAllow || !requiresUserInteraction)) {
                 if (hookResult.shouldAllow) {
+                  if (planShellDecision.classification !== "not-applicable") {
+                    const approval = await validatePlanModeShellApproval({
+                      config: this.config,
+                      decision: planShellDecision,
+                      requestArgs: reqInfo.args,
+                      invocationParams: invocation.params,
+                      signal,
+                      outcome: "proceed_once" /* ProceedOnce */,
+                      payload: hookResult.updatedInput ? { updatedInput: hookResult.updatedInput } : void 0
+                    });
+                    if (approval.outcome === "cancel" /* Cancel */) {
+                      await confirmationDetails.onConfirm(
+                        approval.outcome,
+                        approval.payload
+                      );
+                      rejectPlanShell(
+                        approval.payload?.cancelMessage ?? planShellDecision.noApprovalMessage
+                      );
+                      continue;
+                    }
+                    await confirmationDetails.onConfirm(
+                      approval.outcome,
+                      approval.payload
+                    );
+                    this.recordAutoModeFallbackResolution(
+                      reqInfo.callId,
+                      approval.outcome
+                    );
+                    this.setToolCallOutcome(reqInfo.callId, approval.outcome);
+                    this.setStatusInternal(reqInfo.callId, "scheduled");
+                    continue;
+                  }
                   if (hookResult.updatedInput && typeof reqInfo.args === "object") {
                     this.setArgsInternal(
                       reqInfo.callId,
@@ -139810,7 +141097,11 @@ var CoreToolScheduler = class {
               }
             }
             if (this.config.getShouldAvoidPermissionPrompts?.()) {
-              const errorMessage = `Tool "${reqInfo.name}" requires permission, but background agents cannot prompt for confirmation. The tool call was denied.`;
+              const errorMessage = planShellDecision.classification === "unknown" ? planShellDecision.noApprovalMessage : `Tool "${reqInfo.name}" requires permission, but background agents cannot prompt for confirmation. The tool call was denied.`;
+              if (planShellDecision.classification === "unknown") {
+                rejectPlanShell(errorMessage);
+                continue;
+              }
               this.setStatusInternal(
                 reqInfo.callId,
                 "error",
@@ -139838,25 +141129,68 @@ var CoreToolScheduler = class {
               this.finalizeToolSpan(reqInfo.callId);
               continue;
             }
-            this.openIdeDiffIfEnabled(
-              confirmationDetails,
-              reqInfo.callId,
-              signal
-            );
+            if (planShellDecision.classification !== "not-applicable") {
+              const finalPreDisplayPlanShellError = await validatePlanModeShellContext({
+                config: this.config,
+                decision: planShellDecision,
+                requestArgs: reqInfo.args,
+                invocationParams: invocation.params,
+                signal
+              });
+              if (finalPreDisplayPlanShellError) {
+                rejectPlanShell(finalPreDisplayPlanShellError);
+                continue;
+              }
+            }
+            if (confirmationDetails.type !== "edit" || !confirmationDetails.skipIdeDiff) {
+              this.openIdeDiffIfEnabled(
+                confirmationDetails,
+                reqInfo.callId,
+                signal
+              );
+            }
             const originalOnConfirm = confirmationDetails.onConfirm;
+            let planShellResponseClaimed = false;
             const wrappedConfirmationDetails = {
               ...confirmationDetails,
               // When PM has an explicit 'ask' rule, 'always allow' would be
               // ineffective because ask takes priority over allow.
               // Hide the option so users aren't misled.
               ...pmForcedAsk || requiresUserInteraction ? { hideAlwaysAllow: true } : {},
-              onConfirm: /* @__PURE__ */ __name((outcome, payload) => this.handleConfirmationResponse(
-                reqInfo.callId,
-                originalOnConfirm,
-                outcome,
-                signal,
-                payload
-              ), "onConfirm")
+              onConfirm: /* @__PURE__ */ __name(async (outcome, payload) => {
+                if (planShellDecision.classification !== "not-applicable") {
+                  if (planShellResponseClaimed) return;
+                  planShellResponseClaimed = true;
+                  const currentCall = this.toolCalls.find(
+                    (call) => call.request.callId === reqInfo.callId && call.status === "awaiting_approval"
+                  );
+                  if (!currentCall) return;
+                  const approval = await validatePlanModeShellApproval({
+                    config: this.config,
+                    decision: planShellDecision,
+                    requestArgs: currentCall.request.args,
+                    invocationParams: currentCall.invocation.params,
+                    signal,
+                    outcome,
+                    payload
+                  });
+                  await this.handleConfirmationResponse(
+                    reqInfo.callId,
+                    originalOnConfirm,
+                    approval.outcome,
+                    signal,
+                    approval.payload
+                  );
+                  return;
+                }
+                await this.handleConfirmationResponse(
+                  reqInfo.callId,
+                  originalOnConfirm,
+                  outcome,
+                  signal,
+                  payload
+                );
+              }, "onConfirm")
             };
             this.setStatusInternal(
               reqInfo.callId,
@@ -141151,7 +142485,7 @@ ${failureHookResult.additionalContext}`;
     }
   }
   async maybePersistLargeToolResult(callId, toolName, content) {
-    if (GATE_EXEMPT_TOOLS.has(toolName)) return content;
+    if (GATE_EXEMPT_TOOLS.has(canonicalToolName2(toolName))) return content;
     const text = extractTextFromPartListUnion(content);
     if (!text || isAlreadyTruncated(text)) return content;
     const gateThreshold = this.config.getTruncateToolOutputThreshold() + GATE_HEADROOM;
@@ -141238,6 +142572,9 @@ ${failureHookResult.additionalContext}`;
    * media-bearing, non-text, or already-persisted results.
    */
   async offloadCallOutput(call) {
+    if (canonicalToolName2(call.request.name) === ToolNames.ENTER_PLAN_MODE) {
+      return null;
+    }
     const parts = call.response.responseParts;
     if (parts.length !== 1) return null;
     const fr2 = parts[0]?.functionResponse;
@@ -141297,7 +142634,7 @@ ${failureHookResult.additionalContext}`;
   }
   async autoApproveCompatiblePendingTools(signal, triggeringCallId) {
     const pendingTools = this.toolCalls.filter(
-      (call) => call.status === "awaiting_approval" && call.request.callId !== triggeringCallId && // A tool bounced by a PreToolUse 'ask' must NOT be auto-approved as a
+      (call) => call.status === "awaiting_approval" && call.request.callId !== triggeringCallId && (!("hideAlwaysAllow" in call.confirmationDetails) || call.confirmationDetails.hideAlwaysAllow !== true) && // A tool bounced by a PreToolUse 'ask' must NOT be auto-approved as a
       // side effect of approving a sibling: the hook explicitly requested
       // confirmation, and re-execution skips the hook — auto-approving here
       // would silently defeat the hook's gate. It requires its own explicit
@@ -149580,7 +150917,7 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
             if (isTopLevelInteraction) endInteractionSpan("cancelled");
             return turn;
           }
-          const continueReason = stopOutput.getEffectiveReason();
+          const continueReason = getStopHookContinuationReason(stopOutput);
           const currentIterationCount = (options2?.stopHookState?.iterationCount ?? 0) + 1;
           const currentReasons = [
             ...options2?.stopHookState?.reasons ?? [],
@@ -149630,9 +150967,30 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
           const activeGoal = getActiveGoal(this.config.getSessionId());
           const hookTurnBudget = activeGoal ? boundedTurns : boundedTurns - 1;
           const pendingSteer = await takeSteerInput(hookTurnBudget);
-          const continueRequest = [{ text: continueReason }];
+          const activeGoalAfterSteer = getActiveGoal(
+            this.config.getSessionId()
+          );
+          const activeGoalChanged = activeGoal !== void 0 && activeGoalAfterSteer?.hookId !== activeGoal.hookId;
+          const goalContinuationChanged = activeGoalChanged && stopOutput.hookSpecificOutput?.[GOAL_HOOK_ID_OUTPUT_KEY] === activeGoal.hookId;
+          if (activeGoalChanged) {
+            const activeGoalEvent3 = maybeEmitActiveGoalChange(activeGoalAfterSteer);
+            if (activeGoalEvent3) {
+              yield activeGoalEvent3;
+            }
+          }
+          const discardGoalContinuation = goalContinuationChanged && response.hasNonGoalBlockingStopHook === false;
+          const continuationReasonAfterSteer = discardGoalContinuation ? void 0 : goalContinuationChanged && response.hasNonGoalBlockingStopHook === true ? response.nonGoalBlockingStopReason || "No reason provided" : continueReason;
+          if (!continuationReasonAfterSteer && !pendingSteer) {
+            if (isTopLevelInteraction) endInteractionSpan("ok");
+            normalCompletion = true;
+            return turn;
+          }
+          const continueRequest = continuationReasonAfterSteer ? [{ text: continuationReasonAfterSteer }] : [];
           if (pendingSteer) {
-            continueRequest.push({ text: "\n\n" }, ...pendingSteer.parts);
+            if (continueRequest.length > 0) {
+              continueRequest.push({ text: "\n\n" });
+            }
+            continueRequest.push(...pendingSteer.parts);
           }
           const pushCountBefore = currentPushCount();
           let hookTurn;
@@ -149645,9 +151003,12 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
                 type: "hook" /* Hook */,
                 modelOverride: options2?.modelOverride,
                 getSteerInput: options2?.getSteerInput,
-                stopHookState: {
+                stopHookState: discardGoalContinuation ? void 0 : {
                   iterationCount: currentIterationCount,
-                  reasons: currentReasons
+                  reasons: continuationReasonAfterSteer && continuationReasonAfterSteer !== continueReason ? [
+                    ...currentReasons.slice(0, -1),
+                    continuationReasonAfterSteer
+                  ] : currentReasons
                 }
               },
               hookTurnBudget
@@ -152051,6 +153412,8 @@ var Config = class {
             }
             let result;
             let stopHookCount;
+            let hasNonGoalBlockingStopHook;
+            let nonGoalBlockingStopReason;
             const input = request.input || {};
             const signal = request.signal;
             switch (request.eventName) {
@@ -152081,6 +153444,18 @@ var Config = class {
                 );
                 result = stopResult.finalOutput ? createHookOutput("Stop", stopResult.finalOutput) : void 0;
                 stopHookCount = stopResult.allOutputs.length;
+                const goalHookId = stopResult.finalOutput?.hookSpecificOutput?.[GOAL_HOOK_ID_OUTPUT_KEY];
+                if (typeof goalHookId === "string") {
+                  const nonGoalBlockingOutputs = stopResult.allOutputs.filter(
+                    (output) => output.hookSpecificOutput?.[GOAL_HOOK_ID_OUTPUT_KEY] !== goalHookId && (output.decision === "block" || output.decision === "deny" || output.continue === false)
+                  );
+                  hasNonGoalBlockingStopHook = nonGoalBlockingOutputs.length > 0;
+                  if (hasNonGoalBlockingStopHook) {
+                    nonGoalBlockingStopReason = nonGoalBlockingOutputs.map(
+                      (output) => output.stopReason || output.reason || "No reason provided"
+                    ).join("\n");
+                  }
+                }
                 break;
               }
               case "MessageDisplay": {
@@ -152195,7 +153570,9 @@ var Config = class {
               success: true,
               output: result,
               // Include stop hook count for Stop events
-              stopHookCount
+              stopHookCount,
+              hasNonGoalBlockingStopHook,
+              nonGoalBlockingStopReason
             });
           } catch (error) {
             this.debugLogger.warn(`Hook execution failed: ${error}`);
@@ -155211,25 +156588,25 @@ var Config = class {
       if (options2?.forSubAgent) return;
       const schema = this.jsonSchema;
       await registerLazy(ToolNames.STRUCTURED_OUTPUT, async () => {
-        const { SyntheticOutputTool } = await import("./syntheticOutput-ULOVVLY4.js");
+        const { SyntheticOutputTool } = await import("./syntheticOutput-FG5PQKIR.js");
         return new SyntheticOutputTool(schema);
       });
     }, "registerStructuredOutputIfRequested");
     if (this.getBareMode()) {
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-VSKOE22I.js");
+        const { ReadFileTool } = await import("./read-file-LCQ2KNNP.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-GORZTX2U.js");
+        const { EditTool } = await import("./edit-BTPQWGAA.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-        const { NotebookEditTool } = await import("./notebook-edit-IBEOVZ6A.js");
+        const { NotebookEditTool } = await import("./notebook-edit-GFOYAQAZ.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-2NGEMAVM.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-EON6WVVH.js");
         return new ShellTool2(this);
       });
       await registerStructuredOutputIfRequested();
@@ -155239,35 +156616,35 @@ var Config = class {
       return registry;
     }
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-5IE2VO7X.js");
+      const { ToolSearchTool } = await import("./tool-search-Q27QHQU3.js");
       return new ToolSearchTool(this);
     });
     await registerLazy(ToolNames.READ_MCP_RESOURCE, async () => {
-      const { ReadMcpResourceTool } = await import("./read-mcp-resource-C6NT52T6.js");
+      const { ReadMcpResourceTool } = await import("./read-mcp-resource-AKCL7I43.js");
       return new ReadMcpResourceTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-CKSI7BTR.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-KTOOFWMV.js");
       return new AgentTool2(this);
     });
     await registerLazy(ToolNames.TASK_STOP, async () => {
-      const { TaskStopTool } = await import("./task-stop-CPEQWOT6.js");
+      const { TaskStopTool } = await import("./task-stop-GWC6UWAL.js");
       return new TaskStopTool(this);
     });
     await registerLazy(ToolNames.SEND_MESSAGE, async () => {
-      const { SendMessageTool } = await import("./send-message-5GZ4FX2V.js");
+      const { SendMessageTool } = await import("./send-message-3RHE7HSM.js");
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-3U2T6H3E.js");
+      const { SkillTool } = await import("./skill-FKSYXJ5U.js");
       return new SkillTool(this);
     });
     await registerLazy(ToolNames.LS, async () => {
-      const { LSTool } = await import("./ls-APTSOOS5.js");
+      const { LSTool } = await import("./ls-FHBY3Y7I.js");
       return new LSTool(this);
     });
     await registerLazy(ToolNames.READ_FILE, async () => {
-      const { ReadFileTool } = await import("./read-file-VSKOE22I.js");
+      const { ReadFileTool } = await import("./read-file-LCQ2KNNP.js");
       return new ReadFileTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -155282,7 +156659,7 @@ var Config = class {
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-5V5FLW2A.js");
+          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-Y2XW4EFC.js");
           return new RipGrepTool2(this);
         });
       } else {
@@ -155295,7 +156672,7 @@ var Config = class {
           )
         );
         await registerLazy(ToolNames.GREP, async () => {
-          const { GrepTool } = await import("./grep-HZLSTX7D.js");
+          const { GrepTool } = await import("./grep-U67FKUJT.js");
           return new GrepTool(this);
         });
       }
@@ -155303,139 +156680,139 @@ var Config = class {
       recordStartupEvent("config_initialize_ripgrep_probe_start");
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       await registerLazy(ToolNames.GREP, async () => {
-        const { GrepTool } = await import("./grep-HZLSTX7D.js");
+        const { GrepTool } = await import("./grep-U67FKUJT.js");
         return new GrepTool(this);
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-GOAPGD6G.js");
+      const { GlobTool } = await import("./glob-5YABOPJB.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-GORZTX2U.js");
+      const { EditTool } = await import("./edit-BTPQWGAA.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-      const { NotebookEditTool } = await import("./notebook-edit-IBEOVZ6A.js");
+      const { NotebookEditTool } = await import("./notebook-edit-GFOYAQAZ.js");
       return new NotebookEditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool } = await import("./write-file-DR3HN7IH.js");
+      const { WriteFileTool } = await import("./write-file-EAT3CHUK.js");
       return new WriteFileTool(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-2NGEMAVM.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-EON6WVVH.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.TODO_WRITE, async () => {
-      const { TodoWriteTool } = await import("./todoWrite-JHHIDOIV.js");
+      const { TodoWriteTool } = await import("./todoWrite-ERCAMLFS.js");
       return new TodoWriteTool(this);
     });
     await registerLazy(ToolNames.ASK_USER_QUESTION, async () => {
-      const { AskUserQuestionTool } = await import("./askUserQuestion-CEPBT47X.js");
+      const { AskUserQuestionTool } = await import("./askUserQuestion-6DZC4UV5.js");
       return new AskUserQuestionTool(this);
     });
     if (!this.sdkMode) {
       await registerLazy(ToolNames.EXIT_PLAN_MODE, async () => {
-        const { ExitPlanModeTool } = await import("./exitPlanMode-U5Z6XBLO.js");
+        const { ExitPlanModeTool } = await import("./exitPlanMode-NZWRVIIY.js");
         return new ExitPlanModeTool(this);
       });
       await registerLazy(ToolNames.ENTER_PLAN_MODE, async () => {
-        const { EnterPlanModeTool } = await import("./enterPlanMode-LIIPP37T.js");
+        const { EnterPlanModeTool } = await import("./enterPlanMode-TN2JV5MY.js");
         return new EnterPlanModeTool(this);
       });
     }
     await registerLazy(ToolNames.ENTER_WORKTREE, async () => {
-      const { EnterWorktreeTool } = await import("./enter-worktree-LJB2AW4L.js");
+      const { EnterWorktreeTool } = await import("./enter-worktree-N3SEYKOO.js");
       return new EnterWorktreeTool(this);
     });
     await registerLazy(ToolNames.EXIT_WORKTREE, async () => {
-      const { ExitWorktreeTool } = await import("./exit-worktree-IEP2WHOV.js");
+      const { ExitWorktreeTool } = await import("./exit-worktree-FI3SQY3U.js");
       return new ExitWorktreeTool(this);
     });
     await registerLazy(ToolNames.WEB_FETCH, async () => {
-      const { WebFetchTool } = await import("./web-fetch-ZDNE6FF2.js");
+      const { WebFetchTool } = await import("./web-fetch-L62NQVKN.js");
       return new WebFetchTool(this);
     });
     if (this.isArtifactEnabled()) {
       await registerLazy(ToolNames.ARTIFACT, async () => {
-        const { ArtifactTool } = await import("./artifact-tool-PHO5XEGZ.js");
+        const { ArtifactTool } = await import("./artifact-tool-WBCAMD3O.js");
         return new ArtifactTool(this);
       });
     }
     if (this.isRecordArtifactEnabled()) {
       await registerLazy(ToolNames.RECORD_ARTIFACT, async () => {
-        const { RecordArtifactTool } = await import("./record-artifact-ENCU7QCL.js");
+        const { RecordArtifactTool } = await import("./record-artifact-PEUB7727.js");
         return new RecordArtifactTool();
       });
     }
     if (this.isLspEnabled() && this.getLspClient()) {
       await registerLazy(ToolNames.LSP, async () => {
-        const { LspTool } = await import("./lsp-HPACPJAN.js");
+        const { LspTool } = await import("./lsp-B6VMEW6Y.js");
         return new LspTool(this);
       });
     }
     await registerStructuredOutputIfRequested();
     if (this.isCronEnabled()) {
       await registerLazy(ToolNames.CRON_CREATE, async () => {
-        const { CronCreateTool } = await import("./cron-create-X462ERYA.js");
+        const { CronCreateTool } = await import("./cron-create-JWFHBDRQ.js");
         return new CronCreateTool(this);
       });
       await registerLazy(ToolNames.CRON_LIST, async () => {
-        const { CronListTool } = await import("./cron-list-3MD6SVXI.js");
+        const { CronListTool } = await import("./cron-list-USMAIWPT.js");
         return new CronListTool(this);
       });
       await registerLazy(ToolNames.CRON_DELETE, async () => {
-        const { CronDeleteTool } = await import("./cron-delete-SL5UJUM3.js");
+        const { CronDeleteTool } = await import("./cron-delete-GDX4E26G.js");
         return new CronDeleteTool(this);
       });
       await registerLazy(ToolNames.LOOP_WAKEUP, async () => {
-        const { LoopWakeupTool } = await import("./loop-wakeup-6H7OENTB.js");
+        const { LoopWakeupTool } = await import("./loop-wakeup-5GLTUBHA.js");
         return new LoopWakeupTool(this);
       });
     }
     await registerLazy(ToolNames.CREATE_SUB_SESSION, async () => {
-      const { CreateSubSessionTool } = await import("./create-sub-session-DIJOV6HV.js");
+      const { CreateSubSessionTool } = await import("./create-sub-session-P26FE5GG.js");
       return new CreateSubSessionTool(this);
     });
     if (this.isAgentTeamEnabled()) {
       await registerLazy(ToolNames.TEAM_CREATE, async () => {
-        const { TeamCreateTool } = await import("./team-create-R6AXDYPG.js");
+        const { TeamCreateTool } = await import("./team-create-CYP3YKYT.js");
         return new TeamCreateTool(this);
       });
       await registerLazy(ToolNames.TEAM_DELETE, async () => {
-        const { TeamDeleteTool } = await import("./team-delete-JJV6IUOA.js");
+        const { TeamDeleteTool } = await import("./team-delete-KK37HTOG.js");
         return new TeamDeleteTool(this);
       });
       await registerLazy(ToolNames.TEAM_PLAN_APPROVAL, async () => {
-        const { TeamPlanApprovalTool } = await import("./team-plan-approval-O2ZPPT64.js");
+        const { TeamPlanApprovalTool } = await import("./team-plan-approval-5LXIFKNV.js");
         return new TeamPlanApprovalTool(this);
       });
       await registerLazy(ToolNames.TASK_CREATE, async () => {
-        const { TaskCreateTool } = await import("./task-create-DUE2PMNI.js");
+        const { TaskCreateTool } = await import("./task-create-HX32YXO7.js");
         return new TaskCreateTool(this);
       });
       await registerLazy(ToolNames.TASK_UPDATE, async () => {
-        const { TaskUpdateTool } = await import("./task-update-HY2LNFFB.js");
+        const { TaskUpdateTool } = await import("./task-update-NCTAB73Q.js");
         return new TaskUpdateTool(this);
       });
       await registerLazy(ToolNames.TASK_LIST, async () => {
-        const { TaskListTool } = await import("./task-list-WVPNX7BZ.js");
+        const { TaskListTool } = await import("./task-list-QWSY4ZIU.js");
         return new TaskListTool(this);
       });
     }
     if (this.isWorkflowsEnabled()) {
       await registerLazy(ToolNames.WORKFLOW, async () => {
-        const { WorkflowTool } = await import("./workflow-G7U6OQWS.js");
+        const { WorkflowTool } = await import("./workflow-6MHBBFQU.js");
         return new WorkflowTool(this);
       });
     }
     if (this.isComputerUseEnabled()) {
-      const { registerComputerUseTools } = await import("./computer-use-4PUGCUQK.js");
+      const { registerComputerUseTools } = await import("./computer-use-M6MGRJF2.js");
       await registerComputerUseTools(registerLazy, this);
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-LMYKCF6R.js");
+      const { MonitorTool } = await import("./monitor-Z7NZNNRC.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {
@@ -159075,6 +160452,7 @@ export {
   MAX_GOAL_ITERATIONS,
   GOAL_HOOK_TIMEOUT_SECONDS,
   GOAL_HOOK_TIMEOUT_MS,
+  getStopHookContinuationReason,
   abortGoalForStopHookCap,
   createGoalStopHookCallback,
   unregisterGoalHook,
@@ -159125,7 +160503,14 @@ export {
   TERMINAL_CSI_REGEX,
   TERMINAL_SHIFT_DCS_REGEX,
   stripTerminalControlSequences,
-  buildOrderedUuidChain,
+  TranscriptRecordPreparationError,
+  isTranscriptConversationRecord,
+  isTranscriptArtifactRecord,
+  validateTranscriptRecord,
+  selectTranscriptLeaf,
+  walkTranscriptUuidChain,
+  aggregateTranscriptRecordFragments,
+  prepareTranscriptRecords,
   MAX_FILES,
   MAX_DIFF_SIZE_BYTES,
   MAX_LINES_PER_FILE,
@@ -159142,6 +160527,10 @@ export {
   getGitWorkingTreeStatus,
   parseStatusBranchLine,
   parseStatusEntries,
+  MAX_LOG_LIMIT,
+  DEFAULT_LOG_LIMIT,
+  fetchGitLog,
+  fetchGitCommitDetail,
   MAX_SNAPSHOTS,
   FILE_HISTORY_DIR,
   serializeSnapshot,
@@ -159311,6 +160700,14 @@ export {
   getEffectivePermissionForConfirmation,
   isPlanModeBlocked,
   isAutoEditApproved,
+  isShellCommandReadOnlyAST,
+  extractCommandRules,
+  evaluatePlanModeShellPolicy,
+  validatePlanModeShellContext,
+  decoratePlanModeShellConfirmation,
+  validatePlanModeShellApproval,
+  PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE,
+  findPlanModeEntryBatchBoundaryIndex,
   MAX_TRANSCRIPT_MESSAGES,
   extractShellOperations,
   AUTO_MODE_DENIAL_LIMITS,
@@ -159374,8 +160771,6 @@ export {
   ShellExecutionService,
   StructuredToolError,
   checkPriorRead,
-  isShellCommandReadOnlyAST,
-  extractCommandRules,
   escape,
   globStream,
   glob,
@@ -159480,6 +160875,7 @@ export {
   MAX_RETAINED_TERMINAL_AGENTS,
   buildBackgroundEntryLabel,
   BackgroundTaskRegistry,
+  buildOrderedUuidChain,
   DEFAULT_BACKGROUND_AGENT_CONTINUATION_MESSAGE,
   BackgroundAgentResumeService,
   saveCacheSafeParams,
@@ -159775,6 +161171,7 @@ export {
   applyProviderInstallPlan,
   IMAGE_CAPABILITY,
   generateSessionRecap,
+  inspectConversationBranches,
   createToolUseSummaryMessage,
   TOOL_USE_SUMMARY_SYSTEM_PROMPT,
   generateToolUseSummary,
@@ -159805,6 +161202,7 @@ export {
   getChannelMemoryFilePath,
   getLegacyChannelMemoryFilePath,
   listChannelMemoryEntries,
+  getChannelMemoryRevision,
   addChannelMemoryEntries,
   updateChannelMemoryEntry,
   removeChannelMemoryEntries,
@@ -160110,16 +161508,16 @@ export {
  */
 /**
  * @license
- * Copyright 2026 Qwen Team
+ * Copyright 2026 Qwen
  * SPDX-License-Identifier: Apache-2.0
- *
- * Provider registry — imports all provider definitions and assembles the
- * lookup tables used by the UI and CLI commands.
  */
 /**
  * @license
- * Copyright 2026 Qwen
+ * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
+ *
+ * Provider registry — imports all provider definitions and assembles the
+ * lookup tables used by the UI and CLI commands.
  */
 /**
  * @license