@aiderdesk/aiderdesk 0.64.0 → 0.67.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");
@@ -229,14 +231,16 @@ const TASKS_TOOL_GET_TASK_MESSAGE = "get_task_message";
 const TASKS_TOOL_CREATE_TASK = "create_task";
 const TASKS_TOOL_DELETE_TASK = "delete_task";
 const TASKS_TOOL_SEARCH_TASK = "search_task";
+const TASKS_TOOL_RUN_PROMPT = "run_prompt";
 const TASKS_TOOL_SEARCH_PARENT_TASK = "search_parent_task";
 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_RUN_PROMPT]: "Run a prompt on an existing task. The task must already exist (use create_task first if needed). Use this to send additional instructions to a task, continue work on an existing task, or delegate follow-up work. By default, waits for the prompt to complete before returning. Use executeInBackground to run without waiting.",
   [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."
 };
 const WorktreeSchema = zod.z.object({
@@ -255,6 +259,13 @@ const MergeStateSchema = zod.z.object({
 });
 const AIDER_MODES = ["code", "ask", "architect", "context"];
 const AIDER_COMMANDS = ["commit", "map", "map-refresh", "tokens", "test"];
+var AutonomyMode = /* @__PURE__ */ ((AutonomyMode2) => {
+  AutonomyMode2["Manual"] = "manual";
+  AutonomyMode2["Guided"] = "guided";
+  AutonomyMode2["Autonomous"] = "autonomous";
+  return AutonomyMode2;
+})(AutonomyMode || {});
+const DEFAULT_AUTONOMY_MODE = "guided";
 var DiffViewMode = /* @__PURE__ */ ((DiffViewMode2) => {
   DiffViewMode2["SideBySide"] = "side-by-side";
   DiffViewMode2["Unified"] = "unified";
@@ -297,9 +308,8 @@ 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(),
+  autonomyModeLocked: zod.z.boolean().optional(),
   updatedFilesGroupMode: zod.z.enum(["grouped", "flat"]).default("flat"),
   disabledRuleFiles: zod.z.array(zod.z.string()).default([]),
   contextSidebarSectionsOrder: zod.z.array(zod.z.string()).default([]),
@@ -335,8 +345,15 @@ var MemoryEmbeddingProvider = /* @__PURE__ */ ((MemoryEmbeddingProvider2) => {
 var ContextCompactionType = /* @__PURE__ */ ((ContextCompactionType2) => {
   ContextCompactionType2["Compact"] = "compact";
   ContextCompactionType2["Handoff"] = "handoff";
+  ContextCompactionType2["Smart"] = "smart";
   return ContextCompactionType2;
 })(ContextCompactionType || {});
+var FileWatchMode = /* @__PURE__ */ ((FileWatchMode2) => {
+  FileWatchMode2["Auto"] = "auto";
+  FileWatchMode2["Native"] = "native";
+  FileWatchMode2["Polling"] = "polling";
+  return FileWatchMode2;
+})(FileWatchMode || {});
 var MemoryEmbeddingProgressPhase = /* @__PURE__ */ ((MemoryEmbeddingProgressPhase2) => {
   MemoryEmbeddingProgressPhase2["Idle"] = "idle";
   MemoryEmbeddingProgressPhase2["LoadingModel"] = "loading-model";
@@ -370,7 +387,7 @@ const TaskDataSchema = zod.z.object({
   lastMergeState: MergeStateSchema.optional(),
   aiderTotalCost: zod.z.number(),
   agentTotalCost: zod.z.number(),
-  autoApprove: zod.z.boolean().optional(),
+  autonomyMode: zod.z.nativeEnum(AutonomyMode).optional(),
   agentProfileId: zod.z.string().optional(),
   provider: zod.z.string().optional(),
   model: zod.z.string().optional(),
@@ -380,7 +397,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 +472,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 +578,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 +825,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 +849,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;
@@ -866,6 +901,9 @@ if (process.env.NODE_ENV !== "production" || process.env.AIDER_DESK_HEADLESS ===
 const initEventLogging = (eventManager) => {
   eventTransport.setEventManager(eventManager);
 };
+const isAutoApprove = (task) => {
+  return task.task.autonomyMode !== AutonomyMode.Manual;
+};
 class ApprovalManager {
   constructor(task, profile) {
     this.task = task;
@@ -875,7 +913,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];
@@ -893,7 +931,7 @@ class ApprovalManager {
     key = extensionResult.key;
     text = extensionResult.text;
     subject = extensionResult.subject;
-    if (this.task.task.autoApprove) {
+    if (isAutoApprove(this.task)) {
       return [true, void 0];
     }
     const isApprovedFromSet = this.alwaysApproveForRunKeys.has(key) || (this.profile.toolApprovals[key] || ToolApprovalState.Always) === ToolApprovalState.Always;
@@ -1474,6 +1512,7 @@ const AVAILABLE_PROVIDERS = [
   "lmstudio",
   "minimax",
   "mistral",
+  "neuralwatt",
   "ollama",
   "openai",
   "openai-compatible",
@@ -1519,6 +1558,7 @@ const isOpenCodeProvider = (provider) => provider.name === "opencode";
 const isZaiPlanProvider = (provider) => provider.name === "zai-plan";
 const isMinimaxProvider = (provider) => provider.name === "minimax";
 const isMistralProvider = (provider) => provider.name === "mistral";
+const isNeuralwattProvider = (provider) => provider.name === "neuralwatt";
 const isSyntheticProvider = (provider) => provider.name === "synthetic";
 const DEFAULT_PROVIDER_MODELS = {
   "alibaba-plan": "qwen3-coder-plus",
@@ -1539,7 +1579,8 @@ const DEFAULT_PROVIDER_MODELS = {
   synthetic: "hf:zai-org/GLM-4.7",
   "zai-plan": "glm-5.1",
   minimax: "MiniMax-M2.7",
-  mistral: "mistral-large-latest"
+  mistral: "mistral-large-latest",
+  neuralwatt: "claude-sonnet-4-6"
 };
 const DEFAULT_AIDER_MAIN_MODEL = `anthropic/${DEFAULT_PROVIDER_MODELS.anthropic}`;
 const DEFAULT_AGENT_PROFILE_ID = "default";
@@ -1548,7 +1589,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 +1910,8 @@ const getDefaultProviderParams = (providerName) => {
         name: "openai-compatible",
         apiKey: "",
         baseUrl: "",
-        reasoningEffort: ReasoningEffort.None
+        reasoningEffort: ReasoningEffort.None,
+        trackTokenUsage: true
       };
       break;
     case "litellm":
@@ -1943,6 +1985,12 @@ const getDefaultProviderParams = (providerName) => {
         apiKey: ""
       };
       break;
+    case "neuralwatt":
+      provider = {
+        name: "neuralwatt",
+        apiKey: ""
+      };
+      break;
     case "gemini-cli":
       provider = {
         name: "gemini-cli",
@@ -1984,7 +2032,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 +2042,8 @@ class TelemetryManager {
         distinctId: this.distinctId,
         properties: {
           os: process.platform,
-          version: app?.getVersion()
+          version: app?.getVersion(),
+          appType: APP_TYPE
         }
       });
     } catch (error) {
@@ -2064,7 +2113,7 @@ class TelemetryManager {
         useTodoTools: profile.useTodoTools,
         includeContextFiles: profile.includeContextFiles,
         includeRepoMap: profile.includeRepoMap,
-        autoApprove: task?.autoApprove ?? false,
+        autonomyMode: task?.autonomyMode ?? "guided",
         enabledMcpServersCount: profile.enabledServers.length,
         totalMcpServersCount: Object.keys(this.store.getSettings().mcpServers).length
       }
@@ -2157,6 +2206,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)) {
@@ -2205,7 +2272,8 @@ const readApiKeyFromConfFile = (filePath, envVarName) => {
           OPENCODE_API_KEY: ["opencode"],
           REQUESTY_API_KEY: ["requesty"],
           SYNTHETIC_API_KEY: ["synthetic"],
-          MISTRAL_API_KEY: ["mistral"]
+          MISTRAL_API_KEY: ["mistral"],
+          NEURALWATT_API_KEY: ["neuralwatt"]
         };
         const providerNames = envVarToProviderName[envVarName] || [envVarName.replace(/_API_KEY$/, "").toLowerCase()];
         const apiKeys = Array.isArray(apiKeyValue) ? apiKeyValue : [apiKeyValue];
@@ -2353,7 +2421,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) => {
@@ -2370,7 +2439,7 @@ const getDefaultProjectSettings = (store, providerModels, baseDir, defaultAgentP
     modelEditFormats: {},
     currentMode: "agent",
     agentProfileId: defaultAgentProfileId,
-    autoApproveLocked: false,
+    autonomyModeLocked: false,
     updatedFilesGroupMode: "flat",
     disabledRuleFiles: [],
     contextSidebarSectionsOrder: [],
@@ -2843,8 +2912,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 +2976,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 +3252,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 +3278,30 @@ 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, saveToFile = true, truncationSuffix) => {
   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);
+  let tmpFilePath;
+  if (saveToFile) {
+    const id = Date.now().toString(36) + Math.random().toString(36).substring(2, 8);
+    const tmpFileName = `aider-desk-tool-result-${id}.txt`;
+    tmpFilePath = path.join(os.tmpdir(), tmpFileName);
+    await fs.writeFile(tmpFilePath, content, "utf8");
+  }
   const reasons = [];
   if (lines.length > maxLines) {
     reasons.push(`${lines.length} lines exceeded limit of ${maxLines}`);
@@ -3131,9 +3309,141 @@ 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") + `
-... Content truncated (${reasons.join(", ")}). Full content saved to ${tmpFilePath}.`;
+  if (tokenCount > maxTokens) {
+    reasons.push(`${tokenCount} tokens exceeded limit of ${maxTokens}`);
+  }
+  const getSuffix = () => {
+    if (truncationSuffix) {
+      return truncationSuffix;
+    }
+    const fileNote = tmpFilePath ? ` Full content saved to ${tmpFilePath}.` : "";
+    return `Content truncated (${reasons.join(", ")}).${fileNote}`;
+  };
+  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}.
+
+`;
+    if (truncationSuffix) {
+      const suffixNotice = `
+
+... ${omittedLines} lines omitted. ${truncationSuffix}
+
+`;
+      return headLines.join("\n") + suffixNotice + tailLines.join("\n");
+    }
+    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 + `
+... ${getSuffix()}`;
+};
+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 +3755,97 @@ 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(.*)$/;
+        let pendingBeforeContext = [];
+        let afterContextBreak = false;
+        for (let rawLine of outputLines) {
+          if (rawLine.endsWith("\r")) {
+            rawLine = rawLine.slice(0, -1);
+          }
+          if (rawLine === "--") {
+            pendingBeforeContext = [];
+            afterContextBreak = true;
+            continue;
+          }
+          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) {
+            const context = pendingBeforeContext.length > 0 ? [...pendingBeforeContext, content] : void 0;
+            results.push({
+              filePath,
+              lineNumber: lineNum,
+              lineContent: content,
+              context
+            });
+            pendingBeforeContext = [];
+            afterContextBreak = false;
+          } else {
+            if (afterContextBreak) {
+              pendingBeforeContext.push(content);
+            } else {
+              const lastResult = results[results.length - 1];
+              if (lastResult) {
+                if (!lastResult.context) {
+                  lastResult.context = [];
+                }
+                lastResult.context.push(content);
+              } else {
+                pendingBeforeContext.push(content);
               }
-              results.push(matchResult);
             }
           }
+          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 +3855,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 +3938,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 +3973,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 +3982,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 +3996,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 +4004,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 +4115,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 +4385,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 +4506,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."
+      ),
+      autonomyMode: zod.z.enum(AutonomyMode).optional().describe(
+        'The autonomy mode for the new task. "manual" requires approval for every tool and plan, "guided" (default) auto-approves tools but waits for plan approval from user, "autonomous" runs without interruption.'
+      ),
+      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 { prompt, name, agentProfileId, modelId, mode = "agent", asSubtask = false, autonomyMode, worktree, executeAndWait, executeInBackground } = input;
+      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;
@@ -4174,18 +4551,27 @@ Parent Task ID: ${parentTaskId || "none (top-level task)"}` : ""}`;
         const newTask = await task.getProject().createNewTask({
           parentId: parentTaskId || null,
           name: name || "",
-          autoApprove,
+          autonomyMode,
           workingMode: worktree ? "worktree" : "local"
         });
         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) {
@@ -4243,6 +4629,66 @@ Parent Task ID: ${parentTaskId || "none (top-level task)"}` : ""}`;
       }
     }
   });
+  const runPromptTool = ai.tool({
+    description: TASKS_TOOL_DESCRIPTIONS[TASKS_TOOL_RUN_PROMPT],
+    inputSchema: zod.z.object({
+      taskId: zod.z.string().describe("The ID of the existing task to run the prompt on"),
+      prompt: zod.z.string().describe("The prompt to run on the task"),
+      mode: zod.z.string().optional().describe("Optional mode to use for the prompt. Use only when explicitly requested by the user."),
+      executeAndWait: zod.z.boolean().optional().default(true).describe("If true (default), the tool will wait for the prompt to complete before returning. If false, the prompt will run in the background.")
+    }),
+    execute: async (input, { toolCallId }) => {
+      const { taskId, prompt, mode, executeAndWait = true } = input;
+      task.addToolMessage(
+        toolCallId,
+        TASKS_TOOL_GROUP_NAME,
+        TASKS_TOOL_RUN_PROMPT,
+        { taskId, prompt, mode, executeAndWait },
+        void 0,
+        void 0,
+        promptContext
+      );
+      const toolName = `${TASKS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}${TASKS_TOOL_RUN_PROMPT}`;
+      const questionKey = toolName;
+      const questionText = `Approve running prompt on task ${taskId}?`;
+      const questionSubject = `Task ID: ${taskId}
+Prompt: ${prompt}${executeAndWait ? "\nWait for completion: true" : "\nRun in background: true"}`;
+      const [isApproved, userInput] = await approvalManager.handleToolApproval(toolName, input, questionKey, questionText, questionSubject);
+      if (!isApproved) {
+        return `Running prompt on task denied by user. Reason: ${userInput}`;
+      }
+      try {
+        const targetTask = task.getProject().getTask(taskId);
+        if (!targetTask) {
+          return `Task with ID ${taskId} not found`;
+        }
+        const effectiveMode = mode || targetTask.task.currentMode || "agent";
+        const run = targetTask.runPrompt(prompt, effectiveMode, false);
+        if (executeAndWait) {
+          await run;
+        }
+        const taskState = targetTask.task.state;
+        const contextMessages = await targetTask.getContextMessages();
+        let resultMessage = executeAndWait ? "Prompt has been executed successfully" : "Prompt has been started in the background";
+        if (executeAndWait && taskState === DefaultTaskState.Interrupted) {
+          resultMessage = "Task has been interrupted";
+        } else if (executeAndWait && taskState === DefaultTaskState.Delegated) {
+          resultMessage = "Task has been delegated to a subagent";
+        }
+        return {
+          taskId,
+          result: resultMessage,
+          state: taskState,
+          ...executeAndWait && contextMessages.length > 0 && {
+            lastMessage: contextMessages[contextMessages.length - 1]
+          }
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return `Error running prompt on task: ${errorMessage}`;
+      }
+    }
+  });
   const searchTaskTool = ai.tool({
     description: TASKS_TOOL_DESCRIPTIONS[TASKS_TOOL_SEARCH_TASK],
     inputSchema: zod.z.object({
@@ -4309,6 +4755,7 @@ Please, consider reporting an issue at https://github.com/hotovo/aider-desk/issu
     [`${TASKS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}${TASKS_TOOL_GET_TASK_MESSAGE}`]: getTaskMessageTool,
     [`${TASKS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}${TASKS_TOOL_CREATE_TASK}`]: createTaskTool,
     [`${TASKS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}${TASKS_TOOL_DELETE_TASK}`]: deleteTaskTool,
+    [`${TASKS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}${TASKS_TOOL_RUN_PROMPT}`]: runPromptTool,
     [`${TASKS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}${TASKS_TOOL_SEARCH_TASK}`]: searchTaskTool
   };
   const filteredTools = {};
@@ -4542,7 +4989,7 @@ const createAiderToolset = (task, profile, promptContext) => {
       }
       task.addToolMessage(toolCallId, AIDER_TOOL_GROUP_NAME, AIDER_TOOL_RUN_PROMPT, { prompt }, void 0, void 0, aiderPromptContext);
       const responses = await task.sendPromptToAider(prompt, aiderPromptContext, "code", [], void 0, {
-        autoApprove: task.task.autoApprove,
+        autoApprove: task.task.autonomyMode !== AutonomyMode.Manual,
         denyCommands: true
       });
       task.addLogMessage("loading");
@@ -5748,7 +6195,8 @@ const addImportantReminders = async (task, profile, projectProfiles, userRequest
 ${subagents}`);
     }
   }
-  if (!task.task.autoApprove && !profile.isSubagent) {
+  const shouldPresentPlan = task.task.autonomyMode !== AutonomyMode.Autonomous;
+  if (shouldPresentPlan && !profile.isSubagent) {
     reminders.push("Before making any complex changes, present the plan and wait for my approval.");
   }
   if (task.getTaskDir() !== task.getProjectDir()) {
@@ -5774,6 +6222,7 @@ ${reminder}
       "onImportantReminders",
       {
         profile,
+        agentProfile: profile,
         remindersContent
       },
       task.project,
@@ -5791,9 +6240,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 +6689,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 +6702,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 +6719,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 +6875,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 +6884,33 @@ ${fileList}`
     const userRequestMessage = prompt ? {
       id: promptContext?.id || uuid.v4(),
       role: "user",
-      content: prompt,
-      promptContext
+      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,
+      timestamp: Date.now()
     } : 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 +7129,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:", {
@@ -6711,9 +7187,9 @@ ${fileList}`
       let iterationCount = 0;
       let retryCount = 0;
       while (true) {
-        logger.info(`Starting iteration ${iterationCount}`);
+        logger.info(`Starting iteration ${iterationCount}`, { task: task.taskId });
         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 +7202,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 +7214,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 +7223,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 +7307,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 +7355,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 +7427,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 +7489,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 +7788,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;
@@ -7384,32 +7884,80 @@ ${fileList}`
           ...message,
           id: currentResponseId,
           usageReport,
-          promptContext
+          promptContext,
+          timestamp: Date.now()
         });
       } else if (message.role === "tool") {
         messages.push({
           ...message,
           // @ts-expect-error the id is there
           id: message.id || uuid.v4(),
-          promptContext
+          promptContext,
+          timestamp: Date.now()
         });
       }
     });
     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 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) {
-      return true;
-    }
-    const totalTokens = usageReport.sentTokens + usageReport.receivedTokens + (usageReport.cacheReadTokens ?? 0);
-    if (maxTokens && totalTokens > maxTokens * contextCompactingThreshold / 100) {
+    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.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);
+    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 +7973,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",
@@ -7449,6 +8006,52 @@ ${userRequestMessage.content}`,
     return true;
   }
 }
+let isDockerCache;
+const isDocker = () => {
+  if (isDockerCache !== void 0) {
+    return isDockerCache;
+  }
+  try {
+    isDockerCache = fs__namespace.existsSync("/.dockerenv") || fs__namespace.existsSync("/run/.containerenv");
+  } catch {
+    isDockerCache = false;
+  }
+  return isDockerCache;
+};
+const isNetworkDrive = (drivePath) => {
+  try {
+    const driveLetter = drivePath.charAt(0).toUpperCase();
+    const output = child_process.execSync(`net use ${driveLetter}:`, {
+      encoding: "utf8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output.includes("\\\\") || output.includes("//");
+  } catch {
+    return false;
+  }
+};
+const shouldUsePolling = (watchPath, mode = FileWatchMode.Auto) => {
+  if (mode === FileWatchMode.Polling) {
+    return true;
+  }
+  if (mode === FileWatchMode.Native) {
+    return false;
+  }
+  if (isDocker()) {
+    logger.debug(`[FileWatch] Docker environment detected, using polling for ${watchPath}`);
+    return true;
+  }
+  if (process.platform === "win32") {
+    const isUncPath = watchPath.startsWith("\\\\") || watchPath.startsWith("//");
+    const isNetworkLetterDrive = /^[A-Za-z]:/.test(watchPath) && isNetworkDrive(watchPath);
+    if (isUncPath || isNetworkLetterDrive) {
+      logger.debug(`[FileWatch] Network path detected (${watchPath}), using polling`);
+      return true;
+    }
+  }
+  return false;
+};
 const getGlobalAgentsDir = () => path__namespace.join(os.homedir(), AIDER_DESK_AGENTS_DIR);
 const getProjectAgentsDir = (projectDir) => path__namespace.join(projectDir, AIDER_DESK_AGENTS_DIR);
 const getAgentsDirForProfile = (profile) => profile.projectDir ? getProjectAgentsDir(profile.projectDir) : getGlobalAgentsDir();
@@ -7481,9 +8084,10 @@ const getAllRuleFilesForProfile = async (profile, dirName) => {
   return ruleFiles;
 };
 class AgentProfileManager {
-  constructor(eventManager, extensionManager) {
+  constructor(eventManager, extensionManager, store) {
     this.eventManager = eventManager;
     this.extensionManager = extensionManager;
+    this.store = store;
     this.extensionsChangeListener = () => {
       this.sendAgentProfilesUpdated();
     };
@@ -7598,12 +8202,12 @@ class AgentProfileManager {
     }
     const watcher = chokidar.watch(agentsDir, {
       persistent: true,
-      usePolling: true,
+      usePolling: shouldUsePolling(agentsDir, this.store.getSettings().fileWatchMode),
       ignoreInitial: true
     });
     const rulesWatcher = chokidar.watch(path__namespace.join(agentsDir, "*", AIDER_DESK_RULES_DIR), {
       persistent: true,
-      usePolling: true,
+      usePolling: shouldUsePolling(agentsDir, this.store.getSettings().fileWatchMode),
       ignoreInitial: true
     });
     const reloadFunction = () => this.debounceReloadProfiles(agentsDir);
@@ -7874,6 +8478,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;
@@ -7970,6 +8605,22 @@ class AgentProfileManager {
     this.directoryWatchers.clear();
     this.profiles.clear();
   }
+  async settingsChanged(oldSettings, newSettings) {
+    if (oldSettings.fileWatchMode === newSettings.fileWatchMode) {
+      return;
+    }
+    const watchedDirs = Array.from(this.directoryWatchers.keys());
+    for (const watcher of this.directoryWatchers.values()) {
+      await watcher.close();
+    }
+    this.directoryWatchers.clear();
+    for (const dir of watchedDirs) {
+      if (dir.endsWith("-rules")) {
+        continue;
+      }
+      await this.setupWatcherForDirectory(dir);
+    }
+  }
   getDefaultAgentProfileId() {
     for (const defaultProfile of DEFAULT_AGENT_PROFILES) {
       if (this.profiles.has(defaultProfile.id)) {
@@ -8213,7 +8864,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 +8885,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 +9074,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 +9156,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"),
@@ -8546,7 +9203,8 @@ const InitProjectRulesFileSchema = zod.z.object({
 const CreateNewTaskSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
   parentId: zod.z.string().nullable().optional(),
-  name: zod.z.string().optional()
+  name: zod.z.string().optional(),
+  activate: zod.z.boolean().optional()
 });
 const UpdateTaskSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
@@ -8607,6 +9265,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 +9389,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" });
       })
     );
@@ -8840,8 +9502,8 @@ class ProjectApi extends BaseApi {
         if (!parsed) {
           return;
         }
-        const { projectDir, parentId, name } = parsed;
-        const params = { parentId, name };
+        const { projectDir, parentId, name, activate } = parsed;
+        const params = { parentId, name, activate };
         const task = await this.eventsHandler.createNewTask(projectDir, params);
         res.status(200).json(task);
       })
@@ -9013,6 +9675,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) => {
@@ -10883,10 +11569,11 @@ class ShellCommandError extends Error {
 }
 const execAsync$1 = util.promisify(child_process.exec);
 class CustomCommandManager {
-  constructor(project, eventManager, extensionManager) {
+  constructor(project, eventManager, extensionManager, store) {
     this.project = project;
     this.eventManager = eventManager;
     this.extensionManager = extensionManager;
+    this.store = store;
   }
   commands = /* @__PURE__ */ new Map();
   watchers = [];
@@ -10926,7 +11613,7 @@ class CustomCommandManager {
     }
     const watcher = chokidar.watch(commandsDir, {
       persistent: true,
-      usePolling: true,
+      usePolling: shouldUsePolling(commandsDir, this.store.getSettings().fileWatchMode),
       ignoreInitial: true
     });
     watcher.on("add", async () => {
@@ -10984,14 +11671,16 @@ class CustomCommandManager {
       const args = Array.isArray(parsed.arguments) ? parsed.arguments : [];
       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 autonomyMode = typeof parsed.autonomyMode === "string" && ["manual", "guided", "autonomous"].includes(parsed.autonomyMode) ? parsed.autonomyMode : 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
+        autonomyMode,
+        skills
       });
     } catch (err) {
       logger.error(`Failed to parse command file ${filePath}: ${err}`);
@@ -11123,6 +11812,14 @@ class CustomCommandManager {
     this.watchers.forEach((watcher) => watcher.close());
     this.watchers = [];
   }
+  async settingsChanged(oldSettings, newSettings) {
+    if (oldSettings.fileWatchMode === newSettings.fileWatchMode) {
+      return;
+    }
+    this.watchers.forEach((watcher) => watcher.close());
+    this.watchers = [];
+    await this.setupFileWatchers();
+  }
 }
 const migrateContextMessage = (message) => {
   if (Array.isArray(message.content)) {
@@ -11225,10 +11922,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;
@@ -11247,7 +11954,8 @@ class ContextManager {
         id: uuid.v4(),
         role: roleOrMessage,
         content: content || "",
-        usageReport
+        usageReport,
+        timestamp: Date.now()
       };
     } else {
       message = roleOrMessage;
@@ -11260,6 +11968,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 +11989,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 +12055,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 +12113,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 +12146,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 +12448,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 +12549,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) {
@@ -11866,7 +12621,8 @@ ${JSON.stringify(part.output.value)}`
                 commitMessage: response.commitMessage,
                 diff: response.diff,
                 usageReport: response.usageReport,
-                promptContext: message.promptContext
+                promptContext: message.promptContext,
+                timestamp: message.timestamp
               };
               messagesData.push(responseCompletedData);
             });
@@ -11905,7 +12661,8 @@ ${JSON.stringify(part.output.value)}`
                       baseDir: this.task.getProjectDir(),
                       taskId: this.taskId,
                       usageReport: subMessage.usageReport,
-                      promptContext: subMessage.promptContext
+                      promptContext: subMessage.promptContext,
+                      timestamp: subMessage.timestamp
                     };
                     messagesData.push(responseCompletedData);
                   }
@@ -11921,7 +12678,8 @@ ${JSON.stringify(part.output.value)}`
                         toolName: subToolName,
                         args: subPart.input,
                         usageReport: void 0,
-                        promptContext: subMessage.promptContext
+                        promptContext: subMessage.promptContext,
+                        timestamp: subMessage.timestamp
                       };
                       messagesData.push(toolData);
                     }
@@ -11935,7 +12693,8 @@ ${JSON.stringify(part.output.value)}`
                     baseDir: this.task.getProjectDir(),
                     taskId: this.taskId,
                     usageReport: subMessage.usageReport,
-                    promptContext: subMessage.promptContext
+                    promptContext: subMessage.promptContext,
+                    timestamp: subMessage.timestamp
                   };
                   messagesData.push(responseCompletedData);
                 }
@@ -11978,7 +12737,8 @@ ${JSON.stringify(part.output.value)}`
               commitMessage: message.commitMessage,
               diff: message.diff,
               usageReport: message.usageReport,
-              promptContext: message.promptContext
+              promptContext: message.promptContext,
+              timestamp: message.timestamp
             };
             messagesData.push(responseCompletedData);
             reasoning = "";
@@ -12007,7 +12767,8 @@ ${JSON.stringify(part.output.value)}`
                 toolName,
                 args: toolCall.input,
                 usageReport: message.usageReport,
-                promptContext: message.promptContext
+                promptContext: message.promptContext,
+                timestamp: message.timestamp
               };
               messagesData.push(toolData);
             } else if (part.type === "tool-result") {
@@ -12041,19 +12802,27 @@ ${JSON.stringify(part.output.value)}`
             taskId: this.taskId,
             reflectedMessage: message.reflectedMessage,
             usageReport: message.usageReport,
-            promptContext: message.promptContext
+            promptContext: message.promptContext,
+            timestamp: message.timestamp
           };
           messagesData.push(responseCompletedData);
         }
       } 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,
