@aiderdesk/aiderdesk 0.70.0 → 0.71.0

package/out/runner.js

@@ -33,11 +33,10 @@ const os = require("os");
 const http = require("http");
 const istextorbinary = require("istextorbinary");
 const child_process = require("child_process");
-const util = require("util");
 const treeKill = require("tree-kill");
-const ai = require("ai");
 const glob = require("glob");
 const fs$1 = require("fs");
+const util = require("util");
 const dotenvx = require("@dotenvx/dotenvx");
 const YAML = require("yaml");
 const posthogNode = require("posthog-node");
@@ -66,6 +65,7 @@ const debounce = require("lodash/debounce.js");
 const crypto = require("crypto");
 const undici = require("undici");
 const globalAgent = require("global-agent");
+const ai = require("ai");
 const fileType = require("file-type");
 const anthropic = require("@ai-sdk/anthropic");
 const azure = require("@ai-sdk/azure");
@@ -281,6 +281,7 @@ var MessageViewMode = /* @__PURE__ */ ((MessageViewMode2) => {
   return MessageViewMode2;
 })(MessageViewMode || {});
 var ReasoningEffort = /* @__PURE__ */ ((ReasoningEffort2) => {
+  ReasoningEffort2["Max"] = "max";
   ReasoningEffort2["XHigh"] = "xhigh";
   ReasoningEffort2["High"] = "high";
   ReasoningEffort2["Medium"] = "medium";
@@ -820,7 +821,6 @@ const SETUP_COMPLETE_FILENAME = path.join(AIDER_DESK_DATA_DIR, "setup-complete")
 const PYTHON_VENV_DIR = path.join(AIDER_DESK_DATA_DIR, "python-venv");
 const PYTHON_COMMAND = process.platform === "win32" ? path.join(PYTHON_VENV_DIR, "Scripts", "python.exe") : path.join(PYTHON_VENV_DIR, "bin", "python");
 const AIDER_DESK_CONNECTOR_DIR = path.join(AIDER_DESK_DATA_DIR, "aider-connector");
-const AIDER_DESK_MCP_SERVER_DIR = path.join(AIDER_DESK_DATA_DIR, "mcp-server");
 const AIDER_DESK_BIN_DIR = path.join(AIDER_DESK_DATA_DIR, "bin");
 const UV_EXECUTABLE = process.platform === "win32" ? path.join(AIDER_DESK_BIN_DIR, "uv.exe") : path.join(AIDER_DESK_BIN_DIR, "uv");
 const RIPGREP_BINARY_PATH = process.platform === "win32" ? path.join(AIDER_DESK_BIN_DIR, "rg.exe") : path.join(AIDER_DESK_BIN_DIR, "rg");
@@ -1398,40 +1398,6 @@ const getShellPath = () => {
     return fallbackPath;
   }
 };
-const findExecutableInPath = (executable, checkOnly = false) => {
-  logger.debug(`Finding executable: ${executable}`);
-  const shellPath = getShellPath();
-  const pathSep = getPathSeparator();
-  const paths = shellPath.split(pathSep);
-  const isWindows = process.platform === "win32";
-  logger.debug(`Searching in ${paths.length} PATH directories`);
-  const executableNames = isWindows ? [executable, `${executable}.exe`, `${executable}.cmd`, `${executable}.bat`] : [executable];
-  let searchedPaths = 0;
-  for (const dir of paths) {
-    for (const execName of executableNames) {
-      const fullPath = path__namespace.join(dir, execName);
-      searchedPaths++;
-      try {
-        if (isWindows) {
-          fs__namespace.accessSync(fullPath, fs__namespace.constants.F_OK);
-          logger.debug(`Found executable at: ${fullPath}`);
-          return fullPath;
-        } else {
-          child_process.execSync(`test -x "${fullPath}"`, { stdio: "ignore" });
-          logger.debug(`Found executable at: ${fullPath}`);
-          return fullPath;
-        }
-      } catch {
-      }
-    }
-  }
-  if (!checkOnly) {
-    logger.error(`Executable '${executable}' not found after searching ${searchedPaths} paths`, {
-      firstFewPaths: paths.slice(0, 5).join(", ")
-    });
-  }
-  return null;
-};
 const getShellCommandArgs = (command) => {
   return ShellDetector.getShellCommandArgs(command);
 };
@@ -1502,7 +1468,6 @@ const AVAILABLE_PROVIDERS = [
   "cerebras",
   "deepseek",
   "gemini",
-  "gemini-cli",
   "gpustack",
   "groq",
   "kimi-plan",
@@ -1542,7 +1507,6 @@ const isLmStudioProvider = (provider) => provider.name === "lmstudio";
 const isDeepseekProvider = (provider) => provider.name === "deepseek";
 const isGroqProvider = (provider) => provider.name === "groq";
 const isCerebrasProvider = (provider) => provider.name === "cerebras";
-const isGeminiCliProvider = (provider) => provider.name === "gemini-cli";
 const isBedrockProvider = (provider) => provider.name === "bedrock";
 const isOpenAiCompatibleProvider = (provider) => provider.name === "openai-compatible";
 const isLitellmProvider = (provider) => provider.name === "litellm";
@@ -1563,7 +1527,6 @@ const DEFAULT_PROVIDER_MODELS = {
   cerebras: "qwen-3-235b-a22b-instruct-2507",
   deepseek: "deepseek-v4-pro",
   gemini: "gemini-pro-latest",
-  "gemini-cli": "gemini-2.5-pro",
   groq: "moonshotai/kimi-k2-instruct-0905",
   "kimi-plan": "k2p6",
   openai: "gpt-5.4",
@@ -1959,7 +1922,8 @@ const getDefaultProviderParams = (providerName) => {
     case "zai-plan":
       provider = {
         name: "zai-plan",
-        apiKey: ""
+        apiKey: "",
+        reasoningEffort: ReasoningEffort.Max
       };
       break;
     case "minimax":
@@ -1977,13 +1941,8 @@ const getDefaultProviderParams = (providerName) => {
     case "neuralwatt":
       provider = {
         name: "neuralwatt",
-        apiKey: ""
-      };
-      break;
-    case "gemini-cli":
-      provider = {
-        name: "gemini-cli",
-        projectId: ""
+        apiKey: "",
+        reasoningEffort: ReasoningEffort.High
       };
       break;
     default:
@@ -3456,7 +3415,6 @@ const estimateMessageTokens = (messages) => {
   });
   return textOnlyMessages.reduce((sum, msg) => sum + gpt4o.encode(typeof msg.content === "string" ? msg.content : "").length, 0) + estimatedImageTokens;
 };
-const execFileAsync = util.promisify(child_process.execFile);
 const fileLocks = /* @__PURE__ */ new Map();
 const withFileLock = (filePath, operation) => {
   logger.debug("Acquiring file lock:", { filePath });
@@ -3773,7 +3731,7 @@ Do not use escape characters \\ in the string like \\n or \\" and others. Do not
         return "Error: ripgrep binary is not available. Please try again or check the logs for details.";
       }
       try {
-        const rgArgs = ["--no-heading", "--line-number", "--color", "never", "--max-count", String(maxResults)];
+        const rgArgs = ["--no-heading", "--line-number", "--color", "never"];
         if (!caseSensitive) {
           rgArgs.push("-i");
         }
@@ -3788,41 +3746,29 @@ Do not use escape characters \\ in the string like \\n or \\" and others. Do not
           args: rgArgs,
           cwd: taskDir
         });
-        const { stdout, stderr } = await execFileAsync(RIPGREP_BINARY_PATH, rgArgs, {
-          cwd: taskDir,
-          env: { ...process.env, TERM: "dumb", PATH: getShellPath() },
-          maxBuffer: 10 * 1024 * 1024,
-          windowsHide: true
-        });
-        logger.debug("ripgrep stdout raw:", { stdout: stdout.substring(0, 2e3) });
-        logger.debug("ripgrep stderr:", { stderr: stderr.substring(0, 2e3) });
-        const outputLines = stdout.split("\n").filter(Boolean);
-        logger.debug("outputLines count:", { count: outputLines.length, lines: outputLines.slice(0, 20) });
-        if (outputLines.length === 0) {
-          return `No matches found for pattern '${searchTerm}' in files matching '${filePattern}'.`;
-        }
         const results = [];
         const outputLineRegex = /^(.+?)([:-])(\d+)\2(.*)$/;
         let pendingBeforeContext = [];
         let afterContextBreak = false;
-        for (let rawLine of outputLines) {
+        let stderrData = "";
+        let lineBuffer = "";
+        const processLine = (rawLine) => {
           if (rawLine.endsWith("\r")) {
             rawLine = rawLine.slice(0, -1);
           }
           if (rawLine === "--") {
             pendingBeforeContext = [];
             afterContextBreak = true;
-            continue;
+            return false;
           }
-          const line = rawLine;
-          const match = outputLineRegex.exec(line);
+          const match = outputLineRegex.exec(rawLine);
           if (!match) {
-            continue;
+            return false;
           }
           const [, rawFilePath, separator, lineNumStr, content] = match;
           const lineNum = parseInt(lineNumStr, 10);
           if (isNaN(lineNum)) {
-            continue;
+            return false;
           }
           const filePath = rawFilePath.startsWith("./") ? rawFilePath.slice(2) : rawFilePath;
           const isMatch = separator === ":";
@@ -3851,13 +3797,96 @@ Do not use escape characters \\ in the string like \\n or \\" and others. Do not
               }
             }
           }
-          if (results.length >= maxResults) {
-            break;
+          return results.length >= maxResults;
+        };
+        let wasAborted = false;
+        await new Promise((resolveStream) => {
+          let streamResolved = false;
+          let childProcess = null;
+          let abortListener = null;
+          const cleanup = () => {
+            if (abortListener && abortSignal) {
+              abortSignal.removeEventListener("abort", abortListener);
+            }
+          };
+          const finish = () => {
+            if (streamResolved) {
+              return;
+            }
+            streamResolved = true;
+            cleanup();
+            resolveStream();
+          };
+          abortListener = () => {
+            if (streamResolved) {
+              return;
+            }
+            wasAborted = true;
+            if (childProcess?.pid) {
+              try {
+                childProcess.kill("SIGKILL");
+              } catch {
+              }
+            }
+          };
+          abortSignal?.addEventListener("abort", abortListener);
+          try {
+            childProcess = child_process.spawn(RIPGREP_BINARY_PATH, rgArgs, {
+              cwd: taskDir,
+              env: { ...process.env, TERM: "dumb", PATH: getShellPath() },
+              windowsHide: true
+            });
+          } catch (spawnError) {
+            stderrData = spawnError instanceof Error ? spawnError.message : String(spawnError);
+            finish();
+            return;
           }
+          childProcess.stdout?.on("data", (data) => {
+            if (streamResolved) {
+              return;
+            }
+            lineBuffer += data.toString("utf-8");
+            const lines = lineBuffer.split("\n");
+            lineBuffer = lines.pop() || "";
+            for (const rawLine of lines) {
+              if (!rawLine) {
+                continue;
+              }
+              const reachedLimit = processLine(rawLine);
+              if (reachedLimit) {
+                try {
+                  childProcess?.kill("SIGKILL");
+                } catch {
+                }
+                finish();
+                return;
+              }
+            }
+          });
+          childProcess.stderr?.on("data", (data) => {
+            stderrData += data.toString("utf-8");
+          });
+          childProcess.on("error", (error) => {
+            if (!streamResolved) {
+              stderrData = error.message;
+              finish();
+            }
+          });
+          childProcess.on("close", () => {
+            if (!streamResolved && lineBuffer) {
+              processLine(lineBuffer);
+              lineBuffer = "";
+            }
+            finish();
+          });
+        });
+        if (wasAborted || abortSignal?.aborted) {
+          return "Operation was cancelled by user.";
         }
+        logger.debug("ripgrep results count:", { count: results.length, stderr: stderrData.substring(0, 500) });
         if (results.length === 0) {
-          if (stderr.trim()) {
-            return `Error during grep: ${stderr.trim()}`;
+          if (stderrData.trim()) {
+            return `Error during grep: ${stderrData.trim()}`;
           }
           return `No matches found for pattern '${searchTerm}' in files matching '${filePattern}'.`;
         }
@@ -6819,7 +6848,7 @@ ${fileList}${readOnlyNote}`
   }
   /**
    * Recursively strips unsupported JSON Schema 2019-09 keywords that are not
-   * recognized by some MCP servers (like gemini-cli).
+   * recognized by some MCP servers.
    */
   stripUnsupportedSchemaKeywords(schema) {
     const unsupportedKeywords = [
@@ -6857,7 +6886,7 @@ ${fileList}${readOnlyNote}`
     return processObject(schema);
   }
   fixInputSchema(provider, inputSchema) {
-    if (provider === "gemini" || provider === "gemini-cli") {
+    if (provider === "gemini") {
       const fixedSchema = JSON.parse(JSON.stringify(inputSchema));
       const strippedSchema = this.stripUnsupportedSchemaKeywords(fixedSchema);
       if (strippedSchema.properties) {
@@ -6898,45 +6927,14 @@ ${fileList}${readOnlyNote}`
     }
     return inputSchema;
   }
-  async runAgent(task, profile, prompt, mode = "agent", promptContext, initialContextMessages, initialContextFiles, systemPrompt, includeInContext = true, abortSignal, images) {
+  async runAgent(task, profile, prompt, mode = "agent", promptContext, initialContextMessages, initialContextFiles, systemPrompt, includeInContext = true, abortSignal, images, skillsToActivate) {
     let contextMessages = initialContextMessages ?? await task.getContextMessages();
     let contextFiles = initialContextFiles ?? await task.getContextFiles();
     if (!systemPrompt) {
       systemPrompt = await this.promptsManager.getSystemPrompt(this.store.getSettings(), task, profile);
     }
-    const userRequestMessage = prompt ? {
-      id: promptContext?.id || uuid.v4(),
-      role: "user",
-      content: images && images.length > 0 ? [
-        { type: "text", text: prompt },
-        ...images.map((dataUrl) => {
-          const match = dataUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
-          return {
-            type: "image",
-            image: match ? match[2] : dataUrl,
-            mediaType: match ? match[1] : void 0
-          };
-        })
-      ] : prompt,
-      promptContext,
-      timestamp: Date.now()
-    } : null;
-    if (userRequestMessage) {
-      logger.info("User request message created:", {
-        id: userRequestMessage.id,
-        contentType: typeof userRequestMessage.content === "string" ? "string" : "parts",
-        ...typeof userRequestMessage.content === "string" ? { contentPreview: userRequestMessage.content.substring(0, 200) } : {
-          parts: userRequestMessage.content.map((part) => ({
-            type: part.type,
-            ...part.type === "text" ? { textPreview: part.text?.substring(0, 100) } : {},
-            ...part.type === "image" ? { mediaType: part.mediaType, imagePreview: typeof part.image === "string" ? part.image.substring(0, 80) : typeof part.image } : {}
-          }))
-        }
-      });
-    }
     const settings = this.store.getSettings();
     const projectProfiles = this.agentProfileManager.getProjectProfiles(task.project);
-    let resultMessages = userRequestMessage ? [userRequestMessage] : [];
     const providers = this.modelManager.getProviders();
     let provider = providers.find((p) => p.id === profile.provider);
     let modelName = profile.model;
@@ -6952,7 +6950,9 @@ ${fileList}${readOnlyNote}`
           promptContext,
           contextMessages,
           contextFiles,
-          systemPrompt
+          systemPrompt,
+          images,
+          skillsToActivate
         },
         task.project,
         task
@@ -6969,10 +6969,56 @@ ${fileList}${readOnlyNote}`
       contextMessages = extensionResult.contextMessages;
       contextFiles = extensionResult.contextFiles;
       systemPrompt = extensionResult.systemPrompt;
+      images = extensionResult.images ?? images;
+      skillsToActivate = extensionResult.skillsToActivate;
+    }
+    const userRequestMessage = prompt ? {
+      id: promptContext?.id || uuid.v4(),
+      role: "user",
+      content: images && images.length > 0 ? [
+        { type: "text", text: prompt },
+        ...images.map((dataUrl) => {
+          const match = dataUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
+          return {
+            type: "image",
+            image: match ? match[2] : dataUrl,
+            mediaType: match ? match[1] : void 0
+          };
+        })
+      ] : prompt,
+      promptContext,
+      timestamp: Date.now()
+    } : null;
+    if (userRequestMessage) {
+      logger.info("User request message created:", {
+        id: userRequestMessage.id,
+        contentType: typeof userRequestMessage.content === "string" ? "string" : "parts",
+        ...typeof userRequestMessage.content === "string" ? { contentPreview: userRequestMessage.content.substring(0, 200) } : {
+          parts: userRequestMessage.content.map((part) => ({
+            type: part.type,
+            ...part.type === "text" ? { textPreview: part.text?.substring(0, 100) } : {},
+            ...part.type === "image" ? { mediaType: part.mediaType, imagePreview: typeof part.image === "string" ? part.image.substring(0, 80) : typeof part.image } : {}
+          }))
+        }
+      });
     }
+    let resultMessages = userRequestMessage ? [userRequestMessage] : [];
     if (userRequestMessage && includeInContext) {
       await task.addContextMessage(userRequestMessage);
     }
+    if (skillsToActivate && skillsToActivate.length > 0) {
+      try {
+        const skillMessages = await task.createSkillMessages(...skillsToActivate);
+        if (skillMessages) {
+          for (const message of skillMessages) {
+            await task.addContextMessage(message);
+            resultMessages.push(message);
+          }
+        }
+      } catch (error) {
+        logger.warn(`Failed to activate skills: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
     if (!provider) {
       logger.error(`Provider ${profile.provider} not found`);
       task.addLogMessage("error", "Selected model is not configured. Select another model and try again.", true, promptContext);
@@ -8937,16 +8983,47 @@ class ContextApi extends BaseApi {
 }
 const RunPromptSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
-  taskId: zod.z.string().min(1, "Task ID is required"),
+  taskId: zod.z.string().optional(),
   prompt: zod.z.string().min(1, "Prompt is required"),
   mode: zod.z.string().optional(),
-  images: zod.z.array(zod.z.string()).optional()
+  images: zod.z.array(zod.z.string()).optional(),
+  model: zod.z.string().optional(),
+  agentProfileId: zod.z.string().optional()
 });
+const parseModelParam = (model, agentProfileId) => {
+  if (!model && !agentProfileId) {
+    return void 0;
+  }
+  const params = {};
+  if (agentProfileId) {
+    params.agentProfileId = agentProfileId;
+  }
+  if (model) {
+    const slashIndex = model.indexOf("/");
+    if (slashIndex > 0) {
+      params.provider = model.substring(0, slashIndex);
+      params.model = model.substring(slashIndex + 1);
+    } else {
+      params.model = model;
+    }
+  }
+  return params;
+};
 const SavePromptSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
   taskId: zod.z.string().min(1, "Task ID is required"),
   prompt: zod.z.string().min(1, "Prompt is required")
 });
+const SSE_ALLOWED_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "response-chunk",
+  "response-completed",
+  "tool",
+  "user-message",
+  "log",
+  "ask-question",
+  "task-updated",
+  "task-created"
+]);
 class PromptApi extends BaseApi {
   constructor(eventsHandler) {
     super();
@@ -8954,18 +9031,26 @@ class PromptApi extends BaseApi {
   }
   eventsHandler;
   registerRoutes(router) {
-    router.post(
-      "/run-prompt",
-      this.handleRequest(async (req, res) => {
-        const parsed = this.validateRequest(RunPromptSchema, req.body, res);
-        if (!parsed) {
-          return;
-        }
-        const { projectDir, taskId, prompt, mode, images } = parsed;
-        const responses = await this.eventsHandler.runPrompt(projectDir, taskId, prompt, mode, images);
-        res.status(200).json(responses);
-      })
-    );
+    router.post("/run-prompt", (req, res) => {
+      const acceptsSSE = req.accepts("text/event-stream");
+      const acceptsJSON = req.accepts("application/json");
+      if (!acceptsSSE && !acceptsJSON) {
+        res.status(406).json({ error: "Accept header must be application/json or text/event-stream" });
+        return;
+      }
+      const parsed = RunPromptSchema.safeParse(req.body);
+      if (!parsed.success) {
+        res.status(400).json({ error: parsed.error.flatten() });
+        return;
+      }
+      const { projectDir, taskId, prompt, mode, images, model, agentProfileId } = parsed.data;
+      const isSSE = acceptsSSE && !acceptsJSON;
+      if (isSSE) {
+        void this.handleRunPromptSSE(res, projectDir, prompt, taskId, mode, images, model, agentProfileId);
+      } else {
+        void this.handleRunPromptJSON(res, projectDir, prompt, taskId, mode, images, model, agentProfileId);
+      }
+    });
     router.post(
       "/save-prompt",
       this.handleRequest(async (req, res) => {
@@ -8979,6 +9064,107 @@ class PromptApi extends BaseApi {
       })
     );
   }
+  async handleRunPromptJSON(res, projectDir, prompt, taskId, mode, images, model, agentProfileId) {
+    if (taskId) {
+      const responses = await this.eventsHandler.runPrompt(projectDir, taskId, prompt, mode, images);
+      res.status(200).json(responses);
+    } else {
+      const taskParams = parseModelParam(model, agentProfileId);
+      const result = await this.eventsHandler.ensureProjectAndCreateTask(projectDir, taskParams);
+      const responses = await this.eventsHandler.runPrompt(result.projectDir, result.taskId, prompt, mode, images);
+      res.setHeader("X-Task-Id", result.taskId);
+      res.status(200).json(responses);
+    }
+  }
+  async handleRunPromptSSE(res, projectDir, prompt, taskId, mode, images, model, agentProfileId) {
+    let resolvedTaskId = taskId;
+    if (!resolvedTaskId) {
+      const taskParams = parseModelParam(model, agentProfileId);
+      const result = await this.eventsHandler.ensureProjectAndCreateTask(projectDir, taskParams);
+      resolvedTaskId = result.taskId;
+    }
+    const baseDir = projectDir.endsWith("/") ? projectDir.slice(0, -1) : projectDir;
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+      "X-Task-Id": resolvedTaskId
+    });
+    res.write(": connected\n\n");
+    const eventManager = this.eventsHandler.getEventManager();
+    const listenerId = `sse-${uuid.v4()}`;
+    let closed = false;
+    const listener = (event) => {
+      if (closed) {
+        return;
+      }
+      const data = event.data;
+      if (!SSE_ALLOWED_EVENT_TYPES.has(event.type)) {
+        return;
+      }
+      if (data.baseDir !== void 0 && data.baseDir !== baseDir) {
+        return;
+      }
+      const eventTaskId = data.taskId || data.id;
+      if (eventTaskId !== void 0 && eventTaskId !== resolvedTaskId) {
+        return;
+      }
+      try {
+        const sseData = `event: ${event.type}
+data: ${JSON.stringify(event.data)}
+
+`;
+        res.write(sseData);
+      } catch (err) {
+        logger.error("SSE run-prompt: error writing event", { err });
+        cleanup();
+      }
+    };
+    const cleanup = () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      eventManager.unsubscribeSSE(listenerId, listener);
+      try {
+        res.end();
+      } catch {
+      }
+    };
+    eventManager.subscribeSSE(listenerId, listener, false);
+    res.on("close", () => {
+      if (!closed) {
+        cleanup();
+      }
+    });
+    try {
+      await this.eventsHandler.waitForTaskIdle(baseDir, resolvedTaskId);
+      await this.eventsHandler.runPrompt(baseDir, resolvedTaskId, prompt, mode, images);
+      if (!closed) {
+        try {
+          res.write(`event: stream-end
+data: ${JSON.stringify({ type: "stream-end" })}
+
+`);
+        } catch {
+        }
+      }
+    } catch (error) {
+      logger.error("SSE run-prompt: error running prompt", { error });
+      if (!closed) {
+        try {
+          res.write(`event: error
+data: ${JSON.stringify({ error: String(error) })}
+
+`);
+        } catch {
+        }
+      }
+    } finally {
+      cleanup();
+    }
+  }
 }
 const SettingsDataSchema = zod.z.any();
 const GetRecentProjectsSchema = zod.z.object({});
