@aiderdesk/aiderdesk 0.59.0 → 0.61.0-dev

package/out/runner.js

@@ -772,8 +772,6 @@ const AIDER_DESK_RULES_DIR = "rules";
 const AIDER_DESK_PROJECT_RULES_DIR = path.join(AIDER_DESK_DIR, AIDER_DESK_RULES_DIR);
 const AIDER_DESK_GLOBAL_RULES_DIR = path.join(os.homedir(), AIDER_DESK_DIR, AIDER_DESK_RULES_DIR);
 const AIDER_DESK_COMMANDS_DIR = path.join(AIDER_DESK_DIR, "commands");
-const AIDER_DESK_HOOKS_DIR = path.join(AIDER_DESK_DIR, "hooks");
-const AIDER_DESK_GLOBAL_HOOKS_DIR = path.join(os.homedir(), AIDER_DESK_DIR, "hooks");
 const AIDER_DESK_EXTENSIONS_DIR = path.join(AIDER_DESK_DIR, "extensions");
 const AIDER_DESK_GLOBAL_EXTENSIONS_DIR = path.join(os.homedir(), AIDER_DESK_DIR, "extensions");
 const AIDER_DESK_PROMPTS_DIR = path.join(AIDER_DESK_DIR, "prompts");
@@ -784,6 +782,7 @@ const AIDER_DESK_TMP_DIR = path.join(AIDER_DESK_DIR, "tmp");
 const AIDER_DESK_WATCH_FILES_LOCK = path.join(AIDER_DESK_DIR, "watch-files.lock");
 const WORKTREE_BRANCH_PREFIX = "aider-desk/task/";
 const AIDER_DESK_MEMORY_FILE = path.join(AIDER_DESK_DATA_DIR, "memory.db");
+const EXTENSIONS_REPOS_CACHE_DIR = path.join(AIDER_DESK_CACHE_DIR, "extensions");
 const POSTHOG_PUBLIC_API_KEY = "phc_AF4zkjrcziXLh8PBFsRSvVr4VZ38p3ezsdX0KDYuElI";
 const POSTHOG_HOST = "https://eu.i.posthog.com";
 process.env.AIDER_DESK_HEADLESS === "true";