-          promptContext: message.promptContext
+          images: images && images.length > 0 ? images : void 0,
+          promptContext: message.promptContext,
+          timestamp: message.timestamp
         };
         messagesData.push(userMessageData);
       } else if (message.role === "tool" && Array.isArray(message.content)) {
@@ -12811,7 +13580,16 @@ class SkillManager {
       loadSkillsFromDir(projectSkillsDir, "project"),
       loadSkillsFromDir(AIDER_DESK_BUILTIN_SKILLS_DIR, "builtin")
     ]);
-    return [...projectSkills, ...globalSkills, ...builtinSkills, ...extensionSkills];
+    const allSkills = [...extensionSkills, ...projectSkills, ...globalSkills, ...builtinSkills];
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = [];
+    for (const skill of allSkills) {
+      if (!seen.has(skill.name)) {
+        seen.add(skill.name);
+        deduped.push(skill);
+      }
+    }
+    return deduped;
   }
   async getSkills(contextMessages) {
     const skills = await this.loadAllSkills();
@@ -12960,7 +13738,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 +14898,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 +15001,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
     });
@@ -14606,11 +15400,668 @@ Git output: ${err.stderr || err.stdout || err.message}`
       }
     }
   }
-  async close(projectDir) {
-    logger.info("Closing worktree manager");
-    await this.pruneDeleted(projectDir);
+  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) => {
+  for (let i = messages.length - 2; i >= 0; i--) {
+    const current = messages[i];
+    const next = messages[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 }] : [];
+    messages.splice(i + 1, 1);
+  }
+  return messages.filter((msg) => {
+    if (msg.role === "assistant" && Array.isArray(msg.content) && msg.content.length === 0) {
+      return false;
+    }
+    return true;
+  });
+};
+const truncateNonPowerToolResults = async (messages, protectedMessageCount = 10) => {
+  const protectedStart = getProtectedStartIndex(messages, protectedMessageCount);
+  for (let i = 0; i < protectedStart; i++) {
+    const msg = messages[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] = extractServerNameToolName(part.toolName);
+      if (isPowerTool(serverName)) {
+        continue;
+      }
+      if (part.output.type !== "text" && part.output.type !== "error-text") {
+        continue;
+      }
+      const outputText = part.output.value;
+      if (!outputText) {
+        continue;
+      }
+      const truncated = await truncateToolResult(
+        outputText,
+        20,
+        2,
+        2e3,
+        false,
+        "Output truncated due to compaction, re-execute the tool if full output is needed."
+      );
+      if (truncated !== outputText) {
+        part.output = {
+          type: part.output.type,
+          value: truncated
+        };
+      }
+    }
+  }
+  return messages;
+};
+const smartCompactMessages = async (messages, protectedMessageCount = 10) => {
+  let result = cloneMessages(messages);
+  result = removeErroredTools(result, protectedMessageCount);
+  result = collapseFileEdits(result, protectedMessageCount);
+  result = removeStaleFileReads(result, protectedMessageCount);
+  result = compactFileReads(result, protectedMessageCount);
+  result = removeObsoleteSearches(result, protectedMessageCount);
+  result = compactSemanticSearches(result, protectedMessageCount);
+  result = deduplicateBash(result, protectedMessageCount);
+  result = redactFetchOutputs(result, protectedMessageCount);
+  result = await truncateNonPowerToolResults(result, protectedMessageCount);
+  result = mergeConsecutiveAssistantMessages(result);
+  return result;
+};
+const removeErroredTools = (messages, protectedMessageCount = 10) => {
+  const protectedStart = getProtectedStartIndex(messages, protectedMessageCount);
+  for (let i = protectedStart - 1; i >= 0; i--) {
+    if (i >= messages.length) {
+      continue;
+    }
+    const msg = messages[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(messages, info.toolCallId);
+        removeToolResult(messages, info.toolCallId);
+      }
+    }
+  }
+  return messages;
+};
+const collapseFileEdits = (messages, protectedMessageCount = 10) => {
+  const protectedStart = getProtectedStartIndex(messages, protectedMessageCount);
+  const fileEditGroups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < protectedStart; i++) {
+    if (i >= messages.length) {
+      break;
+    }
+    const msg = messages[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(messages, 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 = messages.findIndex((m) => m.id === lastEdit.assistantMessageId);
+    const insertIndex = assistantIndex !== -1 ? assistantIndex + 1 : 0;
+    messages.splice(insertIndex, 0, syntheticMessage);
+    for (const edit of edits) {
+      removeToolCallFromAssistant(messages, edit.toolCallId);
+      removeToolResult(messages, edit.toolCallId);
+    }
+  }
+  return messages;
+};
+const removeStaleFileReads = (messages, protectedMessageCount = 10) => {
+  const protectedStart = getProtectedStartIndex(messages, protectedMessageCount);
+  const editedFilePaths = /* @__PURE__ */ new Set();
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[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(messages, part.toolCallId);
+      if (callInfo) {
+        const filePath = extractFilePath(callInfo.input);
+        if (filePath) {
+          editedFilePaths.add(filePath);
+        }
+      }
+    }
+  }
+  const protectedReadFilePaths = /* @__PURE__ */ new Set();
+  for (let i = protectedStart; i < messages.length; i++) {
+    const msg = messages[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(messages, 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 >= messages.length) {
+      continue;
+    }
+    const msg = messages[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(messages, part.toolCallId);
+      if (!callInfo) {
+        continue;
+      }
+      const filePath = extractFilePath(callInfo.input);
+      if (!filePath) {
+        continue;
+      }
+      if (editedFilePaths.has(filePath) || protectedReadFilePaths.has(filePath)) {
+        removeToolCallFromAssistant(messages, part.toolCallId);
+        removeToolResult(messages, 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(messages, read.toolCallId);
+      removeToolResult(messages, read.toolCallId);
+    }
+  }
+  return messages;
+};
+const compactFileReads = (messages, protectedMessageCount = 10) => {
+  const protectedStart = getProtectedStartIndex(messages, protectedMessageCount);
+  for (let i = 0; i < protectedStart; i++) {
+    if (i >= messages.length) {
+      break;
+    }
+    const msg = messages[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_FILE_READ) {
+        continue;
+      }
+      if (part.output.type !== "text") {
+        continue;
+      }
+      const lines = part.output.value.split("\n");
+      if (lines.length > 50) {
+        part.output = {
+          type: "text",
+          value: lines.slice(0, 50).join("\n") + "\n<truncated due to compaction, read the file again if full content is needed>"
+        };
+      }
+    }
+  }
+  return messages;
+};
+const removeObsoleteSearches = (messages, protectedMessageCount = 10) => {
+  const protectedStart = getProtectedStartIndex(messages, protectedMessageCount);
+  const fileModificationPositions = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[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 messages;
+  }
+  for (let i = protectedStart - 1; i >= 0; i--) {
+    if (i >= messages.length) {
+      continue;
+    }
+    const msg = messages[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(messages, part.toolCallId);
+        removeToolResult(messages, part.toolCallId);
+      }
+    }
+  }
+  return messages;
+};
+const compactSemanticSearches = (messages, protectedMessageCount = 10) => {
+  const protectedStart = getProtectedStartIndex(messages, protectedMessageCount);
+  const searchIndices = [];
+  for (let i = 0; i < protectedStart; i++) {
+    if (i >= messages.length) {
+      break;
+    }
+    const msg = messages[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 messages;
+  }
+  const toRemove = searchIndices.slice(0, -1);
+  const toKeep = searchIndices[searchIndices.length - 1];
+  for (const search2 of toRemove) {
+    removeToolCallFromAssistant(messages, search2.toolCallId);
+    removeToolResult(messages, search2.toolCallId);
+  }
+  const keptToolIdx = messages.findIndex((m) => m.role === "tool" && m.content.some((p) => p.type === "tool-result" && p.toolCallId === toKeep.toolCallId));
+  if (keptToolIdx !== -1) {
+    const keptMsg = messages[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 messages;
+};
+const deduplicateBash = (messages, protectedMessageCount = 10) => {
+  const protectedStart = getProtectedStartIndex(messages, protectedMessageCount);
+  const bashCommands = /* @__PURE__ */ new Map();
+  for (let i = 0; i < protectedStart; i++) {
+    const msg = messages[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(messages, 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(messages, occ.toolCallId);
+      removeToolResult(messages, occ.toolCallId);
+    }
+  }
+  for (let i = 0; i < protectedStart; i++) {
+    if (i >= messages.length) {
+      break;
+    }
+    const msg = messages[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 {
+        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 (stderr.length > 30) {
+            parsed.stderr = redactionMessage;
+            modified = true;
+          }
+          if (modified) {
+            part.output = {
+              type: "text",
+              value: JSON.stringify(parsed)
+            };
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return messages;
+};
+const redactFetchOutputs = (messages, protectedMessageCount = 10) => {
+  const protectedStart = getProtectedStartIndex(messages, protectedMessageCount);
+  for (let i = 0; i < protectedStart; i++) {
+    const msg = messages[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>"
+        };
+      }
+    }
   }
-}
+  return messages;
+};
 const INTERNAL_TASK_ID = "internal";
 const RESPONSE_CHUNK_FLUSH_INTERVAL_MS = 10;
 const EMPTY_TASK_DATA = {
@@ -14622,7 +16073,6 @@ const EMPTY_TASK_DATA = {
   agentTotalCost: 0,
   mainModel: "",
   currentMode: "agent",
-  contextCompactingThreshold: 0,
   weakModelLocked: false,
   parentId: null,
   lastAgentProviderMetadata: void 0
@@ -15117,7 +16567,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 +16605,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 +16615,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);
     }
@@ -15187,7 +16637,8 @@ class Task {
       id: promptContext.id,
       role: MessageRole.User,
       content: prompt,
-      promptContext
+      promptContext,
+      timestamp: Date.now()
     });
     this.addUserMessage(promptContext.id, prompt);
     await this.saveTask({
@@ -15220,7 +16671,8 @@ class Task {
       id: promptContext.id,
       role: MessageRole.User,
       content: prompt,
-      promptContext
+      promptContext,
+      timestamp: Date.now()
     });
     let messages = this.contextManager.toConnectorMessages();
     let files = this.contextManager.getContextFiles();
@@ -15239,8 +16691,9 @@ class Task {
     promptContext = extensionResult.promptContext;
     messages = extensionResult.messages;
     files = extensionResult.files;
+    const effectiveAutonomyMode = extensionResult.autonomyMode ?? this.task.autonomyMode ?? DEFAULT_AUTONOMY_MODE;
     let responses = await this.sendPromptToAider(prompt, promptContext, mode, messages, files, {
-      autoApprove: extensionResult.autoApprove ?? this.task.autoApprove,
+      autoApprove: effectiveAutonomyMode === AutonomyMode.Autonomous,
       denyCommands: extensionResult.denyCommands
     });
     logger.debug("Responses:", { responses });
@@ -15277,7 +16730,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 +16741,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);
@@ -15613,7 +17078,8 @@ ${contentText}</agent-response>`;
         diff: message.diff,
         usageReport,
         sequenceNumber: message.sequenceNumber,
