@zythum02/fello-server 0.1.46 → 0.1.49

package/out/server/main.js

@@ -57,6 +57,9 @@ var DEFAULT_SETTINGS = {
     volume: 50,
     muted: false,
     theme: "soft"
+  },
+  proxy: {
+    mode: "off"
   }
 };
 function settingsPath() {
@@ -188,6 +191,20 @@ function readSettings() {
         theme: raw2.theme === "soft" || raw2.theme === "crisp" ? raw2.theme : DEFAULT_SETTINGS.sound.theme
       };
     })();
+    const proxy = (() => {
+      const raw2 = rawObj && isObject(rawObj.proxy) ? rawObj.proxy : null;
+      if (!raw2) return DEFAULT_SETTINGS.proxy;
+      const mode = raw2.mode === "off" || raw2.mode === "manual" || raw2.mode === "system" ? raw2.mode : DEFAULT_SETTINGS.proxy.mode;
+      const str = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+      return {
+        mode,
+        httpProxy: str(raw2.httpProxy),
+        httpsProxy: str(raw2.httpsProxy),
+        noProxy: str(raw2.noProxy),
+        username: str(raw2.username),
+        password: str(raw2.password)
+      };
+    })();
     const snippets = Array.isArray(rawObj?.snippets) ? rawObj.snippets.filter(
       (s) => isObject(s) && typeof s.id === "string" && typeof s.title === "string" && typeof s.content === "string"
     ) : [];
@@ -230,6 +247,7 @@ function readSettings() {
       ilink,
       editor,
       sound,
+      proxy,
       snippets,
       imageGeneration
     };
@@ -321,6 +339,7 @@ function getSettings() {
       muted: meta.sound.muted,
       theme: meta.sound.theme
     },
+    proxy: meta.proxy ?? DEFAULT_SETTINGS.proxy,
     snippets: meta.snippets ?? [],
     imageGeneration: (meta.imageGeneration ?? []).map((p) => ({
       id: p.id,
@@ -461,6 +480,21 @@ function updateSettings(settings) {
         theme: settings.sound.theme === "soft" || settings.sound.theme === "crisp" ? settings.sound.theme : prevMeta.sound.theme
       };
     })(),
+    proxy: (() => {
+      if (!settings.proxy) {
+        return prevMeta.proxy;
+      }
+      const mode = settings.proxy.mode === "off" || settings.proxy.mode === "manual" || settings.proxy.mode === "system" ? settings.proxy.mode : prevMeta.proxy?.mode ?? DEFAULT_SETTINGS.proxy.mode;
+      const str = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+      return {
+        mode,
+        httpProxy: str(settings.proxy.httpProxy),
+        httpsProxy: str(settings.proxy.httpsProxy),
+        noProxy: str(settings.proxy.noProxy),
+        username: str(settings.proxy.username),
+        password: str(settings.proxy.password)
+      };
+    })(),
     snippets: settings.snippets ?? prevMeta.snippets,
     imageGeneration: settings.imageGeneration ? settings.imageGeneration.map((p) => ({
       id: p.id,
@@ -1505,19 +1539,6 @@ import { relative as relative2, resolve as resolve2, isAbsolute as isAbsolute2 }
 function toPosixPath(p) {
   return p.replace(/\\/g, "/");
 }
-var IGNORE_NAME_SET = /* @__PURE__ */ new Set([".git", ".svn", ".hg", "node_modules", "vendor", "__pycache__"]);
-function isIgnorePath(fullPath, cwd) {
-  if (fullPath === cwd) return false;
-  const relPath = relative2(cwd, fullPath);
-  if (!relPath) return false;
-  const segments = relPath.split(/[\\/]+/);
-  for (let i = 0; i < segments.length; i++) {
-    const name = segments[i];
-    if (!name || name === ".") continue;
-    if (IGNORE_NAME_SET.has(name)) return true;
-  }
-  return false;
-}
 function resolveSafePath(cwd, relativePath) {
   const safeCwd = resolve2(cwd);
   const fullPath = resolve2(safeCwd, relativePath || "");
@@ -1779,11 +1800,11 @@ function createWebUIModule() {
         }
       });
     });
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const listenPort = options?.port && options.port > 0 ? options.port : 0;
       httpServer.listen(listenPort, "0.0.0.0", () => {
         isEnabled = true;
-        resolve8({ url: getWebUIUrl(httpServer.address()) });
+        resolve9({ url: getWebUIUrl(httpServer.address()) });
       });
       httpServer.on("error", reject);
     });
@@ -2168,7 +2189,7 @@ import { join as join12 } from "path";
 
 // src/shared/zod/mcp-search-schema.ts
 import { z } from "zod";