@@ -10384,6 +10570,12 @@ class SystemApi extends BaseApi {
   eventsHandler;
   pythonInstaller;
   registerRoutes(router) {
+    router.get(
+      "/health",
+      this.handleRequest(async (_req, res) => {
+        res.status(200).json({ status: "ok" });
+      })
+    );
     router.get(
       "/system/env-var",
       this.handleRequest(async (req, res) => {
@@ -11124,7 +11316,11 @@ class ServerController {
   pythonInstaller;
   app = express();
   isStarted = false;
-  serverGuardMiddleware(_, res, next) {
+  serverGuardMiddleware(req, res, next) {
+    if (req.path === "/api/health") {
+      next();
+      return;
+    }
     if (process.env.AIDER_DESK_HEADLESS === "true" || this.isStarted) {
       next();
     } else {
@@ -11134,6 +11330,10 @@ class ServerController {
     }
   }
   timeoutMiddleware(req, res, next) {
+    if (req.accepts("text/event-stream")) {
+      next();
+      return;
+    }
     req.setTimeout(REQUEST_TIMEOUT_MS, () => {
       res.status(504).json({ error: "Request timeout" });
     });
@@ -13204,7 +13404,8 @@ const PROXY_ENV_VAR_NAMES = ["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_pro
 const getProxyEnvVars = (settings) => {
   if (settings.proxy?.enabled && settings.proxy?.url) {
     const url = settings.proxy.url;
-    return {
+    const noProxy = settings.proxy.noProxy;
+    const vars = {
       HTTP_PROXY: url,
       HTTPS_PROXY: url,
       ALL_PROXY: url,
@@ -13212,6 +13413,11 @@ const getProxyEnvVars = (settings) => {
       https_proxy: url,
       all_proxy: url
     };
+    if (noProxy) {
+      vars.NO_PROXY = noProxy;
+      vars.no_proxy = noProxy;
+    }
+    return vars;
   }
   return Object.fromEntries(PROXY_ENV_VAR_NAMES.map((key) => [key, ""]));
 };
@@ -13223,7 +13429,7 @@ class ProxyManager {
   init(settings) {
     globalAgent.bootstrap();
     if (settings.proxy?.enabled && settings.proxy?.url) {
-      this.applyProxy(settings.proxy.url);
+      this.applyProxy(settings.proxy.url, settings.proxy.noProxy);
     } else {
       this.clearProxy();
     }
@@ -13235,20 +13441,25 @@ class ProxyManager {
   settingsChanged(oldSettings, newSettings) {
     const oldProxy = oldSettings.proxy;
     const newProxy = newSettings.proxy;
-    if (oldProxy?.enabled !== newProxy?.enabled || oldProxy?.url !== newProxy?.url) {
+    if (oldProxy?.enabled !== newProxy?.enabled || oldProxy?.url !== newProxy?.url || oldProxy?.noProxy !== newProxy?.noProxy) {
       if (newProxy?.enabled && newProxy?.url) {
         logger.info(`[ProxyManager] Applying proxy: ${newProxy.url}`);
-        this.applyProxy(newProxy.url);
+        this.applyProxy(newProxy.url, newProxy.noProxy);
       } else if (this.currentUrl !== null) {
         logger.info("[ProxyManager] Clearing proxy");
         this.clearProxy();
       }
     }
   }
-  applyProxy(url) {
+  applyProxy(url, noProxy) {
     try {
       global.GLOBAL_AGENT.HTTP_PROXY = url;
-      const proxyAgent = new undici.ProxyAgent(url);
+      global.GLOBAL_AGENT.NO_PROXY = noProxy || void 0;
+      const proxyAgent = new undici.EnvHttpProxyAgent({
+        httpProxy: url,
+        httpsProxy: url,
+        noProxy: noProxy || void 0
+      });
       undici.setGlobalDispatcher(proxyAgent);
       this.currentUrl = url;
       logger.info(`[ProxyManager] Proxy initialized: ${url}`);
@@ -13259,6 +13470,7 @@ class ProxyManager {
   clearProxy() {
     try {
       global.GLOBAL_AGENT.HTTP_PROXY = void 0;
+      global.GLOBAL_AGENT.NO_PROXY = void 0;
       undici.setGlobalDispatcher(
         new undici.Agent({
           headersTimeout: 30 * 60 * 1e3,
@@ -14227,6 +14439,60 @@ class WorktreeManager {
       return void 0;
     }
   }
+  /**
+   * Check if a commit is an ancestor of another commit (or HEAD).
+   * Returns true if `ancestorCommit` is reachable from `descendantRef`.
+   */
+  async isCommitAncestorOf(worktreePath, ancestorCommit, descendantRef = "HEAD") {
+    try {
+      await execWithShellPath(`git merge-base --is-ancestor ${ancestorCommit} ${descendantRef}`, { cwd: worktreePath });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the "onto" commit from an active rebase.
+   * Returns undefined if no rebase is in progress or the file doesn't exist.
+   */
+  async getRebaseOntoCommit(worktreePath) {
+    try {
+      const { stdout: rebaseMergePath } = await execWithShellPath("git rev-parse --git-path rebase-merge", { cwd: worktreePath });
+      const ontoPath = `${rebaseMergePath.trim()}/onto`;
+      try {
+        const { stdout: ontoCommit } = await execWithShellPath(`cat "${ontoPath}"`, { cwd: worktreePath });
+        if (ontoCommit.trim()) {
+          return ontoCommit.trim();
+        }
+      } catch {
+      }
+      const { stdout: rebaseApplyPath } = await execWithShellPath("git rev-parse --git-path rebase-apply", { cwd: worktreePath });
+      const ontoApplyPath = `${rebaseApplyPath.trim()}/onto`;
+      try {
+        const { stdout: ontoCommit } = await execWithShellPath(`cat "${ontoApplyPath}"`, { cwd: worktreePath });
+        if (ontoCommit.trim()) {
+          return ontoCommit.trim();
+        }
+      } catch {
+      }
+      return void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Resolve a commit to the branch name that points to it.
+   * Returns the first branch found, or undefined if no branch points to that exact commit.
+   */
+  async getBranchPointingAtCommit(projectPath, commit) {
+    try {
+      const { stdout } = await execWithShellPath(`git branch --points-at ${commit} --format='%(refname:short)'`, { cwd: projectPath });
+      const branches = stdout.trim().split("\n").map((b) => b.trim()).filter((b) => b && !b.includes("(") && !b.includes("HEAD"));
+      return branches.length > 0 ? branches[0] : void 0;
+    } catch {
+      return void 0;
+    }
+  }
   async getBranchesContainingCommit(projectPath, commit) {
     try {
       const { stdout } = await execWithShellPath(`git branch --contains ${commit} --format='%(refname:short)'`, { cwd: projectPath });
@@ -14335,7 +14601,15 @@ class WorktreeManager {
           });
           logger.info("Created temporary commit for uncommitted changes");
         }
-        const command = baseCommit ? `git rebase --onto ${mainBranch} ${baseCommit}` : `git rebase ${mainBranch}`;
+        let effectiveBaseCommit = baseCommit;
+        if (baseCommit) {
+          const isValid = await this.isCommitAncestorOf(worktreePath, baseCommit);
+          if (!isValid) {
+            logger.warn(`baseCommit ${baseCommit} is not an ancestor of HEAD, falling back to simple rebase`, { worktreePath, mainBranch });
+            effectiveBaseCommit = void 0;
+          }
+        }
+        const command = effectiveBaseCommit ? `git rebase --onto ${mainBranch} ${effectiveBaseCommit}` : `git rebase ${mainBranch}`;
         executedCommands.push(`${command} (in ${worktreePath})`);
         const rebaseResult = await execWithShellPath(command, {
           cwd: worktreePath
@@ -14388,6 +14662,11 @@ class WorktreeManager {
     return await withLock(`git-rebase-continue-${worktreePath}`, async () => {
       const executedCommands = [];
       let lastOutput = "";
+      const ontoCommit = await this.getRebaseOntoCommit(worktreePath);
+      let ontoBranch;
+      if (ontoCommit) {
+        ontoBranch = await this.getBranchPointingAtCommit(worktreePath, ontoCommit);
+      }
       try {
         const command = "git rebase --continue";
         executedCommands.push(`${command} (in ${worktreePath})`);
@@ -14398,6 +14677,7 @@ class WorktreeManager {
         lastOutput = result.stdout || result.stderr || "";
         await this.resetTempCommitIfExists(worktreePath);
         logger.info("Successfully handled temporary commit after continue rebase");
+        return { ontoCommit, ontoBranch };
       } catch (error) {
         const err = error;
         logger.error(`Failed to continue rebase in ${worktreePath}:`, err);
@@ -14426,7 +14706,15 @@ class WorktreeManager {
       if (!commits.trim()) {
         return;
       }
-      command = baseCommit ? `git rebase --onto ${mainBranch} ${baseCommit}` : `git rebase ${mainBranch}`;
+      let effectiveBaseCommit = baseCommit;
+      if (baseCommit) {
+        const isValid = await this.isCommitAncestorOf(worktreePath, baseCommit);
+        if (!isValid) {
+          logger.warn(`baseCommit ${baseCommit} is not an ancestor of HEAD, falling back to simple rebase`, { worktreePath, mainBranch });
+          effectiveBaseCommit = void 0;
+        }
+      }
+      command = effectiveBaseCommit ? `git rebase --onto ${mainBranch} ${effectiveBaseCommit}` : `git rebase ${mainBranch}`;
       executedCommands.push(`${command} (in ${worktreePath})`);
       try {
         const rebaseWorktreeResult = await execWithShellPath(command, {
@@ -15425,7 +15713,7 @@ Git output: ${err.stderr || err.stdout || err.message}`
    */
   async resetTempCommit(worktreePath) {
     try {
-      await execWithShellPath("git reset --mixed HEAD^", { cwd: worktreePath });
+      await execWithShellPath("git reset --soft HEAD^", { cwd: worktreePath });
     } catch (error) {
       logger.error("Failed to reset temp commit:", error);
       throw new Error(`Failed to restore uncommitted changes: ${error instanceof Error ? error.message : String(error)}`);
@@ -16837,6 +17125,18 @@ class Task {
   isPromptRunning() {
     return !!this.currentPromptContext || this.agent.isRunning() || this.isCompacting;
   }
+  hasQueuedPrompts() {
+    return this.queuedPrompts.length > 0;
+  }
+  async waitForIdle() {
+    while (this.isPromptRunning() || this.hasQueuedPrompts()) {
+      if (this.agent.isRunning()) {
+        await this.waitForCurrentAgentToFinish();
+      } else {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    }
+  }
   async runPrompt(prompt, mode = this.task.currentMode || "agent", addToInputHistory = true, userMessageId = uuid.v4(), sendNotification = true, images) {
     if (this.currentQuestion) {
       if (await this.answerQuestion("n", prompt)) {
@@ -17003,7 +17303,7 @@ class Task {
     }
     return responses;
   }
-  async runPromptInAgent(profile, mode, prompt, promptContext = { id: uuid.v4() }, contextMessages, contextFiles, systemPrompt, waitForCurrentAgentToFinish = true, sendNotification = true, images) {
+  async runPromptInAgent(profile, mode, prompt, promptContext = { id: uuid.v4() }, contextMessages, contextFiles, systemPrompt, waitForCurrentAgentToFinish = true, sendNotification = true, images, skillsToActivate) {
     if (waitForCurrentAgentToFinish) {
       await this.waitForCurrentAgentToFinish();
     }
@@ -17026,7 +17326,8 @@ class Task {
       systemPrompt,
       true,
       void 0,
-      images
+      images,
+      skillsToActivate
     );
     if (agentMessages.length > 0) {
       this.contextManager.toConnectorMessages(agentMessages).forEach((message) => {
@@ -17986,42 +18287,59 @@ ${contentText}</agent-response>`;
     const contextMessages = await this.contextManager.getContextMessages();
     return this.skillManager.getSkills(contextMessages);
   }
-  async activateSkill(skillName) {
+  async createSkillMessages(...skillNames) {
+    if (skillNames.length === 0) {
+      return null;
+    }
     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 allMessages = [];
+    for (const skillName of skillNames) {
+      if (activatedNames.has(skillName)) {
+        logger.debug("Skill already activated, skipping", { skillName });
+        continue;
+      }
+      const content = await this.skillManager.getSkillContent(skillName);
+      if (!content) {
+        throw new Error(`Skill '${skillName}' not found`);
+      }
+      const [assistantMessage, toolMessage] = this.skillManager.buildActivateSkillMessages(skillName, content);
+      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
+      );
+      allMessages.push(assistantMessage, toolMessage);
+      activatedNames.add(skillName);
     }
-    const content = await this.skillManager.getSkillContent(skillName);
-    if (!content) {
-      throw new Error(`Skill '${skillName}' not found`);
+    return allMessages.length > 0 ? allMessages : null;
+  }
+  async activateSkill(skillName) {
+    const messages = await this.createSkillMessages(skillName);
+    if (!messages) {
+      return null;
+    }
+    for (const message of messages) {
+      this.contextManager.addContextMessage(message);
     }
-    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();
+    return [messages[0], messages[1]];
   }
   async deactivateSkill(skillName) {
     const contextMessages = await this.contextManager.getContextMessages();
@@ -19020,15 +19338,6 @@ ${error.stderr}`,
           this.addLogMessage("error", "No active Agent profile found");
           return;
         }
-        if (command.skills?.length) {
-          for (const skillName of command.skills) {
-            try {
-              await this.activateSkill(skillName);
-            } catch (error) {
-              logger.warn(`Failed to activate skill '${skillName}' for command '${commandName}': ${error instanceof Error ? error.message : String(error)}`);
-            }
-          }
-        }
         const systemPrompt = await this.promptsManager.getSystemPrompt(
           this.store.getSettings(),
           this,
@@ -19038,7 +19347,7 @@ ${error.stderr}`,
         const messages = command.includeContext === false ? [] : void 0;
         const contextFiles = command.includeContext === false ? [] : void 0;
         this.addLogMessage("loading", "Executing custom command...");
-        await this.runPromptInAgent(profile, mode, prompt, promptContext, messages, contextFiles, systemPrompt);
+        await this.runPromptInAgent(profile, mode, prompt, promptContext, messages, contextFiles, systemPrompt, true, true, void 0, command.skills);
       } else {
         this.addLogMessage("loading", "Executing custom command...");
         await this.runPromptInAider(mode, prompt, promptContext);
@@ -19730,8 +20039,21 @@ ${diff}
     await this.waitForCurrentPromptToFinish();
     try {
       this.addLogMessage("loading", "Continuing rebase...");
-      await this.worktreeManager.continueRebase(this.task.worktree.path);
-      await this.saveTask({ lastMergeState: void 0 });
+      const { ontoBranch } = await this.worktreeManager.continueRebase(this.task.worktree.path);
+      const newHead = await this.worktreeManager.getHeadCommit(this.task.worktree.path);
+      if (newHead) {
+        await this.saveTask({
+          lastMergeState: void 0,
+          worktree: {
+            ...this.task.worktree,
+            baseCommit: newHead,
+            // Update baseBranch if we could determine it from the rebase state, otherwise keep existing
+            baseBranch: ontoBranch || this.task.worktree.baseBranch
+          }
+        });
+      } else {
+        await this.saveTask({ lastMergeState: void 0 });
+      }
       this.addLogMessage("info", "Rebase completed", true);
     } catch (error) {
       logger.error("Failed to continue rebase:", error);
@@ -20529,12 +20851,15 @@ class ProjectManager {
     });
   }
 }
+const EVENT_BUFFER_SIZE = 200;
 class EventManager {
   constructor(windowManager) {
     this.windowManager = windowManager;
   }
   windowManager;
   eventsConnectors = [];
+  sseListeners = /* @__PURE__ */ new Map();
+  eventBuffer = [];
   // Project lifecycle events
   sendProjectStarted(baseDir) {
     const data = { baseDir };
@@ -20879,6 +21204,19 @@ class EventManager {
         this.unsubscribe(connector.socket, log);
       }
     });
+    const event = { type: eventType, data };
+    for (const listeners of this.sseListeners.values()) {
+      for (const listener of listeners) {
+        try {
+          listener(event);
+        } catch {
+        }
+      }
+    }
+    this.eventBuffer.push(event);
+    if (this.eventBuffer.length > EVENT_BUFFER_SIZE) {
+      this.eventBuffer.shift();
+    }
   }
   // Extension UI events
   sendExtensionUIRefresh(options) {
@@ -20898,6 +21236,27 @@ class EventManager {
     this.sendToWindows("aider-connector-status", data);
     this.broadcastToEventConnectors("aider-connector-status", data);
   }
+  // SSE event subscription for CLI streaming
+  subscribeSSE(listenerId, listener, replayBuffer = false) {
+    if (!this.sseListeners.has(listenerId)) {
+      this.sseListeners.set(listenerId, /* @__PURE__ */ new Set());
+    }
+    this.sseListeners.get(listenerId).add(listener);
+    if (replayBuffer) {
+      for (const event of this.eventBuffer) {
+        try {
+          listener(event);
+        } catch {
+        }
+      }
+    }
+  }
+  unsubscribeSSE(listenerId, listener) {
+    this.sseListeners.get(listenerId)?.delete(listener);
+    if (this.sseListeners.get(listenerId)?.size === 0) {
+      this.sseListeners.delete(listenerId);
+    }
+  }
 }
 const getDefaultModelInfo = (provider, modelId, allModelInfos) => {
   let fullModelId = `${provider.name}/${modelId}`;
@@ -21962,81 +22321,6 @@ const geminiProviderStrategy = {
   // Error handling
   isRetryable: isGeminiRetryable
 };
-const GEMINI_CLI_MODELS = [
-  {
-    id: "gemini-3.1-pro-preview",
-    maxInputTokens: 1048576,
-    maxOutputTokens: 65536
-  },
-  {
-    id: "gemini-3-flash-preview",
-    maxInputTokens: 1048576,
-    maxOutputTokens: 65536
-  },
-  { id: "gemini-2.5-pro", maxInputTokens: 1048576, maxOutputTokens: 65536 },
-  { id: "gemini-2.5-flash", maxInputTokens: 1048576, maxOutputTokens: 65536 },
-  { id: "gemini-2.5-flash-lite", maxInputTokens: 1048576, maxOutputTokens: 65536 }
-];
-const loadGeminiCliModels = async (profile, _settings) => {
-  if (!isGeminiCliProvider(profile.provider)) {
-    return { models: [], success: false };
-  }
-  const models = GEMINI_CLI_MODELS.map((m) => ({
-    id: m.id,
-    providerId: profile.id,
-    maxInputTokens: m.maxInputTokens,
-    maxOutputTokensLimit: m.maxOutputTokens
-  }));
-  return { models, success: true };
-};
-const hasGeminiCliEnvVars = () => {
-  return findExecutableInPath("gemini") !== null;
-};
-const getGeminiCliAiderMapping = (provider, modelId, _settings, _projectDir) => {
-  const environmentVariables = {};
-  if (isGeminiCliProvider(provider.provider) && provider.provider.projectId) {
-    environmentVariables.GOOGLE_CLOUD_PROJECT = provider.provider.projectId;
-  }
-  return {
-    modelName: `gemini-cli/${modelId}`,
-    environmentVariables
-  };
-};
-const createGeminiCliLlm = async (profile, model, _settings, _projectDir, _toolSet, _systemPrompt, _providerMetadata) => {
-  const projectId = isGeminiCliProvider(profile.provider) ? profile.provider.projectId : void 0;
-  logger.debug("Creating Gemini CLI LLM", {
-    model: model.id,
-    projectId
-  });
-  const { createGeminiProvider } = await import("ai-sdk-provider-gemini-cli");
-  if (projectId) {
-    process.env.GOOGLE_CLOUD_PROJECT = projectId;
-  }
-  const gemini = createGeminiProvider({ authType: "oauth-personal" });
-  return gemini(model.id);
-};
-const getGeminiCliUsageReport = (task, provider, model, usage, _providerMetadata) => {
-  return getDefaultUsageReport(task, provider, model, usage);
-};
-const getGeminiCliProviderParameters = () => {
-  return {};
-};
-const isGeminiCliRetryable = (error) => {
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  if (errorMessage.includes("GOOGLE_CLOUD_PROJECT") || errorMessage.includes("GOOGLE_CLOUD_PROJECT_ID")) {
-    return false;
-  }
-  return true;
-};
-const geminiCliProviderStrategy = {
-  createLlm: createGeminiCliLlm,
-  getUsageReport: getGeminiCliUsageReport,
-  loadModels: loadGeminiCliModels,
-  hasEnvVars: hasGeminiCliEnvVars,
-  getAiderMapping: getGeminiCliAiderMapping,
-  getProviderParameters: getGeminiCliProviderParameters,
-  isRetryable: isGeminiCliRetryable
-};
 const loadGpustackModels = async (profile, settings) => {
   if (!isGpustackProvider(profile.provider)) {
     return { models: [], success: false };
@@ -23058,13 +23342,31 @@ const getNeuralwattUsageReport = (task, provider, model, usage, providerMetadata
     agentTotalCost: task.task.agentTotalCost + messageCost
   };
 };
+const getNeuralwattProviderOptions = (llmProvider, model) => {
+  if (!isNeuralwattProvider(llmProvider)) {
+    return void 0;
+  }
+  const neuralwattProvider = llmProvider;
+  const providerOverrides = model.providerOverrides;
+  const reasoningEffort = providerOverrides?.reasoningEffort ?? neuralwattProvider.reasoningEffort;
+  const mappedReasoningEffort = reasoningEffort === void 0 ? void 0 : reasoningEffort.toLowerCase();
+  if (mappedReasoningEffort) {
+    return {
+      neuralwatt: {
+        reasoningEffort: mappedReasoningEffort
+      }
+    };
+  }
+  return void 0;
+};
 const neuralwattProviderStrategy = {
   createLlm: createNeuralwattLlm,
   getUsageReport: getNeuralwattUsageReport,
   loadModels: loadNeuralwattModels,
   hasEnvVars: hasNeuralwattEnvVars,
   getAiderMapping: getNeuralwattAiderMapping,
-  getModelInfo: getDefaultModelInfo
+  getModelInfo: getDefaultModelInfo,
+  getProviderOptions: getNeuralwattProviderOptions
 };
 const loadOllamaModels = async (profile, settings) => {
   if (!isOllamaProvider(profile.provider)) {
@@ -24371,6 +24673,7 @@ const getZaiPlanProviderOptions = (llmProvider, model) => {
   if (isZaiPlanProvider(llmProvider)) {
     const providerOverrides = model.providerOverrides;
     const thinkingEnabled = providerOverrides?.thinkingEnabled ?? llmProvider.thinkingEnabled ?? true;
+    const reasoningEffort = providerOverrides?.reasoningEffort ?? llmProvider.reasoningEffort ?? ReasoningEffort.Max;
     if (thinkingEnabled === false) {
       return {
         "zai-plan": {
@@ -24380,6 +24683,14 @@ const getZaiPlanProviderOptions = (llmProvider, model) => {
         }
       };
     }
+    const mappedReasoningEffort = reasoningEffort === ReasoningEffort.None ? void 0 : reasoningEffort.toLowerCase();
+    if (mappedReasoningEffort) {
+      return {
+        "zai-plan": {
+          reasoningEffort: mappedReasoningEffort
+        }
+      };
+    }
   }
   return void 0;
 };
@@ -24420,7 +24731,6 @@ class ModelManager {
     cerebras: cerebrasProviderStrategy,
     deepseek: deepseekProviderStrategy,
     gemini: geminiProviderStrategy,
-    "gemini-cli": geminiCliProviderStrategy,
     gpustack: gpustackProviderStrategy,
     groq: groqProviderStrategy,
     "alibaba-plan": alibabaPlanProviderStrategy,
@@ -26436,7 +26746,7 @@ class TaskContextImpl {
   async runPrompt(prompt, mode) {
     await this.task.runPrompt(prompt, mode);
   }
-  async runPromptInAgent(profile, mode, prompt, promptContext, contextMessages, contextFiles, systemPrompt, waitForCurrentAgentToFinish = true, sendNotification = true) {
+  async runPromptInAgent(profile, mode, prompt, promptContext, contextMessages, contextFiles, systemPrompt, waitForCurrentAgentToFinish = true, sendNotification = true, skillsToActivate) {
     return this.task.runPromptInAgent(
       profile,
       mode,
@@ -26446,7 +26756,9 @@ class TaskContextImpl {
       contextFiles,
       systemPrompt,
       waitForCurrentAgentToFinish,
-      sendNotification
+      sendNotification,
+      void 0,
+      skillsToActivate
     );
   }
   async runCustomCommand(name, args = [], mode) {
@@ -26728,6 +27040,19 @@ class ExtensionContextImpl {
       return false;
     }
   }
+  async getElectronApp() {
+    try {
+      const electron = await import("electron");
+      const app = electron?.app ?? electron?.default?.app;
+      if (!app || typeof app.getAppMetrics !== "function") {
+        return null;
+      }
+      return app;
+    } catch (error) {
+      this.log(`Failed to get Electron app: ${error}`, "debug");
+      return null;
+    }
+  }
   getMemoryContext() {
     if (!this.memoryManager) {
       throw new Error("MemoryManager not available");
@@ -27622,6 +27947,7 @@ class ExtensionManager {
     }
   }
   static TOOL_NAME_REGEX = /^[a-z][a-z0-9_-]*$/;
+  static COMMAND_NAME_REGEX = /^[a-z][a-z0-9_:-]*$/;
   validateToolDefinition(tool) {
     const errors = [];
     try {
@@ -27815,9 +28141,9 @@ class ExtensionManager {
     try {
       if (!command.name) {
         errors.push("Command name must be a non-empty string");
-      } else if (!ExtensionManager.TOOL_NAME_REGEX.test(command.name)) {
+      } else if (!ExtensionManager.COMMAND_NAME_REGEX.test(command.name)) {
         errors.push(
-          `Command name '${command.name}' must start with a lowercase letter and contain only lowercase letters, numbers, hyphens, or underscores (e.g., 'generate-tests', 'my---command', 'command_name')`
+          `Command name '${command.name}' must start with a lowercase letter and contain only lowercase letters, numbers, hyphens, underscores, or colons (e.g., 'generate-tests', 'impl:tweak', 'command_name')`
         );
       }
       if (!command.description || command.description.trim() === "") {
@@ -28452,7 +28778,8 @@ class ExtensionManager {
     return new Promise((resolve, reject) => {
       const child = spawn("npm", ["install"], {
         cwd: extensionPath,
-        stdio: "inherit"
+        stdio: "inherit",
+        shell: true
       });
       child.on("close", (code) => {
         if (code === 0) {
@@ -28676,6 +29003,9 @@ class EventsHandler {
   loadSettings() {
     return this.store.getSettings();
   }
+  getEventManager() {
+    return this.eventManager;
+  }
   async saveSettings(newSettings) {
     const oldSettings = this.store.getSettings();
     this.store.saveSettings(newSettings);
@@ -28921,6 +29251,28 @@ class EventsHandler {
   async runPrompt(baseDir, taskId, prompt, mode, images) {
     return this.projectManager.getProject(baseDir).getTask(taskId)?.runPrompt(prompt, mode, true, void 0, true, images) || [];
   }
+  async waitForTaskIdle(baseDir, taskId) {
+    const project = this.projectManager.getProject(baseDir);
+    const task = project?.getTask(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found in project ${baseDir}`);
+    }
+    await task.waitForIdle();
+  }
+  async ensureProjectAndCreateTask(projectDir, params) {
+    const projects = this.store.getOpenProjects();
+    const baseDir = projectDir.endsWith("/") ? projectDir.slice(0, -1) : projectDir;
+    const existingProject = projects.find((p) => compareBaseDirs$1(p.baseDir, baseDir));
+    if (!existingProject) {
+      await this.addOpenProject(baseDir);
+    }
+    const taskParams = {
+      ...params,
+      autonomyMode: params?.autonomyMode ?? AutonomyMode.Autonomous
+    };
+    const task = await this.createNewTask(baseDir, taskParams);
+    return { taskId: task.id, projectDir: baseDir };
+  }
   async savePrompt(baseDir, taskId, prompt) {
     return this.projectManager.getProject(baseDir).getTask(taskId)?.savePromptOnly(prompt);
   }
@@ -30431,11 +30783,6 @@ const initManagers = async (store, windowManager) => {
 };
 const performStartUp = async (pythonInstaller, updateProgress) => {
   logger.info("Starting AiderDesk setup process (fast path)");
-  updateProgress?.({
-    step: "Setting up MCP server",
-    message: "Setting up MCP server..."
-  });
-  await setupMcpServerInternal();
   if (fs__namespace.existsSync(SETUP_COMPLETE_FILENAME) && fs__namespace.existsSync(PYTHON_VENV_DIR)) {
     logger.info("Setup previously completed, will run update check in background");
     updateProgress?.({
@@ -30457,28 +30804,6 @@ const performStartUp = async (pythonInstaller, updateProgress) => {
   pythonInstaller.ensureInstalled();
   return true;
 };
-const setupMcpServerInternal = async () => {
-  if (isDev()) {
-    logger.info("Skipping AiderDesk MCP server setup in dev mode");
-    return;
-  }
-  if (!fs__namespace.existsSync(AIDER_DESK_MCP_SERVER_DIR)) {
-    fs__namespace.mkdirSync(AIDER_DESK_MCP_SERVER_DIR, { recursive: true });
-  }
-  const sourceMcpServerDir = path.join(RESOURCES_DIR, "mcp-server");
-  if (fs__namespace.existsSync(sourceMcpServerDir)) {
-    const files = fs__namespace.readdirSync(sourceMcpServerDir);
-    for (const file of files) {
-      const sourceFilePath = path.join(sourceMcpServerDir, file);
-      const destFilePath = path.join(AIDER_DESK_MCP_SERVER_DIR, file);
-      if (fs__namespace.statSync(sourceFilePath).isFile()) {
-        fs__namespace.copyFileSync(sourceFilePath, destFilePath);
-      }
-    }
-  } else {
-    logger.error(`MCP server directory not found: ${sourceMcpServerDir}`);
-  }
-};
 const migrateSettingsV0toV1 = (settings) => {
   let mcpConfig = settings.mcpConfig;
   if (typeof mcpConfig?.provider === "string") {
@@ -31009,7 +31334,8 @@ const DEFAULT_SETTINGS = {
   },
   proxy: {
     enabled: false,
-    url: ""
+    url: "",
+    noProxy: ""
   },
   fileWatchMode: FileWatchMode.Auto
 };