-        promptContext: message.promptContext
+        promptContext: message.promptContext,
+        timestamp: Date.now()
       };
       const extensionResult = await this.extensionManager.dispatchEvent("onResponseCompleted", { response: data }, this.project, this);
       data = extensionResult.response;
@@ -15680,14 +17146,20 @@ ${contentText}</agent-response>`;
     if (!determinedAnswer) {
       determinedAnswer = normalizedAnswer === "a" || normalizedAnswer === "y" ? "y" : "n";
     }
-    if ((normalizedAnswer === "d" || normalizedAnswer === "a") && (determinedAnswer == "y" || determinedAnswer == "n")) {
-      logger.debug('Storing answer for question due to "d" or "a" input:', {
+    if (normalizedAnswer === "a") {
+      logger.debug('Storing answer for question due to "a" (Always) input:', {
+        baseDir: this.project.baseDir,
+        questionKey: this.getQuestionKey(this.currentQuestion),
+        rawInput: answer
+      });
+      this.storedQuestionAnswers.set(this.getQuestionKey(this.currentQuestion), "y");
+    } else if (normalizedAnswer === "d") {
+      logger.debug(`Storing answer for question due to "d" (Don't ask again) input:`, {
         baseDir: this.project.baseDir,
         questionKey: this.getQuestionKey(this.currentQuestion),
-        rawInput: answer,
-        determinedAndStoredAnswer: determinedAnswer
+        rawInput: answer
       });
