@zythum02/fello-server 0.1.46 → 0.1.48

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 || "");
@@ -2948,7 +2969,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();
@@ -4041,6 +4066,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, "");
 }
@@ -4090,7 +4317,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",
@@ -4754,7 +4984,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 +4992,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 +5737,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
     });
@@ -5816,7 +6045,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 +6088,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,
@@ -6139,6 +6355,327 @@ 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 [];
+  }
+  // ── 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 max _meta.timestamp for content chunks
+   * (agent_message_chunk / agent_thought_chunk). Used to detect
+   * replayed chunks whose timestamp is earlier than the max seen
+   * for the same session. Only content chunks with
+   * codebuddy.ai/requestId participate — other notification types
+   * (tool_call, session_info_update, etc.) are not tracked.
+   */
+  sessionUpdateTimestamp = /* @__PURE__ */ new Map();
+  /**
+   * One unified hook for all notification processing:
+   *
+   * 1. Replay detection — drop agent_message_chunk / agent_thought_chunk
+   *    whose _meta.timestamp is earlier than the max seen for the same
+   *    session. CodeBuddy sometimes re-sends previous responses during
+   *    a new prompt; these replayed chunks carry original (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 maxTs = this.sessionUpdateTimestamp.get(currentSessionId);
+        if (maxTs !== void 0 && ts < maxTs) {
+          return null;
+        }
+        if (maxTs === void 0 || ts > maxTs) {
+          this.sessionUpdateTimestamp.set(currentSessionId, ts);
+        }
+      }
+    }
+    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);
+    }
+  }
+  cleanup(sessionKey) {
+    this.stateMap.delete(sessionKey);
+    this.sessionUpdateTimestamp.delete(sessionKey);
+  }
+  clearAll() {
+    this.stateMap.clear();
+    this.sessionUpdateTimestamp.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);
+
 // src/backend/agent/resolve-agent-info.ts
 function resolveAgentInfo(agentId) {
   const settings = storageOps.getSettings();
@@ -6200,10 +6737,58 @@ 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,
       onSessionConnect: (connection) => {
         currentSessionId = `${agentId}:${connection.sessionId}`;
         storage.updateSession(currentSessionId, { connectionStatus: "connected" }, false);
@@ -6211,96 +6796,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) => {
@@ -6382,12 +6888,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 +6925,7 @@ function createBridgeConnectModule(ctx, deps) {
     }
     bridges.clear();
     sessionAgentMap.clear();
+    for (const a of adapters) a.clearAll();
     await Promise.all(killPromises);
   }
   return {
@@ -6677,10 +7186,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 relative8, 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 relative7 } 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((resolve8) => {
+    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", () => resolve8(/* @__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));
+      }
+      resolve8(ignored);
+    });
+    try {
+      child.stdin.write(relPaths.join("\0") + "\0");
+      child.stdin.end();
+    } catch {
+      resolve8(/* @__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 = relative7(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 = relative8(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 +7321,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 = relative8(cwd, full);
         const posixRel = toPosixPath(rel);
         allFiles.push({ id: posixRel, filename: rel, isFolder: s.isDirectory() });
         if (s.isDirectory()) await collect(full);
@@ -6732,7 +7340,7 @@ function createFilesystemState(ctx) {
     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));
+    return relative8(project.cwd, resolveSafePath(project.cwd, inputPath));
   }
   async function copyFileToWorkspace({
     projectId,
@@ -6755,7 +7363,7 @@ function createFilesystemState(ctx) {
     }
     await copyFile(sourcePath, destPath);
     markProjectFsDirty(projectId);
-    return { success: true, destPath: toPosixPath(relative7(cwd, destPath)) };
+    return { success: true, destPath: toPosixPath(relative8(cwd, destPath)) };
   }
   async function readUrlAsDataUrl({ url: inputUrl, mimeType }) {
     const MAX_FILE_SIZE = 20 * 1024 * 1024;
@@ -6805,12 +7413,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 = relative8(cwd, full);
         results.push({ id: toPosixPath(rel), filename: rel, isFolder: s.isDirectory() });
         if (results.length >= SEARCH_MAX_RESULTS) break;
       }
@@ -6849,14 +7457,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(relative8(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 +7487,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 +7594,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 +7629,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 +7674,7 @@ function createProjectModule(ctx, deps) {
     addProject: addProject2,
     renameProject,
     deleteProject: deleteProject2,
-    ...fs2,
-    ...git
+    ...fs2
   };
 }
 
@@ -8455,6 +9020,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,
@@ -8541,15 +9133,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 +9986,53 @@ 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,
+      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 +10771,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 +10795,7 @@ function createMemoryModule(_ctx, deps) {
     registerMemoryRoute,
     buildMemoryMcpServer,
     getMemory,
+    deleteMemoryEntry,
     clearMemory,
     getFilePath
   };
@@ -11071,6 +11708,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);
     },
@@ -11096,7 +11736,7 @@ function initBackend(emitter) {
 }
 
 // package.json
-var version = "0.1.46";
+var version = "0.1.48";
 
 // src/server/main.ts
 var port;
@@ -11125,6 +11765,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}`;