@sesamespace/hivemind 0.8.13 → 0.10.0

package/dist/{chunk-ZM7RK5YV.js → chunk-M3A2WRXM.js}

@@ -1343,14 +1343,15 @@ var Agent = class {
     });
     if (relevantEpisodes.length > 0) {
       const episodeIds = relevantEpisodes.map((e) => e.id);
-      this.memory.recordCoAccess(episodeIds).catch(() => {
-      });
+      this.memory.recordCoAccess(episodeIds).catch((err) => console.warn("[memory] recordCoAccess failed:", err.message));
       for (const ep of relevantEpisodes) {
-        this.memory.recordAccess(ep.id).catch(() => {
-        });
+        this.memory.recordAccess(ep.id).catch((err) => console.warn("[memory] recordAccess failed:", err.message));
       }
     }
-    const l3Knowledge = await this.memory.getL3Knowledge(contextName).catch(() => []);
+    const l3Knowledge = await this.memory.getL3Knowledge(contextName).catch((err) => {
+      console.warn("[memory] getL3Knowledge failed:", err.message);
+      return [];
+    });
     const systemPromptResult = buildSystemPrompt({
       config: this.config.agent,
       episodes: relevantEpisodes,
@@ -1587,6 +1588,9 @@ var Agent = class {
   getActiveContext() {
     return this.contextManager.getActiveContext();
   }
+  getConversationHistories() {
+    return this.conversationHistories;
+  }
 };
 
 // packages/runtime/src/events.ts
@@ -4745,29 +4749,43 @@ function parseQuery(url) {
   }
   return params;
 }
-async function proxyMemory(memoryUrl, path, method, res) {
+function readBody(req) {
+  return new Promise((resolve21, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve21(Buffer.concat(chunks).toString()));
+    req.on("error", reject);
+  });
+}
+async function proxyMemory(memoryUrl, path, method, res, body) {
   try {
-    const resp = await fetch(`${memoryUrl}${path}`, { method });
-    const body = await resp.text();
+    const opts = { method };
+    if (body && (method === "POST" || method === "PATCH" || method === "PUT")) {
+      opts.body = body;
+      opts.headers = { "Content-Type": "application/json" };
+    }
+    const resp = await fetch(`${memoryUrl}${path}`, opts);
+    const respBody = await resp.text();
     res.writeHead(resp.status, {
       "Content-Type": resp.headers.get("content-type") ?? "application/json",
       "Access-Control-Allow-Origin": "*"
     });
-    res.end(body);
+    res.end(respBody);
   } catch (err) {
     json(res, { error: err.message }, 502);
   }
 }
-function startDashboardServer(requestLogger, memoryConfig) {
+function startDashboardServer(requestLogger, memoryConfig, getL1) {
   const memoryUrl = memoryConfig.daemon_url;
   const server = createServer(async (req, res) => {
     const method = req.method ?? "GET";
     const rawUrl = req.url ?? "/";
     const urlPath = rawUrl.split("?")[0];
+    const queryStr = rawUrl.includes("?") ? rawUrl.slice(rawUrl.indexOf("?")) : "";
     if (method === "OPTIONS") {
       res.writeHead(204, {
         "Access-Control-Allow-Origin": "*",
-        "Access-Control-Allow-Methods": "GET, DELETE, OPTIONS",
+        "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
         "Access-Control-Allow-Headers": "Content-Type"
       });
       res.end();
@@ -4800,10 +4818,32 @@ function startDashboardServer(requestLogger, memoryConfig) {
         }
         return;
       }
+      if (method === "GET" && urlPath === "/api/health") {
+        await proxyMemory(memoryUrl, "/health", "GET", res);
+        return;
+      }
+      if (method === "GET" && urlPath === "/api/stats") {
+        await proxyMemory(memoryUrl, "/stats", "GET", res);
+        return;
+      }
+      if (method === "GET" && urlPath === "/api/search") {
+        await proxyMemory(memoryUrl, `/search${queryStr}`, "GET", res);
+        return;
+      }
+      if (method === "GET" && urlPath === "/api/search/cross-context") {
+        await proxyMemory(memoryUrl, `/search/cross-context${queryStr}`, "GET", res);
+        return;
+      }
       if (method === "GET" && urlPath === "/api/contexts") {
         await proxyMemory(memoryUrl, "/contexts", "GET", res);
         return;
       }
+      const ctxDeleteMatch = urlPath.match(/^\/api\/contexts\/([^/]+)$/);
+      if (method === "DELETE" && ctxDeleteMatch) {
+        const name = decodeURIComponent(ctxDeleteMatch[1]);
+        await proxyMemory(memoryUrl, `/contexts/${encodeURIComponent(name)}`, "DELETE", res);
+        return;
+      }
       const episodesMatch = urlPath.match(/^\/api\/contexts\/([^/]+)\/episodes$/);
       if (method === "GET" && episodesMatch) {
         const name = decodeURIComponent(episodesMatch[1]);
@@ -4821,12 +4861,69 @@ function startDashboardServer(requestLogger, memoryConfig) {
         );
         return;
       }
-      const l3DeleteMatch = urlPath.match(/^\/api\/l3\/([^/]+)$/);
-      if (method === "DELETE" && l3DeleteMatch) {
-        const id = decodeURIComponent(l3DeleteMatch[1]);
+      const scoringGetMatch = urlPath.match(/^\/api\/contexts\/([^/]+)\/scoring$/);
+      if (method === "GET" && scoringGetMatch) {
+        const name = decodeURIComponent(scoringGetMatch[1]);
+        await proxyMemory(memoryUrl, `/scoring/${encodeURIComponent(name)}`, "GET", res);
+        return;
+      }
+      if (method === "POST" && scoringGetMatch) {
+        const name = decodeURIComponent(scoringGetMatch[1]);
+        const body = await readBody(req);
+        await proxyMemory(memoryUrl, `/contexts/${encodeURIComponent(name)}/scoring`, "POST", res, body);
+        return;
+      }
+      const l3IdMatch = urlPath.match(/^\/api\/l3\/([^/]+)$/);
+      if (method === "DELETE" && l3IdMatch) {
+        const id = decodeURIComponent(l3IdMatch[1]);
         await proxyMemory(memoryUrl, `/promotion/l3/${encodeURIComponent(id)}`, "DELETE", res);
         return;
       }
+      if (method === "PATCH" && l3IdMatch) {
+        const id = decodeURIComponent(l3IdMatch[1]);
+        const body = await readBody(req);
+        await proxyMemory(memoryUrl, `/promotion/l3/${encodeURIComponent(id)}`, "PATCH", res, body);
+        return;
+      }
+      if (method === "POST" && urlPath === "/api/promotion/run") {
+        await proxyMemory(memoryUrl, `/promotion/run${queryStr}`, "POST", res);
+        return;
+      }
+      if (method === "GET" && urlPath === "/api/access/top") {
+        await proxyMemory(memoryUrl, `/access/top${queryStr}`, "GET", res);
+        return;
+      }
+      const accessMatch = urlPath.match(/^\/api\/episodes\/([^/]+)\/access$/);
+      if (method === "GET" && accessMatch) {
+        const id = decodeURIComponent(accessMatch[1]);
+        await proxyMemory(memoryUrl, `/access/${encodeURIComponent(id)}`, "GET", res);
+        return;
+      }
+      if (method === "GET" && urlPath === "/api/l1") {
+        if (!getL1) {
+          json(res, { contexts: {} });
+          return;
+        }
+        const histories = getL1();
+        const result = {};
+        for (const [ctx, msgs] of histories) {
+          result[ctx] = { count: msgs.length };
+        }
+        json(res, { contexts: result });
+        return;
+      }
+      const l1CtxMatch = urlPath.match(/^\/api\/l1\/([^/]+)$/);
+      if (method === "GET" && l1CtxMatch) {
+        if (!getL1) {
+          json(res, { messages: [] });
+          return;
+        }
+        const ctx = decodeURIComponent(l1CtxMatch[1]);
+        const histories = getL1();
+        const messages = histories.get(ctx) || [];
+        json(res, { messages: messages.map((m) => ({ role: m.role, content: m.content ?? "" })) });
+        return;
+      }
       json(res, { error: "Not found" }, 404);
     } catch (err) {
       console.error("[dashboard] Request error:", err.message);
@@ -6039,6 +6136,7 @@ import { mkdirSync as mkdirSync9, existsSync as existsSync13 } from "fs";
 import { randomUUID as randomUUID5 } from "crypto";
 var MAX_OUTPUT2 = 5e4;
 var browserInstance = null;
+var contextInstances = /* @__PURE__ */ new Map();
 var lastUsed = 0;
 var idleTimer = null;
 var IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -6047,7 +6145,16 @@ async function getBrowser() {
     const modName = "playwright";
     const pw = await Function("m", "return import(m)")(modName);
     if (!browserInstance) {
-      browserInstance = await pw.chromium.launch({ headless: true });
+      browserInstance = await pw.chromium.launch({
+        headless: true,
+        args: [
+          "--disable-dev-shm-usage",
+          "--disable-setuid-sandbox",
+          "--no-sandbox",
+          "--disable-web-security",
+          "--disable-features=VizDisplayCompositor"
+        ]
+      });
       if (!idleTimer) {
         idleTimer = setInterval(async () => {
           if (browserInstance && Date.now() - lastUsed > IDLE_TIMEOUT_MS) {
@@ -6064,7 +6171,43 @@ async function getBrowser() {
     );
   }
 }
+async function getBrowserContext(sessionId = "default", options = {}) {
+  const browser = await getBrowser();
+  if (!contextInstances.has(sessionId)) {
+    const contextOptions = {
+      userAgent: options.userAgent || "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+      viewport: options.viewport || { width: 1280, height: 720 },
+      locale: options.locale || "en-US",
+      timezoneId: options.timezone || "America/New_York",
+      deviceScaleFactor: options.deviceScaleFactor || 1,
+      isMobile: options.isMobile || false,
+      hasTouch: options.hasTouch || false,
+      colorScheme: options.colorScheme || "light",
+      reducedMotion: options.reducedMotion || "no-preference",
+      permissions: options.permissions || [],
+      geolocation: options.geolocation,
+      offline: options.offline || false,
+      acceptDownloads: options.downloadBehavior !== "deny"
+    };
+    const context = await browser.newContext(contextOptions);
+    context.on("request", (request) => {
+      console.log(`\u2192 ${request.method()} ${request.url()}`);
+    });
+    context.on("response", (response) => {
+      console.log(`\u2190 ${response.status()} ${response.url()}`);
+    });
+    contextInstances.set(sessionId, context);
+  }
+  return contextInstances.get(sessionId);
+}
 async function closeBrowser() {
+  for (const [sessionId, context] of contextInstances) {
+    try {
+      await context.close();
+    } catch {
+    }
+  }
+  contextInstances.clear();
   if (browserInstance) {
     try {
       await browserInstance.close();
@@ -6082,14 +6225,26 @@ function registerBrowserTools(registry, workspaceDir) {
   registry.register(
     "browse",
     [
-      "Navigate to a URL and interact with the page using a headless browser.",
+      "Navigate to a URL and interact with the page using an enhanced headless browser with session persistence.",
       "Actions:",
       "  extract (default) \u2014 get the readable text content of the page",
       "  screenshot \u2014 take a PNG screenshot and return the file path",
       "  click \u2014 click an element matching a CSS selector",
       "  type \u2014 type text into an element matching a CSS selector",
       "  evaluate \u2014 run arbitrary JavaScript in the page and return the result",
-      "Supports waitForSelector to wait for dynamic content before acting."
+      "  form_fill \u2014 fill out a form with multiple fields at once",
+      "  scroll \u2014 scroll the page (up, down, to element, or to coordinates)",
+      "  hover \u2014 hover over an element",
+      "  select \u2014 select an option from a dropdown",
+      "  upload \u2014 upload a file to a file input",
+      "  download \u2014 download a file and return the path",
+      "  pdf \u2014 generate a PDF of the page",
+      "  wait_for \u2014 wait for various conditions (selector, text, url, timeout)",
+      "  network_logs \u2014 get network request/response logs",
+      "  console_logs \u2014 get browser console logs",
+      "  cookies \u2014 get/set/clear cookies",
+      "  storage \u2014 get/set/clear localStorage/sessionStorage",
+      "Supports session persistence, mobile simulation, and advanced browser features."
     ].join("\n"),
     {
       type: "object",
@@ -6100,21 +6255,101 @@ function registerBrowserTools(registry, workspaceDir) {
         },
         action: {
           type: "string",
-          enum: ["extract", "screenshot", "click", "type", "evaluate"],
+          enum: [
+            "extract",
+            "screenshot",
+            "click",
+            "type",
+            "evaluate",
+            "form_fill",
+            "scroll",
+            "hover",
+            "select",
+            "upload",
+            "download",
+            "pdf",
+            "wait_for",
+            "network_logs",
+            "console_logs",
+            "cookies",
+            "storage"
+          ],
           description: "Action to perform (default: extract)."
         },
         selector: {
           type: "string",
-          description: "CSS selector for click/type actions."
+          description: "CSS selector for element-based actions."
         },
         text: {
           type: "string",
-          description: "Text to type (for 'type' action)."
+          description: "Text to type or search for."
         },
         javascript: {
           type: "string",
           description: "JavaScript to evaluate in the page (for 'evaluate' action)."
         },
+        formData: {
+          type: "object",
+          description: "Key-value pairs for form filling (selector: value)."
+        },
+        scrollDirection: {
+          type: "string",
+          enum: ["up", "down", "left", "right", "top", "bottom"],
+          description: "Scroll direction or position."
+        },
+        scrollDistance: {
+          type: "number",
+          description: "Pixels to scroll (default: 500)."
+        },
+        coordinates: {
+          type: "object",
+          properties: {
+            x: { type: "number" },
+            y: { type: "number" }
+          },
+          description: "X,Y coordinates for scrolling or clicking."
+        },
+        filePath: {
+          type: "string",
+          description: "Path to file for upload action."
+        },
+        waitCondition: {
+          type: "string",
+          enum: ["selector", "text", "url", "timeout", "networkidle"],
+          description: "What to wait for."
+        },
+        waitValue: {
+          type: "string",
+          description: "Value to wait for (selector, text, URL pattern)."
+        },
+        cookieData: {
+          type: "object",
+          description: "Cookie data for cookie operations."
+        },
+        storageData: {
+          type: "object",
+          description: "Storage data for localStorage/sessionStorage operations."
+        },
+        session: {
+          type: "string",
+          description: "Session ID for persistent browser context (default: 'default')."
+        },
+        viewport: {
+          type: "object",
+          properties: {
+            width: { type: "number" },
+            height: { type: "number" }
+          },
+          description: "Browser viewport size."
+        },
+        userAgent: {
+          type: "string",
+          description: "Custom user agent string."
+        },
+        mobile: {
+          type: "boolean",
+          description: "Simulate mobile device."
+        },
         waitForSelector: {
           type: "string",
           description: "CSS selector to wait for before performing the action."
@@ -6132,19 +6367,33 @@ function registerBrowserTools(registry, workspaceDir) {
       const selector = params.selector;
       const text = params.text;
       const javascript = params.javascript;
+      const formData = params.formData;
+      const scrollDirection = params.scrollDirection;
+      const scrollDistance = params.scrollDistance || 500;
+      const coordinates = params.coordinates;
+      const filePath = params.filePath;
+      const waitCondition = params.waitCondition;
+      const waitValue = params.waitValue;
+      const cookieData = params.cookieData;
+      const storageData = params.storageData;
+      const sessionId = params.session || "default";
+      const viewport = params.viewport;
+      const userAgent = params.userAgent;
+      const mobile = params.mobile;
       const waitForSelector = params.waitForSelector;
       const timeout = params.timeout || 3e4;
-      let browser;
-      try {
-        browser = await getBrowser();
-      } catch (err) {
-        return err.message;
-      }
+      let context;
       let page;
       try {
-        page = await browser.newPage({
-          userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
-        });
+        const browserOptions = {
+          session: sessionId,
+          viewport,
+          userAgent,
+          isMobile: mobile,
+          hasTouch: mobile
+        };
+        context = await getBrowserContext(sessionId, browserOptions);
+        page = await context.newPage();
         page.setDefaultTimeout(timeout);
         await page.goto(url, { waitUntil: "domcontentloaded", timeout });
         if (waitForSelector) {
@@ -6170,12 +6419,31 @@ function registerBrowserTools(registry, workspaceDir) {
             await page.screenshot({ path: filepath, fullPage: true });
             return `Screenshot saved: ${filepath}`;
           }
+          case "pdf": {
+            if (!existsSync13(screenshotDir)) {
+              mkdirSync9(screenshotDir, { recursive: true });
+            }
+            const filename = `${randomUUID5()}.pdf`;
+            const filepath = resolve12(screenshotDir, filename);
+            await page.pdf({
+              path: filepath,
+              format: "A4",
+              printBackground: true,
+              margin: { top: "1cm", right: "1cm", bottom: "1cm", left: "1cm" }
+            });
+            return `PDF saved: ${filepath}`;
+          }
           case "click": {
             if (!selector) {
               return "Error: 'selector' parameter is required for click action.";
             }
-            await page.click(selector);
-            return `Clicked: ${selector}`;
+            if (coordinates) {
+              await page.mouse.click(coordinates.x, coordinates.y);
+              return `Clicked at coordinates: (${coordinates.x}, ${coordinates.y})`;
+            } else {
+              await page.click(selector);
+              return `Clicked: ${selector}`;
+            }
           }
           case "type": {
             if (!selector) {
@@ -6187,6 +6455,169 @@ function registerBrowserTools(registry, workspaceDir) {
             await page.fill(selector, text);
             return `Typed into ${selector}: "${text}"`;
           }
+          case "form_fill": {
+            if (!formData) {
+              return "Error: 'formData' parameter is required for form_fill action.";
+            }
+            const results = [];
+            for (const [sel, value] of Object.entries(formData)) {
+              await page.fill(sel, value);
+              results.push(`${sel}: "${value}"`);
+            }
+            return `Form filled:
+${results.join("\n")}`;
+          }
+          case "scroll": {
+            if (coordinates) {
+              await page.evaluate(({ x, y }) => window.scrollTo(x, y), coordinates);
+              return `Scrolled to coordinates: (${coordinates.x}, ${coordinates.y})`;
+            } else if (selector) {
+              await page.locator(selector).scrollIntoViewIfNeeded();
+              return `Scrolled to element: ${selector}`;
+            } else if (scrollDirection) {
+              switch (scrollDirection) {
+                case "up":
+                  await page.keyboard.press("PageUp");
+                  break;
+                case "down":
+                  await page.keyboard.press("PageDown");
+                  break;
+                case "top":
+                  await page.keyboard.press("Home");
+                  break;
+                case "bottom":
+                  await page.keyboard.press("End");
+                  break;
+                default:
+                  await page.mouse.wheel(0, scrollDirection === "down" ? scrollDistance : -scrollDistance);
+              }
+              return `Scrolled ${scrollDirection}`;
+            }
+            return "Error: scroll requires coordinates, selector, or scrollDirection";
+          }
+          case "hover": {
+            if (!selector) {
+              return "Error: 'selector' parameter is required for hover action.";
+            }
+            await page.hover(selector);
+            return `Hovered over: ${selector}`;
+          }
+          case "select": {
+            if (!selector || !text) {
+              return "Error: 'selector' and 'text' parameters are required for select action.";
+            }
+            await page.selectOption(selector, text);
+            return `Selected "${text}" in ${selector}`;
+          }
+          case "upload": {
+            if (!selector || !filePath) {
+              return "Error: 'selector' and 'filePath' parameters are required for upload action.";
+            }
+            const absolutePath = resolve12(workspaceDir, filePath);
+            if (!existsSync13(absolutePath)) {
+              return `Error: File not found: ${absolutePath}`;
+            }
+            await page.setInputFiles(selector, absolutePath);
+            return `Uploaded file ${filePath} to ${selector}`;
+          }
+          case "download": {
+            const downloadPromise = page.waitForEvent("download");
+            if (selector) {
+              await page.click(selector);
+            }
+            const download = await downloadPromise;
+            const filename = download.suggestedFilename() || `download_${randomUUID5()}`;
+            const downloadPath = resolve12(workspaceDir, "downloads", filename);
+            if (!existsSync13(resolve12(workspaceDir, "downloads"))) {
+              mkdirSync9(resolve12(workspaceDir, "downloads"), { recursive: true });
+            }
+            await download.saveAs(downloadPath);
+            return `Downloaded: ${downloadPath}`;
+          }
+          case "wait_for": {
+            if (!waitCondition || !waitValue) {
+              return "Error: 'waitCondition' and 'waitValue' parameters are required for wait_for action.";
+            }
+            switch (waitCondition) {
+              case "selector":
+                await page.waitForSelector(waitValue, { timeout });
+                return `Waited for selector: ${waitValue}`;
+              case "text":
+                await page.waitForFunction(
+                  (text2) => document.body.innerText.includes(text2),
+                  waitValue,
+                  { timeout }
+                );
+                return `Waited for text: ${waitValue}`;
+              case "url":
+                await page.waitForURL(waitValue, { timeout });
+                return `Waited for URL: ${waitValue}`;
+              case "networkidle":
+                await page.waitForLoadState("networkidle", { timeout });
+                return "Waited for network idle";
+              case "timeout":
+                await page.waitForTimeout(parseInt(waitValue));
+                return `Waited for ${waitValue}ms`;
+              default:
+                return `Unknown wait condition: ${waitCondition}`;
+            }
+          }
+          case "network_logs": {
+            const logs = await page.evaluate(() => {
+              return "Network logging not yet implemented - use browser dev tools";
+            });
+            return logs;
+          }
+          case "console_logs": {
+            const logs = [];
+            page.on("console", (msg) => {
+              logs.push(`[${msg.type()}] ${msg.text()}`);
+            });
+            await page.waitForTimeout(1e3);
+            return logs.length > 0 ? logs.join("\n") : "No console logs";
+          }
+          case "cookies": {
+            if (cookieData) {
+              if (cookieData.action === "set") {
+                await context.addCookies([cookieData.cookie]);
+                return `Cookie set: ${cookieData.cookie.name}`;
+              } else if (cookieData.action === "clear") {
+                await context.clearCookies();
+                return "Cookies cleared";
+              }
+            }
+            const cookies = await context.cookies();
+            return JSON.stringify(cookies, null, 2);
+          }
+          case "storage": {
+            if (storageData) {
+              const storageType = storageData.type || "localStorage";
+              if (storageData.action === "set") {
+                await page.evaluate(({ type, key, value }) => {
+                  if (type === "localStorage") {
+                    localStorage.setItem(key, value);
+                  } else {
+                    sessionStorage.setItem(key, value);
+                  }
+                }, { type: storageType, key: storageData.key, value: storageData.value });
+                return `${storageType} set: ${storageData.key}`;
+              } else if (storageData.action === "clear") {
+                await page.evaluate((type) => {
+                  if (type === "localStorage") {
+                    localStorage.clear();
+                  } else {
+                    sessionStorage.clear();
+                  }
+                }, storageType);
+                return `${storageType} cleared`;
+              }
+            }
+            const storage = await page.evaluate(() => ({
+              localStorage: Object.fromEntries(Object.entries(localStorage)),
+              sessionStorage: Object.fromEntries(Object.entries(sessionStorage))
+            }));
+            return JSON.stringify(storage, null, 2);
+          }
           case "evaluate": {
             if (!javascript) {
               return "Error: 'javascript' parameter is required for evaluate action.";
@@ -6200,7 +6631,7 @@ function registerBrowserTools(registry, workspaceDir) {
             return str ?? "(no result)";
           }
           default:
-            return `Unknown action: ${action}. Use: extract, screenshot, click, type, evaluate.`;
+            return `Unknown action: ${action}. Available actions: extract, screenshot, click, type, evaluate, form_fill, scroll, hover, select, upload, download, pdf, wait_for, network_logs, console_logs, cookies, storage.`;
         }
       } catch (err) {
         return `browse error: ${err.message}`;
@@ -6214,6 +6645,98 @@ function registerBrowserTools(registry, workspaceDir) {
       }
     }
   );
+  registry.register(
+    "browser_session",
+    [
+      "Manage browser sessions for persistent contexts across multiple browse operations.",
+      "Actions:",
+      "  list \u2014 list all active browser sessions",
+      "  create \u2014 create a new browser session with custom options",
+      "  close \u2014 close a specific browser session",
+      "  close_all \u2014 close all browser sessions",
+      "  info \u2014 get information about a specific session"
+    ].join("\n"),
+    {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list", "create", "close", "close_all", "info"],
+          description: "Session management action."
+        },
+        sessionId: {
+          type: "string",
+          description: "Session ID for create, close, or info actions."
+        },
+        options: {
+          type: "object",
+          description: "Browser options for create action (viewport, userAgent, mobile, etc.)."
+        }
+      },
+      required: ["action"]
+    },
+    async (params) => {
+      const action = params.action;
+      const sessionId = params.sessionId;
+      const options = params.options;
+      try {
+        switch (action) {
+          case "list": {
+            const sessions = Array.from(contextInstances.keys());
+            return sessions.length > 0 ? `Active sessions: ${sessions.join(", ")}` : "No active browser sessions";
+          }
+          case "create": {
+            if (!sessionId) {
+              return "Error: 'sessionId' parameter is required for create action.";
+            }
+            if (contextInstances.has(sessionId)) {
+              return `Error: Session '${sessionId}' already exists.`;
+            }
+            await getBrowserContext(sessionId, options || {});
+            return `Created browser session: ${sessionId}`;
+          }
+          case "close": {
+            if (!sessionId) {
+              return "Error: 'sessionId' parameter is required for close action.";
+            }
+            const context = contextInstances.get(sessionId);
+            if (!context) {
+              return `Error: Session '${sessionId}' not found.`;
+            }
+            await context.close();
+            contextInstances.delete(sessionId);
+            return `Closed browser session: ${sessionId}`;
+          }
+          case "close_all": {
+            const sessionCount = contextInstances.size;
+            for (const [id, context] of contextInstances) {
+              try {
+                await context.close();
+              } catch {
+              }
+            }
+            contextInstances.clear();
+            return `Closed ${sessionCount} browser sessions`;
+          }
+          case "info": {
+            if (!sessionId) {
+              return "Error: 'sessionId' parameter is required for info action.";
+            }
+            const context = contextInstances.get(sessionId);
+            if (!context) {
+              return `Error: Session '${sessionId}' not found.`;
+            }
+            const pages = context.pages();
+            return `Session '${sessionId}': ${pages.length} active pages`;
+          }
+          default:
+            return `Unknown action: ${action}. Available actions: list, create, close, close_all, info.`;
+        }
+      } catch (err) {
+        return `browser_session error: ${err.message}`;
+      }
+    }
+  );
 }
 
 // packages/runtime/src/tools/system.ts
@@ -7674,8 +8197,8 @@ async function startPipeline(configPath) {
     }
   }
   const requestLogger = new RequestLogger(resolve20(dirname8(configPath), "data", "dashboard.db"));
-  startDashboardServer(requestLogger, config.memory);
   const agent = new Agent(config);
+  startDashboardServer(requestLogger, config.memory, () => agent.getConversationHistories());
   agent.setRequestLogger(requestLogger);
   const hivemindHome = process.env.HIVEMIND_HOME || resolve20(process.env.HOME || "/root", "hivemind");
   const toolRegistry = registerAllTools(hivemindHome, {
@@ -8029,7 +8552,7 @@ var WorkerServer = class {
         return this.handleHealth(res);
       }
       if (method === "POST" && path === "/assign") {
-        const body = await readBody(req);
+        const body = await readBody2(req);
         return this.handleAssign(body, res);
       }
       if (method === "DELETE" && path.startsWith("/assign/")) {
@@ -8040,7 +8563,7 @@ var WorkerServer = class {
         return this.handleStatus(res);
       }
       if (method === "POST" && path === "/sync/push") {
-        const body = await readBody(req);
+        const body = await readBody2(req);
         return this.handleSyncPush(body, res);
       }
       sendJson(res, 404, { error: "Not found" });
@@ -8118,7 +8641,7 @@ var WorkerServer = class {
     sendJson(res, 200, result);
   }
 };
-function readBody(req) {
+function readBody2(req) {
   return new Promise((resolve21, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
@@ -8464,4 +8987,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-ZM7RK5YV.js.map
+//# sourceMappingURL=chunk-M3A2WRXM.js.map