@@ -852,10 +851,6 @@ class ApprovalManager {
     return this.handleApproval(key, text, subject);
   }
   async handleApproval(key, text, subject) {
-    const hookResult = await this.task.hookManager.trigger("onHandleApproval", { key, text, subject }, this.task, this.task.project);
-    if (typeof hookResult.result === "boolean") {
-      return [hookResult.result, void 0];
-    }
     const extensionResult = await this.task.dispatchExtensionEvent("onHandleApproval", { key, text, subject });
     if (extensionResult.blocked) {
       return [false, void 0];
@@ -2315,7 +2310,7 @@ const getTelemetryEnvironmentVariablesForAider = (settings, baseDir) => {
     ...getLangfuseEnvironmentVariables(baseDir, settings)
   };
 };
-const getDefaultProjectSettings = (store, providerModels, baseDir, defaultAgentProfileId = DEFAULT_AGENT_PROFILE.id) => {
+const getDefaultProjectSettings = (store, providerModels, baseDir, defaultAgentProfileId = DEFAULT_AGENT_PROFILE.id, providers) => {
   const openProjects = store.getOpenProjects();
   const activeProject = openProjects.find((p) => p.active);
   if (activeProject) {
@@ -2324,7 +2319,7 @@ const getDefaultProjectSettings = (store, providerModels, baseDir, defaultAgentP
     };
   }
   return {
-    mainModel: determineMainModel(store.getSettings(), store.getProviders(), providerModels, baseDir),
+    mainModel: determineMainModel(store.getSettings(), providers ?? store.getProviders(), providerModels, baseDir),
     weakModel: determineWeakModel(baseDir),
     modelEditFormats: {},
     currentMode: "agent",
@@ -5783,7 +5778,13 @@ class Agent {
     const fileInfos = await Promise.all(
       files.map(async (file) => {
         try {
-          const filePath = path.resolve(task.getTaskDir(), file.path);
+          const filePath = await task.resolveContextFilePath(file.path);
+          if (!filePath) {
+            logger.error("Could not resolve context file path:", {
+              path: file.path
+            });
+            return null;
+          }
           const fileContentBuffer = await fs.readFile(filePath);
           if (istextorbinary.isBinary(filePath, fileContentBuffer)) {
             try {
@@ -5827,9 +5828,13 @@ class Agent {
     );
     fileInfos.filter(Boolean).forEach((file) => {
       if (file.isImage && file.imageBase64) {
+        imageParts.push({
+          type: "text",
+          text: `Here is image ${path.basename(file.path)} for your reference.`
+        });
         imageParts.push({
           type: "image",
-          image: `data:${file.mimeType};base64,${file.imageBase64}`,
+          image: file.imageBase64,
           mediaType: file.mimeType
         });
       } else if (!file.isImage && file.content) {
@@ -5905,16 +5910,27 @@ ${file.content}</content-with-line-numbers>
       const nonImageFiles = [];
       for (const file of contextFiles) {
         try {
-          const filePath = path.resolve(task.getTaskDir(), file.path);
+          const filePath = await task.resolveContextFilePath(file.path);
+          if (!filePath) {
+            logger.error("Could not resolve context file path for working files:", {
+              path: file.path
+            });
+            nonImageFiles.push(file);
+            continue;
+          }
           const fileContentBuffer = await fs.readFile(filePath);
           if (istextorbinary.isBinary(filePath, fileContentBuffer)) {
             try {
               const detected = await fileType.fileTypeFromBuffer(fileContentBuffer);
               if (detected?.mime.startsWith("image/")) {
                 const imageBase64 = fileContentBuffer.toString("base64");
+                imageParts.push({
+                  type: "text",
+                  text: `Here is image ${path.basename(file.path)} for your reference.`
+                });
                 imageParts.push({
                   type: "image",
-                  image: `data:${detected.mime};base64,${imageBase64}`,
+                  image: imageBase64,
                   mediaType: detected.mime
                 });
                 continue;
@@ -6052,12 +6068,7 @@ ${fileList}`
       wrappedToolSet[toolName] = {
         ...toolDef,
         execute: async (input, options) => {
-          const hookResult = await task.hookManager.trigger("onToolCalled", { toolName, args: input }, task, task.project);
-          if (hookResult.blocked) {
-            logger.warn(`Tool execution blocked by hook: ${toolName}`);
-            return "Tool execution blocked by hook.";
-          }
-          let effectiveInput = hookResult.event.args ?? input;
+          let effectiveInput = input;
           const [serverName, messageToolName] = extractServerNameToolName(toolName);
           task.addToolMessage(options.toolCallId, serverName, messageToolName, effectiveInput, void 0, void 0, promptContext);
           const toolCalledExtensionResult = await this.extensionManager.dispatchEvent(
@@ -6074,7 +6085,6 @@ ${fileList}`
             options.abortSignal = abortSignal;
           }
           const result = await toolDef.execute(effectiveInput, options);
-          const toolFinishedHookResult = await task.hookManager.trigger("onToolFinished", { toolName, args: effectiveInput, result }, task, task.project);
           const toolFinishedExtensionResult = await this.extensionManager.dispatchEvent(
             "onToolFinished",
             { toolName, input: effectiveInput, output: result },
@@ -6083,8 +6093,6 @@ ${fileList}`
           );
           if (toolFinishedExtensionResult.output) {
             return toolFinishedExtensionResult.output;
-          } else if (toolFinishedHookResult.event.result) {
-            return toolFinishedHookResult.event.result;
           } else {
             return result;
           }
@@ -6230,18 +6238,6 @@ ${fileList}`
   async runAgent(task, profile, prompt, mode = "agent", promptContext, initialContextMessages, initialContextFiles, systemPrompt, includeInContext = true, abortSignal) {
     let contextMessages = initialContextMessages ?? await task.getContextMessages();
     let contextFiles = initialContextFiles ?? await task.getContextFiles();
-    const hookResult = await task.hookManager.trigger("onAgentStarted", { prompt, contextMessages, contextFiles }, task, task.project);
-    if (hookResult.blocked) {
-      logger.debug("Agent execution blocked by hook");
-      return [];
-    }
-    prompt = hookResult.event.prompt;
-    if (hookResult.event.contextMessages) {
-      contextMessages = hookResult.event.contextMessages;
-    }
-    if (hookResult.event.contextFiles) {
-      contextFiles = hookResult.event.contextFiles;
-    }
     if (!systemPrompt) {
       systemPrompt = await this.promptsManager.getSystemPrompt(this.store.getSettings(), task, profile);
     }
@@ -6254,7 +6250,7 @@ ${fileList}`
     const settings = this.store.getSettings();
     const projectProfiles = this.agentProfileManager.getProjectProfiles(task.project);
     let resultMessages = userRequestMessage ? [userRequestMessage] : [];
-    const providers = this.store.getProviders();
+    const providers = this.modelManager.getProviders();
     let provider = providers.find((p) => p.id === profile.provider);
     let modelName = profile.model;
     if (provider) {
@@ -6555,13 +6551,6 @@ ${fileList}`
             return;
           }
           responseMessages = await this.processStep(currentResponseId, stepResult, task, provider, modelName, promptContext, abortSignal);
-          const hookResult3 = await task.hookManager.trigger("onAgentStepFinished", { stepResult, finishReason, responseMessages }, task, task.project);
-          if (hookResult3?.event?.finishReason) {
-            finishReason = hookResult3.event.finishReason;
-          }
-          if (hookResult3?.event?.responseMessages) {
-            responseMessages = hookResult3.event.responseMessages;
-          }
           const extensionResult2 = await this.extensionManager.dispatchEvent(
             "onAgentStepFinished",
             {
@@ -6772,10 +6761,6 @@ ${fileList}`
           break;
         }
       }
-      const hookResult2 = await task.hookManager.trigger("onAgentFinished", { aborted: false, contextMessages, resultMessages }, task, task.project);
-      if (hookResult2?.event?.resultMessages) {
-        resultMessages = hookResult2.event.resultMessages;
-      }
       const extensionResult = await this.extensionManager.dispatchEvent(
         "onAgentFinished",
         {
@@ -6794,10 +6779,6 @@ ${fileList}`
         if (streamingMessageIds.size > 0) {
           this.removeUnfinishedStreamingMessages(task, streamingMessageIds);
         }
-        const hookResult2 = await task.hookManager.trigger("onAgentFinished", { aborted: true, contextMessages, resultMessages }, task, task.project);
-        if (hookResult2?.event?.resultMessages) {
-          resultMessages = hookResult2.event.resultMessages;
-        }
         const extensionResult = await this.extensionManager.dispatchEvent(
           "onAgentFinished",
           {
@@ -6830,20 +6811,40 @@ ${fileList}`
     return resultMessages;
   }
   filterResultMessages(resultMessages) {
-    return resultMessages.filter((message) => {
-      if (message.role === "tool" && message.id.startsWith(`${HELPERS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}`)) {
-        return false;
+    const helpersPrefix = `${HELPERS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}`;
+    return resultMessages.reduce((acc, message) => {
+      if (message.role === "tool") {
+        const nonHelpersContent = message.content.filter((part) => !part.toolName.startsWith(helpersPrefix));
+        if (nonHelpersContent.length === 0) {
+          return acc;
+        }
+        if (nonHelpersContent.length === message.content.length) {
+          acc.push(message);
+        } else {
+          acc.push({ ...message, content: nonHelpersContent });
+        }
+        return acc;
       }
       if (message.role === "assistant") {
-        if (Array.isArray(message.content) && message.content.some(
-          (content) => content.type === "tool-call" && content.toolName.startsWith(`${HELPERS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}`)
-        )) {
-          return false;
+        if (!Array.isArray(message.content)) {
+          acc.push(message);
+          return acc;
+        }
+        const hasHelpersToolCall = message.content.some((part) => part.type === "tool-call" && part.toolName.startsWith(helpersPrefix));
+        if (!hasHelpersToolCall) {
+          acc.push(message);
+          return acc;
         }
-        return true;
+        const nonHelpersContent = message.content.filter((part) => !(part.type === "tool-call" && part.toolName.startsWith(helpersPrefix)));
+        if (nonHelpersContent.length === 0) {
+          return acc;
+        }
+        acc.push({ ...message, content: nonHelpersContent });
+        return acc;
       }
-      return true;
-    });
+      acc.push(message);
+      return acc;
+    }, []);
   }
   async getContextFilesAsToolCallMessages(task, profile, contextFiles) {
     const messages = [];
@@ -6950,16 +6951,16 @@ ${fileList}`
         }
       }
       for (const imageData of imageFiles) {
-        fileMessages.push({
-          role: "assistant",
-          content: `Provide content of image file: ${imageData.relativePath}`
-        });
         const imageMessage = {
           role: "user",
           content: [
+            {
+              type: "text",
+              text: `Here is content of image file ${path.basename(imageData.relativePath)}`
+            },
             {
               type: "image",
-              image: `data:${imageData.mimeType};base64,${imageData.imageBase64}`,
+              image: imageData.imageBase64,
               mediaType: imageData.mimeType
             }
           ]
@@ -7006,7 +7007,7 @@ ${fileList}`
   }
   async generateText(modelId, systemPrompt, prompt, projectDir, messages = [], abortable = true, abortSignal) {
     const [providerId, modelName] = extractProviderModel(modelId);
-    const providers = this.store.getProviders();
+    const providers = this.modelManager.getProviders();
     const provider = providers.find((p) => p.id === providerId);
     if (!provider) {
       throw new Error(`Provider ${providerId} not found`);
@@ -7059,7 +7060,7 @@ ${fileList}`
   }
   async estimateTokens(task, profile) {
     try {
-      const providers = this.store.getProviders();
+      const providers = this.modelManager.getProviders();
       const provider = providers.find((p) => p.id === profile.provider);
       if (!provider) {
         logger.warn(`Estimation failed: Provider ${profile.provider} not found`);
@@ -8328,7 +8329,8 @@ const RunCommandSchema = zod.z.object({
 });
 const InitProjectRulesFileSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
-  taskId: zod.z.string().min(1, "Task id is required")
+  taskId: zod.z.string().min(1, "Task id is required"),
+  args: zod.z.string().optional()
 });
 const CreateNewTaskSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
@@ -8440,9 +8442,9 @@ const GenerateCommitMessageSchema = zod.z.object({
 const CommitChangesSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
   taskId: zod.z.string().min(1, "Task id is required"),
-  message: zod.z.string().min(1, "Commit message is required"),
+  message: zod.z.string(),
   amend: zod.z.boolean()
-});
+}).refine((data) => data.amend || data.message.trim().length > 0, { message: "Commit message is required", path: ["message"] });
 const ListBranchesSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required")
 });
@@ -8601,8 +8603,8 @@ class ProjectApi extends BaseApi {
         if (!parsed) {
           return;
         }
-        const { projectDir, taskId } = parsed;
-        await this.eventsHandler.initProjectRulesFile(projectDir, taskId);
+        const { projectDir, taskId, args } = parsed;
+        await this.eventsHandler.initProjectRulesFile(projectDir, taskId, args);
         res.status(200).json({ message: "Project rules file initialized" });
       })
     );
@@ -9746,6 +9748,11 @@ const UninstallExtensionSchema = zod.z.object({
   extensionId: zod.z.string().min(1, "Extension ID is required"),
   projectDir: zod.z.string().optional()
 });
+const UpdateExtensionSchema = zod.z.object({
+  extensionId: zod.z.string().min(1, "Extension ID is required"),
+  repositoryUrl: zod.z.string().url("Repository URL must be a valid URL"),
+  projectDir: zod.z.string().optional()
+});
 class ExtensionsApi extends BaseApi {
   constructor(eventsHandler) {
     super();
@@ -9808,6 +9815,22 @@ class ExtensionsApi extends BaseApi {
         }
       })
     );
+    router.post(
+      "/extensions/update",
+      this.handleRequest(async (req, res) => {
+        const parsed = this.validateRequest(UpdateExtensionSchema, req.body, res);
+        if (!parsed) {
+          return;
+        }
+        const { extensionId, repositoryUrl, projectDir } = parsed;
+        const success = await this.eventsHandler.updateExtension(extensionId, repositoryUrl, projectDir);
+        if (success) {
+          res.status(200).json({ message: "Extension updated successfully", success });
+        } else {
+          res.status(500).json({ message: "Failed to update extension", success });
+        }
+      })
+    );
     router.get(
       "/extensions/ui-components",
       this.handleRequest(async (req, res) => {
@@ -10849,12 +10872,18 @@ class ContextManager {
     return isFileIgnored(this.task.getTaskDir(), contextFile.path);
   }
   async addContextFile(contextFile) {
-    const absolutePath = path.resolve(this.task.getTaskDir(), contextFile.path);
-    const isDir = await isDirectory(absolutePath);
-    const alreadyAdded = this.files.find((file) => path.resolve(this.task.getTaskDir(), file.path) === absolutePath);
-    if (alreadyAdded) {
+    const absolutePath = await this.resolveContextFilePath(contextFile.path);
+    if (!absolutePath) {
+      logger.debug("Skipping non-existing file for task:", {
+        taskId: this.taskId,
+        path: contextFile.path
+      });
       return [];
     }
+    if (this.isContextFileAlreadyAdded(absolutePath)) {
+      return [];
+    }
+    const isDir = await isDirectory(absolutePath);
     if (isDir) {
       logger.debug("Recursively adding files in directory to task context:", {
         taskId: this.taskId,
@@ -10882,14 +10911,6 @@ class ContextManager {
       }
       return addedFiles;
     } else {
-      if (!await fileExists(absolutePath)) {
-        logger.debug("Skipping non-existing file for task:", {
-          taskId: this.taskId,
-          path: contextFile.path,
-          absolutePath
-        });
-        return [];
-      }
       if (await this.isFileIgnored(contextFile)) {
         logger.debug("Skipping ignored file for task:", {
           taskId: this.taskId,
@@ -10910,6 +10931,24 @@ class ContextManager {
       return [newContextFile];
     }
   }
+  /**
+   * Resolves a relative file path by delegating to Task.resolveContextFilePath
+   * which tries taskDir first, then falls back to projectDir.
+   */
+  async resolveContextFilePath(relativePath) {
+    return this.task.resolveContextFilePath(relativePath);
+  }
+  /**
+   * Checks whether a resolved absolute path matches any already-added context file.
+   * Accounts for files that may have been resolved from either taskDir or projectDir.
+   */
+  isContextFileAlreadyAdded(absolutePath) {
+    return this.files.some((file) => {
+      const taskDirResolved = path.resolve(this.task.getTaskDir(), file.path);
+      const projectDirResolved = path.resolve(this.task.getProjectDir(), file.path);
+      return taskDirResolved === absolutePath || projectDirResolved === absolutePath;
+    });
+  }
   dropContextFile(filePath) {
     const absolutePath = path.resolve(this.task.getTaskDir(), filePath);
     const droppedFiles = [];
@@ -12249,6 +12288,7 @@ class WorktreeManager {
       await fs.mkdir(worktreePath, { recursive: true });
     } catch (error) {
       logger.error("Failed to create worktree directory:", error);
+      throw error;
     }
   }
   async createWorktree(projectPath, taskId, branch, baseBranch = "HEAD") {
@@ -13268,8 +13308,16 @@ Git output: ${err.stderr || err.stdout || err.message}`
     try {
       const commitMap = /* @__PURE__ */ new Map();
       let diffCommand = "git diff --numstat -z HEAD";
+      let mergeBase = "";
       if (workingMode === "worktree" && mainBranch) {
-        diffCommand = `git diff --numstat -z ${mainBranch}`;
+        mergeBase = mainBranch;
+        try {
+          const { stdout: baseOutput } = await execWithShellPath(`git merge-base HEAD ${mainBranch}`, { cwd: worktreePath });
+          mergeBase = baseOutput.trim();
+        } catch (mergeBaseError) {
+          logger.warn("Failed to get merge-base, falling back to main branch:", mergeBaseError);
+        }
+        diffCommand = `git diff --numstat -z ${mergeBase}`;
         try {
           logger.debug("Getting commit information for worktree", { worktreePath, mainBranch });
           const { stdout: logOutput } = await execWithShellPath(`git log --pretty=format:'%H|%s' --name-only ${mainBranch}..HEAD`, { cwd: worktreePath });
@@ -13324,7 +13372,7 @@ Git output: ${err.stderr || err.stdout || err.message}`
               }
             }
             const escapedPath = filePath.replace(/"/g, '\\"');
-            const gitDiffCmd = workingMode === "worktree" && mainBranch ? `git diff --unified=3 ${mainBranch} -- "${escapedPath}"` : `git diff --unified=3 HEAD -- "${escapedPath}"`;
+            const gitDiffCmd = workingMode === "worktree" && mainBranch ? `git diff --unified=3 ${mergeBase} -- "${escapedPath}"` : `git diff --unified=3 HEAD -- "${escapedPath}"`;
             const { stdout: diffOutput } = await execWithShellPath(gitDiffCmd, {
               cwd: worktreePath,
               maxBuffer: 10 * 1024 * 1024
@@ -13358,24 +13406,22 @@ Git output: ${err.stderr || err.stdout || err.message}`
     try {
       logger.info(`Restoring file: ${filePath}`, { worktreePath });
       const escapedPath = filePath.replace(/"/g, '\\"');
-      let isTracked = false;
+      let existsInHead = false;
       try {
-        await execWithShellPath(`git ls-files --error-unmatch -- "${escapedPath}"`, { cwd: worktreePath });
-        isTracked = true;
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const isUntrackedFileError = errorMessage.includes("did not match");
-        if (isUntrackedFileError) {
-          isTracked = false;
-        } else {
-          throw error;
-        }
+        await execWithShellPath(`git cat-file -e HEAD:"${escapedPath}"`, { cwd: worktreePath });
+        existsInHead = true;
+      } catch {
+        existsInHead = false;
       }
-      if (isTracked) {
-        await execWithShellPath(`git restore -- "${escapedPath}"`, {
+      if (existsInHead) {
+        await execWithShellPath(`git restore --staged --worktree --source=HEAD -- "${escapedPath}"`, {
           cwd: worktreePath
         });
       } else {
+        try {
+          await execWithShellPath(`git rm --cached -f -- "${escapedPath}"`, { cwd: worktreePath });
+        } catch {
+        }
         const absolutePath = path.join(worktreePath, filePath);
         try {
           const stats = await fs.lstat(absolutePath);
@@ -13699,7 +13745,7 @@ const getTaskFinishedNotificationText = (task) => {
 ${TaskStateEmoji[task.state] || ""} ${task.state.toLowerCase().split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ")}` : ""}`;
 };
 class Task {
-  constructor(project, taskId, store, mcpManager, customCommandManager, agentProfileManager, telemetryManager, dataManager, eventManager, modelManager, worktreeManager, memoryManager, hookManager, promptsManager, extensionManager, initialTaskData) {
+  constructor(project, taskId, store, mcpManager, customCommandManager, agentProfileManager, telemetryManager, dataManager, eventManager, modelManager, worktreeManager, memoryManager, promptsManager, extensionManager, initialTaskData) {
     this.project = project;
     this.taskId = taskId;
     this.store = store;
@@ -13712,7 +13758,6 @@ class Task {
     this.modelManager = modelManager;
     this.worktreeManager = worktreeManager;
     this.memoryManager = memoryManager;
-    this.hookManager = hookManager;
     this.promptsManager = promptsManager;
     this.extensionManager = extensionManager;
     this.task = {
@@ -13902,10 +13947,12 @@ class Task {
       } else {
         const branchName = this.generateBranchName();
         this.task.worktree = await this.worktreeManager.createWorktree(this.project.baseDir, this.taskId, branchName);
+        void this.sendUpdatedFilesUpdated();
       }
     } else if (workingMode === "local") {
       if (existingWorktree) {
         await this.worktreeManager.removeWorktree(this.project.baseDir, existingWorktree);
+        void this.sendUpdatedFilesUpdated();
       }
     } else {
       logger.debug("Empty workingMode, setting to local", {
@@ -13933,7 +13980,6 @@ class Task {
     await this.updateAutocompletionData();
     this.eventManager.sendTaskInitialized(this.task);
     this.initialized = true;
-    await this.hookManager.trigger("onTaskInitialized", { task: this.task }, this, this.project);
     await this.extensionManager.dispatchEvent("onTaskInitialized", { task: this.task }, this.project, this);
   }
   async load() {
@@ -14005,6 +14051,30 @@ class Task {
   getTaskDir() {
     return this.task.worktree ? this.task.worktree.path : this.project.baseDir;
   }
+  /**
+   * Resolves a relative file path against taskDir first, then falls back to projectDir.
+   * This handles git worktree cases where files may exist in the project directory
+   * but not in the worktree (taskDir).
+   *
+   * @param relativePath - Relative file path to resolve
+   * @returns The resolved absolute path if the file/dir exists in either location, or null otherwise
+   */
+  async resolveContextFilePath(relativePath) {
+    const taskDirAbsolutePath = path.resolve(this.getTaskDir(), relativePath);
+    if (await fileExists(taskDirAbsolutePath) || await isDirectory(taskDirAbsolutePath)) {
+      return taskDirAbsolutePath;
+    }
+    const projectDirAbsolutePath = path.resolve(this.getProjectDir(), relativePath);
+    if (await fileExists(projectDirAbsolutePath) || await isDirectory(projectDirAbsolutePath)) {
+      logger.debug("File not found in taskDir, falling back to projectDir:", {
+        taskId: this.taskId,
+        relativePath,
+        projectDirAbsolutePath
+      });
+      return projectDirAbsolutePath;
+    }
+    return null;
+  }
   /**
    * Dispatches an extension event through the ExtensionManager.
    * This public method provides controlled access to extension event dispatch
@@ -14038,7 +14108,6 @@ class Task {
       baseDir: this.project.baseDir,
       taskId: this.taskId
     });
-    await this.hookManager.trigger("onTaskClosed", { task: this.task }, this, this.project);
     await this.extensionManager.dispatchEvent("onTaskClosed", { task: this.task }, this.project, this);
     if (clearContext) {
       this.eventManager.sendClearTask(this.project.baseDir, this.taskId, true, true);
@@ -14125,13 +14194,6 @@ class Task {
       this.eventManager.sendQueuedPromptsUpdated(this.project.baseDir, this.taskId, this.queuedPrompts);
       return [];
     }
-    const hookResult = await this.hookManager.trigger("onPromptSubmitted", { prompt, mode }, this, this.project);
-    if (hookResult.blocked) {
-      logger.debug("Prompt blocked by hook");
-      return [];
-    }
-    prompt = hookResult.event.prompt;
-    mode = hookResult.event.mode;
     let promptContext = {
       id: userMessageId
     };
@@ -14206,14 +14268,6 @@ class Task {
   }
   async runPromptInAider(mode, prompt, promptContext, sendNotification = true) {
     await this.waitForCurrentPromptToFinish();
-    await this.hookManager.trigger("onPromptStarted", { prompt, mode }, this, this.project);
-    const aiderHookResult = await this.hookManager.trigger("onAiderPromptStarted", { prompt, mode }, this, this.project);
-    if (aiderHookResult.blocked) {
-      logger.debug("Aider prompt blocked by hook");
-      return [];
-    }
-    prompt = aiderHookResult.event.prompt;
-    mode = aiderHookResult.event.mode;
     await this.saveTask({
       name: this.task.name || this.getTaskNameFromPrompt(prompt),
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -14268,11 +14322,7 @@ class Task {
         this.contextManager.addContextMessage(assistantMessage);
       }
     }
-    void this.sendRequestContextInfo();
-    void this.sendWorktreeIntegrationStatusUpdated();
-    void this.sendUpdatedFilesUpdated();
-    await this.hookManager.trigger("onAiderPromptFinished", { responses }, this, this.project);
-    await this.hookManager.trigger("onPromptFinished", { responses }, this, this.project);
+    this.sendStateUpdated();
     if (this.task.state === DefaultTaskState.InProgress) {
       await this.saveTask({
         completedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -14287,7 +14337,6 @@ class Task {
     return responses;
   }
   async runPromptInAgent(profile, mode, prompt, promptContext = { id: uuid.v4() }, contextMessages, contextFiles, systemPrompt, waitForCurrentAgentToFinish = true, sendNotification = true) {
-    await this.hookManager.trigger("onPromptStarted", { prompt, mode: "agent" }, this, this.project);
     if (waitForCurrentAgentToFinish) {
       await this.waitForCurrentAgentToFinish();
     }
@@ -14302,7 +14351,6 @@ class Task {
         this.sendAddMessage(message.role, message.content, false);
       });
     }
-    await this.hookManager.trigger("onPromptFinished", { responses: [] }, this, this.project);
     void this.sendRequestContextInfo();
     void this.sendWorktreeIntegrationStatusUpdated();
     void this.sendUpdatedFilesUpdated();
@@ -14445,12 +14493,6 @@ ${contentText}</agent-response>`;
       this.registerSubagentAbortController(interruptId, abortController);
     }
     try {
-      const hookResult = await this.hookManager.trigger("onSubagentStarted", { subagentId: profile.id, prompt }, this, this.project);
-      if (hookResult.blocked) {
-        logger.debug("Subagent execution blocked by hook");
-        return [];
-      }
-      prompt = hookResult.event.prompt;
       if (!contextMessages) {
         contextMessages = await this.getContextMessages();
       }
@@ -14491,10 +14533,6 @@ ${contentText}</agent-response>`;
         false,
         abortController?.signal
       );
-      const finishedHookResult = await this.hookManager.trigger("onSubagentFinished", { subagentId: profile.id, resultMessages }, this, this.project);
-      if (finishedHookResult.event.resultMessages) {
-        resultMessages = finishedHookResult.event.resultMessages;
-      }
       const subagentFinishedExtensionResult = await this.extensionManager.dispatchEvent(
         "onSubagentFinished",
         { subagentProfile: profile, resultMessages },
@@ -14542,10 +14580,6 @@ ${contentText}</agent-response>`;
     }
   }
   async processResponseMessage(message, saveToDb = true) {
-    const hookResult = await this.hookManager.trigger("onResponseMessageProcessed", { message }, this, this.project);
-    if (hookResult.result) {
-      message = { ...message, ...hookResult.result };
-    }
     if (!message.finished) {
       const sendResponseChunk = async (chunk) => {
         let data = {
@@ -14679,7 +14713,6 @@ ${contentText}</agent-response>`;
     if (!this.currentQuestion) {
       return false;
     }
-    void this.hookManager.trigger("onQuestionAnswered", { question: this.currentQuestion, answer, userInput }, this, this.project);
     const extensionResult = await this.extensionManager.dispatchEvent(
       "onQuestionAnswered",
       { question: this.currentQuestion, answer, userInput },
@@ -14733,12 +14766,6 @@ ${contentText}</agent-response>`;
   async addFiles(...contextFiles) {
     const addedFiles = [];
     for (let contextFile of contextFiles) {
-      const hookResult = await this.hookManager.trigger("onFileAdded", { file: contextFile }, this, this.project);
-      if (hookResult.blocked) {
-        logger.debug("File addition blocked by hook");
-        return false;
-      }
-      contextFile = hookResult.event.file;
       const extensionResult = await this.extensionManager.dispatchEvent("onFilesAdded", { files: [contextFile] }, this.project, this);
       if (extensionResult.files.length === 0) {
         logger.debug("File addition blocked by extension (empty files array)");
@@ -14767,7 +14794,6 @@ ${contentText}</agent-response>`;
     this.findMessageConnectors("add-file").forEach((connector) => connector.sendAddFileMessage(contextFile, noUpdate));
   }
   async dropFile(filePath) {
-    await this.hookManager.trigger("onFileDropped", { filePath }, this, this.project);
     await this.extensionManager.dispatchEvent("onFilesDropped", { files: [{ path: filePath }] }, this.project, this);
     const normalizedPath = this.normalizeFilePath(filePath);
     logger.info("Dropping file or folder:", { path: normalizedPath });
@@ -14800,18 +14826,18 @@ ${contentText}</agent-response>`;
       this.addLogMessage("warning", `Failed to add new file ${absolutePath} to git staging area: ${gitErrorMessage}`, false, promptContext);
     }
   }
+  sendStateUpdated() {
+    void this.sendRequestContextInfo();
+    void this.sendWorktreeIntegrationStatusUpdated();
+    void this.sendUpdatedFilesUpdated();
+    void this.sendContextFilesUpdated();
+  }
   async sendContextFilesUpdated() {
     const mode = this.getCurrentMode();
     const allFiles = await this.getContextFiles(!AIDER_MODES.includes(mode));
     this.eventManager.sendContextFilesUpdated(this.project.baseDir, this.taskId, allFiles);
   }
   async runCommand(command, addToHistory = true) {
-    const hookResult = await this.hookManager.trigger("onCommandExecuted", { command }, this, this.project);
-    if (hookResult.blocked) {
-      logger.debug("Command execution blocked by hook");
-      return;
-    }
-    command = hookResult.event.command;
     const extensionResult = await this.extensionManager.dispatchEvent("onCommandExecuted", { command }, this.project, this);
     if (extensionResult.blocked) {
       logger.debug("Command execution blocked by extension");
@@ -14883,14 +14909,6 @@ ${contentText}</agent-response>`;
     void this.updateContextInfo(true, true);
   }
   async askQuestion(questionData, awaitAnswer = true) {
-    const hookResult = await this.hookManager.trigger("onQuestionAsked", { question: questionData }, this, this.project);
-    if (hookResult.result && typeof hookResult.result === "string") {
-      logger.info("Question answered by hook", {
-        question: questionData.text,
-        answer: hookResult.result
-      });
-      return [hookResult.result, void 0];
-    }
     const extensionResult = await this.extensionManager.dispatchEvent("onQuestionAsked", { question: questionData }, this.project, this);
     if (extensionResult.answer) {
       logger.info("Question answered by extension", {
@@ -15987,7 +16005,7 @@ ${contentText}</agent-response>`;
     });
     return [];
   }
-  async initProjectAgentsFile() {
+  async initProjectAgentsFile(args) {
     logger.info("Initializing AGENTS.md file", {
       baseDir: this.project.baseDir
     });
@@ -16006,24 +16024,15 @@ ${contentText}</agent-response>`;
         provider: activeProfile.provider,
         model: activeProfile.model
       };
-      await this.runPromptInAgent(initProjectRulesAgentProfile, "init-project-agents-file", await this.promptsManager.getInitProjectPrompt(this));
+      const systemPrompt = await this.promptsManager.getInitProjectSystemPrompt(this);
+      const userPrompt = args ? `/init ${args}` : "/init";
+      await this.runPromptInAgent(initProjectRulesAgentProfile, "init-project-agents-file", userPrompt, { id: uuid.v4() }, void 0, void 0, systemPrompt);
       const projectAgentsPath = path.join(this.project.baseDir, "AGENTS.md");
       const projectAgentsFileExists = await fileExists(projectAgentsPath);
       if (projectAgentsFileExists) {
         logger.info("AGENTS.md file created successfully", {
           path: projectAgentsPath
         });
-        this.addLogMessage("info", "AGENTS.md has been successfully initialized.");
-        const [answer] = await this.askQuestion({
-          baseDir: this.project.baseDir,
-          taskId: this.taskId,
-          text: "Do you want to add AGENTS.md as read-only file for Aider (in .aider.conf.yml)?",
-          defaultAnswer: "y",
-          internal: false
-        });
-        if (answer === "y") {
-          await this.addProjectAgentsToAiderConfig();
-        }
       } else {
         logger.warn("AGENTS.md file was not created");
         this.addLogMessage("warning", "AGENTS.md file was not created.");
@@ -16037,37 +16046,6 @@ ${contentText}</agent-response>`;
       this.contextManager.setContextMessages(messages, false);
     }
   }
-  async addProjectAgentsToAiderConfig() {
-    const aiderConfigPath = path.join(this.project.baseDir, ".aider.conf.yml");
-    const projectAgentsRelativePath = "AGENTS.md";
-    try {
-      let config = {};
-      if (await fileExists(aiderConfigPath)) {
-        const configContent = await fs.readFile(aiderConfigPath, "utf8");
-        config = YAML.parse(configContent) || {};
-      }
-      if (!config.read) {
-        config.read = [];
-      } else if (!Array.isArray(config.read)) {
-        config.read = [config.read];
-      }
-      if (!config.read.includes(projectAgentsRelativePath)) {
-        config.read.push(projectAgentsRelativePath);
-        const yamlContent = YAML.stringify(config);
-        await fs.writeFile(aiderConfigPath, yamlContent, "utf8");
-        logger.info("Added AGENTS.md to .aider.conf.yml", {
-          path: aiderConfigPath
-        });
-        this.addLogMessage("info", `Added ${projectAgentsRelativePath} to .aider.conf.yml`);
-      } else {
-        logger.info("AGENTS.md already exists in .aider.conf.yml");
-      }
-    } catch (error) {
-      logger.error("Error updating .aider.conf.yml:", error);
-      this.addLogMessage("error", `Failed to update .aider.conf.yml: ${error instanceof Error ? error.message : String(error)}`);
-      throw error;
-    }
-  }
   async runExtensionCommand(extensionCommand, args, mode) {
     const { command } = extensionCommand;
     logger.info("Running extension command:", {
@@ -16939,7 +16917,7 @@ const migrateSessionFile = async (project, sessionsDirPath, tasksDirPath, sessio
   }
 };
 class Project {
-  constructor(baseDir, store, mcpManager, telemetryManager, dataManager, eventManager, modelManager, worktreeManager, agentProfileManager, memoryManager, hookManager, promptsManager, extensionManager) {
+  constructor(baseDir, store, mcpManager, telemetryManager, dataManager, eventManager, modelManager, worktreeManager, agentProfileManager, memoryManager, promptsManager, extensionManager) {
     this.baseDir = baseDir;
     this.store = store;
     this.mcpManager = mcpManager;
@@ -16950,7 +16928,6 @@ class Project {
     this.worktreeManager = worktreeManager;
     this.agentProfileManager = agentProfileManager;
     this.memoryManager = memoryManager;
-    this.hookManager = hookManager;
     this.promptsManager = promptsManager;
     this.extensionManager = extensionManager;
     this.customCommandManager = new CustomCommandManager(this, this.eventManager, this.extensionManager);
@@ -16992,6 +16969,7 @@ class Project {
       }
     }
     const sourceTask = parentTask || this.getMostRecentTask();
+    const defaultWorkingMode = this.store.getSettings().taskSettings.defaultWorkingMode || "local";
     let initialTaskData;
     if (sourceTask) {
       initialTaskData = {
@@ -17005,6 +16983,7 @@ class Project {
         provider: parentTask?.task.provider,
         model: parentTask?.task.model,
         weakModelLocked: sourceTask.task.weakModelLocked,
+        workingMode: defaultWorkingMode,
         ...parentTask ? {
           workingMode: parentTask.task.workingMode,
           worktree: parentTask.task.worktree
@@ -17014,9 +16993,10 @@ class Project {
     } else {
       const providerModels = await this.modelManager.getProviderModels();
       initialTaskData = {
-        mainModel: determineMainModel(this.store.getSettings(), this.store.getProviders(), providerModels.models || [], this.baseDir),
+        mainModel: determineMainModel(this.store.getSettings(), this.modelManager.getProviders(), providerModels.models || [], this.baseDir),
         weakModel: determineWeakModel(this.baseDir),
         currentMode: "agent",
+        workingMode: defaultWorkingMode,
         ...normalizedParams
       };
     }
@@ -17056,13 +17036,11 @@ class Project {
       this.modelManager,
       this.worktreeManager,
       this.memoryManager,
-      this.hookManager,
       this.promptsManager,
       this.extensionManager,
       initialTaskData
     );
     this.tasks.set(taskId, task);
-    void task.hookManager.trigger("onTaskCreated", { task: task.task }, task, this);
     const extResult = await this.extensionManager.dispatchEvent("onTaskPrepared", { task: task.task }, this, task);
     if (extResult.task) {
       Object.assign(task.task, extResult.task);
@@ -17299,7 +17277,6 @@ class Project {
     await this.extensionManager.dispatchEvent("onProjectStopped", { baseDir: this.baseDir }, this);
     this.customCommandManager.dispose();
     this.agentProfileManager.removeProject(this.baseDir);
-    await this.hookManager.stopWatchingProject(this.baseDir);
     await this.promptsManager.unwatchProject(this.baseDir);
     this.extensionManager.stopProjectWatcher(this.baseDir);
     await Promise.all(Array.from(this.tasks.values()).map((task) => task.close()));
@@ -17316,7 +17293,7 @@ class Project {
   }
 }
 class ProjectManager {
-  constructor(store, mcpManager, telemetryManager, dataManager, eventManager, modelManager, worktreeManager, agentProfileManager, memoryManager, hookManager, promptsManager, extensionManager) {
+  constructor(store, mcpManager, telemetryManager, dataManager, eventManager, modelManager, worktreeManager, agentProfileManager, memoryManager, promptsManager, extensionManager) {
     this.store = store;
     this.mcpManager = mcpManager;
     this.telemetryManager = telemetryManager;
@@ -17325,7 +17302,6 @@ class ProjectManager {
     this.modelManager = modelManager;
     this.agentProfileManager = agentProfileManager;
     this.memoryManager = memoryManager;
-    this.hookManager = hookManager;
     this.promptsManager = promptsManager;
     this.extensionManager = extensionManager;
     this.worktreeManager = worktreeManager;
@@ -17348,7 +17324,6 @@ class ProjectManager {
       this.worktreeManager,
       this.agentProfileManager,
       this.memoryManager,
-      this.hookManager,
       this.promptsManager,
       this.extensionManager
     );
@@ -21301,13 +21276,14 @@ class ModelManager {
     "vertex-ai": vertexAiProviderStrategy,
     "zai-plan": zaiPlanProviderStrategy
   };
+  extensionProviders = /* @__PURE__ */ new Map();
   async init() {
     try {
       logger.info("Initializing ModelInfoManager...");
       this.updateEnvVarsProviders();
       await this.loadModelsInfo();
       await this.loadModelOverrides();
-      await this.loadProviderModels(this.store.getProviders().filter((p) => !p.disabled));
+      await this.loadProviderModels(this.getProviders().filter((p) => !p.disabled));
       logger.info("ModelInfoManager initialized successfully.", {
         modelCount: Object.keys(this.modelsInfo).length
       });
@@ -21545,7 +21521,8 @@ class ModelManager {
         this.providerModels = {};
         this.providerErrors = {};
       }
-      await this.loadProviderModels(this.store.getProviders().filter((p) => !p.disabled));
+      const allProviders = this.getProviders();
+      await this.loadProviderModels(allProviders.filter((p) => !p.disabled));
     }
     return {
       models: Object.values(this.providerModels).flat(),
@@ -21604,7 +21581,7 @@ class ModelManager {
       logger.info(`Added model override: ${providerId}/${modelId}`);
     }
     await this.saveModelOverrides();
-    await this.loadProviderModels(this.store.getProviders().filter((provider) => provider.id === providerId));
+    await this.loadProviderModels(this.getProviders().filter((provider) => provider.id === providerId));
   }
   async deleteModel(providerId, modelId) {
     await this.initPromise;
@@ -21616,7 +21593,7 @@ class ModelManager {
     if (this.modelOverrides.length < initialLength) {
       await this.saveModelOverrides();
       logger.info(`Deleted model override: ${providerId}/${modelId}`);
-      await this.loadProviderModels(this.store.getProviders().filter((provider) => provider.id === providerId));
+      await this.loadProviderModels(this.getProviders().filter((provider) => provider.id === providerId));
     } else {
       logger.warn(`Model override not found for deletion: ${providerId}/${modelId}`);
     }
@@ -21644,12 +21621,12 @@ class ModelManager {
       affectedProviderIds.add(providerId);
     }
     await this.saveModelOverrides();
-    const affectedProviders = this.store.getProviders().filter((provider) => affectedProviderIds.has(provider.id));
+    const affectedProviders = this.getProviders().filter((provider) => affectedProviderIds.has(provider.id));
     await this.loadProviderModels(affectedProviders);
     logger.info(`Bulk updated ${modelUpdates.length} model overrides for ${affectedProviderIds.size} providers`);
   }
   getAiderModelMapping(modelName, projectDir) {
-    const providers = this.store.getProviders();
+    const providers = this.getProviders();
     const [providerId, modelId] = extractProviderModel(modelName);
     if (!providerId || !modelId) {
       logger.error("Invalid provider/model format:", modelName);
@@ -21862,6 +21839,75 @@ class ModelManager {
     }
     return strategy.isRetryable(error);
   }
+  registerExtensionProviders(providers) {
+    const newProfiles = [];
+    for (const registered of providers) {
+      const { provider } = registered;
+      this.providerRegistry[provider.provider.name] = {
+        ...provider.strategy,
+        createLlm: (profile2, model, settings, projectDir) => provider.strategy.createLlm(profile2, model, settings, projectDir),
+        getUsageReport: provider.strategy.getUsageReport || getDefaultUsageReport,
+        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,
+        hasEnvVars: () => false,
+        getAiderMapping: provider.strategy.getAiderMapping ? provider.strategy.getAiderMapping : (_provider, modelId) => ({
+          modelName: modelId,
+          environmentVariables: {}
+        })
+      };
+      const profile = {
+        id: provider.id,
+        name: provider.name,
+        provider: provider.provider,
+        headers: provider.headers,
+        extensionId: registered.extensionId
+      };
+      logger.info(`Registering extension provider: ${profile.name} (ID: ${profile.id}) from extension ${registered.extensionId}`);
+      this.extensionProviders.set(`${registered.extensionId}:${provider.id}`, {
+        provider,
+        profile
+      });
+      newProfiles.push(profile);
+    }
+    if (newProfiles.length > 0) {
+      logger.info(`[Models] Registered ${newProfiles.length} extension provider(s)`);
+      void this.loadProviderModels(newProfiles);
+      this.eventManager.sendProvidersUpdated(this.getProviders());
+    }
+  }
+  unregisterExtensionProviders(extensionId) {
+    const toRemove = [];
+    for (const [key, entry] of this.extensionProviders) {
+      if (entry.profile.extensionId === extensionId) {
+        toRemove.push(key);
+      }
+    }
+    if (toRemove.length === 0) {
+      return;
+    }
+    for (const key of toRemove) {
+      const entry = this.extensionProviders.get(key);
+      delete this.providerRegistry[entry.provider.provider.name];
+      delete this.providerModels[entry.profile.id];
+      delete this.providerErrors[entry.profile.id];
+      this.extensionProviders.delete(key);
+    }
+    logger.info(`[Models] Unregistered ${toRemove.length} extension provider(s) for extension ${extensionId}`);
+    this.eventManager.sendProviderModelsUpdated({
+      models: Object.values(this.providerModels).flat(),
+      loading: false,
+      errors: this.providerErrors
+    });
+    this.eventManager.sendProvidersUpdated(this.getProviders());
+  }
+  getProviders() {
+    return [...this.store.getProviders(), ...this.getExtensionProviderProfiles()];
+  }
+  getExtensionProviderProfiles() {
+    return [...this.extensionProviders.values()].map((e) => e.profile);
+  }
 }
 class DataManager {
   db;
@@ -22011,9 +22057,8 @@ class DataManager {
   }
 }
 class TerminalManager {
-  constructor(eventManager, worktreeManager, telemetryManager) {
+  constructor(eventManager, telemetryManager) {
     this.eventManager = eventManager;
-    this.worktreeManager = worktreeManager;
     this.telemetryManager = telemetryManager;
   }
   terminals = /* @__PURE__ */ new Map();
@@ -22036,11 +22081,10 @@ class TerminalManager {
     }
     return [];
   }
-  async createTerminal(baseDir, taskId, cols = 80, rows = 24) {
+  async createTerminal(baseDir, taskDir, taskId, cols = 80, rows = 24) {
     const terminalId = uuid.v4();
     try {
-      const worktree = await this.worktreeManager.getTaskWorktree(baseDir, taskId);
-      const cwd = worktree ? worktree.path : baseDir;
+      const cwd = taskDir;
       const shell = this.getShellCommand();
       const args = this.getShellArgs();
       logger.info("Creating terminal:", { terminalId, baseDir, cwd, shell, args, cols, rows });
@@ -23393,7 +23437,9 @@ class ExtensionFetcher {
       return cached.extensions;
     }
     try {
-      const extensions = await this.fetchExtensionsViaGitClone(repoUrl);
+      const repoDir = await this.ensureRepoCloned(repoUrl);
+      const extensionsPath = this.getExtensionsPath(repoUrl, repoDir);
+      const extensions = await this.scanForExtensions(extensionsPath, repoUrl);
       this.cache.set(repoUrl, {
         timestamp: now,
         extensions
@@ -23408,37 +23454,39 @@ class ExtensionFetcher {
       throw error;
     }
   }
-  async fetchExtensionsViaGitClone(repoUrl) {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "ext-repo-"));
+  getRepoDirName(repoUrl) {
     try {
-      const cloneUrl = this.getCloneUrl(repoUrl);
-      if (!cloneUrl) {
-        throw new Error(`Invalid repository URL: ${repoUrl}`);
-      }
-      const extensionSubPath = this.getExtensionSubPath(repoUrl);
-      if (extensionSubPath) {
-        logger.info(`[ExtensionFetcher] Sparse cloning repository to ${tempDir}, path: ${extensionSubPath}`);
-        await execWithShellPath(`git clone --depth 1 --sparse "${cloneUrl}" "${tempDir}"`, {
-          cwd: os.tmpdir()
-        });
-        await execWithShellPath(`git -C "${tempDir}" sparse-checkout set "${extensionSubPath}"`, {
-          cwd: tempDir
-        });
-      } else {
-        logger.info(`[ExtensionFetcher] Cloning repository to ${tempDir}`);
-        await execWithShellPath(`git clone --depth 1 "${cloneUrl}" "${tempDir}"`, {
-          cwd: os.tmpdir()
-        });
+      const url = new URL(repoUrl);
+      const pathParts = url.pathname.split("/").filter(Boolean);
+      if (pathParts.length >= 2) {
+        return `${pathParts[0]}-${pathParts[1]}`;
       }
-      const extensionsPath = this.getExtensionsPath(repoUrl, tempDir);
-      return await this.scanForExtensions(extensionsPath, repoUrl);
-    } finally {
+    } catch {
+    }
+    return repoUrl.replace(/[^a-zA-Z0-9]/g, "-");
+  }
+  async ensureRepoCloned(repoUrl) {
+    const cloneUrl = this.getCloneUrl(repoUrl);
+    if (!cloneUrl) {
+      throw new Error(`Invalid repository URL: ${repoUrl}`);
+    }
+    const dirName = this.getRepoDirName(repoUrl);
+    const repoDir = path.join(EXTENSIONS_REPOS_CACHE_DIR, dirName);
+    const dirExists = await this.fileExists(path.join(repoDir, ".git"));
+    if (dirExists) {
       try {
-        await fs.rm(tempDir, { recursive: true, force: true });
-      } catch (cleanupError) {
-        logger.warn(`[ExtensionFetcher] Failed to cleanup temp directory ${tempDir}:`, cleanupError);
+        logger.debug(`[ExtensionFetcher] Pulling existing repository cache at ${repoDir}`);
+        await execWithShellPath(`git -C "${repoDir}" pull`, { cwd: repoDir });
+        return repoDir;
+      } catch (pullError) {
+        logger.warn(`[ExtensionFetcher] git pull failed for ${repoDir}, removing and re-cloning:`, pullError);
+        await fs.rm(repoDir, { recursive: true, force: true });
       }
     }
+    await fs.mkdir(EXTENSIONS_REPOS_CACHE_DIR, { recursive: true });
+    logger.info(`[ExtensionFetcher] Cloning repository to ${repoDir}`);
+    await execWithShellPath(`git clone "${cloneUrl}" "${repoDir}"`, { cwd: EXTENSIONS_REPOS_CACHE_DIR });
+    return repoDir;
   }
   getCloneUrl(webUrl) {
     try {
@@ -23470,17 +23518,11 @@ class ExtensionFetcher {
     }
   }
   getExtensionsPath(repoUrl, clonedRepoPath) {
-    try {
-      const url = new URL(repoUrl);
-      const pathParts = url.pathname.split("/").filter(Boolean);
-      if (pathParts.length > 4 && pathParts[2] === "tree") {
-        const extensionPath = pathParts.slice(4).join("/");
-        return path.join(clonedRepoPath, extensionPath);
-      }
-      return clonedRepoPath;
-    } catch {
-      return clonedRepoPath;
+    const subPath = this.getExtensionSubPath(repoUrl);
+    if (subPath) {
+      return path.join(clonedRepoPath, subPath);
     }
+    return clonedRepoPath;
   }
   async scanForExtensions(extensionsPath, repoUrl) {
     const extensions = [];
@@ -23850,6 +23892,10 @@ class ExtensionManager {
         reloadComponents: true
       });
     }
+    const providers = this.getProviders(project);
+    if (providers.length > 0) {
+      this.modelManager.registerExtensionProviders(providers);
+    }
     this.debouncedNotifyListeners();
   }
   getExtensions(projectDir) {
@@ -23908,6 +23954,7 @@ class ExtensionManager {
       }
     }
     this.registry.unregister(filePath);
+    this.modelManager.unregisterExtensionProviders(extension.id);
     logger.debug(`[Extensions] Unloaded extension: ${filePath}`);
   }
   findExtensionByPath(filePath) {
@@ -24336,6 +24383,39 @@ class ExtensionManager {
       errors
     };
   }
+  getProviders(project) {
+    const collectedProviders = [];
+    const allExtensions = this.registry.getExtensions(project?.baseDir);
+    const extensions = this.filterEnabledExtensions(allExtensions);
+    for (const loaded of extensions) {
+      const { instance, metadata } = loaded;
+      if (!instance.getProviders) {
+        continue;
+      }
+      try {
+        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, project, void 0);
+        const providers = instance.getProviders(context);
+        if (!Array.isArray(providers)) {
+          logger.error(`[Extensions] Extension '${metadata.name}' getProviders() did not return an array`);
+          continue;
+        }
+        for (const provider of providers) {
+          if (!provider.id || !provider.name || !provider.strategy) {
+            logger.error(`[Extensions] Invalid provider from extension '${metadata.name}': missing id, name or strategy`);
+            continue;
+          }
+          collectedProviders.push({
+            extensionId: loaded.id,
+            extensionName: metadata.name,
+            provider
+          });
+        }
+      } catch (error) {
+        logger.error(`[Extensions] Failed to get providers from extension '${metadata.name}':`, error);
+      }
+    }
+    return collectedProviders;
+  }
   getUIComponents(project, task) {
     const collectedComponents = [];
     const allExtensions = this.registry.getExtensions(project?.baseDir);
@@ -24506,7 +24586,7 @@ class ExtensionManager {
       const allExtensions = [];
       for (const repoUrl of repositories) {
         try {
-          const extensions = await this.fetcher.fetchExtensionsViaGitClone(repoUrl);
+          const extensions = await this.fetcher.fetchExtensionsFromRepo(repoUrl, true);
           allExtensions.push(...extensions);
         } catch (error) {
           logger.error(`[ExtensionManager] Failed to fetch extensions from ${repoUrl}:`, error);
@@ -24549,33 +24629,19 @@ class ExtensionManager {
         await fs.writeFile(targetPath, code, "utf-8");
         logger.debug(`[Extensions] Installed single-file extension: ${extension.file}`);
       } else if (extension.type === "folder" && extension.folder) {
-        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "ext-install-"));
-        try {
-          const cloneUrl = this.getCloneUrl(repositoryUrl);
-          if (!cloneUrl) {
-            throw new Error("Invalid repository URL for cloning");
-          }
-          logger.debug(`[Extensions] Cloning repository to ${tempDir}`);
-          await execWithShellPath(`git clone --depth 1 "${cloneUrl}" "${tempDir}"`);
-          const extensionsPath = this.getExtensionsPath(repositoryUrl, tempDir);
-          const sourcePath = path.join(extensionsPath, extension.folder);
-          const targetPath = path.join(targetDir, extension.folder);
-          if (!await this.fileExists(sourcePath)) {
-            throw new Error(`Extension folder not found in repository: ${extension.folder}`);
-          }
-          await fs.cp(sourcePath, targetPath, { recursive: true });
-          if (extension.hasDependencies) {
-            logger.debug(`[Extensions] Installing dependencies for ${extension.name}...`);
-            await this.installDependencies(targetPath);
-          }
-          logger.debug(`[Extensions] Installed folder extension: ${extension.folder}`);
-        } finally {
-          try {
-            await fs.rm(tempDir, { recursive: true, force: true });
-          } catch (cleanupError) {
-            logger.warn(`[Extensions] Failed to cleanup temp directory ${tempDir}:`, cleanupError);
-          }
+        const repoDir = await this.fetcher.ensureRepoCloned(repositoryUrl);
+        const extensionsPath = this.fetcher.getExtensionsPath(repositoryUrl, repoDir);
+        const sourcePath = path.join(extensionsPath, extension.folder);
+        const targetPath = path.join(targetDir, extension.folder);
+        if (!await this.fileExists(sourcePath)) {
+          throw new Error(`Extension folder not found in repository: ${extension.folder}`);
         }
+        await fs.cp(sourcePath, targetPath, { recursive: true });
+        if (extension.hasDependencies) {
+          logger.debug(`[Extensions] Installing dependencies for ${extension.name}...`);
+          await this.installDependencies(targetPath);
+        }
+        logger.debug(`[Extensions] Installed folder extension: ${extension.folder}`);
       }
       await this.loadExtensionsForDir(targetDir, project);
       logger.info(`[Extensions] Successfully installed ${extension.name}`);
@@ -24606,36 +24672,6 @@ class ExtensionManager {
       child.on("error", reject);
     });
   }
-  getCloneUrl(webUrl) {
-    try {
-      const url = new URL(webUrl);
-      if (url.hostname !== "github.com") {
-        return null;
-      }
-      const pathParts = url.pathname.split("/").filter(Boolean);
-      if (pathParts.length < 2) {
-        return null;
-      }
-      const owner = pathParts[0];
-      const repo = pathParts[1];
-      return `https://github.com/${owner}/${repo}.git`;
-    } catch {
-      return null;
-    }
-  }
-  getExtensionsPath(repoUrl, clonedRepoPath) {
-    try {
-      const url = new URL(repoUrl);
-      const pathParts = url.pathname.split("/").filter(Boolean);
-      if (pathParts.length > 4 && pathParts[2] === "tree") {
-        const extensionPath = pathParts.slice(4).join("/");
-        return path.join(clonedRepoPath, extensionPath);
-      }
-      return clonedRepoPath;
-    } catch {
-      return clonedRepoPath;
-    }
-  }
   /**
    * Uninstall an extension
    * @param extensionId - Extension identifier (filePath)
@@ -24674,10 +24710,72 @@ class ExtensionManager {
       return false;
     }
   }
+  /**
+   * Update an extension from a repository, overwriting existing files
+   * @param extensionId - Extension identifier (filePath of installed extension)
+   * @param repositoryUrl - Repository URL where the extension is located
+   * @param project - Optional project for project-level extension
+   * @returns true if update succeeded
+   */
+  async updateExtension(extensionId, repositoryUrl, project) {
+    const projectDir = project?.baseDir;
+    try {
+      logger.debug(`[Extensions] Updating extension '${extensionId}' from ${repositoryUrl}`);
+      const existingExtension = this.registry.getExtension(extensionId);
+      if (!existingExtension) {
+        throw new Error(`Extension '${extensionId}' not found`);
+      }
+      if (!existingExtension.filePath) {
+        throw new Error(`Extension '${extensionId}' has no file path`);
+      }
+      const targetDir = projectDir ? path.join(projectDir, AIDER_DESK_EXTENSIONS_DIR) : AIDER_DESK_GLOBAL_EXTENSIONS_DIR;
+      const availableExtensions = await this.getAvailableExtensions([repositoryUrl]);
+      const extension = availableExtensions.find((ext) => ext.id === existingExtension.id);
+      if (!extension) {
+        throw new Error(`Extension '${existingExtension.id}' not found in repository`);
+      }
+      const githubRawBase = this.fetcher.getRawUrl(repositoryUrl);
+      if (!githubRawBase) {
+        throw new Error("Invalid GitHub repository URL");
+      }
+      await this.unloadExtensionsForDir(targetDir);
+      if (extension.type === "single" && extension.file) {
+        const url = `${githubRawBase}/${extension.file}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+          throw new Error(`Failed to download: ${response.statusText}`);
+        }
+        const code = await response.text();
+        const targetPath = path.join(targetDir, extension.file);
+        await fs.writeFile(targetPath, code, "utf-8");
+        logger.debug(`[Extensions] Updated single-file extension: ${extension.file}`);
+      } else if (extension.type === "folder" && extension.folder) {
+        const repoDir = await this.fetcher.ensureRepoCloned(repositoryUrl);
+        const extensionsPath = this.fetcher.getExtensionsPath(repositoryUrl, repoDir);
+        const sourcePath = path.join(extensionsPath, extension.folder);
+        const targetPath = path.join(targetDir, extension.folder);
+        if (!await this.fileExists(sourcePath)) {
+          throw new Error(`Extension folder not found in repository: ${extension.folder}`);
+        }
+        await fs.cp(sourcePath, targetPath, { recursive: true });
+        const packageJsonPath = path.join(targetPath, "package.json");
+        if (await this.fileExists(packageJsonPath)) {
+          logger.debug(`[Extensions] Installing dependencies for ${extension.name}...`);
+          await this.installDependencies(targetPath);
+        }
+        logger.debug(`[Extensions] Updated folder extension: ${extension.folder}`);
+      }
+      await this.loadExtensionsForDir(targetDir, project);
+      logger.info(`[Extensions] Successfully updated ${extension.name}`);
+      return true;
+    } catch (error) {
+      logger.error(`[Extensions] Failed to update extension '${extensionId}':`, error);
+      return false;
+    }
+  }
   /**
    * Dispatches an event to all loaded and initialized extensions.
-   * Runs in parallel with HookManager triggers, allowing extensions to respond
-   * to the same events as hooks. Events can be modified or blocked by extensions.
+   * Events can be modified or blocked by extensions.
    *
    * @param eventName - The name of the event to dispatch
    * @param event - The event payload
@@ -25062,7 +25160,9 @@ class EventsHandler {
   }
   async createTerminal(baseDir, taskId, cols, rows) {
     try {
-      return await this.terminalManager.createTerminal(baseDir, taskId, cols, rows);
+      const task = this.projectManager.getProject(baseDir).getTask(taskId);
+      const taskDir = task?.getTaskDir() ?? baseDir;
+      return await this.terminalManager.createTerminal(baseDir, taskDir, taskId, cols, rows);
     } catch (error) {
       logger.error("Failed to create terminal:", { baseDir, error });
       throw error;
@@ -25358,14 +25458,14 @@ ${error instanceof Error ? error.message : String(error)}`);
     return providerModels;
   }
   getProviders() {
-    return this.store.getProviders();
+    return this.modelManager.getProviders();
   }
   async updateProviders(providers) {
     const oldProviders = this.store.getProviders();
     this.store.setProviders(providers);
     await this.modelManager.providersChanged(oldProviders, providers);
     this.projectManager.modelsUpdated();
-    this.eventManager.sendProvidersUpdated(providers);
+    this.eventManager.sendProvidersUpdated(this.modelManager.getProviders());
   }
   async upsertModel(providerId, modelId, model) {
     await this.modelManager.upsertModel(providerId, modelId, model);
@@ -25453,8 +25553,8 @@ ${error instanceof Error ? error.message : String(error)}`);
   async clearAllTodos(baseDir, taskId) {
     return await this.projectManager.getProject(baseDir).getTask(taskId)?.clearAllTodos() || [];
   }
-  async initProjectRulesFile(baseDir, taskId) {
-    return this.projectManager.getProject(baseDir).getTask(taskId)?.initProjectAgentsFile();
+  async initProjectRulesFile(baseDir, taskId, args) {
+    return this.projectManager.getProject(baseDir).getTask(taskId)?.initProjectAgentsFile(args);
   }
   async enableServer(username, password) {
     const currentSettings = this.store.getSettings();
@@ -25571,6 +25671,16 @@ ${error instanceof Error ? error.message : String(error)}`);
   async uninstallExtension(extensionId, projectDir) {
     return await this.extensionManager.uninstallExtension(extensionId, projectDir);
   }
+  async updateExtension(extensionId, repositoryUrl, projectDir) {
+    let project = void 0;
+    if (projectDir) {
+      project = this.projectManager.getProject(projectDir);
+      if (!project) {
+        throw new Error("Project not found");
+      }
+    }
+    return await this.extensionManager.updateExtension(extensionId, repositoryUrl, project);
+  }
   getUIComponents(placement, projectDir, taskId) {
     const project = projectDir ? this.projectManager.getProject(projectDir) : void 0;
     const task = taskId && project ? project.getTask(taskId) ?? void 0 : void 0;
@@ -25609,216 +25719,6 @@ ${error instanceof Error ? error.message : String(error)}`);
     return await this.extensionManager.executeUIExtensionAction(extensionId, componentId, action, args, project, task);
   }
 }
-class HookContextImpl {
-  constructor(task, project) {
-    this.task = task;
-    this.project = project;
-  }
-  addInfoMessage(message) {
-    this.task.addLogMessage("info", message);
-  }
-  addWarningMessage(message) {
-    this.task.addLogMessage("warning", message);
-  }
-  addErrorMessage(message) {
-    this.task.addLogMessage("error", message);
-  }
-  addLoadingMessage(message, finished = false) {
-    this.task.addLogMessage("loading", message, finished);
-  }
-  async setTaskName(name) {
-    await this.task.saveTask({ name });
-  }
-  async addContextMessage(role, content) {
-    await this.task.addRoleContextMessage(role === "user" ? MessageRole.User : MessageRole.Assistant, content);
-  }
-  get taskData() {
-    return this.task.task;
-  }
-  get projectDir() {
-    return this.task.getProjectDir();
-  }
-}
-class HookManager {
-  globalHooks = [];
-  projectHooksCache = /* @__PURE__ */ new Map();
-  globalInitialized = false;
-  globalWatcher = null;
-  projectWatchers = /* @__PURE__ */ new Map();
-  constructor() {
-  }
-  async init() {
-    if (this.globalInitialized) {
-      return;
-    }
-    this.globalHooks = await this.loadHooksFromDir(AIDER_DESK_GLOBAL_HOOKS_DIR);
-    await this.setupGlobalWatcher();
-    this.globalInitialized = true;
-  }
-  async setupGlobalWatcher() {
-    if (this.globalWatcher) {
-      await this.globalWatcher.close();
-    }
-    this.globalWatcher = await this.setupWatcherForDir(AIDER_DESK_GLOBAL_HOOKS_DIR, async () => {
-      logger.debug("Global hooks changed, reloading...");
-      this.globalHooks = await this.loadHooksFromDir(AIDER_DESK_GLOBAL_HOOKS_DIR);
-    });
-  }
-  async reloadProjectHooks(projectDir) {
-    const projectHooksDir = path.join(projectDir, AIDER_DESK_HOOKS_DIR);
-    const hooks = await this.loadHooksFromDir(projectHooksDir);
-    this.projectHooksCache.set(projectDir, hooks);
-    if (!this.projectWatchers.has(projectDir)) {
-      const watcher = await this.setupWatcherForDir(projectHooksDir, async () => {
-        logger.debug(`Project hooks changed for ${projectDir}, reloading...`);
-        const updatedHooks = await this.loadHooksFromDir(projectHooksDir);
-        this.projectHooksCache.set(projectDir, updatedHooks);
-      });
-      if (watcher) {
-        this.projectWatchers.set(projectDir, watcher);
-      }
-    }
-    logger.debug(`Reloaded hooks for project: ${projectDir}`);
-  }
-  async stopWatchingProject(projectDir) {
-    const watcher = this.projectWatchers.get(projectDir);
-    if (watcher) {
-      await watcher.close();
-      this.projectWatchers.delete(projectDir);
-    }
-    this.projectHooksCache.delete(projectDir);
-    logger.debug(`Stopped watching hooks for project: ${projectDir}`);
-  }
-  async setupWatcherForDir(dir, onChange) {
-    try {
-      const dirExists = await fs.access(dir).then(() => true).catch(() => false);
-      if (!dirExists) {
-        await fs.mkdir(dir, { recursive: true });
-      }
-      const debouncedOnChange = debounce(onChange, 1e3);
-      const watcher = chokidar.watch(dir, {
-        persistent: true,
-        usePolling: true,
-        ignoreInitial: true
-      });
-      watcher.on("add", debouncedOnChange).on("change", debouncedOnChange).on("unlink", debouncedOnChange).on("error", (error) => {
-        logger.error(`Watcher error for hooks directory ${dir}:`, error);
-      });
-      return watcher;
-    } catch (error) {
-      logger.error(`Failed to setup watcher for hooks directory ${dir}:`, error);
-      return null;
-    }
-  }
-  async loadHooksFromDir(dir) {
-    const hooks = [];
-    try {
-      const dirExists = await fs.access(dir).then(() => true).catch(() => false);
-      if (!dirExists) {
-        return hooks;
-      }
-      const files = await fs.readdir(dir);
-      for (const file of files) {
-        if (file.endsWith(".js")) {
-          const filePath = path.join(dir, file);
-          try {
-            const resolvedPath = require.resolve(filePath);
-            delete require.cache[resolvedPath];
-            const hookFile = require(filePath);
-            hooks.push(hookFile);
-            logger.debug(`Loaded hook file: ${filePath}`);
-          } catch (error) {
-            logger.error(`Failed to load hook file ${filePath}:`, error);
-          }
-        }
-      }
-    } catch (error) {
-      logger.error(`Failed to load hooks from ${dir}:`, error);
-    }
-    return hooks;
-  }
-  async trigger(hookName, event, task, project) {
-    if (!this.globalInitialized) {
-      await this.init();
-    }
-    let projectHooks = this.projectHooksCache.get(project.baseDir);
-    if (projectHooks === void 0) {
-      await this.reloadProjectHooks(project.baseDir);
-      projectHooks = this.projectHooksCache.get(project.baseDir) || [];
-    }
-    const allHooks = [...this.globalHooks, ...projectHooks];
-    const context = new HookContextImpl(task, project);
-    let currentEvent = { ...event };
-    let blocked = false;
-    let hookResult = void 0;
-    for (const hook of allHooks) {
-      logger.debug(`Executing hook ${hookName}`, {
-        hookName,
-        event,
-        hook
-      });
-      const hookFn = hook[hookName];
-      if (typeof hookFn === "function") {
-        logger.debug(`Hook function found for ${hookName}`, {
-          hookName,
-          event,
-          hook
-        });
-        try {
-          const result = await hookFn(currentEvent, context);
-          logger.debug(`Hook function result for ${hookName}`, {
-            hookName,
-            event,
-            hook,
-            result
-          });
-          if (result === false) {
-            if (hookName === "onHandleApproval") {
-              hookResult = false;
-            } else {
-              blocked = true;
-            }
-            break;
-          }
-          if (result === true && hookName === "onHandleApproval") {
-            hookResult = true;
-            break;
-          }
-          if (typeof result === "string" && hookName === "onQuestionAsked") {
-            hookResult = result;
-            break;
-          }
-          if (result && typeof result === "object") {
-            if (hookName === "onResponseMessageProcessed") {
-              hookResult = result;
-            } else {
-              currentEvent = { ...currentEvent, ...result };
-            }
-          }
-          if (result && hookName === "onToolFinished") {
-            hookResult = result;
-            currentEvent = { ...currentEvent, result };
-          }
-        } catch (error) {
-          logger.error(`Error executing hook ${hookName}:`, error);
-        }
-      }
-    }
-    return { event: currentEvent, blocked, result: hookResult };
-  }
-  async dispose() {
-    if (this.globalWatcher) {
-      await this.globalWatcher.close();
-      this.globalWatcher = null;
-    }
-    for (const watcher of this.projectWatchers.values()) {
-      await watcher.close();
-    }
-    this.projectWatchers.clear();
-    this.projectHooksCache.clear();
-    logger.debug("HookManager disposed");
-  }
-}
 const registerConditionalHelpers = () => {
   Handlebars.registerHelper("equals", (v1, v2) => v1 === v2);
   Handlebars.registerHelper("not", (v) => !v);
@@ -26164,7 +26064,7 @@ ${content}
     );
     return ruleFilesContent.filter(Boolean).join("\n");
   };
-  getInitProjectPrompt = async (task) => {
+  getInitProjectSystemPrompt = async (task) => {
     const data = {};
     return await this.render("init-project", data, task.getProjectDir(), task);
   };
@@ -26231,10 +26131,6 @@ const initManagers = async (store, windowManager) => {
   memoryManager.init().catch((error) => {
     logger.error("[Memory] Memory system initialization failed, continuing without memories:", error);
   });
-  const hookManager = new HookManager();
-  hookManager.init().catch((error) => {
-    logger.error("[Hooks] Hook system initialization failed:", error);
-  });
   const extensionManager = new ExtensionManager(store, modelManager, eventManager, telemetryManager);
   extensionManager.init().catch((error) => {
     logger.error("[Extensions] Extension system initialization failed, continuing without extensions:", error);
@@ -26258,11 +26154,10 @@ const initManagers = async (store, windowManager) => {
     worktreeManager,
     agentProfileManager,
     memoryManager,
-    hookManager,
     promptsManager,
     extensionManager
   );
-  const terminalManager = new TerminalManager(eventManager, worktreeManager, telemetryManager);
+  const terminalManager = new TerminalManager(eventManager, telemetryManager);
   const versionsManager = new VersionsManager(eventManager, store);
   const httpServer = http.createServer();
   const cloudflareTunnelManager = new CloudflareTunnelManager();
@@ -26303,7 +26198,6 @@ const initManagers = async (store, windowManager) => {
         mcpManager.close(),
         telemetryManager.destroy(),
         agentProfileManager.dispose(),
-        hookManager.dispose(),
         promptsManager.dispose(),
         extensionManager.dispose()
       ]);
@@ -26936,10 +26830,12 @@ const migrateV12ToV13 = (settings) => {
   };
 };
 const migrateProvidersV13toV14 = (settings) => {
-  const providers = Object.entries(settings.llmProviders).map(([name, provider]) => ({
-    id: name,
-    provider
-  }));
+  const providers = Object.entries(settings.llmProviders).map(
+    ([name, provider]) => ({
+      id: name,
+      provider
+    })
+  );
   return providers;
 };
 const migrateSettingsV14toV15 = (settings) => {
@@ -27107,7 +27003,8 @@ const DEFAULT_SETTINGS = {
     showTaskStateActions: true,
     worktreeSymlinkFolders: ["node_modules", "vendor", "__pycache__", ".venv", "venv"],
     contextCompactingThreshold: 0,
-    contextCompactionType: ContextCompactionType.Compact
+    contextCompactionType: ContextCompactionType.Compact,
+    defaultWorkingMode: "local"
   },
   extensions: {
     repositories: [AIDER_DESK_EXTENSIONS_REPO_URL],
@@ -27404,7 +27301,7 @@ const addProjectsFromEnv = async (store, modelManager, agentProfileManager) => {
     const defaultAgentProfileId = agentProfileManager.getDefaultAgentProfileId();
     const newProject = {
       baseDir: projectPath.endsWith("/") ? projectPath.slice(0, -1) : projectPath,
-      settings: getDefaultProjectSettings(store, providerModels.models || [], projectPath, defaultAgentProfileId),
+      settings: getDefaultProjectSettings(store, providerModels.models || [], projectPath, defaultAgentProfileId, modelManager.getProviders()),
       active: false
     };
     projectsFromEnv.push(newProject);