@hasna/assistants 1.1.85 → 1.1.86

package/dist/index.js

@@ -25508,9 +25508,9 @@ var init_path_validator = __esm(() => {
 });
 
 // packages/core/src/tools/filesystem.ts
-import { join as join14, resolve as resolve4, dirname as dirname6, sep } from "path";
+import { join as join14, resolve as resolve4, dirname as dirname6, sep, isAbsolute as isAbsolute3 } from "path";
 import { homedir as homedir9 } from "os";
-import { mkdir as mkdir4 } from "fs/promises";
+import { mkdir as mkdir4, copyFile, stat } from "fs/promises";
 function getScriptsFolder(cwd, sessionId) {
   const resolvedSessionId = sessionId || currentSessionId;
   return join14(getProjectDataDir(cwd), "scripts", resolvedSessionId);
@@ -25584,6 +25584,7 @@ var init_filesystem = __esm(async () => {
       registry.register(this.globTool, this.globExecutor);
       registry.register(this.grepTool, this.grepExecutor);
       registry.register(this.readPdfTool, this.readPdfExecutor);
+      registry.register(this.fileCopyTool, this.fileCopyExecutor);
     }
     static setSessionId(sessionId) {
       currentSessionId = sessionId;
@@ -25820,7 +25821,11 @@ var init_filesystem = __esm(async () => {
       const mode = currentWorkspaceConfig.mode || "sandbox";
       let resolvedPath;
       let allowedRoot;
-      if (mode === "sandbox") {
+      const tmpResolved = isAbsolute3(filename) ? resolve4(filename) : null;
+      if (tmpResolved && isWithinDir(tmpResolved, "/tmp")) {
+        resolvedPath = tmpResolved;
+        allowedRoot = "/tmp";
+      } else if (mode === "sandbox") {
         const scriptsFolder = getScriptsFolder(baseCwd, input.sessionId);
         const sanitizedFilename = filename.replace(/\.\.[/\\]/g, "").replace(/\.\./g, "").replace(/^[/\\]+/, "");
         resolvedPath = join14(scriptsFolder, sanitizedFilename);
@@ -26284,6 +26289,247 @@ var init_filesystem = __esm(async () => {
         });
       }
     };
+    static COPY_ALLOWED_SOURCES = [
+      "/tmp",
+      join14(homedir9(), ".connect"),
+      join14(homedir9(), "Downloads")
+    ];
+    static fileCopyTool = {
+      name: "file_copy",
+      description: "Copy a file from an allowed external location into the project workspace. " + "Allowed source locations: /tmp, ~/.connect/*, ~/Downloads, and the project .assistants-data/ directory. " + "The destination must be within the current workspace (sandbox scripts folder, project directory, or custom path depending on workspace.mode).",
+      parameters: {
+        type: "object",
+        properties: {
+          source: {
+            type: "string",
+            description: "Absolute path to the source file (must be in /tmp, ~/.connect, ~/Downloads, or .assistants-data/)"
+          },
+          destination: {
+            type: "string",
+            description: "Destination path within the workspace (relative or absolute)"
+          },
+          cwd: {
+            type: "string",
+            description: "Base working directory for the project (optional)"
+          }
+        },
+        required: ["source", "destination"]
+      }
+    };
+    static fileCopyExecutor = async (input) => {
+      const baseCwd = input.cwd || process.cwd();
+      const rawSource = String(input.source || "").trim();
+      const rawDestination = String(input.destination || "").trim();
+      if (!rawSource) {
+        throw new ToolExecutionError("Source path is required", {
+          toolName: "file_copy",
+          toolInput: input,
+          code: ErrorCodes.VALIDATION_OUT_OF_RANGE,
+          recoverable: false,
+          retryable: false,
+          suggestion: "Provide an absolute path to the source file."
+        });
+      }
+      if (!rawDestination) {
+        throw new ToolExecutionError("Destination path is required", {
+          toolName: "file_copy",
+          toolInput: input,
+          code: ErrorCodes.VALIDATION_OUT_OF_RANGE,
+          recoverable: false,
+          retryable: false,
+          suggestion: "Provide a destination path within the workspace."
+        });
+      }
+      const sourcePath = FilesystemTools.resolveInputPath(baseCwd, rawSource);
+      const allowedSources = [
+        ...FilesystemTools.COPY_ALLOWED_SOURCES,
+        getProjectDataDir(baseCwd)
+      ];
+      let sourceAllowed = false;
+      for (const allowed of allowedSources) {
+        if (isWithinDir(sourcePath, allowed)) {
+          sourceAllowed = true;
+          break;
+        }
+      }
+      if (!sourceAllowed) {
+        getSecurityLogger().log({
+          eventType: "path_violation",
+          severity: "high",
+          details: {
+            tool: "file_copy",
+            path: sourcePath,
+            reason: "Source path not in allowed locations"
+          },
+          sessionId: input.sessionId || "unknown"
+        });
+        throw new ToolExecutionError(`Source path is not in an allowed location. Allowed: /tmp, ~/.connect, ~/Downloads, .assistants-data/. Got: ${sourcePath}`, {
+          toolName: "file_copy",
+          toolInput: input,
+          code: ErrorCodes.TOOL_PERMISSION_DENIED,
+          recoverable: false,
+          retryable: false,
+          suggestion: "Copy files only from /tmp, ~/.connect/*, ~/Downloads, or .assistants-data/."
+        });
+      }
+      const sourceSafety = await isPathSafe(sourcePath, "read", { cwd: baseCwd, allowedPaths: allowedSources });
+      if (!sourceSafety.safe) {
+        getSecurityLogger().log({
+          eventType: "path_violation",
+          severity: "high",
+          details: {
+            tool: "file_copy",
+            path: sourcePath,
+            reason: sourceSafety.reason || "Blocked source path"
+          },
+          sessionId: input.sessionId || "unknown"
+        });
+        throw new ToolExecutionError(sourceSafety.reason || "Blocked source path", {
+          toolName: "file_copy",
+          toolInput: input,
+          code: ErrorCodes.TOOL_PERMISSION_DENIED,
+          recoverable: false,
+          retryable: false
+        });
+      }
+      try {
+        const srcStat = await stat(sourcePath);
+        if (!srcStat.isFile()) {
+          throw new ToolExecutionError(`Source is not a file: ${sourcePath}`, {
+            toolName: "file_copy",
+            toolInput: input,
+            code: ErrorCodes.TOOL_EXECUTION_FAILED,
+            recoverable: false,
+            retryable: false,
+            suggestion: "Provide a path to a regular file, not a directory."
+          });
+        }
+      } catch (error2) {
+        if (error2 instanceof ToolExecutionError)
+          throw error2;
+        throw new ToolExecutionError(`Source file not found: ${sourcePath}`, {
+          toolName: "file_copy",
+          toolInput: input,
+          code: ErrorCodes.TOOL_EXECUTION_FAILED,
+          recoverable: false,
+          retryable: false,
+          suggestion: "Check the source file path and try again."
+        });
+      }
+      const mode = currentWorkspaceConfig.mode || "sandbox";
+      let resolvedDest;
+      let allowedRoot;
+      if (mode === "sandbox") {
+        const scriptsFolder = getScriptsFolder(baseCwd, input.sessionId);
+        const sanitizedDest = rawDestination.replace(/\.\.[/\\]/g, "").replace(/\.\./g, "").replace(/^[/\\]+/, "");
+        resolvedDest = join14(scriptsFolder, sanitizedDest);
+        allowedRoot = scriptsFolder;
+        if (!isInScriptsFolder(resolvedDest, baseCwd, input.sessionId)) {
+          throw new ToolExecutionError(`Cannot copy outside scripts folder. Files are saved to ${scriptsFolder}`, {
+            toolName: "file_copy",
+            toolInput: input,
+            code: ErrorCodes.TOOL_PERMISSION_DENIED,
+            recoverable: false,
+            retryable: false,
+            suggestion: "Copy only within the project scripts folder."
+          });
+        }
+      } else if (mode === "project") {
+        resolvedDest = FilesystemTools.resolveInputPath(baseCwd, rawDestination);
+        allowedRoot = resolve4(baseCwd);
+        if (!isWithinDir(resolvedDest, allowedRoot)) {
+          throw new ToolExecutionError(`Cannot copy outside the project directory (${allowedRoot}).`, {
+            toolName: "file_copy",
+            toolInput: input,
+            code: ErrorCodes.TOOL_PERMISSION_DENIED,
+            recoverable: false,
+            retryable: false,
+            suggestion: "Provide a destination within the project directory."
+          });
+        }
+      } else if (mode === "custom") {
+        const customPath = currentWorkspaceConfig.customPath;
+        if (!customPath) {
+          throw new ToolExecutionError('Workspace mode is "custom" but no customPath is configured.', {
+            toolName: "file_copy",
+            toolInput: input,
+            code: ErrorCodes.TOOL_EXECUTION_FAILED,
+            recoverable: false,
+            retryable: false,
+            suggestion: "Set workspace.customPath to an absolute path in config."
+          });
+        }
+        allowedRoot = resolve4(customPath);
+        resolvedDest = FilesystemTools.resolveInputPath(allowedRoot, rawDestination);
+        if (!isWithinDir(resolvedDest, allowedRoot)) {
+          throw new ToolExecutionError(`Cannot copy outside the custom workspace (${allowedRoot}).`, {
+            toolName: "file_copy",
+            toolInput: input,
+            code: ErrorCodes.TOOL_PERMISSION_DENIED,
+            recoverable: false,
+            retryable: false,
+            suggestion: `Provide a destination within ${allowedRoot}.`
+          });
+        }
+      } else {
+        throw new ToolExecutionError(`Unknown workspace mode: "${mode}".`, {
+          toolName: "file_copy",
+          toolInput: input,
+          code: ErrorCodes.VALIDATION_OUT_OF_RANGE,
+          recoverable: false,
+          retryable: false
+        });
+      }
+      const dangerousReason = isDangerousPath(resolvedDest);
+      if (dangerousReason) {
+        throw new ToolExecutionError(dangerousReason, {
+          toolName: "file_copy",
+          toolInput: input,
+          code: ErrorCodes.TOOL_PERMISSION_DENIED,
+          recoverable: false,
+          retryable: false,
+          suggestion: "Choose a different destination that avoids system directories."
+        });
+      }
+      const destSafety = await isPathSafe(resolvedDest, "write", { cwd: baseCwd });
+      if (!destSafety.safe) {
+        getSecurityLogger().log({
+          eventType: "path_violation",
+          severity: "high",
+          details: {
+            tool: "file_copy",
+            path: resolvedDest,
+            reason: destSafety.reason || "Blocked destination path"
+          },
+          sessionId: input.sessionId || "unknown"
+        });
+        throw new ToolExecutionError(destSafety.reason || "Blocked destination path", {
+          toolName: "file_copy",
+          toolInput: input,
+          code: ErrorCodes.TOOL_PERMISSION_DENIED,
+          recoverable: false,
+          retryable: false
+        });
+      }
+      try {
+        const destDir = dirname6(resolvedDest);
+        await mkdir4(destDir, { recursive: true });
+        await copyFile(sourcePath, resolvedDest);
+        const srcStat = await stat(resolvedDest);
+        const sizeKB = (srcStat.size / 1024).toFixed(1);
+        return `Successfully copied ${sourcePath} \u2192 ${resolvedDest} (${sizeKB} KB)`;
+      } catch (error2) {
+        if (error2 instanceof ToolExecutionError)
+          throw error2;
+        throw new ToolExecutionError(error2 instanceof Error ? error2.message : String(error2), {
+          toolName: "file_copy",
+          toolInput: input,
+          code: ErrorCodes.TOOL_EXECUTION_FAILED,
+          recoverable: true,
+          retryable: false
+        });
+      }
+    };
   };
 });
 
@@ -26359,6 +26605,89 @@ var init_fetch_with_timeout = __esm(() => {
   init_errors();
 });
 
+// packages/core/src/features.ts
+function isAWSConfigured() {
+  return !!(process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY);
+}
+function isElevenLabsConfigured() {
+  return !!process.env.ELEVENLABS_API_KEY;
+}
+function isOpenAIConfigured() {
+  return !!process.env.OPENAI_API_KEY;
+}
+function isAnyLLMConfigured() {
+  return LLM_PROVIDERS.some((provider) => !!process.env[provider.apiKeyEnv]);
+}
+function isExaConfigured() {
+  return !!process.env.EXA_API_KEY;
+}
+function isSystemVoiceAvailable() {
+  return process.platform === "darwin";
+}
+function getFeatureAvailability() {
+  return {
+    coreChat: isAnyLLMConfigured(),
+    awsFeatures: isAWSConfigured(),
+    elevenLabsTTS: isElevenLabsConfigured(),
+    whisperSTT: isOpenAIConfigured(),
+    exaSearch: isExaConfigured(),
+    systemVoice: isSystemVoiceAvailable()
+  };
+}
+function getFeatureStatusMessage() {
+  const features = getFeatureAvailability();
+  const lines = [];
+  if (!features.coreChat) {
+    lines.push("\u26A0\uFE0F  ANTHROPIC_API_KEY not set - core chat disabled");
+  } else {
+    lines.push("\u2713 Core chat enabled");
+  }
+  if (features.awsFeatures) {
+    lines.push("\u2713 AWS features available (inbox, wallet, secrets)");
+  } else {
+    lines.push("\u25CB AWS features disabled (set AWS_REGION to enable)");
+  }
+  if (features.elevenLabsTTS) {
+    lines.push("\u2713 ElevenLabs TTS available");
+  }
+  if (features.whisperSTT) {
+    lines.push("\u2713 Whisper STT available");
+  }
+  if (features.systemVoice) {
+    lines.push("\u2713 System voice available (macOS)");
+  }
+  if (features.exaSearch) {
+    lines.push("\u2713 Exa enhanced search available");
+  }
+  return lines.join(`
+`);
+}
+function validateFeatureEnvVars(config) {
+  const warnings = [];
+  if (config.inbox?.enabled && !isAWSConfigured()) {
+    warnings.push("inbox.enabled is true but AWS credentials are not configured");
+  }
+  if (config.wallet?.enabled && !isAWSConfigured()) {
+    warnings.push("wallet.enabled is true but AWS credentials are not configured");
+  }
+  const secretsProvider = config.secrets?.storage?.provider || "local";
+  if (config.secrets?.enabled && secretsProvider === "aws" && !isAWSConfigured()) {
+    warnings.push("secrets.enabled is true but AWS credentials are not configured");
+  }
+  if (config.voice?.enabled) {
+    if (config.voice.tts?.provider === "elevenlabs" && !isElevenLabsConfigured()) {
+      warnings.push("voice.tts.provider is elevenlabs but ELEVENLABS_API_KEY is not set");
+    }
+    if (config.voice.stt?.provider === "whisper" && !isOpenAIConfigured()) {
+      warnings.push("voice.stt.provider is whisper but OPENAI_API_KEY is not set");
+    }
+  }
+  return warnings;
+}
+var init_features = __esm(() => {
+  init_src2();
+});
+
 // packages/core/src/tools/web.ts
 async function readResponseWithLimit(response, maxBytes = MAX_RESPONSE_BYTES) {
   const reader = response.body?.getReader();
@@ -26437,7 +26766,65 @@ function parseDuckDuckGoResults(html, maxResults) {
 }
 function isLikelyBotChallenge(html) {
   const lower = html.toLowerCase();
-  return lower.includes("anomaly.js") || lower.includes("anomaly-modal") || lower.includes("challenge-form");
+  return lower.includes("anomaly.js") || lower.includes("anomaly-modal") || lower.includes("challenge-form") || lower.includes("bots use duckduckgo") || lower.includes("challenge to confirm") || lower.includes("select all squares") || lower.includes("anomaly/images/challenge");
+}
+function formatSearchResults(query, results) {
+  let output = `Search results for "${query}":
+
+`;
+  for (let i = 0;i < results.length; i++) {
+    const r = results[i];
+    output += `${i + 1}. ${r.title}
+`;
+    output += `   ${r.url}
+`;
+    if (r.snippet) {
+      output += `   ${r.snippet}
+`;
+    }
+    output += `
+`;
+  }
+  return output.trim();
+}
+async function fetchExaSearchResults(query, maxResults, timeout, signal) {
+  const apiKey = process.env.EXA_API_KEY;
+  if (!apiKey)
+    return [];
+  try {
+    const response = await fetchWithTimeout("https://api.exa.ai/search", {
+      timeout,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        Accept: "application/json"
+      },
+      body: JSON.stringify({
+        query,
+        numResults: maxResults,
+        type: "keyword",
+        contents: {
+          text: { maxCharacters: 200 }
+        }
+      }),
+      signal,
+      toolName: "web_search",
+      toolInput: { query }
+    });
+    if (!response.ok)
+      return [];
+    const data = await response.json();
+    if (!data.results || !Array.isArray(data.results))
+      return [];
+    return data.results.filter((r) => r.url && r.title).slice(0, maxResults).map((r) => ({
+      title: (r.title || "").trim(),
+      url: (r.url || "").trim(),
+      snippet: (r.text || "").trim()
+    }));
+  } catch {
+    return [];
+  }
 }
 async function fetchInstantAnswerResults(query, maxResults, timeout, signal) {
   const apiUrl = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&skip_disambig=1`;
@@ -26526,6 +26913,7 @@ var init_web = __esm(() => {
   init_errors();
   init_network_validator();
   init_fetch_with_timeout();
+  init_features();
   MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
   WebFetchTool = class WebFetchTool {
     static tool = {
@@ -26764,12 +27152,19 @@ var init_web = __esm(() => {
       const timeoutInput = Number(input.timeout);
       const timeout = Number.isFinite(timeoutInput) && timeoutInput > 0 ? timeoutInput : 15000;
       try {
+        if (isExaConfigured()) {
+          const exaResults = await fetchExaSearchResults(query, maxResults, timeout, signal);
+          if (exaResults.length > 0) {
+            return formatSearchResults(query, exaResults);
+          }
+        }
         const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
         const response = await fetchWithTimeout(searchUrl, {
           timeout,
           headers: {
-            "User-Agent": "assistants/1.0 (AI Assistant)",
-            Accept: "text/html"
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+            Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            "Accept-Language": "en-US,en;q=0.9"
           },
           signal,
           toolName: "web_search",
@@ -26793,25 +27188,12 @@ var init_web = __esm(() => {
           }
         }
         if (results.length === 0) {
-          return `No results found for "${query}"`;
-        }
-        let output = `Search results for "${query}":
-
-`;
-        for (let i = 0;i < results.length; i++) {
-          const r = results[i];
-          output += `${i + 1}. ${r.title}
-`;
-          output += `   ${r.url}
-`;
-          if (r.snippet) {
-            output += `   ${r.snippet}
-`;
+          if (isLikelyBotChallenge(html)) {
+            return `Web search is currently blocked by DuckDuckGo's bot protection. To enable reliable web search, set EXA_API_KEY in your environment (~/.secrets). Get a key at https://exa.ai`;
           }
-          output += `
-`;
+          return `No results found for "${query}". For more reliable search, set EXA_API_KEY in your environment (~/.secrets). Get a key at https://exa.ai`;
         }
-        return output.trim();
+        return formatSearchResults(query, results);
       } catch (error2) {
         if (error2 instanceof ToolExecutionError)
           throw error2;
@@ -44632,7 +45014,7 @@ var require_gray_matter = __commonJS((exports, module) => {
 // packages/core/src/tools/markdown.ts
 import { resolve as resolve6, join as join18 } from "path";
 import { homedir as homedir12 } from "os";
-import { writeFile as writeFile2, stat } from "fs/promises";
+import { writeFile as writeFile2, stat as stat2 } from "fs/promises";
 function resolveInputPath2(baseCwd, inputPath) {
   const envHome = process.env.HOME || process.env.USERPROFILE;
   const home = envHome && envHome.trim().length > 0 ? envHome : homedir12();
@@ -45403,7 +45785,7 @@ ${newContent}
           regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
         }
         const matches = [];
-        const fileStat = await stat(resolvedPath);
+        const fileStat = await stat2(resolvedPath);
         const files = [];
         if (fileStat.isDirectory()) {
           for await (const file of runtime.glob(globPattern, { cwd: resolvedPath })) {
@@ -45638,7 +46020,7 @@ ${newContent}
       try {
         const resolvedPath = await resolveAndValidate(rawPath, baseCwd, "md_outline", input);
         const runtime = getRuntime();
-        const fileStat = await stat(resolvedPath);
+        const fileStat = await stat2(resolvedPath);
         const files = [];
         if (fileStat.isDirectory()) {
           for await (const file of runtime.glob(globPattern, { cwd: resolvedPath })) {
@@ -47224,7 +47606,7 @@ var init_workflows2 = __esm(async () => {
 // packages/core/src/skills/create.ts
 import { join as join19, dirname as dirname8 } from "path";
 import { homedir as homedir15 } from "os";
-import { mkdir as mkdir5, stat as stat2, writeFile as writeFile3, rm } from "fs/promises";
+import { mkdir as mkdir5, stat as stat3, writeFile as writeFile3, rm } from "fs/promises";
 function slugify(input) {
   return input.trim().toLowerCase().replace(/[^a-z0-9\s_-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
@@ -47286,7 +47668,7 @@ function resolveSkillRoot(scope, cwd) {
 }
 async function pathExists(path3) {
   try {
-    const stats = await stat2(path3);
+    const stats = await stat3(path3);
     return stats.isFile() || stats.isDirectory();
   } catch {
     return false;
@@ -47383,7 +47765,7 @@ var init_executor3 = __esm(async () => {
 // packages/core/src/skills/installer.ts
 import { join as join20 } from "path";
 import { homedir as homedir16 } from "os";
-import { mkdir as mkdir6, readFile as readFile4, writeFile as writeFile4, stat as stat3 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile4, writeFile as writeFile4, stat as stat4 } from "fs/promises";
 function resolveSkillRoot2(scope, cwd) {
   if (scope === "global") {
     return join20(homedir16(), ".skill");
@@ -47394,14 +47776,14 @@ async function ensurePackageJson(dir) {
   await mkdir6(dir, { recursive: true });
   const pkgPath = join20(dir, "package.json");
   try {
-    await stat3(pkgPath);
+    await stat4(pkgPath);
   } catch {
     await writeFile4(pkgPath, JSON.stringify({ name: "assistants-skills", private: true, dependencies: {} }, null, 2) + `
 `);
   }
   const gitignorePath = join20(dir, ".gitignore");
   try {
-    await stat3(gitignorePath);
+    await stat4(gitignorePath);
   } catch {
     await writeFile4(gitignorePath, `node_modules/
 `);
@@ -48187,8 +48569,84 @@ var init_wait = __esm(() => {
   };
 });
 
+// packages/core/src/tools/notify.ts
+import { exec } from "child_process";
+function escapeShellArg(str3) {
+  return str3.replace(/'/g, "'\\''");
+}
+function buildCommand(input) {
+  const platform2 = process.platform;
+  const title = escapeShellArg(input.title);
+  const message = escapeShellArg(input.message);
+  if (platform2 === "darwin") {
+    const soundClause = input.sound ? ' sound name "default"' : "";
+    return `osascript -e 'display notification "${message}" with title "${title}"${soundClause}'`;
+  }
+  if (platform2 === "linux") {
+    return `notify-send '${title}' '${message}'`;
+  }
+  if (platform2 === "win32") {
+    const ps = `[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms') | Out-Null; ` + `$n = New-Object System.Windows.Forms.NotifyIcon; ` + `$n.Icon = [System.Drawing.SystemIcons]::Information; ` + `$n.Visible = $true; ` + `$n.ShowBalloonTip(5000, '${title}', '${message}', 'Info')`;
+    return `powershell -Command "${ps.replace(/"/g, "\\\"")}"`;
+  }
+  throw new Error(`Unsupported platform: ${platform2}`);
+}
+function execAsync(command) {
+  return new Promise((resolve9, reject) => {
+    exec(command, { timeout: 1e4 }, (error2, stdout, stderr) => {
+      if (error2) {
+        reject(error2);
+      } else {
+        resolve9({ stdout, stderr });
+      }
+    });
+  });
+}
+var NotifyTool;
+var init_notify = __esm(() => {
+  NotifyTool = class NotifyTool {
+    static tool = {
+      name: "notify",
+      description: "Send a native desktop notification. Works on macOS (osascript), Linux (notify-send), and Windows (PowerShell).",
+      parameters: {
+        type: "object",
+        properties: {
+          title: {
+            type: "string",
+            description: "Notification title"
+          },
+          message: {
+            type: "string",
+            description: "Notification message body"
+          },
+          sound: {
+            type: "boolean",
+            description: "Play a sound with the notification (macOS only)",
+            default: false
+          }
+        },
+        required: ["title", "message"]
+      }
+    };
+    static executor = async (input) => {
+      const notifyInput = {
+        title: String(input.title || "Notification"),
+        message: String(input.message || ""),
+        sound: input.sound === true
+      };
+      try {
+        const command = buildCommand(notifyInput);
+        await execAsync(command);
+        return `Notification sent: "${notifyInput.title}" \u2014 ${notifyInput.message}`;
+      } catch (error2) {
+        return `Error sending notification: ${error2 instanceof Error ? error2.message : String(error2)}`;
+      }
+    };
+  };
+});
+
 // packages/core/src/tools/tmux.ts
-async function exec(args) {
+async function exec2(args) {
   const runtime = getRuntime();
   const proc = runtime.spawn(["tmux", ...args], {
     stdout: "pipe",
@@ -48310,12 +48768,12 @@ var init_tmux = __esm(async () => {
           if (command) {
             args.push(command);
           }
-          await exec(args);
+          await exec2(args);
           return `Session "${name}" created${cwd ? ` in ${cwd}` : ""}`;
         }
         case "list_sessions": {
           try {
-            const out = await exec(["list-sessions", "-F", "#{session_name}: #{session_windows} windows (created #{session_created_string})#{?session_attached, (attached),}"]);
+            const out = await exec2(["list-sessions", "-F", "#{session_name}: #{session_windows} windows (created #{session_created_string})#{?session_attached, (attached),}"]);
             const lines2 = out.trim().split(`
 `);
             const assistantSessions = lines2.filter((l) => l.startsWith(SESSION_PREFIX));
@@ -48332,7 +48790,7 @@ var init_tmux = __esm(async () => {
           if (!session)
             throw toolError("tmux", "session name is required for kill_session");
           const name = prefixed(session);
-          await exec(["kill-session", "-t", name]);
+          await exec2(["kill-session", "-t", name]);
           return `Session "${name}" killed.`;
         }
         case "send_command": {
@@ -48344,12 +48802,12 @@ var init_tmux = __esm(async () => {
           if (wait) {
             const marker = `asst-done-${Date.now()}`;
             const wrappedCmd = `${command}; tmux wait-for -S ${marker}`;
-            await exec(["send-keys", "-t", t, wrappedCmd, "Enter"]);
-            await exec(["wait-for", marker]);
-            const out = await exec(["capture-pane", "-t", t, "-pJ", "-S", "-50"]);
+            await exec2(["send-keys", "-t", t, wrappedCmd, "Enter"]);
+            await exec2(["wait-for", marker]);
+            const out = await exec2(["capture-pane", "-t", t, "-pJ", "-S", "-50"]);
             return out.trim() || "Command completed (no output).";
           }
-          await exec(["send-keys", "-t", t, command, "Enter"]);
+          await exec2(["send-keys", "-t", t, command, "Enter"]);
           return `Command sent to ${t}.`;
         }
         case "capture_output": {
@@ -48357,7 +48815,7 @@ var init_tmux = __esm(async () => {
             throw toolError("tmux", "target is required for capture_output");
           const t = prefixTarget(target);
           const startLine = -Math.abs(lines);
-          const out = await exec(["capture-pane", "-t", t, "-pJ", "-S", String(startLine)]);
+          const out = await exec2(["capture-pane", "-t", t, "-pJ", "-S", String(startLine)]);
           const trimmed = out.trim();
           return trimmed || "(empty \u2014 no output in scrollback)";
         }
@@ -48365,7 +48823,7 @@ var init_tmux = __esm(async () => {
           if (!target)
             throw toolError("tmux", "target is required for get_status");
           const t = prefixTarget(target);
-          const out = await exec([
+          const out = await exec2([
             "display-message",
             "-t",
             t,
@@ -48385,14 +48843,14 @@ var init_tmux = __esm(async () => {
           if (cwd) {
             args.push("-c", cwd);
           }
-          await exec(args);
+          await exec2(args);
           return `Window${windowName ? ` "${windowName}"` : ""} created in session "${name}".`;
         }
         case "list_windows": {
           if (!session)
             throw toolError("tmux", "session name is required for list_windows");
           const name = prefixed(session);
-          const out = await exec([
+          const out = await exec2([
             "list-windows",
             "-t",
             name,
@@ -48405,7 +48863,7 @@ var init_tmux = __esm(async () => {
           if (!target)
             throw toolError("tmux", "target is required for list_panes");
           const t = prefixTarget(target);
-          const out = await exec([
+          const out = await exec2([
             "list-panes",
             "-t",
             t,
@@ -48423,14 +48881,14 @@ var init_tmux = __esm(async () => {
           if (cwd) {
             args.push("-c", cwd);
           }
-          await exec(args);
+          await exec2(args);
           return `Pane split ${direction}ly in ${t}.`;
         }
         case "interrupt": {
           if (!target)
             throw toolError("tmux", "target is required for interrupt");
           const t = prefixTarget(target);
-          await exec(["send-keys", "-t", t, "C-c", ""]);
+          await exec2(["send-keys", "-t", t, "C-c", ""]);
           return `Ctrl+C sent to ${t}.`;
         }
         default:
@@ -48440,9 +48898,224 @@ var init_tmux = __esm(async () => {
   };
 });
 
+// packages/core/src/tools/diff.ts
+import { resolve as resolve9 } from "path";
+import { homedir as homedir17 } from "os";
+function resolveInputPath4(inputPath) {
+  const envHome = process.env.HOME || process.env.USERPROFILE;
+  const home = envHome && envHome.trim().length > 0 ? envHome : homedir17();
+  if (inputPath === "~") {
+    return home;
+  }
+  if (inputPath.startsWith("~/")) {
+    return resolve9(home, inputPath.slice(2));
+  }
+  return resolve9(inputPath);
+}
+async function runDiff(runtime, args, signal) {
+  const proc = runtime.spawn(["diff", ...args], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  let aborted = false;
+  let handleAbort = null;
+  if (signal) {
+    handleAbort = () => {
+      aborted = true;
+      proc.kill();
+    };
+    signal.addEventListener("abort", handleAbort, { once: true });
+  }
+  try {
+    const [stdout, stderr] = await Promise.all([
+      proc.stdout ? new Response(proc.stdout).text() : "",
+      proc.stderr ? new Response(proc.stderr).text() : ""
+    ]);
+    const exitCode = await proc.exited;
+    if (aborted) {
+      throw new ToolExecutionError("Diff aborted.", {
+        toolName: "diff",
+        toolInput: {},
+        code: ErrorCodes.TOOL_EXECUTION_FAILED,
+        recoverable: false,
+        retryable: true
+      });
+    }
+    if (exitCode === 0) {
+      return "Files are identical \u2014 no differences found.";
+    }
+    if (exitCode === 1) {
+      return stdout;
+    }
+    throw new ToolExecutionError(`diff failed: ${stderr || stdout}`.trim(), {
+      toolName: "diff",
+      toolInput: {},
+      code: ErrorCodes.TOOL_EXECUTION_FAILED,
+      recoverable: false,
+      retryable: false
+    });
+  } finally {
+    if (signal && handleAbort) {
+      signal.removeEventListener("abort", handleAbort);
+    }
+  }
+}
+async function runDiffWithStdin(runtime, args, stdinContent, signal) {
+  const proc = runtime.spawn(["diff", ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "pipe"
+  });
+  let aborted = false;
+  let handleAbort = null;
+  if (signal) {
+    handleAbort = () => {
+      aborted = true;
+      proc.kill();
+    };
+    signal.addEventListener("abort", handleAbort, { once: true });
+  }
+  try {
+    if (proc.stdin) {
+      const writer = proc.stdin.getWriter();
+      await writer.write(new TextEncoder().encode(stdinContent));
+      await writer.close();
+    }
+    const [stdout, stderr] = await Promise.all([
+      proc.stdout ? new Response(proc.stdout).text() : "",
+      proc.stderr ? new Response(proc.stderr).text() : ""
+    ]);
+    const exitCode = await proc.exited;
+    if (aborted) {
+      throw new ToolExecutionError("Diff aborted.", {
+        toolName: "diff",
+        toolInput: {},
+        code: ErrorCodes.TOOL_EXECUTION_FAILED,
+        recoverable: false,
+        retryable: true
+      });
+    }
+    if (exitCode === 0) {
+      return "Content is identical to file \u2014 no differences found.";
+    }
+    if (exitCode === 1) {
+      return stdout;
+    }
+    throw new ToolExecutionError(`diff failed: ${stderr || stdout}`.trim(), {
+      toolName: "diff",
+      toolInput: {},
+      code: ErrorCodes.TOOL_EXECUTION_FAILED,
+      recoverable: false,
+      retryable: false
+    });
+  } finally {
+    if (signal && handleAbort) {
+      signal.removeEventListener("abort", handleAbort);
+    }
+  }
+}
+var diffTool, diffExecutor = async (input, signal) => {
+  const fileA = input.file_a;
+  const fileB = input.file_b;
+  const contentB = input.content_b;
+  const contextLines = typeof input.context_lines === "number" ? Math.max(0, Math.round(input.context_lines)) : 3;
+  if (!fileA) {
+    throw new ToolExecutionError("file_a is required.", {
+      toolName: "diff",
+      toolInput: input,
+      code: ErrorCodes.VALIDATION_SCHEMA_ERROR,
+      recoverable: false,
+      retryable: false,
+      suggestion: "Provide file_a as an absolute or relative path."
+    });
+  }
+  if (!fileB && contentB === undefined) {
+    throw new ToolExecutionError("Either file_b or content_b must be provided.", {
+      toolName: "diff",
+      toolInput: input,
+      code: ErrorCodes.VALIDATION_SCHEMA_ERROR,
+      recoverable: false,
+      retryable: false,
+      suggestion: "Provide file_b (path to second file) or content_b (string to compare against)."
+    });
+  }
+  if (fileB && contentB !== undefined) {
+    throw new ToolExecutionError("Provide either file_b or content_b, not both.", {
+      toolName: "diff",
+      toolInput: input,
+      code: ErrorCodes.VALIDATION_SCHEMA_ERROR,
+      recoverable: false,
+      retryable: false,
+      suggestion: "Use file_b to compare two files, or content_b to compare a file against a string."
+    });
+  }
+  const resolvedA = resolveInputPath4(fileA);
+  const safetyA = await isPathSafe(resolvedA, "read");
+  if (!safetyA.safe) {
+    throw new ToolExecutionError(`Cannot read file_a: ${safetyA.reason}`, {
+      toolName: "diff",
+      toolInput: input,
+      code: ErrorCodes.TOOL_PERMISSION_DENIED,
+      recoverable: false,
+      retryable: false
+    });
+  }
+  const runtime = getRuntime();
+  if (fileB) {
+    const resolvedB = resolveInputPath4(fileB);
+    const safetyB = await isPathSafe(resolvedB, "read");
+    if (!safetyB.safe) {
+      throw new ToolExecutionError(`Cannot read file_b: ${safetyB.reason}`, {
+        toolName: "diff",
+        toolInput: input,
+        code: ErrorCodes.TOOL_PERMISSION_DENIED,
+        recoverable: false,
+        retryable: false
+      });
+    }
+    return runDiff(runtime, ["-u", `-U${contextLines}`, resolvedA, resolvedB], signal);
+  }
+  return runDiffWithStdin(runtime, ["-u", `-U${contextLines}`, resolvedA, "-"], contentB, signal);
+}, DiffTool;
+var init_diff = __esm(async () => {
+  init_errors();
+  init_path_validator();
+  await init_runtime();
+  diffTool = {
+    name: "diff",
+    description: "Compare two files and show differences in unified diff format. " + "Provide file_a and file_b to compare two files, or file_a and content_b to compare a file against a string.",
+    parameters: {
+      type: "object",
+      properties: {
+        file_a: {
+          type: "string",
+          description: "Path to the first file (required)."
+        },
+        file_b: {
+          type: "string",
+          description: "Path to the second file. Mutually exclusive with content_b."
+        },
+        content_b: {
+          type: "string",
+          description: "String content to compare against file_a. Mutually exclusive with file_b."
+        },
+        context_lines: {
+          type: "number",
+          description: "Number of context lines around changes (default: 3)."
+        }
+      },
+      required: ["file_a"]
+    }
+  };
+  DiffTool = class DiffTool {
+    static tool = diffTool;
+    static executor = diffExecutor;
+  };
+});
+
 // packages/core/src/agent/subagent.ts
 function sleepSafe(ms) {
-  return new Promise((resolve9) => safeSetTimeout(resolve9, ms));
+  return new Promise((resolve10) => safeSetTimeout(resolve10, ms));
 }
 async function runHookAssistant(options2) {
   const { hook, input, timeout, cwd, allowedTools, llmClient } = options2;
@@ -51571,7 +52244,7 @@ var require_pattern2 = __commonJS((exports) => {
     const absolute = [];
     const relative3 = [];
     for (const pattern of patterns) {
-      if (isAbsolute3(pattern)) {
+      if (isAbsolute4(pattern)) {
         absolute.push(pattern);
       } else {
         relative3.push(pattern);
@@ -51580,10 +52253,10 @@ var require_pattern2 = __commonJS((exports) => {
     return [absolute, relative3];
   }
   exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
-  function isAbsolute3(pattern) {
+  function isAbsolute4(pattern) {
     return path3.isAbsolute(pattern);
   }
-  exports.isAbsolute = isAbsolute3;
+  exports.isAbsolute = isAbsolute4;
 });
 
 // node_modules/.pnpm/merge2@1.4.1/node_modules/merge2/index.js
@@ -51853,7 +52526,7 @@ var require_async = __commonJS((exports) => {
         callSuccessCallback(callback, lstat3);
         return;
       }
-      settings.fs.stat(path3, (statError, stat4) => {
+      settings.fs.stat(path3, (statError, stat5) => {
         if (statError !== null) {
           if (settings.throwErrorOnBrokenSymbolicLink) {
             callFailureCallback(callback, statError);
@@ -51863,9 +52536,9 @@ var require_async = __commonJS((exports) => {
           return;
         }
         if (settings.markSymbolicLink) {
-          stat4.isSymbolicLink = () => true;
+          stat5.isSymbolicLink = () => true;
         }
-        callSuccessCallback(callback, stat4);
+        callSuccessCallback(callback, stat5);
       });
     });
   }
@@ -51888,11 +52561,11 @@ var require_sync = __commonJS((exports) => {
       return lstat3;
     }
     try {
-      const stat4 = settings.fs.statSync(path3);
+      const stat5 = settings.fs.statSync(path3);
       if (settings.markSymbolicLink) {
-        stat4.isSymbolicLink = () => true;
+        stat5.isSymbolicLink = () => true;
       }
-      return stat4;
+      return stat5;
     } catch (error2) {
       if (!settings.throwErrorOnBrokenSymbolicLink) {
         return lstat3;
@@ -51951,14 +52624,14 @@ var require_out = __commonJS((exports) => {
   var sync = require_sync();
   var settings_1 = require_settings();
   exports.Settings = settings_1.default;
-  function stat4(path3, optionsOrSettingsOrCallback, callback) {
+  function stat5(path3, optionsOrSettingsOrCallback, callback) {
     if (typeof optionsOrSettingsOrCallback === "function") {
       async.read(path3, getSettings(), optionsOrSettingsOrCallback);
       return;
     }
     async.read(path3, getSettings(optionsOrSettingsOrCallback), callback);
   }
-  exports.stat = stat4;
+  exports.stat = stat5;
   function statSync4(path3, optionsOrSettings) {
     const settings = getSettings(optionsOrSettings);
     return sync.read(path3, settings);
@@ -52599,42 +53272,42 @@ var require_queue = __commonJS((exports, module) => {
     queue.drained = drained;
     return queue;
     function push2(value2) {
-      var p = new Promise(function(resolve9, reject) {
+      var p = new Promise(function(resolve10, reject) {
         pushCb(value2, function(err, result) {
           if (err) {
             reject(err);
             return;
           }
-          resolve9(result);
+          resolve10(result);
         });
       });
       p.catch(noop2);
       return p;
     }
     function unshift(value2) {
-      var p = new Promise(function(resolve9, reject) {
+      var p = new Promise(function(resolve10, reject) {
         unshiftCb(value2, function(err, result) {
           if (err) {
             reject(err);
             return;
           }
-          resolve9(result);
+          resolve10(result);
         });
       });
       p.catch(noop2);
       return p;
     }
     function drained() {
-      var p = new Promise(function(resolve9) {
+      var p = new Promise(function(resolve10) {
         process.nextTick(function() {
           if (queue.idle()) {
-            resolve9();
+            resolve10();
           } else {
             var previousDrain = queue.drain;
             queue.drain = function() {
               if (typeof previousDrain === "function")
                 previousDrain();
-              resolve9();
+              resolve10();
               queue.drain = previousDrain;
             };
           }
@@ -53095,9 +53768,9 @@ var require_stream3 = __commonJS((exports) => {
       });
     }
     _getStat(filepath) {
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve10, reject) => {
         this._stat(filepath, this._fsStatSettings, (error2, stats) => {
-          return error2 === null ? resolve9(stats) : reject(error2);
+          return error2 === null ? resolve10(stats) : reject(error2);
         });
       });
     }
@@ -53119,10 +53792,10 @@ var require_async5 = __commonJS((exports) => {
       this._readerStream = new stream_1.default(this._settings);
     }
     dynamic(root2, options2) {
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve10, reject) => {
         this._walkAsync(root2, options2, (error2, entries) => {
           if (error2 === null) {
-            resolve9(entries);
+            resolve10(entries);
           } else {
             reject(error2);
           }
@@ -53132,10 +53805,10 @@ var require_async5 = __commonJS((exports) => {
     async static(patterns, options2) {
       const entries = [];
       const stream = this._readerStream.static(patterns, options2);
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve10, reject) => {
         stream.once("error", reject);
         stream.on("data", (entry) => entries.push(entry));
-        stream.once("end", () => resolve9(entries));
+        stream.once("end", () => resolve10(entries));
       });
     }
   }
@@ -53765,15 +54438,15 @@ var require_out4 = __commonJS((exports, module) => {
 
 // packages/core/src/skills/loader.ts
 import { join as join21, basename as basename5, dirname as dirname10 } from "path";
-import { homedir as homedir17 } from "os";
-import { readFile as readFile5, stat as stat4 } from "fs/promises";
+import { homedir as homedir18 } from "os";
+import { readFile as readFile5, stat as stat5 } from "fs/promises";
 
 class SkillLoader {
   skills = new Map;
   async loadAll(projectDir = process.cwd(), options2 = {}) {
     const includeContent = options2.includeContent ?? true;
     const envHome = process.env.HOME || process.env.USERPROFILE;
-    const userHome = envHome && envHome.trim().length > 0 ? envHome : homedir17();
+    const userHome = envHome && envHome.trim().length > 0 ? envHome : homedir18();
     const globalRoot = join21(userHome, ".skill");
     const projectRoot = join21(projectDir, ".skill");
     await this.loadNpmSkills(globalRoot, { includeContent });
@@ -53786,7 +54459,7 @@ class SkillLoader {
     try {
       const nmDir = join21(skillRoot, "node_modules", "@hasnaxyz");
       try {
-        const stats = await stat4(nmDir);
+        const stats = await stat5(nmDir);
         if (!stats.isDirectory())
           return;
       } catch {
@@ -53820,7 +54493,7 @@ class SkillLoader {
     const includeContent = options2.includeContent ?? true;
     try {
       try {
-        const stats = await stat4(skillRoot);
+        const stats = await stat5(skillRoot);
         if (!stats.isDirectory())
           return;
       } catch {
@@ -53841,7 +54514,7 @@ class SkillLoader {
     const includeContent = options2.includeContent ?? true;
     try {
       try {
-        const stats = await stat4(dir);
+        const stats = await stat5(dir);
         if (!stats.isDirectory())
           return;
       } catch {
@@ -53982,7 +54655,7 @@ var init_loader3 = __esm(() => {
 // packages/core/src/commands/loader.ts
 import { existsSync as existsSync15, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
 import { join as join22, basename as basename6, extname as extname3 } from "path";
-import { homedir as homedir18 } from "os";
+import { homedir as homedir19 } from "os";
 
 class CommandLoader {
   commands = new Map;
@@ -53993,7 +54666,7 @@ class CommandLoader {
   async loadAll() {
     this.commands.clear();
     const envHome = process.env.HOME || process.env.USERPROFILE;
-    const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir18();
+    const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir19();
     const globalDir = join22(homeDir, ".assistants", "commands");
     await this.loadFromDirectory(globalDir, "global");
     const projectDir = join22(this.cwd, ".assistants", "commands");
@@ -54005,11 +54678,11 @@ class CommandLoader {
     const entries = readdirSync6(dir);
     for (const entry of entries) {
       const fullPath = join22(dir, entry);
-      const stat5 = statSync4(fullPath);
-      if (stat5.isDirectory()) {
+      const stat6 = statSync4(fullPath);
+      if (stat6.isDirectory()) {
         const newPrefix = prefix ? `${prefix}:${entry}` : entry;
         await this.loadFromDirectory(fullPath, source, newPrefix);
-      } else if (stat5.isFile() && extname3(entry) === ".md") {
+      } else if (stat6.isFile() && extname3(entry) === ".md") {
         const command = await this.loadCommandFile(fullPath, prefix);
         if (command) {
           this.commands.set(command.name, command);
@@ -54713,7 +55386,7 @@ class JobManager {
     const startTime = Date.now();
     const pollInterval = 500;
     while (Date.now() - startTime < waitMs) {
-      await new Promise((resolve9) => setTimeout(resolve9, pollInterval));
+      await new Promise((resolve10) => setTimeout(resolve10, pollInterval));
       const currentJob = await readJob(jobId);
       if (!currentJob)
         return null;
@@ -55072,7 +55745,7 @@ var init_types4 = __esm(() => {
 // node_modules/.pnpm/@hasna+todos@0.9.23_@types+react@19.2.14/node_modules/@hasna/todos/dist/index.js
 import { Database as Database2 } from "bun:sqlite";
 import { existsSync as existsSync16, mkdirSync as mkdirSync8 } from "fs";
-import { dirname as dirname11, join as join23, resolve as resolve9 } from "path";
+import { dirname as dirname11, join as join23, resolve as resolve10 } from "path";
 import { existsSync as existsSync32 } from "fs";
 import { join as join32 } from "path";
 import { existsSync as existsSync22, mkdirSync as mkdirSync22, readFileSync as readFileSync8, readdirSync as readdirSync7, statSync as statSync5, writeFileSync as writeFileSync7 } from "fs";
@@ -55080,7 +55753,7 @@ function isInMemoryDb(path3) {
   return path3 === ":memory:" || path3.startsWith("file::memory:");
 }
 function findNearestTodosDb(startDir) {
-  let dir = resolve9(startDir);
+  let dir = resolve10(startDir);
   while (true) {
     const candidate = join23(dir, ".todos", "todos.db");
     if (existsSync16(candidate))
@@ -55093,7 +55766,7 @@ function findNearestTodosDb(startDir) {
   return null;
 }
 function findGitRoot(startDir) {
-  let dir = resolve9(startDir);
+  let dir = resolve10(startDir);
   while (true) {
     if (existsSync16(join23(dir, ".git")))
       return dir;
@@ -55124,7 +55797,7 @@ function getDbPath() {
 function ensureDir(filePath) {
   if (isInMemoryDb(filePath))
     return;
-  const dir = dirname11(resolve9(filePath));
+  const dir = dirname11(resolve10(filePath));
   if (!existsSync16(dir)) {
     mkdirSync8(dir, { recursive: true });
   }
@@ -94556,8 +95229,8 @@ var require_simple_parser = __commonJS((exports, module) => {
     }
     let promise;
     if (!callback) {
-      promise = new Promise((resolve10, reject) => {
-        callback = callbackPromise(resolve10, reject);
+      promise = new Promise((resolve11, reject) => {
+        callback = callbackPromise(resolve11, reject);
       });
     }
     options2 = options2 || {};
@@ -94643,13 +95316,13 @@ var require_simple_parser = __commonJS((exports, module) => {
     }
     return promise;
   };
-  function callbackPromise(resolve10, reject) {
+  function callbackPromise(resolve11, reject) {
     return function(...args) {
       let err = args.shift();
       if (err) {
         reject(err);
       } else {
-        resolve10(...args);
+        resolve11(...args);
       }
     };
   }
@@ -95557,7 +96230,19 @@ function createBudgetToolExecutors(getBudgetTracker) {
     budget_status: async (input) => {
       const tracker = getBudgetTracker();
       if (!tracker) {
-        return "Budget tracking is not enabled.";
+        return [
+          "## Budget Status",
+          "",
+          "No budget tracker is configured for this session.",
+          "Budget tracking is available but not active \u2014 no budget limits have been set.",
+          "",
+          "To enable budget tracking, use the `budget_set` tool to configure limits:",
+          '  e.g., budget_set scope="session" maxTotalTokens=100000',
+          "",
+          "Available scopes: session, swarm, project",
+          "Available limits: maxInputTokens, maxOutputTokens, maxTotalTokens, maxLlmCalls, maxToolCalls, maxDurationMs"
+        ].join(`
+`);
       }
       const scopeInput = normalizeScope2(input.scope || "session");
       if (!isBudgetToolScope(scopeInput)) {
@@ -95608,7 +96293,7 @@ function createBudgetToolExecutors(getBudgetTracker) {
     budget_get: async () => {
       const tracker = getBudgetTracker();
       if (!tracker) {
-        return "Budget tracking is not enabled.";
+        return "No budget tracker is configured. Use `budget_set` to configure limits and enable tracking.";
       }
       const config = tracker.getConfig();
       return JSON.stringify(config, null, 2);
@@ -95616,7 +96301,7 @@ function createBudgetToolExecutors(getBudgetTracker) {
     budget_set: async (input) => {
       const tracker = getBudgetTracker();
       if (!tracker) {
-        return "Budget tracking is not enabled.";
+        return "No budget tracker is configured. Budget limits cannot be set without an active tracker.";
       }
       const scopeInput = normalizeScope2(input.scope || "session");
       if (!isBudgetToolScope(scopeInput)) {
@@ -95657,7 +96342,7 @@ ${JSON.stringify(applied, null, 2)}`;
     budget_reset: async (input) => {
       const tracker = getBudgetTracker();
       if (!tracker) {
-        return "Budget tracking is not enabled.";
+        return "No budget tracker is configured. Nothing to reset.";
       }
       const scope = normalizeScope2(input.scope || "session");
       if (!isBudgetResetScope(scope)) {
@@ -97986,7 +98671,7 @@ class TaskGraphScheduler {
     this.stopped = true;
   }
   sleep(ms) {
-    return new Promise((resolve10) => setTimeout(resolve10, ms));
+    return new Promise((resolve11) => setTimeout(resolve11, ms));
   }
 }
 function aggregateTaskResults(graph, aggregationStrategy = "concatenate") {
@@ -99316,7 +100001,7 @@ ${task.description}`,
     };
   }
   sleep(ms) {
-    return new Promise((resolve10) => setTimeout(resolve10, ms));
+    return new Promise((resolve11) => setTimeout(resolve11, ms));
   }
 }
 function createSwarmDispatcher(subassistantManager, context, config) {
@@ -100822,10 +101507,10 @@ var init_swarm = __esm(() => {
 
 // packages/core/src/commands/builtin.ts
 import { join as join26 } from "path";
-import { homedir as homedir19, platform as platform2, release, arch as arch2 } from "os";
+import { homedir as homedir20, platform as platform2, release, arch as arch2 } from "os";
 import { existsSync as existsSync19, mkdirSync as mkdirSync11, writeFileSync as writeFileSync8 } from "fs";
-function resolveAuthTimeout(resolve10) {
-  resolve10({ exitCode: 1, stdout: { toString: () => "{}" } });
+function resolveAuthTimeout(resolve11) {
+  resolve11({ exitCode: 1, stdout: { toString: () => "{}" } });
 }
 function splitArgs(input) {
   const args = [];
@@ -107200,8 +107885,8 @@ Options for install/uninstall:
 `;
           message += `| --- | --- | --- |
 `;
-          for (const stat5 of errorStats.slice(0, 5)) {
-            message += `| ${stat5.code} | ${stat5.count} | ${stat5.lastOccurrence} |
+          for (const stat6 of errorStats.slice(0, 5)) {
+            message += `| ${stat6.code} | ${stat6.count} | ${stat6.lastOccurrence} |
 `;
           }
         }
@@ -107268,7 +107953,7 @@ Format the summary as a brief bullet-point list. This summary will replace the c
 `;
           }
           const envHome = process.env.HOME || process.env.USERPROFILE;
-          const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir19();
+          const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir20();
           message += `
 **Commands Directories:**
 `;
@@ -109370,8 +110055,8 @@ Connector "${connectorName}" not found.
 `;
           try {
             let timeoutId = null;
-            const timeoutPromise = new Promise((resolve10) => {
-              timeoutId = setTimeout(resolveAuthTimeout, 1000, resolve10);
+            const timeoutPromise = new Promise((resolve11) => {
+              timeoutId = setTimeout(resolveAuthTimeout, 1000, resolve11);
             });
             const runtime = getRuntime();
             const cli2 = connector.cli || `connect-${connector.name}`;
@@ -109450,8 +110135,8 @@ Connector "${connectorName}" not found.
             let timeoutId = null;
             try {
               const cli = connector.cli || `connect-${connector.name}`;
-              const timeoutPromise = new Promise((resolve10) => {
-                timeoutId = setTimeout(resolveAuthTimeout, 1000, resolve10);
+              const timeoutPromise = new Promise((resolve11) => {
+                timeoutId = setTimeout(resolveAuthTimeout, 1000, resolve11);
               });
               const runtime = getRuntime();
               const execPromise = (async () => {
@@ -109704,9 +110389,9 @@ ${repoUrl}/issues/new
       selfHandled: true,
       content: "",
       handler: async (args, context) => {
-        const { exec: exec2 } = await import("child_process");
+        const { exec: exec3 } = await import("child_process");
         const { promisify } = await import("util");
-        const execAsync = promisify(exec2);
+        const execAsync2 = promisify(exec3);
         const parts = splitArgs(args);
         try {
           let diffCmd = "git diff";
@@ -109727,8 +110412,8 @@ ${repoUrl}/issues/new
           }
           const opts = { cwd: context.cwd, maxBuffer: 1048576 };
           const [statResult, diffResult] = await Promise.all([
-            execAsync(statCmd, opts).catch(() => ({ stdout: "" })),
-            execAsync(diffCmd, opts).catch(() => ({ stdout: "" }))
+            execAsync2(statCmd, opts).catch(() => ({ stdout: "" })),
+            execAsync2(diffCmd, opts).catch(() => ({ stdout: "" }))
           ]);
           const statOutput = (statResult.stdout || "").trim();
           const diffOutput = (diffResult.stdout || "").trim();
@@ -109782,13 +110467,13 @@ Not a git repository or git not available.
           for (const item of items) {
             const fullPath = join26(dir, item);
             try {
-              const stat5 = statSync6(fullPath);
-              if (stat5.isDirectory()) {
+              const stat6 = statSync6(fullPath);
+              if (stat6.isDirectory()) {
                 walk(fullPath, prefix ? `${prefix}/${item}` : item);
               } else {
                 entries.push({
                   relativePath: prefix ? `${prefix}/${item}` : item,
-                  size: stat5.size
+                  size: stat6.size
                 });
               }
             } catch {}
@@ -109835,14 +110520,14 @@ No generated files yet.
       selfHandled: true,
       content: "",
       handler: async (args, context) => {
-        const { exec: exec2 } = await import("child_process");
+        const { exec: exec3 } = await import("child_process");
         const { promisify } = await import("util");
-        const execAsync = promisify(exec2);
+        const execAsync2 = promisify(exec3);
         const parts = splitArgs(args);
         const opts = { cwd: context.cwd };
         try {
           if (parts.length === 0) {
-            const { stdout: stdout2 } = await execAsync("git diff --stat", opts);
+            const { stdout: stdout2 } = await execAsync2("git diff --stat", opts);
             const statOutput = stdout2.trim();
             if (!statOutput) {
               context.emit("text", `
@@ -109859,7 +110544,7 @@ No uncommitted changes to undo.
             return { handled: true };
           }
           if (parts[0] === "all") {
-            const { stdout: stdout2 } = await execAsync("git diff --stat", opts);
+            const { stdout: stdout2 } = await execAsync2("git diff --stat", opts);
             const statOutput = stdout2.trim();
             if (!statOutput) {
               context.emit("text", `
@@ -109868,13 +110553,13 @@ No uncommitted changes to undo.
               context.emit("done");
               return { handled: true };
             }
-            await execAsync("git checkout -- .", opts);
+            await execAsync2("git checkout -- .", opts);
             context.emit("text", "\n**Reverted all uncommitted changes:**\n```\n" + statOutput + "\n```\n");
             context.emit("done");
             return { handled: true };
           }
           const escaped = parts.map((f) => `'${f.replace(/'/g, "'\\''")}'`).join(" ");
-          const { stdout } = await execAsync(`git diff --stat -- ${escaped}`, opts);
+          const { stdout } = await execAsync2(`git diff --stat -- ${escaped}`, opts);
           const checkOutput = stdout.trim();
           if (!checkOutput) {
             context.emit("text", `
@@ -109883,7 +110568,7 @@ No changes found for: ${parts.join(" ")}
             context.emit("done");
             return { handled: true };
           }
-          await execAsync(`git checkout -- ${escaped}`, opts);
+          await execAsync2(`git checkout -- ${escaped}`, opts);
           context.emit("text", `
 **Reverted:** ${parts.join(" ")}
 `);
@@ -109927,7 +110612,7 @@ Not a git repository or git not available.
     context.setProjectContext(projectContext);
   }
 }
-var VERSION2 = "1.1.85";
+var VERSION2 = "1.1.86";
 var init_builtin = __esm(async () => {
   init_src2();
   init_context3();
@@ -110150,7 +110835,7 @@ var init_values3 = __esm(() => {
 });
 
 // node_modules/.pnpm/@anthropic-ai+sdk@0.74.0_zod@3.25.76/node_modules/@anthropic-ai/sdk/internal/utils/sleep.mjs
-var sleep4 = (ms) => new Promise((resolve10) => setTimeout(resolve10, ms));
+var sleep4 = (ms) => new Promise((resolve11) => setTimeout(resolve11, ms));
 
 // node_modules/.pnpm/@anthropic-ai+sdk@0.74.0_zod@3.25.76/node_modules/@anthropic-ai/sdk/version.mjs
 var VERSION3 = "0.74.0";
@@ -110848,8 +111533,8 @@ var init_api_promise2 = __esm(() => {
   init_parse3();
   APIPromise2 = class APIPromise2 extends Promise {
     constructor(client, responsePromise, parseResponse2 = defaultParseResponse2) {
-      super((resolve10) => {
-        resolve10(null);
+      super((resolve11) => {
+        resolve11(null);
       });
       this.responsePromise = responsePromise;
       this.parseResponse = parseResponse2;
@@ -111805,12 +112490,12 @@ var init_BetaMessageStream = __esm(() => {
         }
         return this._emit("error", new AnthropicError(String(error3)));
       });
-      __classPrivateFieldSet2(this, _BetaMessageStream_connectedPromise, new Promise((resolve10, reject) => {
-        __classPrivateFieldSet2(this, _BetaMessageStream_resolveConnectedPromise, resolve10, "f");
+      __classPrivateFieldSet2(this, _BetaMessageStream_connectedPromise, new Promise((resolve11, reject) => {
+        __classPrivateFieldSet2(this, _BetaMessageStream_resolveConnectedPromise, resolve11, "f");
         __classPrivateFieldSet2(this, _BetaMessageStream_rejectConnectedPromise, reject, "f");
       }), "f");
-      __classPrivateFieldSet2(this, _BetaMessageStream_endPromise, new Promise((resolve10, reject) => {
-        __classPrivateFieldSet2(this, _BetaMessageStream_resolveEndPromise, resolve10, "f");
+      __classPrivateFieldSet2(this, _BetaMessageStream_endPromise, new Promise((resolve11, reject) => {
+        __classPrivateFieldSet2(this, _BetaMessageStream_resolveEndPromise, resolve11, "f");
         __classPrivateFieldSet2(this, _BetaMessageStream_rejectEndPromise, reject, "f");
       }), "f");
       __classPrivateFieldGet2(this, _BetaMessageStream_connectedPromise, "f").catch(() => {});
@@ -111931,11 +112616,11 @@ var init_BetaMessageStream = __esm(() => {
       return this;
     }
     emitted(event) {
-      return new Promise((resolve10, reject) => {
+      return new Promise((resolve11, reject) => {
         __classPrivateFieldSet2(this, _BetaMessageStream_catchingPromiseCreated, true, "f");
         if (event !== "error")
           this.once("error", reject);
-        this.once(event, resolve10);
+        this.once(event, resolve11);
       });
     }
     async done() {
@@ -112268,7 +112953,7 @@ var init_BetaMessageStream = __esm(() => {
             if (done) {
               return { value: undefined, done: true };
             }
-            return new Promise((resolve10, reject) => readQueue.push({ resolve: resolve10, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: undefined, done: true });
+            return new Promise((resolve11, reject) => readQueue.push({ resolve: resolve11, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: undefined, done: true });
           }
           const chunk = pushQueue.shift();
           return { value: chunk, done: false };
@@ -112330,13 +113015,13 @@ Wrap your summary in <summary></summary> tags.`;
 
 // node_modules/.pnpm/@anthropic-ai+sdk@0.74.0_zod@3.25.76/node_modules/@anthropic-ai/sdk/lib/tools/BetaToolRunner.mjs
 function promiseWithResolvers() {
-  let resolve10;
+  let resolve11;
   let reject;
   const promise = new Promise((res, rej) => {
-    resolve10 = res;
+    resolve11 = res;
     reject = rej;
   });
-  return { promise, resolve: resolve10, reject };
+  return { promise, resolve: resolve11, reject };
 }
 async function generateToolResponse(params, lastMessage = params.messages.at(-1)) {
   if (!lastMessage || lastMessage.role !== "assistant" || !lastMessage.content || typeof lastMessage.content === "string") {
@@ -113091,12 +113776,12 @@ var init_MessageStream = __esm(() => {
         }
         return this._emit("error", new AnthropicError(String(error3)));
       });
-      __classPrivateFieldSet2(this, _MessageStream_connectedPromise, new Promise((resolve10, reject) => {
-        __classPrivateFieldSet2(this, _MessageStream_resolveConnectedPromise, resolve10, "f");
+      __classPrivateFieldSet2(this, _MessageStream_connectedPromise, new Promise((resolve11, reject) => {
+        __classPrivateFieldSet2(this, _MessageStream_resolveConnectedPromise, resolve11, "f");
         __classPrivateFieldSet2(this, _MessageStream_rejectConnectedPromise, reject, "f");
       }), "f");
-      __classPrivateFieldSet2(this, _MessageStream_endPromise, new Promise((resolve10, reject) => {
-        __classPrivateFieldSet2(this, _MessageStream_resolveEndPromise, resolve10, "f");
+      __classPrivateFieldSet2(this, _MessageStream_endPromise, new Promise((resolve11, reject) => {
+        __classPrivateFieldSet2(this, _MessageStream_resolveEndPromise, resolve11, "f");
         __classPrivateFieldSet2(this, _MessageStream_rejectEndPromise, reject, "f");
       }), "f");
       __classPrivateFieldGet2(this, _MessageStream_connectedPromise, "f").catch(() => {});
@@ -113217,11 +113902,11 @@ var init_MessageStream = __esm(() => {
       return this;
     }
     emitted(event) {
-      return new Promise((resolve10, reject) => {
+      return new Promise((resolve11, reject) => {
         __classPrivateFieldSet2(this, _MessageStream_catchingPromiseCreated, true, "f");
         if (event !== "error")
           this.once("error", reject);
-        this.once(event, resolve10);
+        this.once(event, resolve11);
       });
     }
     async done() {
@@ -113529,7 +114214,7 @@ var init_MessageStream = __esm(() => {
             if (done) {
               return { value: undefined, done: true };
             }
-            return new Promise((resolve10, reject) => readQueue.push({ resolve: resolve10, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: undefined, done: true });
+            return new Promise((resolve11, reject) => readQueue.push({ resolve: resolve11, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: undefined, done: true });
           }
           const chunk = pushQueue.shift();
           return { value: chunk, done: false };
@@ -115317,7 +116002,7 @@ var init_watchdog = __esm(async () => {
 
 // packages/core/src/heartbeat/install-skills.ts
 import { join as join27 } from "path";
-import { homedir as homedir20 } from "os";
+import { homedir as homedir21 } from "os";
 async function writeSkillIfNeeded(dir, skillName, content3) {
   const { mkdir: mkdir7, writeFile: writeFile6, readFile: readFile7 } = await import("fs/promises");
   const skillDir = join27(dir, `skill-${skillName}`);
@@ -115340,7 +116025,7 @@ async function writeSkillIfNeeded(dir, skillName, content3) {
   }
 }
 async function installHeartbeatSkills() {
-  const sharedSkillsDir = join27(homedir20(), ".skill");
+  const sharedSkillsDir = join27(homedir21(), ".skill");
   const installed = [];
   const results = await Promise.all([
     writeSkillIfNeeded(sharedSkillsDir, "main-loop", MAIN_LOOP_SKILL),
@@ -115761,14 +116446,14 @@ class AudioPlayer {
     if (!player) {
       throw new Error("No supported audio player found. Install afplay, ffplay, mpg123, or aplay.");
     }
-    await new Promise((resolve10, reject) => {
+    await new Promise((resolve11, reject) => {
       this.playing = true;
       this.currentProcess = spawn2(player.command, [...player.args, tempFile], { stdio: "ignore" });
       this.currentProcess.on("close", () => {
         this.playing = false;
         this.currentProcess = null;
         unlink2(tempFile, () => {});
-        resolve10();
+        resolve11();
       });
       this.currentProcess.on("error", (error3) => {
         this.playing = false;
@@ -115793,14 +116478,14 @@ class AudioPlayer {
       unlink2(tempFile, () => {});
       throw new Error("No supported audio player found.");
     }
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve11, reject) => {
       this.playing = true;
       this.currentProcess = spawn2(player.command, [...player.args, tempFile]);
       this.currentProcess.on("close", () => {
         this.playing = false;
         this.currentProcess = null;
         unlink2(tempFile, () => {});
-        resolve10();
+        resolve11();
       });
       this.currentProcess.on("error", (error3) => {
         this.playing = false;
@@ -115873,12 +116558,12 @@ class AudioRecorder {
     if (!recorder) {
       throw new Error("No supported audio recorder found. Install sox or ffmpeg.");
     }
-    await new Promise((resolve10, reject) => {
+    await new Promise((resolve11, reject) => {
       this.currentProcess = spawn3(recorder.command, recorder.args, { stdio: "ignore" });
       this.currentProcess.on("close", (code3) => {
         this.currentProcess = null;
         if (code3 === 0 || this.stoppedIntentionally) {
-          resolve10();
+          resolve11();
         } else {
           reject(new Error("Audio recording failed."));
         }
@@ -115911,12 +116596,12 @@ class AudioRecorder {
     if (!recorder) {
       return this.record({ ...options2, durationSeconds: options2.durationSeconds ?? 5 });
     }
-    await new Promise((resolve10, reject) => {
+    await new Promise((resolve11, reject) => {
       this.currentProcess = spawn3(recorder.command, recorder.args, { stdio: "ignore" });
       this.currentProcess.on("close", (code3) => {
         this.currentProcess = null;
         if (code3 === 0 || this.stoppedIntentionally) {
-          resolve10();
+          resolve11();
         } else {
           reject(new Error("Audio recording failed."));
         }
@@ -116154,7 +116839,7 @@ class VoiceManager {
   }
   async streamOneTurn(options2, autoSend) {
     this.isListening = true;
-    return new Promise(async (resolve10) => {
+    return new Promise(async (resolve11) => {
       let resolved = false;
       const finish = (text5) => {
         if (resolved)
@@ -116162,7 +116847,7 @@ class VoiceManager {
         resolved = true;
         this.isListening = false;
         this.streamingStop = null;
-        resolve10(text5);
+        resolve11(text5);
       };
       try {
         const { stop } = await this.stt.streamFromMic({
@@ -116193,7 +116878,7 @@ class VoiceManager {
         };
       } catch (err) {
         this.isListening = false;
-        resolve10("");
+        resolve11("");
       }
     });
   }
@@ -117814,7 +118499,7 @@ var require_headStream = __commonJS((exports) => {
     if ((0, stream_type_check_1.isReadableStream)(stream)) {
       return (0, headStream_browser_1.headStream)(stream, bytes);
     }
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve11, reject) => {
       const collector = new Collector;
       collector.limit = bytes;
       stream.pipe(collector);
@@ -117825,7 +118510,7 @@ var require_headStream = __commonJS((exports) => {
       collector.on("error", reject);
       collector.on("finish", function() {
         const bytes2 = new Uint8Array(Buffer.concat(this.buffers));
-        resolve10(bytes2);
+        resolve11(bytes2);
       });
     });
   };
@@ -118005,21 +118690,21 @@ var require_dist_cjs11 = __commonJS((exports) => {
     let sendBody = true;
     if (!externalAgent && expect === "100-continue") {
       sendBody = await Promise.race([
-        new Promise((resolve10) => {
-          timeoutId = Number(timing.setTimeout(() => resolve10(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
+        new Promise((resolve11) => {
+          timeoutId = Number(timing.setTimeout(() => resolve11(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
         }),
-        new Promise((resolve10) => {
+        new Promise((resolve11) => {
           httpRequest.on("continue", () => {
             timing.clearTimeout(timeoutId);
-            resolve10(true);
+            resolve11(true);
           });
           httpRequest.on("response", () => {
             timing.clearTimeout(timeoutId);
-            resolve10(false);
+            resolve11(false);
           });
           httpRequest.on("error", () => {
             timing.clearTimeout(timeoutId);
-            resolve10(false);
+            resolve11(false);
           });
         })
       ]);
@@ -118092,13 +118777,13 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
       return socketWarningTimestamp;
     }
     constructor(options2) {
-      this.configProvider = new Promise((resolve10, reject) => {
+      this.configProvider = new Promise((resolve11, reject) => {
         if (typeof options2 === "function") {
           options2().then((_options) => {
-            resolve10(this.resolveDefaultConfig(_options));
+            resolve11(this.resolveDefaultConfig(_options));
           }).catch(reject);
         } else {
-          resolve10(this.resolveDefaultConfig(options2));
+          resolve11(this.resolveDefaultConfig(options2));
         }
       });
     }
@@ -118141,7 +118826,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         const config = this.config;
         let writeRequestBodyPromise = undefined;
         const timeouts = [];
-        const resolve10 = async (arg) => {
+        const resolve11 = async (arg) => {
           await writeRequestBodyPromise;
           timeouts.forEach(timing.clearTimeout);
           _resolve(arg);
@@ -118207,7 +118892,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             headers: getTransformedHeaders(res.headers),
             body: res
           });
-          resolve10({ response: httpResponse });
+          resolve11({ response: httpResponse });
         });
         req.on("error", (err) => {
           if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
@@ -118390,13 +119075,13 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
       return new NodeHttp2Handler(instanceOrOptions);
     }
     constructor(options2) {
-      this.configProvider = new Promise((resolve10, reject) => {
+      this.configProvider = new Promise((resolve11, reject) => {
         if (typeof options2 === "function") {
           options2().then((opts) => {
-            resolve10(opts || {});
+            resolve11(opts || {});
           }).catch(reject);
         } else {
-          resolve10(options2 || {});
+          resolve11(options2 || {});
         }
       });
     }
@@ -118416,7 +119101,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
       return new Promise((_resolve, _reject) => {
         let fulfilled = false;
         let writeRequestBodyPromise = undefined;
-        const resolve10 = async (arg) => {
+        const resolve11 = async (arg) => {
           await writeRequestBodyPromise;
           _resolve(arg);
         };
@@ -118472,7 +119157,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             body: req
           });
           fulfilled = true;
-          resolve10({ response: httpResponse });
+          resolve11({ response: httpResponse });
           if (disableConcurrentStreams) {
             session.close();
             this.connectionManager.deleteSession(authority, session);
@@ -118550,7 +119235,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
     if (isReadableStreamInstance(stream2)) {
       return collectReadableStream(stream2);
     }
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve11, reject) => {
       const collector = new Collector;
       stream2.pipe(collector);
       stream2.on("error", (err) => {
@@ -118560,7 +119245,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
       collector.on("error", reject);
       collector.on("finish", function() {
         const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
-        resolve10(bytes);
+        resolve11(bytes);
       });
     });
   };
@@ -118601,7 +119286,7 @@ var require_dist_cjs12 = __commonJS((exports) => {
     return new Request(url, requestOptions);
   }
   function requestTimeout(timeoutInMs = 0) {
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve11, reject) => {
       if (timeoutInMs) {
         setTimeout(() => {
           const timeoutError = new Error(`Request did not complete within ${timeoutInMs} ms`);
@@ -118718,7 +119403,7 @@ var require_dist_cjs12 = __commonJS((exports) => {
         requestTimeout(requestTimeoutInMs)
       ];
       if (abortSignal) {
-        raceOfPromises.push(new Promise((resolve10, reject) => {
+        raceOfPromises.push(new Promise((resolve11, reject) => {
           const onAbort = () => {
             const abortError = new Error("Request aborted");
             abortError.name = "AbortError";
@@ -118782,7 +119467,7 @@ var require_dist_cjs12 = __commonJS((exports) => {
     return collected;
   }
   function readToBase64(blob) {
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve11, reject) => {
       const reader = new FileReader;
       reader.onloadend = () => {
         if (reader.readyState !== 2) {
@@ -118791,7 +119476,7 @@ var require_dist_cjs12 = __commonJS((exports) => {
         const result = reader.result ?? "";
         const commaIndex = result.indexOf(",");
         const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
-        resolve10(result.substring(dataOffset));
+        resolve11(result.substring(dataOffset));
       };
       reader.onabort = () => reject(new Error("Read aborted"));
       reader.onerror = () => reject(reader.error);
@@ -119909,11 +120594,11 @@ var require_tslib = __commonJS((exports, module) => {
     };
     __awaiter = function(thisArg, _arguments, P, generator) {
       function adopt(value2) {
-        return value2 instanceof P ? value2 : new P(function(resolve10) {
-          resolve10(value2);
+        return value2 instanceof P ? value2 : new P(function(resolve11) {
+          resolve11(value2);
         });
       }
-      return new (P || (P = Promise))(function(resolve10, reject) {
+      return new (P || (P = Promise))(function(resolve11, reject) {
         function fulfilled(value2) {
           try {
             step(generator.next(value2));
@@ -119929,7 +120614,7 @@ var require_tslib = __commonJS((exports, module) => {
           }
         }
         function step(result) {
-          result.done ? resolve10(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve11(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -120158,14 +120843,14 @@ var require_tslib = __commonJS((exports, module) => {
       }, i);
       function verb(n) {
         i[n] = o[n] && function(v) {
-          return new Promise(function(resolve10, reject) {
-            v = o[n](v), settle(resolve10, reject, v.done, v.value);
+          return new Promise(function(resolve11, reject) {
+            v = o[n](v), settle(resolve11, reject, v.done, v.value);
           });
         };
       }
-      function settle(resolve10, reject, d, v) {
+      function settle(resolve11, reject, d, v) {
         Promise.resolve(v).then(function(v2) {
-          resolve10({ value: v2, done: d });
+          resolve11({ value: v2, done: d });
         }, reject);
       }
     };
@@ -132490,7 +133175,7 @@ var require_dist_cjs39 = __commonJS((exports) => {
       this.refillTokenBucket();
       if (amount > this.currentCapacity) {
         const delay = (amount - this.currentCapacity) / this.fillRate * 1000;
-        await new Promise((resolve10) => DefaultRateLimiter.setTimeoutFn(resolve10, delay));
+        await new Promise((resolve11) => DefaultRateLimiter.setTimeoutFn(resolve11, delay));
       }
       this.currentCapacity = this.currentCapacity - amount;
     }
@@ -132823,7 +133508,7 @@ var require_dist_cjs40 = __commonJS((exports) => {
             const delayFromResponse = getDelayFromRetryAfterHeader(err.$response);
             const delay = Math.max(delayFromResponse || 0, delayFromDecider);
             totalDelay += delay;
-            await new Promise((resolve10) => setTimeout(resolve10, delay));
+            await new Promise((resolve11) => setTimeout(resolve11, delay));
             continue;
           }
           if (!err.$metadata) {
@@ -132982,7 +133667,7 @@ var require_dist_cjs40 = __commonJS((exports) => {
           attempts = retryToken.getRetryCount();
           const delay = retryToken.getRetryDelay();
           totalRetryDelay += delay;
-          await new Promise((resolve10) => setTimeout(resolve10, delay));
+          await new Promise((resolve11) => setTimeout(resolve11, delay));
         }
       }
     } else {
@@ -138049,7 +138734,7 @@ var init_dist_es9 = __esm(() => {
 import { Buffer as Buffer3 } from "buffer";
 import { request } from "http";
 function httpRequest(options2) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     const req = request({
       method: "GET",
       ...options2,
@@ -138074,7 +138759,7 @@ function httpRequest(options2) {
         chunks.push(chunk);
       });
       res.on("end", () => {
-        resolve10(Buffer3.concat(chunks));
+        resolve11(Buffer3.concat(chunks));
         req.destroy();
       });
     });
@@ -138535,7 +139220,7 @@ var retryWrapper = (toRetry, maxRetries, delayMs) => {
       try {
         return await toRetry();
       } catch (e2) {
-        await new Promise((resolve10) => setTimeout(resolve10, delayMs));
+        await new Promise((resolve11) => setTimeout(resolve11, delayMs));
       }
     }
     return await toRetry();
@@ -144439,7 +145124,7 @@ var require_signin = __commonJS((exports) => {
 // node_modules/.pnpm/@aws-sdk+credential-provider-login@3.972.8/node_modules/@aws-sdk/credential-provider-login/dist-es/LoginCredentialsFetcher.js
 import { createHash as createHash5, createPrivateKey, createPublicKey, sign } from "crypto";
 import { promises as fs2 } from "fs";
-import { homedir as homedir21 } from "os";
+import { homedir as homedir22 } from "os";
 import { dirname as dirname13, join as join33 } from "path";
 var import_property_provider18, import_protocol_http11, import_shared_ini_file_loader6, LoginCredentialsFetcher;
 var init_LoginCredentialsFetcher = __esm(() => {
@@ -144600,7 +145285,7 @@ var init_LoginCredentialsFetcher = __esm(() => {
       await fs2.writeFile(tokenFilePath, JSON.stringify(token, null, 2), "utf8");
     }
     getTokenFilePath() {
-      const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join33(homedir21(), ".aws", "login", "cache");
+      const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join33(homedir22(), ".aws", "login", "cache");
       const loginSessionBytes = Buffer.from(this.loginSession, "utf8");
       const loginSessionSha256 = createHash5("sha256").update(loginSessionBytes).digest("hex");
       return join33(directory, `${loginSessionSha256}.json`);
@@ -144777,14 +145462,14 @@ var init_getValidatedProcessCredentials = __esm(() => {
 });
 
 // node_modules/.pnpm/@aws-sdk+credential-provider-process@3.972.8/node_modules/@aws-sdk/credential-provider-process/dist-es/resolveProcessCredentials.js
-import { exec as exec2 } from "child_process";
+import { exec as exec3 } from "child_process";
 import { promisify } from "util";
 var import_property_provider20, import_shared_ini_file_loader8, resolveProcessCredentials = async (profileName, profiles, logger) => {
   const profile = profiles[profileName];
   if (profiles[profileName]) {
     const credentialProcess = profile["credential_process"];
     if (credentialProcess !== undefined) {
-      const execPromise = promisify(import_shared_ini_file_loader8.externalDataInterceptor?.getTokenRecord?.().exec ?? exec2);
+      const execPromise = promisify(import_shared_ini_file_loader8.externalDataInterceptor?.getTokenRecord?.().exec ?? exec3);
       try {
         const { stdout } = await execPromise(credentialProcess);
         let data;
@@ -145708,7 +146393,7 @@ async function* readabletoIterable(readStream) {
     streamEnded = true;
   });
   while (!generationEnded) {
-    const value2 = await new Promise((resolve10) => setTimeout(() => resolve10(records.shift()), 0));
+    const value2 = await new Promise((resolve11) => setTimeout(() => resolve11(records.shift()), 0));
     if (value2) {
       yield value2;
     }
@@ -145784,14 +146469,14 @@ var readableStreamHasher = (hashCtor, readableStream) => {
   const hash = new hashCtor;
   const hashCalculator = new HashCalculator(hash);
   readableStream.pipe(hashCalculator);
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     readableStream.on("error", (err) => {
       hashCalculator.end();
       reject(err);
     });
     hashCalculator.on("error", reject);
     hashCalculator.on("finish", () => {
-      hash.digest().then(resolve10).catch(reject);
+      hash.digest().then(resolve11).catch(reject);
     });
   });
 };
@@ -148446,7 +149131,7 @@ var getCircularReplacer = () => {
 
 // node_modules/.pnpm/@smithy+util-waiter@4.2.8/node_modules/@smithy/util-waiter/dist-es/utils/sleep.js
 var sleep5 = (seconds) => {
-  return new Promise((resolve10) => setTimeout(resolve10, seconds * 1000));
+  return new Promise((resolve11) => setTimeout(resolve11, seconds * 1000));
 };
 
 // node_modules/.pnpm/@smithy+util-waiter@4.2.8/node_modules/@smithy/util-waiter/dist-es/waiter.js
@@ -148564,8 +149249,8 @@ var init_utils5 = () => {};
 // node_modules/.pnpm/@smithy+util-waiter@4.2.8/node_modules/@smithy/util-waiter/dist-es/createWaiter.js
 var abortTimeout = (abortSignal) => {
   let onAbort;
-  const promise = new Promise((resolve10) => {
-    onAbort = () => resolve10({ state: WaiterState.ABORTED });
+  const promise = new Promise((resolve11) => {
+    onAbort = () => resolve11({ state: WaiterState.ABORTED });
     if (typeof abortSignal.addEventListener === "function") {
       abortSignal.addEventListener("abort", onAbort);
     } else {
@@ -149261,7 +149946,7 @@ var init_s3_client = __esm(() => {
 
 // packages/core/src/inbox/storage/local-cache.ts
 import { join as join35, basename as basename7 } from "path";
-import { mkdir as mkdir8, readFile as readFile9, writeFile as writeFile8, rm as rm3, readdir, stat as stat5 } from "fs/promises";
+import { mkdir as mkdir8, readFile as readFile9, writeFile as writeFile8, rm as rm3, readdir, stat as stat6 } from "fs/promises";
 import { createHash as createHash6 } from "crypto";
 function isValidAssistantId(id) {
   return typeof id === "string" && id.length > 0 && STRICT_ID_PATTERN.test(id);
@@ -149425,7 +150110,7 @@ class LocalInboxCache {
     }
     try {
       const attachmentPath = join35(this.cacheDir, "attachments", emailFilename, safeFilename);
-      await stat5(attachmentPath);
+      await stat6(attachmentPath);
       return attachmentPath;
     } catch {
       return null;
@@ -149465,7 +150150,7 @@ class LocalInboxCache {
       const emailsDir = join35(this.cacheDir, "emails");
       const files = await readdir(emailsDir);
       for (const file of files) {
-        const fileStat = await stat5(join35(emailsDir, file));
+        const fileStat = await stat6(join35(emailsDir, file));
         totalSize += fileStat.size;
       }
     } catch {}
@@ -149475,7 +150160,7 @@ class LocalInboxCache {
       for (const dir of dirs) {
         const files = await readdir(join35(attachmentsDir, dir));
         for (const file of files) {
-          const fileStat = await stat5(join35(attachmentsDir, dir, file));
+          const fileStat = await stat6(join35(attachmentsDir, dir, file));
           totalSize += fileStat.size;
         }
       }
@@ -154245,9 +154930,9 @@ async function blobToArrayBuffer(blob) {
     return await blob.arrayBuffer();
   }
   const fr = new FileReader;
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     fr.onload = function(e4) {
-      resolve10(e4.target.result);
+      resolve11(e4.target.result);
     };
     fr.onerror = function(e4) {
       reject(fr.error);
@@ -158822,11 +159507,11 @@ var require_dist = __commonJS((exports) => {
 var require_request = __commonJS((exports) => {
   var __awaiter2 = exports && exports.__awaiter || function(thisArg, _arguments, P2, generator) {
     function adopt(value2) {
-      return value2 instanceof P2 ? value2 : new P2(function(resolve10) {
-        resolve10(value2);
+      return value2 instanceof P2 ? value2 : new P2(function(resolve11) {
+        resolve11(value2);
       });
     }
-    return new (P2 || (P2 = Promise))(function(resolve10, reject) {
+    return new (P2 || (P2 = Promise))(function(resolve11, reject) {
       function fulfilled(value2) {
         try {
           step(generator.next(value2));
@@ -158842,7 +159527,7 @@ var require_request = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve10(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve11(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -158972,7 +159657,7 @@ var require_request = __commonJS((exports) => {
   }
   function sendWithRetry(url, init, retryScheduleInMs, nextInterval = 50, triesLeft = 2, fetchImpl = fetch, retryCount = 1) {
     return __awaiter2(this, undefined, undefined, function* () {
-      const sleep7 = (interval) => new Promise((resolve10) => setTimeout(resolve10, interval));
+      const sleep7 = (interval) => new Promise((resolve11) => setTimeout(resolve11, interval));
       try {
         const response = yield fetchImpl(url, init);
         if (triesLeft <= 0 || response.status < 500) {
@@ -173708,7 +174393,7 @@ import { createInterface } from "readline";
 import * as fs3 from "fs";
 import { stat as statPromise, open as open2 } from "fs/promises";
 import { join as join39 } from "path";
-import { homedir as homedir22 } from "os";
+import { homedir as homedir23 } from "os";
 import { dirname as dirname14, join as join210 } from "path";
 import { cwd } from "process";
 import { realpathSync as realpathSync2 } from "fs";
@@ -173992,7 +174677,7 @@ function shouldShowDebugMessage(message, filter) {
   return shouldShowDebugCategories(categories, filter);
 }
 function getClaudeConfigHomeDir() {
-  return process.env.CLAUDE_CONFIG_DIR ?? join39(homedir22(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR ?? join39(homedir23(), ".claude");
 }
 function isEnvTruthy(envVar) {
   if (!envVar)
@@ -174688,7 +175373,7 @@ class ProcessTransport {
       }
       return;
     }
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve11, reject) => {
       const exitHandler = (code3, signal) => {
         if (this.abortController.signal.aborted) {
           reject(new AbortError("Operation aborted"));
@@ -174698,7 +175383,7 @@ class ProcessTransport {
         if (error3) {
           reject(error3);
         } else {
-          resolve10();
+          resolve11();
         }
       };
       this.process.once("exit", exitHandler);
@@ -178945,7 +179630,7 @@ class Protocol {
           return;
         }
         const pollInterval = (_c5 = (_a4 = task2.pollInterval) !== null && _a4 !== undefined ? _a4 : (_b = this._options) === null || _b === undefined ? undefined : _b.defaultTaskPollInterval) !== null && _c5 !== undefined ? _c5 : 1000;
-        await new Promise((resolve10) => setTimeout(resolve10, pollInterval));
+        await new Promise((resolve11) => setTimeout(resolve11, pollInterval));
         (_d2 = options2 === null || options2 === undefined ? undefined : options2.signal) === null || _d2 === undefined || _d2.throwIfAborted();
       }
     } catch (error22) {
@@ -178957,7 +179642,7 @@ class Protocol {
   }
   request(request2, resultSchema, options2) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options2 !== null && options2 !== undefined ? options2 : {};
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve11, reject) => {
       var _a4, _b, _c5, _d2, _e5, _f, _g;
       const earlyReject = (error22) => {
         reject(error22);
@@ -179038,7 +179723,7 @@ class Protocol {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve10(parseResult.data);
+            resolve11(parseResult.data);
           }
         } catch (error22) {
           reject(error22);
@@ -179234,12 +179919,12 @@ class Protocol {
         interval = task.pollInterval;
       }
     } catch (_d2) {}
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve11, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve10, interval);
+      const timeoutId = setTimeout(resolve11, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -179690,7 +180375,7 @@ class McpServer {
     let task = createTaskResult.task;
     const pollInterval = (_a4 = task.pollInterval) !== null && _a4 !== undefined ? _a4 : 5000;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve10) => setTimeout(resolve10, pollInterval));
+      await new Promise((resolve11) => setTimeout(resolve11, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -184001,7 +184686,7 @@ var init_sdk2 = __esm(() => {
       const schOrFunc = root2.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve10.call(this, root2, ref);
+      let _sch = resolve11.call(this, root2, ref);
       if (_sch === undefined) {
         const schema = (_a4 = root2.localRefs) === null || _a4 === undefined ? undefined : _a4[ref];
         const { schemaId } = this.opts;
@@ -184028,7 +184713,7 @@ var init_sdk2 = __esm(() => {
     function sameSchemaEnv(s1, s22) {
       return s1.schema === s22.schema && s1.root === s22.root && s1.baseId === s22.baseId;
     }
-    function resolve10(root2, ref) {
+    function resolve11(root2, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -184526,7 +185211,7 @@ var init_sdk2 = __esm(() => {
       }
       return uri;
     }
-    function resolve10(baseURI, relativeURI, options2) {
+    function resolve11(baseURI, relativeURI, options2) {
       const schemelessOptions = Object.assign({ scheme: "null" }, options2);
       const resolved = resolveComponents(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
       return serialize2(resolved, { ...schemelessOptions, skipEscape: true });
@@ -184759,7 +185444,7 @@ var init_sdk2 = __esm(() => {
     var fastUri = {
       SCHEMES,
       normalize: normalize2,
-      resolve: resolve10,
+      resolve: resolve11,
       resolveComponents,
       equal,
       serialize: serialize2,
@@ -187803,17 +188488,17 @@ var init_sdk2 = __esm(() => {
       if (this.hasError) {
         return Promise.reject(this.hasError);
       }
-      return new Promise((resolve10, reject) => {
-        this.readResolve = resolve10;
+      return new Promise((resolve11, reject) => {
+        this.readResolve = resolve11;
         this.readReject = reject;
       });
     }
     enqueue(value2) {
       if (this.readResolve) {
-        const resolve10 = this.readResolve;
+        const resolve11 = this.readResolve;
         this.readResolve = undefined;
         this.readReject = undefined;
-        resolve10({ done: false, value: value2 });
+        resolve11({ done: false, value: value2 });
       } else {
         this.queue.push(value2);
       }
@@ -187821,10 +188506,10 @@ var init_sdk2 = __esm(() => {
     done() {
       this.isDone = true;
       if (this.readResolve) {
-        const resolve10 = this.readResolve;
+        const resolve11 = this.readResolve;
         this.readResolve = undefined;
         this.readReject = undefined;
-        resolve10({ done: true, value: undefined });
+        resolve11({ done: true, value: undefined });
       }
     }
     error(error3) {
@@ -188128,10 +188813,10 @@ var init_sdk2 = __esm(() => {
         type: "control_request",
         request: request2
       };
-      return new Promise((resolve10, reject) => {
+      return new Promise((resolve11, reject) => {
         this.pendingControlResponses.set(requestId, (response) => {
           if (response.subtype === "success") {
-            resolve10(response);
+            resolve11(response);
           } else {
             reject(new Error(response.error));
             if (response.pending_permission_requests) {
@@ -188221,15 +188906,15 @@ var init_sdk2 = __esm(() => {
         logForDebugging(`[Query.waitForFirstResult] Result already received, returning immediately`);
         return Promise.resolve();
       }
-      return new Promise((resolve10) => {
+      return new Promise((resolve11) => {
         if (this.abortController?.signal.aborted) {
-          resolve10();
+          resolve11();
           return;
         }
-        this.abortController?.signal.addEventListener("abort", () => resolve10(), {
+        this.abortController?.signal.addEventListener("abort", () => resolve11(), {
           once: true
         });
-        this.firstResultReceivedResolve = resolve10;
+        this.firstResultReceivedResolve = resolve11;
       });
     }
     handleHookCallbacks(callbackId, input, toolUseID, abortSignal) {
@@ -188280,13 +188965,13 @@ var init_sdk2 = __esm(() => {
     handleMcpControlRequest(serverName, mcpRequest, transport) {
       const messageId = "id" in mcpRequest.message ? mcpRequest.message.id : null;
       const key = `${serverName}:${messageId}`;
-      return new Promise((resolve10, reject) => {
+      return new Promise((resolve11, reject) => {
         const cleanup = () => {
           this.pendingMcpResponses.delete(key);
         };
         const resolveAndCleanup = (response) => {
           cleanup();
-          resolve10(response);
+          resolve11(response);
         };
         const rejectAndCleanup = (error3) => {
           cleanup();
@@ -195116,8 +195801,8 @@ var Thread = class {
   get id() {
     return this._id;
   }
-  constructor(exec3, options2, threadOptions, id = null) {
-    this._exec = exec3;
+  constructor(exec4, options2, threadOptions, id = null) {
+    this._exec = exec4;
     this._options = options2;
     this._id = id;
     this._threadOptions = threadOptions;
@@ -195290,9 +195975,9 @@ var Thread = class {
         stderrChunks.push(data);
       });
     }
-    const exitPromise = new Promise((resolve10) => {
+    const exitPromise = new Promise((resolve11) => {
       child.once("exit", (code3, signal) => {
-        resolve10({ code: code3, signal });
+        resolve11({ code: code3, signal });
       });
     });
     const rl = readline.createInterface({
@@ -196109,8 +196794,8 @@ class ChannelAgentPool {
     this.clientFactory = options2?.clientFactory;
   }
   async triggerResponses(channelName, personName, message, channelMembers, excludeAssistantId) {
-    return new Promise((resolve10, reject) => {
-      this.queue.push({ channelName, personName, message, channelMembers, excludeAssistantId, resolve: resolve10, reject });
+    return new Promise((resolve11, reject) => {
+      this.queue.push({ channelName, personName, message, channelMembers, excludeAssistantId, resolve: resolve11, reject });
       this.drainQueue();
     });
   }
@@ -197945,7 +198630,7 @@ class BridgeConnection {
   }
   async connect() {
     const url = `${ELEVENLABS_WS_BASE}?agent_id=${this.config.elevenLabsAgentId}`;
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve11, reject) => {
       try {
         this.elevenLabsWs = new WebSocket(url, {
           headers: {
@@ -197954,7 +198639,7 @@ class BridgeConnection {
         });
         this.elevenLabsWs.onopen = () => {
           this.state = "active";
-          resolve10();
+          resolve11();
         };
         this.elevenLabsWs.onmessage = (event) => {
           this.handleElevenLabsMessage(event.data);
@@ -202953,7 +203638,7 @@ function createSelfAwarenessToolExecutors(context) {
       return JSON.stringify(response, null, 2);
     },
     workspace_map: async (input) => {
-      const { readdir: readdir2, stat: stat6, access } = await import("fs/promises");
+      const { readdir: readdir2, stat: stat7, access } = await import("fs/promises");
       const { execSync } = await import("child_process");
       const { join: join40, basename: basename8 } = await import("path");
       const depth = input.depth ?? 3;
@@ -203062,7 +203747,7 @@ function createSelfAwarenessToolExecutors(context) {
               const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
               if (entry.isFile()) {
                 try {
-                  const stats = await stat6(fullPath);
+                  const stats = await stat7(fullPath);
                   recentFiles.push({
                     path: relPath,
                     mtime: stats.mtime.toISOString()
@@ -204765,7 +205450,31 @@ function createCapabilitiesGetExecutor(context) {
   return async (input) => {
     const section = input.section || "all";
     if (!context.isEnabled()) {
-      return "Capability enforcement is disabled.";
+      const lines2 = [];
+      lines2.push("## Capabilities (enforcement disabled)");
+      lines2.push("");
+      lines2.push("Capability enforcement is not active \u2014 all tools and skills are available without restrictions.");
+      lines2.push("");
+      const orchestrationLevel = context.getOrchestrationLevel?.();
+      if (orchestrationLevel) {
+        lines2.push(`Orchestration level: ${orchestrationLevel}`);
+      }
+      const toolPolicy = context.getToolPolicy?.();
+      if (toolPolicy) {
+        lines2.push(`Tool access policy: ${toolPolicy}`);
+      }
+      const allowedTools = context.getAllowedTools?.();
+      if (allowedTools && allowedTools.length > 0) {
+        lines2.push(`Registered tools: ${allowedTools.length}`);
+      }
+      const deniedTools = context.getDeniedTools?.();
+      if (deniedTools && deniedTools.length > 0) {
+        lines2.push(`Denied tools: ${deniedTools.join(", ")}`);
+      }
+      lines2.push("");
+      lines2.push("To enable capability enforcement, configure capabilities in the assistant settings.");
+      return lines2.join(`
+`);
     }
     const capabilities = context.getCapabilities();
     if (!capabilities) {
@@ -205953,15 +206662,15 @@ var init_types11 = __esm(() => {
 // node_modules/.pnpm/@hasna+mementos@0.3.9_@types+react@19.2.14/node_modules/@hasna/mementos/dist/index.js
 import { Database as Database3 } from "bun:sqlite";
 import { existsSync as existsSync27, mkdirSync as mkdirSync14 } from "fs";
-import { dirname as dirname15, join as join40, resolve as resolve10 } from "path";
+import { dirname as dirname15, join as join40, resolve as resolve11 } from "path";
 import { existsSync as existsSync28, mkdirSync as mkdirSync24, readFileSync as readFileSync13 } from "fs";
-import { homedir as homedir23 } from "os";
+import { homedir as homedir24 } from "os";
 import { dirname as dirname22, join as join212, resolve as resolve22 } from "path";
 function isInMemoryDb2(path5) {
   return path5 === ":memory:" || path5.startsWith("file::memory:");
 }
 function findNearestMementosDb(startDir) {
-  let dir = resolve10(startDir);
+  let dir = resolve11(startDir);
   while (true) {
     const candidate = join40(dir, ".mementos", "mementos.db");
     if (existsSync27(candidate))
@@ -205974,7 +206683,7 @@ function findNearestMementosDb(startDir) {
   return null;
 }
 function findGitRoot2(startDir) {
-  let dir = resolve10(startDir);
+  let dir = resolve11(startDir);
   while (true) {
     if (existsSync27(join40(dir, ".git")))
       return dir;
@@ -206005,7 +206714,7 @@ function getDbPath2() {
 function ensureDir2(filePath) {
   if (isInMemoryDb2(filePath))
     return;
-  const dir = dirname15(resolve10(filePath));
+  const dir = dirname15(resolve11(filePath));
   if (!existsSync27(dir)) {
     mkdirSync14(dir, { recursive: true });
   }
@@ -206308,7 +207017,7 @@ function isValidCategory(value2) {
   return VALID_CATEGORIES2.includes(value2);
 }
 function loadConfig5() {
-  const configPath = join212(homedir23(), ".mementos", "config.json");
+  const configPath = join212(homedir24(), ".mementos", "config.json");
   let fileConfig = {};
   if (existsSync28(configPath)) {
     try {
@@ -207791,12 +208500,12 @@ ${hookResult.additionalContext}` : hookResult.additionalContext
     return resultWithId;
   }
   createTimeout(ms, runner, subassistantId) {
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       const timerId = setTimeout(() => {
         this.activeTimeouts.delete(subassistantId);
         this.activeRunners.delete(subassistantId);
         runner.stop();
-        resolve11({
+        resolve12({
           success: false,
           error: `Subassistant timed out after ${Math.round(ms / 1000)} seconds`,
           turns: 0,
@@ -207815,7 +208524,7 @@ ${hookResult.additionalContext}` : hookResult.additionalContext
     }
   }
   sleep(ms) {
-    return new Promise((resolve11) => setTimeout(resolve11, ms));
+    return new Promise((resolve12) => setTimeout(resolve12, ms));
   }
 }
 var DEFAULT_MAX_DEPTH = 3, DEFAULT_MAX_CONCURRENT = 5, DEFAULT_MAX_TURNS = 10, MAX_ALLOWED_TURNS = 25, DEFAULT_TIMEOUT_MS3 = 120000, DEFAULT_SUBASSISTANT_TOOLS, FORBIDDEN_SUBASSISTANT_TOOLS;
@@ -207842,6 +208551,193 @@ var init_subagent_manager = __esm(() => {
   ];
 });
 
+// packages/core/src/agent/stats.ts
+class StatsTracker {
+  sessionId;
+  startedAt;
+  toolStats = new Map;
+  pendingCalls = new Map;
+  durations = new Map;
+  lastCallEndTime = null;
+  timeBetweenCalls = [];
+  llmCallCount = 0;
+  tokenUsage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    maxContextTokens: 180000
+  };
+  constructor(sessionId) {
+    this.sessionId = sessionId;
+    this.startedAt = new Date().toISOString();
+  }
+  onToolStart(toolCall) {
+    const startTime = Date.now();
+    if (this.lastCallEndTime !== null) {
+      const timeSinceLastCall = startTime - this.lastCallEndTime;
+      this.timeBetweenCalls.push(timeSinceLastCall);
+    }
+    this.pendingCalls.set(toolCall.id, {
+      toolCall,
+      startTime
+    });
+    if (!this.toolStats.has(toolCall.name)) {
+      this.toolStats.set(toolCall.name, {
+        name: toolCall.name,
+        callCount: 0,
+        successCount: 0,
+        failureCount: 0,
+        totalDurationMs: 0,
+        minDurationMs: Infinity,
+        maxDurationMs: 0,
+        avgDurationMs: 0,
+        medianDurationMs: 0,
+        lastDurationMs: 0,
+        lastExecutedAt: "",
+        truncatedCount: 0
+      });
+      this.durations.set(toolCall.name, []);
+    }
+  }
+  onToolEnd(toolCall, result) {
+    const endTime = Date.now();
+    const pending = this.pendingCalls.get(toolCall.id);
+    if (!pending) {
+      return;
+    }
+    const duration3 = endTime - pending.startTime;
+    this.lastCallEndTime = endTime;
+    this.pendingCalls.delete(toolCall.id);
+    const stats = this.toolStats.get(toolCall.name);
+    if (stats) {
+      stats.callCount++;
+      stats.totalDurationMs += duration3;
+      stats.minDurationMs = Math.min(stats.minDurationMs, duration3);
+      stats.maxDurationMs = Math.max(stats.maxDurationMs, duration3);
+      stats.lastDurationMs = duration3;
+      stats.lastExecutedAt = new Date().toISOString();
+      if (result.isError) {
+        stats.failureCount++;
+      } else {
+        stats.successCount++;
+      }
+      if (result.truncated) {
+        stats.truncatedCount++;
+      }
+      stats.avgDurationMs = Math.round(stats.totalDurationMs / stats.callCount);
+      const durationsArray = this.durations.get(toolCall.name);
+      if (durationsArray) {
+        durationsArray.push(duration3);
+        if (durationsArray.length > 100) {
+          durationsArray.shift();
+        }
+        stats.medianDurationMs = this.calculateMedian(durationsArray);
+      }
+    }
+  }
+  onLlmCall() {
+    this.llmCallCount++;
+  }
+  updateTokenUsage(usage) {
+    if (usage.inputTokens !== undefined) {
+      this.tokenUsage.inputTokens = usage.inputTokens;
+    }
+    if (usage.outputTokens !== undefined) {
+      this.tokenUsage.outputTokens = usage.outputTokens;
+    }
+    if (usage.totalTokens !== undefined) {
+      this.tokenUsage.totalTokens = usage.totalTokens;
+    }
+    if (usage.maxContextTokens !== undefined) {
+      this.tokenUsage.maxContextTokens = usage.maxContextTokens;
+    }
+    if (usage.cacheReadTokens !== undefined) {
+      this.tokenUsage.cacheReadTokens = usage.cacheReadTokens;
+    }
+    if (usage.cacheWriteTokens !== undefined) {
+      this.tokenUsage.cacheWriteTokens = usage.cacheWriteTokens;
+    }
+  }
+  getToolStats(toolName) {
+    return this.toolStats.get(toolName) || null;
+  }
+  getAllToolStats() {
+    return Array.from(this.toolStats.values());
+  }
+  getSessionStats() {
+    let totalToolCalls = 0;
+    let totalSuccessful = 0;
+    let totalFailed = 0;
+    let totalExecutionTimeMs = 0;
+    const toolStatsRecord = {};
+    for (const [name, stats] of this.toolStats) {
+      totalToolCalls += stats.callCount;
+      totalSuccessful += stats.successCount;
+      totalFailed += stats.failureCount;
+      totalExecutionTimeMs += stats.totalDurationMs;
+      toolStatsRecord[name] = { ...stats };
+    }
+    return {
+      sessionId: this.sessionId,
+      startedAt: this.startedAt,
+      totalToolCalls,
+      totalSuccessful,
+      totalFailed,
+      totalExecutionTimeMs,
+      avgTimeBetweenCallsMs: this.calculateAverage(this.timeBetweenCalls),
+      totalLlmCalls: this.llmCallCount,
+      tokenUsage: { ...this.tokenUsage },
+      toolStats: toolStatsRecord
+    };
+  }
+  getSummary() {
+    const stats = this.getSessionStats();
+    const successRate = stats.totalToolCalls > 0 ? Math.round(stats.totalSuccessful / stats.totalToolCalls * 100) : 100;
+    const avgDurationMs = stats.totalToolCalls > 0 ? Math.round(stats.totalExecutionTimeMs / stats.totalToolCalls) : 0;
+    const topTools = this.getAllToolStats().sort((a5, b5) => b5.callCount - a5.callCount).slice(0, 5).map((t9) => ({
+      name: t9.name,
+      count: t9.callCount,
+      avgMs: t9.avgDurationMs
+    }));
+    return {
+      totalToolCalls: stats.totalToolCalls,
+      successRate,
+      avgDurationMs,
+      topTools,
+      totalLlmCalls: this.llmCallCount,
+      tokensUsed: stats.tokenUsage.totalTokens
+    };
+  }
+  reset() {
+    this.toolStats.clear();
+    this.pendingCalls.clear();
+    this.durations.clear();
+    this.lastCallEndTime = null;
+    this.timeBetweenCalls = [];
+    this.llmCallCount = 0;
+    this.tokenUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      maxContextTokens: 180000
+    };
+    this.startedAt = new Date().toISOString();
+  }
+  calculateMedian(values3) {
+    if (values3.length === 0)
+      return 0;
+    const sorted = [...values3].sort((a5, b5) => a5 - b5);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0 ? Math.round((sorted[mid - 1] + sorted[mid]) / 2) : sorted[mid];
+  }
+  calculateAverage(values3) {
+    if (values3.length === 0)
+      return 0;
+    const sum = values3.reduce((a5, b5) => a5 + b5, 0);
+    return Math.round(sum / values3.length);
+  }
+}
+
 // packages/core/src/capabilities/types.ts
 var ORCHESTRATION_DEFAULTS, DEFAULT_CAPABILITY_SET, RESTRICTED_CAPABILITY_SET, COORDINATOR_CAPABILITY_SET;
 var init_types12 = __esm(() => {
@@ -208638,7 +209534,7 @@ __export(exports_dist2, {
 });
 import { existsSync as existsSync29, cpSync, mkdirSync as mkdirSync15, writeFileSync as writeFileSync10, rmSync as rmSync3, readdirSync as readdirSync12, statSync as statSync7, readFileSync as readFileSync14 } from "fs";
 import { join as join41, dirname as dirname16 } from "path";
-import { homedir as homedir24 } from "os";
+import { homedir as homedir25 } from "os";
 import { fileURLToPath as fileURLToPath6 } from "url";
 import { existsSync as existsSync210, readFileSync as readFileSync22, readdirSync as readdirSync22 } from "fs";
 import { join as join213 } from "path";
@@ -208866,7 +209762,7 @@ function getAgentSkillsDir(agent, scope = "global", projectDir) {
   if (scope === "project") {
     return join41(projectDir || process.cwd(), agentDir, "skills");
   }
-  return join41(homedir24(), agentDir, "skills");
+  return join41(homedir25(), agentDir, "skills");
 }
 function getAgentSkillPath(name, agent, scope = "global", projectDir) {
   const skillName = normalizeSkillName(name);
@@ -211617,6 +212513,7 @@ var init_loop = __esm(async () => {
   init_image();
   init_ask_user();
   init_wait();
+  init_notify();
   init_loader3();
   init_client3();
   init_errors();
@@ -211654,6 +212551,7 @@ var init_loop = __esm(async () => {
     init_workflows2(),
     init_skills2(),
     init_tmux(),
+    init_diff(),
     init_subagent(),
     init_executor3(),
     init_hooks(),
@@ -211777,6 +212675,7 @@ var init_loop = __esm(async () => {
     registryService = null;
     registeredAssistantId = null;
     swarmCoordinator = null;
+    statsTracker;
     paused = false;
     pauseResolve = null;
     maxTurnsPerRun = 50;
@@ -211806,6 +212705,7 @@ var init_loop = __esm(async () => {
       this.commandLoader = new CommandLoader(this.cwd);
       this.commandExecutor = new CommandExecutor(this.commandLoader);
       this.builtinCommands = new BuiltinCommands;
+      this.statsTracker = new StatsTracker(this.sessionId);
       this.allowedTools = this.normalizeAllowedTools(options2.allowedTools);
       this.extraSystemPrompt = options2.extraSystemPrompt || null;
       this.llmClient = options2.llmClient ?? null;
@@ -211985,7 +212885,9 @@ var init_loop = __esm(async () => {
       }));
       this.toolRegistry.register(WaitTool.tool, WaitTool.executor);
       this.toolRegistry.register(SleepTool.tool, SleepTool.executor);
+      this.toolRegistry.register(NotifyTool.tool, NotifyTool.executor);
       this.toolRegistry.register(TmuxTools.tool, TmuxTools.executor);
+      this.toolRegistry.register(DiffTool.tool, DiffTool.executor);
       if (this.config?.inbox?.enabled) {
         const { id: assistantId, name: assistantName } = this.getAssistantIdentity();
         this.inboxManager = createInboxManager(assistantId, assistantName, this.config.inbox, this.storageDir);
@@ -212121,6 +213023,7 @@ var init_loop = __esm(async () => {
         getAssistantManager: () => this.assistantManager,
         getIdentityManager: () => this.identityManager,
         getWalletManager: () => this.walletManager,
+        getStatsTracker: () => this.statsTracker,
         sessionId: this.sessionId,
         model: this.config?.llm?.model
       });
@@ -212562,8 +213465,8 @@ You are running in **autonomous mode**. You manage your own wakeup schedule.
             this.emit({ type: "text", content: `
 [Agent paused - budget exceeded. Use /budgets resume to continue.]
 ` });
-            await new Promise((resolve11) => {
-              this.pauseResolve = resolve11;
+            await new Promise((resolve12) => {
+              this.pauseResolve = resolve12;
             });
             this.pauseResolve = null;
             if (this.shouldStop)
@@ -213068,12 +213971,14 @@ You are running in **autonomous mode**. You manage your own wakeup schedule.
         this.recordHeartbeatActivity("tool");
         this.lastToolName = toolCall.name;
         this.pendingToolCalls.set(toolCall.id, toolCall.name);
+        this.statsTracker.onToolStart(toolCall);
         this.onToolStart?.(toolCall);
         const toolStartTime = Date.now();
         const result = await this.toolRegistry.execute(toolCall, signal);
         const toolDuration = Date.now() - toolStartTime;
         this.recordToolCallBudget(toolDuration);
         const stopAfterTool = this.shouldStop;
+        this.statsTracker.onToolEnd(toolCall, result);
         this.onToolEnd?.(toolCall, result);
         if (!stopAfterTool && !result.isError && toolCall.name === "bash") {
           const command = toolCall.input?.command;
@@ -213698,6 +214603,8 @@ You are running in **autonomous mode**. You manage your own wakeup schedule.
     }
     updateTokenUsage(usage) {
       this.builtinCommands.updateTokenUsage(usage);
+      this.statsTracker.updateTokenUsage(usage);
+      this.statsTracker.onLlmCall();
       this.onTokenUsage?.(this.builtinCommands.getTokenUsage());
       if (this.budgetTracker && (usage.inputTokens || usage.outputTokens)) {
         this.budgetTracker.recordLlmCall(usage.inputTokens || 0, usage.outputTokens || 0, 0);
@@ -214546,196 +215453,9 @@ Be concise but thorough. Focus only on this task.`,
   };
 });
 
-// packages/core/src/agent/stats.ts
-class StatsTracker {
-  sessionId;
-  startedAt;
-  toolStats = new Map;
-  pendingCalls = new Map;
-  durations = new Map;
-  lastCallEndTime = null;
-  timeBetweenCalls = [];
-  llmCallCount = 0;
-  tokenUsage = {
-    inputTokens: 0,
-    outputTokens: 0,
-    totalTokens: 0,
-    maxContextTokens: 180000
-  };
-  constructor(sessionId) {
-    this.sessionId = sessionId;
-    this.startedAt = new Date().toISOString();
-  }
-  onToolStart(toolCall) {
-    const startTime = Date.now();
-    if (this.lastCallEndTime !== null) {
-      const timeSinceLastCall = startTime - this.lastCallEndTime;
-      this.timeBetweenCalls.push(timeSinceLastCall);
-    }
-    this.pendingCalls.set(toolCall.id, {
-      toolCall,
-      startTime
-    });
-    if (!this.toolStats.has(toolCall.name)) {
-      this.toolStats.set(toolCall.name, {
-        name: toolCall.name,
-        callCount: 0,
-        successCount: 0,
-        failureCount: 0,
-        totalDurationMs: 0,
-        minDurationMs: Infinity,
-        maxDurationMs: 0,
-        avgDurationMs: 0,
-        medianDurationMs: 0,
-        lastDurationMs: 0,
-        lastExecutedAt: "",
-        truncatedCount: 0
-      });
-      this.durations.set(toolCall.name, []);
-    }
-  }
-  onToolEnd(toolCall, result) {
-    const endTime = Date.now();
-    const pending = this.pendingCalls.get(toolCall.id);
-    if (!pending) {
-      return;
-    }
-    const duration3 = endTime - pending.startTime;
-    this.lastCallEndTime = endTime;
-    this.pendingCalls.delete(toolCall.id);
-    const stats = this.toolStats.get(toolCall.name);
-    if (stats) {
-      stats.callCount++;
-      stats.totalDurationMs += duration3;
-      stats.minDurationMs = Math.min(stats.minDurationMs, duration3);
-      stats.maxDurationMs = Math.max(stats.maxDurationMs, duration3);
-      stats.lastDurationMs = duration3;
-      stats.lastExecutedAt = new Date().toISOString();
-      if (result.isError) {
-        stats.failureCount++;
-      } else {
-        stats.successCount++;
-      }
-      if (result.truncated) {
-        stats.truncatedCount++;
-      }
-      stats.avgDurationMs = Math.round(stats.totalDurationMs / stats.callCount);
-      const durationsArray = this.durations.get(toolCall.name);
-      if (durationsArray) {
-        durationsArray.push(duration3);
-        if (durationsArray.length > 100) {
-          durationsArray.shift();
-        }
-        stats.medianDurationMs = this.calculateMedian(durationsArray);
-      }
-    }
-  }
-  onLlmCall() {
-    this.llmCallCount++;
-  }
-  updateTokenUsage(usage) {
-    if (usage.inputTokens !== undefined) {
-      this.tokenUsage.inputTokens = usage.inputTokens;
-    }
-    if (usage.outputTokens !== undefined) {
-      this.tokenUsage.outputTokens = usage.outputTokens;
-    }
-    if (usage.totalTokens !== undefined) {
-      this.tokenUsage.totalTokens = usage.totalTokens;
-    }
-    if (usage.maxContextTokens !== undefined) {
-      this.tokenUsage.maxContextTokens = usage.maxContextTokens;
-    }
-    if (usage.cacheReadTokens !== undefined) {
-      this.tokenUsage.cacheReadTokens = usage.cacheReadTokens;
-    }
-    if (usage.cacheWriteTokens !== undefined) {
-      this.tokenUsage.cacheWriteTokens = usage.cacheWriteTokens;
-    }
-  }
-  getToolStats(toolName) {
-    return this.toolStats.get(toolName) || null;
-  }
-  getAllToolStats() {
-    return Array.from(this.toolStats.values());
-  }
-  getSessionStats() {
-    let totalToolCalls = 0;
-    let totalSuccessful = 0;
-    let totalFailed = 0;
-    let totalExecutionTimeMs = 0;
-    const toolStatsRecord = {};
-    for (const [name, stats] of this.toolStats) {
-      totalToolCalls += stats.callCount;
-      totalSuccessful += stats.successCount;
-      totalFailed += stats.failureCount;
-      totalExecutionTimeMs += stats.totalDurationMs;
-      toolStatsRecord[name] = { ...stats };
-    }
-    return {
-      sessionId: this.sessionId,
-      startedAt: this.startedAt,
-      totalToolCalls,
-      totalSuccessful,
-      totalFailed,
-      totalExecutionTimeMs,
-      avgTimeBetweenCallsMs: this.calculateAverage(this.timeBetweenCalls),
-      totalLlmCalls: this.llmCallCount,
-      tokenUsage: { ...this.tokenUsage },
-      toolStats: toolStatsRecord
-    };
-  }
-  getSummary() {
-    const stats = this.getSessionStats();
-    const successRate = stats.totalToolCalls > 0 ? Math.round(stats.totalSuccessful / stats.totalToolCalls * 100) : 100;
-    const avgDurationMs = stats.totalToolCalls > 0 ? Math.round(stats.totalExecutionTimeMs / stats.totalToolCalls) : 0;
-    const topTools = this.getAllToolStats().sort((a5, b5) => b5.callCount - a5.callCount).slice(0, 5).map((t9) => ({
-      name: t9.name,
-      count: t9.callCount,
-      avgMs: t9.avgDurationMs
-    }));
-    return {
-      totalToolCalls: stats.totalToolCalls,
-      successRate,
-      avgDurationMs,
-      topTools,
-      totalLlmCalls: this.llmCallCount,
-      tokensUsed: stats.tokenUsage.totalTokens
-    };
-  }
-  reset() {
-    this.toolStats.clear();
-    this.pendingCalls.clear();
-    this.durations.clear();
-    this.lastCallEndTime = null;
-    this.timeBetweenCalls = [];
-    this.llmCallCount = 0;
-    this.tokenUsage = {
-      inputTokens: 0,
-      outputTokens: 0,
-      totalTokens: 0,
-      maxContextTokens: 180000
-    };
-    this.startedAt = new Date().toISOString();
-  }
-  calculateMedian(values3) {
-    if (values3.length === 0)
-      return 0;
-    const sorted = [...values3].sort((a5, b5) => a5 - b5);
-    const mid = Math.floor(sorted.length / 2);
-    return sorted.length % 2 === 0 ? Math.round((sorted[mid - 1] + sorted[mid]) / 2) : sorted[mid];
-  }
-  calculateAverage(values3) {
-    if (values3.length === 0)
-      return 0;
-    const sum = values3.reduce((a5, b5) => a5 + b5, 0);
-    return Math.round(sum / values3.length);
-  }
-}
-
 // packages/core/src/tools/connector-index.ts
 import { join as join45, dirname as dirname18 } from "path";
-import { homedir as homedir25 } from "os";
+import { homedir as homedir26 } from "os";
 import { existsSync as existsSync33, mkdirSync as mkdirSync17, writeFileSync as writeFileSync12, readFileSync as readFileSync16 } from "fs";
 var TAG_KEYWORDS, INDEX_VERSION = 1, INDEX_TTL_MS, ConnectorIndex;
 var init_connector_index = __esm(() => {
@@ -214770,7 +215490,7 @@ var init_connector_index = __esm(() => {
     }
     getHomeDir() {
       const envHome = process.env.HOME || process.env.USERPROFILE;
-      return envHome && envHome.trim().length > 0 ? envHome : homedir25();
+      return envHome && envHome.trim().length > 0 ? envHome : homedir26();
     }
     getCachePath() {
       return join45(this.getHomeDir(), ".assistants", "cache", "connector-index.json");
@@ -215160,7 +215880,7 @@ function inferToolMetadata(tool2) {
     category = "skills";
   } else if (name.startsWith("web_") || name === "curl") {
     category = "web";
-  } else if (["read", "write", "glob", "grep", "read_pdf"].includes(name)) {
+  } else if (["read", "write", "glob", "grep", "read_pdf", "diff"].includes(name)) {
     category = "filesystem";
   } else if (name === "bash") {
     category = "system";
@@ -215176,7 +215896,7 @@ function inferToolMetadata(tool2) {
     category = "connectors";
     source = "connector";
   }
-  if (!name.includes("_") && !["bash", "read", "write", "glob", "grep", "curl", "wait", "sleep", "feedback"].includes(name)) {
+  if (!name.includes("_") && !["bash", "read", "write", "glob", "grep", "curl", "wait", "sleep", "feedback", "diff"].includes(name)) {
     source = "connector";
     category = "connectors";
   }
@@ -216003,89 +216723,6 @@ var init_security2 = __esm(async () => {
   init_network_validator();
 });
 
-// packages/core/src/features.ts
-function isAWSConfigured() {
-  return !!(process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY);
-}
-function isElevenLabsConfigured() {
-  return !!process.env.ELEVENLABS_API_KEY;
-}
-function isOpenAIConfigured() {
-  return !!process.env.OPENAI_API_KEY;
-}
-function isAnyLLMConfigured() {
-  return LLM_PROVIDERS.some((provider3) => !!process.env[provider3.apiKeyEnv]);
-}
-function isExaConfigured() {
-  return !!process.env.EXA_API_KEY;
-}
-function isSystemVoiceAvailable() {
-  return process.platform === "darwin";
-}
-function getFeatureAvailability() {
-  return {
-    coreChat: isAnyLLMConfigured(),
-    awsFeatures: isAWSConfigured(),
-    elevenLabsTTS: isElevenLabsConfigured(),
-    whisperSTT: isOpenAIConfigured(),
-    exaSearch: isExaConfigured(),
-    systemVoice: isSystemVoiceAvailable()
-  };
-}
-function getFeatureStatusMessage() {
-  const features = getFeatureAvailability();
-  const lines = [];
-  if (!features.coreChat) {
-    lines.push("\u26A0\uFE0F  ANTHROPIC_API_KEY not set - core chat disabled");
-  } else {
-    lines.push("\u2713 Core chat enabled");
-  }
-  if (features.awsFeatures) {
-    lines.push("\u2713 AWS features available (inbox, wallet, secrets)");
-  } else {
-    lines.push("\u25CB AWS features disabled (set AWS_REGION to enable)");
-  }
-  if (features.elevenLabsTTS) {
-    lines.push("\u2713 ElevenLabs TTS available");
-  }
-  if (features.whisperSTT) {
-    lines.push("\u2713 Whisper STT available");
-  }
-  if (features.systemVoice) {
-    lines.push("\u2713 System voice available (macOS)");
-  }
-  if (features.exaSearch) {
-    lines.push("\u2713 Exa enhanced search available");
-  }
-  return lines.join(`
-`);
-}
-function validateFeatureEnvVars(config2) {
-  const warnings = [];
-  if (config2.inbox?.enabled && !isAWSConfigured()) {
-    warnings.push("inbox.enabled is true but AWS credentials are not configured");
-  }
-  if (config2.wallet?.enabled && !isAWSConfigured()) {
-    warnings.push("wallet.enabled is true but AWS credentials are not configured");
-  }
-  const secretsProvider = config2.secrets?.storage?.provider || "local";
-  if (config2.secrets?.enabled && secretsProvider === "aws" && !isAWSConfigured()) {
-    warnings.push("secrets.enabled is true but AWS credentials are not configured");
-  }
-  if (config2.voice?.enabled) {
-    if (config2.voice.tts?.provider === "elevenlabs" && !isElevenLabsConfigured()) {
-      warnings.push("voice.tts.provider is elevenlabs but ELEVENLABS_API_KEY is not set");
-    }
-    if (config2.voice.stt?.provider === "whisper" && !isOpenAIConfigured()) {
-      warnings.push("voice.stt.provider is whisper but OPENAI_API_KEY is not set");
-    }
-  }
-  return warnings;
-}
-var init_features = __esm(() => {
-  init_src2();
-});
-
 // packages/core/src/index.ts
 var exports_src3 = {};
 __export(exports_src3, {
@@ -216654,6 +217291,7 @@ __export(exports_src3, {
   EmailParser: () => EmailParser,
   ElevenLabsTTS: () => ElevenLabsTTS,
   ElevenLabsSTT: () => ElevenLabsSTT,
+  DiffTool: () => DiffTool,
   DEFAULT_WATCHDOG_INTERVAL_MS: () => DEFAULT_WATCHDOG_INTERVAL_MS,
   DEFAULT_TOOL_RULES: () => DEFAULT_TOOL_RULES,
   DEFAULT_SYSTEM_POLICY: () => DEFAULT_SYSTEM_POLICY,
@@ -216773,6 +217411,7 @@ var init_src3 = __esm(async () => {
     init_workflows2(),
     init_scheduler(),
     init_tmux(),
+    init_diff(),
     init_projects(),
     init_heartbeat(),
     init_logs(),
@@ -217186,14 +217825,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
       actScopeDepth = prevActScopeDepth;
     }
-    function recursivelyFlushAsyncActWork(returnValue, resolve11, reject) {
+    function recursivelyFlushAsyncActWork(returnValue, resolve12, reject) {
       var queue = ReactSharedInternals.actQueue;
       if (queue !== null)
         if (queue.length !== 0)
           try {
             flushActQueue(queue);
             enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve11, reject);
+              return recursivelyFlushAsyncActWork(returnValue, resolve12, reject);
             });
             return;
           } catch (error4) {
@@ -217201,7 +217840,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           }
         else
           ReactSharedInternals.actQueue = null;
-      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve11(returnValue);
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve12(returnValue);
     }
     function flushActQueue(queue) {
       if (!isFlushing) {
@@ -217377,14 +218016,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
         });
         return {
-          then: function(resolve11, reject) {
+          then: function(resolve12, reject) {
             didAwaitActCall = true;
             thenable.then(function(returnValue) {
               popActScope(prevActQueue, prevActScopeDepth);
               if (prevActScopeDepth === 0) {
                 try {
                   flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve11, reject);
+                    return recursivelyFlushAsyncActWork(returnValue, resolve12, reject);
                   });
                 } catch (error$0) {
                   ReactSharedInternals.thrownErrors.push(error$0);
@@ -217395,7 +218034,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
                   reject(_thrownError);
                 }
               } else
-                resolve11(returnValue);
+                resolve12(returnValue);
             }, function(error4) {
               popActScope(prevActQueue, prevActScopeDepth);
               0 < ReactSharedInternals.thrownErrors.length ? (error4 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error4)) : reject(error4);
@@ -217411,11 +218050,11 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       if (0 < ReactSharedInternals.thrownErrors.length)
         throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
       return {
-        then: function(resolve11, reject) {
+        then: function(resolve12, reject) {
           didAwaitActCall = true;
           prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve11, reject);
-          })) : resolve11(returnValue$jscomp$0);
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve12, reject);
+          })) : resolve12(returnValue$jscomp$0);
         }
       };
     };
@@ -220174,7 +220813,7 @@ function wrapAnsi(string4, columns, options2) {
   return String(string4).normalize().replaceAll(`\r
 `, `
 `).split(`
-`).map((line) => exec3(line, columns, options2)).join(`
+`).map((line) => exec4(line, columns, options2)).join(`
 `);
 }
 var ESCAPES, END_CODE = 39, ANSI_ESCAPE_BELL = "\x07", ANSI_CSI = "[", ANSI_OSC = "]", ANSI_SGR_TERMINATOR = "m", ANSI_ESCAPE_LINK, wrapAnsiCode = (code3) => `${ESCAPES.values().next().value}${ANSI_CSI}${code3}${ANSI_SGR_TERMINATOR}`, wrapAnsiHyperlink = (url) => `${ESCAPES.values().next().value}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`, wordLengths = (string4) => string4.split(" ").map((character) => stringWidth(character)), wrapWord = (rows, word, columns) => {
@@ -220228,7 +220867,7 @@ var ESCAPES, END_CODE = 39, ANSI_ESCAPE_BELL = "\x07", ANSI_CSI = "[", ANSI_OSC
     return string4;
   }
   return words.slice(0, last).join(" ") + words.slice(last).join("");
-}, exec3 = (string4, columns, options2 = {}) => {
+}, exec4 = (string4, columns, options2 = {}) => {
   if (options2.trim !== false && string4.trim() === "") {
     return "";
   }
@@ -220354,7 +220993,7 @@ function terminalSize() {
   }
   return devTty() ?? tput() ?? resize() ?? fallback;
 }
-var defaultColumns = 80, defaultRows = 24, exec4 = (command, arguments_, { shell, env: env3 } = {}) => execFileSync(command, arguments_, {
+var defaultColumns = 80, defaultRows = 24, exec5 = (command, arguments_, { shell, env: env3 } = {}) => execFileSync(command, arguments_, {
   encoding: "utf8",
   stdio: ["ignore", "pipe", "ignore"],
   timeout: 500,
@@ -220403,8 +221042,8 @@ var defaultColumns = 80, defaultRows = 24, exec4 = (command, arguments_, { shell
   } catch {}
 }, tput = () => {
   try {
-    const columns = exec4("tput", ["cols"], { env: { TERM: "dumb", ...process3.env } });
-    const rows = exec4("tput", ["lines"], { env: { TERM: "dumb", ...process3.env } });
+    const columns = exec5("tput", ["cols"], { env: { TERM: "dumb", ...process3.env } });
+    const rows = exec5("tput", ["lines"], { env: { TERM: "dumb", ...process3.env } });
     if (columns && rows) {
       return createIfNotDefault(columns, rows);
     }
@@ -220414,7 +221053,7 @@ var defaultColumns = 80, defaultRows = 24, exec4 = (command, arguments_, { shell
     if (!isForegroundProcess()) {
       return;
     }
-    const size = exec4("resize", ["-u"]).match(/\d+/g);
+    const size = exec5("resize", ["-u"]).match(/\d+/g);
     if (size.length === 2) {
       return createIfNotDefault(size[0], size[1]);
     }
@@ -222837,8 +223476,8 @@ It can also happen if the client has a browser extension installed which messes
         currentEntangledActionThenable = {
           status: "pending",
           value: undefined,
-          then: function(resolve11) {
-            entangledListeners.push(resolve11);
+          then: function(resolve12) {
+            entangledListeners.push(resolve12);
           }
         };
       }
@@ -222862,8 +223501,8 @@ It can also happen if the client has a browser extension installed which messes
         status: "pending",
         value: null,
         reason: null,
-        then: function(resolve11) {
-          listeners.push(resolve11);
+        then: function(resolve12) {
+          listeners.push(resolve12);
         }
       };
       thenable.then(function() {
@@ -233194,7 +233833,7 @@ function diffAnsiCodes(from, to) {
     ...to.filter((code3) => !startCodesInFrom.has(code3.code))
   ];
 }
-var init_diff = __esm(() => {
+var init_diff2 = __esm(() => {
   init_ansiCodes();
   init_undo();
 });
@@ -233233,7 +233872,7 @@ function styledCharsToString(chars) {
 }
 var init_styledChars = __esm(() => {
   init_ansiCodes();
-  init_diff();
+  init_diff2();
   init_reduce();
 });
 
@@ -233366,7 +234005,7 @@ var init_tokenize = __esm(() => {
 // node_modules/.pnpm/@alcalzone+ansi-tokenize@0.2.5/node_modules/@alcalzone/ansi-tokenize/build/index.js
 var init_build = __esm(() => {
   init_ansiCodes();
-  init_diff();
+  init_diff2();
   init_reduce();
   init_undo();
   init_styledChars();
@@ -235148,8 +235787,8 @@ class Ink {
     }
   }
   async waitUntilExit() {
-    this.exitPromise ||= new Promise((resolve11, reject) => {
-      this.resolveExitPromise = resolve11;
+    this.exitPromise ||= new Promise((resolve12, reject) => {
+      this.resolveExitPromise = resolve12;
       this.rejectExitPromise = reject;
     });
     if (!this.beforeExitHandler) {
@@ -236248,14 +236887,14 @@ var require_filesystem = __commonJS((exports, module) => {
     fs7.close(fd, () => {});
     return buffer.subarray(0, bytesRead);
   };
-  var readFile10 = (path5) => new Promise((resolve11, reject) => {
+  var readFile10 = (path5) => new Promise((resolve12, reject) => {
     fs7.open(path5, "r", (err, fd) => {
       if (err) {
         reject(err);
       } else {
         const buffer = Buffer.alloc(MAX_LENGTH);
         fs7.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
-          resolve11(buffer.subarray(0, bytesRead));
+          resolve12(buffer.subarray(0, bytesRead));
           fs7.close(fd, () => {});
         });
       }
@@ -236316,10 +236955,10 @@ var require_detect_libc = __commonJS((exports, module) => {
   var commandOut = "";
   var safeCommand = () => {
     if (!commandOut) {
-      return new Promise((resolve11) => {
+      return new Promise((resolve12) => {
         childProcess.exec(command, (err, out) => {
           commandOut = err ? " " : out;
-          resolve11(commandOut);
+          resolve12(commandOut);
         });
       });
     }
@@ -238876,14 +239515,14 @@ var require_input = __commonJS((exports, module) => {
       return this;
     } else {
       if (this._isStreamInput()) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           const finished = () => {
             this._flattenBufferIn();
             sharp.metadata(this.options, (err, metadata2) => {
               if (err) {
                 reject(is2.nativeError(err, stack));
               } else {
-                resolve11(metadata2);
+                resolve12(metadata2);
               }
             });
           };
@@ -238894,12 +239533,12 @@ var require_input = __commonJS((exports, module) => {
           }
         });
       } else {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           sharp.metadata(this.options, (err, metadata2) => {
             if (err) {
               reject(is2.nativeError(err, stack));
             } else {
-              resolve11(metadata2);
+              resolve12(metadata2);
             }
           });
         });
@@ -238932,25 +239571,25 @@ var require_input = __commonJS((exports, module) => {
       return this;
     } else {
       if (this._isStreamInput()) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           this.on("finish", function() {
             this._flattenBufferIn();
             sharp.stats(this.options, (err, stats2) => {
               if (err) {
                 reject(is2.nativeError(err, stack));
               } else {
-                resolve11(stats2);
+                resolve12(stats2);
               }
             });
           });
         });
       } else {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           sharp.stats(this.options, (err, stats2) => {
             if (err) {
               reject(is2.nativeError(err, stack));
             } else {
-              resolve11(stats2);
+              resolve12(stats2);
             }
           });
         });
@@ -242349,7 +242988,7 @@ var require_output = __commonJS((exports, module) => {
       return this;
     } else {
       if (this._isStreamInput()) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           this.once("finish", () => {
             this._flattenBufferIn();
             sharp.pipeline(this.options, (err, data, info) => {
@@ -242357,24 +242996,24 @@ var require_output = __commonJS((exports, module) => {
                 reject(is2.nativeError(err, stack));
               } else {
                 if (this.options.resolveWithObject) {
-                  resolve11({ data, info });
+                  resolve12({ data, info });
                 } else {
-                  resolve11(data);
+                  resolve12(data);
                 }
               }
             });
           });
         });
       } else {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           sharp.pipeline(this.options, (err, data, info) => {
             if (err) {
               reject(is2.nativeError(err, stack));
             } else {
               if (this.options.resolveWithObject) {
-                resolve11({ data, info });
+                resolve12({ data, info });
               } else {
-                resolve11(data);
+                resolve12(data);
               }
             }
           });
@@ -242610,7 +243249,7 @@ var init_image3 = __esm(() => {
 
 // node_modules/.pnpm/ink-picture@1.3.3_ink@6.7.0_@types+react@19.2.14_react-devtools-core@7.0.1_react@19.2.4__react@19.2.4/node_modules/ink-picture/build/utils/queryEscapeSequence.js
 function queryEscapeSequence(message, stdin, stdout, setRawMode) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const responseTimeout = 100;
     let responseTimeoutId = undefined;
     const timeoutBetweenReplies = 50;
@@ -242638,18 +243277,18 @@ function queryEscapeSequence(message, stdin, stdout, setRawMode) {
       runningReply += data;
       timeoutBetweenRepliesId = setTimeout(() => {
         restoreState();
-        resolve11(runningReply.length > 0 ? runningReply : undefined);
+        resolve12(runningReply.length > 0 ? runningReply : undefined);
       }, timeoutBetweenReplies);
     };
     const onClose = () => {
       restoreState();
-      resolve11(runningReply.length > 0 ? runningReply : undefined);
+      resolve12(runningReply.length > 0 ? runningReply : undefined);
     };
     stdin.on("data", onData);
     stdin.on("close", onClose);
     responseTimeoutId = setTimeout(() => {
       restoreState();
-      resolve11(undefined);
+      resolve12(undefined);
     }, responseTimeout);
     stdout.write(message);
   });
@@ -242835,15 +243474,15 @@ var require_windows = __commonJS((exports, module) => {
     }
     return false;
   }
-  function checkStat(stat6, path5, options2) {
-    if (!stat6.isSymbolicLink() && !stat6.isFile()) {
+  function checkStat(stat7, path5, options2) {
+    if (!stat7.isSymbolicLink() && !stat7.isFile()) {
       return false;
     }
     return checkPathExt(path5, options2);
   }
   function isexe(path5, options2, cb2) {
-    fs7.stat(path5, function(er, stat6) {
-      cb2(er, er ? false : checkStat(stat6, path5, options2));
+    fs7.stat(path5, function(er, stat7) {
+      cb2(er, er ? false : checkStat(stat7, path5, options2));
     });
   }
   function sync(path5, options2) {
@@ -242857,20 +243496,20 @@ var require_mode = __commonJS((exports, module) => {
   isexe.sync = sync;
   var fs7 = __require("fs");
   function isexe(path5, options2, cb2) {
-    fs7.stat(path5, function(er, stat6) {
-      cb2(er, er ? false : checkStat(stat6, options2));
+    fs7.stat(path5, function(er, stat7) {
+      cb2(er, er ? false : checkStat(stat7, options2));
     });
   }
   function sync(path5, options2) {
     return checkStat(fs7.statSync(path5), options2);
   }
-  function checkStat(stat6, options2) {
-    return stat6.isFile() && checkMode(stat6, options2);
+  function checkStat(stat7, options2) {
+    return stat7.isFile() && checkMode(stat7, options2);
   }
-  function checkMode(stat6, options2) {
-    var mod = stat6.mode;
-    var uid = stat6.uid;
-    var gid = stat6.gid;
+  function checkMode(stat7, options2) {
+    var mod = stat7.mode;
+    var uid = stat7.uid;
+    var gid = stat7.gid;
     var myUid = options2.uid !== undefined ? options2.uid : process.getuid && process.getuid();
     var myGid = options2.gid !== undefined ? options2.gid : process.getgid && process.getgid();
     var u5 = parseInt("100", 8);
@@ -242902,12 +243541,12 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve11, reject) {
+      return new Promise(function(resolve12, reject) {
         isexe(path5, options2 || {}, function(er, is2) {
           if (er) {
             reject(er);
           } else {
-            resolve11(is2);
+            resolve12(is2);
           }
         });
       });
@@ -242969,27 +243608,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i6) => new Promise((resolve11, reject) => {
+    const step = (i6) => new Promise((resolve12, reject) => {
       if (i6 === pathEnv.length)
-        return opt.all && found.length ? resolve11(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve12(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i6];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
       const pCmd = path5.join(pathPart, cmd);
       const p5 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve11(subStep(p5, i6, 0));
+      resolve12(subStep(p5, i6, 0));
     });
-    const subStep = (p5, i6, ii) => new Promise((resolve11, reject) => {
+    const subStep = (p5, i6, ii) => new Promise((resolve12, reject) => {
       if (ii === pathExt.length)
-        return resolve11(step(i6 + 1));
+        return resolve12(step(i6 + 1));
       const ext = pathExt[ii];
       isexe(p5 + ext, { pathExt: pathExtExe }, (er, is2) => {
         if (!er && is2) {
           if (opt.all)
             found.push(p5 + ext);
           else
-            return resolve11(p5 + ext);
+            return resolve12(p5 + ext);
         }
-        return resolve11(subStep(p5, i6, ii + 1));
+        return resolve12(subStep(p5, i6, ii + 1));
       });
     });
     return cb2 ? step(0).then((res) => cb2(null, res), cb2) : step(0);
@@ -243876,7 +244515,7 @@ var require_kill = __commonJS((exports, module) => {
       return spawnedPromise;
     }
     let timeoutId;
-    const timeoutPromise = new Promise((resolve11, reject) => {
+    const timeoutPromise = new Promise((resolve12, reject) => {
       timeoutId = setTimeout(() => {
         timeoutKill(spawned, killSignal, reject);
       }, timeout);
@@ -243987,7 +244626,7 @@ var require_get_stream = __commonJS((exports, module) => {
     };
     const { maxBuffer } = options2;
     const stream2 = bufferStream(options2);
-    await new Promise((resolve11, reject) => {
+    await new Promise((resolve12, reject) => {
       const rejectPromise = (error4) => {
         if (error4 && stream2.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
           error4.bufferedData = stream2.getBufferedValue();
@@ -243997,7 +244636,7 @@ var require_get_stream = __commonJS((exports, module) => {
       (async () => {
         try {
           await streamPipelinePromisified(inputStream, stream2);
-          resolve11();
+          resolve12();
         } catch (error4) {
           rejectPromise(error4);
         }
@@ -244144,9 +244783,9 @@ var require_promise = __commonJS((exports, module) => {
     return spawned;
   };
   var getSpawnedPromise = (spawned) => {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       spawned.on("exit", (exitCode, signal) => {
-        resolve11({ exitCode, signal });
+        resolve12({ exitCode, signal });
       });
       spawned.on("error", (error4) => {
         reject(error4);
@@ -257781,7 +258420,7 @@ await __promiseAll([
 var import_react86 = __toESM(require_react(), 1);
 import { spawn as spawn6 } from "child_process";
 import { join as join48 } from "path";
-import { homedir as homedir26 } from "os";
+import { homedir as homedir27 } from "os";
 
 // packages/terminal/src/components/Input.tsx
 await init_build2();
@@ -258436,16 +259075,20 @@ var Input = import_react30.default.forwardRef(function Input2({
   };
   useSafeInput((input, key) => {
     if (key.ctrl && input === "c") {
+      if (isProcessing && onStopProcessing) {
+        onStopProcessing();
+        return;
+      }
       if (value2.length > 0) {
         setValueAndCursor("");
       }
       return;
     }
+    if (key.escape && isProcessing && onStopProcessing) {
+      onStopProcessing();
+      return;
+    }
     if (key.escape && !isAskingUser) {
-      if (isProcessing && onStopProcessing) {
-        onStopProcessing();
-        return;
-      }
       if (largePaste) {
         setLargePaste(null);
         setShowPastePreview(false);
@@ -262082,35 +262725,47 @@ function QueueIndicator({
   const hasMore = totalCount > maxPreview;
   const inlineCount = messages2.filter((msg) => msg.mode === "inline").length;
   const queuedCount = messages2.filter((msg) => msg.mode === "queued").length;
+  const parts = [];
+  if (queuedCount > 0)
+    parts.push(`${queuedCount} queued`);
+  if (inlineCount > 0)
+    parts.push(`${inlineCount} in-stream`);
+  const summary = parts.join(", ");
   return /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
     flexDirection: "column",
+    marginTop: 0,
+    marginBottom: 0,
     children: [
-      /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
-        dimColor: true,
+      previewItems.map((msg) => /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
         children: [
-          "\u21B3 ",
-          totalCount,
-          " pending",
-          totalCount > 1 ? "" : "",
-          inlineCount > 0 || queuedCount > 0 ? ` \xB7 ${inlineCount} in-stream \xB7 ${queuedCount} queued` : ""
+          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+            color: msg.mode === "inline" ? "cyan" : "yellow",
+            children: [
+              msg.mode === "inline" ? "\u26A1" : "\u23F3",
+              " ",
+              msg.mode === "inline" ? "in-stream" : "queued",
+              ":",
+              " "
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+            dimColor: true,
+            children: [
+              '"',
+              truncateQueued(msg.content, 60),
+              '"'
+            ]
+          }, undefined, true, undefined, this)
         ]
-      }, undefined, true, undefined, this),
-      previewItems.map((queued) => /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
-        marginLeft: 2,
-        children: /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
-          dimColor: true,
-          children: [
-            "\u21B3 ",
-            truncateQueued(queued.content)
-          ]
-        }, undefined, true, undefined, this)
-      }, queued.id, false, undefined, this)),
+      }, msg.id, true, undefined, this)),
       hasMore && /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
         dimColor: true,
         children: [
           "  +",
           totalCount - maxPreview,
-          " more"
+          " more (",
+          summary,
+          ")"
         ]
       }, undefined, true, undefined, this)
     ]
@@ -289347,7 +290002,7 @@ var HOOK_TYPE_SET = new Set(["command", "prompt", "assistant"]);
 var HOOK_LOCATION_SET = new Set(["project", "user", "local"]);
 var HOOK_EVENT_MAP = new Map(Array.from(HOOK_EVENT_SET).map((ev) => [ev.toLowerCase(), ev]));
 async function runShellCommand(command, cwd3) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const child = spawn6(command, { cwd: cwd3, shell: true, env: process.env });
     const stdoutChunks = [];
     const stderrChunks = [];
@@ -289376,7 +290031,7 @@ async function runShellCommand(command, cwd3) {
     }
     child.on("error", (error4) => reject(error4));
     child.on("close", (code3) => {
-      resolve11({
+      resolve12({
         stdout: Buffer.concat(stdoutChunks).toString("utf8").trimEnd(),
         stderr: Buffer.concat(stderrChunks).toString("utf8").trimEnd(),
         exitCode: code3,
@@ -289693,7 +290348,7 @@ function App2({ cwd: cwd3, version: version4 }) {
     setInlinePending((prev) => prev.filter((msg) => msg.id !== id));
   }, []);
   const beginAskUser = import_react86.useCallback((sessionId, request2) => {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       if (askUserStateRef.current.has(sessionId)) {
         reject(new Error("Another interview is already in progress for this session."));
         return;
@@ -289703,7 +290358,7 @@ function App2({ cwd: cwd3, version: version4 }) {
         request: request2,
         index: 0,
         answers: {},
-        resolve: resolve11,
+        resolve: resolve12,
         reject
       };
       askUserStateRef.current.set(sessionId, state);
@@ -289774,7 +290429,7 @@ function App2({ cwd: cwd3, version: version4 }) {
     }
   }, [activeSessionId]);
   const beginInterview = import_react86.useCallback((sessionId, request2) => {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       if (interviewStateRef.current.has(sessionId)) {
         reject(new Error("Another interview is already in progress for this session."));
         return;
@@ -289791,7 +290446,7 @@ function App2({ cwd: cwd3, version: version4 }) {
         sessionId,
         interviewId,
         request: request2,
-        resolve: resolve11,
+        resolve: resolve12,
         reject
       };
       interviewStateRef.current.set(sessionId, state);
@@ -289847,8 +290502,8 @@ function App2({ cwd: cwd3, version: version4 }) {
     }
   }, [isProcessing, processingStartTime]);
   import_react86.useEffect(() => {
-    const { exec: exec5 } = __require("child_process");
-    exec5("git branch --show-current 2>/dev/null", { cwd: cwd3 }, (err, stdout2) => {
+    const { exec: exec6 } = __require("child_process");
+    exec6("git branch --show-current 2>/dev/null", { cwd: cwd3 }, (err, stdout2) => {
       if (!err && stdout2?.trim()) {
         setGitBranch(stdout2.trim());
       }
@@ -291129,7 +291784,7 @@ function App2({ cwd: cwd3, version: version4 }) {
   }, [recoverableSessions, createSessionFromRecovery, workspaceBaseDir]);
   const handleOnboardingComplete = import_react86.useCallback(async (result) => {
     const { existsSync: existsSync30, mkdirSync: mkdirSync19, readFileSync: readFileSync18, writeFileSync: writeFileSync13, appendFileSync: appendFileSync5 } = await import("fs");
-    const secretsPath = join48(homedir26(), ".secrets");
+    const secretsPath = join48(homedir27(), ".secrets");
     const providerInfo = getProviderInfo(result.provider);
     const envName = providerInfo?.apiKeyEnv || "ANTHROPIC_API_KEY";
     const keyExport = `export ${envName}="${result.apiKey}"`;
@@ -294451,7 +295106,7 @@ process.on("unhandledRejection", (reason) => {
   cleanup();
   process.exit(1);
 });
-var VERSION4 = "1.1.85";
+var VERSION4 = "1.1.86";
 var SYNC_START = "\x1B[?2026h";
 var SYNC_END = "\x1B[?2026l";
 function enableSynchronizedOutput() {
@@ -294596,4 +295251,4 @@ export {
   main
 };
 
-//# debugId=B3102F77510944A864756E2164756E21
+//# debugId=27FD559CEE6360B064756E2164756E21