-      this.storedQuestionAnswers.set(this.getQuestionKey(this.currentQuestion), determinedAnswer);
+      this.storedQuestionAnswers.set(this.getQuestionKey(this.currentQuestion), "n");
     }
     const questionToAnswer = this.currentQuestion;
     if (!this.currentQuestion.internal) {
@@ -15850,11 +17322,21 @@ ${contentText}</agent-response>`;
     void this.updateContextInfo(true, true);
   }
   async askQuestion(questionData, awaitAnswer = true) {
-    const extensionResult = await this.extensionManager.dispatchEvent("onQuestionAsked", { question: questionData }, this.project, this);
+    let storedAnswer = this.storedQuestionAnswers.get(this.getQuestionKey(questionData));
+    const extensionResult = await this.extensionManager.dispatchEvent(
+      "onQuestionAsked",
+      {
+        question: questionData,
+        storedAnswer
+      },
+      this.project,
+      this
+    );
     if (extensionResult.answer) {
       logger.info("Question answered by extension", {
         question: questionData.text,
-        answer: extensionResult.answer
+        answer: extensionResult.answer,
+        storedAnswer
       });
       return [extensionResult.answer, void 0];
     }
@@ -15864,7 +17346,7 @@ ${contentText}</agent-response>`;
         this.currentQuestionResolves.push(resolve);
       });
     }
