@google/gemini-cli 0.42.0-preview.1 → 0.43.0-preview.0

package/bundle/{chunk-A564QXJJ.js → chunk-SAISHGWW.js}

@@ -92,6 +92,7 @@ import {
   PREVIEW_GEMINI_MODEL,
   PREVIEW_GEMINI_MODEL_AUTO,
   PRIORITY_SUBAGENT_TOOL,
+  PROJECT_MEMORY_INDEX_FILENAME,
   PolicyDecision,
   QuestionType,
   READ_FILE_DEFINITION,
@@ -223,7 +224,7 @@ import {
   toPathKey,
   unescapePath,
   zodToJsonSchema
-} from "./chunk-JEW7ZIWE.js";
+} from "./chunk-UJ26GAE5.js";
 import {
   wrapper_default
 } from "./chunk-664ZODQF.js";
@@ -2574,7 +2575,7 @@ var require_lib = __commonJS({
       return numMessages > 0;
     }
     async function isBinaryFile2(file2, size) {
-      if (isString(file2)) {
+      if (isString2(file2)) {
         const stat9 = await statAsync(file2);
         isStatFile(stat9);
         const fileDescriptor = await openAsync(file2, "r");
@@ -2602,7 +2603,7 @@ var require_lib = __commonJS({
     }
     exports2.isBinaryFile = isBinaryFile2;
     function isBinaryFileSync(file2, size) {
-      if (isString(file2)) {
+      if (isString2(file2)) {
         const stat9 = fs84.statSync(file2);
         isStatFile(stat9);
         const fileDescriptor = fs84.openSync(file2, "r");
@@ -2682,7 +2683,7 @@ var require_lib = __commonJS({
       }
       return false;
     }
-    function isString(x) {
+    function isString2(x) {
       return typeof x === "string";
     }
     function isStatFile(stat9) {
@@ -24450,7 +24451,7 @@ var require_minimal = __commonJS({
     function isInteger3(value) {
       return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
     };
-    util2.isString = function isString(value) {
+    util2.isString = function isString2(value) {
       return typeof value === "string" || value instanceof String;
     };
     util2.isObject = function isObject6(value) {
@@ -25319,13 +25320,13 @@ var require_path = __commonJS({
   "node_modules/@protobufjs/path/index.js"(exports2) {
     "use strict";
     var path101 = exports2;
-    var isAbsolute8 = (
+    var isAbsolute7 = (
       /**
        * Tests if the specified path is absolute.
        * @param {string} path Path to test
        * @returns {boolean} `true` if path is absolute
        */
-      path101.isAbsolute = function isAbsolute9(path102) {
+      path101.isAbsolute = function isAbsolute8(path102) {
         return /^(?:\/|\w+:)/.test(path102);
       }
     );
@@ -25337,7 +25338,7 @@ var require_path = __commonJS({
        */
       path101.normalize = function normalize6(path102) {
         path102 = path102.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
-        var parts2 = path102.split("/"), absolute = isAbsolute8(path102), prefix = "";
+        var parts2 = path102.split("/"), absolute = isAbsolute7(path102), prefix = "";
         if (absolute)
           prefix = parts2.shift() + "/";
         for (var i3 = 0; i3 < parts2.length; ) {
@@ -25359,7 +25360,7 @@ var require_path = __commonJS({
     path101.resolve = function resolve25(originPath, includePath, alreadyNormalized) {
       if (!alreadyNormalized)
         includePath = normalize5(includePath);
-      if (isAbsolute8(includePath))
+      if (isAbsolute7(includePath))
         return includePath;
       if (!alreadyNormalized)
         originPath = normalize5(originPath);
@@ -42951,7 +42952,7 @@ var require_minimal2 = __commonJS({
     function isInteger3(value) {
       return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
     };
-    util2.isString = function isString(value) {
+    util2.isString = function isString2(value) {
       return typeof value === "string" || value instanceof String;
     };
     util2.isObject = function isObject6(value) {
@@ -96326,7 +96327,7 @@ var require_object_inspect = __commonJS({
       if (isBoolean2(obj)) {
         return markBoxed(booleanValueOf.call(obj));
       }
-      if (isString(obj)) {
+      if (isString2(obj)) {
         return markBoxed(inspect4(String(obj)));
       }
       if (typeof window !== "undefined" && obj === window) {
@@ -96375,7 +96376,7 @@ var require_object_inspect = __commonJS({
     function isError(obj) {
       return toStr(obj) === "[object Error]" && canTrustToString(obj);
     }
-    function isString(obj) {
+    function isString2(obj) {
       return toStr(obj) === "[object String]" && canTrustToString(obj);
     }
     function isNumber3(obj) {
@@ -204423,8 +204424,8 @@ var require_ignore = __commonJS({
       (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
       pattern
     );
-    var isString = (subject) => typeof subject === "string";
-    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var isString2 = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString2(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
     var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
     var IgnoreRule = class {
       constructor(pattern, mark, body2, ignoreCase, negative, prefix) {
@@ -204491,7 +204492,7 @@ var require_ignore = __commonJS({
           this._added = true;
           return;
         }
-        if (isString(pattern)) {
+        if (isString2(pattern)) {
           pattern = {
             pattern
           };
@@ -204506,7 +204507,7 @@ var require_ignore = __commonJS({
       add(pattern) {
         this._added = false;
         makeArray(
-          isString(pattern) ? splitPattern(pattern) : pattern
+          isString2(pattern) ? splitPattern(pattern) : pattern
         ).forEach(this._add, this);
         return this._added;
       }
@@ -204548,7 +204549,7 @@ var require_ignore = __commonJS({
       throw new Ctor(message);
     };
     var checkPath = (path101, originalPath, doThrow) => {
-      if (!isString(path101)) {
+      if (!isString2(path101)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
@@ -229145,13 +229146,13 @@ var require_implementation2 = __commonJS({
         var isObject6 = object3 !== null && typeof object3 === "object";
         var isFunction = toStr.call(object3) === "[object Function]";
         var isArguments = isArgs(object3);
-        var isString = isObject6 && toStr.call(object3) === "[object String]";
+        var isString2 = isObject6 && toStr.call(object3) === "[object String]";
         var theKeys = [];
         if (!isObject6 && !isFunction && !isArguments) {
           throw new TypeError("Object.keys called on a non-object");
         }
         var skipProto = hasProtoEnumBug && isFunction;
-        if (isString && object3.length > 0 && !has.call(object3, 0)) {
+        if (isString2 && object3.length > 0 && !has.call(object3, 0)) {
           for (var i3 = 0; i3 < object3.length; ++i3) {
             theKeys.push(String(i3));
           }
@@ -236749,6 +236750,8 @@ var BINARY_FILE_PATTERNS = [
   "**/*.bz2",
   "**/*.rar",
   "**/*.7z",
+  "**/*.pak",
+  "**/*.rpa",
   "**/*.doc",
   "**/*.docx",
   "**/*.xls",
@@ -237759,8 +237762,14 @@ function escapeShellArg(arg, shell) {
   }
   switch (shell) {
     case "powershell":
+      if (/^[a-zA-Z0-9\-_.]+$/.test(arg)) {
+        return arg;
+      }
       return `'${arg.replace(/'/g, "''")}'`;
     case "cmd":
+      if (/^[a-zA-Z0-9\-_.]+$/.test(arg)) {
+        return arg;
+      }
       return `"${arg.replace(/"/g, '""')}"`;
     case "bash":
     default:
@@ -242047,7 +242056,8 @@ function recordModelRoutingMetrics(config2, event) {
     "routing.approval_mode": event.approval_mode
   };
   if (event.reasoning) {
-    attributes["routing.reasoning"] = event.reasoning;
+    const isStrictTelemetry = process.env["GEMINI_STRICT_TELEMETRY_LIMITS"] === "true";
+    attributes["routing.reasoning"] = isStrictTelemetry && event.reasoning.length > 1e3 ? event.reasoning.substring(0, 1e3) + "..." : event.reasoning;
   }
   if (event.enable_numerical_routing !== void 0) {
     attributes["routing.enable_numerical_routing"] = event.enable_numerical_routing;
@@ -242057,9 +242067,10 @@ function recordModelRoutingMetrics(config2, event) {
   }
   modelRoutingLatencyHistogram.record(event.routing_latency_ms, attributes);
   if (event.failed) {
+    const isStrictTelemetry = process.env["GEMINI_STRICT_TELEMETRY_LIMITS"] === "true";
     modelRoutingFailureCounter.add(1, {
       ...attributes,
-      "routing.error_message": event.error_message
+      "routing.error_message": isStrictTelemetry && event.error_message && event.error_message.length > 1e3 ? event.error_message.substring(0, 1e3) + "..." : event.error_message
     });
   }
 }
@@ -244879,7 +244890,7 @@ var KeychainService = class {
       if (await this.isKeychainFunctional(keychainModule)) {
         return keychainModule;
       }
-      debugLogger.debug("Keychain functional verification failed");
+      debugLogger.debug("Keychain functional verification failed or timed out");
       return null;
     } catch (error40) {
       const message = error40 instanceof Error ? error40.message : String(error40);
@@ -244900,13 +244911,22 @@ var KeychainService = class {
     return null;
   }
   // Performs a set-get-delete cycle to verify keychain functionality.
+  // Capped with a 2s timeout so a non-responsive Secret Service (common on
+  // headless Linux: WSL/SSH/Docker without gnome-keyring or D-Bus) falls back
+  // to FileKeychain instead of hanging the CLI indefinitely.
   async isKeychainFunctional(keychain) {
     const testAccount = `${KEYCHAIN_TEST_PREFIX}${crypto7.randomBytes(8).toString("hex")}`;
     const testPassword = "test";
-    await keychain.setPassword(this.serviceName, testAccount, testPassword);
-    const retrieved = await keychain.getPassword(this.serviceName, testAccount);
-    const deleted = await keychain.deletePassword(this.serviceName, testAccount);
-    return deleted && retrieved === testPassword;
+    const probe = async () => {
+      await keychain.setPassword(this.serviceName, testAccount, testPassword);
+      const retrieved = await keychain.getPassword(this.serviceName, testAccount);
+      const deleted = await keychain.deletePassword(this.serviceName, testAccount);
+      return deleted && retrieved === testPassword;
+    };
+    return Promise.race([
+      probe(),
+      new Promise((resolve25) => setTimeout(() => resolve25(false), 2e3).unref())
+    ]);
   }
   /**
    * MacOS-specific check to detect if a default keychain is available.
@@ -245400,7 +245420,8 @@ async function triggerPostAuthCallbacks(tokens) {
     refresh_token: tokens.refresh_token ?? void 0,
     // Ensure null is not passed
     type: "authorized_user",
-    client_email: userAccountManager2.getCachedGoogleAccount() ?? void 0
+    client_email: userAccountManager2.getCachedGoogleAccount() ?? void 0,
+    quota_project_id: process.env["GOOGLE_CLOUD_QUOTA_PROJECT"] || process.env["GOOGLE_CLOUD_PROJECT"] || process.env["GOOGLE_CLOUD_PROJECT_ID"]
   };
   authEvents.emit("post_auth", jwtInput);
 }
@@ -246273,8 +246294,8 @@ var EventMetadataKey;
 })(EventMetadataKey || (EventMetadataKey = {}));
 
 // packages/core/dist/src/generated/git-commit.js
-var GIT_COMMIT_INFO = "246f98459";
-var CLI_VERSION = "0.42.0-preview.0";
+var GIT_COMMIT_INFO = "022e8baef";
+var CLI_VERSION = "0.43.0-preview.0";
 
 // packages/core/dist/src/ide/detect-ide.js
 var IDE_DEFINITIONS = {
@@ -248124,7 +248145,35 @@ var GcpMetricExporter = class extends import_opentelemetry_cloud_monitoring_expo
       prefix: "custom.googleapis.com/gemini_cli"
     });
   }
+  export(metrics2, resultCallback) {
+    super.export(metrics2, (result2) => {
+      if (result2.code === import_core5.ExportResultCode.FAILED && result2.error) {
+        const errorMessage = result2.error.message || String(result2.error);
+        if (process.env["GEMINI_STRICT_TELEMETRY_LIMITS"] === "true" && errorMessage.includes("written more frequently than the maximum sampling period")) {
+          resultCallback({ code: import_core5.ExportResultCode.SUCCESS });
+          return;
+        }
+      }
+      resultCallback(result2);
+    });
+  }
 };
+function truncateLogPayload(payload, limit = 2e5) {
+  if (typeof payload === "string") {
+    return payload.length > limit ? payload.substring(0, limit) + "... (truncated due to size)" : payload;
+  }
+  if (Array.isArray(payload)) {
+    return payload.map((item) => truncateLogPayload(item, limit));
+  }
+  if (payload !== null && typeof payload === "object") {
+    const truncatedObj = {};
+    for (const [key, value] of Object.entries(payload)) {
+      truncatedObj[key] = truncateLogPayload(value, limit);
+    }
+    return truncatedObj;
+  }
+  return payload;
+}
 var GcpLogExporter = class {
   logging;
   log;
@@ -248136,20 +248185,46 @@ var GcpLogExporter = class {
   export(logs3, resultCallback) {
     try {
       const entries = logs3.map((log) => {
-        const entry = this.log.entry({
-          severity: this.mapSeverityToCloudLogging(log.severityNumber),
-          timestamp: new Date((0, import_core5.hrTimeToMilliseconds)(log.hrTime)),
-          resource: {
-            type: "global",
-            labels: {
-              project_id: this.logging.projectId
-            }
-          }
-        }, {
+        const rawPayload = {
           ...log.attributes,
           ...log.resource?.attributes,
           message: log.body
-        });
+        };
+        const isStrictTelemetry = process.env["GEMINI_STRICT_TELEMETRY_LIMITS"] === "true";
+        let finalPayload = rawPayload;
+        if (isStrictTelemetry) {
+          let safePayload = truncateLogPayload(rawPayload, 1e4);
+          let payloadString = JSON.stringify(safePayload);
+          if (payloadString && payloadString.length > 1e5) {
+            safePayload = truncateLogPayload(rawPayload, 2e3);
+            payloadString = JSON.stringify(safePayload);
+            if (payloadString && payloadString.length > 1e5) {
+              safePayload = truncateLogPayload(rawPayload, 5e3);
+              payloadString = JSON.stringify(safePayload);
+              if (payloadString && payloadString.length > 1e5) {
+                safePayload = {
+                  _warning: "Payload heavily truncated due to strict limits",
+                  data: payloadString.substring(0, 5e4) + "... (truncated)"
+                };
+              }
+            }
+          }
+          finalPayload = safePayload;
+        }
+        const entry = this.log.entry(
+          {
+            severity: this.mapSeverityToCloudLogging(log.severityNumber),
+            timestamp: new Date((0, import_core5.hrTimeToMilliseconds)(log.hrTime)),
+            resource: {
+              type: "global",
+              labels: {
+                project_id: this.logging.projectId
+              }
+            }
+          },
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+          finalPayload
+        );
         return entry;
       });
       const writePromise = this.log.write(entries).then(() => {
@@ -269321,7 +269396,7 @@ function getVersion() {
   }
   versionPromise = (async () => {
     const pkgJson = await getPackageJson(__dirname4);
-    return "0.42.0-preview.1";
+    return "0.43.0-preview.0";
   })();
   return versionPromise;
 }
@@ -270213,18 +270288,25 @@ function cloneChain(chain2) {
   return chain2.map(clonePolicy);
 }
 
+// packages/core/dist/src/utils/modelUtils.js
+function normalizeModelId(modelId) {
+  return modelId.startsWith("models/") ? modelId.slice(7) : modelId;
+}
+
 // packages/core/dist/src/availability/policyHelpers.js
 function resolvePolicyChain(config2, preferredModel, wrapsAround = false) {
-  const modelFromConfig = preferredModel ?? config2.getActiveModel?.() ?? config2.getModel();
-  const configuredModel = config2.getModel();
+  const normalizedPreferredModel = preferredModel ? normalizeModelId(preferredModel) : void 0;
+  const modelFromConfig = normalizeModelId(normalizedPreferredModel ?? config2.getActiveModel?.() ?? config2.getModel());
+  const configuredModel = normalizeModelId(config2.getModel());
   let chain2;
   const useGemini31 = config2.getGemini31LaunchedSync?.() ?? false;
   const useGemini31FlashLite = config2.getGemini31FlashLiteLaunchedSync?.() ?? false;
   const useCustomToolModel = config2.getUseCustomToolModelSync?.() ?? false;
   const hasAccessToPreview = config2.getHasAccessToPreviewModel?.() ?? true;
-  const resolvedModel = resolveModel(modelFromConfig, useGemini31, useGemini31FlashLite, useCustomToolModel, hasAccessToPreview, config2);
-  const isAutoPreferred = preferredModel ? isAutoModel(preferredModel, config2) : false;
+  const resolvedModel = normalizeModelId(resolveModel(modelFromConfig, useGemini31, useGemini31FlashLite, useCustomToolModel, hasAccessToPreview, config2));
+  const isAutoPreferred = normalizedPreferredModel ? isAutoModel(normalizedPreferredModel, config2) : false;
   const isAutoConfigured = isAutoModel(configuredModel, config2);
+  const effectiveWrapsAround = wrapsAround || isAutoPreferred || isAutoConfigured || isGemini3Model(resolvedModel, config2);
   if (config2.getExperimentalDynamicModelConfiguration?.() === true) {
     const context2 = {
       useGemini3_1: useGemini31,
@@ -270233,13 +270315,13 @@ function resolvePolicyChain(config2, preferredModel, wrapsAround = false) {
     };
     if (resolvedModel === DEFAULT_GEMINI_FLASH_LITE_MODEL) {
       chain2 = config2.modelConfigService.resolveChain("lite", context2);
-    } else if (isGemini3Model(resolvedModel, config2) || isAutoPreferred || isAutoConfigured) {
+    } else if (isGemini3Model(normalizeModelId(resolvedModel), config2) || isAutoPreferred || isAutoConfigured) {
       if (isAutoConfigured && config2.modelConfigService.getModelChain(configuredModel)) {
         chain2 = config2.modelConfigService.resolveChain(configuredModel, context2);
       }
       if (!chain2) {
         const isAutoSelection = isAutoPreferred || isAutoConfigured;
-        const previewEnabled = hasAccessToPreview && (isGemini3Model(resolvedModel, config2) || preferredModel === PREVIEW_GEMINI_MODEL_AUTO || configuredModel === PREVIEW_GEMINI_MODEL_AUTO);
+        const previewEnabled = hasAccessToPreview && (isGemini3Model(resolvedModel, config2) || normalizedPreferredModel === PREVIEW_GEMINI_MODEL_AUTO || configuredModel === PREVIEW_GEMINI_MODEL_AUTO);
         const autoPrefix = isAutoSelection ? "auto-" : "";
         const chainKey = previewEnabled ? "preview" : "default";
         chain2 = config2.modelConfigService.resolveChain(`${autoPrefix}${chainKey}`, context2);
@@ -270248,14 +270330,14 @@ function resolvePolicyChain(config2, preferredModel, wrapsAround = false) {
     if (!chain2) {
       chain2 = createSingleModelChain(modelFromConfig);
     }
-    chain2 = applyDynamicSlicing(chain2, resolvedModel, wrapsAround);
+    chain2 = applyDynamicSlicing(chain2, resolvedModel, effectiveWrapsAround);
   } else {
     if (resolvedModel === DEFAULT_GEMINI_FLASH_LITE_MODEL) {
       chain2 = getFlashLitePolicyChain();
     } else if (isGemini3Model(resolvedModel, config2) || isAutoPreferred || isAutoConfigured) {
       const isAutoSelection = isAutoPreferred || isAutoConfigured;
       if (hasAccessToPreview) {
-        const previewEnabled = isGemini3Model(resolvedModel, config2) || preferredModel === PREVIEW_GEMINI_MODEL_AUTO || configuredModel === PREVIEW_GEMINI_MODEL_AUTO;
+        const previewEnabled = isGemini3Model(resolvedModel, config2) || normalizedPreferredModel === PREVIEW_GEMINI_MODEL_AUTO || configuredModel === PREVIEW_GEMINI_MODEL_AUTO;
         chain2 = getModelPolicyChain({
           previewEnabled,
           isAutoSelection,
@@ -270277,7 +270359,7 @@ function resolvePolicyChain(config2, preferredModel, wrapsAround = false) {
     } else {
       chain2 = createSingleModelChain(modelFromConfig);
     }
-    chain2 = applyDynamicSlicing(chain2, resolvedModel, wrapsAround);
+    chain2 = applyDynamicSlicing(chain2, resolvedModel, effectiveWrapsAround);
   }
   if (config2?.getApprovalMode?.() === ApprovalMode.PLAN) {
     return chain2.map((policy) => ({
@@ -270288,14 +270370,16 @@ function resolvePolicyChain(config2, preferredModel, wrapsAround = false) {
   return chain2;
 }
 function applyDynamicSlicing(chain2, resolvedModel, wrapsAround) {
-  const activeIndex = chain2.findIndex((policy) => policy.model === resolvedModel);
+  const normalizedResolved = normalizeModelId(resolvedModel);
+  const activeIndex = chain2.findIndex((policy) => normalizeModelId(policy.model) === normalizedResolved);
   if (activeIndex !== -1) {
     return wrapsAround ? [...chain2.slice(activeIndex), ...chain2.slice(0, activeIndex)] : [...chain2.slice(activeIndex)];
   }
   return [createDefaultPolicy(resolvedModel, { isLastResort: true })];
 }
 function buildFallbackPolicyContext(chain2, failedModel, wrapsAround = false) {
-  const index = chain2.findIndex((policy) => policy.model === failedModel);
+  const normalizedFailed = normalizeModelId(failedModel);
+  const index = chain2.findIndex((policy) => normalizeModelId(policy.model) === normalizedFailed);
   if (index === -1) {
     return { failedPolicy: void 0, candidates: chain2 };
   }
@@ -270891,6 +270975,15 @@ var BaseLlmClient = class {
     }
     return text;
   }
+  async countTokens(options) {
+    const model = options.modelConfigKey ? this.config.modelConfigService.getResolvedConfig(options.modelConfigKey).model : this.config.getActiveModel();
+    const result2 = await this.contentGenerator.countTokens({
+      model,
+      contents: options.contents,
+      config: options.abortSignal ? { abortSignal: options.abortSignal } : void 0
+    });
+    return { totalTokens: result2.totalTokens || 0 };
+  }
   async generateContent(options) {
     const { modelConfigKey, contents, systemInstruction, abortSignal, promptId, role, maxAttempts } = options;
     const shouldRetryOnContent = (response) => {
@@ -271470,6 +271563,9 @@ function isEditToolParams(args2) {
   }
   return "file_path" in args2 && typeof args2.file_path === "string" && "old_string" in args2 && typeof args2.old_string === "string" && "new_string" in args2 && typeof args2.new_string === "string";
 }
+function fileDiffToSummary(diff, editData) {
+  return diff.diffStat ? `${diff.diffStat.model_added_lines} added, ${diff.diffStat.model_removed_lines} removed` : `${editData.occurrences} replacements`;
+}
 var EditToolInvocation = class extends BaseToolInvocation {
   config;
   resolvedPath;
@@ -271846,8 +271942,20 @@ ${snippet2}`);
       if (jitContext) {
         llmContent = appendJitContext(llmContent, jitContext);
       }
+      const resultSummary = typeof displayResult === "string" ? displayResult : fileDiffToSummary(displayResult, editData);
       return {
         llmContent,
+        display: {
+          name: this._toolDisplayName,
+          description: this.getDescription(),
+          resultSummary,
+          result: {
+            type: "diff",
+            path: this.resolvedPath,
+            beforeText: editData.currentContent ?? "",
+            afterText: editData.newContent
+          }
+        },
         returnDisplay: displayResult
       };
     } catch (error40) {
@@ -272377,6 +272485,17 @@ ${snippet2}`);
       }
       return {
         llmContent,
+        display: {
+          name: WRITE_FILE_DISPLAY_NAME,
+          description: this.getDescription(),
+          resultSummary: diffStat ? `${diffStat.model_added_lines} added, ${diffStat.model_removed_lines} removed` : "Written",
+          result: {
+            type: "diff",
+            path: this.resolvedPath,
+            beforeText: correctedContentResult.originalContent ?? "",
+            afterText: correctedContentResult.correctedContent
+          }
+        },
         returnDisplay: displayResult
       };
     } catch (error40) {
@@ -273099,6 +273218,12 @@ var ProjectIdRequiredError = class extends Error {
     this.name = "ProjectIdRequiredError";
   }
 };
+var InvalidNumericProjectIdError = class extends Error {
+  constructor(projectId) {
+    super(`Invalid Google Cloud Project ID: "${projectId}". The GOOGLE_CLOUD_PROJECT (or GOOGLE_CLOUD_PROJECT_ID) environment variable must be set to your string-based Project ID (e.g., "my-project-123"), not your numeric Project Number. Please update your environment variables.`);
+    this.name = "InvalidNumericProjectIdError";
+  }
+};
 var ValidationCancelledError = class extends Error {
   constructor() {
     super("User cancelled account validation");
@@ -273124,6 +273249,9 @@ function resetUserDataCacheForTesting() {
 }
 async function setupUser(client, config2, httpOptions = {}) {
   const projectId = process.env["GOOGLE_CLOUD_PROJECT"] || process.env["GOOGLE_CLOUD_PROJECT_ID"] || void 0;
+  if (projectId && /^\d+$/.test(projectId)) {
+    throw new InvalidNumericProjectIdError(projectId);
+  }
   const projectCache = userDataCache.getOrCreate(client, () => createCache({
     storage: "map",
     defaultTtl: 3e4
@@ -273273,13 +273401,26 @@ function validateLoadCodeAssistResponse(res) {
 
 // packages/core/dist/src/utils/quotaErrorDetection.js
 function isApiError(error40) {
-  return typeof error40 === "object" && error40 !== null && "error" in error40 && // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-  typeof error40.error === "object" && // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-  "message" in error40.error;
+  if (typeof error40 !== "object" || error40 === null || !("error" in error40)) {
+    return false;
+  }
+  const errorProp = error40.error;
+  if (typeof errorProp !== "object" || errorProp === null) {
+    return false;
+  }
+  return "code" in errorProp && typeof errorProp.code === "number" && "message" in errorProp && typeof errorProp.message === "string" && "status" in errorProp && typeof errorProp.status === "string";
 }
 function isStructuredError(error40) {
-  return typeof error40 === "object" && error40 !== null && "message" in error40 && // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-  typeof error40.message === "string";
+  if (typeof error40 !== "object" || error40 === null || !("message" in error40)) {
+    return false;
+  }
+  if (typeof error40.message !== "string") {
+    return false;
+  }
+  if ("status" in error40 && typeof error40.status !== "number") {
+    return false;
+  }
+  return true;
 }
 
 // packages/core/dist/src/utils/tokenCalculation.js
@@ -273296,9 +273437,10 @@ function estimateTextTokens(text, charsPerToken) {
     return text.length / charsPerToken;
   }
   let tokens = 0;
+  const asciiTokensPerChar = 1 / charsPerToken;
   for (let i3 = 0; i3 < text.length; i3++) {
     if (text.charCodeAt(i3) <= 127) {
-      tokens += ASCII_TOKENS_PER_CHAR;
+      tokens += asciiTokensPerChar;
     } else {
       tokens += NON_ASCII_TOKENS_PER_CHAR;
     }
@@ -273937,10 +274079,6 @@ function validateBaseUrl(baseUrl) {
   }
 }
 async function createContentGeneratorConfig(config2, authType, apiKey, baseUrl, customHeaders, vertexAiRouting) {
-  const geminiApiKey = apiKey || process.env["GEMINI_API_KEY"] || await loadApiKey() || void 0;
-  const googleApiKey = process.env["GOOGLE_API_KEY"] || void 0;
-  const googleCloudProject = process.env["GOOGLE_CLOUD_PROJECT"] || process.env["GOOGLE_CLOUD_PROJECT_ID"] || void 0;
-  const googleCloudLocation = process.env["GOOGLE_CLOUD_LOCATION"] || void 0;
   const contentGeneratorConfig = {
     authType,
     proxy: config2?.getProxy(),
@@ -273951,6 +274089,10 @@ async function createContentGeneratorConfig(config2, authType, apiKey, baseUrl,
   if (authType === AuthType.LOGIN_WITH_GOOGLE || authType === AuthType.COMPUTE_ADC) {
     return contentGeneratorConfig;
   }
+  const geminiApiKey = apiKey || process.env["GEMINI_API_KEY"] || await loadApiKey() || void 0;
+  const googleApiKey = process.env["GOOGLE_API_KEY"] || void 0;
+  const googleCloudProject = process.env["GOOGLE_CLOUD_PROJECT"] || process.env["GOOGLE_CLOUD_PROJECT_ID"] || void 0;
+  const googleCloudLocation = process.env["GOOGLE_CLOUD_LOCATION"] || void 0;
   if (authType === AuthType.USE_GEMINI && geminiApiKey) {
     contentGeneratorConfig.apiKey = geminiApiKey;
     contentGeneratorConfig.vertexai = false;
@@ -274898,6 +275040,11 @@ ${directoryContent}`;
       }
       return {
         llmContent: resultMessage,
+        display: {
+          name: LS_DISPLAY_NAME,
+          description: this.getDescription(),
+          resultSummary: displayMessage
+        },
         returnDisplay: {
           summary: displayMessage,
           files: entries.map((entry) => `${entry.isDirectory ? "[DIR] " : ""}${entry.name}`)
@@ -275130,7 +275277,7 @@ var IgnoreFileParser = class {
     return this.patterns;
   }
   getIgnoreFilePaths() {
-    return this.fileNames.slice().reverse().map((fileName) => path39.join(this.projectRoot, fileName)).filter((filePath) => fs34.existsSync(filePath));
+    return this.fileNames.slice().reverse().map((fileName) => path39.join(this.projectRoot, fileName)).filter((filePath) => fs34.statSync(filePath, { throwIfNoEntry: false })?.isFile() ?? false);
   }
   /**
    * Returns true if at least one ignore file exists and has patterns.
@@ -275353,7 +275500,8 @@ var FileDiscoveryService = class {
     const paths = [];
     if (this.gitIgnoreFilter && this.defaultFilterFileOptions.respectGitIgnore) {
       const gitIgnorePath = path41.join(this.projectRoot, ".gitignore");
-      if (fs36.existsSync(gitIgnorePath)) {
+      const stat9 = fs36.statSync(gitIgnorePath, { throwIfNoEntry: false });
+      if (stat9?.isFile()) {
         paths.push(gitIgnorePath);
       }
     }
@@ -275438,8 +275586,15 @@ ${result2.llmContent}`;
         llmContent = appendJitContextToParts(llmContent, jitContext);
       }
     }
+    const displayResultSummary = result2.isTruncated ? `${result2.linesShown[0]}-${result2.linesShown[1]} of ${result2.originalLineCount}` : lines !== void 0 ? `${lines} lines` : void 0;
     return {
       llmContent,
+      display: {
+        name: READ_FILE_DISPLAY_NAME,
+        description: this.getDescription(),
+        resultSummary: displayResultSummary,
+        result: { type: "text", text: result2.returnDisplay || "" }
+      },
       returnDisplay: result2.returnDisplay || ""
     };
   }
@@ -275462,12 +275617,6 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
     if (validationError) {
       return validationError;
     }
-    if (params.start_line !== void 0 && params.start_line < 1) {
-      return "start_line must be at least 1";
-    }
-    if (params.end_line !== void 0 && params.end_line < 1) {
-      return "end_line must be at least 1";
-    }
     if (params.start_line !== void 0 && params.end_line !== void 0 && params.start_line > params.end_line) {
       return "start_line cannot be greater than end_line";
     }
@@ -281703,10 +281852,10 @@ var Ignore = class {
   ignored(p) {
     const fullpath = p.fullpath();
     const fullpaths = `${fullpath}/`;
-    const relative12 = p.relative() || ".";
-    const relatives = `${relative12}/`;
+    const relative11 = p.relative() || ".";
+    const relatives = `${relative11}/`;
     for (const m of this.relative) {
-      if (m.match(relative12) || m.match(relatives))
+      if (m.match(relative11) || m.match(relatives))
         return true;
     }
     for (const m of this.absolute) {
@@ -281717,9 +281866,9 @@ var Ignore = class {
   }
   childrenIgnored(p) {
     const fullpath = p.fullpath() + "/";
-    const relative12 = (p.relative() || ".") + "/";
+    const relative11 = (p.relative() || ".") + "/";
     for (const m of this.relativeChildren) {
-      if (m.match(relative12))
+      if (m.match(relative11))
         return true;
     }
     for (const m of this.absoluteChildren) {
@@ -282824,7 +282973,19 @@ var GrepToolInvocation = class extends BaseToolInvocation {
       } else {
         searchLocationDescription = `in path "${searchDirDisplay}"`;
       }
-      return await formatGrepResults(allMatches, this.params, searchLocationDescription, totalMaxMatches);
+      const result2 = await formatGrepResults(allMatches, this.params, searchLocationDescription, totalMaxMatches);
+      return {
+        ...result2,
+        display: {
+          name: this._toolDisplayName,
+          description: this.getDescription(),
+          resultSummary: result2.returnDisplay.summary,
+          result: {
+            type: "text",
+            text: result2.llmContent.split("\n---\n").slice(1).join("\n---\n")
+          }
+        }
+      };
     } catch (error40) {
       debugLogger.warn(`Error during GrepLogic execution: ${error40}`);
       const errorMessage = getErrorMessage(error40);
@@ -283283,7 +283444,19 @@ var GrepToolInvocation2 = class extends BaseToolInvocation {
       const matchCount = allMatches.filter((m) => !m.isContext).length;
       allMatches = await this.enrichWithRipgrepAutoContext(allMatches, matchCount, totalMaxMatches, searchDirAbs, timeoutController.signal);
       const searchLocationDescription = `in path "${searchDirDisplay}"`;
-      return await formatGrepResults(allMatches, this.params, searchLocationDescription, totalMaxMatches);
+      const result2 = await formatGrepResults(allMatches, this.params, searchLocationDescription, totalMaxMatches);
+      return {
+        ...result2,
+        display: {
+          name: this._toolDisplayName,
+          description: this.getDescription(),
+          resultSummary: result2.returnDisplay.summary,
+          result: {
+            type: "text",
+            text: result2.llmContent.split("\n---\n").slice(1).join("\n---\n")
+          }
+        }
+      };
     } catch (error40) {
       debugLogger.warn(`Error during GrepLogic execution: ${error40}`);
       const errorMessage = getErrorMessage(error40);
@@ -286819,8 +286992,18 @@ ${result2.output}`;
           ...executionError
         };
       }
+      const displayResultSummary = result2.backgrounded ? `PID: ${result2.pid}` : result2.exitCode !== null && result2.exitCode !== 0 ? `Exit Code: ${result2.exitCode}` : void 0;
       return {
         llmContent,
+        display: {
+          name: "Shell",
+          description: this.getDescription(),
+          resultSummary: displayResultSummary,
+          result: typeof returnDisplay === "string" ? { type: "text", text: returnDisplay } : (
+            // TODO: Add support for terminal display type (AnsiOutput)
+            void 0
+          )
+        },
         returnDisplay,
         data,
         ...executionError
@@ -292906,6 +293089,11 @@ Strategic Intent: ${strategicIntent.trim()}`;
     }
     return {
       llmContent,
+      display: {
+        format: "notice",
+        name: title || UPDATE_TOPIC_DISPLAY_NAME,
+        description: this.getDescription()
+      },
       returnDisplay
     };
   }
@@ -293357,6 +293545,9 @@ var GeminiChat = class {
     this.chatRecordingService = new ChatRecordingService(context2);
     this.lastPromptTokenCount = estimateTokenCountSync(this.agentHistory.flatMap((c4) => c4.parts || []));
   }
+  get loopContext() {
+    return this.context;
+  }
   async initialize(resumedSessionData, kind = "main") {
     await this.chatRecordingService.initialize(resumedSessionData, kind);
   }
@@ -293614,9 +293805,10 @@ var GeminiChat = class {
       lastModelToUse = modelToUse;
       lastConfig = config2;
       lastContentsToUse = contentsToUse;
+      const finalContents = stripToolCallIdPrefixes(contentsToUse);
       return this.context.config.getContentGenerator().generateContentStream({
         model: modelToUse,
-        contents: contentsToUse,
+        contents: finalContents,
         config: config2
       }, prompt_id, role);
     };
@@ -293785,7 +293977,9 @@ This error was probably caused by cyclic schema references in one of the followi
     const finalFunctionCallsMap = /* @__PURE__ */ new Map();
     const legacyFunctionCalls = [];
     const callIndexToId = /* @__PURE__ */ new Map();
+    let runningFunctionCallCounter = 0;
     for await (const chunk of streamResponse) {
+      const currentChunkStartCounter = runningFunctionCallCounter;
       const candidateWithReason = chunk?.candidates?.find((candidate) => candidate.finishReason);
       if (candidateWithReason) {
         finishReason = candidateWithReason.finishReason;
@@ -293794,18 +293988,30 @@ This error was probably caused by cyclic schema references in one of the followi
         if (this.context.config.isContextManagementEnabled()) {
           for (let i3 = 0; i3 < chunk.functionCalls.length; i3++) {
             const fnCall = chunk.functionCalls[i3];
+            const globalIndex = currentChunkStartCounter + i3;
             if (!fnCall.id) {
-              let id = callIndexToId.get(i3);
+              let id = callIndexToId.get(globalIndex);
               if (!id) {
                 id = `synth_${this.context.promptId}_${Date.now()}_${this.callCounter++}`;
-                callIndexToId.set(i3, id);
-                debugLogger.log(`[GeminiChat] Assigned synthetic ID: ${id} to tool at index ${i3}: ${fnCall.name}`);
+                callIndexToId.set(globalIndex, id);
+                debugLogger.log(`[GeminiChat] Assigned synthetic ID: ${id} to tool at index ${globalIndex}: ${fnCall.name}`);
               }
               fnCall.id = id;
             }
+            const name3 = fnCall.name?.trim() || "generic_tool";
+            if (fnCall.id && !fnCall.id.startsWith(`${name3}__`)) {
+              fnCall.id = `${name3}__${fnCall.id}`;
+            }
             finalFunctionCallsMap.set(fnCall.id, fnCall);
           }
+          runningFunctionCallCounter += chunk.functionCalls.length;
         } else {
+          for (const fnCall of chunk.functionCalls) {
+            const name3 = fnCall.name?.trim() || "generic_tool";
+            if (fnCall.id && !fnCall.id.startsWith(`${name3}__`)) {
+              fnCall.id = `${name3}__${fnCall.id}`;
+            }
+          }
           legacyFunctionCalls.push(...chunk.functionCalls);
         }
       }
@@ -293819,13 +294025,18 @@ This error was probably caused by cyclic schema references in one of the followi
           if (content.parts.some((part) => part.functionCall)) {
             hasToolCall = true;
           }
+          let localFunctionCallCounter = 0;
           modelResponseParts.push(...content.parts.filter((part) => !part.thought).map((part) => {
             if (!this.context.config.isContextManagementEnabled()) {
               return part;
             }
+            let callIndex;
+            if (part.functionCall) {
+              callIndex = currentChunkStartCounter + localFunctionCallCounter++;
+            }
             return {
               ...part,
-              callIndex: chunk.functionCalls?.findIndex((fc) => fc.name === part.functionCall?.name)
+              callIndex
             };
           }));
         }
@@ -293972,6 +294183,82 @@ function isSchemaDepthError(errorMessage) {
 function isInvalidArgumentError(errorMessage) {
   return errorMessage.includes("Request contains an invalid argument");
 }
+function stripToolCallIdPrefixes(contents) {
+  return contents.map((content) => ({
+    ...content,
+    parts: (content.parts || []).map((part) => {
+      const newPart = { ...part };
+      if (newPart.functionCall) {
+        const fc = newPart.functionCall;
+        const name3 = fc.name?.trim() || "generic_tool";
+        if (fc.id && fc.id.startsWith(`${name3}__`)) {
+          newPart.functionCall = {
+            name: fc.name,
+            args: fc.args,
+            id: fc.id.substring(name3.length + 2)
+          };
+        }
+      }
+      if (newPart.functionResponse) {
+        const fr = newPart.functionResponse;
+        const name3 = fr.name?.trim() || "generic_tool";
+        if (fr.id && fr.id.startsWith(`${name3}__`)) {
+          newPart.functionResponse = {
+            name: fr.name,
+            response: fr.response,
+            id: fr.id.substring(name3.length + 2)
+          };
+        }
+      }
+      return newPart;
+    })
+  }));
+}
+
+// packages/core/dist/src/agent/tool-display-utils.js
+function populateToolDisplay({ name: name3, invocation, resultDisplay, displayName, display: prevDisplay }) {
+  const display = {
+    name: displayName || name3,
+    description: invocation?.getDescription?.(),
+    ...prevDisplay
+  };
+  if (resultDisplay !== void 0 && display.result === void 0) {
+    display.result = toolResultDisplayToDisplayContent(resultDisplay);
+  }
+  return display;
+}
+function toolResultDisplayToDisplayContent(resultDisplay) {
+  if (typeof resultDisplay === "string") {
+    return { type: "text", text: resultDisplay };
+  }
+  if (typeof resultDisplay === "object" && resultDisplay !== null && "fileDiff" in resultDisplay && "newContent" in resultDisplay) {
+    return {
+      type: "diff",
+      path: resultDisplay.filePath || resultDisplay.fileName,
+      beforeText: resultDisplay.originalContent ?? "",
+      afterText: resultDisplay.newContent
+    };
+  }
+  return {
+    type: "text",
+    text: JSON.stringify(resultDisplay)
+  };
+}
+function renderDisplayDiff(diff) {
+  return createPatch(diff.path || "file", diff.beforeText, diff.afterText, "Original", "Modified", { context: 3 });
+}
+function displayContentToString(display) {
+  if (!display) {
+    return void 0;
+  }
+  if (display.type === "text") {
+    return display.text;
+  }
+  if (display.type === "diff") {
+    return renderDisplayDiff(display);
+  }
+  return JSON.stringify(display);
+}
 
 // packages/core/dist/src/core/turn.js
 var GeminiEventType;
@@ -294129,13 +294416,33 @@ ${[...this.pendingCitations].sort().join("\n")}`
     }
   }
   handlePendingFunctionCall(fnCall, traceId) {
-    const name3 = fnCall.name || "undefined_tool_name";
+    const name3 = fnCall.name?.trim() || "generic_tool";
     const args2 = fnCall.args || {};
-    const callId = fnCall.id ?? (this.chat.context.config.isContextManagementEnabled() ? `synth_${this.prompt_id}_${Date.now()}_${this.callCounter++}` : `${name3}_${Date.now()}_${this.callCounter++}`);
+    const rawCallId = fnCall.id ?? (this.chat.context.config.isContextManagementEnabled() ? `synth_${this.prompt_id}_${Date.now()}_${this.callCounter++}` : `${name3}_${Date.now()}_${this.callCounter++}`);
+    const callId = rawCallId.startsWith(`${name3}__`) ? rawCallId : `${name3}__${rawCallId}`;
+    fnCall.id = callId;
+    const tool = this.chat.loopContext.toolRegistry.getTool(name3);
+    let display;
+    if (tool) {
+      let invocation;
+      try {
+        invocation = tool.build(args2);
+      } catch {
+      }
+      display = populateToolDisplay({
+        name: name3,
+        invocation,
+        displayName: tool.displayName
+      });
+      if (!display.description) {
+        display.description = tool.description;
+      }
+    }
     const toolCallRequest = {
       callId,
       name: name3,
       args: args2,
+      display,
       isClientInitiated: false,
       prompt_id: this.prompt_id,
       traceId
@@ -294277,7 +294584,7 @@ Use the following guidelines to optimize your search and read patterns.
 - Prefer using tools like ${GREP_TOOL_NAME} to identify points of interest instead of reading lots of files individually.
 - If you need to read multiple ranges in a file, do so parallel, in as few turns as possible.
 - It is more important to reduce extra turns, but please also try to minimize unnecessarily large file reads and search results, when doing so doesn't result in extra turns. Do this by always providing conservative limits and scopes to tools like ${READ_FILE_TOOL_NAME} and ${GREP_TOOL_NAME}.
-- ${READ_FILE_TOOL_NAME} fails if ${EDIT_PARAM_OLD_STRING} is ambiguous, causing extra turns. Take care to read enough with ${READ_FILE_TOOL_NAME} and ${GREP_TOOL_NAME} to make the edit unambiguous.
+- ${EDIT_TOOL_NAME} fails if ${EDIT_PARAM_OLD_STRING} is ambiguous, causing extra turns. Take care to read enough with ${READ_FILE_TOOL_NAME} and ${GREP_TOOL_NAME} to make the edit unambiguous.
 - You can compensate for the risk of missing results with scoped or limited searches by doing multiple searches in parallel.
 - Your primary goal is still to do your best quality work. Efficiency is an important, but secondary concern.
 </guidelines>
@@ -296756,6 +297063,13 @@ var SubagentActivityErrorType;
 })(SubagentActivityErrorType || (SubagentActivityErrorType = {}));
 var SUBAGENT_REJECTED_ERROR_PREFIX = "User rejected this operation.";
 var SUBAGENT_CANCELLED_ERROR_MESSAGE = "Request cancelled.";
+var SubagentState;
+(function(SubagentState2) {
+  SubagentState2["RUNNING"] = "running";
+  SubagentState2["COMPLETED"] = "completed";
+  SubagentState2["ERROR"] = "error";
+  SubagentState2["CANCELLED"] = "cancelled";
+})(SubagentState || (SubagentState = {}));
 function isSubagentProgress(obj) {
   return typeof obj === "object" && obj !== null && "isSubagentProgress" in obj && obj.isSubagentProgress === true;
 }
@@ -300957,7 +301271,7 @@ var A2AAuthProviderFactory = class _A2AAuthProviderFactory {
         return provider;
       }
       case "oauth2": {
-        const { OAuth2AuthProvider } = await import("./oauth2-provider-ZPJOR5SG.js");
+        const { OAuth2AuthProvider } = await import("./oauth2-provider-DOSIH6VE.js");
         const provider = new OAuth2AuthProvider(authConfig, options.agentName ?? "unknown", agentCard, options.agentCardUrl);
         await provider.initialize();
         return provider;
@@ -302191,8 +302505,10 @@ var SchedulerStateManager = class {
     const call = this.activeCalls.get(callId);
     if (!call || call.status === CoreToolCallStatus.Error)
       return;
+    const display = call.request.display ? { ...call.request.display } : { name: call.request.name };
+    display.description = newInvocation.getDescription();
     this.activeCalls.set(callId, this.patchCall(call, {
-      request: { ...call.request, args: newArgs },
+      request: { ...call.request, args: newArgs, display },
       invocation: newInvocation
     }));
     this.emitUpdate();
@@ -304384,9 +304700,30 @@ var NodeType;
   NodeType2["SNAPSHOT"] = "SNAPSHOT";
   NodeType2["ROLLING_SUMMARY"] = "ROLLING_SUMMARY";
 })(NodeType || (NodeType = {}));
+function isAgentThought(node) {
+  return node.type === NodeType.AGENT_THOUGHT;
+}
+function isAgentYield(node) {
+  return node.type === NodeType.AGENT_YIELD;
+}
 function isToolExecution(node) {
   return node.type === NodeType.TOOL_EXECUTION;
 }
+function isMaskedTool(node) {
+  return node.type === NodeType.MASKED_TOOL;
+}
+function isUserPrompt(node) {
+  return node.type === NodeType.USER_PROMPT;
+}
+function isSystemEvent(node) {
+  return node.type === NodeType.SYSTEM_EVENT;
+}
+function isSnapshot(node) {
+  return node.type === NodeType.SNAPSHOT;
+}
+function isRollingSummary(node) {
+  return node.type === NodeType.ROLLING_SUMMARY;
+}
 
 // packages/core/dist/src/context/processors/nodeDistillationProcessor.js
 var NodeDistillationProcessorOptionsSchema = {
@@ -304519,44 +304856,279 @@ function createNodeDistillationProcessor(id, env2, options) {
 }
 
 // packages/core/dist/src/context/processors/stateSnapshotProcessor.js
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
+
+// packages/core/dist/src/context/utils/formatNodesForLlm.js
+function getSemanticToolWrapper(toolName) {
+  if (toolName.includes("search") || toolName.includes("grep"))
+    return `SEARCH RESULTS`;
+  if (toolName.includes("list") || toolName.includes("dir"))
+    return `WORKSPACE STRUCTURE`;
+  if (toolName.includes("shell") || toolName.includes("cmd"))
+    return `SHELL EXECUTION`;
+  if (toolName.includes("read") || toolName.includes("fetch"))
+    return `FILE/WEB CONTENT`;
+  return `TOOL RESPONSE`;
+}
+function formatNodesForLlm(nodes, options = {}) {
+  const maxToolChars = options.maxToolResponseChars ?? 2e3;
+  let transcript = "";
+  const uniqueTurns = Array.from(new Set(nodes.map((n3) => n3.turnId).filter(Boolean)));
+  for (const node of nodes) {
+    const payload = node.payload;
+    let nodeContent = "";
+    if (payload.text) {
+      nodeContent = payload.text;
+    } else if (payload.functionCall) {
+      nodeContent = `CALL: ${payload.functionCall.name}(${JSON.stringify(payload.functionCall.args)})`;
+    } else if (payload.functionResponse) {
+      const toolName = payload.functionResponse.name || "unknown_tool";
+      const rawResponse = JSON.stringify(payload.functionResponse.response);
+      const semanticWrapper = getSemanticToolWrapper(toolName);
+      let formattedResponse = rawResponse;
+      if (rawResponse.length > maxToolChars) {
+        const half = Math.floor(maxToolChars / 2);
+        const truncatedCount = rawResponse.length - maxToolChars;
+        formattedResponse = `${rawResponse.substring(0, half)}... [TRUNCATED ${truncatedCount} chars] ...${rawResponse.substring(rawResponse.length - half)}`;
+      }
+      nodeContent = `[${semanticWrapper} (${toolName})]: ${formattedResponse}`;
+    } else {
+      nodeContent = JSON.stringify(payload);
+    }
+    const role = (node.role || "system").toUpperCase();
+    let turnMarker = "";
+    if (node.turnId) {
+      const idx = uniqueTurns.indexOf(node.turnId);
+      if (idx !== -1) {
+        const relativeIdx = idx - (uniqueTurns.length - 1);
+        turnMarker = `[Turn ${relativeIdx}] `;
+      }
+    }
+    transcript += `${turnMarker}[${role}] [${node.type}]: ${nodeContent}
+`;
+  }
+  return transcript;
+}
 
 // packages/core/dist/src/context/utils/snapshotGenerator.js
+import { randomUUID as randomUUID8 } from "node:crypto";
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isNumberArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "number");
+}
+function isTaskArray(value) {
+  return Array.isArray(value) && value.every((item) => {
+    if (!isRecord(item))
+      return false;
+    const id = item["id"];
+    const desc = item["description"];
+    return typeof id === "string" && typeof desc === "string";
+  });
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function findLatestSnapshotBaseline(targets) {
+  const lastSnapshotNode = [...targets].reverse().find((n3) => n3.type === NodeType.SNAPSHOT && n3.payload.text);
+  if (lastSnapshotNode?.payload.text) {
+    return {
+      text: lastSnapshotNode.payload.text,
+      abstractsIds: lastSnapshotNode.abstractsIds ? [...lastSnapshotNode.abstractsIds] : [],
+      id: lastSnapshotNode.id
+    };
+  }
+  return void 0;
+}
 var SnapshotGenerator = class {
   env;
   constructor(env2) {
     this.env = env2;
   }
-  async synthesizeSnapshot(nodes, systemInstruction) {
-    const systemPrompt = systemInstruction ?? `You are an expert Context Memory Manager. You will be provided with a raw transcript of older conversation turns between a user and an AI assistant.
-Your task is to synthesize these turns into a single, dense, factual snapshot that preserves all critical context, preferences, active tasks, and factual knowledge.
+  async synthesizeSnapshot(nodes, previousStateJson, options = {}) {
+    const emptyState = {
+      active_tasks: [],
+      discovered_facts: [],
+      constraints_and_preferences: [],
+      recent_arc: []
+    };
+    let previousState = emptyState;
+    if (previousStateJson) {
+      try {
+        const parsed = JSON.parse(previousStateJson);
+        if (isRecord(parsed)) {
+          let loadedArc = [];
+          if (isStringArray(parsed["recent_arc"])) {
+            loadedArc = parsed["recent_arc"];
+          } else if (isString(parsed["summary"]) && parsed["summary"]) {
+            loadedArc = [parsed["summary"]];
+          }
+          previousState = {
+            active_tasks: isTaskArray(parsed["active_tasks"]) ? parsed["active_tasks"] : [],
+            discovered_facts: isStringArray(parsed["discovered_facts"]) ? parsed["discovered_facts"] : [],
+            constraints_and_preferences: isStringArray(parsed["constraints_and_preferences"]) ? parsed["constraints_and_preferences"] : [],
+            recent_arc: loadedArc
+          };
+        }
+      } catch {
+      }
+    }
+    let pressureWarning = "";
+    const stateString = JSON.stringify(previousState);
+    const estimatedTokens = this.env.tokenCalculator.estimateTokensForString(stateString);
+    const maxTokens = options.maxStateTokens ?? 4e3;
+    if (estimatedTokens > maxTokens * 0.8) {
+      pressureWarning = `
 
-Discard conversational filler, pleasantries, and redundant back-and-forth iterations. Output ONLY the raw factual snapshot, formatted compactly. Do not include markdown wrappers, prefixes like "Here is the snapshot", or conversational elements.`;
-    let userPromptText = "TRANSCRIPT TO SNAPSHOT:\n\n";
-    for (const node of nodes) {
-      const payload = node.payload;
-      let nodeContent = "";
-      if (payload.text) {
-        nodeContent = payload.text;
-      } else if (payload.functionCall) {
-        nodeContent = `CALL: ${payload.functionCall.name}(${JSON.stringify(payload.functionCall.args)})`;
-      } else if (payload.functionResponse) {
-        nodeContent = `RESPONSE: ${JSON.stringify(payload.functionResponse.response)}`;
-      }
-      userPromptText += `[${node.type}]: ${nodeContent}
-`;
+[CRITICAL WARNING]: The Master State is currently at ${(estimatedTokens / maxTokens * 100).toFixed(0)}% of its maximum capacity! You MUST aggressively prune obsolete, irrelevant, or overly granular facts and constraints using \`obsolete_fact_indices\` and \`obsolete_constraint_indices\`.`;
     }
-    const response = await this.env.llmClient.generateContent({
-      role: LlmRole.UTILITY_STATE_SNAPSHOT_PROCESSOR,
-      modelConfigKey: { model: "gemini-3-flash-base" },
-      contents: [{ role: "user", parts: [{ text: userPromptText }] }],
-      systemInstruction: { role: "system", parts: [{ text: systemPrompt }] },
-      promptId: this.env.promptId,
-      abortSignal: new AbortController().signal
-    });
-    const candidate = response.candidates?.[0];
-    const textPart = candidate?.content?.parts?.[0];
-    return textPart?.text || "";
+    const systemPrompt = `You are an expert Context Memory Manager. You maintain the long-term "Master State" of the AI agent's memory.
+You will be provided with the CURRENT Master State and a raw transcript of new conversation turns.
+Your task is to generate a JSON Delta Patch representing what has changed in the transcript.${pressureWarning}
+
+CRITICAL OPERATIONAL RULES:
+1. FACTS: Extract explicit empirical facts (file paths, exact error codes, specific configs).
+2. PRUNING: Keep facts dense. Use obsolete indices to aggressively delete facts that are no longer relevant to the current objective.
+3. TASKS: Add any new active user requests to "new_tasks".
+4. TASK RESOLUTION: A task may ONLY be placed in "resolved_task_ids" if a success message or explicit confirmation was provided in the transcript. If the task was being worked on but no final confirmation exists, it MUST remain active. Do not prematurely resolve tasks.`;
+    const userPromptText = `CURRENT MASTER STATE:
+${JSON.stringify(previousState, null, 2)}
+
+TRANSCRIPT OF NEW TURNS:
+${formatNodesForLlm(nodes)}`;
+    const patchSchema = {
+      type: "object",
+      properties: {
+        new_facts: {
+          type: "array",
+          items: { type: "string" },
+          description: "New specific, empirical facts discovered in this transcript chunk."
+        },
+        new_constraints: {
+          type: "array",
+          items: { type: "string" },
+          description: "New specific rules or instructions provided by the user in this chunk."
+        },
+        new_tasks: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              description: {
+                type: "string",
+                description: "The task goal/description."
+              }
+            }
+          }
+        },
+        resolved_task_ids: {
+          type: "array",
+          items: { type: "string" },
+          description: "IDs of tasks from the CURRENT MASTER STATE that were explicitly completed or abandoned in this transcript chunk."
+        },
+        obsolete_fact_indices: {
+          type: "array",
+          items: { type: "number" },
+          description: "Array indices of facts from CURRENT MASTER STATE that are no longer true or relevant and should be deleted."
+        },
+        obsolete_constraint_indices: {
+          type: "array",
+          items: { type: "number" },
+          description: "Array indices of constraints from CURRENT MASTER STATE that are no longer true or relevant and should be deleted."
+        },
+        chronological_summary: {
+          type: "string",
+          description: "A 1-2 sentence summary of the mechanical actions taken in this transcript chunk."
+        }
+      }
+    };
+    let patch = {};
+    try {
+      const result2 = await this.env.llmClient.generateJson({
+        role: LlmRole.UTILITY_STATE_SNAPSHOT_PROCESSOR,
+        modelConfigKey: { model: "context-snapshotter" },
+        contents: [{ role: "user", parts: [{ text: userPromptText }] }],
+        systemInstruction: { role: "system", parts: [{ text: systemPrompt }] },
+        schema: patchSchema,
+        promptId: this.env.promptId,
+        abortSignal: new AbortController().signal
+      });
+      if (isRecord(result2)) {
+        patch = result2;
+      }
+    } catch {
+      return JSON.stringify(previousState);
+    }
+    const newState = {
+      active_tasks: [...previousState.active_tasks],
+      discovered_facts: [...previousState.discovered_facts],
+      constraints_and_preferences: [
+        ...previousState.constraints_and_preferences
+      ],
+      recent_arc: [...previousState.recent_arc]
+    };
+    const resolvedIds = patch["resolved_task_ids"];
+    if (isStringArray(resolvedIds)) {
+      const resolvedSet = new Set(resolvedIds);
+      newState.active_tasks = newState.active_tasks.filter((t2) => !resolvedSet.has(t2.id));
+    }
+    const obsFacts = patch["obsolete_fact_indices"];
+    if (isNumberArray(obsFacts)) {
+      const dropSet = new Set(obsFacts);
+      newState.discovered_facts = newState.discovered_facts.filter((_, i3) => !dropSet.has(i3));
+    }
+    const obsConstraints = patch["obsolete_constraint_indices"];
+    if (isNumberArray(obsConstraints)) {
+      const dropSet = new Set(obsConstraints);
+      newState.constraints_and_preferences = newState.constraints_and_preferences.filter((_, i3) => !dropSet.has(i3));
+    }
+    const newTasks = patch["new_tasks"];
+    if (Array.isArray(newTasks)) {
+      for (const t2 of newTasks) {
+        if (isRecord(t2)) {
+          const desc = t2["description"];
+          if (typeof desc === "string" && desc) {
+            newState.active_tasks.push({
+              id: `task_${randomUUID8().slice(0, 8)}`,
+              description: desc
+            });
+          }
+        }
+      }
+    }
+    const newFacts = patch["new_facts"];
+    if (isStringArray(newFacts)) {
+      newState.discovered_facts.push(...newFacts);
+    }
+    const newConstraints = patch["new_constraints"];
+    if (isStringArray(newConstraints)) {
+      newState.constraints_and_preferences.push(...newConstraints);
+    }
+    const chronoSummary = patch["chronological_summary"];
+    if (typeof chronoSummary === "string" && chronoSummary) {
+      newState.recent_arc.push(chronoSummary);
+      const maxTurns = options.maxSummaryTurns ?? 5;
+      if (newState.recent_arc.length > maxTurns) {
+        newState.recent_arc = newState.recent_arc.slice(-maxTurns);
+      }
+    }
+    let currentTokens = this.env.tokenCalculator.estimateTokensForString(JSON.stringify(newState));
+    while (currentTokens > maxTokens) {
+      if (newState.discovered_facts.length > 0) {
+        newState.discovered_facts.shift();
+      } else if (newState.constraints_and_preferences.length > 0) {
+        newState.constraints_and_preferences.shift();
+      } else if (newState.recent_arc.length > 0) {
+        newState.recent_arc.shift();
+      } else if (newState.active_tasks.length > 0) {
+        newState.active_tasks.shift();
+      } else {
+        break;
+      }
+      currentTokens = this.env.tokenCalculator.estimateTokensForString(JSON.stringify(newState));
+    }
+    return JSON.stringify(newState);
   }
 };
 
@@ -304571,7 +305143,9 @@ var StateSnapshotProcessorOptionsSchema = {
     },
     freeTokensTarget: { type: "number", nullable: true },
     model: { type: "string", nullable: true },
-    systemInstruction: { type: "string", nullable: true }
+    systemInstruction: { type: "string", nullable: true },
+    maxSummaryTurns: { type: "number", nullable: true },
+    maxStateTokens: { type: "number", nullable: true }
   },
   required: []
 };
@@ -304595,7 +305169,7 @@ function createStateSnapshotProcessor(id, env2, options) {
           const targetIds = new Set(targets.map((t2) => t2.id));
           const isValid = consumedIds.every((id2) => targetIds.has(id2));
           if (isValid) {
-            const newId = randomUUID8();
+            const newId = randomUUID9();
             const snapshotNode = {
               id: newId,
               turnId: newId,
@@ -304636,9 +305210,29 @@ function createStateSnapshotProcessor(id, env2, options) {
       }
       if (nodesToSummarize.length < 2)
         return targets;
+      let previousStateJson = void 0;
+      let baselineIdToConsume = void 0;
+      const baseline = findLatestSnapshotBaseline(targets);
+      if (baseline) {
+        previousStateJson = baseline.text;
+        const summaryIdx = nodesToSummarize.findIndex((n3) => n3.id === baseline.id);
+        if (summaryIdx !== -1) {
+          baselineIdToConsume = baseline.id;
+          nodesToSummarize.splice(summaryIdx, 1);
+        }
+      } else {
+        debugLogger.log("[StateSnapshotProcessor] No previous snapshot found in context graph. Initializing new Master State baseline.");
+      }
       try {
-        const snapshotText = await generator.synthesizeSnapshot(nodesToSummarize, options.systemInstruction);
-        const newId = randomUUID8();
+        const snapshotText = await generator.synthesizeSnapshot(nodesToSummarize, previousStateJson, {
+          maxSummaryTurns: options.maxSummaryTurns,
+          maxStateTokens: options.maxStateTokens
+        });
+        const newId = randomUUID9();
+        const consumedIds = nodesToSummarize.map((n3) => n3.id);
+        if (baselineIdToConsume && !consumedIds.includes(baselineIdToConsume)) {
+          consumedIds.push(baselineIdToConsume);
+        }
         const snapshotNode = {
           id: newId,
           turnId: newId,
@@ -304646,9 +305240,8 @@ function createStateSnapshotProcessor(id, env2, options) {
           timestamp: nodesToSummarize[nodesToSummarize.length - 1].timestamp,
           role: "user",
           payload: { text: snapshotText },
-          abstractsIds: nodesToSummarize.map((n3) => n3.id)
+          abstractsIds: [...consumedIds]
         };
-        const consumedIds = nodesToSummarize.map((n3) => n3.id);
         const returnedNodes = targets.filter((t2) => !consumedIds.includes(t2.id));
         const firstRemovedIdx = targets.findIndex((t2) => consumedIds.includes(t2.id));
         if (firstRemovedIdx !== -1) {
@@ -304667,7 +305260,6 @@ function createStateSnapshotProcessor(id, env2, options) {
 }
 
 // packages/core/dist/src/context/processors/stateSnapshotAsyncProcessor.js
-import { randomUUID as randomUUID9 } from "node:crypto";
 var StateSnapshotAsyncProcessorOptionsSchema = {
   type: "object",
   properties: {
@@ -304676,7 +305268,9 @@ var StateSnapshotAsyncProcessorOptionsSchema = {
       enum: ["accumulate", "point-in-time"],
       nullable: true
     },
-    systemInstruction: { type: "string", nullable: true }
+    systemInstruction: { type: "string", nullable: true },
+    maxSummaryTurns: { type: "number", nullable: true },
+    maxStateTokens: { type: "number", nullable: true }
   },
   required: []
 };
@@ -304689,9 +305283,10 @@ function createStateSnapshotAsyncProcessor(id, env2, options) {
       if (targets.length === 0)
         return;
       try {
-        let nodesToSummarize = [...targets];
         let previousConsumedIds = [];
         const processorType = options.type ?? "point-in-time";
+        const nodesToSummarize = [...targets];
+        let previousStateJson = void 0;
         if (processorType === "accumulate") {
           const proposedSnapshots = inbox.getMessages("PROPOSED_SNAPSHOT");
           const accumulateSnapshots = proposedSnapshots.filter((s2) => s2.payload.type === "accumulate");
@@ -304700,19 +305295,29 @@ function createStateSnapshotAsyncProcessor(id, env2, options) {
             inbox.consume(latest.id);
             env2.inbox.drainConsumed(/* @__PURE__ */ new Set([latest.id]));
             previousConsumedIds = latest.payload.consumedIds;
-            const snapshotId = randomUUID9();
-            const previousStateNode = {
-              id: snapshotId,
-              turnId: snapshotId,
-              type: NodeType.SNAPSHOT,
-              timestamp: latest.timestamp,
-              role: "user",
-              payload: { text: latest.payload.newText }
-            };
-            nodesToSummarize = [previousStateNode, ...targets];
+            previousStateJson = latest.payload.newText;
+          } else {
+            const baseline = findLatestSnapshotBaseline(targets);
+            if (baseline) {
+              previousStateJson = baseline.text;
+              previousConsumedIds = [...baseline.abstractsIds];
+            } else {
+              debugLogger.log("[StateSnapshotAsyncProcessor] No previous snapshot found in Inbox or Graph. Initializing new Master State baseline in background.");
+            }
           }
         }
-        const snapshotText = await generator.synthesizeSnapshot(nodesToSummarize, options.systemInstruction);
+        if (previousStateJson) {
+          const summaryIdx = nodesToSummarize.findIndex((n3) => n3.type === NodeType.SNAPSHOT && n3.payload.text === previousStateJson);
+          if (summaryIdx !== -1) {
+            nodesToSummarize.splice(summaryIdx, 1);
+          }
+        }
+        if (nodesToSummarize.length === 0)
+          return;
+        const snapshotText = await generator.synthesizeSnapshot(nodesToSummarize, previousStateJson, {
+          maxSummaryTurns: options.maxSummaryTurns,
+          maxStateTokens: options.maxStateTokens
+        });
         const newConsumedIds = [
           ...previousConsumedIds,
           ...targets.map((t2) => t2.id)
@@ -304789,7 +305394,9 @@ var generalistProfile = {
         triggers: ["gc_backstop"],
         processors: [
           createStateSnapshotProcessor("StateSnapshotSync", env2, resolveProcessorOptions(config2, "StateSnapshotSync", {
-            target: "max"
+            target: "max",
+            maxStateTokens: 4e3,
+            maxSummaryTurns: 5
           }))
         ]
       }
@@ -304801,7 +305408,9 @@ var generalistProfile = {
       triggers: ["nodes_aged_out"],
       processors: [
         createStateSnapshotAsyncProcessor("StateSnapshotAsync", env2, resolveProcessorOptions(config2, "StateSnapshotAsync", {
-          type: "accumulate"
+          type: "accumulate",
+          maxStateTokens: 4e3,
+          maxSummaryTurns: 5
         }))
       ]
     }
@@ -304997,6 +305606,12 @@ var ContextTracer = class {
 // packages/core/dist/src/context/eventBus.js
 import { EventEmitter as EventEmitter4 } from "node:events";
 var ContextEventBus = class extends EventEmitter4 {
+  emitTokenGroundTruth(event) {
+    this.emit("TOKEN_GROUND_TRUTH", event);
+  }
+  onTokenGroundTruth(listener) {
+    this.on("TOKEN_GROUND_TRUTH", listener);
+  }
   emitPristineHistoryUpdated(event) {
     this.emit("PRISTINE_HISTORY_UPDATED", event);
   }
@@ -305023,149 +305638,6 @@ var ContextEventBus = class extends EventEmitter4 {
   }
 };
 
-// packages/core/dist/src/context/utils/contextTokenCalculator.js
-var ContextTokenCalculator = class {
-  charsPerToken;
-  registry;
-  tokenCache = /* @__PURE__ */ new Map();
-  constructor(charsPerToken, registry2) {
-    this.charsPerToken = charsPerToken;
-    this.registry = registry2;
-  }
-  /**
-   * Estimates tokens for a simple string based on character count.
-   * Fast, but inherently inaccurate compared to real model tokenization.
-   */
-  estimateTokensForString(text) {
-    return Math.ceil(text.length / this.charsPerToken);
-  }
-  /**
-   * Fast, simple heuristic conversion from tokens to expected character length.
-   * Useful for calculating truncation thresholds.
-   */
-  tokensToChars(tokens) {
-    return tokens * this.charsPerToken;
-  }
-  /**
-   * Pre-calculates and caches the token cost of a newly minted node.
-   * Because nodes are immutable, this cost never changes for this node ID.
-   */
-  /**
-   * Removes cached token counts for any nodes that are no longer in the given live set.
-   * This prevents unbounded memory growth during long sessions.
-   */
-  garbageCollectCache(liveNodeIds) {
-    for (const [id] of this.tokenCache) {
-      if (!liveNodeIds.has(id)) {
-        this.tokenCache.delete(id);
-      }
-    }
-  }
-  cacheNodeTokens(node) {
-    const behavior = this.registry.get(node.type);
-    const parts2 = behavior.getEstimatableParts(node);
-    const tokens = this.estimateTokensForParts(parts2);
-    this.tokenCache.set(node.id, tokens);
-    return tokens;
-  }
-  /**
-   * Retrieves the token cost of a single node from the cache.
-   * If it misses the cache, it computes it and caches it.
-   */
-  getTokenCost(node) {
-    const cached2 = this.tokenCache.get(node.id);
-    if (cached2 !== void 0)
-      return cached2;
-    return this.cacheNodeTokens(node);
-  }
-  /**
-   * Calculates a detailed breakdown of tokens by category for a list of nodes.
-   * Useful for calibration tracing and debugging overestimation.
-   */
-  calculateTokenBreakdown(nodes) {
-    const breakdown = { total: 0, text: 0, media: 0, tool: 0, overhead: 0 };
-    const seenIds = /* @__PURE__ */ new Set();
-    const seenTurnIds = /* @__PURE__ */ new Set();
-    for (const node of nodes) {
-      if (seenIds.has(node.id))
-        continue;
-      seenIds.add(node.id);
-      if (node.turnId) {
-        if (!seenTurnIds.has(node.turnId)) {
-          seenTurnIds.add(node.turnId);
-          breakdown.overhead += MSG_OVERHEAD_TOKENS;
-          breakdown.total += MSG_OVERHEAD_TOKENS;
-        }
-      }
-      const cost = this.getTokenCost(node);
-      breakdown.total += cost;
-      const behavior = this.registry.get(node.type);
-      const parts2 = behavior.getEstimatableParts(node);
-      for (const part of parts2) {
-        if (typeof part.text === "string") {
-          breakdown.text += estimateTokenCountSync([part], 0, this.charsPerToken);
-        } else if (part.inlineData?.mimeType?.startsWith("image/") || part.fileData?.mimeType?.startsWith("image/")) {
-          breakdown.media += estimateTokenCountSync([part], 0, this.charsPerToken);
-        } else if (part.functionCall || part.functionResponse) {
-          breakdown.tool += estimateTokenCountSync([part], 0, this.charsPerToken);
-        } else {
-          breakdown.overhead += estimateTokenCountSync([part], 0, this.charsPerToken);
-        }
-      }
-    }
-    return breakdown;
-  }
-  /**
-   * Fast calculation for a flat array of ConcreteNodes (The Nodes).
-   * It relies entirely on the O(1) sidecar token cache.
-   */
-  calculateConcreteListTokens(nodes) {
-    let tokens = 0;
-    const seenIds = /* @__PURE__ */ new Set();
-    const seenTurnIds = /* @__PURE__ */ new Set();
-    for (const node of nodes) {
-      if (!seenIds.has(node.id)) {
-        seenIds.add(node.id);
-        tokens += this.getTokenCost(node);
-        if (node.turnId) {
-          if (!seenTurnIds.has(node.turnId)) {
-            seenTurnIds.add(node.turnId);
-            tokens += MSG_OVERHEAD_TOKENS;
-          }
-        }
-      }
-    }
-    return tokens;
-  }
-  /**
-   * Calculates the token cost for a single Gemini Content object.
-   */
-  calculateContentTokens(content) {
-    return this.estimateTokensForParts(content.parts || []) + MSG_OVERHEAD_TOKENS;
-  }
-  /**
-   * Slower, precise estimation for a Gemini Content/Part graph.
-   * Deeply inspects the nested structure and uses the base tokenization math.
-   */
-  partTokenCache = /* @__PURE__ */ new WeakMap();
-  estimateTokensForParts(parts2) {
-    let total = 0;
-    for (const part of parts2) {
-      if (part !== null && typeof part === "object") {
-        let cost = this.partTokenCache.get(part);
-        if (cost === void 0) {
-          cost = estimateTokenCountSync([part], 0, this.charsPerToken);
-          this.partTokenCache.set(part, cost);
-        }
-        total += cost;
-      } else {
-        total += estimateTokenCountSync([part], 0, this.charsPerToken);
-      }
-    }
-    return total;
-  }
-};
-
 // packages/core/dist/src/context/pipeline/inbox.js
 import { randomUUID as randomUUID11 } from "node:crypto";
 var LiveInbox = class {
@@ -305203,81 +305675,6 @@ var InboxSnapshotImpl = class {
   }
 };
 
-// packages/core/dist/src/context/graph/behaviorRegistry.js
-var NodeBehaviorRegistry = class {
-  behaviors = /* @__PURE__ */ new Map();
-  register(behavior) {
-    this.behaviors.set(behavior.type, behavior);
-  }
-  get(type2) {
-    const behavior = this.behaviors.get(type2);
-    if (!behavior) {
-      throw new Error(`Unregistered Node type: ${type2}`);
-    }
-    return behavior;
-  }
-};
-
-// packages/core/dist/src/context/graph/builtinBehaviors.js
-var UserPromptBehavior = {
-  type: NodeType.USER_PROMPT,
-  getEstimatableParts(node) {
-    return [node.payload];
-  }
-};
-var AgentThoughtBehavior = {
-  type: NodeType.AGENT_THOUGHT,
-  getEstimatableParts(node) {
-    return [node.payload];
-  }
-};
-var ToolExecutionBehavior = {
-  type: NodeType.TOOL_EXECUTION,
-  getEstimatableParts(node) {
-    return [node.payload];
-  }
-};
-var MaskedToolBehavior = {
-  type: NodeType.MASKED_TOOL,
-  getEstimatableParts(node) {
-    return [node.payload];
-  }
-};
-var AgentYieldBehavior = {
-  type: NodeType.AGENT_YIELD,
-  getEstimatableParts() {
-    return [];
-  }
-};
-var SystemEventBehavior = {
-  type: NodeType.SYSTEM_EVENT,
-  getEstimatableParts(node) {
-    return [node.payload];
-  }
-};
-var SnapshotBehavior = {
-  type: NodeType.SNAPSHOT,
-  getEstimatableParts(node) {
-    return [node.payload];
-  }
-};
-var RollingSummaryBehavior = {
-  type: NodeType.ROLLING_SUMMARY,
-  getEstimatableParts(node) {
-    return [node.payload];
-  }
-};
-function registerBuiltInBehaviors(registry2) {
-  registry2.register(UserPromptBehavior);
-  registry2.register(AgentThoughtBehavior);
-  registry2.register(ToolExecutionBehavior);
-  registry2.register(MaskedToolBehavior);
-  registry2.register(AgentYieldBehavior);
-  registry2.register(SystemEventBehavior);
-  registry2.register(SnapshotBehavior);
-  registry2.register(RollingSummaryBehavior);
-}
-
 // packages/core/dist/src/context/graph/toGraph.js
 import { randomUUID as randomUUID12, createHash as createHash7 } from "node:crypto";
 var PART_HASH_CACHE = /* @__PURE__ */ new WeakMap();
@@ -305347,9 +305744,9 @@ var ContextGraphBuilder = class {
       const msg = history[turnIdx];
       if (!msg.parts)
         continue;
-      if (turnIdx === 0 && msg.role === "user" && msg.parts.length === 1) {
+      if (msg.role === "user" && msg.parts.length === 1) {
         const text = msg.parts[0].text;
-        if (text?.startsWith("<session_context>") && text?.includes("This is the Gemini CLI.")) {
+        if (text?.startsWith("<session_context>") && text?.includes("This is the Gemini CLI")) {
           debugLogger.log("[ContextGraphBuilder] Skipping legacy environment header turn from graph.");
           continue;
         }
@@ -305449,10 +305846,11 @@ var ContextEnvironmentImpl = class {
   charsPerToken;
   eventBus;
   tokenCalculator;
-  inbox;
   behaviorRegistry;
+  renderOptions;
+  inbox;
   graphMapper;
-  constructor(llmClientProvider, sessionId, promptId, traceDir, projectTempDir, tracer, charsPerToken, eventBus) {
+  constructor(llmClientProvider, sessionId, promptId, traceDir, projectTempDir, tracer, charsPerToken, eventBus, tokenCalculator, behaviorRegistry, renderOptions) {
     this.llmClientProvider = llmClientProvider;
     this.sessionId = sessionId;
     this.promptId = promptId;
@@ -305461,9 +305859,9 @@ var ContextEnvironmentImpl = class {
     this.tracer = tracer;
     this.charsPerToken = charsPerToken;
     this.eventBus = eventBus;
-    this.behaviorRegistry = new NodeBehaviorRegistry();
-    registerBuiltInBehaviors(this.behaviorRegistry);
-    this.tokenCalculator = new ContextTokenCalculator(this.charsPerToken, this.behaviorRegistry);
+    this.tokenCalculator = tokenCalculator;
+    this.behaviorRegistry = behaviorRegistry;
+    this.renderOptions = renderOptions;
     this.inbox = new LiveInbox();
     this.graphMapper = new ContextGraphMapper();
   }
@@ -305501,30 +305899,6 @@ var ContextWorkingBufferImpl = class _ContextWorkingBufferImpl {
     }
     return new _ContextWorkingBufferImpl(pristineNodes, pristineMap, initialProvenance, []);
   }
-  /**
-   * Appends newly observed pristine nodes (e.g. from a user message) to the working buffer.
-   * Ensures they are tracked in the pristine map and point to themselves in provenance.
-   */
-  appendPristineNodes(newNodes) {
-    if (newNodes.length === 0)
-      return this;
-    const newPristineMap = new Map(this.pristineNodesMap);
-    const newProvenanceMap = new Map(this.provenanceMap);
-    const existingIds = new Set(this.nodes.map((n3) => n3.id));
-    const nodesToAdd = [];
-    const batchIds = /* @__PURE__ */ new Set();
-    for (const node of newNodes) {
-      if (!existingIds.has(node.id) && !batchIds.has(node.id)) {
-        newPristineMap.set(node.id, node);
-        newProvenanceMap.set(node.id, /* @__PURE__ */ new Set([node.id]));
-        nodesToAdd.push(node);
-        batchIds.add(node.id);
-      }
-    }
-    if (nodesToAdd.length === 0)
-      return this;
-    return new _ContextWorkingBufferImpl([...this.nodes, ...nodesToAdd], newPristineMap, newProvenanceMap, [...this.history]);
-  }
   /**
    * Generates an entirely new buffer instance by calculating the delta between the processor's input and output.
    */
@@ -305602,10 +305976,90 @@ var ContextWorkingBufferImpl = class _ContextWorkingBufferImpl {
     finalPristineMap = prunedPristineMap;
     return new _ContextWorkingBufferImpl(newGraph, finalPristineMap, newProvenanceMap, [...this.history, mutation]);
   }
-  /** Removes nodes from the working buffer that were completely dropped from the upstream pristine history */
-  prunePristineNodes(retainedIds) {
-    const newGraph = this.nodes.filter((n3) => retainedIds.has(n3.id) || !this.pristineNodesMap.has(n3.id));
+  /**
+   * Rebuilds the working buffer in the exact chronological order of the authoritative pristine history,
+   * while preserving injected/summarized nodes at their relative positions.
+   */
+  syncPristineHistory(authoritativePristineNodes) {
+    const newPristineMap = new Map(this.pristineNodesMap);
     const newProvenanceMap = new Map(this.provenanceMap);
+    const authoritativeIds = new Set(authoritativePristineNodes.map((n3) => n3.id));
+    for (const node of authoritativePristineNodes) {
+      if (!newPristineMap.has(node.id)) {
+        newPristineMap.set(node.id, node);
+        newProvenanceMap.set(node.id, /* @__PURE__ */ new Set([node.id]));
+      }
+    }
+    const survivingCurrentNodes = this.nodes.filter((n3) => {
+      if (authoritativeIds.has(n3.id))
+        return true;
+      if (!this.pristineNodesMap.has(n3.id))
+        return true;
+      const roots = newProvenanceMap.get(n3.id);
+      return !roots || roots.size === 0;
+    }).filter((n3) => {
+      if (!authoritativeIds.has(n3.id) && !this.pristineNodesMap.has(n3.id)) {
+        const roots = newProvenanceMap.get(n3.id);
+        if (roots && roots.size > 0) {
+          for (const root of roots) {
+            if (!authoritativeIds.has(root)) {
+              return false;
+            }
+          }
+        }
+      }
+      return true;
+    });
+    const coveredPristineIds = /* @__PURE__ */ new Set();
+    for (const node of survivingCurrentNodes) {
+      if (!authoritativeIds.has(node.id)) {
+        const roots = newProvenanceMap.get(node.id);
+        if (roots) {
+          for (const root of roots) {
+            coveredPristineIds.add(root);
+          }
+        }
+      }
+    }
+    const pristineIndexMap = new Map(authoritativePristineNodes.map((n3, idx) => [n3.id, idx]));
+    const getPristineIndex = (nodeId) => {
+      const roots = newProvenanceMap.get(nodeId);
+      if (!roots || roots.size === 0)
+        return -1;
+      let maxIndex = -1;
+      for (const root of roots) {
+        const idx = pristineIndexMap.get(root);
+        if (idx !== void 0 && idx > maxIndex) {
+          maxIndex = idx;
+        }
+      }
+      return maxIndex;
+    };
+    const nodeOrder = new Array();
+    for (let i3 = 0; i3 < authoritativePristineNodes.length; i3++) {
+      const node = authoritativePristineNodes[i3];
+      if (!coveredPristineIds.has(node.id)) {
+        nodeOrder.push({ node, sortKey: i3, originalIndex: -1 });
+      }
+    }
+    for (let i3 = 0; i3 < survivingCurrentNodes.length; i3++) {
+      const node = survivingCurrentNodes[i3];
+      if (!authoritativeIds.has(node.id)) {
+        const baseSortKey = getPristineIndex(node.id);
+        nodeOrder.push({
+          node,
+          sortKey: baseSortKey === -1 ? -1 : baseSortKey + 0.5,
+          // Interleave after pristine roots, or at start if injected
+          originalIndex: i3
+        });
+      }
+    }
+    nodeOrder.sort((a2, b) => {
+      if (a2.sortKey !== b.sortKey)
+        return a2.sortKey - b.sortKey;
+      return a2.originalIndex - b.originalIndex;
+    });
+    const newGraph = nodeOrder.map((item) => item.node);
     const reachablePristineIds = /* @__PURE__ */ new Set();
     const reachableCurrentIds = /* @__PURE__ */ new Set();
     for (const node of newGraph) {
@@ -305613,7 +306067,7 @@ var ContextWorkingBufferImpl = class _ContextWorkingBufferImpl {
       const roots = newProvenanceMap.get(node.id);
       if (roots) {
         for (const root of roots) {
-          if (retainedIds.has(root) || !this.pristineNodesMap.has(root)) {
+          if (authoritativeIds.has(root) || !this.pristineNodesMap.has(root)) {
             reachablePristineIds.add(root);
           }
         }
@@ -305626,7 +306080,7 @@ var ContextWorkingBufferImpl = class _ContextWorkingBufferImpl {
     }
     const prunedPristineMap = /* @__PURE__ */ new Map();
     for (const id of reachablePristineIds) {
-      const node = this.pristineNodesMap.get(id);
+      const node = newPristineMap.get(id);
       if (node)
         prunedPristineMap.set(id, node);
     }
@@ -305653,6 +306107,7 @@ var PipelineOrchestrator = class {
   activeTimers = [];
   pendingPipelines = /* @__PURE__ */ new Map();
   pipelineMutex = /* @__PURE__ */ new Map();
+  pipelineScheduled = /* @__PURE__ */ new Set();
   nodeProvider;
   constructor(pipelines, asyncPipelines, env2, eventBus, tracer) {
     this.pipelines = pipelines;
@@ -305693,25 +306148,37 @@ var PipelineOrchestrator = class {
             this.activeTimers.push(timer);
           } else if (trigger === "retained_exceeded" || trigger === "nodes_aged_out") {
             this.eventBus.onConsolidationNeeded((event) => {
-              executeFn(pipeline, event.nodes, event.targetNodeIds, /* @__PURE__ */ new Set());
+              void executeFn(pipeline, event.nodes, event.targetNodeIds, /* @__PURE__ */ new Set());
             });
           } else if (trigger === "new_message" || trigger === "nodes_added") {
             this.eventBus.onChunkReceived((event) => {
-              executeFn(pipeline, event.nodes, event.targetNodeIds, /* @__PURE__ */ new Set());
+              void executeFn(pipeline, event.nodes, event.targetNodeIds, /* @__PURE__ */ new Set());
             });
           }
         }
       }
     };
-    bindTriggers(this.pipelines, (pipeline, nodes, targets, protectedIds) => {
+    const handleSyncExecution = async (pipeline, nodes, targets, protectedIds) => {
+      if (this.pipelineScheduled.has(pipeline.name)) {
+        debugLogger.log(`[Orchestrator] Pipeline ${pipeline.name} already scheduled (sync), dropping.`);
+        return;
+      }
+      this.pipelineScheduled.add(pipeline.name);
       const existing = this.pipelineMutex.get(pipeline.name) || Promise.resolve();
       const nextPromise = (async () => {
         try {
           await existing;
-          const latestNodes = this.nodeProvider();
+          this.pipelineScheduled.delete(pipeline.name);
+          const latestNodes = this.nodeProvider ? this.nodeProvider() : nodes;
+          const latestTargets = latestNodes.filter((n3) => targets.has(n3.id));
+          debugLogger.log(`[Orchestrator] Executing sync pipeline ${pipeline.name} with ${latestTargets.length} latest targets.`);
+          if (latestTargets.length === 0) {
+            debugLogger.log(`[Orchestrator] No latest targets for sync pipeline ${pipeline.name}, returning.`);
+            return;
+          }
           await this.executePipelineAsync(pipeline, latestNodes, new Set(targets), new Set(protectedIds));
         } catch (e2) {
-          debugLogger.error(`Pipeline chain ${pipeline.name} failed:`, e2);
+          debugLogger.error(`Sync pipeline chain ${pipeline.name} failed:`, e2);
         }
       })();
       this.pipelineMutex.set(pipeline.name, nextPromise);
@@ -305723,18 +306190,47 @@ var PipelineOrchestrator = class {
           this.pipelineMutex.delete(pipeline.name);
         }
       });
-    });
-    bindTriggers(this.asyncPipelines, (pipeline, nodes, targetIds) => {
-      const inboxSnapshot = new InboxSnapshotImpl(this.env.inbox.getMessages() || []);
-      const targets = nodes.filter((n3) => targetIds.has(n3.id));
-      for (const processor of pipeline.processors) {
-        processor.process({
-          targets,
-          inbox: inboxSnapshot,
-          buffer: ContextWorkingBufferImpl.initialize(nodes)
-        }).catch((e2) => debugLogger.error(`AsyncProcessor ${processor.name} failed:`, e2));
+    };
+    const handleAsyncExecution = async (pipeline, nodes, targets) => {
+      if (this.pipelineScheduled.has(pipeline.name)) {
+        debugLogger.log(`[Orchestrator] Pipeline ${pipeline.name} already scheduled (async), dropping.`);
+        return;
       }
-    });
+      this.pipelineScheduled.add(pipeline.name);
+      const existing = this.pipelineMutex.get(pipeline.name) || Promise.resolve();
+      const nextPromise = (async () => {
+        try {
+          await existing;
+          this.pipelineScheduled.delete(pipeline.name);
+          const latestNodes = this.nodeProvider ? this.nodeProvider() : nodes;
+          const latestTargets = latestNodes.filter((n3) => targets.has(n3.id));
+          debugLogger.log(`[Orchestrator] Executing async pipeline ${pipeline.name} with ${latestTargets.length} latest targets.`);
+          const inboxSnapshot = new InboxSnapshotImpl(this.env.inbox.getMessages() || []);
+          for (const processor of pipeline.processors) {
+            debugLogger.log(`[Orchestrator] Running async processor ${processor.id}`);
+            await processor.process({
+              targets: latestTargets,
+              inbox: inboxSnapshot,
+              buffer: ContextWorkingBufferImpl.initialize(latestNodes)
+            });
+          }
+          this.env.inbox.drainConsumed(inboxSnapshot.getConsumedIds());
+        } catch (e2) {
+          debugLogger.error(`Async pipeline chain ${pipeline.name} failed:`, e2);
+        }
+      })();
+      this.pipelineMutex.set(pipeline.name, nextPromise);
+      const pipelineId = `${pipeline.name}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+      this.pendingPipelines.set(pipelineId, nextPromise);
+      void nextPromise.finally(() => {
+        this.pendingPipelines.delete(pipelineId);
+        if (this.pipelineMutex.get(pipeline.name) === nextPromise) {
+          this.pipelineMutex.delete(pipeline.name);
+        }
+      });
+    };
+    bindTriggers(this.pipelines, (pipeline, nodes, targets, protectedIds) => handleSyncExecution(pipeline, nodes, targets, protectedIds));
+    bindTriggers(this.asyncPipelines, (pipeline, nodes, targets) => handleAsyncExecution(pipeline, nodes, targets));
   }
   shutdown() {
     for (const timer of this.activeTimers) {
@@ -305889,17 +306385,54 @@ var HistoryObserver = class {
   }
 };
 
+// packages/core/dist/src/context/utils/tokenCalibration.js
+function performCalibration(env2, finalNodes, finalContents) {
+  if (!env2.renderOptions?.calibrateTokenCalculation) {
+    return;
+  }
+  void (async () => {
+    try {
+      const exactResp = await env2.llmClient.countTokens({
+        contents: finalContents
+      });
+      const exactTokens = typeof exactResp.totalTokens === "number" ? exactResp.totalTokens : 0;
+      const estimatedTokens = env2.tokenCalculator.calculateConcreteListTokens(finalNodes);
+      const delta = Math.abs(exactTokens - estimatedTokens);
+      const tolerance = Math.max(exactTokens, estimatedTokens) * 0.2;
+      env2.tracer.logEvent("Render", "Token Calibration Measurement", {
+        exactTokens,
+        estimatedTokens,
+        delta,
+        isWithinTolerance: delta <= tolerance
+      });
+      if (delta > tolerance) {
+        debugLogger.error(`[Token Calibration] Large deviation detected: exact ${exactTokens} vs estimated ${estimatedTokens} (delta: ${delta})`);
+      }
+    } catch {
+    }
+  })();
+}
+
 // packages/core/dist/src/context/graph/render.js
-async function render2(nodes, orchestrator, sidecar, tracer, env2, protectionReasons = /* @__PURE__ */ new Map(), headerTokens = 0) {
+async function render2(nodes, orchestrator, sidecar, tracer, env2, advancedTokenCalculator, protectionReasons = /* @__PURE__ */ new Map(), header, previewNodeIds = /* @__PURE__ */ new Set()) {
+  let headerTokens = 0;
+  let headerBaseUnits = 0;
+  if (header) {
+    const costs = advancedTokenCalculator.calculateContentTokensAndBaseUnits(header);
+    headerTokens = costs.tokens;
+    headerBaseUnits = costs.baseUnits;
+  }
   if (!sidecar.config.budget) {
-    const contents2 = env2.graphMapper.fromGraph(nodes);
+    const visibleNodes2 = nodes.filter((n3) => !previewNodeIds.has(n3.id));
+    const contents2 = env2.graphMapper.fromGraph(visibleNodes2);
     tracer.logEvent("Render", "Render Context to LLM (No Budget)", {
       renderedContext: contents2
     });
-    return { history: contents2, didApplyManagement: false };
+    const baseUnits = advancedTokenCalculator.getRawBaseUnits(nodes) + headerBaseUnits;
+    return { history: contents2, didApplyManagement: false, baseUnits };
   }
   const maxTokens = sidecar.config.budget.maxTokens;
-  const graphTokens = env2.tokenCalculator.calculateConcreteListTokens(nodes);
+  const { tokens: graphTokens, baseUnits: graphBaseUnits } = advancedTokenCalculator.calculateTokensAndBaseUnits(nodes);
   const currentTokens = graphTokens + headerTokens;
   const protectedIds = new Set(protectionReasons.keys());
   tracer.logEvent("Render", "Budget Audit", {
@@ -305919,11 +306452,17 @@ async function render2(nodes, orchestrator, sidecar, tracer, env2, protectionRea
   });
   if (currentTokens <= maxTokens) {
     tracer.logEvent("Render", `View is within maxTokens (${currentTokens} <= ${maxTokens}). Returning view.`);
-    const contents2 = env2.graphMapper.fromGraph(nodes);
+    const visibleNodes2 = nodes.filter((n3) => !previewNodeIds.has(n3.id));
+    const contents2 = env2.graphMapper.fromGraph(visibleNodes2);
     tracer.logEvent("Render", "Render Context for LLM", {
       renderedContext: contents2
     });
-    return { history: contents2, didApplyManagement: false };
+    performCalibration(env2, visibleNodes2, contents2);
+    return {
+      history: contents2,
+      didApplyManagement: false,
+      baseUnits: graphBaseUnits + headerBaseUnits
+    };
   }
   const targetDelta = currentTokens - sidecar.config.budget.retainedTokens;
   tracer.logEvent("Render", `View exceeds maxTokens (${currentTokens} > ${maxTokens}). Hitting Synchronous Pressure Barrier.`, { targetDelta });
@@ -305931,9 +306470,10 @@ async function render2(nodes, orchestrator, sidecar, tracer, env2, protectionRea
   let rollingTokens = 0;
   for (let i3 = nodes.length - 1; i3 >= 0; i3--) {
     const node = nodes[i3];
+    const priorTokens = rollingTokens;
     const nodeTokens = env2.tokenCalculator.calculateConcreteListTokens([node]);
     rollingTokens += nodeTokens;
-    if (rollingTokens > sidecar.config.budget.retainedTokens) {
+    if (priorTokens > sidecar.config.budget.retainedTokens) {
       agedOutNodes.add(node.id);
     }
   }
@@ -305945,12 +306485,17 @@ async function render2(nodes, orchestrator, sidecar, tracer, env2, protectionRea
         skipList.add(id);
     }
   }
-  const visibleNodes = processedNodes.filter((n3) => !skipList.has(n3.id));
+  const visibleNodes = processedNodes.filter((n3) => !skipList.has(n3.id) && !previewNodeIds.has(n3.id));
   const contents = env2.graphMapper.fromGraph(visibleNodes);
   tracer.logEvent("Render", "Render Sanitized Context for LLM", {
     renderedContextSanitized: contents
   });
-  return { history: contents, didApplyManagement: true };
+  performCalibration(env2, visibleNodes, contents);
+  return {
+    history: contents,
+    didApplyManagement: true,
+    baseUnits: advancedTokenCalculator.getRawBaseUnits(visibleNodes) + headerBaseUnits
+  };
 }
 
 // packages/core/dist/src/context/utils/invariantChecker.js
@@ -305983,6 +306528,7 @@ var ContextManager = class {
   sidecar;
   env;
   tracer;
+  advancedTokenCalculator;
   headerProvider;
   // The master state containing the pristine graph and current active graph.
   buffer = ContextWorkingBufferImpl.initialize([]);
@@ -305990,24 +306536,23 @@ var ContextManager = class {
   // Internal sub-components
   orchestrator;
   historyObserver;
+  // Hysteresis tracking to prevent utility call churn
+  lastTriggeredDeficit = 0;
   // Cache for Anomaly 3 (Redundant Renders)
   lastRenderCache;
-  constructor(sidecar, env2, tracer, orchestrator, chatHistory, headerProvider) {
+  hasPerformedHotStart = false;
+  constructor(sidecar, env2, tracer, orchestrator, chatHistory, advancedTokenCalculator, headerProvider) {
     this.sidecar = sidecar;
     this.env = env2;
     this.tracer = tracer;
+    this.advancedTokenCalculator = advancedTokenCalculator;
     this.headerProvider = headerProvider;
     this.eventBus = env2.eventBus;
     this.orchestrator = orchestrator;
     this.orchestrator.setNodeProvider(() => this.buffer.nodes);
     this.historyObserver = new HistoryObserver(chatHistory, this.env.eventBus, this.tracer, this.env.graphMapper);
     this.eventBus.onPristineHistoryUpdated((event) => {
-      const newIds = new Set(event.nodes.map((n3) => n3.id));
-      const addedNodes = event.nodes.filter((n3) => event.newNodes.has(n3.id));
-      this.buffer = this.buffer.prunePristineNodes(newIds);
-      if (addedNodes.length > 0) {
-        this.buffer = this.buffer.appendPristineNodes(addedNodes);
-      }
+      this.buffer = this.buffer.syncPristineHistory(event.nodes);
       this.evaluateTriggers(event.newNodes);
     });
     this.eventBus.onProcessorResult((event) => {
@@ -306051,10 +306596,11 @@ var ContextManager = class {
       }
       for (let i3 = this.buffer.nodes.length - 1; i3 >= 0; i3--) {
         const node = this.buffer.nodes[i3];
+        const priorTokens = rollingTokens;
         rollingTokens += this.env.tokenCalculator.calculateConcreteListTokens([
           node
         ]);
-        if (rollingTokens > this.sidecar.config.budget.retainedTokens) {
+        if (priorTokens > this.sidecar.config.budget.retainedTokens) {
           if (!protectedIds.has(node.id)) {
             agedOutNodes.add(node.id);
           }
@@ -306062,8 +306608,13 @@ var ContextManager = class {
       }
       if (agedOutNodes.size > 0) {
         const targetDeficit = currentTokens - this.sidecar.config.budget.retainedTokens;
+        if (targetDeficit < this.lastTriggeredDeficit) {
+          this.lastTriggeredDeficit = targetDeficit;
+        }
         const threshold = this.sidecar.config.budget.coalescingThresholdTokens || 0;
-        if (targetDeficit >= threshold) {
+        const growthSinceLast = targetDeficit - this.lastTriggeredDeficit;
+        if (targetDeficit >= threshold && (growthSinceLast >= threshold || this.lastTriggeredDeficit === 0)) {
+          this.lastTriggeredDeficit = targetDeficit;
           this.env.tokenCalculator.garbageCollectCache(new Set(this.buffer.nodes.map((n3) => n3.id)));
           this.eventBus.emitConsolidationNeeded({
             nodes: this.buffer.nodes,
@@ -306071,6 +306622,8 @@ var ContextManager = class {
             targetNodeIds: agedOutNodes
           });
         }
+      } else {
+        this.lastTriggeredDeficit = 0;
       }
     }
   }
@@ -306127,24 +306680,42 @@ var ContextManager = class {
   getNodes() {
     return [...this.buffer.nodes];
   }
+  getEnvironment() {
+    return this.env;
+  }
   /**
    * Executes the final 'gc_backstop' pipeline if necessary, enforcing the token budget,
    * and maps the Episodic Context Graph back into a raw Gemini Content[] array for transmission.
    * This is the primary method called by the agent framework before sending a request.
    */
-  async renderHistory(pendingRequest, activeTaskIds = /* @__PURE__ */ new Set()) {
+  async renderHistory(pendingRequest, activeTaskIds = /* @__PURE__ */ new Set(), abortSignal) {
     this.tracer.logEvent("ContextManager", "Starting rendering of LLM context");
-    await this.orchestrator.waitForPipelines();
-    let nodes = this.buffer.nodes;
+    let previewNodes = [];
     if (pendingRequest) {
-      const previewNodes = this.env.graphMapper.applyEvent({
+      previewNodes = this.env.graphMapper.applyEvent({
         type: "PUSH",
         payload: [pendingRequest]
       });
+    }
+    const hotStartPromise = (async () => {
+      if (!this.hasPerformedHotStart) {
+        this.hasPerformedHotStart = true;
+        if (this.buffer.nodes.length > 0) {
+          const nodesForHotStart = [...this.buffer.nodes, ...previewNodes];
+          await this.performHotStartCalibration(nodesForHotStart, abortSignal);
+        }
+      }
+    })();
+    await Promise.all([this.orchestrator.waitForPipelines(), hotStartPromise]);
+    let nodes = this.buffer.nodes;
+    const previewNodeIds = /* @__PURE__ */ new Set();
+    if (previewNodes.length > 0) {
+      for (const n3 of previewNodes) {
+        previewNodeIds.add(n3.id);
+      }
       nodes = [...nodes, ...previewNodes];
     }
     const header = this.headerProvider ? await this.headerProvider() : void 0;
-    const headerTokens = header ? this.env.tokenCalculator.calculateContentTokens(header) : 0;
     const graphHash = nodes.map((n3) => n3.id).join("|");
     const headerHash = header ? JSON.stringify(header.parts) : "no-header";
     const totalHash = `${graphHash}::${headerHash}`;
@@ -306153,7 +306724,7 @@ var ContextManager = class {
       return this.lastRenderCache.result;
     }
     const protectionReasons = this.getProtectedNodeIds(nodes, activeTaskIds);
-    const { history: renderedHistory, didApplyManagement } = await render2(nodes, this.orchestrator, this.sidecar, this.tracer, this.env, protectionReasons, headerTokens);
+    const { history: renderedHistory, didApplyManagement, baseUnits } = await render2(nodes, this.orchestrator, this.sidecar, this.tracer, this.env, this.advancedTokenCalculator, protectionReasons, header, previewNodeIds);
     checkContextInvariants(this.buffer.nodes, "RenderHistory");
     this.tracer.logEvent("ContextManager", "Finished rendering");
     const combinedHistory = header ? [header, ...renderedHistory] : renderedHistory;
@@ -306161,11 +306732,35 @@ var ContextManager = class {
       history: hardenHistory(combinedHistory, {
         sentinels: this.sidecar.sentinels
       }),
-      didApplyManagement
+      didApplyManagement,
+      baseUnits
     };
     this.lastRenderCache = { nodesHash: totalHash, result: result2 };
     return result2;
   }
+  async performHotStartCalibration(nodes, abortSignal) {
+    try {
+      this.tracer.logEvent("ContextManager", "Performing Hot Start Token Calibration");
+      const contents = this.env.graphMapper.fromGraph(nodes);
+      const header = this.headerProvider ? await this.headerProvider() : void 0;
+      const combinedHistory = header ? [header, ...contents] : contents;
+      const baseUnits = this.advancedTokenCalculator.getRawBaseUnits(nodes) + (header ? this.advancedTokenCalculator.getRawBaseUnitsForContent(header) : 0);
+      if (combinedHistory.length > 0) {
+        const result2 = await this.env.llmClient.countTokens({
+          contents: combinedHistory,
+          abortSignal
+        });
+        if (result2.totalTokens > 0) {
+          this.env.eventBus.emitTokenGroundTruth({
+            actualTokens: result2.totalTokens,
+            promptBaseUnits: baseUnits
+          });
+        }
+      }
+    } catch (error40) {
+      this.tracer.logEvent("ContextManager", "Hot Start Token Calibration Failed (Ignored)", { error: error40 });
+    }
+  }
 };
 
 // packages/core/dist/src/context/processors/historyTruncationProcessor.js
@@ -306198,6 +306793,337 @@ var RollingSummaryProcessorOptionsSchema = {
   required: []
 };
 
+// packages/core/dist/src/context/utils/contextTokenCalculator.js
+var StaticTokenCalculator = class {
+  charsPerToken;
+  registry;
+  tokenCache = /* @__PURE__ */ new Map();
+  constructor(charsPerToken, registry2) {
+    this.charsPerToken = charsPerToken;
+    this.registry = registry2;
+  }
+  /**
+   * Estimates tokens for a simple string based on character count.
+   * Fast, but inherently inaccurate compared to real model tokenization.
+   */
+  estimateTokensForString(text) {
+    return Math.ceil(text.length / this.charsPerToken);
+  }
+  /**
+   * Fast, simple heuristic conversion from tokens to expected character length.
+   * Useful for calculating truncation thresholds.
+   */
+  tokensToChars(tokens) {
+    return tokens * this.charsPerToken;
+  }
+  /**
+   * Pre-calculates and caches the token cost of a newly minted node.
+   * Because nodes are immutable, this cost never changes for this node ID.
+   */
+  /**
+   * Removes cached token counts for any nodes that are no longer in the given live set.
+   * This prevents unbounded memory growth during long sessions.
+   */
+  garbageCollectCache(liveNodeIds) {
+    for (const [id] of this.tokenCache) {
+      if (!liveNodeIds.has(id)) {
+        this.tokenCache.delete(id);
+      }
+    }
+  }
+  cacheNodeTokens(node) {
+    const behavior = this.registry.get(node.type);
+    const parts2 = behavior.getEstimatableParts(node);
+    const tokens = this.estimateTokensForParts(parts2);
+    this.tokenCache.set(node.id, tokens);
+    return tokens;
+  }
+  /**
+   * Retrieves the token cost of a single node from the cache.
+   * If it misses the cache, it computes it and caches it.
+   */
+  getTokenCost(node) {
+    const cached2 = this.tokenCache.get(node.id);
+    if (cached2 !== void 0)
+      return cached2;
+    return this.cacheNodeTokens(node);
+  }
+  /**
+   * Calculates a detailed breakdown of tokens by category for a list of nodes.
+   * Useful for calibration tracing and debugging overestimation.
+   */
+  calculateTokenBreakdown(nodes) {
+    const breakdown = { total: 0, text: 0, media: 0, tool: 0, overhead: 0 };
+    const seenIds = /* @__PURE__ */ new Set();
+    const seenTurnIds = /* @__PURE__ */ new Set();
+    for (const node of nodes) {
+      if (seenIds.has(node.id))
+        continue;
+      seenIds.add(node.id);
+      if (node.turnId) {
+        if (!seenTurnIds.has(node.turnId)) {
+          seenTurnIds.add(node.turnId);
+          breakdown.overhead += MSG_OVERHEAD_TOKENS;
+          breakdown.total += MSG_OVERHEAD_TOKENS;
+        }
+      }
+      const cost = this.getTokenCost(node);
+      breakdown.total += cost;
+      const behavior = this.registry.get(node.type);
+      const parts2 = behavior.getEstimatableParts(node);
+      for (const part of parts2) {
+        if (typeof part.text === "string") {
+          breakdown.text += estimateTokenCountSync([part], 0, this.charsPerToken);
+        } else if (part.inlineData?.mimeType?.startsWith("image/") || part.fileData?.mimeType?.startsWith("image/")) {
+          breakdown.media += estimateTokenCountSync([part], 0, this.charsPerToken);
+        } else if (part.functionCall || part.functionResponse) {
+          breakdown.tool += estimateTokenCountSync([part], 0, this.charsPerToken);
+        } else {
+          breakdown.overhead += estimateTokenCountSync([part], 0, this.charsPerToken);
+        }
+      }
+    }
+    return breakdown;
+  }
+  /**
+   * For the static calculator, Raw Base Units are exactly the same as the final tokens,
+   * because there is no dynamic learned weight (the multiplier is effectively 1.0).
+   */
+  getRawBaseUnits(nodes) {
+    return this.calculateConcreteListTokens(nodes);
+  }
+  getRawBaseUnitsForContent(content) {
+    return this.calculateContentTokens(content);
+  }
+  calculateTokensAndBaseUnits(nodes) {
+    const baseUnits = this.calculateConcreteListTokens(nodes);
+    return { tokens: baseUnits, baseUnits };
+  }
+  calculateContentTokensAndBaseUnits(content) {
+    const baseUnits = this.calculateContentTokens(content);
+    return { tokens: baseUnits, baseUnits };
+  }
+  /**
+   * Fast calculation for a flat array of ConcreteNodes (The Nodes).
+   * It relies entirely on the O(1) sidecar token cache.
+   */
+  calculateConcreteListTokens(nodes) {
+    let tokens = 0;
+    const seenIds = /* @__PURE__ */ new Set();
+    const seenTurnIds = /* @__PURE__ */ new Set();
+    for (const node of nodes) {
+      if (!seenIds.has(node.id)) {
+        seenIds.add(node.id);
+        tokens += this.getTokenCost(node);
+        if (node.turnId) {
+          if (!seenTurnIds.has(node.turnId)) {
+            seenTurnIds.add(node.turnId);
+            tokens += MSG_OVERHEAD_TOKENS;
+          }
+        }
+      }
+    }
+    return tokens;
+  }
+  /**
+   * Calculates the token cost for a single Gemini Content object.
+   */
+  calculateContentTokens(content) {
+    return this.estimateTokensForParts(content.parts || []) + MSG_OVERHEAD_TOKENS;
+  }
+  /**
+   * Slower, precise estimation for a Gemini Content/Part graph.
+   * Deeply inspects the nested structure and uses the base tokenization math.
+   */
+  partTokenCache = /* @__PURE__ */ new WeakMap();
+  estimateTokensForParts(parts2) {
+    let total = 0;
+    for (const part of parts2) {
+      if (part !== null && typeof part === "object") {
+        let cost = this.partTokenCache.get(part);
+        if (cost === void 0) {
+          cost = estimateTokenCountSync([part], 0, this.charsPerToken);
+          this.partTokenCache.set(part, cost);
+        }
+        total += cost;
+      } else {
+        total += estimateTokenCountSync([part], 0, this.charsPerToken);
+      }
+    }
+    return total;
+  }
+};
+
+// packages/core/dist/src/context/utils/adaptiveTokenCalculator.js
+var AdaptiveTokenCalculator = class {
+  learnedWeight = 1;
+  baseCalculator;
+  constructor(charsPerToken, registry2, eventBus) {
+    this.baseCalculator = new StaticTokenCalculator(charsPerToken, registry2);
+    eventBus.onTokenGroundTruth((event) => {
+      this.handleGroundTruth(event.actualTokens, event.promptBaseUnits);
+    });
+  }
+  handleGroundTruth(actualTokens, promptBaseUnits) {
+    if (promptBaseUnits <= 0)
+      return;
+    const targetWeight = actualTokens / promptBaseUnits;
+    const oldWeight = this.learnedWeight;
+    const learningRate = 0.2;
+    const newWeight = oldWeight * (1 - learningRate) + targetWeight * learningRate;
+    this.learnedWeight = Math.max(0.5, Math.min(newWeight, 2));
+    debugLogger.log(`[AdaptiveTokenCalculator] Learned weight updated to ${this.learnedWeight.toFixed(3)} (API Tokens: ${actualTokens}, Base Units: ${promptBaseUnits}, Target Ratio: ${targetWeight.toFixed(3)})`);
+  }
+  /**
+   * Retrieves the current learned weight multiplier.
+   */
+  getLearnedWeight() {
+    return this.learnedWeight;
+  }
+  /**
+   * Returns the exact, unweighted Base Heuristic Units for the graph.
+   * This is used exactly once per interaction to capture the baseline sent to the API.
+   */
+  getRawBaseUnits(nodes) {
+    return this.baseCalculator.calculateConcreteListTokens(nodes);
+  }
+  /**
+   * Returns the exact, unweighted Base Heuristic Units for a raw content chunk.
+   */
+  getRawBaseUnitsForContent(content) {
+    return this.baseCalculator.calculateContentTokens(content);
+  }
+  calculateTokensAndBaseUnits(nodes) {
+    const baseUnits = this.baseCalculator.calculateConcreteListTokens(nodes);
+    return {
+      tokens: Math.round(baseUnits * this.learnedWeight),
+      baseUnits
+    };
+  }
+  calculateContentTokensAndBaseUnits(content) {
+    const baseUnits = this.baseCalculator.calculateContentTokens(content);
+    return {
+      tokens: Math.round(baseUnits * this.learnedWeight),
+      baseUnits
+    };
+  }
+  // --- Delegation and Weighting ---
+  garbageCollectCache(liveNodeIds) {
+    this.baseCalculator.garbageCollectCache(liveNodeIds);
+  }
+  cacheNodeTokens(node) {
+    return this.baseCalculator.cacheNodeTokens(node);
+  }
+  calculateTokenBreakdown(nodes) {
+    const raw = this.baseCalculator.calculateTokenBreakdown(nodes);
+    return {
+      text: Math.round(raw.text * this.learnedWeight),
+      media: Math.round(raw.media * this.learnedWeight),
+      tool: Math.round(raw.tool * this.learnedWeight),
+      overhead: Math.round(raw.overhead * this.learnedWeight),
+      total: Math.round(raw.total * this.learnedWeight)
+    };
+  }
+  estimateTokensForParts(parts2) {
+    const baseUnits = this.baseCalculator.estimateTokensForParts(parts2);
+    return Math.round(baseUnits * this.learnedWeight);
+  }
+  getTokenCost(node) {
+    const baseUnits = this.baseCalculator.getTokenCost(node);
+    return Math.round(baseUnits * this.learnedWeight);
+  }
+  calculateConcreteListTokens(nodes) {
+    const baseUnits = this.baseCalculator.calculateConcreteListTokens(nodes);
+    return Math.round(baseUnits * this.learnedWeight);
+  }
+  calculateContentTokens(content) {
+    const baseUnits = this.baseCalculator.calculateContentTokens(content);
+    return Math.round(baseUnits * this.learnedWeight);
+  }
+  estimateTokensForString(text) {
+    const baseUnits = this.baseCalculator.estimateTokensForString(text);
+    return Math.round(baseUnits * this.learnedWeight);
+  }
+  tokensToChars(tokens) {
+    return this.baseCalculator.tokensToChars(tokens / this.learnedWeight);
+  }
+};
+
+// packages/core/dist/src/context/graph/behaviorRegistry.js
+var NodeBehaviorRegistry = class {
+  behaviors = /* @__PURE__ */ new Map();
+  register(behavior) {
+    this.behaviors.set(behavior.type, behavior);
+  }
+  get(type2) {
+    const behavior = this.behaviors.get(type2);
+    if (!behavior) {
+      throw new Error(`Unregistered Node type: ${type2}`);
+    }
+    return behavior;
+  }
+};
+
+// packages/core/dist/src/context/graph/builtinBehaviors.js
+var UserPromptBehavior = {
+  type: NodeType.USER_PROMPT,
+  getEstimatableParts(node) {
+    return [node.payload];
+  }
+};
+var AgentThoughtBehavior = {
+  type: NodeType.AGENT_THOUGHT,
+  getEstimatableParts(node) {
+    return [node.payload];
+  }
+};
+var ToolExecutionBehavior = {
+  type: NodeType.TOOL_EXECUTION,
+  getEstimatableParts(node) {
+    return [node.payload];
+  }
+};
+var MaskedToolBehavior = {
+  type: NodeType.MASKED_TOOL,
+  getEstimatableParts(node) {
+    return [node.payload];
+  }
+};
+var AgentYieldBehavior = {
+  type: NodeType.AGENT_YIELD,
+  getEstimatableParts() {
+    return [];
+  }
+};
+var SystemEventBehavior = {
+  type: NodeType.SYSTEM_EVENT,
+  getEstimatableParts(node) {
+    return [node.payload];
+  }
+};
+var SnapshotBehavior = {
+  type: NodeType.SNAPSHOT,
+  getEstimatableParts(node) {
+    return [node.payload];
+  }
+};
+var RollingSummaryBehavior = {
+  type: NodeType.ROLLING_SUMMARY,
+  getEstimatableParts(node) {
+    return [node.payload];
+  }
+};
+function registerBuiltInBehaviors(registry2) {
+  registry2.register(UserPromptBehavior);
+  registry2.register(AgentThoughtBehavior);
+  registry2.register(ToolExecutionBehavior);
+  registry2.register(MaskedToolBehavior);
+  registry2.register(AgentYieldBehavior);
+  registry2.register(SystemEventBehavior);
+  registry2.register(SnapshotBehavior);
+  registry2.register(RollingSummaryBehavior);
+}
+
 // packages/core/dist/src/context/initializer.js
 async function initializeContextManager(config2, chat, lastPromptId) {
   const isV1Enabled = config2.getContextManagementConfig().enabled;
@@ -306247,9 +307173,15 @@ async function initializeContextManager(config2, chat, lastPromptId) {
     sessionId: lastPromptId
   });
   const eventBus = new ContextEventBus();
-  const env2 = new ContextEnvironmentImpl(() => config2.getBaseLlmClient(), config2.getSessionId(), lastPromptId, logDir, projectTempDir, tracer, 4, eventBus);
+  const charsPerToken = 3;
+  const behaviorRegistry = new NodeBehaviorRegistry();
+  registerBuiltInBehaviors(behaviorRegistry);
+  const calculator = new AdaptiveTokenCalculator(charsPerToken, behaviorRegistry, eventBus);
+  const env2 = new ContextEnvironmentImpl(() => config2.getBaseLlmClient(), config2.getSessionId(), lastPromptId, logDir, projectTempDir, tracer, charsPerToken, eventBus, calculator, behaviorRegistry, {
+    calibrateTokenCalculation: !!process.env["GEMINI_CONTEXT_CALIBRATE_TOKEN_CALCULATIONS"]
+  });
   const orchestrator = new PipelineOrchestrator(sidecarProfile.buildPipelines(env2), sidecarProfile.buildAsyncPipelines(env2), env2, eventBus, tracer);
-  return new ContextManager(sidecarProfile, env2, tracer, orchestrator, chat.agentHistory, async () => {
+  return new ContextManager(sidecarProfile, env2, tracer, orchestrator, chat.agentHistory, calculator, async () => {
     const parts2 = await getEnvironmentContext(config2);
     return { role: "user", parts: parts2 };
   });
@@ -306619,10 +307551,12 @@ var GeminiClient = class {
       return turn;
     }
     const modelForLimitCheck = this._getActiveModelForCurrentTurn();
+    let currentBaseUnits = 0;
     if (this.config.getContextManagementConfig().enabled) {
       if (this.contextManager) {
         const pendingRequest = createUserContent(request);
-        const { history: newHistory, didApplyManagement } = await this.contextManager.renderHistory(pendingRequest);
+        const { history: newHistory, didApplyManagement, baseUnits } = await this.contextManager.renderHistory(pendingRequest, void 0, signal);
+        currentBaseUnits = baseUnits;
         if (didApplyManagement) {
           this.getChat().setHistory(newHistory, { silent: true });
         }
@@ -306722,6 +307656,15 @@ var GeminiClient = class {
         break;
       }
       yield event;
+      if (event.type === GeminiEventType.Finished && this.contextManager) {
+        const usageMetadata = event.value.usageMetadata;
+        if (usageMetadata && usageMetadata.promptTokenCount !== void 0) {
+          this.contextManager.getEnvironment().eventBus.emitTokenGroundTruth({
+            actualTokens: usageMetadata.promptTokenCount,
+            promptBaseUnits: currentBaseUnits
+          });
+        }
+      }
       this.updateTelemetryTokenCount();
       if (event.type === GeminiEventType.Error) {
         isError = true;
@@ -307215,7 +308158,7 @@ var ToolExecutor = class {
           completedToolCall = await this.createSuccessResult(call, toolResult);
         } else {
           const displayText = typeof toolResult.returnDisplay === "string" ? toolResult.returnDisplay : void 0;
-          completedToolCall = this.createErrorResult(call, new Error(toolResult.error.message), toolResult.error.type, displayText, toolResult.tailToolCallRequest);
+          completedToolCall = this.createErrorResult(call, new Error(toolResult.error.message), toolResult.error.type, displayText, toolResult.tailToolCallRequest, toolResult.display);
         }
       } catch (executionError) {
         spanMetadata.error = executionError;
@@ -307313,6 +308256,7 @@ var ToolExecutor = class {
       response: {
         callId: call.request.callId,
         responseParts,
+        display: toolResult?.display,
         resultDisplay: toolResult?.returnDisplay,
         error: void 0,
         errorType: void 0,
@@ -307335,6 +308279,7 @@ var ToolExecutor = class {
     const successResponse = {
       callId,
       responseParts: response,
+      display: toolResult.display,
       resultDisplay: toolResult.returnDisplay,
       error: void 0,
       errorType: void 0,
@@ -307359,8 +308304,8 @@ var ToolExecutor = class {
       tailToolCallRequest: toolResult.tailToolCallRequest
     };
   }
-  createErrorResult(call, error40, errorType, returnDisplay, tailToolCallRequest) {
-    const response = this.createErrorResponse(call.request, error40, errorType, returnDisplay);
+  createErrorResult(call, error40, errorType, returnDisplay, tailToolCallRequest, display) {
+    const response = this.createErrorResponse(call.request, error40, errorType, returnDisplay, display);
     const startTime = "startTime" in call ? call.startTime : void 0;
     return {
       status: CoreToolCallStatus.Error,
@@ -307374,11 +308319,12 @@ var ToolExecutor = class {
       tailToolCallRequest
     };
   }
-  createErrorResponse(request, error40, errorType, returnDisplay) {
+  createErrorResponse(request, error40, errorType, returnDisplay, display) {
     const displayText = returnDisplay ?? error40.message;
     return {
       callId: request.callId,
       error: error40,
+      display,
       responseParts: [
         {
           functionResponse: {
@@ -307650,6 +308596,16 @@ var Scheduler = class {
     }, () => {
       try {
         const invocation = tool.build(request.args);
+        if (!request.display) {
+          request.display = populateToolDisplay({
+            name: tool.name,
+            invocation,
+            displayName: tool.displayName
+          });
+          if (!request.display.description) {
+            request.display.description = tool.description;
+          }
+        }
         return {
           status: CoreToolCallStatus.Validating,
           request,
@@ -308376,8 +309332,8 @@ var WorkspaceContext = class {
    * @returns True if the path is within the root directory, false otherwise
    */
   isPathWithinRoot(pathToCheck, rootDirectory) {
-    const relative12 = path61.relative(rootDirectory, pathToCheck);
-    return !relative12.startsWith(`..${path61.sep}`) && relative12 !== ".." && !path61.isAbsolute(relative12);
+    const relative11 = path61.relative(rootDirectory, pathToCheck);
+    return !relative11.startsWith(`..${path61.sep}`) && relative11 !== ".." && !path61.isAbsolute(relative11);
   }
 };
 
@@ -308702,6 +309658,7 @@ var LocalAgentExecutor = class _LocalAgentExecutor {
   compressionService;
   parentCallId;
   hasFailedCompressionAttempt = false;
+  cache;
   get executionContext() {
     return {
       config: this.context.config,
@@ -308819,6 +309776,7 @@ var LocalAgentExecutor = class _LocalAgentExecutor {
     this.onActivity = onActivity;
     this.compressionService = new ChatCompressionService();
     this.parentCallId = parentCallId;
+    this.cache = new import_lru_cache.default(10);
     this.agentId = Math.random().toString(36).slice(2, 8);
   }
   /**
@@ -309019,7 +309977,14 @@ var LocalAgentExecutor = class _LocalAgentExecutor {
       try {
         const initialHints = this.context.config.injectionService.getInjectionsAfter(startIndex, "user_steering");
         const formattedInitialHints = formatUserHintsForModel(initialHints);
-        const environmentMemory = this.context.config.isJitContextEnabled?.() ? this.context.config.getSessionMemory() : this.context.config.getEnvironmentMemory();
+        let environmentMemory;
+        if (this.context.config.isJitContextEnabled?.()) {
+          environmentMemory = this.definition.includeExtensionContext === false ? this.context.config.getSessionMemory({
+            includeExtensionContext: false
+          }) : this.context.config.getSessionMemory();
+        } else {
+          environmentMemory = this.context.config.getEnvironmentMemory();
+        }
         const initialParts = [];
         if (environmentMemory) {
           initialParts.push({ text: environmentMemory });
@@ -309222,22 +310187,26 @@ var LocalAgentExecutor = class _LocalAgentExecutor {
     const requestedModel = resolvedConfig.model;
     let modelToUse;
     if (isAutoModel(requestedModel)) {
-      try {
-        const routingContext = {
-          history: chat.getHistory(
-            /*curated=*/
-            true
-          ),
-          request: message.parts || [],
-          signal,
-          requestedModel
-        };
-        const router = this.context.config.getModelRouterService();
-        const decision = await router.route(routingContext);
-        modelToUse = decision.model;
-      } catch (error40) {
-        debugLogger.warn(`Error during model routing: ${error40}`);
-        modelToUse = DEFAULT_GEMINI_MODEL;
+      modelToUse = this.cache.get("modelToUse");
+      if (!modelToUse) {
+        try {
+          const routingContext = {
+            history: chat.getHistory(
+              /*curated=*/
+              true
+            ),
+            request: message.parts || [],
+            signal,
+            requestedModel
+          };
+          const router = this.context.config.getModelRouterService();
+          const decision = await router.route(routingContext);
+          modelToUse = decision.model;
+        } catch (error40) {
+          debugLogger.warn(`Error during model routing: ${error40}`);
+          modelToUse = DEFAULT_GEMINI_MODEL;
+        }
+        this.cache.set("modelToUse", modelToUse);
       }
     } else {
       modelToUse = requestedModel;
@@ -309446,12 +310415,14 @@ var LocalAgentExecutor = class _LocalAgentExecutor {
       const part = syncResults.get(callId);
       if (part) {
         toolResponseParts.push(part);
+        continue;
       }
-    }
-    if (functionCalls.length > 0 && toolResponseParts.length === 0 && !taskCompleted) {
-      toolResponseParts.push({
-        text: "All tool calls failed or were unauthorized. Please analyze the errors and try an alternative approach."
-      });
+      const isAborted = signal.aborted;
+      const isTaskComplete = functionCall.name === COMPLETE_TASK_TOOL_NAME && taskCompleted;
+      if (isAborted || isTaskComplete) {
+        continue;
+      }
+      throw new Error(`[LocalAgentExecutor] Critical System Failure: Tool execution result was lost/dropped by the scheduler for callId ${callId} (${functionCall.name}). This indicates an internal race condition or scheduler bug.`);
     }
     return {
       nextMessage: { role: "user", parts: toolResponseParts },
@@ -309760,7 +310731,7 @@ var LocalSubagentInvocation = class extends BaseToolInvocation {
           isSubagentProgress: true,
           agentName: this.definition.name,
           recentActivity: [],
-          state: "running"
+          state: SubagentState.RUNNING
         };
         updateOutput(initialProgress);
       }
@@ -309772,14 +310743,14 @@ var LocalSubagentInvocation = class extends BaseToolInvocation {
           case "THOUGHT_CHUNK": {
             const text = String(activity.data["text"]);
             const lastItem = recentActivity[recentActivity.length - 1];
-            if (lastItem && lastItem.type === "thought" && lastItem.status === "running") {
+            if (lastItem && lastItem.type === "thought" && lastItem.status === SubagentState.RUNNING) {
               lastItem.content = sanitizeThoughtContent(text);
             } else {
               recentActivity.push({
                 id: randomUUID14(),
                 type: "thought",
                 content: sanitizeThoughtContent(text),
-                status: "running"
+                status: SubagentState.RUNNING
               });
             }
             updated = true;
@@ -309801,7 +310772,7 @@ var LocalSubagentInvocation = class extends BaseToolInvocation {
               displayName,
               description,
               args: args2,
-              status: "running"
+              status: SubagentState.RUNNING
             });
             updated = true;
             const latestTool = recentActivity[recentActivity.length - 1];
@@ -309815,8 +310786,8 @@ var LocalSubagentInvocation = class extends BaseToolInvocation {
             const data = activity.data["data"];
             const isError = isToolActivityError(data);
             for (let i3 = recentActivity.length - 1; i3 >= 0; i3--) {
-              if (recentActivity[i3].type === "tool_call" && recentActivity[i3].content === name3 && recentActivity[i3].status === "running") {
-                recentActivity[i3].status = isError ? "error" : "completed";
+              if (recentActivity[i3].type === "tool_call" && recentActivity[i3].content === name3 && recentActivity[i3].status === SubagentState.RUNNING) {
+                recentActivity[i3].status = isError ? SubagentState.ERROR : SubagentState.COMPLETED;
                 updated = true;
                 this.publishActivity(recentActivity[i3]);
                 break;
@@ -309833,16 +310804,16 @@ var LocalSubagentInvocation = class extends BaseToolInvocation {
             const toolName = activity.data["name"] ? String(activity.data["name"]) : void 0;
             if (toolName && (isCancellation || isRejection)) {
               for (let i3 = recentActivity.length - 1; i3 >= 0; i3--) {
-                if (recentActivity[i3].type === "tool_call" && recentActivity[i3].content === toolName && recentActivity[i3].status === "running") {
-                  recentActivity[i3].status = "cancelled";
+                if (recentActivity[i3].type === "tool_call" && recentActivity[i3].content === toolName && recentActivity[i3].status === SubagentState.RUNNING) {
+                  recentActivity[i3].status = SubagentState.CANCELLED;
                   updated = true;
                   break;
                 }
               }
             } else if (toolName) {
               for (let i3 = recentActivity.length - 1; i3 >= 0; i3--) {
-                if (recentActivity[i3].type === "tool_call" && recentActivity[i3].content === toolName && recentActivity[i3].status === "running") {
-                  recentActivity[i3].status = "error";
+                if (recentActivity[i3].type === "tool_call" && recentActivity[i3].content === toolName && recentActivity[i3].status === SubagentState.RUNNING) {
+                  recentActivity[i3].status = SubagentState.ERROR;
                   updated = true;
                   break;
                 }
@@ -309852,7 +310823,7 @@ var LocalSubagentInvocation = class extends BaseToolInvocation {
               id: randomUUID14(),
               type: "thought",
               content: isCancellation || isRejection ? sanitizedError : `Error: ${sanitizedError}`,
-              status: isCancellation || isRejection ? "cancelled" : "error"
+              status: isCancellation || isRejection ? SubagentState.CANCELLED : SubagentState.ERROR
             });
             updated = true;
             break;
@@ -309866,7 +310837,7 @@ var LocalSubagentInvocation = class extends BaseToolInvocation {
             agentName: this.definition.name,
             recentActivity: [...recentActivity],
             // Copy to avoid mutation issues
-            state: "running"
+            state: SubagentState.RUNNING
           };
           updateOutput(progress2);
         }
@@ -309878,7 +310849,7 @@ var LocalSubagentInvocation = class extends BaseToolInvocation {
           isSubagentProgress: true,
           agentName: this.definition.name,
           recentActivity: [...recentActivity],
-          state: "cancelled"
+          state: SubagentState.CANCELLED
         };
         if (updateOutput) {
           updateOutput(progress2);
@@ -309891,7 +310862,7 @@ var LocalSubagentInvocation = class extends BaseToolInvocation {
         isSubagentProgress: true,
         agentName: this.definition.name,
         recentActivity: [...recentActivity],
-        state: "completed",
+        state: SubagentState.COMPLETED,
         result: output.result,
         terminateReason: output.terminate_reason
       };
@@ -309912,18 +310883,18 @@ ${output.result}`;
       debugLogger.error(`Subagent '${this.definition.name}' failed:`, error40);
       const isAbort = error40 instanceof Error && error40.name === "AbortError" || errorMessage.includes("Aborted");
       for (const item of recentActivity) {
-        if (item.status === "running") {
-          item.status = isAbort ? "cancelled" : "error";
+        if (item.status === SubagentState.RUNNING) {
+          item.status = isAbort ? SubagentState.CANCELLED : SubagentState.ERROR;
         }
       }
       if (!isAbort) {
         const lastActivity = recentActivity[recentActivity.length - 1];
-        if (!lastActivity || lastActivity.status !== "error") {
+        if (!lastActivity || lastActivity.status !== SubagentState.ERROR) {
           recentActivity.push({
             id: randomUUID14(),
             type: "thought",
             content: `Error: ${errorMessage}`,
-            status: "error"
+            status: SubagentState.ERROR
           });
         }
       }
@@ -309931,7 +310902,7 @@ ${output.result}`;
         isSubagentProgress: true,
         agentName: this.definition.name,
         recentActivity: [...recentActivity],
-        state: isAbort ? "cancelled" : "error"
+        state: isAbort ? SubagentState.CANCELLED : SubagentState.ERROR
       };
       if (updateOutput) {
         updateOutput(progress);
@@ -310046,7 +311017,7 @@ var A2AResultReassembler = class {
         id: "auth-required",
         type: "thought",
         content: AUTH_REQUIRED_MSG,
-        status: "running"
+        status: SubagentState.RUNNING
       });
     }
     this.messageLog.forEach((msg, index) => {
@@ -310054,7 +311025,7 @@ var A2AResultReassembler = class {
         id: `msg-${index}`,
         type: "thought",
         content: msg.trim(),
-        status: "completed"
+        status: SubagentState.COMPLETED
       });
     });
     if (items.length === 0 && !isAuthRequired) {
@@ -310062,7 +311033,7 @@ var A2AResultReassembler = class {
         id: "pending",
         type: "thought",
         content: "Working...",
-        status: "running"
+        status: SubagentState.RUNNING
       });
     }
     return items;
@@ -310247,13 +311218,13 @@ var RemoteAgentInvocation = class _RemoteAgentInvocation extends BaseToolInvocat
         updateOutput({
           isSubagentProgress: true,
           agentName,
-          state: "running",
+          state: SubagentState.RUNNING,
           recentActivity: [
             {
               id: "pending",
               type: "thought",
               content: "Working...",
-              status: "running"
+              status: SubagentState.RUNNING
             }
           ]
         });
@@ -310284,7 +311255,7 @@ var RemoteAgentInvocation = class _RemoteAgentInvocation extends BaseToolInvocat
           updateOutput({
             isSubagentProgress: true,
             agentName,
-            state: "running",
+            state: SubagentState.RUNNING,
             recentActivity: reassembler.toActivityItems(),
             result: reassembler.toString()
           });
@@ -310304,7 +311275,7 @@ ${JSON.stringify(finalResponse, null, 2)}`);
       const finalProgress = {
         isSubagentProgress: true,
         agentName,
-        state: "completed",
+        state: SubagentState.COMPLETED,
         result: finalOutput,
         recentActivity: reassembler.toActivityItems()
       };
@@ -310324,7 +311295,7 @@ ${errorMessage}` : errorMessage;
       const errorProgress = {
         isSubagentProgress: true,
         agentName,
-        state: "error",
+        state: SubagentState.ERROR,
         result: fullDisplay,
         recentActivity: reassembler.toActivityItems()
       };
@@ -311834,7 +312805,7 @@ var BrowserAgentInvocation = class extends BaseToolInvocation {
           isSubagentProgress: true,
           agentName: this.agentName,
           recentActivity: [],
-          state: "running"
+          state: SubagentState.RUNNING
         };
         updateOutput(initialProgress);
       }
@@ -311844,7 +312815,7 @@ var BrowserAgentInvocation = class extends BaseToolInvocation {
           id: randomUUID15(),
           type: "thought",
           content: sanitizedMsg,
-          status: "completed"
+          status: SubagentState.COMPLETED
         });
         if (recentActivity.length > MAX_RECENT_ACTIVITY) {
           recentActivity = recentActivity.slice(-MAX_RECENT_ACTIVITY);
@@ -311853,7 +312824,7 @@ var BrowserAgentInvocation = class extends BaseToolInvocation {
           isSubagentProgress: true,
           agentName: this.agentName,
           recentActivity: [...recentActivity],
-          state: "running"
+          state: SubagentState.RUNNING
         });
       } : void 0;
       const result2 = await createBrowserAgentDefinition(this.config, this.messageBus, printOutput);
@@ -311869,14 +312840,14 @@ var BrowserAgentInvocation = class extends BaseToolInvocation {
           case "THOUGHT_CHUNK": {
             const text = String(activity.data["text"]);
             const lastItem = recentActivity[recentActivity.length - 1];
-            if (lastItem && lastItem.type === "thought" && lastItem.status === "running") {
+            if (lastItem && lastItem.type === "thought" && lastItem.status === SubagentState.RUNNING) {
               lastItem.content = sanitizeThoughtContent(text);
             } else {
               recentActivity.push({
                 id: randomUUID15(),
                 type: "thought",
                 content: sanitizeThoughtContent(text),
-                status: "running"
+                status: SubagentState.RUNNING
               });
             }
             updated = true;
@@ -311895,7 +312866,7 @@ var BrowserAgentInvocation = class extends BaseToolInvocation {
               displayName,
               description,
               args: args2,
-              status: "running"
+              status: SubagentState.RUNNING
             });
             updated = true;
             break;
@@ -311905,8 +312876,8 @@ var BrowserAgentInvocation = class extends BaseToolInvocation {
             const data = activity.data["data"];
             const isError = isToolActivityError(data);
             for (let i3 = recentActivity.length - 1; i3 >= 0; i3--) {
-              if (recentActivity[i3].type === "tool_call" && callId != null && recentActivity[i3].id === callId && recentActivity[i3].status === "running") {
-                recentActivity[i3].status = isError ? "error" : "completed";
+              if (recentActivity[i3].type === "tool_call" && callId != null && recentActivity[i3].id === callId && recentActivity[i3].status === SubagentState.RUNNING) {
+                recentActivity[i3].status = isError ? SubagentState.ERROR : SubagentState.COMPLETED;
                 updated = true;
                 break;
               }
@@ -311917,10 +312888,10 @@ var BrowserAgentInvocation = class extends BaseToolInvocation {
             const error40 = String(activity.data["error"]);
             const isCancellation = error40 === "Request cancelled.";
             const callId = activity.data["callId"] ? String(activity.data["callId"]) : void 0;
-            const newStatus = isCancellation ? "cancelled" : "error";
+            const newStatus = isCancellation ? SubagentState.CANCELLED : SubagentState.ERROR;
             if (callId) {
               for (let i3 = recentActivity.length - 1; i3 >= 0; i3--) {
-                if (recentActivity[i3].type === "tool_call" && recentActivity[i3].id === callId && recentActivity[i3].status === "running") {
+                if (recentActivity[i3].type === "tool_call" && recentActivity[i3].id === callId && recentActivity[i3].status === SubagentState.RUNNING) {
                   recentActivity[i3].status = newStatus;
                   updated = true;
                   break;
@@ -311928,7 +312899,7 @@ var BrowserAgentInvocation = class extends BaseToolInvocation {
               }
             } else {
               for (const item of recentActivity) {
-                if (item.type === "tool_call" && item.status === "running") {
+                if (item.type === "tool_call" && item.status === SubagentState.RUNNING) {
                   item.status = newStatus;
                   updated = true;
                 }
@@ -311955,7 +312926,7 @@ var BrowserAgentInvocation = class extends BaseToolInvocation {
             isSubagentProgress: true,
             agentName: this.agentName,
             recentActivity: [...recentActivity],
-            state: "running"
+            state: SubagentState.RUNNING
           };
           updateOutput(progress2);
         }
@@ -311974,11 +312945,11 @@ Result:
 ${output.result}`;
       let progressState;
       if (output.terminate_reason === AgentTerminateMode.ABORTED) {
-        progressState = "cancelled";
+        progressState = SubagentState.CANCELLED;
       } else if (output.terminate_reason === AgentTerminateMode.GOAL) {
-        progressState = "completed";
+        progressState = SubagentState.COMPLETED;
       } else {
-        progressState = "error";
+        progressState = SubagentState.ERROR;
       }
       const progress = {
         isSubagentProgress: true,
@@ -312000,15 +312971,15 @@ ${output.result}`;
       const isAbort = error40 instanceof Error && error40.name === "AbortError" || rawErrorMessage.includes("Aborted");
       const errorMessage = sanitizeErrorMessage(rawErrorMessage);
       for (const item of recentActivity) {
-        if (item.status === "running") {
-          item.status = isAbort ? "cancelled" : "error";
+        if (item.status === SubagentState.RUNNING) {
+          item.status = isAbort ? SubagentState.CANCELLED : SubagentState.ERROR;
         }
       }
       const progress = {
         isSubagentProgress: true,
         agentName: this.agentName,
         recentActivity: [...recentActivity],
-        state: isAbort ? "cancelled" : "error"
+        state: isAbort ? SubagentState.CANCELLED : SubagentState.ERROR
       };
       if (updateOutput) {
         updateOutput(progress);
@@ -317289,9 +318260,15 @@ var GitService = class _GitService {
     const gitConfigPath = path66.join(repoDir, ".gitconfig");
     const systemConfigPath = path66.join(repoDir, ".gitconfig_system_empty");
     return {
+      ...sanitizeEnvironment(process.env, getSecureSanitizationConfig({
+        enableEnvironmentVariableRedaction: true
+      })),
       // Prevent git from using the user's global git config.
       GIT_CONFIG_GLOBAL: gitConfigPath,
       GIT_CONFIG_SYSTEM: systemConfigPath,
+      // Ensure we don't inherit isolation-breaking variables from the user environment.
+      GIT_DIR: void 0,
+      GIT_WORK_TREE: void 0,
       // Explicitly provide identity to prevent "Author identity unknown" errors
       // inside sandboxed environments like Docker where the gitconfig might not
       // be picked up properly.
@@ -317346,9 +318323,9 @@ var GitService = class _GitService {
   get shadowGitRepository() {
     const repoDir = this.getHistoryDir();
     return simpleGit(this.projectRoot).env({
+      ...this.getShadowRepoEnv(repoDir),
       GIT_DIR: path66.join(repoDir, ".git"),
-      GIT_WORK_TREE: this.projectRoot,
-      ...this.getShadowRepoEnv(repoDir)
+      GIT_WORK_TREE: this.projectRoot
     });
   }
   async getCurrentCommitHash() {
@@ -318195,16 +319172,19 @@ var TrackerVisualizeTool = class _TrackerVisualizeTool extends BaseDeclarativeTo
 // packages/core/dist/src/availability/modelAvailabilityService.js
 var ModelAvailabilityService = class {
   health = /* @__PURE__ */ new Map();
-  markTerminal(model, reason) {
+  markTerminal(modelId, reason) {
+    const model = normalizeModelId(modelId);
     this.setState(model, {
       status: "terminal",
       reason
     });
   }
-  markHealthy(model) {
+  markHealthy(modelId) {
+    const model = normalizeModelId(modelId);
     this.clearState(model);
   }
-  markRetryOncePerTurn(model, attempts = 1) {
+  markRetryOncePerTurn(modelId, attempts = 1) {
+    const model = normalizeModelId(modelId);
     const currentState = this.health.get(model);
     if (currentState?.status === "terminal") {
       return;
@@ -318220,13 +319200,15 @@ var ModelAvailabilityService = class {
       attempts
     });
   }
-  consumeStickyAttempt(model) {
+  consumeStickyAttempt(modelId) {
+    const model = normalizeModelId(modelId);
     const state = this.health.get(model);
     if (state?.status === "sticky_retry") {
       this.setState(model, { ...state, consumed: true });
     }
   }
-  snapshot(model) {
+  snapshot(modelId) {
+    const model = normalizeModelId(modelId);
     const state = this.health.get(model);
     if (!state) {
       return { available: true };
@@ -318239,9 +319221,10 @@ var ModelAvailabilityService = class {
     }
     return { available: true };
   }
-  selectFirstAvailable(models) {
+  selectFirstAvailable(modelIds) {
     const skipped = [];
-    for (const model of models) {
+    for (const modelId of modelIds) {
+      const model = normalizeModelId(modelId);
       const snapshot = this.snapshot(model);
       if (snapshot.available) {
         const state = this.health.get(model);
@@ -318408,7 +319391,13 @@ ${formattedHistory}
       const routerResponse = ClassifierResponseSchema.parse(jsonResponse);
       const reasoning = routerResponse.reasoning;
       const latencyMs = Date.now() - startTime;
-      const selectedModel = resolveClassifierModel(context2.requestedModel ?? config2.getModel(), routerResponse.model_choice);
+      const [useGemini3_1, useGemini3_1FlashLite, useCustomToolModel, hasAccessToPreview] = await Promise.all([
+        config2.getGemini31Launched(),
+        config2.getGemini31FlashLiteLaunched(),
+        config2.getUseCustomToolModel(),
+        config2.getHasAccessToPreviewModel?.() ?? true
+      ]);
+      const selectedModel = resolveClassifierModel(context2.requestedModel ?? config2.getModel(), routerResponse.model_choice, useGemini3_1, useGemini3_1FlashLite, useCustomToolModel, hasAccessToPreview, config2);
       return {
         model: selectedModel,
         metadata: {
@@ -318566,7 +319555,13 @@ var ClassifierStrategy = class {
         config2.getGemini31FlashLiteLaunched(),
         config2.getUseCustomToolModel()
       ]);
-      const selectedModel = resolveClassifierModel(model, routerResponse.model_choice, useGemini3_1, useGemini3_1FlashLite, useCustomToolModel, config2.getHasAccessToPreviewModel?.() ?? true, config2);
+      const selectedModel = normalizeModelId(resolveClassifierModel(normalizeModelId(model), routerResponse.model_choice, useGemini3_1, useGemini3_1FlashLite, useCustomToolModel, config2.getHasAccessToPreviewModel?.() ?? true, config2));
+      const service = config2.getModelAvailabilityService();
+      const snapshot = service.snapshot(selectedModel);
+      if (!snapshot.available) {
+        debugLogger.warn(`[Routing] Classifier selected unavailable model ${selectedModel} (${snapshot.reason}). Bypassing.`);
+        return null;
+      }
       return {
         model: selectedModel,
         metadata: {
@@ -318664,7 +319659,15 @@ var NumericalClassifierStrategy = class {
         return null;
       }
       const promptId = getPromptIdWithFallback("classifier-router");
-      const finalHistory = context2.history.slice(-HISTORY_TURNS_FOR_CONTEXT3);
+      const candidateSlice = context2.history.slice(-HISTORY_TURNS_FOR_CONTEXT3);
+      let firstTextIndex = -1;
+      for (let i3 = 0; i3 < candidateSlice.length; i3++) {
+        if (!isFunctionCall(candidateSlice[i3]) && !isFunctionResponse(candidateSlice[i3])) {
+          firstTextIndex = i3;
+          break;
+        }
+      }
+      const finalHistory = firstTextIndex === -1 ? [] : candidateSlice.slice(firstTextIndex);
       const requestParts = Array.isArray(context2.request) ? context2.request : [context2.request];
       const sanitizedRequest = requestParts.map((part) => {
         if (typeof part === "string") {
@@ -318692,7 +319695,13 @@ var NumericalClassifierStrategy = class {
         config2.getGemini31FlashLiteLaunched(),
         config2.getUseCustomToolModel()
       ]);
-      const selectedModel = resolveClassifierModel(model, modelAlias, useGemini3_1, useGemini3_1FlashLite, useCustomToolModel, config2.getHasAccessToPreviewModel?.() ?? true, config2);
+      const selectedModel = normalizeModelId(resolveClassifierModel(normalizeModelId(model), modelAlias, useGemini3_1, useGemini3_1FlashLite, useCustomToolModel, config2.getHasAccessToPreviewModel?.() ?? true, config2));
+      const service = config2.getModelAvailabilityService();
+      const snapshot = service.snapshot(selectedModel);
+      if (!snapshot.available) {
+        debugLogger.warn(`[Routing] Numerical classifier selected unavailable model ${selectedModel} (${snapshot.reason}). Bypassing.`);
+        return null;
+      }
       const latencyMs = Date.now() - startTime;
       return {
         model: selectedModel,
@@ -318834,12 +319843,14 @@ var ApprovalModeStrategy = class {
     const startTime = Date.now();
     const approvalMode = config2.getApprovalMode();
     const approvedPlanPath = config2.getApprovedPlanPath();
-    const [useGemini3_1, useCustomToolModel] = await Promise.all([
+    const [useGemini3_1, useGemini3_1FlashLite, useCustomToolModel, hasAccessToPreview] = await Promise.all([
       config2.getGemini31Launched(),
-      config2.getUseCustomToolModel()
+      config2.getGemini31FlashLiteLaunched(),
+      config2.getUseCustomToolModel(),
+      config2.getHasAccessToPreviewModel()
     ]);
     if (approvalMode === ApprovalMode.PLAN) {
-      const proModel = resolveClassifierModel(model, GEMINI_MODEL_ALIAS_PRO, useGemini3_1, useCustomToolModel);
+      const proModel = resolveClassifierModel(model, GEMINI_MODEL_ALIAS_PRO, useGemini3_1, useGemini3_1FlashLite, useCustomToolModel, hasAccessToPreview, config2);
       return {
         model: proModel,
         metadata: {
@@ -318849,7 +319860,7 @@ var ApprovalModeStrategy = class {
         }
       };
     } else if (approvedPlanPath) {
-      const flashModel = resolveClassifierModel(model, GEMINI_MODEL_ALIAS_FLASH, useGemini3_1, useCustomToolModel);
+      const flashModel = resolveClassifierModel(model, GEMINI_MODEL_ALIAS_FLASH, useGemini3_1, useGemini3_1FlashLite, useCustomToolModel, hasAccessToPreview, config2);
       return {
         model: flashModel,
         metadata: {
@@ -319153,6 +320164,19 @@ var DEFAULT_MODEL_CONFIGS = {
       extends: "gemini-3-flash-base",
       modelConfig: {}
     },
+    "context-snapshotter": {
+      extends: "gemini-3-flash-base",
+      modelConfig: {
+        generateContentConfig: {
+          thinkingConfig: {
+            thinkingLevel: ThinkingLevel.HIGH
+          },
+          temperature: 1,
+          topP: 0.95,
+          topK: 64
+        }
+      }
+    },
     "chat-compression-3-pro": {
       modelConfig: {
         model: "gemini-3-pro-preview"
@@ -321786,7 +322810,7 @@ var HookEventHandler = class {
       const hookType = this.getHookTypeFromResult(result2);
       const hookCallEvent = new HookCallEvent(eventName, hookType, hookName, { ...input }, result2.duration, result2.success, result2.output ? { ...result2.output } : void 0, result2.exitCode, result2.stdout, result2.stderr, result2.error?.message);
       logHookCall(this.context.config, hookCallEvent);
-      if (result2.output?.systemMessage && result2.outputFormat === "json") {
+      if (result2.output?.systemMessage) {
         coreEvents.emitHookSystemMessage({
           hookName,
           eventName,
@@ -323839,8 +324863,8 @@ var AllowedPathChecker = class {
       while (current && current !== path73.dirname(current)) {
         if (fs65.existsSync(current)) {
           const canonical = fs65.realpathSync(current);
-          const relative12 = path73.relative(current, resolved);
-          return path73.join(canonical, relative12);
+          const relative11 = path73.relative(current, resolved);
+          return path73.join(canonical, relative11);
         }
         current = path73.dirname(current);
       }
@@ -323850,8 +324874,8 @@ var AllowedPathChecker = class {
     }
   }
   isPathAllowed(targetPath, allowedDir) {
-    const relative12 = path73.relative(allowedDir, targetPath);
-    return relative12 === "" || !relative12.startsWith("..") && !path73.isAbsolute(relative12);
+    const relative11 = path73.relative(allowedDir, targetPath);
+    return relative11 === "" || !relative11.startsWith("..") && !path73.isAbsolute(relative11);
   }
   collectPathsToCheck(args2, includedArgs, excludedArgs, prefix = "") {
     const paths = [];
@@ -327069,21 +328093,29 @@ async function connectToMcpServer(clientVersion, mcpServerName, mcpServerConfig,
   }
 }
 function createUrlTransport(mcpServerName, mcpServerConfig, transportOptions) {
+  const baseFetch = transportOptions.fetch ?? globalThis.fetch;
+  const httpOptions = {
+    ...transportOptions,
+    fetch: async (url3, init2) => {
+      const res = await baseFetch(url3, init2);
+      return init2?.method === "GET" && res.status === 404 ? new Response(null, { status: 405, statusText: "Method Not Allowed" }) : res;
+    }
+  };
   if (mcpServerConfig.httpUrl) {
     if (mcpServerConfig.url) {
       debugLogger.warn(`MCP server '${mcpServerName}': Both 'httpUrl' and 'url' are configured. Using deprecated 'httpUrl'. Please migrate to 'url' with 'type: "http"'.`);
     }
-    return new StreamableHTTPClientTransport(new URL(mcpServerConfig.httpUrl), transportOptions);
+    return new StreamableHTTPClientTransport(new URL(mcpServerConfig.httpUrl), httpOptions);
   }
   if (mcpServerConfig.url && mcpServerConfig.type) {
     if (mcpServerConfig.type === "http") {
-      return new StreamableHTTPClientTransport(new URL(mcpServerConfig.url), transportOptions);
+      return new StreamableHTTPClientTransport(new URL(mcpServerConfig.url), httpOptions);
     } else if (mcpServerConfig.type === "sse") {
       return new SSEClientTransport(new URL(mcpServerConfig.url), transportOptions);
     }
   }
   if (mcpServerConfig.url) {
-    return new StreamableHTTPClientTransport(new URL(mcpServerConfig.url), transportOptions);
+    return new StreamableHTTPClientTransport(new URL(mcpServerConfig.url), httpOptions);
   }
   throw new Error(`No URL configured for MCP server '${mcpServerName}'`);
 }
@@ -336035,7 +337067,15 @@ var Config = class {
       this.workspaceContext.addDirectory(dir);
     }
     if (this.planEnabled) {
-      const plansDir = this.storage.getPlansDir();
+      let plansDir;
+      try {
+        plansDir = this.storage.getPlansDir();
+      } catch (error40) {
+        const errorMessage = error40 instanceof Error ? error40.message : String(error40);
+        coreEvents.emitFeedback("warning", "Invalid custom plans directory: " + errorMessage + ". Falling back to default project temp directory.", error40);
+        this.storage.setCustomPlansDir(void 0);
+        plansDir = this.storage.getPlansDir();
+      }
       try {
         await fs68.promises.access(plansDir);
         this.workspaceContext.addDirectory(plansDir);
@@ -336720,7 +337760,7 @@ var Config = class {
     if (this.experimentalJitContext && this.memoryContextManager) {
       await this.memoryContextManager.refresh();
     } else {
-      const { refreshServerHierarchicalMemory: refreshServerHierarchicalMemory2 } = await import("./memoryDiscovery-KSYZVCWF.js");
+      const { refreshServerHierarchicalMemory: refreshServerHierarchicalMemory2 } = await import("./memoryDiscovery-LLSKN6HL.js");
       await refreshServerHierarchicalMemory2(this);
     }
     if (this._geminiClient?.isInitialized()) {
@@ -336755,12 +337795,13 @@ var Config = class {
    * user message when JIT is enabled. Returns empty string when JIT is
    * disabled (Tier 2 memory is already in the system instruction).
    */
-  getSessionMemory() {
+  getSessionMemory(options) {
     if (!this.experimentalJitContext || !this.memoryContextManager) {
       return "";
     }
     const sections = [];
-    const extension = this.memoryContextManager.getExtensionMemory();
+    const includeExtensionContext = options?.includeExtensionContext ?? true;
+    const extension = includeExtensionContext ? this.memoryContextManager.getExtensionMemory() : "";
     const project = this.memoryContextManager.getEnvironmentMemory();
     if (extension?.trim()) {
       sections.push(`<extension_context>
@@ -337175,16 +338216,32 @@ ${sections.join("\n")}
   setIdeMode(value) {
     this.ideMode = value;
   }
-  isScopedMemoryInboxPatchPathAllowed(absolutePath, resolvedPath, inboxRoot) {
+  isScopedMemoryInboxPatchPathAllowed(absolutePath, resolvedPath, inboxRoot, checkType = "write") {
     if (!hasScopedMemoryInboxAccess()) {
       return false;
     }
     const normalizedPath = path76.resolve(absolutePath);
+    const resolvedMemoryRoot = resolveToRealPath(this.storage.getProjectMemoryTempDir());
+    if (checkType === "read") {
+      const resolvedInboxRoot = resolveToRealPath(inboxRoot);
+      const normalizedInboxRoot = path76.resolve(inboxRoot);
+      if (resolvedPath === resolvedInboxRoot || normalizedPath === normalizedInboxRoot) {
+        return isSubpath(resolvedMemoryRoot, resolvedPath);
+      }
+      for (const kind of ["private", "global"]) {
+        const kindRoot = path76.join(inboxRoot, kind);
+        const resolvedKindRoot = resolveToRealPath(kindRoot);
+        const normalizedKindRoot = path76.resolve(kindRoot);
+        if (resolvedPath === resolvedKindRoot || normalizedPath === normalizedKindRoot || isSubpath(resolvedKindRoot, resolvedPath) || isSubpath(normalizedKindRoot, normalizedPath)) {
+          return isSubpath(resolvedMemoryRoot, resolvedPath);
+        }
+      }
+      return false;
+    }
     const isCanonicalPatchPath = ["private", "global"].some((kind) => normalizedPath === path76.resolve(inboxRoot, kind, "extraction.patch"));
     if (!isCanonicalPatchPath) {
       return false;
     }
-    const resolvedMemoryRoot = resolveToRealPath(this.storage.getProjectMemoryTempDir());
     return isSubpath(resolvedMemoryRoot, resolvedPath);
   }
   isScopedAutoMemoryExtractionWritePathAllowed(absolutePath, resolvedPath) {
@@ -337214,7 +338271,9 @@ ${sections.join("\n")}
    * the auto-memory extraction agent and the `/memory inbox` review flow. The
    * main agent is denied access to it even though it falls inside the project
    * temp dir; the extraction agent receives a narrow execution-scoped exception
-   * for `.inbox/{private,global}/extraction.patch`.
+   * for *writes* to `.inbox/{private,global}/extraction.patch`. Scoped *read*
+   * access to the wider `.inbox/{private,global}/` subtree is granted in
+   * `validatePathAccess` so the extractor can enumerate prior patches.
    *
    * @param absolutePath The absolute path to check.
    * @returns true if the path is allowed, false otherwise.
@@ -337266,6 +338325,12 @@ ${sections.join("\n")}
       if (this.getWorkspaceContext().isPathReadable(absolutePath)) {
         return null;
       }
+      if (hasScopedMemoryInboxAccess()) {
+        const inboxRoot = path76.join(this.storage.getProjectMemoryTempDir(), ".inbox");
+        if (this.isScopedMemoryInboxPatchPathAllowed(absolutePath, resolveToRealPath(absolutePath), inboxRoot, "read")) {
+          return null;
+        }
+      }
     }
     if (this.isPathAllowed(absolutePath)) {
       return null;
@@ -337592,10 +338657,10 @@ ${sections.join("\n")}
     return this.gemmaModelRouter;
   }
   getAgentSessionNoninteractiveEnabled() {
-    return this.agentSessionNoninteractiveEnabled;
+    return process15.env["GEMINI_CLI_EXP_AGENT"] === "true" || this.agentSessionNoninteractiveEnabled;
   }
   getAgentSessionInteractiveEnabled() {
-    return this.agentSessionInteractiveEnabled;
+    return process15.env["GEMINI_CLI_EXP_AGENT"] === "true" || this.agentSessionInteractiveEnabled;
   }
   /**
    * Get override settings for a specific agent.
@@ -338560,11 +339625,228 @@ async function isProjectSkillPatchTarget(targetPath, config2) {
 function hasParsedPatchHunks(parsedPatches) {
   return parsedPatches.length > 0 && parsedPatches.every((patch) => patch.hunks.length > 0);
 }
+function getMemoryPatchRoot(memoryDir, kind) {
+  return path80.join(memoryDir, ".inbox", kind);
+}
+function isSubpathOrSame(childPath, parentPath) {
+  return isSubpath(parentPath, childPath);
+}
+function normalizeInboxMemoryPatchPath(relativePath) {
+  if (relativePath.length === 0 || path80.isAbsolute(relativePath) || relativePath.includes("\\")) {
+    return void 0;
+  }
+  const normalizedPath = path80.posix.normalize(relativePath);
+  if (normalizedPath === "." || normalizedPath.startsWith("../") || normalizedPath === ".." || !normalizedPath.endsWith(".patch")) {
+    return void 0;
+  }
+  return normalizedPath;
+}
+function getAllowedMemoryPatchRoots(config2, kind) {
+  switch (kind) {
+    case "private":
+      return [path80.resolve(config2.storage.getProjectMemoryTempDir())];
+    case "global":
+      return [path80.resolve(getGlobalMemoryFilePath())];
+    default:
+      throw new Error(`Unknown memory patch kind: ${kind}`);
+  }
+}
+function hasMarkdownExtension(fileName) {
+  return fileName.toLowerCase().endsWith(".md");
+}
+function isAllowedPrivateMemoryFileName(fileName) {
+  if (fileName === PROJECT_MEMORY_INDEX_FILENAME) {
+    return true;
+  }
+  return !fileName.startsWith(".") && hasMarkdownExtension(fileName);
+}
+function uniqueResolvedPaths(paths) {
+  return Array.from(new Set(paths.map((filePath) => path80.resolve(filePath))));
+}
+function isSamePath(leftPath, rightPath) {
+  return isSubpath(leftPath, rightPath) && isSubpath(rightPath, leftPath);
+}
+function includesSamePath(paths, targetPath) {
+  return paths.some((candidate) => isSamePath(candidate, targetPath));
+}
+function isAllowedPrivateMemoryDocumentPath(targetPath, memoryDirs) {
+  const resolvedTargetPath = path80.resolve(targetPath);
+  const targetDir = path80.dirname(resolvedTargetPath);
+  if (!includesSamePath(memoryDirs, targetDir)) {
+    return false;
+  }
+  return isAllowedPrivateMemoryFileName(path80.basename(resolvedTargetPath));
+}
+function isAllowedGlobalMemoryDocumentPath(targetPath, globalMemoryFiles) {
+  const resolvedTargetPath = path80.resolve(targetPath);
+  return includesSamePath(globalMemoryFiles, resolvedTargetPath);
+}
+async function getMemoryPatchTargetValidationContext(config2, kind) {
+  const allowedRoots = await canonicalizeAllowedPatchRoots(getAllowedMemoryPatchRoots(config2, kind));
+  if (kind === "global") {
+    const rawGlobalMemoryFile = path80.resolve(getGlobalMemoryFilePath());
+    const canonicalGlobalMemoryFiles = await canonicalizeAllowedPatchRoots([
+      rawGlobalMemoryFile
+    ]);
+    return {
+      kind,
+      allowedRoots,
+      privateMemoryDirs: [],
+      globalMemoryFiles: uniqueResolvedPaths([
+        rawGlobalMemoryFile,
+        ...canonicalGlobalMemoryFiles
+      ])
+    };
+  }
+  const rawPrivateMemoryDir = path80.resolve(config2.storage.getProjectMemoryTempDir());
+  const canonicalPrivateMemoryDirs = await canonicalizeAllowedPatchRoots([
+    rawPrivateMemoryDir
+  ]);
+  const privateMemoryDirs = uniqueResolvedPaths([
+    rawPrivateMemoryDir,
+    ...canonicalPrivateMemoryDirs
+  ]);
+  return { kind, allowedRoots, privateMemoryDirs, globalMemoryFiles: [] };
+}
+function isResolvedMemoryPatchTargetAllowed(resolvedTargetPath, context2) {
+  if (context2.kind === "global") {
+    return isAllowedGlobalMemoryDocumentPath(resolvedTargetPath, context2.globalMemoryFiles);
+  }
+  if (context2.kind === "private") {
+    return isAllowedPrivateMemoryDocumentPath(resolvedTargetPath, context2.privateMemoryDirs);
+  }
+  return true;
+}
+async function resolveMemoryPatchTargetWithinAllowedSet(targetPath, context2) {
+  const resolvedTargetPath = await resolveTargetWithinAllowedRoots(targetPath, context2.allowedRoots);
+  if (!resolvedTargetPath) {
+    return void 0;
+  }
+  if (context2.kind === "private" && (!isAllowedPrivateMemoryDocumentPath(targetPath, context2.privateMemoryDirs) || !isAllowedPrivateMemoryDocumentPath(resolvedTargetPath, context2.privateMemoryDirs))) {
+    return void 0;
+  }
+  if (context2.kind === "global" && (!isAllowedGlobalMemoryDocumentPath(targetPath, context2.globalMemoryFiles) || !isAllowedGlobalMemoryDocumentPath(resolvedTargetPath, context2.globalMemoryFiles))) {
+    return void 0;
+  }
+  return resolvedTargetPath;
+}
+async function findDisallowedMemoryPatchTarget(parsedPatches, context2) {
+  const validated = validateParsedSkillPatchHeaders(parsedPatches);
+  if (!validated.success) {
+    return void 0;
+  }
+  for (const header of validated.patches) {
+    if (!await resolveMemoryPatchTargetWithinAllowedSet(header.targetPath, context2)) {
+      return header.targetPath;
+    }
+  }
+  return void 0;
+}
+async function getInboxMemoryPatchSourcePath(config2, kind, relativePath) {
+  const normalizedPath = normalizeInboxMemoryPatchPath(relativePath);
+  if (!normalizedPath) {
+    return void 0;
+  }
+  const patchRoot = path80.resolve(getMemoryPatchRoot(config2.storage.getProjectMemoryTempDir(), kind));
+  const sourcePath = path80.resolve(patchRoot, ...normalizedPath.split("/"));
+  if (!isSubpathOrSame(sourcePath, patchRoot)) {
+    return void 0;
+  }
+  return sourcePath;
+}
+async function listInboxPatchFiles(config2, kind) {
+  const patchRoot = getMemoryPatchRoot(config2.storage.getProjectMemoryTempDir(), kind);
+  const found = [];
+  async function walk(currentDir) {
+    let dirEntries;
+    try {
+      dirEntries = await fs71.readdir(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of dirEntries) {
+      const entryPath = path80.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(entryPath);
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(".patch")) {
+        found.push(entryPath);
+      }
+    }
+  }
+  await walk(patchRoot);
+  return found.sort();
+}
+async function validateInboxMemoryPatchFile(config2, kind, sourcePath) {
+  let content;
+  try {
+    content = await fs71.readFile(sourcePath, "utf-8");
+  } catch (error40) {
+    return {
+      valid: false,
+      reason: `failed to read patch: ${error40 instanceof Error ? error40.message : String(error40)}`
+    };
+  }
+  let parsed;
+  try {
+    parsed = parsePatch(content);
+  } catch (error40) {
+    return {
+      valid: false,
+      reason: `failed to parse patch: ${error40 instanceof Error ? error40.message : String(error40)}`
+    };
+  }
+  if (!hasParsedPatchHunks(parsed)) {
+    return { valid: false, reason: "no hunks found in patch" };
+  }
+  const validated = validateParsedSkillPatchHeaders(parsed);
+  if (!validated.success) {
+    switch (validated.reason) {
+      case "missingTargetPath":
+        return {
+          valid: false,
+          reason: "missing target file path in patch header"
+        };
+      case "invalidPatchHeaders":
+        return {
+          valid: false,
+          reason: `invalid diff headers${validated.targetPath ? `: ${validated.targetPath}` : ""}`
+        };
+      default:
+        return { valid: false, reason: "invalid patch headers" };
+    }
+  }
+  const validationContext = await getMemoryPatchTargetValidationContext(config2, kind);
+  for (const header of validated.patches) {
+    if (!await resolveMemoryPatchTargetWithinAllowedSet(header.targetPath, validationContext)) {
+      return {
+        valid: false,
+        reason: `target file is outside ${kind} memory roots: ${header.targetPath}`
+      };
+    }
+  }
+  return { valid: true };
+}
+async function listValidInboxPatchFiles(config2, kind) {
+  const patchFiles = await listInboxPatchFiles(config2, kind);
+  if (patchFiles.length === 0) {
+    return [];
+  }
+  const valid = [];
+  for (const sourcePath of patchFiles) {
+    const validation = await validateInboxMemoryPatchFile(config2, kind, sourcePath);
+    if (validation.valid) {
+      valid.push(sourcePath);
+    }
+  }
+  return valid;
+}
 async function applyParsedSkillPatches(parsedPatches, config2) {
   const allowedRoots = await getCanonicalAllowedSkillPatchRoots(config2);
   return applyParsedPatchesWithAllowedRoots(parsedPatches, allowedRoots);
 }
-async function applyParsedPatchesWithAllowedRoots(parsedPatches, allowedRoots) {
+async function applyParsedPatchesWithAllowedRoots(parsedPatches, allowedRoots, options = {}) {
   const results = /* @__PURE__ */ new Map();
   const patchedContentByTarget = /* @__PURE__ */ new Map();
   const originalContentByTarget = /* @__PURE__ */ new Map();
@@ -338575,7 +339857,7 @@ async function applyParsedPatchesWithAllowedRoots(parsedPatches, allowedRoots) {
   for (const [index, patch] of parsedPatches.entries()) {
     const { targetPath, isNewFile } = validatedHeaders.patches[index];
     const resolvedTargetPath = await resolveTargetWithinAllowedRoots(targetPath, allowedRoots);
-    if (!resolvedTargetPath) {
+    if (!resolvedTargetPath || options.isResolvedTargetAllowed && !options.isResolvedTargetAllowed(resolvedTargetPath)) {
       return {
         success: false,
         reason: "outsideAllowedRoots",
@@ -339031,6 +340313,7 @@ var SkillExtractionAgent = (skillsDir, sessionIndex, existingSkillsSummary, memo
   },
   memoryInboxAccess: true,
   autoMemoryExtractionWriteAccess: true,
+  includeExtensionContext: false,
   toolConfig: {
     tools: [
       ACTIVATE_SKILL_TOOL_NAME,
@@ -339756,6 +341039,28 @@ async function snapshotFiles(rootDir, shouldIncludeFile = () => true, shouldDesc
 async function snapshotInboxCandidates(memoryDir) {
   return snapshotFiles(path81.join(memoryDir, ".inbox"));
 }
+var MEMORY_INBOX_PATCH_KINDS = [
+  "private",
+  "global"
+];
+async function validateMemoryInboxPatches(config2) {
+  for (const kind of MEMORY_INBOX_PATCH_KINDS) {
+    const patchFiles = await listInboxPatchFiles(config2, kind);
+    for (const patchFile of patchFiles) {
+      const validation = await validateInboxMemoryPatchFile(config2, kind, patchFile);
+      if (validation.valid) {
+        continue;
+      }
+      try {
+        await fs72.unlink(patchFile);
+        debugLogger.warn(`[MemoryService] Dropped invalid ${kind} memory inbox patch ${patchFile}: ${validation.reason}`);
+      } catch (error40) {
+        const message = error40 instanceof Error ? error40.message : String(error40);
+        debugLogger.warn(`[MemoryService] Failed to drop invalid ${kind} memory inbox patch ${patchFile}: ${validation.reason}; unlink failed: ${message}`);
+      }
+    }
+  }
+}
 async function buildPendingInboxSummary(memoryDir) {
   const sections = [];
   for (const kind of ["private", "global"]) {
@@ -339964,6 +341269,7 @@ ${pendingInboxSummary}`);
     if (validPatches.length > 0) {
       debugLogger.log(`[MemoryService] ${validPatches.length} valid patch(es) currently in inbox; ${patchesCreatedThisRun.length} created or updated this run`);
     }
+    await validateMemoryInboxPatches(config2);
     const memoryFilesUpdated = [];
     const memoryCandidatesCreated = prefixRelativePaths(".inbox", getChangedSnapshotPaths(diffFileSnapshots(inboxCandidatesBefore, await snapshotInboxCandidates(memoryDir))));
     const processedSessions = candidateSessions.filter((session) => processedSessionKeys.has(getSessionVersionKey(session))).map((session) => ({
@@ -340249,33 +341555,6 @@ function formatParsedDiff(parsed) {
 function getErrorMessage4(error40) {
   return error40 instanceof Error ? error40.message : String(error40);
 }
-function getMemoryPatchRoot(memoryDir, kind) {
-  return path82.join(memoryDir, ".inbox", kind);
-}
-function isSubpathOrSame(childPath, parentPath) {
-  const relativePath = path82.relative(parentPath, childPath);
-  return relativePath === "" || !relativePath.startsWith("..") && !path82.isAbsolute(relativePath);
-}
-function normalizeInboxMemoryPatchPath(relativePath) {
-  if (relativePath.length === 0 || path82.isAbsolute(relativePath) || relativePath.includes("\\")) {
-    return void 0;
-  }
-  const normalizedPath = path82.posix.normalize(relativePath);
-  if (normalizedPath === "." || normalizedPath.startsWith("../") || normalizedPath === ".." || !normalizedPath.endsWith(".patch")) {
-    return void 0;
-  }
-  return normalizedPath;
-}
-function getAllowedMemoryPatchRoots(config2, kind) {
-  switch (kind) {
-    case "private":
-      return [path82.resolve(config2.storage.getProjectMemoryTempDir())];
-    case "global":
-      return [path82.resolve(getGlobalMemoryFilePath())];
-    default:
-      throw new Error(`Unknown memory patch kind: ${kind}`);
-  }
-}
 async function getFileMtimeIso(filePath) {
   try {
     const stats = await fs73.stat(filePath);
@@ -340284,18 +341563,6 @@ async function getFileMtimeIso(filePath) {
     return void 0;
   }
 }
-async function getInboxMemoryPatchSourcePath(config2, kind, relativePath) {
-  const normalizedPath = normalizeInboxMemoryPatchPath(relativePath);
-  if (!normalizedPath) {
-    return void 0;
-  }
-  const patchRoot = path82.resolve(getMemoryPatchRoot(config2.storage.getProjectMemoryTempDir(), kind));
-  const sourcePath = path82.resolve(patchRoot, ...normalizedPath.split("/"));
-  if (!isSubpathOrSame(sourcePath, patchRoot)) {
-    return void 0;
-  }
-  return sourcePath;
-}
 async function patchTargetsProjectSkills(targetPaths, config2) {
   for (const targetPath of targetPaths) {
     if (await isProjectSkillPatchTarget(targetPath, config2)) {
@@ -340322,70 +341589,11 @@ function formatMemoryKindLabel(kind) {
       return kind;
   }
 }
-async function listInboxPatchFiles(config2, kind) {
-  const patchRoot = getMemoryPatchRoot(config2.storage.getProjectMemoryTempDir(), kind);
-  const found = [];
-  async function walk(currentDir) {
-    let dirEntries;
-    try {
-      dirEntries = await fs73.readdir(currentDir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of dirEntries) {
-      const entryPath = path82.join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        await walk(entryPath);
-        continue;
-      }
-      if (entry.isFile() && entry.name.endsWith(".patch")) {
-        found.push(entryPath);
-      }
-    }
-  }
-  await walk(patchRoot);
-  return found.sort();
-}
-async function listValidInboxPatchFiles(config2, kind) {
-  const patchFiles = await listInboxPatchFiles(config2, kind);
-  if (patchFiles.length === 0) {
-    return [];
-  }
-  const allowedRoots = await canonicalizeAllowedPatchRoots(getAllowedMemoryPatchRoots(config2, kind));
-  const valid = [];
-  for (const sourcePath of patchFiles) {
-    let content;
-    try {
-      content = await fs73.readFile(sourcePath, "utf-8");
-    } catch {
-      continue;
-    }
-    let parsed;
-    try {
-      parsed = parsePatch(content);
-    } catch {
-      continue;
-    }
-    if (!hasParsedPatchHunks(parsed)) {
-      continue;
-    }
-    const validated = validateParsedSkillPatchHeaders(parsed);
-    if (!validated.success) {
-      continue;
-    }
-    const targetsAllAllowed = await Promise.all(validated.patches.map(async (header) => await resolveTargetWithinAllowedRoots(header.targetPath, allowedRoots) !== void 0));
-    if (!targetsAllAllowed.every(Boolean)) {
-      continue;
-    }
-    valid.push(sourcePath);
-  }
-  return valid;
-}
 async function listInboxMemoryPatches(config2) {
   const kinds = ["private", "global"];
   const aggregated = [];
   for (const kind of kinds) {
-    const allowedRoots = await canonicalizeAllowedPatchRoots(getAllowedMemoryPatchRoots(config2, kind));
+    const validationContext = await getMemoryPatchTargetValidationContext(config2, kind);
     const patchFiles = await listInboxPatchFiles(config2, kind);
     const aggregatedEntries = [];
     const sourceFiles = [];
@@ -340410,7 +341618,7 @@ async function listInboxMemoryPatches(config2) {
       if (!validated.success) {
         continue;
       }
-      const targetsAllAllowed = await Promise.all(validated.patches.map(async (header) => await resolveTargetWithinAllowedRoots(header.targetPath, allowedRoots) !== void 0));
+      const targetsAllAllowed = await Promise.all(validated.patches.map(async (header) => await resolveMemoryPatchTargetWithinAllowedSet(header.targetPath, validationContext) !== void 0));
       if (!targetsAllAllowed.every(Boolean)) {
         continue;
       }
@@ -340591,8 +341799,17 @@ async function applyMemoryPatchFile(config2, kind, patchPath, displayName) {
       message: `Memory patch "${displayName}" contains no valid hunks.`
     };
   }
-  const allowedRoots = await canonicalizeAllowedPatchRoots(getAllowedMemoryPatchRoots(config2, kind));
-  const applied = await applyParsedPatchesWithAllowedRoots(parsed, allowedRoots);
+  const validationContext = await getMemoryPatchTargetValidationContext(config2, kind);
+  const disallowedTargetPath = await findDisallowedMemoryPatchTarget(parsed, validationContext);
+  if (disallowedTargetPath) {
+    return {
+      success: false,
+      message: `Memory patch "${displayName}" targets a file outside the ${kind} memory root or target allowlist: ${disallowedTargetPath}`
+    };
+  }
+  const applied = await applyParsedPatchesWithAllowedRoots(parsed, validationContext.allowedRoots, {
+    isResolvedTargetAllowed: (resolvedTargetPath) => isResolvedMemoryPatchTargetAllowed(resolvedTargetPath, validationContext)
+  });
   if (!applied.success) {
     switch (applied.reason) {
       case "missingTargetPath":
@@ -340608,7 +341825,7 @@ async function applyMemoryPatchFile(config2, kind, patchPath, displayName) {
       case "outsideAllowedRoots":
         return {
           success: false,
-          message: `Memory patch "${displayName}" targets a file outside the ${kind} memory root: ${applied.targetPath}`
+          message: `Memory patch "${displayName}" targets a file outside the ${kind} memory root or target allowlist: ${applied.targetPath}`
         };
       case "newFileAlreadyExists":
         return {
@@ -341482,8 +342699,9 @@ function loadIgnoreRules(service, ignoreDirs = []) {
   const ignorer = new Ignore2();
   const ignoreFiles = service.getAllIgnoreFilePaths();
   for (const filePath of ignoreFiles) {
-    if (fs75.existsSync(filePath)) {
+    try {
       ignorer.add(fs75.readFileSync(filePath, "utf8"));
+    } catch {
     }
   }
   const allIgnoreDirs = [".git", ...ignoreDirs];
@@ -342641,11 +343859,11 @@ var AsyncFzf = class {
 // packages/core/node_modules/chokidar/index.js
 import { EventEmitter as EventEmitter8 } from "node:events";
 import { stat as statcb, Stats } from "node:fs";
-import { readdir as readdir10, stat as stat7 } from "node:fs/promises";
+import { readdir as readdir11, stat as stat7 } from "node:fs/promises";
 import * as sp2 from "node:path";
 
 // packages/core/node_modules/readdirp/index.js
-import { lstat as lstat3, readdir as readdir9, realpath as realpath4, stat as stat5 } from "node:fs/promises";
+import { lstat as lstat3, readdir as readdir10, realpath as realpath4, stat as stat5 } from "node:fs/promises";
 import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 var EntryTypes = {
@@ -342797,7 +344015,7 @@ var ReaddirpStream = class extends Readable3 {
   async _exploreDir(path101, depth) {
     let files;
     try {
-      files = await readdir9(path101, this._rdOptions);
+      files = await readdir10(path101, this._rdOptions);
     } catch (error40) {
       this._onError(error40);
     }
@@ -343662,11 +344880,11 @@ function createPattern(matcher) {
       if (matcher.path === string4)
         return true;
       if (matcher.recursive) {
-        const relative12 = sp2.relative(matcher.path, string4);
-        if (!relative12) {
+        const relative11 = sp2.relative(matcher.path, string4);
+        if (!relative11) {
           return false;
         }
-        return !relative12.startsWith("..") && !sp2.isAbsolute(relative12);
+        return !relative11.startsWith("..") && !sp2.isAbsolute(relative11);
       }
       return false;
     };
@@ -343768,7 +344986,7 @@ var DirEntry = class {
       return;
     const dir = this.path;
     try {
-      await readdir10(dir);
+      await readdir11(dir);
     } catch (err2) {
       if (this._removeWatcher) {
         this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
@@ -345224,8 +346442,8 @@ function normalizePathCandidate(candidate, projectRoot) {
   }
   let normalized2 = trimmed2.replace(/\\/g, "/");
   if (path88.isAbsolute(trimmed2)) {
-    const relative12 = path88.relative(projectRoot, trimmed2);
-    normalized2 = relative12 && !relative12.startsWith("..") && !path88.isAbsolute(relative12) ? relative12.replace(/\\/g, "/") : path88.basename(trimmed2);
+    const relative11 = path88.relative(projectRoot, trimmed2);
+    normalized2 = relative11 && !relative11.startsWith("..") && !path88.isAbsolute(relative11) ? relative11.replace(/\\/g, "/") : path88.basename(trimmed2);
   }
   if (normalized2.length > 120) {
     normalized2 = normalized2.split("/").slice(-3).join("/");
@@ -345940,6 +347158,7 @@ function contentPartsToGeminiParts(content) {
         result2.push({ text: part.text });
         break;
       default:
+        debugLogger.warn(`Unhandled ContentPart type: ${JSON.stringify(part)} fallback to serialization`);
         result2.push({ text: JSON.stringify(part) });
         break;
     }
@@ -345959,50 +347178,6 @@ function buildToolResponseData(response) {
   return Object.keys(parts2).length > 0 ? parts2 : void 0;
 }
 
-// packages/core/dist/src/agent/tool-display-utils.js
-function populateToolDisplay({ name: name3, invocation, resultDisplay, displayName }) {
-  const display = {
-    name: displayName || name3,
-    description: invocation?.getDescription?.()
-  };
-  if (resultDisplay) {
-    display.result = toolResultDisplayToDisplayContent(resultDisplay);
-  }
-  return display;
-}
-function toolResultDisplayToDisplayContent(resultDisplay) {
-  if (typeof resultDisplay === "string") {
-    return { type: "text", text: resultDisplay };
-  }
-  if (typeof resultDisplay === "object" && resultDisplay !== null && "fileDiff" in resultDisplay && "newContent" in resultDisplay) {
-    return {
-      type: "diff",
-      path: resultDisplay.filePath || resultDisplay.fileName,
-      beforeText: resultDisplay.originalContent ?? "",
-      afterText: resultDisplay.newContent
-    };
-  }
-  return {
-    type: "text",
-    text: JSON.stringify(resultDisplay)
-  };
-}
-function renderDisplayDiff(diff) {
-  return createPatch(diff.path || "file", diff.beforeText, diff.afterText, "Original", "Modified", { context: 3 });
-}
-function displayContentToString(display) {
-  if (!display) {
-    return void 0;
-  }
-  if (display.type === "text") {
-    return display.text;
-  }
-  if (display.type === "diff") {
-    return renderDisplayDiff(display);
-  }
-  return JSON.stringify(display);
-}
-
 // packages/core/dist/src/agent/event-translator.js
 function createTranslationState(streamId) {
   return {
@@ -346130,15 +347305,16 @@ function translateEvent(event, state) {
       out2.push(makeEvent("tool_request", state, {
         requestId: event.value.callId,
         name: event.value.name,
-        args: event.value.args
+        args: event.value.args,
+        display: event.value.display
       }));
       break;
     case GeminiEventType.ToolCallResponse: {
       ensureStreamStart(state, out2);
       const data = buildToolResponseData(event.value);
-      const display = event.value.resultDisplay ? {
+      const display = event.value.display ?? (event.value.resultDisplay ? {
         result: toolResultDisplayToDisplayContent(event.value.resultDisplay)
-      } : void 0;
+      } : void 0);
       out2.push(makeEvent("tool_response", state, {
         requestId: event.value.callId,
         name: state.pendingToolNames.get(event.value.callId) ?? "unknown",
@@ -346160,7 +347336,6 @@ function translateEvent(event, state) {
       ((x) => {
         throw new Error(`Unhandled event type: ${JSON.stringify(x)}`);
       })(event);
-      break;
   }
   return out2;
 }
@@ -346360,6 +347535,7 @@ var LegacyAgentProtocol = class {
       } else {
         this._emitErrorAndAgentEnd(err2);
       }
+    } finally {
       this._clearActiveStream();
     }
   }
@@ -346433,7 +347609,8 @@ var LegacyAgentProtocol = class {
           name: request.name,
           invocation: "invocation" in tc ? tc.invocation : void 0,
           resultDisplay: response.resultDisplay,
-          displayName: "tool" in tc ? tc.tool?.displayName : void 0
+          displayName: "tool" in tc ? tc.tool?.displayName : void 0,
+          display: response.display
         });
         const data = buildToolResponseData(response);
         this._emit([
@@ -346527,6 +347704,7 @@ var LegacyAgentProtocol = class {
     const meta = {};
     if (err2 instanceof Error) {
       meta["errorName"] = err2.constructor.name;
+      meta["stack"] = err2.stack;
       if ("exitCode" in err2 && typeof err2.exitCode === "number") {
         meta["exitCode"] = err2.exitCode;
       }
@@ -349214,7 +350392,7 @@ var ENCODING_ALIASES = {
 var serializeEncoding = (encoding) => typeof encoding === "string" ? `"${encoding}"` : String(encoding);
 
 // node_modules/execa/lib/arguments/cwd.js
-import { statSync as statSync3 } from "node:fs";
+import { statSync as statSync4 } from "node:fs";
 import path94 from "node:path";
 import process20 from "node:process";
 var normalizeCwd = (cwd = getDefaultCwd()) => {
@@ -349236,7 +350414,7 @@ var fixCwdError = (originalMessage, cwd) => {
   }
   let cwdStat;
   try {
-    cwdStat = statSync3(cwd);
+    cwdStat = statSync4(cwd);
   } catch (error40) {
     return `The "cwd" option is invalid: ${cwd}.
 ${error40.message}
@@ -353892,8 +355070,8 @@ function isGeminiWorktree(dirPath, projectRoot) {
     const realDirPath = realpathSync4(dirPath);
     const realProjectRoot = realpathSync4(projectRoot);
     const worktreesBaseDir = path96.join(realProjectRoot, ".gemini", "worktrees");
-    const relative12 = path96.relative(worktreesBaseDir, realDirPath);
-    return !relative12.startsWith("..") && !path96.isAbsolute(relative12);
+    const relative11 = path96.relative(worktreesBaseDir, realDirPath);
+    return !relative11.startsWith("..") && !path96.isAbsolute(relative11);
   } catch {
     return false;
   }
@@ -355224,6 +356402,7 @@ export {
   CacheService,
   createCache,
   ProjectIdRequiredError,
+  InvalidNumericProjectIdError,
   ValidationCancelledError,
   IneligibleTierError,
   resetUserDataCacheForTesting,
@@ -355311,6 +356490,11 @@ export {
   GeminiChat,
   isSchemaDepthError,
   isInvalidArgumentError,
+  stripToolCallIdPrefixes,
+  populateToolDisplay,
+  toolResultDisplayToDisplayContent,
+  renderDisplayDiff,
+  displayContentToString,
   GeminiEventType,
   CompressionStatus,
   Turn,
@@ -355348,6 +356532,7 @@ export {
   SubagentActivityErrorType,
   SUBAGENT_REJECTED_ERROR_PREFIX,
   SUBAGENT_CANCELLED_ERROR_MESSAGE,
+  SubagentState,
   isSubagentProgress,
   isToolActivityError,
   getAgentCardLoadOptions,
@@ -355377,6 +356562,16 @@ export {
   getPolicyDenialError,
   checkPolicy,
   updatePolicy,
+  NodeType,
+  isAgentThought,
+  isAgentYield,
+  isToolExecution,
+  isMaskedTool,
+  isUserPrompt,
+  isSystemEvent,
+  isSnapshot,
+  isRollingSummary,
+  SnapshotGenerator,
   generalistProfile,
   stressTestProfile,
   GeminiClient,
@@ -355522,6 +356717,7 @@ export {
   performRestore,
   performInit,
   isProjectSkillPatchTarget,
+  getAllowedMemoryPatchRoots,
   validatePatches,
   startMemoryService,
   showMemory,
@@ -355531,7 +356727,6 @@ export {
   listInboxSkills,
   moveInboxSkill,
   dismissInboxSkill,
-  getAllowedMemoryPatchRoots,
   listInboxMemoryPatches,
   applyInboxMemoryPatch,
   dismissInboxMemoryPatch,
@@ -355567,10 +356762,6 @@ export {
   geminiPartsToContentParts,
   contentPartsToGeminiParts,
   buildToolResponseData,
-  populateToolDisplay,
-  toolResultDisplayToDisplayContent,
-  renderDisplayDiff,
-  displayContentToString,
   createTranslationState,
   translateEvent,
   mapFinishReason,