@google/gemini-cli-a2a-server 0.63.0-preview.0 → 0.64.0-nightly.20260930.g38700b4b3

package/dist/a2a-server.mjs

@@ -28597,10 +28597,10 @@ var require_object_inspect = __commonJS({
       }
       if (!isDate(obj) && !isRegExp(obj)) {
         var ys2 = arrObjKeys(obj, inspect2);
-        var isPlainObject3 = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
+        var isPlainObject4 = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
         var protoTag = obj instanceof Object ? "" : "null prototype";
-        var stringTag = !isPlainObject3 && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
-        var constructorTag = isPlainObject3 || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "";
+        var stringTag = !isPlainObject4 && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
+        var constructorTag = isPlainObject4 || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "";
         var tag = constructorTag + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : "");
         if (ys2.length === 0) {
           return tag + "{}";
@@ -36169,7 +36169,7 @@ var require_extend = __commonJS({
       }
       return toStr.call(arr) === "[object Array]";
     };
-    var isPlainObject3 = function isPlainObject4(obj) {
+    var isPlainObject4 = function isPlainObject5(obj) {
       if (!obj || toStr.call(obj) !== "[object Object]") {
         return false;
       }
@@ -36226,12 +36226,12 @@ var require_extend = __commonJS({
             src = getProperty(target, name3);
             copy = getProperty(options, name3);
             if (target !== copy) {
-              if (deep && copy && (isPlainObject3(copy) || (copyIsArray = isArray(copy)))) {
+              if (deep && copy && (isPlainObject4(copy) || (copyIsArray = isArray(copy)))) {
                 if (copyIsArray) {
                   copyIsArray = false;
                   clone4 = src && isArray(src) ? src : [];
                 } else {
-                  clone4 = src && isPlainObject3(src) ? src : {};
+                  clone4 = src && isPlainObject4(src) ? src : {};
                 }
                 setProperty2(target, { name: name3, newValue: extend4(deep, clone4, copy) });
               } else if (typeof copy !== "undefined") {
@@ -142115,7 +142115,7 @@ var require_lodash_merge = __commonJS({
     var hasOwnProperty2 = objectProto.hasOwnProperty;
     var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
     var nativeObjectToString = objectProto.toString;
-    function isPlainObject3(value) {
+    function isPlainObject4(value) {
       if (!isObjectLike(value) || baseGetTag(value) !== objectTag) {
         return false;
       }
@@ -142126,7 +142126,7 @@ var require_lodash_merge = __commonJS({
       const Ctor = hasOwnProperty2.call(proto, "constructor") && proto.constructor;
       return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) === objectCtorString;
     }
-    exports2.isPlainObject = isPlainObject3;
+    exports2.isPlainObject = isPlainObject4;
     function isObjectLike(value) {
       return value != null && typeof value == "object";
     }
@@ -221340,8 +221340,8 @@ var GIT_COMMIT_INFO, CLI_VERSION;
 var init_git_commit = __esm({
   "packages/core/dist/src/generated/git-commit.js"() {
     "use strict";
-    GIT_COMMIT_INFO = "d75234cae";
-    CLI_VERSION = "0.63.0-preview.0";
+    GIT_COMMIT_INFO = "38700b4b3";
+    CLI_VERSION = "0.64.0-nightly.20260930.g38700b4b3";
   }
 });
 
@@ -337077,7 +337077,7 @@ function getVersion() {
   }
   versionPromise = (async () => {
     const pkgJson = await getPackageJson(__dirname4);
-    return "0.63.0-preview.0";
+    return "0.64.0-nightly.20260930.g38700b4b3";
   })();
   return versionPromise;
 }
@@ -439700,35 +439700,543 @@ import * as path96 from "node:path";
 import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
 
 // packages/a2a-server/src/config/settings.ts
+init_zod();
 init_dist4();
 var import_strip_json_comments3 = __toESM(require_strip_json_comments(), 1);
 import * as fs84 from "node:fs";
 import * as path95 from "node:path";
 var USER_SETTINGS_DIR = path95.join(homedir(), GEMINI_DIR);
 var USER_SETTINGS_PATH = path95.join(USER_SETTINGS_DIR, "settings.json");
-function loadSettings(workspaceDir, isTrustedOverride) {
-  let userSettings = {};
-  let workspaceSettings = {};
-  const settingsErrors = [];
-  try {
-    if (fs84.existsSync(USER_SETTINGS_PATH)) {
-      const userContent = fs84.readFileSync(USER_SETTINGS_PATH, "utf-8");
-      const parsedUserSettings = JSON.parse(
-        (0, import_strip_json_comments3.default)(userContent)
+var MIGRATION_MAP = {
+  accessibility: "ui.accessibility",
+  allowedTools: "tools.allowed",
+  allowMCPServers: "mcp.allowed",
+  autoAccept: "tools.autoAccept",
+  autoConfigureMaxOldSpaceSize: "advanced.autoConfigureMemory",
+  bugCommand: "advanced.bugCommand",
+  chatCompression: "model.compressionThreshold",
+  checkpointing: "general.checkpointing",
+  coreTools: "tools.core",
+  contextFileName: "context.fileName",
+  customThemes: "ui.customThemes",
+  customWittyPhrases: "ui.customWittyPhrases",
+  debugKeystrokeLogging: "general.debugKeystrokeLogging",
+  disableAutoUpdate: "general.disableAutoUpdate",
+  disableUpdateNag: "general.disableUpdateNag",
+  dnsResolutionOrder: "advanced.dnsResolutionOrder",
+  enableHooks: "tools.enableHooks",
+  enablePromptCompletion: "general.enablePromptCompletion",
+  enforcedAuthType: "security.auth.enforcedType",
+  excludeTools: "tools.exclude",
+  excludeMCPServers: "mcp.excluded",
+  excludedProjectEnvVars: "advanced.excludedEnvVars",
+  experimentalSkills: "experimental.skills",
+  extensionManagement: "experimental.extensionManagement",
+  extensions: "extensions",
+  fileFiltering: "context.fileFiltering",
+  folderTrustFeature: "security.folderTrust.featureEnabled",
+  folderTrust: "security.folderTrust.enabled",
+  hasSeenIdeIntegrationNudge: "ide.hasSeenNudge",
+  hideWindowTitle: "ui.hideWindowTitle",
+  showStatusInTitle: "ui.showStatusInTitle",
+  hideTips: "ui.hideTips",
+  hideBanner: "ui.hideBanner",
+  hideFooter: "ui.hideFooter",
+  hideCWD: "ui.footer.hideCWD",
+  hideSandboxStatus: "ui.footer.hideSandboxStatus",
+  hideModelInfo: "ui.footer.hideModelInfo",
+  hideContextSummary: "ui.hideContextSummary",
+  showMemoryUsage: "ui.showMemoryUsage",
+  showLineNumbers: "ui.showLineNumbers",
+  showCitations: "ui.showCitations",
+  ideMode: "ide.enabled",
+  includeDirectories: "context.includeDirectories",
+  loadMemoryFromIncludeDirectories: "context.loadFromIncludeDirectories",
+  logLevel: "logging.level",
+  maxSessionTurns: "model.maxSessionTurns",
+  mcpServers: "mcpServers",
+  mcpServerCommand: "mcp.serverCommand",
+  memoryImportFormat: "context.importFormat",
+  memoryDiscoveryMaxDirs: "context.discoveryMaxDirs",
+  model: "model.name",
+  preferredEditor: "general.preferredEditor",
+  retryFetchErrors: "general.retryFetchErrors",
+  sandbox: "tools.sandbox",
+  selectedAuthType: "security.auth.selectedType",
+  enableInteractiveShell: "tools.shell.enableInteractiveShell",
+  shellPager: "tools.shell.pager",
+  shellShowColor: "tools.shell.showColor",
+  shellInactivityTimeout: "tools.shell.inactivityTimeout",
+  skipNextSpeakerCheck: "model.skipNextSpeakerCheck",
+  summarizeToolOutput: "model.summarizeToolOutput",
+  telemetry: "telemetry",
+  theme: "ui.theme",
+  toolDiscoveryCommand: "tools.discoveryCommand",
+  toolCallCommand: "tools.callCommand",
+  usageStatisticsEnabled: "privacy.usageStatisticsEnabled",
+  useExternalAuth: "security.auth.useExternal",
+  useRipgrep: "tools.useRipgrep",
+  vimMode: "general.vimMode"
+};
+var KNOWN_V2_CONTAINERS = new Set(
+  Object.values(MIGRATION_MAP).map((p2) => p2.split(".")[0])
+);
+var LEGACY_V1_ONLY_KEYS = /* @__PURE__ */ new Set([
+  ...Object.keys(MIGRATION_MAP).filter(
+    (k2) => k2 !== MIGRATION_MAP[k2] && !KNOWN_V2_CONTAINERS.has(k2)
+  ),
+  "telemetryDisabled"
+]);
+var MERGE_STRATEGIES = {
+  mcpServers: "shallow_merge" /* SHALLOW_MERGE */,
+  policyPaths: "union" /* UNION */,
+  adminPolicyPaths: "union" /* UNION */
+};
+function getMergeStrategyForPath(pathSegments) {
+  return MERGE_STRATEGIES[pathSegments.join(".")];
+}
+function isPlainObject3(item) {
+  if (typeof item !== "object" || item === null || Array.isArray(item)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(item);
+  return proto === null || proto === Object.prototype;
+}
+function isUnsafeKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+function mergeRecursively(target, source, getStrategy, currentPath = []) {
+  for (const key of Object.keys(source)) {
+    if (isUnsafeKey(key)) {
+      continue;
+    }
+    const srcValue = source[key];
+    if (srcValue === void 0) {
+      continue;
+    }
+    const newPath = [...currentPath, key];
+    const objValue = target[key];
+    const mergeStrategy = getStrategy(newPath);
+    if (mergeStrategy === "shallow_merge" /* SHALLOW_MERGE */ && objValue && srcValue) {
+      const obj1 = isPlainObject3(objValue) ? objValue : {};
+      const obj2 = isPlainObject3(srcValue) ? srcValue : {};
+      const mergedShallow = {};
+      for (const [k2, v2] of Object.entries(obj1)) {
+        if (!isUnsafeKey(k2)) mergedShallow[k2] = v2;
+      }
+      for (const [k2, v2] of Object.entries(obj2)) {
+        if (!isUnsafeKey(k2)) mergedShallow[k2] = v2;
+      }
+      target[key] = mergedShallow;
+      continue;
+    }
+    if (Array.isArray(objValue)) {
+      const srcArray = Array.isArray(srcValue) ? srcValue : [srcValue];
+      if (mergeStrategy === "concat" /* CONCAT */) {
+        target[key] = objValue.concat(srcArray);
+        continue;
+      }
+      if (mergeStrategy === "union" /* UNION */) {
+        target[key] = [...new Set(objValue.concat(srcArray))];
+        continue;
+      }
+    }
+    if (isPlainObject3(objValue) && isPlainObject3(srcValue)) {
+      mergeRecursively(objValue, srcValue, getStrategy, newPath);
+    } else if (isPlainObject3(srcValue)) {
+      const nestedTarget = {};
+      target[key] = nestedTarget;
+      mergeRecursively(nestedTarget, srcValue, getStrategy, newPath);
+    } else {
+      target[key] = srcValue;
+    }
+  }
+  return target;
+}
+function customDeepMerge(first2, ...rest) {
+  const getStrategy = typeof first2 === "function" ? first2 : getMergeStrategyForPath;
+  const sources = typeof first2 === "function" ? rest : first2 ? [first2, ...rest] : rest;
+  const result2 = {};
+  for (const source of sources) {
+    if (source && isPlainObject3(source)) {
+      mergeRecursively(result2, source, getStrategy);
+    }
+  }
+  return result2;
+}
+function setNestedProperty(obj, dotPath, value) {
+  const keys = dotPath.split(".");
+  const lastKey = keys.pop();
+  if (!lastKey || isUnsafeKey(lastKey)) return;
+  let current = obj;
+  for (const key of keys) {
+    if (isUnsafeKey(key)) return;
+    const existing = current[key];
+    if (existing === void 0) {
+      const nextObj = {};
+      current[key] = nextObj;
+      current = nextObj;
+    } else if (isPlainObject3(existing)) {
+      current = existing;
+    } else {
+      return;
+    }
+  }
+  current[lastKey] = value;
+}
+function getNestedProperty(obj, dotPath) {
+  const keys = dotPath.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (isUnsafeKey(key) || !isPlainObject3(current) || !(key in current)) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+function migrateInvertedBoolean(container, oldKey, newKey) {
+  const oldVal = container[oldKey];
+  const newVal = container[newKey];
+  if (typeof oldVal === "boolean") {
+    if (typeof newVal !== "boolean") {
+      container[newKey] = !oldVal;
+    }
+    delete container[oldKey];
+  }
+}
+function migrateDeprecatedSettings(rawSettings) {
+  if (!isPlainObject3(rawSettings)) {
+    return {};
+  }
+  const v2Settings = {};
+  const remainingKeys = new Set(
+    Object.keys(rawSettings).filter((k2) => !isUnsafeKey(k2))
+  );
+  const rawTelemetry = rawSettings["telemetry"];
+  if (typeof rawTelemetry === "boolean") {
+    setNestedProperty(v2Settings, "telemetry.enabled", rawTelemetry);
+    remainingKeys.delete("telemetry");
+  }
+  const telemetryDisabledVal = rawSettings["telemetryDisabled"];
+  if (typeof telemetryDisabledVal === "boolean") {
+    if (getNestedProperty(v2Settings, "telemetry.enabled") === void 0) {
+      setNestedProperty(v2Settings, "telemetry.enabled", !telemetryDisabledVal);
+    }
+    remainingKeys.delete("telemetryDisabled");
+  }
+  for (const [oldKey, newPath] of Object.entries(MIGRATION_MAP)) {
+    if (oldKey === newPath) {
+      continue;
+    }
+    if (remainingKeys.has(oldKey)) {
+      let val = rawSettings[oldKey];
+      if (KNOWN_V2_CONTAINERS.has(oldKey) && isPlainObject3(val)) {
+        continue;
+      }
+      if (oldKey === "checkpointing" && typeof val === "boolean") {
+        val = { enabled: val };
+      }
+      if (oldKey === "chatCompression" && isPlainObject3(val)) {
+        const threshold = val["contextPercentageThreshold"];
+        if (typeof threshold === "number") {
+          val = threshold;
+        }
+      }
+      setNestedProperty(v2Settings, newPath, val);
+      remainingKeys.delete(oldKey);
+    }
+  }
+  for (const key of remainingKeys) {
+    const newVal = rawSettings[key];
+    if (newVal === void 0) continue;
+    const existingVal = v2Settings[key];
+    if (isPlainObject3(existingVal) && isPlainObject3(newVal)) {
+      v2Settings[key] = customDeepMerge(
+        (subPath) => getMergeStrategyForPath([key, ...subPath]),
+        existingVal,
+        newVal
+      );
+    } else {
+      v2Settings[key] = newVal;
+    }
+  }
+  const generalObj = v2Settings["general"];
+  if (isPlainObject3(generalObj)) {
+    const checkpointingVal = generalObj["checkpointing"];
+    if (typeof checkpointingVal === "boolean") {
+      generalObj["checkpointing"] = { enabled: checkpointingVal };
+    }
+    migrateInvertedBoolean(generalObj, "disableAutoUpdate", "enableAutoUpdate");
+    migrateInvertedBoolean(
+      generalObj,
+      "disableUpdateNag",
+      "enableAutoUpdateNotification"
+    );
+  }
+  const uiObj = v2Settings["ui"];
+  if (isPlainObject3(uiObj)) {
+    const accessibilityObj = uiObj["accessibility"];
+    if (isPlainObject3(accessibilityObj)) {
+      migrateInvertedBoolean(
+        accessibilityObj,
+        "disableLoadingPhrases",
+        "enableLoadingPhrases"
+      );
+      const enableLP = accessibilityObj["enableLoadingPhrases"];
+      if (typeof enableLP === "boolean" && uiObj["loadingPhrases"] === void 0) {
+        if (!enableLP) {
+          uiObj["loadingPhrases"] = "off";
+        }
+      }
+    }
+  }
+  const contextObj = v2Settings["context"];
+  if (isPlainObject3(contextObj)) {
+    const fileFilteringObj = contextObj["fileFiltering"];
+    if (isPlainObject3(fileFilteringObj)) {
+      migrateInvertedBoolean(
+        fileFilteringObj,
+        "disableFuzzySearch",
+        "enableFuzzySearch"
       );
-      userSettings = resolveEnvVarsInObject(parsedUserSettings);
+    }
+  }
+  const toolsObj = v2Settings["tools"];
+  if (isPlainObject3(toolsObj)) {
+    const approvalModeVal = toolsObj["approvalMode"];
+    if (approvalModeVal !== void 0) {
+      const targetGeneral = isPlainObject3(v2Settings["general"]) ? v2Settings["general"] : {};
+      if (targetGeneral["defaultApprovalMode"] === void 0) {
+        targetGeneral["defaultApprovalMode"] = approvalModeVal;
+      }
+      v2Settings["general"] = targetGeneral;
+      delete toolsObj["approvalMode"];
+    }
+  }
+  return v2Settings;
+}
+var booleanPreprocess = external_exports.preprocess((val) => {
+  if (typeof val === "string") {
+    const lower3 = val.toLowerCase();
+    if (lower3 === "true") return true;
+    if (lower3 === "false") return false;
+  }
+  return val;
+}, external_exports.boolean());
+var numberPreprocess = external_exports.preprocess((val) => {
+  if (typeof val === "string" && val.trim() !== "") {
+    const num = Number(val);
+    if (!Number.isNaN(num)) return num;
+  }
+  return val;
+}, external_exports.number());
+var settingsZodSchema = external_exports.object({
+  mcpServers: external_exports.record(external_exports.string(), external_exports.record(external_exports.string(), external_exports.unknown())).optional(),
+  mcp: external_exports.object({
+    serverCommand: external_exports.string().optional(),
+    allowed: external_exports.array(external_exports.string()).optional(),
+    excluded: external_exports.array(external_exports.string()).optional()
+  }).passthrough().optional(),
+  tools: external_exports.object({
+    allowed: external_exports.array(external_exports.string()).optional(),
+    exclude: external_exports.array(external_exports.string()).optional(),
+    core: external_exports.array(external_exports.string()).optional(),
+    autoAccept: booleanPreprocess.optional(),
+    sandbox: external_exports.union([
+      booleanPreprocess,
+      external_exports.string(),
+      external_exports.record(external_exports.string(), external_exports.unknown())
+    ]).optional(),
+    enableHooks: booleanPreprocess.optional(),
+    discoveryCommand: external_exports.string().optional(),
+    callCommand: external_exports.string().optional(),
+    useRipgrep: booleanPreprocess.optional(),
+    shell: external_exports.object({
+      enableInteractiveShell: booleanPreprocess.optional(),
+      pager: external_exports.string().optional(),
+      showColor: booleanPreprocess.optional(),
+      inactivityTimeout: numberPreprocess.optional()
+    }).passthrough().optional()
+  }).passthrough().optional(),
+  telemetry: external_exports.union([
+    booleanPreprocess,
+    external_exports.object({
+      enabled: booleanPreprocess.optional(),
+      target: external_exports.string().optional(),
+      otlpEndpoint: external_exports.string().optional(),
+      otlpProtocol: external_exports.string().optional(),
+      logPrompts: booleanPreprocess.optional(),
+      outfile: external_exports.string().optional(),
+      useCollector: booleanPreprocess.optional()
+    }).passthrough()
+  ]).optional(),
+  logging: external_exports.object({
+    level: external_exports.string().optional()
+  }).passthrough().optional(),
+  ui: external_exports.object({
+    theme: external_exports.string().optional(),
+    showMemoryUsage: booleanPreprocess.optional(),
+    showLineNumbers: booleanPreprocess.optional(),
+    showCitations: booleanPreprocess.optional(),
+    showStatusInTitle: booleanPreprocess.optional(),
+    hideWindowTitle: booleanPreprocess.optional(),
+    hideTips: booleanPreprocess.optional(),
+    hideBanner: booleanPreprocess.optional(),
+    hideFooter: booleanPreprocess.optional(),
+    hideContextSummary: booleanPreprocess.optional(),
+    loadingPhrases: external_exports.string().optional(),
+    customThemes: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+    customWittyPhrases: external_exports.array(external_exports.string()).optional(),
+    footer: external_exports.object({
+      hideCWD: booleanPreprocess.optional(),
+      hideSandboxStatus: booleanPreprocess.optional(),
+      hideModelInfo: booleanPreprocess.optional()
+    }).passthrough().optional(),
+    accessibility: external_exports.object({
+      enableLoadingPhrases: booleanPreprocess.optional(),
+      screenReader: booleanPreprocess.optional()
+    }).passthrough().optional()
+  }).passthrough().optional(),
+  general: external_exports.object({
+    previewFeatures: booleanPreprocess.optional(),
+    vimMode: booleanPreprocess.optional(),
+    preferredEditor: external_exports.string().optional(),
+    checkpointing: external_exports.object({
+      enabled: booleanPreprocess.optional()
+    }).passthrough().optional(),
+    enableAutoUpdate: booleanPreprocess.optional(),
+    enableAutoUpdateNotification: booleanPreprocess.optional(),
+    defaultApprovalMode: external_exports.string().optional(),
+    debugKeystrokeLogging: booleanPreprocess.optional(),
+    enablePromptCompletion: booleanPreprocess.optional(),
+    retryFetchErrors: booleanPreprocess.optional(),
+    plan: external_exports.object({
+      enabled: booleanPreprocess.optional()
+    }).passthrough().optional()
+  }).passthrough().optional(),
+  context: external_exports.object({
+    fileName: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).optional(),
+    includeDirectories: external_exports.array(external_exports.string()).optional(),
+    loadFromIncludeDirectories: booleanPreprocess.optional(),
+    importFormat: external_exports.string().optional(),
+    discoveryMaxDirs: numberPreprocess.optional(),
+    fileFiltering: external_exports.object({
+      respectGitIgnore: booleanPreprocess.optional(),
+      respectGeminiIgnore: booleanPreprocess.optional(),
+      enableRecursiveFileSearch: booleanPreprocess.optional(),
+      enableFuzzySearch: booleanPreprocess.optional(),
+      customIgnoreFilePaths: external_exports.array(external_exports.string()).optional()
+    }).passthrough().optional()
+  }).passthrough().optional(),
+  security: external_exports.object({
+    folderTrust: external_exports.object({
+      enabled: booleanPreprocess.optional(),
+      featureEnabled: booleanPreprocess.optional()
+    }).passthrough().optional(),
+    auth: external_exports.object({
+      selectedType: external_exports.string().optional(),
+      enforcedType: external_exports.string().optional(),
+      useExternal: booleanPreprocess.optional()
+    }).passthrough().optional()
+  }).passthrough().optional(),
+  model: external_exports.object({
+    name: external_exports.string().optional(),
+    maxSessionTurns: numberPreprocess.optional(),
+    compressionThreshold: numberPreprocess.optional(),
+    skipNextSpeakerCheck: booleanPreprocess.optional(),
+    summarizeToolOutput: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+  }).passthrough().optional(),
+  ide: external_exports.object({
+    enabled: booleanPreprocess.optional(),
+    hasSeenNudge: booleanPreprocess.optional()
+  }).passthrough().optional(),
+  privacy: external_exports.object({
+    usageStatisticsEnabled: booleanPreprocess.optional()
+  }).passthrough().optional(),
+  advanced: external_exports.object({
+    autoConfigureMemory: booleanPreprocess.optional(),
+    bugCommand: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+    dnsResolutionOrder: external_exports.string().optional(),
+    excludedEnvVars: external_exports.array(external_exports.string()).optional(),
+    ignoreLocalEnv: booleanPreprocess.optional()
+  }).passthrough().optional(),
+  experimental: external_exports.object({
+    enableAgents: booleanPreprocess.optional(),
+    skills: booleanPreprocess.optional(),
+    extensionManagement: booleanPreprocess.optional(),
+    worktrees: booleanPreprocess.optional()
+  }).passthrough().optional(),
+  extensions: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+  agents: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+  policyPaths: external_exports.array(external_exports.string()).optional(),
+  adminPolicyPaths: external_exports.array(external_exports.string()).optional()
+}).passthrough().superRefine((obj, ctx) => {
+  for (const key of Object.keys(obj)) {
+    if (LEGACY_V1_ONLY_KEYS.has(key)) {
+      ctx.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: [key],
+        message: `Unmigrated V1 setting '${key}' is not valid at the root of V2 settings.`
+      });
+    }
+  }
+});
+function validateSettings(data) {
+  const result2 = settingsZodSchema.safeParse(data);
+  if (result2.success) {
+    return {
+      success: true,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      data: result2.data
+    };
+  }
+  return {
+    success: false,
+    error: result2.error
+  };
+}
+function loadAndMigrateFile(filePath, settingsErrors) {
+  try {
+    if (fs84.existsSync(filePath)) {
+      const content = fs84.readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse((0, import_strip_json_comments3.default)(content));
+      if (!isPlainObject3(parsed)) {
+        settingsErrors.push({
+          message: "Settings file is not a valid JSON object.",
+          path: filePath
+        });
+        return {};
+      }
+      const resolved = resolveEnvVarsInObject(parsed);
+      const migrated = migrateDeprecatedSettings(resolved);
+      const validation = validateSettings(migrated);
+      if (!validation.success && validation.error) {
+        settingsErrors.push({
+          message: validation.error.message,
+          path: filePath
+        });
+        return migrated;
+      }
+      return validation.data ?? migrated;
     }
   } catch (error2) {
     settingsErrors.push({
       message: getErrorMessage(error2),
-      path: USER_SETTINGS_PATH
+      path: filePath
     });
   }
+  return {};
+}
+function loadSettings(workspaceDir, isTrustedOverride) {
+  const settingsErrors = [];
+  const userSettings = loadAndMigrateFile(USER_SETTINGS_PATH, settingsErrors);
   let isTrusted = isTrustedOverride;
   if (isTrusted === void 0) {
+    const isFolderTrustEnabled = userSettings.security?.folderTrust?.enabled ?? true;
     const { isTrusted: trustResult } = checkPathTrust({
       path: workspaceDir,
-      isFolderTrustEnabled: userSettings.folderTrust ?? true,
+      isFolderTrustEnabled,
       isHeadless: isHeadlessMode()
     });
     isTrusted = trustResult ?? false;
@@ -439738,22 +440246,7 @@ function loadSettings(workspaceDir, isTrustedOverride) {
     GEMINI_DIR,
     "settings.json"
   );
-  if (isTrusted) {
-    try {
-      if (fs84.existsSync(workspaceSettingsPath)) {
-        const projectContent = fs84.readFileSync(workspaceSettingsPath, "utf-8");
-        const parsedWorkspaceSettings = JSON.parse(
-          (0, import_strip_json_comments3.default)(projectContent)
-        );
-        workspaceSettings = resolveEnvVarsInObject(parsedWorkspaceSettings);
-      }
-    } catch (error2) {
-      settingsErrors.push({
-        message: getErrorMessage(error2),
-        path: workspaceSettingsPath
-      });
-    }
-  }
+  const workspaceSettings = isTrusted ? loadAndMigrateFile(workspaceSettingsPath, settingsErrors) : {};
   if (settingsErrors.length > 0) {
     debugLogger.error("Errors loading settings:");
     for (const error2 of settingsErrors) {
@@ -439761,29 +440254,41 @@ function loadSettings(workspaceDir, isTrustedOverride) {
       debugLogger.error(`  Message: ${error2.message}`);
     }
   }
-  const mergedSettings = {
-    ...userSettings,
-    ...workspaceSettings
-  };
+  const mergedSettings = customDeepMerge(
+    getMergeStrategyForPath,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    userSettings,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    workspaceSettings
+  );
   mergedSettings.policyPaths = userSettings.policyPaths;
   mergedSettings.adminPolicyPaths = userSettings.adminPolicyPaths;
   return mergedSettings;
 }
 function resolveEnvVarsInString(value) {
-  const envVarRegex = /\$(?:(\w+)|{([^}]+)})/g;
+  const envVarRegex = /\$(?:(\w+)|{([^}]+?)(?::-([^}]*))?})/g;
   return value.replace(
     envVarRegex,
-    (match2, varName1, varName2) => {
+    (match2, varName1, varName2, defaultValue) => {
       const varName = varName1 || varName2;
+      if (!varName) {
+        return match2;
+      }
       const envValue = process?.env?.[varName];
       if (typeof envValue === "string") {
         return envValue;
       }
+      if (defaultValue !== void 0) {
+        return defaultValue;
+      }
       return match2;
     }
   );
 }
 function resolveEnvVarsInObject(obj) {
+  return resolveEnvVarsInObjectInternal(obj, /* @__PURE__ */ new WeakSet());
+}
+function resolveEnvVarsInObjectInternal(obj, visited) {
   if (obj === null || obj === void 0 || typeof obj === "boolean" || typeof obj === "number") {
     return obj;
   }
@@ -439791,15 +440296,34 @@ function resolveEnvVarsInObject(obj) {
     return resolveEnvVarsInString(obj);
   }
   if (Array.isArray(obj)) {
-    return obj.map((item) => resolveEnvVarsInObject(item));
+    if (visited.has(obj)) {
+      return [...obj];
+    }
+    visited.add(obj);
+    const mapped = obj.map(
+      (item) => resolveEnvVarsInObjectInternal(item, visited)
+    );
+    visited.delete(obj);
+    return mapped;
   }
   if (typeof obj === "object") {
-    const newObj = { ...obj };
-    for (const key in newObj) {
-      if (Object.prototype.hasOwnProperty.call(newObj, key)) {
-        newObj[key] = resolveEnvVarsInObject(newObj[key]);
+    if (!isPlainObject3(obj)) {
+      return obj;
+    }
+    const objRef = obj;
+    if (visited.has(objRef)) {
+      return { ...obj };
+    }
+    visited.add(objRef);
+    const newObj = {};
+    const sourceRecord = obj;
+    for (const key of Object.keys(sourceRecord)) {
+      if (isUnsafeKey(key)) {
+        continue;
       }
+      newObj[key] = resolveEnvVarsInObjectInternal(sourceRecord[key], visited);
     }
+    visited.delete(objRef);
     return newObj;
   }
   return obj;
@@ -440017,8 +440541,8 @@ async function loadConfig(settings, extensionLoader, taskId, trusted = false, wo
   const envVars = { ...process.env };
   Object.assign(envVars, workspaceEnv);
   const getEnvLocal = (key) => envVars[key];
-  const folderTrust = settings.folderTrust === true || getEnvLocal("GEMINI_FOLDER_TRUST") === "true";
-  let checkpointing = getEnvLocal("CHECKPOINTING") ? getEnvLocal("CHECKPOINTING") === "true" : settings.checkpointing?.enabled;
+  const folderTrust = settings.security?.folderTrust?.enabled === true || getEnvLocal("GEMINI_FOLDER_TRUST") === "true";
+  let checkpointing = getEnvLocal("CHECKPOINTING") ? getEnvLocal("CHECKPOINTING") === "true" : settings.general?.checkpointing?.enabled;
   if (checkpointing) {
     if (!await GitService.verifyGitAvailability()) {
       logger.warn(
@@ -440063,6 +440587,9 @@ async function loadConfig(settings, extensionLoader, taskId, trusted = false, wo
       telemetry: void 0
     };
   }
+  if (settings.logging?.level) {
+    logger.level = settings.logging.level;
+  }
   const safeMcpServers = settings.mcpServers;
   const policySettings = {
     mcpServers: safeMcpServers,
@@ -440080,6 +440607,7 @@ async function loadConfig(settings, extensionLoader, taskId, trusted = false, wo
     void 0,
     true
   );
+  const resolvedFileFiltering = settings.context?.fileFiltering;
   const configParams = {
     sessionId: taskId,
     clientName: "a2a-server",
@@ -440096,7 +440624,7 @@ async function loadConfig(settings, extensionLoader, taskId, trusted = false, wo
     coreTools: settings.tools?.core || void 0,
     excludeTools: settings.tools?.exclude || void 0,
     allowedTools: settings.tools?.allowed || void 0,
-    showMemoryUsage: settings.showMemoryUsage || false,
+    showMemoryUsage: settings.ui?.showMemoryUsage || false,
     approvalMode,
     policyEngineConfig,
     mcpServers: safeMcpServers,
@@ -440110,11 +440638,11 @@ async function loadConfig(settings, extensionLoader, taskId, trusted = false, wo
     },
     // Git-aware file filtering settings
     fileFiltering: {
-      respectGitIgnore: settings.fileFiltering?.respectGitIgnore,
-      respectGeminiIgnore: settings.fileFiltering?.respectGeminiIgnore,
-      enableRecursiveFileSearch: settings.fileFiltering?.enableRecursiveFileSearch,
+      respectGitIgnore: resolvedFileFiltering?.respectGitIgnore,
+      respectGeminiIgnore: resolvedFileFiltering?.respectGeminiIgnore,
+      enableRecursiveFileSearch: resolvedFileFiltering?.enableRecursiveFileSearch,
       customIgnoreFilePaths: [
-        ...settings.fileFiltering?.customIgnoreFilePaths || [],
+        ...resolvedFileFiltering?.customIgnoreFilePaths || [],
         ...getEnvLocal("CUSTOM_IGNORE_FILE_PATHS") ? getEnvLocal("CUSTOM_IGNORE_FILE_PATHS").split(path96.delimiter) : []
       ]
     },
@@ -440157,14 +440685,14 @@ function setIsTrusted(agentSettings, workspaceRoot) {
     return agentSettings.isTrusted;
   }
   const cliTrustEnv = getEnv2("GEMINI_CLI_TRUST_WORKSPACE");
-  if (cliTrustEnv !== void 0) {
+  if (cliTrustEnv !== void 0 && cliTrustEnv !== "") {
     return cliTrustEnv === "true";
   }
   if (workspaceRoot) {
     const initialSettings = loadSettings(workspaceRoot, false);
     const { isTrusted } = checkPathTrust({
       path: workspaceRoot,
-      isFolderTrustEnabled: initialSettings.folderTrust ?? true,
+      isFolderTrustEnabled: initialSettings.security?.folderTrust?.enabled ?? true,
       isHeadless: isHeadlessMode()
     });
     return isTrusted ?? false;
@@ -442919,7 +443447,7 @@ async function createApp() {
     const initialSettings = loadSettings(workspaceRoot, false);
     const { isTrusted } = checkPathTrust({
       path: workspaceRoot,
-      isFolderTrustEnabled: initialSettings.folderTrust ?? true,
+      isFolderTrustEnabled: initialSettings.security?.folderTrust?.enabled ?? true,
       isHeadless: isHeadlessMode()
     });
     process.chdir(workspaceRoot);