openfox 2.0.66 → 2.0.68

package/dist/{chunk-OE5B44P6.js → chunk-DWZEGLHJ.js}

@@ -21,7 +21,7 @@ import {
   tokenFromPassword,
   verifyPassword,
   workflowExists
-} from "./chunk-ZUM2ZJOX.js";
+} from "./chunk-COWJRBV4.js";
 import {
   agentExists,
   createToolRegistry,
@@ -66,22 +66,22 @@ import {
   setSkillEnabled,
   skillExists,
   updateOwnedSkill
-} from "./chunk-3ACDQKK6.js";
+} from "./chunk-6LK47TNE.js";
 import {
   ALWAYS_ALLOWED,
   ALWAYS_ALLOWED_FOR_SUBAGENTS,
   TOP_LEVEL_ONLY_TOOLS
-} from "./chunk-R4UTFE63.js";
+} from "./chunk-QFSDJIUS.js";
 import {
-  getPathSeparator,
-  isAbsolutePath
-} from "./chunk-BGTEIA2S.js";
+  getProject
+} from "./chunk-KXVFHMSM.js";
 import {
   createMcpTools
 } from "./chunk-NWO6GRYE.js";
 import {
-  ensureWorktree
-} from "./chunk-OBK3I4KD.js";
+  ensureWorktree,
+  syncIgnoredAssets
+} from "./chunk-VLV3XWZS.js";
 import {
   createSession,
   deleteSession,
@@ -113,26 +113,27 @@ import {
 import {
   createContextStateMessage
 } from "./chunk-F4PMNP7S.js";
+import {
+  getPathSeparator,
+  isAbsolutePath
+} from "./chunk-X5DOUA3Z.js";
 import {
   deleteSetting,
   getSetting,
   setSetting
-} from "./chunk-PVRSNXD4.js";
-import {
-  EventEmitter
-} from "./chunk-EU3WWTFH.js";
-import {
-  getProject
-} from "./chunk-KXVFHMSM.js";
+} from "./chunk-XUPKS5FL.js";
 import {
   initDatabase
 } from "./chunk-GMXKJGJ2.js";
+import {
+  EventEmitter
+} from "./chunk-EU3WWTFH.js";
 import {
   createProviderManager,
   detectModel,
   getLlmStatus,
   parseDefaultModelSelection
-} from "./chunk-5EO6SEGV.js";
+} from "./chunk-7OW6X764.js";
 import {
   getModelProfile
 } from "./chunk-V4IE7HJY.js";
@@ -160,9 +161,9 @@ import {
 import express from "express";
 import cors from "cors";
 import { createServer as createHttpServer } from "http";
-import { fileURLToPath as fileURLToPath6 } from "url";
-import { dirname as dirname7, resolve as resolve5, join as join8 } from "path";
-import { readFile as readFile3 } from "fs/promises";
+import { fileURLToPath as fileURLToPath7 } from "url";
+import { dirname as dirname8, resolve as resolve7, join as join10 } from "path";
+import { readFile as readFile5 } from "fs/promises";
 import { createServer as createViteServer } from "vite";
 
 // src/server/llm/mock.ts
@@ -1603,6 +1604,35 @@ var McpManager = class {
   }
 };
 
