@qwen-code/qwen-code 0.21.7 → 0.21.8

package/chunks/{chunk-Y7E5LNLO.js → chunk-GXSNGY5M.js}

@@ -40,7 +40,7 @@ import {
   CronScheduler,
   DEFAULT_RECURRING_MAX_AGE_DAYS,
   normalizeRecurringMaxAge
-} from "./chunk-CNIID3TV.js";
+} from "./chunk-2UUMVNYT.js";
 import {
   consumeUnread,
   forwardApproval,
@@ -71,13 +71,13 @@ import {
   RUNTIME_SNAPSHOT_PREFIX,
   buildModelIdContext,
   resolveModelId
-} from "./chunk-RMH5OWLD.js";
+} from "./chunk-VXZ5HAOV.js";
 import {
   ARTIFACT_TITLE_MAX_LENGTH,
   ARTIFACT_WORKSPACE_PATH_MAX_LENGTH,
   hasControlCharacter,
   hasUnsafeDisplayPayload
-} from "./chunk-Y4NGLFGJ.js";
+} from "./chunk-HUWENAHO.js";
 import {
   promptIdContext,
   todoWorkChainContext
@@ -131,25 +131,31 @@ import {
 import {
   normalizeImageGenerationBaseUrl,
   resolveNetworkTarget
-} from "./chunk-CJXIIILK.js";
+} from "./chunk-2FRY5CRX.js";
 import {
   GoalPersistenceUnavailableError,
   PAUSED_GOAL_SYSTEM_REMINDER,
+  aggregateTranscriptRecordFragments,
+  createGoalCheckpointVerifier,
   createGoalRuntime,
   goalRequiresExactPermit,
   goalTurnContext,
-  parseGoalStateRecordPayloadV2
-} from "./chunk-3K7FH2KQ.js";
+  isTranscriptArtifactRecord,
+  isTranscriptConversationRecord,
+  parseGoalStateRecordPayloadV2,
+  prepareTranscriptRecords,
+  projectUserTranscriptForDisplay,
+  selectTranscriptLeaf,
+  validateTranscriptRecord,
+  walkTranscriptUuidChain,
+  wrapUserPromptSubmitContext
+} from "./chunk-67N6HB5H.js";
 import {
   APPROVAL_MODES,
   SUBAGENT_PLAN_LIFECYCLE_TOOLS,
   buildSubagentPlanToolBlockedResult,
-  childLaunchDepth,
-  getCurrentAgentDepth,
-  getCurrentAgentId,
   getLeaderOnlyToolUnavailableMessage,
   getPlanRequiredTeammatePreApprovalMessage,
-  getRuntimeContentGenerator,
   getSubagentPlanToolUnavailableMessage,
   isLeaderOnlyToolUnavailableInSubagent,
   isPlanLifecycleToolUnavailableInSubagent,
@@ -157,18 +163,38 @@ import {
   isPlanRequiredTeammateContext,
   isPlanRequiredTeammatePreApprovalAllowedTool,
   isSubagentLikeExecutionContext,
+  shouldUsePlanOnlyReminderInSubagentContext
+} from "./chunk-WAUGQKUU.js";
+import {
+  DEFAULT_OTLP_ENDPOINT,
+  DEFAULT_TELEMETRY_TARGET,
+  addToolArgumentsAttributes,
+  addToolCallResultAttributes,
+  addUserPromptAttributes
+} from "./chunk-L4N6TIP7.js";
+import {
+  supportsOpenAIPrefixCaching
+} from "./chunk-SAH4BD2J.js";
+import {
+  childLaunchDepth,
+  getCurrentAgentDepth,
+  getCurrentAgentId,
+  getRuntimeContentGenerator,
   isTopLevelSession,
   runOutsideAgentContext,
   runWithAgentContext,
   runWithRuntimeContentGenerator,
-  shouldUsePlanOnlyReminderInSubagentContext,
   spawnBlockReason
-} from "./chunk-BVWVWGLE.js";
+} from "./chunk-CPG6P4GG.js";
 import {
   getTeammateContext,
   isTeammate,
   runWithTeammateIdentity
 } from "./chunk-S6LOFUVP.js";
