@aiderdesk/aiderdesk 0.61.1 → 0.64.0

package/out/runner.js

@@ -31,12 +31,8 @@ const node_sqlite = require("node:sqlite");
 const path = require("path");
 const os = require("os");
 const http = require("http");
-const undici = require("undici");
-const uuid = require("uuid");
-const ai = require("ai");
 const gpt4o = require("gpt-tokenizer/model/gpt-4o");
 const istextorbinary = require("istextorbinary");
-const fileType = require("file-type");
 const child_process = require("child_process");
 const treeKill = require("tree-kill");
 const glob = require("glob");
@@ -51,7 +47,7 @@ const filenamifyImport = require("filenamify");
 const slugify = require("slugify");
 const Turndown = require("turndown");
 const cheerio = require("cheerio");
-const yamlFrontMatter = require("yaml-front-matter");
+const uuid = require("uuid");
 const index_js = require("@modelcontextprotocol/sdk/client/index.js");
 const stdio_js = require("@modelcontextprotocol/sdk/client/stdio.js");
 const streamableHttp_js = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
@@ -62,8 +58,13 @@ const express = require("express");
 const cors = require("cors");
 const cloudflared = require("cloudflared");
 const socket_io = require("socket.io");
+const yamlFrontMatter = require("yaml-front-matter");
 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");
 const clientBedrock = require("@aws-sdk/client-bedrock");
@@ -78,6 +79,7 @@ const genai = require("@google/genai");
 const openaiCompatible = require("@ai-sdk/openai-compatible");
 const groq = require("@ai-sdk/groq");
 const alibaba = require("@ai-sdk/alibaba");
+const mistral = require("@ai-sdk/mistral");
 const ollamaAiProviderV2 = require("ollama-ai-provider-v2");
 const openai = require("@ai-sdk/openai");
 const aiSdkProvider = require("@openrouter/ai-sdk-provider");
@@ -241,6 +243,7 @@ const WorktreeSchema = zod.z.object({
   path: zod.z.string(),
   baseBranch: zod.z.string().optional(),
   baseCommit: zod.z.string().optional(),
+  branch: zod.z.string().optional(),
   prunable: zod.z.boolean().optional()
 });
 const MergeStateSchema = zod.z.object({
@@ -297,7 +300,10 @@ const ProjectSettingsSchema = zod.z.object({
   contextCompactingThreshold: zod.z.number().optional(),
   weakModelLocked: zod.z.boolean().optional(),
   autoApproveLocked: zod.z.boolean().optional(),
-  updatedFilesGroupMode: zod.z.enum(["grouped", "flat"]).default("flat")
+  updatedFilesGroupMode: zod.z.enum(["grouped", "flat"]).default("flat"),
+  disabledRuleFiles: zod.z.array(zod.z.string()).default([]),
+  contextSidebarSectionsOrder: zod.z.array(zod.z.string()).default([]),
+  contextSidebarSectionsHidden: zod.z.array(zod.z.string()).default([])
 });
 var ToolApprovalState = /* @__PURE__ */ ((ToolApprovalState2) => {
   ToolApprovalState2["Always"] = "always";
@@ -481,19 +487,22 @@ const parseUsageReport = (model, report) => {
 };
 const normalizeBaseDir = (baseDir, os2 = process.platform === "win32" ? OS.Windows : process.platform === "darwin" ? OS.MacOS : OS.Linux) => {
   if (os2 === OS.Windows) {
-    return baseDir.toLowerCase();
+    return baseDir.toLowerCase().replace(/\\+$/, "");
   } else {
     const wslPrefix = "\\\\wsl.localhost\\";
     if (baseDir.startsWith(wslPrefix)) {
       const thirdBackslashIndex = baseDir.indexOf("\\", wslPrefix.length);
       if (thirdBackslashIndex !== -1) {
         const actualPath = baseDir.substring(thirdBackslashIndex + 1);
-        return "/" + actualPath.replace(/\\/g, "/");
+        return ("/" + actualPath.replace(/\\/g, "/")).replace(/\/+$/, "");
       }
     }
-    return baseDir;
+    return baseDir.replace(/\/+$/, "");
   }
 };
+const compareBaseDirs$1 = (baseDir1, baseDir2, os2) => {
+  return normalizeBaseDir(baseDir1, os2) === normalizeBaseDir(baseDir2, os2);
+};
 const fileExists = async (fileName) => {
   return await fs.stat(fileName).catch(() => null) !== null;
 };
@@ -810,6 +819,7 @@ const POSTHOG_HOST = "https://eu.i.posthog.com";
 process.env.AIDER_DESK_HEADLESS === "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;
 const PROBE_BINARY_PATH = path.join(
   RESOURCES_DIR,
   process.platform === "win32" ? "win" : process.platform === "darwin" ? "macos" : "linux",
@@ -1432,6 +1442,7 @@ const search = async (options) => {
       args.push(`${flag} ${String(value)}`);
     }
   }
+  args.push("--");
   args.push(`"${options.query}"`);
   if (options.path) {
     args.push(`"${options.path}"`);
@@ -1462,6 +1473,7 @@ const AVAILABLE_PROVIDERS = [
   "litellm",
   "lmstudio",
   "minimax",
+  "mistral",
   "ollama",
   "openai",
   "openai-compatible",
@@ -1506,24 +1518,28 @@ const isRequestyProvider = (provider) => provider.name === "requesty";
 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 isSyntheticProvider = (provider) => provider.name === "synthetic";
-const DEFAULT_MODEL_TEMPERATURE = 0;
 const DEFAULT_PROVIDER_MODELS = {
   "alibaba-plan": "qwen3-coder-plus",
   anthropic: "claude-sonnet-4-6",
+  auggie: "gpt-5-4",
+  bedrock: "global.anthropic.claude-sonnet-4-6",
   cerebras: "qwen-3-235b-a22b-instruct-2507",
   "claude-agent-sdk": "sonnet",
-  deepseek: "deepseek-chat",
+  deepseek: "deepseek-v4-pro",
   gemini: "gemini-pro-latest",
-  "gemini-cli": "gemini-2.5-flash",
+  "gemini-cli": "gemini-2.5-pro",
   groq: "moonshotai/kimi-k2-instruct-0905",
+  "kimi-plan": "k2p6",
   openai: "gpt-5.4",
   openrouter: "anthropic/claude-sonnet-4.6",
   opencode: "claude-sonnet-4-6",
   requesty: "anthropic/claude-sonnet-4-6",
   synthetic: "hf:zai-org/GLM-4.7",
-  "zai-plan": "glm-5",
-  minimax: "MiniMax-M2"
+  "zai-plan": "glm-5.1",
+  minimax: "MiniMax-M2.7",
+  mistral: "mistral-large-latest"
 };
 const DEFAULT_AIDER_MAIN_MODEL = `anthropic/${DEFAULT_PROVIDER_MODELS.anthropic}`;
 const DEFAULT_AGENT_PROFILE_ID = "default";
@@ -1835,7 +1851,8 @@ const getDefaultProviderParams = (providerName) => {
     case "deepseek":
       provider = {
         name: "deepseek",
-        apiKey: ""
+        apiKey: "",
+        thinkingEnabled: true
       };
       break;
     case "bedrock":
@@ -1920,6 +1937,12 @@ const getDefaultProviderParams = (providerName) => {
         apiKey: ""
       };
       break;
+    case "mistral":
+      provider = {
+        name: "mistral",
+        apiKey: ""
+      };
+      break;
     case "gemini-cli":
       provider = {
         name: "gemini-cli",
@@ -2181,7 +2204,8 @@ const readApiKeyFromConfFile = (filePath, envVarName) => {
           CEREBRAS_API_KEY: ["cerebras"],
           OPENCODE_API_KEY: ["opencode"],
           REQUESTY_API_KEY: ["requesty"],
-          SYNTHETIC_API_KEY: ["synthetic"]
+          SYNTHETIC_API_KEY: ["synthetic"],
+          MISTRAL_API_KEY: ["mistral"]
         };
         const providerNames = envVarToProviderName[envVarName] || [envVarName.replace(/_API_KEY$/, "").toLowerCase()];
         const apiKeys = Array.isArray(apiKeyValue) ? apiKeyValue : [apiKeyValue];
@@ -2347,7 +2371,10 @@ const getDefaultProjectSettings = (store, providerModels, baseDir, defaultAgentP
     currentMode: "agent",
     agentProfileId: defaultAgentProfileId,
     autoApproveLocked: false,
-    updatedFilesGroupMode: "flat"
+    updatedFilesGroupMode: "flat",
+    disabledRuleFiles: [],
+    contextSidebarSectionsOrder: [],
+    contextSidebarSectionsHidden: []
   };
 };
 const filenamify = filenamifyImport.default;
@@ -3034,19 +3061,16 @@ const scrapeWeb = async (url, timeout = 6e4, abortSignal, format = "markdown") =
   const scraper = new WebScraper();
   return await scraper.scrape(url, timeout, abortSignal, format);
 };
-const fileLocks = /* @__PURE__ */ new Map();
-const withFileLock = (filePath, operation) => {
-  logger.debug("Acquiring file lock:", { filePath });
-  const currentLock = fileLocks.get(filePath) || Promise.resolve();
-  const newLock = currentLock.then(operation, operation);
-  fileLocks.set(filePath, newLock);
-  newLock.finally(() => {
-    if (fileLocks.get(filePath) === newLock) {
-      logger.debug("Releasing file lock:", { filePath });
-      fileLocks.delete(filePath);
-    }
-  });
-  return newLock;
+const THINKING_RESPONSE_STAR_TAG = "---\n► **THINKING**\n";
+const ANSWER_RESPONSE_START_TAG = "---\n► **ANSWER**\n";
+const extractPromptContextFromToolResult = (toolResult) => {
+  if (toolResult && typeof toolResult === "object" && "promptContext" in toolResult) {
+    return toolResult.promptContext;
+  }
+  return void 0;
+};
+const findLastUserMessage = (messages) => {
+  return [...messages].reverse().find((msg) => msg.role === MessageRole.User);
 };
 const expandTilde = (filePath) => {
   if (filePath.startsWith("~/") || filePath === "~") {
@@ -3054,11 +3078,25 @@ const expandTilde = (filePath) => {
   }
   return filePath;
 };
-const readFileContent = async (absolutePath, withLines = false, lineOffset = 0, lineLimit = 1e3) => {
+const readFileContent = async (absolutePath, withLines = false, lineOffset = 0, lineLimit = 1e3, sizeLimit = 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 truncatedContent = truncatedBytes.toString("utf8");
+    const truncatedLines = truncatedContent.split("\n");
+    if (withLines) {
+      return truncatedLines.map((line, index) => `${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.`;
+    }
+    return truncatedContent + `
+
+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;
@@ -3074,6 +3112,42 @@ const readFileContent = async (absolutePath, withLines = false, lineOffset = 0,
   }
   return limitedLines.join("\n");
 };
+const truncateToolResult = async (content, maxLines = 1e3, maxSizeKB = 50) => {
+  const lines = content.split("\n");
+  const sizeBytes = Buffer.byteLength(content, "utf8");
+  const sizeKB = sizeBytes / 1024;
+  if (lines.length <= maxLines && sizeKB <= maxSizeKB) {
+    return content;
+  }
+  const id = Date.now().toString(36) + Math.random().toString(36).substring(2, 8);
+  const tmpFileName = `aider-desk-tool-result-${id}.txt`;
+  const tmpFilePath = path.join(os.tmpdir(), tmpFileName);
+  await fs.writeFile(tmpFilePath, content, "utf8");
+  const previewLines = lines.slice(0, maxLines);
+  const reasons = [];
+  if (lines.length > maxLines) {
+    reasons.push(`${lines.length} lines exceeded limit of ${maxLines}`);
+  }
+  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}.`;
+};
+const fileLocks = /* @__PURE__ */ new Map();
+const withFileLock = (filePath, operation) => {
+  logger.debug("Acquiring file lock:", { filePath });
+  const currentLock = fileLocks.get(filePath) || Promise.resolve();
+  const newLock = currentLock.then(operation, operation);
+  fileLocks.set(filePath, newLock);
+  newLock.finally(() => {
+    if (fileLocks.get(filePath) === newLock) {
+      logger.debug("Releasing file lock:", { filePath });
+      fileLocks.delete(filePath);
+    }
+  });
+  return newLock;
+};
 const createPowerToolset = (task, profile, promptContext, abortSignal) => {
   const approvalManager = new ApprovalManager(task, profile);
   const fileEditTool = ai.tool({
@@ -3392,10 +3466,10 @@ Do not use escape characters \\ in the string like \\n or \\" and others. Do not
             encoding: "utf8",
             signal: abortSignal
           });
-          const lines = fileContent.split("\n");
+          const lines2 = fileContent.split("\n");
           const relativeFilePath = path.relative(task.getTaskDir(), absoluteFilePath);
-          for (let index = 0; index < lines.length; index++) {
-            const line = lines[index];
+          for (let index = 0; index < lines2.length; index++) {
+            const line = lines2[index];
             if (searchRegex.test(line)) {
               if (results.length >= maxResults) {
                 break;
@@ -3407,8 +3481,8 @@ Do not use escape characters \\ in the string like \\n or \\" and others. Do not
               };
               if (contextLines > 0) {
                 const start = Math.max(0, index - contextLines);
-                const end = Math.min(lines.length - 1, index + contextLines);
-                matchResult.context = lines.slice(start, end + 1);
+                const end = Math.min(lines2.length - 1, index + contextLines);
+                matchResult.context = lines2.slice(start, end + 1);
               }
               results.push(matchResult);
             }
@@ -3417,7 +3491,40 @@ Do not use escape characters \\ in the string like \\n or \\" and others. Do not
         if (results.length === 0) {
           return `No matches found for pattern '${searchTerm}' in files matching '${filePattern}'.`;
         }
-        return results;
+        const grouped = {};
+        for (const r of results) {
+          if (!grouped[r.filePath]) {
+            grouped[r.filePath] = [];
+          }
+          grouped[r.filePath].push(r);
+        }
+        const lines = [];
+        lines.push(`## Grep Results: \`${searchTerm}\` in \`${filePattern}\` (${results.length} matches)`);
+        lines.push("");
+        for (const [filePath, matches] of Object.entries(grouped)) {
+          lines.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}\``);
+            if (match.context && match.context.length > 0) {
+              lines.push("  ```");
+              for (const ctxLine of match.context) {
+                lines.push(`  ${ctxLine}`);
+              }
+              lines.push("  ```");
+            }
+          }
+          lines.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(". ")}]`);
+        }
+        return lines.join("\n");
       } catch (error) {
         if (isAbortError(error)) {
           return "Operation was cancelled by user.";
@@ -3491,24 +3598,26 @@ Timeout: ${timeout}ms`;
             abortSignal?.removeEventListener("abort", abortListener);
           }
         };
-        const resolveWithResult = () => {
+        const resolveWithResult = async () => {
           if (isResolved) {
             return;
           }
           isResolved = true;
           cleanup();
-          resolve({ stdout, stderr, exitCode });
+          const truncatedStdout = await truncateToolResult(stdout);
+          const truncatedStderr = await truncateToolResult(stderr);
+          resolve({ stdout: truncatedStdout, stderr: truncatedStderr, exitCode });
         };
         abortListener = () => {
           if (isResolved) {
             return;
           }
           if (childProcess?.pid) {
-            treeKill(childProcess.pid, "SIGTERM");
+            treeKill(childProcess.pid, "SIGKILL");
           }
           stderr = "Operation was cancelled by user.";
           exitCode = 130;
-          resolveWithResult();
+          void resolveWithResult();
         };
         abortSignal?.addEventListener("abort", abortListener);
         try {
@@ -3525,13 +3634,16 @@ Timeout: ${timeout}ms`;
               return;
             }
             if (childProcess?.pid) {
-              treeKill(childProcess.pid, "SIGTERM");
+              treeKill(childProcess.pid, "SIGKILL");
             }
             stderr = `Error: Command timed out after ${timeout}ms. Consider increasing the timeout parameter.`;
             exitCode = 124;
-            resolveWithResult();
+            void resolveWithResult();
           }, timeout);
           childProcess.stdout?.on("data", (data) => {
+            if (isResolved) {
+              return;
+            }
             const chunk = data.toString("utf-8");
             stdout += chunk;
             task.addToolMessage(
@@ -3548,6 +3660,9 @@ Timeout: ${timeout}ms`;
             );
           });
           childProcess.stderr?.on("data", (data) => {
+            if (isResolved) {
+              return;
+            }
             const chunk = data.toString("utf-8");
             stderr += chunk;
             task.addToolMessage(
@@ -3567,7 +3682,7 @@ Timeout: ${timeout}ms`;
             if (!isResolved) {
               stderr = error.message;
               exitCode = 1;
-              resolveWithResult();
+              void resolveWithResult();
             }
           });
           childProcess.on("exit", (code, signal) => {
@@ -3579,14 +3694,14 @@ Timeout: ${timeout}ms`;
               } else {
                 exitCode = 1;
               }
-              resolveWithResult();
+              void resolveWithResult();
             }
           });
         } catch (error) {
           if (!isResolved) {
             stderr = error instanceof Error ? error.message : String(error);
             exitCode = 1;
-            resolveWithResult();
+            void resolveWithResult();
           }
         }
       });
@@ -4059,7 +4174,8 @@ Parent Task ID: ${parentTaskId || "none (top-level task)"}` : ""}`;
         const newTask = await task.getProject().createNewTask({
           parentId: parentTaskId || null,
           name: name || "",
-          autoApprove
+          autoApprove,
+          workingMode: worktree ? "worktree" : "local"
         });
         const updates = {};
         if (agentProfileId) {
@@ -4071,9 +4187,6 @@ Parent Task ID: ${parentTaskId || "none (top-level task)"}` : ""}`;
           updates.model = modelParts.join("/");
           updates.mainModel = modelId;
         }
-        if (worktree) {
-          updates.workingMode = "worktree";
-        }
         const taskInstance = task.getProject().getTask(newTask.id);
         if (!taskInstance) {
           throw new Error(`Failed to get task instance for newly created task ${newTask.id}`);
@@ -4685,64 +4798,6 @@ New content: "${content}"`;
   }
   return filteredTools;
 };
-const SKILLS_DIR_NAME = "skills";
-const SKILL_MARKDOWN_FILE = "SKILL.md";
-const parseSkillFrontMatter = (markdown) => {
-  const parsed = yamlFrontMatter.loadFront(markdown);
-  const name = typeof parsed.name === "string" ? parsed.name : void 0;
-  const description = typeof parsed.description === "string" ? parsed.description : void 0;
-  if (!name || !description) {
-    return null;
-  }
-  return { name, description };
-};
-const safeReadDir = async (dirPath) => {
-  try {
-    return await fs.readdir(dirPath);
-  } catch {
-    return [];
-  }
-};
-const safeStat = async (filePath) => {
-  try {
-    return await fs.stat(filePath);
-  } catch {
-    return null;
-  }
-};
-const loadSkillsFromDir = async (skillsRootDir, location) => {
-  const entries = await safeReadDir(skillsRootDir);
-  const skills = [];
-  for (const entry of entries) {
-    const dirPath = path.join(skillsRootDir, entry);
-    const stat = await safeStat(dirPath);
-    if (!stat?.isDirectory()) {
-      continue;
-    }
-    const skillMdPath = path.join(dirPath, SKILL_MARKDOWN_FILE);
-    const skillMdStat = await safeStat(skillMdPath);
-    if (!skillMdStat?.isFile()) {
-      continue;
-    }
-    let markdown;
-    try {
-      markdown = await fs.readFile(skillMdPath, "utf8");
-    } catch {
-      continue;
-    }
-    const parsed = parseSkillFrontMatter(markdown);
-    if (!parsed) {
-      continue;
-    }
-    skills.push({
-      name: parsed.name,
-      description: parsed.description,
-      location,
-      dirPath
-    });
-  }
-  return skills;
-};
 const getActivateSkillDescription = (skills) => {
   const instructions = 'Execute a skill within the main conversation\n\n<skills_instructions>\nWhen users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.\n\nHow to invoke:\n- Use this tool with the skill name only (no arguments)\n- Example: {"skill": "pdf"}\n\nImportant:\n- When a skill is relevant, you must invoke this tool IMMEDIATELY as your first action\n- NEVER just announce or mention a skill in your text response without actually calling this tool\n- Only use skills listed in <available_skills> below\n- Do not invoke a skill that is already running\n</skills_instructions>';
   const availableSkills = skills.map((skill) => {
@@ -4766,15 +4821,10 @@ ${availableSkills}
 };
 const createSkillsToolset = async (task, profile, promptContext) => {
   const approvalManager = new ApprovalManager(task, profile);
+  const skillManager = task.getSkillManager();
   const generateActivateSkillDescription = async () => {
-    const globalSkillsDir = path.join(os.homedir(), AIDER_DESK_DIR, SKILLS_DIR_NAME);
-    const projectSkillsDir = path.join(task.getProjectDir(), AIDER_DESK_DIR, SKILLS_DIR_NAME);
-    const [globalSkills, projectSkills, builtinSkills] = await Promise.all([
-      loadSkillsFromDir(globalSkillsDir, "global"),
-      loadSkillsFromDir(projectSkillsDir, "project"),
-      loadSkillsFromDir(AIDER_DESK_BUILTIN_SKILLS_DIR, "builtin")
-    ]);
-    return getActivateSkillDescription([...projectSkills, ...globalSkills, ...builtinSkills]);
+    const skills = await skillManager.loadAllSkills();
+    return getActivateSkillDescription(skills);
   };
   const activateSkillTool = ai.tool({
     description: await generateActivateSkillDescription(),
@@ -4792,30 +4842,21 @@ const createSkillsToolset = async (task, profile, promptContext) => {
       if (!isApproved) {
         return `Activating skill denied by user. Reason: ${userInput}`;
       }
-      const globalSkillsDir = path.join(os.homedir(), AIDER_DESK_DIR, SKILLS_DIR_NAME);
-      const projectSkillsDir = path.join(task.getProjectDir(), AIDER_DESK_DIR, SKILLS_DIR_NAME);
-      const [globalSkills, projectSkills, builtinSkills] = await Promise.all([
-        loadSkillsFromDir(globalSkillsDir, "global"),
-        loadSkillsFromDir(projectSkillsDir, "project"),
-        loadSkillsFromDir(AIDER_DESK_BUILTIN_SKILLS_DIR, "builtin")
-      ]);
-      const allSkills = [...projectSkills, ...globalSkills, ...builtinSkills];
+      const allSkills = await skillManager.loadAllSkills();
       const requested = allSkills.find((s) => s.name === skill);
       if (!requested) {
         const available = allSkills.map((s) => s.name).join(", ");
         return `Skill '${skill}' not found. Available skills: ${available || "(none)"}.`;
       }
-      const skillMdPath = path.join(requested.dirPath, SKILL_MARKDOWN_FILE);
-      let content;
-      try {
-        content = await fs.readFile(skillMdPath, "utf8");
-      } catch {
-        return `Failed to read skill content from ${skillMdPath}.`;
+      const content = await skillManager.getSkillContent(skill);
+      if (!content) {
+        return `Skill '${requested.name}' has no content or dirPath.`;
       }
+      const dirInfo = requested.dirPath ? `
+Skill directory is ${requested.dirPath} - use it as parent directory for relative paths mentioned in the skill description.` : "";
       return `${content}
 
-Skill '${requested.name}' activated.
-Skill directory is ${requested.dirPath} - use it as parent directory for relative paths mentioned in the skill description.`;
+Skill '${requested.name}' activated.${dirInfo}`;
     }
   });
   const allTools = {
@@ -5252,17 +5293,6 @@ class McpManager {
     }
   }
 }