+// src/server/git/worktree-config.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { resolve, join } from "path";
+var CONFIG_FILENAME = ".openfox/worktree.json";
+function getConfigPath(workdir) {
+  return join(resolve(workdir), CONFIG_FILENAME);
+}
+async function loadWorktreeConfig(workdir) {
+  try {
+    const configPath = getConfigPath(workdir);
+    const raw = await readFile(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.ignoredAssets) return null;
+    return {
+      ignoredAssets: parsed.ignoredAssets,
+      overrides: parsed.overrides ?? void 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function saveWorktreeConfig(workdir, config3) {
+  const resolved = resolve(workdir);
+  const dirPath = join(resolved, ".openfox");
+  await mkdir(dirPath, { recursive: true });
+  const configPath = getConfigPath(workdir);
+  await writeFile(configPath, JSON.stringify(config3, null, 2) + "\n", "utf-8");
+}
+
 // src/server/lsp/server.ts
 import { spawn } from "child_process";
 import { extname } from "path";
@@ -1925,19 +1955,19 @@ var LspServer = class {
    */
   async getDiagnosticsWithWait(path, timeoutMs = DIAGNOSTIC_WAIT_MS) {
     if (this.openDocuments.has(path)) {
-      return new Promise((resolve6) => {
+      return new Promise((resolve8) => {
         const existing = this.diagnostics.get(path);
         if (existing !== void 0) {
           setTimeout(() => {
-            resolve6(this.diagnostics.get(path) ?? []);
+            resolve8(this.diagnostics.get(path) ?? []);
           }, 100);
           return;
         }
         const timeout = setTimeout(() => {
           this.pendingDiagnostics.delete(path);
-          resolve6(this.diagnostics.get(path) ?? []);
+          resolve8(this.diagnostics.get(path) ?? []);
         }, timeoutMs);
-        this.pendingDiagnostics.set(path, { resolve: resolve6, timeout });
+        this.pendingDiagnostics.set(path, { resolve: resolve8, timeout });
       });
     }
     return this.diagnostics.get(path) ?? [];
@@ -2148,14 +2178,14 @@ import { readFileSync as readFileSync2 } from "fs";
 
 // src/server/utils/which.ts
 import { access, constants } from "fs/promises";
-import { join, dirname } from "path";
+import { join as join2, dirname } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __dirname = dirname(fileURLToPath2(import.meta.url));
 function getBundledBinPaths() {
   const paths = [];
-  paths.push(join(process.cwd(), "node_modules", ".bin"));
-  paths.push(join(__dirname, "..", "..", "..", "node_modules", ".bin"));
-  paths.push(join(__dirname, "..", "..", "..", "..", "node_modules", ".bin"));
+  paths.push(join2(process.cwd(), "node_modules", ".bin"));
+  paths.push(join2(__dirname, "..", "..", "..", "node_modules", ".bin"));
+  paths.push(join2(__dirname, "..", "..", "..", "..", "node_modules", ".bin"));
   return paths;
 }
 async function existsExecutable(path) {
@@ -2174,13 +2204,13 @@ async function which(command, workdir) {
     return null;
   }
   for (const binDir of getBundledBinPaths()) {
-    const fullPath = join(binDir, command);
+    const fullPath = join2(binDir, command);
     if (await existsExecutable(fullPath)) {
       return fullPath;
     }
   }
   if (workdir) {
-    const projectBin = join(workdir, "node_modules", ".bin", command);
+    const projectBin = join2(workdir, "node_modules", ".bin", command);
     if (await existsExecutable(projectBin)) {
       return projectBin;
     }
@@ -2189,7 +2219,7 @@ async function which(command, workdir) {
   const paths = pathEnv.split(getPathSeparator());
   for (const dir of paths) {
     if (!dir) continue;
-    const fullPath = join(dir, command);
+    const fullPath = join2(dir, command);
     if (await existsExecutable(fullPath)) {
       return fullPath;
     }
@@ -2201,9 +2231,9 @@ async function which(command, workdir) {
 import { extname as extname2, basename } from "path";
 import { readFileSync } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname2, resolve } from "path";
+import { dirname as dirname2, resolve as resolve2 } from "path";
 var __dirname2 = dirname2(fileURLToPath3(import.meta.url));
-var languagesJson = JSON.parse(readFileSync(resolve(__dirname2, "languages.json"), "utf-8"));
+var languagesJson = JSON.parse(readFileSync(resolve2(__dirname2, "languages.json"), "utf-8"));
 var LANGUAGES = languagesJson;
 var extensionToLanguage = /* @__PURE__ */ new Map();
 for (const lang of LANGUAGES) {
@@ -3181,6 +3211,10 @@ var SessionManager = class {
     if (!project) throw new Error(`Project not found: ${session.projectId}`);
     if (session.worktree) throw new Error("Session already has a worktree");
     const result = await ensureWorktree(project.workdir, name);
+    const wtConfig = await loadWorktreeConfig(project.workdir);
+    if (wtConfig) {
+      await syncIgnoredAssets(project.workdir, result.path, wtConfig);
+    }
     updateSessionWorkdir(sessionId, project.workdir, result.path);
     try {
       await shutdownLspManager(sessionId);
@@ -3245,6 +3279,11 @@ All file and git operations should use this directory.
     if (!project) throw new Error(`Project not found: ${session.projectId}`);
     const closedPath = session.worktree;
     const branchName = closedPath.includes("/worktrees/") ? closedPath.split("/worktrees/")[1] ?? closedPath : closedPath;
+    try {
+      await devServerManager.stop(closedPath);
+    } catch (err) {
+      logger.error("Error stopping dev server for worktree close", { sessionId, worktree: closedPath, error: err });
+    }
     updateSessionWorkdir(sessionId, project.workdir, null);
     try {
       await shutdownLspManager(sessionId);
@@ -3367,15 +3406,15 @@ Operating in the original project directory at ${project.workdir}.
 // src/server/routes/skills.ts
 import { Router as Router2 } from "express";
 import multer from "multer";
-import { access as access2, mkdir as mkdir2, realpath, stat } from "fs/promises";
+import { access as access2, mkdir as mkdir3, realpath, stat } from "fs/promises";
 import { constants as constants2 } from "fs";
 import { homedir } from "os";
-import { isAbsolute as isAbsolute2, join as join4, resolve as resolve2 } from "path";
+import { isAbsolute as isAbsolute2, join as join5, resolve as resolve3 } from "path";
 
 // src/server/skills/installer.ts
 import { randomUUID } from "crypto";
-import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
-import { dirname as dirname3, isAbsolute, join as join2 } from "path";
+import { mkdir as mkdir2, readFile as readFile2, rename, rm, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, isAbsolute, join as join3 } from "path";
 import matter from "gray-matter";
 var SkillInstallError = class extends Error {
   constructor(message, status) {
@@ -3407,17 +3446,17 @@ async function installSkillPackage(libraryDir, packageName, files) {
     totalBytes += file.content.byteLength;
   }
   if (totalBytes > 50 * 1024 * 1024) throw new SkillInstallError("Package exceeds 50 MiB", 413);
-  const destination = join2(libraryDir, packageName);
+  const destination = join3(libraryDir, packageName);
   if (await pathExists(destination)) throw new SkillInstallError("A package with this name already exists", 409);
-  const staging = join2(libraryDir, `.${packageName}.openfox-upload-${randomUUID()}`);
+  const staging = join3(libraryDir, `.${packageName}.openfox-upload-${randomUUID()}`);
   try {
-    await mkdir(staging, { recursive: false });
+    await mkdir2(staging, { recursive: false });
     for (const file of files) {
-      const target = join2(staging, file.path);
-      await mkdir(dirname3(target), { recursive: true });
-      await writeFile(target, file.content);
+      const target = join3(staging, file.path);
+      await mkdir2(dirname3(target), { recursive: true });
+      await writeFile2(target, file.content);
     }
-    const parsed = matter(await readFile(join2(staging, "SKILL.md"), "utf-8"));
+    const parsed = matter(await readFile2(join3(staging, "SKILL.md"), "utf-8"));
     const name = typeof parsed.data["name"] === "string" ? parsed.data["name"].trim() : "";
     const description = typeof parsed.data["description"] === "string" ? parsed.data["description"].trim() : "";
     if (!name || !description || !parsed.content.trim()) {
@@ -3434,7 +3473,7 @@ async function installSkillPackage(libraryDir, packageName, files) {
 
 // src/server/routes/crud-helpers.ts
 import { Router } from "express";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 function computeOverrideIds(defaults, userItems) {
   return userItems.filter((u) => defaults.some((d) => d.metadata.id === u.metadata.id)).map((u) => u.metadata.id);
 }
@@ -3446,7 +3485,7 @@ function validateNameIdPrompt(body) {
   return null;
 }
 function getProjectItemPath(projectDir, dirName, id, ext) {
-  return join3(projectDir, ".openfox", dirName, `${id}${ext}`);
+  return join4(projectDir, ".openfox", dirName, `${id}${ext}`);
 }
 async function isProjectItem(projectDir, dirName, id, ext) {
   if (!projectDir) return false;
@@ -3591,7 +3630,7 @@ var upload = multer({
 });
 function expandHome(path) {
   if (path === "~") return homedir();
-  return path.startsWith("~/") ? join4(homedir(), path.slice(2)) : path;
+  return path.startsWith("~/") ? join5(homedir(), path.slice(2)) : path;
 }
 function configuredDirectory() {
   const raw = getSetting(SKILL_DIRECTORIES_SETTING);
@@ -3604,13 +3643,13 @@ function configuredDirectory() {
   }
 }
 function defaultLibrary(configDir) {
-  const path = resolve2(configDir, "skills");
+  const path = resolve3(configDir, "skills");
   return { configuredPath: path, resolvedPath: path, available: true, custom: false };
 }
 async function resolveLibrary(path) {
   const expanded = expandHome(path);
   if (!isAbsolute2(expanded)) throw new Error("Selected path must be absolute");
-  const absolute = resolve2(expanded);
+  const absolute = resolve3(expanded);
   const info = await stat(absolute);
   if (!info.isDirectory()) throw new Error("Selected path is not a directory");
   await access2(absolute, constants2.R_OK);
@@ -3699,7 +3738,7 @@ function createSkillRoutes(configDir, projectDir) {
       try {
         const configured = configuredDirectory();
         const library = configured ? await resolveLibrary(configured) : defaultLibrary(configDir);
-        await mkdir2(library.resolvedPath, { recursive: true });
+        await mkdir3(library.resolvedPath, { recursive: true });
         const packageName = String(req.body["packageName"] ?? "");
         const paths = JSON.parse(String(req.body["paths"] ?? "[]"));
         const files = req.files;
@@ -3749,19 +3788,19 @@ function createSkillRoutes(configDir, projectDir) {
 }
 
 // src/server/commands/registry.ts
-import { writeFile as writeFile2, mkdir as mkdir3, unlink } from "fs/promises";
-import { join as join5, dirname as dirname4 } from "path";
+import { writeFile as writeFile3, mkdir as mkdir4, unlink } from "fs/promises";
+import { join as join6, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import matter2 from "gray-matter";
 var __bundleDir = dirname4(fileURLToPath4(import.meta.url));
-var DEFAULTS_DIR = join5(__bundleDir, "defaults");
-var DEFAULTS_DIR_ALT = join5(__bundleDir, "command-defaults");
+var DEFAULTS_DIR = join6(__bundleDir, "defaults");
+var DEFAULTS_DIR_ALT = join6(__bundleDir, "command-defaults");
 var COMMAND_EXTENSION = ".command.md";
 function getCommandsDir(configDir) {
-  return join5(configDir, "commands");
+  return join6(configDir, "commands");
 }
 function getProjectCommandsDir(projectDir) {
-  return join5(projectDir, ".openfox", "commands");
+  return join6(projectDir, ".openfox", "commands");
 }
 async function loadDefaultCommands() {
   let defaults = await loadItemsFromDir(DEFAULTS_DIR, {
@@ -3818,19 +3857,19 @@ function findCommandById(commandId, commands) {
   return commands.find((c) => c.metadata.id === commandId);
 }
 async function commandExists(configDir, commandId, projectDir) {
-  if (await pathExists(join5(getCommandsDir(configDir), `${commandId}${COMMAND_EXTENSION}`))) return true;
-  if (projectDir && await pathExists(join5(getProjectCommandsDir(projectDir), `${commandId}${COMMAND_EXTENSION}`)))
+  if (await pathExists(join6(getCommandsDir(configDir), `${commandId}${COMMAND_EXTENSION}`))) return true;
+  if (projectDir && await pathExists(join6(getProjectCommandsDir(projectDir), `${commandId}${COMMAND_EXTENSION}`)))
     return true;
   return false;
 }
 async function saveCommand(configDir, command) {
   const commandsDir = getCommandsDir(configDir);
   if (!await pathExists(commandsDir)) {
-    await mkdir3(commandsDir, { recursive: true });
+    await mkdir4(commandsDir, { recursive: true });
   }
-  const filePath = join5(commandsDir, `${command.metadata.id}${COMMAND_EXTENSION}`);
+  const filePath = join6(commandsDir, `${command.metadata.id}${COMMAND_EXTENSION}`);
   const content = matter2.stringify(command.prompt, command.metadata);
-  await writeFile2(filePath, content, "utf-8");
+  await writeFile3(filePath, content, "utf-8");
 }
 async function saveCommandToProject(projectDir, command) {
   await saveItemToDir(
@@ -3848,7 +3887,7 @@ async function deleteCommand(configDir, commandId) {
   if (isDefault) {
     return { success: false, reason: "Cannot delete built-in defaults" };
   }
-  const filePath = join5(getCommandsDir(configDir), `${commandId}${COMMAND_EXTENSION}`);
+  const filePath = join6(getCommandsDir(configDir), `${commandId}${COMMAND_EXTENSION}`);
   try {
     await unlink(filePath);
     return { success: true };
@@ -4028,10 +4067,38 @@ function createDevServerRoutes() {
   return router;
 }
 
-// src/server/routes/terminals.ts
+// src/server/routes/worktree-config.ts
 import { Router as Router5 } from "express";
-function createTerminalRoutes() {
+function createWorktreeConfigRoutes() {
   const router = Router5();
+  router.get("/config", async (req, res) => {
+    const workdir = req.query["workdir"];
+    if (!workdir) return res.status(400).json({ error: "workdir required" });
+    const config3 = await loadWorktreeConfig(workdir);
+    res.json({ config: config3 });
+  });
+  router.post("/config", async (req, res) => {
+    const workdir = req.query["workdir"];
+    if (!workdir) return res.status(400).json({ error: "workdir required" });
+    const { ignoredAssets, overrides } = req.body;
+    if (!ignoredAssets || !["symlink", "copy", "skip"].includes(ignoredAssets)) {
+      return res.status(400).json({ error: "ignoredAssets must be one of: symlink, copy, skip" });
+    }
+    try {
+      const config3 = { ignoredAssets, overrides: overrides ?? void 0 };
+      await saveWorktreeConfig(workdir, config3);
+      res.json({ config: config3 });
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : "Failed to save config" });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/terminals.ts
+import { Router as Router6 } from "express";
+function createTerminalRoutes() {
+  const router = Router6();
   router.get("/", (req, res) => {
     const projectId = req.query["projectId"];
     const sessions = projectId ? terminalManager.getByProject(projectId) : [];
@@ -4070,20 +4137,20 @@ function createTerminalRoutes() {
 }
 
 // src/server/routes/directories.ts
-import { Router as Router6 } from "express";
+import { Router as Router7 } from "express";
 import { readdir } from "fs/promises";
-import { resolve as resolve3, join as join6, dirname as dirname5, basename as basename2 } from "path";
+import { resolve as resolve4, join as join7, dirname as dirname5, basename as basename2 } from "path";
 function createDirectoryRoutes() {
-  const router = Router6();
+  const router = Router7();
   const DEFAULT_BASE_PATH = process.cwd();
   router.get("/", async (req, res) => {
     const path = req.query["path"] || DEFAULT_BASE_PATH;
     try {
-      const resolvedPath = resolve3(path);
+      const resolvedPath = resolve4(path);
       const entries = await readdir(resolvedPath, { withFileTypes: true });
       const directories = entries.filter((entry) => entry.isDirectory()).map((entry) => ({
         name: entry.name,
-        path: join6(resolvedPath, entry.name)
+        path: join7(resolvedPath, entry.name)
       })).sort((a, b) => a.name.localeCompare(b.name));
       const parent = dirname5(resolvedPath);
       const hasParent = parent !== resolvedPath;
@@ -4107,10 +4174,10 @@ function createDirectoryRoutes() {
 }
 
 // src/server/routes/file-search.ts
-import { Router as Router7 } from "express";
+import { Router as Router8 } from "express";
 import fg from "fast-glob";
 function createFileSearchRoutes() {
-  const router = Router7();
+  const router = Router8();
   router.get("/", async (req, res) => {
     const query = req.query["q"] || "";
     const workdir = req.query["workdir"] || process.cwd();
@@ -4186,11 +4253,11 @@ function fuzzyScore(filePath, query) {
 }
 
 // src/server/routes/auto-update.ts
-import { Router as Router8 } from "express";
+import { Router as Router9 } from "express";
 import { spawn as spawn2 } from "child_process";
 
 // src/constants.ts
-var VERSION = "2.0.66";
+var VERSION = "2.0.68";
 
 // src/server/routes/auto-update.ts
 var updateInProgress = false;
@@ -4208,12 +4275,12 @@ async function checkAuth(req, opts) {
   return true;
 }
 function createAutoUpdateRoutes(options = {}) {
-  const router = Router8();
+  const router = Router9();
   router.get("/check", async (_req, res) => {
     const isService = isRunningAsService();
     const current = VERSION;
     try {
-      const latest = await new Promise((resolve6, reject) => {
+      const latest = await new Promise((resolve8, reject) => {
         const child = spawn2("npm", ["view", "openfox", "version"], {
           stdio: ["ignore", "pipe", "pipe"],
           windowsHide: true
@@ -4224,7 +4291,7 @@ function createAutoUpdateRoutes(options = {}) {
         });
         child.on("close", (code) => {
           if (code === 0) {
-            resolve6(stdout.trim());
+            resolve8(stdout.trim());
           } else {
             reject(new Error(`npm view exited with code ${code}`));
           }
@@ -4268,9 +4335,9 @@ function createAutoUpdateRoutes(options = {}) {
       const timeout = setTimeout(() => {
         child.kill();
       }, UPDATE_TIMEOUT);
-      const exitCode = await new Promise((resolve6) => {
-        child.on("close", resolve6);
-        child.on("error", () => resolve6(1));
+      const exitCode = await new Promise((resolve8) => {
+        child.on("close", resolve8);
+        child.on("error", () => resolve8(1));
       });
       clearTimeout(timeout);
       if (exitCode === 0) {
@@ -4308,9 +4375,9 @@ function createAutoUpdateRoutes(options = {}) {
 }
 
 // src/server/routes/provider-auth.ts
-import { Router as Router9 } from "express";
+import { Router as Router10 } from "express";
 function createProviderAuthRoutes(config3, providerManager, registry) {
-  const router = Router9();
+  const router = Router10();
   function resolveAuthContext(providerId, res) {
     const provider = providerManager.getProviders().find((item) => item.id === providerId);
     if (!provider) {
@@ -4433,14 +4500,16 @@ var ProviderRegistry = class {
   }
   register(map, id, value, kind) {
     if (!id.trim()) throw new Error(`Provider ${kind} id cannot be empty`);
-    if (map.has(id)) throw new Error(`Provider ${kind} already registered: ${id}`);
+    if (map.has(id)) {
+      map.delete(id);
+    }
     map.set(id, value);
   }
 };
 
 // src/server/providers/plugins/loader.ts
-import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
-import { dirname as dirname6, join as join7, resolve as resolve4 } from "path";
+import { readdir as readdir2, readFile as readFile3, stat as stat2 } from "fs/promises";
+import { dirname as dirname6, join as join8, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath5, pathToFileURL } from "url";
 async function packageDirectories(root) {
   let entries;
@@ -4451,13 +4520,13 @@ async function packageDirectories(root) {
   }
   const directories = [];
   for (const entry of entries) {
-    const entryPath = join7(root, entry.name);
+    const entryPath = join8(root, entry.name);
     const isDirectory = entry.isDirectory() || entry.isSymbolicLink() && (await stat2(entryPath).catch(() => void 0))?.isDirectory();
     if (!isDirectory) continue;
     if (entry.name.startsWith("@")) {
       const scoped = await readdir2(entryPath, { withFileTypes: true }).catch(() => []);
       for (const child of scoped) {
-        const childPath = join7(entryPath, child.name);
+        const childPath = join8(entryPath, child.name);
         const childIsDirectory = child.isDirectory() || child.isSymbolicLink() && (await stat2(childPath).catch(() => void 0))?.isDirectory();
         if (childIsDirectory) directories.push(childPath);
       }
@@ -4470,19 +4539,19 @@ async function packageDirectories(root) {
 async function loadProviderPlugins(options) {
   const moduleDirectory = dirname6(fileURLToPath5(import.meta.url));
   const roots = [
-    join7(options.configDirectory, "plugins"),
-    join7(options.cwd ?? process.cwd(), "node_modules"),
-    resolve4(moduleDirectory, "node_modules"),
-    resolve4(moduleDirectory, "../../../../node_modules")
+    join8(options.configDirectory, "plugins"),
+    join8(options.cwd ?? process.cwd(), "node_modules"),
+    resolve5(moduleDirectory, "node_modules"),
+    resolve5(moduleDirectory, "../../../../node_modules")
   ];
   const seen = /* @__PURE__ */ new Set();
   const diagnostics = [];
   for (const root of roots) {
     for (const packageDir of await packageDirectories(root)) {
-      const manifestPath = join7(packageDir, "package.json");
+      const manifestPath = join8(packageDir, "package.json");
       let manifest;
       try {
-        manifest = JSON.parse(await readFile2(manifestPath, "utf8"));
+        manifest = JSON.parse(await readFile3(manifestPath, "utf8"));
       } catch {
         continue;
       }
@@ -4520,7 +4589,7 @@ async function loadProviderPlugins(options) {
         }
       };
       try {
-        const module = await import(pathToFileURL(join7(packageDir, plugin)).href);
+        const module = await import(pathToFileURL(join8(packageDir, plugin)).href);
         if (typeof module.register !== "function") throw new Error("Plugin does not export register(registry)");
         await module.register(trackingRegistry);
         diagnostic.loaded = true;
@@ -4532,8 +4601,199 @@ async function loadProviderPlugins(options) {
   return diagnostics;
 }
 
+// src/server/routes/plugins.ts
+import { Router as Router11 } from "express";
+import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL2 } from "url";
+import { dirname as dirname7, resolve as resolve6, join as join9 } from "path";
+import { readFile as readFile4, readdir as readdir3, rm as rm2, rename as rename2 } from "fs/promises";
+import { platform } from "os";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileP = promisify(execFile);
+async function openFolder(dir, res) {
+  try {
+    await execFileP("mkdir", ["-p", dir], { timeout: 5e3 });
+    const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "explorer" : "xdg-open";
+    await execFileP(cmd, [dir], { timeout: 5e3 });
+    res.json({ success: true });
+  } catch (err) {
+    res.status(500).json({ error: err instanceof Error ? err.message : "Failed to open folder" });
+  }
+}
+function createPluginRoutes(options) {
+  const router = Router11();
+  const { config: config3, providerAdapters, pluginDiagnostics, logger: logger2 } = options;
+  let registryCache = null;
+  router.get("/registry", async (_req, res) => {
+    try {
+      const now = Date.now();
+      if (registryCache && now - registryCache.ts < 3e5) {
+        return res.json({ plugins: registryCache.data });
+      }
+      const moduleDir = dirname7(fileURLToPath6(import.meta.url));
+      const registryPath = resolve6(moduleDir, "../../../plugins-registry.json");
+      const data = JSON.parse(await readFile4(registryPath, "utf8"));
+      registryCache = { data, ts: now };
+      res.json({ plugins: data });
+    } catch (err) {
+      logger2.error("Failed to load plugin registry", { error: String(err) });
+      res.json({ plugins: [] });
+    }
+  });
+  router.post("/install", async (req, res) => {
+    const { githubUrl } = req.body;
+    if (!githubUrl || typeof githubUrl !== "string") {
+      return res.status(400).json({ error: "githubUrl is required" });
+    }
+    const parsed = githubUrl.match(/github\.com\/([^/]+)\/([^/]+?)(?:\/|$)/);
+    if (!parsed) {
+      return res.status(400).json({ error: "Invalid GitHub URL" });
+    }
+    const repoName = parsed[2].replace(/\.git$/, "");
+    if (!/^[a-zA-Z0-9_-]+$/.test(repoName)) {
+      return res.status(400).json({ error: "Invalid repository name" });
+    }
+    const pluginsDir = join9(getGlobalConfigDir(config3.mode ?? "production"), "plugins");
+    const targetDir = join9(pluginsDir, repoName);
+    const tmpDir = join9(pluginsDir, `.${repoName}-tmp-${Date.now()}`);
+    try {
+      await execFileP("mkdir", ["-p", pluginsDir], { timeout: 5e3 });
+    } catch {
+      return res.status(500).json({ error: "Failed to create plugins directory" });
+    }
+    let gitOk = false;
+    try {
+      const { stdout } = await execFileP("git", ["--version"], { timeout: 5e3 });
+      gitOk = stdout.includes("git version");
+    } catch {
+    }
+    if (!gitOk) {
+      return res.status(500).json({ error: "git is not installed or not found in PATH" });
+    }
+    try {
+      const cloneUrl = githubUrl.replace(/\/$/, "") + ".git";
+      await execFileP("git", ["clone", "--depth", "1", cloneUrl, tmpDir], { timeout: 6e4 });
+      await rm2(targetDir, { recursive: true, force: true });
+      await rename2(tmpDir, targetDir);
+      let loaded = false;
+      let loadError;
+      try {
+        await execFileP("npm", ["install", "--no-audit", "--no-fund"], { cwd: targetDir, timeout: 12e4 });
+        await execFileP("npm", ["run", "build"], { cwd: targetDir, timeout: 12e4 });
+      } catch (err) {
+        loadError = "Failed to install/build plugin dependencies";
+        logger2.error("Plugin build failed", { repoName, error: String(err) });
+      }
+      if (!loadError) {
+        try {
+          const manifest = JSON.parse(await readFile4(join9(targetDir, "package.json"), "utf8"));
+          const pluginEntry = manifest.openfox?.plugin;
+          const apiVersion = manifest.openfox?.apiVersion;
+          if (!pluginEntry || !manifest.name) {
+            loadError = "Plugin package.json is missing openfox.plugin or name field";
+          } else if (apiVersion !== 1) {
+            loadError = `Unsupported plugin API version: ${String(apiVersion)}`;
+          } else {
+            const mod = await import(pathToFileURL2(join9(targetDir, pluginEntry)).href);
+            if (typeof mod.register !== "function") {
+              loadError = "Plugin does not export register(registry)";
+            } else {
+              const diagnostic = {
+                packageName: manifest.name,
+                version: manifest.version,
+                source: targetDir,
+                loaded: false,
+                authAdapters: [],
+                transportAdapters: [],
+                presets: []
+              };
+              const trackingRegistry = {
+                runtime: providerAdapters.runtime,
+                registerAuth(adapter) {
+                  providerAdapters.registerAuth(adapter);
+                  diagnostic.authAdapters.push(adapter.id);
+                },
+                registerTransport(adapter) {
+                  providerAdapters.registerTransport(adapter);
+                  diagnostic.transportAdapters.push(adapter.id);
+                },
+                registerPreset(preset) {
+                  providerAdapters.registerPreset(preset);
+                  diagnostic.presets.push(preset.id);
+                }
+              };
+              await mod.register(trackingRegistry);
+              diagnostic.loaded = true;
+              pluginDiagnostics.push(diagnostic);
+              loaded = true;
+              config3.providers = providerAdapters.resolveProviders(config3.providers ?? []);
+            }
+          }
+        } catch (err) {
+          loadError = err instanceof Error ? err.message : "Failed to load plugin";
+          logger2.error("Plugin runtime load failed", { repoName, error: loadError });
+        }
+      }
+      res.json({ success: true, loaded, loadError, path: targetDir });
+    } catch (err) {
+      await rm2(tmpDir, { recursive: true, force: true });
+      const msg = err instanceof Error ? err.message : "Clone failed";
+      logger2.error("Plugin install failed", { githubUrl, error: msg });
+      res.status(500).json({ error: msg });
+    }
+  });
+  router.get("/installed", async (_req, res) => {
+    const pluginsDir = join9(getGlobalConfigDir(config3.mode ?? "production"), "plugins");
+    try {
+      const entries = await readdir3(pluginsDir, { withFileTypes: true });
+      const installed = [];
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const pkgPath = join9(pluginsDir, entry.name, "package.json");
+        let version = null;
+        try {
+          const pkg = JSON.parse(await readFile4(pkgPath, "utf8"));
+          version = pkg.version ?? null;
+        } catch {
+        }
+        installed.push({ name: entry.name, version });
+      }
+      res.json({ installed });
+    } catch {
+      res.json({ installed: [] });
+    }
+  });
+  router.get("/open-folder", async (_req, res) => {
+    const pluginsDir = join9(getGlobalConfigDir(config3.mode ?? "production"), "plugins");
+    await openFolder(pluginsDir, res);
+  });
+  router.get("/:name/open-folder", async (req, res) => {
+    const name = req.params.name;
+    if (!/^[a-zA-Z0-9_-]+$/.test(name)) return res.status(400).json({ error: "Invalid plugin name" });
+    const targetDir = join9(getGlobalConfigDir(config3.mode ?? "production"), "plugins", name);
+    await openFolder(targetDir, res);
+  });
+  router.delete("/:name", async (req, res) => {
+    const name = req.params.name;
+    if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+      return res.status(400).json({ error: "Invalid plugin name" });
+    }
+    const targetDir = join9(getGlobalConfigDir(config3.mode ?? "production"), "plugins", name);
+    try {
+      await rm2(targetDir, { recursive: true, force: true });
+      for (let i = pluginDiagnostics.length - 1; i >= 0; i--) {
+        if (pluginDiagnostics[i].source === targetDir) pluginDiagnostics.splice(i, 1);
+      }
+      res.json({ success: true });
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : "Failed to remove plugin" });
+    }
+  });
+  return router;
+}
+
 // src/server/index.ts
-var __dirname3 = dirname7(fileURLToPath6(import.meta.url));
+var __dirname3 = dirname8(fileURLToPath7(import.meta.url));
 async function createServerHandle(config3) {
   setRuntimeConfig(config3);
   setLogLevel(config3.logging?.level ?? void 0, config3.mode);
@@ -4630,7 +4890,7 @@ async function createServerHandle(config3) {
       setMcpTools(mcpTools);
       logger.info("MCP tools registered", { count: mcpTools.length });
     }
-    const { signalMcpReady } = await import("./server-W42ENYFX.js");
+    const { signalMcpReady } = await import("./server-ECKS2Y3R.js");
     signalMcpReady();
   });
   const app = express();
@@ -4791,7 +5051,7 @@ async function createServerHandle(config3) {
     const { getProject: getProject2 } = await import("./projects-7HSBZY2D.js");
     const project = getProject2(req.params.id);
     if (!project) return res.status(404).json({ error: "Project not found" });
-    const { listBranches } = await import("./worktree-EIF75WGF.js");
+    const { listBranches } = await import("./worktree-6U45P63P.js");
     const branches = await listBranches(project.workdir);
     res.json({ branches });
   });
@@ -4801,7 +5061,7 @@ async function createServerHandle(config3) {
     if (!project) return res.status(404).json({ error: "Project not found" });
     const { branch } = req.body;
     if (!branch || typeof branch !== "string") return res.status(400).json({ error: "branch is required" });
-    const { checkoutBranch } = await import("./worktree-EIF75WGF.js");
+    const { checkoutBranch } = await import("./worktree-6U45P63P.js");
     try {
       await checkoutBranch(project.workdir, branch);
       res.json({ branch });
@@ -4815,7 +5075,7 @@ async function createServerHandle(config3) {
     if (!project) return res.status(404).json({ error: "Project not found" });
     const { name } = req.body;
     if (!name || typeof name !== "string") return res.status(400).json({ error: "name is required" });
-    const { createBranch } = await import("./worktree-EIF75WGF.js");
+    const { createBranch } = await import("./worktree-6U45P63P.js");
     try {
       await createBranch(project.workdir, name);
       res.json({ branch: name });
@@ -4827,7 +5087,7 @@ async function createServerHandle(config3) {
     const { getProject: getProject2 } = await import("./projects-7HSBZY2D.js");
     const project = getProject2(req.params.id);
     if (!project) return res.status(404).json({ error: "Project not found" });
-    const { listWorktrees } = await import("./worktree-EIF75WGF.js");
+    const { listWorktrees } = await import("./worktree-6U45P63P.js");
     const all = await listWorktrees(project.workdir);
     const worktrees = all.filter((wt) => wt.path !== project.workdir);
     res.json({ worktrees });
@@ -4902,7 +5162,7 @@ async function createServerHandle(config3) {
   app.get("/api/sessions/:id", async (req, res) => {
     const { getEventStore: getEventStore2 } = await import("./events-CDQ4HASP.js");
     const { buildMessagesFromStoredEvents } = await import("./folding-V2K34EGN.js");
-    const { getPendingQuestionsForSession } = await import("./tools-2EB7C6H2.js");
+    const { getPendingQuestionsForSession } = await import("./tools-QAEN5KHA.js");
     const session = sessionManager.getSession(req.params.id);
     if (!session) {
       return res.status(404).json({ error: "Session not found" });
@@ -4921,8 +5181,8 @@ async function createServerHandle(config3) {
     if (!session) {
       return res.status(404).json({ error: "Session not found" });
     }
-    const { stopSessionExecution } = await import("./chat-handler-ZRDNSLOG.js");
-    const { cancelQuestionsForSession, cancelPathConfirmationsForSession } = await import("./tools-2EB7C6H2.js");
+    const { stopSessionExecution } = await import("./chat-handler-QFEHJBWN.js");
+    const { cancelQuestionsForSession, cancelPathConfirmationsForSession } = await import("./tools-QAEN5KHA.js");
     sessionManager.clearMessageQueue(sessionId);
     stopSessionExecution(sessionId, sessionManager);
     abortSession(sessionId);
@@ -5076,7 +5336,7 @@ async function createServerHandle(config3) {
     if (!callId || approved === void 0) {
       return res.status(400).json({ error: "callId and approved are required" });
     }
-    const { providePathConfirmation } = await import("./tools-2EB7C6H2.js");
+    const { providePathConfirmation } = await import("./tools-QAEN5KHA.js");
     const result = providePathConfirmation(callId, approved, alwaysAllow);
     if (!result.found) {
       return res.status(404).json({ error: "No pending path confirmation with that ID" });
@@ -5084,7 +5344,7 @@ async function createServerHandle(config3) {
     const { getEventStore: getEventStore2 } = await import("./events-CDQ4HASP.js");
     const { buildMessagesFromStoredEvents, foldPendingConfirmations } = await import("./folding-V2K34EGN.js");
     const { createSessionStateMessage } = await import("./protocol-CTNE3ANP.js");
-    const { getPendingQuestionsForSession } = await import("./tools-2EB7C6H2.js");
+    const { getPendingQuestionsForSession } = await import("./tools-QAEN5KHA.js");
     const eventStore = getEventStore2();
     const events = eventStore.getEvents(sessionId);
     const messages = buildMessagesFromStoredEvents(events);
@@ -5105,7 +5365,7 @@ async function createServerHandle(config3) {
     if (!skip && typeof answer !== "string") {
       return res.status(400).json({ error: "answer is required when not skipping" });
     }
-    const { provideAnswer } = await import("./tools-2EB7C6H2.js");
+    const { provideAnswer } = await import("./tools-QAEN5KHA.js");
     const found = provideAnswer(callId, answer ?? "", skip ?? false);
     if (!found) {
       return res.status(404).json({ error: "No pending question with that ID" });
@@ -5133,7 +5393,7 @@ async function createServerHandle(config3) {
     if (!session) {
       return res.status(404).json({ error: "Session not found" });
     }
-    const { getSetting: getSetting2, SETTINGS_KEYS } = await import("./settings-ZZ6AKFPD.js");
+    const { getSetting: getSetting2, SETTINGS_KEYS } = await import("./settings-6ZPWOBWL.js");
     if (getSetting2(SETTINGS_KEYS.CACHE_WARMING) !== "true") {
       return res.json({ success: false, reason: "disabled" });
     }
@@ -5165,7 +5425,7 @@ async function createServerHandle(config3) {
       backend: activeProvider?.backend ?? llmClient.getBackend(),
       model: llmClient.getModel()
     };
-    const { runAgentTurn, TurnMetrics } = await import("./orchestrator-LZQTDOWM.js");
+    const { runAgentTurn, TurnMetrics } = await import("./orchestrator-GNXKJPX4.js");
     runAgentTurn(
       {
         sessionManager,
@@ -5203,8 +5463,8 @@ async function createServerHandle(config3) {
     if (!session) {
       return res.status(404).json({ error: "Session not found" });
     }
-    const { stopSessionExecution } = await import("./chat-handler-ZRDNSLOG.js");
-    const { cancelQuestionsForSession, cancelPathConfirmationsForSession } = await import("./tools-2EB7C6H2.js");
+    const { stopSessionExecution } = await import("./chat-handler-QFEHJBWN.js");
+    const { cancelQuestionsForSession, cancelPathConfirmationsForSession } = await import("./tools-QAEN5KHA.js");
     const queuedMessages = sessionManager.getQueueState(sessionId);
     sessionManager.clearMessageQueue(sessionId);
     stopSessionExecution(sessionId, sessionManager);
@@ -5284,7 +5544,7 @@ async function createServerHandle(config3) {
     res.json({ accepted: true });
   });
   app.get("/api/settings", async (req, res) => {
-    const { getSetting: getSetting2, SETTINGS_DEFAULTS } = await import("./settings-ZZ6AKFPD.js");
+    const { getSetting: getSetting2, SETTINGS_DEFAULTS } = await import("./settings-6ZPWOBWL.js");
     const keysParam = req.query["keys"];
     if (!keysParam) {
       return res.status(400).json({ error: "keys query parameter is required" });
@@ -5297,19 +5557,19 @@ async function createServerHandle(config3) {
     res.json(result);
   });
   app.get("/api/settings/:key", async (req, res) => {
-    const { getSetting: getSetting2, SETTINGS_DEFAULTS } = await import("./settings-ZZ6AKFPD.js");
+    const { getSetting: getSetting2, SETTINGS_DEFAULTS } = await import("./settings-6ZPWOBWL.js");
     const key = req.params.key;
     const value = getSetting2(key) ?? SETTINGS_DEFAULTS[key] ?? null;
     res.json({ key, value });
   });
   app.get("/api/settings/:key", async (req, res) => {
-    const { getSetting: getSetting2, SETTINGS_DEFAULTS } = await import("./settings-ZZ6AKFPD.js");
+    const { getSetting: getSetting2, SETTINGS_DEFAULTS } = await import("./settings-6ZPWOBWL.js");
     const key = req.params.key;
     const value = getSetting2(key) ?? SETTINGS_DEFAULTS[key] ?? null;
     res.json({ key, value });
   });
   app.put("/api/settings/:key", async (req, res) => {
-    const { setSetting: setSetting2 } = await import("./settings-ZZ6AKFPD.js");
+    const { setSetting: setSetting2 } = await import("./settings-6ZPWOBWL.js");
     const key = req.params.key;
     const { value } = req.body;
     if (value === void 0) {
@@ -5321,20 +5581,24 @@ async function createServerHandle(config3) {
   app.get("/api/tools/rtk-check", async (_req, res) => {
     const { spawn: spawn3 } = await import("child_process");
     try {
-      const available = await new Promise((resolve6) => {
+      const available = await new Promise((resolve8) => {
         const proc = spawn3("rtk", ["--version"], { stdio: ["ignore", "pipe", "pipe"] });
         let out = "";
         proc.stdout?.on("data", (d) => {
           out += d.toString();
         });
-        proc.on("error", () => resolve6(false));
-        proc.on("close", (code) => resolve6(code === 0 && out.startsWith("rtk ")));
+        proc.on("error", () => resolve8(false));
+        proc.on("close", (code) => resolve8(code === 0 && out.startsWith("rtk ")));
       });
       res.json({ available });
     } catch {
       res.json({ available: false });
     }
   });
+  app.get("/api/tools/shells", async (_req, res) => {
+    const { listAvailableShells } = await import("./platform-AB3GIEGO.js");
+    res.json({ shells: listAvailableShells() });
+  });
   app.get("/api/config", async (_req, res) => {
     const llmClient = getLLMClient();
     const activeProvider = providerManager.getActiveProvider();
@@ -5494,7 +5758,7 @@ async function createServerHandle(config3) {
     const backend = req.query["backend"];
     if (!url) return res.status(400).json({ error: "url is required" });
     try {
-      const { fetchModelsWithContext } = await import("./provider-manager-D3KIOD5E.js");
+      const { fetchModelsWithContext } = await import("./provider-manager-7C3JVOLW.js");
       const { getModelProfile: getModelProfile2 } = await import("./profiles-5J7F4BML.js");
       const models = await fetchModelsWithContext(
         url,
@@ -5564,7 +5828,7 @@ async function createServerHandle(config3) {
       }
       const { getModelProfile: getModelProfile2 } = await import("./profiles-5J7F4BML.js");
       const { getBackendCapabilities } = await import("./backend-P3GHHLHJ.js");
-      const { buildNonStreamingCreateParams } = await import("./client-pure-U6ZYUPJQ.js");
+      const { buildNonStreamingCreateParams } = await import("./client-pure-XHH4RRLB.js");
       const { OpenAIHttpClient } = await import("./http-client-PIWB7BXK.js");
       const { ensureVersionPrefix } = await import("./url-utils-SAJP7AEX.js");
       const profile = getModelProfile2(model);
@@ -5690,6 +5954,7 @@ async function createServerHandle(config3) {
       });
     }
   });
+  app.use("/api/plugins", createPluginRoutes({ config: config3, providerAdapters, pluginDiagnostics, logger }));
   app.get("/api/plugins", (_req, res) => res.json({ plugins: pluginDiagnostics }));
   app.get("/api/provider-presets", (_req, res) => res.json({ presets: providerAdapters.getPresets() }));
   app.get(
@@ -5822,7 +6087,7 @@ async function createServerHandle(config3) {
   });
   async function rebuildMcpTools() {
     const { createMcpTools: createMcpTools2 } = await import("./tool-adapter-MOGEI6TP.js");
-    const { setMcpTools: setMcpTools2 } = await import("./tools-2EB7C6H2.js");
+    const { setMcpTools: setMcpTools2 } = await import("./tools-QAEN5KHA.js");
     const mcpTools = createMcpTools2(mcpManager);
     setMcpTools2(mcpTools);
   }
@@ -5977,6 +6242,7 @@ async function createServerHandle(config3) {
   app.use("/api/agents", createAgentRoutes(configDir, projectDir));
   app.use("/api/workflows", createWorkflowRoutes(configDir, config3, projectDir));
   app.use("/api/dev-server", createDevServerRoutes());
+  app.use("/api/worktree", createWorktreeConfigRoutes());
   app.use("/api/terminals", createTerminalRoutes());
   app.use(
     "/api/auto-update",
@@ -5993,13 +6259,13 @@ async function createServerHandle(config3) {
     })
   );
   app.get("/api/sessions/:id/background-processes", async (req, res) => {
-    const { getSessionProcesses } = await import("./manager-344C5JLZ.js");
+    const { getSessionProcesses } = await import("./manager-JXYRGR6B.js");
     const sessionId = req.params.id;
     const processes = getSessionProcesses(sessionId);
     res.json({ processes });
   });
   app.post("/api/sessions/:id/background-process/:processId/stop", async (req, res) => {
-    const { stopProcess } = await import("./manager-344C5JLZ.js");
+    const { stopProcess } = await import("./manager-JXYRGR6B.js");
     const sessionId = req.params.id;
     const processId = req.params.processId;
     const session = sessionManager.getSession(sessionId);
@@ -6019,14 +6285,14 @@ async function createServerHandle(config3) {
   });
   app.use("/api/directories", createDirectoryRoutes());
   app.use("/api/files", createFileSearchRoutes());
-  const webDir = resolve5(__dirname3, "../../web");
+  const webDir = resolve7(__dirname3, "../../web");
   const isDev = config3.mode === "development";
   let viteServer;
   if (isDev) {
     logger.info("Dev mode: using Vite middleware");
     viteServer = await createViteServer({
       root: webDir,
-      configFile: resolve5(__dirname3, "../../web/vite.config.ts"),
+      configFile: resolve7(__dirname3, "../../web/vite.config.ts"),
       server: { middlewareMode: true },
       appType: "spa",
       logLevel: "warn"
@@ -6046,7 +6312,7 @@ async function createServerHandle(config3) {
       }
     });
     app.get("/fox.svg", (_req, res) => {
-      readFile3(join8(webDir, "fox.svg")).then((content) => {
+      readFile5(join10(webDir, "fox.svg")).then((content) => {
         res.set("Content-Type", "image/svg+xml");
         res.send(content);
       }).catch(() => {
@@ -6055,7 +6321,7 @@ async function createServerHandle(config3) {
     });
     app.use(
       "/sounds",
-      express.static(join8(webDir, "public", "sounds"), {
+      express.static(join10(webDir, "public", "sounds"), {
         setHeaders: (res) => {
           res.set("Content-Type", "audio/mpeg");
         }
@@ -6064,13 +6330,13 @@ async function createServerHandle(config3) {
     app.use("/__inspect__.js", (_req, res) => {
       res.set("Access-Control-Allow-Origin", "*");
       res.set("Content-Type", "application/javascript");
-      readFile3(join8(webDir, "public", "__inspect__.js")).then((content) => res.send(content)).catch(() => res.status(404).send("Not found"));
+      readFile5(join10(webDir, "public", "__inspect__.js")).then((content) => res.send(content)).catch(() => res.status(404).send("Not found"));
     });
     app.get("/*path", (req, res) => {
       if (req.path.startsWith("/api/")) {
         return;
       }
-      readFile3(join8(webDir, "index.html"), "utf-8").then((indexHtml) => viteServer.transformIndexHtml(req.originalUrl, indexHtml)).then((transformed) => res.send(transformed)).catch((err) => {
+      readFile5(join10(webDir, "index.html"), "utf-8").then((indexHtml) => viteServer.transformIndexHtml(req.originalUrl, indexHtml)).then((transformed) => res.send(transformed)).catch((err) => {
         logger.error("Error serving index.html", { error: err });
         res.status(500).send("Server error");
       });
@@ -6078,10 +6344,10 @@ async function createServerHandle(config3) {
     logger.info("Vite middleware ready", { port: config3.server.port });
   }
   if (!isDev) {
-    const distWebDir = resolve5(__dirname3, "web");
+    const distWebDir = resolve7(__dirname3, "web");
     app.use(
       "/assets",
-      express.static(join8(distWebDir, "assets"), {
+      express.static(join10(distWebDir, "assets"), {
         setHeaders: (res, filepath) => {
           if (filepath.endsWith(".css")) {
             res.set("Content-Type", "text/css");
@@ -6089,11 +6355,11 @@ async function createServerHandle(config3) {
         }
       })
     );
-    app.use("/manifest.webmanifest", express.static(join8(distWebDir, "manifest.webmanifest")));
-    app.use("/registerSW.js", express.static(join8(distWebDir, "registerSW.js")));
-    app.use("/sw.js", express.static(join8(distWebDir, "sw.js")));
+    app.use("/manifest.webmanifest", express.static(join10(distWebDir, "manifest.webmanifest")));
+    app.use("/registerSW.js", express.static(join10(distWebDir, "registerSW.js")));
+    app.use("/sw.js", express.static(join10(distWebDir, "sw.js")));
     app.get("/fox.svg", (_req, res) => {
-      readFile3(join8(distWebDir, "fox.svg")).then((content) => {
+      readFile5(join10(distWebDir, "fox.svg")).then((content) => {
         res.set("Content-Type", "image/svg+xml");
         res.send(content);
       }).catch(() => {
@@ -6102,7 +6368,7 @@ async function createServerHandle(config3) {
     });
     app.use(
       "/sounds",
-      express.static(join8(distWebDir, "sounds"), {
+      express.static(join10(distWebDir, "sounds"), {
         setHeaders: (res) => {
           res.set("Content-Type", "audio/mpeg");
         }
@@ -6111,10 +6377,10 @@ async function createServerHandle(config3) {
     app.use("/__inspect__.js", (_req, res) => {
       res.set("Access-Control-Allow-Origin", "*");
       res.set("Content-Type", "application/javascript");
-      readFile3(join8(distWebDir, "__inspect__.js")).then((content) => res.send(content)).catch(() => res.status(404).send("Not found"));
+      readFile5(join10(distWebDir, "__inspect__.js")).then((content) => res.send(content)).catch(() => res.status(404).send("Not found"));
     });
     app.get("/", (_req, res) => {
-      readFile3(join8(distWebDir, "index.html"), "utf-8").then((content) => res.send(content)).catch(() => {
+      readFile5(join10(distWebDir, "index.html"), "utf-8").then((content) => res.send(content)).catch(() => {
         res.status(404).send("Web UI not built. Run `npm run build:web`");
       });
     });
@@ -6122,7 +6388,7 @@ async function createServerHandle(config3) {
       if (req.path.startsWith("/api/") || req.path.startsWith("/assets/") || req.path.startsWith("/sounds/") || req.path.startsWith("/manifest.webmanifest") || req.path.startsWith("/registerSW.js") || req.path.startsWith("/sw.js") || req.path === "/fox.svg") {
         return;
       }
-      readFile3(join8(distWebDir, "index.html"), "utf-8").then((content) => res.send(content)).catch(() => {
+      readFile5(join10(distWebDir, "index.html"), "utf-8").then((content) => res.send(content)).catch(() => {
         res.status(404).send("Web UI not built");
       });
     });
@@ -6142,7 +6408,7 @@ async function createServerHandle(config3) {
     const state = sessionManager.getContextState(sessionId);
     wssExports.broadcastForSession(sessionId, createContextStateMessage(state));
   });
-  const { QueueProcessor } = await import("./processor-7KAXESY5.js");
+  const { QueueProcessor } = await import("./processor-TIQEQDP7.js");
   const queueProcessor = new QueueProcessor({
     sessionManager,
     providerManager,
@@ -6165,7 +6431,7 @@ async function createServerHandle(config3) {
   return {
     httpServer,
     ctx: { config: config3, sessionManager, llmClient: getLLMClient(), toolRegistry, providerManager },
-    start: (port) => new Promise((resolve6, reject) => {
+    start: (port) => new Promise((resolve8, reject) => {
       const listenPort = port ?? config3.server.port;
       const host = config3.server.host;
       httpServer.listen(listenPort, host, () => {
@@ -6175,16 +6441,16 @@ async function createServerHandle(config3) {
         logger.info(`OpenFox server running at http://${host}:${actualPort}`);
         logger.info(`WebSocket available at ws://${host}:${actualPort}/ws`);
         logger.info(`LLM backend: ${client.getBackend()}, model: ${client.getModel()}, url: ${config3.llm.baseUrl}`);
-        resolve6({ port: actualPort });
+        resolve8({ port: actualPort });
       });
       httpServer.on("error", reject);
     }),
-    close: () => new Promise((resolve6) => {
+    close: () => new Promise((resolve8) => {
       logger.info("Shutting down...");
       void (async () => {
         await devServerManager.stopAll();
         await mcpManager.disconnectAll();
-        const { stopAllInspectProxies } = await import("./inspect-proxy-PKMDR47R.js");
+        const { stopAllInspectProxies } = await import("./inspect-proxy-OVEFBJ26.js");
         stopAllInspectProxies();
         const { cleanupAllProcesses } = await import("./store-FXTCHBI4.js");
         cleanupAllProcesses();
@@ -6198,7 +6464,7 @@ async function createServerHandle(config3) {
           client.terminate();
         }
         wss.close();
-        httpServer.close(() => resolve6());
+        httpServer.close(() => resolve8());
       })();
     })
   };
@@ -6223,4 +6489,4 @@ export {
   createServerHandle,
   createServer
 };
-//# sourceMappingURL=chunk-OE5B44P6.js.map
+//# sourceMappingURL=chunk-DWZEGLHJ.js.map