@zythum02/fello-server 0.1.39 → 0.1.42

package/out/server/main.js

@@ -11,44 +11,32 @@ process.treeSitterWasmPath = join(resourcesPath, "tree-sitter-wasm");
 
 // src/backend/backend.ts
 import { readdir as readdir2, rm as rm3, readFile as readFile9 } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join22 } from "path";
 
-// src/backend/storage.ts
-import { basename, join as join2 } from "path";
-import { homedir } from "os";
-import {
-  mkdirSync,
-  writeFileSync,
-  readFileSync,
-  readdirSync,
-  rmSync,
-  existsSync,
-  appendFileSync
-} from "fs";
-import { createHash } from "crypto";
+// src/backend/storage/index.ts
+import { join as join5 } from "path";
+import { mkdirSync as mkdirSync3, appendFileSync, existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 
-// src/shared/constants.ts
-var IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
-  "image/jpeg",
-  "image/png",
-  "image/gif",
-  "image/webp",
-  "image/svg+xml",
-  "image/bmp",
-  "image/avif"
-]);
-function isImageMimeType(mimeType) {
-  return !!mimeType && IMAGE_MIME_TYPES.has(mimeType);
-}
-var ALL_FEATURES = ["search", "skills", "ask_user", "share_to_user"];
+// src/backend/storage/prepare.ts
+import { mkdirSync } from "fs";
 
-// src/backend/storage.ts
+// src/backend/storage/constant.ts
+import { join as join2 } from "path";
+import { homedir } from "os";
 var FELLO_DIR = join2(homedir(), ".fello");
 var SOCKETS_DIR = join2(FELLO_DIR, "sockets");
 var PROJECTS_DIR = join2(FELLO_DIR, "projects");
 var TEMP_DIR = join2(FELLO_DIR, "temp");
-var WORKSPACES_DIR = join2(FELLO_DIR, "workspaces");
-var WORKSPACE_TEMP_DIR = join2(WORKSPACES_DIR, "__temp__");
+
+// src/backend/storage/prepare.ts
+mkdirSync(FELLO_DIR, { recursive: true });
+mkdirSync(PROJECTS_DIR, { recursive: true });
+mkdirSync(SOCKETS_DIR, { recursive: true });
+mkdirSync(TEMP_DIR, { recursive: true });
+
+// src/backend/storage/settings.ts
+import { join as join3 } from "path";
+import { writeFileSync, readFileSync, existsSync } from "fs";
 var DEFAULT_SETTINGS = {
   agents: {},
   theme: { theme_mode: "system" },
@@ -71,14 +59,8 @@ var DEFAULT_SETTINGS = {
     theme: "soft"
   }
 };
