@google/gemini-cli 0.36.0-preview.8 → 0.37.0-preview.0

package/bundle/{chunk-S2IQOR7T.js → chunk-7UZ4Y32N.js}

@@ -40771,6 +40771,7 @@ var MessageBusType;
   MessageBusType2["TOOL_CALLS_UPDATE"] = "tool-calls-update";
   MessageBusType2["ASK_USER_REQUEST"] = "ask-user-request";
   MessageBusType2["ASK_USER_RESPONSE"] = "ask-user-response";
+  MessageBusType2["SUBAGENT_ACTIVITY"] = "subagent-activity";
 })(MessageBusType || (MessageBusType = {}));
 var QuestionType;
 (function(QuestionType2) {
@@ -40986,6 +40987,11 @@ var BaseToolInvocation = class {
       }
     });
   }
+  toJSON() {
+    return {
+      params: this.params
+    };
+  }
 };
 var DeclarativeTool = class {
   name;
@@ -41025,6 +41031,15 @@ var DeclarativeTool = class {
     }
     return cloned;
   }
+  toJSON() {
+    return {
+      name: this.name,
+      displayName: this.displayName,
+      description: this.description,
+      kind: this.kind,
+      parameterSchema: this.parameterSchema
+    };
+  }
   get isReadOnly() {
     return READ_ONLY_KINDS.includes(this.kind);
   }
