@aiderdesk/aiderdesk 0.62.0 → 0.64.0

package/out/runner.js

@@ -47,7 +47,6 @@ 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");
@@ -59,6 +58,7 @@ 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");
@@ -243,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({
@@ -299,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";
@@ -483,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;
 };
@@ -812,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",
@@ -1434,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}"`);
@@ -1518,11 +1527,11 @@ const DEFAULT_PROVIDER_MODELS = {
   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-pro",
   groq: "moonshotai/kimi-k2-instruct-0905",
-  "kimi-plan": "k2p5",
+  "kimi-plan": "k2p6",
   openai: "gpt-5.4",
   openrouter: "anthropic/claude-sonnet-4.6",
   opencode: "claude-sonnet-4-6",
@@ -1842,7 +1851,8 @@ const getDefaultProviderParams = (providerName) => {
     case "deepseek":
       provider = {
         name: "deepseek",
-        apiKey: ""
+        apiKey: "",
+        thinkingEnabled: true
       };
       break;
     case "bedrock":
@@ -2361,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;
@@ -3048,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 === "~") {
@@ -3068,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;
@@ -3088,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({
@@ -3406,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;
@@ -3421,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);
             }
@@ -3431,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.";
@@ -3505,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 {
@@ -3539,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(
@@ -3562,6 +3660,9 @@ Timeout: ${timeout}ms`;
             );
           });
           childProcess.stderr?.on("data", (data) => {
+            if (isResolved) {
+              return;
+            }
             const chunk = data.toString("utf-8");
             stderr += chunk;
             task.addToolMessage(
@@ -3581,7 +3682,7 @@ Timeout: ${timeout}ms`;
             if (!isResolved) {
               stderr = error.message;
               exitCode = 1;
-              resolveWithResult();
+              void resolveWithResult();
             }
           });
           childProcess.on("exit", (code, signal) => {
@@ -3593,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();
           }
         }
       });
@@ -4073,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) {
@@ -4085,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}`);
@@ -4699,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) => {
@@ -4780,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(),
@@ -4806,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 = {
@@ -5266,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"
@@ -6246,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 },
@@ -6295,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) {
@@ -6475,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;
@@ -7178,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();
@@ -7202,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
@@ -7233,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(
@@ -8467,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()
 });
@@ -8602,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"),
@@ -8656,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();
@@ -8684,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(
@@ -9022,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) => {
@@ -9166,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) => {
@@ -10119,6 +10182,80 @@ 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, pythonInstaller) {
@@ -10191,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));
@@ -10462,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;
@@ -10472,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,
@@ -11306,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);
@@ -11435,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;
   }
@@ -12584,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;
@@ -12661,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;
@@ -12675,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 {
@@ -12688,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 });
@@ -12697,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);
@@ -12723,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");
@@ -12776,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) {
@@ -12810,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 = {
@@ -12827,7 +13165,7 @@ class WorktreeManager {
           currentWorktree = {
             ...currentWorktree || {},
             path: currentWorktree ? currentWorktree.path : "",
-            baseBranch: void 0
+            branch: void 0
           };
         } else if (line.startsWith("prunable")) {
           currentWorktree = {
@@ -12856,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) {
@@ -12910,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";
@@ -12991,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 = "";
@@ -13010,7 +13364,7 @@ class WorktreeManager {
           });
           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
@@ -13085,7 +13439,7 @@ class WorktreeManager {
       }
     });
   }
-  async squashAndMergeWorktreeToMain(projectPath, worktreePath, mainBranch, commitMessage) {
+  async squashAndMergeWorktreeToMain(projectPath, worktreePath, mainBranch, commitMessage, baseCommit) {
     const executedCommands = [];
     let lastOutput = "";
     try {
@@ -13101,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
@@ -13411,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;
@@ -13506,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}`;
@@ -13534,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);
         }
@@ -13588,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 = [];
@@ -13605,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);
@@ -13634,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.
    *
@@ -14282,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,
@@ -14327,6 +14702,7 @@ class Task {
   contextManager;
   agent;
   aiderManager;
+  skillManager;
   task;
   async getTaskAgentProfile() {
     let agentProfileId = this.task.agentProfileId;
@@ -14380,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;
@@ -14459,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", {
@@ -14483,6 +14909,7 @@ class Task {
         this.task.workingMode = "local";
       }
     }
+    await this.migrateWorktreeData();
     if (await fileExists(this.getTaskDir())) {
       this.git = simpleGit.simpleGit(this.getTaskDir());
     }
@@ -14857,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) {
@@ -14868,6 +15297,7 @@ class Task {
     void this.sendRequestContextInfo();
     void this.sendWorktreeIntegrationStatusUpdated();
     void this.sendUpdatedFilesUpdated();
+    void this.sendSkillsUpdated();
     this.resolveAgentRunPromises();
     if (waitForCurrentAgentToFinish) {
       await this.runNextQueuedPrompt();
@@ -14898,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 {
@@ -15681,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)) {
@@ -15755,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();
@@ -15784,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,
@@ -16064,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) {
@@ -16077,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.");
     }
@@ -16123,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);
@@ -16455,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);
@@ -16734,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,
@@ -16744,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;
@@ -16826,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(
@@ -16848,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");
@@ -16977,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) {
@@ -16988,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,
@@ -17020,8 +17609,12 @@ ${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;
       }
@@ -17062,6 +17655,19 @@ ${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) {
@@ -17727,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);
@@ -17735,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) {
@@ -17769,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();
@@ -17982,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);
@@ -19382,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,
@@ -19390,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)) {
@@ -20015,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 };
@@ -20029,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
@@ -21346,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: {
@@ -21537,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: {
@@ -21928,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;
@@ -21976,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);
@@ -22025,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];
@@ -22067,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));
@@ -22108,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);
@@ -22137,6 +22887,7 @@ class ModelManager {
       errors: this.providerErrors
     });
     this.eventManager.sendSettingsUpdated(this.store.getSettings());
+    await this.saveProviderModelsToCache();
   }
   enrichWithModelInfo(models, profile, strategy) {
     const enrichedModels = [...models];
@@ -22404,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;
@@ -22543,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,
@@ -23802,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);
@@ -24015,7 +24784,11 @@ class ExtensionContextImpl {
     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}`);
@@ -24024,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) {
@@ -24464,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
@@ -24482,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 });
@@ -24510,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) => {
@@ -24640,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() {
@@ -25170,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);
@@ -25610,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);
@@ -25780,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();
@@ -25797,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;
@@ -25847,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();
@@ -26077,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) {
@@ -26159,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);
@@ -26437,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 = {
@@ -26932,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 {
@@ -27332,7 +28215,7 @@ const initManagers = async (store, windowManager) => {
     windowManager
   );
   const serverController = new ServerController(httpServer, projectManager, eventsHandler, store, pythonInstaller);
-  const connectorManager = new ConnectorManager(httpServer, projectManager, eventManager);
+  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;
@@ -27920,6 +28803,10 @@ const DEFAULT_SETTINGS = {
       enabled: false,
       username: "",
       password: ""
+    },
+    cors: {
+      enabled: false,
+      origins: []
     }
   },
   memory: {
@@ -27935,7 +28822,9 @@ 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],
@@ -27999,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