@aiderdesk/aiderdesk 0.64.0 → 0.66.0

package/out/runner.js

@@ -31,22 +31,25 @@ const node_sqlite = require("node:sqlite");
 const path = require("path");
 const os = require("os");
 const http = require("http");
-const gpt4o = require("gpt-tokenizer/model/gpt-4o");
 const istextorbinary = require("istextorbinary");
 const child_process = require("child_process");
+const util = require("util");
 const treeKill = require("tree-kill");
+const ai = require("ai");
 const glob = require("glob");
 const fs$1 = require("fs");
-const util = require("util");
 const dotenvx = require("@dotenvx/dotenvx");
 const YAML = require("yaml");
 const posthogNode = require("posthog-node");
 const langfuseVercel = require("langfuse-vercel");
+const otel = require("@posthog/ai/otel");
 const simpleGit = require("simple-git");
 const filenamifyImport = require("filenamify");
 const slugify = require("slugify");
+const AdmZip = require("adm-zip");
 const Turndown = require("turndown");
 const cheerio = require("cheerio");
+const gpt4o = require("gpt-tokenizer/model/gpt-4o");
 const uuid = require("uuid");
 const index_js = require("@modelcontextprotocol/sdk/client/index.js");
 const stdio_js = require("@modelcontextprotocol/sdk/client/stdio.js");
@@ -63,7 +66,6 @@ const debounce = require("lodash/debounce.js");
 const crypto = require("crypto");
 const undici = require("undici");
 const globalAgent = require("global-agent");
-const ai = require("ai");
 const fileType = require("file-type");
 const anthropic = require("@ai-sdk/anthropic");
 const azure = require("@ai-sdk/azure");
