@cryptiklemur/lattice 5.10.0 → 5.11.0

package/dist/server/mesh/peers.js

@@ -5,26 +5,26 @@ function getPeersPath() {
     return join(getLatticeHome(), "peers.json");
 }
 export function loadPeers() {
-    var path = getPeersPath();
+    const path = getPeersPath();
     if (!existsSync(path)) {
         return [];
     }
-    var raw = readFileSync(path, "utf-8");
+    const raw = readFileSync(path, "utf-8");
     return JSON.parse(raw);
 }
 export function savePeers(peers) {
-    var path = getPeersPath();
+    const path = getPeersPath();
     writeFileSync(path, JSON.stringify(peers, null, 2), "utf-8");
 }
 export function addPeer(peer) {
-    var peers = loadPeers();
-    var idx = peers.findIndex(function (p) { return p.id === peer.id; });
+    const peers = loadPeers();
+    const idx = peers.findIndex(function (p) { return p.id === peer.id; });
     if (idx >= 0) {
         peers[idx] = peer;
     }
     else {
-        var addrSet = new Set(peer.addresses);
-        var dupeIdx = peers.findIndex(function (p) {
+        const addrSet = new Set(peer.addresses);
+        const dupeIdx = peers.findIndex(function (p) {
             return p.addresses.some(function (a) { return addrSet.has(a); });
         });
         if (dupeIdx >= 0) {
@@ -37,8 +37,8 @@ export function addPeer(peer) {
     savePeers(peers);
 }
 export function removePeer(nodeId) {
-    var peers = loadPeers();
-    var next = peers.filter(function (p) { return p.id !== nodeId; });
+    const peers = loadPeers();
+    const next = peers.filter(function (p) { return p.id !== nodeId; });
     if (next.length === peers.length) {
         return false;
     }
@@ -46,7 +46,7 @@ export function removePeer(nodeId) {
     return true;
 }
 export function getPeer(nodeId) {
-    var peers = loadPeers();
+    const peers = loadPeers();
     return peers.find(function (p) { return p.id === nodeId; });
 }
 export function isPaired(nodeId) {

package/dist/server/mesh/proxy.js

@@ -3,19 +3,19 @@ import { getPeerConnection } from "./connector.js";
 import { sendTo, registerVirtualClient, removeVirtualClient } from "../ws/broadcast.js";
 import { routeMessage } from "../ws/router.js";
 import { log } from "../logger.js";
-var pendingRequests = new Map();
+const pendingRequests = new Map();
 export function proxyToRemoteNode(nodeId, projectSlug, clientId, message) {
     log.meshProxy("→ proxy %s to node %s for project %s", message.type, nodeId.slice(0, 8), projectSlug);
-    var ws = getPeerConnection(nodeId);
+    const ws = getPeerConnection(nodeId);
     if (!ws) {
         log.meshProxy("  ✗ no connection to node %s", nodeId.slice(0, 8));
         sendTo(clientId, { type: "chat:error", message: "Remote node is not connected" });
         return;
     }
-    var requestId = randomUUID();
+    const requestId = randomUUID();
     pendingRequests.set(requestId, clientId);
     log.meshProxy("  envelope requestId=%s", requestId.slice(0, 8));
-    var envelope = {
+    const envelope = {
         type: "mesh:proxy_request",
         projectSlug: projectSlug,
         requestId: requestId,
@@ -24,17 +24,17 @@ export function proxyToRemoteNode(nodeId, projectSlug, clientId, message) {
     ws.send(JSON.stringify(envelope));
 }
 export function handleProxyRequest(sourceNodeId, msg) {
-    var proxyClientId = "mesh-proxy:" + sourceNodeId + ":" + msg.requestId;
+    const proxyClientId = "mesh-proxy:" + sourceNodeId + ":" + msg.requestId;
     log.meshProxy("← proxy_request from %s: %s for %s (reqId=%s)", sourceNodeId.slice(0, 8), msg.payload.type, msg.projectSlug, msg.requestId.slice(0, 8));
     registerVirtualClient(proxyClientId, function (response) {
         log.meshProxy("  → proxy_response %s back to %s", response.type, sourceNodeId.slice(0, 8));
-        var ws = getPeerConnection(sourceNodeId);
+        const ws = getPeerConnection(sourceNodeId);
         if (!ws) {
             console.warn("[mesh/proxy] Cannot send response, no connection to: " + sourceNodeId);
             removeVirtualClient(proxyClientId);
             return;
         }
-        var envelope = {
+        const envelope = {
             type: "mesh:proxy_response",
             projectSlug: msg.projectSlug,
             requestId: msg.requestId,
@@ -47,7 +47,7 @@ export function handleProxyRequest(sourceNodeId, msg) {
 }
 export function handleProxyResponse(msg) {
     log.meshProxy("← proxy_response %s (reqId=%s)", msg.payload.type, msg.requestId.slice(0, 8));
-    var clientId = pendingRequests.get(msg.requestId);
+    const clientId = pendingRequests.get(msg.requestId);
     if (!clientId) {
         log.meshProxy("  ✗ no pending request for %s", msg.requestId.slice(0, 8));
         return;
@@ -55,13 +55,13 @@ export function handleProxyResponse(msg) {
     pendingRequests.delete(msg.requestId);
     sendTo(clientId, msg.payload);
 }
-var proxyHandlers = new Map();
+const proxyHandlers = new Map();
 export function registerProxyAwareHandler(prefix, handler) {
     proxyHandlers.set(prefix, handler);
 }
 function proxyRouteMessage(clientId, message, sendToFn) {
-    var prefix = message.type.split(":")[0];
-    var proxyHandler = proxyHandlers.get(prefix);
+    const prefix = message.type.split(":")[0];
+    const proxyHandler = proxyHandlers.get(prefix);
     if (proxyHandler) {
         proxyHandler(clientId, message, sendToFn);
         return;
@@ -69,15 +69,15 @@ function proxyRouteMessage(clientId, message, sendToFn) {
     routeMessage(clientId, message);
 }
 export function getProxySendTo(requestId, sourceNodeId) {
-    var clientId = pendingRequests.get(requestId);
+    const clientId = pendingRequests.get(requestId);
     if (clientId !== undefined) {
-        var resolvedClientId = clientId;
+        const resolvedClientId = clientId;
         return function (msg) {
             sendTo(resolvedClientId, msg);
         };
     }
     return function (msg) {
-        var ws = getPeerConnection(sourceNodeId);
+        const ws = getPeerConnection(sourceNodeId);
         if (!ws) {
             return;
         }

package/dist/server/mesh/session-sync.js

@@ -3,45 +3,45 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { getConnectedPeerIds, getPeerConnection } from "./connector.js";
 import { getLatticeHome } from "../config.js";
-var syncOffsets = new Map();
+const syncOffsets = new Map();
 function getSyncKey(nodeId, sessionId) {
     return nodeId + ":" + sessionId;
 }
 function getRemoteSessionsDir(nodeId, projectSlug) {
-    var dir = join(getLatticeHome(), "remote-sessions", nodeId, projectSlug);
+    const dir = join(getLatticeHome(), "remote-sessions", nodeId, projectSlug);
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
     return dir;
 }
 function getSessionFilePath(projectPath, sessionId) {
-    var hash = projectPath.replace(/\//g, "-");
+    const hash = projectPath.replace(/\//g, "-");
     return join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
 }
 export function syncSessionToPeers(projectPath, projectSlug, sessionId) {
-    var filePath = getSessionFilePath(projectPath, sessionId);
+    const filePath = getSessionFilePath(projectPath, sessionId);
     if (!existsSync(filePath)) {
         return;
     }
-    var content = readFileSync(filePath, "utf-8");
-    var peerIds = getConnectedPeerIds();
-    for (var i = 0; i < peerIds.length; i++) {
-        var nodeId = peerIds[i];
-        var key = getSyncKey(nodeId, sessionId);
-        var lastOffset = syncOffsets.get(key) || 0;
+    const content = readFileSync(filePath, "utf-8");
+    const peerIds = getConnectedPeerIds();
+    for (let i = 0; i < peerIds.length; i++) {
+        const nodeId = peerIds[i];
+        const key = getSyncKey(nodeId, sessionId);
+        const lastOffset = syncOffsets.get(key) || 0;
         if (content.length <= lastOffset) {
             continue;
         }
-        var newContent = content.slice(lastOffset);
-        var newLines = newContent.split("\n").filter(function (l) { return l.trim().length > 0; });
+        const newContent = content.slice(lastOffset);
+        const newLines = newContent.split("\n").filter(function (l) { return l.trim().length > 0; });
         if (newLines.length === 0) {
             continue;
         }
-        var ws = getPeerConnection(nodeId);
+        const ws = getPeerConnection(nodeId);
         if (!ws) {
             continue;
         }
-        var msg = {
+        const msg = {
             type: "mesh:session_sync",
             projectSlug,
             sessionId,
@@ -53,28 +53,28 @@ export function syncSessionToPeers(projectPath, projectSlug, sessionId) {
     }
 }
 export function handleSessionSync(nodeId, msg) {
-    var dir = getRemoteSessionsDir(nodeId, msg.projectSlug);
-    var filePath = join(dir, msg.sessionId + ".jsonl");
-    for (var i = 0; i < msg.lines.length; i++) {
+    const dir = getRemoteSessionsDir(nodeId, msg.projectSlug);
+    const filePath = join(dir, msg.sessionId + ".jsonl");
+    for (let i = 0; i < msg.lines.length; i++) {
         appendFileSync(filePath, msg.lines[i] + "\n", "utf-8");
     }
 }
 export function handleSessionRequest(nodeId, msg, projectPath) {
-    var filePath = getSessionFilePath(projectPath, msg.sessionId);
+    const filePath = getSessionFilePath(projectPath, msg.sessionId);
     if (!existsSync(filePath)) {
         return;
     }
-    var content = readFileSync(filePath, "utf-8");
-    var newContent = content.slice(msg.fromOffset);
-    var lines = newContent.split("\n").filter(function (l) { return l.trim().length > 0; });
+    const content = readFileSync(filePath, "utf-8");
+    const newContent = content.slice(msg.fromOffset);
+    const lines = newContent.split("\n").filter(function (l) { return l.trim().length > 0; });
     if (lines.length === 0) {
         return;
     }
-    var ws = getPeerConnection(nodeId);
+    const ws = getPeerConnection(nodeId);
     if (!ws) {
         return;
     }
-    var syncMsg = {
+    const syncMsg = {
         type: "mesh:session_sync",
         projectSlug: msg.projectSlug,
         sessionId: msg.sessionId,

package/dist/server/project/bookmarks.js

@@ -2,8 +2,8 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "
 import { join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { getLatticeHome } from "../config.js";
-var bookmarksFile = "";
-var bookmarks = [];
+let bookmarksFile = "";
+let bookmarks = [];
 function getBookmarksPath() {
     if (!bookmarksFile) {
         bookmarksFile = join(getLatticeHome(), "bookmarks.json");
@@ -11,13 +11,13 @@ function getBookmarksPath() {
     return bookmarksFile;
 }
 export function loadBookmarks() {
-    var path = getBookmarksPath();
+    const path = getBookmarksPath();
     if (!existsSync(path)) {
         bookmarks = [];
         return;
     }
     try {
-        var raw = readFileSync(path, "utf-8");
+        const raw = readFileSync(path, "utf-8");
         bookmarks = JSON.parse(raw);
     }
     catch (err) {
@@ -26,12 +26,12 @@ export function loadBookmarks() {
     }
 }
 function saveBookmarks() {
-    var path = getBookmarksPath();
-    var dir = join(path, "..");
+    const path = getBookmarksPath();
+    const dir = join(path, "..");
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
-    var tmp = path + ".tmp";
+    const tmp = path + ".tmp";
     try {
         writeFileSync(tmp, JSON.stringify(bookmarks, null, 2));
         renameSync(tmp, path);
@@ -41,7 +41,7 @@ function saveBookmarks() {
     }
 }
 export function listBookmarks(projectSlug, sessionId) {
-    var result = bookmarks;
+    let result = bookmarks;
     if (projectSlug) {
         result = result.filter(function (b) { return b.projectSlug === projectSlug; });
     }
@@ -51,8 +51,8 @@ export function listBookmarks(projectSlug, sessionId) {
     return result.slice();
 }
 export function addBookmark(bookmark) {
-    var now = Date.now();
-    var entry = {
+    const now = Date.now();
+    const entry = {
         id: "bm_" + now + "_" + randomBytes(3).toString("hex"),
         sessionId: bookmark.sessionId,
         projectSlug: bookmark.projectSlug,
@@ -66,7 +66,7 @@ export function addBookmark(bookmark) {
     return entry;
 }
 export function removeBookmark(id) {
-    for (var i = 0; i < bookmarks.length; i++) {
+    for (let i = 0; i < bookmarks.length; i++) {
         if (bookmarks[i].id === id) {
             bookmarks.splice(i, 1);
             saveBookmarks();

package/dist/server/project/context-breakdown.js

@@ -5,7 +5,7 @@ import { homedir } from "node:os";
 import { guessContextWindow } from "./session.js";
 import { loadConfig } from "../config.js";
 import { getInstalledPluginCount, getPluginSkillRuleTokenEstimate } from "../handlers/plugins.js";
-var encoder = encodingForModel("gpt-4o");
+const encoder = encodingForModel("gpt-4o");
 function countTokens(text) {
     if (!text)
         return 0;
@@ -23,9 +23,9 @@ function readDirFiles(dirPath) {
     try {
         if (!existsSync(dirPath))
             return "";
-        var files = readdirSync(dirPath, { withFileTypes: true });
-        var content = "";
-        for (var i = 0; i < files.length; i++) {
+        const files = readdirSync(dirPath, { withFileTypes: true });
+        let content = "";
+        for (let i = 0; i < files.length; i++) {
             if (files[i].isFile()) {
                 content += readFileSafe(join(dirPath, files[i].name)) + "\n";
             }
@@ -39,13 +39,13 @@ function projectPathToHash(projectPath) {
     return projectPath.replace(/\//g, "-");
 }
 function getProjectPath(projectSlug) {
-    var config = loadConfig();
-    var project = config.projects.find(function (p) { return p.slug === projectSlug; });
+    const config = loadConfig();
+    const project = config.projects.find(function (p) { return p.slug === projectSlug; });
     return project ? project.path : null;
 }
 // Known built-in Claude Code tools with approximate per-tool token counts
 // These are the tool definitions sent in every API request
-var BUILTIN_TOOLS = {
+const BUILTIN_TOOLS = {
     "Read": 350,
     "Write": 300,
     "Edit": 400,
@@ -71,20 +71,20 @@ var BUILTIN_TOOLS = {
     "ToolSearch": 250,
 };
 // Average tokens per MCP tool definition (name + description + JSON schema)
-var MCP_TOOL_AVG_TOKENS = 250;
+const MCP_TOOL_AVG_TOKENS = 250;
 function extractToolsFromSession(lines) {
-    var builtinSet = new Set();
-    var mcpMap = new Map();
+    const builtinSet = new Set();
+    const mcpMap = new Map();
     // First: check compact boundary metadata for preCompactDiscoveredTools
-    for (var i = 0; i < lines.length; i++) {
-        var line = lines[i].trim();
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
         if (!line || !line.includes("compactMetadata"))
             continue;
         try {
-            var parsed = JSON.parse(line);
-            var tools = parsed.compactMetadata?.preCompactDiscoveredTools;
+            const parsed = JSON.parse(line);
+            const tools = parsed.compactMetadata?.preCompactDiscoveredTools;
             if (Array.isArray(tools)) {
-                for (var t = 0; t < tools.length; t++) {
+                for (let t = 0; t < tools.length; t++) {
                     categorizeToolName(tools[t], builtinSet, mcpMap);
                 }
             }
@@ -92,15 +92,15 @@ function extractToolsFromSession(lines) {
         catch { }
     }
     // Second: scan tool_use blocks from assistant messages for any we missed
-    for (var j = 0; j < lines.length; j++) {
-        var aLine = lines[j].trim();
+    for (let j = 0; j < lines.length; j++) {
+        const aLine = lines[j].trim();
         if (!aLine || !aLine.includes("tool_use"))
             continue;
         try {
-            var aParsed = JSON.parse(aLine);
+            const aParsed = JSON.parse(aLine);
             if (aParsed.type === "assistant" && aParsed.message && Array.isArray(aParsed.message.content)) {
-                for (var k = 0; k < aParsed.message.content.length; k++) {
-                    var block = aParsed.message.content[k];
+                for (let k = 0; k < aParsed.message.content.length; k++) {
+                    const block = aParsed.message.content[k];
                     if (block.type === "tool_use" && block.name) {
                         categorizeToolName(block.name, builtinSet, mcpMap);
                     }
@@ -125,8 +125,8 @@ function extractToolsFromSession(lines) {
 }
 function categorizeToolName(name, builtinSet, mcpMap) {
     if (name.startsWith("mcp__")) {
-        var parts = name.split("__");
-        var serverName = parts[1] || "unknown";
+        const parts = name.split("__");
+        const serverName = parts[1] || "unknown";
         if (!mcpMap.has(serverName)) {
             mcpMap.set(serverName, new Set());
         }
@@ -137,13 +137,13 @@ function categorizeToolName(name, builtinSet, mcpMap) {
     }
 }
 function estimateBuiltinToolTokens(toolNames) {
-    var total = 0;
-    for (var i = 0; i < toolNames.length; i++) {
+    let total = 0;
+    for (let i = 0; i < toolNames.length; i++) {
         total += BUILTIN_TOOLS[toolNames[i]] || 300;
     }
     // Also include tools that are always sent but might not appear in usage
-    var knownKeys = Object.keys(BUILTIN_TOOLS);
-    for (var j = 0; j < knownKeys.length; j++) {
+    const knownKeys = Object.keys(BUILTIN_TOOLS);
+    for (let j = 0; j < knownKeys.length; j++) {
         if (toolNames.indexOf(knownKeys[j]) === -1) {
             total += BUILTIN_TOOLS[knownKeys[j]];
         }
@@ -151,55 +151,55 @@ function estimateBuiltinToolTokens(toolNames) {
     return total;
 }
 export async function getContextBreakdown(projectSlug, sessionId) {
-    var projectPath = getProjectPath(projectSlug);
+    const projectPath = getProjectPath(projectSlug);
     if (!projectPath)
         return null;
-    var home = homedir();
-    var hash = projectPathToHash(projectPath);
-    var sessionFile = join(home, ".claude", "projects", hash, sessionId + ".jsonl");
+    const home = homedir();
+    const hash = projectPathToHash(projectPath);
+    const sessionFile = join(home, ".claude", "projects", hash, sessionId + ".jsonl");
     if (!existsSync(sessionFile))
         return null;
     // Read instruction files
-    var globalClaudeMd = readFileSafe(join(home, ".claude", "CLAUDE.md"));
-    var globalRulesContent = readDirFiles(join(home, ".claude", "rules"));
-    var projectClaudeMd = readFileSafe(join(projectPath, "CLAUDE.md"));
-    var projectLocalClaudeMd = readFileSafe(join(home, ".claude", "projects", hash, "CLAUDE.md"));
-    var memoryContent = readDirFiles(join(home, ".claude", "projects", hash, "memory"));
-    var memoryIndex = readFileSafe(join(home, ".claude", "projects", hash, "MEMORY.md"));
-    var instructionsTokens = countTokens(globalClaudeMd + globalRulesContent + projectClaudeMd + projectLocalClaudeMd);
-    var memoryTokens = countTokens(memoryContent + memoryIndex);
+    const globalClaudeMd = readFileSafe(join(home, ".claude", "CLAUDE.md"));
+    const globalRulesContent = readDirFiles(join(home, ".claude", "rules"));
+    const projectClaudeMd = readFileSafe(join(projectPath, "CLAUDE.md"));
+    const projectLocalClaudeMd = readFileSafe(join(home, ".claude", "projects", hash, "CLAUDE.md"));
+    const memoryContent = readDirFiles(join(home, ".claude", "projects", hash, "memory"));
+    const memoryIndex = readFileSafe(join(home, ".claude", "projects", hash, "MEMORY.md"));
+    const instructionsTokens = countTokens(globalClaudeMd + globalRulesContent + projectClaudeMd + projectLocalClaudeMd);
+    const memoryTokens = countTokens(memoryContent + memoryIndex);
     // Parse session — read last 2MB for recent context (avoids reading 35MB+ files)
-    var fd = openSync(sessionFile, "r");
-    var fileStat = fstatSync(fd);
-    var readSize = Math.min(fileStat.size, 2 * 1024 * 1024);
-    var readBuf = Buffer.alloc(readSize);
+    const fd = openSync(sessionFile, "r");
+    const fileStat = fstatSync(fd);
+    const readSize = Math.min(fileStat.size, 2 * 1024 * 1024);
+    const readBuf = Buffer.alloc(readSize);
     readSync(fd, readBuf, 0, readSize, fileStat.size - readSize);
     closeSync(fd);
-    var content = readBuf.toString("utf-8");
-    var lines = content.split("\n").filter(function (l) { return l.length > 0; });
+    const content = readBuf.toString("utf-8");
+    const lines = content.split("\n").filter(function (l) { return l.length > 0; });
     // Extract tool info
-    var toolCounts = extractToolsFromSession(lines);
-    var builtinToolTokens = estimateBuiltinToolTokens(toolCounts.builtinTools);
+    const toolCounts = extractToolsFromSession(lines);
+    const builtinToolTokens = estimateBuiltinToolTokens(toolCounts.builtinTools);
     // Parse conversation messages
-    var userText = "";
-    var assistantText = "";
-    var toolResultText = "";
-    var contextWindow = 0;
-    var lastModel = "";
-    for (var i = 0; i < lines.length; i++) {
-        var line = lines[i].trim();
+    let userText = "";
+    let assistantText = "";
+    let toolResultText = "";
+    let contextWindow = 0;
+    let lastModel = "";
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
         if (!line)
             continue;
         try {
-            var parsed = JSON.parse(line);
+            const parsed = JSON.parse(line);
             if (parsed.type === "user" && parsed.message) {
-                var userContent = parsed.message.content;
+                const userContent = parsed.message.content;
                 if (typeof userContent === "string") {
                     userText += userContent + "\n";
                 }
                 else if (Array.isArray(userContent)) {
-                    for (var j = 0; j < userContent.length; j++) {
-                        var block = userContent[j];
+                    for (let j = 0; j < userContent.length; j++) {
+                        const block = userContent[j];
                         if (block.type === "text" && block.text) {
                             userText += block.text + "\n";
                         }
@@ -208,7 +208,7 @@ export async function getContextBreakdown(projectSlug, sessionId) {
                                 toolResultText += block.content + "\n";
                             }
                             else if (Array.isArray(block.content)) {
-                                for (var ri = 0; ri < block.content.length; ri++) {
+                                for (let ri = 0; ri < block.content.length; ri++) {
                                     if (block.content[ri].type === "text" && block.content[ri].text) {
                                         toolResultText += block.content[ri].text + "\n";
                                     }
@@ -219,13 +219,13 @@ export async function getContextBreakdown(projectSlug, sessionId) {
                 }
             }
             else if (parsed.type === "assistant" && parsed.message) {
-                var aContent = parsed.message.content;
+                const aContent = parsed.message.content;
                 if (typeof aContent === "string") {
                     assistantText += aContent + "\n";
                 }
                 else if (Array.isArray(aContent)) {
-                    for (var k = 0; k < aContent.length; k++) {
-                        var ab = aContent[k];
+                    for (let k = 0; k < aContent.length; k++) {
+                        const ab = aContent[k];
                         if (ab.type === "text" && ab.text) {
                             assistantText += ab.text + "\n";
                         }
@@ -244,19 +244,19 @@ export async function getContextBreakdown(projectSlug, sessionId) {
         }
         catch { }
     }
-    var userTokens = countTokens(userText);
-    var assistantTokens = countTokens(assistantText);
-    var toolResultTokens = countTokens(toolResultText);
+    const userTokens = countTokens(userText);
+    const assistantTokens = countTokens(assistantText);
+    const toolResultTokens = countTokens(toolResultText);
     contextWindow = guessContextWindow(lastModel);
-    var autocompactAt = Math.round(contextWindow * 0.9);
-    var systemPromptEstimate = 4500;
-    var segments = [
+    const autocompactAt = Math.round(contextWindow * 0.9);
+    const systemPromptEstimate = 4500;
+    const segments = [
         { label: "System prompt", tokens: systemPromptEstimate, id: "system", estimated: true },
         { label: "Built-in tools (" + Object.keys(BUILTIN_TOOLS).length + ")", tokens: builtinToolTokens, id: "builtin_tools", estimated: true },
     ];
     // Add per-MCP-server segments
     toolCounts.mcpTools.forEach(function (tools, serverName) {
-        var mcpTokens = tools.length * MCP_TOOL_AVG_TOKENS;
+        const mcpTokens = tools.length * MCP_TOOL_AVG_TOKENS;
         segments.push({
             label: serverName + " (" + tools.length + " tools)",
             tokens: mcpTokens,
@@ -264,9 +264,9 @@ export async function getContextBreakdown(projectSlug, sessionId) {
             estimated: true,
         });
     });
-    var pluginCount = getInstalledPluginCount();
+    const pluginCount = getInstalledPluginCount();
     if (pluginCount > 0) {
-        var pluginTokens = getPluginSkillRuleTokenEstimate();
+        const pluginTokens = getPluginSkillRuleTokenEstimate();
         segments.push({
             label: "Plugins (" + pluginCount + ")",
             tokens: pluginTokens,