-mkdirSync(PROJECTS_DIR, { recursive: true });
-mkdirSync(SOCKETS_DIR, { recursive: true });
-mkdirSync(TEMP_DIR, { recursive: true });
-mkdirSync(WORKSPACES_DIR, { recursive: true });
-mkdirSync(WORKSPACE_TEMP_DIR, { recursive: true });
-var streamingSessions = /* @__PURE__ */ new Set();
 function settingsPath() {
-  return join2(FELLO_DIR, "settings.json");
+  return join3(FELLO_DIR, "settings.json");
 }
 function readSettings() {
   try {
@@ -222,579 +204,600 @@ function readSettings() {
 function writeSettings(meta) {
   writeFileSync(settingsPath(), JSON.stringify(meta, null, 2));
 }
-function hashCwd(cwd) {
-  return createHash("sha1").update(cwd.trim()).digest("hex");
-}
-function projectDir(projectId) {
-  return join2(PROJECTS_DIR, projectId);
+function getSettings() {
+  const meta = readSettings();
+  return {
+    agents: Object.entries(meta.agents).map(([id, agentMeta]) => {
+      if (agentMeta.type === "stdio") {
+        return {
+          id,
+          type: agentMeta.type,
+          command: agentMeta.command,
+          args: agentMeta.args.slice(),
+          env: Object.assign({}, agentMeta.env),
+          disabled: agentMeta.disabled
+        };
+      }
+      if (agentMeta.type === "api") {
+        return {
+          id,
+          type: agentMeta.type,
+          provider: agentMeta.provider,
+          baseUrl: agentMeta.baseUrl,
+          apiKey: agentMeta.apiKey,
+          headers: Object.assign({}, agentMeta.headers),
+          disabled: agentMeta.disabled,
+          contextWindowTokens: agentMeta.contextWindowTokens,
+          modelIdTemplate: agentMeta.modelIdTemplate
+        };
+      }
+      throw new Error("Invalid agent type.");
+    }).sort((a, b) => meta.agents[a.id].order - meta.agents[b.id].order),
+    mcpServers: Object.entries(meta.mcpServers).map(([id, srvMeta]) => {
+      if (srvMeta.type === "stdio") {
+        return {
+          id,
+          type: srvMeta.type,
+          command: srvMeta.command,
+          args: srvMeta.args.slice(),
+          env: Object.assign({}, srvMeta.env),
+          disabled: srvMeta.disabled
+        };
+      }
+      if (srvMeta.type === "http") {
+        return {
+          id,
+          type: srvMeta.type,
+          url: srvMeta.url,
+          headers: Object.assign({}, srvMeta.headers),
+          disabled: srvMeta.disabled
+        };
+      }
+      if (srvMeta.type === "sse") {
+        return {
+          id,
+          type: srvMeta.type,
+          url: srvMeta.url,
+          headers: Object.assign({}, srvMeta.headers),
+          disabled: srvMeta.disabled
+        };
+      }
+      throw new Error(`Invalid mcpServer type ${srvMeta.type}.`);
+    }).sort((a, b) => meta.mcpServers[a.id].order - meta.mcpServers[b.id].order),
+    i18n: {
+      language: meta.i18n.language
+    },
+    theme: {
+      themeMode: meta.theme.theme_mode
+    },
+    fileWatcher: {
+      enabled: meta.fileWatcher.enabled
+    },
+    ilink: {
+      useOriginalImage: meta.ilink.useOriginalImage
+    },
+    editor: {
+      name: meta.editor.name
+    },
+    sound: {
+      volume: meta.sound.volume,
+      muted: meta.sound.muted,
+      theme: meta.sound.theme
+    },
+    snippets: meta.snippets ?? []
+  };
 }
-function projectMetaPath(projectId) {
-  return join2(projectDir(projectId), "project.json");
+function updateSettings(settings) {
+  const prevMeta = readSettings();
+  const meta = {
+    agents: (() => {
+      if (!settings.agents) {
+        return prevMeta.agents;
+      }
+      const nextAgents = {};
+      settings.agents.forEach((agent2, idx) => {
+        if (agent2.type === "stdio") {
+          nextAgents[agent2.id] = {
+            type: agent2.type,
+            command: agent2.command,
+            args: agent2.args.slice(),
+            env: Object.assign({}, agent2.env),
+            disabled: agent2.disabled,
+            order: idx
+          };
+        } else if (agent2.type === "api") {
+          nextAgents[agent2.id] = {
+            type: agent2.type,
+            provider: agent2.provider,
+            baseUrl: agent2.baseUrl,
+            apiKey: agent2.apiKey,
+            headers: Object.assign({}, agent2.headers || {}),
+            disabled: agent2.disabled,
+            order: idx,
+            contextWindowTokens: agent2.contextWindowTokens !== void 0 ? Number.isInteger(agent2.contextWindowTokens) && agent2.contextWindowTokens > 0 ? agent2.contextWindowTokens : void 0 : void 0,
+            modelIdTemplate: typeof agent2.modelIdTemplate === "string" && agent2.modelIdTemplate.trim() ? agent2.modelIdTemplate.trim() : void 0
+          };
+        } else {
+          throw new Error("Invalid agent type.");
+        }
+      });
+      return nextAgents;
+    })(),
+    i18n: (() => {
+      if (!settings.i18n) {
+        return prevMeta.i18n;
+      }
+      return {
+        language: settings.i18n.language
+      };
+    })(),
+    theme: (() => {
+      if (!settings.theme) {
+        return prevMeta.theme;
+      }
+      return {
+        theme_mode: settings.theme.themeMode
+      };
+    })(),
+    mcpServers: (() => {
+      if (!settings.mcpServers) {
+        return prevMeta.mcpServers;
+      }
+      const nextMcpServers = {};
+      settings.mcpServers.forEach((srv, idx) => {
+        if (srv.type === "stdio") {
+          nextMcpServers[srv.id] = {
+            type: srv.type,
+            command: srv.command,
+            args: srv.args.slice(),
+            env: Object.assign({}, srv.env),
+            disabled: srv.disabled,
+            order: idx
+          };
+        } else if (srv.type === "http") {
+          nextMcpServers[srv.id] = {
+            type: srv.type,
+            url: srv.url,
+            headers: Object.assign({}, srv.headers),
+            disabled: srv.disabled,
+            order: idx
+          };
+        } else if (srv.type === "sse") {
+          nextMcpServers[srv.id] = {
+            type: srv.type,
+            url: srv.url,
+            headers: Object.assign({}, srv.headers),
+            disabled: srv.disabled,
+            order: idx
+          };
+        }
+      });
+      return nextMcpServers;
+    })(),
+    fileWatcher: (() => {
+      if (!settings.fileWatcher) {
+        return prevMeta.fileWatcher;
+      }
+      return {
+        enabled: settings.fileWatcher.enabled
+      };
+    })(),
+    ilink: (() => {
+      if (!settings.ilink) {
+        return prevMeta.ilink;
+      }
+      return {
+        useOriginalImage: settings.ilink.useOriginalImage
+      };
+    })(),
+    editor: (() => {
+      if (!settings.editor) {
+        return prevMeta.editor;
+      }
+      return {
+        name: settings.editor.name
+      };
+    })(),
+    sound: (() => {
+      if (!settings.sound) {
+        return prevMeta.sound;
+      }
+      return {
+        volume: typeof settings.sound.volume === "number" && settings.sound.volume >= 0 && settings.sound.volume <= 100 ? settings.sound.volume : prevMeta.sound.volume,
+        muted: typeof settings.sound.muted === "boolean" ? settings.sound.muted : prevMeta.sound.muted,
+        theme: settings.sound.theme === "soft" || settings.sound.theme === "crisp" ? settings.sound.theme : prevMeta.sound.theme
+      };
+    })(),
+    snippets: settings.snippets ?? prevMeta.snippets
+  };
+  writeSettings(meta);
 }
-function projectSessionsDir(projectId) {
-  return join2(projectDir(projectId), "sessions");
+
+// src/backend/storage/project-session.ts
+import { basename, dirname as dirname2, join as join4 } from "path";
+import { omit } from "es-toolkit";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync2, readdirSync, rmSync, existsSync as existsSync2 } from "fs";
+import { createHash } from "crypto";
+
+// src/shared/constants.ts
+var IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "image/svg+xml",
+  "image/bmp",
+  "image/avif"
+]);
+function isImageMimeType(mimeType) {
+  return !!mimeType && IMAGE_MIME_TYPES.has(mimeType);
 }
+var ALL_FEATURES = ["search", "skills", "ask_user", "share_to_user", "memory"];
+
+// src/backend/storage/project-session.ts
+var projectMetaMemo = (() => {
+  const memo = /* @__PURE__ */ new Map();
+  const scopes2 = readdirSync(PROJECTS_DIR);
+  for (const scope of scopes2) {
+    if (scope.startsWith(".")) {
+      continue;
+    }
+    const filename = join4(PROJECTS_DIR, scope, "project.json");
+    try {
+      const raw = JSON.parse(readFileSync2(filename, "utf-8"));
+      if (!raw) continue;
+      const id = String(raw.id || "");
+      const title = String(raw.title || "");
+      const cwd = String(raw.cwd || "");
+      const created_at = typeof raw.created_at === "number" ? raw.created_at : Date.now();
+      if (!id || !title || !cwd) continue;
+      const meta = {
+        id,
+        title,
+        cwd,
+        created_at,
+        filename
+      };
+      memo.set(id, meta);
+    } catch (error) {
+      console.error(`load project error ${filename}`, error);
+    }
+  }
+  return memo;
+})();
+var sessionMetaMemo = (() => {
+  const memo = /* @__PURE__ */ new Map();
+  for (const [_, project] of Array.from(projectMetaMemo)) {
+    const dir = join4(dirname2(project.filename), "sessions");
+    if (!existsSync2(dir)) {
+      continue;
+    }
+    try {
+      const scopes2 = readdirSync(dir);
+      for (const scope of scopes2) {
+        if (scope.startsWith(".")) {
+          continue;
+        }
+        const filename = join4(dir, scope, "session.json");
+        try {
+          const raw = JSON.parse(readFileSync2(filename, "utf-8"));
+          if (!raw) continue;
+          const id = String(raw.id);
+          const title = String(raw.title || "");
+          const agent_id = String(raw.agent_id);
+          const resume_id = String(raw.resume_id);
+          const project_id = String(raw.project_id);
+          const created_at = typeof raw.created_at === "number" ? raw.created_at : Date.now();
+          const updated_at = typeof raw.updated_at === "number" ? raw.updated_at : created_at;
+          const mcp_servers = Array.isArray(raw.mcp_servers) ? raw.mcp_servers.filter((v) => typeof v === "string") : void 0;
+          const permission_mode = raw.permission_mode === "allow-all" || raw.permission_mode === "ask" ? raw.permission_mode : "ask";
+          const features = Array.isArray(raw.features) ? raw.features.filter((v) => ALL_FEATURES.includes(v)) : ALL_FEATURES;
+          const models = raw.models ?? null;
+          const modes = raw.modes ?? null;
+          const initialize_info = raw.initialize_info ?? null;
+          if (!id || !agent_id || !resume_id || !project_id) continue;
+          const meta = {
+            filename,
+            isStreaming: false,
+            connectionStatus: "disconnected",
+            id,
+            title,
+            agent_id,
+            resume_id,
+            project_id,
+            created_at,
+            updated_at,
+            mcp_servers,
+            features,
+            permission_mode,
+            models,
+            modes,
+            initialize_info
+          };
+          memo.set(id, meta);
+        } catch (error) {
+          console.error(`[storage] load session error ${filename}`, error);
+        }
+      }
+    } catch (error) {
+      console.error(`[storage] load session error ${dir}`, error);
+    }
+  }
+  return memo;
+})();
 function safeSessionDirName(sessionId) {
   return sessionId.replace(/[\\/:<>"|?*]/g, "_");
 }
-function sessionDir(projectId, sessionId) {
-  const safe = safeSessionDirName(sessionId);
-  const safeDir = join2(projectSessionsDir(projectId), safe);
-  if (safe !== sessionId && !existsSync(safeDir)) {
-    const legacyDir = join2(projectSessionsDir(projectId), sessionId);
-    if (existsSync(legacyDir)) return legacyDir;
-  }
-  return safeDir;
-}
-function sessionMetaPath(projectId, sessionId) {
-  return join2(sessionDir(projectId, sessionId), "session.json");
+function writeProjectMeta(meta) {
+  mkdirSync2(dirname2(meta.filename), { recursive: true });
+  writeFileSync2(meta.filename, JSON.stringify(omit(meta, ["filename"]), null, 2));
+  projectMetaMemo.set(meta.id, meta);
 }
-var projectMetaCache = /* @__PURE__ */ new Map();
-var sessionMetaCache = /* @__PURE__ */ new Map();
-function readProjectMeta(projectId) {
-  const cached = projectMetaCache.get(projectId);
-  if (cached) return cached;
-  try {
-    const raw = JSON.parse(readFileSync(projectMetaPath(projectId), "utf-8"));
-    if (!raw) return null;
-    const id = String(raw.id || "");
-    const title = String(raw.title || "");
-    const cwd = String(raw.cwd || "");
-    const created_at = typeof raw.created_at === "number" ? raw.created_at : Date.now();
-    if (!id || !title || !cwd) return null;
-    const meta = { id, title, cwd, created_at };
-    projectMetaCache.set(id, meta);
-    return meta;
-  } catch {
-    return null;
+function writeSessionMeta(meta) {
+  mkdirSync2(dirname2(meta.filename), { recursive: true });
+  writeFileSync2(
+    meta.filename,
+    JSON.stringify(omit(meta, ["filename", "isStreaming", "connectionStatus"]), null, 2)
+  );
+  sessionMetaMemo.set(meta.id, meta);
+}
+function listProjects() {
+  return Array.from(projectMetaMemo.values()).sort((a, b) => b.created_at - a.created_at).map((p) => ({
+    id: p.id,
+    title: p.title,
+    cwd: p.cwd,
+    createdAt: p.created_at
+  }));
+}
+function addProject(cwd) {
+  cwd = cwd.trim();
+  const projectId = createHash("sha1").update(cwd).digest("hex");
+  const existing = projectMetaMemo.get(projectId);
+  if (existing) {
+    return {
+      id: existing.id,
+      title: existing.title,
+      cwd: existing.cwd,
+      createdAt: existing.created_at
+    };
   }
+  const now = Date.now();
+  const title = basename(cwd) || cwd;
+  const filename = join4(PROJECTS_DIR, projectId, "project.json");
+  const meta = { filename, id: projectId, title, cwd, created_at: now };
+  writeProjectMeta(meta);
+  return {
+    id: meta.id,
+    title: meta.title,
+    cwd: meta.cwd,
+    createdAt: meta.created_at
+  };
 }
-function writeProjectMeta(meta) {
-  mkdirSync(projectDir(meta.id), { recursive: true });
-  mkdirSync(projectSessionsDir(meta.id), { recursive: true });
-  writeFileSync(projectMetaPath(meta.id), JSON.stringify(meta, null, 2));
-  projectMetaCache.set(meta.id, meta);
-}
-function deleteProjectMeta(projectId) {
-  const dir = projectDir(projectId);
-  if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
-  projectMetaCache.delete(projectId);
-  for (const [id, meta] of sessionMetaCache.entries()) {
+function updateProjectTitle(projectId, title) {
+  const project = projectMetaMemo.get(projectId);
+  if (!project) return;
+  const nextTitle = title.trim();
+  if (!nextTitle) return;
+  project.title = nextTitle;
+  writeProjectMeta(project);
+}
+function deleteProject(projectId) {
+  const projectMeta = projectMetaMemo.get(projectId);
+  if (projectMeta) rmSync(dirname2(projectMeta.filename), { recursive: true, force: true });
+  projectMetaMemo.delete(projectId);
+  for (const [id, meta] of sessionMetaMemo.entries()) {
     if (meta.project_id === projectId) {
-      sessionMetaCache.delete(id);
+      sessionMetaMemo.delete(id);
     }
   }
 }
-function getProjectMeta(projectId) {
-  return projectMetaCache.get(projectId) ?? null;
+function getProject(projectId) {
+  const project = projectMetaMemo.get(projectId);
+  if (!project) return null;
+  return {
+    id: project.id,
+    title: project.title,
+    cwd: project.cwd,
+    createdAt: project.created_at
+  };
 }
-function listProjectMetas() {
-  const projects = Array.from(projectMetaCache.values());
-  projects.sort((a, b) => b.created_at - a.created_at);
-  return projects;
+function createSession(projectId, resumeId, agentId, updates) {
+  const projectMeta = projectMetaMemo.get(projectId);
+  if (!projectMeta) throw new Error("Project does not exist");
+  const now = Date.now();
+  const id = `${agentId}:${resumeId}`;
+  const sessionMeta = {
+    filename: join4(
+      dirname2(projectMeta.filename),
+      "sessions",
+      safeSessionDirName(id),
+      "session.json"
+    ),
+    isStreaming: false,
+    connectionStatus: "disconnected",
+    id,
+    title: updates?.title ?? "",
+    agent_id: agentId,
+    resume_id: resumeId,
+    project_id: projectId,
+    created_at: now,
+    updated_at: now,
+    mcp_servers: updates?.mcpServers ?? [],
+    features: updates?.features ?? ALL_FEATURES,
+    permission_mode: updates?.permissionMode ?? "ask",
+    models: updates?.models ?? null,
+    modes: updates?.modes ?? null,
+    initialize_info: updates?.initializeInfo ?? null
+  };
+  writeSessionMeta(sessionMeta);
+  return getSession(id);
+}
+function updateSession(sessionId, updates, updateTime = true) {
+  const meta = sessionMetaMemo.get(sessionId);
+  if (!meta) return;
+  if (updates.isStreaming !== void 0) meta.isStreaming = updates.isStreaming;
+  if (updates.connectionStatus !== void 0) meta.connectionStatus = updates.connectionStatus;
+  if (updates.title !== void 0) meta.title = updates.title;
+  if (updates.mcpServers !== void 0) meta.mcp_servers = updates.mcpServers;
+  if (updates.features !== void 0) meta.features = updates.features;
+  if (updates.permissionMode !== void 0) meta.permission_mode = updates.permissionMode;
+  if (updates.models !== void 0) meta.models = updates.models;
+  if (updates.modes !== void 0) meta.modes = updates.modes;
+  if (updates.initializeInfo !== void 0) meta.initialize_info = updates.initializeInfo;
+  if (updateTime) {
+    meta.updated_at = Date.now();
+  }
+  writeSessionMeta(meta);
 }
-function readSessionMeta(projectId, sessionId) {
-  const cached = sessionMetaCache.get(sessionId);
-  if (cached) return cached;
-  try {
-    const raw = JSON.parse(
-      readFileSync(sessionMetaPath(projectId, sessionId), "utf-8")
-    );
-    if (!raw) return null;
-    const id = String(raw.id);
-    const title = String(raw.title || "");
-    const agent_id = String(raw.agent_id);
-    const resume_id = String(raw.resume_id);
-    const project_id = String(raw.project_id);
-    const created_at = typeof raw.created_at === "number" ? raw.created_at : Date.now();
-    const updated_at = typeof raw.updated_at === "number" ? raw.updated_at : created_at;
-    const mcp_servers = Array.isArray(raw.mcp_servers) ? raw.mcp_servers.filter((v) => typeof v === "string") : void 0;
-    const permission_mode = raw.permission_mode === "allow-all" || raw.permission_mode === "ask" ? raw.permission_mode : "ask";
-    const features = Array.isArray(raw.features) ? raw.features.filter((v) => ALL_FEATURES.includes(v)) : ALL_FEATURES;
-    const models = raw.models ?? null;
-    const modes = raw.modes ?? null;
-    const initialize_info = raw.initialize_info ?? null;
-    if (!id || !agent_id || !resume_id || !project_id) return null;
-    const meta = {
-      id,
-      title,
-      agent_id,
-      resume_id,
-      project_id,
-      created_at,
-      updated_at,
-      mcp_servers,
-      features,
-      permission_mode,
-      models,
-      modes,
-      initialize_info
-    };
-    sessionMetaCache.set(id, meta);
-    return meta;
-  } catch {
-    return null;
+function deleteSession(sessionId) {
+  const sessionMeta = sessionMetaMemo.get(sessionId);
+  if (!sessionMeta) return;
+  const dir = dirname2(sessionMeta.filename);
+  if (existsSync2(dir)) rmSync(dir, { recursive: true, force: true });
+  sessionMetaMemo.delete(sessionId);
+}
+function listSessions() {
+  const sessionMetas = Array.from(sessionMetaMemo.values()).sort(
+    (a, b) => b.updated_at - a.updated_at
+  );
+  const result = [];
+  for (const meta of sessionMetas) {
+    const project = projectMetaMemo.get(meta.project_id);
+    if (project) {
+      result.push({
+        id: meta.id,
+        title: meta.title,
+        cwd: project.cwd,
+        projectId: meta.project_id,
+        projectTitle: project.title,
+        agentId: meta.agent_id,
+        resumeId: meta.resume_id,
+        createdAt: meta.created_at,
+        updatedAt: meta.updated_at,
+        mcpServers: meta.mcp_servers ?? [],
+        features: meta.features ?? ALL_FEATURES,
+        permissionMode: meta.permission_mode ?? "ask",
+        models: meta.models ?? null,
+        modes: meta.modes ?? null,
+        initializeInfo: meta.initialize_info ?? null,
+        isStreaming: meta.isStreaming,
+        connectionStatus: meta.connectionStatus
+      });
+    }
   }
+  return result;
 }
-function writeSessionMeta(meta) {
-  mkdirSync(sessionDir(meta.project_id, meta.id), { recursive: true });
-  writeFileSync(sessionMetaPath(meta.project_id, meta.id), JSON.stringify(meta, null, 2));
-  sessionMetaCache.set(meta.id, meta);
+function getSession(sessionId) {
+  const meta = sessionMetaMemo.get(sessionId);
+  if (!meta) return null;
+  const project = projectMetaMemo.get(meta.project_id);
+  if (!project) return null;
+  return {
+    id: meta.id,
+    title: meta.title,
+    cwd: project.cwd,
+    projectId: meta.project_id,
+    projectTitle: project.title,
+    agentId: meta.agent_id,
+    resumeId: meta.resume_id,
+    createdAt: meta.created_at,
+    updatedAt: meta.updated_at,
+    mcpServers: meta.mcp_servers ?? [],
+    features: meta.features ?? ALL_FEATURES,
+    permissionMode: meta.permission_mode ?? "ask",
+    models: meta.models ?? null,
+    modes: meta.modes ?? null,
+    initializeInfo: meta.initialize_info ?? null,
+    isStreaming: meta.isStreaming,
+    connectionStatus: meta.connectionStatus
+  };
 }
-function deleteSessionMeta(sessionId) {
-  const sessionMeta = sessionMetaCache.get(sessionId);
-  if (!sessionMeta) return;
-  const dir = sessionDir(sessionMeta.project_id, sessionId);
-  if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
-  sessionMetaCache.delete(sessionId);
+function touchSession(sessionId) {
+  const meta = sessionMetaMemo.get(sessionId);
+  if (!meta) return;
+  meta.updated_at = Date.now();
+  writeSessionMeta(meta);
 }
-function getSessionMeta(sessionId) {
-  return sessionMetaCache.get(sessionId) ?? null;
+function sessionDir(sessionId) {
+  const meta = sessionMetaMemo.get(sessionId);
+  if (!meta) return null;
+  return dirname2(meta.filename);
 }
-function listSessionMetas() {
-  const sessions = Array.from(sessionMetaCache.values());
-  sessions.sort((a, b) => b.updated_at - a.updated_at);
-  return sessions;
+function sessionTerminalDir(sessionId) {
+  const dir = sessionDir(sessionId);
+  if (!dir) return null;
+  return join4(dir, "terminals");
 }
-function initMetaCache() {
-  if (!existsSync(PROJECTS_DIR)) return;
-  const dirs = readdirSync(PROJECTS_DIR);
-  for (const dir of dirs) {
-    readProjectMeta(dir);
-  }
-  const projects = listProjectMetas();
-  for (const project of projects) {
-    const sessionsPath = projectSessionsDir(project.id);
-    if (!existsSync(sessionsPath)) continue;
-    const dirs2 = readdirSync(sessionsPath);
-    for (const dir of dirs2) {
-      const meta = readSessionMeta(project.id, dir);
-      if (meta) {
-        sessionMetaCache.set(meta.id, meta);
-      }
+function sessionShareDir(sessionId) {
+  const dir = sessionDir(sessionId);
+  if (!dir) return null;
+  return join4(dir, "share");
+}
+
+// src/backend/storage/index.ts
+function appendSessionMessage(sessionIdOrSubSessionId, notification) {
+  const dir = sessionDir(sessionIdOrSubSessionId);
+  if (!dir) return;
+  mkdirSync3(dir, { recursive: true });
+  const filePath = join5(dir, "messages.jsonl");
+  appendFileSync(filePath, JSON.stringify(notification) + "\n");
+}
+function readSessionMessages(sessionIdOrSubSessionId) {
+  const dir = sessionDir(sessionIdOrSubSessionId);
+  if (!dir) return [];
+  const filePath = join5(dir, "messages.jsonl");
+  if (!existsSync3(filePath)) return [];
+  const content = readFileSync3(filePath, "utf-8");
+  return content.split("\n").filter((line) => line.trim()).map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
     }
+  }).filter(Boolean);
+}
+function appendTerminalOutput(sessionIdOrSubSessionId, terminalId, data) {
+  if (!/^[a-zA-Z0-9_-]{1,64}$/.test(terminalId)) {
+    throw new Error("Invalid terminalId");
+  }
+  const dir = sessionTerminalDir(sessionIdOrSubSessionId);
+  if (!dir) return;
+  if (!existsSync3(dir)) {
+    mkdirSync3(dir, { recursive: true });
   }
+  const filePath = join5(dir, `${terminalId}.log`);
+  appendFileSync(filePath, data);
 }
-initMetaCache();
-var storageOps = {
-  getSettings() {
-    const meta = readSettings();
-    return {
-      agents: Object.entries(meta.agents).map(([id, agentMeta]) => {
-        if (agentMeta.type === "stdio") {
-          return {
-            id,
-            type: agentMeta.type,
-            command: agentMeta.command,
-            args: agentMeta.args.slice(),
-            env: Object.assign({}, agentMeta.env),
-            disabled: agentMeta.disabled
-          };
-        }
-        if (agentMeta.type === "api") {
-          return {
-            id,
-            type: agentMeta.type,
-            provider: agentMeta.provider,
-            baseUrl: agentMeta.baseUrl,
-            apiKey: agentMeta.apiKey,
-            headers: Object.assign({}, agentMeta.headers),
-            disabled: agentMeta.disabled,
-            contextWindowTokens: agentMeta.contextWindowTokens,
-            modelIdTemplate: agentMeta.modelIdTemplate
-          };
-        }
-        throw new Error("Invalid agent type.");
-      }).sort((a, b) => meta.agents[a.id].order - meta.agents[b.id].order),
-      mcpServers: Object.entries(meta.mcpServers).map(([id, srvMeta]) => {
-        if (srvMeta.type === "stdio") {
-          return {
-            id,
-            type: srvMeta.type,
-            command: srvMeta.command,
-            args: srvMeta.args.slice(),
-            env: Object.assign({}, srvMeta.env),
-            disabled: srvMeta.disabled
-          };
-        }
-        if (srvMeta.type === "http") {
-          return {
-            id,
-            type: srvMeta.type,
-            url: srvMeta.url,
-            headers: Object.assign({}, srvMeta.headers),
-            disabled: srvMeta.disabled
-          };
-        }
-        if (srvMeta.type === "sse") {
-          return {
-            id,
-            type: srvMeta.type,
-            url: srvMeta.url,
-            headers: Object.assign({}, srvMeta.headers),
-            disabled: srvMeta.disabled
-          };
-        }
-        throw new Error(`Invalid mcpServer type ${srvMeta.type}.`);
-      }).sort((a, b) => meta.mcpServers[a.id].order - meta.mcpServers[b.id].order),
-      i18n: {
-        language: meta.i18n.language
-      },
-      theme: {
-        themeMode: meta.theme.theme_mode
-      },
-      fileWatcher: {
-        enabled: meta.fileWatcher.enabled
-      },
-      ilink: {
-        useOriginalImage: meta.ilink.useOriginalImage
-      },
-      editor: {
-        name: meta.editor.name
-      },
-      sound: {
-        volume: meta.sound.volume,
-        muted: meta.sound.muted,
-        theme: meta.sound.theme
-      },
-      snippets: meta.snippets ?? []
-    };
-  },
-  updateSettings(settings) {
-    const prevMeta = readSettings();
-    const meta = {
-      agents: (() => {
-        if (!settings.agents) {
-          return prevMeta.agents;
-        }
-        const nextAgents = {};
-        settings.agents.forEach((agent, idx) => {
-          if (agent.type === "stdio") {
-            nextAgents[agent.id] = {
-              type: agent.type,
-              command: agent.command,
-              args: agent.args.slice(),
-              env: Object.assign({}, agent.env),
-              disabled: agent.disabled,
-              order: idx
-            };
-          } else if (agent.type === "api") {
-            nextAgents[agent.id] = {
-              type: agent.type,
-              provider: agent.provider,
-              baseUrl: agent.baseUrl,
-              apiKey: agent.apiKey,
-              headers: Object.assign({}, agent.headers || {}),
-              disabled: agent.disabled,
-              order: idx,
-              contextWindowTokens: agent.contextWindowTokens !== void 0 ? Number.isInteger(agent.contextWindowTokens) && agent.contextWindowTokens > 0 ? agent.contextWindowTokens : void 0 : void 0,
-              modelIdTemplate: typeof agent.modelIdTemplate === "string" && agent.modelIdTemplate.trim() ? agent.modelIdTemplate.trim() : void 0
-            };
-          } else {
-            throw new Error("Invalid agent type.");
-          }
-        });
-        return nextAgents;
-      })(),
-      i18n: (() => {
-        if (!settings.i18n) {
-          return prevMeta.i18n;
-        }
-        return {
-          language: settings.i18n.language
-        };
-      })(),
-      theme: (() => {
-        if (!settings.theme) {
-          return prevMeta.theme;
-        }
-        return {
-          theme_mode: settings.theme.themeMode
-        };
-      })(),
-      mcpServers: (() => {
-        if (!settings.mcpServers) {
-          return prevMeta.mcpServers;
-        }
-        const nextMcpServers = {};
-        settings.mcpServers.forEach((srv, idx) => {
-          if (srv.type === "stdio") {
-            nextMcpServers[srv.id] = {
-              type: srv.type,
-              command: srv.command,
-              args: srv.args.slice(),
-              env: Object.assign({}, srv.env),
-              disabled: srv.disabled,
-              order: idx
-            };
-          } else if (srv.type === "http") {
-            nextMcpServers[srv.id] = {
-              type: srv.type,
-              url: srv.url,
-              headers: Object.assign({}, srv.headers),
-              disabled: srv.disabled,
-              order: idx
-            };
-          } else if (srv.type === "sse") {
-            nextMcpServers[srv.id] = {
-              type: srv.type,
-              url: srv.url,
-              headers: Object.assign({}, srv.headers),
-              disabled: srv.disabled,
-              order: idx
-            };
-          }
-        });
-        return nextMcpServers;
-      })(),
-      fileWatcher: (() => {
-        if (!settings.fileWatcher) {
-          return prevMeta.fileWatcher;
-        }
-        return {
-          enabled: settings.fileWatcher.enabled
-        };
-      })(),
-      ilink: (() => {
-        if (!settings.ilink) {
-          return prevMeta.ilink;
-        }
-        return {
-          useOriginalImage: settings.ilink.useOriginalImage
-        };
-      })(),
-      editor: (() => {
-        if (!settings.editor) {
-          return prevMeta.editor;
-        }
-        return {
-          name: settings.editor.name
-        };
-      })(),
-      sound: (() => {
-        if (!settings.sound) {
-          return prevMeta.sound;
-        }
-        return {
-          volume: typeof settings.sound.volume === "number" && settings.sound.volume >= 0 && settings.sound.volume <= 100 ? settings.sound.volume : prevMeta.sound.volume,
-          muted: typeof settings.sound.muted === "boolean" ? settings.sound.muted : prevMeta.sound.muted,
-          theme: settings.sound.theme === "soft" || settings.sound.theme === "crisp" ? settings.sound.theme : prevMeta.sound.theme
-        };
-      })(),
-      snippets: settings.snippets ?? prevMeta.snippets
-    };
-    writeSettings(meta);
-  },
-  listProjects() {
-    return listProjectMetas().map((p) => ({
-      id: p.id,
-      title: p.title,
-      cwd: p.cwd,
-      createdAt: p.created_at
-    }));
-  },
-  addProject(cwd) {
-    const projectId = hashCwd(cwd);
-    const existing = getProjectMeta(projectId);
-    if (existing) {
-      return {
-        id: existing.id,
-        title: existing.title,
-        cwd: existing.cwd,
-        createdAt: existing.created_at
-      };
-    }
-    const now = Date.now();
-    const title = basename(cwd) || cwd;
-    const meta = { id: projectId, title, cwd, created_at: now };
-    writeProjectMeta(meta);
-    return {
-      id: meta.id,
-      title: meta.title,
-      cwd: meta.cwd,
-      createdAt: meta.created_at
-    };
-  },
-  updateProjectTitle(projectId, title) {
-    const project = getProjectMeta(projectId);
-    if (!project) return;
-    const nextTitle = title.trim();
-    if (!nextTitle) return;
-    project.title = nextTitle;
-    writeProjectMeta(project);
-  },
-  deleteProject(projectId) {
-    deleteProjectMeta(projectId);
-  },
-  getProject(projectId) {
-    const project = getProjectMeta(projectId);
-    if (!project) return null;
-    return {
-      id: project.id,
-      title: project.title,
-      cwd: project.cwd,
-      createdAt: project.created_at
-    };
-  },
-  createSession(projectId, resumeId, agentId, updates) {
-    const project = readProjectMeta(projectId);
-    if (!project) throw new Error("Project does not exist");
-    const now = Date.now();
-    const id = `${agentId}:${resumeId}`;
-    const meta = {
-      id,
-      title: updates?.title ?? "",
-      agent_id: agentId,
-      resume_id: resumeId,
-      project_id: projectId,
-      created_at: now,
-      updated_at: now,
-      mcp_servers: updates?.mcpServers ?? [],
-      features: updates?.features ?? ALL_FEATURES,
-      permission_mode: updates?.permissionMode ?? "ask",
-      models: updates?.models ?? null,
-      modes: updates?.modes ?? null,
-      initialize_info: updates?.initializeInfo ?? null
-    };
-    writeSessionMeta(meta);
-    return this.getSession(id);
-  },
-  updateSession(sessionId, updates, updateTime = true) {
-    const meta = getSessionMeta(sessionId);
-    if (!meta) return;
-    if (updates.title !== void 0) meta.title = updates.title;
-    if (updates.mcpServers !== void 0) meta.mcp_servers = updates.mcpServers;
-    if (updates.features !== void 0) meta.features = updates.features;
-    if (updates.permissionMode !== void 0) meta.permission_mode = updates.permissionMode;
-    if (updates.models !== void 0) meta.models = updates.models;
-    if (updates.modes !== void 0) meta.modes = updates.modes;
-    if (updates.initializeInfo !== void 0) meta.initialize_info = updates.initializeInfo;
-    if (updateTime) {
-      meta.updated_at = Date.now();
-    }
-    writeSessionMeta(meta);
-    if (updates.isStreaming !== void 0) {
-      if (updates.isStreaming) {
-        streamingSessions.add(sessionId);
-      } else {
-        streamingSessions.delete(sessionId);
-      }
-    }
-  },
-  deleteSession(sessionId) {
-    deleteSessionMeta(sessionId);
-    streamingSessions.delete(sessionId);
-  },
-  listSessions() {
-    const metas = listSessionMetas();
-    const result = [];
-    for (const meta of metas) {
-      const project = readProjectMeta(meta.project_id);
-      if (project) {
-        result.push({
-          id: meta.id,
-          title: meta.title,
-          cwd: project.cwd,
-          projectId: meta.project_id,
-          projectTitle: project.title,
-          agentId: meta.agent_id,
-          resumeId: meta.resume_id,
-          createdAt: meta.created_at,
-          updatedAt: meta.updated_at,
-          mcpServers: meta.mcp_servers ?? [],
-          features: meta.features ?? ALL_FEATURES,
-          permissionMode: meta.permission_mode ?? "ask",
-          models: meta.models ?? null,
-          modes: meta.modes ?? null,
-          initializeInfo: meta.initialize_info ?? null,
-          isStreaming: streamingSessions.has(meta.id)
-        });
-      }
-    }
-    return result;
-  },
-  getSession(sessionId) {
-    const meta = getSessionMeta(sessionId);
-    if (!meta) return null;
-    const project = readProjectMeta(meta.project_id);
-    if (!project) return null;
-    return {
-      id: meta.id,
-      title: meta.title,
-      cwd: project.cwd,
-      projectId: meta.project_id,
-      projectTitle: project.title,
-      agentId: meta.agent_id,
-      resumeId: meta.resume_id,
-      createdAt: meta.created_at,
-      updatedAt: meta.updated_at,
-      mcpServers: meta.mcp_servers ?? [],
-      features: meta.features ?? ALL_FEATURES,
-      permissionMode: meta.permission_mode ?? "ask",
-      models: meta.models ?? null,
-      modes: meta.modes ?? null,
-      initializeInfo: meta.initialize_info ?? null,
-      isStreaming: streamingSessions.has(meta.id)
-    };
-  },
-  touchSession(sessionId) {
-    const session = this.getSession(sessionId);
-    if (!session) return;
-    const meta = readSessionMeta(session.projectId, session.id);
-    if (!meta) return;
-    meta.updated_at = Date.now();
-    writeSessionMeta(meta);
-  },
-  appendSessionMessage(sessionId, notification) {
-    const session = this.getSession(sessionId);
-    if (!session) return;
-    const filePath = join2(sessionDir(session.projectId, sessionId), "messages.jsonl");
-    appendFileSync(filePath, JSON.stringify(notification) + "\n");
-  },
-  readSessionMessages(sessionId) {
-    const session = this.getSession(sessionId);
-    if (!session) return [];
-    const filePath = join2(sessionDir(session.projectId, sessionId), "messages.jsonl");
-    if (!existsSync(filePath)) return [];
-    const content = readFileSync(filePath, "utf-8");
-    return content.split("\n").filter((line) => line.trim()).map((line) => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        return null;
-      }
-    }).filter(Boolean);
-  },
-  appendTerminalOutput(sessionId, terminalId, data) {
-    if (!/^[a-zA-Z0-9_-]{1,64}$/.test(terminalId)) {
-      throw new Error("Invalid terminalId");
-    }
-    const session = this.getSession(sessionId);
-    if (!session) return;
-    const sessionTerminalsDir = join2(sessionDir(session.projectId, sessionId), "terminals");
-    if (!existsSync(sessionTerminalsDir)) {
-      mkdirSync(sessionTerminalsDir, { recursive: true });
-    }
-    const filePath = join2(sessionTerminalsDir, `${terminalId}.log`);
-    appendFileSync(filePath, data);
-  },
-  /** 获取 session 的 share 目录路径 */
-  sessionShareDir(sessionId) {
-    const session = this.getSession(sessionId);
-    if (!session) return null;
-    return join2(sessionDir(session.projectId, sessionId), "share");
-  },
-  readTerminalOutput(sessionId, terminalId) {
-    if (!/^[a-zA-Z0-9_-]{1,64}$/.test(terminalId)) {
-      throw new Error("Invalid terminalId");
-    }
-    const session = this.getSession(sessionId);
-    if (!session) return null;
-    const sessionTerminalsDir = join2(sessionDir(session.projectId, sessionId), "terminals");
-    const filePath = join2(sessionTerminalsDir, `${terminalId}.log`);
-    if (!existsSync(filePath)) return null;
-    return readFileSync(filePath, "utf-8");
+function readTerminalOutput(sessionIdOrSubSessionId, terminalId) {
+  if (!/^[a-zA-Z0-9_-]{1,64}$/.test(terminalId)) {
+    throw new Error("Invalid terminalId");
   }
+  const dir = sessionTerminalDir(sessionIdOrSubSessionId);
+  if (!dir) return null;
+  const filePath = join5(dir, `${terminalId}.log`);
+  if (!existsSync3(filePath)) return null;
+  return readFileSync3(filePath, "utf-8");
+}
+var storageOps = {
+  getSettings,
+  updateSettings,
+  addProject,
+  createSession,
+  deleteProject,
+  deleteSession,
+  getProject,
+  getSession,
+  listProjects,
+  listSessions,
+  getSessionDataSystemPath: sessionDir,
+  sessionShareDir,
+  touchSession,
+  updateProjectTitle,
+  updateSession,
+  appendSessionMessage,
+  readSessionMessages,
+  appendTerminalOutput,
+  readTerminalOutput
 };
 
 // src/backend/i18n.ts
@@ -959,15 +962,15 @@ function setLanguage(lang) {
 
 // src/agents/storage.ts
 import { readFile } from "fs/promises";
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync4, readdirSync as readdirSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
 function toSafePathSegment(value) {
   const normalized = value.trim();
   if (!normalized) return "unknown";
   return normalized.replace(/[\\/:<>"|?*]/g, "_");
 }
 function apiAgentSessionDir(agentId, sessionId) {
-  return join3(
+  return join6(
     FELLO_DIR,
     "api-agents",
     toSafePathSegment(agentId),
@@ -976,10 +979,10 @@ function apiAgentSessionDir(agentId, sessionId) {
   );
 }
 function sessionJsonPath(agentId, sessionId) {
-  return join3(apiAgentSessionDir(agentId, sessionId), "session.json");
+  return join6(apiAgentSessionDir(agentId, sessionId), "session.json");
 }
 function historyJsonlPath(agentId, sessionId) {
-  return join3(apiAgentSessionDir(agentId, sessionId), "history.jsonl");
+  return join6(apiAgentSessionDir(agentId, sessionId), "history.jsonl");
 }
 function isModelMessage(value) {
   if (!value || typeof value !== "object") return false;
@@ -1025,7 +1028,7 @@ async function loadPersistedSessionHistory(params) {
   }).filter((value) => isModelMessage(value));
 }
 function ensureSessionDirSync(agentId, sessionId) {
-  mkdirSync2(apiAgentSessionDir(agentId, sessionId), { recursive: true });
+  mkdirSync4(apiAgentSessionDir(agentId, sessionId), { recursive: true });
 }
 async function savePersistedSessionState(params) {
   ensureSessionDirSync(params.agentId, params.sessionId);
@@ -1034,7 +1037,7 @@ async function savePersistedSessionState(params) {
     allowedToolKinds: params.allowedToolKinds,
     contextUsedTokens: params.contextUsedTokens
   };
-  writeFileSync2(
+  writeFileSync3(
     sessionJsonPath(params.agentId, params.sessionId),
     JSON.stringify(sessionJson, null, 2),
     "utf8"
@@ -1043,7 +1046,7 @@ async function savePersistedSessionState(params) {
 async function savePersistedSessionHistory(params) {
   ensureSessionDirSync(params.agentId, params.sessionId);
   const lines = params.messages.map((message) => JSON.stringify(message)).join("\n");
-  writeFileSync2(
+  writeFileSync3(
     historyJsonlPath(params.agentId, params.sessionId),
     lines ? `${lines}
 ` : "",
@@ -1064,11 +1067,11 @@ function deletePersistedSessionDirectory(params) {
   });
 }
 function deleteAgentPersistedStorage(agentId) {
-  const dir = join3(FELLO_DIR, "api-agents", toSafePathSegment(agentId));
+  const dir = join6(FELLO_DIR, "api-agents", toSafePathSegment(agentId));
   rmSync2(dir, { recursive: true, force: true });
 }
 function deleteOrphanedAgentSessionDirectories(agentId, knownSessionIds) {
-  const sessionsDir = join3(FELLO_DIR, "api-agents", toSafePathSegment(agentId), "sessions");
+  const sessionsDir = join6(FELLO_DIR, "api-agents", toSafePathSegment(agentId), "sessions");
   let entries;
   try {
     entries = readdirSync2(sessionsDir);
@@ -1076,7 +1079,7 @@ function deleteOrphanedAgentSessionDirectories(agentId, knownSessionIds) {
     return;
   }
   for (const entry of entries) {
-    const fullPath = join3(sessionsDir, entry);
+    const fullPath = join6(sessionsDir, entry);
     try {
       if (statSync(fullPath).isDirectory() && !knownSessionIds.has(entry)) {
         rmSync2(fullPath, { recursive: true, force: true });
@@ -1091,7 +1094,7 @@ import { createServer } from "http";
 import { WebSocketServer } from "ws";
 import { randomBytes, createHash as createHash2 } from "crypto";
 import { networkInterfaces } from "os";
-import { join as join5 } from "path";
+import { join as join8 } from "path";
 import { readFile as readFile3, stat as stat2 } from "fs/promises";
 
 // src/backend/serve-file.ts
@@ -1161,42 +1164,42 @@ async function serveFile(filename, cwd) {
 }
 
 // src/backend/automation/store.ts
-import { join as join4, dirname as dirname2 } from "path";
+import { join as join7, dirname as dirname3 } from "path";
 import { homedir as homedir2 } from "os";
 import {
-  mkdirSync as mkdirSync3,
-  writeFileSync as writeFileSync3,
-  readFileSync as readFileSync2,
+  mkdirSync as mkdirSync5,
+  writeFileSync as writeFileSync4,
+  readFileSync as readFileSync4,
   readdirSync as readdirSync3,
   rmSync as rmSync3,
-  existsSync as existsSync2,
+  existsSync as existsSync4,
   statSync as statSync2
 } from "fs";
-var AUTOMATIONS_DIR = join4(homedir2(), ".fello", "automations");
-mkdirSync3(AUTOMATIONS_DIR, { recursive: true });
+var AUTOMATIONS_DIR = join7(homedir2(), ".fello", "automations");
+mkdirSync5(AUTOMATIONS_DIR, { recursive: true });
 var store = {
   scheduleDir(scheduleId) {
-    return join4(AUTOMATIONS_DIR, scheduleId);
+    return join7(AUTOMATIONS_DIR, scheduleId);
   },
   scheduleConfigPath(scheduleId) {
-    return join4(this.scheduleDir(scheduleId), "schedule.json");
+    return join7(this.scheduleDir(scheduleId), "schedule.json");
   },
   tasksDir(scheduleId) {
-    return join4(this.scheduleDir(scheduleId), "tasks");
+    return join7(this.scheduleDir(scheduleId), "tasks");
   },
   taskDir(scheduleId, taskId) {
-    return join4(this.tasksDir(scheduleId), taskId);
+    return join7(this.tasksDir(scheduleId), taskId);
   },
   taskMetaPath(scheduleId, taskId) {
-    return join4(this.taskDir(scheduleId, taskId), "task.json");
+    return join7(this.taskDir(scheduleId, taskId), "task.json");
   },
   listSchedules() {
-    if (!existsSync2(AUTOMATIONS_DIR)) return [];
+    if (!existsSync4(AUTOMATIONS_DIR)) return [];
     const dirs = readdirSync3(AUTOMATIONS_DIR);
     const list = [];
     for (const dir of dirs) {
       try {
-        const raw = JSON.parse(readFileSync2(this.scheduleConfigPath(dir), "utf-8"));
+        const raw = JSON.parse(readFileSync4(this.scheduleConfigPath(dir), "utf-8"));
         list.push(raw);
       } catch {
       }
@@ -1206,16 +1209,16 @@ var store = {
   },
   getSchedule(scheduleId) {
     try {
-      return JSON.parse(readFileSync2(this.scheduleConfigPath(scheduleId), "utf-8"));
+      return JSON.parse(readFileSync4(this.scheduleConfigPath(scheduleId), "utf-8"));
     } catch {
       return null;
     }
   },
   saveSchedule(schedule) {
     const dir = this.scheduleDir(schedule.id);
-    mkdirSync3(dir, { recursive: true });
-    mkdirSync3(this.tasksDir(schedule.id), { recursive: true });
-    writeFileSync3(this.scheduleConfigPath(schedule.id), JSON.stringify(schedule, null, 2));
+    mkdirSync5(dir, { recursive: true });
+    mkdirSync5(this.tasksDir(schedule.id), { recursive: true });
+    writeFileSync4(this.scheduleConfigPath(schedule.id), JSON.stringify(schedule, null, 2));
   },
   createSchedule(params) {
     const now = Date.now();
@@ -1237,18 +1240,18 @@ var store = {
   },
   deleteSchedule(scheduleId) {
     const dir = this.scheduleDir(scheduleId);
-    if (existsSync2(dir)) {
+    if (existsSync4(dir)) {
       rmSync3(dir, { recursive: true, force: true });
     }
   },
   listTasks(scheduleId) {
     const dir = this.tasksDir(scheduleId);
-    if (!existsSync2(dir)) return [];
+    if (!existsSync4(dir)) return [];
     const dirs = readdirSync3(dir);
     const list = [];
     for (const d of dirs) {
       try {
-        const raw = JSON.parse(readFileSync2(this.taskMetaPath(scheduleId, d), "utf-8"));
+        const raw = JSON.parse(readFileSync4(this.taskMetaPath(scheduleId, d), "utf-8"));
         list.push(raw);
       } catch {
       }
@@ -1258,28 +1261,28 @@ var store = {
   },
   getTask(scheduleId, taskId) {
     try {
-      return JSON.parse(readFileSync2(this.taskMetaPath(scheduleId, taskId), "utf-8"));
+      return JSON.parse(readFileSync4(this.taskMetaPath(scheduleId, taskId), "utf-8"));
     } catch {
       return null;
     }
   },
   saveTask(scheduleId, task) {
     const dir = this.taskDir(scheduleId, task.id);
-    mkdirSync3(dir, { recursive: true });
-    writeFileSync3(this.taskMetaPath(scheduleId, task.id), JSON.stringify(task, null, 2));
+    mkdirSync5(dir, { recursive: true });
+    writeFileSync4(this.taskMetaPath(scheduleId, task.id), JSON.stringify(task, null, 2));
   },
   deleteTask(scheduleId, taskId) {
     const dir = this.taskDir(scheduleId, taskId);
-    if (existsSync2(dir)) {
+    if (existsSync4(dir)) {
       rmSync3(dir, { recursive: true, force: true });
     }
   },
   listTaskFiles(scheduleId, taskId) {
     const dir = this.taskDir(scheduleId, taskId);
-    if (!existsSync2(dir)) return [];
+    if (!existsSync4(dir)) return [];
     const entries = readdirSync3(dir);
     return entries.filter((f) => f !== "task.json").map((f) => {
-      const fullPath = join4(dir, f);
+      const fullPath = join7(dir, f);
       const s = statSync2(fullPath);
       if (s.isDirectory()) {
         return this._listDirRecursive(fullPath, f);
@@ -1291,30 +1294,30 @@ var store = {
     const result = [];
     const entries = readdirSync3(dir);
     for (const entry of entries) {
-      const full = join4(dir, entry);
+      const full = join7(dir, entry);
       const s = statSync2(full);
       if (s.isDirectory()) {
-        result.push(...this._listDirRecursive(full, join4(prefix, entry)));
+        result.push(...this._listDirRecursive(full, join7(prefix, entry)));
       } else {
-        result.push(join4(prefix, entry));
+        result.push(join7(prefix, entry));
       }
     }
     return result;
   },
   readTaskFile(scheduleId, taskId, filePath, encoding) {
     const base = this.taskDir(scheduleId, taskId);
-    const fullPath = join4(base, filePath);
+    const fullPath = join7(base, filePath);
     if (!fullPath.startsWith(base + "/") && fullPath !== base) throw new Error("Invalid file path");
-    if (!existsSync2(fullPath)) throw new Error("File not found");
-    if (encoding === "base64") return readFileSync2(fullPath).toString("base64");
-    return readFileSync2(fullPath, "utf-8");
+    if (!existsSync4(fullPath)) throw new Error("File not found");
+    if (encoding === "base64") return readFileSync4(fullPath).toString("base64");
+    return readFileSync4(fullPath, "utf-8");
   },
   writeTaskFile(scheduleId, taskId, filePath, content) {
     const base = this.taskDir(scheduleId, taskId);
-    const fullPath = join4(base, filePath);
+    const fullPath = join7(base, filePath);
     if (!fullPath.startsWith(base + "/") && fullPath !== base) throw new Error("Invalid file path");
-    mkdirSync3(dirname2(fullPath), { recursive: true });
-    writeFileSync3(fullPath, content);
+    mkdirSync5(dirname3(fullPath), { recursive: true });
+    writeFileSync4(fullPath, content);
   }
 };
 
@@ -1513,17 +1516,17 @@ function createWebUIModule() {
   function broadcastEvent(channel, payload) {
     if (!isEnabled || !wss) return false;
     let hasClients = false;
-    for (const client of connectedClients) {
-      if (client.readyState === 1) {
+    for (const client2 of connectedClients) {
+      if (client2.readyState === 1) {
         hasClients = true;
         break;
       }
     }
     if (!hasClients) return false;
     const message = JSON.stringify({ type: "event", channel, payload });
-    for (const client of connectedClients) {
-      if (client.readyState === 1) {
-        client.send(message);
+    for (const client2 of connectedClients) {
+      if (client2.readyState === 1) {
+        client2.send(message);
       }
     }
     return true;
@@ -1584,10 +1587,10 @@ function createWebUIModule() {
           reqPath = "/index.html";
         }
         const baseDir = process.rendererPath;
-        let filePath = join5(baseDir, reqPath);
+        let filePath = join8(baseDir, reqPath);
         let s = await stat2(filePath).catch(() => null);
         if (!s || s.isDirectory()) {
-          filePath = join5(baseDir, "index.html");
+          filePath = join8(baseDir, "index.html");
         }
         const mime = mimeTypes2.lookup(filePath) || "application/octet-stream";
         const acceptEncoding = req.headers["accept-encoding"] || "";
@@ -1683,8 +1686,8 @@ function createWebUIModule() {
   function stop() {
     isEnabled = false;
     currentToken = null;
-    for (const client of connectedClients) {
-      client.close();
+    for (const client2 of connectedClients) {
+      client2.close();
     }
     connectedClients.clear();
     if (wss) {
@@ -2056,7 +2059,7 @@ function buildSkillsMcpServer(options) {
 }
 
 // src/backend/search/index.ts
-import { join as join9 } from "path";
+import { join as join12 } from "path";
 
 // src/shared/zod/mcp-search-schema.ts
 import { z } from "zod";
@@ -2099,7 +2102,7 @@ var fileOutlineRespondSchema = z.object({
 });
 
 // src/backend/search/file-outline.ts
-import { extname, join as join7, isAbsolute as isAbsolute4, resolve as resolve3, relative as relative5 } from "path";
+import { extname, join as join10, isAbsolute as isAbsolute4, resolve as resolve3, relative as relative5 } from "path";
 import { readFile as readFile4 } from "fs/promises";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { fork } from "child_process";
@@ -2116,7 +2119,7 @@ var LANGUAGES = [
   {
     name: "JavaScript",
     extensions: [".js", ".jsx", ".mjs", ".cjs"],
-    wasmFile: join7(process.treeSitterWasmPath, "tree-sitter-javascript.wasm"),
+    wasmFile: join10(process.treeSitterWasmPath, "tree-sitter-javascript.wasm"),
     symbols: [
       {
         types: ["function_declaration", "generator_function_declaration"],
@@ -2126,11 +2129,13 @@ var LANGUAGES = [
       { types: ["method_definition"], label: "method", hasName: true },
       { types: ["class_declaration"], label: "class", hasName: true },
       {
-        types: ["lexical_declaration", "variable_declaration"],
-        label: "const",
+        types: ["lexical_declaration"],
+        label: "variable",
         hasName: true,
-        maxDepth: 0
+        maxDepth: 0,
+        labelByChild: { const: "const", let: "let" }
       },
+      { types: ["variable_declaration"], label: "var", hasName: true, maxDepth: 0 },
       { types: ["import_statement"], label: "import", hasName: true }
     ],
     wrappers: [{ node: "export_statement", prefix: "export ", createStandaloneLabel: "export" }],
@@ -2144,36 +2149,60 @@ var LANGUAGES = [
         "export_specifier"
       ],
       identifierTypes: ["identifier", "type_identifier"]
+    },
+    statementDetail: {
+      sourceFields: ["source"],
+      sourceTypes: ["string"],
+      clauseTypes: [
+        "import_clause",
+        "named_imports",
+        "named_exports",
+        "export_clause",
+        "namespace_import"
+      ],
+      typeKeywordTypes: ["type"],
+      detailAsNameWhenNoSource: true
     }
   },
   {
     name: "TypeScript",
     extensions: [".ts"],
-    wasmFile: join7(process.treeSitterWasmPath, "tree-sitter-typescript.wasm"),
+    wasmFile: join10(process.treeSitterWasmPath, "tree-sitter-typescript.wasm"),
     symbols: [
       {
-        types: ["function_declaration", "generator_function_declaration"],
+        types: ["function_declaration", "generator_function_declaration", "function_signature"],
         label: "function",
         hasName: true
       },
-      { types: ["method_definition"], label: "method", hasName: true },
+      { types: ["method_definition", "abstract_method_signature"], label: "method", hasName: true },
       { types: ["class_declaration", "abstract_class_declaration"], label: "class", hasName: true },
       { types: ["interface_declaration"], label: "interface", hasName: true },
       { types: ["type_alias_declaration"], label: "type", hasName: true },
       { types: ["enum_declaration"], label: "enum", hasName: true },
       { types: ["internal_module"], label: "namespace", hasName: true },
-      { types: ["property_signature"], label: "property", hasName: true },
+      { types: ["property_signature"], label: "property", hasName: true, maxDepth: 1 },
+      // object_type acts as a depth barrier to prevent property_signature inside
+      // generic constraints or type arguments from being misidentified as real properties
+      { types: ["object_type"], label: "_", hasName: false, maxDepth: -1 },
       {
-        types: ["lexical_declaration", "variable_declaration"],
-        label: "const",
+        types: ["lexical_declaration"],
+        label: "variable",
         hasName: true,
-        maxDepth: 0
+        maxDepth: 0,
+        labelByChild: { const: "const", let: "let" }
       },
+      { types: ["variable_declaration"], label: "var", hasName: true, maxDepth: 0 },
       { types: ["import_statement"], label: "import", hasName: true }
     ],
     wrappers: [
       { node: "export_statement", prefix: "export ", createStandaloneLabel: "export" },
-      { node: "ambient_declaration", prefix: "declare ", maxDepth: 0 }
+      {
+        node: "ambient_declaration",
+        prefix: "declare ",
+        maxDepth: 0,
+        createStandaloneLabel: "declare",
+        createContainerWhenCovered: true
+      }
     ],
     nameOf: {
       fieldPriority: ["name", "source"],
@@ -2185,15 +2214,30 @@ var LANGUAGES = [
         "export_specifier"
       ],
       identifierTypes: ["identifier", "type_identifier"]
+    },
+    statementDetail: {
+      labels: ["import", "export", "declare"],
+      sourceFields: ["source"],
+      sourceTypes: ["string"],
+      clauseTypes: [
+        "import_clause",
+        "named_imports",
+        "named_exports",
+        "export_clause",
+        "namespace_import"
+      ],
+      typeKeywordTypes: ["type"],
+      trimPatterns: ["\\s*\\{\\s*$"],
+      detailAsNameWhenNoSource: true
     }
   },
   {
     name: "TSX",
     extensions: [".tsx"],
-    wasmFile: join7(process.treeSitterWasmPath, "tree-sitter-tsx.wasm"),
+    wasmFile: join10(process.treeSitterWasmPath, "tree-sitter-tsx.wasm"),
     symbols: [
       {
-        types: ["function_declaration", "generator_function_declaration"],
+        types: ["function_declaration", "generator_function_declaration", "function_signature"],
         label: "function",
         hasName: true
       },
@@ -2204,11 +2248,13 @@ var LANGUAGES = [
       { types: ["enum_declaration"], label: "enum", hasName: true },
       { types: ["internal_module"], label: "namespace", hasName: true },
       {
-        types: ["lexical_declaration", "variable_declaration"],
-        label: "const",
+        types: ["lexical_declaration"],
+        label: "variable",
         hasName: true,
-        maxDepth: 0
+        maxDepth: 0,
+        labelByChild: { const: "const", let: "let" }
       },
+      { types: ["variable_declaration"], label: "var", hasName: true, maxDepth: 0 },
       { types: ["import_statement"], label: "import", hasName: true }
     ],
     wrappers: [{ node: "export_statement", prefix: "export ", createStandaloneLabel: "export" }],
@@ -2222,12 +2268,25 @@ var LANGUAGES = [
         "export_specifier"
       ],
       identifierTypes: ["identifier", "type_identifier"]
+    },
+    statementDetail: {
+      sourceFields: ["source"],
+      sourceTypes: ["string"],
+      clauseTypes: [
+        "import_clause",
+        "named_imports",
+        "named_exports",
+        "export_clause",
+        "namespace_import"
+      ],
+      typeKeywordTypes: ["type"],
+      detailAsNameWhenNoSource: true
     }
   },
   {
     name: "Python",
     extensions: [".py"],
-    wasmFile: join7(process.treeSitterWasmPath, "tree-sitter-python.wasm"),
+    wasmFile: join10(process.treeSitterWasmPath, "tree-sitter-python.wasm"),
     symbols: [
       { types: ["function_definition"], label: "function", hasName: true },
       { types: ["class_definition"], label: "class", hasName: true },
@@ -2239,36 +2298,46 @@ var LANGUAGES = [
       fieldPriority: ["name", "module_name"],
       recurseTypes: [],
       identifierTypes: ["identifier"]
-    }
+    },
+    statementDetail: {
+      sourceFields: ["module_name"],
+      clauseTypes: ["dotted_name", "aliased_import", "wildcard_import"],
+      clausesAsSource: true,
+      textFallbackPattern: "^from\\s+(\\S+)\\s+import\\s+(.+)"
+    },
+    docstrings: [{ nodeType: "expression_statement", prefixes: ['"""', "'''"] }]
   },
   {
     name: "Go",
     extensions: [".go"],
-    wasmFile: join7(process.treeSitterWasmPath, "tree-sitter-go.wasm"),
+    wasmFile: join10(process.treeSitterWasmPath, "tree-sitter-go.wasm"),
     symbols: [
+      { types: ["package_clause"], label: "package", hasName: true },
       { types: ["function_declaration"], label: "function", hasName: true },
       { types: ["method_declaration"], label: "method", hasName: true },
       { types: ["type_spec"], label: "type", hasName: true },
       { types: ["field_declaration"], label: "field", hasName: true },
+      { types: ["const_spec"], label: "const", hasName: true },
       { types: ["import_declaration"], label: "import", hasName: false }
     ],
     wrappers: [],
     nameOf: {
       fieldPriority: ["name"],
       recurseTypes: [],
-      identifierTypes: ["identifier", "type_identifier", "field_identifier"]
+      identifierTypes: ["identifier", "type_identifier", "field_identifier", "package_identifier"]
     }
   },
   {
     name: "C",
     extensions: [".c", ".h"],
-    wasmFile: join7(process.treeSitterWasmPath, "tree-sitter-c.wasm"),
+    wasmFile: join10(process.treeSitterWasmPath, "tree-sitter-c.wasm"),
     symbols: [
       { types: ["function_definition"], label: "function", hasName: true },
       { types: ["struct_specifier"], label: "struct", hasName: true, maxDepth: 0 },
       { types: ["union_specifier"], label: "union", hasName: true, maxDepth: 0 },
       { types: ["enum_specifier"], label: "enum", hasName: true, maxDepth: 0 },
-      { types: ["type_definition"], label: "typedef", hasName: true }
+      { types: ["type_definition"], label: "typedef", hasName: true },
+      { types: ["declaration"], label: "var", hasName: true, maxDepth: 0 }
     ],
     wrappers: [],
     nameOf: {
@@ -2278,6 +2347,7 @@ var LANGUAGES = [
         "function_declarator",
         "array_declarator",
         "pointer_declarator",
+        "parenthesized_declarator",
         "variable_declarator"
       ],
       identifierTypes: ["identifier", "type_identifier", "field_identifier"]
@@ -2286,7 +2356,7 @@ var LANGUAGES = [
   {
     name: "C++",
     extensions: [".cpp", ".cc", ".cxx", ".hpp", ".hxx", ".hh"],
-    wasmFile: join7(process.treeSitterWasmPath, "tree-sitter-cpp.wasm"),
+    wasmFile: join10(process.treeSitterWasmPath, "tree-sitter-cpp.wasm"),
     symbols: [
       { types: ["function_definition"], label: "function", hasName: true },
       { types: ["class_specifier"], label: "class", hasName: true },
@@ -2294,6 +2364,8 @@ var LANGUAGES = [
       { types: ["union_specifier"], label: "union", hasName: true, maxDepth: 0 },
       { types: ["enum_specifier"], label: "enum", hasName: true, maxDepth: 0 },
       { types: ["type_definition"], label: "typedef", hasName: true },
+      { types: ["alias_declaration"], label: "using", hasName: true },
+      { types: ["declaration"], label: "var", hasName: true, maxDepth: 0 },
       { types: ["namespace_definition"], label: "namespace", hasName: true }
     ],
     wrappers: [],
@@ -2304,8 +2376,10 @@ var LANGUAGES = [
         "function_declarator",
         "array_declarator",
         "pointer_declarator",
+        "parenthesized_declarator",
         "reference_declarator",
-        "variable_declarator"
+        "variable_declarator",
+        "init_declarator"
       ],
       identifierTypes: ["identifier", "type_identifier", "field_identifier"],
       rawTextTypes: ["destructor_name", "operator_name"]
@@ -2314,13 +2388,21 @@ var LANGUAGES = [
   {
     name: "Swift",
     extensions: [".swift"],
-    wasmFile: join7(process.treeSitterWasmPath, "tree-sitter-swift.wasm"),
+    wasmFile: join10(process.treeSitterWasmPath, "tree-sitter-swift.wasm"),
     symbols: [
       { types: ["class_declaration"], label: "declaration", hasName: true },
       { types: ["protocol_declaration"], label: "protocol", hasName: true },
       { types: ["function_declaration"], label: "function", hasName: true },
       { types: ["method_declaration"], label: "method", hasName: true },
+      { types: ["init_declaration"], label: "init", hasName: false },
+      { types: ["subscript_declaration"], label: "subscript", hasName: false },
       { types: ["typealias_declaration"], label: "typealias", hasName: true },
+      {
+        types: ["property_declaration"],
+        label: "property",
+        hasName: true,
+        labelByChild: { let: "let", var: "var" }
+      },
       { types: ["import_declaration"], label: "import", hasName: true }
     ],
     wrappers: [],
@@ -2328,31 +2410,93 @@ var LANGUAGES = [
       fieldPriority: ["name"],
       recurseTypes: [],
       identifierTypes: ["identifier", "type_identifier"]
-    }
+    },
+    statementDetail: {}
   },
   {
     name: "Kotlin",
     extensions: [".kt", ".kts"],
-    wasmFile: join7(process.treeSitterWasmPath, "tree-sitter-kotlin.wasm"),
+    wasmFile: join10(process.treeSitterWasmPath, "tree-sitter-kotlin.wasm"),
     symbols: [
       { types: ["class_declaration"], label: "declaration", hasName: true },
       { types: ["function_declaration"], label: "function", hasName: true },
       { types: ["object_declaration"], label: "object", hasName: true },
       { types: ["type_alias"], label: "typealias", hasName: true },
+      {
+        types: ["property_declaration"],
+        label: "property",
+        hasName: true,
+        labelByChild: { val: "val", var: "var" }
+      },
       { types: ["import_header"], label: "import", hasName: true },
       { types: ["package_header"], label: "package", hasName: true }
     ],
     wrappers: [],
     nameOf: {
       fieldPriority: ["name"],
-      recurseTypes: [],
+      recurseTypes: ["variable_declaration"],
       identifierTypes: ["simple_identifier", "type_identifier"]
+    },
+    statementDetail: {
+      labels: ["import", "package"]
+    }
+  },
+  {
+    name: "Dart",
+    extensions: [".dart"],
+    wasmFile: join10(process.treeSitterWasmPath, "tree-sitter-dart.wasm"),
+    symbols: [
+      { types: ["class_definition"], label: "class", hasName: true },
+      { types: ["enum_declaration"], label: "enum", hasName: true },
+      { types: ["mixin_declaration"], label: "mixin", hasName: true },
+      { types: ["extension_declaration"], label: "extension", hasName: true },
+      { types: ["extension_type_declaration"], label: "extension type", hasName: true },
+      { types: ["function_signature"], label: "function", hasName: true, maxDepth: 0 },
+      {
+        types: ["method_signature"],
+        label: "method",
+        hasName: true,
+        labelByChild: { factory_constructor_signature: "factory" }
+      },
+      { types: ["getter_signature"], label: "getter", hasName: true },
+      { types: ["setter_signature"], label: "setter", hasName: true },
+      {
+        types: ["constructor_signature", "constant_constructor_signature"],
+        label: "constructor",
+        hasName: true
+      },
+      { types: ["type_alias"], label: "typedef", hasName: true },
+      { types: ["library_import"], label: "import", hasName: true },
+      { types: ["library_export"], label: "export", hasName: true }
+    ],
+    wrappers: [],
+    nameOf: {
+      fieldPriority: ["name"],
+      recurseTypes: [
+        "function_signature",
+        "factory_constructor_signature",
+        "getter_signature",
+        "setter_signature",
+        "library_import",
+        "library_export",
+        "import_specification",
+        "configurable_uri",
+        "uri"
+      ],
+      identifierTypes: ["identifier", "type_identifier"],
+      rawTextTypes: ["string_literal"]
+    },
+    statementDetail: {
+      labels: ["import", "export", "factory"],
+      sourceTypes: ["configurable_uri", "uri", "import_specification", "string_literal"],
+      clauseTypes: ["combinator"],
+      trimPatterns: ["\\(.*$"]
     }
   }
 ];
 async function parseInChild(filePath, config, cwd, timeout = 3e4) {
   return new Promise((resolve6, reject) => {
-    const modulePath = join7(process.scriptsPath, "/worker-file-outline/worker.mjs");
+    const modulePath = join10(process.scriptsPath, "/worker-file-outline/worker.mjs");
     const child = fork(modulePath, [], { execArgv: [], cwd });
     const timer = setTimeout(() => {
       child.kill();
@@ -2376,14 +2520,16 @@ async function parseInChild(filePath, config, cwd, timeout = 3e4) {
       wasmFile: config.wasmFile,
       symbols: config.symbols,
       wrappers: config.wrappers,
-      nameOf: config.nameOf
+      nameOf: config.nameOf,
+      statementDetail: config.statementDetail,
+      docstrings: config.docstrings
     };
     child.send(request);
   });
 }
 function parseMarkdown(content) {
   const lines = content.split("\n");
-  const totalLines = lines.length;
+  const totalLines = content.endsWith("\n") ? lines.length - 1 : lines.length;
   const symbols = [];
   let inFence = false;
   for (let i = 0; i < lines.length; i++) {
@@ -2498,9 +2644,12 @@ function outlineToSummary(outline, maxSymbols = 128) {
   for (const sym of shown) {
     const indent = "    ".repeat(sym.depth);
     const lr = sym.startLine === sym.endLine ? `line ${sym.startLine}` : `lines ${sym.startLine}-${sym.endLine}`;
-    const cmt = sym.comment ? `  // ${sym.comment}` : "";
     const namePart = sym.name ? ` ${sym.name}` : "";
-    l.push(`${indent}${sym.kind}${namePart} (${lr})${cmt}`);
+    const detailPart = sym.detail ? `: ${sym.detail}` : "";
+    if (sym.comment) {
+      l.push(`${indent}# ${sym.comment}`);
+    }
+    l.push(`${indent}${sym.kind}${namePart}${detailPart} (${lr})`);
   }
   if (outline.symbols.length > maxSymbols)
     l.push(`  ... and ${outline.symbols.length - maxSymbols} more symbols`);
@@ -2513,12 +2662,12 @@ async function fileOutline(options) {
 }
 
 // src/backend/search/ripgrep.ts
-import { join as join8, isAbsolute as isAbsolute5, resolve as resolve4, relative as relative6 } from "path";
+import { join as join11, isAbsolute as isAbsolute5, resolve as resolve4, relative as relative6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { fork as fork2 } from "child_process";
 function ripgrepInChild(args2, cwd, timeout = 3e4) {
   return new Promise((resolve6, reject) => {
-    const child = fork2(join8(process.scriptsPath, "worker-ripgrep/worker.mjs"), [], { cwd });
+    const child = fork2(join11(process.scriptsPath, "worker-ripgrep/worker.mjs"), [], { cwd });
     const timer = setTimeout(() => {
       child.kill();
       reject(new Error(`ripgrep timed out (${timeout}ms)`));
@@ -2588,20 +2737,20 @@ async function rg(options) {
 function createSearchModule(_ctx) {
   return { registerSearchRoute, buildSearchMcpServer };
 }
-function registerSearchRoute(server, projectDir2) {
+function registerSearchRoute(server, projectDir) {
   server.registry("search/search", async (payload) => {
     const params = searchRequestSchema.parse(payload);
-    const result = await search({ projectDir: projectDir2, ...params });
+    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: projectDir2, ...params });
+    const result = await rg({ projectDir, ...params });
     return rgRespondSchema.parse(result);
   });
   server.registry("search/file_outline", async (payload) => {
     const params = fileOutlineRequestSchema.parse(payload);
-    const result = await fileOutline({ projectDir: projectDir2, ...params });
+    const result = await fileOutline({ projectDir, ...params });
     return fileOutlineRespondSchema.parse(result);
   });
 }
@@ -2610,7 +2759,7 @@ function buildSearchMcpServer(options) {
     name: "search",
     command: process.execPath,
     args: [
-      join9(process.scriptsPath, "mcp-search/server.mjs"),
+      join12(process.scriptsPath, "mcp-search/server.mjs"),
       "--project-dir",
       options.projectDir,
       "--socket-path",
@@ -2622,7 +2771,7 @@ function buildSearchMcpServer(options) {
 
 // src/backend/ask-user.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { join as join10 } from "path";
+import { join as join13 } from "path";
 
 // src/shared/zod/mcp-ask-user-schema.ts
 import { z as z2 } from "zod";
@@ -2746,7 +2895,7 @@ function createAskUserModule(ctx, deps) {
       name: "ask-user",
       command: process.execPath,
       args: [
-        join10(process.scriptsPath, "mcp-ask-user/server.mjs"),
+        join13(process.scriptsPath, "mcp-ask-user/server.mjs"),
         "--project-dir",
         options.projectDir,
         "--socket-path",
@@ -2766,10 +2915,10 @@ function createAskUserModule(ctx, deps) {
 
 // src/backend/share-to-user.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { join as join11 } from "path";
+import { join as join14 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { readFile as readFile5, writeFile } from "fs/promises";
-import { existsSync as existsSync4, mkdirSync as mkdirSync4 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6 } from "fs";
 import * as mimeTypes3 from "mime-types";
 
 // src/shared/zod/mcp-share-to-user-schema.ts
@@ -2824,7 +2973,7 @@ function createShareToUserModule(ctx, deps) {
           const session = storage.getSession(sessionId);
           if (session) {
             deps.ilink.appendMediaBuffer({
-              filePath: join11(session.cwd, uri),
+              filePath: join14(session.cwd, uri),
               name,
               toUserId,
               mimeType: resolvedMimeType
@@ -2837,10 +2986,10 @@ function createShareToUserModule(ctx, deps) {
     const shareId = randomUUID3();
     const shareDir = storage.sessionShareDir(sessionId);
     if (!shareDir) throw new Error(`Session not found: ${sessionId}`);
-    const targetDir = join11(shareDir, shareId);
-    const targetPath = join11(targetDir, name);
-    if (!existsSync4(targetDir)) {
-      mkdirSync4(targetDir, { recursive: true });
+    const targetDir = join14(shareDir, shareId);
+    const targetPath = join14(targetDir, name);
+    if (!existsSync6(targetDir)) {
+      mkdirSync6(targetDir, { recursive: true });
     }
     let buffer;
     if (type === "link" && uri) {
@@ -2893,7 +3042,7 @@ function createShareToUserModule(ctx, deps) {
       name: "share-to-user",
       command: process.execPath,
       args: [
-        join11(process.scriptsPath, "mcp-share-to-user/server.mjs"),
+        join14(process.scriptsPath, "mcp-share-to-user/server.mjs"),
         "--project-dir",
         options.projectDir,
         "--socket-path",
@@ -2909,7 +3058,8 @@ function createShareToUserModule(ctx, deps) {
 import { writeFile as writeFile2, readFile as readFile6 } from "fs/promises";
 import {
   ndJsonStream as ndJsonStream2,
-  ClientSideConnection,
+  client,
+  methods as methods3,
   PROTOCOL_VERSION as PROTOCOL_VERSION2
 } from "@agentclientprotocol/sdk";
 
@@ -2919,14 +3069,18 @@ import { Writable, Readable } from "stream";
 function spawnStdioAgent(options) {
   const shouldDetach = process.platform !== "win32";
   const proc = spawn(options.command, options.args, {
-    stdio: ["pipe", "pipe", "inherit"],
-    cwd: WORKSPACE_TEMP_DIR,
+    stdio: ["pipe", "pipe", "pipe"],
+    cwd: options.cwd,
     env: { ...process.env, ...options.env },
-    detached: shouldDetach
+    detached: shouldDetach,
+    windowsHide: true,
+    shell: !shouldDetach && process.platform === "win32"
+    // Windows 上用 shell 解析命令
   });
   if (shouldDetach) {
     proc.unref();
   }
+  proc.stderr?.resume();
   let closed = false;
   async function close() {
     if (closed) {
@@ -2994,16 +3148,80 @@ function spawnStdioAgent(options) {
 }
 
 // src/backend/agent/openai-compatible-api-agent.ts
-import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
+import { agent, ndJsonStream, methods as methods2 } from "@agentclientprotocol/sdk";
 
 // src/agents/openai-compatible-agent.ts
-import { randomUUID as randomUUID5 } from "crypto";
-import { readFileSync as readFileSync4, statSync as statSync4 } from "fs";
-import { join as join12 } from "path";
+import { randomUUID as randomUUID6 } from "crypto";
+import { readFileSync as readFileSync6, statSync as statSync4 } from "fs";
+import { join as join15 } from "path";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-import { stepCountIs, streamText, generateText } from "ai";
+import {
+  isStepCount as isStepCount2,
+  streamText as streamText2,
+  generateText
+} from "ai";
 import { PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
 
+// src/agents/agent-client-proxy.ts
+import {
+  methods
+} from "@agentclientprotocol/sdk";
+var TerminalHandle = class {
+  constructor(id, sessionId, ctx) {
+    this.id = id;
+    this.sessionId = sessionId;
+    this.ctx = ctx;
+  }
+  async currentOutput() {
+    return this.ctx.request(methods.client.terminal.output, {
+      sessionId: this.sessionId,
+      terminalId: this.id
+    });
+  }
+  async waitForExit() {
+    return this.ctx.request(methods.client.terminal.waitForExit, {
+      sessionId: this.sessionId,
+      terminalId: this.id
+    });
+  }
+  async kill() {
+    return this.ctx.request(methods.client.terminal.kill, {
+      sessionId: this.sessionId,
+      terminalId: this.id
+    });
+  }
+  async release() {
+    return this.ctx.request(methods.client.terminal.release, {
+      sessionId: this.sessionId,
+      terminalId: this.id
+    });
+  }
+};
+var AgentClientProxy = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async sessionUpdate(params) {
+    await this.ctx.notify(methods.client.session.update, params);
+  }
+  async requestPermission(params) {
+    return this.ctx.request(methods.client.session.requestPermission, params);
+  }
+  async readTextFile(params) {
+    return this.ctx.request(methods.client.fs.readTextFile, params);
+  }
+  async writeTextFile(params) {
+    return this.ctx.request(methods.client.fs.writeTextFile, params);
+  }
+  async createTerminal(params) {
+    const response = await this.ctx.request(
+      methods.client.terminal.create,
+      params
+    );
+    return new TerminalHandle(response.terminalId, params.sessionId, this.ctx);
+  }
+};
+
 // src/agents/acp-client-tools.ts
 import { resolve as resolve5 } from "path";
 import { tool } from "ai";
@@ -3120,14 +3338,39 @@ function resourceLinkToFilePart(resourceLink) {
 }
 function filePartToEmbeddedResourceResource(filePart) {
   let blob;
-  if (typeof filePart.data === "string") {
-    blob = filePart.data;
-  } else if (filePart.data instanceof URL) {
-    blob = filePart.data.toString();
-  } else if (filePart.data instanceof ArrayBuffer) {
-    blob = Buffer.from(new Uint8Array(filePart.data)).toString("base64");
+  const data = filePart.data;
+  if (typeof data === "string") {
+    blob = data;
+  } else if (data instanceof URL) {
+    blob = data.toString();
+  } else if (data instanceof ArrayBuffer) {
+    blob = Buffer.from(new Uint8Array(data)).toString("base64");
+  } else if (data instanceof Uint8Array) {
+    blob = Buffer.from(data).toString("base64");
+  } else if (typeof data === "object" && data !== null && "type" in data) {
+    const tagged = data;
+    switch (tagged.type) {
+      case "data":
+        if (typeof tagged.data === "string") {
+          blob = tagged.data;
+        } else if (tagged.data instanceof Uint8Array) {
+          blob = Buffer.from(tagged.data).toString("base64");
+        } else {
+          blob = String(tagged.data ?? "");
+        }
+        break;
+      case "url":
+        blob = tagged.url?.toString() ?? "";
+        break;
+      case "text":
+        blob = tagged.text ?? "";
+        break;
+      default:
+        blob = JSON.stringify(data);
+        break;
+    }
   } else {
-    blob = Buffer.from(filePart.data).toString("base64");
+    blob = JSON.stringify(data);
   }
   return {
     resource: {
@@ -3724,7 +3967,7 @@ async function createClient(server, cwd) {
   });
 }
 async function closeClients(clients) {
-  await Promise.all(clients.map((client) => client.close().catch(() => {
+  await Promise.all(clients.map((client2) => client2.close().catch(() => {
   })));
 }
 async function createMCPSessionTools(params) {
@@ -3743,10 +3986,10 @@ async function createMCPSessionTools(params) {
     }
     const allTools = {};
     for (let i = 0; i < clients.length; i++) {
-      const client = clients[i];
+      const client2 = clients[i];
       const server = params.mcpServers[i];
       const prefix = sanitizeName(server.name || `server_${i + 1}`) || `server_${i + 1}`;
-      const [serverTools, definitions] = await Promise.all([client.tools(), client.listTools()]);
+      const [serverTools, definitions] = await Promise.all([client2.tools(), client2.listTools()]);
       const definitionsByName = new Map(definitions.tools.map((item) => [item.name, item]));
       for (const [toolName, toolDef] of Object.entries(serverTools)) {
         const qualifiedName = `mcp_${prefix}__${toolName}`;
@@ -3962,15 +4205,282 @@ 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.
+- 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.
 - 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.
 
+Memory:
+- If memory_query/memory_store tools are available, you have persistent project memory that survives across sessions.
+- Use memory_query at the start of complex or unfamiliar tasks to recall project conventions and user preferences.
+- Use memory_store when the user corrects you, states a preference, or when you discover an important project convention.
+- Keep stored facts concise (one sentence each) and actionable.
+
 Safety:
 - Do not perform destructive actions unless explicitly requested.
 - Do not fabricate results; if something fails, report the real error.`;
 
+// src/agents/subagent-tool.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import { streamText, isStepCount } from "ai";
+import { tool as tool2 } from "ai";
+import { z as z5 } from "zod";
+function createSubsessionConnectionProxy(getConnection, parentSessionId, subSessionId) {
+  return () => {
+    const real = getConnection();
+    if (!real) return null;
+    return new Proxy(real, {
+      get(target, prop, receiver) {
+        if (prop === "sessionUpdate") {
+          return async (params) => {
+            const rewritten = { ...params };
+            if (rewritten.sessionId === parentSessionId) {
+              rewritten.sessionId = subSessionId;
+            }
+            return target.sessionUpdate(rewritten);
+          };
+        }
+        if (prop === "requestPermission") {
+          return async (params) => {
+            const rewritten = { ...params };
+            if (rewritten.sessionId === parentSessionId) {
+              rewritten.sessionId = subSessionId;
+            }
+            return target.requestPermission(rewritten);
+          };
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    });
+  };
+}
+function sendSubagentStatusUpdate(connection, sessionId, subSessionId, name, prompt, status) {
+  const update = {
+    sessionUpdate: "subagent_update",
+    sessionId: subSessionId,
+    name,
+    prompt,
+    status
+  };
+  return connection.sessionUpdate({
+    sessionId,
+    update: {
+      sessionUpdate: "session_info_update",
+      _meta: {
+        fello: {
+          update
+        }
+      }
+    }
+  });
+}
+async function executeSubagent(params, subSessionId, taskName, taskPrompt, signal) {
+  const connection = params.getConnection();
+  if (!connection) {
+    throw new Error("ACP connection is not available.");
+  }
+  await sendSubagentStatusUpdate(
+    connection,
+    params.sessionId,
+    subSessionId,
+    taskName,
+    taskPrompt,
+    "in_progress"
+  );
+  const proxyGetConnection = createSubsessionConnectionProxy(
+    params.getConnection,
+    params.sessionId,
+    subSessionId
+  );
+  const subAcp = createACPClientTools({
+    cwd: params.cwd,
+    sessionId: subSessionId,
+    getConnection: proxyGetConnection,
+    permissionMemory: params.permissionMemory
+  });
+  let accumulatedText = "";
+  try {
+    const result = streamText({
+      model: params.getModel(),
+      system: params.systemPrompt,
+      prompt: taskPrompt,
+      tools: {
+        ...subAcp.tools
+      },
+      stopWhen: isStepCount(64),
+      abortSignal: signal
+    });
+    for await (const part of result.stream) {
+      const conn = params.getConnection();
+      if (!conn) continue;
+      if (part.type === "text-delta") {
+        if (!part.text) continue;
+        accumulatedText += part.text;
+        await conn.sessionUpdate({
+          sessionId: subSessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text: part.text }
+          }
+        });
+        continue;
+      }
+      if (part.type === "reasoning-delta") {
+        if (!part.text) continue;
+        await conn.sessionUpdate({
+          sessionId: subSessionId,
+          update: {
+            sessionUpdate: "agent_thought_chunk",
+            content: { type: "text", text: part.text }
+          }
+        });
+        continue;
+      }
+    }
+    const conn2 = params.getConnection();
+    if (conn2) {
+      await sendSubagentStatusUpdate(
+        conn2,
+        params.sessionId,
+        subSessionId,
+        taskName,
+        taskPrompt,
+        "completed"
+      );
+    }
+    return accumulatedText || "[No output produced]";
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const conn3 = params.getConnection();
+    if (conn3) {
+      await sendSubagentStatusUpdate(
+        conn3,
+        params.sessionId,
+        subSessionId,
+        taskName,
+        taskPrompt,
+        signal.aborted ? "completed" : "failed"
+      );
+      if (!signal.aborted) {
+        await conn3.sessionUpdate({
+          sessionId: subSessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text: `
+
+**Error:** ${errorMessage}` }
+          }
+        });
+      }
+    }
+    if (signal.aborted) {
+      return accumulatedText || "[Cancelled]";
+    }
+    return accumulatedText || `[Error: ${errorMessage}]`;
+  } finally {
+    await closeACPClientTools(subAcp);
+  }
+}
+function createSubagentTool(params) {
+  return {
+    Subagent: tool2({
+      description: `Spawn one or more independent AI sub-agents to work on tasks in parallel.
+Each sub-agent runs with its own context and has access to file read/write, edit, and shell tools.
+Use this when you need to:
+- Parallelize independent work (e.g., implement + test, research multiple topics)
+- Delegate focused sub-tasks while you coordinate the overall approach
+- Run longer operations without blocking other work
+
+Each task gets a name (short identifier) and a prompt (detailed instructions).
+Sub-agents do NOT have access to the parent conversation history \u2014 include all necessary context in the prompt.
+Results from all sub-agents are returned when they all complete.`,
+      inputSchema: z5.object({
+        purpose: z5.string().describe("Brief description of the purpose for spawning sub-agents."),
+        tasks: z5.array(
+          z5.object({
+            name: z5.string().describe("Short name for this sub-task (shown in UI)."),
+            prompt: z5.string().describe(
+              "Detailed instructions for the sub-agent. Include all context it needs since it has no access to the parent conversation history."
+            )
+          })
+        ).min(1).max(8).describe("List of tasks to execute in parallel. Min 1, max 8.")
+      }),
+      execute: async ({ purpose, tasks }, { toolCallId }) => {
+        const connection = params.getConnection();
+        if (!connection) {
+          throw new Error("ACP connection is not available.");
+        }
+        const title = `Subagent: ${purpose}`;
+        await connection.sessionUpdate({
+          sessionId: params.sessionId,
+          update: {
+            sessionUpdate: "tool_call",
+            toolCallId,
+            title,
+            kind: "other",
+            status: "in_progress",
+            rawInput: { purpose, tasks: tasks.map((t2) => ({ name: t2.name, prompt: t2.prompt })) }
+          }
+        });
+        const subagents = tasks.map((task) => ({
+          subSessionId: randomUUID5(),
+          name: task.name,
+          prompt: task.prompt
+        }));
+        await Promise.all(
+          subagents.map(
+            (sa) => sendSubagentStatusUpdate(
+              connection,
+              params.sessionId,
+              sa.subSessionId,
+              sa.name,
+              sa.prompt,
+              "pending"
+            )
+          )
+        );
+        const results = await Promise.allSettled(
+          subagents.map(
+            (sa) => executeSubagent(
+              params,
+              sa.subSessionId,
+              sa.name,
+              sa.prompt,
+              params.parentSignal ?? new AbortController().signal
+            )
+          )
+        );
+        const output = subagents.map((sa, i) => {
+          const result = results[i];
+          if (result.status === "fulfilled") {
+            return {
+              name: sa.name,
+              status: "completed",
+              result: result.value
+            };
+          }
+          return {
+            name: sa.name,
+            status: "failed",
+            result: result.reason instanceof Error ? result.reason.message : String(result.reason)
+          };
+        });
+        const allSucceeded = output.every((o) => o.status === "completed");
+        await connection.sessionUpdate({
+          sessionId: params.sessionId,
+          update: {
+            sessionUpdate: "tool_call_update",
+            toolCallId,
+            status: allSucceeded ? "completed" : "failed",
+            rawOutput: output
+          }
+        });
+        return output;
+      }
+    })
+  };
+}
+
 // src/agents/openai-compatible-agent.ts
 var MODEL_CONFIG_ID = "model";
 var DEFAULT_CONTEXT_WINDOW_TOKENS = 128e3;
@@ -3997,9 +4507,9 @@ ${workspacePrompt}
 
 ${envContext}`;
   try {
-    const agentsMdPath = join12(cwd, "AGENTS.md");
+    const agentsMdPath = join15(cwd, "AGENTS.md");
     if (statSync4(agentsMdPath).size <= 50 * 1024) {
-      const agentsMd = readFileSync4(agentsMdPath, "utf-8").trim();
+      const agentsMd = readFileSync6(agentsMdPath, "utf-8").trim();
       if (agentsMd) {
         prompt += `
 
@@ -4026,6 +4536,37 @@ function applyModelIdTemplate(template, modelItem) {
   });
 }
 var AgentDescription = "Fello/0.1.1 CodeAgent OpenaiCompatibleAgent opencode codex";
+function buildSafeUserMessage(prompt) {
+  const safeContent = prompt.map((block) => {
+    if (block.type === "text") {
+      return textContentToTextPart(block);
+    }
+    if (block.type === "image") {
+      const desc = block.uri ? `[Image: ${block.uri}]` : `[Image]`;
+      return textContentToTextPart({ text: desc });
+    }
+    if (block.type === "audio") {
+      return textContentToTextPart({ text: `[Audio]` });
+    }
+    if (block.type === "resource") {
+      const resource = block.resource;
+      if ("text" in resource) {
+        return textContentToTextPart({ text: resource.text });
+      }
+      const uri = resource.uri || "";
+      const mime = resource.mimeType || "unknown";
+      return textContentToTextPart({ text: `[Resource: ${uri} (${mime})]` });
+    }
+    if (block.type === "resource_link") {
+      return textContentToTextPart({ text: `[Resource: ${block.uri}]` });
+    }
+    return textContentToTextPart({ text: `[Unknown content]` });
+  });
+  if (safeContent.length === 0) {
+    safeContent.push({ type: "text", text: "[empty message]" });
+  }
+  return { role: "user", content: safeContent };
+}
 var AVAILABLE_COMMANDS = [
   { name: "compact", description: "Compress conversation context" }
 ];
@@ -4063,8 +4604,8 @@ var OpenaiCompatibleAgent = class {
       }
     });
   }
-  setConnection(connection) {
-    this.connection = connection;
+  setConnection(ctx) {
+    this.connection = new AgentClientProxy(ctx);
   }
   async initialize(_request) {
     return {
@@ -4204,7 +4745,7 @@ var OpenaiCompatibleAgent = class {
   }
   async newSession(params) {
     const modelState = await this.getModels();
-    const sessionId = randomUUID5();
+    const sessionId = randomUUID6();
     const modelId = modelState.currentModelId ?? modelState.availableModels[0]?.modelId ?? null;
     let sessionRef = null;
     const session = await createSessionState({
@@ -4459,29 +5000,42 @@ var OpenaiCompatibleAgent = class {
       }
     }
     const userMessage = { role: "user", content: userContent };
-    session.history.push(userMessage);
-    await this.appendSessionHistory(session.id, userMessage);
     const abortController = new AbortController();
     session.abortController = abortController;
+    let accumulatedText = "";
     try {
       if (!session.modelId) {
         throw new Error("No model available for current session.");
       }
-      const result = streamText({
+      const systemPrompt = buildWorkspaceSystemPrompt(session.cwd, session.additionalDirectories);
+      const sharedTools = {
+        ...session.mcp.tools,
+        ...session.acp.tools
+      };
+      const subagentTool = createSubagentTool({
+        sessionId: params.sessionId,
+        cwd: session.cwd,
+        getConnection: () => this.connection,
+        getModel: () => this.provider.chatModel(session.modelId),
+        systemPrompt,
+        parentSignal: abortController.signal
+      });
+      const result = streamText2({
         model: this.provider.chatModel(session.modelId),
-        system: buildWorkspaceSystemPrompt(session.cwd, session.additionalDirectories),
-        messages: session.history,
+        system: systemPrompt,
+        messages: [...session.history, userMessage],
         tools: {
-          ...session.mcp.tools,
-          ...session.acp.tools
+          ...sharedTools,
+          ...subagentTool
         },
-        stopWhen: stepCountIs(128),
+        stopWhen: isStepCount2(128),
         abortSignal: abortController.signal
       });
-      for await (const part of result.fullStream) {
+      for await (const part of result.stream) {
         if (!this.connection) continue;
         if (part.type === "text-delta") {
           if (!part.text) continue;
+          accumulatedText += part.text;
           await this.connection.sessionUpdate({
             sessionId: params.sessionId,
             update: {
@@ -4525,8 +5079,8 @@ var OpenaiCompatibleAgent = class {
         }
       }
       const response = await result.response;
-      session.history.push(...response.messages);
-      await this.appendSessionHistory(session.id, ...response.messages);
+      session.history.push(userMessage, ...response.messages);
+      await this.appendSessionHistory(session.id, userMessage, ...response.messages);
       const [turnUsage, lastStepUsage] = await Promise.all([result.totalUsage, result.usage]);
       session.contextUsedTokens = (lastStepUsage.inputTokens ?? 0) + (lastStepUsage.outputTokens ?? 0);
       const usage = {
@@ -4553,8 +5107,28 @@ var OpenaiCompatibleAgent = class {
       };
     } catch (err) {
       if (abortController.signal.aborted) {
+        const safeUserMessage2 = buildSafeUserMessage(params.prompt);
+        const historyEntries2 = [safeUserMessage2];
+        if (accumulatedText.trim()) {
+          historyEntries2.push({
+            role: "assistant",
+            content: accumulatedText + "\n\n_[Generation stopped by user \u2014 continue from user's request]_"
+          });
+        }
+        session.history.push(...historyEntries2);
+        await this.appendSessionHistory(session.id, ...historyEntries2);
         return { stopReason: "cancelled" };
       }
+      const safeUserMessage = buildSafeUserMessage(params.prompt);
+      const historyEntries = [safeUserMessage];
+      if (accumulatedText.trim()) {
+        historyEntries.push({
+          role: "assistant",
+          content: accumulatedText + "\n\n_[Generation interrupted \u2014 continue from user's request]_"
+        });
+      }
+      session.history.push(...historyEntries);
+      await this.appendSessionHistory(session.id, ...historyEntries);
       throw err;
     } finally {
       session.abortController = null;
@@ -4607,11 +5181,15 @@ function spawnOpenaiCompatibleApiAgent(options) {
   const inputStream = new TransformStream();
   const outputStream = new TransformStream();
   const stream = ndJsonStream(outputStream.writable, inputStream.readable);
-  const agent = new OpenaiCompatibleAgent(options);
-  const connection = new AgentSideConnection(() => agent, stream);
-  agent.setConnection(connection);
+  const impl = new OpenaiCompatibleAgent(options);
+  const app = agent({ name: "openai-compatible-api-agent" }).onRequest(methods2.agent.initialize, (ctx) => impl.initialize(ctx.params)).onRequest(methods2.agent.authenticate, () => impl.authenticate()).onRequest(methods2.agent.session.new, (ctx) => impl.newSession(ctx.params)).onRequest(methods2.agent.session.resume, (ctx) => impl.resumeSession(ctx.params)).onRequest(methods2.agent.session.load, (ctx) => impl.loadSession(ctx.params)).onRequest(methods2.agent.session.close, (ctx) => impl.closeSession(ctx.params)).onRequest(methods2.agent.session.delete, (ctx) => impl.deleteSession(ctx.params)).onRequest(
+    methods2.agent.session.setConfigOption,
+    (ctx) => impl.setSessionConfigOption(ctx.params)
+  ).onRequest(methods2.agent.session.prompt, (ctx) => impl.prompt(ctx.params)).onNotification(methods2.agent.session.cancel, (ctx) => impl.cancel(ctx.params));
+  const connection = app.connect(stream);
+  impl.setConnection(connection.client);
   const close = async () => {
-    await agent.abortAll();
+    await impl.abortAll();
     const writer = outputStream.writable.getWriter();
     try {
       await writer.close();
@@ -4627,8 +5205,24 @@ function spawnOpenaiCompatibleApiAgent(options) {
 }
 
 // src/backend/agent/agent-terminal-manager.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn2, execFileSync as execFileSync2 } 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"], {
+      encoding: "buffer",
+      windowsHide: true
+    });
+    const codePage = Number.parseInt(output.toString("latin1").match(/(\d+)/)?.[1] ?? "936", 10);
+    if (codePage === 65001) return "utf-8";
+    if (codePage === 936 || codePage === 54936) return "gbk";
+  } catch {
+  }
+  return "utf-8";
+}
 var AgentTerminalManager = class {
   constructor(emitOutput) {
     this.emitOutput = emitOutput;
@@ -4639,8 +5233,9 @@ var AgentTerminalManager = class {
     const proc = spawn2(command, args2, {
       cwd,
       env: { ...process.env, ...env },
-      shell: true
+      shell: true,
       // Use shell to support commands like 'npm' easily on Windows
+      windowsHide: true
     });
     const terminal = {
       id: terminalId,
@@ -4654,7 +5249,8 @@ var AgentTerminalManager = class {
       onData: () => {
       },
       onExit: () => {
-      }
+      },
+      outputDecoder: new TextDecoder(detectTerminalOutputEncoding(), { fatal: false })
     };
     const handleData = (chunk) => {
       let newBuffer = Buffer.concat([terminal.outputBuffer, chunk]);
@@ -4662,7 +5258,8 @@ var AgentTerminalManager = class {
         newBuffer = newBuffer.subarray(newBuffer.length - terminal.outputByteLimit);
       }
       terminal.outputBuffer = newBuffer;
-      this.emitOutput(sessionId, terminalId, chunk.toString("utf-8"));
+      const text = terminal.outputDecoder.decode(chunk, { stream: true });
+      this.emitOutput(sessionId, terminalId, text);
     };
     proc.stdout?.on("data", handleData);
     proc.stderr?.on("data", handleData);
@@ -4686,7 +5283,7 @@ var AgentTerminalManager = class {
       throw new Error(`Terminal ${terminalId} not found`);
     }
     return {
-      output: terminal.outputBuffer.toString("utf-8"),
+      output: terminal.outputDecoder.decode(terminal.outputBuffer),
       truncated: false
       // Simplification
     };
@@ -4739,17 +5336,22 @@ var AgentTerminalManager = class {
 };
 
 // src/backend/agent/agent-bridge.ts
+var ACP_VERBOSE_LOG = false;
 var ACPBridge = class {
   constructor(id, options) {
     this.id = id;
     this.options = options;
+    this.onSessionConnect = options.onSessionConnect;
     this.onSessionUpdate = options.onSessionUpdate;
+    this.onExtNotification = options.onExtNotification;
     this.onPermissionRequest = options.onPermissionRequest;
     this.terminalManager = new AgentTerminalManager(options.onAgentTerminalOutput);
   }
   process = null;
   connection = null;
+  onSessionConnect;
   onSessionUpdate;
+  onExtNotification;
   onPermissionRequest;
   _isConnected = false;
   _initializeInfo = null;
@@ -4843,9 +5445,8 @@ var ACPBridge = class {
     return found?.id ?? null;
   }
   async connect() {
-    const ACP_VERBOSE_LOG = false;
     const acpId = this.id;
-    const proc = this.options.agentInfo.type === "stdio" ? spawnStdioAgent(this.options.agentInfo) : 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 }) : this.options.agentInfo.provider === "openai-compatible" ? spawnOpenaiCompatibleApiAgent(this.options.agentInfo) : (() => {
       throw new Error(`Unsupported api provider: ${this.options.agentInfo.provider}`);
     })();
     this.process = proc;
@@ -4882,105 +5483,74 @@ var ACPBridge = class {
     }
     const onPermission = this.onPermissionRequest;
     const onUpdate = this.onSessionUpdate;
+    const onExtNotification = this.onExtNotification;
     const applyConfigOptions = this.applyConfigOptions.bind(this);
     const terminalManager = this.terminalManager;
     const sessionsCwdMap = this._sessionsCwdMap;
-    const client = {
-      async requestPermission(params) {
-        return onPermission(params);
-      },
-      async sessionUpdate(params) {
-        if (params.update.sessionUpdate === "config_option_update") {
-          applyConfigOptions(params.sessionId, params.update.configOptions);
-        }
-        onUpdate(params);
-      },
-      async writeTextFile(params) {
-        await writeFile2(params.path, params.content, "utf8");
-        return {};
-      },
-      async readTextFile(params) {
-        const content = await readFile6(params.path, "utf8");
-        return { content };
-      },
-      async createTerminal(params) {
-        const id = terminalManager.create(
-          params.sessionId,
-          params.command,
-          params.args || [],
-          params.cwd || sessionsCwdMap.get(params.sessionId) || WORKSPACE_TEMP_DIR,
-          params.env?.reduce((acc, envVar) => ({ ...acc, [envVar.name]: envVar.value }), {}) || {},
-          params.outputByteLimit || 1048576
-        );
-        return { terminalId: id };
-      },
-      async terminalOutput(params) {
-        const { output, truncated } = terminalManager.getOutput(params.terminalId);
-        const term = terminalManager.getTerminal(params.terminalId);
-        return {
-          output,
-          truncated,
-          ...term?.isFinished ? { exitStatus: { exitCode: term.exitCode, signal: term.signal } } : {}
-        };
-      },
-      async waitForTerminalExit(params) {
-        const { exitCode, signal } = await terminalManager.waitForExit(params.terminalId);
-        return { exitCode: exitCode ?? void 0, signal: signal ?? void 0 };
-      },
-      async killTerminal(params) {
-        terminalManager.kill(params.terminalId);
-        return {};
-      },
-      async releaseTerminal(params) {
-        terminalManager.release(params.terminalId);
-        return {};
-      },
-      async extNotification(method, params) {
-        if (ACP_VERBOSE_LOG && process.env.NODE_ENV === "development") {
-          console.log(`[ACP Ext Notification] Method: ${method}`);
-        }
-        if (typeof params === "object" && params && "sessionId" in params && typeof params.sessionId === "string") {
-          if (method === "_kiro.dev/metadata") {
-            if ("contextUsagePercentage" in params && typeof params.contextUsagePercentage === "number") {
-              onUpdate({
-                sessionId: params.sessionId,
-                update: {
-                  sessionUpdate: "usage_update",
-                  used: params.contextUsagePercentage / 100,
-                  size: 1
-                }
-              });
-            }
-            return;
-          }
-          if (method === "_kiro.dev/commands/available") {
-            if ("commands" in params && Array.isArray(params.commands)) {
-              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) : ""
-                  });
-                }
-              }
-              if (commands.length) {
-                onUpdate({
-                  sessionId: params.sessionId,
-                  update: {
-                    sessionUpdate: "available_commands_update",
-                    availableCommands: commands
-                  }
-                });
-              }
-            }
-            return;
-          }
-        }
+    const clientApp = client({ name: "Fello" }).onRequest(methods3.client.session.requestPermission, (ctx) => {
+      return onPermission(ctx.params);
+    }).onNotification(methods3.client.session.update, (ctx) => {
+      const params = ctx.params;
+      if (params.update.sessionUpdate === "config_option_update") {
+        applyConfigOptions(params.sessionId, params.update.configOptions);
+      }
+      onUpdate(params);
+    }).onRequest(methods3.client.fs.writeTextFile, async (ctx) => {
+      await writeFile2(ctx.params.path, ctx.params.content, "utf8");
+      return {};
+    }).onRequest(methods3.client.fs.readTextFile, async (ctx) => {
+      const content = await readFile6(ctx.params.path, "utf8");
+      return { content };
+    }).onRequest(methods3.client.terminal.create, (ctx) => {
+      const params = ctx.params;
+      const id = terminalManager.create(
+        params.sessionId,
+        params.command,
+        params.args || [],
+        params.cwd || sessionsCwdMap.get(params.sessionId) || process.cwd(),
+        params.env?.reduce((acc, envVar) => ({ ...acc, [envVar.name]: envVar.value }), {}) || {},
+        params.outputByteLimit || 1048576
+      );
+      return { terminalId: id };
+    }).onRequest(methods3.client.terminal.output, (ctx) => {
+      const params = ctx.params;
+      const { output, truncated } = terminalManager.getOutput(params.terminalId);
+      const term = terminalManager.getTerminal(params.terminalId);
+      return {
+        output,
+        truncated,
+        ...term?.isFinished ? { exitStatus: { exitCode: term.exitCode, signal: term.signal } } : {}
+      };
+    }).onRequest(methods3.client.terminal.waitForExit, async (ctx) => {
+      const { exitCode, signal } = await terminalManager.waitForExit(ctx.params.terminalId);
+      return { exitCode: exitCode ?? void 0, signal: signal ?? void 0 };
+    }).onRequest(methods3.client.terminal.kill, (ctx) => {
+      terminalManager.kill(ctx.params.terminalId);
+      return {};
+    }).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);
       }
-    };
-    this.connection = new ClientSideConnection((_agent) => client, stream);
-    const initResult = await this.connection.initialize({
+    );
+    this.connection = clientApp.connect(stream);
+    const initResult = await this.connection.agent.request(methods3.agent.initialize, {
       protocolVersion: PROTOCOL_VERSION2,
       clientInfo: { name: "Fello", version: "0.1.0" },
       clientCapabilities: {
@@ -5027,7 +5597,7 @@ var ACPBridge = class {
   }
   async newSession(params) {
     if (!this.connection) throw new Error("Not connected");
-    const result = await this.connection.newSession(params);
+    const result = await this.connection.agent.request(methods3.agent.session.new, params);
     const { models: configModels, modes: configModes } = result.configOptions ? this.parseSessionConfigOptions(result.configOptions) : { models: null, modes: null };
     const models = configModels ?? result.models ?? null;
     const modes = configModes ?? result.modes ?? null;
@@ -5036,10 +5606,12 @@ var ACPBridge = class {
     this.applyConfigOptions(result.sessionId, result.configOptions);
     this._loadedSessions.add(result.sessionId);
     this._sessionsCwdMap.set(result.sessionId, params.cwd);
+    this.onSessionConnect({ sessionId: result.sessionId });
     return Object.assign(result, { models, modes });
   }
   async hack_setSessionModel(params) {
-    return this.connection.connection.sendRequest("session/set_model", params);
+    if (!this.connection) throw new Error("Not connected");
+    return this.connection.agent.request("session/set_model", params);
   }
   async setSessionModel(params) {
     if (!this.connection) throw new Error("Not connected");
@@ -5047,7 +5619,7 @@ var ACPBridge = class {
     const configId = this.getConfigOptionId(params.sessionId, "model");
     if (configId) {
       try {
-        const cfg = await this.connection.setSessionConfigOption({
+        const cfg = await this.connection.agent.request(methods3.agent.session.setConfigOption, {
           sessionId: params.sessionId,
           configId,
           value: params.modelId
@@ -5072,7 +5644,7 @@ var ACPBridge = class {
   async closeSession(sessionId) {
     if (this.connection) {
       try {
-        await this.connection.closeSession({ sessionId }).catch(() => {
+        await this.connection.agent.request(methods3.agent.session.close, { sessionId }).catch(() => {
         });
       } catch {
       }
@@ -5091,7 +5663,7 @@ var ACPBridge = class {
   async deleteSession(sessionId) {
     if (!this.connection) return;
     try {
-      await this.connection.deleteSession({ sessionId });
+      await this.connection.agent.request(methods3.agent.session.delete, { sessionId });
     } catch {
     }
     this._modelStates.delete(sessionId);
@@ -5111,9 +5683,9 @@ var ACPBridge = class {
     }
     let result;
     try {
-      result = await this.connection.resumeSession(params);
+      result = await this.connection.agent.request(methods3.agent.session.resume, params);
     } catch {
-      result = await this.connection.loadSession({
+      result = await this.connection.agent.request(methods3.agent.session.load, {
         ...params,
         mcpServers: params.mcpServers ?? []
       });
@@ -5126,6 +5698,7 @@ var ACPBridge = class {
     this.applyConfigOptions(params.sessionId, result.configOptions);
     this._loadedSessions.add(params.sessionId);
     this._sessionsCwdMap.set(params.sessionId, params.cwd);
+    this.onSessionConnect({ sessionId: params.sessionId });
     return Object.assign(result, { models, modes });
   }
   async setSessionMode(params) {
@@ -5134,7 +5707,7 @@ var ACPBridge = class {
     const configId = this.getConfigOptionId(params.sessionId, "mode");
     if (configId) {
       try {
-        const cfg = await this.connection.setSessionConfigOption({
+        const cfg = await this.connection.agent.request(methods3.agent.session.setConfigOption, {
           sessionId: params.sessionId,
           configId,
           value: params.modeId
@@ -5142,10 +5715,10 @@ var ACPBridge = class {
         this.applyConfigOptions(params.sessionId, cfg.configOptions);
         result = {};
       } catch {
-        result = await this.connection.setSessionMode(params);
+        result = await this.connection.agent.request(methods3.agent.session.setMode, params);
       }
     } else {
-      result = await this.connection.setSessionMode(params);
+      result = await this.connection.agent.request(methods3.agent.session.setMode, params);
     }
     const state = this._modeStates.get(params.sessionId);
     if (state) {
@@ -5155,18 +5728,18 @@ var ACPBridge = class {
   }
   async sendPrompt(params) {
     if (!this.connection) throw new Error("Not connected");
-    return this.connection.prompt(params);
+    return this.connection.agent.request(methods3.agent.session.prompt, params);
   }
   async cancel(params) {
     if (!this.connection) return;
-    await this.connection.cancel(params);
+    await this.connection.agent.notify(methods3.agent.session.cancel, params);
   }
   async kill() {
     if (this.connection && this._isConnected) {
       const sessionIds = /* @__PURE__ */ new Set([...this._modelStates.keys(), ...this._modeStates.keys()]);
       for (const sid of sessionIds) {
         try {
-          await this.connection.closeSession({ sessionId: sid }).catch(() => {
+          await this.connection.agent.request(methods3.agent.session.close, { sessionId: sid }).catch(() => {
           });
         } catch {
         }
@@ -5193,68 +5766,155 @@ var ACPBridge = class {
 // src/backend/agent/resolve-agent-info.ts
 function resolveAgentInfo(agentId) {
   const settings = storageOps.getSettings();
-  const agent = settings.agents.find((a) => a.id === agentId);
-  if (!agent) {
+  const agent2 = settings.agents.find((a) => a.id === agentId);
+  if (!agent2) {
     throw new Error(`Unknown agent: ${agentId}. Please check your settings.`);
   }
-  if (agent.type === "stdio") {
-    const command = agent.command.trim();
-    if (!command) throw new Error(`Agent "${agent.id}" has no command configured.`);
-    return { ...agent, command };
+  if (agent2.type === "stdio") {
+    const command = agent2.command.trim();
+    if (!command) throw new Error(`Agent "${agent2.id}" has no command configured.`);
+    return { ...agent2, command };
   }
-  const provider = agent.provider.trim();
-  const baseUrl = agent.baseUrl.trim();
-  const apiKey = agent.apiKey.trim();
-  if (!provider) throw new Error(`Agent "${agent.id}" has no provider configured.`);
-  if (!baseUrl) throw new Error(`Agent "${agent.id}" has no baseUrl configured.`);
-  if (!apiKey) throw new Error(`Agent "${agent.id}" has no apiKey configured.`);
-  return { ...agent, provider, baseUrl, apiKey };
+  const provider = agent2.provider.trim();
+  const baseUrl = agent2.baseUrl.trim();
+  const apiKey = agent2.apiKey.trim();
+  if (!provider) throw new Error(`Agent "${agent2.id}" has no provider configured.`);
+  if (!baseUrl) throw new Error(`Agent "${agent2.id}" has no baseUrl configured.`);
+  if (!apiKey) throw new Error(`Agent "${agent2.id}" has no apiKey configured.`);
+  return { ...agent2, provider, baseUrl, apiKey };
 }
 
-// src/backend/bridge-pool.ts
-function createBridgePoolModule(ctx, deps) {
+// src/backend/bridge-connect.ts
+function createBridgeConnectModule(ctx, deps) {
   const { sendEvent, storage } = ctx;
-  const pool = /* @__PURE__ */ new Map();
+  const bridges = /* @__PURE__ */ new Map();
+  const sessionAgentMap = /* @__PURE__ */ new Map();
   let broadcastAndSaveSessionUpdate = () => {
   };
   function setBroadcast(fn) {
     broadcastAndSaveSessionUpdate = fn;
   }
-  async function ensureBridge(agentId) {
-    const connectPromise = pool.get(agentId);
+  async function ensureBridge(sessionKey, agentId, cwd) {
+    const connectPromise = bridges.get(sessionKey);
     if (connectPromise) {
-      const pooledBridge = await connectPromise;
-      if (pooledBridge.isConnected) return pooledBridge;
-      if (pool.get(agentId) === connectPromise) pool.delete(agentId);
-      await pooledBridge.kill();
+      const existingBridge = await connectPromise;
+      if (existingBridge.isConnected) return existingBridge;
+      if (bridges.get(sessionKey) === connectPromise) bridges.delete(sessionKey);
+      await existingBridge.kill();
     }
+    sessionAgentMap.set(sessionKey, agentId);
+    let currentSessionId = null;
     const agentInfo = resolveAgentInfo(agentId);
-    const nextBridge = new ACPBridge(agentId, {
+    const bridge = new ACPBridge(agentId, {
       agentInfo,
+      cwd,
+      onSessionConnect: (connection) => {
+        currentSessionId = `${agentId}:${connection.sessionId}`;
+        storage.updateSession(currentSessionId, { connectionStatus: "connected" }, false);
+        const updated = storage.getSession(currentSessionId);
+        if (updated) sendEvent("session-changed", { session: updated });
+      },
       onSessionUpdate: (notification) => {
-        const sessionId = `${agentId}:${notification.sessionId}`;
         const sessionUpdate = notification.update?.sessionUpdate;
-        if (sessionUpdate === "session_info_update") {
-          if (notification.update.title) {
-            storage.updateSession(sessionId, { title: notification.update.title });
-            const updated = storage.getSession(sessionId);
-            if (updated) sendEvent("session-changed", { session: updated });
+        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 === "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);
         }
-        if (sessionUpdate === "current_mode_update") {
-          const session = storage.getSession(sessionId);
-          if (session && session.modes) {
-            session.modes.currentModeId = notification.update.currentModeId ?? null;
-            storage.updateSession(sessionId, { modes: session.modes });
-            const updated = storage.getSession(sessionId);
-            if (updated) sendEvent("session-changed", { session: updated });
+      },
+      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}`) {
+            broadcastAndSaveSessionUpdate(currentSessionId, {
+              sessionId: params.sessionId,
+              update: {
+                sessionUpdate: "usage_update",
+                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) : ""
+                });
+              }
+            }
+            if (commands.length) {
+              broadcastAndSaveSessionUpdate(currentSessionId, {
+                sessionId: params.sessionId,
+                update: {
+                  sessionUpdate: "available_commands_update",
+                  availableCommands: 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
+                      }
+                    }
+                  }
+                });
+              }
+            }
           }
+          return;
         }
-        broadcastAndSaveSessionUpdate(sessionId, notification);
       },
       onPermissionRequest: async (request) => {
-        const sessionId = `${agentId}:${request.sessionId}`;
-        const session = storage.getSession(sessionId);
+        if (!currentSessionId) {
+          return {
+            outcome: { outcome: "selected", optionId: "deny" }
+          };
+        }
+        const session = storage.getSession(currentSessionId);
         if (session?.permissionMode === "allow-all") {
           const allowOption = request.options.find((o) => o.kind === "allow_always") ?? request.options.find((o) => o.kind === "allow_once") ?? request.options[0];
           return {
@@ -5262,7 +5922,7 @@ function createBridgePoolModule(ctx, deps) {
           };
         }
         const userResponse = await deps.askUser.askUser({
-          sessionId,
+          sessionId: currentSessionId,
           title: request.toolCall.title ?? t("ilink.permissionRequest"),
           description: request.toolCall.rawInput ? JSON.stringify(request.toolCall.rawInput) : "",
           allowCustomInput: false,
@@ -5305,24 +5965,70 @@ function createBridgePoolModule(ctx, deps) {
       }
     });
     let newConnectPromise;
-    newConnectPromise = nextBridge.connect().then(() => nextBridge).catch(async (error) => {
-      if (pool.get(agentId) === newConnectPromise) pool.delete(agentId);
-      await nextBridge.kill();
+    newConnectPromise = bridge.connect().then(() => bridge).catch(async (error) => {
+      if (bridges.get(sessionKey) === newConnectPromise) bridges.delete(sessionKey);
+      await bridge.kill();
       throw error;
     });
-    pool.set(agentId, newConnectPromise);
+    bridges.set(sessionKey, newConnectPromise);
+    storage.updateSession(sessionKey, { connectionStatus: "connecting" }, false);
+    const connectingSession = storage.getSession(sessionKey);
+    if (connectingSession) sendEvent("session-changed", { session: connectingSession });
     return newConnectPromise;
   }
-  async function clearPool() {
+  function rekeyBridge(oldKey, newKey) {
+    const p = bridges.get(oldKey);
+    if (p) {
+      bridges.delete(oldKey);
+      bridges.set(newKey, p);
+    }
+    const agentId = sessionAgentMap.get(oldKey);
+    if (agentId !== void 0) {
+      sessionAgentMap.delete(oldKey);
+      sessionAgentMap.set(newKey, agentId);
+    }
+  }
+  async function killBridge(sessionKey) {
+    const p = bridges.get(sessionKey);
+    if (p) {
+      bridges.delete(sessionKey);
+      sessionAgentMap.delete(sessionKey);
+      try {
+        const b = await p;
+        await b.kill();
+      } catch {
+      }
+    }
+    storage.updateSession(sessionKey, { connectionStatus: "disconnected" }, false);
+    const session = storage.getSession(sessionKey);
+    if (session) sendEvent("session-changed", { session });
+  }
+  async function killBridgesByAgent(agentId) {
+    const keysToKill = [];
+    for (const [key, aid] of sessionAgentMap) {
+      if (aid === agentId) keysToKill.push(key);
+    }
+    await Promise.all(keysToKill.map((key) => killBridge(key)));
+  }
+  async function clearAll() {
     const killPromises = [];
-    for (const p of pool.values()) {
+    for (const p of bridges.values()) {
       killPromises.push(p.then((b) => b.kill()).catch(() => {
       }));
     }
-    pool.clear();
+    bridges.clear();
+    sessionAgentMap.clear();
     await Promise.all(killPromises);
   }
-  return { pool, ensureBridge, clearPool, setBroadcast };
+  return {
+    bridges,
+    ensureBridge,
+    rekeyBridge,
+    killBridge,
+    killBridgesByAgent,
+    clearAll,
+    setBroadcast
+  };
 }
 
 // src/backend/terminal.ts
@@ -5330,7 +6036,7 @@ import { homedir as homedir4 } from "os";
 import { spawn as spawnPty } from "node-pty";
 import { createHash as createHash3 } from "crypto";
 import { chmod, stat as stat3 } from "fs/promises";
-import { dirname as dirname4, join as join13 } from "path";
+import { dirname as dirname5, join as join16 } from "path";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 function createTerminalModule(ctx, deps) {
@@ -5361,8 +6067,8 @@ function createTerminalModule(ctx, deps) {
     if (process.platform === "win32") return;
     if (isNodePtyHelperPrepared) return;
     const packageJsonPath = require2.resolve("node-pty/package.json");
-    const packageDir = dirname4(packageJsonPath);
-    const helperPath = join13(
+    const packageDir = dirname5(packageJsonPath);
+    const helperPath = join16(
       packageDir,
       "prebuilds",
       `${process.platform}-${process.arch}`,
@@ -5505,7 +6211,7 @@ function createTerminalModule(ctx, deps) {
     sessionId,
     terminalId
   }) {
-    for (const connectPromise of deps.bridgePool.values()) {
+    for (const connectPromise of deps.bridges.values()) {
       try {
         const b = await connectPromise;
         const output = b.terminalManager.getOutput(terminalId);
@@ -5549,7 +6255,7 @@ import {
   copyFile
 } from "fs/promises";
 import * as mimeTypes4 from "mime-types";
-import { dirname as dirname5, join as join14, relative as relative7, extname as extname2, basename as basename3 } from "path";
+import { dirname as dirname6, join as join17, relative as relative7, extname as extname2, basename as basename3 } from "path";
 var SEARCH_MAX_RESULTS = 10;
 var SEARCH_FUSE_THRESHOLD = 0.4;
 var SEARCH_CACHE_TTL_MS = 6e4;
@@ -5582,7 +6288,7 @@ function createFilesystemState(ctx) {
       fileScene.add(dir);
       const entries = await readdir(dir).catch(() => []);
       for (const name of entries) {
-        const full = join14(dir, name);
+        const full = join17(dir, name);
         const s = await stat4(full).catch(() => null);
         if (!s) continue;
         if (isIgnorePath(full, cwd)) continue;
@@ -5615,14 +6321,14 @@ function createFilesystemState(ctx) {
     if (!project) throw new Error("Project not found");
     const cwd = destDir || project.cwd;
     const fileName = basename3(sourcePath);
-    let destPath = join14(cwd, fileName);
+    let destPath = join17(cwd, fileName);
     let counter = 1;
     while (true) {
       const info = await stat4(destPath).catch(() => null);
       if (!info) break;
       const ext = extname2(fileName);
       const name = basename3(fileName, ext);
-      destPath = join14(cwd, `${name}(${counter})${ext}`);
+      destPath = join17(cwd, `${name}(${counter})${ext}`);
       counter++;
     }
     await copyFile(sourcePath, destPath);
@@ -5676,7 +6382,7 @@ function createFilesystemState(ctx) {
       const entries = await readdir(cwd).catch(() => []);
       const results = [];
       for (const name of entries) {
-        const full = join14(cwd, name);
+        const full = join17(cwd, name);
         if (isIgnorePath(full, cwd)) continue;
         if (fileScene.has(full)) continue;
         fileScene.add(full);
@@ -5718,7 +6424,7 @@ function createFilesystemState(ctx) {
     const entries = await readdir(startPath).catch(() => []);
     const results = [];
     for (const name of entries) {
-      const full = join14(startPath, name);
+      const full = join17(startPath, name);
       const s = await stat4(full).catch(() => null);
       if (!s) continue;
       if (isIgnorePath(full, cwd)) continue;
@@ -5742,7 +6448,7 @@ function createFilesystemState(ctx) {
     if (isFolder) {
       await mkdir(targetPath, { recursive: true });
     } else {
-      await mkdir(dirname5(targetPath), { recursive: true });
+      await mkdir(dirname6(targetPath), { recursive: true });
       await writeFile3(targetPath, "");
     }
     markProjectFsDirty(projectId);
@@ -5835,14 +6541,14 @@ function createFilesystemState(ctx) {
     const ext = extname2(fileName);
     const base = basename3(fileName, ext);
     let counter = 0;
-    let currentDest = join14(destDir, fileName);
+    let currentDest = join17(destDir, fileName);
     while (true) {
       const existing = await stat4(currentDest).catch(() => null);
       if (!existing) break;
       if (counter === 0 && existing.isDirectory())
         throw new Error("Cannot overwrite a folder with a file");
       counter++;
-      currentDest = join14(destDir, `${base}(${counter})${ext}`);
+      currentDest = join17(destDir, `${base}(${counter})${ext}`);
     }
     const buffer = Buffer.from(base64, "base64");
     await mkdir(destDir, { recursive: true });
@@ -5874,7 +6580,7 @@ function createFilesystemState(ctx) {
 
 // src/backend/project/git.ts
 import { execFile } from "child_process";
-import { dirname as dirname6, relative as relative8 } from "path";
+import { dirname as dirname7, relative as relative8 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 function createGitHandlers(ctx) {
@@ -5925,7 +6631,7 @@ function createGitHandlers(ctx) {
       const project = storage.getProject(projectId);
       if (!project) throw new Error("Project not found");
       const targetPath = resolveSafePath(project.cwd, relativePath);
-      const cwd = dirname6(targetPath);
+      const cwd = dirname7(targetPath);
       const relPath = relative8(cwd, targetPath);
       const { stdout } = await execFileAsync("git", ["show", `HEAD:./${relPath}`], {
         cwd,
@@ -5950,15 +6656,10 @@ function createProjectModule(ctx, deps) {
       fs2.markProjectFsDirty(payload.projectId);
     }
   });
-  async function ensureBridge(agentId) {
-    const p = deps.bridgePool.get(agentId);
-    if (!p) throw new Error(`No bridge for agent ${agentId}`);
-    return p;
-  }
-  async function listProjects() {
+  async function listProjects2() {
     return storage.listProjects();
   }
-  async function addProject(cwd) {
+  async function addProject2(cwd) {
     const info = storage.addProject(cwd);
     fs2.initProjectFsVersion(info.id);
     await deps.watcher.syncWatchers();
@@ -5969,49 +6670,41 @@ function createProjectModule(ctx, deps) {
     storage.updateProjectTitle(projectId, title);
     sendEvent("projects-changed", void 0);
   }
-  async function deleteProject(projectId) {
+  async function deleteProject2(projectId) {
     const projectSessions = storage.listSessions().filter((s) => s.projectId === projectId);
-    storage.deleteProject(projectId);
     for (const session of projectSessions) {
-      try {
-        const b = await ensureBridge(session.agentId);
-        if (b.isSessionLoaded(session.resumeId)) await b.closeSession(session.resumeId);
-        await b.deleteSession(session.resumeId);
-      } catch (error) {
-        console.warn(
-          `[backend] Failed to close/delete session on agent for ${session.agentId}:${session.resumeId}: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
+      await deps.session.deleteSession(session.id);
     }
+    storage.deleteProject(projectId);
     fs2.clearProjectSearchState(projectId);
     await deps.watcher.syncWatchers();
     sendEvent("projects-changed", void 0);
     sendEvent("sessions-changed", void 0);
   }
   return {
-    listProjects,
-    addProject,
+    listProjects: listProjects2,
+    addProject: addProject2,
     renameProject,
-    deleteProject,
+    deleteProject: deleteProject2,
     ...fs2,
     ...git
   };
 }
 
 // src/backend/session/index.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 
 // src/backend/socket-server.ts
 import { createServer as createServer2 } from "http";
-import { dirname as dirname7, join as join15 } from "path";
-import { mkdirSync as mkdirSync5, existsSync as existsSync5, unlinkSync } from "fs";
+import { dirname as dirname8, join as join18 } from "path";
+import { mkdirSync as mkdirSync7, existsSync as existsSync7, unlinkSync } from "fs";
 function isWindowsPipePath(p) {
   return /^\\\\.\\pipe\\/i.test(p);
 }
 async function startSocketServer(socketPath) {
   if (!isWindowsPipePath(socketPath)) {
-    mkdirSync5(dirname7(socketPath), { recursive: true });
-    if (existsSync5(socketPath)) {
+    mkdirSync7(dirname8(socketPath), { recursive: true });
+    if (existsSync7(socketPath)) {
       unlinkSync(socketPath);
     }
   }
@@ -6064,7 +6757,7 @@ async function startSocketServer(socketPath) {
           server.close();
           server.closeAllConnections();
           if (!isWindowsPipePath(socketPath)) {
-            if (existsSync5(socketPath)) {
+            if (existsSync7(socketPath)) {
               try {
                 unlinkSync(socketPath);
               } catch {
@@ -6090,13 +6783,13 @@ function generateSocketPath(key) {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\fello-${key}-${timestamp}`;
   }
-  return join15(SOCKETS_DIR, `${key}-${timestamp}.socket`);
+  return join18(SOCKETS_DIR, `${key}-${timestamp}.socket`);
 }
 
 // src/backend/ilink/ilink-bridge.ts
 import { readFile as readFile7, writeFile as writeFile4, mkdir as mkdir2, rm as rm2 } from "fs/promises";
-import { join as join16 } from "path";
-import { randomUUID as randomUUID6 } from "crypto";
+import { join as join19 } from "path";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/backend/ilink/ilink-crypto.ts
 import { createCipheriv, createDecipheriv, randomBytes as randomBytes3, createHash as createHash4 } from "crypto";
@@ -6294,10 +6987,10 @@ var ILinkClient = class {
 };
 
 // src/backend/ilink/ilink-bridge.ts
-var ILINK_DIR = join16(FELLO_DIR, "ilink");
-var CREDENTIALS_PATH = join16(ILINK_DIR, "credentials.json");
-var CURSOR_PATH = join16(ILINK_DIR, "cursor.json");
-var ACTIVE_SESSION_PATH = join16(ILINK_DIR, "active-session.json");
+var ILINK_DIR = join19(FELLO_DIR, "ilink");
+var CREDENTIALS_PATH = join19(ILINK_DIR, "credentials.json");
+var CURSOR_PATH = join19(ILINK_DIR, "cursor.json");
+var ACTIVE_SESSION_PATH = join19(ILINK_DIR, "active-session.json");
 async function ensureDir() {
   await mkdir2(ILINK_DIR, { recursive: true });
 }
@@ -6508,11 +7201,13 @@ var ILinkBridge = class _ILinkBridge {
   /**
    * Stop the bridge and disconnect.
    */
-  async stop() {
+  async stop({ logout }) {
     this.stopPollLoop();
     this.stopKeepalive();
-    await clearCredentials();
-    await clearCursor();
+    if (logout) {
+      await clearCredentials();
+      await clearCursor();
+    }
     this.client = null;
     this.creds = null;
     this.cursor = { get_updates_buf: "" };
@@ -6540,7 +7235,7 @@ var ILinkBridge = class _ILinkBridge {
         msg: {
           from_user_id: "",
           to_user_id: toUserId,
-          client_id: `fello:${Date.now()}-${randomUUID6().slice(0, 8)}`,
+          client_id: `fello:${Date.now()}-${randomUUID7().slice(0, 8)}`,
           message_type: 2,
           // BOT
           message_state: 2,
@@ -6600,7 +7295,7 @@ var ILinkBridge = class _ILinkBridge {
       msg: {
         from_user_id: "",
         to_user_id: toUserId,
-        client_id: `fello:${Date.now()}-${randomUUID6().slice(0, 8)}`,
+        client_id: `fello:${Date.now()}-${randomUUID7().slice(0, 8)}`,
         message_type: 2,
         // BOT
         message_state: 2,
@@ -6666,7 +7361,7 @@ var ILinkBridge = class _ILinkBridge {
       msg: {
         from_user_id: "",
         to_user_id: toUserId,
-        client_id: `fello:${Date.now()}-${randomUUID6().slice(0, 8)}`,
+        client_id: `fello:${Date.now()}-${randomUUID7().slice(0, 8)}`,
         message_type: 2,
         // BOT
         message_state: 2,
@@ -6885,6 +7580,9 @@ function buildMcpServersConfig(sessionMcpIds, options, ctx, deps) {
   if (socketPath && features.includes("search")) {
     servers.push(deps.search.buildSearchMcpServer({ projectDir: project.cwd, socketPath }));
   }
+  if (socketPath && features.includes("memory")) {
+    servers.push(deps.memory.buildMemoryMcpServer({ projectDir: project.cwd, socketPath }));
+  }
   const globalSettings = ctx.storage.getSettings();
   for (const id of sessionMcpIds) {
     const config = globalSettings.mcpServers?.find((s) => s.id === id);
@@ -6918,12 +7616,30 @@ function buildMcpServersConfig(sessionMcpIds, options, ctx, deps) {
 
 // src/backend/session/notifications.ts
 import { readFile as readFile8 } from "fs/promises";
-import { omit } from "es-toolkit";
-import { randomUUID as randomUUID7 } from "crypto";
-import { zContentBlock } from "@agentclientprotocol/sdk/dist/schema/zod.gen.js";
+import { omit as omit2 } from "es-toolkit";
+import { randomUUID as randomUUID8 } from "crypto";
+var CONTENT_BLOCK_TYPES = /* @__PURE__ */ new Set(["text", "image", "audio", "resource_link", "resource"]);
+function isContentBlock(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const typed = obj;
+  if (typeof typed.type !== "string" || !CONTENT_BLOCK_TYPES.has(typed.type)) return false;
+  switch (typed.type) {
+    case "text":
+      return typeof typed.text === "string";
+    case "image":
+      return typeof typed.data === "string" || typeof typed.url === "string";
+    case "audio":
+      return typeof typed.data === "string" || typeof typed.url === "string";
+    case "resource_link":
+      return typeof typed.uri === "string";
+    case "resource":
+      return typeof typed.resource === "object" && typed.resource !== null;
+    default:
+      return false;
+  }
+}
 function findContentBlock(object) {
-  const { data, success } = zContentBlock.safeParse(object);
-  if (success) return data;
+  if (isContentBlock(object)) return object;
   if (object && typeof object === "object") {
     for (const name in object) {
       if (object.hasOwnProperty(name)) {
@@ -6993,7 +7709,11 @@ function createNotificationHandler(ctx, deps) {
         ...notification.update,
         _meta: {
           ...notification.update?._meta,
-          fello: { receivedAt: Date.now(), displayId: randomUUID7() }
+          fello: {
+            ...notification.update?._meta?.fello,
+            receivedAt: Date.now(),
+            displayId: randomUUID8()
+          }
         }
       }
     };
@@ -7049,53 +7769,39 @@ function createNotificationHandler(ctx, deps) {
         }
         storage.appendSessionMessage(sessionId, {
           ...enrichedNotification,
-          update: omit(enrichedNotification.update, ["rawInput", "rawOutput"])
+          update: omit2(enrichedNotification.update, ["rawInput", "rawOutput"])
         });
         if (ilinkBridge?.isConnected && sessionId === ilinkActiveSessionId) {
           flushIlinkMedia(ilinkBridge, deps.ilink);
         }
       }
     } else {
-      storage.appendSessionMessage(sessionId, enrichedNotification);
+      if (sessionUpdate !== "available_commands_update" && sessionUpdate !== "usage_update") {
+        storage.appendSessionMessage(sessionId, enrichedNotification);
+      }
     }
     sendEvent("session-update", { sessionId, notification: enrichedNotification });
   }
   function mergeNotifications(notifications) {
     const result = [];
     for (const notification of notifications) {
+      const sessionId = notification.sessionId;
       const update = notification.update;
-      if (!update) {
-        result.push(notification);
-        continue;
-      }
       const type = update.sessionUpdate;
-      if (type === "agent_message_chunk" || type === "agent_thought_chunk") {
-        const prev = result.length > 0 ? result[result.length - 1] : void 0;
-        if (prev?.update?.sessionUpdate === type && prev.update.content?.type === "text" && update.content?.type === "text") {
-          result[result.length - 1] = {
-            ...prev,
-            update: {
-              ...prev.update,
-              content: {
-                ...prev.update.content,
-                text: prev.update.content.text + update.content.text
-              }
-            }
-          };
+      if ((type === "agent_message_chunk" || type === "agent_thought_chunk") && update.content.type === "text") {
+        const prev = result[result.length - 1];
+        if (prev && prev.sessionId === sessionId && prev.update.sessionUpdate === type && prev.update.content.type === "text") {
+          prev.update.content.text += update.content.text;
           continue;
         }
       }
-      if (type === "tool_call" || type === "tool_call_update") {
+      if (type === "tool_call_update") {
         const toolCallId = update.toolCallId;
-        const idx = result.findIndex(
-          (n) => (n.update?.sessionUpdate === "tool_call" || n.update?.sessionUpdate === "tool_call_update") && n.update.toolCallId === toolCallId
-        );
-        if (idx !== -1) {
-          const prev = result[idx];
-          result[idx] = {
-            ...prev,
-            update: { ...prev.update, ...update, sessionUpdate: "tool_call" }
-          };
+        const prev = result.find((n) => {
+          return n.sessionId === sessionId && n.update.sessionUpdate === type && n.update.toolCallId === toolCallId;
+        });
+        if (prev && prev.update.sessionUpdate === type) {
+          prev.update = { ...prev.update, ...update };
           continue;
         }
       }
@@ -7120,10 +7826,10 @@ function createNotificationHandler(ctx, deps) {
 // src/backend/session/index.ts
 function createSessionModule(ctx, deps) {
   const { sendEvent, storage } = ctx;
-  const { bridgePool, askUser, shareToUser, skills, search: search2, ilink: ilinkState } = deps;
-  const mcpDeps = { skills, askUser, shareToUser, search: search2 };
+  const { bridgeConnect, askUser, shareToUser, skills, search: search2, memory, ilink: ilinkState } = deps;
+  const mcpDeps = { skills, askUser, shareToUser, search: search2, memory };
   const notif = createNotificationHandler(ctx, { ilink: ilinkState });
-  bridgePool.setBroadcast(notif.broadcastAndSaveSessionUpdate);
+  bridgeConnect.setBroadcast(notif.broadcastAndSaveSessionUpdate);
   const sessionSocketServers = /* @__PURE__ */ new Map();
   async function createSessionSocketServer(sessionId, options) {
     const existing = sessionSocketServers.get(sessionId);
@@ -7137,6 +7843,9 @@ function createSessionModule(ctx, deps) {
     skills.registerSkillsRoute(server, options.project.cwd);
     shareToUser.registerShareToUserRoute(server, sessionId);
     search2.registerSearchRoute(server, options.project.cwd);
+    if (options.sessionContext) {
+      memory.registerMemoryRoute(server, options.project.id, options.sessionContext);
+    }
     sessionSocketServers.set(sessionId, server);
     return server;
   }
@@ -7159,8 +7868,9 @@ function createSessionModule(ctx, deps) {
   }) {
     const project = storage.getProject(projectId);
     if (!project) throw new Error("Project does not exist");
-    const b = await bridgePool.ensureBridge(agentId);
-    const socketPath = generateSocketPath(randomUUID8());
+    const tempKey = `pending:${randomUUID9()}`;
+    const b = await bridgeConnect.ensureBridge(tempKey, agentId, project.cwd);
+    const socketPath = generateSocketPath(randomUUID9());
     const sessionMcpIds = mcpServers ?? (storage.getSettings().mcpServers || []).filter((s) => !s.disabled).map((s) => s.id);
     const effectiveFeatures = features ?? ALL_FEATURES;
     const activeMcpServers = buildMcpServersConfig(
@@ -7182,7 +7892,13 @@ function createSessionModule(ctx, deps) {
       modes: modes ?? null,
       initializeInfo: b.initializeInfo
     });
-    await createSessionSocketServer(sessionInfo.id, { socketPath, project });
+    storage.updateSession(sessionInfo.id, { connectionStatus: "connected" }, false);
+    bridgeConnect.rekeyBridge(tempKey, sessionInfo.id);
+    await createSessionSocketServer(sessionInfo.id, {
+      socketPath,
+      project,
+      sessionContext: { agentId, modelId: models?.currentModelId }
+    });
     sendEvent("sessions-changed", void 0);
     return {
       sessionId: sessionInfo.id,
@@ -7191,12 +7907,26 @@ function createSessionModule(ctx, deps) {
       modes: modes ?? null
     };
   }
+  const sessionLoadPromiseMap = /* @__PURE__ */ new Map();
   async function loadSession({ sessionId, force }) {
+    const last = sessionLoadPromiseMap.get(sessionId);
+    if (last) {
+      if (force) throw new Error("Session is already loading");
+      return last;
+    }
+    const current = _loadSession({ sessionId, force });
+    sessionLoadPromiseMap.set(sessionId, current);
+    current.finally(() => {
+      sessionLoadPromiseMap.delete(sessionId);
+    });
+    return current;
+  }
+  async function _loadSession({ sessionId, force }) {
     const session = storage.getSession(sessionId);
     if (!session) throw new Error("Session does not exist");
     const project = storage.getProject(session.projectId);
     if (!project) throw new Error("Project does not exist");
-    const b = await bridgePool.ensureBridge(session.agentId);
+    const b = await bridgeConnect.ensureBridge(session.id, session.agentId, session.cwd);
     if (b.isSessionLoaded(session.resumeId) && !force) {
       return {
         sessionId: session.id,
@@ -7211,7 +7941,7 @@ function createSessionModule(ctx, deps) {
       sendEvent("session-changed", { session });
     }
     const existingSocketServer = sessionSocketServers.get(session.id);
-    const socketPath = existingSocketServer ? existingSocketServer.socketPath : generateSocketPath(randomUUID8());
+    const socketPath = existingSocketServer ? existingSocketServer.socketPath : generateSocketPath(randomUUID9());
     const activeMcpServers = buildMcpServersConfig(
       session.mcpServers,
       { project, socketPath, features: session.features },
@@ -7231,7 +7961,11 @@ function createSessionModule(ctx, deps) {
         cwd: session.cwd,
         mcpServers: activeMcpServers
       });
-      await createSessionSocketServer(session.id, { socketPath, project });
+      await createSessionSocketServer(session.id, {
+        socketPath,
+        project,
+        sessionContext: { agentId: session.agentId, modelId: session.models?.currentModelId }
+      });
     } finally {
       notif.removeRestoring(session.id);
     }
@@ -7289,7 +8023,7 @@ function createSessionModule(ctx, deps) {
       console.log(
         `[Fello] Session ${sessionId} is already streaming, cancelling previous generation...`
       );
-      const connectPromise = bridgePool.pool.get(session.agentId);
+      const connectPromise = bridgeConnect.bridges.get(sessionId);
       if (connectPromise) {
         const pending = await askUser.getPendingAskUserRequests({ sessionId });
         for (const req of pending) {
@@ -7326,10 +8060,10 @@ function createSessionModule(ctx, deps) {
         storage.updateSession(sessionId, { title: fallbackTitle });
       }
     }
-    const b = await bridgePool.ensureBridge(session.agentId);
+    const b = await bridgeConnect.ensureBridge(sessionId, session.agentId, session.cwd);
     if (!b.isSessionLoaded(session.resumeId)) {
       console.log(`[Fello] Session ${session.resumeId} not loaded in Agent, lazy loading...`);
-      const socketPath = generateSocketPath(randomUUID8());
+      const socketPath = generateSocketPath(randomUUID9());
       const activeMcpServers = buildMcpServersConfig(
         session.mcpServers,
         { project, socketPath, features: session.features },
@@ -7341,7 +8075,11 @@ function createSessionModule(ctx, deps) {
         cwd: session.cwd,
         mcpServers: activeMcpServers
       });
-      await createSessionSocketServer(session.id, { socketPath, project });
+      await createSessionSocketServer(session.id, {
+        socketPath,
+        project,
+        sessionContext: { agentId: session.agentId, modelId: session.models?.currentModelId }
+      });
     }
     storage.updateSession(sessionId, { isStreaming: true });
     const updated = storage.getSession(sessionId);
@@ -7427,7 +8165,7 @@ function createSessionModule(ctx, deps) {
         console.warn("[CancelPrompt] Respond Previous Ask User Error", err);
       }
     }
-    const connectPromise = bridgePool.pool.get(session.agentId);
+    const connectPromise = bridgeConnect.bridges.get(sessionId);
     if (connectPromise) {
       const b = await connectPromise;
       await b.cancel({ sessionId: session.resumeId });
@@ -7436,7 +8174,7 @@ function createSessionModule(ctx, deps) {
         console.log(`[CancelPrompt] Killed ${killed} agent terminal(s) for session ${sessionId}`);
     }
   }
-  async function updateSession({
+  async function updateSession2({
     sessionId,
     ...updates
   }) {
@@ -7447,18 +8185,22 @@ function createSessionModule(ctx, deps) {
   async function changeWorkDir() {
     return { ok: false, cwd: null };
   }
-  async function deleteSession(sessionId) {
+  async function deleteSession2(sessionId) {
     const session = storage.getSession(sessionId);
     if (session) {
       try {
-        const b = await bridgePool.ensureBridge(session.agentId);
-        if (b.isSessionLoaded(session.resumeId)) await b.closeSession(session.resumeId);
-        await b.deleteSession(session.resumeId);
+        const connectPromise = bridgeConnect.bridges.get(sessionId);
+        if (connectPromise) {
+          const b = await connectPromise;
+          if (b.isSessionLoaded(session.resumeId)) await b.closeSession(session.resumeId);
+          await b.deleteSession(session.resumeId);
+        }
       } catch (error) {
         console.warn(
           `[backend] Failed to close/delete session on agent for ${session.agentId}:${session.resumeId}: ${error instanceof Error ? error.message : String(error)}`
         );
       }
+      await bridgeConnect.killBridge(sessionId);
     }
     storage.deleteSession(sessionId);
     stopSessionSocketServer(sessionId);
@@ -7473,11 +8215,14 @@ function createSessionModule(ctx, deps) {
     }
     sendEvent("sessions-changed", void 0);
   }
+  function getSessionDataSystemPath({ sessionId }) {
+    return storage.getSessionDataSystemPath(sessionId);
+  }
   async function resetAgentSessions(agentId) {
     const sessions = storage.listSessions().filter((s) => s.agentId === agentId);
     for (const session of sessions) {
       try {
-        const connectPromise = bridgePool.pool.get(session.agentId);
+        const connectPromise = bridgeConnect.bridges.get(session.id);
         if (connectPromise) {
           const b = await connectPromise;
           if (b.isSessionLoaded(session.resumeId)) await b.closeSession(session.resumeId);
@@ -7487,6 +8232,7 @@ function createSessionModule(ctx, deps) {
           `[backend] Failed to close session on agent for ${session.agentId}:${session.resumeId}: ${error instanceof Error ? error.message : String(error)}`
         );
       }
+      await bridgeConnect.killBridge(session.id);
       stopSessionSocketServer(session.id);
     }
     if (sessions.length > 0) sendEvent("sessions-changed", void 0);
@@ -7497,14 +8243,18 @@ function createSessionModule(ctx, deps) {
     const ids = sessions.map((s) => s.id);
     for (const session of sessions) {
       try {
-        const b = await bridgePool.ensureBridge(session.agentId);
-        if (b.isSessionLoaded(session.resumeId)) await b.closeSession(session.resumeId);
-        await b.deleteSession(session.resumeId);
+        const connectPromise = bridgeConnect.bridges.get(session.id);
+        if (connectPromise) {
+          const b = await connectPromise;
+          if (b.isSessionLoaded(session.resumeId)) await b.closeSession(session.resumeId);
+          await b.deleteSession(session.resumeId);
+        }
       } catch (error) {
         console.warn(
           `[backend] Failed to close/delete session on agent for ${session.agentId}:${session.resumeId}: ${error instanceof Error ? error.message : String(error)}`
         );
       }
+      await bridgeConnect.killBridge(session.id);
       storage.deleteSession(session.id);
       stopSessionSocketServer(session.id);
       if (ilinkState.getActiveSessionId() === session.id) {
@@ -7523,7 +8273,7 @@ function createSessionModule(ctx, deps) {
   async function getModels({ sessionId }) {
     const session = storage.getSession(sessionId);
     if (!session) return null;
-    const connectPromise = bridgePool.pool.get(session.agentId);
+    const connectPromise = bridgeConnect.bridges.get(sessionId);
     if (!connectPromise) return null;
     const b = await connectPromise;
     return b.getModelState(session.resumeId);
@@ -7531,7 +8281,7 @@ function createSessionModule(ctx, deps) {
   async function setModel({ sessionId, modelId }) {
     const session = storage.getSession(sessionId);
     if (!session) throw new Error("Session does not exist");
-    const connectPromise = bridgePool.pool.get(session.agentId);
+    const connectPromise = bridgeConnect.bridges.get(sessionId);
     if (!connectPromise) throw new Error("Agent bridge not found for session");
     const b = await connectPromise;
     await b.setSessionModel({ sessionId: session.resumeId, modelId });
@@ -7545,7 +8295,7 @@ function createSessionModule(ctx, deps) {
   async function getModes({ sessionId }) {
     const session = storage.getSession(sessionId);
     if (!session) return null;
-    const connectPromise = bridgePool.pool.get(session.agentId);
+    const connectPromise = bridgeConnect.bridges.get(sessionId);
     if (!connectPromise) return null;
     const b = await connectPromise;
     return b.getModeState(session.resumeId);
@@ -7553,7 +8303,7 @@ function createSessionModule(ctx, deps) {
   async function setMode({ sessionId, modeId }) {
     const session = storage.getSession(sessionId);
     if (!session) throw new Error("Session does not exist");
-    const connectPromise = bridgePool.pool.get(session.agentId);
+    const connectPromise = bridgeConnect.bridges.get(sessionId);
     if (!connectPromise) throw new Error("Agent bridge not found for session");
     const b = await connectPromise;
     await b.setSessionMode({ sessionId: session.resumeId, modeId });
@@ -7572,9 +8322,10 @@ function createSessionModule(ctx, deps) {
     getSessionHistory,
     sendPrompt,
     cancelPrompt,
-    updateSession,
+    updateSession: updateSession2,
     changeWorkDir,
-    deleteSession,
+    deleteSession: deleteSession2,
+    getSessionDataSystemPath,
     resetAgentSessions,
     deleteAgentSessions,
     getModels,
@@ -7818,15 +8569,15 @@ function createIlinkModule(ctx) {
       }
       const entry = projectEntries[num - 1];
       const settings = storage.getSettings();
-      const agent = settings.agents.find((a) => !a.disabled);
-      if (!agent) {
+      const agent2 = settings.agents.find((a) => !a.disabled);
+      if (!agent2) {
         if (msg.from_user_id) bridge?.sendTextReply(msg.from_user_id, t("ilink.noAgent"));
         return;
       }
       const defaultMcpIds = (settings.mcpServers || []).filter((s) => !s.disabled).map((s) => s.id);
       getHandlers().newSession({
         projectId: entry.projectId,
-        agentId: agent.id,
+        agentId: agent2.id,
         mcpServers: defaultMcpIds,
         features: ALL_FEATURES,
         permissionMode: "allow-all"
@@ -8016,15 +8767,17 @@ function createIlinkModule(ctx) {
     const status = await b.checkQrcodeStatus(qrcode);
     return { status };
   }
-  async function stopIlink() {
+  async function stopIlink({ logout }) {
     if (bridge) {
-      await bridge.stop();
+      await bridge.stop({ logout });
       bridge = null;
     }
     activeSessionId = null;
     replyBuffer = "";
-    await writeActiveSessionId(null);
-    sendEvent("ilink-active-session-changed", { sessionId: null });
+    if (logout) {
+      await writeActiveSessionId(null);
+      sendEvent("ilink-active-session-changed", { sessionId: null });
+    }
   }
   async function setActiveIlinkSession({ sessionId }) {
     if (!sessionId) {
@@ -8078,7 +8831,7 @@ function createIlinkModule(ctx) {
 }
 
 // src/backend/inference.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 function createInferenceModule(_ctx, deps) {
   async function runInference(req) {
     const {
@@ -8087,13 +8840,17 @@ function createInferenceModule(_ctx, deps) {
       model,
       cwd = process.cwd(),
       features = [],
-      timeout = 5 * 60 * 1e3
+      timeout = 30 * 60 * 1e3
     } = req;
     const notifications = [];
     const textChunks = [];
+    const terminalLogs = {};
     const agentInfo = resolveAgentInfo(agentId);
     const bridge = new ACPBridge(agentId, {
       agentInfo,
+      cwd,
+      onSessionConnect: () => {
+      },
       onSessionUpdate: (notification) => {
         notifications.push(notification);
         if (notification.update?.sessionUpdate === "agent_message_chunk") {
@@ -8103,11 +8860,14 @@ function createInferenceModule(_ctx, deps) {
           }
         }
       },
+      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" } };
       },
-      onAgentTerminalOutput: () => {
+      onAgentTerminalOutput: (_sessionId, terminalId, data) => {
+        terminalLogs[terminalId] = (terminalLogs[terminalId] ?? "") + data;
       }
     });
     const servers = [];
@@ -8115,7 +8875,7 @@ function createInferenceModule(_ctx, deps) {
       await bridge.connect();
       const mcpServers = [...req.mcpServers ?? []];
       if (features.length > 0) {
-        const socketPath = generateSocketPath(`inf-${randomUUID9()}`);
+        const socketPath = generateSocketPath(`inf-${randomUUID10()}`);
         const socketServer = await startSocketServer(socketPath);
         servers.push(socketServer);
         if (features.includes("skills")) {
@@ -8149,7 +8909,7 @@ function createInferenceModule(_ctx, deps) {
       }
       await bridge.closeSession(sessionId);
       await bridge.deleteSession(sessionId);
-      return { text: textChunks.join(""), notifications, stopReason };
+      return { text: textChunks.join(""), notifications, terminalLogs, stopReason };
     } finally {
       await bridge.kill().catch(() => {
       });
@@ -8160,7 +8920,7 @@ function createInferenceModule(_ctx, deps) {
 }
 
 // src/backend/automation/index.ts
-import { join as join17 } from "path";
+import { join as join20 } from "path";
 import { CronJob } from "cron";
 function createAutomationModule(ctx, deps) {
   const { sendEvent, storage } = ctx;
@@ -8273,21 +9033,37 @@ function createAutomationModule(ctx, deps) {
         ...n,
         update: {
           ...n.update,
-          _meta: { ...n.update?._meta, fello: { receivedAt: Date.now(), displayId: `auto-${i}` } }
+          _meta: {
+            ...n.update?._meta,
+            fello: {
+              ...n.update?._meta?.fello,
+              receivedAt: Date.now(),
+              displayId: `auto-${i}`
+            }
+          }
         }
       }));
-      const messages = reduceNotificationsToMessages(notifications);
-      store.writeTaskFile(
-        scheduleId,
-        taskId,
-        "conversation.json",
-        JSON.stringify(messages, null, 2)
-      );
       store.writeTaskFile(
         scheduleId,
         taskId,
-        "README.md",
-        generateReadme(schedule, messages, startedAt, null, storage.getSettings().i18n?.language)
+        ".fello-conversation.json",
+        JSON.stringify(
+          {
+            __type: "fello-conversation",
+            meta: {
+              name: schedule.name,
+              agentId: schedule.agentId,
+              modelId: schedule.modelId ?? null,
+              prompt: schedule.prompt,
+              startedAt,
+              completedAt: Date.now()
+            },
+            notifications,
+            terminalLogs: result.terminalLogs
+          },
+          null,
+          2
+        )
       );
       schedule.lastRunAt = Date.now();
       schedule.updatedAt = Date.now();
@@ -8306,15 +9082,6 @@ function createAutomationModule(ctx, deps) {
       store.saveTask(scheduleId, task);
       sendEvent("task-update", { scheduleId, task });
       console.error(`[Automation] Task failed:`, errorMessage);
-      try {
-        store.writeTaskFile(
-          scheduleId,
-          taskId,
-          "README.md",
-          generateErrorReadme(schedule, [], startedAt, errorMessage, storage.getSettings().i18n?.language)
-        );
-      } catch {
-      }
       return task;
     } finally {
       runningTasks.delete(scheduleId);
@@ -8353,7 +9120,7 @@ function createAutomationModule(ctx, deps) {
   }
   function getTaskFileSystemPath(scheduleId, taskId, filePath) {
     const base = store.taskDir(scheduleId, taskId);
-    const fullPath = join17(base, filePath);
+    const fullPath = join20(base, filePath);
     if (!fullPath.startsWith(base + "/") && fullPath !== base) throw new Error("Invalid file path");
     return fullPath;
   }
@@ -8375,84 +9142,374 @@ function createAutomationModule(ctx, deps) {
     stopAllCrons
   };
 }
-function reduceNotificationsToMessages(notifications) {
-  const messages = [];
-  for (const n of notifications) {
-    const update = n.update;
-    if (!update) continue;
-    switch (update.sessionUpdate) {
-      case "user_message_chunk": {
-        const content = update.content;
-        if (!content || content.type !== "text") break;
-        const last = messages[messages.length - 1];
-        if (last && last.role === "user") last.text += content.text ?? "";
-        else messages.push({ role: "user", text: content.text ?? "" });
-        break;
-      }
-      case "agent_message_chunk": {
-        const content = update.content;
-        if (!content || content.type !== "text") break;
-        const last = messages[messages.length - 1];
-        if (last && last.role === "assistant") last.text += content.text ?? "";
-        else messages.push({ role: "assistant", text: content.text ?? "" });
-        break;
-      }
-      case "agent_thought_chunk": {
-        const content = update.content;
-        if (!content || content.type !== "text") break;
-        const last = messages[messages.length - 1];
-        if (last && last.role === "thought") last.text += content.text ?? "";
-        else messages.push({ role: "thought", text: content.text ?? "" });
-        break;
+
+// src/backend/memory.ts
+import { join as join21 } from "path";
+import { randomUUID as randomUUID11, createHash as createHash5 } from "crypto";
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync8, rmSync as rmSync4 } from "fs";
+
+// src/shared/zod/mcp-memory-schema.ts
+import { z as z6 } from "zod";
+var memoryQueryRequestSchema = z6.object({
+  query: z6.string().min(1).describe(
+    "What to search for in memory. Describe what you need to recall (e.g. 'tech stack', 'user preferences', 'build commands')."
+  )
+});
+var memoryQueryRespondSchema = z6.object({
+  content: z6.string().describe("The memory content (full or filtered).")
+});
+var memoryStoreRequestSchema = z6.object({
+  facts: z6.array(
+    z6.object({
+      text: z6.string().max(200).describe("The fact to remember, concise and self-contained."),
+      reason: z6.string().max(300).optional().describe(
+        "Why this should be remembered \u2014 context that helps determine weight and tags (e.g. 'user explicitly corrected me', 'user emphasized with \u4E00\u5B9A/never')."
+      )
+    })
+  ).min(1).max(10).describe(
+    "Facts to remember. The system will organize, deduplicate, and assign priority in the background."
+  )
+});
+var memoryStoreRespondSchema = z6.object({
+  stored: z6.number().describe("Number of facts successfully integrated."),
+  summary: z6.string().optional().describe("Brief confirmation of what was stored.")
+});
+
+// src/shared/zod/mcp-memo-schema.ts
+import { z as z7 } from "zod";
+var memoryEntrySchema = z7.object({
+  weight: z7.number().int().min(1).max(3).describe("Priority weight: 3=critical, 2=important, 1=general"),
+  text: z7.string().max(200).describe("The memory fact, concise and self-contained"),
+  date: z7.string().describe("Date when this fact was recorded or last updated (YYYY-MM-DD)"),
+  tags: z7.array(z7.string()).describe("Category tags: preferences, architecture, commands, corrections, context")
+});
+var memoryFileSchema = z7.object({
+  version: z7.number().int().describe("Schema version for future migration"),
+  entries: z7.array(memoryEntrySchema).describe("Memory entries sorted by weight descending")
+});
+var MEMORY_FILE_VERSION = 1;
+var memoGetCurrentRequestSchema = z7.object({});
+var memoGetCurrentRespondSchema = z7.object({
+  content: z7.string().describe("The current memory.json content as a JSON string.")
+});
+var memoSaveRequestSchema = z7.object({
+  content: z7.string().max(16e3).describe(
+    "The complete memory content as a JSON string. Must conform to the memory file schema: { version, entries: [...] }"
+  )
+});
+var memoSaveRespondSchema = z7.object({
+  ok: z7.boolean(),
+  entries: z7.number().describe("Number of entries saved.")
+});
+var memoTouchRequestSchema = z7.object({
+  indices: z7.array(z7.number().int().min(0)).min(1).describe(
+    "Indices of entries in the entries array that were relevant/used. Updates their date to today."
+  )
+});
+var memoTouchRespondSchema = z7.object({
+  ok: z7.boolean(),
+  touched: z7.number().describe("Number of entries touched.")
+});
+
+// src/backend/memory.ts
+var MEMORY_FILENAME = "memory.json";
+var MAX_ENTRIES = 50;
+var SUMMARY_MAX_ENTRIES = 15;
+function getProjectIdFromCwd(cwd) {
+  return createHash5("sha1").update(cwd).digest("hex");
+}
+function getMemoryPath(projectId) {
+  return join21(PROJECTS_DIR, projectId, MEMORY_FILENAME);
+}
+function readMemoryEntries(projectId) {
+  const memoryPath = getMemoryPath(projectId);
+  if (!existsSync8(memoryPath)) return [];
+  try {
+    const raw = readFileSync7(memoryPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const file = memoryFileSchema.parse(parsed);
+    return file.entries;
+  } catch {
+    return [];
+  }
+}
+function writeMemoryEntries(projectId, entries) {
+  const dir = join21(PROJECTS_DIR, projectId);
+  mkdirSync8(dir, { recursive: true });
+  const sorted = [...entries].sort((a, b) => b.weight - a.weight);
+  const capped = sorted.slice(0, MAX_ENTRIES);
+  const file = { version: MEMORY_FILE_VERSION, entries: capped };
+  writeFileSync6(getMemoryPath(projectId), JSON.stringify(file, null, 2), "utf-8");
+}
+function entriesToText(entries) {
+  return entries.map((e) => e.text).join("\n");
+}
+var WriteQueue = class {
+  queues = /* @__PURE__ */ new Map();
+  async enqueue(projectId, task) {
+    const prev = this.queues.get(projectId) ?? Promise.resolve();
+    const next = prev.then(task, task);
+    this.queues.set(projectId, next);
+    next.finally(() => {
+      if (this.queues.get(projectId) === next) {
+        this.queues.delete(projectId);
       }
-      case "tool_call":
-      case "tool_call_update": {
-        const title = update.title ?? "";
-        const content = update.content;
-        let text = "";
-        if (Array.isArray(content)) {
-          for (const block of content) {
-            if (block.type === "content") text += block.content.type ?? "";
+    });
+    return next;
+  }
+};
+function buildMemoWritePrompt(newFacts) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const factsFormatted = newFacts.map((f) => {
+    if (f.reason) return `   - "${f.text}" (reason: ${f.reason})`;
+    return `   - "${f.text}"`;
+  }).join("\n");
+  return `You are a Memory Organizer Agent. Your job is to maintain a project memory file in JSON format.
+
+## Storage Format
+
+The memory file is a JSON object with this structure:
+
+\`\`\`json
+{
+  "version": 1,
+  "entries": [
+    { "weight": 3, "text": "The fact to remember", "date": "YYYY-MM-DD", "tags": ["category"] }
+  ]
+}
+\`\`\`
+
+## Fields
+- **version**: Always 1
+- **entries**: Array sorted by weight descending. Each entry:
+  - **weight**: Priority (3=critical, 2=important, 1=general). Never use negative values in output; just remove outdated entries.
+  - **text**: Concise fact, under 100 characters when possible. Self-contained.
+  - **date**: Today's date for new/updated entries: ${today}
+  - **tags**: One or more from: preferences, architecture, commands, corrections, context
+
+## Weight Assignment
+- 3: Critical rule. User strongly emphasized (keywords: "always", "never", "remember", "\u4E00\u5B9A", "\u6C38\u8FDC\u4E0D\u8981", "\u5FC5\u987B")
+- 2: Important preference or decision
+- 1: General info (default for new facts)
+
+## Your Task
+1. Call memo_get_current() to read current memory
+2. Parse the JSON
+3. Integrate the following new facts (use the "reason" to help determine weight and tags):
+${factsFormatted}
+4. Integration rules:
+   - If a new fact contradicts an existing one: remove the old, add the new
+   - If a new fact reinforces an existing one: upgrade weight (max 3)
+   - If a new fact is a duplicate: skip it
+5. Maintenance:
+   - Remove outdated/negated entries entirely
+   - Keep total entries \u2264 50
+   - If over 50: remove lowest weight + oldest date first
+6. Call memo_save(content) with the COMPLETE JSON object as a string
+   - Must include "version": 1 and "entries" array
+   - Entries must be sorted by weight descending
+   - Output valid JSON only \u2014 no markdown fences, no explanation
+
+## Rules
+- Preserve the original language of each fact (don't translate)
+- You MUST call memo_save(content) \u2014 this is non-negotiable. The task is incomplete without it.
+- After memo_save() succeeds, reply briefly with the result (e.g. "Saved N entries."). No lengthy explanation needed.
+- The content passed to memo_save must be a valid JSON object string`;
+}
+function buildMemoQueryPrompt(query) {
+  return `You are a Memory Retrieval Agent. Your job is to find and summarize relevant memories for a given query.
+
+## Your Task
+1. Call memo_get_current() to read the current memory
+2. Find entries relevant to this query: "${query}"
+3. Call memo_touch({ indices: [...] }) with the indices of all relevant entries (to mark them as active)
+4. Summarize the relevant memories in natural language, organized and easy to understand
+5. If no entries are relevant, respond with: (no relevant memories found)
+
+## Response Style
+- Use natural language, not raw data format
+- Group related facts together
+- Highlight the most important/high-weight items first
+- Be concise but complete \u2014 don't lose information
+- Respond in the same language as the query
+
+## Rules
+- You MUST call memo_get_current() first \u2014 this is required
+- You MUST call memo_touch() with the indices of relevant entries \u2014 this keeps them from being evicted
+- Base your response ONLY on what's in the memory \u2014 do not fabricate
+- Preserve specific details (names, paths, versions) exactly as stored`;
+}
+function createMemoryModule(_ctx, deps) {
+  const writeQueue = new WriteQueue();
+  async function runMemoAgent(params) {
+    const { projectId, prompt, sessionContext, writable = false } = params;
+    const tempId = `memo-${randomUUID11()}`;
+    const tempDir = join21(TEMP_DIR, tempId);
+    mkdirSync8(tempDir, { recursive: true });
+    const memoSocketPath = generateSocketPath(`memo-${randomUUID11()}`);
+    let memoSocketServer = null;
+    try {
+      memoSocketServer = await startSocketServer(memoSocketPath);
+      memoSocketServer.registry("memo/read", async () => {
+        const entries = readMemoryEntries(projectId);
+        const file = { version: MEMORY_FILE_VERSION, entries };
+        return { content: JSON.stringify(file, null, 2) };
+      });
+      memoSocketServer.registry("memo/touch", async (payload) => {
+        const { indices } = memoTouchRequestSchema.parse(payload);
+        const entries = readMemoryEntries(projectId);
+        const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+        let touched = 0;
+        for (const idx of indices) {
+          if (idx >= 0 && idx < entries.length) {
+            entries[idx].date = today;
+            touched++;
           }
         }
-        messages.push({ role: "tool_call", text, toolTitle: title });
-        break;
+        if (touched > 0) {
+          writeMemoryEntries(projectId, entries);
+        }
+        return { ok: true, touched };
+      });
+      if (writable) {
+        memoSocketServer.registry("memo/save", async (payload) => {
+          try {
+            const { content } = memoSaveRequestSchema.parse(payload);
+            const file = memoryFileSchema.parse(JSON.parse(content));
+            writeMemoryEntries(projectId, file.entries);
+            return { ok: true, entries: file.entries.length };
+          } catch (err) {
+            console.warn("[memory] memo_save received invalid JSON:", err.message);
+            throw new Error(`Invalid memory JSON: ${err.message}`);
+          }
+        });
+      }
+      const memoMcpServer = {
+        name: "memo",
+        command: process.execPath,
+        args: [join21(process.scriptsPath, "mcp-memo/server.mjs"), "--socket-path", memoSocketPath],
+        env: [{ name: "ELECTRON_RUN_AS_NODE", value: "1" }]
+      };
+      const result = await deps.inference.runInference({
+        agentId: sessionContext.agentId,
+        prompt,
+        model: sessionContext.modelId ?? void 0,
+        cwd: tempDir,
+        mcpServers: [memoMcpServer],
+        features: []
+      });
+      if (memoSocketServer) {
+        memoSocketServer.stop();
+        memoSocketServer = null;
+      }
+      if (existsSync8(tempDir)) {
+        rmSync4(tempDir, { recursive: true, force: true });
+      }
+      return result.text || "";
+    } catch (err) {
+      console.warn("[memory] Memo agent failed", err);
+      if (memoSocketServer) {
+        memoSocketServer.stop();
+        memoSocketServer = null;
       }
+      if (existsSync8(tempDir)) {
+        rmSync4(tempDir, { recursive: true, force: true });
+      }
+      throw err;
     }
   }
-  return messages;
-}
-function renderMessages(lines, messages) {
-  for (const msg of messages) {
-    if (msg.role === "user" || msg.role === "assistant") {
-      const text = msg.text.trim();
-      if (text) lines.push(text + "\n");
+  function registerMemoryRoute(server, projectId, sessionContext) {
+    server.registry("memory/query", async (payload) => {
+      const { query } = memoryQueryRequestSchema.parse(payload);
+      const entries = readMemoryEntries(projectId);
+      if (entries.length === 0) {
+        return { content: "(no project memories stored yet)" };
+      }
+      try {
+        const result = await runMemoAgent({
+          projectId,
+          prompt: buildMemoQueryPrompt(query),
+          sessionContext,
+          writable: false
+        });
+        return { content: result || "(no relevant memories found)" };
+      } catch (err) {
+        console.warn("[memory] Memo query inference failed", err);
+        throw err;
+      }
+    });
+    server.registry("memory/store", async (payload) => {
+      const { facts } = memoryStoreRequestSchema.parse(payload);
+      await writeQueue.enqueue(projectId, async () => {
+        try {
+          await runMemoAgent({
+            projectId,
+            prompt: buildMemoWritePrompt(facts),
+            sessionContext,
+            writable: true
+          });
+        } catch (err) {
+          console.warn("[memory] Memo store inference failed", err);
+          throw err;
+        }
+      });
+      return { stored: facts.length, summary: `Stored ${facts.length} fact(s) to project memory.` };
+    });
+  }
+  function buildMemoryMcpServer(options) {
+    const projectId = getProjectIdFromCwd(options.projectDir);
+    const summary = projectId ? getMemorySummary(projectId) : "";
+    const args2 = [
+      join21(process.scriptsPath, "mcp-memory/server.mjs"),
+      "--project-dir",
+      options.projectDir,
+      "--socket-path",
+      options.socketPath
+    ];
+    if (summary) {
+      const summaryFilename = join21(TEMP_DIR, `memory-summary-${randomUUID11()}.txt`);
+      writeFileSync6(summaryFilename, summary, "utf-8");
+      args2.push("--memory-summary", summaryFilename);
     }
+    return {
+      name: "memory",
+      command: process.execPath,
+      args: args2,
+      env: [{ name: "ELECTRON_RUN_AS_NODE", value: "1" }]
+    };
   }
-}
-function generateErrorReadme(schedule, messages, startedAt, errorMessage, locale) {
-  const lines = [
-    `# ${schedule.name}`,
-    `> Run at ${new Date(startedAt).toLocaleString(locale)}`,
-    "",
-    `> \u274C Task failed: ${errorMessage}`,
-    ""
-  ];
-  renderMessages(lines, messages);
-  return lines.join("\n");
-}
-function generateReadme(schedule, messages, startedAt, modelError, locale) {
-  const lines = [
-    `# ${schedule.name}`,
-    `> Run at ${new Date(startedAt).toLocaleString(locale)}`
-  ];
-  if (modelError) {
-    lines.push("", `> \u26A0\uFE0F ${modelError}`);
-    lines.push("", `> The task continued with the agent's default model.`);
+  function getMemorySummary(projectId) {
+    const entries = readMemoryEntries(projectId);
+    if (entries.length === 0) return "";
+    const top = entries.slice(0, SUMMARY_MAX_ENTRIES);
+    return entriesToText(top);
+  }
+  function getEntries(projectId) {
+    const entries = readMemoryEntries(projectId);
+    if (entries.length === 0) {
+      const memoryPath = getMemoryPath(projectId);
+      if (!existsSync8(memoryPath)) return null;
+    }
+    return { version: MEMORY_FILE_VERSION, entries };
+  }
+  function clearMemory(projectId) {
+    const memoryPath = getMemoryPath(projectId);
+    if (existsSync8(memoryPath)) {
+      rmSync4(memoryPath);
+    }
+  }
+  function getFilePath(projectId) {
+    const memoryPath = getMemoryPath(projectId);
+    return existsSync8(memoryPath) ? memoryPath : null;
   }
-  lines.push("");
-  renderMessages(lines, messages);
-  return lines.join("\n");
+  return {
+    registerMemoryRoute,
+    buildMemoryMcpServer,
+    getMemorySummary,
+    getEntries,
+    clearMemory,
+    getFilePath
+  };
 }
 
 // src/backend/backend.ts
@@ -8475,18 +9532,20 @@ function initBackend(emitter) {
   const skills = createSkillsModule(ctx);
   const search2 = createSearchModule(ctx);
   const watcher2 = createWatcherModule(ctx);
-  const bridgePool = createBridgePoolModule(ctx, { askUser });
+  const bridgeConnect = createBridgeConnectModule(ctx, { askUser });
+  const _inference = createInferenceModule(ctx, { skills, search: search2 });
+  const memory = createMemoryModule(ctx, { inference: _inference });
   const session = createSessionModule(ctx, {
-    bridgePool,
+    bridgeConnect,
     askUser,
     shareToUser,
     skills,
     search: search2,
+    memory,
     ilink: ilink.state
   });
-  const project = createProjectModule(ctx, { bridgePool: bridgePool.pool, watcher: watcher2 });
-  const terminal = createTerminalModule(ctx, { bridgePool: bridgePool.pool });
-  const _inference = createInferenceModule(ctx, { skills, search: search2 });
+  const project = createProjectModule(ctx, { session, watcher: watcher2 });
+  const terminal = createTerminalModule(ctx, { bridges: bridgeConnect.bridges });
   ilink.setHandlers({
     sendPrompt: session.sendPrompt,
     cancelPrompt: session.cancelPrompt,
@@ -8564,12 +9623,7 @@ function initBackend(emitter) {
                 deleteOrphanedAgentSessionDirectories(agentId, knownResumeIds);
               }
             }
-            const p = bridgePool.pool.get(agentId);
-            if (p) {
-              bridgePool.pool.delete(agentId);
-              p.then((b) => b.kill()).catch(() => {
-              });
-            }
+            await bridgeConnect.killBridgesByAgent(agentId);
           }
         }
       }
@@ -8597,7 +9651,7 @@ function initBackend(emitter) {
       const projectRoot = projectId ? storageOps.getProject(projectId)?.cwd : void 0;
       const skillDir = skills.getSkillSystemPathFromId(skillId, { projectRoot });
       if (!skillDir) throw new Error(`Failed to read skill: ${skillId}`);
-      return join18(skillDir, SKILL_FILENAME);
+      return join22(skillDir, SKILL_FILENAME);
     },
     async uninstallSkill({ skillId, projectId }) {
       const projectRoot = projectId ? storageOps.getProject(projectId)?.cwd : void 0;
@@ -8652,6 +9706,9 @@ function initBackend(emitter) {
     async deleteSession(sessionId) {
       return session.deleteSession(sessionId);
     },
+    async getSessionDataSystemPath({ sessionId }) {
+      return session.getSessionDataSystemPath({ sessionId });
+    },
     async resetAgent({ agentId }) {
       await session.resetAgentSessions(agentId);
       const agentCfg = storageOps.getSettings().agents.find((a) => a.id === agentId);
@@ -8661,12 +9718,7 @@ function initBackend(emitter) {
         );
         deleteOrphanedAgentSessionDirectories(agentId, knownResumeIds);
       }
-      const p = bridgePool.pool.get(agentId);
-      if (p) {
-        bridgePool.pool.delete(agentId);
-        p.then((b) => b.kill()).catch(() => {
-        });
-      }
+      await bridgeConnect.killBridgesByAgent(agentId);
     },
     async clearAgentSessions({ agentId }) {
       const deletedSessionIds = await session.deleteAgentSessions(agentId);
@@ -8770,8 +9822,8 @@ function initBackend(emitter) {
     async pollIlinkQrcode(params) {
       return ilink.pollIlinkQrcode(params);
     },
-    async stopIlink() {
-      return ilink.stopIlink();
+    async stopIlink(params) {
+      return ilink.stopIlink(params);
     },
     async setActiveIlinkSession(params) {
       return ilink.setActiveIlinkSession(params);
@@ -8833,31 +9885,41 @@ function initBackend(emitter) {
     }) {
       const shareDir = storageOps.sessionShareDir(sessionId);
       if (!shareDir) throw new Error("Session not found");
-      return join18(shareDir, sharePath);
+      return join22(shareDir, sharePath);
     },
     async deleteTask({ scheduleId, taskId }) {
       automation.deleteTask(scheduleId, taskId);
+    },
+    // Memory
+    async getMemory({ projectId }) {
+      return memory.getEntries(projectId);
+    },
+    async clearMemory({ projectId }) {
+      memory.clearMemory(projectId);
+    },
+    async getMemorySystemFilePath({ projectId }) {
+      return memory.getFilePath(projectId);
     }
   };
   webui.setHandlers(backendHandlers2);
   async function closeBackend2() {
     automation.stopAllCrons();
     webui.stop();
-    await ilink.stopIlink();
+    await ilink.stopIlink({ logout: false });
     session.clearSession();
-    await bridgePool.clearPool();
+    await bridgeConnect.clearAll();
     await new Promise((resolve6) => setTimeout(resolve6, 100));
     terminal.killAllTerminals();
     await watcher2.stopAll();
     for (const file of await readdir2(TEMP_DIR)) {
-      await rm3(join18(TEMP_DIR, file), { recursive: true, force: true });
+      await rm3(join22(TEMP_DIR, file), { recursive: true, force: true });
     }
   }
   return { backendHandlers: backendHandlers2, closeBackend: closeBackend2 };
 }
 
 // package.json
-var version = "0.1.39";
+var version = "0.1.42";
 
 // src/server/main.ts
 var port;