@cryptiklemur/lattice 5.4.3 → 5.6.0

package/dist/server/handlers/fs.js

@@ -1,19 +1,24 @@
 import { registerHandler } from "../ws/router.js";
-import { sendTo, broadcast } from "../ws/broadcast.js";
+import { sendTo, subscribeClientToProject, broadcastToProject } from "../ws/broadcast.js";
 import { getProjectBySlug } from "../project/registry.js";
 import { listDirectory, readFile, writeFile } from "../project/file-browser.js";
-import { readdirSync, existsSync, readFileSync, statSync } from "node:fs";
+import { readdir, readFile as fsReadFile, stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { loadConfig } from "../config.js";
 var activeProjectByClient = new Map();
 export function setActiveProject(clientId, projectSlug) {
     activeProjectByClient.set(clientId, projectSlug);
+    subscribeClientToProject(clientId, projectSlug);
 }
 export function clearActiveProject(clientId) {
     activeProjectByClient.delete(clientId);
 }
-registerHandler("fs", function (clientId, message) {
+export function getActiveProjectForClient(clientId) {
+    return activeProjectByClient.get(clientId);
+}
+registerHandler("fs", async function (clientId, message) {
     if (message.type === "fs:list") {
         var listMsg = message;
         var projectSlug = activeProjectByClient.get(clientId) || listMsg.projectSlug;
@@ -30,7 +35,7 @@ registerHandler("fs", function (clientId, message) {
             sendTo(clientId, { type: "chat:error", message: "Project not found: " + projectSlug });
             return;
         }
-        var entries = listDirectory(project.path, listMsg.path);
+        var entries = await listDirectory(project.path, listMsg.path);
         sendTo(clientId, { type: "fs:list_result", path: listMsg.path, entries });
         return;
     }
@@ -50,7 +55,7 @@ registerHandler("fs", function (clientId, message) {
             sendTo(clientId, { type: "chat:error", message: "Project not found: " + projectSlugRead });
             return;
         }
-        var content = readFile(projectRead.path, readMsg.path);
+        var content = await readFile(projectRead.path, readMsg.path);
         if (content === null) {
             sendTo(clientId, { type: "chat:error", message: "Cannot read file: " + readMsg.path });
             return;
@@ -70,12 +75,12 @@ registerHandler("fs", function (clientId, message) {
             sendTo(clientId, { type: "chat:error", message: "Project not found: " + projectSlugWrite });
             return;
         }
-        var ok = writeFile(projectWrite.path, writeMsg.path, writeMsg.content);
+        var ok = await writeFile(projectWrite.path, writeMsg.path, writeMsg.content);
         if (!ok) {
             sendTo(clientId, { type: "chat:error", message: "Cannot write file: " + writeMsg.path });
             return;
         }
-        broadcast({ type: "fs:changed", path: writeMsg.path });
+        broadcastToProject(projectSlugWrite, { type: "fs:changed", path: writeMsg.path });
         return;
     }
 });
@@ -86,59 +91,49 @@ function resolvePath(path) {
         return join(homedir(), path.slice(2));
     return path;
 }
-function detectProjectName(dirPath) {
+async function detectProjectName(dirPath) {
     try {
         var pkgPath = join(dirPath, "package.json");
-        if (existsSync(pkgPath)) {
-            var pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-            if (pkg.name)
-                return pkg.name;
-        }
+        var pkg = JSON.parse(await fsReadFile(pkgPath, "utf-8"));
+        if (pkg.name)
+            return pkg.name;
     }
     catch { }
     try {
         var cargoPath = join(dirPath, "Cargo.toml");
-        if (existsSync(cargoPath)) {
-            var cargo = readFileSync(cargoPath, "utf-8");
-            var cargoMatch = cargo.match(/\[package\][\s\S]*?name\s*=\s*"([^"]+)"/);
-            if (cargoMatch)
-                return cargoMatch[1];
-        }
+        var cargo = await fsReadFile(cargoPath, "utf-8");
+        var cargoMatch = cargo.match(/\[package\][\s\S]*?name\s*=\s*"([^"]+)"/);
+        if (cargoMatch)
+            return cargoMatch[1];
     }
     catch { }
     try {
         var composerPath = join(dirPath, "composer.json");
-        if (existsSync(composerPath)) {
-            var composer = JSON.parse(readFileSync(composerPath, "utf-8"));
-            if (composer.name)
-                return composer.name;
-        }
+        var composer = JSON.parse(await fsReadFile(composerPath, "utf-8"));
+        if (composer.name)
+            return composer.name;
     }
     catch { }
     try {
         var pyprojectPath = join(dirPath, "pyproject.toml");
-        if (existsSync(pyprojectPath)) {
-            var pyproject = readFileSync(pyprojectPath, "utf-8");
-            var pyMatch = pyproject.match(/\[project\][\s\S]*?name\s*=\s*"([^"]+)"/);
-            if (pyMatch)
-                return pyMatch[1];
-        }
+        var pyproject = await fsReadFile(pyprojectPath, "utf-8");
+        var pyMatch = pyproject.match(/\[project\][\s\S]*?name\s*=\s*"([^"]+)"/);
+        if (pyMatch)
+            return pyMatch[1];
     }
     catch { }
     try {
         var goModPath = join(dirPath, "go.mod");
-        if (existsSync(goModPath)) {
-            var goMod = readFileSync(goModPath, "utf-8");
-            var goMatch = goMod.match(/^module\s+(\S+)/m);
-            if (goMatch) {
-                var parts = goMatch[1].split("/");
-                return parts[parts.length - 1];
-            }
+        var goMod = await fsReadFile(goModPath, "utf-8");
+        var goMatch = goMod.match(/^module\s+(\S+)/m);
+        if (goMatch) {
+            var parts = goMatch[1].split("/");
+            return parts[parts.length - 1];
         }
     }
     catch { }
     try {
-        var entries = readdirSync(dirPath);
+        var entries = await readdir(dirPath);
         for (var i = 0; i < entries.length; i++) {
             if (entries[i].endsWith(".sln") || entries[i].endsWith(".csproj")) {
                 return entries[i].replace(/\.[^.]+$/, "");
@@ -148,18 +143,14 @@ function detectProjectName(dirPath) {
     catch { }
     return null;
 }
-registerHandler("browse", function (clientId, message) {
+registerHandler("browse", async function (clientId, message) {
     if (message.type === "browse:list") {
         var browseMsg = message;
         var resolvedPath = resolvePath(browseMsg.path);
         var home = homedir();
-        if (!existsSync(resolvedPath)) {
-            sendTo(clientId, { type: "browse:list_result", path: resolvedPath, homedir: home, entries: [] });
-            return;
-        }
         try {
-            var stat = statSync(resolvedPath);
-            if (!stat.isDirectory()) {
+            var pathStat = await stat(resolvedPath);
+            if (!pathStat.isDirectory()) {
                 sendTo(clientId, { type: "browse:list_result", path: resolvedPath, homedir: home, entries: [] });
                 return;
             }
@@ -169,7 +160,7 @@ registerHandler("browse", function (clientId, message) {
             return;
         }
         try {
-            var dirEntries = readdirSync(resolvedPath, { withFileTypes: true });
+            var dirEntries = await readdir(resolvedPath, { withFileTypes: true });
             var results = [];
             for (var i = 0; i < dirEntries.length; i++) {
                 var entry = dirEntries[i];
@@ -177,7 +168,7 @@ registerHandler("browse", function (clientId, message) {
                     continue;
                 var entryPath = join(resolvedPath, entry.name);
                 var hasClaudeMd = existsSync(join(entryPath, "CLAUDE.md"));
-                var projectName = detectProjectName(entryPath);
+                var projectName = await detectProjectName(entryPath);
                 results.push({
                     name: entry.name,
                     path: entryPath,
@@ -198,35 +189,33 @@ registerHandler("browse", function (clientId, message) {
         var config = loadConfig();
         var existingPaths = new Set(config.projects.map(function (p) { return p.path; }));
         var suggestions = [];
-        if (existsSync(claudeProjectsDir)) {
-            try {
-                var hashDirs = readdirSync(claudeProjectsDir);
-                for (var i = 0; i < hashDirs.length; i++) {
-                    var hashDir = hashDirs[i];
-                    var candidatePath = "/" + hashDir.slice(1).replace(/-/g, "/");
-                    if (!existsSync(candidatePath))
-                        continue;
-                    if (existingPaths.has(candidatePath))
-                        continue;
-                    try {
-                        var stat = statSync(candidatePath);
-                        if (!stat.isDirectory())
-                            continue;
-                    }
-                    catch {
+        try {
+            var hashDirs = await readdir(claudeProjectsDir);
+            for (var i = 0; i < hashDirs.length; i++) {
+                var hashDir = hashDirs[i];
+                var candidatePath = "/" + hashDir.slice(1).replace(/-/g, "/");
+                if (!existsSync(candidatePath))
+                    continue;
+                if (existingPaths.has(candidatePath))
+                    continue;
+                try {
+                    var candidateStat = await stat(candidatePath);
+                    if (!candidateStat.isDirectory())
                         continue;
-                    }
-                    var hasClaudeMd = existsSync(join(candidatePath, "CLAUDE.md"));
-                    var name = candidatePath.split("/").pop() || hashDir;
-                    suggestions.push({
-                        path: candidatePath,
-                        name: name,
-                        hasClaudeMd: hasClaudeMd,
-                    });
                 }
+                catch {
+                    continue;
+                }
+                var hasClaudeMd = existsSync(join(candidatePath, "CLAUDE.md"));
+                var name = candidatePath.split("/").pop() || hashDir;
+                suggestions.push({
+                    path: candidatePath,
+                    name: name,
+                    hasClaudeMd: hasClaudeMd,
+                });
             }
-            catch { }
         }
+        catch { }
         suggestions.sort(function (a, b) { return a.name.localeCompare(b.name); });
         sendTo(clientId, { type: "browse:suggestions_result", suggestions: suggestions });
         return;

package/dist/server/handlers/memory.js

@@ -1,4 +1,5 @@
-import { existsSync, readFileSync, writeFileSync, readdirSync, unlinkSync, mkdirSync } from "node:fs";
+import { readdir, readFile, writeFile, unlink, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { registerHandler } from "../ws/router.js";
@@ -38,16 +39,16 @@ function parseFrontmatter(content) {
     }
     return { name, description, type };
 }
-function regenerateIndex(memoryDir) {
+async function regenerateIndex(memoryDir) {
     if (!existsSync(memoryDir))
         return;
-    var files = readdirSync(memoryDir).filter(function (f) {
+    var files = (await readdir(memoryDir)).filter(function (f) {
         return f.endsWith(".md") && f !== "MEMORY.md";
     });
     var grouped = {};
     for (var i = 0; i < files.length; i++) {
         try {
-            var content = readFileSync(join(memoryDir, files[i]), "utf-8");
+            var content = await readFile(join(memoryDir, files[i]), "utf-8");
             var meta = parseFrontmatter(content);
             var type = meta.type || "other";
             if (!grouped[type])
@@ -67,9 +68,30 @@ function regenerateIndex(memoryDir) {
         }
         lines.push("");
     }
-    writeFileSync(join(memoryDir, "MEMORY.md"), lines.join("\n"), "utf-8");
+    await writeFile(join(memoryDir, "MEMORY.md"), lines.join("\n"), "utf-8");
 }
-registerHandler("memory", function (clientId, message) {
+async function listMemoryFiles(memDir) {
+    var files = (await readdir(memDir)).filter(function (f) {
+        return f.endsWith(".md") && f !== "MEMORY.md";
+    });
+    var memories = [];
+    for (var i = 0; i < files.length; i++) {
+        try {
+            var content = await readFile(join(memDir, files[i]), "utf-8");
+            var meta = parseFrontmatter(content);
+            memories.push({
+                filename: files[i],
+                name: meta.name || files[i].replace(/\.md$/, ""),
+                description: meta.description,
+                type: meta.type || "other",
+            });
+        }
+        catch { }
+    }
+    memories.sort(function (a, b) { return a.name.localeCompare(b.name); });
+    return memories;
+}
+registerHandler("memory", async function (clientId, message) {
     if (message.type === "memory:list") {
         var listMsg = message;
         var memDir = getMemoryDir(listMsg.projectSlug);
@@ -77,24 +99,7 @@ registerHandler("memory", function (clientId, message) {
             sendTo(clientId, { type: "memory:list_result", projectSlug: listMsg.projectSlug, memories: [] });
             return;
         }
-        var files = readdirSync(memDir).filter(function (f) {
-            return f.endsWith(".md") && f !== "MEMORY.md";
-        });
-        var memories = [];
-        for (var i = 0; i < files.length; i++) {
-            try {
-                var content = readFileSync(join(memDir, files[i]), "utf-8");
-                var meta = parseFrontmatter(content);
-                memories.push({
-                    filename: files[i],
-                    name: meta.name || files[i].replace(/\.md$/, ""),
-                    description: meta.description,
-                    type: meta.type || "other",
-                });
-            }
-            catch { }
-        }
-        memories.sort(function (a, b) { return a.name.localeCompare(b.name); });
+        var memories = await listMemoryFiles(memDir);
         sendTo(clientId, { type: "memory:list_result", projectSlug: listMsg.projectSlug, memories: memories });
         return;
     }
@@ -106,7 +111,7 @@ registerHandler("memory", function (clientId, message) {
             return;
         }
         try {
-            var viewContent = readFileSync(join(viewDir, viewMsg.filename), "utf-8");
+            var viewContent = await readFile(join(viewDir, viewMsg.filename), "utf-8");
             sendTo(clientId, { type: "memory:view_result", filename: viewMsg.filename, content: viewContent });
         }
         catch {
@@ -122,21 +127,11 @@ registerHandler("memory", function (clientId, message) {
             return;
         }
         try {
-            mkdirSync(saveDir, { recursive: true });
-            writeFileSync(join(saveDir, saveMsg.filename), saveMsg.content, "utf-8");
-            regenerateIndex(saveDir);
+            await mkdir(saveDir, { recursive: true });
+            await writeFile(join(saveDir, saveMsg.filename), saveMsg.content, "utf-8");
+            await regenerateIndex(saveDir);
             sendTo(clientId, { type: "memory:save_result", success: true });
-            var updatedFiles = readdirSync(saveDir).filter(function (f) { return f.endsWith(".md") && f !== "MEMORY.md"; });
-            var updatedMemories = [];
-            for (var j = 0; j < updatedFiles.length; j++) {
-                try {
-                    var c = readFileSync(join(saveDir, updatedFiles[j]), "utf-8");
-                    var m = parseFrontmatter(c);
-                    updatedMemories.push({ filename: updatedFiles[j], name: m.name || updatedFiles[j].replace(/\.md$/, ""), description: m.description, type: m.type || "other" });
-                }
-                catch { }
-            }
-            updatedMemories.sort(function (a, b) { return a.name.localeCompare(b.name); });
+            var updatedMemories = await listMemoryFiles(saveDir);
             sendTo(clientId, { type: "memory:list_result", projectSlug: saveMsg.projectSlug, memories: updatedMemories });
         }
         catch (err) {
@@ -157,20 +152,10 @@ registerHandler("memory", function (clientId, message) {
                 sendTo(clientId, { type: "memory:delete_result", success: false, message: "Memory not found." });
                 return;
             }
-            unlinkSync(filePath);
-            regenerateIndex(delDir);
+            await unlink(filePath);
+            await regenerateIndex(delDir);
             sendTo(clientId, { type: "memory:delete_result", success: true });
-            var remainingFiles = readdirSync(delDir).filter(function (f) { return f.endsWith(".md") && f !== "MEMORY.md"; });
-            var remainingMemories = [];
-            for (var k = 0; k < remainingFiles.length; k++) {
-                try {
-                    var rc = readFileSync(join(delDir, remainingFiles[k]), "utf-8");
-                    var rm = parseFrontmatter(rc);
-                    remainingMemories.push({ filename: remainingFiles[k], name: rm.name || remainingFiles[k].replace(/\.md$/, ""), description: rm.description, type: rm.type || "other" });
-                }
-                catch { }
-            }
-            remainingMemories.sort(function (a, b) { return a.name.localeCompare(b.name); });
+            var remainingMemories = await listMemoryFiles(delDir);
             sendTo(clientId, { type: "memory:list_result", projectSlug: delMsg.projectSlug, memories: remainingMemories });
         }
         catch (err) {

package/dist/server/handlers/mesh.js

@@ -6,7 +6,7 @@ import { loadConfig } from "../config.js";
 import { loadOrCreateIdentity } from "../identity.js";
 import { generateInviteCode, parseInviteCode, validatePairingToken, consumePairingToken } from "../mesh/pairing.js";
 import { addPeer, removePeer, loadPeers, getPeer } from "../mesh/peers.js";
-import { getConnectedPeerIds, connectToPeer, reconnectPeer, getPeerConnection, disconnectPeer, getConnectedPeerProjects, registerInboundPeer } from "../mesh/connector.js";
+import { getConnectedPeerIds, connectToPeer, reconnectPeer, getPeerConnection, disconnectPeer, getConnectedPeerProjects, registerInboundPeer, getPeerHealth } from "../mesh/connector.js";
 import { getClientWebSocket, registerVirtualClient, removeVirtualClient } from "../ws/broadcast.js";
 import { networkInterfaces } from "node:os";
 import { existsSync, readFileSync } from "node:fs";
@@ -97,6 +97,7 @@ export function buildNodesMessage() {
     };
     var remotes = peers.map(function (peer) {
         var peerProjects = getConnectedPeerProjects(peer.id);
+        var health = getPeerHealth(peer.id);
         return {
             id: peer.id,
             name: peer.name,
@@ -108,6 +109,8 @@ export function buildNodesMessage() {
             projects: peerProjects.map(function (p) {
                 return { slug: p.slug, path: "", title: p.title, nodeId: peer.id };
             }),
+            latencyMs: health?.latencyMs,
+            healthy: health?.healthy,
         };
     });
     return [local, ...remotes];

package/dist/server/handlers/session.js

@@ -1,13 +1,13 @@
 import { registerHandler } from "../ws/router.js";
-import { sendTo } from "../ws/broadcast.js";
+import { sendTo, broadcastToProject } from "../ws/broadcast.js";
 import { loadConfig } from "../config.js";
-import { createSession, deleteSession, findProjectSlugForSession, getSessionPreview, getSessionTitle, getSessionUsage, listSessions, invalidateSessionCache, invalidateHistoryCache, getSessionHistoryPage, loadSessionHistory, renameSession, getSessionFileSizeBytes, } from "../project/session.js";
+import { createSession, deleteSession, findProjectSlugForSession, getSessionPreview, getSessionTitle, getSessionUsage, listSessions, invalidateSessionCache, invalidateHistoryCache, getSessionHistoryPage, loadSessionHistory, renameSession, getSessionFileSizeBytes, updateSessionInIndex, removeSessionFromIndex, } from "../project/session.js";
 import { getContextBreakdown } from "../project/context-breakdown.js";
 import { setActiveSession, getActiveSession } from "./chat.js";
 import { setActiveProject } from "./fs.js";
 import { wasSessionInterrupted, clearInterruptedFlag } from "../project/sdk-bridge.js";
 import { log } from "../logger.js";
-registerHandler("session", function (clientId, message) {
+registerHandler("session", async function (clientId, message) {
     if (message.type === "session:list_request") {
         var listReqMsg = message;
         var offset = listReqMsg.offset || 0;
@@ -71,7 +71,15 @@ registerHandler("session", function (clientId, message) {
     if (message.type === "session:create") {
         var createMsg = message;
         var session = createSession(createMsg.projectSlug);
+        updateSessionInIndex(createMsg.projectSlug, session);
         sendTo(clientId, { type: "session:created", session });
+        broadcastToProject(createMsg.projectSlug, {
+            type: "session:list",
+            projectSlug: createMsg.projectSlug,
+            sessions: [session],
+            totalCount: undefined,
+            offset: 0,
+        });
         return;
     }
     if (message.type === "session:activate") {
@@ -79,12 +87,20 @@ registerHandler("session", function (clientId, message) {
         setActiveSession(clientId, activateMsg.projectSlug, activateMsg.sessionId);
         setActiveProject(clientId, activateMsg.projectSlug);
         invalidateHistoryCache(activateMsg.sessionId);
-        var fileSize = getSessionFileSizeBytes(activateMsg.projectSlug, activateMsg.sessionId);
+        var fileSize = await getSessionFileSizeBytes(activateMsg.projectSlug, activateMsg.sessionId);
         sendTo(clientId, { type: "session:loading_progress", sessionId: activateMsg.sessionId, fileSize });
         var activateT0 = Date.now();
-        void loadSessionHistory(activateMsg.projectSlug, activateMsg.sessionId).then(function (historyResult) {
-            log.session("session:activate history: %dms", Date.now() - activateT0);
-            var title = null;
+        void Promise.all([
+            loadSessionHistory(activateMsg.projectSlug, activateMsg.sessionId),
+            getSessionTitle(activateMsg.projectSlug, activateMsg.sessionId).catch(function () { return null; }),
+            getSessionUsage(activateMsg.projectSlug, activateMsg.sessionId).catch(function () { return null; }),
+            getContextBreakdown(activateMsg.projectSlug, activateMsg.sessionId).catch(function () { return null; }),
+        ]).then(function (results) {
+            var historyResult = results[0];
+            var sessionTitle = results[1];
+            var usage = results[2];
+            var breakdown = results[3];
+            log.session("session:activate: %dms", Date.now() - activateT0);
             var interrupted = wasSessionInterrupted(activateMsg.sessionId);
             if (interrupted) {
                 clearInterruptedFlag(activateMsg.sessionId);
@@ -94,60 +110,33 @@ registerHandler("session", function (clientId, message) {
                 projectSlug: activateMsg.projectSlug,
                 sessionId: activateMsg.sessionId,
                 messages: historyResult.messages,
-                title: title,
+                title: sessionTitle,
                 interrupted: interrupted || undefined,
                 totalMessages: historyResult.totalMessages,
                 hasMore: historyResult.hasMore,
             });
+            if (usage) {
+                sendTo(clientId, {
+                    type: "chat:context_usage",
+                    inputTokens: usage.inputTokens,
+                    outputTokens: usage.outputTokens,
+                    cacheReadTokens: usage.cacheReadTokens,
+                    cacheCreationTokens: usage.cacheCreationTokens,
+                    contextWindow: usage.contextWindow,
+                });
+            }
+            if (breakdown) {
+                sendTo(clientId, {
+                    type: "chat:context_breakdown",
+                    segments: breakdown.segments,
+                    contextWindow: breakdown.contextWindow,
+                    autocompactAt: breakdown.autocompactAt,
+                });
+            }
         }).catch(function (err) {
-            log.session("Error sending session history: %O", err);
-            sendTo(clientId, { type: "chat:error", message: "Failed to load session history" });
+            log.session("Failed to activate session: %O", err);
+            sendTo(clientId, { type: "chat:error", message: "Failed to load session" });
         });
-        setTimeout(function () {
-            void getSessionTitle(activateMsg.projectSlug, activateMsg.sessionId).then(function (sessionTitle) {
-                if (sessionTitle) {
-                    sendTo(clientId, { type: "session:history", projectSlug: activateMsg.projectSlug, sessionId: activateMsg.sessionId, messages: [], title: sessionTitle });
-                }
-            }).catch(function () { });
-            void Promise.all([
-                getSessionUsage(activateMsg.projectSlug, activateMsg.sessionId).catch(function () { return null; }),
-                getContextBreakdown(activateMsg.projectSlug, activateMsg.sessionId).catch(function () { return null; }),
-            ]).then(function (results) {
-                try {
-                    var usage = results[0];
-                    if (usage) {
-                        sendTo(clientId, {
-                            type: "chat:context_usage",
-                            inputTokens: usage.inputTokens,
-                            outputTokens: usage.outputTokens,
-                            cacheReadTokens: usage.cacheReadTokens,
-                            cacheCreationTokens: usage.cacheCreationTokens,
-                            contextWindow: usage.contextWindow,
-                        });
-                    }
-                }
-                catch (err) {
-                    log.session("Error sending context usage: %O", err);
-                }
-                try {
-                    var breakdown = results[1];
-                    if (breakdown) {
-                        sendTo(clientId, {
-                            type: "chat:context_breakdown",
-                            segments: breakdown.segments,
-                            contextWindow: breakdown.contextWindow,
-                            autocompactAt: breakdown.autocompactAt,
-                        });
-                    }
-                }
-                catch (err) {
-                    log.session("Error sending context breakdown: %O", err);
-                }
-            }).catch(function (err) {
-                log.session("Failed to activate session: %O", err);
-                sendTo(clientId, { type: "chat:error", message: "Failed to activate session" });
-            });
-        }, 50);
         return;
     }
     if (message.type === "session:rename") {
@@ -160,7 +149,7 @@ registerHandler("session", function (clientId, message) {
             void renameSession(projectSlug, renameMsg.sessionId, renameMsg.title).then(function () {
                 invalidateSessionCache(projectSlug);
                 void listSessions(projectSlug, { limit: 40 }).then(function (result) {
-                    sendTo(clientId, {
+                    broadcastToProject(projectSlug, {
                         type: "session:list",
                         projectSlug,
                         sessions: result.sessions,
@@ -179,9 +168,9 @@ registerHandler("session", function (clientId, message) {
                 return;
             }
             void deleteSession(deleteProjectSlug, deleteMsg.sessionId).then(function () {
-                invalidateSessionCache(deleteProjectSlug);
+                removeSessionFromIndex(deleteProjectSlug, deleteMsg.sessionId);
                 void listSessions(deleteProjectSlug, { limit: 40 }).then(function (result) {
-                    sendTo(clientId, {
+                    broadcastToProject(deleteProjectSlug, {
                         type: "session:list",
                         projectSlug: deleteProjectSlug,
                         sessions: result.sessions,