@google/gemini-cli-a2a-server 0.38.0-preview.0 → 0.39.0-nightly.20260409.615e07834

package/dist/a2a-server.mjs

@@ -86309,7 +86309,7 @@ var require_gaxios2 = __commonJS({
     var retry_js_1 = require_retry4();
     var stream_1 = __require("stream");
     var interceptor_js_1 = require_interceptor2();
-    var randomUUID14 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
+    var randomUUID13 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
     var HTTP_STATUS_NO_CONTENT = 204;
     var Gaxios = class {
       agentCache = /* @__PURE__ */ new Map();
@@ -86582,7 +86582,7 @@ var require_gaxios2 = __commonJS({
          */
         ["Blob", "File", "FormData"].includes(opts.data?.constructor?.name || "");
         if (opts.multipart?.length) {
-          const boundary = await randomUUID14();
+          const boundary = await randomUUID13();
           preparedHeaders.set("content-type", `multipart/related; boundary=${boundary}`);
           opts.body = stream_1.Readable.from(this.getMultipartRequest(opts.multipart, boundary));
         } else if (shouldDirectlyPassData) {
@@ -112259,7 +112259,7 @@ var init_types2 = __esm({
       InProcessCheckerType2["ALLOWED_PATH"] = "allowed-path";
       InProcessCheckerType2["CONSECA"] = "conseca";
     })(InProcessCheckerType || (InProcessCheckerType = {}));
-    PRIORITY_SUBAGENT_TOOL = 1.05;
+    PRIORITY_SUBAGENT_TOOL = 1.03;
     ALWAYS_ALLOW_PRIORITY_FRACTION = 950;
     ALWAYS_ALLOW_PRIORITY_OFFSET = ALWAYS_ALLOW_PRIORITY_FRACTION / 1e3;
     PRIORITY_YOLO_ALLOW_ALL = 998;
@@ -114104,9 +114104,9 @@ var init_storage = __esm({
       projectIdentifier;
       initPromise;
       customPlansDir;
-      constructor(targetDir, sessionId2) {
+      constructor(targetDir, sessionId) {
         this.targetDir = targetDir;
-        this.sessionId = sessionId2;
+        this.sessionId = sessionId;
       }
       setCustomPlansDir(dir) {
         this.customPlansDir = dir;
@@ -119546,13 +119546,13 @@ ${head}
 
 ${tail}`;
 }
-async function saveTruncatedToolOutput(content, toolName, id, projectTempDir, sessionId2) {
+async function saveTruncatedToolOutput(content, toolName, id, projectTempDir, sessionId) {
   const safeToolName = sanitizeFilenamePart(toolName).toLowerCase();
   const safeId = sanitizeFilenamePart(id.toString()).toLowerCase();
   const fileName = safeId.startsWith(safeToolName) ? `${safeId}.txt` : `${safeToolName}_${safeId}.txt`;
   let toolOutputDir = path9.join(projectTempDir, TOOL_OUTPUTS_DIR);
-  if (sessionId2) {
-    const safeSessionId = sanitizeFilenamePart(sessionId2);
+  if (sessionId) {
+    const safeSessionId = sanitizeFilenamePart(sessionId);
     toolOutputDir = path9.join(toolOutputDir, `session-${safeSessionId}`);
   }
   const outputFile = path9.join(toolOutputDir, fileName);
@@ -120054,88 +120054,94 @@ async function* execStreaming(command, args2, options) {
     cwd: options?.cwd?.toString() ?? process.cwd(),
     env: options?.env ?? process.env
   });
-  const { program: finalCommand, args: finalArgs, env: finalEnv } = prepared;
-  const child = spawn(finalCommand, finalArgs, {
-    ...options,
-    env: finalEnv,
-    // ensure we don't open a window on windows if possible/relevant
-    windowsHide: true
-  });
-  const rl = readline.createInterface({
-    input: child.stdout,
-    terminal: false
-  });
-  const errorChunks = [];
-  let stderrTotalBytes = 0;
-  const MAX_STDERR_BYTES = 20 * 1024;
-  child.stderr.on("data", (chunk2) => {
-    if (stderrTotalBytes < MAX_STDERR_BYTES) {
-      errorChunks.push(chunk2);
-      stderrTotalBytes += chunk2.length;
-    }
-  });
-  let error2 = null;
-  child.on("error", (err2) => {
-    error2 = err2;
-  });
-  const onAbort = () => {
-    if (!child.killed)
-      child.kill();
-  };
-  if (options?.signal?.aborted) {
-    onAbort();
-  } else {
-    options?.signal?.addEventListener("abort", onAbort);
-  }
-  let finished8 = false;
   try {
-    for await (const line of rl) {
-      if (options?.signal?.aborted)
-        break;
-      yield line;
-    }
-    finished8 = true;
-  } finally {
-    rl.close();
-    options?.signal?.removeEventListener("abort", onAbort);
-    let killedByGenerator = false;
-    if (!finished8 && child.exitCode === null && !child.killed) {
-      try {
-        child.kill();
-      } catch {
+    const { program: finalCommand, args: finalArgs, env: finalEnv } = prepared;
+    const child = spawn(finalCommand, finalArgs, {
+      ...options,
+      env: finalEnv,
+      // ensure we don't open a window on windows if possible/relevant
+      windowsHide: true
+    });
+    const rl = readline.createInterface({
+      input: child.stdout,
+      terminal: false
+    });
+    const errorChunks = [];
+    let stderrTotalBytes = 0;
+    const MAX_STDERR_BYTES = 20 * 1024;
+    child.stderr.on("data", (chunk2) => {
+      if (stderrTotalBytes < MAX_STDERR_BYTES) {
+        errorChunks.push(chunk2);
+        stderrTotalBytes += chunk2.length;
       }
-      killedByGenerator = true;
+    });
+    let error2 = null;
+    child.on("error", (err2) => {
+      error2 = err2;
+    });
+    const onAbort = () => {
+      if (!child.killed)
+        child.kill();
+    };
+    if (options?.signal?.aborted) {
+      onAbort();
+    } else {
+      options?.signal?.addEventListener("abort", onAbort);
     }
-    await new Promise((resolve24, reject) => {
-      if (error2) {
-        reject(error2);
-        return;
+    let finished8 = false;
+    try {
+      for await (const line of rl) {
+        if (options?.signal?.aborted)
+          break;
+        yield line;
       }
-      function checkExit(code) {
-        if (options?.signal?.aborted || killedByGenerator) {
-          resolve24();
+      finished8 = true;
+    } finally {
+      rl.close();
+      options?.signal?.removeEventListener("abort", onAbort);
+      let killedByGenerator = false;
+      if (!finished8 && child.exitCode === null && !child.killed) {
+        try {
+          child.kill();
+        } catch {
+        }
+        killedByGenerator = true;
+      }
+      await new Promise((resolve24, reject) => {
+        if (error2) {
+          reject(error2);
           return;
         }
-        const allowed = options?.allowedExitCodes ?? [0];
-        if (code !== null && allowed.includes(code)) {
-          resolve24();
-        } else {
-          if (error2)
-            reject(error2);
-          else {
-            const stderr = Buffer.concat(errorChunks).toString("utf8");
-            const truncatedMsg = stderrTotalBytes >= MAX_STDERR_BYTES ? "...[truncated]" : "";
-            reject(new Error(`Process exited with code ${code}: ${stderr}${truncatedMsg}`));
+        function checkExit(code) {
+          if (options?.signal?.aborted || killedByGenerator) {
+            resolve24();
+            return;
+          }
+          const allowed = options?.allowedExitCodes ?? [0];
+          if (code !== null && allowed.includes(code)) {
+            resolve24();
+          } else {
+            if (error2)
+              reject(error2);
+            else {
+              const stderr = Buffer.concat(errorChunks).toString("utf8");
+              const truncatedMsg = stderrTotalBytes >= MAX_STDERR_BYTES ? "...[truncated]" : "";
+              reject(new Error(`Process exited with code ${code}: ${stderr}${truncatedMsg}`));
+            }
           }
         }
-      }
-      if (child.exitCode !== null) {
-        checkExit(child.exitCode);
-      } else {
-        child.on("close", (code) => checkExit(code));
-        child.on("error", (err2) => reject(err2));
-      }
-    });
+        if (child.exitCode !== null) {
+          checkExit(child.exitCode);
+        } else {
+          child.on("close", (code) => checkExit(code));
+          child.on("error", (err2) => {
+            reject(err2);
+          });
+        }
+      });
+    }
+  } finally {
+    prepared.cleanup?.();
   }
 }
 var import_shell_quote, SHELL_TOOL_NAMES, bashLanguage, treeSitterInitialization, treeSitterInitializationError, ShellParserInitializationError, POWERSHELL_COMMAND_ENV, PARSE_TIMEOUT_MICROS, POWERSHELL_PARSER_SCRIPT, REDIRECTION_NAMES, isWindows, spawnAsync;
@@ -120218,31 +120224,35 @@ foreach ($commandAst in $commandAsts) {
         env: options?.env ?? process.env
       });
       const { program: finalCommand, args: finalArgs, env: finalEnv } = prepared;
-      return new Promise((resolve24, reject) => {
-        const child = spawn(finalCommand, finalArgs, {
-          ...options,
-          env: finalEnv
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.on("data", (data) => {
-          stdout += data.toString();
-        });
-        child.stderr.on("data", (data) => {
-          stderr += data.toString();
-        });
-        child.on("close", (code) => {
-          if (code === 0) {
-            resolve24({ stdout, stderr });
-          } else {
-            reject(new Error(`Command failed with exit code ${code}:
+      try {
+        return await new Promise((resolve24, reject) => {
+          const child = spawn(finalCommand, finalArgs, {
+            ...options,
+            env: finalEnv
+          });
+          let stdout = "";
+          let stderr = "";
+          child.stdout.on("data", (data) => {
+            stdout += data.toString();
+          });
+          child.stderr.on("data", (data) => {
+            stderr += data.toString();
+          });
+          child.on("close", (code) => {
+            if (code === 0) {
+              resolve24({ stdout, stderr });
+            } else {
+              reject(new Error(`Command failed with exit code ${code}:
 ${stderr}`));
-          }
-        });
-        child.on("error", (err2) => {
-          reject(err2);
+            }
+          });
+          child.on("error", (err2) => {
+            reject(err2);
+          });
         });
-      });
+      } finally {
+        prepared.cleanup?.();
+      }
     };
   }
 });
@@ -123316,7 +123326,7 @@ var init_LinuxSandboxManager = __esm({
         const { command: finalCommand, args: finalArgs } = handleReadWriteCommands(req, mergedAdditional, this.options.workspace, req.policy?.allowedPaths);
         const sanitizationConfig = getSecureSanitizationConfig(req.policy?.sanitizationConfig);
         const sanitizedEnv = sanitizeEnvironment(req.env, sanitizationConfig);
-        const { allowed: allowedPaths, forbidden: forbiddenPaths } = await resolveSandboxPaths(this.options, req);
+        const resolvedPaths = await resolveSandboxPaths(this.options, req, mergedAdditional);
         for (const file of GOVERNANCE_FILES) {
           const filePath = join5(this.options.workspace, file.path);
           touch(filePath, file.isDirectory);
@@ -123325,8 +123335,8 @@ var init_LinuxSandboxManager = __esm({
           workspace: this.options.workspace,
           workspaceWrite,
           networkAccess,
-          allowedPaths,
-          forbiddenPaths,
+          allowedPaths: resolvedPaths.policyAllowed,
+          forbiddenPaths: resolvedPaths.forbidden,
           additionalPermissions: mergedAdditional,
           includeDirectories: this.options.includeDirectories || [],
           maskFilePath: this.getMaskFilePath(),
@@ -123566,56 +123576,21 @@ function escapeSchemeString(str2) {
 }
 function buildSeatbeltProfile(options) {
   let profile = BASE_SEATBELT_PROFILE + "\n";
-  const workspacePath = tryRealpath(options.workspace);
-  profile += `(allow file-read* (subpath "${escapeSchemeString(options.workspace)}"))
+  const { resolvedPaths, networkAccess, workspaceWrite } = options;
+  profile += `(allow file-read* (subpath "${escapeSchemeString(resolvedPaths.workspace.original)}"))
 `;
-  profile += `(allow file-read* (subpath "${escapeSchemeString(workspacePath)}"))
+  profile += `(allow file-read* (subpath "${escapeSchemeString(resolvedPaths.workspace.resolved)}"))
 `;
-  if (options.workspaceWrite) {
-    profile += `(allow file-write* (subpath "${escapeSchemeString(options.workspace)}"))
+  if (workspaceWrite) {
+    profile += `(allow file-write* (subpath "${escapeSchemeString(resolvedPaths.workspace.original)}"))
 `;
-    profile += `(allow file-write* (subpath "${escapeSchemeString(workspacePath)}"))
+    profile += `(allow file-write* (subpath "${escapeSchemeString(resolvedPaths.workspace.resolved)}"))
 `;
   }
   const tmpPath = tryRealpath(os8.tmpdir());
   profile += `(allow file-read* file-write* (subpath "${escapeSchemeString(tmpPath)}"))
 `;
-  for (let i4 = 0; i4 < GOVERNANCE_FILES.length; i4++) {
-    const governanceFile = path14.join(workspacePath, GOVERNANCE_FILES[i4].path);
-    const realGovernanceFile = tryRealpath(governanceFile);
-    let isDirectory = GOVERNANCE_FILES[i4].isDirectory;
-    try {
-      if (fs18.existsSync(realGovernanceFile)) {
-        isDirectory = fs18.lstatSync(realGovernanceFile).isDirectory();
-      }
-    } catch {
-    }
-    const ruleType = isDirectory ? "subpath" : "literal";
-    profile += `(deny file-write* (${ruleType} "${escapeSchemeString(governanceFile)}"))
-`;
-    if (realGovernanceFile !== governanceFile) {
-      profile += `(deny file-write* (${ruleType} "${escapeSchemeString(realGovernanceFile)}"))
-`;
-    }
-  }
-  const searchPaths = [options.workspace, ...options.allowedPaths];
-  for (const basePath of searchPaths) {
-    const resolvedBase = tryRealpath(basePath);
-    for (const secret of SECRET_FILES) {
-      let regexPattern;
-      const escapedBase = escapeRegex(resolvedBase);
-      if (secret.pattern.endsWith("*")) {
-        const basePattern = secret.pattern.slice(0, -1).replace(/\./g, "\\\\.");
-        regexPattern = `^${escapedBase}/(.*/)?${basePattern}[^/]+$`;
-      } else {
-        const basePattern = secret.pattern.replace(/\./g, "\\\\.");
-        regexPattern = `^${escapedBase}/(.*/)?${basePattern}$`;
-      }
-      profile += `(deny file-read* file-write* (regex #"${regexPattern}"))
-`;
-    }
-  }
-  const { worktreeGitDir, mainGitDir } = resolveGitWorktreePaths(workspacePath);
+  const { worktreeGitDir, mainGitDir } = resolveGitWorktreePaths(resolvedPaths.workspace.resolved);
   if (worktreeGitDir) {
     profile += `(allow file-read* file-write* (subpath "${escapeSchemeString(worktreeGitDir)}"))
 `;
@@ -123647,56 +123622,91 @@ function buildSeatbeltProfile(options) {
       }
     }
   }
-  const allowedPaths = options.allowedPaths;
+  const allowedPaths = [
+    ...resolvedPaths.policyAllowed,
+    ...resolvedPaths.globalIncludes
+  ];
   for (let i4 = 0; i4 < allowedPaths.length; i4++) {
-    const allowedPath = tryRealpath(allowedPaths[i4]);
+    const allowedPath = allowedPaths[i4];
     profile += `(allow file-read* file-write* (subpath "${escapeSchemeString(allowedPath)}"))
 `;
   }
-  if (options.additionalPermissions?.fileSystem) {
-    const { read: read2, write: write2 } = options.additionalPermissions.fileSystem;
-    if (read2) {
-      for (let i4 = 0; i4 < read2.length; i4++) {
-        const resolved = tryRealpath(read2[i4]);
-        let isFile2 = false;
-        try {
-          isFile2 = fs18.statSync(resolved).isFile();
-        } catch {
-        }
-        if (isFile2) {
-          profile += `(allow file-read* (literal "${escapeSchemeString(resolved)}"))
+  for (let i4 = 0; i4 < resolvedPaths.policyRead.length; i4++) {
+    const resolved = resolvedPaths.policyRead[i4];
+    let isFile2 = false;
+    try {
+      isFile2 = fs18.statSync(resolved).isFile();
+    } catch {
+    }
+    if (isFile2) {
+      profile += `(allow file-read* (literal "${escapeSchemeString(resolved)}"))
 `;
-        } else {
-          profile += `(allow file-read* (subpath "${escapeSchemeString(resolved)}"))
+    } else {
+      profile += `(allow file-read* (subpath "${escapeSchemeString(resolved)}"))
 `;
-        }
+    }
+  }
+  for (let i4 = 0; i4 < resolvedPaths.policyWrite.length; i4++) {
+    const resolved = resolvedPaths.policyWrite[i4];
+    let isFile2 = false;
+    try {
+      isFile2 = fs18.statSync(resolved).isFile();
+    } catch {
+    }
+    if (isFile2) {
+      profile += `(allow file-read* file-write* (literal "${escapeSchemeString(resolved)}"))
+`;
+    } else {
+      profile += `(allow file-read* file-write* (subpath "${escapeSchemeString(resolved)}"))
+`;
+    }
+  }
+  for (let i4 = 0; i4 < GOVERNANCE_FILES.length; i4++) {
+    const governanceFile = path14.join(resolvedPaths.workspace.resolved, GOVERNANCE_FILES[i4].path);
+    const realGovernanceFile = tryRealpath(governanceFile);
+    let isDirectory = GOVERNANCE_FILES[i4].isDirectory;
+    try {
+      if (fs18.existsSync(realGovernanceFile)) {
+        isDirectory = fs18.lstatSync(realGovernanceFile).isDirectory();
       }
+    } catch {
     }
-    if (write2) {
-      for (let i4 = 0; i4 < write2.length; i4++) {
-        const resolved = tryRealpath(write2[i4]);
-        let isFile2 = false;
-        try {
-          isFile2 = fs18.statSync(resolved).isFile();
-        } catch {
-        }
-        if (isFile2) {
-          profile += `(allow file-read* file-write* (literal "${escapeSchemeString(resolved)}"))
+    const ruleType = isDirectory ? "subpath" : "literal";
+    profile += `(deny file-write* (${ruleType} "${escapeSchemeString(governanceFile)}"))
 `;
-        } else {
-          profile += `(allow file-read* file-write* (subpath "${escapeSchemeString(resolved)}"))
+    if (realGovernanceFile !== governanceFile) {
+      profile += `(deny file-write* (${ruleType} "${escapeSchemeString(realGovernanceFile)}"))
 `;
-        }
+    }
+  }
+  const searchPaths = [
+    resolvedPaths.workspace.resolved,
+    resolvedPaths.workspace.original,
+    ...resolvedPaths.policyAllowed,
+    ...resolvedPaths.globalIncludes
+  ];
+  for (const basePath of searchPaths) {
+    for (const secret of SECRET_FILES) {
+      let regexPattern;
+      const escapedBase = escapeRegex(basePath);
+      if (secret.pattern.endsWith("*")) {
+        const basePattern = secret.pattern.slice(0, -1).replace(/\./g, "\\\\.");
+        regexPattern = `^${escapedBase}/(.*/)?${basePattern}[^/]+$`;
+      } else {
+        const basePattern = secret.pattern.replace(/\./g, "\\\\.");
+        regexPattern = `^${escapedBase}/(.*/)?${basePattern}$`;
       }
+      profile += `(deny file-read* file-write* (regex #"${regexPattern}"))
+`;
     }
   }
-  const forbiddenPaths = options.forbiddenPaths;
+  const forbiddenPaths = resolvedPaths.forbidden;
   for (let i4 = 0; i4 < forbiddenPaths.length; i4++) {
-    const forbiddenPath = tryRealpath(forbiddenPaths[i4]);
+    const forbiddenPath = forbiddenPaths[i4];
     profile += `(deny file-read* file-write* (subpath "${escapeSchemeString(forbiddenPath)}"))
 `;
   }
-  if (options.networkAccess || options.additionalPermissions?.network) {
+  if (networkAccess) {
     profile += NETWORK_SEATBELT_PROFILE;
   }
   return profile;
@@ -123783,7 +123793,6 @@ var init_MacOsSandboxManager = __esm({
         const isYolo = this.options.modeConfig?.yolo ?? false;
         const workspaceWrite = !isReadonlyMode || isApproved || isYolo;
         const defaultNetwork = this.options.modeConfig?.network || req.policy?.networkAccess || isYolo;
-        const { allowed: allowedPaths, forbidden: forbiddenPaths } = await resolveSandboxPaths(this.options, req);
         const commandName = await getCommandName2(currentReq);
         const persistentPermissions = allowOverrides ? this.options.policyManager?.getCommandPermissions(commandName) : void 0;
         const mergedAdditional = {
@@ -123799,17 +123808,15 @@ var init_MacOsSandboxManager = __esm({
           },
           network: defaultNetwork || persistentPermissions?.network || req.policy?.additionalPermissions?.network || false
         };
-        const { command: finalCommand, args: finalArgs } = handleReadWriteCommands(req, mergedAdditional, this.options.workspace, req.policy?.allowedPaths);
+        const { command: finalCommand, args: finalArgs } = handleReadWriteCommands(req, mergedAdditional, this.options.workspace, [
+          ...req.policy?.allowedPaths || [],
+          ...this.options.includeDirectories || []
+        ]);
+        const resolvedPaths = await resolveSandboxPaths(this.options, req, mergedAdditional);
         const sandboxArgs = buildSeatbeltProfile({
-          workspace: this.options.workspace,
-          allowedPaths: [
-            ...allowedPaths,
-            ...this.options.includeDirectories || []
-          ],
-          forbiddenPaths,
+          resolvedPaths,
           networkAccess: mergedAdditional.network,
-          workspaceWrite,
-          additionalPermissions: mergedAdditional
+          workspaceWrite
         });
         const tempFile = this.writeProfileToTempFile(sandboxArgs);
         return {
@@ -123897,7 +123904,7 @@ import fs20 from "node:fs";
 import path16 from "node:path";
 import os10 from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var __filename2, __dirname2, LOW_INTEGRITY_SID, WindowsSandboxManager;
+var __filename2, __dirname2, LOW_INTEGRITY_SID, DIRECTORY_FLAGS, WindowsSandboxManager;
 var init_WindowsSandboxManager = __esm({
   "packages/core/dist/src/sandbox/windows/WindowsSandboxManager.js"() {
     "use strict";
@@ -123914,6 +123921,7 @@ var init_WindowsSandboxManager = __esm({
     __filename2 = fileURLToPath2(import.meta.url);
     __dirname2 = path16.dirname(__filename2);
     LOW_INTEGRITY_SID = "*S-1-16-4096";
+    DIRECTORY_FLAGS = "(OI)(CI)";
     WindowsSandboxManager = class _WindowsSandboxManager {
       options;
       static HELPER_EXE = "GeminiSandbox.exe";
@@ -124050,47 +124058,43 @@ var init_WindowsSandboxManager = __esm({
         }
         const defaultNetwork = this.options.modeConfig?.network ?? req.policy?.networkAccess ?? false;
         const networkAccess = defaultNetwork || mergedAdditional.network;
-        const { allowed: allowedPaths, forbidden: forbiddenPaths } = await resolveSandboxPaths(this.options, req);
+        const resolvedPaths = await resolveSandboxPaths(this.options, req, mergedAdditional);
         const writableRoots = [];
         const isApproved = allowOverrides ? await isStrictlyApproved(command, args2, this.options.modeConfig?.approvedTools) : false;
         if (!isReadonlyMode || isApproved) {
-          await this.grantLowIntegrityAccess(this.options.workspace);
-          writableRoots.push(this.options.workspace);
+          await this.grantLowIntegrityAccess(resolvedPaths.workspace.resolved);
+          writableRoots.push(resolvedPaths.workspace.resolved);
         }
-        const includeDirs = sanitizePaths(this.options.includeDirectories);
-        for (const includeDir of includeDirs) {
+        for (const includeDir of resolvedPaths.globalIncludes) {
           await this.grantLowIntegrityAccess(includeDir);
           writableRoots.push(includeDir);
         }
-        for (const allowedPath of allowedPaths) {
-          const resolved = resolveToRealPath(allowedPath);
+        for (const allowedPath of resolvedPaths.policyAllowed) {
           try {
-            await fs20.promises.access(resolved, fs20.constants.F_OK);
+            await fs20.promises.access(allowedPath, fs20.constants.F_OK);
           } catch {
-            throw new Error(`Sandbox request rejected: Allowed path does not exist: ${resolved}. On Windows, granular sandbox access can only be granted to existing paths to avoid broad parent directory permissions.`);
+            throw new Error(`Sandbox request rejected: Allowed path does not exist: ${allowedPath}. On Windows, granular sandbox access can only be granted to existing paths to avoid broad parent directory permissions.`);
           }
-          await this.grantLowIntegrityAccess(resolved);
-          writableRoots.push(resolved);
+          await this.grantLowIntegrityAccess(allowedPath);
+          writableRoots.push(allowedPath);
         }
-        const additionalWritePaths = sanitizePaths(mergedAdditional.fileSystem?.write);
-        for (const writePath of additionalWritePaths) {
-          const resolved = resolveToRealPath(writePath);
+        for (const writePath of resolvedPaths.policyWrite) {
           try {
-            await fs20.promises.access(resolved, fs20.constants.F_OK);
-            await this.grantLowIntegrityAccess(resolved);
+            await fs20.promises.access(writePath, fs20.constants.F_OK);
+            await this.grantLowIntegrityAccess(writePath);
             continue;
           } catch {
-            const isInherited = writableRoots.some((root) => isSubpath(root, resolved));
+            const isInherited = writableRoots.some((root) => isSubpath(root, writePath));
             if (!isInherited) {
-              throw new Error(`Sandbox request rejected: Additional write path does not exist and its parent directory is not allowed: ${resolved}. On Windows, granular sandbox access can only be granted to existing paths to avoid broad parent directory permissions.`);
+              throw new Error(`Sandbox request rejected: Additional write path does not exist and its parent directory is not allowed: ${writePath}. On Windows, granular sandbox access can only be granted to existing paths to avoid broad parent directory permissions.`);
             }
           }
         }
         const secretsToBlock = [];
         const searchDirs = /* @__PURE__ */ new Set([
-          this.options.workspace,
-          ...allowedPaths,
-          ...includeDirs
+          resolvedPaths.workspace.resolved,
+          ...resolvedPaths.policyAllowed,
+          ...resolvedPaths.globalIncludes
         ]);
         for (const dir of searchDirs) {
           try {
@@ -124107,7 +124111,7 @@ var init_WindowsSandboxManager = __esm({
             debugLogger.log(`WindowsSandboxManager: Failed to find secret files in ${dir}`, e3);
           }
         }
-        for (const forbiddenPath of forbiddenPaths) {
+        for (const forbiddenPath of resolvedPaths.forbidden) {
           try {
             await this.denyLowIntegrityAccess(forbiddenPath);
           } catch (e3) {
@@ -124115,10 +124119,10 @@ var init_WindowsSandboxManager = __esm({
           }
         }
         for (const file of GOVERNANCE_FILES) {
-          const filePath = path16.join(this.options.workspace, file.path);
+          const filePath = path16.join(resolvedPaths.workspace.resolved, file.path);
           this.touch(filePath, file.isDirectory);
         }
-        const allForbidden = Array.from(/* @__PURE__ */ new Set([...secretsToBlock, ...forbiddenPaths]));
+        const allForbidden = Array.from(/* @__PURE__ */ new Set([...secretsToBlock, ...resolvedPaths.forbidden]));
         const tempDir = fs20.mkdtempSync(path16.join(os10.tmpdir(), "gemini-cli-forbidden-"));
         const manifestPath = path16.join(tempDir, "manifest.txt");
         fs20.writeFileSync(manifestPath, allForbidden.join("\n"));
@@ -124164,12 +124168,15 @@ var init_WindowsSandboxManager = __esm({
           return;
         }
         try {
+          const stats = await fs20.promises.stat(resolvedPath);
+          const isDirectory = stats.isDirectory();
+          const flags2 = isDirectory ? DIRECTORY_FLAGS : "";
           await spawnAsync("icacls", [
             resolvedPath,
             "/grant",
-            `${LOW_INTEGRITY_SID}:(OI)(CI)(M)`,
+            `${LOW_INTEGRITY_SID}:${flags2}(M)`,
             "/setintegritylevel",
-            "(OI)(CI)Low"
+            `${flags2}Low`
           ]);
           this.allowedCache.add(resolvedPath);
         } catch (e3) {
@@ -124190,20 +124197,22 @@ var init_WindowsSandboxManager = __esm({
         if (this.isSystemDirectory(resolvedPath)) {
           return;
         }
-        const DENY_ALL_INHERIT = "(OI)(CI)(F)";
+        let isDirectory = false;
         try {
-          await fs20.promises.stat(resolvedPath);
+          const stats = await fs20.promises.stat(resolvedPath);
+          isDirectory = stats.isDirectory();
         } catch (e3) {
           if (isNodeError(e3) && e3.code === "ENOENT") {
             return;
           }
           throw e3;
         }
+        const flags2 = isDirectory ? DIRECTORY_FLAGS : "";
         try {
           await spawnAsync("icacls", [
             resolvedPath,
             "/deny",
-            `${LOW_INTEGRITY_SID}:${DENY_ALL_INHERIT}`
+            `${LOW_INTEGRITY_SID}:${flags2}(F)`
           ]);
           this.deniedCache.add(resolvedPath);
         } catch (e3) {
@@ -124307,18 +124316,42 @@ async function findSecretFiles(baseDir, maxDepth = 1) {
   await walk(baseDir, 1);
   return secrets;
 }
-async function resolveSandboxPaths(options, req) {
-  const forbidden = sanitizePaths(await options.forbiddenPaths?.());
-  const allowed = sanitizePaths(req.policy?.allowedPaths);
-  const workspaceIdentity = getPathIdentity(options.workspace);
+async function resolveSandboxPaths(options, req, overridePermissions) {
+  const expand3 = (paths) => {
+    if (!paths || paths.length === 0)
+      return [];
+    const expanded = paths.flatMap((p2) => {
+      try {
+        const resolved = resolveToRealPath(p2);
+        return resolved === p2 ? [p2] : [p2, resolved];
+      } catch {
+        return [p2];
+      }
+    });
+    return sanitizePaths(expanded);
+  };
+  const forbidden = expand3(await options.forbiddenPaths?.());
+  const globalIncludes = expand3(options.includeDirectories);
+  const policyAllowed = expand3(req.policy?.allowedPaths);
+  const policyRead = expand3(overridePermissions?.fileSystem?.read);
+  const policyWrite = expand3(overridePermissions?.fileSystem?.write);
+  const resolvedWorkspace = resolveToRealPath(options.workspace);
+  const workspaceIdentities = new Set([options.workspace, resolvedWorkspace].map(getPathIdentity));
   const forbiddenIdentities = new Set(forbidden.map(getPathIdentity));
-  const filteredAllowed = allowed.filter((p2) => {
+  const filter3 = (paths) => paths.filter((p2) => {
     const identity3 = getPathIdentity(p2);
-    return identity3 !== workspaceIdentity && !forbiddenIdentities.has(identity3);
+    return !workspaceIdentities.has(identity3) && !forbiddenIdentities.has(identity3);
   });
   return {
-    allowed: filteredAllowed,
-    forbidden
+    workspace: {
+      original: options.workspace,
+      resolved: resolvedWorkspace
+    },
+    forbidden,
+    globalIncludes: filter3(globalIncludes),
+    policyAllowed: filter3(policyAllowed),
+    policyRead: filter3(policyRead),
+    policyWrite: filter3(policyWrite)
   };
 }
 function sanitizePaths(paths) {
@@ -124353,6 +124386,7 @@ var init_sandboxManager = __esm({
     init_commandSafety2();
     init_errors2();
     init_environmentSanitization();
+    init_paths();
     init_sandboxManagerFactory();
     GOVERNANCE_FILES = [
       { path: ".gitignore", isDirectory: false },
@@ -208731,8 +208765,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 = "e77b22e63";
-    CLI_VERSION = "0.38.0-preview.0";
+    GIT_COMMIT_INFO = "615e07834";
+    CLI_VERSION = "0.39.0-nightly.20260409.615e07834";
   }
 });
 
@@ -279029,19 +279063,19 @@ var init_thoughtUtils = __esm({
 // packages/core/dist/src/utils/sessionOperations.js
 import * as fs34 from "node:fs/promises";
 import path26 from "node:path";
-function validateAndSanitizeSessionId(sessionId2) {
-  if (!sessionId2 || sessionId2 === "." || sessionId2 === "..") {
-    throw new Error(`Invalid sessionId: ${sessionId2}`);
+function validateAndSanitizeSessionId(sessionId) {
+  if (!sessionId || sessionId === "." || sessionId === "..") {
+    throw new Error(`Invalid sessionId: ${sessionId}`);
   }
-  const sanitized = sanitizeFilenamePart(sessionId2);
+  const sanitized = sanitizeFilenamePart(sessionId);
   if (!sanitized) {
-    throw new Error(`Invalid sessionId after sanitization: ${sessionId2}`);
+    throw new Error(`Invalid sessionId after sanitization: ${sessionId}`);
   }
   return sanitized;
 }
-async function deleteSessionArtifactsAsync(sessionId2, tempDir) {
+async function deleteSessionArtifactsAsync(sessionId, tempDir) {
   try {
-    const safeSessionId = validateAndSanitizeSessionId(sessionId2);
+    const safeSessionId = validateAndSanitizeSessionId(sessionId);
     const logsDir = path26.join(tempDir, LOGS_DIR);
     const logPath = path26.join(logsDir, `session-${safeSessionId}.jsonl`);
     await fs34.unlink(logPath).catch((err2) => {
@@ -279060,7 +279094,7 @@ async function deleteSessionArtifactsAsync(sessionId2, tempDir) {
         throw err2;
     });
   } catch (error2) {
-    debugLogger.error(`Error deleting session artifacts for ${sessionId2}:`, error2);
+    debugLogger.error(`Error deleting session artifacts for ${sessionId}:`, error2);
   }
 }
 async function deleteSubagentSessionDirAndArtifactsAsync(parentSessionId, chatsDir, tempDir) {
@@ -280550,16 +280584,6 @@ var init_activity_monitor = __esm({
   }
 });
 
-// packages/core/dist/src/utils/session.js
-import { randomUUID as randomUUID7 } from "node:crypto";
-var sessionId;
-var init_session = __esm({
-  "packages/core/dist/src/utils/session.js"() {
-    "use strict";
-    sessionId = randomUUID7();
-  }
-});
-
 // packages/core/dist/src/telemetry/trace.js
 function truncateForTelemetry(value, maxLength = 1e4) {
   if (typeof value === "string") {
@@ -280578,7 +280602,7 @@ function isAsyncIterable(value) {
   return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
 }
 async function runInDevTraceSpan(opts, fn2) {
-  const { operation, logPrompts, ...restOfSpanOpts } = opts;
+  const { operation, logPrompts, sessionId, ...restOfSpanOpts } = opts;
   const tracer = trace.getTracer(TRACER_NAME, TRACER_VERSION);
   return tracer.startActiveSpan(operation, restOfSpanOpts, async (span) => {
     const meta = {
@@ -280677,7 +280701,6 @@ var init_trace3 = __esm({
     init_esm2();
     init_safeJsonStringify();
     init_constants2();
-    init_session();
     init_textUtils();
     TRACER_NAME = "gemini-cli";
     TRACER_VERSION = "v1";
@@ -281713,12 +281736,12 @@ function fromCountTokenResponse(res) {
     totalTokens: res.totalTokens ?? 0
   };
 }
-function toGenerateContentRequest(req, userPromptId, project, sessionId2, enabledCreditTypes) {
+function toGenerateContentRequest(req, userPromptId, project, sessionId, enabledCreditTypes) {
   return {
     model: req.model,
     project,
     user_prompt_id: userPromptId,
-    request: toVertexGenerateContentRequest(req, sessionId2),
+    request: toVertexGenerateContentRequest(req, sessionId),
     enabled_credit_types: enabledCreditTypes
   };
 }
@@ -281737,7 +281760,7 @@ function fromGenerateContentResponse(res) {
   out2.modelVersion = inres.modelVersion;
   return out2;
 }
-function toVertexGenerateContentRequest(req, sessionId2) {
+function toVertexGenerateContentRequest(req, sessionId) {
   return {
     contents: toContents(req.contents),
     systemInstruction: maybeToContent(req.config?.systemInstruction),
@@ -281747,7 +281770,7 @@ function toVertexGenerateContentRequest(req, sessionId2) {
     labels: req.config?.labels,
     safetySettings: req.config?.safetySettings,
     generationConfig: toVertexGenerationConfig(req.config),
-    session_id: sessionId2
+    session_id: sessionId
   };
 }
 function toContents(contents) {
@@ -289655,21 +289678,21 @@ var init_protocol = __esm({
        * the error appropriately (e.g., by failing the task, logging, etc.). The Protocol layer
        * simply propagates the error.
        */
-      async _enqueueTaskMessage(taskId, message, sessionId2) {
+      async _enqueueTaskMessage(taskId, message, sessionId) {
         if (!this._taskStore || !this._taskMessageQueue) {
           throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
         }
         const maxQueueSize = this._options?.maxTaskQueueSize;
-        await this._taskMessageQueue.enqueue(taskId, message, sessionId2, maxQueueSize);
+        await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
       }
       /**
        * Clears the message queue for a task and rejects any pending request resolvers.
        * @param taskId The task ID whose queue should be cleared
        * @param sessionId Optional session ID for binding the operation to a specific session
        */
-      async _clearTaskQueue(taskId, sessionId2) {
+      async _clearTaskQueue(taskId, sessionId) {
         if (this._taskMessageQueue) {
-          const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId2);
+          const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
           for (const message of messages) {
             if (message.type === "request" && isJSONRPCRequest(message.message)) {
               const requestId = message.message.id;
@@ -289712,7 +289735,7 @@ var init_protocol = __esm({
           }, { once: true });
         });
       }
-      requestTaskStore(request, sessionId2) {
+      requestTaskStore(request, sessionId) {
         const taskStore = this._taskStore;
         if (!taskStore) {
           throw new Error("No task store configured");
@@ -289725,18 +289748,18 @@ var init_protocol = __esm({
             return await taskStore.createTask(taskParams, request.id, {
               method: request.method,
               params: request.params
-            }, sessionId2);
+            }, sessionId);
           },
           getTask: async (taskId) => {
-            const task = await taskStore.getTask(taskId, sessionId2);
+            const task = await taskStore.getTask(taskId, sessionId);
             if (!task) {
               throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
             }
             return task;
           },
           storeTaskResult: async (taskId, status2, result2) => {
-            await taskStore.storeTaskResult(taskId, status2, result2, sessionId2);
-            const task = await taskStore.getTask(taskId, sessionId2);
+            await taskStore.storeTaskResult(taskId, status2, result2, sessionId);
+            const task = await taskStore.getTask(taskId, sessionId);
             if (task) {
               const notification = TaskStatusNotificationSchema.parse({
                 method: "notifications/tasks/status",
@@ -289749,18 +289772,18 @@ var init_protocol = __esm({
             }
           },
           getTaskResult: (taskId) => {
-            return taskStore.getTaskResult(taskId, sessionId2);
+            return taskStore.getTaskResult(taskId, sessionId);
           },
           updateTaskStatus: async (taskId, status2, statusMessage) => {
-            const task = await taskStore.getTask(taskId, sessionId2);
+            const task = await taskStore.getTask(taskId, sessionId);
             if (!task) {
               throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
             }
             if (isTerminal(task.status)) {
               throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status2}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
             }
-            await taskStore.updateTaskStatus(taskId, status2, statusMessage, sessionId2);
-            const updatedTask = await taskStore.getTask(taskId, sessionId2);
+            await taskStore.updateTaskStatus(taskId, status2, statusMessage, sessionId);
+            const updatedTask = await taskStore.getTask(taskId, sessionId);
             if (updatedTask) {
               const notification = TaskStatusNotificationSchema.parse({
                 method: "notifications/tasks/status",
@@ -289773,7 +289796,7 @@ var init_protocol = __esm({
             }
           },
           listTasks: (cursor) => {
-            return taskStore.listTasks(cursor, sessionId2);
+            return taskStore.listTasks(cursor, sessionId);
           }
         };
       }
@@ -297528,9 +297551,9 @@ var init_streamableHttp = __esm({
             signal: this._abortController?.signal
           };
           const response = await (this._fetch ?? fetch)(this._url, init3);
-          const sessionId2 = response.headers.get("mcp-session-id");
-          if (sessionId2) {
-            this._sessionId = sessionId2;
+          const sessionId = response.headers.get("mcp-session-id");
+          if (sessionId) {
+            this._sessionId = sessionId;
           }
           if (!response.ok) {
             const text = await response.text().catch(() => null);
@@ -331876,7 +331899,7 @@ function getVersion() {
   }
   versionPromise = (async () => {
     const pkgJson = await getPackageJson(__dirname4);
-    return "0.38.0-preview.0";
+    return "0.39.0-nightly.20260409.615e07834";
   })();
   return versionPromise;
 }
@@ -331973,11 +331996,11 @@ var init_server = __esm({
       userTierName;
       paidTier;
       config;
-      constructor(client, projectId, httpOptions = {}, sessionId2, userTier, userTierName, paidTier, config3) {
+      constructor(client, projectId, httpOptions = {}, sessionId, userTier, userTierName, paidTier, config3) {
         this.client = client;
         this.projectId = projectId;
         this.httpOptions = httpOptions;
-        this.sessionId = sessionId2;
+        this.sessionId = sessionId;
         this.userTier = userTier;
         this.userTierName = userTierName;
         this.paidTier = paidTier;
@@ -332812,6 +332835,7 @@ var init_loggingContentGenerator = __esm({
         return runInDevTraceSpan({
           operation: GeminiCliOperation.LLMCall,
           logPrompts: this.config.getTelemetryLogPromptsEnabled(),
+          sessionId: this.config.getSessionId(),
           attributes: {
             [GEN_AI_REQUEST_MODEL]: req.model,
             [GEN_AI_PROMPT_NAME]: userPromptId,
@@ -332852,6 +332876,7 @@ var init_loggingContentGenerator = __esm({
         return runInDevTraceSpan({
           operation: GeminiCliOperation.LLMCall,
           logPrompts: this.config.getTelemetryLogPromptsEnabled(),
+          sessionId: this.config.getSessionId(),
           attributes: {
             [GEN_AI_REQUEST_MODEL]: req.model,
             [GEN_AI_PROMPT_NAME]: userPromptId,
@@ -332919,6 +332944,7 @@ var init_loggingContentGenerator = __esm({
         return runInDevTraceSpan({
           operation: GeminiCliOperation.LLMCall,
           logPrompts: this.config.getTelemetryLogPromptsEnabled(),
+          sessionId: this.config.getSessionId(),
           attributes: {
             [GEN_AI_REQUEST_MODEL]: req.model
           }
@@ -332934,11 +332960,11 @@ var init_loggingContentGenerator = __esm({
 });
 
 // packages/core/dist/src/code_assist/codeAssist.js
-async function createCodeAssistContentGenerator(httpOptions, authType, config3, sessionId2) {
+async function createCodeAssistContentGenerator(httpOptions, authType, config3, sessionId) {
   if (authType === AuthType2.LOGIN_WITH_GOOGLE || authType === AuthType2.COMPUTE_ADC) {
     const authClient = await getOauthClient(authType, config3);
     const userData = await setupUser(authClient, config3, httpOptions);
-    return new CodeAssistServer(authClient, userData.projectId, httpOptions, sessionId2, userData.userTier, userData.userTierName, userData.paidTier, config3);
+    return new CodeAssistServer(authClient, userData.projectId, httpOptions, sessionId, userData.userTier, userData.userTierName, userData.paidTier, config3);
   }
   throw new Error(`Unsupported authType: ${authType}`);
 }
@@ -333224,7 +333250,7 @@ async function createContentGeneratorConfig(config3, authType, apiKey, baseUrl,
   }
   return contentGeneratorConfig;
 }
-async function createContentGenerator(config3, gcConfig, sessionId2) {
+async function createContentGenerator(config3, gcConfig, sessionId) {
   const generator = await (async () => {
     if (gcConfig.fakeResponses) {
       const fakeGenerator = await FakeContentGenerator.fromFile(gcConfig.fakeResponses);
@@ -333268,7 +333294,7 @@ async function createContentGenerator(config3, gcConfig, sessionId2) {
     }
     if (config3.authType === AuthType2.LOGIN_WITH_GOOGLE || config3.authType === AuthType2.COMPUTE_ADC) {
       const httpOptions = { headers: baseHeaders };
-      return new LoggingContentGenerator(await createCodeAssistContentGenerator(httpOptions, config3.authType, gcConfig, sessionId2), gcConfig);
+      return new LoggingContentGenerator(await createCodeAssistContentGenerator(httpOptions, config3.authType, gcConfig, sessionId), gcConfig);
     }
     if (config3.authType === AuthType2.USE_GEMINI || config3.authType === AuthType2.USE_VERTEX_AI || config3.authType === AuthType2.GATEWAY) {
       let headers = { ...baseHeaders };
@@ -333493,6 +333519,7 @@ var init_tool_registry = __esm({
         let finalCommand = callCommand;
         let finalArgs = args2;
         let finalEnv = process.env;
+        let cleanupFunc;
         const sandboxManager = this.config.sandboxManager;
         if (sandboxManager) {
           const prepared = await sandboxManager.prepareCommand({
@@ -333504,47 +333531,52 @@ var init_tool_registry = __esm({
           finalCommand = prepared.program;
           finalArgs = prepared.args;
           finalEnv = prepared.env;
+          cleanupFunc = prepared.cleanup;
         }
-        const child = spawn4(finalCommand, finalArgs, {
-          env: finalEnv
-        });
-        child.stdin.write(JSON.stringify(this.params));
-        child.stdin.end();
         let stdout = "";
         let stderr = "";
         let error2 = null;
         let code = null;
         let signal = null;
-        await new Promise((resolve24) => {
-          const onStdout = (data) => {
-            stdout += data?.toString();
-          };
-          const onStderr = (data) => {
-            stderr += data?.toString();
-          };
-          const onError2 = (err2) => {
-            error2 = err2;
-          };
-          const onClose = (_code, _signal2) => {
-            code = _code;
-            signal = _signal2;
-            cleanup();
-            resolve24();
-          };
-          const cleanup = () => {
-            child.stdout.removeListener("data", onStdout);
-            child.stderr.removeListener("data", onStderr);
-            child.removeListener("error", onError2);
-            child.removeListener("close", onClose);
-            if (child.connected) {
-              child.disconnect();
-            }
-          };
-          child.stdout.on("data", onStdout);
-          child.stderr.on("data", onStderr);
-          child.on("error", onError2);
-          child.on("close", onClose);
-        });
+        try {
+          const child = spawn4(finalCommand, finalArgs, {
+            env: finalEnv
+          });
+          child.stdin.write(JSON.stringify(this.params));
+          child.stdin.end();
+          await new Promise((resolve24) => {
+            const onStdout = (data) => {
+              stdout += data?.toString();
+            };
+            const onStderr = (data) => {
+              stderr += data?.toString();
+            };
+            const onError2 = (err2) => {
+              error2 = err2;
+            };
+            const onClose = (_code, _signal2) => {
+              code = _code;
+              signal = _signal2;
+              cleanup();
+              resolve24();
+            };
+            const cleanup = () => {
+              child.stdout.removeListener("data", onStdout);
+              child.stderr.removeListener("data", onStderr);
+              child.removeListener("error", onError2);
+              child.removeListener("close", onClose);
+              if (child.connected) {
+                child.disconnect();
+              }
+            };
+            child.stdout.on("data", onStdout);
+            child.stderr.on("data", onStderr);
+            child.on("error", onError2);
+            child.on("close", onClose);
+          });
+        } finally {
+          cleanupFunc?.();
+        }
         if (error2 || code !== 0 || signal || stderr) {
           const llmContent = [
             `Stdout: ${stdout || "(empty)"}`,
@@ -333732,6 +333764,7 @@ Signal: Signal number or \`(none)\` if no signal was received.
           let finalCommand = firstPart;
           let finalArgs = cmdParts.slice(1).filter((p2) => typeof p2 === "string");
           let finalEnv = process.env;
+          let cleanupFunc;
           const sandboxManager = this.config.sandboxManager;
           if (sandboxManager) {
             const prepared = await sandboxManager.prepareCommand({
@@ -333743,87 +333776,94 @@ Signal: Signal number or \`(none)\` if no signal was received.
             finalCommand = prepared.program;
             finalArgs = prepared.args;
             finalEnv = prepared.env;
+            cleanupFunc = prepared.cleanup;
           }
-          const proc2 = spawn4(finalCommand, finalArgs, {
-            env: finalEnv
-          });
-          let stdout = "";
-          const stdoutDecoder = new StringDecoder("utf8");
-          let stderr = "";
-          const stderrDecoder = new StringDecoder("utf8");
-          let sizeLimitExceeded = false;
-          const MAX_STDOUT_SIZE = 10 * 1024 * 1024;
-          const MAX_STDERR_SIZE = 10 * 1024 * 1024;
-          let stdoutByteLength = 0;
-          let stderrByteLength = 0;
-          proc2.stdout.on("data", (data) => {
-            if (sizeLimitExceeded)
-              return;
-            if (stdoutByteLength + data.length > MAX_STDOUT_SIZE) {
-              sizeLimitExceeded = true;
-              proc2.kill();
-              return;
-            }
-            stdoutByteLength += data.length;
-            stdout += stdoutDecoder.write(data);
-          });
-          proc2.stderr.on("data", (data) => {
-            if (sizeLimitExceeded)
-              return;
-            if (stderrByteLength + data.length > MAX_STDERR_SIZE) {
-              sizeLimitExceeded = true;
-              proc2.kill();
-              return;
-            }
-            stderrByteLength += data.length;
-            stderr += stderrDecoder.write(data);
-          });
-          await new Promise((resolve24, reject) => {
-            proc2.on("error", reject);
-            proc2.on("close", (code) => {
-              stdout += stdoutDecoder.end();
-              stderr += stderrDecoder.end();
-              if (sizeLimitExceeded) {
-                return reject(new Error(`Tool discovery command output exceeded size limit of ${MAX_STDOUT_SIZE} bytes.`));
-              }
-              if (code !== 0) {
-                coreEvents.emitFeedback("error", `Tool discovery command failed with code ${code}.`, stderr);
-                return reject(new Error(`Tool discovery command failed with exit code ${code}`));
+          try {
+            const proc2 = spawn4(finalCommand, finalArgs, {
+              env: finalEnv
+            });
+            let stdout = "";
+            const stdoutDecoder = new StringDecoder("utf8");
+            let stderr = "";
+            const stderrDecoder = new StringDecoder("utf8");
+            let sizeLimitExceeded = false;
+            const MAX_STDOUT_SIZE = 10 * 1024 * 1024;
+            const MAX_STDERR_SIZE = 10 * 1024 * 1024;
+            let stdoutByteLength = 0;
+            let stderrByteLength = 0;
+            proc2.stdout.on("data", (data) => {
+              if (sizeLimitExceeded)
+                return;
+              if (stdoutByteLength + data.length > MAX_STDOUT_SIZE) {
+                sizeLimitExceeded = true;
+                proc2.kill();
+                return;
               }
-              resolve24();
+              stdoutByteLength += data.length;
+              stdout += stdoutDecoder.write(data);
             });
-          });
-          const functions = [];
-          const discoveredItems = JSON.parse(stdout.trim());
-          if (!discoveredItems || !Array.isArray(discoveredItems)) {
-            throw new Error("Tool discovery command did not return a JSON array of tools.");
-          }
-          for (const tool of discoveredItems) {
-            if (tool && typeof tool === "object") {
-              if (Array.isArray(tool["function_declarations"])) {
-                functions.push(...tool["function_declarations"]);
-              } else if (Array.isArray(tool["functionDeclarations"])) {
-                functions.push(...tool["functionDeclarations"]);
-              } else if (tool["name"]) {
-                functions.push(tool);
+            proc2.stderr.on("data", (data) => {
+              if (sizeLimitExceeded)
+                return;
+              if (stderrByteLength + data.length > MAX_STDERR_SIZE) {
+                sizeLimitExceeded = true;
+                proc2.kill();
+                return;
               }
+              stderrByteLength += data.length;
+              stderr += stderrDecoder.write(data);
+            });
+            await new Promise((resolve24, reject) => {
+              proc2.on("error", (err2) => {
+                reject(err2);
+              });
+              proc2.on("close", (code) => {
+                stdout += stdoutDecoder.end();
+                stderr += stderrDecoder.end();
+                if (sizeLimitExceeded) {
+                  return reject(new Error(`Tool discovery command output exceeded size limit of ${MAX_STDOUT_SIZE} bytes.`));
+                }
+                if (code !== 0) {
+                  coreEvents.emitFeedback("error", `Tool discovery command failed with code ${code}.`, stderr);
+                  return reject(new Error(`Tool discovery command failed with exit code ${code}`));
+                }
+                resolve24();
+              });
+            });
+            const functions = [];
+            const discoveredItems = JSON.parse(stdout.trim());
+            if (!discoveredItems || !Array.isArray(discoveredItems)) {
+              throw new Error("Tool discovery command did not return a JSON array of tools.");
             }
-          }
-          for (const func2 of functions) {
-            if (!func2.name) {
-              debugLogger.warn("Discovered a tool with no name. Skipping.");
-              continue;
+            for (const tool of discoveredItems) {
+              if (tool && typeof tool === "object") {
+                if (Array.isArray(tool["function_declarations"])) {
+                  functions.push(...tool["function_declarations"]);
+                } else if (Array.isArray(tool["functionDeclarations"])) {
+                  functions.push(...tool["functionDeclarations"]);
+                } else if (tool["name"]) {
+                  functions.push(tool);
+                }
+              }
             }
-            const parameters = func2.parametersJsonSchema && typeof func2.parametersJsonSchema === "object" && !Array.isArray(func2.parametersJsonSchema) ? func2.parametersJsonSchema : {};
-            this.registerTool(new DiscoveredTool(
-              this.config,
-              func2.name,
-              DISCOVERED_TOOL_PREFIX + func2.name,
-              func2.description ?? "",
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-              parameters,
-              this.messageBus
-            ));
+            for (const func2 of functions) {
+              if (!func2.name) {
+                debugLogger.warn("Discovered a tool with no name. Skipping.");
+                continue;
+              }
+              const parameters = func2.parametersJsonSchema && typeof func2.parametersJsonSchema === "object" && !Array.isArray(func2.parametersJsonSchema) ? func2.parametersJsonSchema : {};
+              this.registerTool(new DiscoveredTool(
+                this.config,
+                func2.name,
+                DISCOVERED_TOOL_PREFIX + func2.name,
+                func2.description ?? "",
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                parameters,
+                this.messageBus
+              ));
+            }
+          } finally {
+            cleanupFunc?.();
           }
         } catch (e3) {
           debugLogger.error(`Tool discovery command "${discoveryCmd}" failed:`, e3);
@@ -334199,7 +334239,7 @@ ${directoryContent}`;
           if (jitContext) {
             resultMessage = appendJitContext(resultMessage, jitContext);
           }
-          let displayMessage = `Listed ${entries2.length} item(s).`;
+          let displayMessage = `Found ${entries2.length} item(s).`;
           if (ignoredCount > 0) {
             displayMessage += ` (${ignoredCount} ignored)`;
           }
@@ -342642,6 +342682,7 @@ var init_grep = __esm({
           let finalCommand = checkCommand;
           let finalArgs = checkArgs;
           let finalEnv = process.env;
+          let cleanup;
           if (sandboxManager) {
             try {
               const prepared = await sandboxManager.prepareCommand({
@@ -342653,22 +342694,29 @@ var init_grep = __esm({
               finalCommand = prepared.program;
               finalArgs = prepared.args;
               finalEnv = prepared.env;
+              cleanup = prepared.cleanup;
             } catch (err2) {
               debugLogger.debug(`[GrepTool] Sandbox preparation failed for '${command}':`, err2);
             }
           }
-          return await new Promise((resolve24) => {
-            const child = spawn5(finalCommand, finalArgs, {
-              stdio: "ignore",
-              shell: true,
-              env: finalEnv
-            });
-            child.on("close", (code) => resolve24(code === 0));
-            child.on("error", (err2) => {
-              debugLogger.debug(`[GrepTool] Failed to start process for '${command}':`, err2.message);
-              resolve24(false);
+          try {
+            return await new Promise((resolve24) => {
+              const child = spawn5(finalCommand, finalArgs, {
+                stdio: "ignore",
+                shell: true,
+                env: finalEnv
+              });
+              child.on("close", (code) => {
+                resolve24(code === 0);
+              });
+              child.on("error", (err2) => {
+                debugLogger.debug(`[GrepTool] Failed to start process for '${command}':`, err2.message);
+                resolve24(false);
+              });
             });
-          });
+          } finally {
+            cleanup?.();
+          }
         } catch {
           return false;
         }
@@ -372787,6 +372835,7 @@ ${truncated}`;
         };
       }
       static async childProcessFallback(commandToExecute, cwd, onOutputEvent, abortSignal, shellExecutionConfig, isInteractive) {
+        let cmdCleanup;
         try {
           let cleanup2 = function() {
             exited = true;
@@ -372827,7 +372876,9 @@ ${truncated}`;
           };
           var cleanup = cleanup2;
           const isWindows2 = os31.platform() === "win32";
-          const { program: finalExecutable, args: finalArgs, env: finalEnv, cwd: finalCwd, cleanup: cmdCleanup } = await this.prepareExecution(commandToExecute, cwd, shellExecutionConfig, isInteractive);
+          const prepared = await this.prepareExecution(commandToExecute, cwd, shellExecutionConfig, isInteractive);
+          cmdCleanup = prepared.cleanup;
+          const { program: finalExecutable, args: finalArgs, env: finalEnv, cwd: finalCwd } = prepared;
           const child = cpSpawn(finalExecutable, finalArgs, {
             cwd: finalCwd,
             stdio: ["ignore", "pipe", "pipe"],
@@ -372982,8 +373033,8 @@ ${truncated}`;
                 exitCode,
                 signal: exitSignal
               };
-              const sessionId2 = shellExecutionConfig.sessionId ?? "default";
-              const history = _ShellExecutionService.backgroundProcessHistory.get(sessionId2);
+              const sessionId = shellExecutionConfig.sessionId ?? "default";
+              const history = _ShellExecutionService.backgroundProcessHistory.get(sessionId);
               const historyItem = history?.get(pid);
               if (historyItem) {
                 historyItem.status = "exited";
@@ -373022,6 +373073,7 @@ ${truncated}`;
           return { pid: child.pid, result: result2 };
         } catch (e3) {
           const error2 = e3;
+          cmdCleanup?.();
           return {
             pid: void 0,
             result: Promise.resolve({
@@ -373042,10 +373094,13 @@ ${truncated}`;
           throw new Error("PTY implementation not found");
         }
         let spawnedPty;
+        let cmdCleanup;
         try {
           const cols = shellExecutionConfig.terminalWidth ?? 80;
           const rows = shellExecutionConfig.terminalHeight ?? 30;
-          const { program: finalExecutable, args: finalArgs, env: finalEnv, cwd: finalCwd, cleanup: cmdCleanup } = await this.prepareExecution(commandToExecute, cwd, shellExecutionConfig, true);
+          const prepared = await this.prepareExecution(commandToExecute, cwd, shellExecutionConfig, true);
+          cmdCleanup = prepared.cleanup;
+          const { program: finalExecutable, args: finalArgs, env: finalEnv, cwd: finalCwd } = prepared;
           const ptyProcess = ptyInfo.module.spawn(finalExecutable, finalArgs, {
             cwd: finalCwd,
             name: "xterm-256color",
@@ -373267,8 +373322,8 @@ ${truncated}`;
                 exitCode,
                 signal: signal ?? null
               };
-              const sessionId2 = shellExecutionConfig.sessionId ?? "default";
-              const history = _ShellExecutionService.backgroundProcessHistory.get(sessionId2);
+              const sessionId = shellExecutionConfig.sessionId ?? "default";
+              const history = _ShellExecutionService.backgroundProcessHistory.get(sessionId);
               const historyItem = history?.get(ptyPid);
               if (historyItem) {
                 historyItem.status = "exited";
@@ -373328,6 +373383,7 @@ ${truncated}`;
           return { pid: ptyPid, result: result2 };
         } catch (e3) {
           const error2 = e3;
+          cmdCleanup?.();
           if (spawnedPty) {
             try {
               spawnedPty.destroy?.();
@@ -373397,10 +373453,10 @@ ${truncated}`;
        *
        * @param pid The process ID of the target PTY.
        */
-      static background(pid, sessionId2, command) {
+      static background(pid, sessionId, command) {
         const activePty = this.activePtys.get(pid);
         const activeChild = this.activeChildProcesses.get(pid);
-        const resolvedSessionId = sessionId2 ?? activePty?.sessionId ?? activeChild?.sessionId;
+        const resolvedSessionId = sessionId ?? activePty?.sessionId ?? activeChild?.sessionId;
         const resolvedCommand = command ?? activePty?.command ?? activeChild?.command ?? "unknown command";
         if (!resolvedSessionId) {
           throw new Error("Session ID is required for background operations");
@@ -373504,11 +373560,11 @@ ${truncated}`;
           }
         }
       }
-      static listBackgroundProcesses(sessionId2) {
-        if (!sessionId2) {
+      static listBackgroundProcesses(sessionId) {
+        if (!sessionId) {
           throw new Error("Session ID is required");
         }
-        const history = this.backgroundProcessHistory.get(sessionId2);
+        const history = this.backgroundProcessHistory.get(sessionId);
         if (!history)
           return [];
         return Array.from(history.entries()).map(([pid, info2]) => ({
@@ -373666,7 +373722,7 @@ import fs55 from "node:fs";
 import path64 from "node:path";
 import os33 from "node:os";
 import crypto20 from "node:crypto";
-var OUTPUT_UPDATE_INTERVAL_MS, BACKGROUND_DELAY_MS, ShellToolInvocation, ShellTool;
+var OUTPUT_UPDATE_INTERVAL_MS, BACKGROUND_DELAY_MS, SHOW_NL_DESCRIPTION_THRESHOLD, ShellToolInvocation, ShellTool;
 var init_shell2 = __esm({
   "packages/core/dist/src/tools/shell.js"() {
     "use strict";
@@ -373687,6 +373743,7 @@ var init_shell2 = __esm({
     init_proactivePermissions();
     OUTPUT_UPDATE_INTERVAL_MS = 1e3;
     BACKGROUND_DELAY_MS = 200;
+    SHOW_NL_DESCRIPTION_THRESHOLD = 150;
     ShellToolInvocation = class extends BaseToolInvocation {
       context;
       proactivePermissionsConfirmed;
@@ -373734,7 +373791,9 @@ ${trimmed2}
         return details;
       }
       getDescription() {
-        return this.params.description?.trim() ? this.params.description : this.params.command;
+        const descStr = this.params.description?.trim();
+        const commandStr = this.params.command;
+        return Array.from(commandStr).length <= SHOW_NL_DESCRIPTION_THRESHOLD || !descStr ? commandStr : descStr;
       }
       simplifyPaths(paths) {
         if (paths.size === 0)
@@ -374048,10 +374107,10 @@ ${trimmed2}
               }).catch(() => {
                 completed = true;
               });
-              const sessionId2 = this.context.config?.getSessionId?.() ?? "default";
+              const sessionId = this.context.config?.getSessionId?.() ?? "default";
               const delay4 = this.params.delay_ms ?? BACKGROUND_DELAY_MS;
               setTimeout(() => {
-                ShellExecutionService.background(pid, sessionId2, strippedCommand);
+                ShellExecutionService.background(pid, sessionId, strippedCommand);
               }, delay4);
               await new Promise((resolve24) => setTimeout(resolve24, delay4));
               if (!completed) {
@@ -385641,9 +385700,9 @@ var init_toolOutputMaskingService = __esm({
         const newHistory = [...history];
         let actualTokensSaved = 0;
         let toolOutputsDir = path69.join(config3.storage.getProjectTempDir(), TOOL_OUTPUTS_DIR3);
-        const sessionId2 = config3.getSessionId();
-        if (sessionId2) {
-          const safeSessionId = sanitizeFilenamePart(sessionId2);
+        const sessionId = config3.getSessionId();
+        if (sessionId) {
+          const safeSessionId = sanitizeFilenamePart(sessionId);
           toolOutputsDir = path69.join(toolOutputsDir, `session-${safeSessionId}`);
         }
         await fsPromises11.mkdir(toolOutputsDir, { recursive: true });
@@ -391388,35 +391447,39 @@ var init_sandboxedFileSystemService = __esm({
             allowedPaths: [safePath]
           }
         });
-        return new Promise((resolve24, reject) => {
-          const child = spawn8(prepared.program, prepared.args, {
-            cwd: this.cwd,
-            env: prepared.env
-          });
-          let output = "";
-          let error2 = "";
-          child.stdout?.on("data", (data) => {
-            output += data.toString();
-          });
-          child.stderr?.on("data", (data) => {
-            error2 += data.toString();
-          });
-          child.on("close", (code) => {
-            if (code === 0) {
-              resolve24(output);
-            } else {
-              const isEnoent = error2.toLowerCase().includes("no such file or directory") || error2.toLowerCase().includes("enoent") || error2.toLowerCase().includes("could not find file") || error2.toLowerCase().includes("could not find a part of the path");
-              const err2 = new Error(`Sandbox Error: read_file failed for '${filePath}'. Exit code ${code}. ${error2 ? "Details: " + error2 : ""}`);
-              if (isEnoent) {
-                Object.assign(err2, { code: "ENOENT" });
+        try {
+          return await new Promise((resolve24, reject) => {
+            const child = spawn8(prepared.program, prepared.args, {
+              cwd: this.cwd,
+              env: prepared.env
+            });
+            let output = "";
+            let error2 = "";
+            child.stdout?.on("data", (data) => {
+              output += data.toString();
+            });
+            child.stderr?.on("data", (data) => {
+              error2 += data.toString();
+            });
+            child.on("close", (code) => {
+              if (code === 0) {
+                resolve24(output);
+              } else {
+                const isEnoent = error2.toLowerCase().includes("no such file or directory") || error2.toLowerCase().includes("enoent") || error2.toLowerCase().includes("could not find file") || error2.toLowerCase().includes("could not find a part of the path");
+                const err2 = new Error(`Sandbox Error: read_file failed for '${filePath}'. Exit code ${code}. ${error2 ? "Details: " + error2 : ""}`);
+                if (isEnoent) {
+                  Object.assign(err2, { code: "ENOENT" });
+                }
+                reject(err2);
               }
-              reject(err2);
-            }
-          });
-          child.on("error", (err2) => {
-            reject(new Error(`Sandbox Error: Failed to spawn read_file for '${filePath}': ${err2.message}`));
+            });
+            child.on("error", (err2) => {
+              reject(new Error(`Sandbox Error: Failed to spawn read_file for '${filePath}': ${err2.message}`));
+            });
           });
-        });
+        } finally {
+          prepared.cleanup?.();
+        }
       }
       async writeTextFile(filePath, content) {
         const safePath = this.sanitizeAndValidatePath(filePath);
@@ -391434,34 +391497,38 @@ var init_sandboxedFileSystemService = __esm({
             }
           }
         });
-        return new Promise((resolve24, reject) => {
-          const child = spawn8(prepared.program, prepared.args, {
-            cwd: this.cwd,
-            env: prepared.env
-          });
-          child.stdin?.on("error", (err2) => {
-            if (isNodeError(err2) && err2.code === "EPIPE") {
-              return;
-            }
-            debugLogger.error(`Sandbox Error: stdin error for '${filePath}': ${err2 instanceof Error ? err2.message : String(err2)}`);
-          });
-          child.stdin?.write(content);
-          child.stdin?.end();
-          let error2 = "";
-          child.stderr?.on("data", (data) => {
-            error2 += data.toString();
-          });
-          child.on("close", (code) => {
-            if (code === 0) {
-              resolve24();
-            } else {
-              reject(new Error(`Sandbox Error: write_file failed for '${filePath}'. Exit code ${code}. ${error2 ? "Details: " + error2 : ""}`));
-            }
-          });
-          child.on("error", (err2) => {
-            reject(new Error(`Sandbox Error: Failed to spawn write_file for '${filePath}': ${err2.message}`));
+        try {
+          return await new Promise((resolve24, reject) => {
+            const child = spawn8(prepared.program, prepared.args, {
+              cwd: this.cwd,
+              env: prepared.env
+            });
+            child.stdin?.on("error", (err2) => {
+              if (isNodeError(err2) && err2.code === "EPIPE") {
+                return;
+              }
+              debugLogger.error(`Sandbox Error: stdin error for '${filePath}': ${err2 instanceof Error ? err2.message : String(err2)}`);
+            });
+            child.stdin?.write(content);
+            child.stdin?.end();
+            let error2 = "";
+            child.stderr?.on("data", (data) => {
+              error2 += data.toString();
+            });
+            child.on("close", (code) => {
+              if (code === 0) {
+                resolve24();
+              } else {
+                reject(new Error(`Sandbox Error: write_file failed for '${filePath}'. Exit code ${code}. ${error2 ? "Details: " + error2 : ""}`));
+              }
+            });
+            child.on("error", (err2) => {
+              reject(new Error(`Sandbox Error: Failed to spawn write_file for '${filePath}': ${err2.message}`));
+            });
           });
-        });
+        } finally {
+          prepared.cleanup?.();
+        }
       }
     };
   }
@@ -395263,7 +395330,7 @@ var init_scoped_config = __esm({
 });
 
 // packages/core/dist/src/confirmation-bus/message-bus.js
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 import { EventEmitter as EventEmitter10 } from "node:events";
 var MessageBus;
 var init_message_bus = __esm({
@@ -395382,7 +395449,7 @@ var init_message_bus = __esm({
        * The correlation ID is generated internally and added to the request
        */
       async request(request, responseType, timeoutMs = 6e4) {
-        const correlationId = randomUUID8();
+        const correlationId = randomUUID7();
         return new Promise((resolve24, reject) => {
           const timeoutId = setTimeout(() => {
             cleanup();
@@ -407243,7 +407310,7 @@ var init_state_manager = __esm({
 
 // packages/core/dist/src/scheduler/confirmation.js
 import { on as on7 } from "node:events";
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 async function awaitConfirmation(messageBus, correlationId, signal) {
   if (signal.aborted) {
     throw new Error("Operation cancelled");
@@ -407289,7 +407356,7 @@ async function resolveConfirmation(toolCall, signal, deps) {
       details.systemMessage = deps.systemMessage;
     }
     await notifyHooks(deps, details);
-    const correlationId = randomUUID9();
+    const correlationId = randomUUID8();
     const serializableDetails = details;
     lastDetails = serializableDetails;
     const ideConfirmation = "ideConfirmation" in details ? details.ideConfirmation : void 0;
@@ -407938,6 +408005,7 @@ var init_tool_executor = __esm({
         return runInDevTraceSpan({
           operation: GeminiCliOperation.ToolCall,
           logPrompts: this.config.getTelemetryLogPromptsEnabled(),
+          sessionId: this.config.getSessionId(),
           attributes: {
             [GEN_AI_TOOL_NAME]: toolName,
             [GEN_AI_TOOL_CALL_ID]: callId,
@@ -408328,7 +408396,8 @@ var init_scheduler2 = __esm({
       async schedule(request, signal) {
         return runInDevTraceSpan({
           operation: GeminiCliOperation.ScheduleToolCalls,
-          logPrompts: this.context.config.getTelemetryLogPromptsEnabled()
+          logPrompts: this.context.config.getTelemetryLogPromptsEnabled(),
+          sessionId: this.context.config.getSessionId()
         }, async ({ metadata: spanMetadata }) => {
           const requests = Array.isArray(request) ? request : [request];
           spanMetadata.input = requests;
@@ -410055,7 +410124,7 @@ var init_agent_sanitization_utils = __esm({
 });
 
 // packages/core/dist/src/agents/local-invocation.js
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 var INPUT_PREVIEW_MAX_LENGTH, DESCRIPTION_MAX_LENGTH, LocalSubagentInvocation;
 var init_local_invocation = __esm({
   "packages/core/dist/src/agents/local-invocation.js"() {
@@ -410130,7 +410199,7 @@ var init_local_invocation = __esm({
                   lastItem.content = sanitizeThoughtContent(text);
                 } else {
                   recentActivity.push({
-                    id: randomUUID10(),
+                    id: randomUUID9(),
                     type: "thought",
                     content: sanitizeThoughtContent(text),
                     status: "running"
@@ -410149,7 +410218,7 @@ var init_local_invocation = __esm({
                 const description = activity.data["description"] ? sanitizeErrorMessage(String(activity.data["description"])) : void 0;
                 const args2 = JSON.stringify(sanitizeToolArgs(activity.data["args"]));
                 recentActivity.push({
-                  id: randomUUID10(),
+                  id: randomUUID9(),
                   type: "tool_call",
                   content: name3,
                   displayName,
@@ -410203,7 +410272,7 @@ var init_local_invocation = __esm({
                   }
                 }
                 recentActivity.push({
-                  id: randomUUID10(),
+                  id: randomUUID9(),
                   type: "thought",
                   content: isCancellation || isRejection ? sanitizedError : `Error: ${sanitizedError}`,
                   status: isCancellation || isRejection ? "cancelled" : "error"
@@ -410272,7 +410341,7 @@ ${output.result}`;
             const lastActivity = recentActivity[recentActivity.length - 1];
             if (!lastActivity || lastActivity.status !== "error") {
               recentActivity.push({
-                id: randomUUID10(),
+                id: randomUUID9(),
                 type: "thought",
                 content: `Error: ${errorMessage}`,
                 status: "error"
@@ -412221,7 +412290,7 @@ var init_browserAgentFactory = __esm({
 });
 
 // packages/core/dist/src/agents/browser/browserAgentInvocation.js
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 var INPUT_PREVIEW_MAX_LENGTH2, DESCRIPTION_MAX_LENGTH2, MAX_RECENT_ACTIVITY, BrowserAgentInvocation;
 var init_browserAgentInvocation = __esm({
   "packages/core/dist/src/agents/browser/browserAgentInvocation.js"() {
@@ -412289,7 +412358,7 @@ var init_browserAgentInvocation = __esm({
           const printOutput = updateOutput ? (msg) => {
             const sanitizedMsg = sanitizeThoughtContent(msg);
             recentActivity.push({
-              id: randomUUID11(),
+              id: randomUUID10(),
               type: "thought",
               content: sanitizedMsg,
               status: "completed"
@@ -412321,7 +412390,7 @@ var init_browserAgentInvocation = __esm({
                   lastItem.content = sanitizeThoughtContent(text);
                 } else {
                   recentActivity.push({
-                    id: randomUUID11(),
+                    id: randomUUID10(),
                     type: "thought",
                     content: sanitizeThoughtContent(text),
                     status: "running"
@@ -412335,7 +412404,7 @@ var init_browserAgentInvocation = __esm({
                 const displayName = activity.data["displayName"] ? sanitizeErrorMessage(String(activity.data["displayName"])) : void 0;
                 const description = activity.data["description"] ? sanitizeErrorMessage(String(activity.data["description"])) : void 0;
                 const args2 = JSON.stringify(sanitizeToolArgs(activity.data["args"]));
-                const callId = activity.data["callId"] ? String(activity.data["callId"]) : randomUUID11();
+                const callId = activity.data["callId"] ? String(activity.data["callId"]) : randomUUID10();
                 recentActivity.push({
                   id: callId,
                   type: "tool_call",
@@ -412384,7 +412453,7 @@ var init_browserAgentInvocation = __esm({
                 }
                 const sanitizedError = sanitizeErrorMessage(error2);
                 recentActivity.push({
-                  id: randomUUID11(),
+                  id: randomUUID10(),
                   type: "thought",
                   content: isCancellation ? sanitizedError : `Error: ${sanitizedError}`,
                   status: newStatus
@@ -412673,6 +412742,7 @@ var init_subagent_tool = __esm({
         return runInDevTraceSpan({
           operation: GeminiCliOperation.AgentCall,
           logPrompts: this.context.config.getTelemetryLogPromptsEnabled(),
+          sessionId: this.context.config.getSessionId(),
           attributes: {
             [GEN_AI_AGENT_NAME]: this.definition.name,
             [GEN_AI_AGENT_DESCRIPTION]: this.definition.description
@@ -415853,7 +415923,7 @@ var init_envExpansion = __esm({
 // packages/core/dist/src/tools/mcp-client.js
 import { basename as basename10 } from "node:path";
 import { pathToFileURL } from "node:url";
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 function updateMCPServerStatus(serverName, status2) {
   serverStatuses.set(serverName, status2);
   for (const listener of statusChangeListeners) {
@@ -416937,7 +417007,7 @@ var init_mcp_client = __esm({
           throw new Error("McpCallableTool only supports single function call");
         }
         const call = functionCalls[0];
-        const progressToken = randomUUID12();
+        const progressToken = randomUUID11();
         const context2 = getToolCallContext();
         if (context2 && this.progressReporter) {
           this.progressReporter.registerProgressToken(progressToken, context2.callId);
@@ -435958,11 +436028,11 @@ var init_rng3 = __esm({
 });
 
 // packages/core/node_modules/uuid/dist-node/native.js
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 var native_default4;
 var init_native3 = __esm({
   "packages/core/node_modules/uuid/dist-node/native.js"() {
-    native_default4 = { randomUUID: randomUUID13 };
+    native_default4 = { randomUUID: randomUUID12 };
   }
 });
 
@@ -437112,8 +437182,8 @@ var init_config4 = __esm({
       getClientName() {
         return this.clientName;
       }
-      setSessionId(sessionId2) {
-        this._sessionId = sessionId2;
+      setSessionId(sessionId) {
+        this._sessionId = sessionId;
       }
       setTerminalBackground(terminalBackground) {
         this.terminalBackground = terminalBackground;
@@ -439684,6 +439754,45 @@ var init_init2 = __esm({
   }
 });
 
+// packages/core/dist/src/agents/skill-extraction-agent.js
+var SkillExtractionSchema;
+var init_skill_extraction_agent = __esm({
+  "packages/core/dist/src/agents/skill-extraction-agent.js"() {
+    "use strict";
+    init_zod();
+    init_tool_names();
+    init_models();
+    SkillExtractionSchema = external_exports.object({
+      response: external_exports.string().describe("A summary of the skills extracted or updated.")
+    });
+  }
+});
+
+// packages/core/dist/src/services/memoryService.js
+var LOCK_STALE_MS, MIN_IDLE_MS;
+var init_memoryService = __esm({
+  "packages/core/dist/src/services/memoryService.js"() {
+    "use strict";
+    init_chatRecordingService();
+    init_debugLogger();
+    init_events();
+    init_errors2();
+    init_skillLoader();
+    init_local_executor();
+    init_skill_extraction_agent();
+    init_registry();
+    init_executionLifecycleService();
+    init_prompt_registry();
+    init_resource_registry();
+    init_policy_engine();
+    init_types2();
+    init_message_bus();
+    init_storage();
+    LOCK_STALE_MS = 35 * 60 * 1e3;
+    MIN_IDLE_MS = 3 * 60 * 60 * 1e3;
+  }
+});
+
 // packages/core/dist/src/commands/memory.js
 function showMemory(config3) {
   const memoryContent = flattenMemory(config3.getUserMemory());
@@ -439763,7 +439872,10 @@ ${filePaths.join("\n")}`;
 var init_memory2 = __esm({
   "packages/core/dist/src/commands/memory.js"() {
     "use strict";
+    init_storage();
     init_memory();
+    init_skillLoader();
+    init_memoryService();
     init_memoryDiscovery();
   }
 });
@@ -442368,44 +442480,6 @@ var init_sessionSummaryUtils = __esm({
   }
 });
 
-// packages/core/dist/src/agents/skill-extraction-agent.js
-var SkillExtractionSchema;
-var init_skill_extraction_agent = __esm({
-  "packages/core/dist/src/agents/skill-extraction-agent.js"() {
-    "use strict";
-    init_zod();
-    init_tool_names();
-    init_models();
-    SkillExtractionSchema = external_exports.object({
-      response: external_exports.string().describe("A summary of the skills extracted or updated.")
-    });
-  }
-});
-
-// packages/core/dist/src/services/memoryService.js
-var LOCK_STALE_MS, MIN_IDLE_MS;
-var init_memoryService = __esm({
-  "packages/core/dist/src/services/memoryService.js"() {
-    "use strict";
-    init_chatRecordingService();
-    init_debugLogger();
-    init_errors2();
-    init_skillLoader();
-    init_local_executor();
-    init_skill_extraction_agent();
-    init_registry();
-    init_executionLifecycleService();
-    init_prompt_registry();
-    init_resource_registry();
-    init_policy_engine();
-    init_types2();
-    init_message_bus();
-    init_storage();
-    LOCK_STALE_MS = 35 * 60 * 1e3;
-    MIN_IDLE_MS = 3 * 60 * 60 * 1e3;
-  }
-});
-
 // packages/core/dist/src/ide/ide-installer.js
 var init_ide_installer = __esm({
   "packages/core/dist/src/ide/ide-installer.js"() {
@@ -442487,6 +442561,13 @@ ${REFERENCE_CONTENT_END}`;
   }
 });
 
+// packages/core/dist/src/utils/session.js
+var init_session = __esm({
+  "packages/core/dist/src/utils/session.js"() {
+    "use strict";
+  }
+});
+
 // packages/core/dist/src/utils/compatibility.js
 var WarningPriority;
 var init_compatibility = __esm({