+import {
+  InvalidStreamError,
+  getThoughtSummary
+} from "./chunk-2J3OJGTL.js";
 import {
   BUBBLE_APPROVAL_MODE,
   FORK_AGENT,
@@ -202,7 +228,7 @@ import {
   selectForkHistory,
   stripSystemReminderBlocks,
   validateForkToolList
-} from "./chunk-LZC3B5N2.js";
+} from "./chunk-IA7TGCN2.js";
 import {
   collectAvailableSkillEntries,
   renderAvailableSkillsBlock
@@ -221,38 +247,18 @@ import {
   isPathWithinRoot,
   require_ignore
 } from "./chunk-EQL65XGA.js";
-import {
-  DashScopeOpenAICompatibleProvider
-} from "./chunk-IIJEYBNH.js";
 import {
   openBrowserSecurely,
   shouldAttemptBrowserLaunch
 } from "./chunk-NAVJD2PQ.js";
 import {
-  classifyRetryError,
-  isFallbackEligible,
   isUnattendedMode,
   retryWithBackoff
-} from "./chunk-BGG4MBYD.js";
-import {
-  DEFAULT_OPENAI_BASE_URL
-} from "./chunk-AXMWHKXA.js";
-import {
-  combineAbortSignals,
-  createAbortController,
-  createChildAbortController
-} from "./chunk-DJ2GSRLV.js";
+} from "./chunk-4PYCZH2V.js";
 import {
-  DEFAULT_OTLP_ENDPOINT,
-  DEFAULT_TELEMETRY_TARGET,
-  addToolArgumentsAttributes,
-  addToolCallResultAttributes,
-  addUserPromptAttributes
-} from "./chunk-L4N6TIP7.js";
-import {
-  InvalidStreamError,
-  getThoughtSummary
-} from "./chunk-2J3OJGTL.js";
+  classifyRetryError,
+  isFallbackEligible
+} from "./chunk-SR7RZ4MS.js";
 import {
   QUOTA_EXHAUSTED_PREFIX,
   formatQuotaExhaustedMessage,
@@ -263,10 +269,18 @@ import {
   isRateLimitError,
   isStructuredError
 } from "./chunk-M6HMMKVG.js";
+import {
+  DEFAULT_OPENAI_BASE_URL
+} from "./chunk-AXMWHKXA.js";
 import {
   getToolCallPreparations,
   setToolCallPreparations
 } from "./chunk-GLCZKT5V.js";
+import {
+  combineAbortSignals,
+  createAbortController,
+  createChildAbortController
+} from "./chunk-DJ2GSRLV.js";
 import {
   ApiRetryEvent,
   ContentRetryEvent,
@@ -368,7 +382,6 @@ import {
   readTextRangeFromHandle,
   removeMCPServerStatus,
   removeMCPStatusChangeListener,
-  runSideQuery,
   runVisionBridge,
   runWithChatRecordingSuppressed,
   runWithInvocationContext,
@@ -382,7 +395,7 @@ import {
   updateMCPServerStatus,
   writeLine,
   writeLineSync
-} from "./chunk-2U3WZGZG.js";
+} from "./chunk-3PY4LPJF.js";
 import {
   defaultModalities
 } from "./chunk-WOJZWRAZ.js";
@@ -411,9 +424,12 @@ import {
   isTeamAutoMemPath,
   isUserAutoMemPath
 } from "./chunk-FVKHVJZQ.js";
+import {
+  runSideQuery
+} from "./chunk-COBO5EBO.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-NG2R4N5O.js";
+} from "./chunk-6ZRFAKXK.js";
 import {
   AgentStatistics,
   BaseDeclarativeTool,
@@ -425,19 +441,18 @@ import {
   ToolDisplayNamesMigration,
   ToolNames,
   ToolNamesMigration,
+  canonicalToolName,
   hasCycleInSchema,
   isShellProgressData,
   isTool,
   require_dist,
   require_fast_deep_equal,
   require_fast_uri
-} from "./chunk-IC4Z6LX6.js";
+} from "./chunk-PYQADEFD.js";
 import {
   AUTH_ENV_MAPPINGS,
   AuthType,
   DEFAULT_MODELS,
-  DEFAULT_QWEN_EMBEDDING_MODEL,
-  DEFAULT_QWEN_MODEL,
   MODEL_GENERATION_CONFIG_FIELDS,
   PROVIDER_SOURCED_FIELDS,
   QWEN_OAUTH_ALLOWED_MODELS,
@@ -445,7 +460,11 @@ import {
   createContentGenerator,
   resetPreloadedContentGenerator,
   resolveContentGeneratorConfigWithSources
-} from "./chunk-6EOI4HOK.js";
+} from "./chunk-M3STHEMM.js";
+import {
+  DEFAULT_QWEN_EMBEDDING_MODEL,
+  DEFAULT_QWEN_MODEL
+} from "./chunk-F6WFNA7U.js";
 import {
   normalizeMcpToolName,
   sanitizeToolNameForProvider
@@ -8802,16 +8821,16 @@ var require_windows = __commonJS({
       return false;
     }
     __name(checkPathExt, "checkPathExt");
-    function checkStat(stat21, path98, options2) {
-      if (!stat21.isSymbolicLink() && !stat21.isFile()) {
+    function checkStat(stat22, path98, options2) {
+      if (!stat22.isSymbolicLink() && !stat22.isFile()) {
         return false;
       }
       return checkPathExt(path98, options2);
     }
     __name(checkStat, "checkStat");
     function isexe(path98, options2, cb) {
-      fs93.stat(path98, function(er2, stat21) {
-        cb(er2, er2 ? false : checkStat(stat21, path98, options2));
+      fs93.stat(path98, function(er2, stat22) {
+        cb(er2, er2 ? false : checkStat(stat22, path98, options2));
       });
     }
     __name(isexe, "isexe");
@@ -8830,8 +8849,8 @@ var require_mode = __commonJS({
     isexe.sync = sync2;
     var fs93 = __require("fs");
     function isexe(path98, options2, cb) {
-      fs93.stat(path98, function(er2, stat21) {
-        cb(er2, er2 ? false : checkStat(stat21, options2));
+      fs93.stat(path98, function(er2, stat22) {
+        cb(er2, er2 ? false : checkStat(stat22, options2));
       });
     }
     __name(isexe, "isexe");
@@ -8839,14 +8858,14 @@ var require_mode = __commonJS({
       return checkStat(fs93.statSync(path98), options2);
     }
     __name(sync2, "sync");
-    function checkStat(stat21, options2) {
-      return stat21.isFile() && checkMode(stat21, options2);
+    function checkStat(stat22, options2) {
+      return stat22.isFile() && checkMode(stat22, options2);
     }
     __name(checkStat, "checkStat");
-    function checkMode(stat21, options2) {
-      var mod = stat21.mode;
-      var uid = stat21.uid;
-      var gid = stat21.gid;
+    function checkMode(stat22, options2) {
+      var mod = stat22.mode;
+      var uid = stat22.uid;
+      var gid = stat22.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);
@@ -18227,12 +18246,12 @@ var require_resolve_symlink = __commonJS({
       fs_1.default.realpath(path98, (error, resolvedPath) => {
         if (error)
           return queue.dequeue(suppressErrors ? null : error, state);
-        fs_1.default.stat(resolvedPath, (error2, stat21) => {
+        fs_1.default.stat(resolvedPath, (error2, stat22) => {
           if (error2)
             return queue.dequeue(suppressErrors ? null : error2, state);
-          if (stat21.isDirectory() && isRecursive(path98, resolvedPath, state))
+          if (stat22.isDirectory() && isRecursive(path98, resolvedPath, state))
             return queue.dequeue(null, state);
-          callback(stat21, resolvedPath);
+          callback(stat22, resolvedPath);
           queue.dequeue(null, state);
         });
       });
@@ -18242,10 +18261,10 @@ var require_resolve_symlink = __commonJS({
       queue.enqueue();
       try {
         const resolvedPath = fs_1.default.realpathSync(path98);
-        const stat21 = fs_1.default.statSync(resolvedPath);
-        if (stat21.isDirectory() && isRecursive(path98, resolvedPath, state))
+        const stat22 = fs_1.default.statSync(resolvedPath);
+        if (stat22.isDirectory() && isRecursive(path98, resolvedPath, state))
           return;
-        callback(stat21, resolvedPath);
+        callback(stat22, resolvedPath);
       } catch (e) {
         if (!suppressErrors)
           throw e;
@@ -18564,8 +18583,8 @@ var require_walker = __commonJS({
             this.walkDirectory(this.state, path98, path98, depth - 1, this.walk);
           } else if (this.resolveSymlink && entry.isSymbolicLink()) {
             let path98 = joinPath.joinPathWithBasePath(entry.name, directoryPath);
-            this.resolveSymlink(path98, this.state, (stat21, resolvedPath) => {
-              if (stat21.isDirectory()) {
+            this.resolveSymlink(path98, this.state, (stat22, resolvedPath) => {
+              if (stat22.isDirectory()) {
                 resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
                 if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path98 + pathSeparator))
                   return;
@@ -19972,7 +19991,8 @@ var BaseLlmClient = class {
       const request = {
         model: requestModel,
         config: requestConfig,
-        contents: requestContents
+        contents: requestContents,
+        ...options2.promptCacheSharing && { promptCacheSharing: true }
       };
       const apiCall = stream2 ? async () => {
         const responseStream = await contentGenerator.generateContentStream(
@@ -20327,12 +20347,12 @@ async function cleanupLegacyOutputFiles(dir, now, maxAgeMs, result) {
 __name(cleanupLegacyOutputFiles, "cleanupLegacyOutputFiles");
 async function tryDeleteIfOld(filePath, now, maxAgeMs, result) {
   try {
-    const stat21 = await fs2.lstat(filePath);
-    if (!stat21.isFile()) return;
-    if (now - stat21.mtimeMs < maxAgeMs) return;
+    const stat22 = await fs2.lstat(filePath);
+    if (!stat22.isFile()) return;
+    if (now - stat22.mtimeMs < maxAgeMs) return;
     await fs2.unlink(filePath);
     result.filesDeleted++;
-    result.bytesFreed += stat21.size;
+    result.bytesFreed += stat22.size;
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
       return;
@@ -21627,33 +21647,6 @@ function buildContextUsage(contextWindowSize, inputTokens) {
 }
 __name(buildContextUsage, "buildContextUsage");
 
-// packages/core/src/hooks/user-prompt-submit-context.ts
-init_esbuild_shims();
-var USER_PROMPT_SUBMIT_CONTEXT_OPEN_TAG = "<qwen:user-prompt-submit-context>";
-var USER_PROMPT_SUBMIT_CONTEXT_CLOSE_TAG = "</qwen:user-prompt-submit-context>";
-function wrapUserPromptSubmitContext(context2) {
-  return `${USER_PROMPT_SUBMIT_CONTEXT_OPEN_TAG}
-${context2}
-${USER_PROMPT_SUBMIT_CONTEXT_CLOSE_TAG}`;
-}
-__name(wrapUserPromptSubmitContext, "wrapUserPromptSubmitContext");
-function isUserPromptSubmitContextPartText(text) {
-  const trimmed = text.trim();
-  return trimmed.startsWith(USER_PROMPT_SUBMIT_CONTEXT_OPEN_TAG) && trimmed.endsWith(USER_PROMPT_SUBMIT_CONTEXT_CLOSE_TAG) && trimmed.length >= USER_PROMPT_SUBMIT_CONTEXT_OPEN_TAG.length + USER_PROMPT_SUBMIT_CONTEXT_CLOSE_TAG.length;
-}
-__name(isUserPromptSubmitContextPartText, "isUserPromptSubmitContextPartText");
-function stripTrailingUserPromptSubmitContextPart(parts) {
-  if (parts.length <= 1) {
-    return parts;
-  }
-  const last = parts[parts.length - 1];
-  if (!last || typeof last.text !== "string" || !isUserPromptSubmitContextPartText(last.text)) {
-    return parts;
-  }
-  return parts.slice(0, -1);
-}
-__name(stripTrailingUserPromptSubmitContextPart, "stripTrailingUserPromptSubmitContextPart");
-
 // packages/core/src/core/session-start-profiler.ts
 init_esbuild_shims();
 import * as fs3 from "node:fs";
@@ -22165,6 +22158,7 @@ ${coreIdentity}
 
 # Core Mandates
 
+- **UserPromptSubmit Context:** Text inside a \`<qwen:user-prompt-submit-context>\` tag is model context added by a configured \`UserPromptSubmit\` hook, not user input.
 - **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
 - **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it.
 - **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
@@ -24473,357 +24467,6 @@ import fs12 from "node:fs";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import readline from "node:readline";
 
-// packages/core/src/utils/transcript-records.ts
-init_esbuild_shims();
-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",
-  "realtime_message",
-  "custom_title",
-  "parent_session",
-  "rewind",
-  "agent_bootstrap",
-  "agent_launch_prompt",
-  "file_history_snapshot",
-  "session_source",
-  "goal_state",
-  "goal_runtime",
-  ...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();
-  let currentUuid = leafUuid;
-  let cycleUuid;
-  while (currentUuid) {
-    if (visited.has(currentUuid)) {
-      cycleUuid = currentUuid;
-      break;
-    }
-    visited.add(currentUuid);
-    const record2 = lookup2(currentUuid);
-    if (!record2) break;
-    uuids.push(currentUuid);
-    if (!record2.parentUuid) break;
-    if (!lookup2(record2.parentUuid)) {
-      gaps.push({
-        childUuid: currentUuid,
-        missingParentUuid: record2.parentUuid
-      });
-      break;
-    }
-    currentUuid = record2.parentUuid;
-  }
-  uuids.reverse();
-  return { uuids, gaps, ...cycleUuid ? { cycleUuid } : {} };
-}
-__name(walkTranscriptUuidChain, "walkTranscriptUuidChain");
-function aggregateTranscriptRecordFragments(records) {
-  const first = records[0];
-  if (!first) {
-    throw new Error("Cannot aggregate empty transcript record array");
-  }
-  const base = { ...first };
-  let message = first.message ? { ...first.message, parts: [...first.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();
 import { createHash } from "node:crypto";
@@ -29106,6 +28749,7 @@ var SESSION_TRANSCRIPT_MAX_LIMIT = 500;
 var SESSION_TRANSCRIPT_CURSOR_VERSION = 1;
 var SESSION_TRANSCRIPT_MAX_INDEX_BYTES = 256 * 1024 * 1024;
 var SESSION_TRANSCRIPT_MAX_PAGE_BYTES = 4 * 1024 * 1024;
+var SESSION_TRANSCRIPT_MAX_EXPANDED_PAGE_BYTES = 16 * 1024 * 1024;
 var InvalidSessionTranscriptCursorError = class extends Error {
   static {
     __name(this, "InvalidSessionTranscriptCursorError");
@@ -29166,6 +28810,11 @@ var debugLogger14 = createDebugLogger("SESSION_TRANSCRIPT");
 var indexCache = /* @__PURE__ */ new Map();
 var cursorHmacKeys = /* @__PURE__ */ new Map();
 var indexCacheMaxBytesForTest;
+var expandedPageBytesForTest;
+function getExpandedPageBytes() {
+  return expandedPageBytesForTest ?? SESSION_TRANSCRIPT_MAX_EXPANDED_PAGE_BYTES;
+}
+__name(getExpandedPageBytes, "getExpandedPageBytes");
 function makeSessionTranscriptNotFoundError(sessionId) {
   const error = new Error(
     `ENOENT: no such file or directory, open '${sessionId}.jsonl'`
@@ -29176,10 +28825,10 @@ function makeSessionTranscriptNotFoundError(sessionId) {
   return error;
 }
 __name(makeSessionTranscriptNotFoundError, "makeSessionTranscriptNotFoundError");
-function isObjectRecord2(value) {
+function isObjectRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-__name(isObjectRecord2, "isObjectRecord");
+__name(isObjectRecord, "isObjectRecord");
 function isFiniteNonNegativeInteger(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
@@ -29293,11 +28942,11 @@ function decodeCursorState(cursor, key) {
   try {
     const decoded = Buffer.from(cursor, "base64url").toString("utf8");
     const parsed = JSON.parse(decoded);
-    if (!isObjectRecord2(parsed)) {
+    if (!isObjectRecord(parsed)) {
       throw new InvalidSessionTranscriptCursorError();
     }
     const fileIdentity = parsed["fileIdentity"];
-    if (parsed["v"] !== SESSION_TRANSCRIPT_CURSOR_VERSION || typeof parsed["sessionId"] !== "string" || !isObjectRecord2(fileIdentity) || !isFiniteNonNegativeFileId(fileIdentity["dev"]) || !isFiniteNonNegativeFileId(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" || !isObjectRecord(fileIdentity) || !isFiniteNonNegativeFileId(fileIdentity["dev"]) || !isFiniteNonNegativeFileId(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") {
       debugLogger14.debug("cursor decode failed: invalid payload shape");
       throw new InvalidSessionTranscriptCursorError();
     }
@@ -29404,12 +29053,68 @@ function selectPageUuids(index, position, limit, maxBytes) {
   return selected;
 }
 __name(selectPageUuids, "selectPageUuids");
+var REPLAY_MID_TURN_USER_SUBTYPES = /* @__PURE__ */ new Set([
+  "goal_runtime",
+  "notification",
+  "cron",
+  "mid_turn_user_message"
+]);
+function isReplayTurnStartType(type, subtype) {
+  return type === "user" && (subtype === void 0 || !REPLAY_MID_TURN_USER_SUBTYPES.has(subtype));
+}
+__name(isReplayTurnStartType, "isReplayTurnStartType");
 function isReplayTurnStart(index, uuid) {
   const entry = index.byUuid.get(uuid);
-  return entry?.type === "user" && entry.subtype !== "mid_turn_user_message";
+  return isReplayTurnStartType(entry?.type, entry?.subtype);
 }
 __name(isReplayTurnStart, "isReplayTurnStart");
-function selectBackwardPageUuids(index, position, limit, maxBytes) {
+function isReplayPageStart(index, uuid) {
+  const entry = index.byUuid.get(uuid);
+  return entry?.subtype !== "realtime_message" && (entry?.type === "assistant" || isReplayTurnStartType(entry?.type, entry?.subtype));
+}
+__name(isReplayPageStart, "isReplayPageStart");
+function findBoundaryAtOrBefore(items, from, floor, isBoundary) {
+  let candidate = from;
+  while (candidate > floor && !isBoundary(items[candidate])) {
+    candidate--;
+  }
+  return candidate;
+}
+__name(findBoundaryAtOrBefore, "findBoundaryAtOrBefore");
+function findReplayBoundaryAtOrBefore(index, from, floor, isBoundary) {
+  return findBoundaryAtOrBefore(
+    index.activeUuids,
+    from,
+    floor,
+    (uuid) => isBoundary(index, uuid)
+  );
+}
+__name(findReplayBoundaryAtOrBefore, "findReplayBoundaryAtOrBefore");
+function backwardPageBytesFit(index, start, end, budget) {
+  let total = 0;
+  for (let i = start; i < end; i++) {
+    total += recordSegmentBytes(index, index.activeUuids[i]);
+    if (total > budget) return false;
+  }
+  return true;
+}
+__name(backwardPageBytesFit, "backwardPageBytesFit");
+function selectionOrphansToolResult(index, start, end) {
+  for (let i = start; i < end; i++) {
+    if (index.byUuid.get(index.activeUuids[i])?.type !== "tool_result") {
+      continue;
+    }
+    for (let owner = i - 1; owner >= start; owner--) {
+      if (isReplayPageStart(index, index.activeUuids[owner])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+__name(selectionOrphansToolResult, "selectionOrphansToolResult");
+function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
+  if (position === 0) return { uuids: [], nextPosition: 0 };
+  const expansionByteBudget = maxBytes === void 0 ? getExpandedPageBytes() : Math.min(2 * maxBytes, getExpandedPageBytes());
   let start = Math.max(0, position - limit);
   for (let i = start; i < position; i++) {
     if (isReplayTurnStart(index, index.activeUuids[i])) {
@@ -29417,8 +29122,15 @@ function selectBackwardPageUuids(index, position, limit, maxBytes) {
       break;
     }
   }
-  while (start > 0 && !isReplayTurnStart(index, index.activeUuids[start])) {
-    start--;
+  const expansionFloor = Math.max(0, position - 2 * limit);
+  const expandedStart = findReplayBoundaryAtOrBefore(
+    index,
+    start,
+    expansionFloor,
+    isReplayTurnStart
+  );
+  if (isReplayTurnStart(index, index.activeUuids[expandedStart])) {
+    start = expandedStart;
   }
   let selectedStart = position;
   let selectedBytes = 0;
@@ -29431,6 +29143,11 @@ function selectBackwardPageUuids(index, position, limit, maxBytes) {
     selectedStart = i;
     selectedBytes += bytes;
   }
+  const logTurnExpansionSkipped = /* @__PURE__ */ __name((reason) => {
+    debugLogger14.debug(
+      `backward turn expansion skipped session=${sessionId} start=${index.activeUuids[selectedStart]} reason=${reason}`
+    );
+  }, "logTurnExpansionSkipped");
   let alignedToReplayBoundary = false;
   for (let i = selectedStart; i < position; i++) {
     if (isReplayTurnStart(index, index.activeUuids[i])) {
@@ -29440,16 +29157,59 @@ function selectBackwardPageUuids(index, position, limit, maxBytes) {
     }
   }
   if (alignedToReplayBoundary && selectedStart > 0) {
-    let previousTurnStart = selectedStart - 1;
-    while (previousTurnStart >= 0 && !isReplayTurnStart(index, index.activeUuids[previousTurnStart])) {
-      previousTurnStart--;
-    }
+    const previousTurnStart = findReplayBoundaryAtOrBefore(
+      index,
+      selectedStart - 1,
+      -1,
+      isReplayTurnStart
+    );
     if (previousTurnStart < 0) {
-      selectedStart = 0;
+      if (expansionFloor === 0 && backwardPageBytesFit(index, 0, position, expansionByteBudget)) {
+        selectedStart = 0;
+      } else {
+        logTurnExpansionSkipped(
+          expansionFloor === 0 ? "byte-budget" : "record-budget"
+        );
+      }
     }
   } else if (!alignedToReplayBoundary) {
-    while (selectedStart > 0 && !isReplayTurnStart(index, index.activeUuids[selectedStart])) {
-      selectedStart--;
+    const candidate = findReplayBoundaryAtOrBefore(
+      index,
+      selectedStart,
+      expansionFloor,
+      isReplayTurnStart
+    );
+    if (isReplayTurnStart(index, index.activeUuids[candidate])) {
+      if (backwardPageBytesFit(index, candidate, position, expansionByteBudget)) {
+        selectedStart = candidate;
+      } else {
+        logTurnExpansionSkipped("byte-budget");
+      }
+    }
+  }
+  if (selectedStart > 0 && selectionOrphansToolResult(index, selectedStart, position)) {
+    const pairFloor = Math.max(0, selectedStart - limit);
+    const pairStart = findReplayBoundaryAtOrBefore(
+      index,
+      selectedStart,
+      pairFloor,
+      isReplayPageStart
+    );
+    if (!isReplayPageStart(index, index.activeUuids[pairStart])) {
+      debugLogger14.debug(
+        `backward pair extension skipped session=${sessionId} start=${index.activeUuids[selectedStart]} reason=record-budget`
+      );
+    } else if (!backwardPageBytesFit(
+      index,
+      pairStart + 1,
+      selectedStart,
+      expansionByteBudget
+    )) {
+      debugLogger14.debug(
+        `backward pair extension skipped session=${sessionId} start=${index.activeUuids[selectedStart]} reason=byte-budget`
+      );
+    } else {
+      selectedStart = pairStart;
     }
   }
   return {
@@ -29624,7 +29384,7 @@ async function readAggregatedRecords(index, uuids) {
   }
 }
 __name(readAggregatedRecords, "readAggregatedRecords");
-async function readGoalStateBeforePosition(index, position) {
+async function readGoalStatePayloadBeforePosition(index, position) {
   let low = 0;
   let high = index.goalStatePositions.length;
   while (low < high) {
@@ -29639,9 +29399,9 @@ async function readGoalStateBeforePosition(index, position) {
   if (goalStatePosition === void 0) return void 0;
   const uuid = index.activeUuids[goalStatePosition];
   const [record2] = await readAggregatedRecords(index, [uuid]);
-  return parseGoalStateRecordPayloadV2(record2?.systemPayload)?.snapshot;
+  return parseGoalStateRecordPayloadV2(record2?.systemPayload);
 }
-__name(readGoalStateBeforePosition, "readGoalStateBeforePosition");
+__name(readGoalStatePayloadBeforePosition, "readGoalStatePayloadBeforePosition");
 async function buildIndex(params) {
   const { filePath, fileIdentity, snapshotSize, lastUpdated } = params;
   const sessionId = path10.basename(filePath, ".jsonl");
@@ -29675,7 +29435,7 @@ async function buildIndex(params) {
         if (!record2 || !isTranscriptConversationRecord(record2)) {
           continue;
         }
-        if (record2.type === "system" && record2.subtype === "session_source" && isObjectRecord2(record2.systemPayload) && record2.systemPayload["sourceType"] === "side_task") {
+        if (record2.type === "system" && record2.subtype === "session_source" && isObjectRecord(record2.systemPayload) && record2.systemPayload["sourceType"] === "side_task") {
           sideTaskSourceUuid = record2.uuid;
         }
         if (record2.timestamp) startTime ??= record2.timestamp;
@@ -29880,11 +29640,11 @@ var SessionTranscriptReader = class {
       );
       throw new InvalidSessionTranscriptCursorError();
     }
-    const backwardPage = direction === "backward" ? selectBackwardPageUuids(index, position, limit, maxBytes) : void 0;
+    const backwardPage = direction === "backward" ? selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) : void 0;
     const pageUuids = backwardPage?.uuids ?? selectPageUuids(index, position, limit, maxBytes);
     const nextPosition = backwardPage?.nextPosition ?? position + pageUuids.length;
     const records = await readAggregatedRecords(index, pageUuids);
-    const backwardGoalState = direction === "backward" ? await readGoalStateBeforePosition(index, nextPosition) : void 0;
+    const backwardGoalState = direction === "backward" ? await readGoalStatePayloadBeforePosition(index, nextPosition) : void 0;
     const hasMore = direction === "backward" ? nextPosition > 0 : nextPosition < index.activeUuids.length;
     const nextCursorState = hasMore ? {
       v: SESSION_TRANSCRIPT_CURSOR_VERSION,
@@ -29908,7 +29668,12 @@ var SessionTranscriptReader = class {
       hasMore,
       ...direction === "backward" ? { direction: "backward" } : {},
       ...nextCursorState ? { nextCursorState } : {},
-      ...backwardGoalState ? { replay: { goalState: backwardGoalState } } : cursor?.replay !== void 0 ? { replay: cursor.replay } : {},
+      ...backwardGoalState ? {
+        replay: {
+          goalState: backwardGoalState.snapshot,
+          goalCause: backwardGoalState.cause
+        }
+      } : cursor?.replay !== void 0 ? { replay: cursor.replay } : {},
       startTime: index.startTime,
       lastUpdated: index.lastUpdated
     };
@@ -29923,6 +29688,15 @@ import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypt
 import * as fs11 from "node:fs/promises";
 import * as os3 from "node:os";
 import * as path11 from "node:path";
+
+// packages/core/src/utils/file-identity.ts
+init_esbuild_shims();
+function hasVerifiableInode(ino) {
+  return Number(ino) !== 0;
+}
+__name(hasVerifiableInode, "hasVerifiableInode");
+
+// packages/core/src/services/session-writer-lease.ts
 var LEGACY_LOCK_SCHEMA_VERSION = 1;
 var LOCK_SCHEMA_VERSION = 2;
 var MALFORMED_RETRY_COUNT = 3;
@@ -30000,12 +29774,31 @@ var SessionWriterUnavailableError = class extends SessionWriterError {
   static {
     __name(this, "SessionWriterUnavailableError");
   }
+  // Widened from the literal type so the subclass below can redeclare `name`.
+  // Narrowing this back to a literal makes that subclass fail to compile.
   name = "SessionWriterUnavailableError";
   rpcCode = SESSION_WRITER_RPC_CODES.session_writer_unavailable;
   errorKind = "session_writer_unavailable";
   httpStatus = 503;
   constructor(options2) {
-    super("Session write ownership could not be verified.", options2);
+    super(
+      options2?.message ?? "Session write ownership could not be verified.",
+      options2
+    );
+  }
+};
+var SessionTranscriptIdentityUnavailableError = class extends SessionWriterUnavailableError {
+  static {
+    __name(this, "SessionTranscriptIdentityUnavailableError");
+  }
+  name = "SessionTranscriptIdentityUnavailableError";
+  constructor(cause) {
+    super({
+      message: "Session transcript identity could not be verified on this filesystem.",
+      cause: cause ?? new Error(
+        "The session transcript filesystem does not provide a verifiable inode identity (ino=0)."
+      )
+    });
   }
 };
 function isProcessAlive(pid) {
@@ -30043,11 +29836,11 @@ __name(execFileText, "execFileText");
 async function readProcessStartIdentity(pid) {
   if (process.platform === "linux") {
     try {
-      const [stat21, bootId] = await Promise.all([
+      const [stat22, bootId] = await Promise.all([
         fs11.readFile(`/proc/${pid}/stat`, "utf8"),
         fs11.readFile("/proc/sys/kernel/random/boot_id", "utf8")
       ]);
-      const fields = stat21.slice(stat21.lastIndexOf(")") + 1).trim().split(/\s+/);
+      const fields = stat22.slice(stat22.lastIndexOf(")") + 1).trim().split(/\s+/);
       const startTicks = fields[19];
       if (!startTicks || !/^\d+$/.test(startTicks) || !/^[0-9a-f-]+$/i.test(bootId.trim())) {
         return null;
@@ -30125,22 +29918,46 @@ async function delay(ms2) {
   await new Promise((resolve38) => setTimeout(resolve38, ms2));
 }
 __name(delay, "delay");
-function transcriptFingerprint(stat21) {
+function transcriptFingerprint(stat22) {
   return {
-    dev: stat21.dev,
-    ino: stat21.ino,
-    mode: stat21.mode,
-    uid: stat21.uid,
-    gid: stat21.gid,
-    nlink: stat21.nlink,
-    birthtimeMs: stat21.birthtimeMs,
-    ctimeMs: stat21.ctimeMs,
-    mtimeMs: stat21.mtimeMs
+    dev: stat22.dev,
+    ino: stat22.ino,
+    mode: stat22.mode,
+    uid: stat22.uid,
+    gid: stat22.gid,
+    nlink: stat22.nlink,
+    birthtimeMs: stat22.birthtimeMs,
+    ctimeMs: stat22.ctimeMs,
+    mtimeMs: stat22.mtimeMs
   };
 }
 __name(transcriptFingerprint, "transcriptFingerprint");
+function assertVerifiableTranscriptIdentity(fingerprint2) {
+  if (!hasVerifiableInode(fingerprint2.ino)) {
+    throw new SessionTranscriptIdentityUnavailableError();
+  }
+}
+__name(assertVerifiableTranscriptIdentity, "assertVerifiableTranscriptIdentity");
+async function assertTranscriptFilesystemProvidesIdentity(transcriptPath) {
+  let dir = path11.dirname(transcriptPath);
+  for (; ; ) {
+    try {
+      const stat22 = await fs11.stat(dir);
+      assertVerifiableTranscriptIdentity({ ino: stat22.ino });
+      return;
+    } catch (error) {
+      if (error instanceof SessionWriterError) throw error;
+      const code = error.code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") return;
+      const parent = path11.dirname(dir);
+      if (parent === dir) return;
+      dir = parent;
+    }
+  }
+}
+__name(assertTranscriptFilesystemProvidesIdentity, "assertTranscriptFilesystemProvidesIdentity");
 function sameFileIdentity2(left, right) {
-  return left.dev === right.dev && left.ino === right.ino;
+  return left.ino !== 0 && right.ino !== 0 && left.dev === right.dev && left.ino === right.ino;
 }
 __name(sameFileIdentity2, "sameFileIdentity");
 function sameFileSecurityMetadata(left, right) {
@@ -30159,11 +29976,13 @@ function sameTranscriptState(left, right) {
   return sameHardTranscriptState(left, right) && left.fingerprint.birthtimeMs === right.fingerprint.birthtimeMs && left.fingerprint.ctimeMs === right.fingerprint.ctimeMs && left.fingerprint.mtimeMs === right.fingerprint.mtimeMs;
 }
 __name(sameTranscriptState, "sameTranscriptState");
-function transcriptStateFromStat(stat21) {
+function transcriptStateFromStat(stat22) {
+  const fingerprint2 = transcriptFingerprint(stat22);
+  assertVerifiableTranscriptIdentity(fingerprint2);
   return {
     exists: true,
-    byteLength: stat21.size,
-    fingerprint: transcriptFingerprint(stat21)
+    byteLength: stat22.size,
+    fingerprint: fingerprint2
   };
 }
 __name(transcriptStateFromStat, "transcriptStateFromStat");
@@ -30255,20 +30074,20 @@ async function getOpenTranscriptState(filePath, handle, invalidPathIsChange) {
 }
 __name(getOpenTranscriptState, "getOpenTranscriptState");
 async function inspectTranscriptPath(filePath, invalidPathIsChange) {
-  let stat21;
+  let stat22;
   try {
-    stat21 = await fs11.lstat(filePath);
+    stat22 = await fs11.lstat(filePath);
   } catch (error) {
     if (error.code === "ENOENT") {
       return { exists: false, byteLength: 0 };
     }
     throw error;
   }
-  if (!stat21.isFile() || stat21.isSymbolicLink()) {
+  if (!stat22.isFile() || stat22.isSymbolicLink()) {
     if (invalidPathIsChange) throw new SessionTranscriptChangedError();
     throw new SessionWriterUnavailableError();
   }
-  return transcriptStateFromStat(stat21);
+  return transcriptStateFromStat(stat22);
 }
 __name(inspectTranscriptPath, "inspectTranscriptPath");
 async function openTranscriptForRead(filePath, expectedState) {
@@ -30467,15 +30286,10 @@ async function openTranscriptProof(filePath) {
     if (!beforeStat.isFile() || !pathStat.isFile() || pathStat.isSymbolicLink()) {
       throw new SessionWriterUnavailableError();
     }
-    const beforeState = {
-      exists: true,
-      byteLength: beforeStat.size,
-      fingerprint: transcriptFingerprint(beforeStat)
-    };
-    if (!sameFileIdentity2(
-      beforeState.fingerprint,
-      transcriptFingerprint(pathStat)
-    )) {
+    const beforeState = transcriptStateFromStat(beforeStat);
+    const beforePathFingerprint = transcriptFingerprint(pathStat);
+    assertVerifiableTranscriptIdentity(beforePathFingerprint);
+    if (!sameFileIdentity2(beforeState.fingerprint, beforePathFingerprint)) {
       throw new SessionTranscriptChangedError();
     }
     if (beforeStat.size > 0) {
@@ -30508,15 +30322,10 @@ async function openTranscriptProof(filePath) {
       handle.stat(),
       fs11.lstat(filePath)
     ]);
-    const afterState = {
-      exists: true,
-      byteLength: afterStat.size,
-      fingerprint: transcriptFingerprint(afterStat)
-    };
-    if (!sameTranscriptState(beforeState, afterState) || !afterPathStat.isFile() || afterPathStat.isSymbolicLink() || !sameFileIdentity2(
-      afterState.fingerprint,
-      transcriptFingerprint(afterPathStat)
-    )) {
+    const afterState = transcriptStateFromStat(afterStat);
+    const afterPathFingerprint = transcriptFingerprint(afterPathStat);
+    assertVerifiableTranscriptIdentity(afterPathFingerprint);
+    if (!sameTranscriptState(beforeState, afterState) || !afterPathStat.isFile() || afterPathStat.isSymbolicLink() || !sameFileIdentity2(afterState.fingerprint, afterPathFingerprint)) {
       throw new SessionTranscriptChangedError();
     }
     const proof = {
@@ -30555,12 +30364,10 @@ async function validateOpenTranscriptProof(filePath, proof) {
     if (!handleStat.isFile() || !pathStat.isFile() || pathStat.isSymbolicLink()) {
       throw new SessionWriterUnavailableError();
     }
-    const current = {
-      exists: true,
-      byteLength: handleStat.size,
-      fingerprint: transcriptFingerprint(handleStat)
-    };
-    if (!sameTranscriptState(current, proof.state) || !sameFileIdentity2(current.fingerprint, transcriptFingerprint(pathStat))) {
+    const current = transcriptStateFromStat(handleStat);
+    const pathFingerprint = transcriptFingerprint(pathStat);
+    assertVerifiableTranscriptIdentity(pathFingerprint);
+    if (!sameTranscriptState(current, proof.state) || !sameFileIdentity2(current.fingerprint, pathFingerprint)) {
       throw new SessionTranscriptChangedError();
     }
   } catch (error) {
@@ -30697,8 +30504,8 @@ async function removeExactRecord(candidatePath, expectedRaw) {
 __name(removeExactRecord, "removeExactRecord");
 async function inspectExactRecord(candidatePath, expectedRaw) {
   try {
-    const stat21 = await fs11.lstat(candidatePath);
-    if (!stat21.isFile() || stat21.isSymbolicLink()) return { state: "other" };
+    const stat22 = await fs11.lstat(candidatePath);
+    if (!stat22.isFile() || stat22.isSymbolicLink()) return { state: "other" };
     const raw = await fs11.readFile(candidatePath, "utf8");
     return { state: raw === expectedRaw ? "exact" : "other" };
   } catch (error) {
@@ -30752,8 +30559,8 @@ async function releaseTransitionClaim(claimPath, claimRaw) {
 __name(releaseTransitionClaim, "releaseTransitionClaim");
 async function inspectClaimedPrimary(lockPath, sourceRaw, sessionId) {
   try {
-    const stat21 = await fs11.lstat(lockPath);
-    if (!stat21.isFile() || stat21.isSymbolicLink()) return { state: "other" };
+    const stat22 = await fs11.lstat(lockPath);
+    if (!stat22.isFile() || stat22.isSymbolicLink()) return { state: "other" };
     const raw = await fs11.readFile(lockPath, "utf8");
     if (raw === sourceRaw) return { state: "source" };
     const record2 = parseLockRecord(raw);
@@ -31273,6 +31080,11 @@ var SessionWriterLease = class _SessionWriterLease {
         void 0,
         () => lease.released
       );
+      if (!snapshot.state.exists) {
+        await assertTranscriptFilesystemProvidesIdentity(
+          options2.transcriptPath
+        );
+      }
       await lease.readOwnedLock();
       lease.expectedTranscriptState = snapshot.state;
       lease.expectedTranscriptHasher = snapshot.hasher;
@@ -31299,9 +31111,9 @@ var SessionWriterLease = class _SessionWriterLease {
   }
   static async inspectExistingLock(lockPath, expectedSessionId) {
     for (let attempt = 0; attempt < MALFORMED_RETRY_COUNT; attempt++) {
-      let stat21;
+      let stat22;
       try {
-        stat21 = await fs11.lstat(lockPath);
+        stat22 = await fs11.lstat(lockPath);
       } catch (error) {
         if (error.code === "ENOENT") {
           return { kind: "missing" };
@@ -31310,7 +31122,7 @@ var SessionWriterLease = class _SessionWriterLease {
           cause: error instanceof Error ? error : void 0
         });
       }
-      if (!stat21.isFile() || stat21.isSymbolicLink()) {
+      if (!stat22.isFile() || stat22.isSymbolicLink()) {
         throw new SessionWriterUnavailableError({
           cause: new Error("Session writer lock is not a regular file")
         });
@@ -31346,16 +31158,16 @@ var SessionWriterLease = class _SessionWriterLease {
   }
   async readOwnedLock() {
     if (this.released) throw new SessionWriterLostError();
-    let stat21;
+    let stat22;
     try {
-      stat21 = await fs11.lstat(this.lockPath);
+      stat22 = await fs11.lstat(this.lockPath);
     } catch (error) {
       if (error.code === "ENOENT") {
         throw new SessionWriterLostError();
       }
       throw new SessionWriterUnavailableError();
     }
-    if (!stat21.isFile() || stat21.isSymbolicLink()) {
+    if (!stat22.isFile() || stat22.isSymbolicLink()) {
       throw new SessionWriterLostError();
     }
     let raw;
@@ -31454,6 +31266,7 @@ var SessionWriterLease = class _SessionWriterLease {
       candidateHasher.update(bytes);
       const nextByteLength = expectedBefore.byteLength + bytes.byteLength;
       await this.readOwnedLock();
+      assertVerifiableTranscriptIdentity(beforeState.fingerprint);
       await handle.writeFile(bytes);
       await handle.sync();
       const afterStat = await handle.stat();
@@ -31781,8 +31594,8 @@ var SessionWriterLease = class _SessionWriterLease {
   }
   async inspectReleasePath(candidatePath) {
     try {
-      const stat21 = await fs11.lstat(candidatePath);
-      if (!stat21.isFile() || stat21.isSymbolicLink()) return "other";
+      const stat22 = await fs11.lstat(candidatePath);
+      if (!stat22.isFile() || stat22.isSymbolicLink()) return "other";
       const raw = await fs11.readFile(candidatePath, "utf8");
       return raw === this.lockRecordRaw ? "owned" : "other";
     } catch (error) {
@@ -33476,7 +33289,8 @@ function getResumeTokenCounts(conversation) {
       if (candidate) {
         return {
           promptTokenCount: candidate,
-          outputTokenCount: getUsageOutputTokenCountForPromptEstimate(usage)
+          outputTokenCount: getUsageOutputTokenCountForPromptEstimate(usage),
+          isEstimated: false
         };
       }
     }
@@ -33485,7 +33299,11 @@ function getResumeTokenCounts(conversation) {
       if (payload?.info) {
         return {
           promptTokenCount: payload.info.newTokenCount,
-          outputTokenCount: 0
+          outputTokenCount: 0,
+          // Checkpoints created before provenance was persisted are safest to
+          // treat as estimates: this keeps the output clamp's overhead pad on
+          // and prevents an optimistic resume from overflowing the window.
+          isEstimated: payload.info.newTokenCountIsEstimated ?? true
         };
       }
     }
@@ -34345,15 +34163,17 @@ var ChatRecordingService = class {
    * Queues the write immediately on the serialized async writer.
    *
    * @param message The raw PartListUnion object as used with the API
+   * @param goalContext Goal identity and turn that own this message
+   * @param promptPayload User-authored display text and hook-context provenance
    */
-  recordUserMessage(message, goalContext, payload) {
+  recordUserMessage(message, goalContext, promptPayload) {
     try {
       this.turnParentUuids.push(this.lastRecordUuid);
       const record2 = {
         ...this.createBaseRecord("user"),
         ...goalContext ? { goalContext: copyGoalContext(goalContext) } : {},
         message: createUserContent(message),
-        ...payload ? { systemPayload: payload } : {}
+        ...promptPayload ? { systemPayload: promptPayload } : {}
       };
       this.appendRecord(record2);
     } catch (error) {
@@ -35439,18 +35259,9 @@ function getCitations(resp) {
 }
 __name(getCitations, "getCitations");
 
-// packages/core/src/core/openaiContentGenerator/prefix-caching.ts
-init_esbuild_shims();
-function supportsOpenAIPrefixCaching(contentGeneratorConfig) {
-  return DashScopeOpenAICompatibleProvider.isDashScopeProvider(
-    contentGeneratorConfig
-  );
-}
-__name(supportsOpenAIPrefixCaching, "supportsOpenAIPrefixCaching");
-
 // packages/core/src/services/postCompactAttachments.ts
 init_esbuild_shims();
-import { readFile as readFile7, stat as stat4 } from "node:fs/promises";
+import { readFile as readFile7, stat as stat5 } from "node:fs/promises";
 import { realpathSync } from "node:fs";
 import { resolve as resolvePath2, sep as pathSep } from "node:path";
 var POST_COMPACT_MAX_FILES_TO_RESTORE = 5;
@@ -35585,7 +35396,7 @@ async function readFileSizeAdaptive(filePath, maxTokens, signal) {
   if (signal?.aborted) return { kind: "missing" };
   const maxChars = maxTokens * CHARS_PER_TOKEN;
   try {
-    const { size } = await stat4(filePath);
+    const { size } = await stat5(filePath);
     if (size > maxChars * 4) return { kind: "reference" };
   } catch {
     return { kind: "missing" };
@@ -35909,9 +35720,12 @@ ${parts.join("\n\n")}`;
 __name(buildCompressionSystemPrompt, "buildCompressionSystemPrompt");
 function supportsCompressionCacheSharing(config) {
   const provider = config.getContentGeneratorConfig();
+  if (provider.authType === "gemini" /* USE_GEMINI */ || provider.authType === "vertex-ai" /* USE_VERTEX_AI */) {
+    return true;
+  }
   if (provider.enableCacheControl === false) return false;
   if (provider.authType === "anthropic" /* USE_ANTHROPIC */) return true;
-  return (provider.authType === "qwen-oauth" /* QWEN_OAUTH */ || provider.authType === "openai" /* USE_OPENAI */) && supportsOpenAIPrefixCaching(provider);
+  return supportsOpenAIPrefixCaching(provider);
 }
 __name(supportsCompressionCacheSharing, "supportsCompressionCacheSharing");
 function hasStateSnapshot(summary) {
@@ -36123,11 +35937,11 @@ Do not call tools; tool execution is disabled for this request. ` + COMPRESSION_
     );
     const usesMainModel = effectiveCompactionModel === config.getModel();
     const providerSupportsCacheSharing = supportsCompressionCacheSharing(config);
-    const hasProviderTokenCount = (chat.getLastPromptTokenCount?.() ?? 0) > 0;
+    const hasProviderTokenCount = (chat.getLastPromptTokenCount?.() ?? 0) > 0 && chat.isLastPromptTokenCountEstimated?.() !== true;
     const sharedRequestFits = sharedPromptTokenCount + sharedDirectiveTokenCount + COMPACT_MAX_OUTPUT_TOKENS <= contextLimit;
     const canShareCache = usesMainModel && providerSupportsCacheSharing && hasProviderTokenCount && sharedRequestFits;
     if (!canShareCache) {
-      const reason = !usesMainModel ? "distinct compaction model" : !providerSupportsCacheSharing ? "provider does not support cache sharing" : !hasProviderTokenCount ? "no provider token-count anchor" : `shared request exceeds context window: prompt=${sharedPromptTokenCount}, directive=${sharedDirectiveTokenCount}, reserve=${COMPACT_MAX_OUTPUT_TOKENS}, window=${contextLimit}`;
+      const reason = !usesMainModel ? "distinct compaction model" : !providerSupportsCacheSharing ? "provider does not support cache sharing" : !hasProviderTokenCount ? "no provider-reported token-count anchor" : `shared request exceeds context window: prompt=${sharedPromptTokenCount}, directive=${sharedDirectiveTokenCount}, reserve=${COMPACT_MAX_OUTPUT_TOKENS}, window=${contextLimit}`;
       debugLogger20.debug(`[compaction] skipping cache sharing: ${reason}`);
     }
     if (canShareCache) {
@@ -36139,6 +35953,7 @@ Do not call tools; tool execution is disabled for this request. ` + COMPRESSION_
         const mainSystemInstruction = generationConfig.systemInstruction;
         delete generationConfig.systemInstruction;
         delete generationConfig.abortSignal;
+        const authType = config.getContentGeneratorConfig().authType;
         const sharedResult = await config.getBaseLlmClient().generateText({
           contents: [
             ...sideQueryHistory,
@@ -36155,7 +35970,7 @@ Do not call tools; tool execution is disabled for this request. ` + COMPRESSION_
           systemInstruction: mainSystemInstruction,
           config: {
             ...generationConfig,
-            ...contentGeneratorConfig.authType === "anthropic" /* USE_ANTHROPIC */ ? {
+            ...authType === "anthropic" /* USE_ANTHROPIC */ ? {
               thinkingConfig: {
                 ...generationConfig.thinkingConfig,
                 // Manual Anthropic thinking requires budget_tokens to be
@@ -36163,13 +35978,19 @@ Do not call tools; tool execution is disabled for this request. ` + COMPRESSION_
                 // compatibility while keeping this bounded request valid.
                 thinkingBudget: COMPACT_MAX_OUTPUT_TOKENS - 1
               }
+            } : authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */ ? {
+              thinkingConfig: {
+                ...generationConfig.thinkingConfig,
+                includeThoughts: false
+              }
             } : {},
             maxOutputTokens: COMPACT_MAX_OUTPUT_TOKENS
           },
           abortSignal,
           promptId,
           stream: true,
-          maxAttempts: 1
+          maxAttempts: 1,
+          promptCacheSharing: true
         });
         if (!sharedResult.hadToolCall && hasStateSnapshot(sharedResult.text)) {
           summaryResult = sharedResult;
@@ -36367,6 +36188,7 @@ Do not call tools; tool execution is disabled for this request. ` + COMPRESSION_
         info: {
           originalTokenCount,
           newTokenCount,
+          newTokenCountIsEstimated: true,
           compressionStatus: 1 /* COMPRESSED */,
           triggerReason,
           ...compactionWarning && { warning: compactionWarning }
@@ -37067,7 +36889,7 @@ function syncFunctionCallsField(response, parts) {
 __name(syncFunctionCallsField, "syncFunctionCallsField");
 function canonicalPlanToolName(toolName) {
   if (!toolName) return "";
-  return ToolNamesMigration[toolName] ?? toolName;
+  return canonicalToolName(toolName);
 }
 __name(canonicalPlanToolName, "canonicalPlanToolName");
 function approvedPlanRedactionText(planPath) {
@@ -37179,7 +37001,7 @@ var TRANSPORT_STREAM_RETRY_CONFIG = {
    */
   maxContinuationRetries: 3
 };
-var FIRST_SEND_CLAMP_OVERHEAD_PAD = 2e4;
+var ESTIMATE_CLAMP_OVERHEAD_PAD = 2e4;
 var MAX_OUTPUT_RECOVERY_ATTEMPTS = 3;
 var RECOVERY_RESUME_INSTRUCTION = "Resume directly \u2014 no apology, no recap of what you were doing. Pick up mid-thought if that is where the cut happened. Break remaining work into smaller pieces.";
 var OUTPUT_RECOVERY_MESSAGE = `Output token limit hit. ${RECOVERY_RESUME_INSTRUCTION}`;
@@ -37283,6 +37105,10 @@ ${suffix}`;
   return continuationText;
 }
 __name(getRecoveryContinuationSuffix, "getRecoveryContinuationSuffix");
+function mergeDeliveredPrefix(deliveredText, continuationText) {
+  return deliveredText + getRecoveryContinuationSuffix(deliveredText, continuationText);
+}
+__name(mergeDeliveredPrefix, "mergeDeliveredPrefix");
 function isPlainTextPart(part) {
   return part !== void 0 && isValidNonThoughtTextPart(part);
 }
@@ -37784,6 +37610,7 @@ var GeminiChat = class {
    * still make compaction decisions based on their *own* context size.
    */
   lastPromptTokenCount = 0;
+  lastPromptTokenCountIsEstimated = false;
   /**
    * Per-chat output-token count from the previous model response. The
    * previous response is appended to local history after `promptTokenCount`
@@ -37932,18 +37759,26 @@ var GeminiChat = class {
    * comes from a different chat instance and should not inherit this chat's
    * last response size.
    */
-  setLastPromptTokenCount(count) {
+  setLastPromptTokenCount(count, isEstimated = false) {
     this.lastPromptTokenCount = count;
+    this.lastPromptTokenCountIsEstimated = isEstimated;
     this.lastOutputTokenCount = 0;
   }
+  isLastPromptTokenCountEstimated() {
+    return this.lastPromptTokenCountIsEstimated;
+  }
+  promptCountIsEstimateDerived() {
+    return this.lastPromptTokenCount === 0 || this.lastPromptTokenCountIsEstimated;
+  }
   /**
    * Seed the restored prompt and previous-response output token counts in one
-   * step. Resume restores chat history plus both counters from the same
-   * assistant usage record, so callers must avoid the normal
+   * step. Resume restores chat history plus both counters and their provenance
+   * from the same checkpoint, so callers must avoid the normal
    * setLastPromptTokenCount() clearing behavior.
    */
-  seedResumeTokenCounts(promptTokenCount, outputTokenCount) {
+  seedResumeTokenCounts(promptTokenCount, outputTokenCount, isEstimated = false) {
     this.lastPromptTokenCount = Number.isFinite(promptTokenCount) ? Math.max(0, promptTokenCount) : 0;
+    this.lastPromptTokenCountIsEstimated = isEstimated;
     this.lastOutputTokenCount = Number.isFinite(outputTokenCount) ? Math.max(0, outputTokenCount) : 0;
   }
   /**
@@ -37958,13 +37793,21 @@ var GeminiChat = class {
    * post-compression guards pass.
    */
   async tryCompress(promptId, force = false, signal, options2) {
+    const originalTokenCountIsEstimated = options2?.originalTokenCountOverride === void 0 && this.promptCountIsEstimateDerived();
+    const originalTokenCount = originalTokenCountIsEstimated ? options2?.precomputedEffectiveTokens ?? estimateContentTokens(
+      options2?.pendingUserMessage ? [...this.getHistoryShallow(true), options2.pendingUserMessage] : this.getHistoryShallow(true),
+      resolveSlimmingConfig(this.config.getChatCompression()).imageTokenEstimate
+    ) : options2?.originalTokenCountOverride ?? this.lastPromptTokenCount;
+    debugLogger22.debug(
+      `[compaction] token-count provenance: prompt_id=${promptId}, originalTokenCount=${originalTokenCount}, estimated=${originalTokenCountIsEstimated}`
+    );
     const service = new ChatCompressionService();
     const { newHistory, info } = await service.compress(this, {
       promptId,
       force,
       config: this.config,
       consecutiveFailures: this.consecutiveFailures,
-      originalTokenCount: options2?.originalTokenCountOverride ?? this.lastPromptTokenCount,
+      originalTokenCount,
       pendingUserMessage: options2?.pendingUserMessage,
       precomputedEffectiveTokens: options2?.precomputedEffectiveTokens,
       requestGenerationConfig: options2?.requestGenerationConfig,
@@ -37973,6 +37816,7 @@ var GeminiChat = class {
       signal
     });
     if (info.compressionStatus === 1 /* COMPRESSED */ && newHistory) {
+      info.newTokenCountIsEstimated ??= true;
       if (!options2?.deferChatCompressionRecord) {
         this.chatRecordingService?.recordChatCompression({
           info,
@@ -37982,8 +37826,10 @@ var GeminiChat = class {
       this.setHistory(newHistory);
       debugLogger22.debug("[FILE_READ_CACHE] clear after auto tryCompress");
       this.config.getFileReadCache().clear();
-      this.lastPromptTokenCount = info.newTokenCount;
-      this.lastOutputTokenCount = 0;
+      this.setLastPromptTokenCount(
+        info.newTokenCount,
+        info.newTokenCountIsEstimated
+      );
       this.telemetryService?.setLastPromptTokenCount(info.newTokenCount);
       this.consecutiveFailures = 0;
       this.hardRescueFailureCount = 0;
@@ -38033,10 +37879,15 @@ var GeminiChat = class {
     }
     const reduction = beforeEstimate - afterEstimate;
     const apiBaseline = this.lastPromptTokenCount || beforeEstimate;
+    const baselineIsEstimated = this.promptCountIsEstimateDerived();
     const adjustedTokenCount = Math.max(0, apiBaseline - reduction);
+    debugLogger22.debug(
+      `[compaction] fast token-count provenance: originalTokenCount=${apiBaseline}, estimated=${baselineIsEstimated}`
+    );
     const info = {
       originalTokenCount: apiBaseline,
       newTokenCount: adjustedTokenCount,
+      newTokenCountIsEstimated: true,
       compressionStatus: 1 /* COMPRESSED */,
       triggerReason: "manual"
     };
@@ -38053,6 +37904,7 @@ var GeminiChat = class {
     );
     this.setHistory(newHistory);
     this.lastPromptTokenCount = adjustedTokenCount;
+    this.lastPromptTokenCountIsEstimated = true;
     this.telemetryService?.setLastPromptTokenCount(adjustedTokenCount);
     this.consecutiveFailures = 0;
     return { info, microcompactMeta: mcMeta };
@@ -38173,6 +38025,7 @@ var GeminiChat = class {
       const shouldForceFromHard = !exactRoute && isHardTier && this.hardRescueFailureCount < MAX_CONSECUTIVE_FAILURES;
       const historyBeforeHardRescue = shouldForceFromHard ? this.getHistoryShallow() : void 0;
       const lastPromptTokenCountBeforeHardRescue = this.lastPromptTokenCount;
+      const lastPromptTokenCountWasEstimatedBeforeHardRescue = this.lastPromptTokenCountIsEstimated;
       const hardRescueFailureCountBeforeHardRescue = this.hardRescueFailureCount;
       if (shouldForceFromHard) {
         debugLogger22.warn(
@@ -38232,6 +38085,7 @@ var GeminiChat = class {
         if (compressionInfo.compressionStatus === 1 /* COMPRESSED */ && historyBeforeHardRescue) {
           this.setHistory(historyBeforeHardRescue);
           this.lastPromptTokenCount = lastPromptTokenCountBeforeHardRescue;
+          this.lastPromptTokenCountIsEstimated = lastPromptTokenCountWasEstimatedBeforeHardRescue;
           this.telemetryService?.setLastPromptTokenCount(
             lastPromptTokenCountBeforeHardRescue
           );
@@ -38293,7 +38147,13 @@ var GeminiChat = class {
         imageTokenEstimate,
         /* conservative= */
         true
-      ) : effectiveTokens + FIRST_SEND_CLAMP_OVERHEAD_PAD;
+      ) : effectiveTokens;
+      if (this.promptCountIsEstimateDerived()) {
+        promptTokensForClamp += ESTIMATE_CLAMP_OVERHEAD_PAD;
+        debugLogger22.debug(
+          `[clamp] estimate-derived prompt count; padded by ${ESTIMATE_CLAMP_OVERHEAD_PAD}: promptTokensForClamp=${promptTokensForClamp}, count=${this.lastPromptTokenCount}`
+        );
+      }
       const clampedMaxOutputTokens = clampOutputTokensToWindow(
         outputCeiling,
         contextWindowForClamp,
@@ -38414,7 +38274,11 @@ var GeminiChat = class {
               params,
               prompt_id,
               requestOverrides,
-              turnGoalContext
+              turnGoalContext,
+              // Captured by value, so the attempt records exactly the prefix
+              // `buildAttemptContents()` just asked the model to resume from,
+              // even if a later branch resets the continuation.
+              transportContinuationPrefix.length > 0 ? transportContinuationPrefix : void 0
             );
             lastFinishReason = void 0;
             for await (const chunk of stream2) {
@@ -38435,10 +38299,7 @@ var GeminiChat = class {
               yield { type: "chunk" /* CHUNK */, value: chunk };
             }
             lastError = null;
-            if (transportContinuationPrefix.length > 0) {
-              self2.prependTextToLastModelTurn(transportContinuationPrefix);
-              transportContinuationPrefix = "";
-            }
+            transportContinuationPrefix = "";
             break;
           } catch (error) {
             lastError = error;
@@ -38846,7 +38707,7 @@ var GeminiChat = class {
             const walkRecoveryEstimate = estimateContentTokens(
               recoveryContents,
               recoveryImageTokenEstimate
-            ) + FIRST_SEND_CLAMP_OVERHEAD_PAD;
+            ) + ESTIMATE_CLAMP_OVERHEAD_PAD;
             const recoveryPromptEstimate = Math.max(
               countBasedRecoveryEstimate,
               walkRecoveryEstimate
@@ -39093,7 +38954,7 @@ var GeminiChat = class {
    * by the fallback chain to call alternative models without duplicating
    * the retry wiring.
    */
-  async makeApiCallAndProcessStream(model, requestContents, params, prompt_id, overrides, goalContext) {
+  async makeApiCallAndProcessStream(model, requestContents, params, prompt_id, overrides, goalContext, transportContinuationPrefix) {
     const generator = overrides?.contentGenerator ?? this.config.getContentGenerator();
     const apiCall = /* @__PURE__ */ __name(() => generator.generateContentStream(
       {
@@ -39150,7 +39011,12 @@ var GeminiChat = class {
         );
       }, "onRetry")
     });
-    return this.processStreamResponse(model, streamResponse, goalContext);
+    return this.processStreamResponse(
+      model,
+      streamResponse,
+      goalContext,
+      transportContinuationPrefix
+    );
   }
   async *makeFallbackStream(model, requestContents, params, prompt_id, contentGenerator, retryAuthType, retryErrorCodes, goalContext) {
     const stream2 = await this.makeApiCallAndProcessStream(
@@ -39471,7 +39337,15 @@ This error was probably caused by cyclic schema references in one of the followi
       }
     }
   }
-  async *processStreamResponse(model, streamResponse, goalContext) {
+  /**
+   * @param transportContinuationPrefix - Text a previous attempt already
+   *   delivered before a socket cut, which this attempt was asked to resume
+   *   from (issue #7832). On success it is folded into the response parts
+   *   before either durable write, so the JSONL transcript and in-memory
+   *   history carry the same merged turn (issue #8094). Undefined on every
+   *   non-continuation send.
+   */
+  async *processStreamResponse(model, streamResponse, goalContext, transportContinuationPrefix) {
     const allModelParts = [];
     const usedToolCallIds = collectToolCallIdsFromHistory(this.history);
     const rawToolCallIdsInCurrentTurn = /* @__PURE__ */ new Set();
@@ -39619,6 +39493,7 @@ This error was probably caused by cyclic schema references in one of the followi
           const lastPromptTokenCount = hasUsablePromptTokenCount ? promptTokenCount : totalTokenCount;
           if (lastPromptTokenCount) {
             this.lastPromptTokenCount = lastPromptTokenCount;
+            this.lastPromptTokenCountIsEstimated = false;
             this.lastOutputTokenCount = hasUsablePromptTokenCount ? getUsageOutputTokenCountForPromptEstimate({
               promptTokenCount,
               ...hasUsableTotalTokenCount ? { totalTokenCount } : {},
@@ -39768,6 +39643,22 @@ This error was probably caused by cyclic schema references in one of the followi
       yield recoveredChunk;
     }
     const willPersistToHistory = streamError === null || hasToolCall && (thoughtContentPart || consolidatedHistoryParts.length > 0);
+    if (streamError === null && transportContinuationPrefix) {
+      const textIndex = consolidatedHistoryParts.findIndex(isPlainTextPart);
+      if (textIndex < 0) {
+        consolidatedHistoryParts.unshift({ text: transportContinuationPrefix });
+      } else {
+        const remainderPart = consolidatedHistoryParts[textIndex];
+        consolidatedHistoryParts[textIndex] = {
+          ...remainderPart,
+          text: mergeDeliveredPrefix(
+            transportContinuationPrefix,
+            remainderPart.text
+          )
+        };
+      }
+      contentText = consolidatedHistoryParts.filter((part) => part.text).map((part) => part.text).join("").trim();
+    }
     if (willPersistToHistory && (thoughtContentPart || contentText || hasToolCall || usageMetadata)) {
       const contextWindowSize = this.config.getContentGeneratorConfig()?.contextWindowSize;
       const recordArgs = {
@@ -39819,49 +39710,6 @@ This error was probably caused by cyclic schema references in one of the followi
       };
     }
   }
-  /**
-   * Prepend already-delivered text to the trailing model turn.
-   *
-   * Used by the transport-continuation path (issue #7832): after a socket cut
-   * mid-response, the caller has seen text that `processStreamResponse`
-   * deliberately did not persist, and the continuation attempt's own turn
-   * carries only the resumed remainder. Without this, durable history would
-   * hold an answer that starts mid-sentence — visibly wrong on `/compress`,
-   * `--resume`, and every later turn's context.
-   *
-   * The delivered text is merged into the turn's first plain-text part (kept
-   * after any leading thought part, matching the
-   * `[thoughtPart?, ...text]` shape `processStreamResponse` produces), or
-   * inserted as a new part when the continuation returned no text of its own.
-   * Overlap is deduped by the same helper the output-recovery merge uses, so a
-   * model that replays part of its previous tail does not double it.
-   */
-  prependTextToLastModelTurn(deliveredText) {
-    if (deliveredText.length === 0) return;
-    const lastEntry = this.history.at(-1);
-    if (lastEntry?.role !== "model") {
-      debugLogger22.warn(
-        "[TRANSPORT_CONTINUATION] Trailing entry is not a model turn; dropping the delivered-text merge.",
-        { role: lastEntry?.role ?? "undefined" }
-      );
-      return;
-    }
-    const parts = [...lastEntry.parts ?? []];
-    const textIndex = parts.findIndex(isPlainTextPart);
-    if (textIndex < 0) {
-      const insertAt = parts.findIndex((part) => !part.thought);
-      parts.splice(insertAt < 0 ? parts.length : insertAt, 0, {
-        text: deliveredText
-      });
-    } else {
-      const continuationPart = parts[textIndex];
-      parts[textIndex] = {
-        ...continuationPart,
-        text: deliveredText + getRecoveryContinuationSuffix(deliveredText, continuationPart.text)
-      };
-    }
-    lastEntry.parts = parts;
-  }
   /**
    * Merge `pairCount` trailing (user_recovery, model_continuation) pairs back
    * into the model turn that precedes them. Used after the output-token
@@ -39933,6 +39781,19 @@ function canonicalizeForHash(value) {
   return value;
 }
 __name(canonicalizeForHash, "canonicalizeForHash");
+function getToolCallRepeatKey(toolName, args) {
+  const argsString = JSON.stringify(canonicalizeForHash(args));
+  const keyString = `${canonicalToolName(toolName)}:${argsString}`;
+  return createHash5("sha256").update(keyString).digest("hex");
+}
+__name(getToolCallRepeatKey, "getToolCallRepeatKey");
+function shouldHaltOnTurnToolCallCap(totalCalls, maxKeyRepeat, cap, isExplicitCap) {
+  if (totalCalls <= cap) return false;
+  const hardCap = cap * ADAPTIVE_CAP_HARD_MULTIPLIER;
+  const stuck = maxKeyRepeat >= GLOBAL_DUPLICATE_THRESHOLD;
+  return isExplicitCap || totalCalls > hardCap || stuck;
+}
+__name(shouldHaltOnTurnToolCallCap, "shouldHaltOnTurnToolCallCap");
 var LoopDetectionService = class _LoopDetectionService {
   static {
     __name(this, "LoopDetectionService");
@@ -40024,9 +39885,7 @@ var LoopDetectionService = class _LoopDetectionService {
     );
   }
   getToolCallKey(toolCall) {
-    const argsString = JSON.stringify(canonicalizeForHash(toolCall.args));
-    const keyString = `${toolCall.name}:${argsString}`;
-    return createHash5("sha256").update(keyString).digest("hex");
+    return getToolCallRepeatKey(toolCall.name, toolCall.args);
   }
   /**
    * Convenience aggregate that runs every tier in order: the always-on
@@ -40486,22 +40345,20 @@ var LoopDetectionService = class _LoopDetectionService {
    */
   checkTurnToolCallCap() {
     this.turnToolCallTotal++;
-    const cap = this.config.getMaxToolCallsPerTurn();
-    if (this.turnToolCallTotal <= cap) {
+    if (!shouldHaltOnTurnToolCallCap(
+      this.turnToolCallTotal,
+      this.capMaxKeyRepeat,
+      this.config.getMaxToolCallsPerTurn(),
+      this.config.isMaxToolCallsPerTurnExplicit()
+    )) {
       return false;
     }
-    const explicitHardCap = this.config.isMaxToolCallsPerTurnExplicit();
-    const hardCap = cap * ADAPTIVE_CAP_HARD_MULTIPLIER;
-    const stuck = this.capMaxKeyRepeat >= GLOBAL_DUPLICATE_THRESHOLD;
-    if (explicitHardCap || this.turnToolCallTotal > hardCap || stuck) {
-      this.lastLoopType = "turn_tool_call_cap" /* TURN_TOOL_CALL_CAP */;
-      logLoopDetected(
-        this.config,
-        new LoopDetectedEvent("turn_tool_call_cap" /* TURN_TOOL_CALL_CAP */, this.promptId)
-      );
-      return true;
-    }
-    return false;
+    this.lastLoopType = "turn_tool_call_cap" /* TURN_TOOL_CALL_CAP */;
+    logLoopDetected(
+      this.config,
+      new LoopDetectedEvent("turn_tool_call_cap" /* TURN_TOOL_CALL_CAP */, this.promptId)
+    );
+    return true;
   }
   /**
    * Non-consecutive global duplicate detection: the SAME (tool, args) pair
@@ -41777,14 +41634,14 @@ function resolveToolName(rawName) {
   return TOOL_NAME_ALIASES[rawName] ?? rawName;
 }
 __name(resolveToolName, "resolveToolName");
-function getSpecifierKind(canonicalToolName3) {
-  if (SHELL_TOOL_NAMES.has(canonicalToolName3)) {
+function getSpecifierKind(canonicalToolName2) {
+  if (SHELL_TOOL_NAMES.has(canonicalToolName2)) {
     return "command";
   }
-  if (READ_TOOLS.has(canonicalToolName3) || EDIT_TOOLS.has(canonicalToolName3)) {
+  if (READ_TOOLS.has(canonicalToolName2) || EDIT_TOOLS.has(canonicalToolName2)) {
     return "path";
   }
-  if (WEBFETCH_TOOLS.has(canonicalToolName3)) {
+  if (WEBFETCH_TOOLS.has(canonicalToolName2)) {
     return "domain";
   }
   return "literal";
@@ -41911,8 +41768,8 @@ var CANONICAL_TO_RULE_DISPLAY = {
   exit_plan_mode: "ExitPlanMode",
   enter_plan_mode: "EnterPlanMode"
 };
-function getRuleDisplayName(canonicalToolName3) {
-  return CANONICAL_TO_RULE_DISPLAY[canonicalToolName3] ?? canonicalToolName3;
+function getRuleDisplayName(canonicalToolName2) {
+  return CANONICAL_TO_RULE_DISPLAY[canonicalToolName2] ?? canonicalToolName2;
 }
 __name(getRuleDisplayName, "getRuleDisplayName");
 var FILE_TARGETED_TOOLS = /* @__PURE__ */ new Set([
@@ -61574,6 +61431,39 @@ function sigtermPids(pids) {
 }
 __name(sigtermPids, "sigtermPids");
 
+// packages/core/src/tools/mcp-session-config.ts
+init_esbuild_shims();
+function normalizeMcpIncludeEntry(entry) {
+  const paren = entry.indexOf("(");
+  return paren === -1 ? entry : entry.slice(0, paren);
+}
+__name(normalizeMcpIncludeEntry, "normalizeMcpIncludeEntry");
+function coerceMcpFilterEntries(entries) {
+  return (Array.isArray(entries) ? entries : []).filter(
+    (entry) => typeof entry === "string"
+  );
+}
+__name(coerceMcpFilterEntries, "coerceMcpFilterEntries");
+function normalizeFilter(entries, stripParenthesizedSuffix) {
+  const normalized2 = coerceMcpFilterEntries(entries).map(
+    (entry) => stripParenthesizedSuffix ? normalizeMcpIncludeEntry(entry) : entry
+  );
+  return [...new Set(normalized2)].sort();
+}
+__name(normalizeFilter, "normalizeFilter");
+function mcpSessionMetadataKey(config) {
+  return JSON.stringify({
+    trust: config.trust ?? null,
+    alwaysLoadTools: config.alwaysLoadTools === true,
+    // An absent allowlist accepts every name, while an explicit empty
+    // allowlist accepts none. JSON `null` is treated as absent because
+    // every runtime filter treats a falsy include list as "allow all".
+    includeTools: config.includeTools == null ? null : normalizeFilter(config.includeTools, true),
+    excludeTools: normalizeFilter(config.excludeTools, false)
+  });
+}
+__name(mcpSessionMetadataKey, "mcpSessionMetadataKey");
+
 // packages/core/src/tools/mcp-client-manager.ts
 var debugLogger40 = createDebugLogger("MCP");
 var RUNTIME_MCP_IF_ABSENT_CONFIG_FLAG = "__qwenRuntimeMcpIfAbsent";
@@ -61680,13 +61570,13 @@ var McpClientManager = class _McpClientManager {
    * Per connected server, the single-session "connected config key" of the
    * config it was last connected with — see {@link singleSessionConnectedKeyOf}.
    * Single-session path only; pool mode tracks transport identity via
-   * `pooledConnections[].id` and its own `desiredIds` diff.
+   * `pooledConnections[].transportId` and its own `desiredIds` diff.
    * Lets `discoverAllMcpToolsIncremental` detect an in-place config change to an
    * already-connected server and reconnect it, instead of leaving it on the
    * stale config. Unlike the transport-only `connectionIdOf`, this key also
-   * covers the discovery-time filters (trust / includeTools / excludeTools) so
-   * editing those re-applies them. Set on successful connect; cleared on every
-   * teardown path so a stale key can't mask a later change.
+   * covers the discovery-time metadata (trust / alwaysLoadTools / includeTools /
+   * excludeTools) so editing those re-applies it. Set on successful connect;
+   * cleared on every teardown path so a stale key can't mask a later change.
    */
   connectedConfigKeys = /* @__PURE__ */ new Map();
   /**
@@ -62445,7 +62335,7 @@ var McpClientManager = class _McpClientManager {
       }
       for (const [name, conn] of [...this.pooledConnections]) {
         const desired = desiredIds.get(name);
-        if (desired === void 0 || desired !== conn.id) {
+        if (desired === void 0 || desired !== conn.transportId) {
           try {
             conn.release();
           } catch (err) {
@@ -62474,7 +62364,17 @@ var McpClientManager = class _McpClientManager {
             await this.discoverMcpToolsForServer(name, cliConfig);
             return;
           }
-          if (this.pooledConnections.has(name)) return;
+          const existingConnection = this.pooledConnections.get(name);
+          if (existingConnection) {
+            try {
+              existingConnection.updateConfig(config);
+            } catch (err) {
+              debugLogger40.error(
+                `Pool metadata refresh failed for ${name}: ${getErrorMessage(err)}`
+              );
+            }
+            return;
+          }
           try {
             const conn = await this.pool.acquire(
               name,
@@ -62982,18 +62882,11 @@ var McpClientManager = class _McpClientManager {
    * intentionally transport-only (it excludes the per-session discovery filters
    * so the shared pool can reuse a transport across sessions with different
    * filters). But the single-session reconcile must ALSO reconnect when only a
-   * discovery filter changes — `trust`, `includeTools`, `excludeTools` are
-   * applied during `discover()` and baked into the registered tools, so a
-   * config edit to them otherwise never takes effect mid-session. Append a
-   * stable hash of those fields (arrays sorted so order alone doesn't churn).
+   * discovery metadata changes. Append the same canonical metadata identity
+   * used by pooled session views so equivalent filters do not reconnect.
    */
   singleSessionConnectedKeyOf(serverName, config) {
-    const discovery = JSON.stringify({
-      trust: config.trust ?? null,
-      includeTools: [...config.includeTools ?? []].sort(),
-      excludeTools: [...config.excludeTools ?? []].sort()
-    });
-    return `${connectionIdOf(serverName, config)}|${discovery}`;
+    return `${connectionIdOf(serverName, config)}|${mcpSessionMetadataKey(config)}`;
   }
   /**
    * Purge a server's entries from all three registries (tools + prompts +
@@ -63180,9 +63073,10 @@ var McpClientManager = class _McpClientManager {
       }
     }
     const existingConn = this.pooledConnections.get(name);
-    if (existingConn && existingConn.id === newConnId) {
+    if (existingConn && existingConn.transportId === newConnId) {
+      existingConn.updateConfig(config);
       this.cliConfig.addRuntimeMcpServer(name, config);
-      const toolCount2 = existingConn.toolsSnapshot.length;
+      const toolCount2 = this.toolRegistry.getToolsByServer(name).length;
       return {
         name,
         transport,
@@ -64116,16 +64010,6 @@ var ToolRegistry = class _ToolRegistry {
   }
 };
 
-// packages/core/src/tools/mcp-transport-pool.ts
-init_esbuild_shims();
-
-// packages/core/src/tools/mcp-pool-entry.ts
-init_esbuild_shims();
-import { EventEmitter } from "node:events";
-
-// packages/core/src/tools/mcp-pool-events.ts
-init_esbuild_shims();
-
 // packages/core/src/tools/mcp-discovery-timeout.ts
 init_esbuild_shims();
 var MIN_DISCOVERY_TIMEOUT_MS = 100;
@@ -64168,6 +64052,16 @@ function runWithTimeout(task, timeoutMs, label) {
 }
 __name(runWithTimeout, "runWithTimeout");
 
+// packages/core/src/tools/mcp-transport-pool.ts
+init_esbuild_shims();
+
+// packages/core/src/tools/mcp-pool-entry.ts
+init_esbuild_shims();
+import { EventEmitter } from "node:events";
+
+// packages/core/src/tools/mcp-pool-events.ts
+init_esbuild_shims();
+
 // packages/core/src/tools/mcp-pool-entry.ts
 var debugLogger42 = createDebugLogger("McpPool:Entry");
 function defaultPoolEntryOptions(transport) {
@@ -64182,7 +64076,8 @@ function defaultPoolEntryOptions(transport) {
 __name(defaultPoolEntryOptions, "defaultPoolEntryOptions");
 var PoolEntry = class {
   /**
-   * @param id Stable ConnectionId (`name::fingerprint`).
+   * @param id Lifecycle identity. Pooled entries use `name::fingerprint`;
+   *   unpooled entries use a unique `name::unpooled-N` value.
    * @param serverName Server name as advertised in `MCPServerConfig`.
    * @param entryIndex Opaque, monotonic-within-name-group index for
    *   status-route exposure. Stable across reconnect / drain
@@ -64211,6 +64106,7 @@ var PoolEntry = class {
     this.opts = opts;
     this.onClosed = onClosed;
     this.aggregateStatusByName = aggregateStatusByName;
+    this.transportId = connectionIdOf(serverName, cfg);
     this.emitter.setMaxListeners(0);
     this.statusChangeListener = (name, status) => {
       if (name !== this.serverName) return;
@@ -64323,6 +64219,8 @@ var PoolEntry = class {
    * us. Skip those echoes (we already know our localStatus).
    */
   suppressNextStatusEcho = false;
+  /** Transport identity captured at spawn, separate from unpooled lifecycle id. */
+  transportId;
   get generation() {
     return this._generation;
   }
@@ -64423,6 +64321,30 @@ var PoolEntry = class {
     this.subscriberHandles.set(sessionId, handle);
     return handle;
   }
+  /**
+   * Refresh one attached session's metadata without reconnecting the shared
+   * transport. The view owns filtering and per-session tool decoration; the
+   * entry remains the single source of truth for discovery snapshots.
+   */
+  updateSessionConfig(sessionId, cfg) {
+    if (this.isTerminated()) {
+      throw new Error(
+        `Cannot update config on PoolEntry ${this.id} in state ${this.state}`
+      );
+    }
+    const view = this.subscribers.get(sessionId);
+    if (!view) {
+      throw new Error(
+        `Cannot update config for detached session ${sessionId} on PoolEntry ${this.id}`
+      );
+    }
+    if (!view.updateConfig(cfg)) return;
+    if (this.state === "active") {
+      view.applyTools(this.toolsSnapshot);
+      view.applyPrompts(this.promptsSnapshot);
+      view.applyResources(this.resourcesSnapshot);
+    }
+  }
   /**
    * Detach a session subscriber. Tears down the subscriber's
    * registrations via `view.teardown()` and removes the ref.
@@ -64780,6 +64702,9 @@ var PooledConnectionImpl = class {
   get id() {
     return this.entry.id;
   }
+  get transportId() {
+    return this.entry.transportId;
+  }
   get serverName() {
     return this.entry.serverName;
   }
@@ -64798,6 +64723,14 @@ var PooledConnectionImpl = class {
   get resourcesSnapshot() {
     return this.entry.resourcesSnapshot;
   }
+  updateConfig(cfg) {
+    if (this.released) {
+      throw new Error(
+        `Cannot update config on released MCP connection ${this.id}`
+      );
+    }
+    this.entry.updateSessionConfig(this.sessionId, cfg);
+  }
   on(event, listener) {
     if (event !== "event") return this;
     if (this.listeners.has(listener)) return this;
@@ -64827,11 +64760,9 @@ init_esbuild_shims();
 var debugLogger43 = createDebugLogger("McpPool:View");
 function compileNameFilter(includeTools, excludeTools) {
   return {
-    excludeSet: excludeTools ? new Set(excludeTools) : void 0,
-    includeSet: includeTools ? new Set(
-      includeTools.map(
-        (entry) => entry.includes("(") ? entry.slice(0, entry.indexOf("(")) : entry
-      )
+    excludeSet: excludeTools ? new Set(coerceMcpFilterEntries(excludeTools)) : void 0,
+    includeSet: includeTools != null ? new Set(
+      coerceMcpFilterEntries(includeTools).map(normalizeMcpIncludeEntry)
     ) : void 0
   };
 }
@@ -64846,16 +64777,18 @@ var SessionMcpView = class {
   /**
    * @param sessionToolRegistry The session-owned ToolRegistry; receives
    *   filtered + trust-decorated `DiscoveredMCPTool` instances.
-   * @param sessionPromptRegistry The session-owned PromptRegistry;
-   *   receives the unfiltered prompt snapshot (prompts have no
-   *   per-session filter today — pool fans out the full set).
+   * @param sessionPromptRegistry The session-owned PromptRegistry; receives
+   *   prompts selected by the same name filter as tools.
+   * @param sessionResourceRegistry The session-owned ResourceRegistry;
+   *   receives the full resource snapshot because tool-name filters do not
+   *   apply to resource URIs.
    * @param sessionId Stamped onto debug logs for cross-session
    *   correlation; not used for routing (pool's reverse index handles that).
    * @param serverName Server name as advertised in the per-session
    *   merged mcpServers map; used as the key into the registries'
    *   `removeMcpToolsByServer` / `removePromptsByServer` cleanup paths.
    * @param cfg The session's view of this server's config, source of
-   *   `includeTools` / `excludeTools` / `trust`.
+   *   `includeTools` / `excludeTools` / `trust` / `alwaysLoadTools`.
    */
   constructor(sessionToolRegistry, sessionPromptRegistry, sessionResourceRegistry, sessionId, serverName, cfg) {
     this.sessionToolRegistry = sessionToolRegistry;
@@ -64864,10 +64797,12 @@ var SessionMcpView = class {
     this.sessionId = sessionId;
     this.serverName = serverName;
     this.cfg = cfg;
+    this.metadataKey = mcpSessionMetadataKey(cfg);
   }
   static {
     __name(this, "SessionMcpView");
   }
+  metadataKey;
   /**
    * Replace this session's registered tools for `serverName` with a
    * filtered+decorated copy of `snapshot`. Idempotent: re-apply on
@@ -64885,7 +64820,10 @@ var SessionMcpView = class {
       if (!compiledFilterAccepts(filter3, tool.serverToolName)) {
         continue;
       }
-      const sessionTool = tool.withTrust(this.cfg.trust);
+      const sessionTool = tool.withSessionConfig(
+        this.cfg.trust,
+        this.cfg.alwaysLoadTools === true
+      );
       try {
         this.sessionToolRegistry.registerTool(sessionTool);
         registered += 1;
@@ -64994,14 +64932,17 @@ var SessionMcpView = class {
    * `/mcp` tweaks `includeTools` at runtime). Re-apply uses the new
    * filter against the most recent snapshot.
    *
-   * The caller (typically the `PoolEntry.attach` path or
-   * `pool.notifyConfigChanged`) is responsible for invoking
-   * `applyTools` / `applyPrompts` with the current snapshot after
-   * this update — `SessionMcpView` doesn't cache snapshots itself
-   * (single-source-of-truth is the pool entry).
+   * The caller is responsible for invoking `applyTools` / `applyPrompts` /
+   * `applyResources` with the current snapshots when this method returns true.
+   * The captured key also detects callers that mutate and resubmit the same
+   * config object.
    */
   updateConfig(cfg) {
+    const nextKey = mcpSessionMetadataKey(cfg);
+    const changed = this.metadataKey !== nextKey;
     this.cfg = cfg;
+    this.metadataKey = nextKey;
+    return changed;
   }
   /**
    * Tear down this view's registrations. Called on:
@@ -74808,6 +74749,16 @@ async function checkPriorRead(cache, filePath, verb, options2 = {}) {
       displayMessage: `file changed since last read; re-run ${ToolNames.READ_FILE} first.`
     };
   }
+  if (status.state === "unverifiable") {
+    const verbBare2 = verb === "editing" ? "edit" : "overwrite";
+    const raw2 = `File ${filePath} is on a filesystem that does not provide a verifiable inode identity (ino=0), so the ${verbBare2} tool cannot safely confirm a prior read. Use a different mechanism (for example, the shell tool) to ${verbBare2} this file.`;
+    return {
+      ok: false,
+      type: "prior_read_verification_failed" /* PRIOR_READ_VERIFICATION_FAILED */,
+      rawMessage: raw2,
+      displayMessage: `cannot verify prior read of ${filePath}; use a different mechanism to ${verbBare2} it.`
+    };
+  }
   if (status.state === "fresh" && status.entry.lastReadAt !== void 0 && !status.entry.lastReadCacheable) {
     const verbBare2 = verb === "editing" ? "edit" : "overwrite";
     const raw2 = `File ${filePath} is a binary / image / audio / video / PDF / notebook payload that the ${ToolNames.READ_FILE} tool returns as a structured value rather than as plain text. The Edit / WriteFile tools cannot mutate that payload safely \u2014 re-reading it would not change this. If this is a Jupyter notebook (.ipynb), use the ${ToolNames.NOTEBOOK_EDIT} tool for cell-level edits after reading it. For other non-text files, use a different mechanism (e.g. shell tool with an appropriate writer) if you need to ${verbBare2} it.`;
@@ -75802,7 +75753,7 @@ var TOKEN_PLAN_MODELS = [
     enableThinking: true
   },
   { id: "deepseek-v4-pro", contextWindowSize: 1e6 },
-  { id: "deepseek-v4-flash", contextWindowSize: 1e6 },
+  { id: "deepseek-v4-flash-0731", contextWindowSize: 1e6 },
   { id: "deepseek-v3.2", contextWindowSize: 131072 },
   {
     id: "kimi-k2.7-code",
@@ -76755,6 +76706,10 @@ var FileReadCache = class _FileReadCache {
   static inodeKey(stats) {
     return `${stats.dev}:${stats.ino}`;
   }
+  /** See {@link hasVerifiableInode}. */
+  static hasVerifiableIdentity(stats) {
+    return hasVerifiableInode(stats.ino);
+  }
   /**
    * Record a successful Read of `absPath`.
    *
@@ -76793,8 +76748,21 @@ var FileReadCache = class _FileReadCache {
    * The fast-path `file_unchanged` check still gates on the
    * incoming request's own `isFullRead` (in `read-file.ts`), so a
    * partial read does not get a placeholder it shouldn't.
+   *
+   * When `stats.ino` is `0` the read is not stored and the returned
+   * entry is **detached**: it describes this read for the immediate
+   * caller, but it is not in the map, so mutating it has no effect
+   * and a later {@link check} still reports `unverifiable`.
    */
   recordRead(absPath, stats, opts) {
+    if (!_FileReadCache.hasVerifiableIdentity(stats)) {
+      const entry2 = _FileReadCache.createEntry(absPath, stats);
+      entry2.lastReadAt = Date.now();
+      entry2.readResidentInHistory = opts.full;
+      entry2.lastReadWasFull = opts.full;
+      entry2.lastReadCacheable = opts.cacheable;
+      return entry2;
+    }
     const key = _FileReadCache.inodeKey(stats);
     const existing = this.byInode.get(key);
     const sameFingerprint = existing !== void 0 && existing.mtimeMs === stats.mtimeMs && existing.sizeBytes === stats.size;
@@ -76830,9 +76798,12 @@ var FileReadCache = class _FileReadCache {
    * the default `cacheable: true`; structured writers such as notebook cell
    * editors can set `cacheable: false` so regular Edit / WriteFile still
    * reject the file as a non-text payload.
+   *
+   * As with {@link recordRead}, an `ino === 0` write returns a
+   * **detached** entry that was never added to the map.
    */
   recordWrite(absPath, stats, opts = {}) {
-    const entry = this.upsert(absPath, stats);
+    const entry = _FileReadCache.hasVerifiableIdentity(stats) ? this.upsert(absPath, stats) : _FileReadCache.createEntry(absPath, stats);
     const now = Date.now();
     entry.lastWriteAt = now;
     entry.lastReadAt = now;
@@ -76844,6 +76815,8 @@ var FileReadCache = class _FileReadCache {
   /**
    * Compare the cached fingerprint against `stats` for the same inode.
    *
+   *  - `unverifiable` — the filesystem reported `ino === 0`, so the
+   *    file identity cannot be safely compared or cached.
    *  - `unknown` — no entry. The file has never been Read or written in
    *    this session.
    *  - `stale`   — entry exists but mtime or size differs. The file has
@@ -76858,6 +76831,9 @@ var FileReadCache = class _FileReadCache {
    * `0 occurrences` failure mode, which prompts the model to re-read.
    */
   check(stats) {
+    if (!_FileReadCache.hasVerifiableIdentity(stats)) {
+      return { state: "unverifiable" };
+    }
     const entry = this.byInode.get(_FileReadCache.inodeKey(stats));
     if (!entry) return { state: "unknown" };
     if (entry.mtimeMs !== stats.mtimeMs || entry.sizeBytes !== stats.size) {
@@ -76885,6 +76861,9 @@ var FileReadCache = class _FileReadCache {
    * fall back to {@link clear}.
    */
   markReadEvictedFromHistory(stats) {
+    if (!_FileReadCache.hasVerifiableIdentity(stats)) {
+      return false;
+    }
     const entry = this.byInode.get(_FileReadCache.inodeKey(stats));
     if (entry) {
       entry.readResidentInHistory = false;
@@ -76894,6 +76873,9 @@ var FileReadCache = class _FileReadCache {
   }
   /** Remove the entry for the given Stats, if any. */
   invalidate(stats) {
+    if (!_FileReadCache.hasVerifiableIdentity(stats)) {
+      return;
+    }
     this.byInode.delete(_FileReadCache.inodeKey(stats));
   }
   /**
@@ -76966,8 +76948,13 @@ var FileReadCache = class _FileReadCache {
         this.byInode.delete(oldestKey);
       }
     }
-    const entry = {
-      inodeKey: key,
+    const entry = _FileReadCache.createEntry(absPath, stats);
+    this.byInode.set(key, entry);
+    return entry;
+  }
+  static createEntry(absPath, stats) {
+    return {
+      inodeKey: _FileReadCache.inodeKey(stats),
       realPath: absPath,
       mtimeMs: stats.mtimeMs,
       sizeBytes: stats.size,
@@ -76975,8 +76962,6 @@ var FileReadCache = class _FileReadCache {
       lastReadCacheable: false,
       readResidentInHistory: false
     };
-    this.byInode.set(key, entry);
-    return entry;
   }
 };
 
@@ -77806,8 +77791,8 @@ var GitWorktreeService = class _GitWorktreeService {
   async getRegisteredWorktreeBranch(worktreePath) {
     let resolvedWorktreePath;
     try {
-      const stat21 = await fs29.stat(worktreePath);
-      if (!stat21.isDirectory()) return null;
+      const stat22 = await fs29.stat(worktreePath);
+      if (!stat22.isDirectory()) return null;
       resolvedWorktreePath = await fs29.realpath(worktreePath);
     } catch {
       return null;
@@ -78847,7 +78832,7 @@ ${body}`;
     const out = [];
     for (const rec of records) {
       if (rec.type === "user") {
-        const text = this.visibleText(rec.message);
+        const text = this.visibleUserText(rec);
         if (text) out.push(`User: ${text}`);
       } else if (rec.type === "assistant") {
         const text = this.visibleText(rec.message);
@@ -78862,8 +78847,17 @@ ${body}`;
     return out;
   }
   visibleText(message) {
-    if (!message?.parts) return "";
-    return message.parts.filter((p2) => !p2.thought && p2.text).map((p2) => p2.text).join("").trim();
+    return this.visibleTextParts(message?.parts ?? []);
+  }
+  visibleUserText(record2) {
+    const projection = projectUserTranscriptForDisplay(record2);
+    if (projection.displayText !== void 0) {
+      return projection.displayText.trim();
+    }
+    return this.visibleTextParts(projection.parts);
+  }
+  visibleTextParts(parts) {
+    return parts.filter((p2) => !p2.thought && p2.text).map((p2) => p2.text).join("").trim();
   }
   static TITLE_MAX_LENGTH = 80;
   deriveTitle(records) {
@@ -78877,7 +78871,7 @@ ${body}`;
     if (customTitle) return customTitle;
     for (const rec of records) {
       if (rec.type !== "user") continue;
-      const text = this.visibleText(rec.message);
+      const text = this.visibleUserText(rec);
       if (!text) continue;
       const firstLine = text.split("\n")[0].trim();
       if (firstLine.length === 0) continue;
@@ -79186,8 +79180,8 @@ async function restoreWorktreeContext(sidecarPath, onWarn) {
   }
   let worktreeAlive = false;
   try {
-    const stat21 = await fs30.stat(session.worktreePath);
-    worktreeAlive = stat21.isDirectory();
+    const stat22 = await fs30.stat(session.worktreePath);
+    worktreeAlive = stat22.isDirectory();
   } catch {
     worktreeAlive = false;
   }
@@ -79896,6 +79890,10 @@ function applyUtf8Prefix(command, shell) {
   }
 }
 __name(applyUtf8Prefix, "applyUtf8Prefix");
+function isSignalTermination(signal) {
+  return signal !== null && signal !== 0;
+}
+__name(isSignalTermination, "isSignalTermination");
 function createPreSpawnAbortedHandle() {
   return {
     pid: void 0,
@@ -80928,7 +80926,7 @@ var ShellExecutionService = class _ShellExecutionService {
                   rawOutput: finalBuffer,
                   output: fullOutput,
                   exitCode,
-                  signal: signal ?? null,
+                  signal: signal === 0 ? null : signal ?? null,
                   error,
                   aborted: abortSignal.aborted,
                   pid: ptyProcess.pid,
@@ -81068,7 +81066,7 @@ var ShellExecutionService = class _ShellExecutionService {
                 }) => {
                   firePostSettle({
                     exitCode,
-                    signal: signal ?? null,
+                    signal: signal === 0 ? null : signal ?? null,
                     endTime: Date.now()
                   });
                 }
@@ -82088,10 +82086,10 @@ function readOutputTail(outputFile) {
   let fd;
   try {
     fd = fs32.openSync(outputFile, getReadOutputOpenFlags());
-    const stat21 = fs32.fstatSync(fd);
-    if (!stat21.isFile() || stat21.size <= 0) return void 0;
-    const length = Math.min(stat21.size, MAX_NOTIFICATION_OUTPUT_TAIL_BYTES);
-    const start = stat21.size - length;
+    const stat22 = fs32.fstatSync(fd);
+    if (!stat22.isFile() || stat22.size <= 0) return void 0;
+    const length = Math.min(stat22.size, MAX_NOTIFICATION_OUTPUT_TAIL_BYTES);
+    const start = stat22.size - length;
     const buffer = Buffer.allocUnsafe(length);
     const bytesRead = fs32.readSync(fd, buffer, 0, length, start);
     let sliceOffset = 0;
@@ -82460,6 +82458,14 @@ var BackgroundShellRegistry = class {
 init_esbuild_shims();
 var debugLogger61 = createDebugLogger("WORKFLOW_REGISTRY");
 var MAX_RETAINED_TERMINAL_WORKFLOWS = 10;
+function isActiveWorkflowStatus(status) {
+  return status === "running" || status === "pausing" || status === "paused";
+}
+__name(isActiveWorkflowStatus, "isActiveWorkflowStatus");
+function isTerminalWorkflowStatus(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+__name(isTerminalWorkflowStatus, "isTerminalWorkflowStatus");
 var MAX_PENDING_WORKFLOW_APPROVALS = 32;
 var MAX_WORKFLOW_APPROVAL_DISPLAY_CHARS = 64 * 1024;
 var WorkflowRunRegistry = class {
@@ -82573,7 +82579,7 @@ var WorkflowRunRegistry = class {
    */
   register(registration) {
     const existing = this.entries.get(registration.runId);
-    if (existing?.status === "running" || this.handles.has(registration.runId)) {
+    if (existing && isActiveWorkflowStatus(existing.status) || this.handles.has(registration.runId)) {
       throw new Error(`Workflow run ${registration.runId} is already active.`);
     }
     const entry = registration;
@@ -82611,10 +82617,34 @@ var WorkflowRunRegistry = class {
     return entry;
   }
   attachHandle(handle) {
-    if (this.entries.get(handle.runId)?.status === "running") {
+    const status = this.entries.get(handle.runId)?.status;
+    if (status && isActiveWorkflowStatus(status)) {
       this.handles.set(handle.runId, handle);
     }
   }
+  pause(runId) {
+    const entry = this.entries.get(runId);
+    const handle = this.handles.get(runId);
+    if (!entry?.isBackgrounded || entry.status !== "running" || !handle) {
+      return false;
+    }
+    return handle.pause();
+  }
+  resume(runId) {
+    const entry = this.entries.get(runId);
+    const handle = this.handles.get(runId);
+    if (!entry || entry.status !== "paused" || !handle) return false;
+    return handle.resume();
+  }
+  onDispatchStateChange(runId, state) {
+    const entry = this.entries.get(runId);
+    if (!entry || isTerminalWorkflowStatus(entry.status)) return;
+    if (state === "pausing" && entry.status !== "running") return;
+    if (state === "paused" && entry.status !== "pausing") return;
+    if (state === "running" && entry.status !== "paused") return;
+    entry.status = state;
+    this.emitStatusChange(entry);
+  }
   getHandle(runId) {
     return this.handles.get(runId);
   }
@@ -82710,9 +82740,9 @@ var WorkflowRunRegistry = class {
   }
   parkPendingApproval(runId, event) {
     const entry = this.entries.get(runId);
-    if (!entry || entry.status !== "running" || !this.approvalChangeCallback && !this.approvalRequestCallback) {
+    if (!entry || !isActiveWorkflowStatus(entry.status) || !this.approvalChangeCallback && !this.approvalRequestCallback) {
       debugLogger61.warn(
-        `Workflow approval rejected for ${runId}/${event.callId}: entry missing, not running, or no host channel`
+        `Workflow approval rejected for ${runId}/${event.callId}: entry missing, not active, or no host channel`
       );
       return "rejected";
     }
@@ -82793,7 +82823,7 @@ var WorkflowRunRegistry = class {
    */
   onPhaseStarted(runId, title) {
     const entry = this.entries.get(runId);
-    if (!entry || entry.status !== "running") return;
+    if (!entry || !isActiveWorkflowStatus(entry.status)) return;
     entry.currentPhase = title;
     const last = entry.phases[entry.phases.length - 1];
     if (last !== title) entry.phases.push(title);
@@ -82802,14 +82832,14 @@ var WorkflowRunRegistry = class {
   /** Cumulative dispatch counter — incremented before each `agent()` call resolves. */
   onAgentDispatched(runId) {
     const entry = this.entries.get(runId);
-    if (!entry || entry.status !== "running") return;
+    if (!entry || !isActiveWorkflowStatus(entry.status)) return;
     entry.agentsDispatched++;
     this.emitStatusChange(entry);
   }
   /** Cumulative completion counter — incremented after each `agent()` call settles. */
   onAgentCompleted(runId) {
     const entry = this.entries.get(runId);
-    if (!entry || entry.status !== "running") return;
+    if (!entry || entry.agentsCompleted >= entry.agentsDispatched) return;
     entry.agentsCompleted++;
     this.emitStatusChange(entry);
   }
@@ -82825,7 +82855,7 @@ var WorkflowRunRegistry = class {
    */
   onBudgetUpdated(runId, spent, total) {
     const entry = this.entries.get(runId);
-    if (!entry || entry.status !== "running") return;
+    if (!entry) return;
     const delta = spent - entry.tokensSpent;
     const totalChanged = entry.tokenBudgetTotal !== total;
     if (delta <= 0 && !totalChanged) return;
@@ -82855,14 +82885,15 @@ var WorkflowRunRegistry = class {
   setRecentLogs(runId, logs) {
     const entry = this.entries.get(runId);
     if (!entry) return;
-    if (entry.status !== "running" && entry.status !== "cancelled") return;
+    if (!isActiveWorkflowStatus(entry.status) && entry.status !== "cancelled")
+      return;
     const tail = logs.length > 100 ? logs.slice(-100) : Array.from(logs);
     entry.recentLogs = tail;
     this.emitStatusChange(entry);
   }
   complete(runId, result, endTime) {
     const entry = this.entries.get(runId);
-    if (!entry || entry.status !== "running") return;
+    if (!entry || !isActiveWorkflowStatus(entry.status)) return;
     this.rejectPendingApprovals(runId);
     entry.status = "completed";
     entry.endTime = endTime;
@@ -82875,7 +82906,7 @@ var WorkflowRunRegistry = class {
   }
   fail(runId, message, endTime) {
     const entry = this.entries.get(runId);
-    if (!entry || entry.status !== "running") return;
+    if (!entry || !isActiveWorkflowStatus(entry.status)) return;
     this.rejectPendingApprovals(runId);
     entry.status = "failed";
     entry.endTime = endTime;
@@ -82887,13 +82918,13 @@ var WorkflowRunRegistry = class {
     this.evictTerminal();
   }
   /**
-   * Mark a running entry as cancelled and abort its controller. No-op
+   * Mark an active entry as cancelled and abort its controller. No-op
    * if the entry has already settled — protects against an explicit
    * dialog cancel racing with the natural complete/fail path.
    */
   cancel(runId, endTime) {
     const entry = this.entries.get(runId);
-    if (!entry || entry.status !== "running") return;
+    if (!entry || !isActiveWorkflowStatus(entry.status)) return;
     this.rejectPendingApprovals(runId);
     entry.status = "cancelled";
     entry.endTime = endTime;
@@ -82909,21 +82940,33 @@ var WorkflowRunRegistry = class {
   get(runId) {
     return this.entries.get(runId);
   }
-  /** All entries (running + terminal, no filter). Iteration order = registration order. */
+  /** All entries (active + terminal, no filter). Iteration order = registration order. */
   list() {
     return Array.from(this.entries.values());
   }
   /**
-   * R7 (wenshao): true if any entry is still `'running'`. Mirrors the
-   * three sibling registries' `hasUnfinalizedTasks()` /
+   * R7 (wenshao): true if any entry is still actively executing.
+   * Mirrors the three sibling registries' `hasUnfinalizedTasks()` /
    * `hasRunningEntries()` / `getRunning().length > 0` so the unified
    * `hasBlockingBackgroundWork()` helper (the gate `/clear` and session-
    * resume both use to refuse a switch with live work) can count
    * workflow runs the same way.
+   *
+   * R12 (doudouOUC): `paused` deliberately does NOT count. A paused run
+   * has drained its dispatches and executes nothing, and its wall-clock
+   * watchdog is suspended — if it blocked the switch, a paused-and-
+   * forgotten run would block `/clear` and session switching forever
+   * with no backstop to release it. Mirrors the sibling
+   * `BackgroundTaskRegistry.hasRunningTasks()`, which also counts only
+   * `running` (a paused background agent does not block a switch).
+   * Session-switch teardown cancels paused runs via `abortAll()` before
+   * `reset()` so they settle terminal instead of leaking.
    */
   hasRunningEntries() {
     for (const entry of this.entries.values()) {
-      if (entry.status === "running") return true;
+      if (entry.status === "running" || entry.status === "pausing") {
+        return true;
+      }
     }
     return false;
   }
@@ -82931,7 +82974,7 @@ var WorkflowRunRegistry = class {
    * R7 (wenshao): drop every in-memory entry without touching
    * controllers. Mirrors `BackgroundShellRegistry.reset()` and the
    * other siblings' contract — callers (`/clear`, session-resume)
-   * MUST verify via `hasRunningEntries()` first that no still-running
+   * MUST verify via `hasRunningEntries()` first that no active
    * work exists before invoking. The companion path that aborts
    * controllers is `abortAll()`.
    */
@@ -82951,7 +82994,7 @@ var WorkflowRunRegistry = class {
     if (sample) this.emitStatusChange(sample);
   }
   /**
-   * R7 (wenshao): cancel every still-running entry. Called on session/
+   * R7 (wenshao): cancel every active entry. Called on session/
    * Config shutdown so workflow runs don't outlive the CLI process and
    * leak orphaned dispatches. Symmetric with `BackgroundShellRegistry.
    * abortAll()` and `BackgroundTaskRegistry.abortAll()`.
@@ -82959,13 +83002,13 @@ var WorkflowRunRegistry = class {
    * Settles each entry inline (status → 'cancelled', abort the
    * controller) and fires the status-change callback exactly once
    * after the loop — the per-entry `cancel()` path would have fired
-   * the callback for every running entry, wasteful on shutdown.
+   * the callback for every active entry, wasteful on shutdown.
    */
   abortAll() {
     const endTime = Date.now();
     let lastCancelled;
     for (const entry of Array.from(this.entries.values())) {
-      if (entry.status !== "running") continue;
+      if (!isActiveWorkflowStatus(entry.status)) continue;
       this.rejectPendingApprovals(entry.runId);
       entry.status = "cancelled";
       entry.endTime = endTime;
@@ -82985,11 +83028,13 @@ var WorkflowRunRegistry = class {
   }
   /**
    * Sweep terminal entries when they exceed `MAX_RETAINED_TERMINAL_WORKFLOWS`.
-   * Running entries are always retained. Oldest terminal entries
+   * Active entries are always retained. Oldest terminal entries
    * (by `endTime`) are evicted first.
    */
   evictTerminal() {
-    const terminal = this.list().filter((e) => e.status !== "running");
+    const terminal = this.list().filter(
+      (e) => isTerminalWorkflowStatus(e.status)
+    );
     if (terminal.length <= MAX_RETAINED_TERMINAL_WORKFLOWS) return;
     terminal.sort((a, b2) => (a.endTime ?? 0) - (b2.endTime ?? 0));
     const toEvict = terminal.slice(
@@ -83096,6 +83141,7 @@ function restrictWorkflowConfirmationDetails(details) {
         type: "info",
         title: details.title,
         prompt: details.prompt,
+        renderPromptAsPlainText: details.renderPromptAsPlainText,
         urls: details.urls ? [...details.urls] : void 0,
         hideAlwaysAllow: true
       };
@@ -83116,6 +83162,9 @@ import { promises as fs33 } from "node:fs";
 var debugLogger62 = createDebugLogger("WORKFLOW_SNAPSHOT");
 var MAX_RETAINED_SNAPSHOTS = 30;
 function toSnapshot(task) {
+  if (!isTerminalWorkflowStatus(task.status)) {
+    throw new Error(`Cannot snapshot active workflow ${task.runId}.`);
+  }
   return {
     runId: task.runId,
     meta: task.meta,
@@ -83150,9 +83199,9 @@ async function writeWorkflowSnapshot(config, task) {
   const storage = config.storage;
   if (!storage) return;
   try {
+    const snapshot = toSnapshot(task);
     const dir = storage.getWorkflowRunsDir();
     await fs33.mkdir(dir, { recursive: true });
-    const snapshot = toSnapshot(task);
     await fs33.writeFile(
       storage.getWorkflowRunSnapshotPath(task.runId),
       JSON.stringify(snapshot, null, 2),
@@ -85530,10 +85579,6 @@ var WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
   ToolNames.WRITE_FILE,
   ToolNames.EDIT
 ]);
-function canonicalToolName(toolName) {
-  return ToolNamesMigration[toolName] ?? toolName;
-}
-__name(canonicalToolName, "canonicalToolName");
 function candidateFilePath(args) {
   const value = args?.["file_path"] ?? args?.["path"] ?? args?.["target_file"];
   return typeof value === "string" && value.length > 0 ? value : void 0;
@@ -85577,6 +85622,19 @@ function didWriteManagedMemory(candidates, projectRoot) {
   );
 }
 __name(didWriteManagedMemory, "didWriteManagedMemory");
+function didWriteProjectContextFile(candidates, projectRoot) {
+  const contextFilePaths = new Set(
+    getAllGeminiMdFilenames().map((name) => name.trim()).filter((name) => name.length > 0).map((name) => path42.resolve(projectRoot, name))
+  );
+  return candidates.some((candidate) => {
+    if (!isSuccessfulWrite(candidate)) {
+      return false;
+    }
+    const filePath = candidateFilePath(candidate.args);
+    return filePath !== void 0 && contextFilePaths.has(resolveCandidatePath(filePath, projectRoot));
+  });
+}
+__name(didWriteProjectContextFile, "didWriteProjectContextFile");
 async function rebuildWrittenMemoryIndexes(candidates, projectRoot, options2) {
   let wroteProjectMemory = false;
   let wroteUserMemory = false;
@@ -86425,11 +86483,11 @@ var WorkspaceMemoryFileTooLargeError = class extends Error {
 async function composeAppendedContent(filePath, newContent) {
   let existing = "";
   try {
-    const stat21 = await fs41.stat(filePath);
-    if (stat21.size > MAX_EXISTING_FILE_BYTES) {
+    const stat22 = await fs41.stat(filePath);
+    if (stat22.size > MAX_EXISTING_FILE_BYTES) {
       throw new WorkspaceMemoryFileTooLargeError(
         filePath,
-        stat21.size,
+        stat22.size,
         MAX_EXISTING_FILE_BYTES
       );
     }
@@ -87471,13 +87529,13 @@ var IdeClient = class _IdeClient {
       lockFiles.map(async (file) => {
         const fullPath = path47.join(ideDir, file);
         try {
-          const stat21 = await fs42.promises.stat(fullPath);
+          const stat22 = await fs42.promises.stat(fullPath);
           const content = await fs42.promises.readFile(fullPath, "utf8");
           try {
             return {
               file,
               fullPath,
-              mtimeMs: stat21.mtimeMs,
+              mtimeMs: stat22.mtimeMs,
               parsed: JSON.parse(content)
             };
           } catch (error) {
@@ -89017,7 +89075,7 @@ var LspResponseNormalizer = class {
   /**
    * Convert diagnostic back to LSP format for requests
    */
-  denormalizeDiagnostic(diagnostic2) {
+  denormalizeDiagnostic(diagnostic) {
     const severityMap = {
       error: 1,
       warning: 2,
@@ -89025,11 +89083,11 @@ var LspResponseNormalizer = class {
       hint: 4
     };
     return {
-      range: diagnostic2.range,
-      message: diagnostic2.message,
-      severity: diagnostic2.severity ? severityMap[diagnostic2.severity] : void 0,
-      code: diagnostic2.code,
-      source: diagnostic2.source
+      range: diagnostic.range,
+      message: diagnostic.message,
+      severity: diagnostic.severity ? severityMap[diagnostic.severity] : void 0,
+      code: diagnostic.code,
+      source: diagnostic.source
     };
   }
   /**
@@ -95340,11 +95398,9 @@ import * as os16 from "node:os";
 init_esbuild_shims();
 var REDACTED_URL_CREDENTIAL = "***REDACTED***";
 var URL_CREDENTIALS_PATTERN = /\b([a-z][a-z0-9+.-]*:\/\/)(?:[^/\s]+@)+/gi;
+var UPLOAD_IDENTITY_PATTERN = /\bupload:v1:[0-9a-fA-F-]+:/gu;
 function redactUrlCredentials(source) {
-  return source.replace(
-    URL_CREDENTIALS_PATTERN,
-    `$1${REDACTED_URL_CREDENTIAL}@`
-  );
+  return source.replace(UPLOAD_IDENTITY_PATTERN, "upload:").replace(URL_CREDENTIALS_PATTERN, `$1${REDACTED_URL_CREDENTIAL}@`);
 }
 __name(redactUrlCredentials, "redactUrlCredentials");
 
@@ -96626,8 +96682,8 @@ async function collectResources(resourcePaths, pluginRoot, destDir) {
       debugLogger79.warn(`Resource path not found: ${resolvedPath}`);
       continue;
     }
-    const stat21 = fs53.statSync(resolvedPath);
-    if (stat21.isDirectory()) {
+    const stat22 = fs53.statSync(resolvedPath);
+    if (stat22.isDirectory()) {
       const dirName = path56.basename(resolvedPath);
       const finalDestDir = dirName === destFolderName ? destDir : path56.join(destDir, dirName);
       const files = await glob("**/*", {
@@ -97283,6 +97339,9 @@ async function checkForExtensionUpdate(extension, extensionManager, signal) {
   signal?.throwIfAborted();
   const installMetadata = extension.installMetadata;
   if (installMetadata?.type === "local") {
+    if (installMetadata.source.startsWith("upload:")) {
+      return "not updatable" /* NOT_UPDATABLE */;
+    }
     let latestConfig;
     let tempDir;
     let convertedDir;
@@ -98204,7 +98263,7 @@ import * as path62 from "node:path";
 init_esbuild_shims();
 import * as fs59 from "node:fs";
 import * as path61 from "node:path";
-import { stat as stat11 } from "node:fs/promises";
+import { stat as stat12 } from "node:fs/promises";
 var debugLogger83 = createDebugLogger("EXT_MARKETPLACE");
 function parseSourceAndPluginName(source) {
   const urlSchemes = ["http://", "https://", "git@", "sso://"];
@@ -98391,7 +98450,7 @@ async function loadMarketplaceConfigFromSource(source, networkPolicy) {
   const trimmed = source.trim();
   const lowerTrimmed = trimmed.toLowerCase();
   try {
-    const stats = await stat11(trimmed);
+    const stats = await stat12(trimmed);
     if (stats.isDirectory()) {
       return await readLocalMarketplaceConfig(trimmed);
     }
@@ -98464,7 +98523,7 @@ async function parseInstallSource(source, options2 = {}) {
   let marketplaceConfig = null;
   let isLocalPath = false;
   try {
-    await stat11(repo);
+    await stat12(repo);
     isLocalPath = true;
   } catch {
   }
@@ -103544,7 +103603,8 @@ var ExtensionManager = class _ExtensionManager {
       options2.initialActivation,
       options2.signal,
       true,
-      false
+      false,
+      options2.localSourcePath
     );
   }
   async prepareExtensionUpdateFromState(extension, signal) {
@@ -103593,7 +103653,10 @@ var ExtensionManager = class _ExtensionManager {
       )
     };
   }
-  async installExtensionInternal(installMetadata, requestConsent, requestSetting, cwd, previousExtensionConfig, initialActivation, signal, prepareOnly, emitMutation) {
+  async installExtensionInternal(installMetadata, requestConsent, requestSetting, cwd, previousExtensionConfig, initialActivation, signal, prepareOnly, emitMutation, localSourcePathOverride) {
+    if (localSourcePathOverride && installMetadata.type !== "local") {
+      throw new Error("A local source path requires a local install.");
+    }
     installMetadata = this.withNetworkPolicy(installMetadata);
     const currentDir = cwd ?? this.workspaceDir;
     const telemetryConfig = getTelemetryConfig(
@@ -103620,7 +103683,7 @@ var ExtensionManager = class _ExtensionManager {
       }
       const extensionsDir = this.configDir;
       await fs66.promises.mkdir(extensionsDir, { recursive: true });
-      if (!path67.isAbsolute(installMetadata.source) && (installMetadata.type === "local" || installMetadata.type === "link")) {
+      if (!localSourcePathOverride && !path67.isAbsolute(installMetadata.source) && (installMetadata.type === "local" || installMetadata.type === "link")) {
         installMetadata.source = path67.resolve(
           currentDir,
           installMetadata.source
@@ -103667,12 +103730,18 @@ var ExtensionManager = class _ExtensionManager {
         );
         installMetadata.releaseTag = result.version;
         localSourcePath = tempDir;
-      } else if (installMetadata.type === "local" && isSupportedArchivePath(installMetadata.source)) {
+      } else if (installMetadata.type === "local" && isSupportedArchivePath(
+        localSourcePathOverride ?? installMetadata.source
+      )) {
         tempDir = await ExtensionStorage.createTmpDir();
-        await extractArchiveFile(installMetadata.source, tempDir, signal);
+        await extractArchiveFile(
+          localSourcePathOverride ?? installMetadata.source,
+          tempDir,
+          signal
+        );
         localSourcePath = tempDir;
       } else if (installMetadata.type === "local" || installMetadata.type === "link") {
-        localSourcePath = installMetadata.source;
+        localSourcePath = localSourcePathOverride ?? installMetadata.source;
       } else {
         throw new Error(`Unsupported install type: ${installMetadata.type}`);
       }
@@ -104484,13 +104553,13 @@ import * as os21 from "os";
 // node_modules/chokidar/esm/index.js
 init_esbuild_shims();
 import { stat as statcb } from "fs";
-import { stat as stat15, readdir as readdir10 } from "fs/promises";
+import { stat as stat16, readdir as readdir10 } from "fs/promises";
 import { EventEmitter as EventEmitter4 } from "events";
 import * as sysPath2 from "path";
 
 // node_modules/readdirp/esm/index.js
 init_esbuild_shims();
-import { stat as stat13, lstat as lstat7, readdir as readdir9, realpath as realpath6 } from "node:fs/promises";
+import { stat as stat14, lstat as lstat7, readdir as readdir9, realpath as realpath6 } 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 = {
@@ -104531,7 +104600,7 @@ var FILE_TYPES = /* @__PURE__ */ new Set([
 var isNormalFlowError = /* @__PURE__ */ __name((error) => NORMAL_FLOW_ERRORS.has(error.code), "isNormalFlowError");
 var wantBigintFsStats = process.platform === "win32";
 var emptyFn = /* @__PURE__ */ __name((_entryInfo) => true, "emptyFn");
-var normalizeFilter = /* @__PURE__ */ __name((filter3) => {
+var normalizeFilter2 = /* @__PURE__ */ __name((filter3) => {
   if (filter3 === void 0)
     return emptyFn;
   if (typeof filter3 === "function")
@@ -104558,9 +104627,9 @@ var ReaddirpStream = class extends Readable {
     });
     const opts = { ...defaultOptions, ...options2 };
     const { root, type } = opts;
-    this._fileFilter = normalizeFilter(opts.fileFilter);
-    this._directoryFilter = normalizeFilter(opts.directoryFilter);
-    const statMethod = opts.lstat ? lstat7 : stat13;
+    this._fileFilter = normalizeFilter2(opts.fileFilter);
+    this._directoryFilter = normalizeFilter2(opts.directoryFilter);
+    const statMethod = opts.lstat ? lstat7 : stat14;
     if (wantBigintFsStats) {
       this._stat = (path98) => statMethod(path98, { bigint: true });
     } else {
@@ -104715,7 +104784,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 open8, stat as stat14, lstat as lstat8, realpath as fsrealpath } from "fs/promises";
+import { open as open8, stat as stat15, lstat as lstat8, realpath as fsrealpath } from "fs/promises";
 import * as sysPath from "path";
 import { type as osType } from "os";
 var STR_DATA = "data";
@@ -104742,7 +104811,7 @@ var EVENTS = {
 };
 var EV = EVENTS;
 var THROTTLE_MODE_WATCH = "watch";
-var statMethods = { lstat: lstat8, stat: stat14 };
+var statMethods = { lstat: lstat8, stat: stat15 };
 var KEY_LISTENERS = "listeners";
 var KEY_ERR = "errHandlers";
 var KEY_RAW = "rawEmitters";
@@ -105232,7 +105301,7 @@ var NodeFsHandler = class {
         return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
-          const newStats2 = await stat14(file);
+          const newStats2 = await stat15(file);
           if (this.fsw.closed)
             return;
           const at2 = newStats2.atimeMs;
@@ -105945,7 +106014,7 @@ var FSWatcher = class extends EventEmitter4 {
       const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path98) : path98;
       let stats2;
       try {
-        stats2 = await stat15(fullPath);
+        stats2 = await stat16(fullPath);
       } catch (err) {
       }
       if (!stats2 || this.closed)
@@ -106073,8 +106142,8 @@ var FSWatcher = class extends EventEmitter4 {
     }
     return this._userIgnored(path98, stats);
   }
-  _isntIgnored(path98, stat21) {
-    return !this._isIgnored(path98, stat21);
+  _isntIgnored(path98, stat22) {
+    return !this._isIgnored(path98, stat22);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
@@ -107280,12 +107349,12 @@ __name(isWithin, "isWithin");
 async function readBoundedTaskFile(filePath) {
   const handle = await fs68.open(filePath, "r");
   try {
-    const stat21 = await handle.stat();
-    if (!stat21.isFile()) {
+    const stat22 = await handle.stat();
+    if (!stat22.isFile()) {
       return null;
     }
     const cap = LOOP_TASK_FILE_MAX_BYTES + 1;
-    const allocSize = Math.min(cap, stat21.size + 1);
+    const allocSize = Math.min(cap, stat22.size + 1);
     const buffer = Buffer.alloc(allocSize);
     let total = 0;
     while (total < allocSize) {
@@ -112224,6 +112293,29 @@ var BackgroundTaskRegistry = class {
     }
     return false;
   }
+  /**
+   * The agent ids behind `hasUnfinalizedTasks()`, in registration order.
+   *
+   * Callers that must *name* the outstanding work — rather than just know
+   * that some exists — use this. The daemon's active-work snapshot builds
+   * one hold per id so a restart controller and the session-retention path
+   * both see the same set the registry itself would report, with no second
+   * ledger to drift out of sync. Deliberately shares
+   * `hasUnfinalizedTasks()`'s predicate (and not `hasRunningTasks()`'s):
+   * a cancelled entry still owes its terminal task-notification, and
+   * dropping it here would let the daemon reap the session inside the
+   * cancel → finalizeCancelled() window.
+   */
+  listUnfinalizedBackgroundAgentIds() {
+    const ids = [];
+    for (const entry of this.agents.values()) {
+      if (!entry.isBackgrounded) continue;
+      if (entry.status === "running" || entry.status === "cancelled" && !entry.notified) {
+        ids.push(entry.agentId);
+      }
+    }
+    return ids;
+  }
   /**
    * True while any background entry is still actually executing. Unlike
    * `hasUnfinalizedTasks()`, a `cancelled`-but-not-yet-finalized entry
@@ -112387,6 +112479,19 @@ var BackgroundTaskRegistry = class {
   setStatusChangeCallback(cb) {
     this.statusChangeCallback = cb;
   }
+  /**
+   * Retract `cb`, but only if it is still the installed one.
+   *
+   * The slot holds a single callback, so a subscriber that clears it
+   * unconditionally on teardown can unhook whoever claimed it afterwards. This
+   * makes the retraction safe to call from any owner's dispose path without
+   * having to know whether it is still the owner.
+   */
+  clearStatusChangeCallback(cb) {
+    if (this.statusChangeCallback === cb) {
+      this.statusChangeCallback = void 0;
+    }
+  }
   setActivityChangeCallback(cb) {
     this.activityChangeCallback = cb;
   }
@@ -114764,7 +114869,7 @@ async function runSpeculativeLoop(config, state, cacheSafe, modelOverride) {
               toolInvocationGuard,
               {
                 callId: persistenceCallId,
-                toolName: canonicalToolName2(name),
+                toolName: canonicalToolName(name),
                 args: invocation.params,
                 signal: state.abortController.signal,
                 ...invocationContext ? { invocationContext } : {}
@@ -115442,12 +115547,12 @@ function resolveGitDir2(crawlDirectory) {
   while (current) {
     const gitPath = path76.join(current, ".git");
     try {
-      const stat21 = fs72.statSync(gitPath);
-      if (stat21.isDirectory()) {
+      const stat22 = fs72.statSync(gitPath);
+      if (stat22.isDirectory()) {
         pathCacheSet(resolveGitDirCache, cacheKey, gitPath);
         return gitPath;
       }
-      if (stat21.isFile()) {
+      if (stat22.isFile()) {
         const contents = fs72.readFileSync(gitPath, "utf8").trim();
         const match2 = contents.match(/^gitdir:\s*(.+)$/i);
         if (!match2) {
@@ -116055,13 +116160,13 @@ async function crawlWithGitLsFiles(stateKey, crawlDirectory, cwd, options2, work
     if (deletedSet.has(normalizedFile)) {
       return true;
     }
-    let stat21;
+    let stat22;
     try {
-      stat21 = fs72.lstatSync(path76.join(gitRoot, ...normalizedFile.split("/")));
+      stat22 = fs72.lstatSync(path76.join(gitRoot, ...normalizedFile.split("/")));
     } catch {
       return true;
     }
-    if (stat21.isDirectory()) {
+    if (stat22.isDirectory()) {
       return true;
     }
     if (relativeToGitRoot && relativeToGitRoot !== "." && normalizedFile === relativeToGitRoot) {
@@ -121940,8 +122045,8 @@ function getWelcomeBackStatePath() {
   return path85.join(process.cwd(), ".qwen", WELCOME_BACK_STATE_FILENAME);
 }
 __name(getWelcomeBackStatePath, "getWelcomeBackStatePath");
-function buildSummaryFingerprint(stat21) {
-  return `${stat21.mtimeMs}:${stat21.size}`;
+function buildSummaryFingerprint(stat22) {
+  return `${stat22.mtimeMs}:${stat22.size}`;
 }
 __name(buildSummaryFingerprint, "buildSummaryFingerprint");
 async function getWelcomeBackState() {
@@ -127084,11 +127189,30 @@ function createInstructionsLoadedCallback(getHookSystem) {
 }
 __name(createInstructionsLoadedCallback, "createInstructionsLoadedCallback");
 
+// packages/core/src/hooks/user-prompt-submit-context.ts
+init_esbuild_shims();
+
 // packages/core/src/goals/index.ts
 init_esbuild_shims();
 
 // packages/core/src/goals/goal-legacy-projection.ts
 init_esbuild_shims();
+function isGoalCheckpointBookkeepingTransition(previous, next) {
+  const previousGoal = previous?.goal;
+  const nextGoal = next.goal;
+  if (!previousGoal || !nextGoal) return false;
+  return previousGoal.goalId === nextGoal.goalId && previousGoal.revision === nextGoal.revision && previousGoal.objective === nextGoal.objective && previousGoal.status === nextGoal.status && previousGoal.turnCount === nextGoal.turnCount && previousGoal.createdAt === nextGoal.createdAt && previousGoal.lastReason === nextGoal.lastReason;
+}
+__name(isGoalCheckpointBookkeepingTransition, "isGoalCheckpointBookkeepingTransition");
+function isGoalCheckpointBookkeepingCause(cause, previousCause) {
+  if (cause === "checkpoint") return true;
+  return cause === "verifier_reject" && (previousCause === "verifier_reject" || previousCause === "checkpoint");
+}
+__name(isGoalCheckpointBookkeepingCause, "isGoalCheckpointBookkeepingCause");
+function isGoalCheckpointBookkeepingRecord(input) {
+  return isGoalCheckpointBookkeepingTransition(input.previous, input.next) && isGoalCheckpointBookkeepingCause(input.cause, input.previousCause);
+}
+__name(isGoalCheckpointBookkeepingRecord, "isGoalCheckpointBookkeepingRecord");
 
 // packages/core/src/goals/goal-verifier.ts
 init_esbuild_shims();
@@ -129423,7 +129547,7 @@ ${result.output}`;
     }
     const elapsedMs = performance.now() - executionStartTime;
     const longRunThreshold = effectiveTimeout === 0 ? null : longRunThresholdFor(effectiveTimeout);
-    const shouldAppendLongRunHint = longRunThreshold !== null && !result.aborted && result.signal === null && elapsedMs >= longRunThreshold;
+    const shouldAppendLongRunHint = longRunThreshold !== null && !result.aborted && !isSignalTermination(result.signal) && elapsedMs >= longRunThreshold;
     debugLogger122.debug(
       `long-run hint: elapsed=${Math.round(elapsedMs)}ms threshold=${longRunThreshold === null ? "disabled" : `${longRunThreshold}ms`} aborted=${result.aborted} signal=${result.signal} \u2192 ${shouldAppendLongRunHint ? "fire" : "suppress"}`
     );
@@ -129437,7 +129561,7 @@ ${result.output}` : result.output;
       } else {
         if (result.aborted) {
           returnDisplayMessage = wasTimeout ? `${timeoutSummary} There was no output before it timed out.` : wasPromoteRefused ? "Command finished before background-promote could be honoured." : "Command cancelled by user.";
-        } else if (result.signal) {
+        } else if (isSignalTermination(result.signal)) {
           returnDisplayMessage = `Command terminated by signal: ${result.signal}`;
         } else if (result.error) {
           returnDisplayMessage = `Command failed: ${getErrorMessage(
@@ -129509,7 +129633,7 @@ ${attributionWarning}`;
 ${longRunHint}` : ""),
         type: "shell_execute_error" /* SHELL_EXECUTE_ERROR */
       }
-    } : isShellExitError(this.params.command, result.exitCode) ? {
+    } : !result.aborted && isSignalTermination(result.signal) || isShellExitError(this.params.command, result.exitCode) ? {
       error: {
         // Schedulers use error.message as the model-facing response.
         message: typeof llmContent === "string" ? llmContent : returnDisplayMessage,
@@ -129709,16 +129833,17 @@ ${longRunHint}` : ""),
     let postPromoteFinalStatus = null;
     const classifySettle = /* @__PURE__ */ __name((info) => {
       if (info.error) return { status: "failed", failMsg: info.error.message };
-      if (info.exitCode === 0) return { status: "completed", failMsg: null };
-      if (info.exitCode !== null)
+      if (isSignalTermination(info.signal)) {
         return {
           status: "failed",
-          failMsg: `Exited with code ${info.exitCode}`
+          failMsg: `Terminated by signal ${info.signal}`
         };
-      if (info.signal !== null)
+      }
+      if (info.exitCode === 0) return { status: "completed", failMsg: null };
+      if (info.exitCode !== null)
         return {
           status: "failed",
-          failMsg: `Terminated by signal ${info.signal}`
+          failMsg: `Exited with code ${info.exitCode}`
         };
       debugLogger122.warn(
         `promote: classifySettle all-null fallback hit for ${shellId} \u2014 exitCode=${info.exitCode}, signal=${info.signal}, error=undefined`
@@ -129729,6 +129854,10 @@ ${longRunHint}` : ""),
       };
     }, "classifySettle");
     const transitionRegistry = /* @__PURE__ */ __name((info) => {
+      if (entryAc.signal.aborted) {
+        registry.cancel(shellId, info.endTime);
+        return;
+      }
       const cls = classifySettle(info);
       if (cls.status === "completed") {
         registry.complete(shellId, info.exitCode, info.endTime);
@@ -129886,8 +130015,8 @@ ${longRunHint}` : ""),
             if (registry.get(shellId)?.status === "running") {
               registry.cancel(shellId, endTime);
             }
-          } else if (result.error || result.exitCode !== null && result.exitCode !== 0 || result.signal !== null) {
-            const reason = result.error ? result.error.message : result.signal !== null ? `terminated by signal ${result.signal}` : `exited with code ${result.exitCode}`;
+          } else if (result.error || result.exitCode !== null && result.exitCode !== 0 || isSignalTermination(result.signal)) {
+            const reason = result.error ? result.error.message : isSignalTermination(result.signal) ? `terminated by signal ${result.signal}` : `exited with code ${result.exitCode}`;
             registry.fail(shellId, reason, endTime);
           } else {
             registry.complete(shellId, result.exitCode ?? 0, endTime);
@@ -130857,12 +130986,8 @@ var FS_PATH_TOOL_NAMES = /* @__PURE__ */ new Set([
   ToolNames.NOTEBOOK_EDIT,
   ToolNames.DISPLAY_IMAGE
 ]);
-function canonicalToolName2(toolName) {
-  return ToolNamesMigration[toolName] ?? toolName;
-}
-__name(canonicalToolName2, "canonicalToolName");
 function isFilesystemPathTool(toolName) {
-  return FS_PATH_TOOL_NAMES.has(canonicalToolName2(toolName));
+  return FS_PATH_TOOL_NAMES.has(canonicalToolName(toolName));
 }
 __name(isFilesystemPathTool, "isFilesystemPathTool");
 function trimTrailingSlash(s3) {
@@ -130892,7 +131017,7 @@ function pushLspPathCandidate(out, v2) {
 }
 __name(pushLspPathCandidate, "pushLspPathCandidate");
 function extractToolFilePaths(toolName, toolInput) {
-  const canonical = canonicalToolName2(toolName);
+  const canonical = canonicalToolName(toolName);
   if (!FS_PATH_TOOL_NAMES.has(canonical)) {
     if (toolInput && typeof toolInput === "object") {
       const obj2 = toolInput;
@@ -131273,7 +131398,7 @@ function withPostToolBatchStop(completedCalls, stopReason) {
 }
 __name(withPostToolBatchStop, "withPostToolBatchStop");
 function isToolCallConcurrencySafe(name, kind, args) {
-  if (canonicalToolName2(name) === ToolNames.AGENT) return true;
+  if (canonicalToolName(name) === ToolNames.AGENT) return true;
   if (kind === "execute" /* Execute */) {
     const command = args?.command;
     if (typeof command !== "string") return false;
@@ -132006,7 +132131,7 @@ var CoreToolScheduler = class {
         Array.isArray(request) ? request : [request]
       );
       const planModeEntryBoundaryIndex = findPlanModeEntryBatchBoundaryIndex(
-        requestsToProcess.map((item) => canonicalToolName2(item.name))
+        requestsToProcess.map((item) => canonicalToolName(item.name))
       );
       if (this.validationRetryCounts.size > 0) {
         const currentToolNames = new Set(requestsToProcess.map((r) => r.name));
@@ -132071,7 +132196,7 @@ var CoreToolScheduler = class {
             });
             continue;
           }
-          const canonicalName = canonicalToolName2(reqInfo.name);
+          const canonicalName = canonicalToolName(reqInfo.name);
           const pm = this.config.getPermissionManager?.();
           const permissionEnabled = pm ? await pm.isToolEnabled(canonicalName) : true;
           if (recordPrevalidationCancellation()) continue;
@@ -132263,7 +132388,7 @@ var CoreToolScheduler = class {
           continue;
         }
         const { request: reqInfo, invocation } = toolCall;
-        const canonicalName = canonicalToolName2(reqInfo.name);
+        const canonicalName = canonicalToolName(reqInfo.name);
         const toolSpan = startToolSpan(
           canonicalName,
           {
@@ -133358,7 +133483,7 @@ var CoreToolScheduler = class {
     }
     let toolSpan = this.toolSpans.get(callId);
     if (!toolSpan) {
-      const canonical = canonicalToolName2(toolName);
+      const canonical = canonicalToolName(toolName);
       toolSpan = startToolSpan(
         canonical,
         {
@@ -133436,12 +133561,13 @@ var CoreToolScheduler = class {
    */
   bounceToAwaitingApprovalForAsk(scheduledCall, reason, toolSpan, signal) {
     const { callId, name: toolName } = scheduledCall.request;
-    const canonicalName = canonicalToolName2(toolName);
+    const canonicalName = canonicalToolName(toolName);
     this.bouncedAwaitingApproval.add(callId);
     const confirmationDetails = {
       type: "info",
       title: `Hook requested confirmation to run ${toolName}`,
       prompt: reason || `A PreToolUse hook requested confirmation before running ${toolName}.`,
+      renderPromptAsPlainText: true,
       hideAlwaysAllow: true,
       onConfirm: /* @__PURE__ */ __name((outcome, payload) => this.handleConfirmationResponse(
         callId,
@@ -133490,7 +133616,7 @@ var CoreToolScheduler = class {
   }
   async _executeToolCallBody(scheduledCall, signal, span) {
     const { callId, name: toolName } = scheduledCall.request;
-    const canonicalName = canonicalToolName2(toolName);
+    const canonicalName = canonicalToolName(toolName);
     const invocation = scheduledCall.invocation;
     const toolInput = scheduledCall.request.args;
     const isPostAskReexecution = this.bouncedAwaitingApproval.delete(callId);
@@ -134570,7 +134696,7 @@ ${failureHookResult.additionalContext}`;
     }
   }
   async maybePersistLargeToolResult(callId, toolName, content) {
-    if (GATE_EXEMPT_TOOLS.has(canonicalToolName2(toolName))) return { content };
+    if (GATE_EXEMPT_TOOLS.has(canonicalToolName(toolName))) return { content };
     const text = extractTextFromPartListUnion(content);
     if (!text || isAlreadyTruncated(text)) return { content };
     const gateThreshold = this.config.getTruncateToolOutputThreshold() + GATE_HEADROOM;
@@ -139902,6 +140028,9 @@ async function runAutoMemoryExtract(params) {
       );
     }) : Promise.resolve();
     await Promise.all([projectRebuild, userRebuild]);
+    await refreshMemoryInstruction(params.config, {
+      logContext: "managed auto-memory extraction"
+    });
   }
   const madeGenuineProgress = agentResult.touchedTopics.length > 0 || agentResult.hasToolActivity;
   const cursor = {
@@ -142108,7 +142237,8 @@ var GeminiClient = class _GeminiClient {
       if (resumeTokenCounts) {
         chat.seedResumeTokenCounts(
           resumeTokenCounts.promptTokenCount,
-          resumeTokenCounts.outputTokenCount
+          resumeTokenCounts.outputTokenCount,
+          resumeTokenCounts.isEstimated
         );
       } else {
         chat.setLastPromptTokenCount(
@@ -143477,7 +143607,8 @@ var GeminiClient = class _GeminiClient {
       strippedRetryEntries = this.stripOrphanedUserEntriesFromHistory() ?? [];
       pushCountAfterStrip = currentPushCount();
     }
-    let preInjectionPromptText;
+    const preHookUserPromptText = messageType === "userQuery" /* UserQuery */ ? partToString(request) : void 0;
+    let userPromptRecordPayload;
     let hooksEnabled;
     let messageBus;
     try {
@@ -143488,7 +143619,7 @@ var GeminiClient = class _GeminiClient {
       // hooks must not fire on (or be able to block) internal team
       // coordination traffic.
       messageType !== "teammate" /* Teammate */ && messageType !== "goal" /* Goal */ && hooksEnabled && messageBus && this.config.hasHooksForEvent("UserPromptSubmit")) {
-        const promptText = partToString(request);
+        const promptText = preHookUserPromptText ?? partToString(request);
         const submittedPrompt = messageType === "userQuery" /* UserQuery */ && typeof options2?.submittedPrompt === "string" && options2.submittedPrompt.trim().length > 0 ? options2.submittedPrompt : void 0;
         const response = await messageBus.request(
           {
@@ -143538,7 +143669,12 @@ var GeminiClient = class _GeminiClient {
             ...requestArray,
             { text: wrapUserPromptSubmitContext(additionalContext) }
           ];
-          preInjectionPromptText = promptText;
+          if (messageType === "userQuery" /* UserQuery */) {
+            userPromptRecordPayload = {
+              displayText: submittedPrompt ?? promptText,
+              hookContext: additionalContext
+            };
+          }
         }
       }
     } catch (error) {
@@ -143640,7 +143776,7 @@ var GeminiClient = class _GeminiClient {
         addUserPromptAttributes(
           this.config,
           interactionSpan,
-          preInjectionPromptText ?? partToString(request)
+          preHookUserPromptText ?? partToString(request)
         );
       }
     }
@@ -143668,7 +143804,7 @@ var GeminiClient = class _GeminiClient {
           }
           const promise = this.config.getMemoryManager().recall(
             this.config.getProjectRoot(),
-            preInjectionPromptText ?? partToString(request),
+            preHookUserPromptText ?? partToString(request),
             {
               config: this.config,
               excludedFilePaths: this.surfacedRelevantAutoMemoryPaths,
@@ -143720,13 +143856,15 @@ var GeminiClient = class _GeminiClient {
             goalPermit
           );
         } else {
-          const recordingService = this.config.getChatRecordingService();
-          if (recordingService && preInjectionPromptText !== void 0) {
-            recordingService.recordUserMessage(request, goalPermit, {
-              displayText: preInjectionPromptText
-            });
-          } else if (recordingService) {
-            recordingService.recordUserMessage(request, goalPermit);
+          const recorder = this.config.getChatRecordingService();
+          if (userPromptRecordPayload) {
+            recorder?.recordUserMessage(
+              request,
+              goalPermit,
+              userPromptRecordPayload
+            );
+          } else {
+            recorder?.recordUserMessage(request, goalPermit);
           }
         }
       }
@@ -144614,15 +144752,15 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
   async tryCompressChat(prompt_id, force = false, signal, customInstructions) {
     const previousSessionStartContext = this.lastSessionStartContext;
     const previousSessionStartSource = this.lastSessionStartSource;
-    const info = await this.getChat().tryCompress(
+    const previousChat = this.getChat();
+    const info = await previousChat.tryCompress(
       prompt_id,
       force,
       signal,
       customInstructions ? { customInstructions } : void 0
     );
     if (info.compressionStatus === 1 /* COMPRESSED */) {
-      const chat = this.getChat();
-      const compressedHistory = chat.getHistoryShallow?.() ?? chat.getHistory();
+      const compressedHistory = previousChat.getHistoryShallow?.() ?? previousChat.getHistory();
       await this.startChat(compressedHistory, "compact" /* Compact */);
       if (!this.lastSessionStartContext && previousSessionStartContext && previousSessionStartSource) {
         this.lastSessionStartContext = previousSessionStartContext;
@@ -144634,7 +144772,10 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
       }
       debugLogger133.debug("[FILE_READ_CACHE] clear after tryCompressChat");
       this.config.getFileReadCache().clear();
-      this.getChat().setLastPromptTokenCount(info.newTokenCount);
+      this.getChat().setLastPromptTokenCount(
+        info.newTokenCount,
+        info.newTokenCountIsEstimated ?? true
+      );
       this.forceFullIdeContext = true;
     }
     return info;
@@ -150579,7 +150720,8 @@ var Config = class _Config {
     const runtime = createGoalRuntime({
       journal: this.chatRecordingService,
       evidenceSource: this.chatRecordingService,
-      verifier: createGoalVerifier(this)
+      verifier: createGoalVerifier(this),
+      checkpointVerifier: createGoalCheckpointVerifier(this)
     });
     this.goalRuntime = runtime;
     if (this.goalTurnHost) {
@@ -150911,7 +151053,7 @@ var Config = class _Config {
     }
     if (!enabled) return;
     registry.registerFactory(ToolNames.IMAGE_GEN, async () => {
-      const { ImageGenTool } = await import("./image-gen-7C6IK6DC.js");
+      const { ImageGenTool } = await import("./image-gen-AUIZJJNK.js");
       return new ImageGenTool(this);
     });
   }
@@ -150941,36 +151083,36 @@ var Config = class _Config {
       if (options2?.forSubAgent) return;
       const schema = this.jsonSchema;
       await registerLazy(ToolNames.STRUCTURED_OUTPUT, async () => {
-        const { SyntheticOutputTool } = await import("./syntheticOutput-ZLCUTKO2.js");
+        const { SyntheticOutputTool } = await import("./syntheticOutput-PEBJQYJV.js");
         return new SyntheticOutputTool(schema);
       });
     }, "registerStructuredOutputIfRequested");
     const registerGoalWorkerTools = /* @__PURE__ */ __name(async () => {
       if (options2?.forSubAgent) return;
       await registerLazy(ToolNames.GET_GOAL, async () => {
-        const { GetGoalTool } = await import("./goal-tools-APOW6UXL.js");
+        const { GetGoalTool } = await import("./goal-tools-PXWN5VK3.js");
         return new GetGoalTool(this);
       });
       await registerLazy(ToolNames.UPDATE_GOAL, async () => {
-        const { UpdateGoalTool } = await import("./goal-tools-APOW6UXL.js");
+        const { UpdateGoalTool } = await import("./goal-tools-PXWN5VK3.js");
         return new UpdateGoalTool(this);
       });
     }, "registerGoalWorkerTools");
     if (this.getBareMode()) {
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-HPSODLPK.js");
+        const { ReadFileTool } = await import("./read-file-3M6WXDXP.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-LHHRFNFK.js");
+        const { EditTool } = await import("./edit-ITMZYFKA.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-        const { NotebookEditTool } = await import("./notebook-edit-4YM65BBO.js");
+        const { NotebookEditTool } = await import("./notebook-edit-474DPMRL.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-3SWW22MH.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-23OMNMW6.js");
         return new ShellTool2(this);
       });
       await registerGoalWorkerTools();
@@ -150982,43 +151124,43 @@ var Config = class _Config {
     }
     await registerGoalWorkerTools();
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-2BFCGLI6.js");
+      const { ToolSearchTool } = await import("./tool-search-UJV3A24H.js");
       return new ToolSearchTool(this);
     });
     await registerLazy(ToolNames.READ_MCP_RESOURCE, async () => {
-      const { ReadMcpResourceTool } = await import("./read-mcp-resource-2TNSJTC3.js");
+      const { ReadMcpResourceTool } = await import("./read-mcp-resource-PZ4ZF6YL.js");
       return new ReadMcpResourceTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-T6PTGX5R.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-624T2BLO.js");
       return new AgentTool2(this);
     });
     await registerLazy(ToolNames.LIST_AGENTS, async () => {
-      const { ListAgentsTool } = await import("./list-agents-KFFIIS2G.js");
+      const { ListAgentsTool } = await import("./list-agents-Z4WABFDZ.js");
       return new ListAgentsTool(this);
     });
     await registerLazy(ToolNames.TASK_STOP, async () => {
-      const { TaskStopTool } = await import("./task-stop-7ZQM5CFF.js");
+      const { TaskStopTool } = await import("./task-stop-FPCOIRYX.js");
       return new TaskStopTool(this);
     });
     await registerLazy(ToolNames.SEND_MESSAGE, async () => {
-      const { SendMessageTool } = await import("./send-message-ZM7MRUGP.js");
+      const { SendMessageTool } = await import("./send-message-CAMSLG2L.js");
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-KDHWYS7W.js");
+      const { SkillTool } = await import("./skill-6HBDYZRS.js");
       return new SkillTool(this);
     });
     await registerLazy(ToolNames.LS, async () => {
-      const { LSTool } = await import("./ls-UVVE2XGE.js");
+      const { LSTool } = await import("./ls-TVHDGIES.js");
       return new LSTool(this);
     });
     await registerLazy(ToolNames.READ_FILE, async () => {
-      const { ReadFileTool } = await import("./read-file-HPSODLPK.js");
+      const { ReadFileTool } = await import("./read-file-3M6WXDXP.js");
       return new ReadFileTool(this);
     });
     await registerLazy(ToolNames.ZOOM_IMAGE, async () => {
-      const { ZoomImageTool } = await import("./zoom-image-HPRBZHSS.js");
+      const { ZoomImageTool } = await import("./zoom-image-E7D72GYV.js");
       return new ZoomImageTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -151033,7 +151175,7 @@ var Config = class _Config {
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-ZKQGTQAO.js");
+          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-PLPENT3E.js");
           return new RipGrepTool2(this);
         });
       } else {
@@ -151046,7 +151188,7 @@ var Config = class _Config {
           )
         );
         await registerLazy(ToolNames.GREP, async () => {
-          const { GrepTool } = await import("./grep-V43ILZVX.js");
+          const { GrepTool } = await import("./grep-6ZFC7RJ5.js");
           return new GrepTool(this);
         });
       }
@@ -151054,77 +151196,77 @@ var Config = class _Config {
       recordStartupEvent("config_initialize_ripgrep_probe_start");
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       await registerLazy(ToolNames.GREP, async () => {
-        const { GrepTool } = await import("./grep-V43ILZVX.js");
+        const { GrepTool } = await import("./grep-6ZFC7RJ5.js");
         return new GrepTool(this);
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-3N6GGI75.js");
+      const { GlobTool } = await import("./glob-7KZG44BR.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-LHHRFNFK.js");
+      const { EditTool } = await import("./edit-ITMZYFKA.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-      const { NotebookEditTool } = await import("./notebook-edit-4YM65BBO.js");
+      const { NotebookEditTool } = await import("./notebook-edit-474DPMRL.js");
       return new NotebookEditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-B34CDELV.js");
+      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-CGS57TS4.js");
       return new WriteFileTool2(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-3SWW22MH.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-23OMNMW6.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.TODO_WRITE, async () => {
-      const { TodoWriteTool } = await import("./todoWrite-UPVOHYGD.js");
+      const { TodoWriteTool } = await import("./todoWrite-JGV6VLOX.js");
       return new TodoWriteTool(this);
     });
     const supportsUserInteraction = resolveInteractionMode(this) !== "headless";
     if (supportsUserInteraction) {
       await registerLazy(ToolNames.ASK_USER_QUESTION, async () => {
-        const { AskUserQuestionTool } = await import("./askUserQuestion-XOBQLPFA.js");
+        const { AskUserQuestionTool } = await import("./askUserQuestion-ONW74PKJ.js");
         return new AskUserQuestionTool(this);
       });
     }
     if (!this.sdkMode && (supportsUserInteraction || options2?.forSubAgent)) {
       await registerLazy(ToolNames.EXIT_PLAN_MODE, async () => {
-        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-7CCWKO7I.js");
+        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-ZLI5F7KR.js");
         return new ExitPlanModeTool2(this);
       });
     }
     if (!this.sdkMode && supportsUserInteraction) {
       await registerLazy(ToolNames.ENTER_PLAN_MODE, async () => {
-        const { EnterPlanModeTool } = await import("./enterPlanMode-ZVQT4U7D.js");
+        const { EnterPlanModeTool } = await import("./enterPlanMode-YV52NNJT.js");
         return new EnterPlanModeTool(this);
       });
     }
     await registerLazy(ToolNames.ENTER_WORKTREE, async () => {
-      const { EnterWorktreeTool } = await import("./enter-worktree-6NXCRZPF.js");
+      const { EnterWorktreeTool } = await import("./enter-worktree-S4PL5UV6.js");
       return new EnterWorktreeTool(this);
     });
     await registerLazy(ToolNames.EXIT_WORKTREE, async () => {
-      const { ExitWorktreeTool } = await import("./exit-worktree-I2YLUHHY.js");
+      const { ExitWorktreeTool } = await import("./exit-worktree-XRM6LH5F.js");
       return new ExitWorktreeTool(this);
     });
     await registerLazy(ToolNames.WEB_FETCH, async () => {
-      const { WebFetchTool } = await import("./web-fetch-QWJYRXFL.js");
+      const { WebFetchTool } = await import("./web-fetch-ILB4GAVR.js");
       return new WebFetchTool(this);
     });
     if (resolveInteractionMode(this) === "interactive" && !this.sdkMode && !this.getScreenReader() && !options2?.forSubAgent) {
       await registerLazy(ToolNames.DISPLAY_IMAGE, async () => {
-        const { DisplayImageTool } = await import("./display-image-O2XFPQTC.js");
+        const { DisplayImageTool } = await import("./display-image-NQRSIBXM.js");
         return new DisplayImageTool(this);
       });
     }
     if (this.webSearchSettings?.enabled) {
-      const { evaluateWebSearchGate } = await import("./web-search-2AOXJGHU.js");
+      const { evaluateWebSearchGate } = await import("./web-search-HKRPGPZZ.js");
       const gate = evaluateWebSearchGate(this);
       if (gate.ok) {
         await registerLazy(ToolNames.WEB_SEARCH, async () => {
-          const { WebSearchTool } = await import("./web-search-2AOXJGHU.js");
+          const { WebSearchTool } = await import("./web-search-HKRPGPZZ.js");
           return new WebSearchTool(this);
         });
       } else if (!this.webSearchNoticeEmitted && !options2?.forSubAgent) {
@@ -151135,83 +151277,83 @@ var Config = class _Config {
     await this.registerImageGenerationTool(registry);
     if (this.isArtifactEnabled()) {
       await registerLazy(ToolNames.ARTIFACT, async () => {
-        const { ArtifactTool } = await import("./artifact-tool-U4VOZIK5.js");
+        const { ArtifactTool } = await import("./artifact-tool-N652YE4L.js");
         return new ArtifactTool(this);
       });
     }
     if (this.isRecordArtifactEnabled()) {
       await registerLazy(ToolNames.RECORD_ARTIFACT, async () => {
-        const { RecordArtifactTool } = await import("./record-artifact-RAON52FC.js");
+        const { RecordArtifactTool } = await import("./record-artifact-P4HFMS7X.js");
         return new RecordArtifactTool();
       });
     }
     if (this.isLspEnabled() && this.getLspClient()) {
       await registerLazy(ToolNames.LSP, async () => {
-        const { LspTool } = await import("./lsp-QMEA2VLB.js");
+        const { LspTool } = await import("./lsp-CVN6OQPI.js");
         return new LspTool(this);
       });
     }
     await registerStructuredOutputIfRequested();
     if (this.isCronEnabled()) {
       await registerLazy(ToolNames.CRON_CREATE, async () => {
-        const { CronCreateTool } = await import("./cron-create-GRBWYMIJ.js");
+        const { CronCreateTool } = await import("./cron-create-VONA5JYY.js");
         return new CronCreateTool(this);
       });
       await registerLazy(ToolNames.CRON_LIST, async () => {
-        const { CronListTool } = await import("./cron-list-W7K4ASOA.js");
+        const { CronListTool } = await import("./cron-list-KE4F2CIR.js");
         return new CronListTool(this);
       });
       await registerLazy(ToolNames.CRON_DELETE, async () => {
-        const { CronDeleteTool } = await import("./cron-delete-4CMKBR2M.js");
+        const { CronDeleteTool } = await import("./cron-delete-5JXSP2MI.js");
         return new CronDeleteTool(this);
       });
       await registerLazy(ToolNames.LOOP_WAKEUP, async () => {
-        const { LoopWakeupTool } = await import("./loop-wakeup-TLMJPMMP.js");
+        const { LoopWakeupTool } = await import("./loop-wakeup-UZ5RL5Y2.js");
         return new LoopWakeupTool(this);
       });
     }
     await registerLazy(ToolNames.CREATE_SUB_SESSION, async () => {
-      const { CreateSubSessionTool } = await import("./create-sub-session-E4PBYXV5.js");
+      const { CreateSubSessionTool } = await import("./create-sub-session-QIDZUOPU.js");
       return new CreateSubSessionTool(this);
     });
     if (this.isAgentTeamEnabled()) {
       await registerLazy(ToolNames.TEAM_CREATE, async () => {
-        const { TeamCreateTool } = await import("./team-create-2WTNGAOX.js");
+        const { TeamCreateTool } = await import("./team-create-CFFKU7KL.js");
         return new TeamCreateTool(this);
       });
       await registerLazy(ToolNames.TEAM_DELETE, async () => {
-        const { TeamDeleteTool } = await import("./team-delete-MHY3UZGY.js");
+        const { TeamDeleteTool } = await import("./team-delete-MMQB4OSC.js");
         return new TeamDeleteTool(this);
       });
       await registerLazy(ToolNames.TEAM_PLAN_APPROVAL, async () => {
-        const { TeamPlanApprovalTool } = await import("./team-plan-approval-LZTYLEG4.js");
+        const { TeamPlanApprovalTool } = await import("./team-plan-approval-6EFOKR6A.js");
         return new TeamPlanApprovalTool(this);
       });
       await registerLazy(ToolNames.TASK_CREATE, async () => {
-        const { TaskCreateTool } = await import("./task-create-CQP5UEA3.js");
+        const { TaskCreateTool } = await import("./task-create-5NWCQSJF.js");
         return new TaskCreateTool(this);
       });
       await registerLazy(ToolNames.TASK_UPDATE, async () => {
-        const { TaskUpdateTool } = await import("./task-update-JA75U2SN.js");
+        const { TaskUpdateTool } = await import("./task-update-5HN577LS.js");
         return new TaskUpdateTool(this);
       });
       await registerLazy(ToolNames.TASK_LIST, async () => {
-        const { TaskListTool } = await import("./task-list-XLEZOJXP.js");
+        const { TaskListTool } = await import("./task-list-53265TRZ.js");
         return new TaskListTool(this);
       });
     }
     if (this.isWorkflowsEnabled()) {
       await registerLazy(ToolNames.WORKFLOW, async () => {
-        const { WorkflowTool } = await import("./workflow-ERH3SJG2.js");
+        const { WorkflowTool } = await import("./workflow-FXIPRQQA.js");
         return new WorkflowTool(this);
       });
     }
     if (this.isComputerUseEnabled()) {
-      const { registerComputerUseTools } = await import("./computer-use-KEAPATUY.js");
+      const { registerComputerUseTools } = await import("./computer-use-ESQYJ3JY.js");
       await registerComputerUseTools(registerLazy, this);
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-GN24FH6C.js");
+      const { MonitorTool } = await import("./monitor-DAKD6OU4.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {
@@ -151635,8 +151777,6 @@ export {
   DEFAULT_STOP_HOOK_BLOCK_CAP,
   formatStopHookBlockingCapWarning,
   buildContextUsage,
-  wrapUserPromptSubmitContext,
-  stripTrailingUserPromptSubmitContextPart,
   isGitRepository,
   findGitRoot,
   getGitBranch,
@@ -151691,12 +151831,15 @@ export {
   SESSION_TRANSCRIPT_MAX_LIMIT,
   SESSION_TRANSCRIPT_MAX_INDEX_BYTES,
   SESSION_TRANSCRIPT_MAX_PAGE_BYTES,
+  SESSION_TRANSCRIPT_MAX_EXPANDED_PAGE_BYTES,
   InvalidSessionTranscriptCursorError,
   SessionTranscriptSnapshotUnavailableError,
   SessionTranscriptTooLargeError,
   SessionTranscriptPageTooLargeError,
   SessionTranscriptCursorCodec,
   encodeSessionTranscriptCursor,
+  isReplayTurnStartType,
+  findBoundaryAtOrBefore,
   SessionTranscriptReader,
   SessionWriterError,
   SESSION_WRITER_RPC_CODES,
@@ -151714,7 +151857,10 @@ export {
   acquireSleepInhibitor,
   approxBase64Bytes,
   clampInlineMediaPart,
+  GLOBAL_DUPLICATE_THRESHOLD,
   DEFAULT_MAX_TOOL_CALLS_PER_TURN,
+  getToolCallRepeatKey,
+  shouldHaltOnTurnToolCallCap,
   CommitAttributionService,
   generateToolUseId,
   firePreToolUseHook,
@@ -151781,6 +151927,7 @@ export {
   sessionIdContext,
   getShellContextEnvVars,
   getShellPagerEnv,
+  isSignalTermination,
   ShellExecutionService,
   escape,
   globStream,
@@ -151805,7 +151952,6 @@ export {
   IdeClient,
   bridgeToolResultImages,
   evaluateToolInvocationGuard,
-  canonicalToolName2 as canonicalToolName,
   convertToFunctionResponse,
   convertToFunctionErrorResponse,
   isToolCallConcurrencySafe,
@@ -151840,6 +151986,9 @@ export {
   MAX_RECENT_ACTIVITIES,
   buildBackgroundEntryLabel,
   runForkedAgent,
+  didWriteProjectContextFile,
+  refreshMemoryInstruction,
+  refreshMemoryAfterManagedWrite,
   runManagedAutoMemoryDream,
   MessageDisplayDispatcher,
   collectMemoryDiagnostics,
@@ -151862,6 +152011,8 @@ export {
   SubagentManager,
   MAX_CONCURRENT_MONITORS,
   getMonitorOutputPath,
+  isActiveWorkflowStatus,
+  isTerminalWorkflowStatus,
   EXTENSIONS_CONFIG_FILENAME,
   So,
   redactUrlCredentials,
@@ -151930,6 +152081,7 @@ export {
   TURN_INTERRUPTION_HISTORY_TAIL_COUNT,
   buildSessionRecoveryPlan,
   buildSessionRecoveryPlanFromApiHistory,
+  runWithTimeout,
   McpTransportPool,
   WorkspaceMcpBudget,
   ClientMcpRegistrar,
@@ -151969,8 +152121,6 @@ export {
   buildManagedRememberPrompt,
   buildBareRememberPrompt,
   runManagedRememberByAgent,
-  refreshMemoryInstruction,
-  refreshMemoryAfterManagedWrite,
   parseLearnVideoInput,
   buildLearnSkillPrompt,
   buildLearnVideoSkillRequest,
@@ -152019,7 +152169,8 @@ export {
   subagentGenerator,
   BTW_MAX_INPUT_LENGTH,
   buildBtwPrompt,
-  buildBtwCacheSafeParams
+  buildBtwCacheSafeParams,
+  isGoalCheckpointBookkeepingRecord
 };
 /**
  * @license
@@ -152043,12 +152194,12 @@ export {
  */
 /**
  * @license
- * Copyright 2025 Qwen Code
+ * Copyright 2026 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2026 Qwen
+ * Copyright 2025 Qwen Code
  * SPDX-License-Identifier: Apache-2.0
  */
 /**