@@ -234,7 +236,7 @@ const TASKS_TOOL_DESCRIPTIONS = {
   [TASKS_TOOL_LIST_TASKS]: "List all tasks in the current project. Returns basic information for each task including id, name, and creation/update timestamps. Use this to get an overview of all available tasks before performing specific task operations.",
   [TASKS_TOOL_GET_TASK]: "Get comprehensive details about a specific task by its ID. Returns task metadata, current state, list of context files with their read-only status, and the total count of context messages. Use this to understand a task's configuration and context before working with it or its messages.",
   [TASKS_TOOL_GET_TASK_MESSAGE]: "Retrieve a specific message from a task's conversation history by message index and task ID. The first message (index 0) is always the user's initial prompt, and subsequent messages alternate between user and assistant. Use this to examine the conversation flow, understand previous interactions, or extract specific information from the task history.",
-  [TASKS_TOOL_CREATE_TASK]: "Create a new task in the current project with an initial prompt. Optionally specify an agent profile ID to use different capabilities, a model ID to override the default model, or a parentTaskId to create a subtask of another task. The parentTaskId parameter is only available for top-level tasks; if the current task is itself a subtask, you cannot create subtasks from it. The new task will start with the provided prompt as its first user message. Use this to begin new work streams, separate different aspects of a project, or break down complex tasks into manageable subtasks. Use execute to create a task and wait for the task to be finished. Use executeInBackground to create a task in the background without waiting for the task to be finished.",
+  [TASKS_TOOL_CREATE_TASK]: "Create a new task in the current project with an initial prompt. Optionally use user-provided agentProfileId to use a different agent, a modelId to override the model, or a parentTaskId (if available) to create a subtask of another task. The new task will start with the provided prompt as its first user message. Use this to begin new work streams, separate different aspects of a project, or break down complex tasks into manageable subtasks. Use execute to create a task and wait for the task to be finished. Use executeInBackground to create a task in the background without waiting for the task to be finished.",
   [TASKS_TOOL_DELETE_TASK]: "Permanently delete a task and all its associated data including messages, context files, and metadata. This action cannot be undone. Note that you cannot delete the currently active task. Use this to clean up completed or abandoned tasks, but be cautious as this removes all task history permanently.",
   [TASKS_TOOL_SEARCH_TASK]: "Search content within a specific task using semantic search. Use natural language queries with 2-5 descriptive words including key concepts and context. Searches through task conversation history and context files. Use this to find relevant information, discussions, or code snippets within a task.",
   [TASKS_TOOL_SEARCH_PARENT_TASK]: "Search content within parent task using semantic search. Use natural language queries with 2-5 descriptive words including key concepts and context. Automatically searches parent task conversation history and context files."
@@ -297,7 +299,6 @@ const ProjectSettingsSchema = zod.z.object({
   reasoningEffort: zod.z.string().optional(),
   thinkingTokens: zod.z.string().optional(),
   currentMode: zod.z.string(),
-  contextCompactingThreshold: zod.z.number().optional(),
   weakModelLocked: zod.z.boolean().optional(),
   autoApproveLocked: zod.z.boolean().optional(),
   updatedFilesGroupMode: zod.z.enum(["grouped", "flat"]).default("flat"),
@@ -335,6 +336,7 @@ var MemoryEmbeddingProvider = /* @__PURE__ */ ((MemoryEmbeddingProvider2) => {
 var ContextCompactionType = /* @__PURE__ */ ((ContextCompactionType2) => {
   ContextCompactionType2["Compact"] = "compact";
   ContextCompactionType2["Handoff"] = "handoff";
+  ContextCompactionType2["Smart"] = "smart";
   return ContextCompactionType2;
 })(ContextCompactionType || {});
 var MemoryEmbeddingProgressPhase = /* @__PURE__ */ ((MemoryEmbeddingProgressPhase2) => {
@@ -380,7 +382,7 @@ const TaskDataSchema = zod.z.object({
   reasoningEffort: zod.z.string().optional(),
   thinkingTokens: zod.z.string().optional(),
   currentMode: zod.z.string().optional(),
-  contextCompactingThreshold: zod.z.number().optional(),
+  contextCompactingThresholdTokens: zod.z.number().optional(),
   weakModelLocked: zod.z.boolean().optional(),
   handoff: zod.z.boolean().optional(),
   lastAgentProviderMetadata: zod.z.unknown().optional(),
@@ -455,6 +457,20 @@ const extractTextContent = (content) => {
   }
   return "";
 };
+const extractImagesFromContent = (content) => {
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  const images = content.filter((part) => part.type === "image").map((part) => {
+    const data = part.image;
+    if (typeof data !== "string") {
+      return void 0;
+    }
+    const mediaType = part.mediaType || "image/png";
+    return data.startsWith("data:") ? data : `data:${mediaType};base64,${data}`;
+  }).filter((v) => v !== void 0);
+  return images.length > 0 ? images : void 0;
+};
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const parseUsageReport = (model, report) => {
   const sentMatch = report.match(/Tokens: ([\d.]+k?) sent/);
@@ -547,6 +563,7 @@ const extractProviderModel = (modelId) => {
   const [providerId, ...modelParts] = modelId.split("/");
   return [providerId, modelParts.join("/")];
 };
+const isUuid = (id) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
 const DEFAULT_PAGE_SIZE = 100;
 class LogBuffer {
   db = null;
@@ -793,6 +810,7 @@ const AIDER_DESK_CONNECTOR_DIR = path.join(AIDER_DESK_DATA_DIR, "aider-connector
 const AIDER_DESK_MCP_SERVER_DIR = path.join(AIDER_DESK_DATA_DIR, "mcp-server");
 const AIDER_DESK_BIN_DIR = path.join(AIDER_DESK_DATA_DIR, "bin");
 const UV_EXECUTABLE = process.platform === "win32" ? path.join(AIDER_DESK_BIN_DIR, "uv.exe") : path.join(AIDER_DESK_BIN_DIR, "uv");
+const RIPGREP_BINARY_PATH = process.platform === "win32" ? path.join(AIDER_DESK_BIN_DIR, "rg.exe") : path.join(AIDER_DESK_BIN_DIR, "rg");
 const SERVER_PORT = process.env.AIDER_DESK_PORT ? parseInt(process.env.AIDER_DESK_PORT) : 24337;
 const PID_FILES_DIR = path.join(AIDER_DESK_DATA_DIR, "aider-processes");
 const AIDER_DESK_DIR = ".aider-desk";
@@ -816,7 +834,9 @@ const AIDER_DESK_MEMORY_FILE = path.join(AIDER_DESK_DATA_DIR, "memory.db");
 const EXTENSIONS_REPOS_CACHE_DIR = path.join(AIDER_DESK_CACHE_DIR, "extensions");
 const POSTHOG_PUBLIC_API_KEY = "phc_AF4zkjrcziXLh8PBFsRSvVr4VZ38p3ezsdX0KDYuElI";
 const POSTHOG_HOST = "https://eu.i.posthog.com";
-process.env.AIDER_DESK_HEADLESS === "true";
+const HEADLESS_MODE = process.env.AIDER_DESK_HEADLESS === "true";
+const APP_TYPE = process.env.AIDER_DESK_APP_TYPE || (HEADLESS_MODE ? "docker" : "electron");
+process.env.AIDER_DESK_DISABLE_MENU === "true";
 const AUTH_USERNAME = process.env.AIDER_DESK_USERNAME;
 const AUTH_PASSWORD = process.env.AIDER_DESK_PASSWORD;
 const CORS_ALLOWED_ORIGINS = process.env.AIDER_DESK_CORS_ALLOWED_ORIGINS;
@@ -875,7 +895,7 @@ class ApprovalManager {
   async handleToolApproval(toolName, input, key, text, subject) {
     const extensionResult = await this.task.dispatchExtensionEvent("onToolApproval", { toolName, input });
     if (extensionResult.blocked) {
-      return [false, void 0];
+      return [false, typeof extensionResult.blocked === "string" ? extensionResult.blocked : void 0];
     }
     if (extensionResult.allowed) {
       return [true, void 0];
@@ -1548,7 +1568,7 @@ const DEFAULT_AGENT_PROFILE = {
   name: "Default Agent",
   provider: "anthropic",
   model: DEFAULT_PROVIDER_MODELS.anthropic,
-  maxIterations: 250,
+  maxIterations: 0,
   minTimeBetweenToolCalls: 0,
   toolApprovals: {
     // aider tools
@@ -1869,7 +1889,8 @@ const getDefaultProviderParams = (providerName) => {
         name: "openai-compatible",
         apiKey: "",
         baseUrl: "",
-        reasoningEffort: ReasoningEffort.None
+        reasoningEffort: ReasoningEffort.None,
+        trackTokenUsage: true
       };
       break;
     case "litellm":
@@ -1984,7 +2005,7 @@ class TelemetryManager {
   }
   async init() {
     try {
-      await Promise.resolve().then(() => require("./open-telemetry-CcefKvbB.js"));
+      await Promise.resolve().then(() => require("./open-telemetry-baOvr6sK.js"));
       const app = getElectronApp();
       this.client = new posthogNode.PostHog(POSTHOG_PUBLIC_API_KEY, {
         host: POSTHOG_HOST
@@ -1994,7 +2015,8 @@ class TelemetryManager {
         distinctId: this.distinctId,
         properties: {
           os: process.platform,
-          version: app?.getVersion()
+          version: app?.getVersion(),
+          appType: APP_TYPE
         }
       });
     } catch (error) {
@@ -2157,6 +2179,24 @@ const getLangfuseEnvironmentVariables = (baseDir, settings) => {
     LANGFUSE_HOST: getEffectiveEnvironmentVariable("LANGFUSE_HOST", settings, baseDir)?.value
   };
 };
+const initializePostHogExporter = () => {
+  const posthogApiKey = getEffectiveEnvironmentVariable("POSTHOG_API_KEY");
+  const posthogHost = getEffectiveEnvironmentVariable("POSTHOG_HOST");
+  if (posthogApiKey) {
+    logger.info("Initializing PostHog Trace Exporter...");
+    return new otel.PostHogTraceExporter({
+      apiKey: posthogApiKey.value,
+      host: posthogHost?.value || "https://us.i.posthog.com"
+    });
+  }
+  return void 0;
+};
+const getPostHogAiderEnvironmentVariables = (baseDir, settings) => {
+  return {
+    POSTHOG_API_KEY: getEffectiveEnvironmentVariable("POSTHOG_API_KEY", settings, baseDir)?.value,
+    POSTHOG_API_URL: getEffectiveEnvironmentVariable("POSTHOG_HOST", settings, baseDir)?.value
+  };
+};
 const readEnvFile = (filePath) => {
   try {
     if (fs$1.existsSync(filePath)) {
@@ -2353,7 +2393,8 @@ const getEnvironmentVariablesForAider = (settings, baseDir) => {
 };
 const getTelemetryEnvironmentVariablesForAider = (settings, baseDir) => {
   return {
-    ...getLangfuseEnvironmentVariables(baseDir, settings)
+    ...getLangfuseEnvironmentVariables(baseDir, settings),
+    ...getPostHogAiderEnvironmentVariables(baseDir, settings)
   };
 };
 const getDefaultProjectSettings = (store, providerModels, baseDir, defaultAgentProfileId = DEFAULT_AGENT_PROFILE.id, providers) => {
@@ -2843,8 +2884,8 @@ const downloadUv = async () => {
         strip: 1
       });
     } else if (filename.endsWith(".zip")) {
-      const AdmZip = (await import("adm-zip")).default;
-      const zip = new AdmZip(tempFile);
+      const AdmZip2 = (await import("adm-zip")).default;
+      const zip = new AdmZip2(tempFile);
       zip.extractAllTo(AIDER_DESK_BIN_DIR, true);
     }
     if (platform !== "win32") {
@@ -2907,6 +2948,111 @@ const getLatestPythonLibVersion = async (library) => {
     return null;
   }
 };
+const RIPGREP_VERSION = "15.1.0";
+const RIPGREP_BASE_URL = `https://github.com/BurntSushi/ripgrep/releases/download/${RIPGREP_VERSION}`;
+const getRipgrepAssetName = () => {
+  const platform = process.platform;
+  const arch = process.arch;
+  if (platform === "win32") {
+    return arch === "arm64" ? `ripgrep-${RIPGREP_VERSION}-aarch64-pc-windows-msvc.zip` : `ripgrep-${RIPGREP_VERSION}-x86_64-pc-windows-msvc.zip`;
+  }
+  if (platform === "darwin") {
+    return arch === "arm64" ? `ripgrep-${RIPGREP_VERSION}-aarch64-apple-darwin.tar.gz` : `ripgrep-${RIPGREP_VERSION}-x86_64-apple-darwin.tar.gz`;
+  }
+  if (arch === "arm64") {
+    return `ripgrep-${RIPGREP_VERSION}-aarch64-unknown-linux-gnu.tar.gz`;
+  }
+  return `ripgrep-${RIPGREP_VERSION}-x86_64-unknown-linux-musl.tar.gz`;
+};
+const isRipgrepAvailable = () => {
+  try {
+    if (!fs$1.existsSync(RIPGREP_BINARY_PATH)) {
+      return false;
+    }
+    const result = child_process.execSync(`"${RIPGREP_BINARY_PATH}" --version`, {
+      encoding: "utf8",
+      timeout: 5e3,
+      windowsHide: true
+    });
+    if (!result.includes("ripgrep")) {
+      return false;
+    }
+    logger.debug(`ripgrep is available at ${RIPGREP_BINARY_PATH}: ${result.trim()}`);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const downloadRipgrep = async () => {
+  const filename = getRipgrepAssetName();
+  const url = `${RIPGREP_BASE_URL}/${filename}`;
+  if (!fs$1.existsSync(AIDER_DESK_BIN_DIR)) {
+    fs$1.mkdirSync(AIDER_DESK_BIN_DIR, { recursive: true });
+  }
+  const tempFile = path.join(AIDER_DESK_BIN_DIR, filename);
+  const rgExeName = process.platform === "win32" ? "rg.exe" : "rg";
+  try {
+    logger.info(`Downloading ripgrep from ${url}`);
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    fs$1.writeFileSync(tempFile, buffer);
+    if (filename.endsWith(".tar.gz")) {
+      const { extract } = await import("tar");
+      await extract({
+        cwd: AIDER_DESK_BIN_DIR,
+        file: tempFile,
+        strip: 1
+      });
+    } else if (filename.endsWith(".zip")) {
+      const zip = new AdmZip(tempFile);
+      const entry = zip.getEntry(rgExeName) || zip.getEntries().find((e) => e.entryName.endsWith(rgExeName));
+      if (entry) {
+        fs$1.writeFileSync(path.join(AIDER_DESK_BIN_DIR, rgExeName), entry.getData());
+      } else {
+        throw new Error(`Could not find ${rgExeName} in zip archive`);
+      }
+    }
+    if (process.platform !== "win32") {
+      fs$1.chmodSync(path.join(AIDER_DESK_BIN_DIR, rgExeName), 493);
+    }
+    logger.info(`ripgrep downloaded successfully to ${AIDER_DESK_BIN_DIR}`);
+  } finally {
+    if (fs$1.existsSync(tempFile)) {
+      fs$1.unlinkSync(tempFile);
+    }
+  }
+};
+let ripgrepEnsured = false;
+let ripgrepEnsurePromise = null;
+const ensureRipgrepBinary = async () => {
+  if (ripgrepEnsured) {
+    return true;
+  }
+  if (!ripgrepEnsurePromise) {
+    ripgrepEnsurePromise = (async () => {
+      if (isRipgrepAvailable()) {
+        ripgrepEnsured = true;
+        return;
+      }
+      await downloadRipgrep();
+      if (!isRipgrepAvailable()) {
+        throw new Error("ripgrep binary not found after download");
+      }
+      ripgrepEnsured = true;
+    })();
+  }
+  try {
+    await ripgrepEnsurePromise;
+    return true;
+  } catch (error) {
+    ripgrepEnsurePromise = null;
+    logger.error("Failed to ensure ripgrep binary:", error);
+    return false;
+  }
+};
 const isAbortError = (error) => {
   if (!(error instanceof Error)) {
     return false;
@@ -3078,18 +3224,25 @@ const expandTilde = (filePath) => {
   }
   return filePath;
 };
-const readFileContent = async (absolutePath, withLines = false, lineOffset = 0, lineLimit = 1e3, sizeLimit = 0.05 * lineLimit) => {
+const readFileContent = async (absolutePath, withLines = false, lineOffset = 0, lineLimit = 1e3, sizeLimit = Math.max(50, 0.05 * lineLimit)) => {
   const fileContentBuffer = await fs.readFile(absolutePath);
   if (istextorbinary.isBinary(absolutePath, fileContentBuffer)) {
     throw new Error("Binary files cannot be read.");
   }
-  const fileSizeKB = fileContentBuffer.length / 1024;
-  if (fileSizeKB > sizeLimit) {
-    const truncatedBytes = fileContentBuffer.subarray(0, Math.floor(sizeLimit * 1024));
+  const fileContent = fileContentBuffer.toString("utf8");
+  const lines = fileContent.split("\n");
+  const totalLines = lines.length;
+  const startIndex = Math.max(0, lineOffset);
+  const endIndex = Math.min(totalLines, startIndex + lineLimit);
+  const limitedLines = lines.slice(startIndex, endIndex);
+  const limitedContent = limitedLines.join("\n");
+  const limitedSizeKB = Buffer.byteLength(limitedContent, "utf8") / 1024;
+  if (limitedSizeKB > sizeLimit) {
+    const truncatedBytes = Buffer.from(limitedContent, "utf8").subarray(0, Math.floor(sizeLimit * 1024));
     const truncatedContent = truncatedBytes.toString("utf8");
     const truncatedLines = truncatedContent.split("\n");
     if (withLines) {
-      return truncatedLines.map((line, index) => `${index + 1}|${line}`).join("\n") + `
+      return truncatedLines.map((line, index) => `${startIndex + index + 1}|${line}`).join("\n") + `
 
 File size limit (${sizeLimit.toFixed(1)} KB) exceeded. Use shell commands (e.g., head, tail, grep) to read specific parts.`;
     }
@@ -3097,33 +3250,27 @@ File size limit (${sizeLimit.toFixed(1)} KB) exceeded. Use shell commands (e.g.,
 
 File size limit (${sizeLimit.toFixed(1)} KB) exceeded. Use shell commands (e.g., head, tail, grep) to read specific parts.`;
   }
-  const fileContent = fileContentBuffer.toString("utf8");
-  const lines = fileContent.split("\n");
-  const totalLines = lines.length;
-  const startIndex = Math.max(0, lineOffset);
-  const endIndex = Math.min(totalLines, startIndex + lineLimit);
-  let limitedLines = lines.slice(startIndex, endIndex);
+  let resultLines = limitedLines;
   if (withLines) {
-    limitedLines = limitedLines.map((line, index) => `${startIndex + index + 1}|${line}`);
+    resultLines = limitedLines.map((line, index) => `${startIndex + index + 1}|${line}`);
   }
   if (endIndex < totalLines) {
-    limitedLines.push("...");
-    limitedLines.push(`Total lines in the file: ${totalLines}`);
+    resultLines = [...resultLines, "...", `Total lines in the file: ${totalLines}`];
   }
-  return limitedLines.join("\n");
+  return resultLines.join("\n");
 };
-const truncateToolResult = async (content, maxLines = 1e3, maxSizeKB = 50) => {
+const truncateToolResult = async (content, maxLines = 1e3, maxSizeKB = 50, maxTokens = 5e4) => {
   const lines = content.split("\n");
   const sizeBytes = Buffer.byteLength(content, "utf8");
   const sizeKB = sizeBytes / 1024;
-  if (lines.length <= maxLines && sizeKB <= maxSizeKB) {
+  const tokenCount = maxTokens === Infinity ? 0 : gpt4o.encode(content).length;
+  if (lines.length <= maxLines && sizeKB <= maxSizeKB && tokenCount <= maxTokens) {
     return content;
   }
   const id = Date.now().toString(36) + Math.random().toString(36).substring(2, 8);
   const tmpFileName = `aider-desk-tool-result-${id}.txt`;
   const tmpFilePath = path.join(os.tmpdir(), tmpFileName);
   await fs.writeFile(tmpFilePath, content, "utf8");
-  const previewLines = lines.slice(0, maxLines);
   const reasons = [];
   if (lines.length > maxLines) {
     reasons.push(`${lines.length} lines exceeded limit of ${maxLines}`);
@@ -3131,9 +3278,126 @@ const truncateToolResult = async (content, maxLines = 1e3, maxSizeKB = 50) => {
   if (sizeKB > maxSizeKB) {
     reasons.push(`${sizeKB.toFixed(1)} KB exceeded limit of ${maxSizeKB} KB`);
   }
-  return previewLines.join("\n") + `
+  if (tokenCount > maxTokens) {
+    reasons.push(`${tokenCount} tokens exceeded limit of ${maxTokens}`);
+  }
+  if (tokenCount > maxTokens) {
+    const headBudget = Math.floor(maxTokens / 2);
+    const tailBudget = maxTokens - headBudget;
+    const headLines = [];
+    let headTokens = 0;
+    for (const line of lines) {
+      const lineTokens = gpt4o.encode(line).length;
+      if (headTokens + lineTokens > headBudget) {
+        break;
+      }
+      headLines.push(line);
+      headTokens += lineTokens;
+    }
+    const tailLines = [];
+    let tailTokens = 0;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (headLines.length + tailLines.length >= lines.length) {
+        break;
+      }
+      const lineTokens = gpt4o.encode(lines[i]).length;
+      if (tailTokens + lineTokens > tailBudget) {
+        break;
+      }
+      tailLines.unshift(lines[i]);
+      tailTokens += lineTokens;
+    }
+    const omittedLines = lines.length - headLines.length - tailLines.length;
+    const truncationNotice = `
+
+... ${omittedLines} lines omitted (${reasons.join(", ")}). Full content saved to ${tmpFilePath}.
+
+`;
+    return headLines.join("\n") + truncationNotice + tailLines.join("\n");
+  }
+  let preview;
+  if (sizeKB > maxSizeKB) {
+    const maxBytes = Math.floor(maxSizeKB * 1024);
+    const contentBuffer = Buffer.from(content, "utf8");
+    preview = contentBuffer.subarray(0, maxBytes).toString("utf8");
+  } else {
+    preview = lines.slice(0, maxLines).join("\n");
+  }
+  return preview + `
 ... Content truncated (${reasons.join(", ")}). Full content saved to ${tmpFilePath}.`;
 };
+const NETWORK_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT", "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH", "EAI_AGAIN"];
+const UNDICI_ERROR_PREFIX = "UND_ERR_";
+const isNetworkError = (error) => {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  if (error instanceof TypeError && error.message === "terminated") {
+    return true;
+  }
+  if ("code" in error) {
+    const code = error.code;
+    if (typeof code === "string") {
+      if (code.startsWith(UNDICI_ERROR_PREFIX)) {
+        return true;
+      }
+      if (NETWORK_ERROR_CODES.includes(code)) {
+        return true;
+      }
+    }
+  }
+  if (error.cause instanceof Error && isNetworkError(error.cause)) {
+    return true;
+  }
+  return false;
+};
+const IMAGE_TOKEN_ESTIMATE = 1e3;
+const extractToolResultText = (output) => {
+  if (!output || typeof output !== "object") {
+    return "";
+  }
+  const o = output;
+  if (o.type === "text" || o.type === "error-text") {
+    return String(o.value ?? "");
+  }
+  if (o.type === "json" || o.type === "error-json") {
+    return JSON.stringify(o.value);
+  }
+  if (o.type === "content" && Array.isArray(o.value)) {
+    return o.value.map((v) => v.type === "text" ? v.text ?? "" : v.type === "media" ? "[media]" : "").join("\n");
+  }
+  return JSON.stringify(output);
+};
+const estimateMessageTokens = (messages) => {
+  let estimatedImageTokens = 0;
+  const textOnlyMessages = messages.map((msg) => {
+    if (typeof msg.content === "string") {
+      return msg;
+    }
+    if (!Array.isArray(msg.content)) {
+      return { role: msg.role, content: "" };
+    }
+    const parts = msg.content;
+    const textParts = [];
+    for (const part of parts) {
+      const type = part.type;
+      if (type === "text" && typeof part.text === "string") {
+        textParts.push(part.text);
+      } else if (type === "tool-call") {
+        textParts.push(JSON.stringify(part.input ?? ""));
+      } else if (type === "tool-result") {
+        textParts.push(extractToolResultText(part.output));
+      } else if (type === "reasoning" && typeof part.text === "string") {
+        textParts.push(part.text);
+      } else if (type === "image") {
+        estimatedImageTokens += IMAGE_TOKEN_ESTIMATE;
+      }
+    }
+    return { role: msg.role, content: textParts.join("\n\n") };
+  });
+  return textOnlyMessages.reduce((sum, msg) => sum + gpt4o.encode(typeof msg.content === "string" ? msg.content : "").length, 0) + estimatedImageTokens;
+};
+const execFileAsync = util.promisify(child_process.execFile);
 const fileLocks = /* @__PURE__ */ new Map();
 const withFileLock = (filePath, operation) => {
   logger.debug("Acquiring file lock:", { filePath });
@@ -3445,50 +3709,80 @@ Do not use escape characters \\ in the string like \\n or \\" and others. Do not
       if (!isApproved) {
         return `Grep search for '${searchTerm}' in files matching '${filePattern}' denied by user. Reason: ${userInput}`;
       }
+      const rgAvailable = await ensureRipgrepBinary();
+      if (!rgAvailable) {
+        return "Error: ripgrep binary is not available. Please try again or check the logs for details.";
+      }
       try {
-        const files = await glob.glob(filePattern, {
-          cwd: task.getTaskDir(),
-          nodir: true,
-          absolute: true,
-          signal: abortSignal
+        const rgArgs = ["--no-heading", "--line-number", "--color", "never", "--max-count", String(maxResults)];
+        if (!caseSensitive) {
+          rgArgs.push("-i");
+        }
+        if (contextLines > 0) {
+          rgArgs.push("-C", String(contextLines));
+        }
+        rgArgs.push("-g", filePattern);
+        rgArgs.push("--", searchTerm, ".");
+        const taskDir = task.getTaskDir();
+        logger.debug("Executing ripgrep:", {
+          binary: RIPGREP_BINARY_PATH,
+          args: rgArgs,
+          cwd: taskDir
         });
-        if (files.length === 0) {
-          return `No files found matching pattern '${filePattern}'.`;
-        }
-        const filteredFiles = await filterIgnoredFiles(task.getTaskDir(), files);
-        if (filteredFiles.length === 0) {
-          return `No files found matching pattern '${filePattern}' (all files were ignored).`;
+        const { stdout, stderr } = await execFileAsync(RIPGREP_BINARY_PATH, rgArgs, {
+          cwd: taskDir,
+          env: { ...process.env, TERM: "dumb", PATH: getShellPath() },
+          maxBuffer: 10 * 1024 * 1024,
+          windowsHide: true
+        });
+        logger.debug("ripgrep stdout raw:", { stdout: stdout.substring(0, 2e3) });
+        logger.debug("ripgrep stderr:", { stderr: stderr.substring(0, 2e3) });
+        const outputLines = stdout.split("\n").filter(Boolean);
+        logger.debug("outputLines count:", { count: outputLines.length, lines: outputLines.slice(0, 20) });
+        if (outputLines.length === 0) {
+          return `No matches found for pattern '${searchTerm}' in files matching '${filePattern}'.`;
         }
         const results = [];
-        const searchRegex = new RegExp(searchTerm, caseSensitive ? void 0 : "i");
-        for (const absoluteFilePath of filteredFiles) {
-          const fileContent = await fs.readFile(absoluteFilePath, {
-            encoding: "utf8",
-            signal: abortSignal
-          });
-          const lines2 = fileContent.split("\n");
-          const relativeFilePath = path.relative(task.getTaskDir(), absoluteFilePath);
-          for (let index = 0; index < lines2.length; index++) {
-            const line = lines2[index];
-            if (searchRegex.test(line)) {
-              if (results.length >= maxResults) {
-                break;
-              }
-              const matchResult = {
-                filePath: relativeFilePath,
-                lineNumber: index + 1,
-                lineContent: line
-              };
-              if (contextLines > 0) {
-                const start = Math.max(0, index - contextLines);
-                const end = Math.min(lines2.length - 1, index + contextLines);
-                matchResult.context = lines2.slice(start, end + 1);
+        const outputLineRegex = /^(.+?)([:-])(\d+)\2(.*)$/;
+        for (let rawLine of outputLines) {
+          if (rawLine.endsWith("\r")) {
+            rawLine = rawLine.slice(0, -1);
+          }
+          const line = rawLine;
+          const match = outputLineRegex.exec(line);
+          if (!match) {
+            continue;
+          }
+          const [, rawFilePath, separator, lineNumStr, content] = match;
+          const lineNum = parseInt(lineNumStr, 10);
+          if (isNaN(lineNum)) {
+            continue;
+          }
+          const filePath = rawFilePath.startsWith("./") ? rawFilePath.slice(2) : rawFilePath;
+          const isMatch = separator === ":";
+          if (isMatch) {
+            results.push({
+              filePath,
+              lineNumber: lineNum,
+              lineContent: content
+            });
+          } else {
+            const lastResult = results[results.length - 1];
+            if (lastResult) {
+              if (!lastResult.context) {
+                lastResult.context = [];
               }
-              results.push(matchResult);
+              lastResult.context.push(content);
             }
           }
+          if (results.length >= maxResults) {
+            break;
+          }
         }
         if (results.length === 0) {
+          if (stderr.trim()) {
+            return `Error during grep: ${stderr.trim()}`;
+          }
           return `No matches found for pattern '${searchTerm}' in files matching '${filePattern}'.`;
         }
         const grouped = {};
@@ -3498,33 +3792,33 @@ Do not use escape characters \\ in the string like \\n or \\" and others. Do not
           }
           grouped[r.filePath].push(r);
         }
-        const lines = [];
-        lines.push(`## Grep Results: \`${searchTerm}\` in \`${filePattern}\` (${results.length} matches)`);
-        lines.push("");
+        const markdownLines = [];
+        markdownLines.push(`## Grep Results: \`${searchTerm}\` in \`${filePattern}\` (${results.length} matches)`);
+        markdownLines.push("");
         for (const [filePath, matches] of Object.entries(grouped)) {
-          lines.push(`### ${filePath} (${matches.length} ${matches.length === 1 ? "match" : "matches"})`);
+          markdownLines.push(`### ${filePath} (${matches.length} ${matches.length === 1 ? "match" : "matches"})`);
           for (const match of matches) {
             const escapedContent = match.lineContent.replace(/`/g, "\\`");
-            lines.push(`- **L${match.lineNumber}:** \`${escapedContent}\``);
+            markdownLines.push(`- **L${match.lineNumber}:** \`${escapedContent}\``);
             if (match.context && match.context.length > 0) {
-              lines.push("  ```");
+              markdownLines.push("  ```");
               for (const ctxLine of match.context) {
-                lines.push(`  ${ctxLine}`);
+                markdownLines.push(`  ${ctxLine}`);
               }
-              lines.push("  ```");
+              markdownLines.push("  ```");
             }
           }
-          lines.push("");
+          markdownLines.push("");
         }
         const notices = [];
         if (results.length >= maxResults) {
           notices.push(`${maxResults} matches limit reached. Use maxResults=${maxResults * 2} for more, or refine pattern`);
         }
         if (notices.length > 0) {
-          lines.push("---");
-          lines.push(`[${notices.join(". ")}]`);
+          markdownLines.push("---");
+          markdownLines.push(`[${notices.join(". ")}]`);
         }
-        return lines.join("\n");
+        return await truncateToolResult(markdownLines.join("\n"), 1e3, 50, 1e4);
       } catch (error) {
         if (isAbortError(error)) {
           return "Operation was cancelled by user.";
@@ -3581,6 +3875,18 @@ Timeout: ${timeout}ms`;
         return `Bash command execution denied by user. Reason: ${userInput}`;
       }
       const absoluteCwd = expandedCwd ? path.resolve(task.getTaskDir(), expandedCwd) : task.getTaskDir();
+      const isPosix = process.platform !== "win32";
+      const killProcess = (pid) => {
+        if (isPosix) {
+          try {
+            process.kill(-pid, "SIGKILL");
+          } catch {
+            treeKill(pid, "SIGKILL");
+          }
+        } else {
+          treeKill(pid, "SIGKILL");
+        }
+      };
       return await new Promise((resolve) => {
         let stdout = "";
         let stderr = "";
@@ -3604,8 +3910,8 @@ Timeout: ${timeout}ms`;
           }
           isResolved = true;
           cleanup();
-          const truncatedStdout = await truncateToolResult(stdout);
-          const truncatedStderr = await truncateToolResult(stderr);
+          const truncatedStdout = await truncateToolResult(stdout, 1e3, 50, 1e4);
+          const truncatedStderr = await truncateToolResult(stderr, 1e3, 50, 1e4);
           resolve({ stdout: truncatedStdout, stderr: truncatedStderr, exitCode });
         };
         abortListener = () => {
@@ -3613,7 +3919,7 @@ Timeout: ${timeout}ms`;
             return;
           }
           if (childProcess?.pid) {
-            treeKill(childProcess.pid, "SIGKILL");
+            killProcess(childProcess.pid);
           }
           stderr = "Operation was cancelled by user.";
           exitCode = 130;
@@ -3627,6 +3933,7 @@ Timeout: ${timeout}ms`;
             env: { ...process.env, TERM: "dumb", DEBIAN_FRONTEND: "noninteractive", PATH: getShellPath() },
             stdio: ["ignore", "pipe", "pipe"],
             // Explicitly pipe stdout and stderr to capture output from piped commands
+            detached: isPosix,
             signal: abortSignal
           });
           timeoutHandle = setTimeout(() => {
@@ -3634,7 +3941,7 @@ Timeout: ${timeout}ms`;
               return;
             }
             if (childProcess?.pid) {
-              treeKill(childProcess.pid, "SIGKILL");
+              killProcess(childProcess.pid);
             }
             stderr = `Error: Command timed out after ${timeout}ms. Consider increasing the timeout parameter.`;
             exitCode = 124;
@@ -3745,7 +4052,8 @@ Format: ${format}`;
         return `Error: Invalid URL provided: ${url}. Please provide a valid URL.`;
       }
       try {
-        return await scrapeWeb(url, timeout, abortSignal, format);
+        const content = await scrapeWeb(url, timeout, abortSignal, format);
+        return await truncateToolResult(content, 1e3, 50, 1e4);
       } catch (error) {
         if (isAbortError(error)) {
           return "Operation was cancelled by user.";
@@ -4014,6 +4322,11 @@ const createTasksToolset = (settings, task, profile, promptContext) => {
         if (state) {
           allTasks = allTasks.filter((t) => t.state === state);
         }
+        allTasks.sort((a, b) => {
+          const dateA = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
+          const dateB = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
+          return dateB - dateA;
+        });
         const startIndex = Math.max(0, offset);
         const endIndex = startIndex + Math.max(0, limit || allTasks.length);
         const paginatedTasks = allTasks.slice(startIndex, endIndex);
@@ -4130,34 +4443,35 @@ const createTasksToolset = (settings, task, profile, promptContext) => {
       }
     }
   });
-  const isSubtask = task.task.parentId !== null;
   const autoGenerateTaskName = settings.taskSettings.autoGenerateTaskName;
   const nameProperty = autoGenerateTaskName ? zod.z.string().optional().describe("Optional concise name for the new task. If not provided, the task name will be auto-generated from the prompt.") : zod.z.string().describe("Concise name for the new task.");
-  const CreateTaskInputSchema = zod.z.object({
-    prompt: zod.z.string().describe("The initial prompt for the new task"),
-    name: nameProperty,
-    agentProfileId: zod.z.string().optional().describe("Optional agent profile ID to use for the task. Use only when explicitly requested by the user."),
-    modelId: zod.z.string().optional().describe("Optional model ID to use for the task. Use only when explicitly requested by the user."),
-    mode: zod.z.string().optional().default("agent").describe("Optional mode to use for the task. Use only when explicitly requested by the user."),
-    asSubtask: zod.z.boolean().optional().default(false).describe("If true, the task will be created as a subtask of the current task. Use only when explicitly requested by the user."),
-    autoApprove: zod.z.boolean().optional().default(false).describe(
-      "If true, the task will be created with auto-approve enabled. Set autoApprove to true when no planning is needed, just execution of the task with all the work."
-    ),
-    worktree: zod.z.boolean().optional().default(false).describe("If true, the task will be created in worktree mode. Use only when explicitly requested by the user."),
-    executeAndWait: zod.z.boolean().optional().default(false).describe("If true, the task will be created and executed immediately and the tool will wait for it to complete before returning."),
-    executeInBackground: zod.z.boolean().optional().default(false).describe("If true, the task will be created and executed in the background.")
-  });
-  const CreateTaskWithParentInputSchema = CreateTaskInputSchema.extend({
-    parentTaskId: zod.z.string().nullable().optional().describe(
-      `Optional ID of the parent task. If provided, the new task will be created as a subtask of the specified parent. Use the current task's ID (${task.taskId}) to create a subtask of the current task. When asSubtask is true, this tasks ID will be used automatically.`
-    )
-  });
+  const availableAgents = task.getProject().getAgentProfiles().map((p) => {
+    const slug = deriveDirName(p.name, /* @__PURE__ */ new Set());
+    const shortId = isUuid(p.id) ? p.id.substring(0, 8) : p.id;
+    return `${slug}(${shortId})`;
+  }).join(",");
   const createTaskTool = ai.tool({
     description: TASKS_TOOL_DESCRIPTIONS[TASKS_TOOL_CREATE_TASK],
-    inputSchema: isSubtask ? CreateTaskInputSchema : CreateTaskWithParentInputSchema,
+    inputSchema: zod.z.object({
+      prompt: zod.z.string().describe("The initial prompt for the new task"),
+      name: nameProperty,
+      agentProfileId: zod.z.string().optional().describe(`Optional agent profile ID or name. Available agents: ${availableAgents}. Use only when explicitly requested by the user.`),
+      modelId: zod.z.string().optional().describe("Optional model ID in the format `provider/model` to use for the task. Use only when explicitly requested by the user."),
+      mode: zod.z.string().optional().default("agent").describe("Optional mode to use for the task. Use only when explicitly requested by the user."),
+      asSubtask: zod.z.boolean().optional().default(false).describe("If true, the task will be created as a subtask of the current task. Use only when explicitly requested by the user."),
+      parentTaskId: zod.z.string().nullable().optional().describe(
+        "Optional ID of the parent task. If provided, the new task will be created as a subtask of the specified parent. When asSubtask is specified as true, this is not needed as parent ID is resolved automatically."
+      ),
+      autoApprove: zod.z.boolean().optional().default(false).describe(
+        "If true, the task will be created with auto-approve enabled. Set autoApprove to true when no planning is needed, just execution of the task with all the work."
+      ),
+      worktree: zod.z.boolean().optional().default(false).describe("If true, the task will be created in worktree mode. Use only when explicitly requested by the user."),
+      executeAndWait: zod.z.boolean().optional().default(false).describe("If true, the task will be created and executed immediately and the tool will wait for it to complete before returning."),
+      executeInBackground: zod.z.boolean().optional().default(false).describe("If true, the task will be created and executed in the background.")
+    }),
     execute: async (input, { toolCallId }) => {
       const { prompt, name, agentProfileId, modelId, mode = "agent", asSubtask = false, autoApprove, worktree, executeAndWait, executeInBackground } = input;
-      const parentTaskId = asSubtask ? task.taskId : "parentTaskId" in input ? input.parentTaskId : void 0;
+      const parentTaskId = asSubtask ? task.task.parentId || task.taskId : "parentTaskId" in input ? input.parentTaskId : void 0;
       task.addToolMessage(toolCallId, TASKS_TOOL_GROUP_NAME, TASKS_TOOL_CREATE_TASK, input, void 0, void 0, promptContext);
       const toolName = `${TASKS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}${TASKS_TOOL_CREATE_TASK}`;
       const questionKey = toolName;
@@ -4179,13 +4493,22 @@ Parent Task ID: ${parentTaskId || "none (top-level task)"}` : ""}`;
         });
         const updates = {};
         if (agentProfileId) {
-          updates.agentProfileId = agentProfileId;
+          const resolvedProfile = task.getProject().resolveAgentProfile(agentProfileId);
+          if (resolvedProfile) {
+            updates.agentProfileId = resolvedProfile.id;
+          } else {
+            const availableProfiles = task.getProject().getAgentProfiles().map((p) => `"${p.name}"`).join(", ");
+            return `Agent profile '${agentProfileId}' not found. Available profiles: ${availableProfiles}`;
+          }
         }
         if (modelId) {
           const [provider, ...modelParts] = modelId.split("/");
           updates.provider = provider;
           updates.model = modelParts.join("/");
           updates.mainModel = modelId;
+        } else {
+          updates.provider = void 0;
+          updates.model = void 0;
         }
         const taskInstance = task.getProject().getTask(newTask.id);
         if (!taskInstance) {
@@ -5774,6 +6097,7 @@ ${reminder}
       "onImportantReminders",
       {
         profile,
+        agentProfile: profile,
         remindersContent
       },
       task.project,
@@ -5791,9 +6115,12 @@ ${reminder}
 ${remindersContent}
 </ThisIsImportant>`;
   }
-  const updatedFirstUserMessage = {
+  const updatedFirstUserMessage = typeof userRequestMessage.content === "string" ? {
     ...userRequestMessage,
     content: `${userRequestMessage.content}${remindersContent}`
+  } : {
+    ...userRequestMessage,
+    content: [...userRequestMessage.content, { type: "text", text: remindersContent }]
   };
   const newMessages = [...messages];
   newMessages[userRequestMessageIndex] = updatedFirstUserMessage;
@@ -6237,9 +6564,9 @@ ${fileList}`
       const extensionTools = this.extensionManager.createExtensionToolset(task, mode, profile, toolSet, abortSignal);
       Object.assign(toolSet, extensionTools);
     }
-    return this.wrapToolsWithHooks(task, toolSet, abortSignal, promptContext);
+    return this.wrapToolsWithHooks(task, profile, toolSet, abortSignal, promptContext);
   }
-  wrapToolsWithHooks(task, toolSet, abortSignal, promptContext) {
+  wrapToolsWithHooks(task, profile, toolSet, abortSignal, promptContext) {
     const wrappedToolSet = {};
     for (const [toolName, toolDef] of Object.entries(toolSet)) {
       wrappedToolSet[toolName] = {
@@ -6250,7 +6577,7 @@ ${fileList}`
           task.addToolMessage(options.toolCallId, serverName, messageToolName, effectiveInput, void 0, void 0, promptContext);
           const toolCalledExtensionResult = await this.extensionManager.dispatchEvent(
             "onToolCalled",
-            { toolName, input: effectiveInput, abortSignal: options.abortSignal || abortSignal },
+            { toolName, agentProfile: profile, input: effectiveInput, abortSignal: options.abortSignal || abortSignal },
             task.project,
             task
           );
@@ -6267,7 +6594,7 @@ ${fileList}`
           }
           const toolFinishedExtensionResult = await this.extensionManager.dispatchEvent(
             "onToolFinished",
-            { toolName, input: effectiveInput, output: result },
+            { toolName, agentProfile: profile, input: effectiveInput, output: result },
             task.project,
             task
           );
@@ -6423,7 +6750,7 @@ ${fileList}`
     }
     return inputSchema;
   }
-  async runAgent(task, profile, prompt, mode = "agent", promptContext, initialContextMessages, initialContextFiles, systemPrompt, includeInContext = true, abortSignal) {
+  async runAgent(task, profile, prompt, mode = "agent", promptContext, initialContextMessages, initialContextFiles, systemPrompt, includeInContext = true, abortSignal, images) {
     let contextMessages = initialContextMessages ?? await task.getContextMessages();
     let contextFiles = initialContextFiles ?? await task.getContextFiles();
     if (!systemPrompt) {
@@ -6432,9 +6759,32 @@ ${fileList}`
     const userRequestMessage = prompt ? {
       id: promptContext?.id || uuid.v4(),
       role: "user",
-      content: prompt,
+      content: images && images.length > 0 ? [
+        { type: "text", text: prompt },
+        ...images.map((dataUrl) => {
+          const match = dataUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
+          return {
+            type: "image",
+            image: match ? match[2] : dataUrl,
+            mediaType: match ? match[1] : void 0
+          };
+        })
+      ] : prompt,
       promptContext
     } : null;
+    if (userRequestMessage) {
+      logger.info("User request message created:", {
+        id: userRequestMessage.id,
+        contentType: typeof userRequestMessage.content === "string" ? "string" : "parts",
+        ...typeof userRequestMessage.content === "string" ? { contentPreview: userRequestMessage.content.substring(0, 200) } : {
+          parts: userRequestMessage.content.map((part) => ({
+            type: part.type,
+            ...part.type === "text" ? { textPreview: part.text?.substring(0, 100) } : {},
+            ...part.type === "image" ? { mediaType: part.mediaType, imagePreview: typeof part.image === "string" ? part.image.substring(0, 80) : typeof part.image } : {}
+          }))
+        }
+      });
+    }
     const settings = this.store.getSettings();
     const projectProfiles = this.agentProfileManager.getProjectProfiles(task.project);
     let resultMessages = userRequestMessage ? [userRequestMessage] : [];
@@ -6653,7 +7003,7 @@ ${fileList}`
           return null;
         }
       };
-      const modelSettings = this.modelManager.getModelSettings(provider.provider.name, modelName);
+      const modelSettings = this.modelManager.getModelSettings(provider.id, modelName);
       const effectiveTemperature = profile.temperature ?? modelSettings?.temperature;
       const effectiveMaxOutputTokens = profile.maxTokens ?? modelSettings?.maxOutputTokens;
       logger.debug("Parameters:", {
@@ -6687,6 +7037,31 @@ ${fileList}`
           return extensionResult2.optimizedMessages ?? optimized;
         };
         const optimizedMessages = await getOptimizedMessages();
+        logger.info("Optimized messages for LLM:", {
+          count: optimizedMessages.length,
+          lastUserMessage: (() => {
+            for (let i = optimizedMessages.length - 1; i >= 0; i--) {
+              if (optimizedMessages[i].role === "user") {
+                const msg = optimizedMessages[i];
+                return {
+                  index: i,
+                  contentType: typeof msg.content,
+                  contentIsArray: Array.isArray(msg.content),
+                  contentPreview: typeof msg.content === "string" ? msg.content.substring(0, 200) : Array.isArray(msg.content) ? msg.content.map((p) => ({
+                    type: p.type,
+                    ...p.type === "text" ? { textPreview: p.text?.substring(0, 100) } : {},
+                    ...p.type === "image" ? {
+                      mediaType: p.mediaType,
+                      imageType: typeof p.image,
+                      imagePreview: typeof p.image === "string" ? p.image.substring(0, 80) : void 0
+                    } : {}
+                  })) : String(msg.content).substring(0, 200)
+                };
+              }
+            }
+            return null;
+          })()
+        });
         return {
           providerOptions,
           model: ai.wrapLanguageModel({
@@ -6713,7 +7088,7 @@ ${fileList}`
       while (true) {
         logger.info(`Starting iteration ${iterationCount}`);
         iterationCount++;
-        if (iterationCount > profile.maxIterations) {
+        if (profile.maxIterations > 0 && iterationCount > profile.maxIterations) {
           logger.warn(`Max iterations (${profile.maxIterations}) reached. Stopping agent.`);
           task.addLogMessage(
             "warning",
@@ -6726,7 +7101,7 @@ ${fileList}`
         let iterationError = null;
         let hasReasoning = false;
         let finishReason = null;
-        let responseMessages = [];
+        let currentStepMessages = [];
         let responseMessageIndex = 0;
         const onStepFinish = async (stepResult) => {
           finishReason = stepResult.finishReason;
@@ -6738,7 +7113,7 @@ ${fileList}`
             logger.info("Prompt aborted by user");
             return;
           }
-          responseMessages = await this.processStep(currentResponseId, stepResult, task, provider, modelName, promptContext, abortSignal);
+          currentStepMessages = await this.processStep(currentResponseId, stepResult, task, provider, modelName, promptContext, abortSignal);
           const extensionResult2 = await this.extensionManager.dispatchEvent(
             "onAgentStepFinished",
             {
@@ -6747,18 +7122,18 @@ ${fileList}`
               currentResponseId,
               stepResult,
               finishReason,
-              responseMessages
+              responseMessages: currentStepMessages
             },
             task.project,
             task
           );
-          responseMessages = extensionResult2.responseMessages;
+          currentStepMessages = extensionResult2.responseMessages;
           finishReason = extensionResult2.finishReason;
           currentResponseId = uuid.v4();
           responseMessageIndex = 0;
           hasReasoning = false;
           streamingMessageIds.clear();
-          if (responseMessages.length > 0) {
+          if (currentStepMessages.length > 0) {
             retryCount = 0;
           }
         };
@@ -6831,25 +7206,46 @@ ${fileList}`
             onStepFinish,
             experimental_repairToolCall: repairToolCall
           });
-          for await (const chunk of result.fullStream) {
-            logger.debug("Chunk:", { chunk: chunk.type, responseMessageIndex });
-            const responseMessageId = responseMessageIndex > 0 ? `${currentResponseId}-${responseMessageIndex}` : currentResponseId;
-            if (chunk.type === "text-start") {
-              if (hasReasoning) {
+          try {
+            for await (const chunk of result.fullStream) {
+              logger.debug("Chunk:", { chunk: chunk.type, responseMessageIndex });
+              const responseMessageId = responseMessageIndex > 0 ? `${currentResponseId}-${responseMessageIndex}` : currentResponseId;
+              if (chunk.type === "text-start") {
+                if (hasReasoning) {
+                  streamingMessageIds.add(responseMessageId);
+                  await task.processResponseMessage({
+                    id: responseMessageId,
+                    action: "response",
+                    content: ANSWER_RESPONSE_START_TAG,
+                    finished: false,
+                    promptContext
+                  });
+                  hasReasoning = false;
+                }
+              } else if (chunk.type === "text-end") {
+                responseMessageIndex++;
+              } else if (chunk.type === "text-delta") {
+                if (chunk.text.trim()) {
+                  streamingMessageIds.add(responseMessageId);
+                  await task.processResponseMessage({
+                    id: responseMessageId,
+                    action: "response",
+                    content: chunk.text,
+                    finished: false,
+                    promptContext
+                  });
+                }
+              } else if (chunk.type === "reasoning-start") {
                 streamingMessageIds.add(responseMessageId);
                 await task.processResponseMessage({
                   id: responseMessageId,
                   action: "response",
-                  content: ANSWER_RESPONSE_START_TAG,
+                  content: THINKING_RESPONSE_STAR_TAG,
                   finished: false,
                   promptContext
                 });
-                hasReasoning = false;
-              }
-            } else if (chunk.type === "text-end") {
-              responseMessageIndex++;
-            } else if (chunk.type === "text-delta") {
-              if (chunk.text.trim()) {
+                hasReasoning = true;
+              } else if (chunk.type === "reasoning-delta") {
                 streamingMessageIds.add(responseMessageId);
                 await task.processResponseMessage({
                   id: responseMessageId,
@@ -6858,51 +7254,53 @@ ${fileList}`
                   finished: false,
                   promptContext
                 });
+              } else if (chunk.type === "tool-input-start") {
+                task.addLogMessage("loading", "Preparing tool...", false, promptContext);
+                streamingMessageIds.add(chunk.id);
+              } else if (chunk.type === "tool-call") {
+                task.addLogMessage("loading", "Executing tool...", false, promptContext);
+                streamingMessageIds.add(chunk.toolCallId);
+              } else if (chunk.type === "tool-result") {
+                const [serverName, toolName] = extractServerNameToolName(chunk.toolName);
+                const toolPromptContext = extractPromptContextFromToolResult(chunk.output) ?? promptContext;
+                streamingMessageIds.add(chunk.toolCallId);
+                task.addToolMessage(chunk.toolCallId, serverName, toolName, chunk.input, JSON.stringify(chunk.output), void 0, toolPromptContext);
+                task.addLogMessage("loading", void 0, false, promptContext);
               }
-            } else if (chunk.type === "reasoning-start") {
-              streamingMessageIds.add(responseMessageId);
-              await task.processResponseMessage({
-                id: responseMessageId,
-                action: "response",
-                content: THINKING_RESPONSE_STAR_TAG,
-                finished: false,
-                promptContext
-              });
-              hasReasoning = true;
-            } else if (chunk.type === "reasoning-delta") {
-              streamingMessageIds.add(responseMessageId);
-              await task.processResponseMessage({
-                id: responseMessageId,
-                action: "response",
-                content: chunk.text,
-                finished: false,
-                promptContext
-              });
-            } else if (chunk.type === "tool-input-start") {
-              task.addLogMessage("loading", "Preparing tool...", false, promptContext);
-              streamingMessageIds.add(chunk.id);
-            } else if (chunk.type === "tool-call") {
-              task.addLogMessage("loading", "Executing tool...", false, promptContext);
-              streamingMessageIds.add(chunk.toolCallId);
-            } else if (chunk.type === "tool-result") {
-              const [serverName, toolName] = extractServerNameToolName(chunk.toolName);
-              const toolPromptContext = extractPromptContextFromToolResult(chunk.output) ?? promptContext;
-              streamingMessageIds.add(chunk.toolCallId);
-              task.addToolMessage(chunk.toolCallId, serverName, toolName, chunk.input, JSON.stringify(chunk.output), void 0, toolPromptContext);
-              task.addLogMessage("loading", void 0, false, promptContext);
+            }
+          } catch (streamError) {
+            if (effectiveAbortSignal?.aborted) {
+              throw streamError;
+            }
+            if (isNetworkError(streamError) && retryCount < MAX_RETRIES) {
+              logger.warn(`Network error during streaming, retrying (${retryCount + 1}/${MAX_RETRIES})...`, { error: streamError });
+              iterationError = streamError;
+              this.removeUnfinishedStreamingMessages(task, streamingMessageIds);
+              task.addLogMessage("loading", "Network error occured. Retrying...");
+            } else if (isNetworkError(streamError)) {
+              const error = streamError;
+              const underlyingMessage = error.cause instanceof Error ? error.cause.message : error.message;
+              throw new Error(`Network error after ${MAX_RETRIES} retries (check your connection): ${underlyingMessage}`, { cause: streamError });
+            } else {
+              throw streamError;
             }
           }
         }
         if (iterationError) {
-          logger.error("Error during prompt:", iterationError);
-          if (iterationError instanceof ai.APICallError && iterationError.isRetryable && this.modelManager.isRetryable(resolvedProvider, modelName, iterationError)) {
+          logger.error("Error during iteration:", iterationError);
+          if (isNetworkError(iterationError) && retryCount < MAX_RETRIES) {
+            logger.info(`Network error, retrying (${retryCount + 1}/${MAX_RETRIES})...`);
+            this.removeUnfinishedStreamingMessages(task, streamingMessageIds);
+            retryCount++;
+            continue;
+          } else if (iterationError instanceof ai.APICallError && iterationError.isRetryable && this.modelManager.isRetryable(resolvedProvider, modelName, iterationError)) {
             continue;
           } else {
             break;
           }
         }
-        const newMessages = this.filterResultMessages(responseMessages);
-        messages.push(...responseMessages);
+        const newMessages = this.filterResultMessages(currentStepMessages);
+        messages.push(...currentStepMessages);
         resultMessages.push(...newMessages);
         if (includeInContext) {
           try {
@@ -6928,7 +7326,7 @@ ${fileList}`
           retryCount++;
           continue;
         }
-        const lastMessage = responseMessages[responseMessages.length - 1];
+        const lastMessage = currentStepMessages[currentStepMessages.length - 1];
         if (finishReason === "stop" && lastMessage?.role === "tool") {
           logger.debug('Finish reason is "stop" but last message is a tool call. Retrying...');
           retryCount++;
@@ -6990,6 +7388,9 @@ ${fileList}`
       } else {
         task.addLogMessage("error", `${error instanceof Error ? error.message : String(error)}`, false, promptContext);
       }
+      await task.updateTask({
+        state: DefaultTaskState.Interrupted
+      });
     } finally {
       if (controllerId) {
         this.abortControllers.delete(controllerId);
@@ -7286,11 +7687,9 @@ ${fileList}`
       optimizedMessages.unshift({ role: "system", content: systemPrompt });
       const chatMessages = optimizedMessages.map((msg) => ({
         role: msg.role === "tool" ? "user" : msg.role,
-        // Map 'tool' role to user message as gpt-tokenizer does not support tool messages
-        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
-        // Handle potential non-string content if necessary
+        content: msg.content
       }));
-      return gpt4o.countTokens(chatMessages);
+      return estimateMessageTokens(chatMessages);
     } catch (error) {
       logger.error(`Error counting tokens: ${error}`);
       return 0;
@@ -7398,18 +7797,64 @@ ${fileList}`
     return messages;
   }
   async compactMessagesIfNeeded(task, profile, provider, model, userRequestMessage, contextMessages, contextFiles, messages, resultMessages, promptContext, abortSignal) {
-    const contextCompactingThreshold = task.task.contextCompactingThreshold ?? this.store.getProjectSettings(task.getProjectDir())?.contextCompactingThreshold ?? 0;
-    const contextCompactionType = profile.isSubagent ? ContextCompactionType.Compact : this.store.getSettings().taskSettings.contextCompactionType ?? ContextCompactionType.Compact;
+    const taskSettings = this.store.getSettings().taskSettings;
+    const thresholdConfig = {
+      percentage: profile.autoCompactThresholdPercentage ?? taskSettings.contextCompactingThreshold.percentage,
+      tokens: profile.autoCompactThresholdTokens ?? taskSettings.contextCompactingThreshold.tokens
+    };
+    const taskTokensOverride = task.task.contextCompactingThresholdTokens;
+    let contextCompactionType = profile.autoCompactionType ?? taskSettings.contextCompactionType ?? ContextCompactionType.Compact;
+    if (profile.isSubagent && contextCompactionType === ContextCompactionType.Handoff) {
+      contextCompactionType = ContextCompactionType.Compact;
+    }
+    logger.debug("Compaction threshold", {
+      thresholdConfig,
+      profile: {
+        autoCompactThresholdPercentage: profile.autoCompactThresholdPercentage,
+        autoCompactThresholdTokens: profile.autoCompactThresholdTokens
+      },
+      taskSettings: {
+        contextCompactingThreshold: taskSettings.contextCompactingThreshold
+      },
+      taskTokensOverride,
+      contextCompactionType
+    });
     const lastAssistantMessage = [...resultMessages].reverse().find((m) => m.role === "assistant");
     const usageReport = lastAssistantMessage?.usageReport;
-    const maxTokens = this.modelManager.getModelSettings(provider.provider.name, model)?.maxInputTokens;
-    if (contextCompactingThreshold === 0 || !usageReport || !maxTokens) {
+    const maxTokens = this.modelManager.getModelSettings(provider.id, model)?.maxInputTokens;
+    if (!usageReport || !maxTokens) {
+      logger.debug("No usageReport or maxTokens", {
+        usageReport,
+        maxTokens
+      });
       return true;
     }
     const totalTokens = usageReport.sentTokens + usageReport.receivedTokens + (usageReport.cacheReadTokens ?? 0);
-    if (maxTokens && totalTokens > maxTokens * contextCompactingThreshold / 100) {
+    let effectiveThreshold;
+    let thresholdDescription;
+    if (taskTokensOverride !== void 0) {
+      if (taskTokensOverride === 0) {
+        return true;
+      }
+      effectiveThreshold = taskTokensOverride;
+      thresholdDescription = `task override: ${taskTokensOverride}`;
+    } else {
+      if (thresholdConfig.percentage === 0) {
+        return true;
+      }
+      const percentageThreshold = maxTokens * thresholdConfig.percentage / 100;
+      const tokenThreshold = thresholdConfig.tokens;
+      effectiveThreshold = Math.min(percentageThreshold, tokenThreshold);
+      thresholdDescription = `percentage: ${percentageThreshold}, tokens: ${tokenThreshold}`;
+    }
+    logger.debug("Checking total tokens vs effective threshold", {
+      totalTokens,
+      effectiveThreshold,
+      thresholdDescription
+    });
+    if (totalTokens > effectiveThreshold) {
       logger.info(
-        `Token usage ${totalTokens} exceeds threshold of ${contextCompactingThreshold}%. Compacting conversation with type: ${contextCompactionType}.`
+        `Token usage ${totalTokens} exceeds effective threshold of ${effectiveThreshold} (${thresholdDescription}). Compacting conversation with type: ${contextCompactionType}.`
       );
       if (contextCompactionType === ContextCompactionType.Compact) {
         await task.compactConversation(
@@ -7425,15 +7870,24 @@ ${fileList}`
         messages.length = 0;
         resultMessages.length = 0;
         messages.push(...await this.prepareMessages(task, profile, await task.getContextMessages(), contextFiles));
+        const continuationText = `Based on your compacted summary of our previous conversation, please continue our work with my request:
+
+${extractTextContent(userRequestMessage.content)}`;
+        const originalImageParts = Array.isArray(userRequestMessage.content) ? userRequestMessage.content.filter((part) => part.type === "image") : [];
         resultMessages.push({
           id: uuid.v4(),
           role: "user",
-          content: `Based on your compacted summary of our previous conversation, please continue our work with my request:
-
-${userRequestMessage.content}`,
+          content: originalImageParts.length > 0 ? [{ type: "text", text: continuationText }, ...originalImageParts] : continuationText,
           promptContext
         });
         messages.push(...resultMessages);
+      } else if (contextCompactionType === ContextCompactionType.Smart) {
+        const compactedMessages = await task.smartCompactConversation([...contextMessages, ...resultMessages], "Previous conversation has been compacted.");
+        contextMessages.length = 0;
+        messages.length = 0;
+        resultMessages.length = 0;
+        contextMessages.push(...compactedMessages);
+        messages.push(...await this.prepareMessages(task, profile, compactedMessages, contextFiles));
       } else if (contextCompactionType === ContextCompactionType.Handoff) {
         await task.handoffConversation(
           "agent",
@@ -7874,6 +8328,37 @@ class AgentProfileManager {
     }
     return this.profiles.get(profileId)?.agentProfile;
   }
+  resolveAgentProfile(id) {
+    const lowerId = id.toLowerCase();
+    const directMatch = this.getProfile(id);
+    if (directMatch) {
+      return directMatch;
+    }
+    const allProfiles = this.getAllProfiles();
+    for (const profile of allProfiles) {
+      if (profile.name.toLowerCase() === lowerId) {
+        return profile;
+      }
+    }
+    for (const context of this.profiles.values()) {
+      if (context.dirName.toLowerCase() === lowerId) {
+        return context.agentProfile;
+      }
+    }
+    const slugifiedId = deriveDirName(id, /* @__PURE__ */ new Set()).toLowerCase();
+    for (const context of this.profiles.values()) {
+      if (context.dirName.toLowerCase() === slugifiedId) {
+        return context.agentProfile;
+      }
+    }
+    for (const profile of allProfiles) {
+      const derivedName = deriveDirName(profile.name, /* @__PURE__ */ new Set()).toLowerCase();
+      if (derivedName === slugifiedId) {
+        return profile;
+      }
+    }
+    return null;
+  }
   getOrderedProfiles(profileContexts) {
     return profileContexts.sort((a, b) => {
       const aIsProject = !!a.agentProfile.projectDir;
@@ -8213,7 +8698,8 @@ const RunPromptSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
   taskId: zod.z.string().min(1, "Task ID is required"),
   prompt: zod.z.string().min(1, "Prompt is required"),
-  mode: zod.z.string().optional()
+  mode: zod.z.string().optional(),
+  images: zod.z.array(zod.z.string()).optional()
 });
 const SavePromptSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
@@ -8233,8 +8719,8 @@ class PromptApi extends BaseApi {
         if (!parsed) {
           return;
         }
-        const { projectDir, taskId, prompt, mode } = parsed;
-        const responses = await this.eventsHandler.runPrompt(projectDir, taskId, prompt, mode);
+        const { projectDir, taskId, prompt, mode, images } = parsed;
+        const responses = await this.eventsHandler.runPrompt(projectDir, taskId, prompt, mode, images);
         res.status(200).json(responses);
       })
     );
@@ -8422,6 +8908,10 @@ const ClearContextSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
   taskId: zod.z.string().min(1, "Task id is required")
 });
+const UndoContextChangeSchema = zod.z.object({
+  projectDir: zod.z.string().min(1, "Project directory is required"),
+  taskId: zod.z.string().min(1, "Task id is required")
+});
 const AnswerQuestionSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
   taskId: zod.z.string().min(1, "Task id is required"),
@@ -8500,7 +8990,8 @@ const RedoUserPromptSchema = zod.z.object({
   taskId: zod.z.string().min(1, "Task id is required"),
   messageId: zod.z.string().min(1, "Message id is required"),
   mode: zod.z.string().min(1, "Mode is required"),
-  updatedPrompt: zod.z.string().optional()
+  updatedPrompt: zod.z.string().optional(),
+  updatedImages: zod.z.array(zod.z.string()).optional()
 });
 const ResumeTaskSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
@@ -8607,6 +9098,10 @@ const HandoffConversationSchema = zod.z.object({
   taskId: zod.z.string().min(1, "Task id is required"),
   focus: zod.z.string().optional()
 });
+const SmartCompactConversationSchema = zod.z.object({
+  projectDir: zod.z.string().min(1, "Project directory is required"),
+  taskId: zod.z.string().min(1, "Task id is required")
+});
 const ChangeRequestItemSchema = zod.z.object({
   filename: zod.z.string().min(1, "Filename is required"),
   lineNumber: zod.z.number().int().min(1, "Line number is required"),
@@ -8727,8 +9222,8 @@ class ProjectApi extends BaseApi {
         if (!parsed) {
           return;
         }
-        const { projectDir, taskId, messageId, mode, updatedPrompt } = parsed;
-        await this.eventsHandler.redoUserPrompt(projectDir, taskId, messageId, mode, updatedPrompt);
+        const { projectDir, taskId, messageId, mode, updatedPrompt, updatedImages } = parsed;
+        await this.eventsHandler.redoUserPrompt(projectDir, taskId, messageId, mode, updatedPrompt, updatedImages);
         res.status(200).json({ message: "Redo user prompt initiated" });
       })
     );
@@ -9013,6 +9508,30 @@ class ProjectApi extends BaseApi {
         res.status(200).json({ message: "Conversation compacted" });
       })
     );
+    router.post(
+      "/project/smart-compact-conversation",
+      this.handleRequest(async (req, res) => {
+        const parsed = this.validateRequest(SmartCompactConversationSchema, req.body, res);
+        if (!parsed) {
+          return;
+        }
+        const { projectDir, taskId } = parsed;
+        await this.eventsHandler.smartCompactConversation(projectDir, taskId);
+        res.status(200).json({ message: "Conversation smart-compacted" });
+      })
+    );
+    router.post(
+      "/project/undo-context-change",
+      this.handleRequest(async (req, res) => {
+        const parsed = this.validateRequest(UndoContextChangeSchema, req.body, res);
+        if (!parsed) {
+          return;
+        }
+        const { projectDir, taskId } = parsed;
+        const undone = await this.eventsHandler.undoContextChange(projectDir, taskId);
+        res.status(200).json({ undone });
+      })
+    );
     router.post(
       "/project/handoff-conversation",
       this.handleRequest(async (req, res) => {
@@ -10985,13 +11504,15 @@ class CustomCommandManager {
       const template = parsed.__content?.trim() || "";
       const includeContext = typeof parsed.includeContext === "boolean" ? parsed.includeContext : true;
       const autoApprove = typeof parsed.autoApprove === "boolean" ? parsed.autoApprove : void 0;
+      const skills = typeof parsed.skills === "string" && parsed.skills.trim() ? parsed.skills.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
       commands.set(name, {
         name,
         description: parsed.description || "Not specified",
         arguments: args,
         template,
         includeContext,
-        autoApprove
+        autoApprove,
+        skills
       });
     } catch (err) {
       logger.error(`Failed to parse command file ${filePath}: ${err}`);
@@ -11225,10 +11746,20 @@ class ContextManager {
   }
   messages;
   files;
+  undoSnapshot = null;
   loadPromise = null;
   loaded = false;
   autosaveEnabled = false;
   storagePath;
+  hasUndoSnapshot() {
+    return this.undoSnapshot !== null;
+  }
+  undoContextChange() {
+    const snapshot = this.undoSnapshot;
+    this.undoSnapshot = null;
+    this.task.sendContextInfoUpdated();
+    return snapshot;
+  }
   enableAutosave() {
     logger.debug("Enabling autosave for task", { taskId: this.taskId });
     this.autosaveEnabled = true;
@@ -11260,6 +11791,10 @@ class ContextManager {
     }
     this.messages.push(message);
     logger.debug(`Task ${this.taskId}: Added ${message.role} message. Total messages: ${this.messages.length}`);
+    if (this.undoSnapshot !== null) {
+      this.undoSnapshot = null;
+      this.task.sendContextInfoUpdated();
+    }
     this.autosave();
   }
   async isFileIgnored(contextFile) {
@@ -11277,7 +11812,14 @@ class ContextManager {
       });
       return [];
     }
-    if (this.isContextFileAlreadyAdded(absolutePath)) {
+    const existingContextFile = this.findExistingContextFile(absolutePath);
+    if (existingContextFile) {
+      const readOnly = contextFile.readOnly ?? false;
+      if (existingContextFile.readOnly !== readOnly) {
+        existingContextFile.readOnly = readOnly;
+        this.autosave();
+        return [existingContextFile];
+      }
       return [];
     }
     const isDir = await isDirectory(absolutePath);
@@ -11336,11 +11878,11 @@ class ContextManager {
     return this.task.resolveContextFilePath(relativePath);
   }
   /**
-   * Checks whether a resolved absolute path matches any already-added context file.
+   * Finds an already-added context file matching the given resolved absolute path, if any.
    * Accounts for files that may have been resolved from either taskDir or projectDir.
    */
-  isContextFileAlreadyAdded(absolutePath) {
-    return this.files.some((file) => {
+  findExistingContextFile(absolutePath) {
+    return this.files.find((file) => {
       const taskDirResolved = path.resolve(this.task.getTaskDir(), file.path);
       const projectDirResolved = path.resolve(this.task.getProjectDir(), file.path);
       return taskDirResolved === absolutePath || projectDirResolved === absolutePath;
@@ -11394,6 +11936,10 @@ class ContextManager {
       messages: contextMessages.length,
       save
     });
+    if (this.messages.length > 0 && this.messages !== contextMessages) {
+      this.undoSnapshot = [...this.messages];
+      this.task.sendContextInfoUpdated();
+    }
     this.messages = contextMessages;
     if (save) {
       this.autosave();
@@ -11423,8 +11969,12 @@ class ContextManager {
       this.autosave();
     }
   }
-  clearMessages(save = true) {
+  clearMessages(save = true, createSnapshot = true) {
     logger.debug("Clearing task messages", { taskId: this.taskId });
+    if (createSnapshot && this.messages.length > 0) {
+      this.undoSnapshot = [...this.messages];
+      this.task.sendContextInfoUpdated();
+    }
     this.messages = [];
     if (save) {
       this.autosave();
@@ -11721,6 +12271,34 @@ ${JSON.stringify(part.output.value)}`
       throw error;
     }
   }
+  /**
+   * Creates a backup of the current context.json file before a destructive operation
+   * (e.g., smart compaction). Backups are named context.backup.001.json, context.backup.002.json, etc.
+   * For debugging purposes only.
+   */
+  async backupContext() {
+    try {
+      const dir = path.dirname(this.storagePath);
+      const files = await fs$1.promises.readdir(dir);
+      const backupPattern = /^context\.backup\.(\d+)\.json$/;
+      let maxNumber = 0;
+      for (const file of files) {
+        const match = backupPattern.exec(file);
+        if (match) {
+          const num = parseInt(match[1], 10);
+          if (num > maxNumber) {
+            maxNumber = num;
+          }
+        }
+      }
+      const nextNumber = String(maxNumber + 1).padStart(3, "0");
+      const backupPath = path.join(dir, `context.backup.${nextNumber}.json`);
+      await fs$1.promises.copyFile(this.storagePath, backupPath);
+      logger.debug(`Task context backed up to ${backupPath}`, { taskId: this.taskId });
+    } catch (error) {
+      logger.error("Failed to backup task context:", { error, taskId: this.taskId });
+    }
+  }
   async cleanupContext() {
     const existingFiles = [];
     for (const file of this.files) {
@@ -11794,8 +12372,8 @@ ${JSON.stringify(part.output.value)}`
     this.loaded = true;
     await this.cleanupContext();
   }
-  async loadMessages(messages) {
-    await this.task.clearContext(false, false);
+  async loadMessages(messages, updateTaskState = true) {
+    await this.task.clearContext(false, false, updateTaskState, false);
     this.messages = messages;
     const messagesData = this.getContextMessagesData(messages);
     for (const messageData of messagesData) {
@@ -12047,12 +12625,18 @@ ${JSON.stringify(part.output.value)}`
         }
       } else if (message.role === "user") {
         const content = extractTextContent(message.content);
+        const images = Array.isArray(message.content) ? message.content.filter((part) => part.type === "image").map((part) => {
+          const data = part.image;
+          const mediaType = part.mediaType || "image/png";
+          return data.startsWith("data:") ? data : `data:${mediaType};base64,${data}`;
+        }) : void 0;
         const userMessageData = {
           type: "user",
           id: message.id || uuid.v4(),
           baseDir: this.task.getProjectDir(),
           taskId: this.taskId,
           content,
+          images: images && images.length > 0 ? images : void 0,
           promptContext: message.promptContext
         };
         messagesData.push(userMessageData);
@@ -12960,7 +13544,13 @@ class WorktreeManager {
             await execWithShellPath("git add -A", { cwd: projectPath });
           } catch {
           }
-          await execWithShellPath('git commit -m "Initial commit" --allow-empty', { cwd: projectPath });
+          try {
+            await execWithShellPath('git commit -m "Initial commit" --allow-empty', { cwd: projectPath });
+          } catch {
+            await execWithShellPath('git -c user.name="AiderDesk" -c user.email="aiderdesk@aiderdesk" commit -m "Initial commit" --allow-empty', {
+              cwd: projectPath
+            });
+          }
         }
         let baseCommit;
         let newBranchName;
@@ -14114,6 +14704,11 @@ Git output: ${err.stderr || err.stdout || err.message}`
         logger.warn(`Failed to get files for commit ${commit.hash}:`, commitError);
       }
     }
+    try {
+      await execWithShellPath("git rev-parse HEAD", { cwd: worktreePath });
+    } catch {
+      return files;
+    }
     try {
       const { stdout: uncommittedNumstat } = await execWithShellPath("git diff --numstat -z HEAD", {
         cwd: worktreePath
@@ -14212,6 +14807,11 @@ Git output: ${err.stderr || err.stdout || err.message}`
    * Non-worktree mode: simple uncommitted changes vs HEAD.
    */
   async getNonWorktreeUpdatedFiles(worktreePath) {
+    try {
+      await execWithShellPath("git rev-parse HEAD", { cwd: worktreePath });
+    } catch {
+      return [];
+    }
     const { stdout } = await execWithShellPath("git diff --numstat -z HEAD", {
       cwd: worktreePath
     });
@@ -14515,102 +15115,691 @@ Git output: ${err.stderr || err.stdout || err.message}`
         }
         throw new Error(`Failed to apply uncommitted changes: ${error instanceof Error ? error.message : String(error)}`);
       }
-    });
+    });
+  }
+  /**
+   * Revert a merge operation using the stored MergeState
+   * Restores the main branch to its pre-merge state while preserving uncommitted changes
+   */
+  async revertMerge(projectPath, taskId, worktreePath, mergeState, symlinkFolders = []) {
+    return await withLock(`git-revert-merge-${worktreePath}`, async () => {
+      const timestamp = Date.now();
+      const currentWorktreeStashId = `worktree-${taskId.length > 24 ? taskId.substring(24) : taskId}-revert-${timestamp}`;
+      const currentMainStashId = `main-${taskId.length > 24 ? taskId.substring(24) : taskId}-revert-${timestamp}`;
+      let worktreeRevertStashId = null;
+      let mainRevertStashId = null;
+      try {
+        logger.info("Starting merge revert operation", { mergeState });
+        worktreeRevertStashId = await this.stashUncommittedChanges(
+          currentWorktreeStashId,
+          worktreePath,
+          "Current uncommitted changes before revert",
+          symlinkFolders
+        );
+        mainRevertStashId = await this.stashUncommittedChanges(currentMainStashId, projectPath, "Current uncommitted changes before revert", []);
+        const targetBranch = mergeState.targetBranch || await this.getProjectMainBranch(projectPath);
+        await execWithShellPath(`git checkout ${targetBranch}`, {
+          cwd: projectPath
+        });
+        logger.info(`Resetting ${targetBranch} branch to ${mergeState.beforeMergeCommitHash}`);
+        await execWithShellPath(`git reset --hard ${mergeState.beforeMergeCommitHash}`, { cwd: projectPath });
+        logger.info(`Resetting worktree branch to ${mergeState.worktreeBranchCommitHash}`);
+        await execWithShellPath(`git reset --hard ${mergeState.worktreeBranchCommitHash}`, { cwd: worktreePath });
+        if (mergeState.mainOriginalStashId) {
+          logger.info("Restoring main branch original uncommitted changes");
+          await this.applyStash(projectPath, mergeState.mainOriginalStashId);
+          await this.dropStash(projectPath, mergeState.mainOriginalStashId);
+        }
+        if (worktreeRevertStashId) {
+          logger.info("Restoring uncommitted changes in worktree");
+          await this.applyStash(worktreePath, currentWorktreeStashId);
+          await this.dropStash(worktreePath, currentWorktreeStashId);
+        }
+        if (mainRevertStashId) {
+          await this.dropStash(projectPath, currentMainStashId);
+        }
+        logger.info("Merge revert completed successfully");
+      } catch (error) {
+        logger.error("Failed to revert merge:", error);
+        if (worktreeRevertStashId) {
+          try {
+            await this.applyStash(worktreePath, currentWorktreeStashId);
+            await this.dropStash(worktreePath, currentWorktreeStashId);
+          } catch (recoveryError) {
+            logger.error("Failed to recover worktree stash:", recoveryError);
+          }
+        }
+        if (mainRevertStashId) {
+          try {
+            await this.applyStash(projectPath, currentMainStashId);
+            await this.dropStash(projectPath, currentMainStashId);
+          } catch (recoveryError) {
+            logger.error("Failed to recover main branch stash:", recoveryError);
+          }
+        }
+        throw new Error(`Failed to revert merge: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    });
+  }
+  async pruneDeleted(projectDir) {
+    logger.info("Pruning deleted worktrees", {
+      projectDir
+    });
+    const worktrees = await this.listWorktrees(projectDir);
+    logger.debug("Found worktrees", {
+      worktrees
+    });
+    for (const worktree of worktrees) {
+      if (worktree.path.startsWith(path.join(projectDir, AIDER_DESK_TASKS_DIR)) && worktree.prunable) {
+        try {
+          logger.debug(`Pruning deleted worktree: ${worktree.path}`);
+          await execWithShellPath(`git worktree remove ${worktree.path}`, {
+            cwd: projectDir
+          });
+        } catch (error) {
+          logger.warn("Failed to prune worktree:", {
+            worktree,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          await fs.rm(worktree.path, { recursive: true, force: true });
+        }
+      }
+    }
+  }
+  async close(projectDir) {
+    logger.info("Closing worktree manager");
+    await this.pruneDeleted(projectDir);
+  }
+}
+const extractFilePath = (args) => {
+  if (typeof args === "object" && args !== null && "filePath" in args) {
+    return args.filePath;
+  }
+  return void 0;
+};
+const getToolOutputText = (output) => {
+  if (!output) {
+    return "";
+  }
+  if (output.type === "text") {
+    return output.value;
+  }
+  if (output.type === "error-text") {
+    return output.value;
+  }
+  return JSON.stringify(output.value);
+};
+const isErrorResult = (output) => {
+  const text = getToolOutputText(output).toLowerCase();
+  return text.includes("denied by user") || text.startsWith("error:") || text.includes("no files found") || text.includes("no matches found") || text.includes("operation was cancelled") || text.includes("warning:") || text.includes("already updated - no changes were needed") || text.includes("failed to");
+};
+const isNoOpResult = (output) => {
+  const text = getToolOutputText(output);
+  return text.includes("Already updated - no changes were needed");
+};
+const isPowerTool = (serverName) => {
+  return serverName === POWER_TOOL_GROUP_NAME;
+};
+const getToolInfoFromToolMessage = (message) => {
+  return message.content.filter((part) => part.type === "tool-result").map((part) => {
+    const [serverName, toolName] = extractServerNameToolName(part.toolName);
+    return {
+      messageIndex: -1,
+      toolCallId: part.toolCallId,
+      toolName,
+      serverName,
+      input: void 0,
+      output: part.output
+    };
+  });
+};
+const findAssistantToolCall = (messages, toolCallId) => {
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== "assistant") {
+      continue;
+    }
+    if (!Array.isArray(msg.content)) {
+      continue;
+    }
+    for (let j = 0; j < msg.content.length; j++) {
+      const part = msg.content[j];
+      if (part.type === "tool-call" && part.toolCallId === toolCallId) {
+        const [, toolName] = extractServerNameToolName(part.toolName);
+        return {
+          messageId: msg.id,
+          messageIndex: i,
+          partIndex: j,
+          toolCallId: part.toolCallId,
+          toolName,
+          input: part.input
+        };
+      }
+    }
+  }
+  return void 0;
+};
+const cloneMessages = (messages) => {
+  return messages.map((msg) => {
+    if (msg.role === "tool") {
+      return {
+        ...msg,
+        content: msg.content.map((part) => ({ ...part }))
+      };
+    }
+    return {
+      ...msg,
+      content: Array.isArray(msg.content) ? msg.content.map((part) => ({ ...part })) : msg.content
+    };
+  });
+};
+const removeToolCallFromAssistant = (messages, toolCallId) => {
+  const callInfo = findAssistantToolCall(messages, toolCallId);
+  if (!callInfo) {
+    return;
+  }
+  const assistantMsg = messages[callInfo.messageIndex];
+  if (!Array.isArray(assistantMsg.content)) {
+    return;
+  }
+  assistantMsg.content.splice(callInfo.partIndex, 1);
+  const hasToolCalls = assistantMsg.content.some((p) => p.type === "tool-call");
+  if (!hasToolCalls) {
+    messages.splice(callInfo.messageIndex, 1);
+  }
+};
+const removeToolResult = (messages, toolCallId) => {
+  const toolMsgIdx = messages.findIndex((m) => m.role === "tool" && m.content.some((p) => p.type === "tool-result" && p.toolCallId === toolCallId));
+  if (toolMsgIdx === -1) {
+    return;
+  }
+  const toolMsg = messages[toolMsgIdx];
+  const partIdx = toolMsg.content.findIndex((p) => p.type === "tool-result" && p.toolCallId === toolCallId);
+  if (partIdx === -1) {
+    return;
+  }
+  toolMsg.content.splice(partIdx, 1);
+  if (toolMsg.content.length === 0) {
+    messages.splice(toolMsgIdx, 1);
+  }
+};
+const getProtectedStartIndex = (messages, protectedMessageCount) => {
+  return Math.max(0, messages.length - protectedMessageCount);
+};
+const mergeConsecutiveAssistantMessages = (messages) => {
+  const result = cloneMessages(messages);
+  for (let i = result.length - 2; i >= 0; i--) {
+    const current = result[i];
+    const next = result[i + 1];
+    if (current.role !== "assistant" || next.role !== "assistant") {
+      continue;
+    }
+    const currentHasToolCalls = Array.isArray(current.content) && current.content.some((p) => p.type === "tool-call");
+    const nextHasToolCalls = Array.isArray(next.content) && next.content.some((p) => p.type === "tool-call");
+    if (currentHasToolCalls || nextHasToolCalls) {
+      continue;
+    }
+    const currentTextParts = Array.isArray(current.content) ? current.content.filter((p) => p.type === "text") : [];
+    const nextTextParts = Array.isArray(next.content) ? next.content.filter((p) => p.type === "text") : [];
+    const mergedText = [...currentTextParts, ...nextTextParts].map((p) => p.text).filter(Boolean).join("\n\n");
+    current.content = mergedText ? [{ type: "text", text: mergedText }] : [];
+    result.splice(i + 1, 1);
+  }
+  return result.filter((msg) => {
+    if (msg.role === "assistant" && Array.isArray(msg.content) && msg.content.length === 0) {
+      return false;
+    }
+    return true;
+  });
+};
+const smartCompactMessages = (messages, protectedMessageCount = 10) => {
+  let result = cloneMessages(messages);
+  result = removeErroredTools(result, protectedMessageCount);
+  result = collapseFileEdits(result, protectedMessageCount);
+  result = removeStaleFileReads(result, protectedMessageCount);
+  result = removeObsoleteSearches(result, protectedMessageCount);
+  result = compactSemanticSearches(result, protectedMessageCount);
+  result = deduplicateBash(result, protectedMessageCount);
+  result = redactFetchOutputs(result, protectedMessageCount);
+  result = mergeConsecutiveAssistantMessages(result);
+  return result;
+};
+const removeErroredTools = (messages, protectedMessageCount = 10) => {
+  const result = cloneMessages(messages);
+  const protectedStart = getProtectedStartIndex(result, protectedMessageCount);
+  for (let i = protectedStart - 1; i >= 0; i--) {
+    if (i >= result.length) {
+      continue;
+    }
+    const msg = result[i];
+    if (msg.role !== "tool") {
+      continue;
+    }
+    const toolInfos = getToolInfoFromToolMessage(msg);
+    for (const info of toolInfos) {
+      if (!isPowerTool(info.serverName)) {
+        continue;
+      }
+      if (isErrorResult(info.output) || isNoOpResult(info.output)) {
+        removeToolCallFromAssistant(result, info.toolCallId);
+        removeToolResult(result, info.toolCallId);
+      }
+    }
+  }
+  return result;
+};
+const collapseFileEdits = (messages, protectedMessageCount = 10) => {
+  const result = cloneMessages(messages);
+  const protectedStart = getProtectedStartIndex(result, protectedMessageCount);
+  const fileEditGroups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < protectedStart; i++) {
+    if (i >= result.length) {
+      break;
+    }
+    const msg = result[i];
+    if (msg.role !== "tool") {
+      continue;
+    }
+    for (const part of msg.content) {
+      if (part.type !== "tool-result") {
+        continue;
+      }
+      const [serverName, toolName] = extractServerNameToolName(part.toolName);
+      if (!isPowerTool(serverName)) {
+        continue;
+      }
+      if (toolName !== POWER_TOOL_FILE_EDIT && toolName !== POWER_TOOL_FILE_WRITE) {
+        continue;
+      }
+      const callInfo = findAssistantToolCall(result, part.toolCallId);
+      if (!callInfo) {
+        continue;
+      }
+      const filePath = extractFilePath(callInfo.input);
+      if (!filePath) {
+        continue;
+      }
+      if (!fileEditGroups.has(filePath)) {
+        fileEditGroups.set(filePath, []);
+      }
+      fileEditGroups.get(filePath).push({
+        assistantMessageId: callInfo.messageId,
+        toolCallId: part.toolCallId
+      });
+    }
+  }
+  for (const [filePath, edits] of fileEditGroups) {
+    if (edits.length === 0) {
+      continue;
+    }
+    const lastEdit = edits[edits.length - 1];
+    const syntheticMessage = {
+      id: uuid.v4(),
+      role: "assistant",
+      content: [
+        {
+          type: "text",
+          text: `<file-edited path="${filePath}">File was edited. Read the content again if you need to work on it.</file-edited>`
+        }
+      ]
+    };
+    const assistantIndex = result.findIndex((m) => m.id === lastEdit.assistantMessageId);
+    const insertIndex = assistantIndex !== -1 ? assistantIndex + 1 : 0;
+    result.splice(insertIndex, 0, syntheticMessage);
+    for (const edit of edits) {
+      removeToolCallFromAssistant(result, edit.toolCallId);
+      removeToolResult(result, edit.toolCallId);
+    }
+  }
+  return result;
+};
+const removeStaleFileReads = (messages, protectedMessageCount = 10) => {
+  const result = cloneMessages(messages);
+  const protectedStart = getProtectedStartIndex(result, protectedMessageCount);
+  const editedFilePaths = /* @__PURE__ */ new Set();
+  for (let i = 0; i < result.length; i++) {
+    const msg = result[i];
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part.type === "text") {
+          const match = part.text.match(/<file-edited path="([^"]+)">/);
+          if (match) {
+            editedFilePaths.add(match[1]);
+          }
+        }
+      }
+      continue;
+    }
+    if (msg.role !== "tool") {
+      continue;
+    }
+    for (const part of msg.content) {
+      if (part.type !== "tool-result") {
+        continue;
+      }
+      const [serverName, toolName] = extractServerNameToolName(part.toolName);
+      if (!isPowerTool(serverName)) {
+        continue;
+      }
+      if (toolName !== POWER_TOOL_FILE_EDIT && toolName !== POWER_TOOL_FILE_WRITE) {
+        continue;
+      }
+      const callInfo = findAssistantToolCall(result, part.toolCallId);
+      if (callInfo) {
+        const filePath = extractFilePath(callInfo.input);
+        if (filePath) {
+          editedFilePaths.add(filePath);
+        }
+      }
+    }
+  }
+  const protectedReadFilePaths = /* @__PURE__ */ new Set();
+  for (let i = protectedStart; i < result.length; i++) {
+    const msg = result[i];
+    if (msg.role !== "tool") {
+      continue;
+    }
+    for (const part of msg.content) {
+      if (part.type !== "tool-result") {
+        continue;
+      }
+      const [serverName, toolName] = extractServerNameToolName(part.toolName);
+      if (!isPowerTool(serverName) || toolName !== POWER_TOOL_FILE_READ) {
+        continue;
+      }
+      const callInfo = findAssistantToolCall(result, part.toolCallId);
+      if (callInfo) {
+        const filePath = extractFilePath(callInfo.input);
+        if (filePath) {
+          protectedReadFilePaths.add(filePath);
+        }
+      }
+    }
+  }
+  const readFileGroups = /* @__PURE__ */ new Map();
+  for (let i = protectedStart - 1; i >= 0; i--) {
+    if (i >= result.length) {
+      continue;
+    }
+    const msg = result[i];
+    if (msg.role !== "tool") {
+      continue;
+    }
+    for (const part of msg.content) {
+      if (part.type !== "tool-result") {
+        continue;
+      }
+      const [serverName, toolName] = extractServerNameToolName(part.toolName);
+      if (!isPowerTool(serverName) || toolName !== POWER_TOOL_FILE_READ) {
+        continue;
+      }
+      const callInfo = findAssistantToolCall(result, part.toolCallId);
+      if (!callInfo) {
+        continue;
+      }
+      const filePath = extractFilePath(callInfo.input);
+      if (!filePath) {
+        continue;
+      }
+      if (editedFilePaths.has(filePath) || protectedReadFilePaths.has(filePath)) {
+        removeToolCallFromAssistant(result, part.toolCallId);
+        removeToolResult(result, part.toolCallId);
+        continue;
+      }
+      if (!readFileGroups.has(filePath)) {
+        readFileGroups.set(filePath, []);
+      }
+      readFileGroups.get(filePath).push({
+        messageIndex: i,
+        toolCallId: part.toolCallId
+      });
+    }
+  }
+  for (const [, reads] of readFileGroups) {
+    if (reads.length <= 1) {
+      continue;
+    }
+    const toRemove = reads.slice(0, -1);
+    for (const read of toRemove) {
+      removeToolCallFromAssistant(result, read.toolCallId);
+      removeToolResult(result, read.toolCallId);
+    }
+  }
+  return result;
+};
+const removeObsoleteSearches = (messages, protectedMessageCount = 10) => {
+  const result = cloneMessages(messages);
+  const protectedStart = getProtectedStartIndex(result, protectedMessageCount);
+  const fileModificationPositions = [];
+  for (let i = 0; i < result.length; i++) {
+    const msg = result[i];
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part.type === "text" && part.text.includes("<file-edited")) {
+          fileModificationPositions.push(i);
+          break;
+        }
+      }
+      continue;
+    }
+    if (msg.role !== "tool") {
+      continue;
+    }
+    for (const part of msg.content) {
+      if (part.type !== "tool-result") {
+        continue;
+      }
+      const [serverName, toolName] = extractServerNameToolName(part.toolName);
+      if (!isPowerTool(serverName)) {
+        continue;
+      }
+      if (toolName === POWER_TOOL_FILE_EDIT || toolName === POWER_TOOL_FILE_WRITE) {
+        fileModificationPositions.push(i);
+      }
+    }
+  }
+  const hasFileModifications = fileModificationPositions.length > 0;
+  if (!hasFileModifications) {
+    return result;
+  }
+  for (let i = protectedStart - 1; i >= 0; i--) {
+    if (i >= result.length) {
+      continue;
+    }
+    const msg = result[i];
+    if (msg.role !== "tool") {
+      continue;
+    }
+    for (const part of msg.content) {
+      if (part.type !== "tool-result") {
+        continue;
+      }
+      const [serverName, toolName] = extractServerNameToolName(part.toolName);
+      if (!isPowerTool(serverName)) {
+        continue;
+      }
+      if (toolName !== POWER_TOOL_GLOB && toolName !== POWER_TOOL_GREP) {
+        continue;
+      }
+      const hasLaterModification = fileModificationPositions.some((pos) => pos > i);
+      if (hasLaterModification) {
+        removeToolCallFromAssistant(result, part.toolCallId);
+        removeToolResult(result, part.toolCallId);
+      }
+    }
   }
-  /**
-   * Revert a merge operation using the stored MergeState
-   * Restores the main branch to its pre-merge state while preserving uncommitted changes
-   */
-  async revertMerge(projectPath, taskId, worktreePath, mergeState, symlinkFolders = []) {
-    return await withLock(`git-revert-merge-${worktreePath}`, async () => {
-      const timestamp = Date.now();
-      const currentWorktreeStashId = `worktree-${taskId.length > 24 ? taskId.substring(24) : taskId}-revert-${timestamp}`;
-      const currentMainStashId = `main-${taskId.length > 24 ? taskId.substring(24) : taskId}-revert-${timestamp}`;
-      let worktreeRevertStashId = null;
-      let mainRevertStashId = null;
+  return result;
+};
+const compactSemanticSearches = (messages, protectedMessageCount = 10) => {
+  const result = cloneMessages(messages);
+  const protectedStart = getProtectedStartIndex(result, protectedMessageCount);
+  const searchIndices = [];
+  for (let i = 0; i < protectedStart; i++) {
+    if (i >= result.length) {
+      break;
+    }
+    const msg = result[i];
+    if (msg.role !== "tool") {
+      continue;
+    }
+    for (let j = 0; j < msg.content.length; j++) {
+      const part = msg.content[j];
+      if (part.type !== "tool-result") {
+        continue;
+      }
+      const [serverName, toolName] = extractServerNameToolName(part.toolName);
+      if (!isPowerTool(serverName) || toolName !== POWER_TOOL_SEMANTIC_SEARCH) {
+        continue;
+      }
+      searchIndices.push({ messageIndex: i, partIndex: j, toolCallId: part.toolCallId });
+    }
+  }
+  if (searchIndices.length <= 1) {
+    return result;
+  }
+  const toRemove = searchIndices.slice(0, -1);
+  const toKeep = searchIndices[searchIndices.length - 1];
+  for (const search2 of toRemove) {
+    removeToolCallFromAssistant(result, search2.toolCallId);
+    removeToolResult(result, search2.toolCallId);
+  }
+  const keptToolIdx = result.findIndex((m) => m.role === "tool" && m.content.some((p) => p.type === "tool-result" && p.toolCallId === toKeep.toolCallId));
+  if (keptToolIdx !== -1) {
+    const keptMsg = result[keptToolIdx];
+    const keptPartIdx = keptMsg.content.findIndex((p) => p.type === "tool-result" && p.toolCallId === toKeep.toolCallId);
+    const keptPart = keptMsg.content[keptPartIdx];
+    if (keptPart && keptPart.output.type === "text") {
+      const lines = keptPart.output.value.split("\n");
+      if (lines.length > 50) {
+        keptPart.output = {
+          type: "text",
+          value: lines.slice(0, 50).join("\n") + "\n<truncated due to compaction, run again if full output is needed>"
+        };
+      }
+    }
+  }
+  return result;
+};
+const deduplicateBash = (messages, protectedMessageCount = 10) => {
+  const result = cloneMessages(messages);
+  const protectedStart = getProtectedStartIndex(result, protectedMessageCount);
+  const bashCommands = /* @__PURE__ */ new Map();
+  for (let i = 0; i < protectedStart; i++) {
+    const msg = result[i];
+    if (msg.role !== "tool") {
+      continue;
+    }
+    for (const part of msg.content) {
+      if (part.type !== "tool-result") {
+        continue;
+      }
+      const [serverName, toolName] = extractServerNameToolName(part.toolName);
+      if (!isPowerTool(serverName) || toolName !== POWER_TOOL_BASH) {
+        continue;
+      }
+      const callInfo = findAssistantToolCall(result, part.toolCallId);
+      if (!callInfo) {
+        continue;
+      }
+      const command = typeof callInfo.input?.command === "string" ? callInfo.input.command.trim() : null;
+      if (!command) {
+        continue;
+      }
+      if (!bashCommands.has(command)) {
+        bashCommands.set(command, []);
+      }
+      bashCommands.get(command).push({
+        messageIndex: i,
+        toolCallId: part.toolCallId
+      });
+    }
+  }
+  for (const [, occurrences] of bashCommands) {
+    if (occurrences.length <= 1) {
+      continue;
+    }
+    const toRemove = occurrences.slice(0, -1);
+    for (const occ of toRemove) {
+      removeToolCallFromAssistant(result, occ.toolCallId);
+      removeToolResult(result, occ.toolCallId);
+    }
+  }
+  for (let i = 0; i < protectedStart; i++) {
+    if (i >= result.length) {
+      break;
+    }
+    const msg = result[i];
+    if (msg.role !== "tool") {
+      continue;
+    }
+    for (let j = 0; j < msg.content.length; j++) {
+      const part = msg.content[j];
+      if (part.type !== "tool-result") {
+        continue;
+      }
+      const [serverName, toolName] = extractServerNameToolName(part.toolName);
+      if (!isPowerTool(serverName) || toolName !== POWER_TOOL_BASH) {
+        continue;
+      }
+      if (part.output.type !== "text") {
+        continue;
+      }
       try {
-        logger.info("Starting merge revert operation", { mergeState });
-        worktreeRevertStashId = await this.stashUncommittedChanges(
-          currentWorktreeStashId,
-          worktreePath,
-          "Current uncommitted changes before revert",
-          symlinkFolders
-        );
-        mainRevertStashId = await this.stashUncommittedChanges(currentMainStashId, projectPath, "Current uncommitted changes before revert", []);
-        const targetBranch = mergeState.targetBranch || await this.getProjectMainBranch(projectPath);
-        await execWithShellPath(`git checkout ${targetBranch}`, {
-          cwd: projectPath
-        });
-        logger.info(`Resetting ${targetBranch} branch to ${mergeState.beforeMergeCommitHash}`);
-        await execWithShellPath(`git reset --hard ${mergeState.beforeMergeCommitHash}`, { cwd: projectPath });
-        logger.info(`Resetting worktree branch to ${mergeState.worktreeBranchCommitHash}`);
-        await execWithShellPath(`git reset --hard ${mergeState.worktreeBranchCommitHash}`, { cwd: worktreePath });
-        if (mergeState.mainOriginalStashId) {
-          logger.info("Restoring main branch original uncommitted changes");
-          await this.applyStash(projectPath, mergeState.mainOriginalStashId);
-          await this.dropStash(projectPath, mergeState.mainOriginalStashId);
-        }
-        if (worktreeRevertStashId) {
-          logger.info("Restoring uncommitted changes in worktree");
-          await this.applyStash(worktreePath, currentWorktreeStashId);
-          await this.dropStash(worktreePath, currentWorktreeStashId);
-        }
-        if (mainRevertStashId) {
-          await this.dropStash(projectPath, currentMainStashId);
-        }
-        logger.info("Merge revert completed successfully");
-      } catch (error) {
-        logger.error("Failed to revert merge:", error);
-        if (worktreeRevertStashId) {
-          try {
-            await this.applyStash(worktreePath, currentWorktreeStashId);
-            await this.dropStash(worktreePath, currentWorktreeStashId);
-          } catch (recoveryError) {
-            logger.error("Failed to recover worktree stash:", recoveryError);
+        const parsed = JSON.parse(part.output.value);
+        if (typeof parsed === "object" && parsed !== null) {
+          const stdout = typeof parsed.stdout === "string" ? parsed.stdout : "";
+          const stderr = typeof parsed.stderr === "string" ? parsed.stderr : "";
+          const redactionMessage = "<output redacted due to compaction, run again if output is needed>";
+          let modified = false;
+          if (stdout.length > 30) {
+            parsed.stdout = redactionMessage;
+            modified = true;
           }
-        }
-        if (mainRevertStashId) {
-          try {
-            await this.applyStash(projectPath, currentMainStashId);
-            await this.dropStash(projectPath, currentMainStashId);
-          } catch (recoveryError) {
-            logger.error("Failed to recover main branch stash:", recoveryError);
+          if (stderr.length > 30) {
+            parsed.stderr = redactionMessage;
+            modified = true;
+          }
+          if (modified) {
+            part.output = {
+              type: "text",
+              value: JSON.stringify(parsed)
+            };
           }
         }
-        throw new Error(`Failed to revert merge: ${error instanceof Error ? error.message : String(error)}`);
+      } catch {
       }
-    });
+    }
   }
-  async pruneDeleted(projectDir) {
-    logger.info("Pruning deleted worktrees", {
-      projectDir
-    });
-    const worktrees = await this.listWorktrees(projectDir);
-    logger.debug("Found worktrees", {
-      worktrees
-    });
-    for (const worktree of worktrees) {
-      if (worktree.path.startsWith(path.join(projectDir, AIDER_DESK_TASKS_DIR)) && worktree.prunable) {
-        try {
-          logger.debug(`Pruning deleted worktree: ${worktree.path}`);
-          await execWithShellPath(`git worktree remove ${worktree.path}`, {
-            cwd: projectDir
-          });
-        } catch (error) {
-          logger.warn("Failed to prune worktree:", {
-            worktree,
-            error: error instanceof Error ? error.message : String(error)
-          });
-          await fs.rm(worktree.path, { recursive: true, force: true });
-        }
+  return result;
+};
+const redactFetchOutputs = (messages, protectedMessageCount = 10) => {
+  const result = cloneMessages(messages);
+  const protectedStart = getProtectedStartIndex(result, protectedMessageCount);
+  for (let i = 0; i < protectedStart; i++) {
+    const msg = result[i];
+    if (msg.role !== "tool") {
+      continue;
+    }
+    for (let j = 0; j < msg.content.length; j++) {
+      const part = msg.content[j];
+      if (part.type !== "tool-result") {
+        continue;
+      }
+      const [serverName, toolName] = extractServerNameToolName(part.toolName);
+      if (!isPowerTool(serverName) || toolName !== POWER_TOOL_FETCH) {
+        continue;
+      }
+      const outputText = getToolOutputText(part.output);
+      if (outputText.length > 0) {
+        part.output = {
+          type: "text",
+          value: "<content redacted due to compaction, fetch again if content is needed>"
+        };
       }
     }
   }
-  async close(projectDir) {
-    logger.info("Closing worktree manager");
-    await this.pruneDeleted(projectDir);
-  }
-}
+  return result;
+};
 const INTERNAL_TASK_ID = "internal";
 const RESPONSE_CHUNK_FLUSH_INTERVAL_MS = 10;
 const EMPTY_TASK_DATA = {
@@ -14622,7 +15811,6 @@ const EMPTY_TASK_DATA = {
   agentTotalCost: 0,
   mainModel: "",
   currentMode: "agent",
-  contextCompactingThreshold: 0,
   weakModelLocked: false,
   parentId: null,
   lastAgentProviderMetadata: void 0
@@ -15117,7 +16305,7 @@ class Task {
   isPromptRunning() {
     return !!this.currentPromptContext || this.agent.isRunning() || this.isCompacting;
   }
-  async runPrompt(prompt, mode = this.task.currentMode || "agent", addToInputHistory = true, userMessageId = uuid.v4(), sendNotification = true) {
+  async runPrompt(prompt, mode = this.task.currentMode || "agent", addToInputHistory = true, userMessageId = uuid.v4(), sendNotification = true, images) {
     if (this.currentQuestion) {
       if (await this.answerQuestion("n", prompt)) {
         logger.debug("Processed by the answerQuestion function.");
@@ -15155,7 +16343,7 @@ class Task {
     if (addToInputHistory) {
       await this.project.addToInputHistory(prompt);
     }
-    this.addUserMessage(userMessageId, prompt);
+    this.addUserMessage(userMessageId, prompt, promptContext, images);
     this.addLogMessage("loading");
     this.telemetryManager.captureRunPrompt(mode);
     let responses = [];
@@ -15165,7 +16353,7 @@ class Task {
       if (!profile) {
         throw new Error("No active Agent profile found");
       }
-      responses = await this.runPromptInAgent(profile, mode, prompt, promptContext, void 0, void 0, void 0, true, sendNotification);
+      responses = await this.runPromptInAgent(profile, mode, prompt, promptContext, void 0, void 0, void 0, true, sendNotification, images);
     } else {
       responses = await this.runPromptInAider(mode, prompt, promptContext, sendNotification);
     }
@@ -15277,7 +16465,7 @@ class Task {
     }
     return responses;
   }
-  async runPromptInAgent(profile, mode, prompt, promptContext = { id: uuid.v4() }, contextMessages, contextFiles, systemPrompt, waitForCurrentAgentToFinish = true, sendNotification = true) {
+  async runPromptInAgent(profile, mode, prompt, promptContext = { id: uuid.v4() }, contextMessages, contextFiles, systemPrompt, waitForCurrentAgentToFinish = true, sendNotification = true, images) {
     if (waitForCurrentAgentToFinish) {
       await this.waitForCurrentAgentToFinish();
     }
@@ -15288,7 +16476,19 @@ class Task {
       provider: this.task.provider || profile.provider,
       model: this.task.model || profile.model
     });
-    const agentMessages = await this.agent.runAgent(this, profile, prompt, mode, promptContext, contextMessages, contextFiles, systemPrompt);
+    const agentMessages = await this.agent.runAgent(
+      this,
+      profile,
+      prompt,
+      mode,
+      promptContext,
+      contextMessages,
+      contextFiles,
+      systemPrompt,
+      true,
+      void 0,
+      images
+    );
     if (agentMessages.length > 0) {
       this.contextManager.toConnectorMessages(agentMessages).forEach((message) => {
         this.sendAddMessage(message.role, message.content, false);
@@ -16325,7 +17525,8 @@ ${contentText}</agent-response>`;
   sendUserMessage(data) {
     logger.debug("Sending user message:", {
       baseDir: this.project.baseDir,
-      content: data.content.substring(0, 100)
+      content: data.content?.substring(0, 100),
+      hasImages: (data.images?.length ?? 0) > 0
     });
     this.eventManager.sendUserMessage(data);
   }
@@ -16342,18 +17543,20 @@ ${contentText}</agent-response>`;
     });
     this.eventManager.sendTool(data);
   }
-  async clearContext(addToHistory = false, updateContextInfo = true) {
+  async clearContext(addToHistory = false, updateContextInfo = true, updateTaskState = true, createSnapshot = true) {
     logger.info("Clearing context:", {
       baseDir: this.project.baseDir,
       addToHistory,
       updateContextInfo
     });
-    await this.updateTask({
-      state: DefaultTaskState.Todo,
-      metadata: void 0,
-      lastAgentProviderMetadata: null
-    });
-    this.contextManager.clearMessages();
+    if (updateTaskState) {
+      await this.updateTask({
+        state: DefaultTaskState.Todo,
+        metadata: void 0,
+        lastAgentProviderMetadata: null
+      });
+    }
+    this.contextManager.clearMessages(true, createSnapshot);
     await this.runCommand("clear", addToHistory);
     this.eventManager.sendClearTask(this.project.baseDir, this.taskId, true, false);
     if (updateContextInfo) {
@@ -16369,6 +17572,29 @@ ${contentText}</agent-response>`;
     this.contextManager.clearMessages();
     await this.contextManager.save();
   }
+  sendContextInfoUpdated() {
+    this.eventManager.sendContextInfoUpdated({
+      baseDir: this.project.baseDir,
+      taskId: this.taskId,
+      canUndoContextChange: this.contextManager.hasUndoSnapshot()
+    });
+  }
+  async undoContextChange() {
+    const snapshot = this.contextManager.undoContextChange();
+    if (!snapshot) {
+      logger.debug("No undo snapshot available", { taskId: this.taskId });
+      return false;
+    }
+    logger.info("Undoing context change", {
+      baseDir: this.project.baseDir,
+      taskId: this.taskId,
+      messagesCount: snapshot.length
+    });
+    await this.contextManager.loadMessages(snapshot);
+    await this.updateContextInfo();
+    this.sendContextInfoUpdated();
+    return true;
+  }
   /**
    * Load context messages into the task context and send them to the UI.
    * This is used for loading pre-authored context (e.g., from extensions).
@@ -16382,6 +17608,12 @@ ${contentText}</agent-response>`;
     await this.contextManager.loadMessages(messages);
   }
   async interruptResponse(interruptId) {
+    const extensionResult = await this.extensionManager.dispatchEvent("onInterrupted", { interruptId }, this.project, this);
+    if (extensionResult.blocked) {
+      logger.debug("Interrupt blocked by extension", { interruptId });
+      return;
+    }
+    interruptId = extensionResult.interruptId;
     if (interruptId) {
       const subagentAbortController = this.subagentAbortControllers[interruptId];
       if (subagentAbortController) {
@@ -16554,7 +17786,7 @@ ${contentText}</agent-response>`;
       this.eventManager.sendTaskUpdated(this.task);
     }
   }
-  addUserMessage(id, content, promptContext) {
+  addUserMessage(id, content, promptContext, images) {
     logger.info("Adding user message:", {
       baseDir: this.project.baseDir,
       content: content.substring(0, 100)
@@ -16565,6 +17797,7 @@ ${contentText}</agent-response>`;
       baseDir: this.project.baseDir,
       taskId: this.taskId,
       content,
+      images,
       promptContext
     };
     this.eventManager.sendUserMessage(data);
@@ -16597,12 +17830,13 @@ ${contentText}</agent-response>`;
       this.eventManager.sendTaskMessageRemoved(this.project.baseDir, this.taskId, messageIds);
     }
   }
-  async redoUserPrompt(messageId, mode, updatedPrompt) {
+  async redoUserPrompt(messageId, mode, updatedPrompt, updatedImages) {
     logger.info("Redoing user prompt:", {
       baseDir: this.project.baseDir,
       messageId,
       mode,
-      hasUpdatedPrompt: !!updatedPrompt
+      hasUpdatedPrompt: !!updatedPrompt,
+      hasUpdatedImages: !!updatedImages
     });
     const removedMessages = this.contextManager.removeMessagesUpToUserMessage(messageId);
     const originalUserMessage = removedMessages[0];
@@ -16610,14 +17844,16 @@ ${contentText}</agent-response>`;
       logger.warn("Could not find the specified user message to redo.", { messageId });
       return;
     }
-    const promptToRun = updatedPrompt ?? originalUserMessage.content;
+    const originalText = extractTextContent(originalUserMessage.content);
+    const promptToRun = updatedPrompt ?? originalText;
+    const imagesToRun = updatedImages ?? (updatedPrompt !== void 0 ? void 0 : extractImagesFromContent(originalUserMessage.content));
     if (promptToRun) {
       logger.info("Found message content to run, reloading and re-running prompt.", {
         remainingMessagesCount: (await this.contextManager.getContextMessages()).length
       });
       this.sendTaskMessageRemoved(removedMessages.slice(1).map((msg) => msg.id));
       await this.updateContextInfo();
-      void this.runPrompt(promptToRun, mode, false, originalUserMessage.id);
+      void this.runPrompt(promptToRun, mode, false, originalUserMessage.id, true, imagesToRun);
     } else {
       logger.warn("Could not find a previous user message to redo or an updated prompt to run.");
     }
@@ -16713,6 +17949,22 @@ ${contentText}</agent-response>`;
     }
     return skillMessages;
   }
+  async smartCompactConversation(contextMessages, infoMessage = "Conversation smart-compacted.") {
+    if (!contextMessages) {
+      contextMessages = await this.contextManager.getContextMessages();
+    }
+    if (contextMessages.length === 0) {
+      this.addLogMessage("warning", "No conversation to compact.");
+      return [];
+    }
+    await this.contextManager.backupContext();
+    const compactedMessages = smartCompactMessages(contextMessages);
+    this.contextManager.setContextMessages(compactedMessages);
+    await this.contextManager.loadMessages(compactedMessages, false);
+    await this.updateContextInfo();
+    this.addLogMessage("info", infoMessage, false, void 0, ["undoContextChange"]);
+    return compactedMessages;
+  }
   async compactConversation(mode, customInstructions, profile = null, contextMessages, promptContext, abortSignal, waitForAgentCompletion = true, loadingMessage = "Compacting conversation...") {
     if (!profile) {
       profile = await this.getTaskAgentProfile();
@@ -16801,7 +18053,7 @@ ${contentText}</agent-response>`;
         await this.contextManager.loadMessages(await this.contextManager.getContextMessages());
       }
       await this.updateContextInfo();
-      this.addLogMessage("info", "Conversation compacted.");
+      this.addLogMessage("info", "Conversation compacted.", false, void 0, ["undoContextChange"]);
     } catch (error) {
       logger.error("Failed to compact conversation", {
         baseDir: this.project.baseDir,
@@ -16899,6 +18151,7 @@ ${contentText}</agent-response>`;
   }
   async updateContextInfo(checkContextFilesIncluded = false, checkRepoMapIncluded = false) {
     void this.debouncedUpdateContextInfo(checkContextFilesIncluded, checkRepoMapIncluded);
+    void this.sendSkillsUpdated();
   }
   debouncedUpdateContextInfo = debounce(async (checkContextFilesIncluded = false, checkRepoMapIncluded = false) => {
     void this.sendRequestContextInfo();
@@ -17172,7 +18425,6 @@ ${error.stderr}`,
       id: uuid.v4()
     };
     this.addUserMessage(promptContext.id, prompt);
-    this.addLogMessage("loading", "Executing custom command...");
     try {
       if (!AIDER_MODES.includes(mode)) {
         const profile = await this.getTaskAgentProfile();
@@ -17180,11 +18432,22 @@ ${error.stderr}`,
           this.addLogMessage("error", "No active Agent profile found");
           return;
         }
+        if (command.skills?.length) {
+          for (const skillName of command.skills) {
+            try {
+              await this.activateSkill(skillName);
+            } catch (error) {
+              logger.warn(`Failed to activate skill '${skillName}' for command '${commandName}': ${error instanceof Error ? error.message : String(error)}`);
+            }
+          }
+        }
         const systemPrompt = await this.promptsManager.getSystemPrompt(this.store.getSettings(), this, profile, command.autoApprove ?? this.task.autoApprove);
         const messages = command.includeContext === false ? [] : void 0;
         const contextFiles = command.includeContext === false ? [] : void 0;
+        this.addLogMessage("loading", "Executing custom command...");
         await this.runPromptInAgent(profile, mode, prompt, promptContext, messages, contextFiles, systemPrompt);
       } else {
+        this.addLogMessage("loading", "Executing custom command...");
         await this.runPromptInAider(mode, prompt, promptContext);
       }
     } finally {
@@ -18106,6 +19369,9 @@ class Project {
       if (!parentTask) {
         throw new Error(`Parent task with id ${normalizedParams.parentId} not found`);
       }
+      if (parentTask.task.parentId) {
+        normalizedParams.parentId = parentTask.task.parentId;
+      }
       if (!parentTask.task.createdAt) {
         await parentTask.saveTask();
       }
@@ -18143,9 +19409,7 @@ class Project {
       };
     }
     const projectSettings = this.getProjectSettings();
-    const taskSettings = this.store.getSettings().taskSettings;
     const taskData = {
-      contextCompactingThreshold: taskSettings.contextCompactingThreshold,
       autoApprove: projectSettings.autoApproveLocked ? true : initialTaskData.autoApprove,
       ...initialTaskData
     };
@@ -18164,7 +19428,14 @@ class Project {
     }
     return task.task;
   }
-  async prepareTask(taskId = uuid.v4(), initialTaskData) {
+  generateShortTaskId() {
+    let id;
+    do {
+      id = uuid.v4().substring(0, 8);
+    } while (this.tasks.has(id));
+    return id;
+  }
+  async prepareTask(taskId = this.generateShortTaskId(), initialTaskData) {
     const task = new Task(
       this,
       taskId,
@@ -18333,6 +19604,9 @@ class Project {
   getAgentProfiles() {
     return this.agentProfileManager.getProjectProfiles(this);
   }
+  resolveAgentProfile(id) {
+    return this.agentProfileManager.resolveAgentProfile(id);
+  }
   /**
    * Checks if any other task (excluding the specified taskId) uses the given worktree path.
    */
@@ -18588,6 +19862,10 @@ class EventManager {
     this.sendToWindows("clear-task", data);
     this.broadcastToEventConnectors("clear-task", data);
   }
+  sendContextInfoUpdated(data) {
+    this.sendToWindows("context-info-updated", data);
+    this.broadcastToEventConnectors("context-info-updated", data);
+  }
   // File management events
   sendFileAdded(baseDir, taskId, file) {
     const data = {
@@ -20979,7 +22257,8 @@ const createLmStudioLlm = (profile, model, settings, projectDir) => {
   const lmStudioProvider = openaiCompatible.createOpenAICompatible({
     name: "lmstudio",
     baseURL: baseUrl,
-    headers: profile.headers
+    headers: profile.headers,
+    includeUsage: true
   });
   return lmStudioProvider(model.id);
 };
@@ -21652,12 +22931,18 @@ const loadOpenaiCompatibleModels = async (profile, settings) => {
       return { models: [], success: false, error: errorMsg };
     }
     const data = await response.json();
-    const models = data.data?.map((model) => {
-      return {
-        id: model.id,
-        providerId: profile.id
-      };
-    }) || [];
+    const models = data.data?.map(
+      (model) => {
+        const maxInputTokens = model.max_model_len ?? model.context_length ?? model.num_ctx ?? model.context_window;
+        const maxOutputTokensLimit = model.max_completion_tokens ?? model.max_tokens;
+        return {
+          id: model.id,
+          providerId: profile.id,
+          ...maxInputTokens != null && { maxInputTokens },
+          ...maxOutputTokensLimit != null && { maxOutputTokensLimit }
+        };
+      }
+    ) || [];
     logger.info(`Loaded ${models.length} OpenAI-compatible models for profile ${profile.id}`);
     return { models, success: true };
   } catch (error) {
@@ -21706,11 +22991,14 @@ const createOpenAiCompatibleLlm = (profile, model, settings, projectDir) => {
   if (!baseUrl) {
     throw new Error(`Base URL is required for ${provider.name} provider. Set it in Providers settings or via the OPENAI_API_BASE environment variable.`);
   }
+  const providerOverrides = model.providerOverrides;
+  const trackTokenUsage = providerOverrides?.trackTokenUsage ?? provider.trackTokenUsage;
   const compatibleProvider = openaiCompatible.createOpenAICompatible({
     name: provider.name,
     apiKey,
     baseURL: baseUrl,
-    headers: profile.headers
+    headers: profile.headers,
+    includeUsage: trackTokenUsage !== false
   });
   return compatibleProvider(model.id);
 };
@@ -22192,7 +23480,7 @@ const getRequestyUsageReport = (task, provider, model, usage, providerMetadata)
   const cacheWriteTokens = requesty?.usage?.cachingTokens ?? 0;
   const cacheReadTokens = requesty?.usage?.cachedTokens ?? 0;
   const sentTokens = totalSentTokens - cacheReadTokens;
-  const messageCost = calculateRequestyCost(model, sentTokens, receivedTokens, cacheWriteTokens, cacheReadTokens);
+  const messageCost = requesty?.usage?.cost ?? calculateRequestyCost(model, sentTokens, receivedTokens, cacheWriteTokens, cacheReadTokens);
   return {
     model: `${provider.id}/${model.id}`,
     sentTokens,
@@ -23102,6 +24390,7 @@ class ModelManager {
   getModelSettings(providerId, modelId, useModelInfoFallback = false) {
     let model;
     const providerModels = this.providerModels[providerId];
+    logger.debug(`getModelSettings providerModels for provider: ${providerId}`, { providerModels });
     if (providerModels) {
       model = providerModels.find((m) => m.id === modelId);
     }
@@ -23115,6 +24404,11 @@ class ModelManager {
         };
       }
     }
+    logger.debug("getModelSettings model", {
+      providerId,
+      modelId,
+      model
+    });
     return model;
   }
   createLlm(provider, model, settings, projectDir, toolSet, systemPrompt, providerMetadata) {
@@ -23680,7 +24974,7 @@ class VersionsManager {
         ...this.versionsInfo
       };
     }
-    logger.info("Checking for version updates...");
+    logger.debug("Checking for version updates...");
     const aiderDeskCurrentVersion = app.getVersion();
     const autoUpdater = require("electron-updater").autoUpdater;
     if (this.pythonInstaller) {
@@ -25036,6 +26330,41 @@ class ExtensionFetcher {
     const extensions = [];
     try {
       const entries = await fs.readdir(extensionsPath, { withFileTypes: true });
+      const rootIndexTs = path.join(extensionsPath, "index.ts");
+      const rootIndexJs = path.join(extensionsPath, "index.js");
+      const rootPackageJson = path.join(extensionsPath, "package.json");
+      let rootIndexFile = null;
+      if (await this.fileExists(rootIndexTs)) {
+        rootIndexFile = rootIndexTs;
+      } else if (await this.fileExists(rootIndexJs)) {
+        rootIndexFile = rootIndexJs;
+      }
+      const hasRootPackageJson = await this.fileExists(rootPackageJson);
+      if (rootIndexFile && hasRootPackageJson) {
+        const metadata = await this.extractMetadataFromLocalFile(rootIndexFile);
+        if (metadata) {
+          const repoName = this.getRepoName(repoUrl);
+          let readmeContent;
+          const readmePath = path.join(extensionsPath, "README.md");
+          try {
+            const content = await fs.readFile(readmePath, "utf-8");
+            if (content.trim()) {
+              readmeContent = content;
+            }
+          } catch {
+          }
+          extensions.push({
+            ...metadata,
+            id: repoName,
+            type: "folder",
+            folder: repoName,
+            repositoryUrl: repoUrl,
+            hasDependencies: true,
+            readmeContent
+          });
+          return extensions;
+        }
+      }
       for (const entry of entries) {
         if (entry.isDirectory()) {
           const indexPathTs = path.join(extensionsPath, entry.name, "index.ts");
@@ -25089,6 +26418,17 @@ class ExtensionFetcher {
     }
     return extensions;
   }
+  getRepoName(repoUrl) {
+    try {
+      const url = new URL(repoUrl);
+      const pathParts = url.pathname.split("/").filter(Boolean);
+      if (pathParts.length >= 2) {
+        return pathParts[1].replace(/\.git$/, "");
+      }
+    } catch {
+    }
+    return repoUrl.replace(/[^a-zA-Z0-9]/g, "-");
+  }
   async fileExists(filePath) {
     try {
       await fs.access(filePath);
@@ -26009,7 +27349,7 @@ class ExtensionManager {
           }
           collectedSkills.push({
             ...skill,
-            location: "extension"
+            location: skill.location || "extension"
           });
         }
       } catch (error) {
@@ -26350,12 +27690,19 @@ class ExtensionManager {
       } else if (extension.type === "folder" && extension.folder) {
         const repoDir = await this.fetcher.ensureRepoCloned(repositoryUrl);
         const extensionsPath = this.fetcher.getExtensionsPath(repositoryUrl, repoDir);
-        const sourcePath = path.join(extensionsPath, extension.folder);
         const targetPath = path.join(targetDir, extension.folder);
+        let sourcePath = path.join(extensionsPath, extension.folder);
+        if (!await this.fileExists(sourcePath)) {
+          sourcePath = extensionsPath;
+        }
         if (!await this.fileExists(sourcePath)) {
           throw new Error(`Extension folder not found in repository: ${extension.folder}`);
         }
         await fs.cp(sourcePath, targetPath, { recursive: true });
+        const gitDir = path.join(targetPath, ".git");
+        if (await this.fileExists(gitDir)) {
+          await fs.rm(gitDir, { recursive: true, force: true });
+        }
         if (extension.hasDependencies) {
           logger.debug(`[Extensions] Installing dependencies for ${extension.name}...`);
           await this.installDependencies(targetPath);
@@ -26480,12 +27827,19 @@ class ExtensionManager {
       } else if (extension.type === "folder" && extension.folder) {
         const repoDir = await this.fetcher.ensureRepoCloned(repositoryUrl);
         const extensionsPath = this.fetcher.getExtensionsPath(repositoryUrl, repoDir);
-        const sourcePath = path.join(extensionsPath, extension.folder);
         const targetPath = path.join(targetDir, extension.folder);
+        let sourcePath = path.join(extensionsPath, extension.folder);
+        if (!await this.fileExists(sourcePath)) {
+          sourcePath = extensionsPath;
+        }
         if (!await this.fileExists(sourcePath)) {
           throw new Error(`Extension folder not found in repository: ${extension.folder}`);
         }
         await fs.cp(sourcePath, targetPath, { recursive: true });
+        const gitDir = path.join(targetPath, ".git");
+        if (await this.fileExists(gitDir)) {
+          await fs.rm(gitDir, { recursive: true, force: true });
+        }
         const packageJsonPath = path.join(targetPath, "package.json");
         if (await this.fileExists(packageJsonPath)) {
           logger.debug(`[Extensions] Installing dependencies for ${extension.name}...`);
@@ -26535,7 +27889,7 @@ class ExtensionManager {
         if (result && typeof result === "object") {
           const partialEvent = result;
           currentEvent = { ...currentEvent, ...partialEvent };
-          if ("blocked" in currentEvent && currentEvent.blocked === true) {
+          if ("blocked" in currentEvent && currentEvent.blocked) {
             logger.debug(`[Extensions] Event '${String(eventName)}' blocked by extension '${metadata.name}'`);
             break;
           }
@@ -26704,8 +28058,8 @@ class EventsHandler {
     const removedIds = await this.projectManager.getProject(baseDir).getTask(taskId)?.removeMessagesUpTo(messageId) ?? [];
     this.eventManager.sendTaskMessageRemoved(baseDir, taskId, removedIds);
   }
-  async redoUserPrompt(baseDir, taskId, messageId, mode, updatedPrompt) {
-    void this.projectManager.getProject(baseDir).getTask(taskId)?.redoUserPrompt(messageId, mode, updatedPrompt);
+  async redoUserPrompt(baseDir, taskId, messageId, mode, updatedPrompt, updatedImages) {
+    void this.projectManager.getProject(baseDir).getTask(taskId)?.redoUserPrompt(messageId, mode, updatedPrompt, updatedImages);
   }
   async resumeTask(baseDir, taskId) {
     void this.projectManager.getProject(baseDir).getTask(taskId)?.resumeTask();
@@ -26716,6 +28070,19 @@ class EventsHandler {
       await task.compactConversation(mode, customInstructions);
     }
   }
+  async smartCompactConversation(baseDir, taskId) {
+    const task = this.projectManager.getProject(baseDir).getTask(taskId);
+    if (task) {
+      await task.smartCompactConversation();
+    }
+  }
+  async undoContextChange(baseDir, taskId) {
+    const task = this.projectManager.getProject(baseDir).getTask(taskId);
+    if (task) {
+      return task.undoContextChange();
+    }
+    return false;
+  }
   async handoffConversation(baseDir, taskId, focus) {
     const task = this.projectManager.getProject(baseDir).getTask(taskId);
     if (!task) {
@@ -26800,8 +28167,8 @@ class EventsHandler {
   applyEdits(baseDir, taskId, edits) {
     this.projectManager.getProject(baseDir).getTask(taskId)?.applyEdits(edits);
   }
-  async runPrompt(baseDir, taskId, prompt, mode) {
-    return this.projectManager.getProject(baseDir).getTask(taskId)?.runPrompt(prompt, mode) || [];
+  async runPrompt(baseDir, taskId, prompt, mode, images) {
+    return this.projectManager.getProject(baseDir).getTask(taskId)?.runPrompt(prompt, mode, true, void 0, true, images) || [];
   }
   async savePrompt(baseDir, taskId, prompt) {
     return this.projectManager.getProject(baseDir).getTask(taskId)?.savePromptOnly(prompt);
@@ -28760,6 +30127,16 @@ const migrateSettingsV18toV19 = (settings) => {
     }
   };
 };
+const migrateSettingsV19toV20 = (settings) => {
+  const oldThreshold = settings.taskSettings?.contextCompactingThreshold;
+  return {
+    ...settings,
+    taskSettings: {
+      ...settings.taskSettings,
+      contextCompactingThreshold: typeof oldThreshold === "number" ? { percentage: oldThreshold, tokens: 1e5 } : oldThreshold || { percentage: 90, tokens: 1e5 }
+    }
+  };
+};
 const DEFAULT_SETTINGS = {
   language: "en",
   startupMode: ProjectStartMode.Empty,
@@ -28820,7 +30197,7 @@ const DEFAULT_SETTINGS = {
     autoGenerateTaskName: true,
     showTaskStateActions: true,
     worktreeSymlinkFolders: ["node_modules", "vendor", "__pycache__", ".venv", "venv"],
-    contextCompactingThreshold: 0,
+    contextCompactingThreshold: { percentage: 90, tokens: 1e5 },
     contextCompactionType: ContextCompactionType.Compact,
     defaultWorkingMode: "local",
     worktreeBranchPrefix: "aider-desk/task/",
@@ -28838,7 +30215,7 @@ const DEFAULT_SETTINGS = {
 const compareBaseDirs = (baseDir1, baseDir2) => {
   return normalizeBaseDir(baseDir1) === normalizeBaseDir(baseDir2);
 };
-const CURRENT_SETTINGS_VERSION = 19;
+const CURRENT_SETTINGS_VERSION = 20;
 class Store {
   // @ts-expect-error expected to be initialized
   store;
@@ -28989,6 +30366,10 @@ class Store {
         settings = migrateSettingsV18toV19(settings);
         settingsVersion = 19;
       }
+      if (settingsVersion === 19) {
+        settings = migrateSettingsV19toV20(settings);
+        settingsVersion = 20;
+      }
       this.store.set("settings", settings);
       this.store.set("openProjects", openProjects || []);
       this.store.set("providers", providers || []);
@@ -29182,4 +30563,5 @@ if (!process.env.VITEST) {
 }
 exports.addProjectsFromEnv = addProjectsFromEnv;
 exports.initializeLangfuseExporter = initializeLangfuseExporter;
+exports.initializePostHogExporter = initializePostHogExporter;
 exports.logger = logger;