-    const storedAnswer = this.storedQuestionAnswers.get(this.getQuestionKey(questionData));
+    storedAnswer = this.storedQuestionAnswers.get(this.getQuestionKey(questionData));
     if (questionData.isGroupQuestion && !questionData.answers) {
       questionData.answers = [
         { text: "(Y)es", shortkey: "y" },
@@ -16205,7 +17687,8 @@ ${contentText}</agent-response>`;
       message,
       finished,
       promptContext,
-      actionIds
+      actionIds,
+      timestamp: Date.now()
     };
     this.eventManager.sendLog(data);
   }
@@ -16325,7 +17808,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 +17826,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 +17855,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 +17891,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) {
@@ -16525,7 +18040,8 @@ ${contentText}</agent-response>`;
       response,
       usageReport,
       promptContext,
-      finished
+      finished,
+      timestamp: Date.now()
     };
     if (response && usageReport && saveToDb) {
       this.dataManager.saveMessage(id, "tool", this.project.baseDir, usageReport.model, usageReport, {
@@ -16554,7 +18070,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,7 +18081,9 @@ ${contentText}</agent-response>`;
       baseDir: this.project.baseDir,
       taskId: this.taskId,
       content,
-      promptContext
+      images,
+      promptContext,
+      timestamp: Date.now()
     };
     this.eventManager.sendUserMessage(data);
   }
@@ -16597,12 +18115,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 +18129,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 +18234,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 = await 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 +18338,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,
@@ -16869,7 +18406,7 @@ ${contentText}</agent-response>`;
     const newTaskData = await this.project.createNewTask({
       parentId: this.task.parentId || this.taskId,
       sendEvent: false,
-      autoApprove: execute ? this.task.autoApprove : void 0,
+      autonomyMode: execute ? this.task.autonomyMode : void 0,
       activate: true
     });
     const newTask = this.project.getTask(newTaskData.id);
@@ -16899,6 +18436,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 +18710,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 +18717,27 @@ ${error.stderr}`,
           this.addLogMessage("error", "No active Agent profile found");
           return;
         }
-        const systemPrompt = await this.promptsManager.getSystemPrompt(this.store.getSettings(), this, profile, command.autoApprove ?? this.task.autoApprove);
+        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.autonomyMode ?? this.task.autonomyMode ?? DEFAULT_AUTONOMY_MODE
+        );
         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 {
@@ -17929,7 +19482,7 @@ ${diff}
     const newTaskData = await this.project.createNewTask({
       name: taskName,
       sendEvent: false,
-      autoApprove: true,
+      autonomyMode: AutonomyMode.Autonomous,
       activate: true,
       mode,
       parentId: this.task.parentId || this.taskId,
@@ -18069,7 +19622,7 @@ class Project {
     this.promptsManager = promptsManager;
     this.extensionManager = extensionManager;
     this.pythonInstaller = pythonInstaller;
-    this.customCommandManager = new CustomCommandManager(this, this.eventManager, this.extensionManager);
+    this.customCommandManager = new CustomCommandManager(this, this.eventManager, this.extensionManager, this.store);
     this.tasksLoadingPromise = this.loadTasks();
   }
   customCommandManager;
@@ -18106,6 +19659,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();
       }
@@ -18142,11 +19698,7 @@ class Project {
         ...normalizedParams
       };
     }
-    const projectSettings = this.getProjectSettings();
-    const taskSettings = this.store.getSettings().taskSettings;
     const taskData = {
-      contextCompactingThreshold: taskSettings.contextCompactingThreshold,
-      autoApprove: projectSettings.autoApproveLocked ? true : initialTaskData.autoApprove,
       ...initialTaskData
     };
     const extResult = await this.extensionManager.dispatchEvent("onTaskCreated", { task: taskData }, this);
@@ -18164,7 +19716,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 +19892,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.
    */
@@ -18438,6 +20000,7 @@ class Project {
     this.forEachTask((task) => {
       void task.settingsChanged(oldSettings, newSettings);
     });
+    void this.customCommandManager.settingsChanged(oldSettings, newSettings);
   }
   async projectSettingsChanged(oldSettings, newSettings) {
     this.forEachTask((task) => {
@@ -18588,6 +20151,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 = {
@@ -18683,7 +20250,8 @@ class EventManager {
       baseDir,
       taskId,
       command,
-      output
+      output,
+      timestamp: Date.now()
     };
     this.sendToWindows("command-output", data);
     this.broadcastToEventConnectors("command-output", data);
@@ -20979,7 +22547,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);
 };
@@ -21291,6 +22860,117 @@ const mistralProviderStrategy = {
   getAiderMapping: getMistralAiderMapping,
   getModelInfo: getDefaultModelInfo
 };
+const NEURALWATT_BASE_URL = "https://api.neuralwatt.com/v1";
+const loadNeuralwattModels = async (profile, settings) => {
+  if (!isNeuralwattProvider(profile.provider)) {
+    return { models: [], success: false };
+  }
+  const provider = profile.provider;
+  const apiKey = provider.apiKey || "";
+  const apiKeyEnv = getEffectiveEnvironmentVariable("NEURALWATT_API_KEY", settings);
+  const effectiveApiKey = apiKey || apiKeyEnv?.value || "";
+  if (!effectiveApiKey) {
+    logger.debug("Neuralwatt API key is required. Please set it in Providers settings or via NEURALWATT_API_KEY environment variable.");
+    return { models: [], success: false };
+  }
+  try {
+    const response = await fetch(`${NEURALWATT_BASE_URL}/models`, {
+      headers: { Authorization: `Bearer ${effectiveApiKey}` }
+    });
+    if (!response.ok) {
+      const errorMsg = `Neuralwatt models API response failed: ${response.status} ${response.statusText} ${await response.text()}`;
+      logger.error(errorMsg, { status: response.status, statusText: response.statusText });
+      return { models: [], success: false, error: errorMsg };
+    }
+    const data = await response.json();
+    logger.info(`Received response from Neuralwatt models API for profile ${profile.id}`, { data });
+    const models = data.data?.map((model) => {
+      const metadata = model.metadata;
+      const pricing = metadata?.pricing;
+      const limits = metadata?.limits;
+      const capabilities = metadata?.capabilities;
+      return {
+        id: model.id,
+        providerId: profile.id,
+        maxInputTokens: limits?.max_context_length ?? model.max_model_len,
+        maxOutputTokensLimit: limits?.max_output_tokens ?? void 0,
+        inputCostPerToken: pricing ? pricing.input_per_million / 1e6 : void 0,
+        outputCostPerToken: pricing ? pricing.output_per_million / 1e6 : void 0,
+        cacheReadInputTokenCost: pricing?.cached_input_per_million != null ? pricing.cached_input_per_million / 1e6 : void 0,
+        supportsTools: capabilities?.tools
+      };
+    }) || [];
+    logger.info(`Loaded ${models.length} Neuralwatt models for profile ${profile.id}`);
+    return { models, success: true };
+  } catch (error) {
+    const errorMsg = typeof error === "string" ? error : error instanceof Error ? error.message : "Unknown error loading Neuralwatt models";
+    logger.error("Error loading Neuralwatt models:", error);
+    return { models: [], success: false, error: errorMsg };
+  }
+};
+const hasNeuralwattEnvVars = (settings) => {
+  return !!getEffectiveEnvironmentVariable("NEURALWATT_API_KEY", settings, void 0)?.value;
+};
+const getNeuralwattAiderMapping = (provider, modelId) => {
+  const neuralwattProvider = provider.provider;
+  const envVars = {};
+  if (neuralwattProvider.apiKey) {
+    envVars.OPENAI_API_KEY = neuralwattProvider.apiKey;
+  }
+  envVars.OPENAI_API_BASE = NEURALWATT_BASE_URL;
+  return {
+    modelName: `openai/${modelId}`,
+    environmentVariables: envVars
+  };
+};
+const createNeuralwattLlm = (profile, model, settings, projectDir) => {
+  const provider = profile.provider;
+  let apiKey = provider.apiKey;
+  if (!apiKey) {
+    const effectiveVar = getEffectiveEnvironmentVariable("NEURALWATT_API_KEY", settings, projectDir);
+    if (effectiveVar) {
+      apiKey = effectiveVar.value;
+      logger.debug(`Loaded NEURALWATT_API_KEY from ${effectiveVar.source}`);
+    }
+  }
+  if (!apiKey) {
+    throw new Error("Neuralwatt API key is required in Providers settings or Aider environment variables (NEURALWATT_API_KEY)");
+  }
+  const compatibleProvider = openaiCompatible.createOpenAICompatible({
+    name: "neuralwatt",
+    apiKey,
+    baseURL: NEURALWATT_BASE_URL,
+    headers: profile.headers
+  });
+  return compatibleProvider(model.id);
+};
+const getNeuralwattUsageReport = (task, provider, model, usage, providerMetadata) => {
+  const totalSentTokens = usage.inputTokens || 0;
+  const receivedTokens = usage.outputTokens || 0;
+  const cacheReadTokens = usage.cachedInputTokens || 0;
+  const sentTokens = totalSentTokens - cacheReadTokens;
+  logger.info("Neuralwatt usage report", {
+    providerMetadata,
+    usage
+  });
+  const messageCost = calculateCost(model, sentTokens, receivedTokens, cacheReadTokens);
+  return {
+    model: `${provider.id}/${model.id}`,
+    sentTokens,
+    receivedTokens,
+    cacheReadTokens,
+    messageCost,
+    agentTotalCost: task.task.agentTotalCost + messageCost
+  };
+};
+const neuralwattProviderStrategy = {
+  createLlm: createNeuralwattLlm,
+  getUsageReport: getNeuralwattUsageReport,
+  loadModels: loadNeuralwattModels,
+  hasEnvVars: hasNeuralwattEnvVars,
+  getAiderMapping: getNeuralwattAiderMapping,
+  getModelInfo: getDefaultModelInfo
+};
 const loadOllamaModels = async (profile, settings) => {
   if (!isOllamaProvider(profile.provider)) {
     return { models: [], success: false };
@@ -21652,12 +23332,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 +23392,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 +23881,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,
@@ -22645,6 +24334,7 @@ class ModelManager {
     lmstudio: lmStudioProviderStrategy,
     minimax: minimaxProviderStrategy,
     mistral: mistralProviderStrategy,
+    neuralwatt: neuralwattProviderStrategy,
     ollama: ollamaProviderStrategy,
     openai: openaiProviderStrategy,
     "openai-compatible": openaiCompatibleProviderStrategy,
@@ -23102,6 +24792,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 +24806,11 @@ class ModelManager {
         };
       }
     }
+    logger.debug("getModelSettings model", {
+      providerId,
+      modelId,
+      model
+    });
     return model;
   }
   createLlm(provider, model, settings, projectDir, toolSet, systemPrompt, providerMetadata) {
@@ -23680,7 +25376,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) {
@@ -23990,7 +25686,7 @@ class MemoryManager {
               done: this.embeddingProgress.done,
               total: this.embeddingProgress.total,
               finished: true,
-              error: "Failed to load @huggingface/transformers. This is usually a packaging issue with native dependencies (e.g. sharp/libvips)."
+              error: "Failed to load @huggingface/transformers. This is usually a packaging issue with native dependencies."
             };
             logger.error("Failed to load transformers module. Memory embedding will be unavailable.", error);
             return;
@@ -24162,7 +25858,7 @@ class MemoryManager {
           done: this.embeddingProgress.done,
           total: this.embeddingProgress.total,
           finished: true,
-          error: "Failed to load @huggingface/transformers. This is usually a packaging issue with native dependencies (e.g. sharp/libvips)."
+          error: "Failed to load @huggingface/transformers. This is usually a packaging issue with native dependencies."
         };
         logger.error("Failed to load transformers module. Memory embedding will be unavailable.", error);
         return;
@@ -24818,6 +26514,18 @@ class ExtensionContextImpl {
       return [];
     }
   }
+  getProviders() {
+    if (!this.modelManager) {
+      this.log("ModelManager not available, returning empty providers", "warn");
+      return [];
+    }
+    try {
+      return this.modelManager.getProviders();
+    } catch (error) {
+      this.log(`Failed to get providers: ${error}`, "error");
+      return [];
+    }
+  }
   async getSetting(key) {
     if (!this.store) {
       throw new Error("Store not available");
@@ -24908,6 +26616,9 @@ class ExtensionContextImpl {
     }
     return this.memoryManager;
   }
+  async truncateToolResult(content, maxLines, maxSizeKB, maxTokens, saveToFile, truncationSuffix) {
+    return truncateToolResult(content, maxLines, maxSizeKB, maxTokens, saveToFile, truncationSuffix);
+  }
 }
 const CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 class ExtensionFetcher {
@@ -25036,6 +26747,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 +26835,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);
@@ -25267,6 +27024,9 @@ class ExtensionManager {
       logger.debug("[Extensions] Repository list changed, refreshing extension cache");
       void this.fetcher.getAvailableExtensions(newRepositories, true);
     }
+    if (oldSettings.fileWatchMode !== newSettings.fileWatchMode) {
+      void this.restartWatchers();
+    }
   }
   addListener(listener) {
     this.listeners.push(listener);
@@ -25571,7 +27331,7 @@ class ExtensionManager {
       };
       const watcher = chokidar.watch(dir, {
         persistent: true,
-        usePolling: true,
+        usePolling: shouldUsePolling(dir, this.store.getSettings().fileWatchMode),
         ignoreInitial: true,
         ignored: (filePath) => {
           const basename = path.basename(filePath);
@@ -25655,6 +27415,25 @@ class ExtensionManager {
       logger.debug(`[Extensions] Stopped watching project extensions: ${projectDir}`);
     }
   }
+  async restartWatchers() {
+    const projectDirs = Array.from(this.projectWatchers.keys());
+    await this.stopGlobalWatcher();
+    for (const dir of projectDirs) {
+      await this.stopProjectWatcher(dir);
+    }
+    await this.startHotReloadWatcher();
+    for (const dir of projectDirs) {
+      const projectExtensionsDir = path.join(dir, AIDER_DESK_EXTENSIONS_DIR);
+      const watcher = await this.setupWatcherForDir(projectExtensionsDir, async () => {
+        logger.debug(`[Extensions] Project extensions changed for ${dir}, reloading...`);
+        await this.unloadExtensionsForDir(projectExtensionsDir);
+        await this.loadExtensionsForDir(projectExtensionsDir);
+      });
+      if (watcher) {
+        this.projectWatchers.set(dir, watcher);
+      }
+    }
+  }
   static TOOL_NAME_REGEX = /^[a-z][a-z0-9_-]*$/;
   validateToolDefinition(tool) {
     const errors = [];
@@ -26009,7 +27788,7 @@ class ExtensionManager {
           }
           collectedSkills.push({
             ...skill,
-            location: "extension"
+            location: skill.location || "extension"
           });
         }
       } catch (error) {
@@ -26350,12 +28129,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 +28266,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 +28328,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;
           }
@@ -26559,7 +28352,7 @@ class ExtensionManager {
   }
 }
 class EventsHandler {
-  constructor(projectManager, store, mcpManager, versionsManager, modelManager, telemetryManager, dataManager, terminalManager, cloudflareTunnelManager, eventManager, agentProfileManager, memoryManager, extensionManager, proxyManager, windowManager) {
+  constructor(projectManager, store, mcpManager, versionsManager, modelManager, telemetryManager, dataManager, terminalManager, cloudflareTunnelManager, eventManager, agentProfileManager, memoryManager, extensionManager, proxyManager, promptsManager, windowManager) {
     this.projectManager = projectManager;
     this.store = store;
     this.mcpManager = mcpManager;
@@ -26574,6 +28367,7 @@ class EventsHandler {
     this.memoryManager = memoryManager;
     this.extensionManager = extensionManager;
     this.proxyManager = proxyManager;
+    this.promptsManager = promptsManager;
     this.windowManager = windowManager;
   }
   loadSettings() {
@@ -26587,6 +28381,8 @@ class EventsHandler {
     this.telemetryManager.settingsChanged(oldSettings, newSettings);
     void this.memoryManager.settingsChanged(oldSettings, newSettings);
     this.extensionManager.settingsChanged(oldSettings, newSettings);
+    void this.agentProfileManager.settingsChanged(oldSettings, newSettings);
+    void this.promptsManager.settingsChanged(oldSettings, newSettings);
     this.eventManager.sendSettingsUpdated(newSettings);
     return this.store.getSettings();
   }
@@ -26704,8 +28500,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 +28512,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 +28609,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);
@@ -27554,8 +29363,9 @@ const registerAllHelpers = () => {
   registerFormattingHelpers();
 };
 class PromptsManager {
-  constructor(extensionManager, defaultTemplatesDir = AIDER_DESK_DEFAULT_PROMPTS_DIR, globalPromptsDir = AIDER_DESK_GLOBAL_PROMPTS_DIR) {
+  constructor(extensionManager, store, defaultTemplatesDir = AIDER_DESK_DEFAULT_PROMPTS_DIR, globalPromptsDir = AIDER_DESK_GLOBAL_PROMPTS_DIR) {
     this.extensionManager = extensionManager;
+    this.store = store;
     this.defaultTemplatesDir = defaultTemplatesDir;
     this.globalPromptsDir = globalPromptsDir;
     registerAllHelpers();
@@ -27649,7 +29459,7 @@ class PromptsManager {
     }
     const watcher = chokidar.watch(this.globalPromptsDir, {
       persistent: true,
-      usePolling: true,
+      usePolling: shouldUsePolling(this.globalPromptsDir, this.store.getSettings().fileWatchMode),
       ignoreInitial: true
     });
     const debouncedReload = debounce(async () => {
@@ -27674,7 +29484,7 @@ class PromptsManager {
     await this.compileProjectTemplates(projectDir);
     const watcher = chokidar.watch(projectPromptsDir, {
       persistent: true,
-      usePolling: true,
+      usePolling: shouldUsePolling(projectPromptsDir, this.store.getSettings().fileWatchMode),
       ignoreInitial: true
     });
     const debouncedReload = debounce(async () => {
@@ -27703,6 +29513,20 @@ class PromptsManager {
     this.projectTemplatesCache.clear();
     logger.info("PromptsManager disposed");
   }
+  async settingsChanged(oldSettings, newSettings) {
+    if (oldSettings.fileWatchMode === newSettings.fileWatchMode) {
+      return;
+    }
+    const watchedProjects = Array.from(this.watchers.keys()).filter((k) => k !== "global");
+    for (const watcher of this.watchers.values()) {
+      await watcher.close();
+    }
+    this.watchers.clear();
+    await this.setupGlobalWatcher();
+    for (const projectDir of watchedProjects) {
+      await this.watchProject(projectDir);
+    }
+  }
   async render(name, data, projectDir, task) {
     const projectTemplates = this.projectTemplatesCache.get(projectDir);
     const projectTemplate = projectTemplates?.get(name);
@@ -27728,7 +29552,7 @@ class PromptsManager {
     }
     return prompt;
   }
-  calculateToolPermissions = (settings, agentProfile, autoApprove) => {
+  calculateToolPermissions = (settings, agentProfile, autonomyMode) => {
     const { usePowerTools = false, useMemoryTools = false, useSkillsTools = false } = agentProfile;
     const memoryEnabled = settings.memory.enabled && useMemoryTools;
     const isAllowed = (tool) => agentProfile.toolApprovals[tool] !== ToolApprovalState.Never;
@@ -27757,11 +29581,12 @@ class PromptsManager {
       skills: {
         allowed: useSkillsTools && isAllowed(`${SKILLS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}${SKILLS_TOOL_ACTIVATE_SKILL}`)
       },
-      autoApprove
+      autonomyMode
     };
   };
-  getSystemPrompt = async (settings, task, agentProfile, autoApprove = task.task.autoApprove ?? false, additionalInstructions) => {
-    const toolPermissions = this.calculateToolPermissions(settings, agentProfile, autoApprove);
+  getSystemPrompt = async (settings, task, agentProfile, autonomyMode, additionalInstructions) => {
+    const effectiveAutonomyMode = autonomyMode ?? task.task.autonomyMode ?? DEFAULT_AUTONOMY_MODE;
+    const toolPermissions = this.calculateToolPermissions(settings, agentProfile, effectiveAutonomyMode);
     toolPermissions.powerTools.anyEnabled = Object.values(toolPermissions.powerTools).some((v) => v);
     const rulesFiles = await this.getRulesContent(task, agentProfile);
     const customInstructions = [agentProfile.customInstructions, additionalInstructions].filter(Boolean).join("\n\n").trim();
@@ -28170,12 +29995,12 @@ const initManagers = async (store, windowManager) => {
   extensionManager.init().catch((error) => {
     logger.error("[Extensions] Extension system initialization failed, continuing without extensions:", error);
   });
-  const promptsManager = new PromptsManager(extensionManager);
+  const promptsManager = new PromptsManager(extensionManager, store);
   promptsManager.init().catch((error) => {
     logger.error("[Prompts] Prompts system initialization failed:", error);
   });
   const worktreeManager = new WorktreeManager();
-  const agentProfileManager = new AgentProfileManager(eventManager, extensionManager);
+  const agentProfileManager = new AgentProfileManager(eventManager, extensionManager, store);
   agentProfileManager.init().catch((error) => {
     logger.error("[AgentProfile] Agent profile system initialization failed:", error);
   });
@@ -28212,6 +30037,7 @@ const initManagers = async (store, windowManager) => {
     memoryManager,
     extensionManager,
     proxyManager,
+    promptsManager,
     windowManager
   );
   const serverController = new ServerController(httpServer, projectManager, eventsHandler, store, pythonInstaller);
@@ -28760,6 +30586,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 +30656,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/",
@@ -28833,12 +30669,13 @@ const DEFAULT_SETTINGS = {
   proxy: {
     enabled: false,
     url: ""
-  }
+  },
+  fileWatchMode: FileWatchMode.Auto
 };
 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 +30826,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 +31023,5 @@ if (!process.env.VITEST) {
 }
 exports.addProjectsFromEnv = addProjectsFromEnv;
 exports.initializeLangfuseExporter = initializeLangfuseExporter;
+exports.initializePostHogExporter = initializePostHogExporter;
 exports.logger = logger;