@@ -41235,6 +41250,7 @@ function isStructuredToolResult(obj) {
 var hasSummary = (res) => isStructuredToolResult(res);
 var isGrepResult = (res) => isStructuredToolResult(res) && "matches" in res && Array.isArray(res.matches);
 var isListResult = (res) => isStructuredToolResult(res) && "files" in res && Array.isArray(res.files);
+var isReadManyFilesResult = (res) => isListResult(res) && "include" in res;
 var isFileDiff = (res) => typeof res === "object" && res !== null && "fileDiff" in res && "fileName" in res && "filePath" in res;
 var ToolConfirmationOutcome;
 (function(ToolConfirmationOutcome2) {
@@ -41971,6 +41987,10 @@ var Storage = class _Storage {
     const historyDir = path6.join(_Storage.getGlobalGeminiDir(), "history");
     return path6.join(historyDir, identifier);
   }
+  getProjectMemoryDir() {
+    const identifier = this.getProjectIdentifier();
+    return path6.join(_Storage.getGlobalGeminiDir(), "memory", identifier);
+  }
   getWorkspaceSettingsPath() {
     return path6.join(this.getGeminiDir(), "settings.json");
   }
@@ -43168,6 +43188,7 @@ var READ_MANY_PARAM_RECURSIVE = "recursive";
 var READ_MANY_PARAM_USE_DEFAULT_EXCLUDES = "useDefaultExcludes";
 var MEMORY_TOOL_NAME = "save_memory";
 var MEMORY_PARAM_FACT = "fact";
+var MEMORY_PARAM_SCOPE = "scope";
 var GET_INTERNAL_DOCS_TOOL_NAME = "get_internal_docs";
 var DOCS_PARAM_PATH = "path";
 var ACTIVATE_SKILL_TOOL_NAME = "activate_skill";
@@ -43187,6 +43208,11 @@ var EXIT_PLAN_PARAM_PLAN_FILENAME = "plan_filename";
 var ENTER_PLAN_MODE_TOOL_NAME = "enter_plan_mode";
 var PLAN_MODE_PARAM_REASON = "reason";
 var PARAM_ADDITIONAL_PERMISSIONS = "additional_permissions";
+var UPDATE_TOPIC_TOOL_NAME = "update_topic";
+var UPDATE_TOPIC_DISPLAY_NAME = "Update Topic Context";
+var TOPIC_PARAM_TITLE = "title";
+var TOPIC_PARAM_SUMMARY = "summary";
+var TOPIC_PARAM_STRATEGIC_INTENT = "strategic_intent";
 
 // packages/core/dist/src/tools/definitions/dynamic-declaration-helpers.js
 import * as os4 from "node:os";
@@ -48605,7 +48631,7 @@ function getShellDeclaration(enableInteractiveShell, enableEfficiency, enableToo
 function getExitPlanModeDeclaration() {
   return {
     name: EXIT_PLAN_MODE_TOOL_NAME,
-    description: "Finalizes the planning phase and transitions to implementation by presenting the plan for user approval. This tool MUST be used to exit Plan Mode before any source code edits can be performed. Call this whenever a plan is ready or the user requests implementation.",
+    description: "Finalizes the planning phase and transitions to implementation by presenting the plan for formal user approval. You MUST reach an informal agreement with the user in the chat regarding the proposed strategy BEFORE calling this tool. This tool MUST be used to exit Plan Mode before any source code edits can be performed.",
     parametersJsonSchema: {
       type: "object",
       required: [EXIT_PLAN_PARAM_PLAN_FILENAME],
@@ -48636,6 +48662,30 @@ function getActivateSkillDeclaration(skillNames) {
     parametersJsonSchema: zodToJsonSchema(schema)
   };
 }
+function getUpdateTopicDeclaration() {
+  return {
+    name: UPDATE_TOPIC_TOOL_NAME,
+    description: "Manages your narrative flow. Include `title` and `summary` only when starting a new Chapter (logical phase) or shifting strategic intent.",
+    parametersJsonSchema: {
+      type: "object",
+      properties: {
+        [TOPIC_PARAM_TITLE]: {
+          type: "string",
+          description: "The title of the new topic or chapter."
+        },
+        [TOPIC_PARAM_SUMMARY]: {
+          type: "string",
+          description: "(OPTIONAL) A detailed summary (5-10 sentences) covering both the work completed in the previous topic and the strategic intent of the new topic. This is required when transitioning between topics to maintain continuity."
+        },
+        [TOPIC_PARAM_STRATEGIC_INTENT]: {
+          type: "string",
+          description: "A mandatory one-sentence statement of your immediate intent."
+        }
+      },
+      required: [TOPIC_PARAM_STRATEGIC_INTENT]
+    }
+  };
+}
 
 // packages/core/dist/src/tools/definitions/model-family-sets/default-legacy.js
 var DEFAULT_LEGACY_SET = {
@@ -49005,19 +49055,24 @@ Use this tool when the user's query implies needing the content of several files
   save_memory: {
     name: MEMORY_TOOL_NAME,
     description: `
-Saves concise global user context (preferences, facts) for use across ALL workspaces.
+Saves concise user context (preferences, facts) for use across future sessions.
 
-### CRITICAL: GLOBAL CONTEXT ONLY
-NEVER save workspace-specific context, local paths, or commands (e.g. "The entry point is src/index.js", "The test command is npm test"). These are local to the current workspace and must NOT be saved globally. EXCLUSIVELY for context relevant across ALL workspaces.
+Supports two scopes:
+- **global** (default): Cross-project preferences loaded in every workspace. Use for "Remember X" or clear personal facts.
+- **project**: Facts specific to the current workspace, private to the user (not committed to the repo). Use for local dev setup notes, project-specific workflows, or personal reminders about this codebase.
 
-- Use for "Remember X" or clear personal facts.
-- Do NOT use for session context.`,
+Do NOT use for session-specific context or temporary data.`,
     parametersJsonSchema: {
       type: "object",
       properties: {
         [MEMORY_PARAM_FACT]: {
           type: "string",
           description: "The specific fact or piece of information to remember. Should be a clear, self-contained statement."
+        },
+        [MEMORY_PARAM_SCOPE]: {
+          type: "string",
+          enum: ["global", "project"],
+          description: "Where to save the memory. 'global' (default) saves to a file loaded in every workspace. 'project' saves to a project-specific file private to the user, not committed to the repo."
         }
       },
       required: [MEMORY_PARAM_FACT],
@@ -49571,13 +49626,18 @@ Use this tool when the user's query implies needing the content of several files
   },
   save_memory: {
     name: MEMORY_TOOL_NAME,
-    description: `Persists global preferences or facts across ALL future sessions. Use this for recurring instructions like coding styles or tool aliases. Unlike '${WRITE_FILE_TOOL_NAME}', which is for project-specific files, this appends to a global memory file loaded in every workspace. If you are unsure whether a fact should be remembered globally, ask the user first. CRITICAL: Do not use for session-specific context or temporary data.`,
+    description: `Persists preferences or facts across ALL future sessions. Supports two scopes: 'global' (default) for cross-project preferences loaded in every workspace, and 'project' for facts specific to the current workspace that are private to the user (not committed to the repo). Use 'project' scope for things like local dev setup notes, project-specific workflows, or personal reminders about this codebase. CRITICAL: Do not use for session-specific context or temporary data.`,
     parametersJsonSchema: {
       type: "object",
       properties: {
         [MEMORY_PARAM_FACT]: {
           type: "string",
-          description: "A concise, global fact or preference (e.g., 'I prefer using tabs'). Do not include local paths or project-specific names."
+          description: "A concise fact or preference to remember. Should be a clear, self-contained statement."
+        },
+        [MEMORY_PARAM_SCOPE]: {
+          type: "string",
+          enum: ["global", "project"],
+          description: "Where to save the memory. 'global' (default) saves to a file loaded in every workspace. 'project' saves to a project-specific file private to the user, not committed to the repo."
         }
       },
       required: [MEMORY_PARAM_FACT],
@@ -49780,7 +49840,8 @@ The agent did not use the todo list because this task could be completed by a ti
     }
   },
   exit_plan_mode: () => getExitPlanModeDeclaration(),
-  activate_skill: (skillNames) => getActivateSkillDeclaration(skillNames)
+  activate_skill: (skillNames) => getActivateSkillDeclaration(skillNames),
+  update_topic: getUpdateTopicDeclaration()
 };
 
 // packages/core/dist/src/tools/definitions/coreTools.js
@@ -50359,7 +50420,8 @@ var ALL_BUILTIN_TOOL_NAMES = [
   TRACKER_VISUALIZE_TOOL_NAME,
   GET_INTERNAL_DOCS_TOOL_NAME,
   ENTER_PLAN_MODE_TOOL_NAME,
-  EXIT_PLAN_MODE_TOOL_NAME
+  EXIT_PLAN_MODE_TOOL_NAME,
+  UPDATE_TOPIC_TOOL_NAME
 ];
 var PLAN_MODE_TOOLS = [
   GLOB_TOOL_NAME,
@@ -50370,6 +50432,7 @@ var PLAN_MODE_TOOLS = [
   ASK_USER_TOOL_NAME,
   ACTIVATE_SKILL_TOOL_NAME,
   GET_INTERNAL_DOCS_TOOL_NAME,
+  UPDATE_TOPIC_TOOL_NAME,
   "codebase_investigator",
   "cli_help"
 ];
@@ -50455,6 +50518,9 @@ function getAllGeminiMdFilenames() {
 function getGlobalMemoryFilePath() {
   return path7.join(Storage.getGlobalGeminiDir(), getCurrentGeminiMdFilename());
 }
+function getProjectMemoryFilePath(storage) {
+  return path7.join(storage.getProjectMemoryDir(), getCurrentGeminiMdFilename());
+}
 function ensureNewlineSeparation(currentContent) {
   if (currentContent.length === 0)
     return "";
@@ -50464,9 +50530,9 @@ function ensureNewlineSeparation(currentContent) {
     return "\n";
   return "\n\n";
 }
-async function readMemoryFileContent() {
+async function readMemoryFileContent(filePath) {
   try {
-    return await fs8.readFile(getGlobalMemoryFilePath(), "utf-8");
+    return await fs8.readFile(filePath, "utf-8");
   } catch (err) {
     const error = err;
     if (!(error instanceof Error) || error.code !== "ENOENT")
@@ -50503,20 +50569,28 @@ ${afterSectionMarker}`.trimEnd() + "\n";
 var MemoryToolInvocation = class _MemoryToolInvocation extends BaseToolInvocation {
   static allowlist = /* @__PURE__ */ new Set();
   proposedNewContent;
-  constructor(params, messageBus, toolName, displayName) {
+  storage;
+  constructor(params, messageBus, toolName, displayName, storage) {
     super(params, messageBus, toolName, displayName);
+    this.storage = storage;
+  }
+  getMemoryFilePath() {
+    if (this.params.scope === "project" && this.storage) {
+      return getProjectMemoryFilePath(this.storage);
+    }
+    return getGlobalMemoryFilePath();
   }
   getDescription() {
-    const memoryFilePath = getGlobalMemoryFilePath();
+    const memoryFilePath = this.getMemoryFilePath();
     return `in ${tildeifyPath(memoryFilePath)}`;
   }
   async getConfirmationDetails(_abortSignal) {
-    const memoryFilePath = getGlobalMemoryFilePath();
+    const memoryFilePath = this.getMemoryFilePath();
     const allowlistKey = memoryFilePath;
     if (_MemoryToolInvocation.allowlist.has(allowlistKey)) {
       return false;
     }
-    const currentContent = await readMemoryFileContent();
+    const currentContent = await readMemoryFileContent(memoryFilePath);
     const { fact, modified_by_user, modified_content } = this.params;
     const contentForDiff = modified_by_user && modified_content !== void 0 ? modified_content : computeNewContent(currentContent, fact);
     this.proposedNewContent = contentForDiff;
@@ -50540,6 +50614,7 @@ var MemoryToolInvocation = class _MemoryToolInvocation extends BaseToolInvocatio
   }
   async execute(_signal) {
     const { fact, modified_by_user, modified_content } = this.params;
+    const memoryFilePath = this.getMemoryFilePath();
     try {
       let contentToWrite;
       let successMessage;
@@ -50549,16 +50624,16 @@ var MemoryToolInvocation = class _MemoryToolInvocation extends BaseToolInvocatio
         successMessage = `Okay, I've updated the memory file with your modifications.`;
       } else {
         if (this.proposedNewContent === void 0) {
-          const currentContent = await readMemoryFileContent();
+          const currentContent = await readMemoryFileContent(memoryFilePath);
           this.proposedNewContent = computeNewContent(currentContent, fact);
         }
         contentToWrite = this.proposedNewContent;
         successMessage = `Okay, I've remembered that: "${sanitizedFact}"`;
       }
-      await fs8.mkdir(path7.dirname(getGlobalMemoryFilePath()), {
+      await fs8.mkdir(path7.dirname(memoryFilePath), {
         recursive: true
       });
-      await fs8.writeFile(getGlobalMemoryFilePath(), contentToWrite, "utf-8");
+      await fs8.writeFile(memoryFilePath, contentToWrite, "utf-8");
       return {
         llmContent: JSON.stringify({
           success: true,
@@ -50584,27 +50659,39 @@ var MemoryToolInvocation = class _MemoryToolInvocation extends BaseToolInvocatio
 };
 var MemoryTool = class _MemoryTool extends BaseDeclarativeTool {
   static Name = MEMORY_TOOL_NAME;
-  constructor(messageBus) {
+  storage;
+  constructor(messageBus, storage) {
     super(_MemoryTool.Name, "SaveMemory", MEMORY_DEFINITION.base.description, Kind.Think, MEMORY_DEFINITION.base.parametersJsonSchema, messageBus, true, false);
+    this.storage = storage;
+  }
+  resolveMemoryFilePath(params) {
+    if (params.scope === "project" && this.storage) {
+      return getProjectMemoryFilePath(this.storage);
+    }
+    return getGlobalMemoryFilePath();
   }
   validateToolParamValues(params) {
     if (params.fact.trim() === "") {
       return 'Parameter "fact" must be a non-empty string.';
     }
+    if (params.scope === "project" && !this.storage) {
+      return "Project-level memory is not available: storage is not initialized.";
+    }
     return null;
   }
   createInvocation(params, messageBus, toolName, displayName) {
-    return new MemoryToolInvocation(params, messageBus, toolName ?? this.name, displayName ?? this.displayName);
+    return new MemoryToolInvocation(params, messageBus, toolName ?? this.name, displayName ?? this.displayName, this.storage);
   }
   getSchema(modelId) {
     return resolveToolDeclaration(MEMORY_DEFINITION, modelId);
   }
   getModifyContext(_abortSignal) {
     return {
-      getFilePath: (_params) => getGlobalMemoryFilePath(),
-      getCurrentContent: async (_params) => readMemoryFileContent(),
+      getFilePath: (params) => this.resolveMemoryFilePath(params),
+      getCurrentContent: async (params) => readMemoryFileContent(this.resolveMemoryFilePath(params)),
       getProposedContent: async (params) => {
-        const currentContent = await readMemoryFileContent();
+        const filePath = this.resolveMemoryFilePath(params);
+        const currentContent = await readMemoryFileContent(filePath);
         const { fact, modified_by_user, modified_content } = params;
         return modified_by_user && modified_content !== void 0 ? modified_content : computeNewContent(currentContent, fact);
       },
@@ -50628,14 +50715,22 @@ var logger2 = {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   error: (...args) => debugLogger.error("[ERROR] [ImportProcessor]", ...args)
 };
-async function findProjectRoot(startDir) {
+async function findProjectRoot(startDir, boundaryMarkers = [".git"]) {
+  if (boundaryMarkers.length === 0) {
+    return path8.resolve(startDir);
+  }
   let currentDir = path8.resolve(startDir);
   while (true) {
-    const gitPath = path8.join(currentDir, ".git");
-    try {
-      await fs9.access(gitPath);
-      return currentDir;
-    } catch {
+    for (const marker of boundaryMarkers) {
+      if (path8.isAbsolute(marker) || marker.includes("..")) {
+        continue;
+      }
+      const markerPath = path8.join(currentDir, marker);
+      try {
+        await fs9.access(markerPath);
+        return currentDir;
+      } catch {
+      }
     }
     const parentDir = path8.dirname(currentDir);
     if (parentDir === currentDir) {
@@ -50697,9 +50792,9 @@ async function processImports(content, basePath, debugMode = false, importState
   processedFiles: /* @__PURE__ */ new Set(),
   maxDepth: 5,
   currentDepth: 0
-}, projectRoot, importFormat = "tree") {
+}, projectRoot, importFormat = "tree", boundaryMarkers = [".git"]) {
   if (!projectRoot) {
-    projectRoot = await findProjectRoot(basePath);
+    projectRoot = await findProjectRoot(basePath, boundaryMarkers);
   }
   if (importState.currentDepth >= importState.maxDepth) {
     if (debugMode) {
@@ -50786,7 +50881,7 @@ ${f.content.trim()}
         currentFile: fullPath
       };
       newImportState.processedFiles.add(fullPath);
-      const imported = await processImports(fileContent, path8.dirname(fullPath), debugMode, newImportState, projectRoot, importFormat);
+      const imported = await processImports(fileContent, path8.dirname(fullPath), debugMode, newImportState, projectRoot, importFormat, boundaryMarkers);
       result += `<!-- Imported from: ${importPath} -->
 ${imported.content}
 <!-- End of import from: ${importPath} -->`;
@@ -51189,48 +51284,57 @@ function getErrorMessage(error) {
 function getErrorType(error) {
   if (!(error instanceof Error))
     return "unknown";
-  return error.name === "Error" ? error.constructor?.name ?? "Error" : error.name;
+  const name = error.name && error.name !== "Error" ? error.name : error.constructor?.name ?? "Error";
+  return name.replace(/^_+/, "");
 }
 var FatalError = class extends Error {
   exitCode;
   constructor(message, exitCode) {
     super(message);
     this.exitCode = exitCode;
+    this.name = "FatalError";
   }
 };
 var FatalAuthenticationError = class extends FatalError {
   constructor(message) {
     super(message, 41);
+    this.name = "FatalAuthenticationError";
   }
 };
 var FatalInputError = class extends FatalError {
   constructor(message) {
     super(message, 42);
+    this.name = "FatalInputError";
   }
 };
 var FatalSandboxError = class extends FatalError {
   constructor(message) {
     super(message, 44);
+    this.name = "FatalSandboxError";
   }
 };
 var FatalConfigError = class extends FatalError {
   constructor(message) {
     super(message, 52);
+    this.name = "FatalConfigError";
   }
 };
 var FatalTurnLimitedError = class extends FatalError {
   constructor(message) {
     super(message, 53);
+    this.name = "FatalTurnLimitedError";
   }
 };
 var FatalToolExecutionError = class extends FatalError {
   constructor(message) {
     super(message, 54);
+    this.name = "FatalToolExecutionError";
   }
 };
 var FatalCancellationError = class extends FatalError {
   constructor(message) {
     super(message, 130);
+    this.name = "FatalCancellationError";
   }
 };
 var CanceledError = class extends Error {
@@ -51240,6 +51344,10 @@ var CanceledError = class extends Error {
   }
 };
 var ForbiddenError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ForbiddenError";
+  }
 };
 var AccountSuspendedError = class extends ForbiddenError {
   appealUrl;
@@ -51252,8 +51360,16 @@ var AccountSuspendedError = class extends ForbiddenError {
   }
 };
 var UnauthorizedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnauthorizedError";
+  }
 };
 var BadRequestError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BadRequestError";
+  }
 };
 var ChangeAuthRequestedError = class extends Error {
   constructor() {
@@ -51330,7 +51446,7 @@ function isAuthenticationError(error) {
       return true;
     }
   }
-  if (error instanceof Error && error.constructor.name === "UnauthorizedError") {
+  if (error instanceof Error && error.name === "UnauthorizedError") {
     return true;
   }
   if (error instanceof UnauthorizedError) {
@@ -51416,23 +51532,31 @@ async function deduplicatePathsByFileIdentity(filePaths) {
     identityMap: pathToIdentityMap
   };
 }
-async function findProjectRoot2(startDir) {
+async function findProjectRoot2(startDir, boundaryMarkers = [".git"]) {
+  if (boundaryMarkers.length === 0) {
+    return null;
+  }
   let currentDir = normalizePath(startDir);
   while (true) {
-    const gitPath = path9.join(currentDir, ".git");
-    try {
-      await fs10.access(gitPath);
-      return currentDir;
-    } catch (error) {
-      const isENOENT = typeof error === "object" && error !== null && "code" in error && // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      error.code === "ENOENT";
-      const isTestEnv = process.env["NODE_ENV"] === "test" || process.env["VITEST"];
-      if (!isENOENT && !isTestEnv) {
-        if (typeof error === "object" && error !== null && "code" in error) {
-          const fsError = error;
-          logger3.warn(`Error checking for .git at ${gitPath}: ${fsError.message}`);
-        } else {
-          logger3.warn(`Non-standard error checking for .git at ${gitPath}: ${String(error)}`);
+    for (const marker of boundaryMarkers) {
+      if (path9.isAbsolute(marker) || marker.includes("..")) {
+        continue;
+      }
+      const markerPath = path9.join(currentDir, marker);
+      try {
+        await fs10.access(markerPath);
+        return currentDir;
+      } catch (error) {
+        const isENOENT = typeof error === "object" && error !== null && "code" in error && // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        error.code === "ENOENT";
+        const isTestEnv = process.env["NODE_ENV"] === "test" || process.env["VITEST"];
+        if (!isENOENT && !isTestEnv) {
+          if (typeof error === "object" && error !== null && "code" in error) {
+            const fsError = error;
+            logger3.warn(`Error checking for ${marker} at ${markerPath}: ${fsError.message}`);
+          } else {
+            logger3.warn(`Non-standard error checking for ${marker} at ${markerPath}: ${String(error)}`);
+          }
         }
       }
     }
@@ -51443,7 +51567,7 @@ async function findProjectRoot2(startDir) {
     currentDir = parentDir;
   }
 }
-async function getGeminiMdFilePathsInternal(currentWorkingDirectory, includeDirectoriesToReadGemini, userHomePath, fileService, folderTrust, fileFilteringOptions, maxDirs) {
+async function getGeminiMdFilePathsInternal(currentWorkingDirectory, includeDirectoriesToReadGemini, userHomePath, fileService, folderTrust, fileFilteringOptions, maxDirs, boundaryMarkers = [".git"]) {
   const dirs = /* @__PURE__ */ new Set([
     ...includeDirectoriesToReadGemini,
     currentWorkingDirectory
@@ -51454,7 +51578,7 @@ async function getGeminiMdFilePathsInternal(currentWorkingDirectory, includeDire
   const projectPaths = /* @__PURE__ */ new Set();
   for (let i = 0; i < dirsArray.length; i += CONCURRENT_LIMIT) {
     const batch = dirsArray.slice(i, i + CONCURRENT_LIMIT);
-    const batchPromises = batch.map((dir) => getGeminiMdFilePathsInternalForEachDir(dir, userHomePath, fileService, folderTrust, fileFilteringOptions, maxDirs));
+    const batchPromises = batch.map((dir) => getGeminiMdFilePathsInternalForEachDir(dir, userHomePath, fileService, folderTrust, fileFilteringOptions, maxDirs, boundaryMarkers));
     const batchResults = await Promise.allSettled(batchPromises);
     for (const result of batchResults) {
       if (result.status === "fulfilled") {
@@ -51472,7 +51596,7 @@ async function getGeminiMdFilePathsInternal(currentWorkingDirectory, includeDire
     project: Array.from(projectPaths)
   };
 }
-async function getGeminiMdFilePathsInternalForEachDir(dir, userHomePath, fileService, folderTrust, fileFilteringOptions, maxDirs) {
+async function getGeminiMdFilePathsInternalForEachDir(dir, userHomePath, fileService, folderTrust, fileFilteringOptions, maxDirs, boundaryMarkers = [".git"]) {
   const globalPaths = /* @__PURE__ */ new Set();
   const projectPaths = /* @__PURE__ */ new Set();
   const geminiMdFilenames = getAllGeminiMdFilenames();
@@ -51489,7 +51613,7 @@ async function getGeminiMdFilePathsInternalForEachDir(dir, userHomePath, fileSer
     if (dir && folderTrust) {
       const resolvedCwd = normalizePath(dir);
       debugLogger.debug("[DEBUG] [MemoryDiscovery] Searching for", geminiMdFilename, "starting from CWD:", resolvedCwd);
-      const projectRoot = await findProjectRoot2(resolvedCwd);
+      const projectRoot = await findProjectRoot2(resolvedCwd, boundaryMarkers);
       debugLogger.debug("[DEBUG] [MemoryDiscovery] Determined project root:", projectRoot ?? "None");
       const upwardPaths = [];
       let currentDir = resolvedCwd;
@@ -51533,7 +51657,7 @@ async function getGeminiMdFilePathsInternalForEachDir(dir, userHomePath, fileSer
     project: Array.from(projectPaths)
   };
 }
-async function readGeminiMdFiles(filePaths, importFormat = "tree") {
+async function readGeminiMdFiles(filePaths, importFormat = "tree", boundaryMarkers = [".git"]) {
   const CONCURRENT_LIMIT = 20;
   const results = [];
   for (let i = 0; i < filePaths.length; i += CONCURRENT_LIMIT) {
@@ -51541,7 +51665,7 @@ async function readGeminiMdFiles(filePaths, importFormat = "tree") {
     const batchPromises = batch.map(async (filePath) => {
       try {
         const content = await fs10.readFile(filePath, "utf-8");
-        const processedResult = await processImports(content, path9.dirname(filePath), false, void 0, void 0, importFormat);
+        const processedResult = await processImports(content, path9.dirname(filePath), false, void 0, void 0, importFormat, boundaryMarkers);
         debugLogger.debug("[DEBUG] [MemoryDiscovery] Successfully read and processed imports:", filePath, `(Length: ${processedResult.content.length})`);
         return { filePath, content: processedResult.content };
       } catch (error) {
@@ -51593,15 +51717,29 @@ async function getGlobalMemoryPaths() {
   });
   return (await Promise.all(accessChecks)).filter((p) => p !== null);
 }
+async function getUserProjectMemoryPaths(projectMemoryDir) {
+  const geminiMdFilenames = getAllGeminiMdFilenames();
+  const accessChecks = geminiMdFilenames.map(async (filename) => {
+    const memoryPath = normalizePath(path9.join(projectMemoryDir, filename));
+    try {
+      await fs10.access(memoryPath, fsSync2.constants.R_OK);
+      debugLogger.debug("[DEBUG] [MemoryDiscovery] Found user project memory file:", memoryPath);
+      return memoryPath;
+    } catch {
+      return null;
+    }
+  });
+  return (await Promise.all(accessChecks)).filter((p) => p !== null);
+}
 function getExtensionMemoryPaths(extensionLoader) {
   const extensionPaths = extensionLoader.getExtensions().filter((ext) => ext.isActive).flatMap((ext) => ext.contextFiles).map((p) => normalizePath(p));
   return Array.from(new Set(extensionPaths)).sort();
 }
-async function getEnvironmentMemoryPaths(trustedRoots) {
+async function getEnvironmentMemoryPaths(trustedRoots, boundaryMarkers = [".git"]) {
   const allPaths = /* @__PURE__ */ new Set();
   const traversalPromises = trustedRoots.map(async (root) => {
     const resolvedRoot = normalizePath(root);
-    const gitRoot = await findProjectRoot2(resolvedRoot);
+    const gitRoot = await findProjectRoot2(resolvedRoot, boundaryMarkers);
     const ceiling = gitRoot ? normalizePath(gitRoot) : resolvedRoot;
     debugLogger.debug("[DEBUG] [MemoryDiscovery] Loading environment memory for trusted root:", resolvedRoot, "(Stopping at", gitRoot ? `git root: ${ceiling})` : `trusted root: ${ceiling} \u2014 no git root found)`);
     return findUpwardGeminiFiles(resolvedRoot, ceiling);
@@ -51615,7 +51753,8 @@ function categorizeAndConcatenate(paths, contentsMap) {
   return {
     global: getConcatenated(paths.global),
     extension: getConcatenated(paths.extension),
-    project: getConcatenated(paths.project)
+    project: getConcatenated(paths.project),
+    userProjectMemory: getConcatenated(paths.userProjectMemory ?? [])
   };
 }
 async function findUpwardGeminiFiles(startDir, stopDir) {
@@ -51648,7 +51787,7 @@ async function findUpwardGeminiFiles(startDir, stopDir) {
   }
   return upwardPaths;
 }
-async function loadServerHierarchicalMemory(currentWorkingDirectory, includeDirectoriesToReadGemini, fileService, extensionLoader, folderTrust, importFormat = "tree", fileFilteringOptions, maxDirs = 200) {
+async function loadServerHierarchicalMemory(currentWorkingDirectory, includeDirectoriesToReadGemini, fileService, extensionLoader, folderTrust, importFormat = "tree", fileFilteringOptions, maxDirs = 200, boundaryMarkers = [".git"]) {
   const realCwd = normalizePath(await fs10.realpath(path9.resolve(currentWorkingDirectory)));
   const realHome = normalizePath(await fs10.realpath(path9.resolve(homedir())));
   const isHomeDirectory = realCwd === realHome;
@@ -51656,7 +51795,7 @@ async function loadServerHierarchicalMemory(currentWorkingDirectory, includeDire
   debugLogger.debug("[DEBUG] [MemoryDiscovery] Loading server hierarchical memory for CWD:", currentWorkingDirectory, `(importFormat: ${importFormat})`);
   const userHomePath = homedir();
   const [discoveryResult, extensionPaths] = await Promise.all([
-    getGeminiMdFilePathsInternal(currentWorkingDirectory, includeDirectoriesToReadGemini, userHomePath, fileService, folderTrust, fileFilteringOptions || DEFAULT_MEMORY_FILE_FILTERING_OPTIONS, maxDirs),
+    getGeminiMdFilePathsInternal(currentWorkingDirectory, includeDirectoriesToReadGemini, userHomePath, fileService, folderTrust, fileFilteringOptions || DEFAULT_MEMORY_FILE_FILTERING_OPTIONS, maxDirs, boundaryMarkers),
     Promise.resolve(getExtensionMemoryPaths(extensionLoader))
   ]);
   const allFilePathsStringDeduped = Array.from(/* @__PURE__ */ new Set([
@@ -51681,7 +51820,7 @@ async function loadServerHierarchicalMemory(currentWorkingDirectory, includeDire
       filePaths: []
     };
   }
-  const allContents = await readGeminiMdFiles(allFilePaths, importFormat);
+  const allContents = await readGeminiMdFiles(allFilePaths, importFormat, boundaryMarkers);
   const contentsMap = new Map(allContents.map((c) => [c.filePath, c]));
   const hierarchicalMemory = categorizeAndConcatenate({
     global: discoveryResult.global,
@@ -51695,7 +51834,7 @@ async function loadServerHierarchicalMemory(currentWorkingDirectory, includeDire
   };
 }
 async function refreshServerHierarchicalMemory(config) {
-  const result = await loadServerHierarchicalMemory(config.getWorkingDir(), config.shouldLoadMemoryFromIncludeDirectories() ? config.getWorkspaceContext().getDirectories() : [], config.getFileService(), config.getExtensionLoader(), config.isTrustedFolder(), config.getImportFormat(), config.getFileFilteringOptions(), config.getDiscoveryMaxDirs());
+  const result = await loadServerHierarchicalMemory(config.getWorkingDir(), config.shouldLoadMemoryFromIncludeDirectories() ? config.getWorkspaceContext().getDirectories() : [], config.getFileService(), config.getExtensionLoader(), config.isTrustedFolder(), config.getImportFormat(), config.getFileFilteringOptions(), config.getDiscoveryMaxDirs(), config.getMemoryBoundaryMarkers());
   const mcpInstructions = config.getMcpClientManager()?.getMcpInstructions() || "";
   const finalMemory = {
     ...result.memoryContent,
@@ -51707,7 +51846,7 @@ async function refreshServerHierarchicalMemory(config) {
   coreEvents.emit(CoreEvent.MemoryChanged, { fileCount: result.fileCount });
   return result;
 }
-async function loadJitSubdirectoryMemory(targetPath, trustedRoots, alreadyLoadedPaths, alreadyLoadedIdentities) {
+async function loadJitSubdirectoryMemory(targetPath, trustedRoots, alreadyLoadedPaths, alreadyLoadedIdentities, boundaryMarkers = [".git"]) {
   const resolvedTarget = normalizePath(targetPath);
   let bestRoot = null;
   for (const root of trustedRoots) {
@@ -51723,7 +51862,7 @@ async function loadJitSubdirectoryMemory(targetPath, trustedRoots, alreadyLoaded
     debugLogger.debug("[DEBUG] [MemoryDiscovery] JIT memory skipped:", resolvedTarget, "is not in any trusted root.");
     return { files: [], fileIdentities: [] };
   }
-  const gitRoot = await findProjectRoot2(bestRoot);
+  const gitRoot = await findProjectRoot2(bestRoot, boundaryMarkers);
   const resolvedCeiling = gitRoot ? normalizePath(gitRoot) : bestRoot;
   debugLogger.debug("[DEBUG] [MemoryDiscovery] Loading JIT memory for", resolvedTarget, `(Trusted root: ${bestRoot}, Ceiling: ${resolvedCeiling}${gitRoot ? " [git root]" : " [trusted root, no git]"})`);
   let startDir = resolvedTarget;
@@ -51774,7 +51913,7 @@ async function loadJitSubdirectoryMemory(targetPath, trustedRoots, alreadyLoaded
     return { files: [], fileIdentities: [] };
   }
   debugLogger.debug("[DEBUG] [MemoryDiscovery] Found new JIT memory files:", JSON.stringify(newPaths));
-  const contents = await readGeminiMdFiles(newPaths, "tree");
+  const contents = await readGeminiMdFiles(newPaths, "tree", boundaryMarkers);
   return {
     files: contents.filter((item) => item.content !== null).map((item) => ({
       path: item.filePath,
@@ -51832,6 +51971,7 @@ export {
   hasSummary,
   isGrepResult,
   isListResult,
+  isReadManyFilesResult,
   isFileDiff,
   ToolConfirmationOutcome,
   Kind,
@@ -51958,7 +52098,13 @@ export {
   ENTER_PLAN_MODE_TOOL_NAME,
   PLAN_MODE_PARAM_REASON,
   PARAM_ADDITIONAL_PERMISSIONS,
+  UPDATE_TOPIC_TOOL_NAME,
+  UPDATE_TOPIC_DISPLAY_NAME,
+  TOPIC_PARAM_TITLE,
+  TOPIC_PARAM_SUMMARY,
+  TOPIC_PARAM_STRATEGIC_INTENT,
   zodToJsonSchema,
+  getUpdateTopicDeclaration,
   REFERENCE_CONTENT_START,
   REFERENCE_CONTENT_END,
   DEFAULT_MAX_LINES_TEXT_FILE,
@@ -52023,6 +52169,7 @@ export {
   getCurrentGeminiMdFilename,
   getAllGeminiMdFilenames,
   getGlobalMemoryFilePath,
+  getProjectMemoryFilePath,
   MemoryTool,
   parseGoogleApiError,
   isNodeError,
@@ -52061,6 +52208,7 @@ export {
   readGeminiMdFiles,
   concatenateInstructions,
   getGlobalMemoryPaths,
+  getUserProjectMemoryPaths,
   getExtensionMemoryPaths,
   getEnvironmentMemoryPaths,
   categorizeAndConcatenate,