-var searchRequestSchema = z.object({
+var grepRequestSchema = z.object({
   pattern: z.string().describe("Search pattern (literal text by default, set regex=true for regex)."),
   path: z.string().describe(
     "Directory or file(s) to search. Accepts: relative path (relative to project root), absolute path (POSIX or Windows), or file:// URI."
@@ -2183,20 +2204,10 @@ var searchRequestSchema = z.object({
   invertMatch: z.boolean().optional().describe("Show lines that do NOT match the pattern (-v)."),
   wordMatch: z.boolean().optional().describe("Only match whole words (-w).")
 });
-var searchRespondSchema = z.object({
+var grepRespondSchema = z.object({
   output: z.string(),
   code: z.number()
 });
-var rgRequestSchema = z.object({
-  args: z.array(z.string()).describe(
-    "Raw ripgrep CLI arguments (e.g. ['-i', 'pattern', 'src/']). The pattern and path are included in this array."
-  )
-});
-var rgRespondSchema = z.object({
-  output: z.string(),
-  code: z.number(),
-  stderr: z.string().optional()
-});
 var fileOutlineRequestSchema = z.object({
   path: z.string().describe(
     "File path to analyze. Accepts: relative path (relative to project root), absolute path (POSIX or Windows), or file:// URI."
@@ -2205,6 +2216,20 @@ var fileOutlineRequestSchema = z.object({
 var fileOutlineRespondSchema = z.object({
   outline: z.string().describe("Structural outline of the file in text format.")
 });
+var globRequestSchema = z.object({
+  pattern: z.string().describe("Glob pattern, e.g. '**/*.rs', 'src/**/*.{ts,tsx}'."),
+  path: z.string().optional().describe("Root directory to search from. Defaults to project root."),
+  limit: z.number().int().positive().optional().describe("Maximum number of results to return."),
+  maxDepth: z.number().int().positive().optional().describe("Maximum directory depth to traverse."),
+  dot: z.boolean().optional().describe("Include dotfiles (hidden files/directories). Default: false."),
+  onlyFiles: z.boolean().optional().describe("Only match files, not directories. Default: false (includes directories)."),
+  gitignore: z.boolean().optional().describe("Respect .gitignore patterns. Default: true.")
+});
+var globRespondSchema = z.object({
+  filePaths: z.array(z.string()),
+  totalFiles: z.number(),
+  truncated: z.boolean()
+});
 
 // src/backend/search/file-outline.ts
 import { extname, join as join10, isAbsolute as isAbsolute4, resolve as resolve3, relative as relative5 } from "path";
@@ -2627,7 +2652,7 @@ var LANGUAGES = [
   }
 ];
 async function parseInChild(filePath, config, cwd, timeout = 3e4) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const modulePath = join10(process.scriptsPath, "/worker-file-outline/worker.mjs");
     const child = fork(modulePath, [], { execArgv: [], cwd });
     const timer = setTimeout(() => {
@@ -2636,7 +2661,7 @@ async function parseInChild(filePath, config, cwd, timeout = 3e4) {
     }, timeout);
     child.on("message", (msg) => {
       clearTimeout(timer);
-      if (msg.type === "result") resolve8({ symbols: msg.symbols, totalLines: msg.totalLines });
+      if (msg.type === "result") resolve9({ symbols: msg.symbols, totalLines: msg.totalLines });
       else reject(new Error(msg.error));
     });
     child.on("error", (err) => {
@@ -2799,7 +2824,7 @@ import { join as join11, isAbsolute as isAbsolute5, resolve as resolve4, relativ
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { fork as fork2 } from "child_process";
 function ripgrepInChild(args2, cwd, timeout = 3e4) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const child = fork2(join11(process.scriptsPath, "worker-ripgrep/worker.mjs"), [], { cwd });
     const timer = setTimeout(() => {
       child.kill();
@@ -2808,7 +2833,7 @@ function ripgrepInChild(args2, cwd, timeout = 3e4) {
     child.on("message", (msg) => {
       clearTimeout(timer);
       if (msg.type === "error") reject(new Error(msg.error));
-      else resolve8({ code: msg.code, stdout: msg.stdout, stderr: msg.stderr });
+      else resolve9({ code: msg.code, stdout: msg.stdout, stderr: msg.stderr });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
@@ -2831,7 +2856,7 @@ function normalizePath2(inputPath, cwd) {
   }
   return resolve4(cwd ?? process.cwd(), inputPath);
 }
-async function search(options) {
+async function grep(options) {
   const args2 = [];
   args2.push("--heading");
   args2.push("--line-number");
@@ -2853,16 +2878,38 @@ async function search(options) {
   const { code, stdout } = await ripgrepInChild(args2, options.projectDir, options.timeout);
   return { output: stdout || "", code };
 }
-async function rg(options) {
-  const { code, stdout, stderr } = await ripgrepInChild(
-    options.args,
-    options.projectDir,
-    options.timeout
-  );
+
+// src/backend/search/glob.ts
+import { globby } from "globby";
+import { isAbsolute as isAbsolute6, resolve as resolve5 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+function normalizePath3(inputPath, cwd) {
+  if (inputPath.startsWith("file://")) {
+    return fileURLToPath5(inputPath);
+  }
+  if (isAbsolute6(inputPath)) {
+    return inputPath;
+  }
+  return resolve5(cwd ?? process.cwd(), inputPath);
+}
+async function glob(options) {
+  const cwd = options.path ? normalizePath3(options.path, options.projectDir) : options.projectDir;
+  const entries = await globby(options.pattern, {
+    cwd,
+    dot: options.dot ?? false,
+    onlyFiles: options.onlyFiles ?? false,
+    markDirectories: true,
+    gitignore: options.gitignore ?? true,
+    deep: options.maxDepth
+  });
+  entries.sort();
+  const limit = options.limit ?? 500;
+  const truncated = entries.length > limit;
+  const filePaths = truncated ? entries.slice(0, limit) : entries;
   return {
-    output: stdout || "",
-    code,
-    stderr: stderr || void 0
+    filePaths,
+    totalFiles: entries.length,
+    truncated
   };
 }
 
@@ -2871,21 +2918,21 @@ function createSearchModule(_ctx) {
   return { registerSearchRoute, buildSearchMcpServer };
 }
 function registerSearchRoute(server, projectDir) {
-  server.registry("search/search", async (payload) => {
-    const params = searchRequestSchema.parse(payload);
-    const result = await search({ projectDir, ...params });
-    return searchRespondSchema.parse(result);
-  });
-  server.registry("search/rg", async (payload) => {
-    const params = rgRequestSchema.parse(payload);
-    const result = await rg({ projectDir, ...params });
-    return rgRespondSchema.parse(result);
+  server.registry("search/grep", async (payload) => {
+    const params = grepRequestSchema.parse(payload);
+    const result = await grep({ projectDir, ...params });
+    return grepRespondSchema.parse(result);
   });
   server.registry("search/file_outline", async (payload) => {
     const params = fileOutlineRequestSchema.parse(payload);
     const result = await fileOutline({ projectDir, ...params });
     return fileOutlineRespondSchema.parse(result);
   });
+  server.registry("search/glob", async (payload) => {
+    const params = globRequestSchema.parse(payload);
+    const result = await glob({ projectDir, ...params });
+    return globRespondSchema.parse(result);
+  });
 }
 function buildSearchMcpServer(options) {
   return {
@@ -2948,7 +2995,11 @@ function createAskUserModule(ctx, deps) {
   async function askUser(options) {
     const { sessionId } = options;
     const askUserId = randomUUID2();
-    const request = { ...options, askUserId };
+    const request = {
+      ...options,
+      askUserId,
+      timeoutAt: Date.now() + USER_REQUEST_TIMEOUT_MS
+    };
     sendEvent("ask-user-request", request);
     const ilinkBridge = deps.ilink.getBridge();
     const ilinkActiveSessionId = deps.ilink.getActiveSessionId();
@@ -2963,13 +3014,13 @@ function createAskUserModule(ctx, deps) {
         });
       }
     }
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       const timeoutId = setTimeout(() => {
         const pending = pendingRequests.get(askUserId);
         if (pending) {
           pendingRequests.delete(askUserId);
           const response = { value: null, reason: "timeout" };
-          resolve8(response);
+          resolve9(response);
           sendEvent("ask-user-response", {
             sessionId,
             askUserId,
@@ -2980,7 +3031,7 @@ function createAskUserModule(ctx, deps) {
           console.warn(`[askUser] timeout fired but no pending request found for ${askUserId}`);
         }
       }, USER_REQUEST_TIMEOUT_MS);
-      pendingRequests.set(askUserId, { resolve: resolve8, timeoutId, sessionId, request });
+      pendingRequests.set(askUserId, { resolve: resolve9, timeoutId, sessionId, request });
     });
   }
   async function getPendingAskUserRequests({ sessionId }) {
@@ -3048,8 +3099,8 @@ function createAskUserModule(ctx, deps) {
 
 // src/backend/share-to-user.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { join as join14 } from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import { join as join14, relative as relative7, isAbsolute as isAbsolute7 } from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
 import { readFile as readFile5, writeFile } from "fs/promises";
 import { existsSync as existsSync6, mkdirSync as mkdirSync6 } from "fs";
 import * as mimeTypes3 from "mime-types";
@@ -3098,23 +3149,29 @@ function createShareToUserModule(ctx, deps) {
     const { sessionId, type, uri, data, name, mimeType } = options;
     const resolvedMimeType = resolveMimeType(name, mimeType);
     if (type === "project" && uri) {
+      const session = storage.getSession(sessionId);
+      if (!session) throw new Error(`Session not found: ${sessionId}`);
+      let projectPath = uri.startsWith("file://") ? fileURLToPath6(uri) : uri;
+      if (isAbsolute7(projectPath)) {
+        const rel = relative7(session.cwd, projectPath);
+        if (!rel.startsWith("..") && !isAbsolute7(rel)) {
+          projectPath = rel;
+        }
+      }
       const ilinkBridge2 = deps.ilink.getBridge();
       const ilinkActiveSessionId2 = deps.ilink.getActiveSessionId();
       if (ilinkBridge2?.isConnected && sessionId === ilinkActiveSessionId2) {
         const toUserId = ilinkBridge2.userId;
         if (toUserId) {
-          const session = storage.getSession(sessionId);
-          if (session) {
-            deps.ilink.appendMediaBuffer({
-              filePath: join14(session.cwd, uri),
-              name,
-              toUserId,
-              mimeType: resolvedMimeType
-            });
-          }
+          deps.ilink.appendMediaBuffer({
+            filePath: join14(session.cwd, projectPath),
+            name,
+            toUserId,
+            mimeType: resolvedMimeType
+          });
         }
       }
-      return { name, projectPath: uri, mimeType: resolvedMimeType };
+      return { name, projectPath, mimeType: resolvedMimeType };
     }
     const shareId = randomUUID3();
     const shareDir = storage.sessionShareDir(sessionId);
@@ -3132,7 +3189,7 @@ function createShareToUserModule(ctx, deps) {
           if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
           buffer = Buffer.from(await response.arrayBuffer());
         } else {
-          const sourcePath = uri.startsWith("file://") ? fileURLToPath5(uri) : uri;
+          const sourcePath = uri.startsWith("file://") ? fileURLToPath6(uri) : uri;
           buffer = await readFile5(sourcePath);
         }
       } catch (err) {
@@ -3224,9 +3281,9 @@ function spawnStdioAgent(options) {
       proc.stdin.end();
     } catch {
     }
-    await new Promise((resolve8) => {
+    await new Promise((resolve9) => {
       if (proc.exitCode !== null) {
-        resolve8();
+        resolve9();
         return;
       }
       let killTimer = null;
@@ -3234,13 +3291,13 @@ function spawnStdioAgent(options) {
         if (killTimer) {
           clearTimeout(killTimer);
         }
-        resolve8();
+        resolve9();
       };
       proc.once("exit", onExit);
       killProcessGroup(proc, "SIGTERM");
       killTimer = setTimeout(() => {
         killProcessGroup(proc, "SIGKILL");
-        resolve8();
+        resolve9();
       }, 2e3);
     });
   }
@@ -3356,7 +3413,7 @@ var AgentClientProxy = class {
 };
 
 // src/agents/acp-client-tools.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 import { tool } from "ai";
 import { z as z4 } from "zod";
 
@@ -3549,7 +3606,7 @@ Always prefer using line/limit to read specific sections, or use the Search MCP'
         if (!connection) {
           throw new Error("ACP connection is not available.");
         }
-        const filename = resolve5(cwd ?? params.cwd, path2);
+        const filename = resolve6(cwd ?? params.cwd, path2);
         let title = `ReadFile ${filename}`;
         if (line || limit) {
           title += `:${line ?? 0}`;
@@ -3656,7 +3713,7 @@ Always prefer using line/limit to read specific sections, or use the Search MCP'
         if (!connection) {
           throw new Error("ACP connection is not available.");
         }
-        const filename = resolve5(cwd ?? params.cwd, path2);
+        const filename = resolve6(cwd ?? params.cwd, path2);
         let title = `WriteFile ${filename}`;
         const toolCall = {
           toolCallId,
@@ -3741,7 +3798,7 @@ Use exact string matching for oldText and set replaceAll=true when needed.`,
         if (!connection) {
           throw new Error("ACP connection is not available.");
         }
-        const filename = resolve5(cwd ?? params.cwd, path2);
+        const filename = resolve6(cwd ?? params.cwd, path2);
         const title = `EditFile ${filename}`;
         const toolCall = {
           toolCallId,
@@ -3921,8 +3978,8 @@ Avoid destructive commands and prefer deterministic, non-interactive commands.`,
           try {
             const waitPromise = terminal.waitForExit();
             if (timeoutMs) {
-              const timeoutPromise = new Promise((resolve8) => {
-                setTimeout(() => resolve8(null), timeoutMs);
+              const timeoutPromise = new Promise((resolve9) => {
+                setTimeout(() => resolve9(null), timeoutMs);
               });
               const waitResult = await Promise.race([waitPromise, timeoutPromise]);
               if (waitResult === null) {
@@ -4041,6 +4098,208 @@ async function closeACPClientTools(session) {
 import { createMCPClient } from "@ai-sdk/mcp";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { ContentBlockSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/backend/proxy.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import http from "node:http";
+import https from "node:https";
+import { Agent as UndiciAgent, EnvHttpProxyAgent, setGlobalDispatcher } from "undici";
+import { ProxyAgent as NodeProxyAgent } from "proxy-agent";
+var PROXY_ENV_KEYS = [
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "NO_PROXY",
+  "http_proxy",
+  "https_proxy",
+  "no_proxy"
+];
+var currentConfig = { enabled: false };
+function settingProxyInfoToProxyConfig(input) {
+  if (!input || input.mode === "off") return { enabled: false };
+  const str = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+  return {
+    enabled: true,
+    httpProxy: str(input.httpProxy),
+    httpsProxy: str(input.httpsProxy),
+    noProxy: str(input.noProxy),
+    username: str(input.username),
+    password: str(input.password)
+  };
+}
+function normalizeProxyUrl(raw) {
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    try {
+      url = new URL(`http://${trimmed}`);
+    } catch {
+      return void 0;
+    }
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+  return url.toString().replace(/\/+$/, "");
+}
+function withAuth(url, username, password) {
+  if (!username) return url;
+  try {
+    const parsed = new URL(url);
+    parsed.username = username;
+    if (password) parsed.password = password;
+    return parsed.toString().replace(/\/+$/, "");
+  } catch {
+    return url;
+  }
+}
+function buildProxyEnv() {
+  const config = currentConfig;
+  if (config.enabled === false) return {};
+  const httpProxy = normalizeProxyUrl(config.httpProxy);
+  const httpsProxy = normalizeProxyUrl(config.httpsProxy ?? config.httpProxy);
+  if (!httpProxy && !httpsProxy) return {};
+  const noProxy = config.noProxy?.trim();
+  const env = {};
+  if (httpProxy) {
+    const httpUrl = withAuth(httpProxy, config.username, config.password);
+    if (httpUrl) {
+      env.HTTP_PROXY = httpUrl;
+      env.http_proxy = httpUrl;
+    }
+  }
+  if (httpsProxy) {
+    const httpsUrl = withAuth(httpsProxy, config.username, config.password);
+    if (httpsUrl) {
+      env.HTTPS_PROXY = httpsUrl;
+      env.https_proxy = httpsUrl;
+    }
+  }
+  if (noProxy) {
+    env.NO_PROXY = noProxy;
+    env.no_proxy = noProxy;
+  }
+  return env;
+}
+function setProcessEnv(env) {
+  for (const key of PROXY_ENV_KEYS) {
+    if (env[key]) {
+      process.env[key] = env[key];
+    } else {
+      delete process.env[key];
+    }
+  }
+}
+function resetGlobalDispatchers() {
+  setGlobalDispatcher(new UndiciAgent());
+  http.globalAgent = new http.Agent();
+  https.globalAgent = new https.Agent();
+}
+function enableGlobalDispatchers() {
+  setGlobalDispatcher(new EnvHttpProxyAgent());
+  http.globalAgent = new NodeProxyAgent();
+  https.globalAgent = new NodeProxyAgent();
+}
+function applyProxy(config) {
+  currentConfig = config;
+  if (config.enabled === false) {
+    setProcessEnv({});
+    resetGlobalDispatchers();
+    return;
+  }
+  const env = buildProxyEnv();
+  if (Object.keys(env).length === 0) {
+    setProcessEnv({});
+    resetGlobalDispatchers();
+    return;
+  }
+  setProcessEnv(env);
+  enableGlobalDispatchers();
+}
+function detectSystemProxy() {
+  const envHttp = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
+  if (envHttp) {
+    return {
+      enabled: true,
+      httpProxy: process.env.HTTP_PROXY || process.env.http_proxy || void 0,
+      httpsProxy: process.env.HTTPS_PROXY || process.env.https_proxy || void 0,
+      noProxy: process.env.NO_PROXY || process.env.no_proxy || void 0
+    };
+  }
+  try {
+    if (process.platform === "darwin") {
+      const stdout = execFileSync2("scutil", ["--proxy"], { timeout: 3e3 }).toString();
+      return parseScutilProxy(stdout);
+    }
+    if (process.platform === "win32") {
+      const stdout = execFileSync2("netsh", ["winhttp", "show", "proxy"], {
+        timeout: 3e3
+      }).toString();
+      return parseNetshProxy(stdout);
+    }
+  } catch {
+  }
+  return { enabled: false };
+}
+function parseScutilProxy(stdout) {
+  const get = (key) => {
+    const m = stdout.match(new RegExp(`^\\s*${key}\\s*:\\s*(.+)$`, "m"));
+    return m ? m[1].trim() : void 0;
+  };
+  const host = (key) => {
+    const value = get(key);
+    if (!value || value === "<null>") return void 0;
+    return value.replace(/^"|"$/g, "");
+  };
+  const port2 = (key) => {
+    const value = get(key);
+    return value && value !== "0" ? value : void 0;
+  };
+  const build = (enableKey, hostKey, portKey) => {
+    if (get(enableKey) !== "1") return void 0;
+    const h = host(hostKey);
+    if (!h) return void 0;
+    const p = port2(portKey);
+    let proxyUrl = `http://${h}`;
+    if (p) {
+      proxyUrl += `:${p}`;
+    }
+    return proxyUrl;
+  };
+  const httpProxy = build("HTTPEnable", "HTTPProxy", "HTTPPort");
+  const httpsProxy = build("HTTPSEnable", "HTTPSProxy", "HTTPSPort");
+  if (!httpProxy && !httpsProxy) return { enabled: false };
+  return { enabled: true, httpProxy, httpsProxy };
+}
+function parseNetshProxy(stdout) {
+  const match = stdout.match(/Proxy\s*Server\(s\)\s*:\s*(.+)$/m);
+  if (!match) return { enabled: false };
+  const raw = match[1].trim();
+  if (!raw || raw === "<none>") return { enabled: false };
+  let httpProxy;
+  let httpsProxy;
+  for (const part of raw.split(";")) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) {
+      httpProxy = `http://${trimmed}`;
+      httpsProxy = `http://${trimmed}`;
+    } else {
+      const scheme = trimmed.slice(0, eq).trim().toLowerCase();
+      const value = trimmed.slice(eq + 1).trim();
+      if (scheme === "http") httpProxy = `http://${value}`;
+      else if (scheme === "https") httpsProxy = `http://${value}`;
+    }
+  }
+  const bypass = stdout.match(/Bypass\s*List\s*:\s*(.+)$/m);
+  const noProxy = bypass ? bypass[1].trim().replace(/<local>/g, "localhost,127.0.0.1") : void 0;
+  if (!httpProxy && !httpsProxy) return { enabled: false };
+  return { enabled: true, httpProxy, httpsProxy, noProxy };
+}
+
+// src/agents/mcp-tools.ts
 function sanitizeName(input) {
   return input.trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
 }
@@ -4060,7 +4319,7 @@ function toEnvRecord(env) {
 }
 function inferToolKind(name) {
   const normalized = name.toLowerCase();
-  if (normalized.includes("read") || normalized.includes("list") || normalized.includes("search")) {
+  if (normalized.includes("read") || normalized.includes("list") || normalized.includes("search") || normalized.includes("grep") || normalized.includes("glob")) {
     return "read";
   }
   if (normalized.includes("write") || normalized.includes("edit") || normalized.includes("update")) {
@@ -4090,7 +4349,10 @@ async function createClient(server, cwd) {
     transport: new StdioClientTransport({
       command: server.command,
       args: server.args,
-      env: toEnvRecord(server.env),
+      env: {
+        ...buildProxyEnv(),
+        ...toEnvRecord(server.env)
+      },
       cwd
     }),
     clientName: "fello-openai-compatible-agent",
@@ -4338,7 +4600,7 @@ Working style:
 File reading & editing strategy:
 - ReadFile will REJECT full reads of files over 100KB. Use line/limit to read specific sections, or set force=true if you genuinely need the full file content (rare).
 - Use the Search MCP's file_outline tool to preview file structure before reading (function/class/interface names with line ranges). Supports TypeScript, JavaScript, TSX, Python, Go, C, C++, Swift, Kotlin, Dart.
-- Use the Search MCP's search tool (structured) or rg tool (raw args) to search file contents instead of reading entire files.
+- Use the Search MCP's grep tool (structured pattern search) or glob tool (file finder) to search file contents instead of reading entire files.
 - EditFile uses exact string matching (StrReplace style). Use unique surrounding code context in oldText to make matches precise. Set replaceAll=true when you intend to replace all occurrences.
 - You do NOT need to re-read a file after editing it \u2014 the changes are already saved.
 
@@ -4362,7 +4624,7 @@ import { tool as tool3 } from "ai";
 import { z as z6 } from "zod";
 
 // src/agents/image-tools.ts
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 import { readFile as readFile6 } from "fs/promises";
 import mime from "mime-types";
 import { tool as tool2, generateText } from "ai";
@@ -4399,7 +4661,7 @@ Provide a specific query describing what you want to know about the image \u2014
           });
         }
         try {
-          const absPath = resolve6(params.cwd, imgPath);
+          const absPath = resolve7(params.cwd, imgPath);
           const buffer = await readFile6(absPath);
           const base64 = buffer.toString("base64");
           const mimeType = mime.lookup(absPath) || "image/png";
@@ -4754,7 +5016,6 @@ function buildWorkspaceSystemPrompt(cwd, additionalDirectories) {
   const workspacePrompt = `Current session working directory (cwd): ${cwd}.${extras} Use this as the default base path for relative paths.`;
   const now = /* @__PURE__ */ new Date();
   const dateStr = now.toLocaleDateString("en-CA");
-  const timeStr = now.toLocaleTimeString("en-US", { hour12: false });
   const weekday = now.toLocaleDateString("en-US", { weekday: "long" });
   const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
   const timezoneOffset = -now.getTimezoneOffset();
@@ -4763,7 +5024,7 @@ function buildWorkspaceSystemPrompt(cwd, additionalDirectories) {
   const offsetMinutes = String(Math.abs(timezoneOffset) % 60).padStart(2, "0");
   const utcOffset = `UTC${offsetSign}${offsetHours}:${offsetMinutes}`;
   const platform = process.platform;
-  const envContext = `Date and time: ${dateStr} ${timeStr} (${weekday})
+  const envContext = `Date: ${dateStr} (${weekday})
 Timezone: ${timezone} (${utcOffset})
 Platform: ${platform}`;
   let prompt = `${BASE_SYSTEM_PROMPT}
@@ -5508,14 +5769,14 @@ function spawnOpenaiCompatibleApiAgent(options) {
 }
 
 // src/backend/agent/agent-terminal-manager.ts
-import { spawn as spawn2, execFileSync as execFileSync2 } from "child_process";
+import { spawn as spawn2, execFileSync as execFileSync3 } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
 function detectTerminalOutputEncoding() {
   if (process.platform !== "win32") {
     return "utf-8";
   }
   try {
-    const output = execFileSync2("cmd", ["/d", "/s", "/c", "chcp"], {
+    const output = execFileSync3("cmd", ["/d", "/s", "/c", "chcp"], {
       encoding: "buffer",
       windowsHide: true
     });
@@ -5603,11 +5864,11 @@ var AgentTerminalManager = class {
     if (terminal.isFinished) {
       return { exitCode: terminal.exitCode, signal: terminal.signal };
     }
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       const originalOnExit = terminal.onExit;
       terminal.onExit = (code, signal) => {
         originalOnExit(code, signal);
-        resolve8({ exitCode: code, signal });
+        resolve9({ exitCode: code, signal });
       };
     });
   }
@@ -5775,7 +6036,14 @@ var ACPBridge = class {
   }
   async connect() {
     const acpId = this.id;
-    const proc = this.options.agentInfo.type === "stdio" ? spawnStdioAgent({ ...this.options.agentInfo, cwd: this.options.cwd }) : this.options.agentInfo.provider === "openai-compatible" ? spawnOpenaiCompatibleApiAgent(this.options.agentInfo) : (() => {
+    const proc = this.options.agentInfo.type === "stdio" ? spawnStdioAgent({
+      ...this.options.agentInfo,
+      cwd: this.options.cwd,
+      env: {
+        ...this.options.agentEnv,
+        ...this.options.agentInfo.env
+      }
+    }) : this.options.agentInfo.provider === "openai-compatible" ? spawnOpenaiCompatibleApiAgent(this.options.agentInfo) : (() => {
       throw new Error(`Unsupported api provider: ${this.options.agentInfo.provider}`);
     })();
     this.process = proc;
@@ -5816,7 +6084,7 @@ var ACPBridge = class {
     const applyConfigOptions = this.applyConfigOptions.bind(this);
     const terminalManager = this.terminalManager;
     const sessionsCwdMap = this._sessionsCwdMap;
-    const clientApp = client({ name: "Fello" }).onRequest(methods3.client.session.requestPermission, (ctx) => {
+    let clientApp = client({ name: "Fello" }).onRequest(methods3.client.session.requestPermission, (ctx) => {
       return onPermission(ctx.params);
     }).onNotification(methods3.client.session.update, (ctx) => {
       const params = ctx.params;
@@ -5859,25 +6127,12 @@ var ACPBridge = class {
     }).onRequest(methods3.client.terminal.release, (ctx) => {
       terminalManager.release(ctx.params.terminalId);
       return {};
-    }).onNotification(
-      "_kiro.dev/metadata",
-      (p) => p,
-      (ctx) => {
-        onExtNotification("_kiro.dev/metadata", ctx.params);
-      }
-    ).onNotification(
-      "_kiro.dev/commands/available",
-      (p) => p,
-      (ctx) => {
-        onExtNotification("_kiro.dev/commands/available", ctx.params);
-      }
-    ).onNotification(
-      "_kiro.dev/subagent/list_update",
-      (p) => p,
-      (ctx) => {
-        onExtNotification("_kiro.dev/subagent/list_update", ctx.params);
-      }
-    );
+    });
+    for (const spec of this.options.extNotificationSpecs) {
+      clientApp = clientApp.onNotification(spec.method, spec.parse, (ctx) => {
+        onExtNotification(spec.method, ctx.params);
+      });
+    }
     this.connection = clientApp.connect(stream);
     const initResult = await this.connection.agent.request(methods3.agent.initialize, {
       protocolVersion: PROTOCOL_VERSION2,
@@ -6103,7 +6358,9 @@ var ACPBridge = class {
   }
   async sendPrompt(params) {
     if (!this.connection) throw new Error("Not connected");
-    return this.connection.agent.request(methods3.agent.session.prompt, params);
+    const res = await this.connection.agent.request(methods3.agent.session.prompt, params);
+    this.options.onPromptCompleted?.(params.sessionId, res);
+    return res;
   }
   async cancel(params) {
     if (!this.connection) return;
@@ -6139,6 +6396,378 @@ var ACPBridge = class {
   }
 };
 
+// src/backend/acp-adapters/acp-adapter.ts
+var AcpAdapter = class {
+  /** Ext notification specs to register on the ACP client. */
+  extNotificationSpecs = [];
+  /**
+   * Process an incoming notification.
+   * - Return null to drop.
+   * - Return [notification] to pass through (possibly transformed).
+   * - Return [notification, ...synthetic] to pass through AND produce
+   *   additional notifications.
+   *
+   * Results go through the REST of the pipeline (title check, broadcast,
+   * storage) — NOT through preprocessNotification again, so adapters
+   * can safely inspect _meta fields without recursion risk. The original
+   * notification (if included in results) is stored, which preserves
+   * _meta for replay/state-rebuild.
+   */
+  preprocessNotification(notification, _currentSessionId, _agentId) {
+    return [notification];
+  }
+  handleExtNotification(_method, _params, _currentSessionId, _agentId) {
+    return [];
+  }
+  /**
+   * Agent process env vars to inject when spawning the agent. Protocol-
+   * specific environment needed by the agent process (e.g.
+   * CODEBUDDY_DEFER_TOOL_LOADING for CodeBuddy). Aggregated by
+   * adapters.ts and applied by ACPBridge when spawning a stdio agent;
+   * agent-specific agentInfo.env still takes precedence.
+   */
+  getAgentEnv() {
+    return {};
+  }
+  /**
+   * Called by the bridge when a prompt round completes, with the full
+   * PromptResponse in hand. Adapters that do turn-boundary / replay detection
+   * override this to extract the agent's own protocol-clock timestamp and
+   * freeze the boundary. Default no-op — only protocol-specific adapters
+   * (e.g. CodeBuddy, which stamps PromptResponse._meta with
+   * codebuddy.ai/requestId + timestamp) need it; generic adapters have no
+   * protocol timestamp to work from.
+   */
+  handlePromptCompleted(_sessionId, _res) {
+  }
+  // ── State lifecycle (default no-ops) ───────────────────────────────
+  rekey(_oldKey, _newKey) {
+  }
+  cleanup(_sessionKey) {
+  }
+  clearAll() {
+  }
+};
+
+// src/backend/acp-adapters/codebuddy-adapter.ts
+var CODEBUDDY_STATUS_MAP = {
+  running: "in_progress",
+  completed: "completed",
+  idle: "in_progress",
+  pending: "pending",
+  failed: "failed"
+};
+var CodebuddyAdapter = class extends AcpAdapter {
+  stateMap = /* @__PURE__ */ new Map();
+  /**
+   * Per-session turn-boundary timestamp (epoch ms, from the agent's own
+   * protocol clock). Frozen when a prompt completes (via handlePromptCompleted),
+   * so content chunks emitted afterwards with an earlier protocol timestamp
+   * are previous-turn replays. Only CodeBuddy stamps PromptResponse._meta
+   * with a protocol timestamp, so this stays here rather than in the base.
+   */
+  turnBoundaryTs = /* @__PURE__ */ new Map();
+  /**
+   * CodeBuddy spawn env.
+   */
+  getAgentEnv() {
+    return {
+      CODEBUDDY_DEFER_TOOL_LOADING: "0",
+      CODEBUDDY_DISABLE_AUTO_MEMORY: "1"
+    };
+  }
+  /**
+   * Freeze the turn-boundary on prompt completion. Only CodeBuddy stamps the
+   * PromptResponse._meta with codebuddy.ai/requestId + a protocol timestamp,
+   * so this stays here rather than in the generic bridge — the agent's own
+   * clock is the boundary used to drop replayed prior-turn chunks (avoids
+   * timezone / clock-skew issues that wall-clock Date.now() would introduce).
+   */
+  handlePromptCompleted(sessionId, res) {
+    const meta = res._meta;
+    if (meta && typeof meta["codebuddy.ai/requestId"] === "string") {
+      const ts = Date.parse(typeof meta["timestamp"] === "string" ? meta["timestamp"] : "");
+      if (!isNaN(ts)) this.turnBoundaryTs.set(sessionId, ts);
+    }
+  }
+  /**
+   * One unified hook for all notification processing:
+   *
+   * 1. Replay detection — the adapter freezes a turn-boundary timestamp in
+   *    handlePromptCompleted() when a prompt completes (using the agent's own
+   *    protocol clock). Drop agent_message_chunk / agent_thought_chunk whose
+   *    _meta.timestamp is earlier than that boundary: CodeBuddy re-broadcasts
+   *    the previous turn's messages when a new prompt begins, and those
+   *    re-emitted chunks carry the previous turn's (earlier) timestamps. Only
+   *    applies to chunks that carry codebuddy.ai/requestId.
+   * 2. memberEvent chunk routing — rewrite notification.sessionId from
+   *    parent to member sessionId (CodeBuddy stamps all member chunks
+   *    with the parent session).
+   * 3. Drop teammate-directed user_message_chunks (task assignments from
+   *    team-lead to members, wrapped in <teammate-message>).
+   * 4. teamUpdate lifecycle — convert team_created / member_status_change /
+   *    team_deleted into AddonSessionUpdate broadcasts via _meta.fello.update.
+   *
+   * Returns null to drop, [notification] to pass through, or
+   * [notification, ...synthetic] to pass through + produce additional.
+   * Results go through the REST of the pipeline (not this method again).
+   */
+  preprocessNotification(notification, currentSessionId, agentId) {
+    const meta = notification.update?._meta;
+    const sessionUpdate = notification.update?.sessionUpdate;
+    const requestId = meta?.["codebuddy.ai/requestId"];
+    const metaTimestamp = meta?.["timestamp"];
+    if (typeof requestId === "string" && typeof metaTimestamp === "string" && (sessionUpdate === "agent_message_chunk" || sessionUpdate === "agent_thought_chunk")) {
+      const ts = Date.parse(metaTimestamp);
+      if (!isNaN(ts)) {
+        const boundary = this.turnBoundaryTs.get(currentSessionId);
+        if (boundary !== void 0 && ts < boundary) {
+          return null;
+        }
+      }
+    }
+    const memberEvent = meta?.["codebuddy.ai/memberEvent"];
+    if (sessionUpdate === "user_message_chunk" && typeof memberEvent === "string") {
+      return null;
+    }
+    let result = notification;
+    if (typeof memberEvent === "string") {
+      const state = this.stateMap.get(currentSessionId);
+      const memberSessionId = state?.members.get(memberEvent)?.sessionId;
+      if (memberSessionId && notification.sessionId !== memberSessionId) {
+        result = { ...notification, sessionId: memberSessionId };
+      }
+    }
+    const teamUpdate = meta?.["codebuddy.ai/teamUpdate"];
+    if (teamUpdate && typeof teamUpdate === "object") {
+      const synthetic = this.processTeamUpdate(
+        teamUpdate,
+        currentSessionId,
+        agentId
+      );
+      return synthetic.length > 0 ? [result, ...synthetic] : [result];
+    }
+    return [result];
+  }
+  // ── Team update processing ─────────────────────────────────────────
+  /**
+   * Process a codebuddy.ai/teamUpdate event. Updates the cached team
+   * state and produces synthetic subagent_update notifications.
+   *
+   * - team_created → cache teamName as activeTeamName (no notifications)
+   * - member_status_change → resolve each member's teamName via event-level
+   *   teamName / existing member's teamName / activeTeamName, then produce
+   *   a subagent_update notification per member
+   * - team_deleted → mark still-active members of THAT team as `failed`
+   *   (preserving completed/failed), then produce a notification per active
+   *   member. Only removes that team's members from the cache.
+   * - team_idle / others → no-op
+   */
+  processTeamUpdate(teamUpdate, currentSessionId, agentId) {
+    const type = typeof teamUpdate.type === "string" ? teamUpdate.type : "";
+    const eventTeamName = typeof teamUpdate.teamName === "string" ? teamUpdate.teamName : null;
+    const getOrCreateState = () => {
+      let s = this.stateMap.get(currentSessionId);
+      if (!s) {
+        s = { members: /* @__PURE__ */ new Map(), activeTeamName: null };
+        this.stateMap.set(currentSessionId, s);
+      }
+      return s;
+    };
+    const makeSubagentUpdate = (memberSessionId, memberName, prompt, status) => {
+      const update = {
+        sessionUpdate: "subagent_update",
+        sessionId: memberSessionId,
+        ...memberName !== void 0 && { name: memberName },
+        ...prompt !== void 0 && { prompt },
+        status
+      };
+      return {
+        sessionId: currentSessionId.replace(`${agentId}:`, ""),
+        update: {
+          sessionUpdate: "session_info_update",
+          _meta: { fello: { update } }
+        }
+      };
+    };
+    if (type === "team_created") {
+      const state = getOrCreateState();
+      if (eventTeamName) state.activeTeamName = eventTeamName;
+      return [];
+    }
+    if (type === "team_deleted") {
+      const state = this.stateMap.get(currentSessionId);
+      if (!state || !eventTeamName) return [];
+      const results = [];
+      for (const [memberName, member] of state.members) {
+        if (member.teamName !== eventTeamName) continue;
+        if (member.status !== "completed" && member.status !== "failed") {
+          results.push(makeSubagentUpdate(member.sessionId, void 0, void 0, "failed"));
+        }
+        state.members.delete(memberName);
+      }
+      if (state.activeTeamName === eventTeamName) {
+        state.activeTeamName = null;
+      }
+      return results;
+    }
+    if (type === "member_status_change") {
+      const state = getOrCreateState();
+      const members = Array.isArray(teamUpdate.members) ? teamUpdate.members : [];
+      const results = [];
+      for (const member of members) {
+        if (!member || typeof member !== "object") continue;
+        const m = member;
+        const memberName = typeof m.name === "string" ? m.name : null;
+        const memberSessionId = typeof m.sessionId === "string" ? m.sessionId : null;
+        if (!memberName || !memberSessionId) continue;
+        const status = typeof m.status === "string" ? CODEBUDDY_STATUS_MAP[m.status] ?? "in_progress" : "in_progress";
+        const existing = state.members.get(memberName);
+        const resolvedTeamName = eventTeamName ?? existing?.teamName ?? state.activeTeamName ?? "";
+        state.members.set(memberName, {
+          sessionId: memberSessionId,
+          status,
+          teamName: resolvedTeamName
+        });
+        const prompt = typeof m.description === "string" ? m.description : void 0;
+        results.push(makeSubagentUpdate(memberSessionId, memberName, prompt, status));
+      }
+      return results;
+    }
+    return [];
+  }
+  // ── State lifecycle (mirror bridge-connect) ────────────────────────
+  rekey(oldKey, newKey) {
+    const state = this.stateMap.get(oldKey);
+    if (state) {
+      this.stateMap.delete(oldKey);
+      this.stateMap.set(newKey, state);
+    }
+    const boundary = this.turnBoundaryTs.get(oldKey);
+    if (boundary !== void 0) {
+      this.turnBoundaryTs.delete(oldKey);
+      this.turnBoundaryTs.set(newKey, boundary);
+    }
+  }
+  cleanup(sessionKey) {
+    this.stateMap.delete(sessionKey);
+    this.turnBoundaryTs.delete(sessionKey);
+  }
+  clearAll() {
+    this.stateMap.clear();
+    this.turnBoundaryTs.clear();
+  }
+};
+
+// src/backend/acp-adapters/kiro-adapter.ts
+var KIRO_STATUS_MAP = {
+  pending: "pending",
+  working: "in_progress",
+  terminated: "completed",
+  failed: "failed"
+};
+var parseMetadata = (p) => p;
+var parseCommandsAvailable = (p) => p;
+var parseSubagentList = (p) => p;
+var KiroAdapter = class extends AcpAdapter {
+  /** Ext notification specs declared here, registered by ACPBridge. */
+  extNotificationSpecs = [
+    { method: "_kiro.dev/metadata", parse: parseMetadata },
+    { method: "_kiro.dev/commands/available", parse: parseCommandsAvailable },
+    { method: "_kiro.dev/subagent/list_update", parse: parseSubagentList }
+  ];
+  /**
+   * Translate a Kiro ext notification into synthetic SessionNotification(s).
+   * Returns an empty array if the method is unrecognized.
+   */
+  handleExtNotification(method, params, currentSessionId, agentId) {
+    switch (method) {
+      case "_kiro.dev/metadata":
+        return this.handleMetadata(params, currentSessionId, agentId);
+      case "_kiro.dev/commands/available":
+        return this.handleCommandsAvailable(params, currentSessionId, agentId);
+      case "_kiro.dev/subagent/list_update":
+        return this.handleSubagentListUpdate(params, currentSessionId, agentId);
+      default:
+        return [];
+    }
+  }
+  // ── Handlers ──────────────────────────────────────────────────────
+  handleMetadata(params, currentSessionId, agentId) {
+    if (typeof params === "object" && params && "sessionId" in params && typeof params.sessionId === "string" && "contextUsagePercentage" in params && typeof params.contextUsagePercentage === "number" && currentSessionId === `${agentId}:${params.sessionId}`) {
+      return [
+        {
+          sessionId: params.sessionId,
+          update: {
+            sessionUpdate: "usage_update",
+            used: params.contextUsagePercentage / 100,
+            size: 1
+          }
+        }
+      ];
+    }
+    return [];
+  }
+  handleCommandsAvailable(params, currentSessionId, agentId) {
+    if (typeof params === "object" && params && "sessionId" in params && typeof params.sessionId === "string" && "commands" in params && Array.isArray(params.commands) && currentSessionId === `${agentId}:${params.sessionId}`) {
+      const commands = [];
+      for (const item of params.commands) {
+        if (typeof item === "object" && item && "name" in item && typeof item.name === "string") {
+          commands.push({
+            name: item.name.replace(/^\//, ""),
+            description: item.description ? String(item.description) : ""
+          });
+        }
+      }
+      return [
+        {
+          sessionId: params.sessionId,
+          update: {
+            sessionUpdate: "available_commands_update",
+            availableCommands: commands
+          }
+        }
+      ];
+    }
+    return [];
+  }
+  handleSubagentListUpdate(params, currentSessionId, agentId) {
+    if (typeof params === "object" && params && currentSessionId && "subagents" in params && Array.isArray(params.subagents)) {
+      const results = [];
+      for (const subagent of params.subagents) {
+        if (typeof subagent === "object" && subagent && "sessionId" in subagent && typeof subagent.sessionId === "string") {
+          const update = {
+            sessionUpdate: "subagent_update",
+            sessionId: subagent.sessionId,
+            name: typeof subagent.sessionName === "string" ? subagent.sessionName : void 0,
+            prompt: typeof subagent.initialQuery === "string" ? subagent.initialQuery : void 0,
+            status: KIRO_STATUS_MAP[String(subagent?.status?.type)]
+          };
+          results.push({
+            sessionId: currentSessionId.replace(`${agentId}:`, ""),
+            update: {
+              sessionUpdate: "session_info_update",
+              _meta: { fello: { update } }
+            }
+          });
+        }
+      }
+      return results;
+    }
+    return [];
+  }
+};
+
+// src/backend/acp-adapters/adapters.ts
+var codebuddyAdapter = new CodebuddyAdapter();
+var kiroAdapter = new KiroAdapter();
+var adapters = [codebuddyAdapter, kiroAdapter];
+var extNotificationSpecs = adapters.flatMap((a) => a.extNotificationSpecs);
+var agentEnv = Object.assign(
+  {},
+  ...adapters.map((a) => a.getAgentEnv())
+);
+
 // src/backend/agent/resolve-agent-info.ts
 function resolveAgentInfo(agentId) {
   const settings = storageOps.getSettings();
@@ -6200,10 +6829,59 @@ function createBridgeConnectModule(ctx, deps) {
     }
     sessionAgentMap.set(sessionKey, agentId);
     let currentSessionId = null;
+    function processSessionUpdate(notification) {
+      let results = [notification];
+      if (currentSessionId) {
+        for (const adapter of adapters) {
+          const next = [];
+          for (const n of results) {
+            const processed = adapter.preprocessNotification(n, currentSessionId, agentId);
+            if (processed !== null) {
+              next.push(...processed);
+            }
+          }
+          results = next;
+        }
+      }
+      if (results.length === 0) return;
+      if (!currentSessionId) return;
+      for (const result of results) {
+        const sessionUpdate = result.update?.sessionUpdate;
+        if (currentSessionId && currentSessionId === `${agentId}:${result.sessionId}`) {
+          if (sessionUpdate === "session_info_update") {
+            if (result.update.title) {
+              storage.updateSession(currentSessionId, { title: result.update.title });
+              const updated = storage.getSession(currentSessionId);
+              if (updated) sendEvent("session-changed", { session: updated });
+            }
+          }
+          if (sessionUpdate === "usage_update") {
+            publishUsage(currentSessionId, result.update);
+            continue;
+          }
+          if (sessionUpdate === "available_commands_update") {
+            publishAvailableCommands(currentSessionId, result.update.availableCommands ?? []);
+            continue;
+          }
+          if (sessionUpdate === "current_mode_update") {
+            const session = storage.getSession(currentSessionId);
+            if (session && session.modes) {
+              session.modes.currentModeId = result.update.currentModeId ?? null;
+              storage.updateSession(currentSessionId, { modes: session.modes });
+              const updated = storage.getSession(currentSessionId);
+              if (updated) sendEvent("session-changed", { session: updated });
+            }
+          }
+        }
+        broadcastAndSaveSessionUpdate(currentSessionId, result);
+      }
+    }
     const agentInfo = resolveAgentInfo(agentId);
     const bridge = new ACPBridge(agentId, {
       agentInfo,
       cwd,
+      extNotificationSpecs,
+      agentEnv,
       onSessionConnect: (connection) => {
         currentSessionId = `${agentId}:${connection.sessionId}`;
         storage.updateSession(currentSessionId, { connectionStatus: "connected" }, false);
@@ -6211,96 +6889,17 @@ function createBridgeConnectModule(ctx, deps) {
         if (updated) sendEvent("session-changed", { session: updated });
       },
       onSessionUpdate: (notification) => {
-        const sessionUpdate = notification.update?.sessionUpdate;
-        if (currentSessionId) {
-          if (currentSessionId === `${agentId}:${notification.sessionId}`) {
-            if (sessionUpdate === "session_info_update") {
-              if (notification.update.title) {
-                storage.updateSession(currentSessionId, { title: notification.update.title });
-                const updated = storage.getSession(currentSessionId);
-                if (updated) sendEvent("session-changed", { session: updated });
-              }
-            }
-            if (sessionUpdate === "usage_update") {
-              publishUsage(currentSessionId, notification.update);
-              return;
-            }
-            if (sessionUpdate === "available_commands_update") {
-              publishAvailableCommands(
-                currentSessionId,
-                notification.update.availableCommands ?? []
-              );
-              return;
-            }
-            if (sessionUpdate === "current_mode_update") {
-              const session = storage.getSession(currentSessionId);
-              if (session && session.modes) {
-                session.modes.currentModeId = notification.update.currentModeId ?? null;
-                storage.updateSession(currentSessionId, { modes: session.modes });
-                const updated = storage.getSession(currentSessionId);
-                if (updated) sendEvent("session-changed", { session: updated });
-              }
-            }
-          }
-          broadcastAndSaveSessionUpdate(currentSessionId, notification);
-        }
+        processSessionUpdate(notification);
       },
       onExtNotification: (method, params) => {
-        if (method === "_kiro.dev/metadata") {
-          if (typeof params === "object" && params && "sessionId" in params && typeof params.sessionId === "string" && "contextUsagePercentage" in params && typeof params.contextUsagePercentage === "number" && currentSessionId === `${agentId}:${params.sessionId}`) {
-            publishUsage(currentSessionId, {
-              used: params.contextUsagePercentage / 100,
-              size: 1
-            });
-          }
-          return;
-        }
-        if (method === "_kiro.dev/commands/available") {
-          if (typeof params === "object" && params && "sessionId" in params && typeof params.sessionId === "string" && "commands" in params && Array.isArray(params.commands) && currentSessionId === `${agentId}:${params.sessionId}`) {
-            const commands = [];
-            for (const item of params.commands) {
-              if (typeof item === "object" && item && "name" in item && typeof item.name === "string") {
-                commands.push({
-                  name: item.name.replace(/^\//, ""),
-                  description: item.description ? String(item.description) : ""
-                });
-              }
-            }
-            publishAvailableCommands(currentSessionId, commands);
-          }
-          return;
-        }
-        if (method === "_kiro.dev/subagent/list_update") {
-          if (typeof params === "object" && params && currentSessionId && "subagents" in params && Array.isArray(params.subagents)) {
-            for (const subagent of params.subagents) {
-              if (typeof subagent === "object" && subagent && "sessionId" in subagent && typeof subagent.sessionId === "string") {
-                const update = {
-                  sessionUpdate: "subagent_update",
-                  sessionId: subagent.sessionId,
-                  name: typeof subagent.sessionName === "string" ? subagent.sessionName : void 0,
-                  prompt: typeof subagent.initialQuery === "string" ? subagent.initialQuery : void 0,
-                  status: {
-                    pending: "pending",
-                    working: "in_progress",
-                    terminated: "completed",
-                    failed: "failed"
-                  }[String(subagent?.status?.type)]
-                };
-                broadcastAndSaveSessionUpdate(currentSessionId, {
-                  sessionId: currentSessionId.replace(`${agentId}:`, ""),
-                  update: {
-                    sessionUpdate: "session_info_update",
-                    _meta: {
-                      fello: {
-                        update
-                      }
-                    }
-                  }
-                });
-              }
+        for (const adapter of adapters) {
+          const results = adapter.handleExtNotification(method, params, currentSessionId, agentId);
+          if (results.length > 0) {
+            for (const result of results) {
+              processSessionUpdate(result);
             }
+            return;
           }
-          return;
         }
       },
       onPermissionRequest: async (request) => {
@@ -6357,6 +6956,13 @@ function createBridgeConnectModule(ctx, deps) {
           console.error("write terminal output error: ", { sessionId, terminalId, err });
         }
         sendEvent("agent-terminal-output", { sessionId, terminalId, data });
+      },
+      // On prompt completion, hand the full PromptResponse to each adapter so
+      // it can freeze its own turn-boundary (CodeBuddy extracts its protocol
+      // timestamp; other adapters are no-ops).
+      onPromptCompleted: (sessionId, res) => {
+        const key = `${agentId}:${sessionId}`;
+        for (const a of adapters) a.handlePromptCompleted(key, res);
       }
     });
     let newConnectPromise;
@@ -6382,12 +6988,14 @@ function createBridgeConnectModule(ctx, deps) {
       sessionAgentMap.delete(oldKey);
       sessionAgentMap.set(newKey, agentId);
     }
+    for (const a of adapters) a.rekey(oldKey, newKey);
   }
   async function killBridge(sessionKey) {
     const p = bridges.get(sessionKey);
     if (p) {
       bridges.delete(sessionKey);
       sessionAgentMap.delete(sessionKey);
+      for (const a of adapters) a.cleanup(sessionKey);
       try {
         const b = await p;
         await b.kill();
@@ -6417,6 +7025,7 @@ function createBridgeConnectModule(ctx, deps) {
     }
     bridges.clear();
     sessionAgentMap.clear();
+    for (const a of adapters) a.clearAll();
     await Promise.all(killPromises);
   }
   return {
@@ -6677,10 +7286,109 @@ import {
   copyFile
 } from "fs/promises";
 import * as mimeTypes4 from "mime-types";
-import { dirname as dirname6, join as join17, relative as relative7, extname as extname2, basename as basename3 } from "path";
+import { dirname as dirname7, join as join17, relative as relative9, extname as extname2, basename as basename3 } from "path";
+
+// src/backend/project/git-utils.ts
+import { execFile, spawn as spawn3 } from "child_process";
+import { dirname as dirname6, relative as relative8 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function getGitIgnoredPaths(cwd, relPaths) {
+  if (relPaths.length === 0) return /* @__PURE__ */ new Set();
+  return new Promise((resolve9) => {
+    const child = spawn3("git", ["check-ignore", "-z", "--stdin"], {
+      cwd,
+      timeout: 3e3,
+      // spawn defaults windowsHide to false; without this, every readDir
+      // would flash a console window on Windows.
+      windowsHide: true
+    });
+    const chunks = [];
+    child.stdout.on("data", (chunk) => chunks.push(chunk));
+    child.on("error", () => resolve9(/* @__PURE__ */ new Set()));
+    child.on("close", () => {
+      const ignored = /* @__PURE__ */ new Set();
+      for (const p of Buffer.concat(chunks).toString("utf8").split("\0")) {
+        if (p) ignored.add(toPosixPath(p));
+      }
+      resolve9(ignored);
+    });
+    try {
+      child.stdin.write(relPaths.join("\0") + "\0");
+      child.stdin.end();
+    } catch {
+      resolve9(/* @__PURE__ */ new Set());
+    }
+  });
+}
+async function getGitStatus(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["status", "--porcelain", "-b", "-z"], {
+      cwd,
+      timeout: 2e3,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    const lines = stdout.split("\0").filter(Boolean);
+    if (lines.length === 0) return null;
+    let branchLine = lines[0];
+    let branch = "";
+    if (branchLine.startsWith("## ")) {
+      branchLine = branchLine.slice(3);
+      if (branchLine.startsWith("No commits yet on "))
+        branch = branchLine.slice("No commits yet on ".length);
+      else if (branchLine.startsWith("HEAD (no branch)")) branch = "HEAD";
+      else branch = branchLine.split("...")[0];
+    }
+    const files = {};
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i];
+      const status = line.slice(0, 2);
+      if (line.length < 4) continue;
+      let path2 = line.slice(3);
+      if ((status.includes("R") || status.includes("C")) && i + 1 < lines.length) {
+        path2 = lines[i + 1];
+        i++;
+      }
+      files[toPosixPath(path2)] = status;
+    }
+    return { branch, files };
+  } catch {
+    return null;
+  }
+}
+async function readGitHeadFile(targetPath, encoding) {
+  try {
+    const cwd = dirname6(targetPath);
+    const relPath = relative8(cwd, targetPath);
+    const { stdout } = await execFileAsync("git", ["show", `HEAD:./${relPath}`], {
+      cwd,
+      maxBuffer: 10 * 1024 * 1024,
+      encoding: encoding ?? "utf8"
+    });
+    return stdout;
+  } catch {
+    return "";
+  }
+}
+
+// src/backend/project/filesystem.ts
 var SEARCH_MAX_RESULTS = 10;
 var SEARCH_FUSE_THRESHOLD = 0.4;
 var SEARCH_CACHE_TTL_MS = 6e4;
+var IGNORE_NAME_SET = /* @__PURE__ */ new Set([".git", ".svn", ".hg"]);
+var SEARCH_IGNORE_NAME_SET = /* @__PURE__ */ new Set(["node_modules", "vendor", "__pycache__"]);
+function hasForbiddenSegment(fullPath, cwd, ...nameSets) {
+  if (fullPath === cwd) return false;
+  const relPath = relative9(cwd, fullPath);
+  if (!relPath) return false;
+  const segments = relPath.split(/[\\/]+/);
+  for (let i = 0; i < segments.length; i++) {
+    const name = segments[i];
+    if (!name || name === ".") continue;
+    if (nameSets.some((set) => set.has(name))) return true;
+  }
+  return false;
+}
 function createFilesystemState(ctx) {
   const { storage } = ctx;
   const projectFsVersions = /* @__PURE__ */ new Map();
@@ -6713,9 +7421,9 @@ function createFilesystemState(ctx) {
         const full = join17(dir, name);
         const s = await stat4(full).catch(() => null);
         if (!s) continue;
-        if (isIgnorePath(full, cwd)) continue;
+        if (hasForbiddenSegment(full, cwd, IGNORE_NAME_SET, SEARCH_IGNORE_NAME_SET)) continue;
         if (fileScene.has(full)) continue;
-        const rel = relative7(cwd, full);
+        const rel = relative9(cwd, full);
         const posixRel = toPosixPath(rel);
         allFiles.push({ id: posixRel, filename: rel, isFolder: s.isDirectory() });
         if (s.isDirectory()) await collect(full);
@@ -6727,12 +7435,12 @@ function createFilesystemState(ctx) {
   async function getSystemFilePath({
     projectId,
     path: inputPath,
-    isAbsolute: isAbsolute6
+    isAbsolute: isAbsolute8
   }) {
     const project = storage.getProject(projectId);
     if (!project) throw new Error("Project not found");
-    if (isAbsolute6) return resolveSafePath(project.cwd, inputPath);
-    return relative7(project.cwd, resolveSafePath(project.cwd, inputPath));
+    if (isAbsolute8) return resolveSafePath(project.cwd, inputPath);
+    return relative9(project.cwd, resolveSafePath(project.cwd, inputPath));
   }
   async function copyFileToWorkspace({
     projectId,
@@ -6755,7 +7463,7 @@ function createFilesystemState(ctx) {
     }
     await copyFile(sourcePath, destPath);
     markProjectFsDirty(projectId);
-    return { success: true, destPath: toPosixPath(relative7(cwd, destPath)) };
+    return { success: true, destPath: toPosixPath(relative9(cwd, destPath)) };
   }
   async function readUrlAsDataUrl({ url: inputUrl, mimeType }) {
     const MAX_FILE_SIZE = 20 * 1024 * 1024;
@@ -6805,12 +7513,12 @@ function createFilesystemState(ctx) {
       const results = [];
       for (const name of entries) {
         const full = join17(cwd, name);
-        if (isIgnorePath(full, cwd)) continue;
+        if (hasForbiddenSegment(full, cwd, IGNORE_NAME_SET, SEARCH_IGNORE_NAME_SET)) continue;
         if (fileScene.has(full)) continue;
         fileScene.add(full);
         const s = await stat4(full).catch(() => null);
         if (!s) continue;
-        const rel = relative7(cwd, full);
+        const rel = relative9(cwd, full);
         results.push({ id: toPosixPath(rel), filename: rel, isFolder: s.isDirectory() });
         if (results.length >= SEARCH_MAX_RESULTS) break;
       }
@@ -6849,14 +7557,23 @@ function createFilesystemState(ctx) {
       const full = join17(startPath, name);
       const s = await stat4(full).catch(() => null);
       if (!s) continue;
-      if (isIgnorePath(full, cwd)) continue;
-      const relId = toPosixPath(relative7(cwd, full));
-      results.push({ id: relId, name, isFolder: s.isDirectory() });
+      if (hasForbiddenSegment(full, cwd, IGNORE_NAME_SET)) continue;
+      const relId = toPosixPath(relative9(cwd, full));
+      results.push({ id: relId, name, isFolder: s.isDirectory(), ignored: false });
     }
     results.sort((a, b) => {
       if (a.isFolder !== b.isFolder) return a.isFolder ? -1 : 1;
       return a.name.localeCompare(b.name);
     });
+    const ignoredPaths = await getGitIgnoredPaths(
+      cwd,
+      results.map((r) => r.id)
+    );
+    if (ignoredPaths.size > 0) {
+      for (const r of results) {
+        if (ignoredPaths.has(r.id)) r.ignored = true;
+      }
+    }
     return results;
   }
   async function createFile({
@@ -6870,7 +7587,7 @@ function createFilesystemState(ctx) {
     if (isFolder) {
       await mkdir(targetPath, { recursive: true });
     } else {
-      await mkdir(dirname6(targetPath), { recursive: true });
+      await mkdir(dirname7(targetPath), { recursive: true });
       await writeFile3(targetPath, "");
     }
     markProjectFsDirty(projectId);
@@ -6977,6 +7694,22 @@ function createFilesystemState(ctx) {
     await writeFile3(currentDest, buffer);
     markProjectFsDirty(projectId);
   }
+  async function getGitStatus2({ projectId, cwd }) {
+    const project = storage.getProject(projectId);
+    if (!project) return null;
+    const targetCwd = cwd ? resolveSafePath(project.cwd, cwd) : project.cwd;
+    return getGitStatus(targetCwd);
+  }
+  async function readGitHeadFile2({
+    projectId,
+    relativePath,
+    encoding
+  }) {
+    const project = storage.getProject(projectId);
+    if (!project) return "";
+    const targetPath = resolveSafePath(project.cwd, relativePath);
+    return readGitHeadFile(targetPath, encoding);
+  }
   async function getPlatform() {
     return process.platform;
   }
@@ -6996,83 +7729,16 @@ function createFilesystemState(ctx) {
     readFile: readFile11,
     getFileInfo,
     writeExternalFile,
+    getGitStatus: getGitStatus2,
+    readGitHeadFile: readGitHeadFile2,
     getPlatform
   };
 }
 
-// src/backend/project/git.ts
-import { execFile } from "child_process";
-import { dirname as dirname7, relative as relative8 } from "path";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-function createGitHandlers(ctx) {
-  const { storage } = ctx;
-  async function getGitStatus({ projectId, cwd }) {
-    try {
-      const project = storage.getProject(projectId);
-      if (!project) throw new Error("Project not found");
-      const targetCwd = cwd ? resolveSafePath(project.cwd, cwd) : project.cwd;
-      const { stdout } = await execFileAsync("git", ["status", "--porcelain", "-b", "-z"], {
-        cwd: targetCwd,
-        timeout: 2e3
-      });
-      const lines = stdout.split("\0").filter(Boolean);
-      if (lines.length === 0) return null;
-      let branchLine = lines[0];
-      let branch = "";
-      if (branchLine.startsWith("## ")) {
-        branchLine = branchLine.slice(3);
-        if (branchLine.startsWith("No commits yet on "))
-          branch = branchLine.slice("No commits yet on ".length);
-        else if (branchLine.startsWith("HEAD (no branch)")) branch = "HEAD";
-        else branch = branchLine.split("...")[0];
-      }
-      const files = {};
-      for (let i = 1; i < lines.length; i++) {
-        const line = lines[i];
-        const status = line.slice(0, 2);
-        if (line.length < 4) continue;
-        let path2 = line.slice(3);
-        if ((status.includes("R") || status.includes("C")) && i + 1 < lines.length) {
-          path2 = lines[i + 1];
-          i++;
-        }
-        files[toPosixPath(path2)] = status;
-      }
-      return { branch, files };
-    } catch {
-      return null;
-    }
-  }
-  async function readGitHeadFile({
-    projectId,
-    relativePath,
-    encoding
-  }) {
-    try {
-      const project = storage.getProject(projectId);
-      if (!project) throw new Error("Project not found");
-      const targetPath = resolveSafePath(project.cwd, relativePath);
-      const cwd = dirname7(targetPath);
-      const relPath = relative8(cwd, targetPath);
-      const { stdout } = await execFileAsync("git", ["show", `HEAD:./${relPath}`], {
-        cwd,
-        maxBuffer: 10 * 1024 * 1024,
-        encoding: encoding ?? "utf8"
-      });
-      return stdout;
-    } catch {
-      return "";
-    }
-  }
-  return { getGitStatus, readGitHeadFile };
-}
-
 // src/backend/project/index.ts
 function createProjectModule(ctx, deps) {
   const { sendEvent, onEvent, storage } = ctx;
   const fs2 = createFilesystemState(ctx);
-  const git = createGitHandlers(ctx);
   onEvent((channel, payload) => {
     if (channel === "fs-changed") {
       fs2.markProjectFsDirty(payload.projectId);
@@ -7108,8 +7774,7 @@ function createProjectModule(ctx, deps) {
     addProject: addProject2,
     renameProject,
     deleteProject: deleteProject2,
-    ...fs2,
-    ...git
+    ...fs2
   };
 }
 
@@ -7172,7 +7837,7 @@ async function startSocketServer(socketPath) {
     res.writeHead(404, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ error: "Not found" }));
   });
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     server.listen(socketPath, () => {
       const serverRef = {
         stop: () => {
@@ -7192,7 +7857,7 @@ async function startSocketServer(socketPath) {
         },
         socketPath
       };
-      resolve8(serverRef);
+      resolve9(serverRef);
     });
     server.on("error", (err) => {
       console.error("[socket-server] Failed to start:", err);
@@ -8261,7 +8926,7 @@ function createSessionModule(ctx, deps) {
     askUser,
     shareToUser,
     skills,
-    search: search2,
+    search,
     memory,
     imageGeneration,
     toolbox,
@@ -8271,7 +8936,7 @@ function createSessionModule(ctx, deps) {
     skills,
     askUser,
     shareToUser,
-    search: search2,
+    search,
     memory,
     imageGeneration,
     toolbox
@@ -8289,7 +8954,7 @@ function createSessionModule(ctx, deps) {
     const server = await startSocketServer(options.socketPath);
     toolbox.registerToolboxRoute(server, options.project.cwd);
     skills.registerSkillsRoute(server, options.project.cwd);
-    search2.registerSearchRoute(server, options.project.cwd);
+    search.registerSearchRoute(server, options.project.cwd);
     imageGeneration.registerImageGenerationRoute(server, sessionId);
     memory.registerMemoryRoute(server, options.project.id, sessionId);
     askUser.registerAskUserRoute(server, sessionId);
@@ -8455,6 +9120,33 @@ function createSessionModule(ctx, deps) {
         shouldUpdateCache = true;
       } else finalThoughtLevels = session.thoughtLevels;
     }
+    const restorePushback = [];
+    if (finalModels && session.models?.currentModelId && finalModels.currentModelId !== session.models.currentModelId && finalModels.availableModels.some((m) => m.modelId === session.models.currentModelId)) {
+      const cachedModelId = session.models.currentModelId;
+      finalModels = { ...finalModels, currentModelId: cachedModelId };
+      restorePushback.push(
+        b.setSessionModel({ sessionId: session.resumeId, modelId: cachedModelId }).catch((err) => console.warn("[loadSession] Failed to restore model selection:", err))
+      );
+    }
+    if (finalModes && session.modes?.currentModeId && finalModes.currentModeId !== session.modes.currentModeId && finalModes.availableModes.some((m) => m.id === session.modes.currentModeId)) {
+      const cachedModeId = session.modes.currentModeId;
+      finalModes = { ...finalModes, currentModeId: cachedModeId };
+      restorePushback.push(
+        b.setSessionMode({ sessionId: session.resumeId, modeId: cachedModeId }).catch((err) => console.warn("[loadSession] Failed to restore mode selection:", err))
+      );
+    }
+    if (finalThoughtLevels && session.thoughtLevels?.currentThoughtLevelId && finalThoughtLevels.currentThoughtLevelId !== session.thoughtLevels.currentThoughtLevelId && finalThoughtLevels.availableThoughtLevels.some(
+      (m) => m.id === session.thoughtLevels.currentThoughtLevelId
+    )) {
+      const cachedId = session.thoughtLevels.currentThoughtLevelId;
+      finalThoughtLevels = { ...finalThoughtLevels, currentThoughtLevelId: cachedId };
+      restorePushback.push(
+        b.setThoughtLevel({ sessionId: session.resumeId, thoughtLevelId: cachedId }).catch((err) => console.warn("[loadSession] Failed to restore thought level:", err))
+      );
+    }
+    if (restorePushback.length > 0) {
+      await Promise.all(restorePushback);
+    }
     if (shouldUpdateCache || b.initializeInfo) {
       storage.updateSession(
         session.id,
@@ -8521,7 +9213,7 @@ function createSessionModule(ctx, deps) {
             `[SendPrompt] Killed ${killed} agent terminal(s) from previous generation for session ${sessionId}`
           );
       }
-      await new Promise((resolve8) => setTimeout(resolve8, 30));
+      await new Promise((resolve9) => setTimeout(resolve9, 30));
     }
     if (!session.title) {
       const firstTextContent = contents.find((c) => c.type === "text");
@@ -8541,15 +9233,20 @@ function createSessionModule(ctx, deps) {
         ctx,
         mcpDeps
       );
-      await b.loadSession({
-        sessionId: session.resumeId,
-        cwd: session.cwd,
-        mcpServers: activeMcpServers
-      });
-      await createSessionSocketServer(session.id, {
-        socketPath,
-        project
-      });
+      notif.addRestoring(session.id);
+      try {
+        await b.loadSession({
+          sessionId: session.resumeId,
+          cwd: session.cwd,
+          mcpServers: activeMcpServers
+        });
+        await createSessionSocketServer(session.id, {
+          socketPath,
+          project
+        });
+      } finally {
+        notif.removeRestoring(session.id);
+      }
     }
     storage.updateSession(sessionId, { isStreaming: true });
     const updated = storage.getSession(sessionId);
@@ -9389,22 +10086,54 @@ function createInferenceModule(_ctx, deps) {
     const textChunks = [];
     const terminalLogs = {};
     const agentInfo = resolveAgentInfo(agentId);
+    let currentSessionId = null;
+    function processNotification(notification) {
+      let results = [notification];
+      if (currentSessionId) {
+        for (const adapter of adapters) {
+          const next = [];
+          for (const n of results) {
+            const processed = adapter.preprocessNotification(n, currentSessionId, agentId);
+            if (processed !== null) {
+              next.push(...processed);
+            }
+          }
+          results = next;
+        }
+      }
+      if (results.length === 0) return;
+      for (const result of results) {
+        notifications.push(result);
+        if (result.update?.sessionUpdate === "agent_message_chunk") {
+          const content = result.update.content;
+          if (content?.type === "text" && content.text) {
+            textChunks.push(content.text);
+          }
+        }
+      }
+    }
     const bridge = new ACPBridge(agentId, {
       agentInfo,
       cwd,
-      onSessionConnect: () => {
+      extNotificationSpecs,
+      agentEnv,
+      onSessionConnect: (connection) => {
+        currentSessionId = `${agentId}:${connection.sessionId}`;
       },
       onSessionUpdate: (notification) => {
-        notifications.push(notification);
-        if (notification.update?.sessionUpdate === "agent_message_chunk") {
-          const content = notification.update.content;
-          if (content?.type === "text" && content.text) {
-            textChunks.push(content.text);
+        processNotification(notification);
+      },
+      onExtNotification: (method, params) => {
+        for (const adapter of adapters) {
+          const results = adapter.handleExtNotification(method, params, currentSessionId, agentId);
+          if (results.length > 0) {
+            for (const result of results) {
+              processNotification(result);
+            }
+            return;
           }
         }
       },
-      onExtNotification: () => {
-      },
       onPermissionRequest: async (request) => {
         const opt = request.options.find((o) => o.kind === "allow_always") ?? request.options.find((o) => o.kind === "allow_once") ?? request.options[0];
         return { outcome: { outcome: "selected", optionId: opt?.optionId ?? "allow" } };
@@ -10143,7 +10872,15 @@ function createMemoryModule(_ctx, deps) {
     if (file.entries.length === 0 && !existsSync8(getMemoryPath(projectId))) {
       return null;
     }
-    return file;
+    return { version: file.version, entries: getMemoEntries(file.entries) };
+  }
+  function deleteMemoryEntry(projectId, entryId) {
+    const file = readMemoryFile(projectId);
+    const index = file.entries.findIndex((entry) => getMemoryEntryId(entry.text) === entryId);
+    if (index === -1) return false;
+    file.entries.splice(index, 1);
+    writeMemoryFile(projectId, file);
+    return true;
   }
   function clearMemory(projectId) {
     const memoryPath = getMemoryPath(projectId);
@@ -10159,6 +10896,7 @@ function createMemoryModule(_ctx, deps) {
     registerMemoryRoute,
     buildMemoryMcpServer,
     getMemory,
+    deleteMemoryEntry,
     clearMemory,
     getFilePath
   };
@@ -10348,7 +11086,7 @@ function createImageGenerationModule(ctx, deps) {
 }
 
 // src/backend/toolbox.ts
-import { join as join23, resolve as resolve7, dirname as dirname9, basename as basename4, extname as extname3 } from "path";
+import { join as join23, resolve as resolve8, dirname as dirname9, basename as basename4, extname as extname3 } from "path";
 import { writeFile as writeFile6 } from "fs/promises";
 import { createHash as createHash6, randomUUID as randomUUID13, randomInt } from "crypto";
 import * as qr from "qr-image";
@@ -10595,15 +11333,15 @@ function createToolboxModule(_ctx) {
     });
     server.registry("toolbox/image-metadata", async (payload) => {
       const { path: imgPath } = imageMetadataRequestSchema.parse(payload);
-      const absPath = resolve7(projectDir, imgPath);
+      const absPath = resolve8(projectDir, imgPath);
       const sharp = await getSharp();
       const metadata = await sharp(absPath).metadata();
       return { result: extractMetadata(metadata) };
     });
     server.registry("toolbox/image-thumbnail", async (payload) => {
       const { path: imgPath, width, output } = imageThumbnailRequestSchema.parse(payload);
-      const absPath = resolve7(projectDir, imgPath);
-      const outputPath = output ? resolve7(projectDir, output) : join23(
+      const absPath = resolve8(projectDir, imgPath);
+      const outputPath = output ? resolve8(projectDir, output) : join23(
         dirname9(absPath),
         `${basename4(absPath, extname3(absPath))}.thumb${width}${extname3(absPath)}`
       );
@@ -10614,7 +11352,7 @@ function createToolboxModule(_ctx) {
     });
     server.registry("toolbox/image-resize", async (payload) => {
       const { path: imgPath, width, height, fit, output } = imageResizeRequestSchema.parse(payload);
-      const absPath = resolve7(projectDir, imgPath);
+      const absPath = resolve8(projectDir, imgPath);
       const sharp = await getSharp();
       const resized = await sharp(absPath).resize({ width, height, fit }).toBuffer();
       const resizedMeta = await sharp(resized).metadata();
@@ -10622,15 +11360,15 @@ function createToolboxModule(_ctx) {
       const actualHeight = resizedMeta.height ?? height ?? 0;
       const ext = extname3(absPath);
       const base = basename4(absPath, ext);
-      const outputPath = output ? resolve7(projectDir, output) : join23(dirname9(absPath), `${base}.${actualWidth}x${actualHeight}${ext}`);
+      const outputPath = output ? resolve8(projectDir, output) : join23(dirname9(absPath), `${base}.${actualWidth}x${actualHeight}${ext}`);
       await writeFile6(outputPath, resized);
       const metadata = await sharp(outputPath).metadata();
       return { result: { output: outputPath, metadata: extractMetadata(metadata) } };
     });
     server.registry("toolbox/image-convert", async (payload) => {
       const { path: imgPath, format, quality, output } = imageConvertRequestSchema.parse(payload);
-      const absPath = resolve7(projectDir, imgPath);
-      const outputPath = output ? resolve7(projectDir, output) : join23(dirname9(absPath), `${basename4(absPath, extname3(absPath))}.${format}`);
+      const absPath = resolve8(projectDir, imgPath);
+      const outputPath = output ? resolve8(projectDir, output) : join23(dirname9(absPath), `${basename4(absPath, extname3(absPath))}.${format}`);
       const sharp = await getSharp();
       let pipeline = sharp(absPath);
       const opts = {};
@@ -10642,7 +11380,7 @@ function createToolboxModule(_ctx) {
     });
     server.registry("toolbox/image-qrcode", async (payload) => {
       const { text, output, size, margin, errorCorrection } = qrCodeRequestSchema.parse(payload);
-      const outputPath = resolve7(projectDir, output ?? "qrcode.png");
+      const outputPath = resolve8(projectDir, output ?? "qrcode.png");
       const png = qr.imageSync(text, {
         type: "png",
         size,
@@ -10691,11 +11429,11 @@ function initBackend(emitter) {
   const askUser = createAskUserModule(ctx, { ilink: ilink.state });
   const shareToUser = createShareToUserModule(ctx, { ilink: ilink.state });
   const skills = createSkillsModule(ctx);
-  const search2 = createSearchModule(ctx);
+  const search = createSearchModule(ctx);
   const watcher2 = createWatcherModule(ctx);
   const toolbox = createToolboxModule(ctx);
   const bridgeConnect = createBridgeConnectModule(ctx, { askUser });
-  const _inference = createInferenceModule(ctx, { skills, search: search2, toolbox });
+  const _inference = createInferenceModule(ctx, { skills, search, toolbox });
   const memory = createMemoryModule(ctx, { inference: _inference });
   const imageGeneration = createImageGenerationModule(ctx, { ilink: ilink.state });
   const session = createSessionModule(ctx, {
@@ -10703,7 +11441,7 @@ function initBackend(emitter) {
     askUser,
     shareToUser,
     skills,
-    search: search2,
+    search,
     memory,
     imageGeneration,
     toolbox,
@@ -11071,6 +11809,9 @@ function initBackend(emitter) {
     async getMemory({ projectId }) {
       return memory.getMemory(projectId);
     },
+    async deleteMemoryEntry({ projectId, entryId }) {
+      return memory.deleteMemoryEntry(projectId, entryId);
+    },
     async clearMemory({ projectId }) {
       memory.clearMemory(projectId);
     },
@@ -11085,7 +11826,7 @@ function initBackend(emitter) {
     await ilink.stopIlink({ logout: false });
     session.clearSession();
     await bridgeConnect.clearAll();
-    await new Promise((resolve8) => setTimeout(resolve8, 100));
+    await new Promise((resolve9) => setTimeout(resolve9, 100));
     terminal.killAllTerminals();
     await watcher2.stopAll();
     for (const file of await readdir2(TEMP_DIR)) {
@@ -11096,7 +11837,7 @@ function initBackend(emitter) {
 }
 
 // package.json
-var version = "0.1.46";
+var version = "0.1.49";
 
 // src/server/main.ts
 var port;
@@ -11125,6 +11866,14 @@ Options:
     process.exit(0);
   }
 }
+var proxySettings = storageOps.getSettings().proxy;
+if (proxySettings.mode === "system") {
+  const detected = detectSystemProxy();
+  applyProxy(detected);
+  console.log(`[proxy] system proxy: ${detected.httpProxy || detected.httpsProxy || "none"}`);
+} else {
+  applyProxy(settingProxyInfoToProxyConfig(proxySettings));
+}
 var { backendHandlers, closeBackend } = initBackend(() => false);
 backendHandlers.startWebUIServer({ port, token }).then(({ url }) => {
   const title = `Fello Server v${version}`;