-const THINKING_RESPONSE_STAR_TAG = "---\n► **THINKING**\n";
-const ANSWER_RESPONSE_START_TAG = "---\n► **ANSWER**\n";
-const extractPromptContextFromToolResult = (toolResult) => {
-  if (toolResult && typeof toolResult === "object" && "promptContext" in toolResult) {
-    return toolResult.promptContext;
-  }
-  return void 0;
-};
-const findLastUserMessage = (messages) => {
-  return [...messages].reverse().find((msg) => msg.role === MessageRole.User);
-};
 const extractReasoningMiddleware = function extractReasoningMiddleware2({
   tagName,
   separator = "\n"
@@ -5905,16 +5935,6 @@ const removeDuplicateToolCalls = (messages) => {
   }
   return newMessages;
 };
-undici.setGlobalDispatcher(
-  new undici.Agent({
-    headersTimeout: 30 * 60 * 1e3,
-    // 30 minutes
-    bodyTimeout: 30 * 60 * 1e3,
-    // 30 minutes
-    connectTimeout: 30 * 1e3
-    // 30 seconds
-  })
-);
 const MAX_RETRIES = 3;
 class Agent {
   constructor(store, agentProfileManager, mcpManager, modelManager, telemetryManager, memoryManager, promptsManager, extensionManager) {
@@ -6242,6 +6262,9 @@ ${fileList}`
             options.abortSignal = abortSignal;
           }
           const result = await toolDef.execute(effectiveInput, options);
+          if (options.abortSignal?.aborted) {
+            return result;
+          }
           const toolFinishedExtensionResult = await this.extensionManager.dispatchEvent(
             "onToolFinished",
             { toolName, input: effectiveInput, output: result },
@@ -6291,6 +6314,14 @@ ${fileList}`
           }
         );
         logger.debug(`Tool ${toolDef.name} returned response`, { response });
+        if (response && typeof response === "object" && "content" in response && Array.isArray(response.content)) {
+          for (let i = 0; i < response.content.length; i++) {
+            const part = response.content[i];
+            if (part && typeof part === "object" && part.type === "text" && typeof part.text === "string") {
+              part.text = await truncateToolResult(part.text);
+            }
+          }
+        }
         this.lastToolCallTime = Date.now();
         return response;
       } catch (error) {
@@ -6471,7 +6502,7 @@ ${fileList}`
       this.abortControllers.set(controllerId, newController);
     }
     const effectiveAbortSignal = abortSignal || (controllerId ? this.abortControllers.get(controllerId)?.signal : void 0);
-    const cacheControl = this.modelManager.getCacheControl(profile, provider.provider);
+    const cacheControl = this.modelManager.getCacheControl(provider, modelName);
     const providerOptions = this.modelManager.getProviderOptions(provider, modelName);
     const providerParameters = this.modelManager.getProviderParameters(provider, modelName);
     const firstUserMessage = contextMessages.length > 0 ? contextMessages[0] : null;
@@ -6727,6 +6758,9 @@ ${fileList}`
           responseMessageIndex = 0;
           hasReasoning = false;
           streamingMessageIds.clear();
+          if (responseMessages.length > 0) {
+            retryCount = 0;
+          }
         };
         const extensionStepStartedResult = await this.extensionManager.dispatchEvent(
           "onAgentStepStarted",
@@ -7171,6 +7205,7 @@ ${fileList}`
     }
     const settings = this.store.getSettings();
     const model = await this.modelManager.createLlm(provider, modelName, settings, projectDir, void 0, systemPrompt, void 0);
+    const cacheControl = this.modelManager.getCacheControl(provider, modelName);
     const providerOptions = this.modelManager.getProviderOptions(provider, modelName);
     const providerParameters = this.modelManager.getProviderParameters(provider, modelName);
     const controllerId = uuid.v4();
@@ -7195,7 +7230,7 @@ ${fileList}`
       const result = await ai.generateText({
         model,
         system: systemPrompt,
-        messages: await optimizeMessages(messages),
+        messages: await optimizeMessages(messages, cacheControl),
         abortSignal: effectiveAbortSignal,
         providerOptions,
         ...providerParameters
@@ -7226,7 +7261,7 @@ ${fileList}`
       const messages = await this.prepareMessages(task, profile, await task.getContextMessages(), await task.getContextFiles());
       const toolSet = await this.getAvailableTools(task, "agent", profile, provider, profile.model);
       const systemPrompt = await this.promptsManager.getSystemPrompt(this.store.getSettings(), task, profile);
-      const cacheControl = this.modelManager.getCacheControl(profile, provider.provider);
+      const cacheControl = this.modelManager.getCacheControl(provider, profile.model);
       const lastUserIndex = messages.map((m) => m.role).lastIndexOf("user");
       const userRequestMessageIndex = lastUserIndex >= 0 ? lastUserIndex : 0;
       const optimizedMessages = await optimizeMessages(
@@ -8460,9 +8495,10 @@ const UpdateOpenProjectsOrderSchema = zod.z.object({
 const LoadInputHistorySchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required")
 });
-const RedoLastUserPromptSchema = zod.z.object({
+const RedoUserPromptSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
   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()
 });
@@ -8571,12 +8607,15 @@ const HandoffConversationSchema = zod.z.object({
   taskId: zod.z.string().min(1, "Task id is required"),
   focus: zod.z.string().optional()
 });
-const RunCodeInlineRequestSchema = 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"),
-  userComment: zod.z.string().min(1, "User comment is required"),
+  userComment: zod.z.string().min(1, "User comment is required")
+});
+const RunCodeChangeRequestsSchema = zod.z.object({
+  projectDir: zod.z.string().min(1, "Project directory is required"),
+  taskId: zod.z.string().min(1, "Task id is required"),
+  requests: zod.z.array(ChangeRequestItemSchema).min(1, "At least one request is required"),
   createNewTask: zod.z.boolean().optional()
 });
 const ScrapeWebSchema = zod.z.object({
@@ -8592,6 +8631,11 @@ const MergeWorktreeToMainSchema = zod.z.object({
   targetBranch: zod.z.string().optional(),
   commitMessage: zod.z.string().optional()
 });
+const MergeAndSwitchToLocalSchema = zod.z.object({
+  projectDir: zod.z.string().min(1, "Project directory is required"),
+  taskId: zod.z.string().min(1, "Task id is required"),
+  targetBranch: zod.z.string().optional()
+});
 const ApplyUncommittedChangesSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
   taskId: zod.z.string().min(1, "Task id is required"),
@@ -8608,6 +8652,7 @@ const RestoreFileSchema = zod.z.object({
 });
 const ReadFileSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
+  taskId: zod.z.string().min(1, "Task id is required"),
   filePath: zod.z.string().min(1, "File path is required")
 });
 const GenerateCommitMessageSchema = zod.z.object({
@@ -8645,6 +8690,11 @@ const ResolveWorktreeConflictsWithAgentSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
   taskId: zod.z.string().min(1, "Task id is required")
 });
+const RenameWorktreeBranchSchema = zod.z.object({
+  projectDir: zod.z.string().min(1, "Project directory is required"),
+  taskId: zod.z.string().min(1, "Task id is required"),
+  newBranchName: zod.z.string().min(1, "New branch name is required")
+});
 class ProjectApi extends BaseApi {
   constructor(eventsHandler) {
     super();
@@ -8673,13 +8723,13 @@ class ProjectApi extends BaseApi {
     router.post(
       "/project/redo-prompt",
       this.handleRequest(async (req, res) => {
-        const parsed = this.validateRequest(RedoLastUserPromptSchema, req.body, res);
+        const parsed = this.validateRequest(RedoUserPromptSchema, req.body, res);
         if (!parsed) {
           return;
         }
-        const { projectDir, taskId, mode, updatedPrompt } = parsed;
-        await this.eventsHandler.redoLastUserPrompt(projectDir, taskId, mode, updatedPrompt);
-        res.status(200).json({ message: "Redo last user prompt initiated" });
+        const { projectDir, taskId, messageId, mode, updatedPrompt } = parsed;
+        await this.eventsHandler.redoUserPrompt(projectDir, taskId, messageId, mode, updatedPrompt);
+        res.status(200).json({ message: "Redo user prompt initiated" });
       })
     );
     router.post(
@@ -8976,15 +9026,15 @@ class ProjectApi extends BaseApi {
       })
     );
     router.post(
-      "/project/run-code-inline-request",
+      "/project/run-code-change-requests",
       this.handleRequest(async (req, res) => {
-        const parsed = this.validateRequest(RunCodeInlineRequestSchema, req.body, res);
+        const parsed = this.validateRequest(RunCodeChangeRequestsSchema, req.body, res);
         if (!parsed) {
           return;
         }
-        const { projectDir, taskId, filename, lineNumber, userComment, createNewTask } = parsed;
-        await this.eventsHandler.runCodeInlineRequest(projectDir, taskId, filename, lineNumber, userComment, createNewTask);
-        res.status(200).json({ message: "Code inline request initiated" });
+        const { projectDir, taskId, requests, createNewTask } = parsed;
+        await this.eventsHandler.runCodeChangeRequests(projectDir, taskId, requests, createNewTask);
+        res.status(200).json({ message: "Code change requests initiated" });
       })
     );
     router.post(
@@ -9011,6 +9061,18 @@ class ProjectApi extends BaseApi {
         res.status(200).json({ message: "Worktree merged" });
       })
     );
+    router.post(
+      "/project/worktree/merge-and-switch-to-local",
+      this.handleRequest(async (req, res) => {
+        const parsed = this.validateRequest(MergeAndSwitchToLocalSchema, req.body, res);
+        if (!parsed) {
+          return;
+        }
+        const { projectDir, taskId, targetBranch } = parsed;
+        await this.eventsHandler.mergeAndSwitchToLocal(projectDir, taskId, targetBranch);
+        res.status(200).json({ message: "Worktree merged and switched to local" });
+      })
+    );
     router.post(
       "/project/worktree/apply-uncommitted",
       this.handleRequest(async (req, res) => {
@@ -9054,8 +9116,8 @@ class ProjectApi extends BaseApi {
         if (!parsed) {
           return;
         }
-        const { projectDir, filePath } = parsed;
-        const content = await this.eventsHandler.readFile(projectDir, filePath);
+        const { projectDir, taskId, filePath } = parsed;
+        const content = await this.eventsHandler.readFile(projectDir, taskId, filePath);
         res.status(200).json({ content });
       })
     );
@@ -9155,6 +9217,18 @@ class ProjectApi extends BaseApi {
         res.status(200).json({ message: "Conflicts resolved" });
       })
     );
+    router.post(
+      "/project/worktree/rename-branch",
+      this.handleRequest(async (req, res) => {
+        const parsed = this.validateRequest(RenameWorktreeBranchSchema, req.body, res);
+        if (!parsed) {
+          return;
+        }
+        const { projectDir, taskId, newBranchName } = parsed;
+        await this.eventsHandler.renameWorktreeBranch(projectDir, taskId, newBranchName);
+        res.status(200).json({ message: "Branch renamed" });
+      })
+    );
     router.post(
       "/project/update-order",
       this.handleRequest(async (req, res) => {
@@ -9488,9 +9562,10 @@ const GetSystemLogsSchema = zod.z.object({
   levels: zod.z.array(zod.z.string()).optional()
 });
 class SystemApi extends BaseApi {
-  constructor(eventsHandler) {
+  constructor(eventsHandler, pythonInstaller) {
     super();
     this.eventsHandler = eventsHandler;
+    this.pythonInstaller = pythonInstaller;
   }
   registerRoutes(router) {
     router.get(
@@ -9524,6 +9599,13 @@ class SystemApi extends BaseApi {
         res.status(200).json({ success: true });
       })
     );
+    router.get(
+      "/system/aider-connector-status",
+      this.handleRequest(async (_req, res) => {
+        const status = this.pythonInstaller.getStatus();
+        res.status(200).json(status);
+      })
+    );
   }
 }
 const GetTodosSchema = zod.z.object({
@@ -10100,13 +10182,88 @@ class ExtensionsApi extends BaseApi {
     );
   }
 }
+const GetSkillsSchema = zod.z.object({
+  projectDir: zod.z.string().min(1, "Project directory is required"),
+  taskId: zod.z.string().min(1, "Task ID is required")
+});
+const ActivateSkillSchema = zod.z.object({
+  projectDir: zod.z.string().min(1, "Project directory is required"),
+  taskId: zod.z.string().min(1, "Task ID is required"),
+  skillName: zod.z.string().min(1, "Skill name is required")
+});
+class SkillsApi extends BaseApi {
+  constructor(eventsHandler) {
+    super();
+    this.eventsHandler = eventsHandler;
+  }
+  registerRoutes(router) {
+    router.get(
+      "/skills",
+      this.handleRequest(async (req, res) => {
+        const parsed = this.validateRequest(GetSkillsSchema, req.query, res);
+        if (!parsed) {
+          return;
+        }
+        const { projectDir, taskId } = parsed;
+        const skills = await this.eventsHandler.getSkills(projectDir, taskId);
+        res.status(200).json(skills);
+      })
+    );
+    router.post(
+      "/skills/activate",
+      this.handleRequest(async (req, res) => {
+        const parsed = this.validateRequest(ActivateSkillSchema, req.body, res);
+        if (!parsed) {
+          return;
+        }
+        const { projectDir, taskId, skillName } = parsed;
+        await this.eventsHandler.activateSkill(projectDir, taskId, skillName);
+        res.status(200).json({ success: true });
+      })
+    );
+    router.post(
+      "/skills/deactivate",
+      this.handleRequest(async (req, res) => {
+        const parsed = this.validateRequest(ActivateSkillSchema, req.body, res);
+        if (!parsed) {
+          return;
+        }
+        const { projectDir, taskId, skillName } = parsed;
+        await this.eventsHandler.deactivateSkill(projectDir, taskId, skillName);
+        res.status(200).json({ success: true });
+      })
+    );
+  }
+}
+const createCorsOriginValidator = (store) => (origin, callback) => {
+  if (CORS_ALLOWED_ORIGINS) {
+    const origins = CORS_ALLOWED_ORIGINS.split(",").map((o) => o.trim()).filter(Boolean);
+    if (!origin || origins.includes(origin)) {
+      callback(null, true);
+    } else {
+      callback(null, false);
+    }
+    return;
+  }
+  const corsSettings = store.getSettings().server.cors;
+  if (!corsSettings.enabled || corsSettings.origins.length === 0) {
+    callback(null, false);
+    return;
+  }
+  if (!origin || corsSettings.origins.includes(origin)) {
+    callback(null, true);
+  } else {
+    callback(null, false);
+  }
+};
 const REQUEST_TIMEOUT_MS = 5 * 60 * 1e3;
 class ServerController {
-  constructor(server, projectManager, eventsHandler, store) {
+  constructor(server, projectManager, eventsHandler, store, pythonInstaller) {
     this.server = server;
     this.projectManager = projectManager;
     this.eventsHandler = eventsHandler;
     this.store = store;
+    this.pythonInstaller = pythonInstaller;
     this.init();
   }
   app = express();
@@ -10162,7 +10319,7 @@ class ServerController {
     new ProjectApi(this.eventsHandler).registerRoutes(apiRouter);
     new CommandsApi(this.eventsHandler).registerRoutes(apiRouter);
     new UsageApi(this.eventsHandler).registerRoutes(apiRouter);
-    new SystemApi(this.eventsHandler).registerRoutes(apiRouter);
+    new SystemApi(this.eventsHandler, this.pythonInstaller).registerRoutes(apiRouter);
     new TodoApi(this.eventsHandler).registerRoutes(apiRouter);
     new McpApi(this.eventsHandler).registerRoutes(apiRouter);
     new ProvidersApi(this.eventsHandler).registerRoutes(apiRouter);
@@ -10171,11 +10328,15 @@ class ServerController {
     new VoiceApi(this.eventsHandler).registerRoutes(apiRouter);
     new TerminalApi(this.eventsHandler).registerRoutes(apiRouter);
     new ExtensionsApi(this.eventsHandler).registerRoutes(apiRouter);
+    new SkillsApi(this.eventsHandler).registerRoutes(apiRouter);
     this.app.use("/api", apiRouter);
   }
+  setupCors() {
+    this.app.use(cors({ origin: createCorsOriginValidator(this.store) }));
+  }
   init() {
     this.app.use(express.json({ limit: "50mb" }));
-    this.app.use(cors());
+    this.setupCors();
     this.app.use(this.serverGuardMiddleware.bind(this));
     this.app.use(this.timeoutMiddleware.bind(this));
     this.app.use(this.basicAuthMiddleware.bind(this));
@@ -10442,9 +10603,10 @@ const isUnsubscribeEventsMessage = (message) => {
   return message.action === "unsubscribe-events";
 };
 class ConnectorManager {
-  constructor(httpServer, projectManager, eventManager) {
+  constructor(httpServer, projectManager, eventManager, store) {
     this.projectManager = projectManager;
     this.eventManager = eventManager;
+    this.store = store;
     this.init(httpServer);
   }
   io = null;
@@ -10452,7 +10614,7 @@ class ConnectorManager {
   init(httpServer) {
     this.io = new socket_io.Server(httpServer, {
       cors: {
-        origin: "*",
+        origin: createCorsOriginValidator(this.store),
         methods: ["GET", "POST"]
       },
       pingTimeout: 6e5,
@@ -11286,6 +11448,15 @@ class ContextManager {
     }
     return this.removeByToolCallId(messageId);
   }
+  removeMessagesByIds(ids) {
+    for (const id of ids) {
+      const index = this.messages.findIndex((msg) => msg.id === id);
+      if (index !== -1) {
+        this.messages.splice(index, 1);
+      }
+    }
+    this.autosave();
+  }
   removeMessageByIndex(index, messageId) {
     const removedIds = [];
     removedIds.push(messageId);
@@ -11415,16 +11586,17 @@ class ContextManager {
     }
     this.autosave();
   }
-  removeMessagesUpToLastUserMessage() {
-    const lastUserMessageIndex = this.messages.findLastIndex((msg) => msg.role === MessageRole.User);
-    if (lastUserMessageIndex === -1) {
-      logger.warn("No user message found to remove up to.", {
-        taskId: this.taskId
+  removeMessagesUpToUserMessage(messageId) {
+    const userMessageIndex = this.messages.findIndex((msg) => msg.id === messageId && msg.role === MessageRole.User);
+    if (userMessageIndex === -1) {
+      logger.warn("No user message found with the given ID to remove up to.", {
+        taskId: this.taskId,
+        messageId
       });
       return [];
     }
-    const removedMessages = this.messages.splice(lastUserMessageIndex);
-    logger.debug(`Task ${this.taskId}: Removed ${removedMessages.length} messages up to last user message. Total messages: ${this.messages.length}`);
+    const removedMessages = this.messages.splice(userMessageIndex);
+    logger.debug(`Task ${this.taskId}: Removed ${removedMessages.length} messages up to user message ${messageId}. Total messages: ${this.messages.length}`);
     this.autosave();
     return removedMessages;
   }
@@ -12078,6 +12250,82 @@ ${JSON.stringify(part.output.value, null, 2)}
     return removedIds;
   }
 }
+const PROXY_ENV_VAR_NAMES = ["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy"];
+const getProxyEnvVars = (settings) => {
+  if (settings.proxy?.enabled && settings.proxy?.url) {
+    const url = settings.proxy.url;
+    return {
+      HTTP_PROXY: url,
+      HTTPS_PROXY: url,
+      ALL_PROXY: url,
+      http_proxy: url,
+      https_proxy: url,
+      all_proxy: url
+    };
+  }
+  return Object.fromEntries(PROXY_ENV_VAR_NAMES.map((key) => [key, ""]));
+};
+class ProxyManager {
+  currentUrl = null;
+  /**
+   * Initialize proxy from settings. Called once during app startup (first in managers init).
+   */
+  init(settings) {
+    globalAgent.bootstrap();
+    if (settings.proxy?.enabled && settings.proxy?.url) {
+      this.applyProxy(settings.proxy.url);
+    } else {
+      this.clearProxy();
+    }
+  }
+  /**
+   * React to settings changes. Called on every saveSettings().
+   * Re-initializes the proxy if the config changed.
+   */
+  settingsChanged(oldSettings, newSettings) {
+    const oldProxy = oldSettings.proxy;
+    const newProxy = newSettings.proxy;
+    if (oldProxy?.enabled !== newProxy?.enabled || oldProxy?.url !== newProxy?.url) {
+      if (newProxy?.enabled && newProxy?.url) {
+        logger.info(`[ProxyManager] Applying proxy: ${newProxy.url}`);
+        this.applyProxy(newProxy.url);
+      } else if (this.currentUrl !== null) {
+        logger.info("[ProxyManager] Clearing proxy");
+        this.clearProxy();
+      }
+    }
+  }
+  applyProxy(url) {
+    try {
+      global.GLOBAL_AGENT.HTTP_PROXY = url;
+      const proxyAgent = new undici.ProxyAgent(url);
+      undici.setGlobalDispatcher(proxyAgent);
+      this.currentUrl = url;
+      logger.info(`[ProxyManager] Proxy initialized: ${url}`);
+    } catch (error) {
+      logger.error("[ProxyManager] Failed to initialize proxy", { error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  clearProxy() {
+    try {
+      global.GLOBAL_AGENT.HTTP_PROXY = void 0;
+      undici.setGlobalDispatcher(
+        new undici.Agent({
+          headersTimeout: 30 * 60 * 1e3,
+          // 30 minutes
+          bodyTimeout: 30 * 60 * 1e3,
+          // 30 minutes
+          connectTimeout: 30 * 1e3
+          // 30 seconds
+        })
+      );
+      this.currentUrl = null;
+      logger.info("[ProxyManager] Proxy cleared");
+    } catch (error) {
+      logger.error("[ProxyManager] Failed to clear proxy", { error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+}
 class AiderManager {
   constructor(task, store, modelManager, eventManager, getConnectors, pythonInstaller) {
     this.task = task;
@@ -12186,11 +12434,13 @@ class AiderManager {
       taskId: this.task.taskId,
       args
     });
+    const proxyEnvVars = getProxyEnvVars(settings);
     const env = {
       ...process.env,
       ...environmentVariables,
       ...envFromMain,
       ...envFromWeak,
+      ...proxyEnvVars,
       PYTHONPATH: AIDER_DESK_CONNECTOR_DIR,
       PYTHONUTF8: process.env.AIDER_DESK_OMIT_PYTHONUTF8 ? void 0 : "1",
       BASE_DIR: this.task.getProjectDir(),
@@ -12486,6 +12736,156 @@ class AiderManager {
     connectors.filter((connector) => connector.listenTo.includes("update-env-vars")).forEach((connector) => connector.sendUpdateEnvVarsMessage(environmentVariables));
   }
 }
+const SKILLS_DIR_NAME = "skills";
+const SKILL_MARKDOWN_FILE = "SKILL.md";
+const TOOL_NAME = `${SKILLS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}${SKILLS_TOOL_ACTIVATE_SKILL}`;
+const parseSkillFrontMatter = (markdown) => {
+  const parsed = yamlFrontMatter.loadFront(markdown);
+  const name = typeof parsed.name === "string" ? parsed.name : void 0;
+  const description = typeof parsed.description === "string" ? parsed.description : void 0;
+  if (!name || !description) {
+    return null;
+  }
+  return { name, description };
+};
+const safeReadDir = async (dirPath) => {
+  try {
+    return await fs.readdir(dirPath);
+  } catch {
+    return [];
+  }
+};
+const safeStat = async (filePath) => {
+  try {
+    return await fs.stat(filePath);
+  } catch {
+    return null;
+  }
+};
+const loadSkillsFromDir = async (skillsRootDir, location) => {
+  const entries = await safeReadDir(skillsRootDir);
+  const skills = [];
+  for (const entry of entries) {
+    const dirPath = path.join(skillsRootDir, entry);
+    const stat = await safeStat(dirPath);
+    if (!stat?.isDirectory()) {
+      continue;
+    }
+    const skillMdPath = path.join(dirPath, SKILL_MARKDOWN_FILE);
+    const skillMdStat = await safeStat(skillMdPath);
+    if (!skillMdStat?.isFile()) {
+      continue;
+    }
+    let markdown;
+    try {
+      markdown = await fs.readFile(skillMdPath, "utf8");
+    } catch {
+      continue;
+    }
+    const parsed = parseSkillFrontMatter(markdown);
+    if (!parsed) {
+      continue;
+    }
+    skills.push({
+      name: parsed.name,
+      description: parsed.description,
+      location,
+      dirPath
+    });
+  }
+  return skills;
+};
+class SkillManager {
+  extensionManager;
+  projectDir;
+  constructor(projectDir, extensionManager) {
+    this.projectDir = projectDir;
+    this.extensionManager = extensionManager;
+  }
+  async loadAllSkills() {
+    const globalSkillsDir = path.join(os.homedir(), AIDER_DESK_DIR, SKILLS_DIR_NAME);
+    const projectSkillsDir = path.join(this.projectDir, AIDER_DESK_DIR, SKILLS_DIR_NAME);
+    const extensionSkills = this.extensionManager ? this.extensionManager.getSkills({ baseDir: this.projectDir }, { getTaskDir: () => this.projectDir }) : [];
+    const [globalSkills, projectSkills, builtinSkills] = await Promise.all([
+      loadSkillsFromDir(globalSkillsDir, "global"),
+      loadSkillsFromDir(projectSkillsDir, "project"),
+      loadSkillsFromDir(AIDER_DESK_BUILTIN_SKILLS_DIR, "builtin")
+    ]);
+    return [...projectSkills, ...globalSkills, ...builtinSkills, ...extensionSkills];
+  }
+  async getSkills(contextMessages) {
+    const skills = await this.loadAllSkills();
+    const activatedSkillNames = contextMessages ? this.getActivatedSkillNames(contextMessages) : /* @__PURE__ */ new Set();
+    return skills.map((skill) => ({
+      ...skill,
+      activated: activatedSkillNames.has(skill.name)
+    }));
+  }
+  async getSkillContent(skillName) {
+    const skills = await this.loadAllSkills();
+    const skill = skills.find((s) => s.name === skillName);
+    if (!skill) {
+      return null;
+    }
+    if (skill.content) {
+      return skill.content;
+    }
+    if (skill.dirPath) {
+      const skillMdPath = path.join(skill.dirPath, SKILL_MARKDOWN_FILE);
+      try {
+        return await fs.readFile(skillMdPath, "utf8");
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  getActivatedSkillNames(contextMessages) {
+    const activatedNames = /* @__PURE__ */ new Set();
+    for (const message of contextMessages) {
+      if (message.role === "assistant" && Array.isArray(message.content)) {
+        for (const part of message.content) {
+          if (part.type === "tool-call" && part.toolName === TOOL_NAME && part.input?.skill) {
+            activatedNames.add(part.input.skill);
+          }
+        }
+      }
+    }
+    return activatedNames;
+  }
+  buildActivateSkillMessages(skillName, content) {
+    const toolCallId = uuid.v4();
+    const assistantMessage = {
+      id: uuid.v4(),
+      role: "assistant",
+      content: [
+        {
+          type: "text",
+          text: "User requested the skill activation."
+        },
+        {
+          type: "tool-call",
+          toolCallId,
+          toolName: TOOL_NAME,
+          input: { skill: skillName }
+        }
+      ]
+    };
+    const toolMessage = {
+      id: uuid.v4(),
+      role: "tool",
+      content: [
+        {
+          type: "tool-result",
+          toolCallId,
+          toolName: TOOL_NAME,
+          output: { type: "text", value: content }
+        }
+      ]
+    };
+    return [assistantMessage, toolMessage];
+  }
+}
 class GitError extends Error {
   name = "GitError";
   gitCommands;
@@ -12563,7 +12963,7 @@ class WorktreeManager {
           await execWithShellPath('git commit -m "Initial commit" --allow-empty', { cwd: projectPath });
         }
         let baseCommit;
-        let actualBaseBranch;
+        let newBranchName;
         const baseRef = baseBranch;
         if (branch) {
           let branchExists = false;
@@ -12577,7 +12977,7 @@ class WorktreeManager {
             baseCommit = (await execWithShellPath(`git rev-parse ${branch}`, {
               cwd: projectPath
             })).stdout.trim();
-            actualBaseBranch = branch;
+            newBranchName = branch;
           } else {
             if (baseBranch !== "HEAD") {
               try {
@@ -12590,7 +12990,7 @@ class WorktreeManager {
               cwd: projectPath
             })).stdout.trim();
             await execWithShellPath(`git worktree add -b ${branch} "${worktreePath}" ${baseRef}`, { cwd: projectPath });
-            actualBaseBranch = branch;
+            newBranchName = branch;
           }
         } else {
           await execWithShellPath(`git worktree add "${worktreePath}" ${baseRef}`, { cwd: projectPath });
@@ -12599,25 +12999,38 @@ class WorktreeManager {
           })).stdout.trim();
           if (baseRef === "HEAD") {
             try {
-              actualBaseBranch = (await execWithShellPath("git rev-parse --abbrev-ref HEAD", {
+              newBranchName = (await execWithShellPath("git rev-parse --abbrev-ref HEAD", {
                 cwd: projectPath
               })).stdout.trim();
-              if (actualBaseBranch === "HEAD") {
-                actualBaseBranch = "DETACHED HEAD";
+              if (newBranchName === "HEAD") {
+                newBranchName = "DETACHED HEAD";
               }
             } catch {
-              actualBaseBranch = "DETACHED HEAD";
+              newBranchName = "DETACHED HEAD";
             }
           } else {
-            actualBaseBranch = `${baseRef} (DETACHED)`;
+            newBranchName = `${baseRef} (DETACHED)`;
           }
           logger.info(`Worktree created in DETACHED HEAD mode from commit: ${baseCommit}`);
         }
+        let resolvedBaseBranch;
+        if (baseRef === "HEAD") {
+          try {
+            const result = await execWithShellPath("git rev-parse --abbrev-ref HEAD", { cwd: projectPath });
+            const headBranch = result.stdout.trim();
+            resolvedBaseBranch = headBranch !== "HEAD" ? headBranch : void 0;
+          } catch {
+            resolvedBaseBranch = void 0;
+          }
+        } else {
+          resolvedBaseBranch = baseRef;
+        }
         logger.info(`Worktree created successfully at: ${worktreePath}`);
         return {
           path: worktreePath,
           baseCommit,
-          baseBranch: actualBaseBranch
+          baseBranch: resolvedBaseBranch,
+          branch: newBranchName
         };
       } catch (error) {
         logger.error("Failed to create worktree:", error);
@@ -12625,6 +13038,29 @@ class WorktreeManager {
       }
     });
   }
+  async renameBranch(projectPath, oldBranch, newBranch) {
+    try {
+      const finalBranchName = await this.findUniqueBranchName(projectPath, newBranch);
+      await execWithShellPath(`git branch -m ${oldBranch} ${finalBranchName}`, { cwd: projectPath });
+      logger.info(`Renamed branch: ${oldBranch} -> ${finalBranchName}`);
+      return finalBranchName;
+    } catch (error) {
+      logger.warn(`Failed to rename branch ${oldBranch} to ${newBranch}:`, error);
+      return newBranch;
+    }
+  }
+  async findUniqueBranchName(projectPath, baseName) {
+    const existingBranches = await this.listBranches(projectPath);
+    const branchNames = new Set(existingBranches.map((b) => b.name));
+    if (!branchNames.has(baseName)) {
+      return baseName;
+    }
+    let suffix = 2;
+    while (branchNames.has(`${baseName}-${suffix}`)) {
+      suffix++;
+    }
+    return `${baseName}-${suffix}`;
+  }
   async createSymlinks(projectPath, worktreePath, folderNames) {
     if (folderNames.length === 0) {
       logger.debug("No symlink folders configured, skipping symlink creation");
@@ -12678,14 +13114,14 @@ class WorktreeManager {
     return await withLock(`worktree-remove-${projectDir}-${worktree.path}`, async () => {
       try {
         await execWithShellPath(`git worktree remove "${worktree.path}" --force`, { cwd: projectDir });
-        if (worktree.baseBranch) {
+        if (worktree.branch) {
           try {
-            await execWithShellPath(`git branch -D ${worktree.baseBranch}`, {
+            await execWithShellPath(`git branch -D ${worktree.branch}`, {
               cwd: projectDir
             });
-            logger.info(`Deleted task branch: ${worktree.baseBranch}`);
+            logger.info(`Deleted task branch: ${worktree.branch}`);
           } catch (error) {
-            logger.debug(`Could not delete branch ${worktree.baseBranch}:`, error);
+            logger.debug(`Could not delete branch ${worktree.branch}:`, error);
           }
         }
       } catch (error) {
@@ -12712,12 +13148,12 @@ class WorktreeManager {
               ...currentWorktree
             });
           }
-          currentWorktree = { path: line.substring(9), baseBranch: "" };
+          currentWorktree = { path: line.substring(9), branch: "" };
         } else if (line.startsWith("branch ")) {
           currentWorktree = {
             ...currentWorktree || {},
             path: currentWorktree ? currentWorktree.path : "",
-            baseBranch: line.substring(7).replace("refs/heads/", "")
+            branch: line.substring(7).replace("refs/heads/", "")
           };
         } else if (line.startsWith("HEAD ")) {
           currentWorktree = {
@@ -12729,7 +13165,7 @@ class WorktreeManager {
           currentWorktree = {
             ...currentWorktree || {},
             path: currentWorktree ? currentWorktree.path : "",
-            baseBranch: void 0
+            branch: void 0
           };
         } else if (line.startsWith("prunable")) {
           currentWorktree = {
@@ -12758,7 +13194,7 @@ class WorktreeManager {
         cwd: projectPath
       });
       const worktrees = await this.listWorktrees(projectPath);
-      const worktreeBranches = new Set(worktrees.map((w) => w.baseBranch));
+      const worktreeBranches = new Set(worktrees.map((w) => w.branch));
       const branches = [];
       const lines = branchOutput.split("\n").filter((line) => line.trim());
       for (const line of lines) {
@@ -12812,6 +13248,22 @@ class WorktreeManager {
     logger.warn("getEffectiveMainBranch is deprecated, use getProjectMainBranch instead");
     return await this.getProjectMainBranch(project.path);
   }
+  async getHeadCommit(worktreePath) {
+    try {
+      const { stdout } = await execWithShellPath("git rev-parse HEAD", { cwd: worktreePath });
+      return stdout.trim();
+    } catch {
+      return void 0;
+    }
+  }
+  async getBranchesContainingCommit(projectPath, commit) {
+    try {
+      const { stdout } = await execWithShellPath(`git branch --contains ${commit} --format='%(refname:short)'`, { cwd: projectPath });
+      return stdout.trim().split("\n").map((b) => b.trim()).filter((b) => b);
+    } catch {
+      return [];
+    }
+  }
   async hasChangesToRebase(worktreePath, mainBranch) {
     try {
       let stdout = "0";
@@ -12893,7 +13345,7 @@ class WorktreeManager {
       };
     }
   }
-  async rebaseMainIntoWorktree(worktreePath, mainBranch) {
+  async rebaseMainIntoWorktree(worktreePath, mainBranch, baseCommit) {
     return await withLock(`git-rebase-${worktreePath}`, async () => {
       const executedCommands = [];
       let lastOutput = "";
@@ -12905,14 +13357,14 @@ class WorktreeManager {
           const addCommand = "git add -A";
           executedCommands.push(`${addCommand} (in ${worktreePath})`);
           await execWithShellPath(addCommand, { cwd: worktreePath });
-          const commitCommand = `git commit -m "TEMP_UNCOMMITTED_${Date.now()}"`;
+          const commitCommand = `git commit --no-verify -m "TEMP_UNCOMMITTED_${Date.now()}"`;
           executedCommands.push(`${commitCommand} (in ${worktreePath})`);
           await execWithShellPath(commitCommand, {
             cwd: worktreePath
           });
           logger.info("Created temporary commit for uncommitted changes");
         }
-        const command = `git rebase ${mainBranch}`;
+        const command = baseCommit ? `git rebase --onto ${mainBranch} ${baseCommit}` : `git rebase ${mainBranch}`;
         executedCommands.push(`${command} (in ${worktreePath})`);
         const rebaseResult = await execWithShellPath(command, {
           cwd: worktreePath
@@ -12987,7 +13439,7 @@ class WorktreeManager {
       }
     });
   }
-  async squashAndMergeWorktreeToMain(projectPath, worktreePath, mainBranch, commitMessage) {
+  async squashAndMergeWorktreeToMain(projectPath, worktreePath, mainBranch, commitMessage, baseCommit) {
     const executedCommands = [];
     let lastOutput = "";
     try {
@@ -13003,8 +13455,8 @@ class WorktreeManager {
       if (!commits.trim()) {
         return;
       }
-      command = `git rebase ${mainBranch}`;
-      executedCommands.push(`git rebase ${mainBranch} (in ${worktreePath})`);
+      command = baseCommit ? `git rebase --onto ${mainBranch} ${baseCommit}` : `git rebase ${mainBranch}`;
+      executedCommands.push(`${command} (in ${worktreePath})`);
       try {
         const rebaseWorktreeResult = await execWithShellPath(command, {
           cwd: worktreePath
@@ -13313,10 +13765,12 @@ Git output: ${err.stderr || err.stdout || err.message}`
    */
   async hasUncommittedChanges(path2) {
     try {
-      const { stdout } = await execWithShellPath("git status --porcelain=v1", {
+      const { stdout } = await execWithShellPath("git status --porcelain=v1 -z", {
         cwd: path2
       });
-      return stdout.trim().length > 0;
+      const filePaths = this.parseGitStatusEntries(stdout);
+      const realChanges = filePaths.filter((filePath) => !this.isSymlinkPath(path2, filePath));
+      return realChanges.length > 0;
     } catch (error) {
       logger.error("Failed to check for uncommitted changes:", error);
       return false;
@@ -13408,7 +13862,7 @@ Git output: ${err.stderr || err.stdout || err.message}`
    * Merge worktree to main branch with uncommitted changes support
    * Returns MergeState for potential revert
    */
-  async mergeWorktreeToMainWithUncommitted(projectPath, taskId, worktreePath, squash, commitMessage, targetBranch, symlinkFolders = []) {
+  async mergeWorktreeToMainWithUncommitted(projectPath, taskId, worktreePath, squash, commitMessage, targetBranch, symlinkFolders = [], baseCommit) {
     return await withLock(`git-merge-worktree-${worktreePath}`, async () => {
       const timestamp = Date.now();
       const worktreeStashId = `worktree-${taskId.length > 24 ? taskId.substring(24) : taskId}-merge-${timestamp}`;
@@ -13436,7 +13890,7 @@ Git output: ${err.stderr || err.stdout || err.message}`
           if (!commitMessage) {
             throw new Error("Commit message is required for squash merge");
           }
-          await this.squashAndMergeWorktreeToMain(projectPath, worktreePath, mainBranch, commitMessage);
+          await this.squashAndMergeWorktreeToMain(projectPath, worktreePath, mainBranch, commitMessage, baseCommit);
         } else {
           await this.mergeWorktreeToMain(projectPath, worktreePath, mainBranch);
         }
@@ -13490,10 +13944,15 @@ Git output: ${err.stderr || err.stdout || err.message}`
    * Check if worktree has uncommitted changes or unmerged commits
    * Returns information about unsaved work in the worktree
    */
-  async checkWorktreeForUnmergedWork(projectPath, worktreePath, targetBranch) {
+  async checkWorktreeForUnmergedWork(projectPath, worktreePath, targetBranch, symlinkFolders = []) {
     try {
-      const hasUncommittedChanges = await this.hasUncommittedChanges(worktreePath);
       const { files: uncommittedFiles } = await this.getUncommittedFiles(worktreePath);
+      const filteredUncommittedFiles = uncommittedFiles.filter((file) => {
+        const pathPart = file.replace(/^..\s*/, "").trim();
+        const normalizedPath = pathPart.replace(/\\/g, "/");
+        return !symlinkFolders.some((folder) => normalizedPath.startsWith(`${folder}/`) || normalizedPath === folder);
+      });
+      const actualHasUncommittedChanges = filteredUncommittedFiles.length > 0;
       const effectiveTargetBranch = targetBranch || await this.getProjectMainBranch(projectPath);
       let unmergedCommitCount = 0;
       let unmergedCommits = [];
@@ -13507,11 +13966,11 @@ Git output: ${err.stderr || err.stdout || err.message}`
       }
       const hasUnmergedCommits = unmergedCommitCount > 0;
       return {
-        hasUncommittedChanges,
+        hasUncommittedChanges: actualHasUncommittedChanges,
         hasUnmergedCommits,
         unmergedCommitCount,
         unmergedCommits,
-        uncommittedFiles
+        uncommittedFiles: filteredUncommittedFiles
       };
     } catch (error) {
       logger.error("Failed to check worktree for unmerged work:", error);
@@ -13536,12 +13995,25 @@ Git output: ${err.stderr || err.stdout || err.message}`
     const { stdout } = await execWithShellPath("git status --porcelain=v1 -z", {
       cwd: worktreePath
     });
-    const files = stdout.split("\0").map((l) => l.trim()).filter((l) => l.length > 0);
+    const filePaths = this.parseGitStatusEntries(stdout);
+    const files = filePaths.filter((filePath) => !this.isSymlinkPath(worktreePath, filePath));
     return {
       count: files.length,
       files: Array.from(new Set(files))
     };
   }
+  parseGitStatusEntries(stdout) {
+    return stdout.split("\0").map((entry) => entry.substring(3).trim()).filter((filePath) => filePath.length > 0);
+  }
+  isSymlinkPath(cwd, filePath) {
+    try {
+      const fullPath = path.join(cwd, filePath);
+      const stat = fs$1.lstatSync(fullPath);
+      return stat.isSymbolicLink();
+    } catch {
+      return false;
+    }
+  }
   /**
    * Get updated files with per-commit and uncommitted diffs.
    *
@@ -13553,13 +14025,17 @@ Git output: ${err.stderr || err.stdout || err.message}`
    */
   async getUpdatedFiles(worktreePath, workingMode, mainBranch, groupMode = UpdatedFilesGroupMode.Grouped) {
     try {
+      let files;
       if (workingMode === "worktree" && mainBranch) {
         if (groupMode === UpdatedFilesGroupMode.Flat) {
-          return await this.getWorktreeFlatUpdatedFiles(worktreePath, mainBranch);
+          files = await this.getWorktreeFlatUpdatedFiles(worktreePath, mainBranch);
+        } else {
+          files = await this.getWorktreeUpdatedFiles(worktreePath, mainBranch);
         }
-        return await this.getWorktreeUpdatedFiles(worktreePath, mainBranch);
+      } else {
+        files = await this.getNonWorktreeUpdatedFiles(worktreePath);
       }
-      return await this.getNonWorktreeUpdatedFiles(worktreePath);
+      return await this.markConflictingFiles(worktreePath, files);
     } catch (error) {
       logger.warn("Failed to get updated files:", error);
       return [];
@@ -13799,6 +14275,20 @@ Git output: ${err.stderr || err.stdout || err.message}`
     }
     return fileDiffs;
   }
+  async markConflictingFiles(worktreePath, files) {
+    try {
+      const { stdout } = await execWithShellPath("git diff --name-only --diff-filter=U", { cwd: worktreePath });
+      const unmergedFiles = new Set(
+        stdout.split("\n").map((l) => l.trim()).filter((l) => l.length > 0)
+      );
+      if (unmergedFiles.size === 0) {
+        return files;
+      }
+      return files.map((f) => unmergedFiles.has(f.path) ? { ...f, hasConflicts: true } : f);
+    } catch {
+      return files;
+    }
+  }
   async restoreFile(worktreePath, filePath) {
     try {
       logger.info(`Restoring file: ${filePath}`, { worktreePath });
@@ -14166,6 +14656,7 @@ class Task {
     };
     this.taskDataPath = path.join(this.project.baseDir, AIDER_DESK_TASKS_DIR, this.taskId, "settings.json");
     this.contextManager = new ContextManager(this, this.taskId);
+    this.skillManager = new SkillManager(project.baseDir, extensionManager);
     this.agent = new Agent(
       this.store,
       this.agentProfileManager,
@@ -14211,6 +14702,7 @@ class Task {
   contextManager;
   agent;
   aiderManager;
+  skillManager;
   task;
   async getTaskAgentProfile() {
     let agentProfileId = this.task.agentProfileId;
@@ -14264,10 +14756,56 @@ class Task {
    * Generate a branch name from task name (first 7 words, separated by '-')
    */
   generateBranchName() {
+    const settings = this.store.getSettings();
+    const branchPrefix = settings.taskSettings.worktreeBranchPrefix || WORKTREE_BRANCH_PREFIX;
     const words = this.task.name.toLowerCase().replace(/[^a-z0-9\s-]/g, "").split(/\s+/).filter((word) => word.length > 0).slice(0, 7);
     const branchName = words.join("-");
     const cleanBranchName = branchName.replace(/^[.-]+/, "").replace(/-+/g, "-").replace(/-$/, "");
-    return `${WORKTREE_BRANCH_PREFIX}${cleanBranchName || this.taskId}`;
+    const fallbackId = /^[0-9a-f]{8}-/i.test(this.taskId) ? this.taskId.split("-")[0] : this.taskId;
+    return `${branchPrefix}${cleanBranchName || fallbackId}`;
+  }
+  async renameWorktreeBranchIfNeeded() {
+    if (this.task.workingMode !== "worktree" || !this.task.worktree?.branch) {
+      return;
+    }
+    const settings = this.store.getSettings();
+    if (!settings.taskSettings.renameBranchOnNameGeneration) {
+      return;
+    }
+    const oldBranch = this.task.worktree.branch;
+    const newBranch = this.generateBranchName();
+    if (oldBranch === newBranch) {
+      return;
+    }
+    await this.renameWorktreeBranch(newBranch);
+  }
+  /**
+   * @deprecated This migration ensures older task data has the `branch` field
+   * and `baseBranch` stores the branch the worktree was created from.
+   * Can be removed once all users have migrated past v0.64.0.
+   */
+  async migrateWorktreeData() {
+    if (!this.task.worktree || this.task.worktree.branch) {
+      return;
+    }
+    const currentBranch = this.task.worktree.baseBranch;
+    this.task.worktree.branch = currentBranch;
+    let resolvedBase = "";
+    if (this.task.worktree.baseCommit) {
+      const branches = await this.worktreeManager.getBranchesContainingCommit(this.project.baseDir, this.task.worktree.baseCommit);
+      if (branches.length === 1) {
+        resolvedBase = branches[0];
+      }
+    }
+    if (!resolvedBase) {
+      try {
+        resolvedBase = await this.worktreeManager.getProjectMainBranch(this.project.baseDir);
+      } catch {
+        resolvedBase = "";
+      }
+    }
+    this.task.worktree.baseBranch = resolvedBase || void 0;
+    await this.saveTask({ worktree: this.task.worktree });
   }
   isInternal() {
     return this.taskId === INTERNAL_TASK_ID;
@@ -14343,14 +14881,18 @@ class Task {
           worktreePath: this.task.worktree.path
         });
       } else {
-        const branchName = this.generateBranchName();
-        this.task.worktree = await this.worktreeManager.createWorktree(this.project.baseDir, this.taskId, branchName);
+        await this.initWorktree();
         void this.sendUpdatedFilesUpdated();
+        void this.sendWorktreeIntegrationStatusUpdated();
       }
     } else if (workingMode === "local") {
       if (existingWorktree) {
-        await this.worktreeManager.removeWorktree(this.project.baseDir, existingWorktree);
+        const isShared = this.project.isWorktreeSharedWithOtherTasks(existingWorktree.path, this.taskId);
+        if (!isShared) {
+          await this.worktreeManager.removeWorktree(this.project.baseDir, existingWorktree);
+        }
         void this.sendUpdatedFilesUpdated();
+        void this.sendWorktreeIntegrationStatusUpdated();
       }
     } else {
       logger.debug("Empty workingMode, setting to local", {
@@ -14367,6 +14909,7 @@ class Task {
         this.task.workingMode = "local";
       }
     }
+    await this.migrateWorktreeData();
     if (await fileExists(this.getTaskDir())) {
       this.git = simpleGit.simpleGit(this.getTaskDir());
     }
@@ -14741,7 +15284,9 @@ class Task {
     await this.saveTask({
       name: this.task.name || this.getTaskNameFromPrompt(prompt || ""),
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      state: DefaultTaskState.InProgress
+      state: DefaultTaskState.InProgress,
+      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);
     if (agentMessages.length > 0) {
@@ -14752,6 +15297,7 @@ class Task {
     void this.sendRequestContextInfo();
     void this.sendWorktreeIntegrationStatusUpdated();
     void this.sendUpdatedFilesUpdated();
+    void this.sendSkillsUpdated();
     this.resolveAgentRunPromises();
     if (waitForCurrentAgentToFinish) {
       await this.runNextQueuedPrompt();
@@ -14782,14 +15328,11 @@ class Task {
     const settings = this.store.getSettings();
     if (settings.taskSettings.autoGenerateTaskName) {
       this.generateTaskNameInBackground(prompt).then((taskName) => {
-        if (taskName) {
-          void this.saveTask({ name: taskName });
-        } else {
-          void this.saveTask({ name: fallbackName });
-        }
+        const newName = taskName || fallbackName;
+        void this.saveTask({ name: newName }).then(() => this.renameWorktreeBranchIfNeeded());
       }).catch((error) => {
         logger.warn("Failed to generate task name:", error);
-        void this.saveTask({ name: fallbackName });
+        void this.saveTask({ name: fallbackName }).then(() => this.renameWorktreeBranchIfNeeded());
       });
       return "<<generating>>";
     } else {
@@ -15565,10 +16108,10 @@ ${contentText}</agent-response>`;
       return contextFiles;
     }
     const profile = await this.getTaskAgentProfile();
-    const ruleFiles = await this.getRuleFilesAsContextFiles(profile || void 0);
+    const ruleFiles = await this.getRuleFilesAsContextFiles(profile || void 0, true);
     return [...contextFiles, ...ruleFiles];
   }
-  async getRuleFilesAsContextFiles(profile) {
+  async getRuleFilesAsContextFiles(profile, includeDisabled = false) {
     const ruleFiles = [];
     const homeDir = os.homedir();
     if (await fileExists(AIDER_DESK_GLOBAL_RULES_DIR)) {
@@ -15639,7 +16182,8 @@ ${contentText}</agent-response>`;
       }
     }
     const extensionResult = await this.extensionManager.dispatchEvent("onRuleFilesRetrieved", { files: ruleFiles }, this.project, this);
-    return extensionResult.files;
+    const disabledRuleFiles = this.project.getProjectSettings().disabledRuleFiles ?? [];
+    return includeDisabled ? extensionResult.files : extensionResult.files.filter((f) => !disabledRuleFiles.includes(f.path));
   }
   getRepoMap() {
     return this.aiderManager.getRepoMap();
@@ -15668,6 +16212,92 @@ ${contentText}</agent-response>`;
   getContextMessages() {
     return this.contextManager.getContextMessages();
   }
+  getSkillManager() {
+    return this.skillManager;
+  }
+  async getSkills() {
+    const contextMessages = await this.contextManager.getContextMessages();
+    return this.skillManager.getSkills(contextMessages);
+  }
+  async activateSkill(skillName) {
+    const contextMessages = await this.contextManager.getContextMessages();
+    const activatedNames = this.skillManager.getActivatedSkillNames(contextMessages);
+    if (activatedNames.has(skillName)) {
+      logger.debug("Skill already activated, skipping", { skillName });
+      return;
+    }
+    const content = await this.skillManager.getSkillContent(skillName);
+    if (!content) {
+      throw new Error(`Skill '${skillName}' not found`);
+    }
+    const [assistantMessage, toolMessage] = this.skillManager.buildActivateSkillMessages(skillName, content);
+    this.contextManager.addContextMessage(assistantMessage);
+    this.contextManager.addContextMessage(toolMessage);
+    await this.processResponseMessage(
+      {
+        id: assistantMessage.id,
+        action: "response",
+        content: "User requested the skill activation.",
+        finished: true
+      },
+      false
+    );
+    const toolCallId = toolMessage.content[0].toolCallId;
+    this.addToolMessage(
+      toolCallId,
+      SKILLS_TOOL_GROUP_NAME,
+      SKILLS_TOOL_ACTIVATE_SKILL,
+      { skill: skillName },
+      JSON.stringify(content),
+      void 0,
+      void 0,
+      false,
+      true
+    );
+    await this.updateContextInfo();
+  }
+  async deactivateSkill(skillName) {
+    const contextMessages = await this.contextManager.getContextMessages();
+    const toolName = `${SKILLS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}${SKILLS_TOOL_ACTIVATE_SKILL}`;
+    for (let i = contextMessages.length - 1; i >= 0; i--) {
+      const message = contextMessages[i];
+      if (message.role === "assistant" && Array.isArray(message.content)) {
+        const toolCallPart = message.content.find(
+          (part) => part.type === "tool-call" && part.toolName === toolName && part.input?.skill === skillName
+        );
+        if (!toolCallPart || toolCallPart.type !== "tool-call") {
+          continue;
+        }
+        const toolCallId = toolCallPart.toolCallId;
+        const toolMessage = contextMessages.find(
+          (msg) => msg.role === "tool" && Array.isArray(msg.content) && msg.content.some((part) => part.type === "tool-result" && part.toolCallId === toolCallId)
+        );
+        const removedIds = [];
+        const idsToRemoveFromContext = [];
+        if (toolMessage) {
+          removedIds.push(toolMessage.id);
+          removedIds.push(toolCallId);
+          idsToRemoveFromContext.push(toolMessage.id);
+        }
+        const otherToolCalls = message.content.filter((part) => part.type === "tool-call" && part !== toolCallPart);
+        if (otherToolCalls.length > 0) {
+          this.contextManager.removeMessageById(toolCallId);
+        } else {
+          removedIds.push(message.id);
+          idsToRemoveFromContext.push(message.id);
+          this.contextManager.removeMessagesByIds(idsToRemoveFromContext);
+        }
+        if (removedIds.length > 0) {
+          await this.reloadConnectorMessages();
+          await this.updateContextInfo();
+          void this.sendSkillsUpdated();
+        }
+        return removedIds;
+      }
+    }
+    logger.debug(`No activation found for skill '${skillName}' to deactivate.`);
+    return [];
+  }
   async addRoleContextMessage(role, content, usageReport) {
     logger.debug("Adding role message to session:", {
       baseDir: this.project.baseDir,
@@ -15948,12 +16578,18 @@ ${contentText}</agent-response>`;
     const removedIds = this.contextManager.removeMessageById(messageId);
     await this.reloadConnectorMessages();
     await this.updateContextInfo();
+    if (removedIds.length > 0) {
+      void this.sendSkillsUpdated();
+    }
     return removedIds;
   }
   async removeMessagesUpTo(messageId) {
     const removedIds = this.contextManager.removeMessagesAfter(messageId);
     await this.reloadConnectorMessages();
     await this.updateContextInfo();
+    if (removedIds.length > 0) {
+      void this.sendSkillsUpdated();
+    }
     return removedIds;
   }
   sendTaskMessageRemoved(messageIds) {
@@ -15961,26 +16597,27 @@ ${contentText}</agent-response>`;
       this.eventManager.sendTaskMessageRemoved(this.project.baseDir, this.taskId, messageIds);
     }
   }
-  async redoLastUserPrompt(mode, updatedPrompt) {
-    logger.info("Redoing last user prompt:", {
+  async redoUserPrompt(messageId, mode, updatedPrompt) {
+    logger.info("Redoing user prompt:", {
       baseDir: this.project.baseDir,
+      messageId,
       mode,
       hasUpdatedPrompt: !!updatedPrompt
     });
-    const removedMessages = this.contextManager.removeMessagesUpToLastUserMessage();
-    const originalLastUserMessage = removedMessages.findLast((msg) => msg.role === MessageRole.User);
-    if (!originalLastUserMessage) {
-      logger.warn("Could not find original last user message content to redo.");
+    const removedMessages = this.contextManager.removeMessagesUpToUserMessage(messageId);
+    const originalUserMessage = removedMessages[0];
+    if (!originalUserMessage || originalUserMessage.role !== MessageRole.User) {
+      logger.warn("Could not find the specified user message to redo.", { messageId });
       return;
     }
-    const promptToRun = updatedPrompt ?? originalLastUserMessage.content;
+    const promptToRun = updatedPrompt ?? 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(0, -1).map((msg) => msg.id));
+      this.sendTaskMessageRemoved(removedMessages.slice(1).map((msg) => msg.id));
       await this.updateContextInfo();
-      void this.runPrompt(promptToRun, mode, false, originalLastUserMessage.id);
+      void this.runPrompt(promptToRun, mode, false, originalUserMessage.id);
     } else {
       logger.warn("Could not find a previous user message to redo or an updated prompt to run.");
     }
@@ -16007,7 +16644,7 @@ ${contentText}</agent-response>`;
       if (lastMessage && lastMessage.role === MessageRole.User) {
         logger.info("Last message is from user, redoing prompt");
         this.addLogMessage("loading", "Resuming task...");
-        void this.redoLastUserPrompt(mode);
+        void this.redoUserPrompt(lastMessage.id, mode);
       } else {
         logger.info("Last message is not from user, sending Continue prompt");
         void this.runPrompt("Continue", mode, false);
@@ -16320,12 +16957,16 @@ ${contentText}</agent-response>`;
     const aiderWatchFilesChanged = oldSettings.aider.watchFiles !== newSettings?.aider.watchFiles;
     const aiderCachingEnabledChanged = oldSettings.aider.cachingEnabled !== newSettings?.aider.cachingEnabled;
     const aiderConfirmBeforeEditChanged = oldSettings.aider.confirmBeforeEdit !== newSettings?.aider.confirmBeforeEdit;
+    const proxyChanged = oldSettings.proxy?.enabled !== newSettings.proxy?.enabled || oldSettings.proxy?.url !== newSettings.proxy?.url;
     if ((aiderOptionsChanged || aiderAutoCommitsChanged || aiderWatchFilesChanged || aiderCachingEnabledChanged || aiderConfirmBeforeEditChanged) && await this.shouldStartAider()) {
       logger.debug("Aider options changed, restarting Aider.");
       void this.aiderManager.start(true);
-    } else if (aiderEnvVarsChanged) {
+    } else if (aiderEnvVarsChanged || proxyChanged) {
       logger.debug("Aider environment variables changed, updating connectors.");
-      const updatedEnvironmentVariables = getEnvironmentVariablesForAider(newSettings, this.project.baseDir);
+      const updatedEnvironmentVariables = {
+        ...getEnvironmentVariablesForAider(newSettings, this.project.baseDir),
+        ...getProxyEnvVars(newSettings)
+      };
       this.sendUpdateEnvVars(updatedEnvironmentVariables);
     }
   }
@@ -16335,9 +16976,13 @@ ${contentText}</agent-response>`;
   async projectSettingsChanged(oldSettings, newSettings) {
     const modeChanged = oldSettings.currentMode !== newSettings.currentMode;
     const agentProfileIdChanged = oldSettings.agentProfileId !== newSettings.agentProfileId;
-    if (agentProfileIdChanged || modeChanged) {
+    const disabledRulesChanged = JSON.stringify(oldSettings.disabledRuleFiles) !== JSON.stringify(newSettings.disabledRuleFiles);
+    if (agentProfileIdChanged || modeChanged || disabledRulesChanged) {
       void this.sendContextFilesUpdated();
     }
+    if (disabledRulesChanged) {
+      void this.updateAgentEstimatedTokens();
+    }
   }
   sendUpdateEnvVars(environmentVariables) {
     this.aiderManager.sendUpdateEnvVars(environmentVariables);
@@ -16614,6 +17259,18 @@ ${error.stderr}`,
     });
     this.eventManager.sendUpdatedFilesUpdated(this.project.baseDir, this.taskId, updatedFiles);
   }
+  async sendSkillsUpdated() {
+    const skills = await this.getSkills();
+    this.eventManager.sendSkillsUpdated(this.project.baseDir, this.taskId, skills);
+  }
+  async initWorktree() {
+    const branchName = this.generateBranchName();
+    this.task.worktree = await this.worktreeManager.createWorktree(this.project.baseDir, this.taskId, branchName);
+    const settings = this.store.getSettings();
+    if (settings.taskSettings.worktreeSymlinkFolders && settings.taskSettings.worktreeSymlinkFolders.length > 0) {
+      await this.worktreeManager.createSymlinks(this.project.baseDir, this.task.worktree.path, settings.taskSettings.worktreeSymlinkFolders);
+    }
+  }
   async applyWorkingMode(mode) {
     logger.info("Applying workingMode configuration", {
       baseDir: this.project.baseDir,
@@ -16624,17 +17281,15 @@ ${error.stderr}`,
     const currentWorktree = await this.worktreeManager.getTaskWorktree(this.project.baseDir, this.taskId);
     if (mode === "worktree") {
       if (!currentWorktree) {
-        const branchName = this.generateBranchName();
-        this.task.worktree = await this.worktreeManager.createWorktree(this.project.baseDir, this.taskId, branchName);
-        const settings = this.store.getSettings();
-        if (settings.taskSettings.worktreeSymlinkFolders && settings.taskSettings.worktreeSymlinkFolders.length > 0) {
-          await this.worktreeManager.createSymlinks(this.project.baseDir, this.task.worktree.path, settings.taskSettings.worktreeSymlinkFolders);
-        }
+        await this.initWorktree();
       }
       this.task.workingMode = mode;
     } else if (mode === "local") {
       if (currentWorktree) {
-        await this.worktreeManager.removeWorktree(this.project.baseDir, currentWorktree);
+        const isShared = this.project.isWorktreeSharedWithOtherTasks(currentWorktree.path, this.taskId);
+        if (!isShared) {
+          await this.worktreeManager.removeWorktree(this.project.baseDir, currentWorktree);
+        }
       }
       this.task.worktree = void 0;
       this.task.lastMergeState = void 0;
@@ -16706,7 +17361,8 @@ Only answer with the commit message, nothing else.`,
         squash,
         effectiveCommitMessage || this.task.name || `Task ${this.taskId} changes`,
         targetBranch,
-        symlinkFolders
+        symlinkFolders,
+        this.task.worktree.baseCommit
       );
       await this.saveTask({ lastMergeState: mergeState });
       this.addLogMessage(
@@ -16728,6 +17384,47 @@ Only answer with the commit message, nothing else.`,
     await this.sendUpdatedFilesUpdated();
     await this.sendWorktreeIntegrationStatusUpdated();
   }
+  async mergeAndSwitchToLocal(targetBranch) {
+    if (!this.task.worktree) {
+      throw new Error("No worktree exists for this task");
+    }
+    logger.info("Merging worktree and switching to local mode", {
+      baseDir: this.project.baseDir,
+      taskId: this.taskId
+    });
+    await this.waitForCurrentPromptToFinish();
+    try {
+      const effectiveTargetBranch = targetBranch || await this.worktreeManager.getProjectMainBranch(this.project.baseDir);
+      this.addLogMessage("loading", `Merging worktree to ${effectiveTargetBranch} branch and switching to local mode...`);
+      const settings = this.store.getSettings();
+      const symlinkFolders = settings.taskSettings.worktreeSymlinkFolders || [];
+      const mergeState = await this.worktreeManager.mergeWorktreeToMainWithUncommitted(
+        this.project.baseDir,
+        this.task.id,
+        this.task.worktree.path,
+        false,
+        this.task.name || `Task ${this.taskId} changes`,
+        targetBranch,
+        symlinkFolders
+      );
+      await this.saveTask({ lastMergeState: mergeState });
+      this.addLogMessage("info", `Successfully merged worktree to ${effectiveTargetBranch} branch`, true);
+      await this.updateTask({ workingMode: "local" });
+    } catch (error) {
+      logger.error("Failed to merge worktree and switch to local:", { error });
+      const isConflict = error instanceof GitError && (error.gitOutput?.toLowerCase().includes("resolve all conflicts") || error.message?.toLowerCase().includes("conflicts must be resolved first") || error.gitOutput?.toLowerCase().includes("conflicts must be resolved first"));
+      this.addLogMessage(
+        "error",
+        isConflict ? "worktree.mergeConflicts" : error instanceof GitError ? error.getErrorDetails() : `Failed to merge worktree: ${error instanceof Error ? error.message : String(error)}`,
+        true,
+        void 0,
+        isConflict ? ["rebase-worktree"] : void 0
+      );
+      await this.sendUpdatedFilesUpdated();
+      await this.sendWorktreeIntegrationStatusUpdated();
+      throw error;
+    }
+  }
   async applyUncommittedChanges(targetBranch) {
     if (!this.task.worktree) {
       throw new Error("No worktree exists for this task");
@@ -16857,10 +17554,18 @@ ${diff}
       taskId: this.taskId,
       amend
     });
+    const beforeResult = await this.extensionManager.dispatchEvent("onBeforeCommit", { message, amend }, this.project, this);
+    if (beforeResult.blocked) {
+      logger.debug("Commit blocked by extension");
+      return;
+    }
+    message = beforeResult.message;
+    amend = beforeResult.amend;
     const taskDir = this.getTaskDir();
     await this.worktreeManager.commitChanges(taskDir, message, amend);
     await this.sendUpdatedFilesUpdated();
     await this.sendWorktreeIntegrationStatusUpdated();
+    await this.extensionManager.dispatchEvent("onAfterCommit", { message, amend }, this.project, this);
   }
   async getWorktreeIntegrationStatus(targetBranch) {
     if (!this.task.worktree) {
@@ -16868,12 +17573,16 @@ ${diff}
     }
     const effectiveTargetBranch = targetBranch || await this.worktreeManager.getProjectMainBranch(this.project.baseDir);
     const worktreePath = this.task.worktree.path;
+    const settings = this.store.getSettings();
+    const symlinkFolders = settings.taskSettings.worktreeSymlinkFolders || [];
     const [unmergedWork, predictedConflicts, rebaseState] = await Promise.all([
-      this.worktreeManager.checkWorktreeForUnmergedWork(this.project.baseDir, worktreePath, effectiveTargetBranch),
+      this.worktreeManager.checkWorktreeForUnmergedWork(this.project.baseDir, worktreePath, effectiveTargetBranch, symlinkFolders),
       this.worktreeManager.checkForRebaseConflicts(worktreePath, effectiveTargetBranch),
       this.worktreeManager.getRebaseState(worktreePath)
     ]);
     return {
+      currentBranch: this.task.worktree.branch || "",
+      baseBranch: this.task.worktree.baseBranch || "",
       targetBranch: effectiveTargetBranch,
       aheadCommits: {
         count: unmergedWork.unmergedCommitCount,
@@ -16900,22 +17609,24 @@ ${diff}
     await this.waitForCurrentPromptToFinish();
     try {
       this.addLogMessage("loading", `Rebasing worktree from ${effectiveFromBranch}...`);
-      const { success, error } = await this.worktreeManager.rebaseMainIntoWorktree(this.task.worktree.path, effectiveFromBranch);
+      const { success, error } = await this.worktreeManager.rebaseMainIntoWorktree(this.task.worktree.path, effectiveFromBranch, this.task.worktree.baseCommit);
       if (success) {
+        const newHead = await this.worktreeManager.getHeadCommit(this.task.worktree.path);
+        if (newHead) {
+          await this.saveTask({ worktree: { ...this.task.worktree, baseCommit: newHead, baseBranch: effectiveFromBranch } });
+        }
         this.addLogMessage("info", "Worktree rebased successfully", true);
         return;
       }
       if (error) {
+        this.addLogMessage("loading", void 0, true);
         const isConflict = error.gitOutput?.includes("Resolve all conflicts");
-        this.addLogMessage(
-          "error",
-          isConflict ? "worktree.rebaseConflicts" : error.getErrorDetails(),
-          true,
-          void 0,
-          isConflict ? ["abort-rebase", "resolve-conflicts-with-agent"] : void 0
-        );
+        if (!isConflict) {
+          this.addLogMessage("error", error.getErrorDetails(), true);
+        }
       }
     } catch (error) {
+      this.addLogMessage("loading", void 0, true);
       logger.error("Failed to rebase worktree:", {
         error: error instanceof Error ? error.message : String(error)
       });
@@ -16944,11 +17655,26 @@ ${diff}
     await this.sendUpdatedFilesUpdated();
     await this.sendWorktreeIntegrationStatusUpdated();
   }
+  async renameWorktreeBranch(newBranchName) {
+    if (!this.task.worktree) {
+      throw new Error("No worktree exists for this task");
+    }
+    const oldBranchName = this.task.worktree.branch;
+    if (!oldBranchName) {
+      throw new Error("Cannot determine current branch name");
+    }
+    const actualBranchName = await this.worktreeManager.renameBranch(this.project.baseDir, oldBranchName, newBranchName);
+    this.task.worktree.branch = actualBranchName;
+    await this.saveTask({ worktree: this.task.worktree });
+    void this.sendWorktreeIntegrationStatusUpdated();
+  }
   async executeConflictResolution(directoryPath, directoryName) {
     const activeProfile = await this.getTaskAgentProfile();
     if (!activeProfile) {
       throw new Error("No active agent profile found");
     }
+    const previousTaskState = this.task.state;
+    await this.saveTask({ state: DefaultTaskState.InProgress });
     try {
       this.addLogMessage("loading", `Resolving conflicts in ${directoryName}...`);
       const files = await this.worktreeManager.listConflictedFiles(directoryPath);
@@ -17033,13 +17759,8 @@ ${diff}
         }
       });
       await Promise.all(resolutionPromises);
-      if (interruptedCount === 0) {
-        this.addLogMessage("info", "Conflicts resolved and staged. You can now continue the rebase.", true, void 0, ["continue-rebase", "abort-rebase"]);
-      } else if (interruptedCount < files.length) {
-        this.addLogMessage("warning", "Some conflicts were resolved, but some were interrupted. You can continue the rebase.", true, void 0, [
-          "continue-rebase",
-          "abort-rebase"
-        ]);
+      if (interruptedCount > 0 && interruptedCount < files.length) {
+        this.addLogMessage("warning", "Some conflicts were resolved, but some were interrupted. You can continue the rebase.", true, void 0, []);
       }
     } catch (error) {
       logger.error("Failed to resolve conflicts with agent:", error);
@@ -17048,6 +17769,8 @@ ${diff}
         error instanceof GitError ? error.getErrorDetails() : `Failed to resolve conflicts with agent: ${error instanceof Error ? error.message : String(error)}`,
         true
       );
+    } finally {
+      await this.saveTask({ state: previousTaskState });
     }
     await this.sendWorktreeIntegrationStatusUpdated();
   }
@@ -17084,17 +17807,17 @@ ${diff}
       this.addLogMessage("loading", "Continuing rebase...");
       await this.worktreeManager.continueRebase(this.task.worktree.path);
       await this.saveTask({ lastMergeState: void 0 });
-      this.addLogMessage("info", "Rebase continued", true);
+      this.addLogMessage("info", "Rebase completed", true);
     } catch (error) {
       logger.error("Failed to continue rebase:", error);
       const isConflict = error instanceof GitError && error.gitOutput?.includes("Resolve all conflicts manually");
-      this.addLogMessage(
-        "error",
-        isConflict ? "worktree.rebaseConflicts" : error instanceof GitError ? error.getErrorDetails() : `Failed to continue rebase: ${error instanceof Error ? error.message : String(error)}`,
-        true,
-        void 0,
-        isConflict ? ["abort-rebase", "resolve-conflicts-with-agent"] : void 0
-      );
+      if (!isConflict) {
+        this.addLogMessage(
+          "error",
+          error instanceof GitError ? error.getErrorDetails() : `Failed to continue rebase: ${error instanceof Error ? error.message : String(error)}`,
+          true
+        );
+      }
     }
     await this.sendUpdatedFilesUpdated();
     await this.sendWorktreeIntegrationStatusUpdated();
@@ -17158,50 +17881,53 @@ ${diff}
   async generateText(modelId, systemPrompt, prompt) {
     return this.agent.generateText(modelId, systemPrompt, prompt, this.getProjectDir());
   }
-  async runCodeInlineRequest(filename, lineNumber, userComment, createNewTask, contextSize = 5) {
-    const filePath = path.isAbsolute(filename) ? filename : path.join(this.getTaskDir(), filename);
-    const fileExtension = path.extname(filename).slice(1) || "";
-    let contextLines = [];
-    try {
-      const fileContent = await fs.readFile(filePath, "utf-8");
-      const lines = fileContent.split("\n");
-      const startLine = Math.max(0, lineNumber - contextSize - 1);
-      const endLine = Math.min(lines.length, lineNumber + contextSize);
-      contextLines = lines.slice(startLine, endLine).map((content, index) => ({
-        lineNumber: startLine + index + 1,
-        content
-      }));
-    } catch (error) {
-      logger.warn("Failed to read file for context extraction", {
-        filePath,
-        error
-      });
-    }
-    const prompt = await this.promptsManager.getCodeInlineRequestPrompt(this, {
-      filename,
-      lineNumber,
-      fileExtension,
-      contextLines,
-      userComment
-    });
+  async runCodeChangeRequests(requests, contextSize = 5, createNewTask) {
     const mode = this.getCurrentMode();
+    const promptRequests = await Promise.all(
+      requests.map(async (request) => {
+        const filePath = path.isAbsolute(request.filename) ? request.filename : path.join(this.getTaskDir(), request.filename);
+        const fileExtension = path.extname(request.filename).slice(1) || "";
+        let contextLines = [];
+        try {
+          const fileContent = await fs.readFile(filePath, "utf-8");
+          const lines = fileContent.split("\n");
+          const startLine = Math.max(0, request.lineNumber - contextSize - 1);
+          const endLine = Math.min(lines.length, request.lineNumber + contextSize);
+          contextLines = lines.slice(startLine, endLine).map((content, index) => ({
+            lineNumber: startLine + index + 1,
+            content
+          }));
+        } catch (error) {
+          logger.warn("Failed to read file for context extraction", {
+            filePath,
+            error
+          });
+        }
+        return {
+          filename: request.filename,
+          lineNumber: request.lineNumber,
+          fileExtension,
+          contextLines,
+          userComment: request.userComment
+        };
+      })
+    );
+    const prompt = await this.promptsManager.getCodeChangeRequestsPrompt(this, {
+      requests: promptRequests
+    });
     if (!createNewTask) {
+      const uniqueFiles = [...new Set(requests.map((r) => r.filename))];
       if (AIDER_MODES.includes(mode)) {
-        await this.addFiles({
-          path: filename
-        });
+        for (const filename of uniqueFiles) {
+          await this.addFiles({ path: filename });
+        }
       }
       void this.runPrompt(prompt, mode, false);
       return;
     }
-    this.eventManager.sendLog({
-      baseDir: this.project.baseDir,
-      taskId: INTERNAL_TASK_ID,
-      level: "loading",
-      message: "Creating task for inline code request..."
-    });
+    const taskName = requests.length === 1 ? `${requests[0].filename}:${requests[0].lineNumber}` : `${requests.length} change requests`;
     const newTaskData = await this.project.createNewTask({
-      name: `${filename}:${lineNumber}`,
+      name: taskName,
       sendEvent: false,
       autoApprove: true,
       activate: true,
@@ -17215,9 +17941,10 @@ ${diff}
     }
     await newTask.init();
     if (AIDER_MODES.includes(mode)) {
-      await newTask.addFiles({
-        path: filename
-      });
+      const uniqueFiles = [...new Set(requests.map((r) => r.filename))];
+      for (const filename of uniqueFiles) {
+        await newTask.addFiles({ path: filename });
+      }
     }
     this.eventManager.sendTaskCreated(newTask.task, true);
     void newTask.runPrompt(prompt, mode, false);
@@ -17379,6 +18106,9 @@ class Project {
       if (!parentTask) {
         throw new Error(`Parent task with id ${normalizedParams.parentId} not found`);
       }
+      if (!parentTask.task.createdAt) {
+        await parentTask.saveTask();
+      }
     }
     const sourceTask = parentTask || this.getMostRecentTask();
     const defaultWorkingMode = this.store.getSettings().taskSettings.defaultWorkingMode || "local";
@@ -17603,6 +18333,17 @@ class Project {
   getAgentProfiles() {
     return this.agentProfileManager.getProjectProfiles(this);
   }
+  /**
+   * Checks if any other task (excluding the specified taskId) uses the given worktree path.
+   */
+  isWorktreeSharedWithOtherTasks(worktreePath, excludeTaskId) {
+    for (const [id, task] of this.tasks.entries()) {
+      if (id !== excludeTaskId && task.task.worktree?.path === worktreePath) {
+        return true;
+      }
+    }
+    return false;
+  }
   async deleteTaskInternal(taskId) {
     const taskDir = path.join(this.baseDir, ".aider-desk", "tasks", taskId);
     const task = this.tasks.get(taskId);
@@ -17611,6 +18352,19 @@ class Project {
       this.tasks.delete(taskId);
       this.eventManager.sendTaskDeleted(task.task);
     }
+    const taskData = task?.task;
+    if (taskData?.worktree && !this.isWorktreeSharedWithOtherTasks(taskData.worktree.path, taskId)) {
+      try {
+        await this.worktreeManager.removeWorktree(this.baseDir, taskData.worktree);
+      } catch (error) {
+        logger.warn("Failed to remove worktree during task deletion", {
+          baseDir: this.baseDir,
+          taskId,
+          worktreePath: taskData.worktree.path,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
     await fs.rm(taskDir, { recursive: true, force: true });
   }
   async deleteTask(taskId) {
@@ -17645,8 +18399,12 @@ class Project {
     if (!sourceTask) {
       throw new Error(`Task with id ${taskId} not found`);
     }
+    const hasWorktree = sourceTask.task.worktree && sourceTask.task.workingMode === "worktree";
     const newTask = await this.prepareTask(void 0, {
       ...sourceTask.task,
+      // When the source task has a worktree, make the duplicate a subtask
+      // so both tasks sharing the same worktree are clearly related
+      ...hasWorktree ? { parentId: sourceTask.task.parentId || taskId } : {},
       state: sourceTask.task.state === DefaultTaskState.InProgress ? DefaultTaskState.Todo : sourceTask.task.state
     });
     await newTask.init();
@@ -17858,6 +18616,15 @@ class EventManager {
     this.sendToWindows("updated-files-updated", data);
     this.broadcastToEventConnectors("updated-files-updated", data);
   }
+  sendSkillsUpdated(baseDir, taskId, skills) {
+    const data = {
+      baseDir,
+      taskId,
+      skills
+    };
+    this.sendToWindows("skills-updated", data);
+    this.broadcastToEventConnectors("skills-updated", data);
+  }
   // Response events
   sendResponseChunk(data) {
     this.sendToWindows("response-chunk", data);
@@ -18361,8 +19128,7 @@ const loadAnthropicCompatibleModels = async (profile, settings) => {
     const models = data.data?.map((model) => {
       return {
         id: model.id,
-        providerId: profile.id,
-        temperature: DEFAULT_MODEL_TEMPERATURE
+        providerId: profile.id
       };
     }) || [];
     logger.info(`Loaded ${models.length} Anthropic-compatible models for profile ${profile.id}`);
@@ -18475,6 +19241,11 @@ const AUGGIE_MODELS = [
     maxInputTokens: 2e5,
     maxOutputTokensLimit: 32768
   },
+  {
+    id: "claude-opus-4-7",
+    maxInputTokens: 2e5,
+    maxOutputTokensLimit: 32768
+  },
   { id: "gpt-5-1", maxInputTokens: 2e5, maxOutputTokensLimit: 16384 },
   { id: "gpt-5-2", maxInputTokens: 2e5, maxOutputTokensLimit: 16384 },
   { id: "gpt-5-4", maxInputTokens: 2e5, maxOutputTokensLimit: 16384 }
@@ -18786,8 +19557,7 @@ const loadBedrockModels = async (profile, settings) => {
       if (response.authorizationStatus === "AUTHORIZED" && response.entitlementAvailability === "AVAILABLE" && response.regionAvailability === "AVAILABLE") {
         availableModels.push({
           id: inferenceProfile.inferenceProfileId,
-          providerId: profile.id,
-          temperature: DEFAULT_MODEL_TEMPERATURE
+          providerId: profile.id
         });
         logger.debug(`Profile ${inferenceProfile.inferenceProfileId} with model ${modelId} is available and authorized`);
       } else {
@@ -18941,8 +19711,7 @@ const loadCerebrasModels = async (profile, settings) => {
       return {
         id: model.id,
         providerId: profile.id,
-        maxInputTokens: model.max_context_length,
-        temperature: DEFAULT_MODEL_TEMPERATURE
+        maxInputTokens: model.max_context_length
       };
     }) || [];
     logger.info(`Loaded ${models.length} Cerebras models for profile ${profile.id}`);
@@ -19212,8 +19981,7 @@ const loadDeepseekModels = async (profile, settings) => {
     const models = data.data?.map((m) => {
       return {
         id: m.id,
-        providerId: profile.id,
-        temperature: DEFAULT_MODEL_TEMPERATURE
+        providerId: profile.id
       };
     }) || [];
     logger.info(`Loaded ${models.length} DeepSeek models for profile ${profile.id}`);
@@ -19257,6 +20025,34 @@ const createDeepseekLlm = (profile, model, settings, projectDir) => {
   });
   return deepseekProvider(model.id);
 };
+const getDeepseekProviderOptions = (llmProvider, model) => {
+  if (!isDeepseekProvider(llmProvider)) {
+    return void 0;
+  }
+  const providerOverrides = model.providerOverrides;
+  const thinkingEnabled = providerOverrides?.thinkingEnabled ?? llmProvider.thinkingEnabled ?? true;
+  const reasoningEffort = providerOverrides?.reasoningEffort ?? llmProvider.reasoningEffort ?? "high";
+  return {
+    deepseek: {
+      thinking: { type: thinkingEnabled ? "enabled" : "disabled" },
+      ...thinkingEnabled && { reasoningEffort }
+    }
+  };
+};
+const getDeepseekProviderParameters = (llmProvider, model) => {
+  if (!isDeepseekProvider(llmProvider)) {
+    return {};
+  }
+  const providerOverrides = model.providerOverrides;
+  const thinkingEnabled = providerOverrides?.thinkingEnabled ?? llmProvider.thinkingEnabled ?? true;
+  if (thinkingEnabled) {
+    return {
+      temperature: void 0,
+      topP: void 0
+    };
+  }
+  return {};
+};
 const deepseekProviderStrategy = {
   // Core LLM functions
   createLlm: createDeepseekLlm,
@@ -19265,7 +20061,9 @@ const deepseekProviderStrategy = {
   loadModels: loadDeepseekModels,
   hasEnvVars: hasDeepseekEnvVars,
   getAiderMapping: getDeepseekAiderMapping,
-  getModelInfo: getDefaultModelInfo
+  getModelInfo: getDefaultModelInfo,
+  getProviderOptions: getDeepseekProviderOptions,
+  getProviderParameters: getDeepseekProviderParameters
 };
 const loadGeminiModels = async (profile, settings) => {
   if (!isGeminiProvider(profile.provider)) {
@@ -19619,8 +20417,7 @@ const loadGpustackModels = async (profile, settings) => {
         id: model.name,
         providerId: profile.id,
         // Extract max_model_len from meta if available
-        maxInputTokens: model.meta?.max_model_len,
-        temperature: DEFAULT_MODEL_TEMPERATURE
+        maxInputTokens: model.meta?.max_model_len
       };
     }) || [];
     logger.info(`Loaded ${models.length} GPUStack models for profile ${profile.id}`);
@@ -19740,8 +20537,7 @@ const loadGroqModels = async (profile, settings) => {
     const models = data.data?.map((model) => {
       return {
         id: model.id,
-        providerId: profile.id,
-        temperature: DEFAULT_MODEL_TEMPERATURE
+        providerId: profile.id
       };
     }) || [];
     logger.info(`Loaded ${models.length} Groq models for profile ${profile.id}`);
@@ -19892,7 +20688,6 @@ const alibabaPlanProviderStrategy = {
   getProviderOptions: getAlibabaPlanProviderOptions
 };
 const KIMI_PLAN_BASE_URL = "https://api.kimi.com/coding/v1";
-const KIMI_PLAN_MODEL_ID = "k2p5";
 const loadKimiPlanModels = async (profile, settings) => {
   if (!isKimiPlanProvider(profile.provider)) {
     return { models: [], success: false };
@@ -19906,7 +20701,19 @@ const loadKimiPlanModels = async (profile, settings) => {
   }
   const models = [
     {
-      id: KIMI_PLAN_MODEL_ID,
+      id: "kimi-k2-thinking",
+      providerId: profile.id,
+      maxInputTokens: 262144,
+      maxOutputTokensLimit: 32768
+    },
+    {
+      id: "k2p5",
+      providerId: profile.id,
+      maxInputTokens: 262144,
+      maxOutputTokensLimit: 32768
+    },
+    {
+      id: "k2p6",
       providerId: profile.id,
       maxInputTokens: 262144,
       maxOutputTokensLimit: 32768
@@ -20129,8 +20936,7 @@ const loadLmStudioModels = async (profile, settings) => {
       return {
         id: model.id,
         providerId: profile.id,
-        maxInputTokens: model.max_context_length,
-        temperature: DEFAULT_MODEL_TEMPERATURE
+        maxInputTokens: model.max_context_length
       };
     }) || [];
     logger.info(`Loaded ${models.length} LM Studio models from ${effectiveBaseUrl} for profile ${profile.id}`);
@@ -20210,7 +21016,63 @@ const loadMinimaxModels = async (profile) => {
   }
   const hardcodedModels = [
     {
-      id: "MiniMax-M2",
+      id: "MiniMax-M2.7",
+      providerId: profile.id,
+      maxInputTokens: 204800,
+      maxOutputTokensLimit: 131072,
+      inputCostPerToken: 3e-7,
+      // 0.3 per 1M tokens
+      outputCostPerToken: 12e-7,
+      // 1.2 per 1M tokens
+      cacheReadInputTokenCost: 6e-8,
+      // 0.06 per 1M tokens
+      cacheWriteInputTokenCost: 375e-9
+      // 0.375 per 1M tokens
+    },
+    {
+      id: "MiniMax-M2.7-highspeed",
+      providerId: profile.id,
+      maxInputTokens: 204800,
+      maxOutputTokensLimit: 131072,
+      inputCostPerToken: 6e-7,
+      // 0.6 per 1M tokens
+      outputCostPerToken: 24e-7,
+      // 2.4 per 1M tokens
+      cacheReadInputTokenCost: 6e-8,
+      // 0.06 per 1M tokens
+      cacheWriteInputTokenCost: 375e-9
+      // 0.375 per 1M tokens
+    },
+    {
+      id: "MiniMax-M2.5",
+      providerId: profile.id,
+      maxInputTokens: 204800,
+      maxOutputTokensLimit: 131072,
+      inputCostPerToken: 3e-7,
+      // 0.3 per 1M tokens
+      outputCostPerToken: 12e-7,
+      // 1.2 per 1M tokens
+      cacheReadInputTokenCost: 3e-8,
+      // 0.03 per 1M tokens
+      cacheWriteInputTokenCost: 375e-9
+      // 0.375 per 1M tokens
+    },
+    {
+      id: "MiniMax-M2.5-highspeed",
+      providerId: profile.id,
+      maxInputTokens: 204800,
+      maxOutputTokensLimit: 131072,
+      inputCostPerToken: 6e-7,
+      // 0.6 per 1M tokens
+      outputCostPerToken: 24e-7,
+      // 2.4 per 1M tokens
+      cacheReadInputTokenCost: 3e-8,
+      // 0.03 per 1M tokens
+      cacheWriteInputTokenCost: 375e-9
+      // 0.375 per 1M tokens
+    },
+    {
+      id: "MiniMax-M2.1",
       providerId: profile.id,
       maxInputTokens: 204800,
       maxOutputTokensLimit: 131072,
@@ -20220,12 +21082,25 @@ const loadMinimaxModels = async (profile) => {
       // 1.2 per 1M tokens
       cacheReadInputTokenCost: 3e-8,
       // 0.03 per 1M tokens
-      cacheWriteInputTokenCost: 4e-8,
-      // 0.04 per 1M tokens
-      temperature: 0.5
+      cacheWriteInputTokenCost: 375e-9
+      // 0.375 per 1M tokens
+    },
+    {
+      id: "MiniMax-M2.1-highspeed",
+      providerId: profile.id,
+      maxInputTokens: 204800,
+      maxOutputTokensLimit: 131072,
+      inputCostPerToken: 6e-7,
+      // 0.6 per 1M tokens
+      outputCostPerToken: 24e-7,
+      // 2.4 per 1M tokens
+      cacheReadInputTokenCost: 3e-8,
+      // 0.03 per 1M tokens
+      cacheWriteInputTokenCost: 375e-9
+      // 0.375 per 1M tokens
     },
     {
-      id: "MiniMax-M2-Stable",
+      id: "MiniMax-M2",
       providerId: profile.id,
       maxInputTokens: 204800,
       maxOutputTokensLimit: 131072,
@@ -20235,9 +21110,8 @@ const loadMinimaxModels = async (profile) => {
       // 1.2 per 1M tokens
       cacheReadInputTokenCost: 3e-8,
       // 0.03 per 1M tokens
-      cacheWriteInputTokenCost: 4e-8,
-      // 0.04 per 1M tokens
-      temperature: 0.5
+      cacheWriteInputTokenCost: 375e-9
+      // 0.375 per 1M tokens
     }
   ];
   return { models: hardcodedModels, success: true };
@@ -20333,6 +21207,90 @@ const minimaxProviderStrategy = {
   // Configuration helpers
   getCacheControl: getMinimaxCacheControl
 };
+const loadMistralModels = async (profile, settings) => {
+  if (!isMistralProvider(profile.provider)) {
+    return { models: [], success: false };
+  }
+  const provider = profile.provider;
+  const apiKey = provider.apiKey || "";
+  const apiKeyEnv = getEffectiveEnvironmentVariable("MISTRAL_API_KEY", settings);
+  const effectiveApiKey = apiKey || apiKeyEnv?.value || "";
+  if (!effectiveApiKey) {
+    const errorMsg = "Mistral API key is required. Please set it in Providers settings or via MISTRAL_API_KEY environment variable.";
+    logger.debug(errorMsg);
+    return { models: [], success: false };
+  }
+  try {
+    const response = await fetch("https://api.mistral.ai/v1/models", {
+      headers: { Authorization: `Bearer ${effectiveApiKey}` }
+    });
+    if (!response.ok) {
+      const errorMsg = `Mistral 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();
+    const models = data.data?.map((model) => {
+      return {
+        id: model.id,
+        providerId: profile.id,
+        temperature: 0.7
+      };
+    }) || [];
+    logger.info(`Loaded ${models.length} Mistral 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 Mistral models";
+    logger.error("Error loading Mistral models:", error);
+    return { models: [], success: false, error: errorMsg };
+  }
+};
+const hasMistralEnvVars = (settings) => {
+  return !!getEffectiveEnvironmentVariable("MISTRAL_API_KEY", settings, void 0)?.value;
+};
+const getMistralAiderMapping = (provider, modelId) => {
+  const mistralProvider = provider.provider;
+  const envVars = {};
+  if (mistralProvider.apiKey) {
+    envVars.MISTRAL_API_KEY = mistralProvider.apiKey;
+  }
+  return {
+    modelName: `mistral/${modelId}`,
+    environmentVariables: envVars
+  };
+};
+const createMistralLlm = (profile, model, settings, projectDir) => {
+  const provider = profile.provider;
+  let apiKey = provider.apiKey;
+  if (!apiKey) {
+    const effectiveVar = getEffectiveEnvironmentVariable("MISTRAL_API_KEY", settings, projectDir);
+    if (effectiveVar) {
+      apiKey = effectiveVar.value;
+      logger.debug(`Loaded MISTRAL_API_KEY from ${effectiveVar.source}`);
+    }
+  }
+  if (!apiKey) {
+    throw new Error("Mistral API key is required in Providers settings or Aider environment variables (MISTRAL_API_KEY)");
+  }
+  const mistralProvider = mistral.createMistral({
+    apiKey,
+    headers: profile.headers
+  });
+  return mistralProvider(model.id);
+};
+const mistralProviderStrategy = {
+  // Core LLM functions
+  createLlm: createMistralLlm,
+  getUsageReport: getDefaultUsageReport,
+  // Model discovery functions
+  loadModels: loadMistralModels,
+  hasEnvVars: hasMistralEnvVars,
+  getAiderMapping: getMistralAiderMapping,
+  getModelInfo: getDefaultModelInfo
+};
 const loadOllamaModels = async (profile, settings) => {
   if (!isOllamaProvider(profile.provider)) {
     return { models: [], success: false };
@@ -20359,8 +21317,7 @@ const loadOllamaModels = async (profile, settings) => {
     const models = data?.models?.map((m) => {
       return {
         id: m.name,
-        providerId: profile.id,
-        temperature: DEFAULT_MODEL_TEMPERATURE
+        providerId: profile.id
       };
     }) || [];
     logger.info(`Loaded ${models.length} Ollama models from ${effectiveBaseUrl} for profile ${profile.id}`);
@@ -20698,8 +21655,7 @@ const loadOpenaiCompatibleModels = async (profile, settings) => {
     const models = data.data?.map((model) => {
       return {
         id: model.id,
-        providerId: profile.id,
-        temperature: DEFAULT_MODEL_TEMPERATURE
+        providerId: profile.id
       };
     }) || [];
     logger.info(`Loaded ${models.length} OpenAI-compatible models for profile ${profile.id}`);
@@ -20818,7 +21774,7 @@ const getDefaultModelTemperature$2 = (modelId) => {
   if (modelId.includes("glm-")) {
     return 0.7;
   }
-  return DEFAULT_MODEL_TEMPERATURE;
+  return void 0;
 };
 const loadOpencodeModels = async (profile, settings) => {
   if (!isOpenCodeProvider(profile.provider)) {
@@ -20949,7 +21905,7 @@ const getDefaultModelTemperature$1 = (modelId) => {
   if (modelId.includes("qwen")) {
     return 0.55;
   }
-  return DEFAULT_MODEL_TEMPERATURE;
+  return void 0;
 };
 const loadOpenrouterModels = async (profile, settings) => {
   if (!isOpenRouterProvider(profile.provider)) {
@@ -21074,9 +22030,9 @@ const getOpenRouterUsageReport = (task, provider, model, usage, providerMetadata
     agentTotalCost: task.task.agentTotalCost + messageCost
   };
 };
-const getOpenRouterCacheControl = (profile, llmProvider) => {
+const getOpenRouterCacheControl = (llmProvider, model) => {
   if (isOpenRouterProvider(llmProvider)) {
-    if (profile.model?.startsWith("anthropic/")) {
+    if (model.id?.startsWith("anthropic/")) {
       return {
         providerOptions: {
           openrouter: {
@@ -21113,7 +22069,7 @@ const getDefaultModelTemperature = (modelId) => {
   if (modelId.includes("qwen")) {
     return 0.55;
   }
-  return DEFAULT_MODEL_TEMPERATURE;
+  return void 0;
 };
 const loadRequestyModels = async (profile, settings) => {
   if (!isRequestyProvider(profile.provider)) {
@@ -21265,9 +22221,9 @@ const normalizeRequestyMessages = (_provider, model, messages) => {
   }
   return messages;
 };
-const getRequestyCacheControl = (profile, llmProvider) => {
+const getRequestyCacheControl = (llmProvider, model) => {
   if (isRequestyProvider(llmProvider) && !llmProvider.useAutoCache) {
-    if (profile.model?.startsWith("anthropic/")) {
+    if (model.id?.startsWith("anthropic/")) {
       return {
         providerOptions: {
           requesty: {
@@ -21317,8 +22273,7 @@ const loadSyntheticModels = async (profile, settings) => {
     const models = data.data?.map((model) => {
       return {
         id: model.id,
-        providerId: profile.id,
-        temperature: DEFAULT_MODEL_TEMPERATURE
+        providerId: profile.id
       };
     }) || [];
     logger.info(`Loaded ${models.length} Synthetic models for profile ${profile.id}`);
@@ -21657,6 +22612,8 @@ const zaiPlanProviderStrategy = {
 };
 const MODELS_META_URL = "https://models.dev/api.json";
 const MODELS_FILE = path.join(AIDER_DESK_DATA_DIR, "models.json");
+const PROVIDER_MODELS_CACHE_FILE = path.join(AIDER_DESK_CACHE_DIR, "provider-models.json");
+const PROVIDER_MODELS_CACHE_VERSION = 1;
 class ModelManager {
   constructor(store, eventManager) {
     this.store = store;
@@ -21687,6 +22644,7 @@ class ModelManager {
     litellm: litellmProviderStrategy,
     lmstudio: lmStudioProviderStrategy,
     minimax: minimaxProviderStrategy,
+    mistral: mistralProviderStrategy,
     ollama: ollamaProviderStrategy,
     openai: openaiProviderStrategy,
     "openai-compatible": openaiCompatibleProviderStrategy,
@@ -21704,9 +22662,20 @@ class ModelManager {
       this.updateEnvVarsProviders();
       await this.loadModelsInfo();
       await this.loadModelOverrides();
-      await this.loadProviderModels(this.getProviders().filter((p) => !p.disabled));
+      const cacheLoaded = await this.loadProviderModelsFromCache();
+      if (cacheLoaded) {
+        this.eventManager.sendProviderModelsUpdated({
+          models: Object.values(this.providerModels).flat(),
+          loading: true,
+          errors: this.providerErrors
+        });
+        this.loadProviderModelsInBackground(this.getProviders().filter((p) => !p.disabled));
+      } else {
+        await this.loadProviderModels(this.getProviders().filter((p) => !p.disabled));
+      }
       logger.info("ModelInfoManager initialized successfully.", {
-        modelCount: Object.keys(this.modelsInfo).length
+        modelCount: Object.keys(this.modelsInfo).length,
+        cacheLoaded
       });
     } catch (error) {
       logger.error("Error initializing ModelInfoManager:", error);
@@ -21753,6 +22722,44 @@ class ModelManager {
       await freshDataPromise;
     }
   }
+  async loadProviderModelsFromCache() {
+    try {
+      const cacheData = await fs$1.promises.readFile(PROVIDER_MODELS_CACHE_FILE, "utf-8");
+      const cache = JSON.parse(cacheData);
+      if (cache.version !== PROVIDER_MODELS_CACHE_VERSION) {
+        logger.info("Provider models cache version mismatch, ignoring cache");
+        return false;
+      }
+      this.providerModels = cache.providerModels;
+      this.providerErrors = cache.providerErrors;
+      logger.info("Loaded provider models from cache", {
+        providerCount: Object.keys(cache.providerModels).length
+      });
+      return true;
+    } catch {
+      logger.info("Provider models cache not found or invalid");
+      return false;
+    }
+  }
+  async saveProviderModelsToCache() {
+    try {
+      const cache = {
+        version: PROVIDER_MODELS_CACHE_VERSION,
+        providerModels: this.providerModels,
+        providerErrors: this.providerErrors
+      };
+      await fs$1.promises.mkdir(AIDER_DESK_CACHE_DIR, { recursive: true });
+      await fs$1.promises.writeFile(PROVIDER_MODELS_CACHE_FILE, JSON.stringify(cache));
+      logger.info("Saved provider models to cache");
+    } catch (error) {
+      logger.error("Failed to save provider models to cache:", error);
+    }
+  }
+  loadProviderModelsInBackground(providers) {
+    this.loadProviderModels(providers).catch((error) => {
+      logger.error("Background loading of provider models failed:", error);
+    });
+  }
   processModelsMeta(data) {
     for (const providerId in data) {
       const providerData = data[providerId];
@@ -21795,6 +22802,21 @@ class ModelManager {
     }
     return Array.from(changed);
   }
+  async loadModelsWithRetry(strategy, profile, retryCount = 3) {
+    let lastResponse;
+    for (let attempt = 0; attempt <= retryCount; attempt++) {
+      if (attempt > 0) {
+        const delayMs = Math.pow(2, attempt - 1) * 1e3;
+        logger.info(`Retrying load models for provider profile ${profile.id} in ${delayMs}ms (attempt ${attempt + 1}/${retryCount + 1})`);
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+      lastResponse = await strategy.loadModels(profile, this.store.getSettings());
+      if (lastResponse.success) {
+        return lastResponse;
+      }
+    }
+    return lastResponse;
+  }
   async providersChanged(oldProviders, newProviders) {
     await this.initPromise;
     const removedProviders = oldProviders.filter((p) => !newProviders.find((np) => np.id === p.id));
@@ -21836,7 +22858,7 @@ class ModelManager {
               continue;
             }
             let providerModels = [];
-            const response = await strategy.loadModels(profile, this.store.getSettings());
+            const response = await this.loadModelsWithRetry(strategy, profile);
             delete this.providerErrors[profile.id];
             if (response.success) {
               providerModels.push(...response.models);
@@ -21865,6 +22887,7 @@ class ModelManager {
       errors: this.providerErrors
     });
     this.eventManager.sendSettingsUpdated(this.store.getSettings());
+    await this.saveProviderModelsToCache();
   }
   enrichWithModelInfo(models, profile, strategy) {
     const enrichedModels = [...models];
@@ -22132,12 +23155,22 @@ class ModelManager {
     }
     return strategy.getUsageReport(task, provider, modelObj, usage, providerMetadata);
   }
-  getCacheControl(profile, llmProvider) {
+  getCacheControl(provider, modelId) {
+    const llmProvider = provider.provider;
     const strategy = this.providerRegistry[llmProvider.name];
     if (!strategy?.getCacheControl) {
       return void 0;
     }
-    return strategy.getCacheControl(profile, llmProvider);
+    const models = this.providerModels[provider.id] || [];
+    const modelObj = models.find((m) => m.id === modelId);
+    if (!modelObj) {
+      const fallbackModel = {
+        id: modelId,
+        providerId: provider.id
+      };
+      return strategy.getCacheControl(llmProvider, fallbackModel);
+    }
+    return strategy.getCacheControl(llmProvider, modelObj);
   }
   isStreamingDisabled(provider, modelId) {
     const llmProvider = provider.provider;
@@ -22271,7 +23304,7 @@ class ModelManager {
         getProviderOptions: provider.strategy.getProviderOptions ? (_provider, model) => provider.strategy.getProviderOptions(model) : void 0,
         getProviderTools: provider.strategy.getProviderTools ? (_provider, model) => provider.strategy.getProviderTools(model) : void 0,
         getProviderParameters: provider.strategy.getProviderParameters ? (_provider, model) => provider.strategy.getProviderParameters(model) : void 0,
-        getCacheControl: provider.strategy.getCacheControl ? (profile2) => provider.strategy.getCacheControl(profile2) : void 0,
+        getCacheControl: provider.strategy.getCacheControl ? (_provider, model) => provider.strategy.getCacheControl(model) : void 0,
         hasEnvVars: () => false,
         getAiderMapping: provider.strategy.getAiderMapping ? provider.strategy.getAiderMapping : (_provider, modelId) => ({
           modelName: modelId,
@@ -23171,12 +24204,13 @@ class MemoryManager {
    */
   async storeMemory(projectId, taskId, type, content) {
     if (!await this.waitForInit() || !this.isMemoryEnabled() || !this.db) {
-      return;
+      return "";
     }
     try {
       const embedding = await this.getEmbedding(content);
+      const id = uuid.v4();
       const memoryWithVector = {
-        id: uuid.v4(),
+        id,
         type,
         content,
         taskid: taskId,
@@ -23196,8 +24230,10 @@ class MemoryManager {
         taskId: memoryWithVector.taskid,
         content: memoryWithVector.content.substring(0, 100)
       });
+      return id;
     } catch (error) {
       logger.error("Failed to store memory:", error);
+      return "";
     }
   }
   /**
@@ -23353,6 +24389,16 @@ class MemoryManager {
   isMemoryEnabled() {
     return this.isInitialized && this.store.getSettings().memory.enabled || false;
   }
+  setMemoryEnabled(enabled) {
+    const settings = this.store.getSettings();
+    this.store.saveSettings({
+      ...settings,
+      memory: {
+        ...settings.memory,
+        enabled
+      }
+    });
+  }
 }
 const AIDER_DESK_EXTENSIONS_REPO_URL = "https://github.com/hotovo/aider-desk/tree/main/packages/extensions/extensions/";
 const baseJitiOptions = {
@@ -23517,8 +24563,16 @@ class TaskContextImpl {
   async loadContextMessages(messages) {
     await this.task.loadContextMessages(messages);
   }
+  async redoUserPrompt(messageId, mode, updatedPrompt) {
+    await this.task.redoUserPrompt(messageId, mode || "agent", updatedPrompt);
+  }
   async redoLastUserPrompt(mode, updatedPrompt) {
-    await this.task.redoLastUserPrompt(mode || "agent", updatedPrompt);
+    const messages = await this.task.getContextMessages();
+    const lastUserMessage = messages.findLast((msg) => msg.role === "user");
+    if (!lastUserMessage) {
+      return;
+    }
+    await this.task.redoUserPrompt(lastUserMessage.id, mode || "agent", updatedPrompt);
   }
   async removeMessagesUpTo(messageId) {
     await this.task.removeMessagesUpTo(messageId);
@@ -23721,15 +24775,20 @@ class ProjectContextImpl {
   }
 }
 class ExtensionContextImpl {
-  constructor(extensionId, extensionName, store, modelManager, eventManager, project, task) {
+  constructor(extensionId, extensionName, store, modelManager, eventManager, memoryManager, project, task) {
     this.extensionId = extensionId;
     this.extensionName = extensionName;
     this.store = store;
     this.modelManager = modelManager;
     this.eventManager = eventManager;
+    this.memoryManager = memoryManager;
     this.project = project;
     this.task = task;
+    this.taskContext = this.task ? new TaskContextImpl(this.task) : null;
+    this.projectContext = this.project ? new ProjectContextImpl(this.project) : null;
   }
+  taskContext;
+  projectContext;
   log(message, type = "info") {
     const logFn = logger[type];
     logFn(`[Extension:${this.extensionName}] ${message}`);
@@ -23738,13 +24797,13 @@ class ExtensionContextImpl {
     return this.project?.baseDir ?? "";
   }
   getTaskContext() {
-    return this.task ? new TaskContextImpl(this.task) : null;
+    return this.taskContext;
   }
   getProjectContext() {
-    if (!this.project) {
+    if (!this.projectContext) {
       throw new Error("Project context not available");
     }
-    return new ProjectContextImpl(this.project);
+    return this.projectContext;
   }
   async getModelConfigs() {
     if (!this.modelManager) {
@@ -23843,6 +24902,12 @@ class ExtensionContextImpl {
       return false;
     }
   }
+  getMemoryContext() {
+    if (!this.memoryManager) {
+      throw new Error("MemoryManager not available");
+    }
+    return this.memoryManager;
+  }
 }
 const CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 class ExtensionFetcher {
@@ -24142,11 +25207,12 @@ class ExtensionFetcher {
   }
 }
 class ExtensionManager {
-  constructor(store, modelManager, eventManager, telemetryManager, registry = new ExtensionRegistry()) {
+  constructor(store, modelManager, eventManager, telemetryManager, memoryManager, registry = new ExtensionRegistry()) {
     this.store = store;
     this.modelManager = modelManager;
     this.eventManager = eventManager;
     this.telemetryManager = telemetryManager;
+    this.memoryManager = memoryManager;
     this.registry = registry;
     this.loader = new ExtensionLoader();
     this.fetcher = new ExtensionFetcher();
@@ -24171,7 +25237,7 @@ class ExtensionManager {
   filterEnabledExtensions(extensions) {
     const settings = this.store.getSettings();
     const disabledExtensions = settings.extensions?.disabled || [];
-    return extensions.filter((ext) => !disabledExtensions.includes(ext.metadata.name));
+    return extensions.filter((ext) => !disabledExtensions.includes(ext.filePath));
   }
   /**
    * Handle settings changes. Detects when extensions with UI components
@@ -24189,7 +25255,7 @@ class ExtensionManager {
       const changedExtensions = [...newlyDisabled, ...newlyEnabled];
       if (changedExtensions.length > 0) {
         const allExtensions = this.registry.getExtensions();
-        const hasUIComponentsChange = allExtensions.some((ext) => changedExtensions.includes(ext.metadata.name) && ext.instance.getUIComponents !== void 0);
+        const hasUIComponentsChange = allExtensions.some((ext) => changedExtensions.includes(ext.filePath) && ext.instance.getUIComponents !== void 0);
         if (hasUIComponentsChange) {
           logger.debug("[Extensions] Extensions with UI components changed, triggering UI refresh");
           this.eventManager.sendExtensionUIRefresh({ reloadComponents: true });
@@ -24217,6 +25283,7 @@ class ExtensionManager {
       this.registry.clear();
       await this.loadExtensionsForDir(AIDER_DESK_GLOBAL_EXTENSIONS_DIR);
       this.initialized = true;
+      this.migrateDisabledExtensions();
       await this.startHotReloadWatcher();
       this.captureExtensionsTelemetry();
       this.preloadAvailableExtensions().catch((error) => {
@@ -24253,7 +25320,7 @@ class ExtensionManager {
       return true;
     }
     try {
-      const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, project, void 0);
+      const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, this.memoryManager, project);
       await instance.onLoad(context);
       this.registry.setInitialized(filePath, true);
       this.eventManager.sendExtensionUIRefresh({
@@ -24347,13 +25414,51 @@ class ExtensionManager {
   isInitialized() {
     return this.initialized;
   }
+  /**
+   * @deprecated Migration helper: converts old name-based disabled list to filePath-based.
+   * Will be removed in a future version.
+   */
+  migrateDisabledExtensions() {
+    const settings = this.store.getSettings();
+    const disabled = settings.extensions?.disabled;
+    if (!disabled || disabled.length === 0) {
+      return;
+    }
+    const allExtensions = this.registry.getExtensions();
+    const filePaths = new Set(allExtensions.map((ext) => ext.filePath));
+    const migrated = [];
+    let changed = false;
+    for (const item of disabled) {
+      if (filePaths.has(item)) {
+        migrated.push(item);
+      } else {
+        const match = allExtensions.find((ext) => ext.metadata.name === item);
+        if (match) {
+          migrated.push(match.filePath);
+          changed = true;
+        } else {
+          migrated.push(item);
+        }
+      }
+    }
+    if (changed) {
+      logger.info("[Extensions] Migrated disabled extensions from name-based to filePath-based identifiers");
+      this.store.saveSettings({
+        ...settings,
+        extensions: {
+          ...settings.extensions,
+          disabled: migrated
+        }
+      });
+    }
+  }
   captureExtensionsTelemetry() {
     const allExtensions = this.registry.getExtensions();
     const settings = this.store.getSettings();
     const disabledExtensions = settings.extensions?.disabled || [];
     const globalExtensions = allExtensions.filter((ext) => !ext.projectDir).length;
     const projectExtensions = allExtensions.filter((ext) => ext.projectDir).length;
-    const enabledCount = allExtensions.filter((ext) => !disabledExtensions.includes(ext.metadata.name)).length;
+    const enabledCount = allExtensions.filter((ext) => !disabledExtensions.includes(ext.filePath)).length;
     this.telemetryManager.captureExtensionsLoaded(allExtensions.length, globalExtensions, projectExtensions, enabledCount, disabledExtensions.length);
   }
   async dispose() {
@@ -24588,7 +25693,16 @@ class ExtensionManager {
         continue;
       }
       try {
-        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, task.project, task);
+        const context = new ExtensionContextImpl(
+          loaded.id,
+          metadata.name,
+          this.store,
+          this.modelManager,
+          this.eventManager,
+          this.memoryManager,
+          task.project,
+          task
+        );
         const tools = instance.getTools(context, mode, profile);
         if (!Array.isArray(tools)) {
           logger.error(`[Extensions] Extension '${metadata.name}' getTools() did not return an array`);
@@ -24628,7 +25742,16 @@ class ExtensionManager {
     const registeredTools = this.getTools(task, mode, profile);
     for (const { extensionId, extensionName, tool } of registeredTools) {
       const toolId = tool.name;
-      const context = new ExtensionContextImpl(extensionId, extensionName, this.store, this.modelManager, this.eventManager, task.project, task);
+      const context = new ExtensionContextImpl(
+        extensionId,
+        extensionName,
+        this.store,
+        this.modelManager,
+        this.eventManager,
+        this.memoryManager,
+        task.project,
+        task
+      );
       if (profile.toolApprovals?.[toolId] === ToolApprovalState.Never) {
         logger.debug(`[Extensions] Skipping tool '${tool.name}' (marked as Never approved)`);
         continue;
@@ -24709,7 +25832,7 @@ class ExtensionManager {
         continue;
       }
       try {
-        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, project, void 0);
+        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, this.memoryManager, project);
         const commands = instance.getCommands(context);
         if (!Array.isArray(commands)) {
           logger.error(`[Extensions] Extension '${metadata.name}' getCommands() did not return an array`);
@@ -24743,7 +25866,7 @@ class ExtensionManager {
         continue;
       }
       try {
-        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, project, void 0);
+        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, this.memoryManager, project);
         const agents = instance.getAgents(context);
         if (!Array.isArray(agents)) {
           logger.error(`[Extensions] Extension '${metadata.name}' getAgents() did not return an array`);
@@ -24783,7 +25906,7 @@ class ExtensionManager {
         continue;
       }
       try {
-        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, project, void 0);
+        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, this.memoryManager, project);
         const modes = instance.getModes(context);
         if (!Array.isArray(modes)) {
           logger.error(`[Extensions] Extension '${metadata.name}' getModes() did not return an array`);
@@ -24836,7 +25959,7 @@ class ExtensionManager {
         continue;
       }
       try {
-        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, project, void 0);
+        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, this.memoryManager, project);
         const providers = instance.getProviders(context);
         if (!Array.isArray(providers)) {
           logger.error(`[Extensions] Extension '${metadata.name}' getProviders() did not return an array`);
@@ -24859,6 +25982,42 @@ class ExtensionManager {
     }
     return collectedProviders;
   }
+  getSkills(project, task) {
+    const collectedSkills = [];
+    const allExtensions = this.registry.getExtensions(project.baseDir);
+    const extensions = this.filterEnabledExtensions(allExtensions);
+    for (const loaded of extensions) {
+      const { instance, metadata } = loaded;
+      if (!instance.getSkills) {
+        continue;
+      }
+      try {
+        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, this.memoryManager, project, task);
+        const skills = instance.getSkills(context);
+        if (!Array.isArray(skills)) {
+          logger.error(`[Extensions] Extension '${metadata.name}' getSkills() did not return an array`);
+          continue;
+        }
+        for (const skill of skills) {
+          if (!skill.name || !skill.description) {
+            logger.error(`[Extensions] Invalid skill from extension '${metadata.name}': missing name or description`);
+            continue;
+          }
+          if (!skill.dirPath && !skill.content) {
+            logger.error(`[Extensions] Invalid skill from extension '${metadata.name}': must have dirPath or content`);
+            continue;
+          }
+          collectedSkills.push({
+            ...skill,
+            location: "extension"
+          });
+        }
+      } catch (error) {
+        logger.error(`[Extensions] Failed to get skills from extension '${metadata.name}':`, error);
+      }
+    }
+    return collectedSkills;
+  }
   getUIComponents(project, task) {
     const collectedComponents = [];
     const allExtensions = this.registry.getExtensions(project?.baseDir);
@@ -24872,7 +26031,7 @@ class ExtensionManager {
         continue;
       }
       try {
-        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, project, task);
+        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, this.memoryManager, project, task);
         const components = instance.getUIComponents(context);
         if (!Array.isArray(components)) {
           logger.error(`[Extensions] Extension '${metadata.name}' getUIComponents() did not return an array`);
@@ -24906,7 +26065,7 @@ class ExtensionManager {
       return false;
     }
     try {
-      const context = new ExtensionContextImpl(loadedExt.id, loadedExt.metadata.name, this.store, this.modelManager, this.eventManager);
+      const context = new ExtensionContextImpl(loadedExt.id, loadedExt.metadata.name, this.store, this.modelManager, this.eventManager, this.memoryManager);
       const jsx = instance.getConfigComponent(context);
       return typeof jsx === "string" && jsx.length > 0;
     } catch {
@@ -24930,7 +26089,7 @@ class ExtensionManager {
       }
       try {
         logger.debug(`[Extensions] Getting UI extension data from '${id}' for component '${componentId}'`);
-        const context = new ExtensionContextImpl(id, metadata.name, this.store, this.modelManager, this.eventManager, project, task);
+        const context = new ExtensionContextImpl(id, metadata.name, this.store, this.modelManager, this.eventManager, this.memoryManager, project, task);
         return await instance.getUIExtensionData(componentId, context);
       } catch (error) {
         logger.error(`[Extensions] Failed to get UI extension data from '${id}' for component '${componentId}':`, error);
@@ -24956,7 +26115,7 @@ class ExtensionManager {
       }
       try {
         logger.debug(`[Extensions] Executing UI extension action '${action}' from '${id}' for component '${componentId}'`);
-        const context = new ExtensionContextImpl(id, metadata.name, this.store, this.modelManager, this.eventManager, project, task);
+        const context = new ExtensionContextImpl(id, metadata.name, this.store, this.modelManager, this.eventManager, this.memoryManager, project, task);
         return await instance.executeUIExtensionAction(componentId, action, args, context);
       } catch (error) {
         logger.error(`[Extensions] Failed to execute UI extension action '${action}' from '${id}' for component '${componentId}':`, error);
@@ -24979,7 +26138,15 @@ class ExtensionManager {
         return null;
       }
       try {
-        const context = new ExtensionContextImpl(loaded.id, loaded.metadata.name, this.store, this.modelManager, this.eventManager, project, void 0);
+        const context = new ExtensionContextImpl(
+          loaded.id,
+          loaded.metadata.name,
+          this.store,
+          this.modelManager,
+          this.eventManager,
+          this.memoryManager,
+          project
+        );
         const jsx = loaded.instance.getConfigComponent(context);
         if (typeof jsx !== "string" || jsx.length === 0) {
           return null;
@@ -25007,7 +26174,15 @@ class ExtensionManager {
         return null;
       }
       try {
-        const context = new ExtensionContextImpl(loaded.id, loaded.metadata.name, this.store, this.modelManager, this.eventManager, project, void 0);
+        const context = new ExtensionContextImpl(
+          loaded.id,
+          loaded.metadata.name,
+          this.store,
+          this.modelManager,
+          this.eventManager,
+          this.memoryManager,
+          project
+        );
         return await loaded.instance.getConfigData(context);
       } catch (error) {
         logger.error(`[Extensions] Failed to get config data from extension '${extensionId}':`, error);
@@ -25031,7 +26206,15 @@ class ExtensionManager {
         return null;
       }
       try {
-        const context = new ExtensionContextImpl(loaded.id, loaded.metadata.name, this.store, this.modelManager, this.eventManager, project, void 0);
+        const context = new ExtensionContextImpl(
+          loaded.id,
+          loaded.metadata.name,
+          this.store,
+          this.modelManager,
+          this.eventManager,
+          this.memoryManager,
+          project
+        );
         return await loaded.instance.saveConfigData(configData, context);
       } catch (error) {
         logger.error(`[Extensions] Failed to save config data for extension '${extensionId}':`, error);
@@ -25064,7 +26247,7 @@ class ExtensionManager {
         continue;
       }
       try {
-        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, void 0, void 0);
+        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, this.memoryManager);
         const agents = instance.getAgents(context);
         if (!Array.isArray(agents)) {
           continue;
@@ -25100,7 +26283,7 @@ class ExtensionManager {
     }
     const { extensionId, extensionName, command } = registered;
     try {
-      const context = new ExtensionContextImpl(extensionId, extensionName, this.store, this.modelManager, this.eventManager, project, task);
+      const context = new ExtensionContextImpl(extensionId, extensionName, this.store, this.modelManager, this.eventManager, this.memoryManager, project, task);
       logger.debug(`[Extensions] Executing command '${commandName}' from extension '${extensionName}'`);
       await command.execute(args, context);
       logger.debug(`[Extensions] Command '${commandName}' executed successfully`);
@@ -25275,6 +26458,15 @@ class ExtensionManager {
         throw new Error("Invalid GitHub repository URL");
       }
       await this.unloadExtensionsForDir(targetDir);
+      const parsedExistingPath = path.parse(existingExtension.filePath);
+      const existingIsFolder = parsedExistingPath.name === "index";
+      if (extension.type === "folder" && !existingIsFolder) {
+        await fs.unlink(existingExtension.filePath);
+        logger.debug(`[Extensions] Removed old single-file extension: ${existingExtension.filePath}`);
+      } else if (extension.type === "single" && existingIsFolder) {
+        await fs.rm(parsedExistingPath.dir, { recursive: true, force: true });
+        logger.debug(`[Extensions] Removed old folder extension: ${parsedExistingPath.dir}`);
+      }
       if (extension.type === "single" && extension.file) {
         const url = `${githubRawBase}/${extension.file}`;
         const response = await fetch(url);
@@ -25338,7 +26530,7 @@ class ExtensionManager {
       }
       logger.debug(`[Extensions] Dispatching event '${String(eventName)}' to extension '${metadata.name}'`);
       try {
-        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, project, task);
+        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, this.memoryManager, project, task);
         const result = await handler.call(instance, currentEvent, context);
         if (result && typeof result === "object") {
           const partialEvent = result;
@@ -25361,13 +26553,13 @@ class ExtensionManager {
    * @returns Sorted array of extensions
    */
   sortExtensionsForDispatch(extensions, projectDir) {
-    const global = extensions.filter((e) => !e.projectDir);
+    const global2 = extensions.filter((e) => !e.projectDir);
     const projectSpecific = extensions.filter((e) => e.projectDir === projectDir);
-    return [...global, ...projectSpecific];
+    return [...global2, ...projectSpecific];
   }
 }
 class EventsHandler {
-  constructor(projectManager, store, mcpManager, versionsManager, modelManager, telemetryManager, dataManager, terminalManager, cloudflareTunnelManager, eventManager, agentProfileManager, memoryManager, extensionManager, windowManager) {
+  constructor(projectManager, store, mcpManager, versionsManager, modelManager, telemetryManager, dataManager, terminalManager, cloudflareTunnelManager, eventManager, agentProfileManager, memoryManager, extensionManager, proxyManager, windowManager) {
     this.projectManager = projectManager;
     this.store = store;
     this.mcpManager = mcpManager;
@@ -25381,6 +26573,7 @@ class EventsHandler {
     this.agentProfileManager = agentProfileManager;
     this.memoryManager = memoryManager;
     this.extensionManager = extensionManager;
+    this.proxyManager = proxyManager;
     this.windowManager = windowManager;
   }
   loadSettings() {
@@ -25389,6 +26582,7 @@ class EventsHandler {
   async saveSettings(newSettings) {
     const oldSettings = this.store.getSettings();
     this.store.saveSettings(newSettings);
+    this.proxyManager.settingsChanged(oldSettings, newSettings);
     void this.projectManager.settingsChanged(oldSettings, newSettings);
     this.telemetryManager.settingsChanged(oldSettings, newSettings);
     void this.memoryManager.settingsChanged(oldSettings, newSettings);
@@ -25443,7 +26637,7 @@ class EventsHandler {
   }
   async addOpenProject(baseDir) {
     const projects = this.store.getOpenProjects();
-    const existingProject = projects.find((p) => normalizeBaseDir(p.baseDir) === normalizeBaseDir(baseDir));
+    const existingProject = projects.find((p) => compareBaseDirs$1(p.baseDir, baseDir));
     if (!existingProject) {
       logger.info("EventsHandler: addOpenProject", { baseDir });
       const providerModels = await this.modelManager.getProviderModels();
@@ -25460,7 +26654,7 @@ class EventsHandler {
   }
   removeOpenProject(baseDir) {
     const projects = this.store.getOpenProjects();
-    const updatedProjects = projects.filter((project) => normalizeBaseDir(project.baseDir) !== normalizeBaseDir(baseDir));
+    const updatedProjects = projects.filter((project) => !compareBaseDirs$1(project.baseDir, baseDir));
     if (updatedProjects.length > 0) {
       if (!updatedProjects.some((p) => p.active)) {
         updatedProjects[updatedProjects.length - 1].active = true;
@@ -25510,8 +26704,8 @@ class EventsHandler {
     const removedIds = await this.projectManager.getProject(baseDir).getTask(taskId)?.removeMessagesUpTo(messageId) ?? [];
     this.eventManager.sendTaskMessageRemoved(baseDir, taskId, removedIds);
   }
-  async redoLastUserPrompt(baseDir, taskId, mode, updatedPrompt) {
-    void this.projectManager.getProject(baseDir).getTask(taskId)?.redoLastUserPrompt(mode, updatedPrompt);
+  async redoUserPrompt(baseDir, taskId, messageId, mode, updatedPrompt) {
+    void this.projectManager.getProject(baseDir).getTask(taskId)?.redoUserPrompt(messageId, mode, updatedPrompt);
   }
   async resumeTask(baseDir, taskId) {
     void this.projectManager.getProject(baseDir).getTask(taskId)?.resumeTask();
@@ -25530,8 +26724,8 @@ class EventsHandler {
     const mode = this.store.getProjectSettings(baseDir).currentMode || "agent";
     await task.handoffConversation(mode, focus);
   }
-  async runCodeInlineRequest(baseDir, taskId, filename, lineNumber, userComment, createNewTask) {
-    await this.projectManager.getProject(baseDir).getTask(taskId)?.runCodeInlineRequest(filename, lineNumber, userComment, createNewTask);
+  async runCodeChangeRequests(baseDir, taskId, requests, createNewTask) {
+    await this.projectManager.getProject(baseDir).getTask(taskId)?.runCodeChangeRequests(requests, 5, createNewTask);
   }
   async loadInputHistory(baseDir) {
     return await this.projectManager.getProject(baseDir).loadInputHistory();
@@ -25740,6 +26934,13 @@ class EventsHandler {
     }
     await task.mergeWorktreeToMain(squash, targetBranch, commitMessage);
   }
+  async mergeAndSwitchToLocal(baseDir, taskId, targetBranch) {
+    const task = this.projectManager.getProject(baseDir).getTask(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+    await task.mergeAndSwitchToLocal(targetBranch);
+  }
   async applyUncommittedChanges(baseDir, taskId, targetBranch) {
     const task = this.projectManager.getProject(baseDir).getTask(taskId);
     if (!task) {
@@ -25761,8 +26962,9 @@ class EventsHandler {
     }
     await task.restoreFile(filePath);
   }
-  async readFile(baseDir, filePath) {
-    const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(baseDir, filePath);
+  async readFile(baseDir, taskId, filePath) {
+    const task = this.projectManager.getProject(baseDir).getTask(taskId);
+    const absolutePath = path.isAbsolute(filePath) ? filePath : task ? await task.resolveContextFilePath(filePath) ?? path.join(baseDir, filePath) : path.join(baseDir, filePath);
     const fileContentBuffer = await fs.readFile(absolutePath);
     if (istextorbinary.isBinary(filePath, fileContentBuffer)) {
       throw new Error("Cannot read binary file");
@@ -25821,6 +27023,13 @@ class EventsHandler {
     }
     await task.resolveConflictsWithAgent();
   }
+  async renameWorktreeBranch(baseDir, taskId, newBranchName) {
+    const task = this.projectManager.getProject(baseDir).getTask(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+    await task.renameWorktreeBranch(newBranchName);
+  }
   async scrapeWeb(baseDir, taskId, url, filePath) {
     const content = await scrapeWeb(url);
     const project = this.projectManager.getProject(baseDir);
@@ -26099,6 +27308,17 @@ ${error instanceof Error ? error.message : String(error)}`);
   async initProjectRulesFile(baseDir, taskId, args) {
     return this.projectManager.getProject(baseDir).getTask(taskId)?.initProjectAgentsFile(args);
   }
+  async getSkills(baseDir, taskId) {
+    return await this.projectManager.getProject(baseDir).getTask(taskId)?.getSkills() || [];
+  }
+  async activateSkill(baseDir, taskId, skillName) {
+    await this.projectManager.getProject(baseDir).getTask(taskId)?.activateSkill(skillName);
+    void this.projectManager.getProject(baseDir).getTask(taskId)?.sendSkillsUpdated();
+  }
+  async deactivateSkill(baseDir, taskId, skillName) {
+    const removedIds = await this.projectManager.getProject(baseDir).getTask(taskId)?.deactivateSkill(skillName) ?? [];
+    this.eventManager.sendTaskMessageRemoved(baseDir, taskId, removedIds);
+  }
   async enableServer(username, password) {
     const currentSettings = this.store.getSettings();
     const updatedSettings = {
@@ -26387,7 +27607,7 @@ class PromptsManager {
       "conflict-resolution-system",
       "update-task-state",
       "handoff",
-      "code-inline-request"
+      "code-change-requests"
     ];
   }
   async loadGlobalTemplateSource(name) {
@@ -26594,6 +27814,7 @@ class PromptsManager {
   };
   getRulesContent = async (task, agentProfile) => {
     const ruleFiles = await task.getRuleFilesAsContextFiles(agentProfile);
+    logger.debug("Rule files for prompt content:", { ruleFiles });
     const ruleFilesContent = await Promise.all(
       ruleFiles.map(async (file) => {
         try {
@@ -26664,8 +27885,8 @@ ${content}
     };
     return await this.render("handoff", data, task.getProjectDir(), task);
   };
-  getCodeInlineRequestPrompt = async (task, data) => {
-    return await this.render("code-inline-request", data, task.getProjectDir(), task);
+  getCodeChangeRequestsPrompt = async (task, data) => {
+    return await this.render("code-change-requests", data, task.getProjectDir(), task);
   };
 }
 const execAsync = util.promisify(child_process.exec);
@@ -26925,6 +28146,8 @@ class PythonDependenciesInstaller {
   }
 }
 const initManagers = async (store, windowManager) => {
+  const proxyManager = new ProxyManager();
+  proxyManager.init(store.getSettings());
   const telemetryManager = new TelemetryManager(store);
   telemetryManager.init().catch((error) => {
     logger.error("[Telemetry] Telemetry initialization failed, continuing without analytics:", error);
@@ -26943,7 +28166,7 @@ const initManagers = async (store, windowManager) => {
   memoryManager.init().catch((error) => {
     logger.error("[Memory] Memory system initialization failed, continuing without memories:", error);
   });
-  const extensionManager = new ExtensionManager(store, modelManager, eventManager, telemetryManager);
+  const extensionManager = new ExtensionManager(store, modelManager, eventManager, telemetryManager, memoryManager);
   extensionManager.init().catch((error) => {
     logger.error("[Extensions] Extension system initialization failed, continuing without extensions:", error);
   });
@@ -26988,10 +28211,11 @@ const initManagers = async (store, windowManager) => {
     agentProfileManager,
     memoryManager,
     extensionManager,
+    proxyManager,
     windowManager
   );
-  const serverController = new ServerController(httpServer, projectManager, eventsHandler, store);
-  const connectorManager = new ConnectorManager(httpServer, projectManager, eventManager);
+  const serverController = new ServerController(httpServer, projectManager, eventsHandler, store, pythonInstaller);
+  const connectorManager = new ConnectorManager(httpServer, projectManager, eventManager, store);
   httpServer.listen(SERVER_PORT);
   logger.info(`AiderDesk headless server listening on http://localhost:${SERVER_PORT}`);
   let cleanedUp = false;
@@ -27579,6 +28803,10 @@ const DEFAULT_SETTINGS = {
       enabled: false,
       username: "",
       password: ""
+    },
+    cors: {
+      enabled: false,
+      origins: []
     }
   },
   memory: {
@@ -27594,11 +28822,17 @@ const DEFAULT_SETTINGS = {
     worktreeSymlinkFolders: ["node_modules", "vendor", "__pycache__", ".venv", "venv"],
     contextCompactingThreshold: 0,
     contextCompactionType: ContextCompactionType.Compact,
-    defaultWorkingMode: "local"
+    defaultWorkingMode: "local",
+    worktreeBranchPrefix: "aider-desk/task/",
+    renameBranchOnNameGeneration: true
   },
   extensions: {
     repositories: [AIDER_DESK_EXTENSIONS_REPO_URL],
     disabled: []
+  },
+  proxy: {
+    enabled: false,
+    url: ""
   }
 };
 const compareBaseDirs = (baseDir1, baseDir2) => {
@@ -27654,7 +28888,14 @@ class Store {
         }
       },
       mcpServers: settings.mcpServers || DEFAULT_SETTINGS.mcpServers,
-      server: settings.server || DEFAULT_SETTINGS.server,
+      server: {
+        ...DEFAULT_SETTINGS.server,
+        ...settings.server,
+        cors: {
+          ...DEFAULT_SETTINGS.server.cors,
+          ...settings.server?.cors
+        }
+      },
       memory: {
         ...DEFAULT_SETTINGS.memory,
         ...settings?.memory